Nested stacks for modularity in AWS - Mini Project: Build & Apply

Nested stacks for modularity

📖 Scenario: You are building a cloud infrastructure using AWS CloudFormation. To keep your templates clean and reusable, you want to split your infrastructure into smaller parts using nested stacks.Imagine you have a main template that includes a network stack and a compute stack as nested stacks.

🎯 Goal: Create a main CloudFormation template that uses nested stacks for network and compute resources. Each nested stack should be referenced properly to keep the infrastructure modular and organized.

📋 What You'll Learn

Create a main CloudFormation template with two nested stacks: NetworkStack and ComputeStack.

Define the nested stacks using the AWS::CloudFormation::Stack resource type.

Use parameters to pass the VpcId from the network stack to the compute stack.

Ensure the nested stacks are referenced with the correct template URLs.

💡 Why This Matters

🌍 Real World

Large cloud infrastructures are often split into smaller templates to improve readability and reuse. Nested stacks allow teams to manage parts of infrastructure independently.

💼 Career

Cloud architects and DevOps engineers use nested stacks to modularize infrastructure as code, making deployments safer and easier to maintain.

1

Create the main CloudFormation template skeleton

Create a CloudFormation template called main_template.yaml with an empty Resources section.

AWS

Resources:
  # Your code here

Hint

Start with the basic CloudFormation template structure including AWSTemplateFormatVersion and Resources.

2

Add the NetworkStack nested stack resource

In main_template.yaml, add a resource called NetworkStack of type AWS::CloudFormation::Stack with a TemplateURL set to https://s3.amazonaws.com/mybucket/network.yaml.

AWS

AWSTemplateFormatVersion: '2010-09-09'
Description: Main template with nested stacks
Resources:
  NetworkStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: https://s3.amazonaws.com/mybucket/network.yaml
  # Your code here

Hint

Use the AWS::CloudFormation::Stack resource type and set the TemplateURL to the network stack template location.

3

Add the ComputeStack nested stack with parameter passing

In main_template.yaml, add a resource called ComputeStack of type AWS::CloudFormation::Stack. Set its TemplateURL to https://s3.amazonaws.com/mybucket/compute.yaml and pass the VpcId parameter from the output of NetworkStack using Fn::GetAtt with attribute Outputs.VpcId.

AWS

AWSTemplateFormatVersion: '2010-09-09'
Description: Main template with nested stacks
Resources:
  NetworkStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: https://s3.amazonaws.com/mybucket/network.yaml
  ComputeStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: https://s3.amazonaws.com/mybucket/compute.yaml
      Parameters:
        VpcId: !GetAtt NetworkStack.Outputs.VpcId
  # Your code here

Hint

Use Parameters to pass VpcId from NetworkStack outputs using !GetAtt NetworkStack.Outputs.VpcId.

4

Complete the main template with description and resources

Ensure the main_template.yaml includes the AWSTemplateFormatVersion, a Description, and both nested stack resources NetworkStack and ComputeStack with their properties as specified.

AWS

AWSTemplateFormatVersion: '2010-09-09'
Description: Main template with nested stacks
Resources:
  NetworkStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: https://s3.amazonaws.com/mybucket/network.yaml
  ComputeStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: https://s3.amazonaws.com/mybucket/compute.yaml
      Parameters:
        VpcId: !GetAtt NetworkStack.Outputs.VpcId
# Your code here

Hint

Review the entire template to ensure all required parts are included and correctly formatted.

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