What is AWS CDK (Cloud Development Kit)
Tags: aws, awscdk, cdk, iac
Published: 2023-10-15 19:37:24

---
title: What is AWS CDK (Cloud Development Kit)
published: true
date: 2023-01-10 15:00:42 UTC
tags: #aws #awscdk #cdk #iac
canonical_url: https://blog.mikaeels.com/what-is-aws-cdk
---

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7nfaatc3h50j2kjtz2q1.jpeg)

The AWS CDK (Cloud Development Kit) is an open-source software development framework that allows developers to design, compose, and share cloud infrastructure in a familiar programming language. With the AWS CDK, you can design, compose, and share cloud infrastructure in TypeScript, JavaScript, Python, C#, or Java.

The CDK leverages familiar programming concepts and software development tools to help developers build cloud infrastructure in a systematic and predictable manner. It has several core components that work together to help you create and manage cloud infrastructure. Some of the key components of the CDK include:

- <mark>Constructs</mark>: These are the building blocks of the CDK, and are used to define your cloud infrastructure. Constructs are high-level abstractions that represent AWS resources and can be composed together to build more complex infrastructures. The CDK provides a wide range of constructs for various AWS services such as AWS Lambda, AWS S3, AWS DynamoDb, AWS ECS, and more.

- <mark>Stacks</mark>: A stack is a container for AWS resources that are defined using constructs. A stack can be deployed, updated, or deleted as a unit.

- <mark>App</mark>: An app is a container for one or more stacks, and is used to organize your CDK resources. Each app has a unique CloudFormation template and a CloudFormation stack per environment.

- <mark>Synthesis</mark>: This process converts your CDK app into a CloudFormation template. This can be done by running the `cdk synth` command.

- <mark>Deployment</mark>: Once your app has been synthesized, you can deploy it to your AWS account using the `cdk deploy` command.

- <mark>Context</mark>: The context is used to pass configuration information to your CDK app, such as environment variables, parameter values, and tags.

- <mark>L1</mark> and <mark>L2 constructs</mark>: The CDK has two levels of constructs. The L1 constructs are high-level abstractions that are easier to use and understand. The L2 constructs, on the other hand, are low-level constructs that give more flexibility but require more knowledge of AWS Services.

One of the main benefits of using the AWS CDK is that it allows you to define your cloud infrastructure as code. This means that you can use your preferred version control system to manage your infrastructure and make changes to it in a predictable and reliable manner. You can also automate the deployment of your infrastructure using continuous integration and delivery (CI/CD) pipelines.

In this post, I'll walk through an example of how to use the AWS CDK to create a simple cloud infrastructure that consists of an Amazon S3 bucket and an Amazon EC2 instance.

First, make sure that you have the AWS CDK installed on your development machine. You can follow the instructions in the AWS CDK documentation to install it.

Next, create a new CDK project by running the following command:

```
cdk init sample-app --language=typescript

```

This will create a new directory called "sample-app" and initialize it with a basic CDK project, written in TypeScript.

Next, open the file `lib/sample-app-stack.ts` and replace the contents with the following code:

```
import * as cdk from 'aws-cdk-lib';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as ec2 from 'aws-cdk-lib/aws-ec2';

export class SampleAppStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Create an S3 bucket
    const bucket = new s3.Bucket(this, 'my-bucket', {
      bucketName: 'my-bucket'
    });

    // Create an EC2 instance
    const vpc = new ec2.Vpc(this, 'my-vpc', {
      cidr: '10.0.0.0/16'
    });

    const instance = new ec2.Instance(this, 'my-instance', {
      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T2,             
      ec2.InstanceSize.MICRO),
      machineImage: new ec2.AmazonLinuxImage(),
      vpc: vpc,
      keyName: 'my-key-pair'
    });
  }
}

```

This code defines a CDK stack called `SampleAppStack` that creates an Amazon S3 bucket and an Amazon EC2 instance.

To deploy the stack, make sure to run the **bootstrap** command:

```
cdk bootstrap

or 

cdk bootstrap --account xxxxxxxxxxxxxx --region us-east-1

```

The `cdk bootstrap` command is a key part of the AWS CDK (Cloud Development Kit) workflow. It is used to create the necessary resources in your AWS account to deploy CDK applications.

The `cdk bootstrap` command creates an AWS CloudFormation stack in your account that includes the resources needed to deploy CDK applications, such as an Amazon S3 bucket for storing CloudFormation templates and an Amazon SNS topic for receiving notifications.

Now, to deploy the stack, run the following command:

```
cdk deploy

```

This will build the CDK app and deploy it to your AWS account. The deployment process will create the S3 bucket and EC2 instance in your account.

You can verify that the resources have been created by going to the AWS Management Console and navigating to the S3 and EC2 pages.

To delete the stack and remove all the resources that it created, run the following command:

```
cdk destroy

```

This will delete the S3 bucket and EC2 instance from your account.

That's it! You've just created and deployed a simple cloud infrastructure using the AWS CDK. With the CDK, you can create and manage complex cloud infrastructures in a systematic and predictable manner.

I hope this blog post has given you a good overview of what the AWS CDK is and how you can use it to create cloud infrastructure. For more information, you can refer to the AWS CDK [documentation](https://docs.aws.amazon.com/cdk/api/v2/).