Intermediate Level

DevOps

★ 4.8 (300 learners) 60 hrs total 41 modules

AWS EC2 S3 IAM RDS EKS +8 more

Only 7 seats left · Next batch starts 15 Aug 2026

Download Curriculum

60 hrs: of content
41 modules: in curriculum
16 projects: hands-on builds
Intermediate: difficulty

Curriculum covers

Frameworks you'll master

14 tools & frameworks

AWS EC2 S3 IAM RDS EKS Docker Kubernetes Helm Jenkins GitLab GitHub Actions Ansible Grafana

Course Curriculum

41 modules · 60 hours · 24 live sessions

Containerisation & Kubernetes 7 sessions

Docker & Kubernetes CKAD (Certified Kubernetes Application Developer) Certification
“”””” Discover how we can containerize our WebApps using container technology like Docker & orchestrated containers u...
Introduction to Docker Container Fundamentals
Docker Overview
Docker Installation
Docker HUB
Docker Images
Docker Containers & Shell
Docker Architecture
Docker Push & Pull Containers
Docker Containers & Hosts
Docker Configuration
Docker Files (Dockerfile)
Docker Building Files
Docker Public Repositories
Docker Private Registries
Building Webserver using Dockerfile
Docker Commands
Docker Container Linking
Docker Storage
Docker Networking
Docker Logging
Docker Compose
Docker Kubernetes
K8s Application Design and Build 20%
Build, Define and Modify Container Images
Choose and use the right workload resource (Deployment, Daemon Set, Cronjob, etc.)
Understand multicontainer Pod design patterns (e.g. sidecar, init and others)
Utilize persistent and ephemeral volumes
Kubernetes Deployments (Stateful Sets, Daemon Sets, Jobs & Cron Jobs)
K8s Storage Volumes Persistence Volume (PV) & Persistence Volume Claim (PVC)
K8S Jobs & Scheduling Multiple Schedulers & Scheduler Profile
K8S Storage Classes
Imperative & Declarative Approach
K8s Labels & Selectors
K8s Application Deployment 20%
Use Kubernetes primitives to implement common deployment strategies (e.g. blue/green or canary)
Understand Deployments and how to perform rolling updates
Use the Helm package manager to deploy existing packages
Kustomize
Deployment Strategy (Canary, BlueGreen, Recreate Strategy, Rolling Update (Default))
HELM Charts Package Manager
Application Observability and Maintenance 15%
Understand API deprecations
Implement probes and health checks
Use builtin CLI tools to monitor Kubernetes applications
Utilize container logs
Debugging in Kubernetes
Logging & Monitoring
Application Lifecycle Management Rolling Updates and Rollbacks
Cluster Maintenance OS Upgrades
Cluster Upgrade Process
Backup & Restore
Application Environment, Configuration and Security 25%
Discover and use resources that extend Kubernetes (CRD, Operators)
Understand authentication, authorization and admission control
Understand requests, limits, quotas
Understand ConfigMaps
Define resource requirements
Create & consume Secrets
Understand Service Accounts
Understand Application Security (Security Contexts, Capabilities, etc.)
Operator Framework
Custom Controllers
Admission Controllers
Authentication & Authorization RBAC (Rolebased Access Controls)
Security Primitives
K8s TLS Certificates
Security KUBECONFIG
API Groups
Image Security
Security Context
Services and Networking 20%
Demonstrate basic understanding of Network Policies
Provide and troubleshoot access to applications via services
Use Ingress rules to expose applications
Network Policies
Networking (INGRESS)
Readiness Probes
Liveness Probes
Network Namespaces
Weave Works (CNI)
Kubernetes Network Policy
Docker & Kubernetes CKAD (Certified Kubernetes Application Developer) Certification
“Discover how we can containerize our WebApps using container technology like Docker & orchestrated containers using...
Introduction to Docker Container Fundamentals
Docker Overview
Docker Installation
Docker HUB
Docker Images
Docker Containers & Shell
Docker Architecture
Docker Push & Pull Containers
Docker Containers & Hosts
Docker Configuration
Docker Files (Dockerfile)
Docker Building Files
Docker Public Repositories
Docker Private Registries
Building Webserver using Dockerfile
Docker Commands
Docker Container Linking
Docker Storage
Docker Networking
Docker Logging
Docker Compose
Docker Kubernetes
K8s Cluster Architecture, Installation & Configuration 25%
Kubernetes Installation
Kubernetes Architecture
Kubernetes Master Server Components (etcd, kubeapiserver, Kubecontrollermanager, Kubescheduler, Cloudcontrollermanager)
Kubernetes Node Server Components (container runtime, kubelet, Kubeproxy, Kubescheduler, cloudcontrollermanager)
Kubernetes Objects & Workloads (Kubernetes Pods, Kubernetes Replication Controller & Replica Sets)
Manage rolebased access control (RBAC)
Prepare underlying infrastructure for installing a Kubernetes cluster
Create and manage Kubernetes clusters using kubeadm
Manage the lifecycle of Kubernetes Clusters
Implement and configure a highlyavailable control plane
Use Helm and Kustomize to install cluster components
Understand extension interfaces (CNI, CSI, CRI, etc.)
Understand CRDs, install and configure operators
Services & Networking 20%
Understand connectivity between Pods
Define and enforce Network Policies
Use Cluster IP, Node Port, Load Balancer service types and endpoints
Use the Gateway API to manage Ingress traffic
Know how to use Ingress controllers and Ingress resources
Understand and use CoreDNS
Kubernetes Network Policy
Network Namespaces
Liveness Probes
Networking (INGRESS)
Network Policies
ETCD in HA
Weave Works (CNI)
API Groups
Workloads & Scheduling 15%
Understand application deployments and how to perform rolling update and rollbacks
Use ConfigMaps and Secrets to configure applications
Configure workload autoscaling
Understand the primitives used to create robust, selfhealing, application deployments
Configure Pod admission and scheduling (limits, node affinity, etc.)
Kubernetes Deployments (Stateful Sets, Daemon SetsJobs & Cron Jobs)
Labels, Selectors & Annotations
Kubernetes Secrets
Kubernetes App Deployment
Kubernetes Autoscaling
K8s Deployment Strategy (Canary, BlueGreen, Recreate Strategy, Rolling Update (Default))
K8S Jobs & Scheduling (Multiple Schedulers, Scheduler Profile)
Operator Framework
Custom Controllers
Node Affinity
Node Selectors
Storage 10%
Implement storage classes and dynamic volume provisioning
Configure volume types, access modes and reclaim policies
Manage persistent volumes and persistent volume claims
K8s Storage Volumes (Persistence Volume (PV) & Persistence Volume Claim (PVC) & Persistence Volume Claim (PVC))
Backup & Restore
Troubleshooting 30%
Troubleshoot clusters and nodes
Troubleshoot cluster components
Monitor cluster and application resource usage
Manage and evaluate container output streams
Troubleshoot services and networking
Kubernetes Namespaces
Kubernetes Dashboard Setup
Kubernetes Monitoring
DNS
Content Switching
K8s Labels & Selectors
Taints & Tolerations
Resource Limits
Static Pods
Logging & Monitoring
Cluster Maintenance OS Upgrades
Cluster Upgrade Process
Backup & Restore
Security Primitives
K8s TLS Certificates
Security KUBECONFIG
API Groups
Image Security
Security Context
Network Policies
Stateful Sets
Networking (INGRESS)
Readiness Probes
Liveness Probes
Controllers
Service MESH (Istio: The Service MESH Tool for K8s Monitoring)
“Discover how we can containerize our WebApps using container technology like Docker & orchestrated containers using...

Introducing Istio 1 sessions

What is Istio?
Installing a Local Kubernetes Environment
Installing Minikube
Getting Istio Running
Enabling Sidecar Injection
Visualizing the System with Kiali
Finding Performance Problems

Introducing Envoy 1 sessions

Introducing Envoy The Data Plane
Going Depper into Envoy

Telemetry 1 sessions

Starting the Demo System
Kiali Deeper Dive
Kiali Dynamic Traffic Routing
Distributed Tracing Overview
Using Jaeger UI
Why we need to "Propagate Headers"
What happens if we don't propagate headers?
Metrics with Grafana

Traffic Management 1 sessions

Introducing Canaries
Canaries with Replicas
Version Grouping
Elegant Canaries and Staged Releases
What is an Istio Virtual Service?
Virtual Service Configuration in YAML
What is Istio Destination Rule?

LOAD Balancing 1 sessions

Session Affinity ("Stickness")
What is Consistent Hashing useful for?

Gateways 1 sessions

Reminder for Docker Desktop users port forwarding
Why do I need an Ingress Gateway?
Edge Proxies and Gateways
Prefix based routing
Subdomain Routing

Dark Releases 1 sessions

Using a browser extension to modify headers
If we have problems
Header Based Routing
Dark Releases for all Microservices

Circuit Breaking 1 sessions

Cascading Failures
Configuring Outlier Detection
Testing Circuit Breakers

Mutual LTS 5 sessions

Why is encryption needed inside a cluster?
How Istio can upgrade traffic to TLS
Enabling mTLS It's Automatic
STRICT Vs PERMISSIVE mTLS
STRICT mTLS Works in Both Directories
HELM Package Manager for Kubernetes
“Discover how we can containerize our WebApps using container technology like Docker & orchestrated containers using Kubernetes engine that combine the advantages of DevOps & infrastructure automation capabilities. Understand K8s role within your cloud data ecosystem and leverage its scaling and IAAC capabilities to automate cloud infrastructure. Explore how Docker & K8s products and features empower all DevOps practitioners to develop cloud autodriven solutions tailored to infraautomation requirements.
Introduction to HELM
Helm Introduction
Package manager need and purpose
Helm component introduction
Helm V3 installation Difference between V2 and V3
Repository quick introduction
Chart install quick introduction
Create new Helm chart
Minikube Installation for Helm
Helm with Minikube
HELM Charts Templates
Chart template getting started
Builtin objects
Read values for templates
Set values to templates
Template functions
Template pipeline and default values
Control flow ifelse
Defining scope using with
Range
Variables
Include content from same file
Include scope
Include template using keyword include
Sub Charts
Sub Chart global
HELM – Repository Management
Repository Workflow
Repository hosting options
Chart museum installation
Add Chart Museum repository
Add Chart to Chart Museum repository
Maintain Chart version
Maintain multiple Charts
Chart push plugin
Maintain github as repository
Add Charts to github repository
HELM – Chart Management
Upgrade Helm Installed Chart
Rollback Helm Installed Chart
Helm Dependency
Chart Hook Pre and Post Install Hook
Kubernetes Job as Hooks
Hook Execution using Weight
Testing and Verification
Helm Lint
Helm Hook test
Helm Get and Status
Provenance and Integrity
Kubernetes Revision
Orchestration Introduction
Kubernetes Component Introduction
YAML Introduction
Kubernetes Cluster Components Analogy
Kubernetes Cluster Types of Installation
Minikube Windows Installation
Minikube CentOS Installation
Pod Getting Started
Pod Ports and file Copy concepts
Replicaset Introduction
Deployment Introduction
Service Introduction
Label Selector Introduction
Volume Introduction
ConfigMap Introduction
Secrets Introduction
Namespace Introduction
Exploring HELM's Nginx Chart
Adding a Helm chart repository
Installing the Nginx HELM chart
Installing a HELM chart
Customizing HELM chart installation
Upgrading and deleting HELM charts
HELM: Testing the waters
Test Helm releases using "dryrun"
Inspect a HELM release using "helm get"
HELM release history and rollback
HELM install/upgrade tips and tricks
HELM Templates Development
HELM templates playground
The toYaml, indent, and nindent template functions
Using the .Files template method with ConfigMaps and Secrets
How to get the API key used for the "Weather App"
'if", "else", and "else if" conditional statements
Looping using the range and index functions
The _helpers file and the named templates
HELM: The Full Thrust
Helm chart dependencies
Helm Library charts
Creating your own Helm repository
Host your Helm repo on a web server (using AWS S3)
Host your Helm repo using Chartmusem
Extending HELM
Helm plugins with S3 as an example
Build your own Helm plugin
Use your own chart protocol with Helm downloader plugin
Helm starter charts
HELM in Production
Helm Blue/Green Deployments
(Re)exploring our sample application
Provisioning the app to EKS cluster through Helm
HELM CI/CD techniques on Gitlab and EKS
What is CI/CD
Setting up a CI/CD user for EKS and nonEKS Kubernetes clusters
Deploying EKS using eksctl
Setting up a GitLab repository
Preparing the GitLab CI/CD pipeline
GitLab CI stage 1: Build and Push
GitLab CI stage 2: Delivery to staging environments
GitLab CI stage 3: Deployment to production environment
OpenShift K8S Redhat Enterprise Kubernetes Platform
“Discover how we can containerize our WebApps using container technology like Docker & orchestrated containers using...
Introduction to OpenShift
PreRequisite – Docker ad Kubernetes
Docker Overview
Kubernetes Overview
Getting Started with OpenShift
Architecture Overview
OpenShift – Setup
OpenShift Setup with Minishift
Management – Web, CLI and REST API
Demo – OpenShift Management
OpenShift Concepts Projects and Users
Architecture Overview
Concepts Builds and Deployments
Builds and Deployments
Builds
Build Triggers
Deployments
Networks, Services, Routes and Scaling
Networking Overview
Services and Routes
Scaling
Storage, Templates and Catalog
Storage
Example Voting Application Introduction
Templates and Catalog
Argo CD Techniques in GitOps & DevOps
“Discover how we can containerize our WebApps using container technology like Docker & orchestrated containers using...

Argo CD Introduction 1 sessions

Argo CD & GitOps Introduction
GitOps Workflow
Core Features of Argo CD
Argo CD Key Differentiators
Argo CD Architecture & Components

Setting up the Environment 1 sessions

Argo CD Prerequisites & Requirements
AWS EC2 Setup & Configuration
Installing Minikube, Docker & Kubectl
Installing Argo CD on Minikube
Configuring Argo CD CLI
Understand Port Forward – Local Host
Understand Port Forward – All Host
Understand SSH Tunnel – Connect Argo CD
Argo CD Node port configuration
Revert Node Configuration
Understand Various Ports & IP Summary
Accessing the Argo CD Web UI
Accessing the Argo CD CLI
Setting Up a Sample Application – Web UI
Setting Up a Sample Application – CLI

Manage Applications 1 sessions

Understanding Applications in Argo CD
Argo CD Application Specifications
Creating Applications in Argo CD
Application SelfHeal Option & Demo
Application Prune Option & Demo
Application Sync Options – DryrunApplyForce
Application Prune Propagation Policy
Application Refresh & Hard Refresh
Application Sync Options
Application Sync Skip Schema Validation
Application Sync Respect Ignore Differences
Application Sync Replace
Application Sync Retry
Application Dashboard Overview
Application compares differences
Rollback & History Management
Managing Application Lifecycle
Configuring Application Parameters
Application Readiness & Liveness

Repositories 1 sessions

Introduction to Repositories in Argo CD
Public & Private Repository
Repository Credentials using SSH Keys
Repository Credential Template
Best Practices – Repository Organization

Argo CD Projects 1 sessions

Overview of Projects in Argo CD
Creating & Configuring Argo CD Projects
Project Source Configuration
Project Destination Configuration
Cluster and Namespace Scope Differences
Cluster Scoped List Configuration
Sync Window Introduction
Setup Sync Window in Project
Project Roles
Managing Project Quotas & Limits
Project Specification
Declarative Setup for Projects using YAML
Project Finalizers

HELM Applications 1 sessions

HELM Application
HELM Install & Setup
HELM Quick Start Demo
Best Practices for Managing HELM Chart Values
HELM Chart Demo – Grafana
Rollback and Rollout using HELM
Argo CD HELM Multi Environment Concept

Argo CD Security & Administration 1 sessions

GPG Keys Introduction & Keys Management
Adding Gnu Public Key to Argo CD
Git Verified Commit with VSCode
Sync based on Verified Commit
Application Reconciliation Timeout Configuration
Adding new user or account
Update admin password

Production Grade Setup 1 sessions

Vultr Cloud Setup
Argo CD in Vultr Cloud
Add Vultr Cloud to Argo CD
Kustomize Mastery Manage Kubernetes Configuration with Ease
“Kustomize is a configuration management tool for K8s that works along with K8s manifests to generate a base template...
QuickStart
What is Kustomize? – The Theory
Kustomize HandsOn
Why Kustomize
2) Course Introduction
Installing Kustomize
Local Cluster Setup
The Kustomization File
Kustomization File – An Overview
Transformers
Generators
ConfigMap Generators
Secret Generator
Resources
Kubernetes Resource Abbreviations
Namespaces
Labels & Annotations
4) Working with Patches
Patches Overview
Patches – Strategic Merge
Patches – JSON6902
5) Working with Patches
Patches Overview
Working with Custom Resource Definitions – CRD’s
CRD’s in Kustomize (Using Transformer Configurations)
Managing Multiple Environments with Overlays
MultiEnv workflows overview
Day 1 : Simple Workflows for Monolithic & Microservices
Day 3: Large Microservices Applications
Reusing Kustomize Configurations
Components
Replacements
Continuous Integration & Deployment Pipelines (CI/CD)
GitHub Actions Workflow with Kustomize & GKE
AWS EKS
“Discover how we can containerize our WebApps using container technology like Docker & orchestrated containers using...

EKS – Create Cluster using eksctl 1 sessions

Install AWS CLI
Install kubectl CLI
Install eksctl CLI
EKS Cluster Introduction
Create EKS Cluster
Create EKS Managed Node Group & IAM OIDC Provider
Verify EKS Cluster Nodes
EKS Cluster Pricing Note
EKS Delete Cluster

– Install AWS CLI 1 sessions

Install kubectl CLI
Install eksctl CLI
EKS Cluster Introduction
Create EKS Cluster
Create EKS Managed Node Group & IAM OIDC Provider
Verify EKS Cluster Nodes
EKS Cluster Pricing Note
EKS Delete Cluster

Docker Fundamentals 1 sessions

Docker Fundamentals –Introduction
Introduction to Docker, Why Docker, What Problems Docker Solve
Docker Architecture or Docker Terminology
Docker Installation
Docker – Pull Docker Image from Docker HUB and run it locally
Docker – Build Docker Image locally, Test and Push it to Docker HUB
Docker – Essential Commands Overview

– Kubernetes Fundamentals – Imperative Commands using kubectl 1 sessions

Kubernetes Architecture
Kubernetes vs AWS EKS Architecture
Kubernetes Fundamentals Introduction
Kubernetes Pods Demo
Kubernetes Node Port Service Introduction
Kubernetes Node Port Service and PODS demo
Interact with POD – Connect to container in a POD
Delete POD
Kubernetes Replicate Set – Introduction
Kubernetes Replicate Set – Review manifests and create Replica Set
Kubernetes Replicate Set – Expose and Test via Browser
Kubernetes Deployment Introduction
Kubernetes Deployment – Update Deployment using Set Image Option
Kubernetes Deployment – Edit Deployment using kubectl edit
Kubernetes Deployment – Rollback Application to Previous version Undo
Kubernetes Service

Kubernetes Fundamentals – Declarative Approach using YAML 1 sessions

Introduction to Kubernetes Declarative Approach
Create PODS with YAML
Create Node Port Service with YAML and access application via Browser
Create Replica Sets using YAML
Create Node Port Service with YAML and access application via Browser
Create Deployment with YAML and test
Backend Application – Create Deployment and Cluster IP Service
Frontend Application – Create Deployment and Node Port Service
Deploy and Test – Frontend and Backend Applications

Kubernetes Fundamentals – Declarative Approach using YAML 1 sessions

Introduction to Kubernetes Declarative Approach
Create PODS with YAML
Create Node Port Service with YAML and access application via Browser
Create Replica Sets using YAML
Create Node Port Service with YAML and access application via Browser
Create Deployment with YAML and test
Backend Application – Create Deployment and Cluster IP Service
Frontend Application – Create Deployment and Node Port Service
Deploy and Test – Frontend and Backend Applications

EKS Hosted Applications Storage with AWS EBS – Elastic Block Store 1 sessions

Step01 – EKS Storage Introduction
Step02 – Install EBS CSI Driver
Step03 – Create Kubernetes Manifests for Storage Class, PVC and ConfigMaps
Step04 Create Kubernetes Manifests for MySQL Deployment & Cluster IP Service
Step05 – Test by connecting to MySQL Database
Step06 – Storage References
Step07 – Create Kubernetes Manifests for User Management Microservices Deployment
Step08 – Test User Management Microservice with MySQL Database in Kubernetes
Step09 Test User Management Microservice UMS using Postman

Kubernetes Secrets, Init Containers, Liveness Probes, Request Limits & Namespaces 1 sessions

Kubernetes Important Concepts for Application Deployments Introduction
Kubernetes Secrets
Kubernetes Init Containers
Kubernetes Liveness & Readiness Probes Introduction
Create Kubernetes Liveness & Readiness Probes
Kubernetes Resources – Requests & Limits
Kubernetes Namespaces Introduction
Kubernetes Namespaces – Create Imperatively using kubectl
Kubernetes Namespaces – Create Limit Range k8s manifest
Kubernetes Namespaces – Limit Range – Update App k8s manifest, Deploy
Kubernetes – Resource Quota

EKS Hosted Applications Storage with AWS RDS – Relational Database Service 1 sessions

Step01 – EKS Storage – RDS DB Introduction
Step02 – Create RDS DB
Step03 – Create Kubernetes External Name Service & Other Manifests, Deploy & Test

EKS with AWS Load Balancers – Classic & Network Load Balancers 1 sessions

Step01 – AWS Load Balancers Introduction
Step02 – Create EKS Private Node Group
Step03 – EKS with Classic Load Balancers Demo
Step04 – EKS with Network Load Balancers Demo

ALB Ingres – Install AWS Load Balancer Controller Install on AWS EKS Cluster 1 sessions

Ingress Introduction
Introduction to AWS Load Balancer Controller
Create IAM Policy, IAM Role, k8s service account and annotate it
Install AWS Load Balancer Controller using HELM
Verify AWS LBC Deployment and Webhook Service
LBC Service Account and TLS Cert Internals
Uninstall Load Balancer Controller Command SHOULD NOT BE EXECUTED
Introduction to Kubernetes Ingress Class Resource
Deploy Ingress and Verify

ALB Ingres – Basics using AWS Application Load Balancer 1 sessions

Introduction to Ingress Basics
Review Kubernetes Deployment and Node Port Service manifest
Create Ingress k8s manifest with default backend
Deploy Ingress default backend and verify and cleanup
Create, Deploy Ingress Rules and verify and cleanup

ALB Ingres – Context Path Routing using AWS Application Load Balancer 1 sessions

Introduction to Ingress Context Path Based Routing
Review Kubernetes Deployment and Node Port Service manifest for App1
Review Ingress CPR, Deploy and Verify
Discuss Ingress Importance of Rules ordering

ALB Ingres – SSL Redirect using AWS Application Load Balancer – 2 Demos 1 sessions

Introduction to ALB Ingress SSL
Register Domain AWS Route 53
Create SSL Certificate in AWS Certificate Manager
Update SSL Ingress Annotation, Deploy and Test
Update SSL Ingress Redirection Annotation, Deploy and Test

ALB Ingres – External DNS Install and Implement Ingress & Service – 2 Demos 1 sessions

Introduction to ALB Ingress External DNS Install
Create IAM Policy, k8s Service Account, IAM Role and Verify
Review and Update External DNS k8s manifest
Deploy External DNS and Verify Logs
Ingress Service Demo with External DNS
Kubernetes Service Demo with External DNS

ALB Ingres – Name based Virtual HOST / Host Header Routing 1 sessions

Introduction to Ingress Name Based Virtual Host Routing
Implement Ingress NVR Demo

ALB Ingres SSL Discovery Host and TLS – 2 Demos 1 sessions

Introduction to Ingress SSL Discovery
Implement SSL Discovery Host Demo
Implement SSL Discovery TLS Demo

ALB Ingres – Ingress Groups 1 sessions

Introduction to Ingress Groups
Implement Ingress Groups Demo with 3 Apps

ALB Ingres – Target Type – IP Mode 1 sessions

Introduction to Ingress Target Type IP Mode
Implement Ingress Target Type IP Mode

ALB Ingres – Internal Application Load Balancer 1 sessions

Introduction to Ingress Internal ALB
Create internal ALB using Ingress and Test and cleanup

EKS Fargate Serverless 1 sessions

EKS and Fargate Introduction
Fargate Basics Introduction
Create EKS Profile using eksctl & Review k8s manifests to be deployed
EKS Fargate – Deploy to Fargate & Test & Cleanup
EKS Fargate – Mixed Mode Introduction
EKS Fargate – Create Profiles using YAML
EKS Fargate – Deploy 3 Apps & Test, 2 on Fargate and 1 on EC2Node Group

AWS Network Load Balancer with AWS Load Balancer Controller 1 sessions

Introduction to AWS NLB 6 Demos
Introduction to Network Load Balancer with k8s Service
Review Kubernetes Manifests – Deployment & Service with NLB Annotation
Deploy NLB Basics k8s manifests, Verify and cleanup
Introduction to NLB TLS with k8s service
NLB TLS Demo Deploy, Verify and cleanup
NLB External DNS Demo using k8s service
NLB Elastic Ips Demo using K8s service
NLB Fargate Demo with Target Type IP

EKS & ECR – Elastic Container Registry 1 sessions

EKS & ECR Introduction
ECR Terminology & Prerequisites
Create ECR Repository on AWS, Build Docker Image Locally and Push to ECR
Review Kubernetes Manifests & Node Group Role
Deploy Kubernetes Manifests & Test & Cleanup
Jenkins & Ansible
Jenkins Introduction
Ø Introduction to Jenkins UI
Ø Creating First Jenkins Job
Ø Redirect our First Job output
Ø Learn how to execute a bash script from Jenkins
Ø Add parameters to our Job
Ø Learn how to create a Jenkins list parameter with our script
Ø Add basic logic & Boolean parameters
Jenkins & Docker
Ø Docker + Jenkins +SSH – 1
Ø Docker + Jenkins + SSH – 2
Ø Docker + Jenkins + SSH – 3
Ø Learn how to install Jenkins Plugins (SSH Plugin)
Ø Integrate our Docker SSH server with Jenkins
Ø Run Jenkins Job on our Docker remote host through SSH
Jenkins & AWS
Ø Introduction: MySQL + AWS + Shell Scripting + Jenkins
Ø Create a Jenkins Job to upload our DB to AWS
Jenkins & Ansible
Ø Introduction: Jenkins + Ansible
Ø Install Ansible: Docker + Jenkins
Ø Make the SSH Keys permanent on the Jenkins container
Ø Create a simple Ansible Inventory
Ø Create first Ansible Playbook
Ø Integrate Ansible & Jenkins (Ansible Plugin)
Ø Learn how to execute Playbooks from a Jenkins Job
Ø Power up: Add parameters to Ansible & Jenkins
Ø Missing the colours? Colorize our playbooks output
Ø Challenge: Jenkins + Ansible + MySQL + PHP + NGINX + Shell scripting
Ø Create a Playbook in Ansible to update our web table
Ø Test our playbook
Jenkins & Maven
Ø Introduction: Jenkins & Maven
Ø Install the Maven Plugin
Ø Install the GIT Plugin
Ø Learn how to clone a GIT/GUB repository from Jenkins
Ø Learn how to build a JAR using Maven
Ø Learn how to test our code
Ø Deploy our Jar Locally
Ø Display the results of our tests using a graph
Ø Archive the last successful artifact
Ø Send Email notifications about the status of our maven project.
Jenkins & GIT
Ø Create a GIT server using Docker
Ø Create first GIT Repository
Ø Create a GIT user to interact with our repository
Ø Upload the code for the Java App in our Repo
Ø Integrate the GIT server to our Maven Job
Ø Learn about GIT Hooks
Ø Trigger Jenkins Job using a GIT Hook
Jenkins Pipeline – Jenkinsfile
Ø Introduction to Pipeline
Ø Introduction to Jenkinsfile
Ø Install the Jenkins Pipeline Plugin
Ø Create first Pipeline
Ø Add multisteps to our Pipeline
Ø Retry
Ø Timeouts
Ø Environment Variables
Ø Credentials
Ø Post actions
CI/CD + Jenkins Pipeline + Docker + Maven
Ø Define the steps of Pipeline
Ø Write Bash scripts to automate Jar creation
Ø Write a Bash script to automate Docker Image creation
Ø Build: Add scripts to the Jenkinsfile
Ø Start the CI/CD process by committing new code to GIT.
Architectures:

Download Full Curriculum

Batch Schedule

⚡ Seats filling fast — only 7 remaining across all batches

Available Batches
Batch Type	Schedule	Duration	Next Start Date	Availability
Weekend	Sat & Sun, 10am–1pm	10 weeks	15 Aug 2026	Available
Weekday	Mon–Fri, 7–9pm	8 weeks	17 Aug 2026	Available
Fast-track	Mon–Sun, 6 hours/day	2 weeks	24 Aug 2026	Available

Ready to Get Started?