AWS CDK - Building Cloud Infrastructure as Code🧑‍💻

👉 Quick Intro 🔥

• There are many ways to create resources in AWS like

  • AWS Management Console

  • AWS CLI

  • AWS Software Development Kit (AWS SDK)

  • AWS Cloud Development Kit (CDK)

  • Terraform

  • many more…

• You should know AWS CloudFormation before going ahead

• AWS CDK is framework for defining cloud infrastructure as code using familiar programming languages like Python, TypeScript, JavaScript, Java, C#

• It includes CLI interface for creating, managing, & deploying resources

  Let’s dive in! ➡️

👉 AWS CDK vs SDK vs Terraform 📃

Note:- If you are using AWS for resources and you want separate code for infrastructure management then go for AWS CDK

👉 Cloud Development Kit (CDK) 🤖

• In this blog, we’ll break down AWS CDK using a pizza restaurant analogy. Ready to cook up some epic cloud infrastructure ?

• Setting up a pizza outlet, is kinda like setting up cloud infrastructure with AWS CDK. Your kitchen resources (cloud resources), prepping the ingredients (cloud services) and serving up the delicious pizza (application)

• With AWS CDK, instead of fiddling with AWS management console for every little thing, you’re coding in languages you already know to define cloud resources.

  Cool, right ? 😎

👉 Setup CDK Project ⚙️

1. Install CDK & pre-requisites

   • Install AWS CLI by following this AWS CLI Installation Guide

   • Install NodeJS, as AWS CDK uses NodeJS in the backend

   • Install Python if you are using Python for CDK coding

   • Install CDK as a global npm package

     npm install -g cdk

   • Check the version

     cdk --version

2. Setting up project (pizza outlet)

   • Before you serve those cheesy pizzas, you need to get your kitchen ready 🧑‍🍳

   • In AWS CDK, the kitchen is your project workspace where you code your cloud setup

   • I will be referring to CDK with python in this blog

   • To create the project, make a new folder. Inside it, use the command below and specify the language you will use for coding resources

     cdk init --language python

3. Install dependencies (libraries)

   As I am referring python, so I will install libraries using pip

   pip install -r requirements.txt

👉 CDK CLI Commands 💻

1. Creating project (pizza outlet)

   • We already saw creating CDK project above

     cdk init --language python

2. Needed resources (stock your kitchen)

   • This step is done only for the first-time setup

   • Now the kitchen is ready, but you need to stock it with all the essentials like the oven and utensils

   • The command below will prepare your AWS account with all the necessary resources CDK needs to deploy

     cdk bootstrap

   • This command sets up your AWS account with the S3 buckets, roles, and permissions needed for CDK. These resources are created through the bootstrap stack - CloudFormation template, which has default name CDKToolkit

3. Verify everything (check the recipe)

   • Before you start cooking, you need to check the recipe 📃

   • In CDK, the recipe is a CloudFormation template that tells AWS what to do

   • The AWS CDK project is converted into a CloudFormation template using the below command. The template is stored in a new folder called cdk.out at the root level

     cdk synth

     cdk synth <stack_name>

   • If the code is correct, this command will succeed; otherwise, it will give an error

4. Push the template (serve the pizza)

   • Time to cook and serve those cheesy pizzas! 🍕

   • Below is the command where magic happens. It takes your CloudFormation template (recipe) and sets up the cloud resources in AWS (pizzas in oven) and get things rolling 🚀

     cdk deploy

     cdk deploy <stack_name>

     cdk deploy --all

   • Your cloud infrastructure is live - like serving up fresh, hot pizzas to your customers! 👋

5. Check for changes (menu changes)

   • Thinking of adding new pizza to the menu ? 🤔

   • Before making changes, it’s smart to compare old and new menus just like the below command which compares your current deployed infrastructure with the changes you made in code

     cdk diff

     cdk diff <stack_name>

   • You’ll see a detailed list of changes, so you know exactly what’s different 🧐

6. Overview (checkout your restaurant)

   • Want to see a quick overview of your pizza restaurant setup ? 🤔

   • Below command helps you see all the different stacks (or outlet branches) you have got running

     cdk ls

     cdk ls <stack_name>

   • It will list all the stacks in your CDK app, it is like looking at map of all your restaurant branches 📝

7. Remove everything (closing time)

   • All the good things must come to an end! 🏴

   • When you’re done with your cloud infrastructure and want to clean up, it’s time to delete all the resources (shut down the kitchen). You can do this using the command below, which ensures everything gets cleaned up, leaving no traces behind

     cdk destroy

     cdk destroy <stack_name>

   • As of now, except S3 buckets everything gets deleted in the stack on destroy

👉 CDK Architecture 📝

👉 Constructs 🔗

• Basic building blocks of AWS CDK applications, categorized into three levels

• Each level offers an increasing level of abstraction

• The higher the abstraction, the less configuration required, meaning less expertise is needed, and vice-versa

• In simple terms, constructs are classes available in libraries for each resource. Some resources may not have all levels of constructs available yet

👉 Constructs Levels 🔢

1. L1 Construct (Low-level)

   • Also known as CFN resources, these are the lowest level of constructs and offer no abstraction

   • They require the most configuration and the highest level of expertise

   • Think of them as your raw ingredients—flour, cheese, tomatoes needed for pizza 🧀🍅🍕

   • They map directly to CloudFormation resources and are very flexible, but you have to do a lot of work yourself. These constructs are named starting with Cfn

   • Example: CfnFunction for lambda, CfnBucket for S3

2. L2 Construct (Mid-level)

   • Also known as curated constructs, these are a widely used type

   • They map directly to CloudFormation resources like L1, but offer a higher level of abstraction and provide helper methods for easier and faster configuration

   • These are like pre-made pizza dough, ready-made pizza sauce, or shredded cheese—some of the hard work is already done 🧑‍🍳

   • Example: Function for lambda, Bucket for S3

3. L3 Construct (High-level)

   • Also known as patterns, with highest level of abstraction

   • Each L3 construct can contain collection of resources that are configured to work together to accomplish a specific task or service within your application

   • These are like pre-made pizzas which are dried and packaged, - you just have to oven it and eat 🍕🔥

   • Example: PythonFunction for lambda, NodejsFunction for lambda

👉 Stack 🗄️

• An AWS CDK stack is a collection of one or more constructs that define AWS resources

• Each CDK stack represents a CloudFormation stack in your CDK app

• When you run cdk init, you get only one stack by default in your app, but now we will create two stacks in separate files

    # Stack 1 - s3_stack.py
  
    from aws_cdk import Stack, aws_s3 as s3
    from constructs import Construct
  
    class S3BucketStack(Stack):
        def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
            super().__init__(scope, construct_id, **kwargs)
  
            firstBucket = s3.Bucket(
                self,
                "FirstBucket",
                bucket_name="first-bucket-s3",
                versioned=True,
            )
  

    # Stack 2 - lambda_stack.py
  
    from aws_cdk import Stack, aws_lambda as _lambda
    from constructs import Construct
  
    class LambdaStack(Stack):
        def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
            super().__init__(scope, construct_id, **kwargs)
  
            myLambda = _lambda.Function(
                self,
                "FirstLambda",
                runtime=_lambda.Runtime.PYTHON_3_9,
                code=_lambda.Code.from_asset("lambda"),
                handler="hello.handler",
            )
  

    # app.py
  
    #!/usr/bin/env python3
    import aws_cdk as cdk
    from cdk_practice.lambda_stack import LambdaStack
    from cdk_practice.s3_stack import S3BucketStack
  
    app = cdk.App()
  
    LambdaStack(app, "LambdaStack")
    S3BucketStack(app, "S3BucketStack")
  
    app.synth()
  

👉 Apps 📦

• AWS CDK app is a collection of one or more CDK Stacks

• App construct doesn’t require any initialization argument, it is only a construct that can be used as root

• The App and Stack classes from the AWS Construct Library are unique constructs that provide context to your other constructs without setting up AWS resources themselves

• All constructs representing AWS resources must be defined within a Stack construct, and Stack constructs must be defined within an App construct

• By default, when a CDK project is initialized, it will have only one app and one stack

    # app.py
  
    #!/usr/bin/env python3
    from aws_cdk import App
    from cdk_demo.cdk_demo_stack import CdkDemoStack
  
    app = App()
    CdkDemoStack(app, "CdkDemoStack")
  
    app.synth()
  

👉 Conclusion ✅

This is more than enough to get started with AWS CDK. You can learn as you code. For more details, you can always refer to the CDK documentation.

Happy Learning !!! 👋