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 One Last Piece of Windows Setup – Professional and Enterprise Editions
3 Installing Docker on Linux
4 Using the Docker Client
5 But Really…What’s a Container
6 How’s Docker Running on Your Computer
7 Why Use Docker
8 What is Docker
9 Docker for MacWindows
10 Installing Docker on MacOS
11 Installing Docker for Windows Home users
12 Windows 10 Pro and Enterprise Docker Desktop v2.2 Issues
13 Installing Docker for Windows – Professional and Enterprise Editions
14 More Windows Setup – Professional and Enterprise Editions

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

Building Custom Images Through Docker Server
29 Creating Docker Images
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 Manual Image Generation with Docker Commit

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

Docker Compose with Multiple Local Containers
49 App Overview
50 Container Maintenance with Compose
51 Automatic Container Restarts
52 Container Status with Docker Compose
53 App Server Code
54 Completed Node 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

Creating a Production-Grade Workflow
61 Development Workflow
62 Starting the Container
63 Quick Note for Windows Users
64 Docker Volumes
65 Windows 10 Pro and Enterprise Docker Desktop v2.2 Issues
66 Fix for ENOENT no such file or directory, open ‘apppackage.json
67 Bookmarking Volumes fix for Windows
68 Bookmarking Volumes
69 Shorthand with Docker Compose
70 Overriding Dockerfile Selection
71 Do We Need Copy
72 Flow Specifics
73 Executing Tests
74 Live Updating Tests
75 Docker Compose for Running Tests
76 Tests Not Re-running on Windows
77 Shortcomings on Testing
78 Need for Nginx
79 Multi-Step Docker Builds
80 Implementing Multi-Step Builds
81 Running Nginx
82 Docker’s Purpose
83 Project Generation
84 npx Create React App Generation
85 More on Project Generation
86 Necessary Commands
87 Creating the Dev Dockerfile
88 Duplicating Dependencies

Continuous Integration and Deployment with AWS
89 Services Overview
90 Travis Config for Deployment
91 Fix for Missing bucket name error
92 Travis Script Fix for access key id
93 Automated Deployments
94 Exposing Ports Through the Dockerfile
95 AWS Build Still Failing
96 Workflow With Github
97 Redeploy on Pull Request Merge
98 Deployment Wrapup
99 Environment Cleanup
100 Github Setup
101 Travis CI Setup
102 Travis YML File Configuration
103 Fix for Failing Travis Builds
104 A Touch More Travis Setup
105 Automatic Build Creation
106 AWS Elastic Beanstalk
107 More on Elastic Beanstalk

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

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

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

Multi-Container Deployments to AWS
149 Multi-Container Definition Files
150 ElastiCache Redis Creation
151 Creating a Custom Security Group
152 Applying Security Groups to Resources
153 Setting Environment Variables
154 IAM Keys for Deployment
155 Travis Script Fix for access key id
156 Fix for Missing bucket name error
157 Travis Deploy Script
158 Container Memory Allocations
159 Verifying Deployment
160 Finding Docs on Container Definitions
161 A Quick App Change
162 Making Changes
163 Cleaning Up AWS Resources
164 AWS Configuration Cheat Sheet
165 Adding Container Definitions to DockerRun
166 More Container Definitions
167 Forming Container Links
168 Creating the EB Environment
169 Managed Data Service Providers
170 Overview of AWS VPC’s and Security Groups
171 RDS Database Creation

Onwards to Kubernetes!
172 The Why’s and What’s of Kubernetes
173 Adding Configuration Files
174 Object Types and API Versions
175 Running Containers in Pods
176 Service Config Files in Depth
177 Connecting to Running Containers
178 The Entire Deployment Flow
179 Imperative vs Declarative Deployments
180 Kubernetes in Development and Production
181 New Minikube Install Instructions
182 Minikube Setup on MacOS
183 Minikube Setup on Windows ProEnterprise
184 Minikube Setup on Windows Home
185 Minikube Setup on Linux
186 Docker Desktop’s Kubernetes instead of Minikube
187 Mapping Existing Knowledge

Maintaining Sets of Containers with Deployments
188 Updating Existing Objects
189 Updating Deployment Images
190 Rebuilding the Client Image
191 Triggering Deployment Updates
192 Imperatively Updating a Deployment’s Image
193 Multiple Docker Installations
194 Reconfiguring Docker CLI
195 Why Mess with Docker in the Node
196 Declarative Updates in Action
197 Limitations in Config Updates
198 Running Containers with Deployments
199 Deployment Configuration Files
200 Walking Through the Deployment Config
201 Applying a Deployment
202 Why Use Services
203 Scaling and Changing Deployments

A Multi-Container App with Kubernetes
204 The Path to Production
205 Combining Config Into Single Files
206 The Worker Deployment
207 Reapplying a Batch of Config Files
208 Creating and Applying Redis Config
209 Last Set of Boring Config!
210 The Need for Volumes with Databases
211 Kubernetes Volumes
212 Volumes vs Persistent Volumes
213 Persistent Volumes vs Persistent Volume Claims
214 Claim Config Files
215 Checkpoint Files
216 Persistent Volume Access Modes
217 Where Does Kubernetes Allocate Persistent Volumes
218 Designating a PVC in a Pod Template
219 Fix for Postgres CrashLoopBackOff Error on Windows Pro
220 Applying a PVC
221 Defining Environment Variables
222 Adding Environment Variables to Config
223 Creating an Encoded Secret
224 Passing Secrets as Environment Variables
225 Environment Variables as Strings
226 A Quick Checkpoint
227 Recreating the Deployment
228 NodePort vs ClusterIP Services
229 The ClusterIP Config
230 Applying Multiple Files with Kubectl
231 Express API Deployment Config
232 Cluster IP for the Express API

Handling Traffic with Ingress Controllers
233 Load Balancer Services
234 Creating the Ingress Configuration
235 Testing Ingress Locally
236 The Minikube Dashboard
237 Docker Desktop’s Kubernetes Dashboard
238 A Quick Note on Ingresses
239 One Other Quick Note!
240 Behind the Scenes of Ingress
241 More Behind the Scenes of Ingress
242 Optional Reading on Ingress Nginx
243 Setting up Ingress Locally with Minikube
244 Setting up Ingress with Docker Desktop’s Kubernetes
245 Ingress Fix is not a function Fix

Kubernetes Production Deployment
246 The Deployment Process
247 Don’t Forget to Cleanup!
248 Kubernetes Dashboard on Google Cloud
249 Travis Deployment Overview
250 Installing the Google Cloud SDK
251 Generating a Service Account
252 Running Travis CLI in a Container
253 iv undefined Open SSL Error Fix
254 Encrypting a Service Account File
255 More Google Cloud CLI Config
256 Fix For Failing Travis Builds
257 Google Cloud vs AWS for Kubernetes
258 Running Tests with Travis
259 Custom Deployment Providers
260 Unique Deployment Images
261 Unique Tags for Built Images
262 Updating the Deployment Script
263 Configuring the GCloud CLI on Cloud Console
264 Creating a Secret on Google Cloud
265 Helm v3 Update
266 Helm v2 Update
267 Helm Setup
268 Creating a Git Repo
269 Kubernetes Security with RBAC
270 Assigning Tiller a Service Account
271 Ingress-Nginx with Helm
272 The Result of Ingress-Nginx
273 Finally – Deployment!
274 Did I Really Type That
275 Verifying Deployment
276 A Workflow for Changing in Prod
277 Merging a PR for Deployment
278 That’s It! What’s Next
279 Linking the Github Repo to Travis
280 Free Google Cloud Credits
281 Creating a Google Cloud Project
282 Linking a Billing Account
283 Kubernetes Engine Init
284 Creating a Cluster with Google Cloud

HTTPS Setup with Kubernetes
285 HTTPS Setup Overview
286 Verifying the Certificate
287 Ingress Config for HTTPS
288 It Worked!
289 Google Cloud Cleanup
290 Local Environment Cleanup
291 Domain Purchase
292 Domain Name Setup
293 Fix for Cert Manager Breaking Changes
294 Cert Manager Install
295 How to Wire Up Cert Manager
296 Issuer Config File
297 Certificate Config File
298 Deploying Changes

Local Development with Skaffold
299 Awkward Local Development
300 Installing Skaffold
301 The Skaffold Config File
302 Live Sync Changes
303 Automatic Shutdown
304 Testing Live Sync with the API Server

305 Bonus!