Nested stacks for modularity in AWS - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a nested stack in AWS CloudFormation?

A nested stack is a CloudFormation stack created as part of another stack. It helps organize and reuse templates by breaking complex setups into smaller, manageable parts.

beginner

Why use nested stacks for modularity?

Nested stacks let you reuse common infrastructure patterns, reduce template size, and simplify management by separating resources into logical groups.

intermediate

How do nested stacks improve infrastructure management?

They allow updating parts of the infrastructure independently, making changes safer and easier to track.

intermediate

What is a key requirement for using nested stacks?

The parent stack must reference child stack templates by URL or S3 URL, and the child templates must be valid and accessible during deployment.

advanced

Can nested stacks be nested further?

Yes, nested stacks can contain other nested stacks, allowing deep modularity, but too many levels can increase complexity and deployment time.

What is the main benefit of using nested stacks in AWS CloudFormation?

A Breaking complex templates into smaller reusable parts

B Increasing the size of the main template

C Avoiding the use of parameters

D Automatically scaling resources

Nested stacks help organize and reuse templates by breaking complex setups into smaller, manageable parts.

How does a parent stack reference a nested stack template?

A By copying resources manually

B By embedding the entire child template inline

C By URL or local path to the child template

D By using environment variables

The parent stack references child stack templates by URL or local path during deployment.

Which of the following is NOT a benefit of nested stacks?

A Simplifies management by grouping resources

B Allows independent updates of parts

C Enables reuse of common infrastructure patterns

D Automatically fixes template errors

Nested stacks do not automatically fix errors; templates must be valid and error-free.

Can nested stacks contain other nested stacks?

A No, only one level is allowed

B Yes, but too many levels can increase complexity

C Yes, with no limits or downsides

D Only if using AWS Lambda

Nested stacks can be nested further, but too many levels can increase complexity and deployment time.

What must be true about child templates in nested stacks?

A They must be accessible and valid during deployment

B They must be written in JSON only

C They cannot use parameters

D They must be stored in the same folder as the parent

Child templates must be valid and accessible by the parent stack during deployment.

Explain how nested stacks help with modularity in AWS CloudFormation.

Think about how dividing a big task into smaller tasks makes it easier.

Describe the key considerations when using nested stacks in your infrastructure design.

Consider what must be true for nested stacks to work well and what challenges might arise.

Practice

1. What is the main benefit of using nested stacks in AWS CloudFormation?

easy

A. They replace the need for IAM roles.

B. They automatically increase server CPU capacity.

C. They break large templates into smaller, reusable parts.

D. They encrypt all data stored in S3 buckets.

Solution

1. Step 1: Understand the purpose of nested stacks

   Nested stacks allow splitting a big CloudFormation template into smaller templates for easier management.

2. Step 2: Compare options with this purpose

   Only They break large templates into smaller, reusable parts. describes breaking large templates into reusable parts, which matches nested stacks' main benefit.

3. Final Answer:

   They break large templates into smaller, reusable parts. -> Option C

4. Quick Check:

   Nested stacks = modular templates [OK]

Hint: Think modular: nested stacks split big templates [OK]

Common Mistakes:

• Confusing nested stacks with scaling features
• Assuming nested stacks handle encryption automatically
• Mixing nested stacks with IAM role functions

2. Which syntax correctly defines a nested stack resource in a CloudFormation template?

easy

A. "Type": "AWS::Lambda::Function",
"Properties": {"Handler": "index.handler"}

B. "Type": "AWS::S3::Bucket",
"Properties": {"BucketName": "nested-stack"}

C. "Type": "AWS::EC2::Instance",
"Properties": {"ImageId": "ami-123456"}

D. "Type": "AWS::CloudFormation::Stack",
"Properties": {"TemplateURL": "https://s3.amazonaws.com/mybucket/mystack.yaml"}

Solution

1. Step 1: Identify nested stack resource type

   The resource type for nested stacks is AWS::CloudFormation::Stack.

2. Step 2: Check the properties for nested stack

   Nested stacks require a TemplateURL property pointing to the child template location.

3. Final Answer:

   "Type": "AWS::CloudFormation::Stack", "Properties": {"TemplateURL": "https://s3.amazonaws.com/mybucket/mystack.yaml"} -> Option D

4. Quick Check:

   Nested stack resource = AWS::CloudFormation::Stack [OK]

Hint: Nested stack resource type is AWS::CloudFormation::Stack [OK]

Common Mistakes:

• Using S3 bucket or EC2 instance types for nested stacks
• Omitting TemplateURL property
• Confusing Lambda function syntax with nested stacks

3. Given a parent stack that passes a parameter VpcId to a nested stack, what will happen if the nested stack template does NOT declare VpcId as a parameter?

medium

A. The nested stack deployment will fail with a parameter validation error.

B. The nested stack will ignore the parameter and deploy successfully.

C. The parent stack will automatically create the missing parameter.

D. The nested stack will use a default VPC ID automatically.

Solution

1. Step 1: Understand parameter passing in nested stacks

   Parameters passed from parent to nested stack must be declared in the nested stack template.

2. Step 2: Consequence of missing parameter declaration

   If the nested stack does not declare the parameter, CloudFormation cannot map the value, causing deployment failure.

3. Final Answer:

   The nested stack deployment will fail with a parameter validation error. -> Option A

4. Quick Check:

   Missing nested stack parameter = deployment error [OK]

Hint: Nested stack must declare all passed parameters [OK]

Common Mistakes:

• Assuming parameters are optional in nested stacks
• Thinking parent stack auto-creates missing parameters
• Believing nested stacks use default values without declaration

4. You have a nested stack that fails to update because the child stack template URL is incorrect. What is the best way to fix this error?

medium

A. Delete the parent stack and recreate it from scratch.

B. Update the parent stack template to use the correct TemplateURL for the nested stack.

C. Change the nested stack resource type to AWS::S3::Bucket.

D. Remove the nested stack resource from the parent template.

Solution

1. Step 1: Identify cause of failure

   The error is due to an incorrect TemplateURL in the parent stack referencing the nested stack template.

2. Step 2: Correct the TemplateURL

   Fixing the TemplateURL in the parent stack template ensures CloudFormation can find and deploy the nested stack correctly.

3. Final Answer:

   Update the parent stack template to use the correct TemplateURL for the nested stack. -> Option B

4. Quick Check:

   Fix TemplateURL in parent stack to fix nested stack update [OK]

Hint: Fix TemplateURL in parent template to fix nested stack errors [OK]

Common Mistakes:

• Deleting entire parent stack unnecessarily
• Changing resource type incorrectly
• Removing nested stack resource instead of fixing URL

5. You want to create a modular infrastructure with nested stacks where a VPC stack outputs a VpcId and a subnet stack needs this VpcId as input. How should you connect these stacks to ensure modularity and correct parameter passing?

hard

A. Use Outputs in the VPC stack and pass them as Parameters to the subnet nested stack in the parent template.

B. Hardcode the VPC ID in the subnet stack template directly.

C. Deploy the subnet stack separately without any parameters.

D. Merge both VPC and subnet resources into a single large template.

Solution

1. Step 1: Use Outputs to share data from VPC stack

   The VPC nested stack should declare an Output for VpcId to share it externally.

2. Step 2: Pass Output as Parameter to subnet stack

   The parent stack template passes the VPC stack's VpcId Output as a Parameter to the subnet nested stack, maintaining modularity.

3. Final Answer:

   Use Outputs in the VPC stack and pass them as Parameters to the subnet nested stack in the parent template. -> Option A

4. Quick Check:

   Outputs to Parameters connect nested stacks modularly [OK]

Hint: Connect stacks via Outputs and Parameters in parent template [OK]

Common Mistakes:

• Hardcoding values breaking modularity
• Deploying stacks separately without parameter passing
• Combining all resources in one big template losing modularity