Docker and Kubernetes: The Complete Guide
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.
More
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
- 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
- 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 Docker and Kubernetes: The Complete Guide
| # | Title | Duration |
|---|---|---|
| 1 | Why Use Docker? | 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 |
Similar courses to Docker and Kubernetes: The Complete Guide
Kubernetes Certified Application Developer (CKAD) with Tests
DevOps Deployment Automation with Terraform, AWS and Docker
The complete guide to running Java in Docker and Kubernetes
Amazon EKS Starter: Docker on AWS EKS with Kubernetes
Istio Hands-On for Kubernetes
Mastering Kubernetes
Cloud-Native: Microservices, Kubernetes, Service Mesh, CI/CD
