Cloud Engineer Job Oriented Program

2.1: Introduction to Amazon Elastic Compute Cloud (EC2)

2.2: Benefits of EC2

2.3: EC2 Instance Types

2.4: Public IP vs. Elastic IP

2.5: Introduction to Amazon Machine Image (AMI)

2.6: Hardware Tenancy – Shared vs. Dedicated

2.7: Introduction to EBS

2.8: EBS Volume Types and Snapshots

2.9: Solid State Drive and Hard Disk Drive

2.10: Introduction to EFS

2.11: Difference between EBS and EFS

2.12: Amazon FSx

2.13: AWS Batch

• Hands On:

• Creating a Linux and Windows Based EC2 Instance
• Creating Custom AMI
• Copying AMI to another region
• Creating EBS volume
• Attaching EBS volume with an instance
• Taking backup of EBS volume
• Attaching EFS Volume to an EC2 Instance
• Creating Snapshot
• Mounting FSx into Windows Servers

3.1: Why move to Cloud Storage?

3.2: Traditional vs. Cloud Storage: Comparing Cost

3.3: Introduction to AWS Storage

3.4: Amazon S3 Architecture

3.5: Working of Simple Storage Service (S3)

3.6: Bucket Policy

3.7: Version Control in S3

3.8: S3: Policies, Storage Classes, and Pricing

3.9: S3 Select and S3 Glacier Select

3.10: Access Control List

3.11: Cross Region Replication (CRR)

3.12: Lifecycle Policy of S3 Bucket

3.13: AWS Backup

3.14: CloudFront

3.15: Snowball

3.16: Amazon Athena and Macie

• Hands On:

• Creating S3 Bucket
• Object Upload to S3 Bucket
• Object Versioning in S3
• Establishing Lifecycle Management for all objects
• Static Website Hosting through S3
• Facilitate transfer and retrieval of data from Glacier
• Creating a Backup Vault
• Sharing File through AWS Storage Gateway

4.1: Introduction to Amazon VPC

4.2: Components of VPC: Route Tables, NAT, Network Interfaces, Internet Gateway

4.3: Benefits of VPC

4.4: CIDR Notations

4.5: IP Addresses

4.6: Network Address Translation: NAT Gateway, NAT Devices, and NAT Instance

4.7: VPC Peering with Scenarios

4.8: VPC: Types, Pricing, Endpoints, Design Patterns

4.9: Direct Connect and Private Link

4.10: Bastion Host and Auto Scaling

4.11: AWS Global Accelerator

4.12: AWS Transit Gateway

• Hands On:

• Creating a VPC, its subnets, and attaching it to an EC2 Instance
• Building triad architecture with security groups
• Using VPC Peering by connecting two instances in different VPCs
• NAT Gateway, NACL, and Internet Gateway 

5.1: Introduction to Elastic Load Balancer

5.2: Types and Features of ELB

5.3: Components and Benefits of Application Load Balancer

5.4: Tripartite comparison between Application, Network, and Classic Load Balancer

5.5: Cross-Zone Load Balancing

5.6: Load Balancer Architecture

5.7: Auto-Scaling: Introduction, Components, Types, Groups, Lifecycle, and Benefits

5.8: Launch Configurations/Launch Templates

5.9: Load Balancer and Auto Scaling

5.10: Working of DNS

5.11: Route 53: Need and Working

5.12: Routing Policies

• Hands On:

• Creating a Classic, Network, or Application ELB
• Creating and Configuring an Auto-Scale Group
• Integrating ELB with Auto Scaling
• Making use of Launch Template for creating ASG

6.1: Introduction to Databases

6.2: Types of Databases

6.3: Introduction to Amazon Relational Database Service (RDS)

6.4: Features and Pricing of and Read Replicas in RDS

6.5: Amazon Aurora: Introduction, Pricing, Design Patterns, and Benefits

6.6: Amazon Redshift: Introduction and Advantages

6.7: DynamoDB: Introduction, Components, Design Patterns, and Pricing

6.8: Introduction to ElastiCache

• Hands On:

• Launching and Modifying an RDS instance
• Data Caching using Amazon ElastiCache
• Creating an Aurora replica, a Multi-az Deployment, and an Aurora DB Cluster
• Conducting CRUD operations on No-SQL Database
• Creating a DynamoDB Table

7.1: Introduction to Identity Access Management (IAM)

7.2: Introduction to Amazon Resource Name (ARN) and Multi-Factor Authentication (MFA) in JSON and IAM

7.3: IAM: Policies, Roles, Permissions, Pricing, and Identity Federation

7.4: IAM: Groups, Users, Features

7.5: Introduction to Resource Access Manager (RAM)

7.6: AWS Single Sign-On (SSO)

7.7: Introduction to CloudTrail 

7.8: Introduction to CloudWatch: Architecture, Pricing, Metrics and Namespaces, Design Patterns, Alarms, Dashboards, and Logs

7.9: AWS Directory Service

• Hands On:

• Creating IAM users, a group, a policy, and a role
• Creating CloudWatch dashboard
• Building a log group, billing alarm, and a trail
• Configuring Secure Authentication Access Mechanism through Amazon Cognito

8.1: Introduction to AWS CloudWatch

8.2: What is AWS Config

8.3: Introduction to AWS CloudTrain and Control Tower

8.4: What are AWS Organizations and License Tower

8.5: Introduction to AWS Service Catalog and Systems Manager

8.6: What is AWS Personal Health Dashboard

• Hands On:

• Conducting an audit of Amazon Cloud Services through AWS CloudTrail
• Application Metrics monitoring through CloudWatch Dashboard

9.1: Introduction to AWS Simple Email Service (SES) and Simple Notification Service (SNS)

9.2: Working of SES and SNS

9.3: Working with Amazon Simple Queue Service

9.4: Comparison between Amazon SNS and SQS

9.5: Amazon MQ and Amazon Event Bridge

9.6: Amazon Simple Workflow Service (SWF)

9.7: Introduction to AWS Lambda, AWS Fargate, AWS Step Functions, AWS Elastic Beanstalk, AWS CloudFormation

9.8: Amazon Elastic Transcoder, Amazon Kinesis, and Amazon Workspaces

9.9: Advantages and Disadvantages of AWS Lambda

9.10: Elastic Beanstalk: Working, Pricing, Concepts

9.11: Introduction to AWS OpsWorks

• Hands On:

• Creating Lambda function and Setting up Lambda triggers and destinations
• Monitoring EC2 instance status through the combination of SNS and EventBridge
• Using AWS StepFunctions to create Workflows
• Creating an Elastic Beanstalk application
• Using JSON and YAML to create Cloud Formation templates
• Creating a stack in OpsWorks
• Using Beanstalk for Web Application deployment with DynamoDB

10.1: Introduction to AWS Well-Architected Framework

10.2: Designing a Well-Architected Framework 

10.3: Pillars of AWS Well-Architected Framework

10.4: How to build Highly Available and Fault Tolerant Architectures

10.5: Deciding upon Resilient Storage

10.6: Designing Decoupling Mechanisms and Multi-tier Architecture Solution

10.7: Introduction to Disaster Recovery and ways to implement the same

10.8: Guaranteeing Performance Efficiency through Selection, Review, and Monitoring

• Hands On:

• Website designing using Serverless Architecture

11.1: What is SageMaker?

11.2: Key features and benefits

11.3: Use cases and applications

11.4: Overview of SageMaker Studio

11.5: Setting up SageMaker Studio

11.6: Data cleaning and preprocessing

11.7: Handling missing data

11.8: Feature scaling and normalization

11.9: Exploratory Data Analysis (EDA) using SageMaker

11:10: Visualizing and understanding your data

2.1: EC2 Walkthrough

2.2: Installation of DevOps Tools in the Cloud

• ELK
• Git
• Puppet
• Docker
• Selenium
• Ansible
• Jenkins
• Kubernetes

3.1: What is Version Control?
3.2: Types of Version Control System
3.3: Introduction to SVN
3.4: Introduction to Git
3.5: Git Lifecycle
3.6 : Common Git Commands
3.7 : Working with Branches in Git
3.8 : Merging Branches
3.9 : Resolving Merge Conflicts
3.10 : Git Workflow

• Hands On:

• Git Life cycle Commands
• Stashing Code in Git
• Creating, Deleting Git Branches
• Pushing Code to GitHub
• Reverting a Push to GitHub
• Using Git to merge branches
• Using Git rebase to merge branches
• Using git merge tool to resolve merge conflicts 

4.1: Introduction to Docker

 4.2: Understanding Docker Lifecycle

 4.3: Components of Docker Ecosystem

 4.4: Common Docker Operations

 4.5: Creating a DockerHub Account

 4.6: Committing changes in a Container

 4.7: Pushing a Container Image to DockerHub

 4.8: Using Dockerfile to create Custom Docker Images

• Hands On:

• Common Docker Operations
• Creating a DockerHub Account
• Committing Changes to a Container
• Pushing container to DockerHub
• Creating Local Image Repository
• Building an Image using Dockerfile

5.1: What is Ansible?

 5.2: Ansible vs Puppet

 5.3: Ansible Architecture

 5.4: Using Ansible to set up Master-Slave 

 5.5: Ansible Playbook

 5.6: Ansible Roles

 5.7: Using Ansible for applying configuration 

• Hands On:

• Installing Ansible on AWS
• Creating a Playbook using YAML
• Creating an Ansible Role
• Using Roles in Playbook

6.1:Branching and Merging with Git

6.1:Resolving Merge Conflicts

6.1:Utilizing Stashing, Rebasing, Reverting, and Resetting in Git

6.1:Understanding Git Workflows

6.1:Introduction to Maven and Its Uses

6.1:Exploring Maven Architecture

6.1:Introduction to Continuous Integration Principles

• Hands On:

• Applying Branching and Merging Techniques in Git
• Managing Merge Conflicts
• Implementing Stashing, Rebasing, Reverting, and Resetting in Git
• Configuring Maven for Project Management

7.1: Introduction to Continuous Integration

 7.2: Jenkins Master-Slave Architecture

 7.3: Understanding CI/CD Pipelines

 7.4: Creating an end-to-end automated CI/CD Pipeline

• Hands On:

• Creating a Jenkins Master-Slave on AWS
• Installing Plug-ins in Jenkins
• Creating Jenkins Builds
• Creating Scheduled Builds
• Triggering Jobs using Git Webhooks
• Using the Pipeline Plugin in Jenkins

8.1: Introduction to Kubernetes

 8.2: Docker Swarm vs Kubernetes

 8.3: Kubernetes Architecture

 8.4: Deploying Kubernetes using Kubeadms

 8.5: Alternate ways of deploying Kubernetes

 8.6: YAML Files

 8.7: Creating a Deployment in Kubernetes using YAML

 8.8: Services in Kubernetes

 8.9: Ingress in Kubernetes

 8.10: Case Study – Kubernetes Architecture

• Hands On:

• Setting up Kubernetes using kubeadm
• Installing Kubernetes using kops and GCK
• Creating a Deployment
• Creating Services
• Creating an Ingress
• Demonstrating the use of Ingress, services, and deployments together

9.1: What are volumes?

 9.2: Types of volumes

 9.3: Persistent volumes

 9.4: Introduction to secrets

 9.5: Taints and tolerations

 9.6: Introduction to Federation

 9.7: Kubernetes Monitoring

 9.8: Setting up Prometheus

 9.9: Setting up Grafana

• Hands On:

• Creating volumes
• Creating Persistent Volumes
• Creating and working with secrets, Taints, and Tolerations
• Controlling clusters from the outside
• Setting up and working with Prometheus
• Setting up and working with Grafana

10.1: Introduction to Prometheus and Grafana

10.2: Setting up Prometheus and Grafana

10.3: Utilizing Prometheus for Monitoring

10.4: Visualization Techniques with Grafana Dashboards

10.5 : Creating Pipelines Monitoring Dashboard

• Hands On:

• Service Monitoring with Prometheus
• Implementing Alerts with Prometheus
• Dashboard Creation in Grafana
• Pipeline Monitoring Techniques                       

11.1: What is Infrastructure as a code

 11.2: IaC vs Configuration Management

 11.3: Introduction to Terraform

 11.4: Installing Terraform on AWS

 11.5: Basic Operations in Terraform

• init
• plan
• apply
• destroy

11.6 : Terraform Code Basics

 11.7 : Deploying an end-to-end architecture on AWS using Terraform

Hands-on:

• Installing Terraform
• Initializing AWS Terraform Provider
• Creating an EC2 instance using Terraform
• Updating changes to EC2 using Terraform
• Destroying EC2 using Terraform
• Deploying EC2 inside a custom VPC using Terraform

12.1: HCL (HashiCorp Configuration Language) basics

12.2: Defining providers in Terraform

12.3: Configuring provider-specific settings

12.4: Defining resources in Terraform

12.5: Common resource types

12.6: Understanding Terraform state

12.7: Managing state files
Using variables in Terraform

12.8: Variable types and scope

12.9: Introduction to modules

12.10: Creating and using modules

12.11: Configuring remote backends for state storage

12.12: Using AWS S3 or other backends

12.13: Utilizing data sources in Terrafor

12.14: Querying external data

12.15: Organizing Terraform code

12.16: Code structuring and naming conventions

12.17: Version control with Terraform

• Hands On:
• Create a simple module for a specific resource type (e.g., VPC).
• Use the module in a main Terraform configuration.
• Configure a remote backend, such as an AWS S3 bucket.
• Initialize and apply your Terraform configuration using the remote backend.
• Use a data source to retrieve information from an existing AWS resource (e.g., an AMI ID).
• Integrate the data source into your Terraform configuration
• Refactor your existing Terraform code following best practices.
• Implement version control for your Terraform code using Git.

13.1: Understanding code quality and its importance

13.2: Installation and setup of SonarQube

13.3: Configuring projects in SonarQube

13.4: Analyzing code with SonarQube

13.5: Interpreting SonarQube analysis results

13.6: Addressing code issues identified by SonarQube

13.7: Utilizing quality gates for automated quality control

13.8: Integrating SonarQube into CI/CD pipelines

13.9: Managing and maintaining SonarQube instance

13.10: Best practices for effective usage of SonarQube