[Udemy] AWS CloudFormation – Simplified | Hands On with YAML
What you’ll learn
- You will learn all CloudFormation template sections with multiple handson examples for each section of template.
- You will write 45 CloudFormation templates during the period of this course with different varitions in templates.
- You will learn writing CloudFormation templates for AWS CodeBuild, CodeDeploy & CodePipeline services which are very important services in AWS for achieving Continuous Integration, Continuous Delivery & Infrastructure as Code.
- You will learn Metadata cfn-init and Helper Scripts (cfn-init, cfn-signal & cfn-hup) in a step by step manner by deploying a simple rest service application to an EC2 instance.
- You will get complete knowledge on every section of cfn-init metadata (packages, users, source, services etc) and helper scripts (cfn-init, cfn-signal & cfn-hup).
- You will learn in implementing the Infrastructure as Code with a VPC sample provided.
- You will master the Nested Stacks concepts by building two nested stacks and using them in Root Stack.
- You will learn implementing cfn-init Config sets(Both Single Config sets and Multiple Config Sets)
- You will learn practically implementing AWS CodeCommit, CodeBuild, CodeDeploy & CodePipeline Services both via AWS Management Console and CloudFormation
- You will learn and master using 14 Intrinsic functions in AWS CloudFormation
- You will learn YAML basics and write all the CloudFormation templates using YAML.
- You will learn concepts, features and integration aspects present in CodeCommit, CodeBuild, CodeDeploy & CodePipeline services.
- You will learn about creating simple rest application using Spring Boot.
- You will learn about AWS SNS (Simple Notification Service – Topics, Subscriptions) and implement the notificaitons in CodeBuild and CodeDeploy Services using CloudFormation.
- You will learn and understand the local git repository, remote git repository and how to use them from Spring Tool Suite IDE.
- You will learn deploying java based rest applications to EC2 Instances using AWS CloudFormation and AWS Developer Tools.
- You will write CloudFormation templates for EC2 Instances and VPC.
- You must have an AWS account to follow with me for hands-on activities.
- Having basic knowledge on AWS EC2 service will suffice.
******* Course Overview *******
Welcome to this Amazing course on AWS CloudFormation Simplified. We will learn by practically implementing all the CloudFormation concepts with multiple examples.
AWS CloudFormation is a core Service in AWS which allows us to automate the Infrastructure and Application Deployments. We can achieve Continuous Integration, Continuous Delivery and Infrastructure as Code when using AWS CloudFormation in combination with AWS Developer Tools like AWS CodeCommit, AWS CodeBuild, AWS CodeDeploy and AWS CodePipeline.
There are two parts to this course.
In the first part of the course you will learn all the AWS CloudFormation concepts by practically implementing them. Below are the sections for part one.
Part-1: AWS CloudFormation
01. Introduction to CloudFormation
02. YAML Essentials
03. Stack Features
10. EC2 UserData
11. Metadata cfn-init & Helper Scripts (cfn-init, cfn-signal and cfn-hup)
12. Metadata cfn-init – Config Sets
13. Nested Stacks
In the second part of the course, you will implement the below listed three concepts using AWS CloudFormation & AWS Management Console. You will write cloud formation templates for AWS Developer tools (AWS CodeCommit, CodeBuild, CodeDeploy & CodePipeline) to implement the CI, CD and IAC.
01. Continuous Integration (CI)
02. Continuous Delivery (CD)
03. Infrastructure as Code (IAC)
Part-2: AWS Continuous Integration, Continuous Delivery and Infrastructure as Code using AWS CloudFormation & AWS Management Console
14. Continuous Integration & Continuous Delivery using CloudFormation
15. Infrastructure as Code using CloudFormation
During the learning process, you will write 45+ cloud formation templates written in YAML.
This course also provides 45+ pre-built templates which you can use them during the learning process. In addition this course comes with 190 slides in a PDF document.
Each of my courses come with
- Amazing Hands-on Step By Step Learning Experiences
- Real Implementation Experience
- Friendly Support in the Q&A section
- 30 Day “No Questions Asked” Money Back Guarantee!
***************Section wise course details**********************
01 Step 01: Introduction to AWS CloudFormation
01 Step 02: AWS CloudFormation Templates and Slides
02 Step 01: YAML Concepts
03 Step 01: Pre-requisites
03 Step 02: Create Stack
03 Step 03: Update Stack
03 Step 04: Create Change Set – KeyName
03 Step 05: Create Change Set – Instance Type
03 Step 06: Update Rollback
03 Step 07: Create Stack – Invalid Template
04 Step 00: Resources Introduction
04 Step 01: Create a Resource – EC2 Instance
04 Step 02: Create a Resource – Security Group
04 Step 03: Create a new rule in existing Security Group
04 Step 04: Create a new resource – Elastic IP
04 Step 05: Perform CloudFormation Template – Case Sensitivity Test
05 Step 00: Parameters Introduction
05 Step 01: Add Keyname as Parameter – AWS Specific Parameter
05 Step 02: Add Availability Zone as Parameter – Parameter Type String
05 Step 03: Add InstanceType as Parameter – Parameter Type String
05 Step 04: Add InstanceType as Parameter – Parameter Type SSM
06 Step 00: Mappings Introduction
06 Step 01: Pseudo Parameters
06 Step 02: Create a Map for AMI’s
06 Step 03: Create a Map for Environments
07 Step 00: Conditions Introduction
07 Step 01: Conditions – Intrinsic Function Fn::Equals
07 Step 02: Conditions – Intrinsic Function Fn::If and Pseudo Parameter AWS::NoValue
07 Step 03: Conditions – Intrinsic Function Fn::If (Additional usecase)
07 Step 04: Conditions – Intrinsic Function Fn::Not
07 Step 05: Conditions – Intrinsic Function Fn::Or
07 Step 06: Conditions – Intrinsic Function Fn::And
08 Step 00: Outputs Introduction
08 Step 01: Outputs – Base Template Overview
08 Step 02: Outputs – InstanceId as Output
08 Step 03: Outputs – Intrinsic Function Fn::GetAtt
08 Step 04: Outputs – Intrinsic Function Fn::Sub and Exports Feature and Pseudo Parameter AWS::StackName
08 Step 05: Outputs – Cross Reference Stacks using Exports feature and Intrinsic Function Fn::ImportValue
08 Step 06: Outputs – For Master Stack – Test Delete Stack and Modify Stack
08 Step 07: Outputs – Conditions in Outputs section of a template
08 Step 08: Outputs – Intrinsic Function Fn::Join
09 Step 00: Metadata Introduction
09 Step 01: Metadata – Designer Metadata Introduction
09 Step 02: Metadata – Designer Metadata Demo
09 Step 03: Metadata – Interface Metadata Introduction
09 Step 04: Metadata – Interface Metadata Base Template Overview
09 Step 05: Metadata – Interface Metadata Demo
10 Step 00: EC2 UserData Introduction
10 Step 01: EC2 UserData – Base Template Overview
10 Step 02: EC2 UserData – Demo
Metadata cfn-init & Helper Scripts (cfn-init, cfn-signal and cfn-hup)
11 Step 00: Metadata cfn-init – Introduction
11 Step 00: Metadata cnf-init – Base Template Overview
11 Step 01: Metadata cfn-init – Metadata Format
11 Step 02: Metadata cfn-init – Packages
11 Step 03: Metadata cfn-init – Groups
11 Step 04: Metadata cfn-init – Users
11 Step 05: Metadata cfn-init – Sources
11 Step 06: Metadata cfn-init – files
11 Step 07: Metadata cfn-init – commands
11 Step 08: Metadata cfn-init – Services
11 Step 09: UserData – Update Helper Scripts – aws-cfn-bootsrap
11 Step 10: UserData – cfn-init
11 Step 11: UserData – cfn-signal
11 Step 12: Outputs & Create Stack
11 Step 13: Creation Policy & Create Stack
11 Step 14: UserData – cfn-hup & Update the v2 version of App – Update Stack Demo
11 Step 15: Metadata cfn-init – Conclusion
Metadata cfn-init – Config Sets
12 Step 00: ConfigSets Introduction
12 Step 01: Single ConfigSet – Demo
12 Step 02: Multiple ConfigSets – Demo 1
12 Step 03: Multiple ConfigSets – Demo 2 – Configset in Configset
12 Step 04: Multiple ConfigSets – Demo 3 – default ConfigSet
13 Step 00: Nested Stacks Introduction
13 Step 00: Nested Stacks – S3 Pre-requisites
13 Step 01: Nested Stacks – Manual VPC Creation
13 Step 02: Create Nested Stack VPC Template – Create VPC
13 Step 03: Create Nested Stack VPC Template – Create Subnet
13 Step 04: Create Nested Stack VPC Template – Create Route Table
13 Step 05: Create Nested Stack VPC Template – Associate Subnet to Route Table
13 Step 06: Create Nested Stack VPC Template – Create Internet Gateway and Associate it
13 Step 07: Create Nested Stack VPC Template – Add Route for Internet Access
13 Step 08: Create Nested Stack VPC Template – Parameterize CidrBlocks
13 Step 09: Create Nested Stack VPC Template – Create Interface Metadata
13 Step 10: Create Nested Stack VPC Template – Create Outputs
13 Step 11: Create Nested Stack VPC Template – Test and Upload to S3
13 Step 12: Create Root Stack Template – Create Base Template
13 Step 13: Create Root Stack Template – Nest VPC stack in Root Stack
13 Step 14: Nested VPC Stack – Demo
13 Step 15: Create Nested Security Group Stack Template
13 Step 16: Update Root Stack Template – Nest Security Group stack in Root Stack
13 Step 17: Nested Security Group Stack – Demo
13 Step 18: Update Nested Security Group Stack with new Inbound Security Rule
13 Step 19: Delete Nested Stacks
Continuous Integration & Continuous Delivery using CloudFormation
14.00.00: Introduction to Continuous Integration & Continuous Delivery
14.01.00: Introduction to EC2 Apps Stack
14.01.01: EC2 Apps Stack – Create Security Group
14.01.02: EC2 Apps Stack – Create VM Instances, Parameters and Outputs
14.01.03: EC2 Apps Stack – Create Instance Profile Role and Instance Profile
14.01.04: EC2 Apps Stack – Create Stack and Verify
14.02.00: CodeCommit – Introduction
14.02.01: CodeCommit – Create a Simple Rest Application
14.02.02: CodeCommit – Create Repo in CodeCommit and check-in code
14.02.03: CodeCommit – Additional CodeCommit Features
14.03.00: Introduction to CodeBuild with AWS Web Console & CloudFormation
14.03.01: CodeBuild – Introduction
14.03.02: CodeBuild – Create Project
14.03.03: CodeBuild – Create buildspec.yml and start buil
14.03.04: CodeBuild – Create Build Notifications
14.03.05: CodeBuild CFN – CloudFormation Introduction
14.03.06: CodeBuild CFN – Update buildspec.yml with Runtime Version
14.03.07: CodeBuild CFN – Create CodeBuild CloudFormation Template
14.03.08: CodeBuild CFN – Create CodeBuild Stack and Test
14.04.00: Introduction to CodeDeploy with AWS Web Console & CloudFormation
14.04.01: CodeDeploy – Introduction
14.04.02: CodeDeploy – Create CodeDeploy Service Role
14.04.03: CodeDeploy – Create a Test VM
14.04.04: CodeDeploy – Create Application & Deployment Group
14.04.05: CodeDeploy – Create appspec.yml and scripts
14.04.06: CodeDeploy – Create New Build & Deploymen
14.04.07: CodeDeploy – Verify the new Deployment
14.04.08: CodeDeploy – New Application Release
14.04.09: CodeDeploy CFN – CloudFormation Introduction
14.04.10: CodeDeploy CFN – appspec.yml and Scripts
14.04.11: CodeDeploy CFN – Create Template – Role, Application and Deployment Group
14.04.12: CodeDeploy CFN – Create CodeDeploy Stack
14.04.13: CodeDeploy CFN – Create Deployment and Update Stack and Test
14.05.00: Introduction to CodePipeline with AWS Web Console & CloudFormation
14.05.01: CodePipeline – Introduction
14.05.02: CodePipeline – Create Pipeline
14.05.03: CodePipeline – Make changes to Rest App and Verify CodePipeline
14.05.04: CodePipeline – Introduction to Prod Approval and Deploy Stages
14.05.05: CodePipeline – Create Prod EC2 Instance & Prod Deployment Group
14.05.06: CodePipeline – Create Prod Approval and Prod Deploy Stages
14.05.07: CodePipeline – Change Code in App and Check-In Code to Trigger Pipeline
14.05.08: CodePipeline – Conclusion for Prod Approval and Deploy Stages
14.05.09: CodePipeline CFN – Introduction
14.05.10: CodePipeline CFN – Create CodePipeline Role
14.05.11: CodePipeline CFN – Create Pipeline Stages – Source, Build and Stage
14.05.12: CodePipeline CFN – Create Pipeline Stack and Verify
14.05.13: CodePipeline CFN – Create SNS and Prod Deployment Group
14.05.14: CodePipeline CFN – Create Prod Pipeline Stages – Approval & Deploy
14.05.15: CodePipeline CFN – Update Stack with Prod Stages
Infrastructure as Code using CloudFormation
15.00.00: Introduction to Infrastructure as Code
15.01.00: Introduction to Infrastructure as Code using AWS Management Console
15.01.01: Understand VPC Source Files
15.01.02: Create VPCRepo in CodeCommit and Check-In VPC Source files
15.01.03: Create Pipeline with Source and Build Stages
15.01.04: Create Pipeline with Test VPC Stage
15.01.05: Create Pipeline with Prod Stage (Create Change Set, Approval, Execute CS)
15.01.06: Update VPC CFN Template with new VPC resources and check-in code
15.02.00: Introduction to Infrastructure as Code using CloudFormation
15.02.01: VPC Source files check-in to CodeCommit Repository
15.02.02: Create CodeBuild Role and CodeBuild Project in CFN Template
15.02.03: Create CodePipeline Role and CloudFormation Role in CFN Template
15.02.04: Create CodePipeline stages Source, Build and Tes
15.02.05: Create CodePipeline CloudFormation Stack with 3 stages
15.02.06: Create Pipeline Stage for Prod(Create Change Set, Approval, Execute CS)
15.02.07: Create CodePipeline CloudFormation Stack with 4 stages
15.02.08: Check-in VPCRepo with new subnet resource added and Monitor Pipeline
CloudFormation Stack Policy
16 Step 00: Introduction to Stack Policy
16 Step 01: Stack Policy – Resource
16 Step 02: Stack Policy – Resource Type
16 Step 03: Stack Policy – Action:Update:Replace
16 Step 04: Stack Policy – NotAction:Update:Delete
16 Step 05: Stack Policy – Override the existing Stack Policy during Stack Update
Who this course is for:
- AWS Developers planning to learn writing CloudFormation templates to provision AWS services.
- System Engineers or Infrastructure engineers who want to better understand the Automated deployment process in AWS.
- Technologists who want to implement Continuous Integration and Continuos Delivery/Deployment process (CI/CD) in AWS.
- DevOps Teams who want to automate the Application and Infrastructure deployments using AWS CloudFormation and AWS Developer Tools.
- Anyone who want to learn end to end automation in AWS (Application Deployments and Infrastructure Deployments).