[AWS CDK](https://aws.amazon.com/cdk/) has definitely made deploying infrastructure simpler than it used to be. Gone are the days where you have to manage
your infrastructure with long [Cloudformation](https://aws.amazon.com/cloudformation/) templates. [AWS SAM](https://aws.amazon.com/serverless/sam/) was an initial attempt
to simplify some of the complicated ways of defining resources in AWS. Like I have realised with many new AWS releases,
the documentation isn't always up to par with everyday-use cases the community tends to have.

 

This might have been an issue with my own expectations **(just another developer being lazy)** when I
expected [@aws-cdk/aws-lambda](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-lambda-readme.html)
to be a no-build setup. After being able to successfully deploy, it was a bit of a surprise when I had issues
at runtime. I will now recount the problems I faced and how I solved them.

## Outline

- [Prerequisites](#prerequisites)
- [Getting Started](#getting-started)
- [Reference project architecture](#reference-project-architecture)
- [Resources](resources)

## Prerequisites

This might not be the best place to get started if you are a beginner. Some prior knowledge and setup is required for the technologies listed below:

- [NodeJS](https://nodejs.org/en/)
- [Typescript](https://www.youtube.com/watch?v=N4u7VjDEa_Y&list=PL-wUrhz1SjEABF5NQu8MwWFtX0tOFyCAh)
- [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

## Getting Started

Install CDK globally

```bash
$ npm install -g aws-cdk
```

Inside an empty folder of your choice, run the command to initiate a new app.

```bash
$ cdk init app --language typescript
```

### Reference project architecture

The initial default project structure that CDK creates is not something I tend to use as-is.
However, if you prefer the defaults, you can continue without making any of the changes I will be making.

 

Change the app field in your cdk.json

 

```json:cdk.json
{
 "app": "npx ts-node bin/app.ts",
 ...
}
```

Your project should have a similar structure to the one below:

```ts
.
├── bin
| ├── app.ts
├── lib
│ ├── LambdaStack.ts
├── src
| ├── lambda.ts
└── tsconfig.json
└── cdk.json.json
```

### Getting our hands dirty-ish

Creating our stack.

```ts:lib/LambdaStack.ts
import { Stack, Construct } from '@aws-cdk/core';
import { Code, Function as Handler, Runtime } from '@aws-cdk/aws-lambda';

export class LambdaStack extends Stack {
 constructor(scope: Construct) {
 super(scope, 'lambda-stack');
 const code = Code.fromAsset('./src');
 const handler = new Handler(this, 'Handler', {
 runtime: Runtime.NODEJS_14_X,
 handler: 'lambda.handler',
 functionName: 'handler',
 code,
 });
 }
}
```

Creating and echo function as our handler.

```ts:src/lambda.ts
/**
 * Echo handler
 *
 * @param event
 * @returns
 */
export async function handler(event: any){
 return event
}
```

```bash
$ yarn cdk deploy
```

Once deployed, let's try and execute our newly deployed function.

```bash
$ aws lambda invoke \
 --cli-binary-format raw-in-base64-out \
 --function-name handler \
 --payload '{ "name": "Bob" }' \
 response.json
```

```json:response.json
{
 "errorType": "Runtime.ImportModuleError",
 "errorMessage": "Error: Cannot find module 'lambda'\nRequire stack:\n- /var/runtime/UserFunction.js\n- /var/runtime/index.js",
 "trace": [
 "Runtime.ImportModuleError: Error: Cannot find module 'lambda'",
 "Require stack:",
 "- /var/runtime/UserFunction.js",
 "- /var/runtime/index.js",
 " at _loadUserApp (/var/runtime/UserFunction.js:202:13)",
 " at Object.module.exports.load (/var/runtime/UserFunction.js:242:17)",
 " at Object.<anonymous> (/var/runtime/index.js:43:30)",
 " at Module._compile (internal/modules/cjs/loader.js:1085:14)",
 " at Object.Module._extensions..js (internal/modules/cjs/loader.js:1114:10)",
 " at Module.load (internal/modules/cjs/loader.js:950:32)",
 " at Function.Module._load (internal/modules/cjs/loader.js:790:12)",
 " at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:76:12)",
 " at internal/main/run_main_module.js:17:47"
 ]
}
```

There is clearly something wrong with our function. The invocation error shouldn't come as a surprise because our typescript file doesn't seem to have been compiled when looking at the lambda console.

 
<Flex justifyContent="space-between" justifyContent="center" alignItems="center" m={2}>
 <img
 src="/posts/cdk-lambda-console.png"
 alt="AWS Lambda code console"
 minWidth="200px"
 minHeight="100px"
 rounded="xl"
 />
</Flex>

 

This meant I needed to set up my own build to compile my typescript files to javascript. Like most of my fellow developers, I wasted time on the internet looking for a solution that
would give me my no-build solution instead of using what I already knew. I came across [Serverless Stack](https://serverless-stack.com/)
**(excellent tool and easy to setup)** but I wasn't keen on creating a new project from scratch, so I kept
looking. [@aws-cdk/aws-lambda-nodejs](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-lambda-nodejs-readme.html)
to the rescue.

 

Changing our LambdaStack to look like the code below allows us to have auto-compiled typescript:

 

```ts:lib/LambdaStack.ts
import { NodejsFunction } from '@aws-cdk/aws-lambda-nodejs';
...
const handler = new NodejsFunction(this, 'Handler', {
 runtime: Runtime.NODEJS_14_X,
 handler: 'handler',
 functionName: 'handler',
 entry: './src/lambda.ts',
});
```

As mentioned in the documentation, to build this locally you need to have docker running or add esbuild to your project.
Even though I have docker on my computer, I prefer to add esbuild to the project.

```bash
$ yarn add --dev esbuild@0
```

Deploying once more

```bash
$ yarn cdk deploy
```

Invoking our lambda once more

```bash
$ aws lambda invoke \
 --cli-binary-format raw-in-base64-out \
 --function-name handler \
 --payload '{ "name": "Bob" }' \
 response.json
```

 

We have the expected response.

 

```json:response.json
{
 "name": "Bob"
}
```

 
This basic setup is needed to deploy your Lambda function with CDK and TypeScript. You might need to
adapt this solution to your use cases for a more complete solution. Hopefully, this is sufficient enough
to get you started.

## Resources

- [AWS CDK](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-construct-library.html)
 - [AWS CDK Lambda](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-lambda-readme.html)
 - [AWS CDK NodeJS Lambda](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-lambda-nodejs-readme.html)
- [Serverless Stack](https://serverless-stack.com/)
- [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)
- [NodeJS](https://nodejs.dev/learn)
- [Typescript](https://www.youtube.com/watch?v=N4u7VjDEa_Y&list=PL-wUrhz1SjEABF5NQu8MwWFtX0tOFyCAh)

AWS released CDK (Cloud Developer Kit) in the second half of 2019, this is an attempt to get more developers writing infrastructure code.

Deploying Lambda functions with CDK and Typescript

Javascript is known as the language of the web. With over **97%** of the web built on Javascript,
it is natural for people to think that they should learn it if they want to start with web development.

## Outline

- [Decision Fatigue](#decision-fatigue)

- [What should I learn?](#what-should-i-learn)

- [Javascript Considerations](#javascript-considerations)

- [Typescript Considerations](#typescript-considerations)

- [Conclusion](#conclusion)

- [Resources](#resources)

## Decision Fatigue

As many of us have realised, there is a lot of decision fatigue when entering web development, especially as a beginner.
With so many frameworks and libraries to choose from, it can sometimes be daunting to start.

## What should I learn?

**Should you learn Javascript before Typescript?** The quick answer is no. However, like most things in life, it depends.
Before I ventured into web development, I had experience using **Java** and **C#**, two statically-typed languages.
The fun began when I started using Javascript. I almost instantly had problems because I was approaching it with a Java mindset.
Classes in Javascript were not as commonly used in their current form. `null`, `undefined` and everything falsy
were somewhat of an issue, but that can also be explained by my inexperience.

 

A lot of my previous google searches about the language were primarily out of frustration. Mainly
because of the freedom and somewhat lack of structure, opposite to what I was used to. Along came Typescript,
with some structure and a little bit of consistency. I know I haven't answered the question, but I will
get to that in a moment. There are things you need to consider before making this decision.

## Javascript Considerations

- You're following a tutorial that primarily uses Javascript
- You are used to dynamically-typed languages
- Looking to move quickly **(easier to get started)**
- No compilation needed depending on setup

## Typescript Considerations

- You are indirectly learning Javascript, with some benefits
- Willing to spend a little more time dealing with typing issues
- Experience with statically-typed languages **(not equivalent, but it helps)**
- You already have Javascript anxiety
- Willing to deal with some support issues from some npm packages **(This is fast becoming a none-factor)**

## Conclusion

If you are not in a hurry and are willing to deal with the pain points of learning Typescript **(recommended)**, then Typescript is the way to go.
Looking to hack up something quick from a good tutorial online that does not support Typescript?
Learn Javascript, the skills are transferable to the former. The community is headed towards more Typescript adoption and a lot of new projects are Typescript first.

 

## Resources

Suppose you want to learn some typescript from scratch. Check out my [Typescript Essentials](https://www.youtube.com/watch?v=N4u7VjDEa_Y&list=PL-wUrhz1SjEABF5NQu8MwWFtX0tOFyCAh)
on youtube.

Flaticon

Javascript is known as the language of the web. With over 97% of the web built on Javascript, it is natural for people to think they should learn it if they want to start with web development.