CF

Docker and Kubernetes - The Complete Developers Guide

12h 40m 38s
English
Free

This course guides you from your first steps with Docker and Kubernetes to building real apps on your own. You will learn through clear diagrams and hands-on work. You will containerize five projects, each one harder than the last. You will finish by building a small microservice app with Kubernetes and deploying it to AWS.

You will also build a set of projects you can share to show what you know.

What You Will Learn

  • What Docker containers are and why you use them
  • How to build Docker images and run containers
  • How to connect to a container from your host
  • How to keep data inside a database container
  • How to build a small app with docker-compose
  • How Kubernetes works and why it helps
  • The main Kubernetes objects and what they do
  • How a Kubernetes cluster is built
  • How to run a multi-part app on Kubernetes
  • How to push and pull images from a registry
  • How to deploy a container app to AWS ECS and AWS EKS
  • How to build a simple, production-ready CI/CD pipeline

You will learn by doing, and you will finish with skills you can use in real projects.

About the Author: Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

Watch Online 135 lessons

  • Space or K: play or pause
  • J: rewind 10 seconds
  • L: forward 10 seconds
  • Left Arrow: rewind 5 seconds
  • Right Arrow: forward 5 seconds
  • Up Arrow: volume up
  • Down Arrow: volume down
  • M: mute or unmute
  • F: toggle fullscreen
  • T: toggle theater mode
  • I: toggle mini player
  • 0 to 9: seek to 0 to 90 percent of the video
  • Shift plus N: next video
  • Shift plus P: previous video
0:00 0:00
#Lesson TitleDuration
1What We'll Learn 03:26
2Some Stuff We Need to Download 03:12
3Installing Docker Desktop 03:15
4A Little Analogy 05:49
5Relating Our Analogy to Docker 07:28
6Building a Small Node App 06:17
7Running Our Node App Locally 05:48
8Creating a Dockerfile 03:39
9We are Really Building an Image 05:29
10Understanding the Rest of the Dockerfile 08:21
11Building an Image and Running a Container 06:55
12Port Mapping 04:18
13Rebuilding Our Image 06:15
14Syncing Our Code with Bind Mounts 04:38
15Using Anonymous Volumes 07:03
16It's Not Docker's Fault! 09:19
17Ignoring Files with Docker Ignore 06:18
18Docker Layering and Caching 07:34
19The Challenge 05:17
20The Solution 10:13
21An Intro to Control Plane 05:57
22Viewing Our GVC 03:35
23Pushing Our Image to an Image Repository 07:40
24Running a Workload 02:53
25Killing Our Deployment 00:47
26Application Overview 02:43
27How to Handle Multiple Component Applications 04:58
28Going Through the Starter Code 03:48
29Pulling Images From an Image Repository 06:43
30Building our Node Image and Running the Container 04:20
31Connecting Our Containers Through Localhost 09:51
32Utilizing the Container's IP Address 05:20
33Introducing Docker Networks 06:00
34Dockerizing Our React App 02:59
35Running into a Little Issue 04:40
36Client Side Rendering is the Problem 05:30
37Optimizing Our Workflow with Volumes 17:07
38An Intro to Docker Compose 03:54
39A Little About YAML Syntax 04:32
40Writing the MongoDB Configuration 04:44
41Setting Environment Variables 05:13
42docker-compose up and docker-compose down 03:30
43Setting Up the Backend Container 10:40
44Testing the Integration 01:43
45Setting Up the Frontend Container 05:44
46Our Deployment Workflow 03:31
47Writing the Dockerfile 06:22
48Running the Container Locally 03:02
49Create an Image Repository and Downloading the AWS CLI 11:23
50IAM for Access Management 10:28
51Pushing Our Image to the Registry 04:03
52Creating an ECS Cluster 07:13
53Creating a Task Definition 04:15
54Running the Task with a ECS Service 03:11
55Configuring the Inbound Rules of Our Security Group 04:16
56Redeploying Changes in the Codebase 07:56
57The Issues with a Manual Process 02:10
58The Solution is Automation 01:21
59Understanding a Production Grade Workflow 08:06
60Pushing Our Code to GitHub 02:45
61Creating a Pull Request 05:11
62Building the Integration Pipeline 10:05
63Setting up Branch Protection Rules (Not Really) 02:17
64Setting Up AWS Credentials in GitHub Actions 11:21
65Building and Pushing Our Image to ECR 11:49
66My Bad Everyone 02:38
67Downloading and Updating the task-definition.json File 10:11
68Deploying the Task Definition 07:41
69Fixing Our Deployment Issue 04:24
70The Major Issue with This Solution 04:56
71Blue/Green Deployments is the Optimal Solution 04:21
72Tearing Down the ECS Cluster 01:59
73Multi Container Deployment 02:08
74The Need for NGINX 04:06
75Multi Stage Dockerfile 07:20
76The Issues With Using a Database Container 05:50
77Setting Up Our Codebase for Deployment 04:27
78Pushing Our Image to AWS ECR 04:24
79Defining a Multi Container Task Defintion 06:46
80Adding Environment Variables 05:07
81Updating the Task Definition 04:30
82Our New (Much Larger) Project 08:15
83Can We Just Do the Same Thing? 04:28
84Kubernetes to the Rescue 02:57
85Communication via Kubectl 03:57
86Installing Kubernetes 01:33
87Writing Our First Manifest File 04:50
88Containers Run in Pods 05:35
89Selecting Kubernetes Objects With the apiVersion 02:17
90Understanding the Rest of the Manifest File 09:04
91Running Our Pod 02:54
92Writing a Service Manifest File 04:19
93How the NodePort Service Works 09:31
94Creating the Node and Mongo Pods 09:16
95ClusterIP Service for Internal Communication 09:06
96What Happens if the Pod Crashes? 04:37
97Deployments to the Rescue 07:50
98Dissecting the Manifest File 04:21
99Creating the Frontend Store ClusterIP 04:15
100Creating the Deployment and ClusterIP For the Products API 05:39
101Creating the MongoDB Deployment 03:51
102Running All the Manifest Files 06:43
103Deployment for the Notifications API 08:26
104Deployment and ClusterIP for RabbitMQ 05:14
105Checking if Everything Works 02:20
106Adding Environment Variables to Our Code 04:46
107Defining Environment Variables 07:35
108ConfigMaps for Commonly Used Environment Variables 08:32
109Hide Environment Variables With Secrets 11:24
110The Need for an Ingress Service 06:33
111Writing Some Ingress Configuration 05:50
112Manually Testing Out Our App 11:52
113Understanding the Ingress Configuration 08:09
114Our Data is Not Persisting! 02:38
115A Reminder on Volumes 02:51
116Kubernetes Volumes Are Not the Solution 02:53
117Persistent Volumes, for well... Persistent Data 01:06
118Persistent Volume Claims 02:16
119Writing the Config and Applying the PVC 09:19
120The Deployment Process 07:46
121Creating a EKS Cluster with Eksctl 05:19
122Understanding Kubectl Context 06:03
123Creating the Twilio Secret in Prod 04:18
124Adding an AWS Ingress Load Balancer 02:40
125Defining the Host Domain 05:36
126Applying the Rest of Our Configuration 04:30
127Testing Our Deployed App! 02:50
128Updating Our Production Cluster 07:00
129The Steps Our CD Pipeline Needs to Take 04:19
130Creating a GitHub Repository 07:12
131Starting Our Deployment Workflow 11:39
132Building and Pushing Our Image to DockerHub 08:05
133Completing Our Pipeline By Updating Our Cluster 07:03
134It Worked! 01:15
135Deleting Our Cluster 01:03

Related courses

Frequently asked questions

What prerequisites are needed before starting the course?
Before starting this course, you should have a basic understanding of software development and familiarity with command-line interfaces. While the course guides you from the basics, knowledge of programming concepts and experience in developing applications will help you grasp the course content more effectively.
What projects will I build during the course?
Throughout the course, you will containerize five projects, each increasing in complexity. The final project involves building a small microservice application with Kubernetes and deploying it to AWS. These projects are designed to reinforce your learning and provide practical experience with Docker and Kubernetes.
Who is the target audience for this course?
This course is ideal for software developers interested in learning about containerization and orchestration using Docker and Kubernetes. It is also suitable for those looking to understand how to deploy applications using AWS ECS and AWS EKS, as well as those interested in building production-ready CI/CD pipelines.
How does the depth of this course compare to other similar courses?
The course offers a comprehensive exploration of Docker and Kubernetes, including practical exercises like containerizing applications and deploying them to AWS. Lessons cover essential topics such as Dockerfile creation, Kubernetes cluster configuration, and CI/CD pipeline development, providing a solid foundation for real-world applications.
What specific tools and platforms will I learn to use?
You will learn to use Docker for creating and managing containers, Docker Compose for building applications, and Kubernetes for orchestration. Additionally, the course covers deploying applications to AWS using ECS and EKS, and setting up CI/CD pipelines for automation.
What topics are not covered in the course?
The course does not cover advanced Kubernetes configurations beyond deploying small-scale applications, nor does it dive into in-depth AWS infrastructure management outside of ECS and EKS deployments. It focuses primarily on practical containerization and orchestration tasks rather than broader cloud architecture.
What is the expected time commitment for completing the course?
The course consists of 135 lessons, and while the total runtime is not specified, it is designed to be completed at your own pace. Allocating consistent time each week will help you work through the lessons and projects effectively. Engaging with hands-on exercises and projects will also require additional time for practice and experimentation.