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 MB

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

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

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

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

Docker Compose with Multiple Local Containers
47 App Overview
48 Container Maintenance with Compose
49 Automatic Container Restarts
50 Container Status with Docker Compose
51 App Server Code
52 Completed Node Code
53 Assembling a Dockerfile
54 Introducing Docker Compose
55 Docker Compose Files
56 Networking with Docker Compose
57 Docker Compose Commands
58 Stopping Docker Compose Containers

Creating a Production-Grade Workflow
59 Development Workflow
60 Quick Note for Windows Users
61 Docker Volumes
62 Bookmarking Volumes
63 Shorthand with Docker Compose
64 Overriding Dockerfile Selection
65 Do We Need Copy
66 Executing Tests
67 Live Updating Tests
68 Docker Compose for Running Tests
69 Shortcomings on Testing
70 Flow Specifics
71 Need for Nginx
72 Multi-Step Docker Builds
73 Implementing Multi-Step Builds
74 Running Nginx
75 Docker’s Purpose
76 Project Generation
77 More on Project Generation
78 Necessary Commands
79 Creating the Dev Dockerfile
80 Duplicating Dependencies
81 Starting the Container

Continuous Integration and Deployment with AWS
82 Services Overview
83 Travis Config for Deployment
84 Automated Deployments
85 Exposing Ports Through the Dockerfile
86 AWS Build Still Failing
87 Workflow With Github
88 Redeploy on Pull Request Merge
89 Deployment Wrapup
90 Environment Cleanup
91 Github Setup
92 Travis CI Setup
93 Travis YML File Configuration
94 Fix for Failing Travis Builds
95 A Touch More Travis Setup
96 Automatic Build Creation
97 AWS Elastic Beanstalk
98 More on Elastic Beanstalk

Building a Multi-Container Application
99 Single Container Deployment Issues
100 Fetching Data in the React App
101 Rendering Logic in the App
102 Exporting the Fib Class
103 Routing in the React App
104 Application Overview
105 A Quick Note
106 Application Architecture
107 Worker Process Setup
108 Express API Setup
109 Connecting to Postgres
110 More Express API Setup
111 Generating the React App

Dockerizing Multiple Services
112 Checkpoint Files
113 Routing with Nginx
114 Building a Custom Nginx Image
115 Starting Up Docker Compose
116 Troubleshooting
117 Troubleshooting Startup Bugs
118 Opening Websocket Connections
119 Checkpoint Catchup
120 Dockerizing a React App – Again!
121 Dockerizing Generic Node Apps
122 Adding Postgres as a Service
123 Docker-compose Config
124 Environment Variables with Docker Compose
125 The Worker and Client Services
126 Nginx Path Routing

A Continuous Integration Workflow for Multiple Images
127 Production Multi-Container Deployments
128 Pushing Images to Docker Hub
129 Successful Image Building
130 Production Dockerfiles
131 Multiple Nginx Instances
132 Altering Nginx’s Listen Port
133 Nginx fix for React Router
134 Cleaning Up Tests
135 Github and Travis CI Setup
136 Fix for Failing Travis Builds
137 Travis Configuration Setup

Multi-Container Deployments to AWS
138 Multi-Container Definition Files
139 ElastiCache Redis Creation
140 Creating a Custom Security Group
141 Applying Security Groups to Resources
142 Setting Environment Variables
143 IAM Keys for Deployment
144 Travis Script Fix for access key id
145 Travis Deploy Script
146 Container Memory Allocations
147 Verifying Deployment
148 A Quick App Change
149 Finding Docs on Container Definitions
150 Making Changes
151 Cleaning Up AWS Resources
152 AWS Configuration Cheat Sheet
153 Adding Container Definitions to DockerRun
154 More Container Definitions
155 Forming Container Links
156 Creating the EB Environment
157 Managed Data Service Providers
158 Overview of AWS VPC’s and Security Groups
159 RDS Database Creation

Onwards to Kubernetes!
160 The Why’s and What’s of Kubernetes
161 Object Types and API Versions
162 Running Containers in Pods
163 Service Config Files in Depth
164 Connecting to Running Containers
165 The Entire Deployment Flow
166 Imperative vs Declarative Deployments
167 Kubernetes in Development and Production
168 Minikube Setup on MacOS
169 Minikube Setup on Windows ProEnterprise
170 Minikube Setup on Windows Home
171 Minikube Setup on Linux
172 Docker Desktop’s Kubernetes instead of Minikube
173 Mapping Existing Knowledge
174 Adding Configuration Files

Maintaining Sets of Containers with Deployments
175 Updating Existing Objects
176 Updating Deployment Images
177 Rebuilding the Client Image
178 Triggering Deployment Updates
179 Imperatively Updating a Deployment’s Image
180 Multiple Docker Installations
181 Reconfiguring Docker CLI
182 Why Mess with Docker in the Node
183 Declarative Updates in Action
184 Limitations in Config Updates
185 Running Containers with Deployments
186 Deployment Configuration Files
187 Walking Through the Deployment Config
188 Applying a Deployment
189 Why Use Services
190 Scaling and Changing Deployments

A Multi-Container App with Kubernetes
191 The Path to Production
192 Combining Config Into Single Files
193 The Worker Deployment
194 Reapplying a Batch of Config Files
195 Creating and Applying Redis Config
196 Last Set of Boring Config!
197 The Need for Volumes with Databases
198 Kubernetes Volumes
199 Volumes vs Persistent Volumes
200 Persistent Volumes vs Persistent Volume Claims
201 Claim Config Files
202 Checkpoint Files
203 Persistent Volume Access Modes
204 Where Does Kubernetes Allocate Persistent Volumes
205 Designating a PVC in a Pod Template
206 Fix for Postgres CrashLoopBackOff Error on Windows Pro
207 Applying a PVC
208 Defining Environment Variables
209 Adding Environment Variables to Config
210 Creating an Encoded Secret
211 Passing Secrets as Environment Variables
212 Environment Variables as Strings
213 A Quick Checkpoint
214 Recreating the Deployment
215 NodePort vs ClusterIP Services
216 The ClusterIP Config
217 Applying Multiple Files with Kubectl
218 Express API Deployment Config
219 Cluster IP for the Express API

Handling Traffic with Ingress Controllers
220 Load Balancer Services
221 Fix for ingress-service.yaml Configuration
222 Testing Ingress Locally
223 The Minikube Dashboard
224 Docker Desktop’s Kubernetes Dashboard
225 A Quick Note on Ingresses
226 One Other Quick Note!
227 Behind the Scenes of Ingress
228 More Behind the Scenes of Ingress
229 Optional Reading on Ingress Nginx
230 Setting up Ingress Locally with Minikube
231 Setting up Ingress with Docker Desktop’s Kubernetes
232 Creating the Ingress Configuration

Kubernetes Production Deployment
233 The Deployment Process
234 Don’t Forget to Cleanup!
235 Kubernetes Dashboard on Google Cloud
236 Travis Deployment Overview
237 Installing the Google Cloud SDK
238 Generating a Service Account
239 Running Travis CLI in a Container
240 Encrypting a Service Account File
241 More Google Cloud CLI Config
242 Fix For Failing Travis Builds
243 Running Tests with Travis
244 Google Cloud vs AWS for Kubernetes
245 Custom Deployment Providers
246 Unique Deployment Images
247 Unique Tags for Built Images
248 Updating the Deployment Script
249 Configuring the GCloud CLI on Cloud Console
250 Creating a Secret on Google Cloud
251 Helm Setup
252 Kubernetes Security with RBAC
253 Assigning Tiller a Service Account
254 Ingress-Nginx with Helm
255 Creating a Git Repo
256 The Result of Ingress-Nginx
257 Finally – Deployment!
258 Did I Really Type That
259 Verifying Deployment
260 A Workflow for Changing in Prod
261 Merging a PR for Deployment
262 That’s It! What’s Next
263 Linking the Github Repo to Travis
264 Free Google Cloud Credits
265 Creating a Google Cloud Project
266 Linking a Billing Account
267 Kubernetes Engine Init
268 Creating a Cluster with Google Cloud

HTTPS Setup with Kubernetes
269 HTTPS Setup Overview
270 Ingress Config for HTTPS
271 It Worked!
272 Google Cloud Cleanup
273 Local Environment Cleanup
274 Domain Purchase
275 Domain Name Setup
276 Cert Manager Install
277 Fix for Failing Travis Builds
278 How to Wire Up Cert Manager
279 Issuer Config File
280 Certificate Config File
281 Deploying Changes
282 Verifying the Certificate

Local Development with Skaffold
283 Awkward Local Development
284 Installing Skaffold
285 The Skaffold Config File
286 Live Sync Changes
287 Automatic Shutdown
288 Testing Live Sync with the API Server