Skip to main content
Mapagam

60 SECTIONS · 1621 TOPICS

Kubernetes Roadmap

  1. Understanding Kubernetes Architecture

    1. 1. Understanding Control Plane Components
    2. Example: API Server Configuration
    3. 2. Understanding Node Components
    4. Example: kubelet configuration
    5. 3. Understanding Pods as Deployment Units
    6. Example: Basic Pod Definition
    7. 4. Understanding Services and Networking
    8. Example: Exposing a Service with NodePort
    9. Example: Creating a LoadBalancer Service
    10. Networking Concepts in Kubernetes
    11. 5. Understanding Workload Resources
    12. Example: Deployment Configuration
    13. Example: StatefulSet Configuration
    14. 6. Understanding Storage Abstractions
    15. Example: Using PersistentVolume and PersistentVolumeClaim
    16. Example: Using StorageClass for Dynamic Provisioning
    17. 7. Understanding Configuration Resources
    18. Example: Using ConfigMap in a Pod
    19. Example: Using Secret in a Pod
    20. Key Concepts
    21. 8. Understanding Namespaces and Multi-Tenancy
    22. Example: Creating a Namespace
    23. Example: Deploying to a Namespace
    24. Key Benefits of Namespaces
    25. Namespaces vs. Clusters
    26. 9. Understanding API Resources and Extensions
    27. Example: Creating a Custom Resource Definition (CRD)
    28. API Resource Categories
    29. 10. Understanding Cluster Add-Ons
    30. Example: Deploying CoreDNS Add-On
    31. Add-Ons Overview

  2. Installing and Configuring kubectl

    1. 1. Installing kubectl CLI
    2. Example: Verify kubectl installation
    3. 2. Configuring kubeconfig File
    4. Example: Basic kubeconfig structure
    5. Example: Setting current context
    6. Example: Adding a new cluster
    7. Example: Setting a user credential
    8. 3. Managing Multiple Contexts
    9. Example: View current context
    10. Example: List all contexts
    11. Example: Switch context
    12. 4. Setting Default Namespace
    13. 5. Viewing Cluster Information
    14. Example: kubectl cluster-info Output
    15. Example: kubectl get nodes Output
    16. 6. Checking kubectl Version
    17. Example: Checking kubectl version
    18. 7. Enabling kubectl Autocompletion
    19. Example: Bash Autocompletion Setup
    20. Example: Zsh Autocompletion Setup
    21. 8. Using kubectl Aliases
    22. Example: Creating a kubectl alias
    23. Example: Using a kubectl alias
    24. 9. Installing kubectl Plugins
    25. Example: Installing a Plugin via kubectl plugin install
    26. Example: Manual Plugin Installation
    27. 10. Configuring Authentication Methods
    28. Example: Token Authentication
    29. Example: Client Certificate Authentication

  3. Working with Clusters

    1. 1. Creating Local Cluster
    2. Example: Create local cluster with kind
    3. 2. Connecting to Remote Cluster
    4. Example: Configure kubectl to connect to a remote cluster
    5. 3. Viewing Cluster Nodes
    6. Example: Get node details using kubectl
    7. Example: Describe a specific node
    8. 4. Describing Node Details
    9. Example: Describe Node Details
    10. Example: Get Node Info in JSON Format
    11. 5. Labeling Nodes
    12. Example: Applying Labels to a Node
    13. Example: Listing Nodes with Labels
    14. 6. Tainting Nodes
    15. Example: Taint a Node
    16. Example: Remove a Taint
    17. 7. Cordoning Nodes
    18. Example: Cordon a Node
    19. Example: Uncordon a Node
    20. 8. Draining Nodes
    21. Example: Drain a Node
    22. 9. Uncordoning Nodes
    23. Example: Uncordon a Node
    24. 10. Checking Cluster Health
    25. Example: kubectl get nodes
    26. Example: kubectl get pods --all-namespaces
    27. Example: kubectl describe node minikube
    28. Workflow: Cluster Health Check Steps
    29. 11. Viewing API Resources
    30. Example: Get all pods in a namespace
    31. Example: Get detailed pod information
    32. 12. Managing Cluster Certificates
    33. Example: Renewing a Cluster Certificate

  4. Working with Namespaces

    1. 1. Creating Namespaces
    2. Example: Create a Namespace using kubectl
    3. 2. Listing Namespaces
    4. Example: Listing Namespaces with Labels
    5. Example: Listing Namespaces in JSON Format
    6. 3. Switching Namespaces
    7. Example: Switching to a Different Namespace
    8. 4. Deleting Namespaces
    9. Example: Delete a namespace
    10. 5. Using Namespace Flag
    11. Example: Using namespace flag in kubectl commands
    12. 6. Viewing Resources Across Namespaces
    13. Example: List all pods across all namespaces
    14. Example: Get all services across namespaces
    15. Example: View all deployments in all namespaces
    16. 7. Setting Resource Quotas
    17. Example: ResourceQuota YAML Definition
    18. 8. Configuring Limit Ranges
    19. Example: LimitRange Configuration
    20. Key Points
    21. 9. Understanding Default Namespaces
    22. Example: Creating a Pod in the Default Namespace
    23. 10. Isolating Namespaces with Network Policies
    24. Example: Basic Network Policy to Allow Ingress
    25. Example: Deny All Egress
    26. Example: Allow Egress to Specific Namespace

  5. Working with Contexts and Kubeconfig

    1. 1. Viewing Current Context
    2. Example: Current Context Output
    3. 2. Listing All Contexts
    4. Example: Output of kubectl config get-contexts
    5. 3. Switching Contexts
    6. Example: Switching Contexts
    7. Example: Viewing Current Context
    8. Example: Listing All Contexts
    9. 4. Creating New Context
    10. Example: Create a new context using kubectl
    11. 5. Renaming Contexts
    12. Example: Renaming a Context
    13. 6. Deleting Contexts
    14. Example: Delete a Context
    15. 7. Setting Context Namespace
    16. Example: Setting Namespace in kubeconfig
    17. 8. Merging Kubeconfig Files
    18. Example: Merge kubeconfig files
    19. 9. Viewing Kubeconfig Content
    20. Example: Display current kubeconfig
    21. Example: View specific context
    22. Example: Show current context
    23. 10. Setting Cluster Server
    24. Example: Setting Cluster Server URL
    25. 11. Setting User Credentials
    26. Example: Configure User Credentials

  6. Creating and Managing Pods

    1. 1. Creating Pod from YAML
    2. Example: Basic Pod Definition
    3. 2. Running Pod Imperatively
    4. Example: Run a Pod with Environment Variables
    5. Example: Run a Pod with Resource Limits
    6. 3. Listing Pods
    7. Example: Listing Pods in a Namespace
    8. Example: Listing All Pods with Labels
    9. 4. Describing Pod Details
    10. Example: Describe Pod in YAML
    11. 5. Viewing Pod Logs
    12. Example: Fetching logs from a pod
    13. Example: Fetching logs with timestamp
    14. Example: Fetching logs from a specific container in a pod
    15. Example: Fetching logs for the last hour
    16. Example: Fetching last 100 lines of logs
    17. 6. Following Log Streams
    18. 7. Executing Commands in Pod
    19. Example: Executing a command in a pod
    20. Example: Running a command in a specific container
    21. 8. Port Forwarding to Pod
    22. Example: Forwarding Local Port to Pod
    23. 9. Deleting Pods
    24. Example: Delete a Pod by Name
    25. Example: Delete Pods with Label Selector
    26. 10. Using Pod Selectors
    27. Example: Label Selector in Deployment
    28. Example: Field Selector in Pod List
    29. 11. Watching Pod Status
    30. Example: Watching Pod Status in Real Time
    31. Example: Describing a Pod for Detailed Information
    32. 12. Getting Pod YAML
    33. 13. Copying Files to Pod
    34. Example: Copying a file to a pod
    35. Example: Copying a directory to a pod

  7. Configuring Pod Specifications

    1. 1. Setting Container Images
    2. Example: Basic Pod with Container Image
    3. Example: Pod with Private Image
    4. 2. Defining Resource Requests
    5. Example: Defining CPU and Memory Requests
    6. 3. Defining Resource Limits
    7. Example: Setting Resource Limits in a Pod Spec
    8. 4. Configuring Environment Variables
    9. Example: Setting Environment Variables
    10. Example: Loading Variables from ConfigMap
    11. Example: Loading Variables from Secret
    12. 5. Setting Container Commands
    13. Example: Overriding entrypoint and arguments
    14. 6. Configuring Working Directory
    15. Example: Setting Working Directory
    16. 7. Setting Security Context
    17. Example: Setting Security Context for a Pod
    18. 8. Configuring Pod Priority
    19. Example: Setting Pod Priority
    20. 9. Using Pod Preemption Policy
    21. Example: Setting preemptionPolicy to Never
    22. 10. Setting Pod Restart Policy
    23. Example: Setting Restart Policy in Pod Spec
    24. 11. Configuring Pod DNS Policy
    25. Example: Setting DNS Policy in Pod Spec
    26. 12. Using Service Account
    27. Example: Define ServiceAccount in Pod Spec

  8. Configuring Init Containers

    1. 1. Understanding Init Container Purpose
    2. Example: Init Container Setup
    3. 2. Defining Init Containers
    4. Example: Basic Init Container Definition
    5. Example: Init Container with Volume Mount
    6. 3. Setting Init Container Order
    7. Example: Defining init containers with dependencies
    8. 4. Sharing Volumes with Main Containers
    9. Example: Mounting a Shared Volume
    10. 5. Setting Init Container Resources
    11. Example: Setting CPU and Memory Limits in Init Container
    12. 6. Handling Init Container Failures
    13. Example: Configuring Init Container with Retry Logic
    14. Key Points for Handling Failures
    15. 7. Debugging Init Containers
    16. Example: Debugging with Logs
    17. Debugging Workflow
    18. 8. Using Init Containers for Dependencies
    19. Example: Waiting for a Database
    20. 9. Running Database Migrations
    21. Example: Init Container for Database Migration
    22. 10. Downloading Configuration Files
    23. Example: Downloading Config Files from a ConfigMap
    24. Example: Using Secret to Download Sensitive Data

  9. Configuring Sidecar Containers

    1. 1. Understanding Sidecar Pattern
    2. Example: Sidecar Pod Configuration
    3. 2. Creating Multi-Container Pods
    4. Example: Pod with Main App and Sidecar
    5. 3. Sharing Volumes Between Containers
    6. Example: Mounting a Shared Volume
    7. 4. Implementing Logging Sidecars
    8. Example: Logging Sidecar Configuration
    9. 5. Implementing Proxy Sidecars
    10. Example: Sidecar Configuration with Nginx
    11. 6. Using Ambassador Pattern
    12. Example: Ambassador Sidecar Configuration
    13. Key Benefits of Ambassador Pattern
    14. 7. Using Adapter Pattern
    15. Example: Implementing an Adapter Pattern in a Sidecar
    16. Adapter Pattern Benefits
    17. 8. Setting Container Lifecycle
    18. Example: Container Lifecycle Hooks Configuration
    19. 9. Configuring Shared Network Namespace
    20. Example: Enabling Shared Network Namespace
    21. 10. Debugging Sidecar Containers
    22. Example: Attaching to a Sidecar Container
    23. Debugging Approaches

  10. Implementing Health Checks

    1. 1. Configuring Liveness Probes
    2. Example: HTTP GET Liveness Probe
    3. Example: TCP Socket Liveness Probe
    4. Example: Exec Liveness Probe
    5. 2. Configuring Readiness Probes
    6. Example: HTTP Readiness Probe
    7. 3. Configuring Startup Probes
    8. Example: Startup Probe Configuration
    9. 4. Using HTTP Probes
    10. Example: HTTP Probe Configuration
    11. 5. Using TCP Probes
    12. Example: TCP Probe Configuration
    13. 6. Using Exec Probes
    14. Example: Exec Probe Configuration
    15. 7. Using gRPC Probes
    16. Example: gRPC Probe Configuration
    17. 8. Setting Initial Delay
    18. Example: Configuring initialDelaySeconds in a readiness probe
    19. 9. Configuring Period Seconds
    20. Example: Configuring periodSeconds in a Probe
    21. 10. Setting Failure Threshold
    22. Example: Configuring failureThreshold in a readiness probe
    23. 11. Setting Success Threshold
    24. Example: Configuring successThreshold in a readiness probe
    25. 12. Configuring Timeout Seconds
    26. Example: Setting timeoutSeconds in a Probe

  11. Working with Pod Lifecycle Hooks

    1. 1. Understanding Lifecycle Hooks
    2. Example: Defining Lifecycle Hooks in a Pod Spec
    3. 2. Configuring PostStart Hook
    4. Example: PostStart Hook with Exec
    5. 3. Configuring PreStop Hook
    6. Example: Exec PreStop Hook
    7. Example: HTTP PreStop Hook
    8. Example: TCP Socket PreStop Hook
    9. 4. Using Exec Handler
    10. Example: Using exec handler in lifecycle hook
    11. 5. Using HTTP Handler
    12. Example: HTTP Handler Configuration
    13. 6. Implementing Graceful Shutdown
    14. Example: preStop Hook Configuration
    15. 7. Understanding Hook Guarantees
    16. 8. Setting Termination Grace Period
    17. Example: Setting termination grace period in Pod spec
    18. 9. Debugging Lifecycle Hooks
    19. Example: Debugging with Logs
    20. Example: Inspecting Hook Execution
    21. Workflow: Debugging Lifecycle Hook Issues
    22. 10. Using Hooks for Deregistration
    23. Example: preStop Hook for Deregistration

  12. Working with Labels and Selectors

    1. 1. Adding Labels to Resources
    2. Example: Adding Labels to a Pod
    3. Example: Adding Labels to a Deployment
    4. 2. Viewing Resource Labels
    5. Example: Get Pods with Specific Label
    6. Example: Get Pods with Multiple Labels
    7. Example: Get Pods with Label Not Equal to Value
    8. Example: Get Pods with Label Key Exists
    9. Example: Get Pods with Label Key Does Not Exist
    10. Label Query Operators
    11. 3. Filtering by Label Selectors
    12. Example: Using Label Selectors in a Pod Definition
    13. Example: Filtering Pods by Label Selector
    14. 4. Using Equality-Based Selectors
    15. Example: Using Equality-Based Selectors in a Deployment
    16. Example: Using Equality-Based Selectors in a Service
    17. 5. Using Set-Based Selectors
    18. Example: Using Set-Based Selectors in a Pod
    19. Example: Using Set-Based Selectors in a Service
    20. 6. Removing Labels
    21. Example: Removing a Label from a Pod
    22. 7. Overwriting Labels
    23. Example: Updating a Pod's Label
    24. 8. Using Labels in YAML
    25. Example: Deploying a Pod with Labels
    26. 9. Selecting with matchLabels
    27. Example: Using matchLabels in a Pod Spec
    28. Example: Using matchLabels in a Service
    29. 10. Selecting with matchExpressions
    30. Example: Using matchExpressions in a Pod selector
    31. matchExpressions Operators

  13. Managing Annotations

    1. 1. Adding Annotations
    2. Example: Adding Annotations to a Pod
    3. 2. Viewing Annotations
    4. Example: Viewing Annotations on a Pod
    5. 3. Removing Annotations
    6. Example: Remove annotation from a pod
    7. 4. Using Annotations in YAML
    8. Example: Pod with Annotations
    9. 5. Understanding Common Annotations
    10. Example: Using Annotations in a Deployment
    11. 6. Using Deployment Annotations
    12. Example: Adding Annotations to a Deployment
    13. 7. Configuring Ingress Annotations
    14. Example: Basic Ingress with Annotations
    15. 8. Using Prometheus Annotations
    16. Example: Annotating a Deployment for Prometheus
    17. 9. Setting Autoscaler Annotations
    18. Example: Setting Annotations on a Deployment
    19. 10. Understanding Annotation Size Limits

  14. Working with Deployments

    1. 1. Creating Deployment
    2. Example: Basic Deployment
    3. 2. Applying Deployment YAML
    4. Example: Basic Deployment YAML
    5. 3. Scaling Deployment
    6. Example: Scaling Deployment
    7. Example: Update Replicas Count
    8. 4. Updating Deployment Image
    9. Example: Update Deployment Image
    10. Update Process
    11. 5. Viewing Rollout Status
    12. Example: Check rollout status of a deployment
    13. 6. Viewing Rollout History
    14. Example: View rollout history
    15. 7. Rolling Back Deployment
    16. Example: Rolling Back Deployment
    17. Example: Check Rollout History
    18. 8. Pausing Rollouts
    19. Example: Pausing and Resuming a Rollout
    20. 9. Resuming Rollouts
    21. Example: Resuming a Paused Deployment
    22. 10. Configuring Update Strategy
    23. Example: Deployment with custom update strategy
    24. 11. Setting Max Unavailable
    25. Example: Setting maxUnavailable in Deployment
    26. 12. Setting Max Surge
    27. Example: Deployment with maxSurge and maxUnavailable
    28. 13. Setting Revision History Limit
    29. Example: Setting Revision History Limit in Deployment YAML

  15. Managing ReplicaSets

    1. 1. Listing ReplicaSets
    2. Example: Listing ReplicaSets in default namespace
    3. Example: Listing ReplicaSets with wide output
    4. 2. Describing ReplicaSet Details
    5. Example: Describe a ReplicaSet
    6. Example: Get ReplicaSet YAML
    7. 3. Scaling ReplicaSets
    8. Example: Scaling a ReplicaSet
    9. 4. Deleting ReplicaSets
    10. Example: Delete a ReplicaSet
    11. Example: Delete a ReplicaSet and keep its Pods
    12. 5. Understanding ReplicaSet Selectors
    13. Example: ReplicaSet with Label Selectors
    14. 6. Viewing ReplicaSet Ownership
    15. Example: Describe ReplicaSet to View Ownership
    16. Example: Get ReplicaSet with Owner References
    17. 7. Viewing ReplicaSet Pods
    18. Example: Get ReplicaSet Pod List
    19. Example: Describe ReplicaSet
    20. 8. Orphaning Pods During Deletion
    21. Example: Orphaning Pods During ReplicaSet Deletion
    22. 9. Understanding ReplicaSet vs Deployment
    23. When to Use Which?
    24. 10. Troubleshooting ReplicaSet Issues
    25. Example: Check ReplicaSet Status
    26. Example: Describe ReplicaSet

  16. Managing StatefulSets

    1. 1. Creating StatefulSet
    2. Example: Basic StatefulSet Configuration
    3. 2. Listing StatefulSets
    4. Example: List all StatefulSets in the current namespace
    5. Example: List all StatefulSets in all namespaces
    6. Example: List StatefulSets with additional details
    7. 3. Describing StatefulSet Details
    8. Example: Basic StatefulSet Definition
    9. 4. Scaling StatefulSet
    10. Example: Scaling StatefulSet
    11. 5. Understanding Ordered Pod Creation
    12. Example: Setting Ordered Pod Creation
    13. 6. Using Parallel Pod Management
    14. Example: Setting Parallel Pod Management
    15. 7. Configuring Volume Claim Templates
    16. Example: Volume Claim Template Configuration
    17. 8. Using Headless Services
    18. Example: Headless Service Definition
    19. 9. Understanding Stable Network IDs
    20. Example: Headless Service Configuration
    21. 10. Updating StatefulSets
    22. Example: Update Strategy Configuration
    23. 11. Deleting StatefulSets
    24. Example: Delete a StatefulSet with foreground cascading
    25. 12. Troubleshooting StatefulSet Issues
    26. Example: Debugging Pod Events
    27. Example: Checking Volume Claims

  17. Working with DaemonSets

    1. 1. Creating DaemonSet
    2. Example: Basic DaemonSet YAML
    3. 2. Listing DaemonSets
    4. Example: Listing DaemonSets in the default namespace
    5. Example: Listing all DaemonSets across all namespaces
    6. 3. Describing DaemonSet Details
    7. Example: DaemonSet YAML Definition
    8. 4. Understanding DaemonSet Scheduling
    9. Example: DaemonSet with update strategy
    10. 5. Using Node Selectors
    11. Example: DaemonSet with Node Selector
    12. 6. Using Node Affinity
    13. Example: Node Affinity Configuration
    14. 7. Tolerating Taints
    15. Example: Tolerating Master Node Taints
    16. 8. Updating DaemonSets
    17. Example: Update DaemonSet with RollingUpdate
    18. 9. Setting Max Unavailable
    19. Example: Setting maxUnavailable to 20%
    20. 10. Deleting DaemonSets
    21. Example: Delete a DaemonSet
    22. 11. Troubleshooting DaemonSet Pods
    23. Example: Check DaemonSet Pod Status

  18. Managing Jobs

    1. 1. Creating Job
    2. Example: Creating a Job
    3. 2. Creating Job from CronJob
    4. Example: Creating a CronJob that runs a Job daily
    5. 3. Listing Jobs
    6. Example: Listing Jobs in Current Namespace
    7. Example: Listing Jobs Across All Namespaces
    8. 4. Describing Job Details
    9. Example: Describe Job Details
    10. 5. Setting Completions Count
    11. Example: Setting Completions Count
    12. 6. Setting Parallelism Level
    13. Example: Setting parallelism to 3
    14. 7. Configuring Backoff Limit
    15. Example: Setting Backoff Limit
    16. 8. Setting Active Deadline
    17. Example: Setting Active Deadline on a Job
    18. 9. Using Job Selectors
    19. Example: Label Selector
    20. Example: Field Selector
    21. 10. Viewing Job Logs
    22. Example: View job logs
    23. Example: View logs from previous job run
    24. 11. Deleting Jobs
    25. Example: Delete a Job by Name
    26. Example: Delete a Job in a Specific Namespace
    27. Example: Delete All Jobs in a Namespace
    28. 12. Cleaning Up Finished Jobs
    29. Example: Setting TTL for Job Cleanup

  19. Working with CronJobs

    1. 1. Creating CronJob
    2. Example: Creating a CronJob
    3. 2. Listing CronJobs
    4. Example: List CronJobs in a Namespace
    5. Example: List All CronJobs Across All Namespaces
    6. 3. Describing CronJob Details
    7. Example: CronJob Spec
    8. 4. Setting Schedule Expression
    9. Example: Cron Schedule Expression
    10. 5. Understanding Cron Syntax
    11. Example: Cron Schedule Expression
    12. 6. Configuring Concurrency Policy
    13. Example: Setting Concurrency Policy in CronJob
    14. 7. Setting Successful Jobs History
    15. Example: Setting Successful Jobs History Limit
    16. 8. Setting Failed Jobs History
    17. Example: Setting Failed Jobs History Limit
    18. 9. Suspending CronJobs
    19. Example: Suspending a CronJob
    20. 10. Setting Starting Deadline
    21. Example: CronJob with startingDeadlineSeconds
    22. 11. Creating Manual Job Run
    23. Example: Creating a CronJob
    24. Example: Manually Triggering a CronJob
    25. 12. Deleting CronJobs
    26. Example: Delete a CronJob

  20. Creating and Managing Services

    1. 1. Creating ClusterIP Service
    2. Example: Creating a ClusterIP Service
    3. 2. Creating NodePort Service
    4. Example: NodePort Service YAML
    5. 3. Creating LoadBalancer Service
    6. Example: Creating a LoadBalancer Service
    7. 4. Creating Headless Service
    8. Example: Headless Service Definition
    9. 5. Listing Services
    10. Example: List all services with extended output
    11. Example: List services in a specific namespace
    12. 6. Describing Service Details
    13. Example: Describe Service Details
    14. Service Types Overview
    15. 7. Exposing Deployments
    16. Example: Exposing a Deployment with NodePort
    17. Example: Exposing a Deployment with LoadBalancer
    18. 8. Configuring Service Selectors
    19. Example: Basic Service with Label Selector
    20. Example: Service with MatchExpressions
    21. 9. Configuring Session Affinity
    22. Example: Service with ClientIP Session Affinity
    23. 10. Setting External IPs
    24. Example: Service with External IPs
    25. 11. Using ExternalName Services
    26. Example: Define an ExternalName Service
    27. 12. Viewing Service Endpoints
    28. Example: Get Endpoints for a Service

  21. Working with Ingress

    1. 1. Creating Ingress Resource
    2. Example: Basic Ingress Configuration
    3. 2. Listing Ingress Resources
    4. Example: Listing Ingress in a specific namespace
    5. 3. Describing Ingress Details
    6. Example: Describe Ingress Details
    7. 4. Configuring Ingress Rules
    8. Example: Basic Ingress Rule
    9. Example: Multiple Paths with Different Services
    10. 5. Setting Default Backend
    11. Example: Default Backend Configuration
    12. 6. Using Path Types
    13. Example: Ingress with Path Types
    14. 7. Configuring TLS Termination
    15. Example: Ingress with TLS
    16. 8. Using Ingress Annotations
    17. Example: Using Ingress Annotations
    18. 9. Setting Ingress Class
    19. Example: Define Ingress with Class
    20. 10. Installing Ingress Controllers
    21. Example: Deploying NGINX Ingress Controller
    22. 11. Troubleshooting Ingress
    23. Common Ingress Issues and Solutions
    24. Example: Check Ingress Controller Logs
    25. Example: Verify Service and Pod Status

  22. Working with Gateway API

    1. 1. Installing Gateway API CRDs
    2. Example: Install Gateway API CRDs using kubectl
    3. 2. Creating GatewayClass Resource
    4. Example: Creating a GatewayClass Resource
    5. 3. Creating Gateway Resource
    6. Example: Basic Gateway Resource
    7. 4. Configuring HTTPRoute
    8. Example: Basic HTTPRoute Configuration
    9. Example: Route with Multiple Rules
    10. 5. Using TCPRoute
    11. Example: Basic TCPRoute Configuration
    12. 6. Using TLSRoute
    13. Example: TLSRoute with Certificate Reference
    14. 7. Setting Gateway Listeners
    15. Example: Basic HTTP Listener
    16. Example: HTTPS Listener with TLS
    17. 8. Configuring Backend References
    18. Example: Basic Backend Reference
    19. Example: Weighted Backend Routing
    20. 9. Using Request Matching
    21. Example: Matching a GET request with specific headers
    22. 10. Implementing Traffic Splitting
    23. Example: Basic Traffic Splitting Rule
    24. Key Concepts
    25. 11. Understanding Gateway API vs Ingress
    26. Gateway API vs Ingress

  23. Managing ConfigMaps

    1. 1. Creating ConfigMap from Literal
    2. Example: Creating ConfigMap from Literal Values
    3. 2. Creating ConfigMap from File
    4. Example: Creating ConfigMap from File
    5. 3. Creating ConfigMap from Env File
    6. Example: Creating ConfigMap from env file
    7. 4. Creating ConfigMap from YAML
    8. Example: Creating a ConfigMap from YAML
    9. 5. Listing ConfigMaps
    10. Example: Listing ConfigMaps in Current Namespace
    11. Example: Listing All ConfigMaps Across Namespaces
    12. 6. Describing ConfigMap Details
    13. Example: Describe ConfigMap using kubectl
    14. Example: Get ConfigMap details in YAML format
    15. 7. Using ConfigMap as Environment Variables
    16. Example: Using ConfigMap as Environment Variables
    17. Example: Using Specific ConfigMap Key as Environment Variable
    18. 8. Mounting ConfigMap as Volume
    19. Example: Mounting ConfigMap as Volume
    20. 9. Using Specific ConfigMap Keys
    21. Example: Mounting Specific Keys
    22. Example: Using Keys in Environment Variables
    23. 10. Updating ConfigMaps
    24. Example: Patching a ConfigMap
    25. Example: Editing a ConfigMap
    26. 11. Using Immutable ConfigMaps
    27. Example: Creating an Immutable ConfigMap
    28. 12. Deleting ConfigMaps
    29. Example: Delete a ConfigMap
    30. Example: Delete a ConfigMap in a specific namespace

  24. Managing Secrets

    1. 1. Creating Generic Secret
    2. Example: Creating a Generic Secret from Literal Values
    3. Example: Creating a Secret from Environment File
    4. 2. Creating TLS Secret
    5. Example: Create TLS Secret from Files
    6. Example: Create TLS Secret from Literal Values
    7. 3. Creating Docker Registry Secret
    8. Example: Creating a Docker Registry Secret from .docker/config.json
    9. 4. Encoding Secret Data
    10. Example: Encoding a Secret Value
    11. 5. Listing Secrets
    12. Example: Listing Secrets in a Namespace
    13. 6. Describing Secret Details
    14. Example: Describe Secret Details
    15. 7. Using Secrets as Environment Variables
    16. Example: Injecting All Secret Values as Environment Variables
    17. Example: Using Specific Secret Key as Environment Variable
    18. 8. Mounting Secrets as Volumes
    19. Example: Mounting a Secret as a Volume
    20. 9. Using imagePullSecrets
    21. Example: Define imagePullSecrets in a Pod
    22. Example: Define imagePullSecrets in a Deployment
    23. 10. Updating Secrets
    24. Example: Updating a Secret with kubectl
    25. Example: Updating a Secret with kubectl edit
    26. 11. Understanding Secret Types
    27. 12. Deleting Secrets
    28. Example: Delete a Secret
    29. Example: Delete a Secret with Cascading

  25. Working with Service Accounts

    1. 1. Creating Service Account
    2. Example: Creating a Service Account
    3. 2. Listing Service Accounts
    4. Example: List Service Accounts in a Namespace
    5. Example: List All Service Accounts Across Namespaces
    6. 3. Describing Service Account Details
    7. Example: Describe Service Account
    8. Example: Get Service Account as YAML
    9. 4. Using Service Account in Pod
    10. Example: Using Service Account in Pod
    11. 5. Understanding Default Service Account
    12. Example: Pod using default service account
    13. 6. Configuring Automount Token
    14. Example: Disabling Automount Token
    15. 7. Creating Service Account Token
    16. Example: Create ServiceAccount with Token
    17. Example: Create Token Secret for ServiceAccount
    18. 8. Using Bound Service Account Tokens
    19. Example: Creating a Bound Token
    20. Example: Using Bound Token in Pod
    21. 9. Configuring Token Expiration
    22. Example: Setting Token Expiration in ServiceAccount
    23. 10. Deleting Service Accounts
    24. Example: Delete Service Account

  26. Working with Volumes

    1. 1. Using emptyDir Volumes
    2. Example: Mounting an emptyDir Volume
    3. 2. Using hostPath Volumes
    4. Example: Mounting hostPath volume in Pod
    5. 3. Configuring PersistentVolumes
    6. Example: Creating a PersistentVolume
    7. 4. Creating PersistentVolumeClaims
    8. Example: Creating a PVC
    9. 5. Binding PVC to PV
    10. Example: Binding PVC to PV
    11. 6. Listing PersistentVolumes
    12. Example: Listing PersistentVolumes using kubectl
    13. Example: Listing PersistentVolumes with detailed output
    14. Example: Listing PersistentVolumes in JSON format
    15. 7. Listing PersistentVolumeClaims
    16. Example: List PVCs in a Namespace
    17. Example: List All PVCs in the Cluster
    18. Example: Describe a Specific PVC
    19. 8. Understanding Access Modes
    20. 9. Setting Reclaim Policies
    21. Example: Setting Reclaim Policy to Retain
    22. 10. Using Dynamic Provisioning
    23. Example: Creating a PersistentVolumeClaim with Dynamic Provisioning
    24. 11. Expanding PersistentVolumes
    25. Example: Expanding a PersistentVolume
    26. Key Points
    27. 12. Deleting PersistentVolumeClaims
    28. Example: Delete PVC using kubectl

  27. Configuring Storage Classes

    1. 1. Creating StorageClass
    2. Example: Creating a StorageClass for AWS EBS
    3. 2. Listing StorageClasses
    4. Example: List StorageClasses using kubectl
    5. Example: List StorageClasses with detailed output
    6. 3. Setting Default StorageClass
    7. Example: Setting Default StorageClass
    8. 4. Configuring Provisioners
    9. Example: Configuring AWS EBS Provisioner
    10. Example: Configuring GCP PD Provisioner
    11. 5. Setting Volume Binding Mode
    12. Example: Setting Volume Binding Mode in StorageClass
    13. 6. Configuring Reclaim Policy
    14. Example: Setting Reclaim Policy in StorageClass
    15. 7. Enabling Volume Expansion
    16. Example: Enabling Volume Expansion in StorageClass
    17. 8. Using Storage Parameters
    18. Example: Storage Class with Parameters
    19. 9. Configuring Mount Options
    20. Example: Setting Mount Options in StorageClass
    21. 10. Deleting StorageClasses
    22. Example: Delete StorageClass

  28. Working with Volume Snapshots

    1. 1. Installing VolumeSnapshot CRDs
    2. Example: Apply VolumeSnapshot CRDs
    3. 2. Creating VolumeSnapshotClass
    4. Example: VolumeSnapshotClass YAML Definition
    5. 3. Creating VolumeSnapshot
    6. Example: Creating a VolumeSnapshot from a PVC
    7. 4. Listing VolumeSnapshots
    8. Example: Listing VolumeSnapshots using kubectl
    9. Example: Listing VolumeSnapshots with details using kubectl
    10. Example: Listing VolumeSnapshots in a specific namespace
    11. 5. Describing VolumeSnapshot Details
    12. Example: Describe VolumeSnapshot in YAML
    13. Example: Describe VolumeSnapshot using kubectl
    14. 6. Restoring PVC from Snapshot
    15. Example: Restoring PVC from VolumeSnapshot
    16. 7. Configuring Snapshot Deletion Policy
    17. Example: Snapshot Deletion Policy Configuration
    18. 8. Using Snapshot with CSI Drivers
    19. Example: Create Volume from Snapshot
    20. 9. Deleting VolumeSnapshots
    21. Example: Delete VolumeSnapshot using kubectl
    22. 10. Troubleshooting Snapshot Issues
    23. Example: Describe VolumeSnapshot for diagnostics

  29. Working with Projected Volumes

    1. 1. Understanding Projected Volumes
    2. Example: Projecting a ConfigMap and Secret
    3. 2. Projecting Secrets
    4. Example: Projecting a Secret
    5. 3. Projecting ConfigMaps
    6. Example: Projecting a ConfigMap
    7. 4. Projecting Service Account Tokens
    8. Example: Configuring Service Account Token Projection
    9. 5. Projecting Downward API
    10. Example: Projecting Pod Name
    11. Example: Projecting Pod Namespace
    12. Example: Projecting Pod Labels
    13. 6. Configuring Token Expiration
    14. Example: Using Token Expiration in a Projected Volume
    15. 7. Setting Token Audience
    16. Example: Configuring Token Audience in ServiceAccount
    17. 8. Combining Multiple Sources
    18. Example: ConfigMap and Secret in One Projected Volume
    19. 9. Using Projected Volumes for mTLS
    20. Example: mTLS Configuration
    21. 10. Debugging Projected Volumes
    22. Example: Check Volume Mounts in Pod

  30. Configuring Resource Management

    1. 1. Setting CPU Requests
    2. Example: Setting CPU Requests in a Pod
    3. 2. Setting Memory Requests
    4. Example: Setting Memory Requests in a Pod Spec
    5. 3. Setting CPU Limits
    6. Example: CPU Limits in Pod Spec
    7. 4. Setting Memory Limits
    8. Example: Setting Memory Limits in a Pod
    9. 5. Understanding Resource Units
    10. Example: Resource Requests and Limits in Pod Spec
    11. 6. Configuring LimitRange
    12. Example: LimitRange Configuration
    13. 7. Setting ResourceQuota
    14. Example: ResourceQuota YAML Definition
    15. 8. Viewing Resource Usage
    16. Example: Resource Usage Output
    17. Key Points
    18. 9. Understanding QoS Classes
    19. Example: QoS Class Determination
    20. QoS Class Summary
    21. 10. Setting Priority Classes
    22. Example: Creating a PriorityClass
    23. 11. Configuring Pod Disruption Budgets
    24. Example: Basic PDB Configuration
    25. Example: PDB with maxUnavailable
    26. Key Points
    27. 12. Using Extended Resources
    28. Example: Requesting Extended Resource in Pod Spec

  31. Implementing Horizontal Pod Autoscaling

    1. 1. Creating HPA
    2. Example: HPA Configuration
    3. 2. Creating HPA from YAML
    4. Example: HPA Configuration
    5. 3. Listing HPAs
    6. Example: Listing HPAs in a Namespace
    7. 4. Describing HPA Details
    8. Example: Describe HPA in YAML
    9. HPA Configuration Summary
    10. 5. Setting Min and Max Replicas
    11. Example: HPA with min and max replicas
    12. 6. Using CPU-Based Scaling
    13. Example: HPA Configuration Using CPU Utilization
    14. 7. Using Memory-Based Scaling
    15. Example: Memory-based HPA Configuration
    16. 8. Using Custom Metrics
    17. Example: External Custom Metric
    18. Example: Object Metric
    19. 9. Configuring Scale Up Behavior
    20. Example: HPA Configuration
    21. 10. Configuring Scale Down Behavior
    22. Example: Configuring Scale Down Behavior in HPA
    23. 11. Setting Stabilization Window
    24. Example: Configuring Stabilization Window in HPA
    25. 12. Troubleshooting HPA
    26. Common HPA Issues and Solutions
    27. Example: Debugging HPA Metrics

  32. Implementing Vertical Pod Autoscaling

    1. 1. Installing VPA Components
    2. Example: Install VPA using Helm
    3. 2. Creating VPA Resource
    4. Example: Basic VPA Configuration
    5. 3. Setting Update Mode
    6. Example: Setting Update Mode in VPA Spec
    7. 4. Configuring Resource Policy
    8. Example: VPA Resource Policy Configuration
    9. 5. Setting Min Allowed Resources
    10. Example: VPA Configuration with Min Allowed Resources
    11. 6. Setting Max Allowed Resources
    12. Example: Configuring Max Allowed Resources in VPA
    13. 7. Viewing VPA Recommendations
    14. Example: Viewing VPA Recommendations via kubectl
    15. Example: Viewing VPA Status
    16. 8. Understanding VPA Components
    17. Example: VPA Controller Configuration
    18. 9. Using VPA with HPA
    19. Vertical Pod Autoscaler (VPA) vs Horizontal Pod Autoscaler (HPA)
    20. Example: VPA Configuration
    21. Example: HPA Configuration
    22. Best Practices for Using VPA with HPA
    23. 10. Deleting VPA Resources
    24. Example: Deleting a VPA Resource

  33. Working with Taints and Tolerations

    1. 1. Adding Taints to Nodes
    2. Example: Add a taint to a node
    3. Example: Add a taint with multiple keys and values
    4. 2. Removing Taints from Nodes
    5. Example: Remove taint from node
    6. 3. Listing Node Taints
    7. Example: List taints on a node
    8. 4. Understanding Taint Effects
    9. Example: Applying Taints with Different Effects
    10. 5. Configuring Tolerations
    11. Example: Pod with Tolerations
    12. 6. Using Toleration Operators
    13. Example: Using Equal Operator
    14. Example: Using Exists Operator
    15. 7. Setting Toleration Seconds
    16. Example: Setting Toleration Seconds on a Pod
    17. 8. Understanding Default Tolerations
    18. Example: Default toleration in a Pod spec
    19. 9. Using Taints for Dedicated Nodes
    20. Example: Taint a Node for Dedicated Use
    21. Example: Pod with Tolerations for Dedicated Node
    22. 10. Combining Taints with Node Affinity
    23. Example: Taints and Affinity Together

  34. Configuring Node Affinity

    1. 1. Using requiredDuringScheduling
    2. Example: Node Affinity with requiredDuringScheduling
    3. 2. Using preferredDuringScheduling
    4. Example: Preferred Node Affinity
    5. 3. Configuring Node Selectors
    6. Example: Setting Node Selector
    7. 4. Using matchExpressions
    8. Example: matchExpressions with In operator
    9. Example: matchExpressions with Gt operator
    10. 5. Setting Node Label Selectors
    11. Example: Setting Node Label Selectors
    12. 6. Combining Multiple Affinity Rules
    13. Example: Combining nodeSelector and nodeAffinity
    14. Example: Using podAntiAffinity to avoid duplicate pods
    15. 7. Using Node Anti-Affinity
    16. Example: Anti-Affinity with Label Match
    17. Example: Hard Anti-Affinity Using Node Selector
    18. 8. Setting Weight Priority
    19. Example: Node Affinity with Weight
    20. 9. Using IgnoredDuringExecution
    21. Example: Node Affinity with IgnoredDuringExecution
    22. 10. Troubleshooting Affinity Rules
    23. Example: Debugging Node Affinity Issues

  35. Configuring Pod Affinity and Anti-Affinity

    1. 1. Using Pod Affinity
    2. Example: Affinity Rule for Same Node
    3. Example: Soft Affinity with Preferred Rules
    4. 2. Using Pod Anti-Affinity
    5. Example: Pod Anti-Affinity with topologyKey
    6. Example: Preferred Anti-Affinity
    7. 3. Setting Topology Keys
    8. Example: Pod Affinity with Topology Key
    9. Example: Pod Anti-Affinity with Topology Key
    10. 4. Using requiredDuringScheduling
    11. Example: Pod Affinity with requiredDuringScheduling
    12. Example: Pod Anti-Affinity with requiredDuringScheduling
    13. 5. Using preferredDuringScheduling
    14. Example: Preferred Affinity Rule
    15. 6. Configuring Label Selectors
    16. Example: Using matchLabels
    17. Example: Using matchExpressions
    18. 7. Setting Namespace Selectors
    19. Example: Using namespaceSelector in Pod Affinity
    20. 8. Understanding Topology Domains
    21. 9. Combining Affinity Rules
    22. Example: Combining Node and Pod Affinity
    23. 10. Troubleshooting Pod Placement
    24. Steps to Troubleshoot Pod Placement Issues
    25. Example: Describe Pod to Find Scheduling Issues

  36. Configuring Pod Topology Spread Constraints

    1. 1. Understanding Topology Spread
    2. Example: Basic Topology Spread Constraint
    3. 2. Setting Maximum Skew
    4. Example: Setting maxSkew to 2
    5. 3. Configuring When Unsatisfiable
    6. Example: Setting
    7. 4. Using Topology Keys
    8. Example: Pod with Topology Key
    9. 5. Configuring Label Selectors
    10. Example: Using labelSelector in Pod Topology Spread Constraints
    11. 6. Setting Match Label Keys
    12. Example: Match Label Keys Configuration
    13. 7. Using Min Domains
    14. Example: Setting minDomains in Pod Spec
    15. 8. Combining Multiple Constraints
    16. Example: Pod Topology Spread Constraints with Multiple Selectors
    17. Best Practices for Combining Constraints
    18. 9. Understanding Node Inclusion Policy
    19. Example: NodeInclusionPolicy in Pod Spec
    20. 10. Troubleshooting Spread Issues
    21. Example: Misconfigured Topology Spread Constraint
    22. Workflow: Diagnose Spread Constraint Issues

  37. Configuring Network Policies

    1. 1. Creating NetworkPolicy
    2. Example: Basic Ingress Policy
    3. Example: Egress Policy
    4. 2. Defining Pod Selectors
    5. Example: Using matchLabels
    6. Example: Using matchExpressions
    7. 3. Configuring Ingress Rules
    8. Example: Basic Ingress Rule
    9. 4. Configuring Egress Rules
    10. Example: Allow Egress to DNS Server
    11. Example: Allow Egress to Specific Namespace
    12. 5. Using Namespace Selectors
    13. Example: Allow traffic from production namespace to default namespace
    14. 6. Allowing Specific Ports
    15. Example: Allow HTTP traffic on port 80
    16. Example: Allow traffic on a port range
    17. 7. Using IP Blocks
    18. Example: Allow traffic from a specific IP block
    19. Example: Allow traffic from a specific IP block but exclude a subnet
    20. 8. Implementing Default Deny All
    21. Example: Default Deny All Policy
    22. 9. Testing Network Policies
    23. Example: Testing Network Policy with curl
    24. Testing Steps Summary
    25. 10. Listing Network Policies
    26. Example: Listing Network Policies in a Namespace

  38. Configuring RBAC Authorization

    1. 1. Creating ServiceAccount
    2. Example: Create a ServiceAccount
    3. 2. Creating Role
    4. Example: Define a Role to Read Pods
    5. 3. Creating ClusterRole
    6. Example: Define a ClusterRole with Pod Access
    7. 4. Creating RoleBinding
    8. Example: Creating a RoleBinding
    9. 5. Creating ClusterRoleBinding
    10. Example: Creating a ClusterRoleBinding
    11. 6. Viewing Permissions
    12. Example: Check permissions for a user
    13. 7. Testing User Permissions
    14. Example: Check Permission for Pod List
    15. Example: Simulate User Access
    16. 8. Using Default ClusterRoles
    17. Example: Assigning ClusterRole to a User
    18. 9. Configuring API Groups
    19. Example: Define a Role with API Group Permissions
    20. 10. Setting Resource Names
    21. Example: Defining a Role with Resource Names
    22. Example: Binding a Role to a User
    23. 11. Understanding Verbs
    24. 12. Aggregating ClusterRoles
    25. Example: Aggregating ClusterRoles

  39. Managing Security Context

    1. 1. Setting runAsUser
    2. Example: Setting runAsUser in Pod Spec
    3. 2. Setting runAsGroup
    4. Example: Setting runAsGroup in Pod Spec
    5. 3. Setting fsGroup
    6. Example: Setting fsGroup in Pod Spec
    7. 4. Running as Non-Root
    8. Example: Setting Non-Root User
    9. 5. Setting Read-Only Root Filesystem
    10. Example: Pod with Read-Only Root Filesystem
    11. 6. Adding Capabilities
    12. Example: Adding Capabilities to a Pod
    13. 7. Dropping Capabilities
    14. Example: Dropping Capabilities in Pod Spec
    15. 8. Using Privileged Mode
    16. Example: Setting privileged mode in a Pod
    17. 9. Setting SELinux Options
    18. Example: Setting SELinux Context for a Pod
    19. 10. Configuring Seccomp Profiles
    20. Example: Applying a Seccomp Profile
    21. 11. Setting AppArmor Profiles
    22. Example: AppArmor Profile in Pod Spec

  40. Implementing Pod Security Admission

    1. 1. Understanding Pod Security Standards
    2. Example: Applying Pod Security Standard
    3. 2. Using Pod Security Admission
    4. Example: Enforcing Pod Security Admission
    5. 3. Configuring Namespace Labels
    6. Example: Applying Pod Security Labels to a Namespace
    7. 4. Setting Enforce Level
    8. Example: Enforce Level Configuration
    9. 5. Setting Audit Level
    10. Example: Setting Audit Level in Kubernetes
    11. 6. Setting Warn Level
    12. Example: Setting Warn Level in a Namespace
    13. 7. Controlling Host Namespaces
    14. Example: Setting hostNetwork to true in a Pod
    15. 8. Restricting Volume Types
    16. Example: Restricting Volume Types in Pod Security Admission
    17. 9. Configuring Allowed Capabilities
    18. Example: Pod with Allowed Capabilities
    19. 10. Migrating from PodSecurityPolicy
    20. Example: Migrating PSP to Pod Security Admission
    21. Migration Steps

  41. Working with Admission Controllers

    1. 1. Understanding Admission Controllers
    2. Example: Admission Controller Configuration
    3. 2. Enabling Admission Plugins
    4. Example: Enabling a Custom Admission Plugin via Webhook
    5. 3. Using ValidatingWebhookConfiguration
    6. Example: ValidatingWebhookConfiguration YAML
    7. 4. Using MutatingWebhookConfiguration
    8. Example: MutatingWebhookConfiguration YAML
    9. 5. Implementing OPA Gatekeeper
    10. Example: Basic OPA Gatekeeper Policy
    11. Example: Constraint Template
    12. Key Concepts
    13. 6. Creating Constraint Templates
    14. Example: Basic Constraint Template
    15. 7. Creating Constraints
    16. Example: Constraint Template
    17. Example: Constraint Instance
    18. 8. Implementing Image Policy
    19. Example: Image Policy Configuration
    20. Example: Image Policy Enforcement
    21. 9. Using LimitRanger
    22. Example: LimitRanger Configuration
    23. Example: Pod with LimitRanger Enforced Limits
    24. 10. Testing Admission Webhooks
    25. Example: Testing Admission Webhook with curl
    26. Example: Validating Admission Response
    27. Testing Workflow
    28. 11. Troubleshooting Admission Failures
    29. Example: Checking Admission Controller Logs
    30. Workflow: Debugging Admission Controller Issues

  42. Managing Cluster Certificates

    1. 1. Viewing Certificate Expiration
    2. Example: Check Certificate Expiry via kubectl
    3. Example: Using OpenSSL to Parse Cert
    4. 2. Renewing Certificates
    5. Example: Renewing kube-apiserver Certificate
    6. 3. Generating New Certificates
    7. Example: Using kubectl to generate a new certificate
    8. 4. Configuring Certificate Rotation
    9. Example: Enabling Certificate Rotation for Kubelet
    10. Example: API Server Certificate Rotation Configuration
    11. 5. Installing cert-manager
    12. Example: Installing cert-manager via Helm
    13. Example: Installing cert-manager via kubectl
    14. Installation Steps
    15. 6. Creating Certificate Resources
    16. Example: Creating a Certificate Resource
    17. 7. Configuring Issuers
    18. Example: ACME Issuer Configuration
    19. Example: Self-Signed Issuer
    20. Example: ClusterIssuer for Wildcard Certificates
    21. 8. Using ACME Protocol
    22. Example: ACME Configuration in Kubernetes
    23. 9. Troubleshooting Certificate Issues
    24. Example: Renewing a Certificate
    25. Certificate Troubleshooting Workflow
    26. 10. Updating kubeconfig After Renewal
    27. Example: Update kubeconfig with new certificate

  43. Managing External Secrets

    1. 1. Installing External Secrets Operator
    2. Example: Install External Secrets Operator using Helm
    3. Installation Steps
    4. 2. Creating SecretStore
    5. Example: AWS SecretStore
    6. Example: Vault SecretStore
    7. 3. Creating ClusterSecretStore
    8. Example: Creating a ClusterSecretStore for AWS Secrets Manager
    9. 4. Creating ExternalSecret Resource
    10. Example: Creating an ExternalSecret
    11. 5. Syncing Secrets Automatically
    12. Example: ExternalSecret Configuration
    13. 6. Using Secret Templates
    14. Example: Define a Secret Template
    15. Example: Using Template in Deployment
    16. 7. Configuring Secret Keys
    17. Example: Secret Key Configuration
    18. Example: Using Secret Keys in Pod
    19. 8. Rotating Secrets
    20. Example: Manual Rotation of Opaque Secret
    21. Example: Using Sealed Secrets for Rotation
    22. 9. Configuring Data Transformation
    23. Example: Transforming Secret Data
    24. 10. Troubleshooting Secret Sync
    25. Example: Check Secret Status
    26. Example: Describe Pod Volume Mount

  44. Managing Custom Resource Definitions

    1. 1. Creating CRD
    2. Example: Basic CRD Definition
    3. 2. Listing CRDs
    4. Example: List CRDs using kubectl
    5. Example: List CRDs with detailed output
    6. Example: List CRDs in JSON format
    7. 3. Describing CRD Details
    8. Example: CRD Definition
    9. 4. Defining CRD Versions
    10. Example: Defining a CRD with multiple versions
    11. 5. Setting CRD Scope
    12. Example: Namespaced CRD
    13. Example: Cluster-scoped CRD
    14. 6. Configuring Validation Schema
    15. Example: Validating Custom Resource Fields
    16. 7. Using CRD Subresources
    17. Example: Status Subresource
    18. Example: Scale Subresource
    19. 8. Setting Printer Columns
    20. Example: Printer Column Definition
    21. 9. Creating Custom Resources
    22. Example: Define a Custom Resource Definition (CRD)
    23. Example: Create a Custom Resource using the CRD
    24. 10. Understanding CRD Finalizers
    25. Example: CRD with Finalizer
    26. 11. Deleting CRDs
    27. Example: Delete CRD using kubectl
    28. 2. Listing CRDs
    29. Example: List CRDs using kubectl
    30. Example: List CRDs with detailed output
    31. Example: List CRDs in JSON format
    32. 3. Describing CRD Details
    33. Example: CRD Definition
    34. 4. Defining CRD Versions
    35. Example: Defining a CRD with multiple versions
    36. 5. Setting CRD Scope
    37. Example: Namespaced CRD
    38. Example: Cluster-scoped CRD
    39. 6. Configuring Validation Schema
    40. Example: Validating Custom Resource Fields
    41. 7. Using CRD Subresources
    42. Example: Status Subresource
    43. Example: Scale Subresource
    44. 8. Setting Printer Columns
    45. Example: Printer Column Definition
    46. 9. Creating Custom Resources
    47. Example: Define a Custom Resource Definition (CRD)
    48. Example: Create a Custom Resource using the CRD
    49. 10. Understanding CRD Finalizers
    50. Example: CRD with Finalizer
    51. 11. Deleting CRDs
    52. Example: Delete CRD using kubectl

  45. Working with Operators

    1. 1. Understanding Operator Pattern
    2. Example: Operator Deployment
    3. Operator vs Helm Chart
    4. 2. Installing Operators
    5. Example: Installing via OperatorHub
    6. 3. Using Operator Lifecycle Manager
    7. Example: Install OLM via YAML
    8. Key Concepts
    9. 4. Creating Custom Resources
    10. Example: Creating a Custom Resource
    11. 5. Viewing Operator Logs
    12. Example: Viewing Operator Logs
    13. Example: Streaming Operator Logs
    14. 6. Updating Custom Resources
    15. Example: Update Custom Resource Spec
    16. 7. Monitoring Operator Status
    17. Example: Operator Status Output
    18. 8. Troubleshooting Operators
    19. Common Troubleshooting Steps
    20. Operator vs Helm Chart Debugging
    21. 9. Upgrading Operators
    22. 10. Deleting Operators
    23. Example: Delete Operator Deployment
    24. Example: Delete CRDs

  46. Working with Helm Charts

    1. 1. Installing Helm CLI
    2. Example: Verify Installation
    3. 2. Adding Helm Repositories
    4. Repository Management
    5. 3. Updating Helm Repositories
    6. Example: Update all repositories
    7. Example: Update specific repository
    8. 4. Searching Helm Charts
    9. Example: Search for charts in a repository
    10. Example: Search for charts in Artifact Hub
    11. 5. Installing Helm Chart
    12. Example: Installing a Helm Chart
    13. 6. Upgrading Helm Release
    14. Example: Upgrading a Release
    15. Example: Upgrading with Values File
    16. Example: Upgrading with Set Values
    17. 7. Rolling Back Release
    18. Example: Rolling Back to Previous Revision
    19. Example: Rolling Back to Last Successful Revision
    20. 8. Listing Helm Releases
    21. Example: Listing Helm Releases in a Specific Namespace
    22. Example: Listing All Helm Releases Across Namespaces
    23. 9. Viewing Release Values
    24. Example: Fetching Release Values
    25. Example: Fetching All Values Including Defaults
    26. 10. Uninstalling Helm Release
    27. Example: Uninstalling a Helm Release
    28. Example: Dry Run Uninstall
    29. 11. Creating Custom Chart
    30. Example: Basic Chart Structure
    31. Example: Deployment Template
    32. Example: Values Override
    33. 12. Using Helm Templating
    34. Example: Using .Values in a Deployment
    35. Example: Conditional Template with .Values

  47. Working with Kustomize

    1. 1. Understanding Kustomize Concepts
    2. Example: Basic Kustomization Structure
    3. Key Benefits of Kustomize
    4. 2. Creating kustomization.yaml
    5. Example: Basic kustomization.yaml
    6. 3. Applying Kustomize Manifests
    7. Example: Applying Kustomize Manifests
    8. 4. Using Strategic Merge Patches
    9. Example: Applying Strategic Merge Patch
    10. 5. Using JSON Patches
    11. Example: Applying a JSON Patch
    12. Example: JSON Patch Content
    13. 6. Configuring Name Prefixes
    14. Example: Applying Name Prefix
    15. 7. Generating ConfigMaps
    16. Example: Creating a ConfigMap from literals
    17. Example: Creating a ConfigMap from a file
    18. 8. Generating Secrets
    19. Example: Creating a Secret from Literal Values
    20. Example: Creating a Secret from a File
    21. 9. Setting Common Labels
    22. Example: Setting Common Labels in Kustomize
    23. 10. Using Overlays
    24. Example: Basic Overlay Structure
    25. Example: Overlay kustomization.yaml
    26. Example: Patch Deployment
    27. 11. Configuring Image Tags
    28. Example: Override image tag in Kustomization
    29. 12. Building Kustomize Output
    30. Example: Basic kustomize build command
    31. Example: Building with output to file
    32. Example: Building with Helm support

  48. Implementing GitOps

    1. 1. Understanding GitOps Principles
    2. Example: GitOps Workflow
    3. Core GitOps Concepts
    4. 2. Installing Flux
    5. Example: Install Flux CLI
    6. Installation Steps
    7. 3. Installing ArgoCD
    8. Example: Install ArgoCD using Helm
    9. Installation Steps
    10. 4. Creating GitRepository Source
    11. Example: GitRepository with branch reference
    12. Example: GitRepository with tag reference
    13. 5. Creating Kustomization
    14. Example: Creating a Kustomization resource
    15. 6. Creating ArgoCD Application
    16. Example: ArgoCD Application Manifest
    17. 7. Configuring Auto-Sync
    18. Example: Auto-Sync Configuration
    19. 8. Managing Helm Releases
    20. Example: Installing a Helm Release
    21. Example: Upgrading a Helm Release
    22. Example: Rolling Back a Helm Release
    23. 9. Monitoring Sync Status
    24. Example: Check Application Sync Status
    25. 10. Troubleshooting Sync Issues
    26. Example: Debugging a failed sync

  49. Using Advanced kubectl Techniques

    1. 1. Using JSONPath Queries
    2. Example: Filtering Pods by Label
    3. Example: Getting Container Image Names
    4. 2. Using Custom Columns
    5. Example: Custom Columns with kubectl get
    6. 3. Formatting Output
    7. Example: Custom Columns Output
    8. Example: Filtering Pods by Node Name
    9. 5. Using Label Selectors
    10. Example: Label Selectors in kubectl
    11. 6. Performing Bulk Operations
    12. Example: Apply Configuration to Multiple Resources
    13. Example: Update Labels on Multiple Pods
    14. Example: Delete Multiple Resources by Label
    15. 7. Using kubectl patch
    16. Example: Patching a Deployment's Replicas
    17. Example: Patching with Strategic Merge
    18. 8. Creating Resources from stdin
    19. Example: Creating a Pod from stdin
    20. 9. Using kubectl diff
    21. Example: Comparing a Deployment Configuration
    22. 10. Using kubectl wait
    23. Example: Waiting for a Pod to be Ready
    24. Example: Waiting for a Deployment to be Available
    25. 11. Creating Dry Runs
    26. Example: Dry Run Deployment
    27. 12. Using kubectl explain
    28. Example: Explaining a Pod resource
    29. Example: Explaining a specific field in a Pod

  50. Debugging and Troubleshooting Pods

    1. 1. Viewing Pod Logs
    2. Example: Retrieve logs from a pod
    3. Example: Follow logs in real-time
    4. Example: Retrieve logs from a specific container
    5. 2. Following Log Streams
    6. Example: Follow logs from a pod
    7. Example: Follow logs from a specific container in a pod
    8. 3. Viewing Previous Container Logs
    9. Example: View Previous Logs
    10. 4. Executing Commands in Pods
    11. Example: Running a command in a pod
    12. Example: Running a command in a specific container
    13. 5. Creating Debug Containers
    14. Example: Creating a Debug Container
    15. 6. Using Ephemeral Containers
    16. Example: Adding an Ephemeral Container
    17. 7. Viewing Pod Events
    18. Example: Get Pod Events
    19. Example: Get Events for Specific Pod
    20. 8. Using Port Forwarding
    21. Example: Forwarding a Local Port to a Pod
    22. 9. Inspecting API Objects
    23. Example: Inspecting a Pod's Details
    24. Example: Getting Raw YAML of a Pod
    25. 10. Checking Cluster Events
    26. Example: Viewing Events for a Specific Pod
    27. Example: Inspect Pod Network Interfaces
    28. Workflow: Diagnose Pod Network Issues
    29. 12. Using Node Debug Pods
    30. Example: Create debug pod on node

  51. Analyzing Resource Usage

    1. 1. Installing Metrics Server
    2. Example: Install Metrics Server via kubectl
    3. 2. Viewing Node Metrics
    4. Example: Fetching Node Metrics via kubectl
    5. 3. Viewing Pod Metrics
    6. Example: Get Pod CPU and Memory Usage
    7. Example: Get All Pods' Metrics
    8. 4. Viewing Container Metrics
    9. Example: Fetching Pod Metrics
    10. 5. Sorting by Resource Usage
    11. Example: Sort pods by CPU usage
    12. Example: Sort nodes by memory usage
    13. 6. Using Prometheus
    14. Example: Querying CPU Usage
    15. Example: Setting up a Prometheus Rule
    16. 7. Creating Grafana Dashboards
    17. Example: Basic Kubernetes Metrics Dashboard
    18. 8. Setting Up Alerts
    19. Example: Prometheus Rule for CPU Usage
    20. Example: Alertmanager Configuration
    21. Alerting Workflow Overview
    22. 9. Using kube-state-metrics
    23. Example: Collecting Pod Metrics
    24. 10. Monitoring Control Plane
    25. Example: Collecting API Server Metrics

  52. Implementing Centralized Logging

    1. 1. Installing Fluentd DaemonSet
    2. Example: Deploying Fluentd DaemonSet
    3. 2. Configuring Elasticsearch
    4. Example: Elasticsearch Configuration in Kubernetes
    5. 3. Configuring Kibana
    6. Example: Basic Kibana Configuration
    7. Key Configuration Points
    8. 4. Setting Up Log Forwarding
    9. Example: Forwarding Logs to Elasticsearch
    10. Key Considerations
    11. 5. Using Loki for Logging
    12. Example: Deploying Loki with Grafana
    13. Example: Configuring Fluentd to Send Logs to Loki
    14. Key Features of Loki
    15. 6. Installing Promtail
    16. Example: Installing Promtail via Helm
    17. Example: Installing Promtail via Manifests
    18. 7. Querying Logs with LogQL
    19. Example: Basic Log Query
    20. Example: Aggregating Logs by Level
    21. Example: Rate of Log Entries
    22. 8. Setting Log Retention Policies
    23. Example: Configuring Log Retention in Fluentd
    24. 9. Configuring Structured Logging
    25. Example: Structured Logging Configuration
    26. 10. Troubleshooting Logging Stack
    27. Common Logging Issues and Solutions
    28. Example: Check Logging Agent Status
    29. Example: Validate Log Format in Agent Config

  53. Implementing Service Mesh

    1. 1. Understanding Service Mesh Concepts
    2. Example: Service Mesh Architecture
    3. Core Components
    4. Service Mesh vs API Gateway
    5. 2. Installing Istio
    6. Example: Install Istio using istioctl
    7. Installation Steps
    8. 3. Installing Linkerd
    9. Example: Install Linkerd CLI
    10. Installation Summary
    11. 4. Enabling Sidecar Injection
    12. Example: Enable Sidecar Injection on a Namespace
    13. Example: Enable Sidecar Injection on a Pod
    14. 5. Configuring Traffic Management
    15. Example: Route traffic based on headers
    16. Example: Set timeout and retries
    17. 6. Implementing mTLS
    18. Example: mTLS Configuration in Istio
    19. 7. Configuring Request Routing
    20. Example: Basic Route Configuration
    21. Example: Route with Header Matching
    22. 8. Implementing Circuit Breaking
    23. Example: Configuring Circuit Breaker in Istio
    24. 9. Observing Service Mesh
    25. Example: Grafana Dashboard Setup
    26. Example: Jaeger Trace Sampling
    27. Key Observability Concepts
    28. 10. Troubleshooting Service Mesh
    29. Common Service Mesh Troubleshooting Steps
    30. Example: Inspecting Proxy Logs
    31. Service Mesh Troubleshooting Checklist

  54. Managing Multi-Tenancy

    1. 1. Creating Tenant Namespaces
    2. Example: Create a Tenant Namespace
    3. 2. Setting Resource Quotas
    4. Example: Resource Quota Definition
    5. 3. Configuring Limit Ranges
    6. Example: Define LimitRange for Namespace
    7. 4. Implementing RBAC Isolation
    8. Example: Creating a Role for Pod Access
    9. Example: Binding Role to User
    10. 5. Using Network Policies
    11. Example: Basic Network Policy
    12. Example: Deny All Ingress
    13. Example: Allow From Specific Namespace
    14. 6. Configuring Pod Security
    15. Example: Applying Pod Security Standard
    16. Example: Enforcing Restricted Policy
    17. 7. Using Virtual Clusters
    18. Example: Creating a Virtual Cluster with Namespaces
    19. Virtual Clusters vs. Dedicated Clusters
    20. 8. Implementing Hierarchical Namespaces
    21. Example: Creating a Hierarchical Namespace
    22. Best Practices for Hierarchical Namespaces
    23. 9. Monitoring Tenant Resources
    24. Example: Querying CPU Usage for a Namespace
    25. Key Metrics to Monitor
    26. 10. Implementing Cost Allocation
    27. Example: Labeling Namespaces for Cost Tracking
    28. Example: Setting Resource Limits
    29. Example: Configuring Horizontal Pod Autoscaler

  55. Implementing Backup and Disaster Recovery

    1. 1. Installing Velero
    2. Example: Installing Velero CLI
    3. Example: Installing Velero Server with AWS
    4. 2. Configuring Backup Storage
    5. Example: Configuring a Persistent Volume for Backup Storage
    6. Example: Using Cloud Storage with AWS S3
    7. 3. Creating Backups
    8. Example: Backup etcd
    9. Example: Backup ConfigMaps and Secrets
    10. 4. Scheduling Backups
    11. Example: Cron Schedule
    12. Example: Backup Template
    13. 5. Restoring from Backup
    14. Example: Restore a Kubernetes StatefulSet from Backup
    15. Workflow: Restore Process Steps
    16. Summary of Restoration Considerations
    17. 6. Backing Up Specific Namespaces
    18. Example: Backup a Specific Namespace
    19. Example: Restore a Specific Namespace
    20. 7. Excluding Resources
    21. Example: Excluding a Deployment from Backup
    22. 8. Using Backup Hooks
    23. Example: Using Backup Hooks in a CronJob
    24. 9. Migrating Across Clusters
    25. Example: Migrating a Deployment
    26. 10. Monitoring Backup Status
    27. Example: Check Backup Status
    28. Example: Check Restore Status
    29. 11. Troubleshooting Backups
    30. Common Backup Issues and Resolution Steps
    31. Example: Debugging Backup Job Logs

  56. Managing Cluster Upgrades

    1. 1. Planning Cluster Upgrades
    2. Upgrade Planning Steps
    3. Upgrade Strategies
    4. 2. Upgrading Control Plane
    5. Example: Upgrade Control Plane Components
    6. 3. Upgrading Worker Nodes
    7. Example: Drain and Upgrade Worker Node
    8. 4. Upgrading kubectl
    9. Example: Install kubectl v1.29
    10. 5. Upgrading Managed Clusters
    11. Example: GKE Cluster Upgrade
    12. Upgrade Considerations
    13. 6. Using Blue-Green Strategy
    14. Example: Deploying with Blue-Green Strategy
    15. Deployment Workflow
    16. Benefits of Blue-Green Deployment
    17. 7. Performing Rolling Upgrades
    18. Example: Performing a Rolling Upgrade
    19. 8. Testing Before Upgrade
    20. Example: Pre-upgrade testing with kubectl
    21. Pre-Upgrade Checklist
    22. 9. Rolling Back Upgrades
    23. Example: Rolling Back a Deployment
    24. 10. Monitoring Upgrade Progress
    25. Example: Monitoring etcd leader changes

  57. Optimizing Cluster Performance

    1. 1. Optimizing API Server
    2. Example: API Server Configuration
    3. 2. Tuning etcd Performance
    4. Example: etcd Configuration in kube-apiserver
    5. 3. Optimizing Node Resources
    6. Example: Resource Requests and Limits in a Pod Spec
    7. 4. Configuring DNS Optimization
    8. Example: Configuring CoreDNS with Custom Upstream Servers
    9. Example: Enabling Cache in CoreDNS
    10. 5. Using Node Local DNS Cache
    11. Example: Enabling NodeLocal DNS in Helm Values
    12. 6. Reducing Image Pull Time
    13. Example: Optimizing Image Pull Policy
    14. Example: Using Image Pull Secrets
    15. 7. Optimizing Pod Startup
    16. Example: Pod with optimized startup settings
    17. 8. Using Pod Priority
    18. Example: Setting Pod Priority
    19. 9. Right-Sizing Resources
    20. Example: Right-sizing a Deployment
    21. 10. Monitoring Cluster Performance
    22. Example: Querying CPU Usage with Prometheus
    23. Example: Monitoring Memory Usage in Grafana

  58. Implementing Security Best Practices

    1. 1. Implementing Network Segmentation
    2. Example: Network Policy for Frontend to Database
    3. 2. Enabling RBAC Authorization
    4. Example: Role for Pod Access
    5. 3. Using Pod Security Standards
    6. Example: Enforce Restricted Standard
    7. 4. Scanning Container Images
    8. Example: Trivy Scan Output
    9. 5. Enabling Secrets Encryption
    10. Example: Secrets Encryption Config
    11. 6. Using Admission Controllers
    12. Example: Admission Controller Configuration
    13. 7. Enabling Audit Logging
    14. Example: Audit Log Configuration
    15. 8. Implementing mTLS
    16. Example: mTLS Configuration in Istio
    17. 9. Rotating Certificates
    18. Example: Renewing Certificates
    19. 10. Running CIS Benchmarks
    20. Example: CIS Benchmark Scan
    21. 11. Using Runtime Security
    22. Example: Falco Rule for Suspicious Activity
    23. 12. Implementing Supply Chain Security
    24. Example: Supply Chain Policy Enforcement

  59. Implementing Cost Optimization

    1. 1. Right-Sizing Resources
    2. Example: Resource Configuration
    3. Right-Sizing Best Practices
    4. 2. Using Spot Instances
    5. Example: Spot Instance Configuration
    6. 3. Implementing Cluster Autoscaler
    7. Example: Cluster Autoscaler Deployment Configuration
    8. Example: Node Group Tagging for Discovery
    9. 4. Configuring Pod Disruption Budgets
    10. Example: Basic PDB Configuration
    11. Key Points
    12. 5. Using Vertical Pod Autoscaler
    13. Example: VPA Configuration
    14. Example: Resource Recommendation
    15. 6. Scheduling Workloads Efficiently
    16. Example: Node Affinity Configuration
    17. Example: Tolerations for Master Node
    18. Key Concepts
    19. 7. Implementing Resource Quotas
    20. Example: Setting Resource Limits in a Pod
    21. Example: Creating a ResourceQuota in a Namespace
    22. 8. Using Storage Classes Wisely
    23. Example: Creating a StorageClass with optimized settings
    24. 9. Cleaning Up Unused Resources
    25. Example: Delete Unused Deployment
    26. Example: Delete Unused Service
    27. 10. Monitoring Cost Allocation
    28. Example: Resource Quotas
    29. Key Points

  60. Working with Multi-Cluster Federation

    1. 1. Understanding Multi-Cluster Patterns
    2. Example: Active-Active Cluster Setup
    3. Key Considerations
    4. 2. Installing KubeFed
    5. Example: Install KubeFed using kubectl
    6. Installation Steps
    7. 3. Creating Federated Clusters
    8. Example: Federated Cluster Configuration
    9. 4. Deploying Federated Resources
    10. Example: Deploying a Federated Deployment
    11. 5. Configuring Placement Policies
    12. Example: Placement Policy with Cluster Affinity
    13. 6. Implementing Cross-Cluster Discovery
    14. Example: Federated Service Configuration
    15. 7. Using Multi-Cluster Ingress
    16. Example: Basic Multi-Cluster Ingress Configuration
    17. Key Considerations for Multi-Cluster Ingress
    18. 8. Configuring Context Switching
    19. Example: Define a new context in kubeconfig
    20. Example: Switch context using kubectl
    21. Example: View current context
    22. 9. Implementing Disaster Recovery
    23. Example: Backup etcd
    24. Example: Restore etcd from Snapshot
    25. Disaster Recovery Steps
    26. 10. Monitoring Federated Clusters
    27. Example: Setting up Prometheus Federation for Multi-Cluster Metrics
    28. Monitoring Tools Comparison