Bouw je eerste AWS CDK-stack: een beginnersvriendelijke tutorial

Werken met CDK-constructs

AWS CDK-apps steunen op constructs als essentiële bouwelementen. Je infrastructuurcode wordt modularer, onderhoudbaarder en leesbaarder wanneer je constructs beheerst, of je nu ingebouwde serviceconstructs gebruikt of je eigen herbruikbare patronen maakt.

In deze sectie leer je L2 (high-level) constructs gebruiken en hoe je custom constructs ontwikkelt die repetitieve patronen verminderen.

L2-constructs gebruiken

L2-constructs zijn CDK-native abstracties die eenvoudiger te gebruiken zijn dan ruwe CloudFormation (L1). Ze hebben zinnige defaults en typeveiligheid en vereisen vaak minder regels code om een AWS-resource op te zetten.

Waarom L2-constructs gebruiken?

• Minder boilerplate — minder verplichte velden vergeleken met L1
• Leesbaardere en idiomatische Python-code
• Bevat hulpmethoden zoals .add_to_role_policy() of .add_event_notification()
• Beheert automatisch afhankelijkheden tussen resources

Voorbeeld: een S3-bucket maken met 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
)Mogelijk gemaakt door

Het equivalente L1-construct, s3.CfnBucket, zou alle eigenschappen handmatig moeten instellen en configuratie als ruwe dicts moeten definiëren—veel minder intuïtief.

Andere veelvoorkomende L2-constructs zijn onder meer:

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

Custom constructs maken

Je infrastructuur groeit met terugkerende patronen, zoals het maken van Lambda-functies met bepaalde permissies en S3-buckets. Custom constructs zijn de ideale oplossing voor dit specifieke scenario.

Custom constructs laten je gerelateerde resources combineren tot één logische eenheid die je kunt hergebruiken over stacks of projecten heen.

Wanneer maak je een custom construct:

• Wanneer je 3+ resources hebt die altijd samen worden geprovisioneerd
• Wanneer je herbruikbare logica wilt inkapselen
• Wanneer je code-duplicatie over stacks wilt verminderen

Voorbeeld: een herbruikbaar S3 + Lambda-patroon

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)Mogelijk gemaakt door

Je kunt dit construct nu in elke stack als volgt gebruiken:

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

Maak, voordat je het bovenstaande draait, in de projectroot een map lambda en maak een bestand index.py met de volgende inhoud:

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

Tips voor hergebruik

• Voorzie bestanden van het prefix construct_ of plaats ze in een map constructs/
• Stel outputs bloot zoals self.bucket of self.function voor flexibiliteit
• Houd elk construct gefocust op één verantwoordelijkheid

CDK-apps testen en synthetiseren

Na het schrijven van je infrastructuurcode is het essentieel te controleren wat de CDK gaat deployen en idealiter te testen dat je stacks zich naar verwachting gedragen. De AWS CDK biedt tools om CloudFormation-templates te synthetiseren en geautomatiseerde tests te schrijven om misconfiguraties vóór deployment op te vangen.

Templates synthetiseren

Het commando cdk synth genereert de CloudFormation-template uit je CDK-code.

cdk synthMogelijk gemaakt door

Wanneer je dit draait, doet CDK het volgende:

• Laadt je app (via app.py)
• Resolvet alle constructs en stacks
• Geeft ruwe YAML/JSON CloudFormation-templates als output

Gesynthetiseerde CloudFormation-template 

Standaard gaat de output naar je terminal, maar je kunt desgewenst ook naar een bestand schrijven:

cdk synth > template.yamlMogelijk gemaakt door

Dit is handig wanneer:

• Je de daadwerkelijke template wilt inspecteren vóór deployment
• Je de structuur van een stack debugt
• Je de template wilt delen met teams die geen CDK gebruiken

Infrastructuur testen

Hoewel infrastructuur als code testen ongebruikelijk kan klinken, is het erg nuttig, vooral wanneer je stacks groot worden of conditionele logica, lussen of herbruikbare constructs bevatten.

De AWS CDK biedt de assertions-module om gesynthetiseerde stacks te testen.

Een eenvoudige test schrijven met pytest

Hier is een voorbeeldtest die controleert of een specifieke resource (zoals een S3-bucket) in de stack is opgenomen:

# 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)Mogelijk gemaakt door

Om de tests uit te voeren, zorg dat pytest is geïnstalleerd:

pip install -U pytestMogelijk gemaakt door

Draai vervolgens:

pytestMogelijk gemaakt door

Als alles slaagt, zie je een groen vinkje. Zo niet, dan vertelt de testoutput je wat er ontbreekt.

Pytest-output die het succesvol uitvoeren van alle testcases voor de AWS CDK-stack toont

Je kunt ook validatie opnemen in je CDK-stack. Validatietests zijn runtimecontroles binnen je construct- of stackcode die invoer valideren voordat deployment plaatsvindt. Ze helpen misconfiguraties vroeg in de ontwikkelcyclus op te vangen of beperkingen af te dwingen.

Stel dat we de bucket_name als contextvariabele willen doorgeven, maar we willen valideren dat:

• De bucketnaam niet leeg is
• Hij voldoet aan S3-naamregels (bijv. alleen lowercase)

Maak een bestand genaamd test/test_storage_with_lambda.py en voeg het volgende toe:

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")Mogelijk gemaakt door

 Om de validatie te testen, voer je onderstaand commando uit:

test/test_storage_with_lambda.pyMogelijk gemaakt door

Pytest-output die het succesvol uitvoeren van alle testcases voor de AWS CDK-stack toont

Wanneer testen gebruiken:

• Je herbruikbare constructs of patronen maakt.
• Het implementeren van tests dient om standaard technische vereisten onder teamleden vast te leggen.
• Je regressies of onbedoelde wijzigingen tijdens CI/CD wilt opvangen.

Wil je je CDK-kennis versterken in een interviewsetting? Deze top AWS DevOps-interviewvragen helpen je voorbereiden.

Best practices en tips voor werken met de AWS CDK

Nadat je het maken en deployen van CDK-stacks onder de knie hebt, is het goed om best practices te volgen om je infrastructuurcode schoon, veilig en schaalbaar te houden. In deze sectie bespreken we hoe je grote projecten structureert, security goed aanpakt en CDK integreert in CI/CD-pijplijnen.

Grote projecten organiseren

Naarmate je CDK-app groeit, wordt het essentieel om code op te delen in beheersbare eenheden.

Gebruik meerdere stacks

Splits je infrastructuur op per aandachtsgebied. Bijvoorbeeld:

• NetworkingStack: VPC's, subnets, security groups
• ComputeStack: EC2, Lambda
• StorageStack: S3, DynamoDB

Dit laat je delen van je infrastructuur onafhankelijk deployen, testen of vernietigen. Zo kun je het opnemen in app.py:

network_stack = NetworkingStack(app, "NetworkingStack")
compute_stack = ComputeStack(app, "ComputeStack")Mogelijk gemaakt door

Je kunt ook resources tussen stacks doorgeven met outputs of referenties.

Maak herbruikbare geneste constructs

Kapsel gerelateerde resources (zoals een Lambda en de permissies) in een custom construct, zoals je deed met StorageWithLambda. Dit verbetert de leesbaarheid en herbruikbaarheid over stacks of apps heen.

Gebruik omgevingsspecifieke configuratie

Ondersteun meerdere omgevingen (dev, staging, prod) met:

• cdk.json met contextwaarden
• CLI-overrides: cdk deploy -c env=prod
• Conditionele logica in je stacks

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

Beveiliging en permissies

In elk infrastructuurproject moet security prioriteit krijgen tijdens geautomatiseerde deployments met AWS CDK. In de volgende sectie zie je hoe je IAM-resources veilig beheert met het principe van minimale privileges.

Definieer IAM-rollen in plaats van defaults te gebruiken

CDK-constructs, waaronder Lambda of ECS-taken, maken automatisch IAM-rollen aan. Hoewel dit handig is, kan het je controle over permissies en naamgeving beperken.

Definieer in plaats daarvan rollen expliciet:

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")
    ]
)Mogelijk gemaakt door

Deze rol staat standaard alleen logging toe en verder niets.

Pas het principe van minimale privileges toe

Vermijd het gebruik van "*" in actions of resources, tenzij het echt niet anders kan.

Voorbeeld:

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

Gebruik ook waar mogelijk resource-specifieke grants:

bucket.grant_read(lambda_fn)Mogelijk gemaakt door

Dit genereert automatisch het benodigde beleid met beperkt toegangsbereik tot de S3-bucket.

Gebruik beheerde policies waar mogelijk

Door AWS beheerde policies vereenvoudigen het onderhoud en verkleinen de kans op fouten.

iam.ManagedPolicy.from_aws_managed_policy_name("AmazonSQSReadOnlyAccess")Mogelijk gemaakt door

Je kunt deze koppelen aan custom rollen voor services zoals ECS, Batch of Step Functions.

CI/CD-integratie

De AWS CDK wordt extra krachtig door integratie met moderne CI/CD-pijplijnen. CDK ondersteunt geautomatiseerde infrastructuurlevering via versiebeheerde codedeployments, die werken met GitHub, GitLab en AWS-native services zoals CodePipeline. Dit vermindert menselijke fouten, verkort feedbackcycli en maakt deployment over meerdere omgevingen mogelijk.

GitHub Actions: CDK-deployments automatiseren

Je kunt GitHub Actions gebruiken om CDK-stacks te synthetiseren, diffen, testen en deployen bij elke push of pull request.

Bekijk deze .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 }}Mogelijk gemaakt door

Gebruik cdk diff in PR's om infraveranderingen te bekijken vóór het mergen.

CDK-pipelines: Native CDK CI/CD met CodePipeline

Voor volledig beheerde deployments binnen AWS biedt CDK een module genaamd aws_cdk.pipelines, waarmee je je volledige CI/CD-pipeline als code kunt definiëren, net als infrastructuur.

Hier is een vereenvoudigd voorbeeld:

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")
        )Mogelijk gemaakt door

In de bovenstaande code:

• SecretValue.secrets_manager("GITHUB_TOKEN") haalt je GitHub-token veilig op uit Secrets Manager.
• MyAppStage moet een klasse zijn die Stage uitbreidt en je daadwerkelijke CDK-stacks omhult.

Als je ML-systemen deployt, wordt het integreren van CDK met continuous deployment-praktijken behandeld in onze cursus CI/CD for Machine Learning.

Conclusie

Deze tutorial liet je zien hoe je cloudinfrastructuur in Python opzet en deployt met AWS Cloud Development Kit (CDK). Je hebt geleerd om:

• Je eerste CDK-stack te maken.
• S3-buckets en Lambda-functies als resources te definiëren en te valideren.
• Een project te organiseren met custom constructs en multi-stackpatronen.
• Security-best practices toe te passen met het principe van minimale privileges.
• Deployments te automatiseren door GitHub Actions te combineren met CDK Pipelines.
• Tests te schrijven om je infrastructuurlogica te valideren.

Nu je je eerste CDK-app hebt gedeployd, zijn dit een paar manieren om verder te groeien:

• Gebruik geparametriseerde omgevingen voor dev/staging/prod
• Voeg CloudWatch-alarms, API Gateway of Step Functions toe
• Verken CDK-constructs zoals aws_s3_deployment, aws_ecs_patterns en cdk.pipelines
• Zet je constructs om in een interne Python-library voor hergebruik

Blijf leren en bouwen: bekijk de cursus Introduction to AWS Boto in Python!