• History of UNIX (Linux) and General booting process of Linux
•  Installation of Red Hat 8 and 9 on VMWare
• Linux File System Hierarchy
• Getting help with Man Pages.
• Working with Linux Directories and Files
• Shell Expansion
• Pipes and Command: Filters
• How to use find and grep command in Linux
• Compress, decompress, Zip & Unzip files in Linux
• Regular expressions in Linux
• What is VI and Nano editor & how to use it
• Local user,groups and password management in Linux
• Profiles files
• File Security: Standard file permissions
• Access control list (ACL) in Linux
• File links and & I nodes
• Process management, Top command , Process priority, Nice Value and Jobs
• Create and Manage partitions in Linux. Difference between  Primary, Extended and Logical partitions
• File System and mounting
• Logical Volume (LVM) in Linux
• Resize (Extend or Reduce ) LVM in Linux
• Manage Swap space in Linux
• Create swap file in RedHat
• Concept of RAID and different of RAID levels in Linux
• Booting process of Linux (version 8 and 9)
• Allow or deny selected Users/Groups to login via SSH
• Networking
• What is Firewall ? Why do we need to use Firewall? How to manage Firewall in Linux?
• Introduction to Shell Scripting and practical
• Use of rsync and Crontab
• How to host a website in web server and deploy it

1. Introduction to Cloud :
   1. What is Virtualization
   2. Virtualization vs Cloud
   3. Deployment models of clouds - Public, Private and Hybrid
   4. IAAS, PAAS, SAAS
   5. Account creation     

2. Introduction to AWS :
   1. Region vs AZ
   2. Introduction to EC2 service
   3. Creating instance of Red Hat, Ubuntu and Windows
   4. What is Security Group ?
   5. Remotely access to Linux and Windows machine
3. SSH Service :
   1. SSH key based authentication
   2. Creating another user and login with that user
   3. How to change port number of SSH and other services
4.  Website Deployment :
   1. Installing NGINX and Apache web server
   2. Deploying website
   3. Changing the port number of NGINX and Apache web server
   4. Working with User-data 

5. EC2 instance in depth :
   1. Creating and copying of AMI
   2. Launch Template
   3. Purchasing Options 

6. EBS Volumes :
   1. What is EBS volumes and it’s usage
   2. EBS volumes and it’s types
   3. What is File system and it’s types
   4. Creating partition, Formatting and mounting of EBS volumes
   5. Temporary and Permanent mounting of EBS volumes 

7. Logical Volume Management (LVM)
   1. Creating Physical volme and Volume group
   2. Creating Logical Volume
   3. Extending and Resizing the LVM 

8. Introduction to NFS
   1. Create EFS file system
   2. Attach and Mount the EFS file system
   3. Introduction to fstab file
   4. Temporary and permanent mount(using fstab)             

9. Basics of Networking and CIDR 

10. Virtual Private Cloud (VPC)
    1. Introduction to VPC
    2. CIDR calculation for Subnets
    3. Create VPC and Subnets
    4. Create Internet Gateway and Route Table
    5. Creating Public and Private instance inside the subnets
    6. What is NAT gateway and it’s practical usage
    7. VPC peering 

11. NIC, Elastic IP and Placement Groups
12. NACL and Security Groups 

13. Load Balancer
    1. Introduction to Load Balancer
    2. Load Balancer and it’s types
    3. Difference between Application Load Balancer and Network Load Balancer
    4. Creating Load Balancer and Target Groups 

14. AutoScaling
    1. AutoScaling and it’s types
    2. Creating Launch Templates
    3. AutoScaling Group
    4. Pratical on AutoScaling 

15. Identity and Access Management (IAM)
    1. Introduction to IAM
    2. Creating IAM user
    3. Enabling console access for the IAM user
    4. Enabling programatic access
    5. Creating Group, Add user to group, attach default policy
    6. Demo on IAM 

16. Simple Storage Service (S3)
    1. Introduction to S3
    2. Create Bucket
    3. Upload Objects
    4. S3 properties
    5. Versioning, Static Website Hosting, Server Access Logging
    6. Permission & Metrics tab
    7. Management tab
    8. Lifecyle Rule
    9. Sorage Classess 

17. AWS Cli
    1. Installing AWS CLI windows and Linux
    2. Usage of Cloud Shell
    3. AWS CLI commands for EC2 and S3 

18. CloudWatch
    1. Introduction to CloudWatch
    2. CloudWatch Metrics
    3. How to create Alarms in CW
    4. Log Groups and Log Insights
    5. CloudWatch Logging
    6. CloudWatch Events
    7. SNS topic 

19. RDS Database
    1. Introduction to RDS
    2. Advantages of RDS
    3. Introduction to DBMS, SQL and MariaDB
    4. Backup and Restore the database (Schema only, Data only and Full DB) 

20. Route 53
    1. Introduction to DNS service
    2. Explain Records and Zones
    3. Introduction to Route 53
    4. Domain Purchasing
    5. Create Hosted zone and Simple A record to map instance IP
    6. Different types of Routing Policy 

21. CloudFront
    1. Introduction to CloudFront
    2. Cloud Front practical with S3

22. Lambda
    1. Introduction to Lambda
    2. Demo on Lambda
    3. Using Zip file method to upload Lambda function

23. Project on AWS
24. Revision of whole course

1. Introduction to DevOps
   1. SDLC - Waterfall and Agile Method
   2. What is API and it’s uses ?
   3. What is Frontend and Backend ?
   4. Stages of Application Development
2. GIT
   • Introduction to SCM tool
   • Diff between C-VCS and D-VCS
   • Introduction to GIT
   • Lifecycle of GIT
   • GIT CLI installation
   • GIT commands (git init, commit, logs, revert, restore, status, git branch, checkout, diff, merge)
   • Introduction to Remote Repo (GitHub)
   • Git clone, pull, push, git init, config, remote
   • Public and Private repo
   • Fork and Pull Request
   • Difference between Github and Gitlab
   • Authentication methods (HTTP and SSH)
   • Resolving conflicts
   • Merge repo branches in git
   • What is IDE and installing Visual Studio Code IDE

1. 1. Introduction to Docker
      1. Difference between Monolithic and MicroServices
      2. Difference between Traditional, Virtualization and Containerization Deployment
      3. Introduction to Containerization, Container, Image
      4. Difference between Docker CE and Docker EE
      5. Installing Docker EngineRunning first container
   2. Docker Container Commands
      1. Different flags in commands (-d, -p, -P, -e, --name), create, start, stop, rm, ps, exec, inspect, cp, logs, stats
   3. Docker Images
      1. Docker images and it’s naming
      2. Introduction to DockerHub and ECR
      3. Docker image commands
      4. Docker pull, login, pushDocker commit, tag, image, rm, rmi, save, load, prune
   4. Docker Network
      1. Introduction to Docker Network
      2. Docker Network commands (create, delete, run )
   5. Docker File
      1. Introduction to Docker file
      2. FROM, LABEL, RUN, CMD, ENTRYPOINT, ENV, ARG, COPY, ADD, EXPOSE
      3. Docker build, push
      4. Docker Compose with practical
   6. Project on Docker

1. Introduction to Kubernetes
   1. What is Orchestration tool and why we need it
   2. Architecture of Kubernetes
   3. Lifecycle of Pods
   4. Cluster creation methods (minikube, kind, kubeadm, EKS, GKE, AKS etc)
2. Cluster Creation
   1. Create cluster on EKS
   2. Install kubectl and access EKS cluster
   3. Introduction to Pods and Service
   4. Main and Side car
   5. Run first pod by kubectl run pod
   6. Expose pod using kubectl expose
3. Kubernetes Network
   1. Intrap-pod and inter-pod communication
   2. Pod IP, Container Port, Node IP, Node Port, LoadBalancer
4. Introduction to YAML scrips
   1. Deploy manifest for Pods and Services
   2. Namespace, ReplicationController, ReplicaSet
   3. Deployment vs Stateful Set
   4. Daemon Set
   5. Config Map and Secret Map
   6. PV and PVC
5. HPA (Horizontal Pod AutoScaling)
   1. Types of AutoScaling
   2. Manifest for HPA
6. Ingress Controller
   1. Introduction to Ingress
   2. Implementing Ingress controller using ALB (Application Load Balancer)
   3. Manifest file for Ingress Controller

• Introduction to IAC
  • What is the need of IAC
  • Difference between Shell Script, Ansible and IAC tool
  • Introduction to Terraform
  • Terraform Language
  • List of Blocks
• Installation and Scripting
  • Installing terraform in Linux and Windows
  • First script to deploy EC2 instance using Terraform code
  • Terraform Lifecycle
  • Different types of files in Terraform
  • Terraform script to deploy Security Group and attatching to EC2 instance
  • Provider, Resource and Variable
  • Terraform script to deploy LoadBalancer
• Modules
  • What is Module and it’s usage
  • Writing module for VPC and ALB
  • Procedure to call user created modules
  • Calling modules from remote repository
•  .tfstate and .tfvar file
  •  Importance of .tfstate file
  •  Storing the .tfstate file on remote location (S3)
  • Usage of .tfvar file and it’s implementation 

• Loops and Conditional Operator

• • Conditional Operator
  • For each loop

1. Introduction to Jenkins
   1. Introduction to CI process
   2. Difference between Continious Delivery and Deployment
   3. What is Jenkins?
   4. Installation of Jenkins Server
2. Jobs in Jenkins
   1. Creating first job
   2. Installation of Plugins (Git Plugin)
   3. Create a freestyle job to pull source code from Git
   4. Install SSH build agent
   5. Create and attach SSH agents to Master Jenkins
3. Pipeline
   1. Introduction to Pipeline
   2. Installing Pipeline plugins
   3. Scripted vs Declarative pipeline
   4. Write a basic 4 stages pipeline
   5. Add pull stage

• Introduction to Maven
• Installing Maven
• Creating a project using Maven
• Maven directory hierarchy
• Maven phases
• Maven clean package command to build .war artifact
• Integrate Maven with Jenkins
• Add build stage to Maven

• Introduction to SonaQube
• QA result (bugs, vulnerabilities etc)
• Creating Sonarqube server
• Scanning the project
• Create quality gate to explain project failure

Docker Project :

A 2-tier project in the context of Docker Compose typically refers to a system architecture where the application is divided into two distinct layers or tiers: the application layer and the database layer.

2-Tier Architecture in Docker Compose
Tier 1: Application Layer – This is where the application code runs. It could be a web server, API server,
or a microservice. In the case of Docker, this would typically be a container that runs the application
code (e.g., Node.js, Python, or Java Spring Boot).

Tier 2: Database Layer – This is where the data is stored. It could be any database system such as MySQL,
PostgreSQL, or MongoDB. In Docker, this is typically another container running
the database system.

Kubernetes Project :

A Kubernetes 2-tier project with AWS and an Ingress controller involves setting up a Kubernetes cluster on
AWS using Amazon Elastic Kubernetes Service (EKS) or a self-managed EC2-based Kubernetes cluster,
while integrating it with a multi-tier application architecture. This type of project typically involves two layers: a backend tier (database or application logic layer) and a frontend tier (client-facing API or web application). The Ingress controller is used to manage external access to services within the Kubernetes cluster, routing traffic to the appropriate service.

Heres an overview of how you might design and implement such a project:

1. Kubernetes Cluster on AWS
AWS EKS: Use Amazon Elastic Kubernetes Service (EKS) to manage Kubernetes on AWS.
EKS simplifies the deployment and management of Kubernetes clusters, providing automatic
scaling and security.

EKS Cluster: Set up an EKS cluster using the AWS Management Console, AWS CLI, or Terraform. This
cluster can run in an Amazon VPC (Virtual Private Cloud) to ensure network isolation and
security.

Node Groups: Create node groups for the Kubernetes cluster (EC2 instances that run the Kubernetes worker
nodes). These nodes will run your application workloads.

IAM Roles and Policies: Configure IAM roles for the EKS cluster to access other AWS services like S3, RDS, or ECR.

2. 2-Tier Application Architecture

A typical 2-tier architecture includes:

Frontend Tier (Client-Facing Service):

This could be a React or Vue.js application, or a Node.js service, or any other frontend application that serves the client with data.
The frontend communicates with the backend via HTTP or HTTPS.
Backend Tier (Service Layer):

The backend could be an API (e.g., a REST API built in Python/Django, Java/Spring Boot, or Node.js).
The backend service interacts with a database (e.g., PostgreSQL or MySQL), often hosted in AWS RDS (Relational Database Service) or inside the Kubernetes cluster itself using StatefulSets and Persistent Volumes.
Database: The database could be hosted either externally (e.g., in AWS RDS) or within the Kubernetes cluster (using Persistent Volumes).

3. Ingress Controller
The Ingress controller is crucial for managing external traffic to your Kubernetes cluster. AWS provides
several ways to expose services, but using an Ingress Controller makes it easier to manage traffic routing.

Terraform Project :

Project 1 : End to End VPC using Terraform

A VPC (Virtual Private Cloud) project using Terraform involves creating and managing a network infrastructure in the cloud, typically within services like Amazon Web Services (AWS), Google Cloud Platform (GCP), or Microsoft Azure. Terraform is an Infrastructure as Code (IaC) tool that enables you to define and provision the cloud infrastructure you need using a declarative configuration language.

Description of a VPC Project on Terraform
In a typical VPC project, Terraform would be used to automate the creation of various networking components such as:

Virtual Private Cloud (VPC): The main network environment where your resources will reside.
Subnets: Logical subdivisions within the VPC, used to organize and isolate resources. There are typically public and private subnets.
Route Tables: Control the routing of traffic between subnets, VPCs, and the internet.
Internet Gateways: Allow communication between the VPC and the public internet.
NAT Gateways or NAT Instances: Allow resources in private subnets to access the internet.
Security Groups & Network ACLs: Control inbound and outbound traffic to/from instances.

Project 2 : Complete ALB (Application Load Balancer ) implementation

The goal of this project is to set up and configure an Application Load Balancer (ALB) in AWS using Terraform, a popular Infrastructure as Code (IaC) tool. ALB is a scalable load balancer that automatically distributes incoming application traffic across multiple targets, such as EC2 instances, containers, and IP addresses, within one or more Availability Zones.

Key Components of the ALB Project:
VPC (Virtual Private Cloud):

Define a custom VPC to host the ALB and the resources behind it, such as EC2 instances.
Set up subnets in multiple availability zones to ensure high availability and fault tolerance.

Security Groups:
Create security groups to control access to the ALB and EC2 instances.
Configure inbound and outbound rules for the ALB to allow HTTP or HTTPS traffic.

Target Group:
Set up a target group that defines the instances or resources the ALB will route traffic to.
Specify health checks to monitor the health of the targets.
Application Load Balancer (ALB):

Create an ALB in the specified VPC and subnets.
Configure listeners for HTTP and/or HTTPS.
Associate the ALB with the target group to ensure traffic is forwarded to healthy targets.
EC2 Instances:

Deploy EC2 instances or services (e.g., containers in ECS) behind the ALB.
Ensure that instances are registered in the target group for routing traffic.
IAM Roles (if needed):

Define roles and policies for managing permissions, such as allowing EC2 instances to register with the target group.

Jenkins, Maven and Sonarqube Project

Automating a Java or Node.js application using Jenkins, Maven, and SonarQube involves several key steps. Heres an overview of how to set this up, with detailed instructions on integrating each tool in the CI/CD pipeline.

Overview of Tools
Jenkins: A popular open-source automation server for building, deploying, and automating software projects.
Maven: A build automation tool primarily used for Java projects to manage dependencies, build lifecycle, and compile code.
SonarQube: A static code analysis tool that performs automatic reviews of code to detect bugs, vulnerabilities, and code smells.