Docker and Kubernetes: The Complete Guide
4.7 (31,648 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
148,908 students enrolled

Docker and Kubernetes: The Complete Guide

Build, test, and deploy Docker applications with Kubernetes while learning production-style development workflows
4.7 (31,648 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
148,908 students enrolled
Created by Stephen Grider
Last updated 9/2020
English
English [Auto], French [Auto], 5 more
  • German [Auto]
  • Indonesian [Auto]
  • Italian [Auto]
  • Portuguese [Auto]
  • Spanish [Auto]
This course includes
  • 21.5 hours on-demand video
  • 62 articles
  • 18 downloadable resources
  • Access on mobile
  • Certificate of Completion
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!
Course content
Expand all 319 lectures 22:04:22
+ Dive Into Docker!
13 lectures 35:22
Finished Code Repositories and Diagrams
00:13
Installing Docker for Windows Home users
00:44
Installing Docker for Windows Profressional
02:03
More Windows Professional Setup
00:40
One Last Piece of Windows Professional Setup
01:09
Installing Docker on Linux
00:58
Using the Docker Client
05:03
But Really...What's a Container?
08:30
How's Docker Running on Your Computer?
02:44
+ Manipulating Containers with the Docker Client
14 lectures 50:59
Docker Run in Detail
01:54
Overriding Default Commands
05:12
Listing Running Containers
04:09
Container Lifecycle
05:16
Restarting Stopped Containers
03:43
Removing Stopped Containers
01:39
Retrieving Log Outputs
02:33
Stopping Containers
05:21
Multi-Command Containers
04:16
Executing Commands in Running Containers
02:53
The Purpose of the IT Flag
04:35
Getting a Command Prompt in a Container
04:06
Starting with a Shell
02:13
Container Isolation
03:09
+ Building Custom Images Through Docker Server
10 lectures 47:03
Creating Docker Images
02:36
Building a Dockerfile
04:51
Dockerfile Teardown
02:41
What's a Base Image?
05:40
The Build Process in Detail
11:09
A Brief Recap
03:24
Rebuilds with Cache
07:02
Tagging an Image
04:26
Quick Note for Windows Users
00:14
Manual Image Generation with Docker Commit
05:00
+ Making Real Projects with Docker
12 lectures 53:36
Project Outline
02:35
Node Server Setup
05:03
A Few Planned Errors
05:12
Base Image Issues
07:50
A Few Missing Files
03:18
Copying Build Files
04:50
Reminder for Windows Home / Docker Toolbox Students
00:13
Container Port Mapping
07:26
Specifying a Working Directory
07:52
Unnecessary Rebuilds
04:16
Minimizing Cache Busting and Rebuilds
04:58
Completed Code for Section 4
00:03
+ Docker Compose with Multiple Local Containers
12 lectures 52:15
App Overview
03:57
App Server Starter Code
06:43
Assembling a Dockerfile
03:12
Introducing Docker Compose
05:31
Docker Compose Files
06:02
Networking with Docker Compose
05:00
Docker Compose Commands
04:38
Stopping Docker Compose Containers
02:34
Container Maintenance with Compose
02:53
Automatic Container Restarts
09:21
Container Status with Docker Compose
02:21
Completed Code for Section 5 Visits App
00:03
+ Creating a Production-Grade Workflow
29 lectures 01:34:50
Development Workflow
01:28
Flow Specifics
06:32
Docker's Purpose
01:50
Project Generation
03:25
Create React App Generation
00:19
More on Project Generation
01:44
Necessary Commands
05:09
Creating the Dev Dockerfile
03:42
Duplicating Dependencies
01:29
React App Exits Immediately with Docker Run Command
00:10
Starting the Container
02:50
Docker Volumes
06:53
Windows not Detecting Changes - Update
01:58
Bookmarking Volumes
04:50
React App Exited With Code 0
00:13
Shorthand with Docker Compose
04:22
Overriding Dockerfile Selection
02:02
Windows not Detecting Changes - Docker Compose
00:08
Do We Need Copy?
02:51
Executing Tests
03:38
Live Updating Tests
04:54
Docker Compose for Running Tests
05:45
Tests Not Re-running on Windows
00:25
Attaching to Web container
00:08
Shortcomings on Testing
08:30
Need for Nginx
03:07
Multi-Step Docker Builds
06:54
Implementing Multi-Step Builds
07:05
Running Nginx
02:27
+ Continuous Integration and Deployment with AWS
20 lectures 01:05:38
Services Overview
03:04
Github Setup
03:57
Travis CI Setup
04:17
Travis YML File Configuration
07:39
Required Travis Updates
00:21
A Touch More Travis Setup
04:14
Automatic Build Creation
03:30
AWS Elastic Beanstalk
04:10
More on Elastic Beanstalk
02:25
Travis Config for Deployment
08:46
Travis Keys Update
00:12
Automated Deployments
07:17
Exposing Ports Through the Dockerfile
03:56
AWS Build Still Failing?
00:57
Workflow With Github
03:59
Redeploy on Pull Request Merge
02:01
Deployment Wrapup
02:03
Environment Cleanup
00:24
AWS Configuration Cheat Sheet
02:18
Finished Project Code with Updates Applied
00:07
+ Building a Multi-Container Application
14 lectures 01:12:20
Single Container Deployment Issues
03:02
Application Overview
04:30
A Quick Note
00:15
Application Architecture
05:11
Worker Process Setup
11:41
Express API Setup
05:19
Connecting to Postgres
07:36
More Express API Setup
12:20
Create React App Generation
00:32
Generating the React App
01:51
Fetching Data in the React App
06:31
Rendering Logic in the App
08:29
Exporting the Fib Class
00:26
Routing in the React App
04:36
+ "Dockerizing" Multiple Services
18 lectures 01:17:44
Checkpoint Files
00:06
Checkpoint Catchup
02:39
Dockerizing a React App - Again!
06:41
Dockerizing Generic Node Apps
03:47
Adding Postgres as a Service
07:05
Docker-compose Config
06:17
Postgres Database Required Fixes and Updates
00:37
Environment Variables with Docker Compose
10:20
The Worker and Client Services
03:42
Nginx Path Routing
09:41
Routing with Nginx
11:12
Building a Custom Nginx Image
05:38
React App Exited With Code 0
00:13
Starting Up Docker Compose
01:50
Nginx connect() failed - Connection refused while connecting to upstream
00:15
Fix for "I Calculated Nothing Yet" message
00:25
Troubleshooting Startup Bugs
03:22
Opening Websocket Connections
03:51
+ A Continuous Integration Workflow for Multiple Images
11 lectures 46:04
Production Multi-Container Deployments
05:39
Production Dockerfiles
06:05
Multiple Nginx Instances
05:23
Altering Nginx's Listen Port
04:53
Nginx fix for React Router
00:14
Cleaning Up Tests
01:11
Github and Travis CI Setup
04:08
Fix for Failing Travis Builds
00:22
Travis Configuration Setup
08:45
Pushing Images to Docker Hub
07:34
Successful Image Building
01:49
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
Description

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


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

Who this course is for:
  • Software engineers looking to deploy their apps easily and quickly