Docker and Kubernetes - The Complete Developers Guide

Name: Docker and Kubernetes - The Complete Developers Guide
Availability: InStock
Rating: 5 (4 reviews)

12h 40m 38s

English

Free

May 22, 2024

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 is a global online marketplace for teaching and learning. It connects students with instructors who share skills in many fields.

Who Uses Udemy

Millions of learners use Udemy to gain skills for work and personal growth. Companies, governments, and nonprofits also use Udemy to train their teams.

What Udemy Offers

Udemy provides a curated set of business and technical courses. These courses help teams build practical skills and support ongoing learning at work.

Watch Online 135 lessons

0:00 0:00

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