Master Docker & Kubernetes

Introduction to Docker

Difference between Docker Engine and Docker Desktop

System requirements

Virtual Machine Setup

Docker Engine setup using package manager (Ubuntu)

Docker Engine setup using script

Understanding Docker default parameters

What is a Docker container

Nginx application container creation Part 1

Nginx application container creation Part 2

MySQL Deployment

Container creation Workflow in Docker Engine

Configure static IP address for Docker host machine

Understanding how to access applications from outside of Docker host machine

Practical session on accessing applications from outside of Docker Host

Understanding container restart policy

Container restart policy

Introduction to WordPress and MySQL Deployment

WordPress and MySQL Deployment on Docker Engine

Resource cleanup

Introduction to Jenkins CICD application

Jenkins CICD deployment on Docker Engine

Points to remember while creating container (rm, exec, create)

Difference between docker container create and run

What is Docker Image for Containers

Understanding Docker Image and Container Layers

Disk utilization of Containers and Images

Docker Hub account creation and pricing

Docker Image pull workflow

Push and Pull Images from Docker Hub

Share Images in Docker Hub account

Introduction to Dockerfile (A Custom Image Build Solution from Docker)

Dockerfile - FROM parameter

Dockerfile - MAINTAINER and RUN parameter (with and without build cache)

Dockerfile - LABEL and ENV parameter

Dockerfile - ARG and EXPOSE parameter

Dockerfile - COPY and ADD parameter

Dockerfile - ENTRYPOINT and CMD parameter

Dockerfile - SHELL and WORKDIR parameter

Dockerfile - STOPSIGNAL and HEALTHCHECK parameter

Dockerfile - VOLUME and USER parameter

Demo : Deploy Nginx app on Ubuntu 22.04 base image as non-root user

How to choose right base Image to save the size (Ubuntu Vs Alpine)

Introduction to Docker Storage types

Understanding volume mount with scenarios Part 1

Understanding volume mount with scenarios Part 2

Understanding Jenkins deployment using volume mount architecture

Jenkins CICD application deployment using volume mount

Understanding bind mount with scenarios Part 1

Understanding bind mount with scenarios Part 2

Understanding Jenkins deployment using bind mount architecture

Jenkins CICD application deployment using bind mount

Docker tmpfs mount

Points to remember while using Storage

Understanding remote storage using NFS server

Implement Docker volume mount with NFS server

Network types suppported by Docker

Docker default bridge network

Docker user-defined bridge network

User-defined bridge network managed by Daemon

Container with static IP address allocation

Points to remember while using Bridge network

Understanding Host network

Demo on host network creation

Points to remember while using Host network

Understanding None network

None network

Understanding Docker overlay network

Implementing Docker overlay network

Points to consider while working with overlay network

How to change default docker root directory

Docker root directory status check

How to change default bridge network CIDR

How to change default bridge network to custom network

What are links in Docker

Introduction to resources limits on Docker containers

Introduction to UI access

Portainer archirecture and pricing details

Setup and configure Portainer on Docker Engine

Access Portainer dashboard

Part 1 - Environments

Part 2 - Containers

Part 3 - Network, Images, and Volumes

App templates and stack

Conclusion - limitations of community edition

Challenges with Docker Engine

Introduction to Docker Compose

Docker compose file parameters

Introduction to Docker Engine machine for compose

Docker compose installation scenarios

High level view of Kubernetes architecture and components

Common components for control and compute plane nodes

Introduction to Kubernetes control plane components

Kubernetes control plane components working principle

Introduction to Kubernetes compute plane components

Kubernetes compute plane components working principle

Kubernetes Components ports and protocols

Tools to setup kubernetes cluster and Cloud service

Overview on single and multi node setup using kubeadm tool

Why Containerd not Docker (K8S dropped support for Docker)

Kubernetes single node setup using kubeadm tool (CRI_ Containerd)

Kubernetes multi-node setup using kubeadm tool (CRI_Containerd)

Part 1 - Kubernetes HA setup using kubeadm tool (CRI_ containerd)

Part 2 - Kubernetes HA setup using kubeadm tool (CRI_containerd)

Part 3 - Kubernetes HA setup using kubeadm tool (CRI_containerd)

Part 4 Kubernetes HA setup using kubeadm tool (CRI_containerd)

Part 5 - Kubernetes HA setup using kubeadm tool (CRI_containerd)

Kubernetes Objects overview

POD overview

Intergrating VS code with K8S cluster

Overview on K8S objects creation using imperative and declarative approach

POD creation using Declarative approach

POD creation using Imperative approach

POD creation workflow

POD resource allocation CPU and Memory

POD multi-container with shared volume

Handling containers in POD using crictl (restart container POD)

Access POD application outside cluster (hostPort)

POD init Containers Introduction

Demo : POD init Containers

POD Lifecycle - restart policy

Static POD (controlled by Kubelet)

Challenges of standalone POD applications

Introduction to Workload resources

Workload resource replication

Introduction to Replication Controller (rc)

Demo : Implement RC using declarative approach

Demo : RC scalein and scaleout

Demo : RC and POD label selector

Demo : How to delete RC using cascade option

Introduction to Replica Set (rs)

Demo : Implement RS using declarative approach

Demo : RS scalein and scaleout

Demo : RS and POD label selector (matchLabels)

Demo : RS and POD label selector (matchExpressions)

Demo : How to delete RS using cascade option

Introduction to Deployment (deploy)

Demo : Deployment workflow (Declarative and Imperative)

Demo : Deployment scalein and scaleout

Demo : Deployment Rollout and Rollback (StrategyType & RollingUpdate)

Demo : Deployment Rollout and Rollback (StrategyType & Recreate)

Introduction to Daemon Set (ds)

Demo: Daemonset work flow (Declarative approach)

Demo : Daemonset rollout and rollback (strategy type & RollingUpdate)

Demo: Daemonset rollout and rollback (strategy type & OnDelete)

Introduction to Jobs

Demo : Jobs workflow (restart Policy)

Demo : Jobs termination and cleanup

Introduction to CronJobs (cj)

Demo : CronJob workflow (restart Policy)

Demo : CronJob concurrency policy

Demo : CronJob Job history limits

Introduction to Auto-cleanup of finished Jobs

Demo : Jobs auto-cleanup

Demo : CronJobs auto-cleanup

When to learn Statefulset workload resource

Introduction to K8S Service and Types

Overview on need of Service for workload resources

Introduction to ClusterIP service

Demo: Overview on Service type ClusterIP

Demo: Service (ClusterIP) with Endpoint

Demo: Service ClusterIP type creation using Imperative approach

Demo: Service selector and pod labels

Advanced: Traffic flow from client (POD) to service to target PODs

Introduction to NodePort service

Demo: Overview on Service type NodePort

Demo: Service NodePort type creation using Imperative approach

Demo: Customize service NodePort range and IP addresses range

Advanaced: Traffic flow from external to node to service to POD

Introduction to LoadBalancer service

Introduction to MetalLB for On-premises K8S cluster

Demo: Deploying MetalLB on cluster (On-premises)

Advanced: Traffic flow while using LoadBalancer service type

Introduction to ExternalIP service

Demo: Overview on Service type ExternalIP

Introduction to ExternalName service

Demo: Overview on Service type ExternalName

Introduction to Headless service (ClusterIP & None)

Demo: Overview on Service type Headless (ClusterIP & None)

Introduction to Kubernetes Storage types

Overview on Kubernetes Volumes

Overview on Kubernetes Volumes

EmptyDir: Working principle of emptyDir volume type

EmptyDir: Demo for emptyDir volume type (Disk and Memory)

HostPath: Working principle of hostPath volume type

HostPath: Demo for hostPath volume type (Directory and DirectoryOrCreate)

HostPath: Demo for hostPath volume type (File and FileOrCreate)

NFS: Working principle of nfs volume type

Setup NFS server for Kubernetes Volume Demo

NFS: Demo for NFS volume type

NFS: Jenkins CICD Deployment Object with active and passive mode

DownwardAPI: Demo on downwardAPI (Information_ fieldRef)

DownwardAPI: Demo on downwardAPI (Information_ resourcefieldRef)

Introduction to Persistent Storage

Understanding Persistent Volume Access Modes

Demo: Static PV and PVC (volume plugin & hostPath)

Demo: PV and PVC management (hostPath)

Demo: Static PV and PVC (volume plugin & nfs)

Demo: Persistent Volume Reclaim Policies (nfs - retain, recycle, delete)

Introduction to Access Modes for PV and PVC

Demo: Access Modes

Understanding PV phases

Introduction to Kubernetes Configuration

Introduction to Statefulset Object

Demo: understanding STS workflow

Demo: STS scalein and scaleout stratagies

Demo: STS with Headless service

Demo: Update strategies supported by STS

Introduction to Kubernetes Configuration

Introduction to Kubernetes ConfigMap

Demo: Handling ConfigMap using Imperative approach (environment variables)

Demo: Handling ConfigMap using Declarative approach (environment variables)

Demo: Handling ConfigMap using Declarative approach (volume plugin)

Demo: Immutable ConfigMap

Introduction to Kubernetes Secrets

Demo: Handling Secrets using Imperative approach (environment variables)

Demo: Handling Secrets using Declarative approach

Demo: Handling Secrets using Declarative approach (volume plugin)

Demo: Secrets to pull registry Private images (imagePullSecrets)

Introduction to Kubernetes scheduler

Demo: Scheduling POD using nodeName

Demo: Scheduling POD using nodeSelector

Introduction to nodeAffinity operators

Demo: Scheduling POD using nodeAffinity (requiredDuringScheduling)

Demo: preferred and required for nodeAffinity

Demo: nodeAntiAffinity using NotIn operator

Demo: Scheduling POD using podAffinity (requiredDuringScheduling)

Demo: Scheduling POD using podAffinity (preferredDuringScheduling)

Demo: Scheduling POD using podAntiAffinity (requiredDuringScheduling)

Demo: Scheduling POD using podAntiAffinity (preferredDuringScheduling)

Demo: Scheduling POD using Taints and Tolerations (NoSchedule)

Demo: Scheduling POD using Taints and Tolerations (NoExecute)

Introduction to Kubernetes Authentication and Authorization strategies

Understanding Kubernetes authentication

Understanding Kubernetes authorization

Working principle of Cloud Kubernetes cluster

Understanding kubeconfig file

Demo: K8S authenticating using cert based (Role and RoleBinding)

Demo: K8S authenticating using cert based (ClusterRole and ClusterRoleBinding)

Understanding k8s ServiceAccount

Demo: K8S POD to use Service Account

Demo: K8S authenticating using SA based (Role and RoleBinding)

Demo: K8S authenticating using SA based (ClusterRole and ClusterRoleBinding)

Demo: How to handle multiple context in kubeconfig file

Introduction to Kubernetes Namespaces

Demo: Implementing Kubernetes namespaces (imperative and declarative)

How to access applications in k8s from outside cluster

Introduction to Ingress Controller

Understanding Nginx Ingress Controller for On-premises K8S

Demo: Deploy Nginx Ingress Controller

Demo: Deploy Ingress resource for applications in k8s (host-based routing)

K8s Ingress resource workflow (host-based routing)

Demo: TLS termination for Ingress resource (host-based routing)

K8S Ingress resource workflow (path-based routing)

Demo: Deploy Ingress resource for applications in k8s (path-based routing)

Introduction to Kubernetes Network Policy

Understanding Network Policy resource implementation (calico network policy)

Demo: Network Policy Implementation with podSelector (Ingress type)

Demo: Network Policy Implementation with namespaceSelector (Ingress type)

Demo: Network Policy Implementation with ipBlock (Ingress type)

Demo: Network Policy with podSelector and namespaceSelector (Ingress type)

Demo: Network Policy with podSelector and namespaceSelector (Egress type)

Demo: Network Policy with ipBlock (Egress type)

Understanding Default Network Policies

Introduction to web-based UI for kubernetes

Demo: Deploy k8s dashboard

Demo: Admin user management in k8s dashboard (ServiceAccount)

Demo: Dashboard walk through as Admin user

Demo: User access to k8s dashboard (read only access)

Understanding k8s upgrade principles

Upgrade k8s from v1.25.x to v1.26.x (minor version upgrade)

K8S upgrade - Conclusion

Introduction to ETCD

ETCD cli tool setup and configuration

Backup: ETCD snapshot (Scenario 1)

Restore: ETCD snapshot restore (Scenario 1)

Introduction to monitoring tools for Kubernetes

Introduction to Prometheus

Understanding prometheus components and architecture

Understanding prometheus manifest files

Deploy Promethues on Kubernetes cluster

Access Prometheus dashboard

Metric server for Prometheus

Understanding Grafana manifest files

Deploy Grafana on Kubernetes cluster

Access Grafana dashboard with node-exporter

Grafana dashboard

Resource cleanup

Understanding Docker overlay network

Implementing Docker overlay network

Points to consider while working with overlay network

Understanding Jenkins deployment using volume mount architecture

Jenkins CICD application deployment using volume mount

Introduction to WordPress and MySQL Deployment

Understanding remote storage using NFS server

Implement Docker volume mount with NFS server

Deploy Nginx app on Ubuntu 22.04 base image as non-root user

GitHub and Docker Hub account walk through

GitHub integration with VS Code

Scenario 1: Implement Dockerfile for Nginx webapp

Scenario 1: GitHub Secrets for authentication

Scenario 1: GitHub actions workflow YAML (GitHub actions)

Scenario 1: GitHub actions execution

Scenario 2: Repository tags

Scenario 2: Repository tags

Image vulnerability scan implementation (build and push action)

CICD workflow: Commit changes to run Image scan (dynamic tagging)

Manual: Run github workflow

Run Build, Scan and Push github workflow

Project agenda

AWS EC2 Instance setup for Docker Engine

WordPress and MySQL Deployment on Docker Engine

EC2 ssh access and configuration

Basic check of Docker Engine tool and directory structure

K8SEngineers application deployment workflow

PostgreSQL: deployment workflow

PostgreSQL: Implement Dockerfile

PostgreSQL: Implement scripts to initialize

PostgreSQL: Download and access initial DB backup file

PostgreSQL: Build image from Dockerfile

Launch PostgreSQL database

NodeJS deployment workflow

Backend: Clone repository for k8sengineers backend code

Backend: Implement Dockerfile

Backend: Define ENV for NodeJS to access PostgreSQL

Backend: Build Image from Dockerfile

Backend: Launch NodeJS container

Backend: Check NodeJS health after deployment

ReactJS deployment workflow

Frontend: Clone repository for k8sengineers frontend code

Frontend: Implement Dockerfile

Frontend: Build image from Dockerfile

Frontend: Launch ReactJS container

Allow ports to access k8sengineers application

Conclusion_ Access application to verify deployment

Changes for Docker Compose

Implement Docker compose file

Image build with Docker compose

Deploy service with Docker compose

Update AWS Rote53 with A and CNAME record

Access application after deployment

Cleanup activity

Project Introduction

Docker Project: Project agenda

Docker Project: AWS EC2 Instance setup for Docker Engine

Docker Project: EC2 ssh access and configuration

Docker Project: Basic check of Docker Engine tool and directory structure

Docker Project: K8SEngineers application deployment workflow

Docker Engine: PostgreSQL deployment workflow

Docker Engine: PostgreSQL Implement Dockerfile

Docker Engine: PostgreSQL Implement scripts to initialize

Docker Engine: PostgreSQL Download and access initial DB backup file

Docker Engine: PostgreSQL Build image from Dockerfile

Docker Engine: Launch PostgreSQL database

Docker Engine: NodeJS deployment workflow

Docker Engine: Backend Clone repository for k8sengineers backend code

Docker Engine: Backend: Implement Dockerfile

Docker Engine: Backend: Define ENV for NodeJS to access PostgreSQL

Docker Engine: Backend: Build Image from Dockerfile

Docker Engine: Backend: Launch NodeJS container

Docker Engine: Backend: Check NodeJS health after deployment

Docker Engine: ReactJS deployment workflow

Docker Engine: Frontend: Clone repository for k8sengineers frontend code

Docker Engine: Frontend: Implement Dockerfile

Docker Engine: Frontend Build image from Dockerfile

Docker Engine: Frontend: Launch ReactJS container

Docker Engine: Allow ports to access k8sengineers application

Docker Engine: Conclusion: Access application to verify deployment

Introduction

Understanding Kubernetes application deployment stratagies

Introduction to HELM

Helm Workflow

Difference between Helm v2 vs v3 Architecture

Introduction to Helm Setup and Configuration

Demo: Helm setup and configuration on k8s node (Binary release)

Demo: Helm setup and configuration on remote machine (Package manager)

Introduction to Helm charts

Understanding: Chart.yaml file parameters

Understanding: templates folder and values.yaml file purpose

Understanding: LICENSE and README file

Understanding: .helmignore and NOTES.txt file

Understanding: charts folder

Understanding: _helpers.tpl file

Understanding: JSON schema file and crds folder

Understanding: test folder

Introduction to Helm repository

Add and update help repos (bitnami repository)

How to remove repo from helm

Understanding basic chart creation steps

Basic steps to deploy and test helm chart

Rollout and Rollback of helm chart

Working with helm command to check status and package chart

Helm commands with preview

Implement metadata and template files for Nginx application deployment

Understanding chart version

Inherit variables from Chart.yaml file

Recap: Implement Nginx application deployment templates

Part1: Implement values.yaml for template files

Part2: Implement values.yaml for template files

Predefined variables (Release)

Predefined variables (Capabilities)

Part1: Handling _helpers.tpl in template files (template)

Part2: Handling _helpers.tpl in template files (include)

Part3: Handling _helpers.tpl in template files (include)

Part1: Helm test using test hook (helm testing)

Part2: Helm test using delete policy hook (helm testing)

Part3: Types of delete policy hook (helm testing)

Introduction to MYSQL application deployment process using manifests

Deploy MySQL app through manifest approach

Part1: Implement values for pv template files

Part2: Implement pv template files with labels

Part3: Implement pv template files with annotations

Part1: Implement values for secrets template files

Part2: Implement values for secrets template files with annotations and labels

Implement values for service template file

Part1: Implement statefulset template for MySQL

Part2: Implement statefulset template for MySQL

Part3: Implement statefulset template for MySQL

Part4: Implement statefulset template for MySQL

Implement Job template for MySQL backup

Implement CronJob template for scheduled backups

Deploy MySQL application with all templates enabled

Cleanup MySQL chart

Introduction to Helm hooks

GitOps Deployment stratagies

Introduction to ArgoCD

ArgoCD architecture

Components: API, Repository Server and Application Controller

Requirments for ArgoCD setup

ArgoCD Setup

Dashboard Setup

ArgoCD CLI setup

ArgoCD intergration with GitHub

Password reset for admin user

Nginx Deployment using manifest

Deployment rollout

Deployment rollback

Deployment rollback using git revert

Application cleanup

Deploy MySQL application

Deployment and Service yaml creation

Deploy Jenkins application

Disaster recovery of application data

Jenkins image rollout

Jenkins rollback

Resource cleanup

Nginx app deployment using helm chart

Nginx helm chart with custom values

Nginx app using declarative approach

Declarative approach with custom parameters

Introduction to Hooks and Waves

Sync and waves workflow

Basic hook details

PreSync and PostSync Demo

Part1: Hook delete policy demo

Part2: Hook delete policy demo

Part1: Demo on argocd waves priority

Part2: Demo on argocd waves priority