Aws Cdk

# AWS CDK Core Concepts

## Table of Contents

- [App Lifecycle](#app-lifecycle)
- [Stacks](#stacks)
- [Constructs](#constructs)
- [Environments](#environments)
- [Context](#context)
- [Assets](#assets)
- [Tokens and Lazy Values](#tokens-and-lazy-values)
- [Aspects](#aspects)

---

## App Lifecycle

The CDK app lifecycle follows a predictable flow from code to deployed infrastructure:

```
Code → Construct Tree → Synthesis → CloudFormation Template → Deployment
```

### Phases

| Phase | Description | CLI Command |
|-------|-------------|-------------|
| **Construction** | Instantiate App, Stacks, Constructs | — |
| **Preparation** | Mutate construct tree (Aspects run here) | — |
| **Validation** | Validate construct configurations | — |
| **Synthesis** | Generate CloudFormation templates + assets | `cdk synth` |
| **Deployment** | Create/update CloudFormation stacks | `cdk deploy` |

```typescript
import { App } from 'aws-cdk-lib';

const app = new App();

// Construction phase: define stacks and constructs
new MyStack(app, 'MyStack', {
  env: { account: '123456789012', region: 'us-east-1' },
});

// Synthesis phase: generates cdk.out/ directory
app.synth();
```

### Output Directory

After `cdk synth`, the `cdk.out/` directory contains:

```
cdk.out/
├── MyStack.template.json     # CloudFormation template
├── manifest.json              # Assembly manifest
├── tree.json                  # Construct tree
└── asset.*                    # Bundled assets (Lambda code, Docker images)
```

---

## Stacks

A Stack is the unit of deployment — it maps 1:1 to a CloudFormation stack.

### Single Stack

```typescript
import { Stack, StackProps } from 'aws-cdk-lib';
import { Construct } from 'constructs';

export class MyAppStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);
    // Define resources here
  }
}
```

### Multi-Stack Architecture

```typescript
const app = new App();

const networkStack = new NetworkStack(app, 'Network', {
  env: { account: '123456789012', region: 'us-east-1' },
});

const appStack = new AppStack(app, 'App', {
  vpc: networkStack.vpc,
  env: { account: '123456789012', region: 'us-east-1' },
});

// Explicit dependency ensures correct deploy order
appStack.addDependency(networkStack);
```

### Stack Best Practices

- Keep stacks under 500 resources (CloudFormation limit)
- Group resources by lifecycle (network rarely changes, app changes often)
- Use `terminationProtection: true` for production stacks
- Export shared resources as public properties for cross-stack references

---

## Constructs

Constructs are the building blocks of CDK apps. They form a tree hierarchy: App → Stack → Constructs.

### L1 Constructs (CloudFormation Resources)

Direct 1:1 mapping to CloudFormation resource types. Prefixed with `Cfn`.

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

// Full control, no defaults
new s3.CfnBucket(this, 'RawBucket', {
  bucketName: 'my-raw-bucket',
  versioningConfiguration: { status: 'Enabled' },
  bucketEncryption: {
    serverSideEncryptionConfiguration: [{
      serverSideEncryptionByDefault: { sseAlgorithm: 'AES256' },
    }],
  },
});
```

### L2 Constructs (Curated)

Higher-level abstractions with sensible defaults, helper methods, and grant patterns.

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

// Sensible defaults + helper methods
const bucket = new s3.Bucket(this, 'DataBucket', {
  versioned: true,
  encryption: s3.BucketEncryption.S3_MANAGED,
  blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
});

// Grant pattern — generates least-privilege IAM automatically
bucket.grantRead(myLambdaFunction);
```

### L3 Constructs (Patterns)

Combine multiple L2 constructs into reusable architectural patterns.

```typescript
import * as apigateway from 'aws-cdk-lib/aws-apigateway';

// Creates API Gateway + Lambda integration + IAM permissions
new apigateway.LambdaRestApi(this, 'MyApi', {
  handler: myLambdaFunction,