Docker and Kubernetes: The Complete Guide

Name: Docker and Kubernetes: The Complete Guide
Price: 9 USD
Availability: InStock

21h 32m 42s

English

Paid

May 18, 2023

Course description

This is the ultimate course to learn how to deploy any web application you can possibly dream up. Docker and Kubernetes are the newest tech in the Dev Ops world, and have dramatically changed the flow of creating and deploying web apps. Docker is a technology that allows applications to run in constructs called 'containers', while Kubernetes allows for many different 'containers' to run in coordination.

Read more about the course

If you're tired of spinning your wheels learning how to deploy web applications, this is the course for you.

CI+CD Workflows? You will learn it. AWS Deployment? Included. Kubernetes in Production? Of course!

Docker from Scratch!

In this course you'll learn Docker from absolute fundamentals, beginning by learning the answer to basic questions such as "What is a container?" and "How does a container work?". From the very first few lectures, we will do a deep dive on the inner workings of containers, so you get a core understanding of exactly how they are implemented. Once you understand what a container is, you'll learn how to work with them using basic Docker CLI commands. After that, you'll apply your new-found mastery of the Docker CLI to build your own custom images, effectively 'Dockerizing' your own personal applications.

CI + CD Pipelines

Of course, no course on Docker would be complete without a full understanding of common Continuous Integration and Continuous Deployment patterns. You will learn how to implement a full CI + CD workflow using Github, Travis CI, and Amazon Web Services, creating a pipeline that automatically deploys your code every time you push your latest changes to Github!

Multi-Container Deployments on AWS!

After building a deployment pipeline, you'll apply it to master both single-container and multi-container deployments on Amazon Web Services. You will construct a multi-container application utilizing Node, React, Redis, and Postgres, and see the amazing power of containers in action (Note: all Javascript coding in this course is optional, the full source code is provided if you don't want to write JS).

Kubernetes!

Finally, you will tackle Kubernetes, a production-grade system for managing complex applications with many different running containers. You will learn the right way to build a Kubernetes Cluster - this course doesn't have any of those annoying "don't do this in production" comments! You will first build a Kubernetes Cluster on your local machine, then eventually move it over to a cloud provider. You'll even learn how to set up HTTPS on Kubernetes, which is harder than it sounds!

Here's what you'll do:

Learn Docker from scratch, no previous experience required
Build your own custom images tailored to your applications
Master the Docker CLI to inspect and debug running containers
Understand how Docker works behind the scenes, and what a container is
Build a CI + CD pipeline from scratch with Github, Travis CI, and AWS
Automatically deploy your code when it is pushed to Github!
Build a complex multi-container application from scratch and deploy it to AWS
Understand the purpose and theory of Kubernetes
Deploy a production-ready Kubernetes Cluster to Google Cloud

Requirements:

Basic understanding of terminal and command line usage
No previous Docker or Kubernetes experience is required!
A credit card is required to deploy projects to AWS or Google Cloud

Who this course is for:

Software engineers looking to deploy their apps easily and quickly

What you'll learn:

Learn Docker from scratch, no previous experience required
Master the Docker CLI to inspect and debug running containers
Build a CI + CD pipeline from scratch with Github, Travis CI, and AWS
Understand the purpose and theory of Kubernetes by building a complex app
Automatically deploy your code when it is pushed to Github!

Watch Online

Watch Online Docker and Kubernetes: The Complete Guide

0:00

#1: Why Use Docker?

All Course Lessons (257)

#	Lesson Title	Duration
1	Why Use Docker? Demo	03:44
2	What is Docker?	02:54
3	Docker for Mac/Windows	01:58
4	Installing Docker on MacOS	04:46
5	Installing Docker for Windows Professional with HyperV	02:04
6	More Windows Professional Setup with HyperV	00:41
7	One Last Piece of Windows Professional Setup with HyperV	01:10
8	Using the Docker Client	05:04
9	But Really...What's a Container?	08:31
10	How's Docker Running on Your Computer?	02:45
11	Docker Run in Detail	01:55
12	Overriding Default Commands	05:13
13	Listing Running Containers	04:10
14	Container Lifecycle	05:17
15	Restarting Stopped Containers	03:44
16	Removing Stopped Containers	01:40
17	Retrieving Log Outputs	02:34
18	Stopping Containers	05:22
19	Multi-Command Containers	04:17
20	Executing Commands in Running Containers	02:54
21	The Purpose of the IT Flag	04:36
22	Getting a Command Prompt in a Container	04:07
23	Starting with a Shell	02:14
24	Container Isolation	03:10
25	Creating Docker Images	02:37
26	Building a Dockerfile	04:52
27	Dockerfile Teardown	02:42
28	What's a Base Image?	05:41
29	The Build Process in Detail	11:10
30	A Brief Recap	03:25
31	Rebuilds with Cache	07:03
32	Tagging an Image	04:27
33	Manual Image Generation with Docker Commit	05:01
34	Project Outline	02:36
35	Node Server Setup	05:04
36	A Few Planned Errors	05:13
37	Base Image Issues	07:51
38	A Few Missing Files	03:19
39	Copying Build Files	04:51
40	Container Port Mapping	07:27
41	Specifying a Working Directory	07:53
42	Unnecessary Rebuilds	04:17
43	Minimizing Cache Busting and Rebuilds	04:59
44	App Overview	03:58
45	App Server Starter Code	06:44
46	Assembling a Dockerfile	03:13
47	Introducing Docker Compose	05:33
48	Docker Compose Files	06:03
49	Networking with Docker Compose	05:01
50	Docker Compose Commands	04:39
51	Stopping Docker Compose Containers	02:35
52	Container Maintenance with Compose	02:54
53	Automatic Container Restarts	09:22
54	Container Status with Docker Compose	02:22
55	Development Workflow	01:29
56	Flow Specifics	06:33
57	Docker's Purpose	01:51
58	Project Generation	03:26
59	More on Project Generation	01:45
60	Necessary Commands	05:10
61	Creating the Dev Dockerfile	03:43
62	Duplicating Dependencies	01:30
63	Starting the Container	02:51
64	Docker Volumes	06:54
65	Bookmarking Volumes	04:51
66	Shorthand with Docker Compose	04:23
67	Overriding Dockerfile Selection	02:03
68	Do We Need Copy?	02:52
69	Executing Tests	03:39
70	Live Updating Tests	04:55
71	Docker Compose for Running Tests	05:46
72	Shortcomings on Testing	08:31
73	Need for Nginx	03:08
74	Multi-Step Docker Builds	06:55
75	Implementing Multi-Step Builds	07:06
76	Running Nginx	02:28
77	Services Overview	03:05
78	Github Setup	03:58
79	Travis CI Setup	04:18
80	Travis YML File Configuration	07:40
81	A Touch More Travis Setup	04:15
82	Automatic Build Creation	03:31
83	AWS Elastic Beanstalk	04:11
84	More on Elastic Beanstalk	02:26
85	Travis Config for Deployment	08:47
86	Automated Deployments	07:18
87	Exposing Ports Through the Dockerfile	03:57
88	Workflow With Github	04:00
89	Redeploy on Pull Request Merge	02:02
90	Deployment Wrapup	02:04
91	Single Container Deployment Issues	03:03
92	Application Overview	04:31
93	Application Architecture	05:12
94	Worker Process Setup	11:42
95	Express API Setup	05:20
96	Connecting to Postgres	07:37
97	More Express API Setup	12:21
98	Generating the React App	01:52
99	Fetching Data in the React App	06:32
100	Rendering Logic in the App	08:30
101	Exporting the Fib Class	00:27
102	Routing in the React App	04:37
103	Checkpoint Catchup	02:40
104	Dockerizing a React App - Again!	06:42
105	Dockerizing Generic Node Apps	03:48
106	Adding Postgres as a Service	07:06
107	Docker-compose Config	06:18
108	Environment Variables with Docker Compose	10:21
109	The Worker and Client Services	03:43
110	Nginx Path Routing	09:42
111	Routing with Nginx	11:13
112	Building a Custom Nginx Image	05:39
113	Starting Up Docker Compose	01:51
114	Troubleshooting Startup Bugs	03:23
115	Opening Websocket Connections	03:52
116	Production Multi-Container Deployments	05:40
117	Production Dockerfiles	06:06
118	Multiple Nginx Instances	05:24
119	Altering Nginx's Listen Port	04:54
120	Cleaning Up Tests	01:12
121	Github and Travis CI Setup	04:09
122	Travis Configuration Setup	08:46
123	Pushing Images to Docker Hub	07:35
124	Successful Image Building	01:50
125	Multi-Container Definition Files	04:31
126	Finding Docs on Container Definitions	03:10
127	Adding Container Definitions to DockerRun	05:46
128	More Container Definitions	05:19
129	Forming Container Links	07:48
130	Creating the EB Environment	03:31
131	Managed Data Service Providers	10:45
132	Overview of AWS VPC's and Security Groups	09:22
133	RDS Database Creation	06:32
134	ElastiCache Redis Creation	04:12
135	Creating a Custom Security Group	04:19
136	Applying Security Groups to Resources	05:00
137	Setting Environment Variables	07:56
138	IAM Keys for Deployment	05:13
139	Travis Deploy Script	03:21
140	Container Memory Allocations	04:11
141	Verifying Deployment	02:57
142	A Quick App Change	01:30
143	Making Changes	00:58
144	Cleaning Up AWS Resources	05:06
145	The Why's and What's of Kubernetes	08:07
146	Kubernetes in Development and Production	05:48
147	Minikube Setup on MacOS	05:37
148	Mapping Existing Knowledge	07:38
149	Adding Configuration Files	06:53
150	Object Types and API Versions	06:56
151	Running Containers in Pods	09:20
152	Service Config Files in Depth	13:38
153	Connecting to Running Containers	10:25
154	The Entire Deployment Flow	13:03
155	Imperative vs Declarative Deployments	13:37
156	Updating Existing Objects	06:11
157	Declarative Updates in Action	07:05
158	Limitations in Config Updates	02:56
159	Running Containers with Deployments	06:04
160	Deployment Configuration Files	03:19
161	Walking Through the Deployment Config	04:24
162	Applying a Deployment	06:23
163	Why Use Services?	05:20
164	Scaling and Changing Deployments	06:32
165	Updating Deployment Images	03:58
166	Rebuilding the Client Image	03:00
167	Triggering Deployment Updates	12:25
168	Imperatively Updating a Deployment's Image	07:25
169	Multiple Docker Installations	05:38
170	Reconfiguring Docker CLI	05:58
171	Why Mess with Docker in the Node?	05:06
172	The Path to Production	05:14
173	A Quick Checkpoint	04:37
174	Recreating the Deployment	05:31
175	NodePort vs ClusterIP Services	03:42
176	The ClusterIP Config	03:53
177	Applying Multiple Files with Kubectl	04:19
178	Express API Deployment Config	06:03
179	Cluster IP for the Express API	03:09
180	Combining Config Into Single Files	06:00
181	The Worker Deployment	04:37
182	Reapplying a Batch of Config Files	04:52
183	Creating and Applying Redis Config	07:27
184	Last Set of Boring Config!	06:15
185	The Need for Volumes with Databases	07:19
186	Kubernetes Volumes	05:18
187	Volumes vs Persistent Volumes	03:00
188	Persistent Volumes vs Persistent Volume Claims	09:23
189	Claim Config Files	02:58
190	Persistent Volume Access Modes	03:32
191	Where Does Kubernetes Allocate Persistent Volumes?	07:43
192	Designating a PVC in a Pod Template	06:10
193	Applying a PVC	02:23
194	Defining Environment Variables	04:10
195	Adding Environment Variables to Config	05:45
196	Creating an Encoded Secret	09:26
197	Passing Secrets as Environment Variables	05:54
198	Environment Variables as Strings	02:18
199	Load Balancer Services	04:15
200	A Quick Note on Ingresses	03:33
201	One Other Quick Note!	01:38
202	Behind the Scenes of Ingress	05:18
203	More Behind the Scenes of Ingress	06:39
204	Setting up Ingress Locally with Minikube	06:22
205	Creating the Ingress Configuration	07:01
206	Testing Ingress Locally	02:51
207	The Minikube Dashboard	03:29
208	The Deployment Process	05:50
209	Google Cloud vs AWS for Kubernetes	04:54
210	Creating a Git Repo	04:00
211	Linking the Github Repo to Travis	01:36
212	Creating a Google Cloud Project	02:00
213	Linking a Billing Account	02:12
214	Kubernetes Engine Init	01:48
215	Creating a Cluster with Google Cloud	04:48
216	Kubernetes Dashboard on Google Cloud	04:35
217	Travis Deployment Overview	05:05
218	Installing the Google Cloud SDK	05:45
219	Generating a Service Account	05:30
220	Running Travis CLI in a Container	09:18
221	Encrypting a Service Account File	07:55
222	More Google Cloud CLI Config	04:41
223	Running Tests with Travis	06:19
224	Custom Deployment Providers	03:50
225	Unique Deployment Images	08:34
226	Unique Tags for Built Images	07:48
227	Updating the Deployment Script	07:52
228	Configuring the GCloud CLI on Cloud Console	05:35
229	Creating a Secret on Google Cloud	02:25
230	Helm Setup	08:16
231	Kubernetes Security with RBAC	08:22
232	Assigning Tiller a Service Account	05:09
233	Ingress-Nginx with Helm	01:57
234	The Result of Ingress-Nginx	03:49
235	Finally - Deployment!	03:31
236	Did I Really Type That?	00:46
237	Verifying Deployment	05:21
238	A Workflow for Changing in Prod	04:30
239	Merging a PR for Deployment	01:02
240	That's It! What's Next?	01:38
241	HTTPS Setup Overview	05:36
242	Domain Purchase	02:18
243	Domain Name Setup	03:31
244	Cert Manager Install	01:58
245	How to Wire Up Cert Manager	05:59
246	Issuer Config File	05:08
247	Certificate Config File	05:19
248	Deploying Changes	03:16
249	Verifying the Certificate	03:55
250	Ingress Config for HTTPS	06:50
251	It Worked!	02:53
252	Awkward Local Development	03:55
253	Installing Skaffold	02:00
254	The Skaffold Config File	06:44
255	Live Sync Changes	05:03
256	Automatic Shutdown	05:08
257	Testing Live Sync with the API Server	05:30

Unlock unlimited learning

Get instant access to all 256 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Comments

0 comments

Want to join the conversation?

Similar courses

DevOps Deployment Automation with Terraform, AWS and Docker

Sources: udemy

Welcome to the advanced course on how to set up a deployment automation that’s capable of handling millions of users! In this course you will learn some of the most in-demand sk...

10 hours 59 minutes 9 seconds

Intensive Kubernetes: 2.0

Sources: ardanlabs.com

Intensive Kubernetes: 2.0 is a course designed for those looking to become experts in container management and orchestration using Kubernetes.

18 hours 55 minutes 51 seconds

React: Intermediate Topics

Sources: codewithmosh (Mosh Hamedani)

If you know the basics of building web apps with React and TypeScript and are looking for a more advanced course to take your skills to the next level, you're in the right place...

6 hours 5 minutes 3 seconds

Amazon EKS Starter: Docker on AWS EKS with Kubernetes