Join today
Write your awesome label here.
Docker and Kubernetes: The Complete Course
Go from containerization beginner to confident practitioner with hands-on training in Docker and Kubernetes. Learn to build optimized images, orchestrate complex deployments, and manage cloud-native applications with the industry's most in-demand tools.
🏅 Included in the PRO membership!
Write your awesome label here.
302 Lectures
Comprehensive Knowledge
33 Hours
Video Duration
130+ Labs
Focus on Practice
Course Certificate
Validate Your Learning
Course Contents
01
Course Introduction
Welcome and Motivation!
How to Make Best Use of this Course
Aligning Expectations
Let's Stay Connected!
Course Resources
02
[Docker] Introduction to Containers
This section provides a comprehensive introduction to Docker fundamentals, establishing the foundational knowledge needed to understand container technology. The learning objectives include understanding why containers are valuable by comparing deployment approaches with and without them, exploring the key benefits of containerization such as simplified setup, portability, consistent environments, isolation, and resource efficiency, comparing containers with virtual machines to understand when to use each technology, and examining the core Docker components (Docker client, Docker host, Docker daemon, image cache, and image registries) and how they interact during common operations like running containers and pushing images.
Section Introduction
Why Using Containers?
Containers and Virtual Machines (VMs)
Docker Architecture and Components
03
[Docker] Installing Docker and Necessary Tools
This section covers the foundational setup required to work with Docker across multiple operating systems and introduces essential supporting tools. The learning objectives include installing Docker Desktop on Windows (with WSL2 integration), macOS, and Linux through the Docker Engine, understanding Docker configuration and post-installation setup to run containers without elevated privileges, exploring alternative cloud-based Docker environments, and installing complementary development tools including Node.js, Postman API client, and Visual Studio Code IDE. By the end of this section, learners will have a fully configured Docker environment and all necessary tools to follow along with subsequent course lectures and develop applications.
Section Introduction
[MacOS Users] Installing Docker on MacOS
[Linux Users] Installing Docker on Linux
[Linux Users] Running Docker without Sudo
[Windows Users] Note about enabling the WSL Windows feature
[Windows Users] Installing Windows Subsystem for Linux (WSL)
[Windows Users] Windows Subsystem for Linux Features
[Windows Users] Installing Docker in Windows
[Windows Users] Using Docker in Windows Subsystem for Linux (WSL)
Exploring Play with Docker
Installing NodeJS
Installing Postman
Installing Visual Studio Code
04
[Docker] Running Containers with Docker
This section provides a comprehensive introduction to Docker fundamentals, focusing on practical hands-on experience with containers and the Docker CLI. The learning objectives include understanding how to run containers, managing the container lifecycle through different states, mastering essential Docker CLI commands for managing both images and containers, exploring logging and shell access within containers, and introducing the Docker build process with Dockerfiles. Students will learn to work with both short-lived and long-lived containers, handle port mapping, use filtering and bulk operations, and create custom Docker images, building a foundation for effective Docker container management and development.
Section Introduction
Hands-On: Running Your First Container
The Container Lifecycle
Hands-On: Working with the Docker CLI - Part 1
Hands-On: Working with the Docker CLI - Part 2
Hands-On: Getting Help in the Docker CLI
05
[Docker] Project - Customizing NGINX Containers
This section introduces Docker fundamentals through a hands-on project focused on customizing an NGINX server container. The learning objectives include understanding how to pull and run Docker images with specific version tags, executing commands interactively within a running container, and modifying container files. By completing this foundational project, learners gain practical experience with essential Docker workflows while also learning about key limitations of manual container modifications, including lack of scalability, non-persistent storage, and the need for better configuration management approaches to handle real-world scenarios.
Project Overview
Running NGINX Containers
Modifying the Contents of Our NGINX Container
Project Conclusion
06
[Docker] Introduction to Docker Images
This section focuses on mastering Docker images and container registries, which are foundational concepts for working effectively with Docker. The learning objectives include understanding what Docker images are and their purpose, exploring container registries and their various implementations, learning to browse and use Docker Hub, managing images with the CLI, creating and building Dockerfiles, and clarifying the critical distinction between images and containers. Through practical demonstrations and deep dives into Docker's architecture, this section equips learners with the knowledge to build custom images, publish them to registries, and manage containers efficiently throughout their development and deployment workflows.
Section Introduction
What Are Docker Images?
Container Registries
Hands-On: Introduction to DockerHub
Hands-On: Logging Into DockerHub in the Docker CLI
Hands-On: Managing Images with the Docker CLI
Introduction to Dockerfiles
Hands-On: Creating Our First Dockerfile for Nginx
Hands-On: Copying Local Files Into Our Image
Hands-On: Images vs. Containers
07
[Docker] Project - Containerize an Express App
This section focuses on the fundamentals of Docker containerization through a practical hands-on approach. The learning objectives include understanding Docker image creation using Dockerfiles, building containers from images, and mastering the complete lifecycle of containerizing applications. Using a Node.js Express backend API as the example application, students learn core Docker concepts such as setting working directories, installing dependencies, copying source code, and running applications within containers. The section emphasizes the importance of understanding container management operations including starting, stopping, pausing, and removing containers, while exploring how containerization provides consistent environments for application deployment.
Project Introduction
Create a Hello World Express App
Save and Return Users in Memory
Test Users App
Dockerize Our Express App
Explore Interacting with Containers + Project Cleanup
08
[Docker] Images Deep Dive
This section covers advanced Docker image building techniques and optimization strategies. The section's learning objectives include understanding Docker's layered architecture and how each instruction creates a layer, mastering build contexts and .dockerignore files to optimize what gets sent to the Docker daemon, managing environment variables through multiple methods (Dockerfile ENV, CLI flags, and .env files), differentiating between CMD and ENTRYPOINT instructions and how they work together, implementing multi-stage builds for efficient image construction, leveraging distroless images for enhanced security, and applying various optimization strategies to reduce both image size and build time through base image selection, instruction ordering, and installing only necessary runtime dependencies.
Section Introduction
Bundled Code from "Containerize Express App" Section
Hands-On: Docker’s Layered Architecture
Hands-On: Build Contexts
Hands-On: Skipping files with Dockerignore
Hands-On: Introduction to Environment Variables
Hands-On: Setting Environment Variables via the CLI
Hands-On: Setting Environment Variables via Files
Hands-On: CMD vs. ENTRYPOINT
Introduction to Distroless Images
Hands-On: Motivation to Multistage Dockerfiles
Hands-On: Multistage Dockerfiles and Distroless Images
Hands-On: Adding Typescript to Our Express App
Hands-On: Update Dockerfile to Transpile Typescript Code
Hands-On: Optimizing Images - The Role of Base Images
Hands-On: Optimizing Images - The Role of Instruction Order
Hands-On: Optimizing Images - The Role of Dependencies
Hands-On: Revisiting and Optimizing Our Typescript Dockerfile
09
[Docker] Project - Containerize React App
This section covers containerizing a React application using Docker with a focus on multistage builds. Students will learn how to create a React application using Create React App, understand the development vs. production build process, write a multistage Dockerfile that builds the React application and serves it through Nginx, and explore real-world deployment strategies like zero-downtime deployments. The primary learning objectives are to master multistage Docker builds for complex applications, understand how static files are served in production, and see how Docker can manage both the build and runtime stages of an application lifecycle.
Project Introduction
IMPORTANT! What to do if you face an error with create-react-app
Initializing the React App
Build and Serve the React App
Create a Dockerfile for Our React App - Part 1
Create a Dockerfile for Our React App - Part 2
10
[Docker] Volumes and Data Persistence
This section focuses on Docker volumes and data persistence, covering the fundamental concepts and practical applications of volume management. Learners will understand the limitations of container-level data storage, explore different volume types (bind mounts and named volumes), and gain hands-on experience managing volumes through the Docker CLI. The section emphasizes how volumes enable data persistence beyond container lifecycles, facilitate data sharing between containers, and support scalable application architectures. By the end, students will be able to differentiate between volume types and effectively manage data in containerized environments.
Section Introduction
Bundled Code from "Containerize React App" Section
Hands-On: Why Do We Need Volumes?
Introduction to Volumes
IMPORTANT! Hot Reloading Fix
Hands-On: Bind Mounts
Hands-On: Named Volumes
Hands-On: Managing Volumes with the CLI
11
[Docker] Advanced Topics - Resource Management, Restart Policies, and Networking
This section covers advanced Docker topics focused on resource management, container lifecycle policies, and networking infrastructure. The learning objectives include understanding how to set CPU and memory limits to protect the Docker host from runaway containers, implementing restart policies to ensure container availability, and mastering Docker networking through both default and user-defined networks. Students will learn practical techniques for constraining container resources, managing container failures, and enabling inter-container communication while maintaining security and isolation.
Section Introduction
Hands-On: Setting CPU Limits for Containers
Hands-On: Setting Memory Limits for Containers
Hands-On: Restart Policies
Introduction to Networking in Docker
Hands-On: The Default Bridge Network
Hands-On: User-Defined Networks
Hands-On: The Host Network
12
[Docker] Project - Code and Deploy a Key-Value App with Data Persistence
This section covers building a complete key-value REST API using Docker, implementing multi-container architecture with Express.js for the backend and MongoDB for data persistence. Students learn essential Docker concepts including containers, volumes for data persistence, user-defined networks for inter-container communication, and shell scripts for container management. The project progresses from database setup with authentication to implementing a full CRUD API with proper error handling, environment configuration, and testing data persistence and cleanup procedures. Key learning objectives include understanding containerization best practices, managing microservices, configuring databases in containers, setting up networked services, and building production-ready Node.js applications within Docker environments.
Project Introduction
Running a MongoDB Server
Adding Root Credentials to MongoDB
Adding Credentials for the Key-Value Database
Defining Ports, Volumes, and Networks
Improving the Structure of Our Utility Scripts
Setting Up the Express App
Dockerizing the Express App
Create Scripts to Initialize the Backend Container
Adding Hot Reloading with Nodemon
Defining the API Routes
Creating and Getting Key-Value Pairs
Updating and Deleting Key-Value Pairs
Testing the Application and Final Cleanup
13
[Docker] Docker Compose
focuses on Docker Compose, a powerful tool for managing multi-container applications in a declarative way. The learning objectives include understanding the benefits and use cases of Docker Compose, learning how to define and manage services, volumes, networks, and environment variables through YAML configuration files, managing the application lifecycle with start/stop/delete operations, handling service dependencies to ensure correct startup order, configuring hot reloading for development workflows, and mastering the Docker Compose CLI for efficient project management. By the end of this section, learners will be able to orchestrate complex multi-container applications with a single configuration file and manage them effectively across development, testing, and production environments.
Section Introduction
Docker Compose Overview
Docker-Compose vs. Compose CLI Commands
Hands-On: Run MongoDB with Docker Compose
Hands-On: Environment Variables in Docker Compose
Hands-On: Bind Mounts in Docker Compose
Hands-On: Volumes and Networks in Docker Compose
Hands-On: Adding a Backend Service to Our Docker Compose File
Hands-On: Service Dependencies in Docker Compose
Hands-On: Hot Reloading and Watching for Changes
Hands-On: Docker Compose CLI
Hands-On: Getting Help with Docker Compose CLI
14
[Docker] Project - Code and Deploy a Notes App with Docker Compose
This section builds a complete Notes Rest API microservices architecture using Docker and Docker Compose. The section covers containerizing two independent services (Notebooks and Notes) with a shared database layer, configuring an NGINX reverse proxy to route requests, and implementing full CRUD REST APIs for both services. Students learn advanced Docker concepts including multistage builds, service networking, Docker Compose file inclusion, and handling service resilience and validation when services may be temporarily unavailable. The project demonstrates production-ready patterns for orchestrating multiple containerized services, managing their dependencies, and ensuring proper communication between services.
Project Introduction
Setup NPM Projects
Dockerize the Notebooks Backend
Setup Docker Compose for Notebooks Services
Setup Docker Compose for Notes Services
Use Multistage Builds for Our Images
Merging Multiple Projects in Docker Compose
Implement the NGINX Reverse Proxy
Establish the Connections between Services
Setup Models and Routes for the Notebooks Service
Implement Routes to Create and Retrieve Notebooks
Implement Routes to Update and Delete Notebooks
Code Refactorings
Implement Routes and Business Logic in the Notes Backend
Storing Notebook IDs in the Notes Service - Part 1
Storing Notebook IDs in the Notes Service - Part 2
Storing Notebook IDs in the Notes Service - Part 3
15
[Kubernetes] 10.000-Foot Overview
This section provides a comprehensive introduction to Kubernetes fundamentals, covering what Kubernetes is, why it's essential for production workloads, and how it works. The learning objectives include understanding container orchestration and Kubernetes advantages over Docker (including container scheduling, load balancing, auto-scaling, self-healing, service discovery, and configuration management); understanding Kubernetes architecture with its control plane (containing API server, scheduler, controller manager, etcd store, and cloud controller manager) and data plane with worker nodes; understanding core components like kubelet, container runtime, and kube-proxy; and learning to use kubectl CLI for interacting with Kubernetes clusters through imperative and declarative resource management.
Section Introduction
Why Use Kubernetes?
What Is Kubernetes?
Kubernetes Architecture
The Control Plane
The Data Plane
The kubectl CLI
16
[Kubernetes] Installing Tools
This section covers the essential setup and installation phase for Kubernetes development environments across different operating systems. The learning objectives include: installing kubectl (the Kubernetes command-line interface) on macOS, Linux, and Windows systems; understanding kubectl versioning and compatibility requirements with Kubernetes server versions; installing and configuring Minikube to create local Kubernetes clusters; and verifying proper cluster connectivity through kubectl commands. These foundational tools and configurations enable learners to interact with Kubernetes clusters locally and understand the relationship between kubectl client versions and Kubernetes server versions.
[MacOS Users] Installing Kubectl in MacOS
[MacOS Users] Installing Minikube in MacOS
[Linux Users] Installing Kubectl in Linux
[Linux Users] Installing Minikube in Linux
[Windows Users] Installing Kubectl in Windows Subsystem for Linux (WSL)
[Windows Users] Installing Minikube in Windows Subsystem for Linux (WSL)
17
[Kubernetes] Running Containers in Kubernetes
This section introduces the fundamental concepts of Kubernetes pods, their lifecycle, and pod management using kubectl. The learning objectives covered include understanding pods as the smallest deployable units in Kubernetes, managing pod creation and deletion with kubectl commands, examining pod lifecycle phases (pending, running, succeeded, failed), implementing pod restart policies and exponential backoff mechanisms, exposing pods via services for stable DNS resolution and communication, and building the complete workflow from Dockerfile to running pods in a Kubernetes cluster.
Section Introduction
Introduction to Pods
The Pod Lifecycle
Hands-On: Creating Pods with Kubectl
Hands-On: Managing Pods with Kubectl
Hands-On: Exposing Pods via Services
Hands-On: Color API - Implement v1.0.0
Hands-On: From Dockerfiles to Pods
18
[Kubernetes] Object Management and YAML Manifests
This section introduces Kubernetes object management with YAML configuration files. The learning objectives covered include: understanding three approaches to managing Kubernetes objects (imperative with kubectl commands, imperative with configuration files, and declarative with configuration files), exploring the structure and syntax of Kubernetes manifest files, writing YAML configuration for common objects like pods and services, understanding the differences between imperative and declarative management approaches including their respective advantages and limitations, using kubectl create, replace, apply, and delete commands, leveraging the dry-run flag to generate configuration files, migrating from imperative to declarative management, and organizing multiple objects within single manifest files or directories.
Section Introduction
Object Management in Kubernetes
Kubernetes Manifest Files
Hands-On: Working with Imperative Commands - Part 1
Hands-On: Working with Imperative Commands - Part 2
Hands-On: Generating Kubernetes Manifests with kubectl
Hands-On: Shortcomings of Imperative Commands with Configuration Files
Hands-On: Declarative Object Management in Kubernetes
Hands-On: Migrating from Imperative to Declarative Object Management
Hands-On: Creating Multiple Kubernetes Manifests in the Same YAML File
19
[Kubernetes] ReplicaSets and Deployments
This section covers the fundamental concepts of managing pods at scale in Kubernetes through replica sets and deployments. Learning objectives include understanding how replica sets maintain a desired number of pod replicas, identifying their limitations in managing pod updates, exploring how deployments extend replica sets with rolling update capabilities, debugging failed rollouts, and scaling deployments dynamically.
Section Introduction
What Are ReplicaSets?
Hands-On: Creating and Managing ReplicaSets
Hands-On: Shortcomings of ReplicaSets - Updating Pods
Hands-On: Shortcomings of ReplicaSets - Managing Existing Pods
Introduction to Deployments
Hands-On: Creating and Managing Deployments
Hands-On: Updating the Pod Template
Hands-On: Understanding Rollouts
Hands-On: Scaling Deployments with Kubectl
Hands-On: Troubleshooting Failed Rollouts
20
[Kubernetes] Services Deep Dive
This section on Kubernetes Services covers the fundamentals of service types and their role in facilitating cluster communication. Students will learn about four service types: Cluster IP (for internal cluster communication with stable IP addresses), Node Port (for external access via node IP and port), External Name (for mapping to external DNS names), and Load Balancer (deferred to later sections). The core learning objectives include understanding how services abstract pod IP addresses to provide stable endpoints, how Cluster IP services perform load balancing across pods, how Node Port services expose applications externally, and how External Name services enable communication with external services. Practical demonstrations show service creation, traffic routing, DNS resolution via CoreDNS, and the difference between accessing services internally versus externally.
Section Introduction
Overview of Services
Hands-On: Color API - Implement v1.1.0: Add hostname information
Hands-On: Traffic Generator - Implement v1.0.0
Hands-On: Deploy the Color API and Traffic Generator
Hands-On: Working with ClusterIP Services
Hands-On: Working with NodePort Services
Hands-On: NodePort Services in Linux
Hands-On: Working with ExternalName Services
21
[Kubernetes] Resource Management
This section covers essential resource management concepts in Kubernetes. Learning objectives include understanding labels and selectors for identifying and grouping resources across the cluster, annotations for adding metadata and configuration information to objects, namespaces for isolating resources and enabling multi-environment deployments with cross-namespace service communication, resource quotas and resource requests/limits for managing CPU and memory allocation to prevent resource starvation, and health probes (startup, liveness, and readiness) for maintaining container health and lifecycle management.
Section Introduction
Labels and Selectors
Hands-On: Labels and Selectors in Kubectl
Hands-On: Selecting Objects with MatchLabels and MatchExpressions
Annotations
Introduction to Namespaces
Hands-On: Creating and Managing Namespaces
Hands-On: Cross-Namespace Service Communication
Introduction to Resource Quotas, Requests, and Limits
Hands-On: Working with Resource Quotas
Hands-On: Setting Resource Requests and Limits
Hands-On: Rollouts, Resource Requests and Limits
Introduction to Startup, Liveness, and Readiness Probes
Hands-On: Color API - Implement v1.2.0: Add health endpoints
Hands-On: Startup Probes in Details
Hands-On: Color API - Implement v1.2.1: Add dedicated startup endpoint
Hands-On: Liveness Probes in Details
Hands-On: Readiness Probes in Details
22
[Kubernetes] Storage and Persistence
This section covers essential concepts for managing persistent storage in Kubernetes. The learning objectives include understanding how persistent storage is handled in Kubernetes at a high level, working with emptyDir volumes for temporary ephemeral storage within pods, exploring persistent volumes (PVs) and persistent volume claims (PVCs) with local and dynamically provisioned storage, understanding the configuration and lifecycle of PVs and PVCs, and learning about StatefulSets and headless services for managing stateful applications with stable pod identities and DNS entries.
Section Introduction
Introduction to Volumes
EmptyDir and Local Volumes
Hands-On: Working with EmptyDir Ephemeral Storage
Introduction to Persistent Volume Claims
Hands-On: Creating Persistent Volumes and Persistent Volume Claims
Hands-On: Mounting Volumes in Pods and Containers
Hands-On: Deleting Persistent Volumes and Persistent Volume Claims
Hands-On: Dynamically Provisioning Persistent Volumes
Introduction to StatefulSets
Hands-On: Working with StatefulSets - Creating Persistent Volumes
Hands-On: Working with StatefulSets - Creating the StatefulSet
Quick Note: Delete StatefulSets, PVCs, and PVs from Previous Lectures
Hands-On: StatefulSets with Dynamically Provisioned Persistent Volumes
Hands-On: Headless Services
23
[Kubernetes] Configuration Management
This section covers configuration management in Kubernetes through ConfigMaps and Secrets as native mechanisms for decoupling configuration and sensitive data from application code. Learning objectives include understanding ConfigMaps for non-sensitive data storage in key-value pairs with a one megabyte size limit, passing ConfigMap data via environment variables and volume mounts, creating and managing ConfigMaps and Secrets in Kubernetes, recognizing that Secrets store data in base64 encoding (not encryption) and require RBAC protections, and mounting both ConfigMaps and Secrets as containers files or environment variables while understanding namespace requirements and access control implications.
Section Introduction
Introduction to ConfigMaps
Hands-On: Color API - Implement v1.3.0: Receive color information externally
Hands-On: Passing Information from ConfigMaps via Environment Variables
Hands-On: Mounting ConfigMaps as Volumes
Introduction to Secrets
Hands-On: Passing Information from Secrets via Environment Variables
Hands-On: Mounting Secrets as Volumes
24
[Kubernetes] Project - Deploying a MongoDB Database
This section covers implementing persistent data storage for a Kubernetes-based color API application using MongoDB. The learning objectives include deploying a MongoDB StatefulSet with a headless service and persistent volume claims to enable dynamic volume provisioning, creating configuration maps and secrets for database initialization and secure credential management, refactoring a Node.js Express color API application to accept database connection parameters via environment variables and establish connections using Mongoose, implementing database persistence and CRUD operations for color data, and deploying the updated color API alongside MongoDB to demonstrate stateful and stateless application patterns in Kubernetes.
Project Overview
Create Database Credentials
Create Headless Service and ConfigMaps
Create the StatefulSet
Deploy and Validate the StatefulSet
Test Scaling the StatefulSet
Color API - Implement v2.0.0: Refactoring the Code
Color API - Implement v2.0.0: Persist Data in the MongoDB Database
Color API - Implement v2.0.0: Implement Database Connection Logic
Color API - Implement v2.0.0: Implement Routes for Business Logic
Deploy the New Color API Version
Project Wrap-Up and Clean-Up
25
[Kubernetes] Security Fundamentals
This section covers Kubernetes security fundamentals, focusing on practical security mechanisms and controls for protecting clusters and applications. The learning objectives include understanding role-based access control (RBAC) with roles, cluster roles, and their bindings to users, groups, and service accounts; exploring the Kubernetes API structure and API groups for defining access control rules; creating and managing service accounts for pod-to-API authentication; regulating network traffic through network policies for ingress and egress control; and enforcing pod security standards to ensure workloads meet security best practices.
Section Introduction
Introduction to Security in Kubernetes
Role-Based Access Control (RBAC)
Hands-On: Overview of Minikube’s Roles and ClusterRoles
The Kubernetes API
Hands-On: Exploring API Resources
Hands-On: Creating Two Users: Alice and Bob
Hands-On: Configure Access Credentials for Alice and Bob
Hands-On: Setup Permissions to Read Pods
Hands-On: Use ClusterRoles for Cluster-Wide Permissions
Hands-On: Exploring Subresources and Permissions
Introduction to Service Accounts
Hands-On: Default Service Accounts
Hands-On: Creating Our Own Service Accounts
Hands-On: RBAC - Clean-Up
Introduction to Network Policies
Calico vs. Native Kubernetes Network Policies
Hands-On: Deny All Ingress Traffic
Hands-On: Allow Traffic Between Specific Pods
Hands-On: Exploring Pod Selectors
Hands-On: Combining Pod Selectors
Hands-On: Handling Egress Traffic
Hands-On: Network Policies and Namespaces
Introduction to Pod Security Standards (PSS)
Hands-On: Working with Pod Security Standards
Hands-On: Exploring the Pod Security Standards Documentation
26
[Kubernetes] Kustomize
This section covers Kustomize, a declarative tool for customizing and managing Kubernetes resources in YAML format. Key learning objectives include understanding Kustomize fundamentals and its role in managing configurations across environments; leveraging bases and overlays to define shared resource configurations and apply environment-specific customizations; applying common transformations such as namespace assignment, name prefixes/suffixes, labels, and annotations; generating ConfigMaps and Secrets dynamically from files and environment variables; and mastering patching techniques including inline patches, strategic merge patches, and JSON patches to achieve fine-grained resource customization without duplicating manifests.
Section Introduction
Introduction to Kustomize
Update: Deprecation of commonLabels
Hands-On: Our First Kustomize Project
Bases and Overlays
Hands-On: Creating the Dev and Prod Overlays
Transformations
Hands-On: Working with Transformations
Hands-On: Generating ConfigMaps
Hands-On: Generating Secrets
Hands-On: Introduction to Patching
Hands-On: Working with Strategic Merge Patches
Hands-On: Working with JSON Patches
27
[Kubernetes] Project - Deploying Our Color API to Google Kubernetes Engine (GKE)
This section provides a comprehensive guide to deploying a production-ready color API application across two environments (dev and prod) in Google Kubernetes Engine. Learners will understand how to set up a Google Cloud account with free trial credits, provision and configure an autopilot GKE cluster, deploy stateful applications using MongoDB with persistent storage, integrate managed cloud services with Kubernetes, implement network policies for secure communication, configure ingress and TLS certificates, and leverage Kustomize for managing environment-specific configurations across multiple Kubernetes namespaces.
Project Overview
Creating a Google Cloud Platform (GCP) Account
Overview of Project Costs
Overview of GCP’s UI Console
Installing the gcloud CLI
Exploring the GKE UI Console
Create a Google Kubernetes Engine (GKE) Cluster
Connecting kubectl and GKE
Deploying an Nginx-based Website
Exploring Storage Classes in GKE
Exploring API Resources in GKE
Create Database Credentials for MongoDB
Deploy the MongoDB StatefulSet - Part 1
Deploy the MongoDB StatefulSet - Part 2
Deploy the MongoDB StatefulSet - Part 3
Deploy the Color API Application
Create a LoadBalancer Service for External Access
Color API - Implement v2.1.0-dev: Expose Prometheus Metrics
Customize Database Deployments
Deploy Prod Overlay and Customize Dev Color API Image
Deny All Ingress and Allow Traffic Between Color API and MongoDB
Allow External Traffic into Color API Pods
Register Our Website Domain
Allocate Static IPs for Ingress
Create Ingress Objects
Create Managed TLS Certificates
Test Ingress Traffic from the Web Towards the Color API Pods
Project Cleanup
28
[Kubernetes] Conclusion
Conclusion and Wrap-Up
Certificate of Completion
Frequently asked questions
Who is this course designed for?
This course is designed for multiple technical roles:
What prior knowledge do I need before taking this course?
You should have familiarity with any programming language to understand the application examples used throughout the course. Basic comfort with running commands in the terminal and using the command line is highly recommended, as you will be working extensively with Docker and kubectl command-line tools.
No prior knowledge of Docker or Kubernetes is required. The course starts from the fundamentals and builds your knowledge progressively through hands-on exercises.
What software or hardware do I need for the hands-on labs?
Will I incur costs from the cloud provider while taking this course?
The majority of the course can be completed entirely for free using local tools like Docker Desktop and Minikube.
Optional Cloud Costs: The final project section deploys an application to Google Kubernetes Engine (GKE), which may incur minimal costs. However, Google Cloud offers a generous free tier with $300 in credits for new users, which is more than sufficient to complete the project. If you carefully follow the cleanup instructions provided at the end of the project, your costs should remain within the free tier.
The course includes detailed guidance on creating your Google Cloud account and activating free credits, understanding cost estimates before deploying resources, and properly cleaning up resources to avoid unexpected charges.
Optional Cloud Costs: The final project section deploys an application to Google Kubernetes Engine (GKE), which may incur minimal costs. However, Google Cloud offers a generous free tier with $300 in credits for new users, which is more than sufficient to complete the project. If you carefully follow the cleanup instructions provided at the end of the project, your costs should remain within the free tier.
The course includes detailed guidance on creating your Google Cloud account and activating free credits, understanding cost estimates before deploying resources, and properly cleaning up resources to avoid unexpected charges.
Does this course cover Helm for Kubernetes package management?
This course focuses on core Kubernetes concepts and native tools to build a solid foundation. We cover Kustomize extensively for managing configurations across multiple environments, which is a native Kubernetes solution that provides powerful customization capabilities without requiring external templating languages.
We do offer a complete Helm course, and the deep understanding you will gain of Kubernetes manifests, deployments, services, ConfigMaps, and Secrets will prepare you well to learn it quickly!
We do offer a complete Helm course, and the deep understanding you will gain of Kubernetes manifests, deployments, services, ConfigMaps, and Secrets will prepare you well to learn it quickly!
Do I need to know Go to succeed in this course?
No, you do not need to know Go. The course uses Node.js with Express for application examples, which are simple enough to follow even if you are not a Node.js expert. The focus is on containerizing and deploying applications, not on complex application development.
The concepts you learn apply to applications written in any language including Python, Java, Go, Ruby, PHP, and others. Docker and Kubernetes are language-agnostic tools, so the skills you acquire will transfer directly to whatever programming languages your projects use.
The concepts you learn apply to applications written in any language including Python, Java, Go, Ruby, PHP, and others. Docker and Kubernetes are language-agnostic tools, so the skills you acquire will transfer directly to whatever programming languages your projects use.