Infrastructure As Code and How to do it on AWS

2022-06-26T00:00:00+00:00

One interesting new concept I learnt when I was an intern at AWS is Infrastructure as Code (IaC). IaC refers to provision, management and deployment of cloud infrastructure, i.e. the cloud application resources, through code. This would replace the old practice of manually managing cloud resources (e.g. using AWS console) or writing scripts (e.g. using AWS CLI).

IaC provides the smoothness of managing cloud infrastructure by writing code, and managing the code using the same way as we do to application codes. You can write unit and integration tests to test the code defining your infra stack to make it more robust, and you can also do code reviews and use source version control systems like Git to manage the code.

The benefit of using IaC is that it will make the whole process of managing cloud infrastructure to be repeatable, reliable and consistent.

How can we do IaC using AWS

If you are using AWS, one possible tool you can use is AWS Cloud Development Kit (AWS CDK).

AWS CDK is an open-source software development framework that defines several high-level concepts like constructs and stacks that could be used to build infrastructure stacks. Once the infrastructure stack is defined through code, a template will be generated by AWS CloudFormation which is used for deployment to the cloud. The template could be re-used so that the same infrastructure could be generated repeatedly, in a reliable and consistent way.

High-level concepts of AWS CDK

Diagram below shows how infrastructure stacks are generated using AWS CDK:

In the diagram, you can see the smallest building block of an App is Construct. Constructs are re-usable cloud components that could either represent a single AWS resource (e.g. S3, Lambda), or it could be a higher-level abstraction of multiple AWS resources. To initialize a stack, you have to define 3 parameters, namely scope, id and props. An example provided by AWS developer guide could be seen as follow:

import { App, Stack, StackProps } from 'aws-cdk-lib';
import * as s3 from 'aws-cdk-lib/aws-s3';

class HelloCdkStack extends Stack {
  constructor(scope: App, id: string, props?: StackProps) {
    super(scope, id, props);a

    new s3.Bucket(this, 'MyFirstBucket', {
      versioned: true
    }); // construct
  }
}

const app = new App();
new HelloCdkStack(app, "HelloCdkStack");

As can be seen in this example, the construct in this case is an S3 bucket. The scope of S3 bucket is this, referring to the current object (new HelloCdkStack()). The id of a construct is a string that uniquely identifies the construct, in this case ‘MyFirstBucket’. The props is a set of key-value pairs that defines the constructs’ initial configuration. This is optional, since some defaults are pre-defined. But if you want to specify this, check out the API reference for AWS CDK to take a closer look (all the props available for S3 buckets could be found (all the props available for S3 buckets could be found here.

Constructs must be defined within the scope of a stack. Stacks are the unit of deployment that AWS CloudFormation instantiates (implemented through CloudFormation stacks). Stacks contain sets or sets of AWS resources that are created and managed as a single unit. An AWS CDK App can have one or more stacks.

Stacks must be defined within the scope of an App. An App could have one or more stacks. The App construct represents the entire CDK app, which serves as the root of the construct tree.

How to generate an Infra Stack using AWS CDK

After talking about the concept used in CDK code, the next question would be how to generate an infra stack using AWS CDK? We can use the code snippet above to see how to generate a S3 bucket using AWS CDK. Before diving deeper, please make sure you have an AWS account.

To get started, we first need to install AWS CDK. This can be done by npm install -g aws-cdk (a sudo is needed for my case). You can check if you have got CDK CLI installed by using cdk --version.

The first thing we need to do to create an AWS CDK app is to initialize it in a directory with the language we intend to use (in this case TypeScript). Currently the most commonly used language to build CDK applications is TypeScript. Most documents and examples provided by AWS are also using TypeScript. Run the following commands in terminal: mkdir HelloCdk && cd HelloCdk and cdk init --language typescript.

cdk init is a CDK CLI command that could create a new CDK project in the current directory using a template (more info could be found via cdk init --help).

Then, go into the hello_cdk_stack.ts under lib directory and copy the source code into the file:

import { Stack, StackProps } from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as s3 from 'aws-cdk-lib/aws-s3';

export class HelloCdkStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);

    // The code that defines your stack goes here
    new s3.Bucket(this, 'MyFirstBucket', {
      versioned: true
    }); // construct
  }
}

You can run npm run watch inside HelloCdk directory to watch the code updates and check for potential errors.

After modifying code, run cdk diff to take a look at what changes we are about to deploy.

Then, let’s synthesize the CloudFormation template by using cdk synth. The template will be printed out when you run the command.

To explain more about what happens in this step, let’s use an analogy of running a compiled language like C++. In this case, CDK CLI acts like the compiler that turns your source code into assembly language (i.e. the machine instructions), and cdk synth is the command used to generate the “assembly language” - the CloudFormation template.

After “compiling” the source code, the next step would be to execute the compiled code, in this case is to deploy our infra stack to the cloud. Before doing this, we need to run an extra command, cdk bootstrap, to bootstrap our cloud environment (i.e. to specify the account and region that the infra stack will be deployed). We can specify the environment in this command, but in our case a default environment will be used (which we have specified in ~/.aws/credentials).

Finally, let’s deploy our infra stack using cdk deploy and check it out on AWS console!

Go to S3 bucket, we can see the S3 bucket created using cdk code We can also see the stack we deployed in CloudFormation. Note that the CDKToolKit stack is created by default and can be re-used by many CDK applications.

That’s it, we can now clean up the environment by running cdk destroy to avoid any unnecessary billing when we are done with the experiment.

Conclusion

In this post, we have talked about the concept of Infrastructure as Code (IaC) and why we should consider using IaC to manage our cloud infrastructures. In a nutshell, IaC makes the provision, management and deployment of our cloud infra in a more repeatable, reliable and consistent manner.

While I believe all the mainstream cloud service providers have their own service to support IaC, I have used CDK as an example to show how IaC is done at AWS. According to AWS, AWS CDK can provide higher level abstraction (using the construct, stack and app), easy to share and have all the benefits of AWS CloudFormation.

Gloria Tan

Infrastructure As Code and How to do it on AWS

How can we do IaC using AWS

High-level concepts of AWS CDK

How to generate an Infra Stack using AWS CDK

Conclusion

References