Créez votre première pile AWS CDK : Un tutoriel pour les débutants

Travailler avec des constructions CDK

Les applications AWS CDK s'appuient sur des constructions en tant qu'éléments structurels essentiels. Votre code d'infrastructure deviendra plus modulaire, plus facile à maintenir et plus lisible lorsque vous maîtriserez les constructions, que vous utilisiez les constructions de services intégrées ou que vous créiez vos propres modèles réutilisables.

Cette section vous apprend à utiliser les constructions L2 (de haut niveau) et à développer des constructions personnalisées qui réduisent les schémas répétitifs.

Utiliser les concepts de la L2

Les constructions L2 sont des abstractions natives de CDK qui sont plus faciles à utiliser que CloudFormation brut (L1). Ils ont des valeurs par défaut raisonnables et une sécurité de type, ce qui nécessite souvent moins de lignes de code pour configurer une ressource AWS.

Pourquoi utiliser des constructions en L2 ?

• Moins de formulaires standard - moins de champs obligatoires par rapport à L1
• Un code Python plus lisible et idiomatique
• Comprend des méthodes utilitaires telles que .add_to_role_policy() ou .add_event_notification()
• Gestion automatique des dépendances entre les ressources

Exemple : Création d'un seau S3 à l'aide de L2

from aws_cdk import aws_s3 as s3
# Create a versioned and encrypted S3 bucket
bucket = s3.Bucket(
    self,
    "MyBucket",
    versioned=True,
    encryption=s3.BucketEncryption.S3_MANAGED
)

La construction équivalente en L1, s3.CfnBucket, nécessiterait que toutes les propriétés soient définies manuellement et que la configuration soit définie sous forme de dictionnaires bruts, ce qui est beaucoup moins intuitif.

Parmi les autres constructions courantes de la L2, on peut citer

• lambda_.Function() pour AWS Lambda
• dynamodb.Table() pour DynamoDB
• sqs.Queue() pour SQS
• sns.Topic() pour le SNS

Créer des constructions personnalisées

Votre infrastructure se développera avec des schémas récurrents, comme la création de fonctions Lambda avec des autorisations et des buckets S3 particuliers. Les constructions personnalisées constituent la solution idéale pour ce scénario spécifique.

Les constructions personnalisées vous permettent de combiner des ressources connexes en une seule unité logique, qui peut être réutilisée dans des piles ou des projets.

Quand créer une construction personnalisée :

• Lorsque vous avez plus de 3 ressources qui sont toujours provisionnées ensemble
• Lorsque vous souhaitez encapsuler une logique réutilisable
• Lorsque vous souhaitez réduire la duplication du code entre les piles

Exemple : Un modèle S3 + Lambda réutilisable

from constructs import Construct
from aws_cdk import aws_s3 as s3, aws_lambda as lambda_
class StorageWithLambda(Construct):
    def __init__(self, scope: Construct, id: str) -> None:
        super().__init__(scope, id)
        # S3 bucket
        self.bucket = s3.Bucket(self, "MyBucket")

        # Lambda function
        self.function = lambda_.Function(
            self,
            "MyFunction",
            runtime=lambda_.Runtime.PYTHON_3_9,
            handler="index.handler",
            code=lambda_.Code.from_asset("lambda")
        )
        # Grant Lambda access to the S3 bucket
        self.bucket.grant_read_write(self.function)

Vous pouvez maintenant utiliser cette construction à l'intérieur de n'importe quelle pile comme ceci :

from my_project.storage_with_lambda import StorageWithLambda
storage = StorageWithLambda(self, "ReusableComponent")

Avant d'exécuter l'opération ci-dessus, créez un dossier nommé lambda à la racine du projet et créez un fichier index.py avec le contenu suivant :

def handler(event, context):
    return {
        "statusCode": 200,
        "body": "Hello from Lambda!"
    }

Conseils de réutilisation

• Préfixez les fichiers par construct_ ou placez-les dans un dossier constructs/.
• Exposez des sorties telles que self.bucket ou self.function pour plus de flexibilité.
• Veillez à ce que chaque construction se concentre sur une seule responsabilité

Test et synthèse des applications CDK

Après avoir écrit votre code d'infrastructure, il est essentiel de vérifier ce que le CDK va déployer et, idéalement, de tester que vos piles se comportent comme prévu. Le CDK AWS fournit des outils pour synthétiser les modèles CloudFormation et écrire des tests automatisés pour détecter les mauvaises configurations avant le déploiement.

Synthèse des modèles

La commande cdk synth génère le modèle CloudFormation à partir de votre code CDK.

cdk synth

Lorsque vous exécutez ce programme, le CDK :

• Charge votre application (via app.py)
• Résout toutes les constructions et les piles
• Produit des modèles CloudFormation YAML/JSON bruts.

Modèle CloudFormation synthétisé 

Par défaut, la sortie s'effectue dans votre terminal, mais vous pouvez également l'effectuer dans un fichier si nécessaire :

cdk synth > template.yaml

Ceci est utile lorsque :

• Vous souhaitez inspecter le modèle réel avant de le déployer
• Vous déboguez la structure d'une pile
• Vous partagez le modèle avec des équipes qui n'utilisent pas CDK

Infrastructure de test

Bien que le test de l'infrastructure en tant que code puisse sembler inhabituel, il est bénéfique, en particulier lorsque vos piles deviennent importantes ou comprennent une logique conditionnelle, des boucles ou des constructions réutilisables.

Le CDK AWS propose le module assertions pour tester les piles synthétisées.

Écrire un test simple avec pytest

Voici un exemple de test qui vérifie si une ressource spécifique (comme un seau S3) est incluse dans la pile :

# test/test_cdk_datacamp_stack.py
import aws_cdk as cdk
from aws_cdk.assertions import Template
from cdk_datacamp.cdk_datacamp_stack import CdkDatacampStack
def test_s3_bucket_created():
    app = cdk.App()
    stack = CdkDatacampStack(app, "TestStack")
    template = Template.from_stack(stack)
    # Assert that an S3 bucket exists
    template.resource_count_is("AWS::S3::Bucket", 1)

Pour exécuter les tests, assurez-vous que pytest est installé :

pip install -U pytest

Ensuite, courez :

pytest

Si tout se passe bien, vous verrez apparaître une coche verte. Si ce n'est pas le cas, le résultat du test vous indiquera ce qui manque.

Sortie de Pytest montrant l'exécution réussie de tous les cas de test pour la pile AWS CDK

Vous pouvez également inclure la validation dans votre pile CDK. Les tests de validation sont des vérifications au moment de l'exécution dans votre code de construction ou de pile qui valident les entrées avant le déploiement. Ils permettent de détecter les mauvaises configurations ou d'appliquer des contraintes dès le début du cycle de développement.

Supposons que nous voulions transmettre le site bucket_name en tant que variable de contexte, mais que nous voulions le valider :

• Le nom du seau n'est pas vide
• Il respecte les règles de dénomination du S3 (par exemple, minuscules uniquement).

Créez un fichier nommé test/test_storage_with_lambda.py et ajoutez-y ce qui suit :

import pytest
from aws_cdk import App, Stack
from cdk_datacamp.storage_with_lambda import StorageWithLambda

def test_missing_bucket_name():
    app = App()
    stack = Stack(app, "TestStack")

    with pytest.raises(ValueError, match="bucket_name is required"):
        StorageWithLambda(stack, "FailingConstruct", bucket_name=None)

def test_bucket_name_uppercase():
    app = App()
    stack = Stack(app, "TestStack")

    with pytest.raises(ValueError, match="must be lowercase"):
        StorageWithLambda(stack, "FailingConstruct", bucket_name="InvalidName")

 Pour tester la validation, exécutez la commande suivante :

test/test_storage_with_lambda.py

Sortie de Pytest montrant l'exécution réussie de tous les cas de test pour la pile AWS CDK

Quand utiliser les tests ?

• Vous créez des constructions ou des modèles réutilisables.
• La mise en œuvre de tests permet d'établir des exigences techniques standard parmi les membres de l'équipe.
• Vous souhaitez détecter les régressions ou les changements involontaires pendant le processus CI/CD.

Vous souhaitez renforcer vos connaissances sur les CDK lors d'un entretien ? Ces principales questions d'entretien AWS DevOps peuvent vous aider à vous préparer.

Meilleures pratiques et conseils pour travailler avec le CDK AWS

Après avoir maîtrisé la création et le déploiement de la pile CDK, vous devez suivre les meilleures pratiques pour que le code de votre infrastructure reste propre, sécurisé et évolutif. Cette section aborde la manière de structurer les grands projets, de gérer correctement la sécurité et d'intégrer CDK dans les pipelines CI/CD.

Organiser de grands projets

Au fur et à mesure que votre application CDK se développe, il devient essentiel d'organiser le code en unités gérables.

Utilisez plusieurs piles

Répartissez votre infrastructure en fonction de vos préoccupations. Par exemple :

• NetworkingStack : VPC, sous-réseaux, groupes de sécurité
• ComputeStack : EC2, Lambda
• StorageStack : S3, DynamoDB

Cela vous permet de déployer, de tester ou de détruire des parties de votre infrastructure de manière indépendante. Voici comment l'inclure dans le site app.py:

network_stack = NetworkingStack(app, "NetworkingStack")
compute_stack = ComputeStack(app, "ComputeStack")

Vous pouvez également transmettre des ressources entre les piles à l'aide de sorties ou de références.

Créer des constructions imbriquées réutilisables

Encapsulez les ressources connexes (comme une Lambda et ses autorisations) dans une construction personnalisée, comme vous l'avez fait avec StorageWithLambda. Cela améliore la lisibilité et la réutilisation des piles ou des applications.

Utiliser une configuration spécifique à l'environnement

Prendre en charge plusieurs environnements (dev, staging, prod) en utilisant :

• cdk.json avec des valeurs contextuelles
• Remplacements de l'interface de programmation : cdk deploy -c env=prod
• Logique conditionnelle dans vos piles

env = app.node.try_get_context("env")
if env == "prod":
    bucket_name = "mycompany-prod-logs"

Sécurité et autorisations

Tout projet d'infrastructure doit donner la priorité à la sécurité lors des processus de déploiement automatisé d'AWS CDK. La section suivante présente la gestion sécurisée des ressources IAM à l'aide des principes du moindre privilège.

Définir les rôles IAM au lieu d'utiliser les valeurs par défaut

Les constructions CDK, qui incluent des tâches Lambda ou ECS, créeront automatiquement des rôles IAM. Bien que pratique, elle peut limiter votre contrôle sur les autorisations et le nommage.

Définissez plutôt les rôles de manière explicite :

from aws_cdk import aws_iam as iam

execution_role = iam.Role(
    self,
    "LambdaExecutionRole",
    assumed_by=iam.ServicePrincipal("lambda.amazonaws.com"),
    description="Custom role for Lambda with least privilege",
    managed_policies=[
        iam.ManagedPolicy.from_aws_managed_policy_name("service-role/AWSLambdaBasicExecutionRole")
    ]
)

Par défaut, ce rôle n'autorise que la journalisation et rien d'autre.

Appliquer le principe du moindre privilège

Évitez d'utiliser "*" dans actions ou resources, sauf en cas d'absolue nécessité.

Exemple :

lambda_fn.add_to_role_policy(
    iam.PolicyStatement(
        actions=["*"],
        resources=["*"]
    )
)

Vous pouvez également utiliser des subventions spécifiques aux ressources lorsqu'elles sont disponibles :

bucket.grant_read(lambda_fn)

Cela génère automatiquement la politique nécessaire avec un accès limité au seau S3.

Utiliser des politiques gérées lorsque c'est possible

Les règles gérées par AWS simplifient la maintenance et réduisent les risques d'erreur.

iam.ManagedPolicy.from_aws_managed_policy_name("AmazonSQSReadOnlyAccess")

Vous pouvez les associer à des rôles personnalisés pour des services tels que ECS, Batch ou Step Functions.

Intégration CI/CD

Le CDK AWS offre une puissance exceptionnelle grâce à sa capacité à s'intégrer aux pipelines CI/CD contemporains. CDK prend en charge la fourniture automatisée d'infrastructures grâce au déploiement de code contrôlé par version, qui fonctionne avec GitHub, GitLab et les services natifs d'AWS, y compris CodePipeline. Le système réduit les erreurs humaines tout en raccourcissant les cycles de retour d'information et permet un déploiement dans des environnements multiples.

Actions GitHub : Automatiser les déploiements de CDK

Vous pouvez utiliser les actions GitHub pour synthétiser, différencier, tester et déployer les piles CDK à chaque demande de téléchargement.

Jetez un coup d'œil à ce site .github/workflows/deploy.yml:

name: Deploy CDK App

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - uses: actions/setup-python@v4
        with:
          python-version: 3.11

      - name: Install dependencies
        run: |
          pip install -r requirements.txt
          npm install -g aws-cdk

      - name: Run unit tests
        run: pytest

      - name: CDK Synth
        run: cdk synth -c environment=prod

      - name: Deploy to AWS
        run: cdk deploy --require-approval never
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}

Utilisez cdk diff dans les PR pour prévisualiser les changements infra avant de les fusionner.

Pipelines CDK : CDK natif CI/CD avec CodePipeline

Pour les déploiements entièrement gérés au sein d'AWS, CDK fournit un module appelé aws_cdk.pipelines, qui vous permet de définir l'ensemble de votre pipeline CI/CD en tant que code, tout comme l'infrastructure.

Voici un exemple simplifié :

from aws_cdk import pipelines, SecretValue, Stack
from constructs import Construct
from my_app_stage import MyAppStage  # replace with your actual stage import

class PipelineStack(Stack):
    def __init__(
        self,
        scope: Construct,
        construct_id: str,
        **kwargs
    ) -> None:
        super().__init__(scope, construct_id, **kwargs)

        # Define the source of the pipeline from a GitHub repository
        source = pipelines.CodePipelineSource.git_hub(
            repo_string="your-org/your-repo",  # GitHub org/repo
            branch="main",
            authentication=SecretValue.secrets_manager("GITHUB_TOKEN")
        )

        # Define the CodePipeline and its synthesis step
        pipeline = pipelines.CodePipeline(
            self,
            "MyAppPipeline",
            synth=pipelines.ShellStep(
                "Synth",
                input=source,
                commands=[
                    "pip install -r requirements.txt",
                    "npm install -g aws-cdk",
                    "cdk synth"
                ]
            )
        )

        # Add an application stage (e.g., production deployment)
        pipeline.add_stage(
            MyAppStage(self, "ProdStage")
        )

Dans le code ci-dessus :

• SecretValue.secrets_manager("GITHUB_TOKEN") extrait en toute sécurité votre jeton GitHub de Secrets Manager.
• MyAppStage doit être une classe qui étend Stage et qui englobe vos piles CDK réelles.

Si vous déployez des systèmes d'apprentissage automatique, l'intégration de CDK aux pratiques de déploiement continu est abordée dans notre cours CI/CD pour l'apprentissage automatique.

Conclusion

Ce tutoriel vous a montré comment construire et déployer une infrastructure cloud en Python grâce aux opérations du kit de développement cloud (CDK) d'AWS. Vous avez appris à.. :

• Créez votre première pile CDK.
• Définir et valider les buckets S3 et les fonctions Lambda en tant que ressources.
• Organisez un projet à l'aide de constructions personnalisées et de modèles à plusieurs piles.
• Appliquer les meilleures pratiques en matière de sécurité en appliquant le principe du moindre privilège.
• Automatisez les déploiements en combinant les actions GitHub et les pipelines CDK.
• Rédigez des tests pour valider la logique de votre infrastructure.

Maintenant que vous avez déployé votre première application CDK, voici quelques moyens de progresser :

• Utiliser des environnements paramétrés pour dev/staging/prod
• Ajouter des alarmes CloudWatch, API Gateway ou des fonctions Step
• Explorez les constructions CDK telles que aws_s3_deployment, aws_ecs_patterns, et cdk.pipelines
• Convertissez vos constructions en une bibliothèque Python interne afin de pouvoir les réutiliser.

Pour continuer à apprendre et à construire, consultez le cours Introduction à AWS Boto en Python.le cours Introduction à AWS Boto en Python!