Docker and Kubernetes: The Complete Guide

Docker and Kubernetes: The Complete Guide
Docker and Kubernetes: The Complete Guide
English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 21.5 Hours | 11.7 GB

Build, test, and deploy Docker applications with Kubernetes while learning production-style development workflows

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!

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.

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).


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
Table of Contents

Dive Into Docker!
1 Finished Code Repositories and Diagrams
2 Why Use Docker
3 What is Docker
4 Docker for MacWindows
5 Installing Docker on MacOS
6 Installing Docker for Windows Home users
7 Installing Docker for Windows Profressional
8 More Windows Professional Setup
9 One Last Piece of Windows Professional Setup
10 Installing Docker on Linux
11 Using the Docker Client
12 But Really…What’s a Container
13 How’s Docker Running on Your Computer

Manipulating Containers with the Docker Client
14 Docker Run in Detail
15 Executing Commands in Running Containers
16 The Purpose of the IT Flag
17 Getting a Command Prompt in a Container
18 Starting with a Shell
19 Container Isolation
20 Overriding Default Commands
21 Listing Running Containers
22 Container Lifecycle
23 Restarting Stopped Containers
24 Removing Stopped Containers
25 Retrieving Log Outputs
26 Stopping Containers
27 Multi-Command Containers

Building Custom Images Through Docker Server
28 Creating Docker Images
29 Manual Image Generation with Docker Commit
30 Building a Dockerfile
31 Dockerfile Teardown
32 What’s a Base Image
33 The Build Process in Detail
34 A Brief Recap
35 Rebuilds with Cache
36 Tagging an Image
37 Quick Note for Windows Users

Making Real Projects with Docker
38 Project Outline
39 Unnecessary Rebuilds
40 Minimizing Cache Busting and Rebuilds
41 Completed Code for Section 4
42 Node Server Setup
43 A Few Planned Errors
44 Base Image Issues
45 A Few Missing Files
46 Copying Build Files
47 Reminder for Windows Home Docker Toolbox Students
48 Container Port Mapping
49 Specifying a Working Directory

Docker Compose with Multiple Local Containers
50 App Overview
51 Automatic Container Restarts
52 Container Status with Docker Compose
53 Completed Code for Section 5 Visits App
54 App Server Starter Code
55 Assembling a Dockerfile
56 Introducing Docker Compose
57 Docker Compose Files
58 Networking with Docker Compose
59 Docker Compose Commands
60 Stopping Docker Compose Containers
61 Container Maintenance with Compose

Creating a Production-Grade Workflow
62 Development Workflow
63 React App Exits Immediately with Docker Run Command
64 Starting the Container
65 Docker Volumes
66 Windows not Detecting Changes – Update
67 Bookmarking Volumes
68 React App Exited With Code 0
69 Shorthand with Docker Compose
70 Overriding Dockerfile Selection
71 Windows not Detecting Changes – Docker Compose
72 Do We Need Copy
73 Flow Specifics
74 Executing Tests
75 Live Updating Tests
76 Docker Compose for Running Tests
77 Tests Not Re-running on Windows
78 Attaching to Web container
79 Shortcomings on Testing
80 Need for Nginx
81 Multi-Step Docker Builds
82 Implementing Multi-Step Builds
83 Running Nginx
84 Docker’s Purpose
85 Project Generation
86 Create React App Generation
87 More on Project Generation
88 Necessary Commands
89 Creating the Dev Dockerfile
90 Duplicating Dependencies

Continuous Integration and Deployment with AWS
91 Services Overview
92 Travis Config for Deployment
93 Travis Keys Update
94 Automated Deployments
95 Exposing Ports Through the Dockerfile
96 AWS Build Still Failing
97 Workflow With Github
98 Redeploy on Pull Request Merge
99 Deployment Wrapup
100 Environment Cleanup
101 AWS Configuration Cheat Sheet
102 Github Setup
103 Finished Project Code with Updates Applied
104 Travis CI Setup
105 Travis YML File Configuration
106 Required Travis Updates
107 A Touch More Travis Setup
108 Automatic Build Creation
109 AWS Elastic Beanstalk
110 More on Elastic Beanstalk

Building a Multi-Container Application
111 Single Container Deployment Issues
112 Generating the React App
113 Fetching Data in the React App
114 Rendering Logic in the App
115 Exporting the Fib Class
116 Routing in the React App
117 Application Overview
118 A Quick Note
119 Application Architecture
120 Worker Process Setup
121 Express API Setup
122 Connecting to Postgres
123 More Express API Setup
124 Create React App Generation

Dockerizing Multiple Services
125 Checkpoint Files
126 Nginx Path Routing
127 Routing with Nginx
128 Building a Custom Nginx Image
129 React App Exited With Code 0
130 Starting Up Docker Compose
131 Nginx connect() failed – Connection refused while connecting to upstream
132 Fix for I Calculated Nothing Yet message
133 Troubleshooting Startup Bugs
134 Opening Websocket Connections
135 Checkpoint Catchup
136 Dockerizing a React App – Again!
137 Dockerizing Generic Node Apps
138 Adding Postgres as a Service
139 Docker-compose Config
140 Postgres Database Required Fixes and Updates
141 Environment Variables with Docker Compose
142 The Worker and Client Services

A Continuous Integration Workflow for Multiple Images
143 Production Multi-Container Deployments
144 Pushing Images to Docker Hub
145 Successful Image Building
146 Production Dockerfiles
147 Multiple Nginx Instances
148 Altering Nginx’s Listen Port
149 Nginx fix for React Router
150 Cleaning Up Tests
151 Github and Travis CI Setup
152 Fix for Failing Travis Builds
153 Travis Configuration Setup

Multi-Container Deployments to AWS
154 Multi-Container Definition Files
155 RDS Database Creation
156 ElastiCache Redis Creation
157 Creating a Custom Security Group
158 Applying Security Groups to Resources
159 Setting Environment Variables
160 IAM Keys for Deployment
161 Travis Keys Update
162 Fix for Missing bucket name error
163 Travis Deploy Script
164 Container Memory Allocations
165 Finding Docs on Container Definitions
166 Verifying Deployment
167 A Quick App Change
168 Making Changes
169 Cleaning Up AWS Resources
170 AWS Configuration Cheat Sheet
171 Finished Project Code with Updates Applied
172 Adding Container Definitions to DockerRun
173 More Container Definitions
174 Forming Container Links
175 AWS Configuration Cheat Sheet – Updated for new UI
176 Creating the EB Environment
177 Managed Data Service Providers
178 Overview of AWS VPC’s and Security Groups

Onwards to Kubernetes!
179 The Why’s and What’s of Kubernetes
180 Quick Note to Prevent an Error
181 Adding Configuration Files
182 Object Types and API Versions
183 Running Containers in Pods
184 Service Config Files in Depth
185 Connecting to Running Containers
186 The Entire Deployment Flow
187 Imperative vs Declarative Deployments
188 Kubernetes in Development and Production
189 Updated Minikube Install and Setup Info – macOS
190 Minikube Setup on MacOS
191 Minikube Setup on Windows Pro
192 Minikube Setup on Windows Home
193 Minikube Setup on Linux
194 Docker Desktop’s Kubernetes instead of Minikube
195 Mapping Existing Knowledge

Maintaining Sets of Containers with Deployments
196 Updating Existing Objects
197 Scaling and Changing Deployments
198 Updating Deployment Images
199 Rebuilding the Client Image
200 Triggering Deployment Updates
201 Imperatively Updating a Deployment’s Image
202 Multiple Docker Installations
203 Reconfiguring Docker CLI
204 Why Mess with Docker in the Node
205 Declarative Updates in Action
206 Limitations in Config Updates
207 Quick Note to Prevent an Error
208 Running Containers with Deployments
209 Deployment Configuration Files
210 Walking Through the Deployment Config
211 Applying a Deployment
212 Why Use Services

A Multi-Container App with Kubernetes
213 The Path to Production
214 Combining Config Into Single Files
215 The Worker Deployment
216 Reapplying a Batch of Config Files
217 Creating and Applying Redis Config
218 Important Note about Expected Postgres Error
219 Last Set of Boring Config!
220 The Need for Volumes with Databases
221 Kubernetes Volumes
222 Volumes vs Persistent Volumes
223 Persistent Volumes vs Persistent Volume Claims
224 Checkpoint Files
225 Claim Config Files
226 Persistent Volume Access Modes
227 Where Does Kubernetes Allocate Persistent Volumes
228 Designating a PVC in a Pod Template
229 Applying a PVC
230 Defining Environment Variables
231 Adding Environment Variables to Config
232 Creating an Encoded Secret
233 Postgres Environment Variable Fix
234 Passing Secrets as Environment Variables
235 A Quick Checkpoint
236 Environment Variables as Strings
237 Recreating the Deployment
238 NodePort vs ClusterIP Services
239 The ClusterIP Config
240 Applying Multiple Files with Kubectl
241 Express API Deployment Config
242 Cluster IP for the Express API

Handling Traffic with Ingress Controllers
243 Load Balancer Services
244 Setting up Ingress with Docker Desktop’s Kubernetes
245 Ingress Update is not a function 404 errors
246 Creating the Ingress Configuration
247 Testing Ingress Locally
248 Indexes I Have Seen is Empty
249 The Minikube Dashboard
250 Docker Desktop’s Kubernetes Dashboard
251 A Quick Note on Ingresses
252 One Other Quick Note!
253 Behind the Scenes of Ingress
254 More Behind the Scenes of Ingress
255 Optional Reading on Ingress Nginx
256 Docker Driver and Ingress – IMPORTANT
257 Update on Mandatory Commands
258 Setting up Ingress Locally with Minikube

Kubernetes Production Deployment
259 The Deployment Process
260 Don’t Forget to Cleanup!
261 Kubernetes Dashboard on Google Cloud
262 Travis Deployment Overview
263 Installing the Google Cloud SDK
264 Generating a Service Account
265 Ruby Version Fix
266 Running Travis CLI in a Container
267 Fixes for Travis iv undefined orrepository not known
268 Encrypting a Service Account File
269 More Google Cloud CLI Config
270 Google Cloud vs AWS for Kubernetes
271 Fix For Failing Travis Builds
272 Running Tests with Travis
273 Custom Deployment Providers
274 Unique Deployment Images
275 Unique Tags for Built Images
276 Updating the Deployment Script
277 Configuring the GCloud CLI on Cloud Console
278 Creating a Secret on Google Cloud
279 Helm v3 Update
280 Helm v2 Update
281 Creating a Git Repo
282 Helm Setup
283 Kubernetes Security with RBAC
284 Assigning Tiller a Service Account
285 Ingress-Nginx with Helm
286 The Result of Ingress-Nginx
287 Finally – Deployment!
288 Did I Really Type That
289 Verifying Deployment
290 A Workflow for Changing in Prod
291 Merging a PR for Deployment
292 Linking the Github Repo to Travis
293 That’s It! What’s Next
294 Free Google Cloud Credits
295 Creating a Google Cloud Project
296 Linking a Billing Account
297 Kubernetes Engine Init
298 Creating a Cluster with Google Cloud

HTTPS Setup with Kubernetes
299 HTTPS Setup Overview
300 Domain Purchase
301 Domain Name Setup
302 Fix for Cert Manager Breaking Changes
303 Cert Manager Install
304 How to Wire Up Cert Manager
305 Issuer Config File
306 Certificate Config File
307 Deploying Changes
308 Verifying the Certificate
309 Ingress Config for HTTPS
310 It Worked!
311 Google Cloud Cleanup
312 Local Environment Cleanup

Local Development with Skaffold
313 Awkward Local Development
314 Installing Skaffold
315 The Skaffold Config File
316 Live Sync Changes
317 Automatic Shutdown
318 Testing Live Sync with the API Server

319 Bonus!