基础设施即代码 (IaC) 是一种软件开发实践，涉及使用代码而非手动流程来管理和配置计算机基础设施。这种方法可以帮助解决组织在管理基础设施时面临的多个问题，包括：

L'Infrastructure en tant que code (IaC) 是一种软件开发实践，涉及使用代码而非手动流程来管理和配置计算机基础设施。这种方法可以帮助解决组织在管理基础设施时面临的多个问题，包括：

• *一致性*：通过 *IaC*，可以在不同环境中一致地部署基础设施，确保每次应用相同的配置。
• 可扩展性*：*IaC 可以通过自动化按需配置新资源，帮助组织快速高效地扩展其基础设施。
• 速度*：通过自动化基础设施部署和管理任务，*IaC 可以帮助组织减少设置和维护基础设施所需的时间。
• 协作*：*IaC 通过提供一个可供多名团队成员访问的、版本控制的共享基础设施代码库，使团队能够更轻松地协作处理基础设施管理任务。
• *版本控制*：通过 *IaC*，基础设施代码可以像软件代码一样进行版本控制、跟踪和测试。这使组织能够在需要时回滚到基础设施配置的早期版本，并确保变更得到妥善记录和测试。

总而言之，*IaC* 帮助组织以更自动化、更一致且更具可扩展性的方式管理其基础设施，从而提高其 IT 运营的效率、可靠性和敏捷性。

• *Cohérence*（一致性）：通过 *IaC*，可以在不同环境中一致地部署基础设施，确保每次应用相同的配置。
• Scalabilité*（可扩展性）：*IaC 可以通过自动化按需配置新资源，帮助组织快速高效地扩展其基础设施。
• Rapidité*（速度）：通过自动化基础设施部署和管理任务，*IaC 可以帮助组织减少设置和维护基础设施所需的时间。
• Collaboration*（协作）：*IaC 通过提供一个可供多名团队成员访问的、版本控制的共享基础设施代码库，使团队能够更轻松地协作处理基础设施管理任务。
• *Versioning*（版本控制）：通过 *IaC*，基础设施代码可以像软件代码一样进行版本控制、跟踪和测试。这使组织能够在需要时回滚到基础设施配置的早期版本，并确保变更得到妥善记录和测试。

总而言之，*IaC* 帮助组织以更自动化、更一致且更具可扩展性的方式管理其基础设施，从而提高其 IT 运营的效率、可靠性和敏捷性。

• 维基百科 (英文)
• 维基百科 (法文)

• AWS 的 Cloud Formation
• Hashicorp 的 Terraform

• Hashicorp 的 Terraform CDK
• AWS 的 AWS CDK

Amazon Sagemaker 是 AWS 产品的一部分，它通过完全托管的基础设施、工具和工作流，帮助构建、训练和部署机器学习 (ML) 模型，适用于任何用例。 Sagemaker 科学环境本身依赖于 Conda，这是一种用于 FORTRAN、C/C++、Python、R 等多种语言的包、依赖项和环境管理工具。对于我们的数据与云研讨会，我们对 Julia 感兴趣。请注意，Jupyter 是 Julia、Python 和 R 的松散缩写。

让我们从引导 AWS CDK 环境开始：

#!/bin/bash
set -x #echo on

cd `pwd`/infra && cdk bootstrap

from pathlib import Path

from aws_cdk import (
    Fn as fn,
    Stack,
    aws_iam as iam,
    aws_sagemaker as sagemaker,
)
from constructs import Construct

def read_text(file_path: str, encoding="utf-8"):
  text = ""
  if file_path is not None:
    text = Path(file_path).read_text(encoding=encoding)
  return text

class InfraStack(Stack):

    def __init__(
            self, scope: Construct, construct_id: str,
            on_create_script_path=None, on_start_script_path=None, **kwargs,
    ) -> None:

        super().__init__(scope, construct_id, **kwargs)

        # The code that defines your stack goes here

        onCreateScript = read_text(on_create_script_path)

        onStartScript = read_text(on_start_script_path)

        role = iam.Role(self, "DataAndCloudScienceRole", **dict(
            assumed_by=iam.ServicePrincipal("sagemaker.amazonaws.com"),
            managed_policies=[
                iam.ManagedPolicy.from_aws_managed_policy_name("AmazonSageMakerFullAccess"),
            ],
        ))

        lifecycle_config = sagemaker.CfnNotebookInstanceLifecycleConfig(
            self, "DataAndCloudScienceLifecycleConfig", **dict(
                notebook_instance_lifecycle_config_name="DataAndCloudScienceLifecycleConfig",
                on_create=[
                    dict(
                        content_type="text/x-shellscript",
                        content=fn.base64(onCreateScript),
                    ),
                ],
                on_start=[
                    dict(
                        content_type="text/x-shellscript",
                        content=fn.base64(onStartScript),
                    ),
                ],
            )
        )

        fastai_fastbook_repository = "FastAIFastBookRepository"

        sagemaker.CfnCodeRepository(
            self, "DataAndCloudFastAICodeRepository",
            code_repository_name=fastai_fastbook_repository,
            git_config=sagemaker.CfnCodeRepository.GitConfigProperty(
                branch="master",
                repository_url="https://github.com/fastai/fastbook.git",
            ),
        )

        julia_academy_datascience_repository = "JuliaAcademyDataScienceRepository"

        sagemaker.CfnCodeRepository(
            self, "DataAndCloudScienceCodeRepository",
            code_repository_name=julia_academy_datascience_repository,
            git_config=sagemaker.CfnCodeRepository.GitConfigProperty(
                branch="main",
                repository_url="https://github.com/JuliaAcademy/DataScience.git",
            ),
        )

        fluxml_fastaijl_repository = "FluxMLFastAIjlRepository"

        sagemaker.CfnCodeRepository(
          self, "DataAndCloudFluxMLFastAICodeRepository",
          code_repository_name=fluxml_fastaijl_repository,
          git_config=sagemaker.CfnCodeRepository.GitConfigProperty(
              branch="master",
              repository_url="https://github.com/FluxML/FastAI.jl.git",
          ),
        )

        sagemaker.CfnNotebookInstance(
            self, "DataAndCloudScienceNotebookCPU", **dict(
                lifecycle_config_name=lifecycle_config.notebook_instance_lifecycle_config_name,
                role_arn=role.role_arn,
                instance_type="ml.c5.xlarge", # "ml.p2.xlarge", # "ml.c5.2xlarge",
                additional_code_repositories=[
                  fastai_fastbook_repository,
                  julia_academy_datascience_repository,
                  fluxml_fastaijl_repository,
                ],
            ),
        )

        # sagemaker.CfnNotebookInstance(
        #     self, "DataAndCloudScienceNotebookGPU", **dict(
        #         lifecycle_config_name=lifecycle_config.notebook_instance_lifecycle_config_name,
        #         role_arn=role.role_arn,
        #         instance_type="ml.p2.xlarge",  # "ml.c5.xlarge", # "ml.c5.2xlarge",
        #         additional_code_repositories=[julia_academy_datascience_repository],
        #     ),
        # )

#!/usr/bin/env python3
import os

import aws_cdk as cdk

from infra.infra_stack import InfraStack

project_path = os.path.dirname(os.path.realpath(__file__))
scripts_path = f"{project_path}/../scripts"
app = cdk.App()
InfraStack(app, "InfraStack",
    # If you don't specify 'env', this stack will be environment-agnostic.
    # Account/Region-dependent features and context lookups will not work,
    # but a single synthesized template can be deployed anywhere.

    # Uncomment the next line to specialize this stack for the AWS Account
    # and Region that are implied by the current CLI configuration.

    #env=cdk.Environment(account=os.getenv('CDK_DEFAULT_ACCOUNT'), region=os.getenv('CDK_DEFAULT_REGION')),

    # Uncomment the next line if you know exactly what Account and Region you
    # want to deploy the stack to. */

    #env=cdk.Environment(account='123456789012', region='us-east-1'),

    # For more information, see https://docs.aws.amazon.com/cdk/latest/guide/environments.html

    # Science Environment Lifecycle Scripts
    ,**dict(
      on_create_script_path=f"{scripts_path}/aws/onCreate.sh",
      on_start_script_path=f"{scripts_path}/aws/onStart.sh",
    ),
)

app.synth()

现在，让我们继续配置 Amazon Sagemaker 科学环境：

#!/bin/bash
set -x #echo on

cd `pwd`/infra && cdk deploy

我们可以通过执行以下命令来终止 Sagemaker 科学环境：

#!/bin/bash
set -x #echo on

cd `pwd`/infra && cdk destroy

使用 AWS CDK 在 AWS SageMaker 中配置数据科学环境

初始项目使用 AWS CDK Python API 在 AWS SageMaker 中配置数据科学环境。此代码位于 infra\(\_\)stack.py 文件中。

将 Julia 内核自定义安装到 Sagemaker Conda 环境中

为了将 Julia 内核安装到 SageMaker Conda 环境中，使用了两个 shell 脚本：*onCreate.sh* 和 onStart.sh*。这些脚本位于 *scripts/aws 目录中。

• *onCreate.sh*：此脚本在创建 SageMaker 笔记本实例时执行。它为 Julia 内核安装设置环境。
• *onStart.sh*：此脚本在启动 SageMaker 笔记本实例时执行。它将 Julia 内核安装到 SageMaker Conda 环境中。

将 Julia 内核安装到 SageMaker Conda 环境中

为了将 Julia 内核安装到 SageMaker Conda 环境中，使用了 onStart.sh 脚本。以下是脚本执行的步骤：

设置变量：脚本设置 Julia 发布版本、Julia 版本、下载 URL、安装目录和 depot 路径的变量。 创建 Conda 环境：脚本为 Julia 安装创建一个 Conda 环境。 下载并解压 Julia：脚本从 Julia 下载站点下载 Julia tarball 并将其解压到安装目录。 设置 Julia 环境变量：脚本设置 Julia depot 路径的环境变量并将其添加到 env.sh 文件中。 安装 IJulia：脚本安装 IJulia（一个为 Jupyter 笔记本提供 Julia 内核的包）并将其添加到内核列表中。 清理：脚本删除下载的 Julia tarball。

设置 AWS CDK 和项目依赖项

要设置 AWS CDK 和项目依赖项，您需要创建一个 requirements.txt 文件，其中列出了项目所需的依赖项。在此项目中，*requirements.txt* 文件包含以下依赖项：

• *aws-cdk-lib==2.70.0*：AWS CDK 库版本 *2.70.0*。
• *constructs>=10.0.0,<11.0.0*：Constructs 库版本 *10.x*。

在 infra\(\_\)stack.py 中，使用 sagemaker.CfnNotebookInstanceLifecycleConfig 类创建 SageMaker 笔记本实例生命周期配置。此配置指定了在创建或启动笔记本实例时要运行的脚本。

使用 sagemaker.CfnCodeRepository 类创建 fastai\(\_\)fastbook\(\_\)repository 和 julia\(\_\)academy\(\_\)datascience\(\_\)repository 存储库。这些存储库包含笔记本实例将使用的代码。

使用 sagemaker.CfnGitHubLocation 类创建 fluxml\(\_\)fastaijl\(\_\)repository 存储库。此存储库包含笔记本实例将使用的 Julia 代码。

最后，在 app.py 中实例化 InfraStack 类，传入 on\(\_\)create\(\_\)script\(\_\)path 和 on\(\_\)start\(\_\)script\(\_\)path 参数，分别指定 onCreate.sh 和 onStart.sh 脚本的路径。

调用 app.synth() 方法来合成堆栈的 CloudFormation 模板，然后可以将其部署到 AWS。

这是此代码文档的结尾。请记住，该项目使用 AWS CDK Python API 在 AWS Sagemaker 中配置数据科学环境，并且 onCreate.sh 和 onStart.sh shell 脚本用于将自定义 Julia 内核安装到 Sagemaker Conda 环境中。

Provisionnement d'environnements de science des données dans AWS SageMaker à l'aide d'AWS CDK

Le projet initial utilise l'API AWS CDK Python pour provisionner des environnements de science des données dans AWS SageMaker. Le code pour cela se trouve dans le fichier infra\(\_\)stack.py.

Pour installer un noyau Julia dans l'environnement SageMaker Conda, deux scripts shell sont utilisés: onCreate.sh et onStart.sh. Ces scripts se trouvent dans le répertoire scripts/aws.

• onCreate.sh: ce script est exécuté lorsqu'une instance de notebook SageMaker est créée. Il configure l'environnement pour l'installation du noyau Julia.
• onStart.sh: ce script est exécuté lorsqu'une instance de notebook SageMaker est démarrée. Il installe le noyau Julia dans l'environnement SageMaker Conda.

Pour installer le noyau Julia dans l'environnement Conda de SageMaker, le script onStart.sh est utilisé. Voici les étapes que le script prend :

Configurer les variables : Le script configure les variables pour la version de sortie de Julia, la version de Julia, l'URL de téléchargement, le répertoire d'installation et le chemin du dépôt. Créer l'environnement Conda : Le script crée un environnement Conda pour l'installation de Julia. Télécharger et extraire Julia : Le script télécharge le tarball de Julia à partir du site de téléchargement de Julia et l'extrait dans le répertoire d'installation. Configurer les variables d'environnement de Julia : Le script configure les variables d'environnement pour le chemin du dépôt Julia et les ajoute au fichier env.sh. Installer IJulia : Le script installe IJulia, un package qui fournit un noyau Julia pour les notebooks Jupyter, et l'ajoute à la liste des noyaux. Nettoyer : Le script supprime le tarball Julia téléchargé.

Configuration d'AWS CDK et des dépendances du projet

Pour configurer AWS CDK et les dépendances du projet, vous devez créer un fichier requirements.txt qui répertorie les dépendances requises pour le projet. Dans ce projet, le fichier requirements.txt inclut les dépendances suivantes :

• aws-cdk-lib==2.70.0: version 2.70.0 de la bibliothèque AWS CDK.
• constructs>=10.0.0,<11.0.0: version 10.x de la bibliothèque Constructs.

Dans infra\(\_\)stack.py, une configuration du cycle de vie de l'instance de notebook SageMaker est créée à l'aide de la classe sagemaker.CfnNotebookInstanceLifecycleConfig. Cette configuration spécifie les scripts à exécuter lorsqu'une instance de notebook est créée ou démarrée.

Les référentiels fastai\(\_\)fastbook\(\_\)repository et julia\(\_\)academy\(\_\)datascience\(\_\)repository sont créés à l'aide de la classe sagemaker.CfnCodeRepository. Ces référentiels contiennent le code qui sera utilisé par l'instance de notebook.

Le référentiel fluxml\(\_\)fastaijl\(\_\)repository est créé à l'aide de la classe sagemaker.CfnGitHubLocation. Ce référentiel contient le code Julia qui sera utilisé par l'instance de notebook.

Enfin, la classe InfraStack est instanciée dans app.py, en passant les arguments on\(\_\)create\(\_\)script\(\_\)path et on\(\_\)start\(\_\)script\(\_\)path pour spécifier les chemins des scripts onCreate.sh et onStart.sh, respectivement.

La méthode app.synth() est appelée pour synthétiser le modèle CloudFormation pour la pile, qui peut ensuite être déployée sur AWS.

C'est la fin de la documentation pour ce code. Gardez à l'esprit que ce projet utilise l'API AWS CDK Python pour provisionner des environnements de science des données dans AWS Sagemaker, et que les scripts shell onCreate.sh et onStart.sh sont utilisés pour installer un noyau Julia personnalisé dans l'environnement Conda de Sagemaker.