इंफ्रास्ट्रक्चर एज़ कोड (IaC) सॉफ्टवेयर विकास में एक अभ्यास है जिसमें मैनुअल प्रक्रियाओं के बजाय कोड का उपयोग करके कंप्यूटर इंफ्रास्ट्रक्चर का प्रबंधन और प्रावधान करना शामिल है। यह दृष्टिकोण उन कई समस्याओं को हल करने में मदद कर सकता है जिनका सामना संगठन अपने इंफ्रास्ट्रक्चर का प्रबंधन करते समय करते हैं, जिनमें शामिल हैं:

L'Infrastructure en tant que code (IaC) (इंफ्रास्ट्रक्चर एज़ कोड) सॉफ्टवेयर विकास में एक अभ्यास है जिसमें मैनुअल प्रक्रियाओं के बजाय कोड का उपयोग करके कंप्यूटर इंफ्रास्ट्रक्चर का प्रबंधन और प्रावधान करना शामिल है। यह दृष्टिकोण उन कई समस्याओं को हल करने में मदद कर सकता है जिनका सामना संगठन अपने इंफ्रास्ट्रक्चर का प्रबंधन करते समय करते हैं, जिनमें शामिल हैं:

• निरंतरता (Consistency): IaC के साथ, इंफ्रास्ट्रक्चर को विभिन्न वातावरणों में लगातार तैनात किया जा सकता है, यह सुनिश्चित करते हुए कि हर बार समान कॉन्फ़िगरेशन लागू हों।
• स्केलेबिलिटी (Scalability): IaC संगठनों को आवश्यकतानुसार नए संसाधनों के प्रावधान को स्वचालित करने की अनुमति देकर अपने इंफ्रास्ट्रक्चर को तेजी से और कुशलता से स्केल करने में मदद कर सकता है।
• गति (Speed): इंफ्रास्ट्रक्चर परिनियोजन और प्रबंधन कार्यों को स्वचालित करके, IaC संगठनों को अपने इंफ्रास्ट्रक्चर को स्थापित करने और बनाए रखने में लगने वाले समय को कम करने में मदद कर सकता है।
• सहयोग (Collaboration): IaC टीमों के लिए इंफ्रास्ट्रक्चर प्रबंधन कार्यों पर सहयोग करना आसान बनाता है, क्योंकि यह इंफ्रास्ट्रक्चर कोड का एक साझा, संस्करण-नियंत्रित रिपॉजिटरी प्रदान करता है जिसे कई टीम सदस्यों द्वारा एक्सेस किया जा सकता है।
• वर्ज़निंग (Versioning): IaC के साथ, इंफ्रास्ट्रक्चर कोड को सॉफ्टवेयर कोड की तरह ही वर्ज़निंग, ट्रैक और टेस्ट किया जा सकता है। यह संगठनों को आवश्यकता पड़ने पर अपने इंफ्रास्ट्रक्चर कॉन्फ़िगरेशन के पिछले संस्करणों पर वापस जाने और यह सुनिश्चित करने में सक्षम बनाता है कि परिवर्तन ठीक से प्रलेखित और परीक्षण किए गए हैं।

कुल मिलाकर, IaC संगठनों को अपने इंफ्रास्ट्रक्चर को अधिक स्वचालित, सुसंगत और स्केलेबल तरीके से प्रबंधित करने में मदद करता है, जो उनके आईटी संचालन की दक्षता, विश्वसनीयता और चपलता में सुधार कर सकता है।

• Cohérence (निरंतरता): IaC के साथ, इंफ्रास्ट्रक्चर को विभिन्न वातावरणों में लगातार तैनात किया जा सकता है, यह सुनिश्चित करते हुए कि हर बार समान कॉन्फ़िगरेशन लागू हों।
• Scalabilité (स्केलेबिलिटी): IaC संगठनों को तेजी से और कुशलता से अपने इंफ्रास्ट्रक्चर को स्केल करने में मदद कर सकता है, जिससे उन्हें आवश्यकतानुसार नए संसाधनों के प्रावधान को स्वचालित करने की अनुमति मिलती है।
• Rapidité (गति): इंफ्रास्ट्रक्चर परिनियोजन और प्रबंधन कार्यों को स्वचालित करके, IaC संगठनों को अपने इंफ्रास्ट्रक्चर को स्थापित करने और बनाए रखने में लगने वाले समय को कम करने में मदद कर सकता है।
• Collaboration (सहयोग): IaC टीमों के लिए इंफ्रास्ट्रक्चर प्रबंधन कार्यों पर सहयोग करना आसान बनाता है, क्योंकि यह इंफ्रास्ट्रक्चर कोड का एक साझा, संस्करण-नियंत्रित रिपॉजिटरी प्रदान करता है जिसे कई टीम सदस्यों द्वारा एक्सेस किया जा सकता है।
• Versioning (वर्ज़निंग): IaC के साथ, इंफ्रास्ट्रक्चर कोड को सॉफ्टवेयर कोड की तरह ही वर्ज़निंग, ट्रैक और टेस्ट किया जा सकता है। यह संगठनों को आवश्यकता पड़ने पर अपने इंफ्रास्ट्रक्चर कॉन्फ़िगरेशन के पिछले संस्करणों पर वापस जाने और यह सुनिश्चित करने में सक्षम बनाता है कि परिवर्तन ठीक से प्रलेखित और परीक्षण किए गए हैं।

कुल मिलाकर, IaC संगठनों को अपने इंफ्रास्ट्रक्चर को अधिक स्वचालित, सुसंगत और स्केलेबल तरीके से प्रबंधित करने में मदद करता है, जो उनके आईटी संचालन की दक्षता, विश्वसनीयता और चपलता में सुधार कर सकता है।

• विकिपीडिया (en)
• विकिपीडिया (fr)

• 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 SageMaker में डेटा साइंस वातावरण का प्रावधान करने के लिए AWS CDK पायथन API का उपयोग करता है। इसके लिए कोड infra\(\_\)stack.py फ़ाइल में स्थित है।

Sagemaker Conda वातावरण में Julia कर्नेल का कस्टम इंस्टॉलेशन

SageMaker Conda वातावरण में Julia कर्नेल स्थापित करने के लिए, दो शेल स्क्रिप्ट का उपयोग किया जाता है: onCreate.sh और onStart.sh*। ये स्क्रिप्ट *scripts/aws निर्देशिका में स्थित हैं।

• onCreate.sh: यह स्क्रिप्ट तब निष्पादित होती है जब एक SageMaker नोटबुक इंस्टेंस बनाया जाता है। यह Julia कर्नेल इंस्टॉलेशन के लिए वातावरण स्थापित करता है।
• onStart.sh: यह स्क्रिप्ट तब निष्पादित होती है जब एक SageMaker नोटबुक इंस्टेंस शुरू किया जाता है। यह SageMaker Conda वातावरण में Julia कर्नेल स्थापित करता है।

SageMaker Conda वातावरण में Julia कर्नेल स्थापित करना

SageMaker Conda वातावरण में Julia कर्नेल स्थापित करने के लिए, onStart.sh स्क्रिप्ट का उपयोग किया जाता है। यहाँ वे चरण दिए गए हैं जो स्क्रिप्ट लेती है:

चर सेट करें: स्क्रिप्ट Julia रिलीज़ संस्करण, Julia संस्करण, डाउनलोड URL, इंस्टॉलेशन निर्देशिका और डिपो पथ के लिए चर सेट करती है। Conda वातावरण बनाएं: स्क्रिप्ट Julia इंस्टॉलेशन के लिए एक Conda वातावरण बनाती है। Julia डाउनलोड और निकालें: स्क्रिप्ट Julia डाउनलोड साइट से Julia टारबॉल डाउनलोड करती है और इसे इंस्टॉलेशन निर्देशिका में निकालती है। Julia वातावरण चर सेट करें: स्क्रिप्ट Julia डिपो पथ के लिए वातावरण चर सेट करती है और उन्हें env.sh फ़ाइल में जोड़ती है। IJulia स्थापित करें: स्क्रिप्ट IJulia स्थापित करती है, एक पैकेज जो Jupyter नोटबुक के लिए एक Julia कर्नेल प्रदान करता है, और इसे कर्नेल सूची में जोड़ता है। साफ़ करें: स्क्रिप्ट डाउनलोड की गई Julia टारबॉल को हटा देती है।

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: कंस्ट्रक्ट्स लाइब्रेरी संस्करण *10.x*।

infra\(\_\)stack.py में, sagemaker.CfnNotebookInstanceLifecycleConfig क्लास का उपयोग करके एक SageMaker नोटबुक इंस्टेंस जीवनचक्र कॉन्फ़िगरेशन बनाया जाता है। यह कॉन्फ़िगरेशन उन स्क्रिप्ट को निर्दिष्ट करता है जिन्हें नोटबुक इंस्टेंस बनाए जाने या शुरू किए जाने पर चलाया जाना है।

fastai\(\_\)fastbook\(\_\)repository और julia\(\_\)academy\(\_\)datascience\(\_\)repository रिपॉजिटरी sagemaker.CfnCodeRepository क्लास का उपयोग करके बनाई गई हैं। इन रिपॉजिटरी में वह कोड होता है जिसका उपयोग नोटबुक इंस्टेंस द्वारा किया जाएगा।

fluxml\(\_\)fastaijl\(\_\)repository रिपॉजिटरी sagemaker.CfnGitHubLocation क्लास का उपयोग करके बनाई गई है। इस रिपॉजिटरी में Julia कोड होता है जिसका उपयोग नोटबुक इंस्टेंस द्वारा किया जाएगा।

अंत में, InfraStack क्लास को app.py में इंस्टेंट किया जाता है, on\(\_\)create\(\_\)script\(\_\)path और on\(\_\)start\(\_\)script\(\_\)path तर्कों को पास करते हुए, क्रमशः onCreate.sh और onStart.sh स्क्रिप्ट के पथ निर्दिष्ट करने के लिए।

स्टैक के लिए CloudFormation टेम्प्लेट को संश्लेषित करने के लिए app.synth() विधि को कॉल किया जाता है, जिसे बाद में AWS पर तैनात किया जा सकता है।

यह इस कोड के लिए दस्तावेज़ीकरण का अंत है। ध्यान रखें कि यह प्रोजेक्ट AWS Sagemaker में डेटा साइंस वातावरण का प्रावधान करने के लिए AWS CDK पायथन API का उपयोग करता है, और onCreate.sh और onStart.sh शेल स्क्रिप्ट का उपयोग Sagemaker Conda वातावरण में एक कस्टम Julia कर्नेल स्थापित करने के लिए किया जाता है।

Provisionnement d'environnements de science des données dans AWS SageMaker à l'aide d'AWS CDK (AWS CDK का उपयोग करके AWS SageMaker में डेटा साइंस वातावरण का प्रावधान)

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 (Conda वातावरण बनाएं) : Le script crée un environnement Conda pour l'installation de Julia. Télécharger et extraire Julia (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 (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 (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 (AWS CDK और प्रोजेक्ट निर्भरताएँ स्थापित करना)

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.