Each day should include around 2-3 hours for topic review and exercises, with 1-2 hours

for practical tasks or hands-on practice.

Week 1: Automation Using Shell Scripting & RedHat Linux Administration

Session 1: Getting Started With Red Hat Linux (Days 1-4)

Day 1: Introduction to Red Hat Linux & File System Management

• Introduction to Red Hat Linux: Overview, uses in DevOps, setup options.

• File System Management: Learn about Linux file systems, directory structures,
and commands like ls, cd, pwd, mkdir, rm.

Day 2: User and Group Administration & Package Management with Yum

• User and Group Administration: Adding/removing users, assigning permissions.

• Package Management with Yum: Install, update, and manage packages using
Yum, enabling/disabling repositories.

Day 3: System Services, Networking Configuration, & Networking Concepts

• System Services: Understanding systemd and managing system services.

• Networking Configuration: Basics of IP configuration, managing network

interfaces.

• Networking Concepts: SNAT, DNAT, IP, and Netmask—essential for security and
permissions.

Day 4: Security, Permissions, System Performance Monitoring

• Security and Permissions: File permissions, chmod, chown commands.

• System Performance Monitoring: Tools like top, htop, and vmstat to monitor
performance.

• Hands-on: Practice commands for managing permissions and monitoring

system performance.

Day 5: Storage Management & Backup and Restore

• Storage Management: Disk management, using fdisk, df, and mount commands.

• Backup and Restore: Simple techniques for backup (using tar, rsync).

• Hands-on: Backup files and simulate a restore to understand the process.

Session 2: Shell Scripting (Days 6-7)

Day 6: Basics of Shell Scripting

• Introduction to Shell Scripting: Writing and executing basic scripts.

• Variables, conditions, loops in shell scripts (for, while, if statements).

• Hands-on: Write scripts for basic tasks, like printing a message, and creating
files.

Day 7: Real-Time Scenarios in Shell Scripting

• Real-Time Scenarios: Automating tasks such as user creation, file cleanup, and
monitoring.

• Writing scripts that interact with system services (e.g., service status checks).

• Hands-on Project: Write a script to automate a task (e.g., monitoring disk

usage).

Week 2: Cloud Services & AWS Fundamentals

Session 3: AWS Global Infrastructure and EC2 Basics (Days 1-3)

Day 1: Overview of AWS Global Infrastructure & Elastic Compute Cloud (EC2)

• AWS Global Infrastructure: Understanding regions, availability zones, edge

locations.

• Elastic Compute Cloud (EC2): Overview of its purpose, benefits, and basic
setup.

• Hands-on: Sign up for AWS Free Tier if needed, explore the AWS Management
Console.

Day 2: Setting Up Your First EC2 Instance & Instance Configuration

• Step-by-step setup for launching an EC2 instance (key pairs, AMIs, instance
types).

• EC2 Configuration: Explore security groups, instance roles, storage options.

• Hands-on: Launch an EC2 instance, connect using SSH, explore instance

settings.

Day 3: EC2 Options, Connecting to Cloud Instances

• In-depth look at EC2 options: EBS volumes, instance lifecycle, backups,

snapshots.
 • Connecting Instances: SSH, using key pairs, security considerations.

• Hands-on: Practice connecting to the instance and testing network

configurations.

Session 4: Advanced AWS Services and Security (Days 4-6)

Day 4: Security Groups, Amazon S3, Auto Scaling and Load Balancing

• Security Groups: Setting up and managing access rules.

• Amazon S3: Overview, creating an S3 bucket, managing files, permissions.

• Auto Scaling and Load Balancing: Basics of setting up for resilience and
scalability.

• Hands-on: Set up an S3 bucket and test uploading/downloading files.

Day 5: CloudFormation, CloudWatch, SNS, and SQS

• CloudFormation: Basics of Infrastructure as Code (IaC) using CloudFormation.

• CloudWatch: Monitoring, creating alarms, using CloudWatch for billing alerts.

• SNS and SQS: Overview, basic setup, sending notifications with SNS.

• Hands-on: Set up a CloudWatch alarm and SNS notification.

Day 6: RDS, IAM, Serverless, and Project-Based Learning with ECS & ECR

• Relational Database Service (RDS): Set up an RDS instance, connect to it.

• IAM: Basics of user permissions, role creation, and security best practices.

• Serverless Architecture: Introduction to Lambda functions.

• Hands-on Project: Launch a simple ECS cluster and create an ECR repository.

Day 7: Practical Review & Practice on AWS

• Practice Tasks: Revisit key AWS services used this week.

• Complete practice tasks to deepen your familiarity with setting up instances,

managing security groups, using S3, and monitoring.

Week 3: Source Code Management & Networking Concepts

Session 5: Mastering Git for Version Control (Days 1-4)

Day 1: Version Control Basics, CVCS vs. DVCS, Importance of Git

 • Difference between Centralized Version Control (CVCS) and Distributed Version
Control (DVCS).

• Basics of Git: What it is, its importance, initial setup.

• Hands-on: Install Git, configure Git with your name and email.

Day 2: Git Architecture, Repository, Commit, and Branching

• Three-Stage Architecture: Working directory, staging area, repository.

• Creating repositories, making commits, branching.

• Hands-on: Initialize a repository, create branches, practice committing and

merging.

Day 3: Advanced Git: Stash, Pop, Merge Conflicts

• Git Stash and Pop: Temporarily saving changes, applying stashed changes.

• Resolving Merge Conflicts: Best practices for handling conflicts.

• Hands-on: Create scenarios to test stash/pop and resolve merge conflicts.

Day 4: Revert, Reset, Rebase, Squash, Cherry Pick, Forking

• Revert and Reset: Differences, when to use each.

• Rebase, Squash, and Cherry Pick: Working with Git history.

• Hands-on: Practice using revert, reset, rebase, squash, and cherry-pick

commands.

Session 6: GitHub & Networking Fundamentals (Days 5-7)

Day 5: Git Integration with VSCode, GitHub Authentication

• Setting up Git integration in VSCode.

• Authentication with GitHub via SSH and HTTPS protocols.

• Hands-on: Set up GitHub with VSCode, authenticate using SSH.

Day 6: Networking Basics - IP, OSI Model, LAN/WAN

• Overview of IP address types, OSI model layers, LAN/WAN.

• Practical understanding of how systems communicate.

• Hands-on: Use tools like ping, traceroute, ipconfig/ifconfig.

Day 7: Subnetting, DNS, Routing, Switching

 • Introduction to subnetting and DNS basics.

• Switching and routing concepts.

• Hands-on: Practice using networking tools and test routing configurations.

Week 4: Package Management (Docker) Using Real-Time Scenarios &

Understanding SonarQube

Session 7: Docker Fundamentals (Days 1-4)

Day 1: Introduction to Virtualization, Docker vs Virtual Machines

• Basics of virtualization: Traditional VM vs. Docker containers.

• Docker Introduction: History, benefits, and use cases.

• Docker Architecture: Understanding Docker Daemon, Docker Client, Docker

Host.

• Hands-on: Install Docker, familiarize yourself with Docker CLI.

Day 2: Docker Images, Containers, and Dockerfile Basics

• Docker Image Lifecycle: Creation, pulling images from Docker Hub.

• Dockerfile: Writing a basic Dockerfile, understanding layers.

• Docker Container Lifecycle: Start, stop, restart, remove containers.

• Hands-on: Build and run a simple Docker container from a Dockerfile.

Day 3: Docker Networking, Volumes, and Security Basics

• Docker Networking: Bridge, host, and overlay networks, port mapping.

• Docker Volumes: Managing persistent data with volumes.

• Docker Security: Basics of container security.

• Hands-on: Set up container networking, create and manage volumes.

Day 4: Docker Compose & Real-World CD Flow

• Introduction to Docker Compose: Defining multi-container applications.

• Continuous Deployment (CD) Flow: Using Docker with CD tools (Jenkins, GitHub
Actions).

• Hands-on: Create a docker-compose.yml file for a basic multi-service setup.

Session 8: SonarQube, Quality Gates, and Profiles (Days 5-7)

Day 5: Introduction to SonarQube and Code Quality Analysis

• SonarQube Overview: Purpose and benefits for code quality.

• Setting Up SonarQube: Installation and setup on Docker.

• Hands-on: Install and configure SonarQube locally using Docker.

Day 6: Quality Gates, Code Analysis, and SonarQube Profiles

• Quality Gates: Set up quality gates for automated code quality checks.

• SonarQube Profiles: Configure profiles for specific project needs.

• Hands-on: Run code analysis on a sample project and review results in

SonarQube.

Day 7: Review & Practice Day

• Practice tasks: Review Docker commands, SonarQube configurations.

• Hands-on: Complete tasks to reinforce understanding of Docker containers,

SonarQube setup, and code analysis.

Week 5: Minor Project Week

Session 9: Shell Scripting and RedHat Linux Minor Project (Days 1-4)

Day 1: Automate User and Group Administration

• Project task: Write a shell script to manage users and groups.

• Automate adding, deleting, and listing users and groups.

• Hands-on: Test the script and ensure it covers all administration tasks.

Day 2: File System Management via Shell Scripting

• Automate file system management: Create directories, set permissions, manage

disk usage.

• Hands-on: Implement and test the script on directories and files.

Day 3: System Performance Monitoring Script

• Write a script to monitor CPU and memory usage.

• Generate reports on system performance periodically.

• Hands-on: Test script, ensure it logs data and outputs expected results.
Day 4: Project Refinement and Review

• Refine scripts from previous days, add comments and error handling.

• Hands-on: Document setup, usage instructions, and known issues.

Session 10: Integrate Git and Docker with the Project (Days 5-7)

Day 5: Initialize Git Repository, Commit Scripts

• Create a Git repository for the project.

• Commit shell scripts and push to GitHub.

• Hands-on: Practice using Git commands, update README for project.

Day 6: Create Dockerfile & Containerize the Application

• Create a Dockerfile to run the shell scripting application within a container.

• Build and test the Docker container, ensuring it executes the scripts.

• Hands-on: Test running the scripts inside the Docker environment.

Day 7: Final Project Review & Documentation

• Refine documentation, finalize project setup and usage instructions.

• Document any issues and resolutions found during implementation.

• Hands-on: Test the entire project workflow from setup to execution.

Week 6: Continuous Integration and Continuous Delivery

Session 11: CI/CD Workflow with Jenkins (Days 1-3)

Day 1: Introduction to CI/CD and Jenkins Workflow

• CI/CD Overview: Understand the concepts, benefits, and CI/CD lifecycle.

• Introduction to Jenkins: Installing Jenkins, understanding Jenkins Jobs.

• JenkinsFile Basics: Introduction to Jenkins Pipelines and the role of JenkinsFiles.

• Hands-on: Install Jenkins, create a basic job, explore Jenkins UI.

Day 2: Build Triggers and Jenkins Pipeline Configuration

• Build Triggers: SCM Polling, GITScm Polling, Build Periodically options.

• Configuring Jenkins Pipeline: Creating a simple pipeline using JenkinsFile.

 • Hands-on: Set up a Jenkins Pipeline job with SCM polling for automated builds.

Day 3: Groovy Scripting and GitHub Integration

• Groovy in Jenkins: Writing Groovy scripts to enhance Jenkins automation.

• GitHub Integration: Setting up webhooks for GitHub-Jenkins integration.

• Hands-on: Create a Jenkins pipeline with Groovy scripts and GitHub triggers.

Session 12: Advanced Jenkins & GitLab Integration (Days 4-7)

Day 4: Jenkins Master-Slave Setup and Pipeline Triggers

• Master-Slave Configuration in Jenkins: Benefits, setup, optimizing resources.

• Pipeline Triggers: Understanding how to trigger pipelines directly from

JenkinsFile.

• Hands-on: Set up a master-slave configuration in Jenkins and test pipeline

triggers.

Day 5: GitLab Branching Strategy and Merge Requests in CI/CD

• GitLab Branching Strategies: Best practices for branching and collaboration.

• Merge Requests: How merge requests fit into the CI/CD process.

• Hands-on: Implement branching strategy on a GitLab repo, set up merge

requests.

Day 6: Jenkins Dynamic Slave Configuration with Docker

• Using Docker as Jenkins Slave: Configure Docker containers as dynamic Jenkins

slaves.

• Configuring Jenkins Plugins: Docker, Git, Maven, and other essential plugins.

• Hands-on: Set up a Jenkins job to use a Docker container as a dynamic slave.

Day 7: Kubernetes and Jenkins Integration

• Integrate Kubernetes with Jenkins for scalable CI/CD workflows.

• Create a basic Kubernetes-based pipeline in Jenkins.

• Hands-on: Set up Jenkins to deploy to Kubernetes, test integration with a small

app.
Week 7: Deep Dive into Kubernetes

Session 13: Introduction to Kubernetes (Days 1-3)

Day 1: Kubernetes Basics and Architecture

• Introduction to Kubernetes: Purpose, benefits, and use cases.

• Kubernetes Architecture: Nodes, pods, and the control plane.

• Hands-on: Install kubectl and minikube on your local environment, explore

commands.

Day 2: Node Components, Manifest File Components, and Control Plane

• Node Components: Understanding kubelet, kube-proxy, and container runtime.

• Manifest Files: Structure of YAML configurations, creating basic resources.

• Control Plane: Role of Master Node, API server, etcd, scheduler, controller
manager.

• Hands-on: Deploy a simple pod using a YAML manifest file.

Day 3: Exploring Kubernetes Objects and Service Components

• Kubernetes Objects: Pods, Services, Deployments, ReplicaSets.

• Service Components: Understanding NodePort, ClusterIP, and LoadBalancer.

• Hands-on: Deploy a Kubernetes service, test connectivity between pods.

Session 14: Kubernetes Basics (Days 4-7)

Day 4: Labels, Selectors, and Namespaces

• Labels and Selectors: Tagging resources, filtering based on labels.

• Namespaces: Organizing and isolating resources within the cluster.

• Hands-on: Set up and manage labels, selectors, and namespaces in a test

environment.

Day 5: Managing Multi-Container Pods

• Multi-Container Pods: Use cases, Sidecar and Ambassador patterns.

• Pod Design Patterns: Explore different patterns for deploying services.

• Hands-on: Deploy a pod with multiple containers using the Sidecar pattern.

Day 6: Managing Kubernetes YAML Configurations

 • YAML Best Practices: Writing clean, maintainable configurations.

• Kubernetes Commands: Key commands for managing resources.

• Hands-on: Practice creating, updating, and deleting Kubernetes resources via

YAML files.

Day 7: Review and Practice Day

• Practice tasks: Review Kubernetes commands, concepts, and YAML

configurations.

• Hands-on: Complete a series of tasks to deepen understanding, such as

creating and deleting resources, using namespaces, and setting up services.

Week 8: Working with Applications in Kubernetes

Session 15: Deploying Applications on Kubernetes (Days 1-4)

Day 1: Setting Up Kubernetes on AWS

• Install Kubernetes on AWS: Set up an EC2 instance as a Kubernetes node.

• Configure kubectl to access the AWS-based Kubernetes cluster.

• Hands-on: Deploy a small application on the AWS-based Kubernetes cluster.

Day 2: Microservices Deployment in Kubernetes

• Deploying Microservices: Structure, advantages, deploying each service as a

separate pod.

• Hands-on: Deploy a sample microservices application on the Kubernetes

cluster.

Day 3: ConfigMaps and Secrets in Kubernetes

• ConfigMaps: Managing configuration outside of application code.

• Secrets: Securely storing sensitive data such as passwords and API keys.

• Hands-on: Create and mount ConfigMaps and Secrets in a Kubernetes

application.

Day 4: Persistent Volumes and Liveness Probes

• Persistent Volumes: Create and manage storage that persists beyond container
lifecycle.
 • Liveness Probes: Configuring checks to monitor container health.

• Hands-on: Add persistent storage to a pod, set up a liveness probe for health
monitoring.

Session 16: Advanced Kubernetes Topics (Days 5-7)

Day 5: Helm and Istio Service Mesh

• Helm: Package management for Kubernetes, creating and deploying Helm

charts.

• Istio: Understanding service mesh and its role in Kubernetes networking.

• Hands-on: Install a Helm chart for an application; set up Istio for traffic
management.

Day 6: Role-Based Access Control (RBAC) and Service Accounts

• RBAC: Managing permissions within Kubernetes using roles and bindings.

• Service Accounts: Assigning specific roles to services for security control.

• Hands-on: Create custom roles, set up a Service Account with limited

permissions.

Day 7: Higher-Level Kubernetes Concepts and Patterns

• Horizontal Pod Autoscaler (HPA): Scaling pods based on CPU and memory
usage.

• Ingress and Taints/Tolerations: Manage external access, node restrictions.

• Hands-on: Implement HPA, configure Ingress for application traffic, set up

taints.

Week 9: Ansible for Configuration Management

Session 17: Getting Started with Ansible (Days 1-3)

Day 1: Ansible Introduction and Architecture

• Understanding Configuration Management and Ansible's role in DevOps.

• Ansible Architecture: Modules, inventory, playbooks, and roles.

• Hands-on: Install Ansible, create a basic inventory file and run a sample
playbook.
Day 2: Ansible Roles, Collections, and Ad-hoc Commands

• Roles and Collections: Organizing playbooks, modules, and files.

• Ad-hoc Commands: Executing tasks quickly using Ansible CLI.

• Hands-on: Create and run a playbook using roles and collections.

Day 3: Setting Up Ansible Playbooks

• Playbook Basics: YAML structure, tasks, handlers, variables.

• Ansible Variables: Defining and using variables within playbooks.

• Hands-on: Write a basic playbook using variables, tasks, and handlers.

Session 18: Advanced Automation with Ansible Playbooks (Days 4-7)

Day 4: File Copying and Handlers in Playbooks

• Copying Files: Use playbooks to copy files to target servers.

• Handlers: Triggering tasks conditionally after certain actions.

• Hands-on: Create a playbook to copy files and use handlers effectively.

Day 5: Downloading Artifacts and Unzipping Files

• Automate Artifact Downloads: Use Ansible to download and manage files.

• Unzipping Files: Extract downloaded archives to target locations.

• Hands-on: Write a playbook to download, extract, and configure artifacts.

Day 6: Targeted Deployment and Ansible Tags

• Using Tags: Running specific parts of a playbook using tags.

• Targeted Deployment: Limiting tasks to specific hosts or groups.

• Hands-on: Create a playbook with tagged tasks, run tasks selectively.

Day 7: Automating Multi-Node Kubernetes Setup with Ansible

• Multi-Node Kubernetes: Configure multiple nodes using Ansible automation.

• Manage Variables and Facts: Gathering and using facts for dynamic deployment.

• Hands-on: Write a playbook to automate the setup of a multi-node Kubernetes

cluster.
Week 10: Infrastructure as Code using Terraform

Session 19: Introduction to Terraform and Infrastructure as Code (Days 1-3)

Day 1: Introduction to Infrastructure as Code (IaC) and Terraform Basics

• Understanding Infrastructure as Code: Benefits and principles of IaC.

• Terraform Basics: What is Terraform, how it works, providers, resources, and

attributes.

• Hands-on: Install Terraform, configure your first Terraform provider, and create
simple resources.

Day 2: Terraform State Management

• State Files: What they are, why they matter, and how Terraform manages state.

• Backend Configuration: Storing state remotely, using cloud providers like S3.

• Hands-on: Initialize a Terraform project with remote state using AWS S3 as the
backend.

Day 3: Terraform Variables and Resource Configuration

• Terraform Variables: Define input variables, use in resource creation.

• Resources and Dependencies: How to manage dependencies and relationships

between resources.

• Hands-on: Create variables for a resource setup, use them in an example

configuration (e.g., EC2).

Session 20: Advanced Terraform Techniques and Project Development (Days 4-7)

Day 4: Advanced Terraform Concepts (for-each, modules, etc.)

• For-each and Looping: Looping over resources dynamically with for_each.

• Modules: Organizing and reusing code with modules.

• Hands-on: Create a module for provisioning an AWS EC2 instance and use
for_each to deploy multiple instances.

Day 5: Security with Terraform on AWS

• Managing AWS Security: IAM roles, policies, and securing resources.

• Using Terraform to set up AWS security groups and IAM roles.

 • Hands-on: Write a Terraform configuration for securing AWS EC2 with security
groups and IAM roles.

Day 6: CIDR Setup and Subnet Configuration with Terraform

• Understanding CIDR and IP Addressing in AWS.

• Creating and managing subnets and routing tables with Terraform.

• Hands-on: Set up a VPC with multiple subnets, configure route tables, and
associate them.

Day 7: Terraform State Locking and Project Wrap-Up

• State Locking: Preventing concurrent state file changes during deployment.

• Wrapping Up: Review of all concepts, finalize a sample infrastructure project.

• Hands-on: Complete a project with VPC, EC2, and IAM using Terraform,
implement state locking, and finalize deployment.

Week 11: Monitoring and Logging

Session 21: Setting Up Grafana for Monitoring (Days 1-3)

Day 1: Introduction to Grafana and Installation

• Introduction to Grafana: Features and benefits for monitoring.

• Installing Grafana: Setup on local or cloud servers.

• Hands-on: Install Grafana on a server or VM, start Grafana server.

Day 2: Database Installation and Grafana Setup

• Database Integration: Install MySQL or any relational database for data sources.

• Configure Grafana with MySQL as a data source.

• Hands-on: Set up MySQL, connect Grafana to MySQL, create a dashboard

displaying database metrics.

Day 3: Creating Dashboards and Visualizations

• Grafana Dashboards: Creating and configuring dashboards.

• Visualizations: Understanding different types of charts and visualizations.

• Hands-on: Create a custom Grafana dashboard to visualize server metrics

(CPU, memory usage).
Session 22: Integrating Prometheus for Comprehensive Monitoring (Days 4-7)

Day 4: Introduction to Prometheus and Installation

• Overview of Prometheus: Metrics collection, scraping, and monitoring.

• Installing Prometheus: Set up Prometheus server for monitoring.

• Hands-on: Install Prometheus on a server, configure it to scrape metrics from an

application or system.

Day 5: Setting Up Prometheus on Kubernetes Cluster

• Prometheus on Kubernetes: Install Prometheus on a Kubernetes cluster using

Helm.

• Configure Prometheus to scrape Kubernetes metrics.

• Hands-on: Set up Prometheus on Kubernetes, configure it to monitor cluster

performance.

Day 6: Integrating Prometheus with Grafana

• Grafana and Prometheus Integration: Use Prometheus as a data source in

Grafana.

• Building Grafana Dashboards from Prometheus Metrics.

• Hands-on: Create dashboards in Grafana to visualize Prometheus metrics, such

as pod CPU usage.

Day 7: Setting Alerts and Using Grafana Plugins

• Alerts in Grafana: Setting up alert rules based on metric thresholds.

• Grafana Plugins: Extend Grafana's capabilities with plugins.

• Hands-on: Configure Grafana to send alerts when certain thresholds are

exceeded, explore Grafana plugins.

Week 12: Major Projects

Session 23: Mentor Guided Project: Amazon ECS Deployment (Days 1-3)

Day 1: Project Overview and ECS Introduction

• Overview: Understanding the project scope and requirements for deploying

Amazon ECS.
 • ECS Basics: Learn about Amazon Elastic Container Service (ECS) and its role in
container orchestration.

• Hands-on: Set up a basic ECS cluster on AWS, configure the required IAM roles
for ECS tasks and services.

Day 2: ECS Deployment and CloudWatch Integration

• Deploy Containers to ECS: Launch a Docker container on ECS.

• CloudWatch Setup: Set up CloudWatch for monitoring ECS tasks and services.

• Hands-on: Deploy a microservices application on ECS, configure CloudWatch

for task-level monitoring.

Day 3: Load Balancer and Scaling Setup

• Load Balancer: Learn how to set up an Application Load Balancer (ALB) with
ECS to distribute traffic across containers.

• Auto Scaling: Configure auto-scaling for ECS tasks based on CPU and memory
utilization.

• Hands-on: Set up an ALB, configure auto-scaling policies, and verify the auto-
scaling functionality by generating load.

Session 24: Mentor Guided Project: Amazon EKS and Nginx Ingress Controller (Days
4-6)

Day 4: Introduction to Amazon EKS and Nginx Ingress Controller

• Amazon EKS Overview: Understanding the features of Amazon Elastic

Kubernetes Service (EKS) and its integration with AWS services.

• Nginx Ingress Controller: Learn about Kubernetes ingress controllers and their
role in managing external traffic.

• Hands-on: Set up an EKS cluster and install Nginx Ingress Controller.

Day 5: EKS Deployment and Ingress Controller Configuration

• Deploying on EKS: Deploy a sample microservices application to EKS.

• Ingress Configuration: Set up Nginx Ingress Controller to route external traffic to

internal services.

• Hands-on: Configure Nginx Ingress for routing traffic to the deployed services,
verify external access.
Day 6: SSL/TLS Management with Cert-Manager

• Cert-Manager Overview: Learn how to use Cert-Manager to automate SSL

certificate provisioning in Kubernetes.

• Hands-on: Install and configure Cert-Manager to generate SSL certificates for

the deployed services in EKS.

Session 25: Self-Guided Projects (Days 7-8)

Day 7: GitHub Action - Self-hosted Runner and Docker Integration

• GitHub Actions: Set up and configure GitHub Actions for CI/CD pipelines.

• Self-hosted Runner Setup: Learn how to add a node as a self-hosted runner

and run Docker images.

• Hands-on: Create a GitHub Action workflow to build a Docker image, expose it

on a specific port using Nginx.

Day 8: System Monitoring Script with Shell Scripting

• System Monitoring: Learn how to monitor system resources (CPU, memory, disk
usage) using shell scripting.

• Automation: Automate the process of system resource monitoring and send

periodic alerts.

• Hands-on: Write a shell script to monitor system resources, log data, and create
alerts for threshold breaches.

Final Day: Project Wrap-Up and Review

• Complete Projects: Ensure all tasks for the ECS, EKS, and self-guided projects
are completed and tested.

• Review & Documentation: Review the code and infrastructure, and document
all steps taken.

• Demo and Feedback: Present the completed projects to the mentor or team for
feedback and improvements.