Docker and Kubernetes The Complete Guide

Docker and Kubernetes The Complete Guide

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!

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 PipelinesOf 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 requiredBuild your own custom images tailored to your applicationsMaster the Docker CLI to inspect and debug running containersUnderstand how Docker works behind the scenes, and what a container isBuild a CI + CD pipeline from scratch with Github, Travis CI, and AWSAutomatically deploy your code when it is pushed to Github!Build a complex multi-container application from scratch and deploy it to AWSUnderstand the purpose and theory of KubernetesDeploy a production-ready Kubernetes Cluster to Google Cloud

Overview

Section 1: Dive Into Docker!

Lecture 1 Finished Code and Diagrams

Lecture 2 Join Our Community!

Lecture 3 Why Use Docker?

Lecture 4 What is Docker?

Lecture 5 Docker for Mac/Windows

Lecture 6 Installing Docker on macOS

Lecture 7 Installing Docker with WSL2 on Windows 10/11

Lecture 8 Installing Docker on Linux

Lecture 9 Using the Docker Client

Lecture 10 But Really…What’s a Container?

Lecture 11 How’s Docker Running on Your Computer?

Section 2: Manipulating Containers with the Docker Client

Lecture 12 Docker Run in Detail

Lecture 13 Overriding Default Commands

Lecture 14 Listing Running Containers

Lecture 15 Container Lifecycle

Lecture 16 Restarting Stopped Containers

Lecture 17 Removing Stopped Containers

Lecture 18 Retrieving Log Outputs

Lecture 19 Stopping Containers

Lecture 20 Multi-Command Containers

Lecture 21 Executing Commands in Running Containers

Lecture 22 The Purpose of the IT Flag

Lecture 23 Getting a Command Prompt in a Container

Lecture 24 Starting with a Shell

Lecture 25 Container Isolation

Section 3: Building Custom Images Through Docker Server

Lecture 26 Creating Docker Images

Lecture 27 Buildkit for Docker Desktop

Lecture 28 Building a Dockerfile

Lecture 29 Dockerfile Teardown

Lecture 30 What’s a Base Image?

Lecture 31 The Build Process in Detail

Lecture 32 A Brief Recap

Lecture 33 Rebuilds with Cache

Lecture 34 Tagging an Image

Lecture 35 Quick Note for Windows Users

Lecture 36 Manual Image Generation with Docker Commit

Section 4: Making Real Projects with Docker

Lecture 37 Project Outline

Lecture 38 Node Server Setup

Lecture 39 A Few Planned Errors

Lecture 40 Required Node Base Image Version

Lecture 41 Base Image Issues

Lecture 42 A Few Missing Files

Lecture 43 Copying Build Files

Lecture 44 Container Port Mapping

Lecture 45 Specifying a Working Directory

Lecture 46 Unnecessary Rebuilds

Lecture 47 Minimizing Cache Busting and Rebuilds

Section 5: Docker Compose with Multiple Local Containers

Lecture 48 App Overview

Lecture 49 App Server Starter Code

Lecture 50 Assembling a Dockerfile

Lecture 51 Introducing Docker Compose

Lecture 52 Docker Compose Files

Lecture 53 Networking with Docker Compose

Lecture 54 Docker Compose Commands

Lecture 55 Stopping Docker Compose Containers

Lecture 56 Container Maintenance with Compose

Lecture 57 Automatic Container Restarts

Lecture 58 Container Status with Docker Compose

Section 6: Creating a Production-Grade Workflow

Lecture 59 Development Workflow

Lecture 60 Flow Specifics

Lecture 61 Docker’s Purpose

Lecture 62 Project Generation

Lecture 63 Create React App Generation

Lecture 64 More on Project Generation

Lecture 65 Necessary Commands

Lecture 66 Creating the Dev Dockerfile

Lecture 67 Duplicating Dependencies

Lecture 68 Starting the Container

Lecture 69 Docker Volumes

Lecture 70 WSL2 and Windows Users Must Read Before Next Lecture

Lecture 71 Bookmarking Volumes

Lecture 72 Shorthand with Docker Compose

Lecture 73 Overriding Dockerfile Selection

Lecture 74 Do We Need Copy?

Lecture 75 Executing Tests

Lecture 76 Live Updating Tests

Lecture 77 Docker Compose for Running Tests

Lecture 78 Shortcomings on Testing

Lecture 79 Need for Nginx

Lecture 80 Multi-Step Docker Builds

Lecture 81 Implementing Multi-Step Builds

Lecture 82 Running Nginx

Section 7: Continuous Integration and Deployment with AWS

Lecture 83 Services Overview

Lecture 84 Github Setup

Lecture 85 Important Info About Travis and Account Registration

Lecture 86 Travis CI Setup

Lecture 87 Travis YML File Configuration

Lecture 88 Required Travis Script Updates

Lecture 89 A Touch More Travis Setup

Lecture 90 Automatic Build Creation

Lecture 91 Required Updates for Amazon Linux 2 Platform – DO NOT SKIP

Lecture 92 AWS Elastic Beanstalk

Lecture 93 More on Elastic Beanstalk

Lecture 94 Travis Config for Deployment

Lecture 95 Automated Deployments

Lecture 96 Exposing Ports Through the Dockerfile

Lecture 97 Workflow With Github

Lecture 98 Redeploy on Pull Request Merge

Lecture 99 Deployment Wrapup

Lecture 100 Environment Cleanup

Lecture 101 AWS Configuration Cheat Sheet

Lecture 102 Finished Project Code with Updates Applied

Section 8: Building a Multi-Container Application

Lecture 103 Single Container Deployment Issues

Lecture 104 Application Overview

Lecture 105 A Quick Note

Lecture 106 Application Architecture

Lecture 107 Worker Process Setup

Lecture 108 Express API Setup

Lecture 109 Important Update for Table Query

Lecture 110 Connecting to Postgres

Lecture 111 More Express API Setup

Lecture 112 Create React App Generation

Lecture 113 Generating the React App

Lecture 114 Fetching Data in the React App

Lecture 115 Rendering Logic in the App

Lecture 116 Exporting the Fib Class

Lecture 117 Routing in the React App

Section 9: “Dockerizing” Multiple Services

Lecture 118 Checkpoint Files

Lecture 119 Checkpoint Catchup

Lecture 120 Expected Output for Latest Create React App Versions

Lecture 121 Dockerizing a React App – Again!

Lecture 122 Dockerizing Generic Node Apps

Lecture 123 Adding Postgres as a Service

Lecture 124 Docker-compose Config

Lecture 125 Postgres Database Required Fixes and Updates

Lecture 126 Environment Variables with Docker Compose

Lecture 127 Required Worker Environment Variables

Lecture 128 The Worker and Client Services

Lecture 129 Nginx Path Routing

Lecture 130 Routing with Nginx

Lecture 131 Building a Custom Nginx Image

Lecture 132 Starting Up Docker Compose

Lecture 133 Nginx connect() failed – Connection refused while connecting to upstream

Lecture 134 Troubleshooting Startup Bugs

Lecture 135 WebSocket connection to ‘ws://localhost:3000/ws’ failed

Lecture 136 Opening Websocket Connections

Section 10: A Continuous Integration Workflow for Multiple Images

Lecture 137 Production Multi-Container Deployments

Lecture 138 Production Dockerfiles

Lecture 139 Multiple Nginx Instances

Lecture 140 Nginx fix for React Router

Lecture 141 Altering Nginx’s Listen Port

Lecture 142 Cleaning Up Tests

Lecture 143 Travis Configuration Setup

Lecture 144 Fix for Failing Travis Builds

Lecture 145 Github and Travis CI Setup

Lecture 146 Pushing Images to Docker Hub

Lecture 147 Successful Image Building

Section 11: Multi-Container Deployments to AWS

Lecture 148 Important Info About Multi Containers on Amazon Linux 2 Platform

Lecture 149 Multi-Container Definition Files

Lecture 150 Finding Docs on Container Definitions

Lecture 151 Adding Container Definitions to DockerRun

Lecture 152 More Container Definitions

Lecture 153 Forming Container Links

Lecture 154 Using the Amazon Linux 2 Platform

Lecture 155 AWS Configuration Cheat Sheet – Updated for new UI

Lecture 156 Creating the EB Environment

Lecture 157 Managed Data Service Providers

Lecture 158 Overview of AWS VPC’s and Security Groups

Lecture 159 RDS Database Creation

Lecture 160 ElastiCache Redis Creation

Lecture 161 Creating a Custom Security Group

Lecture 162 Applying Security Groups to Resources

Lecture 163 Setting Environment Variables

Lecture 164 IAM Keys for Deployment

Lecture 165 Travis Keys Update

Lecture 166 Travis Deploy Script

Lecture 167 Container Memory Allocations

Lecture 168 Verifying Deployment

Lecture 169 A Quick App Change

Lecture 170 Making Changes

Lecture 171 Cleaning Up AWS Resources

Lecture 172 AWS Configuration Cheat Sheet

Lecture 173 Finished Project Code with Updates Applied

Section 12: Onwards to Kubernetes!

Lecture 174 The Why’s and What’s of Kubernetes

Lecture 175 Kubernetes in Development and Production

Lecture 176 Docker Desktop’s Kubernetes Setup and Installation – macOS

Lecture 177 Docker Desktop’s Kubernetes Setup and Installation – Windows

Lecture 178 Updated Minikube Install and Setup Info – macOS

Lecture 179 Minikube Setup on MacOS

Lecture 180 Minikube Setup on Windows

Lecture 181 Minikube Setup on Linux

Lecture 182 Mapping Existing Knowledge

Lecture 183 Quick Note to Prevent an Error

Lecture 184 Adding Configuration Files

Lecture 185 Object Types and API Versions

Lecture 186 Running Containers in Pods

Lecture 187 Service Config Files in Depth

Lecture 188 Connecting to Running Containers

Lecture 189 The Entire Deployment Flow

Lecture 190 Imperative vs Declarative Deployments

Section 13: Maintaining Sets of Containers with Deployments

Lecture 191 Updating Existing Objects

Lecture 192 Declarative Updates in Action

Lecture 193 Limitations in Config Updates

Lecture 194 Running Containers with Deployments

Lecture 195 Quick Note to Prevent an Error

Lecture 196 Deployment Configuration Files

Lecture 197 Walking Through the Deployment Config

Lecture 198 Applying a Deployment

Lecture 199 Why Use Services?

Lecture 200 Scaling and Changing Deployments

Lecture 201 Updating Deployment Images

Lecture 202 Rebuilding the Client Image

Lecture 203 Triggering Deployment Updates

Lecture 204 Imperatively Updating a Deployment’s Image

Lecture 205 Reminder for Docker Desktop’s Kubernetes Users

Lecture 206 Multiple Docker Installations

Lecture 207 Reconfiguring Docker CLI

Lecture 208 Why Mess with Docker in the Node?

Section 14: A Multi-Container App with Kubernetes

Lecture 209 The Path to Production

Lecture 210 Checkpoint Files

Lecture 211 A Quick Checkpoint

Lecture 212 Recreating the Deployment

Lecture 213 NodePort vs ClusterIP Services

Lecture 214 The ClusterIP Config

Lecture 215 Applying Multiple Files with Kubectl

Lecture 216 Express API Deployment Config

Lecture 217 Cluster IP for the Express API

Lecture 218 Combining Config Into Single Files

Lecture 219 The Worker Deployment

Lecture 220 Reapplying a Batch of Config Files

Lecture 221 Creating and Applying Redis Config

Lecture 222 Important Note about Expected Postgres Error

Lecture 223 Last Set of Boring Config!

Lecture 224 The Need for Volumes with Databases

Lecture 225 Kubernetes Volumes

Lecture 226 Volumes vs Persistent Volumes

Lecture 227 Persistent Volumes vs Persistent Volume Claims

Lecture 228 Claim Config Files

Lecture 229 Persistent Volume Access Modes

Lecture 230 Where Does Kubernetes Allocate Persistent Volumes?

Lecture 231 Designating a PVC in a Pod Template

Lecture 232 Applying a PVC

Lecture 233 Defining Environment Variables

Lecture 234 Adding Environment Variables to Config

Lecture 235 Creating an Encoded Secret

Lecture 236 Postgres Environment Variable Fix

Lecture 237 Passing Secrets as Environment Variables

Lecture 238 Environment Variables as Strings

Section 15: Handling Traffic with Ingress Controllers

Lecture 239 Load Balancer Services

Lecture 240 A Quick Note on Ingresses

Lecture 241 One Other Quick Note!

Lecture 242 Behind the Scenes of Ingress

Lecture 243 More Behind the Scenes of Ingress

Lecture 244 Optional Reading on Ingress Nginx

Lecture 245 Docker Driver and Ingress – IMPORTANT

Lecture 246 Important – DO NOT SKIP – Ingress Nginx Installation Info

Lecture 247 Setting up Ingress Locally with Minikube

Lecture 248 Ingress v1 API Update + “this.state.seenIndexes.map…” + 404 errors

Lecture 249 Creating the Ingress Configuration

Lecture 250 Testing Ingress Locally

Lecture 251 The Minikube Dashboard

Lecture 252 Docker Desktop’s Kubernetes Dashboard

Section 16: Kubernetes Production Deployment

Lecture 253 The Deployment Process

Lecture 254 Google Cloud vs AWS for Kubernetes

Lecture 255 Creating a Git Repo

Lecture 256 Linking the Github Repo to Travis

Lecture 257 Free Google Cloud Credits

Lecture 258 Creating a Google Cloud Project

Lecture 259 Linking a Billing Account

Lecture 260 Updated GKE creation steps for new Google Cloud UI

Lecture 261 Kubernetes Engine Init

Lecture 262 Creating a Cluster with Google Cloud

Lecture 263 Don’t Forget to Cleanup!

Lecture 264 Kubernetes Dashboard on Google Cloud

Lecture 265 Travis Deployment Overview

Lecture 266 Installing the Google Cloud SDK

Lecture 267 Updated Service Account steps for new GCP UI

Lecture 268 Generating a Service Account

Lecture 269 Ruby Version Fix

Lecture 270 Running Travis CLI in a Container

Lecture 271 Travis Login Issues, “iv undefined” or “repository not known”

Lecture 272 Encrypting a Service Account File

Lecture 273 More Google Cloud CLI Config

Lecture 274 Fix For Failing Travis Builds

Lecture 275 Running Tests with Travis

Lecture 276 Custom Deployment Providers

Lecture 277 Unique Deployment Images

Lecture 278 Unique Tags for Built Images

Lecture 279 Updating the Deployment Script

Lecture 280 Configuring the GCloud CLI on Cloud Console

Lecture 281 Creating a Secret on Google Cloud

Lecture 282 Helm v3 Update

Lecture 283 Helm Setup

Lecture 284 Kubernetes Security with RBAC

Lecture 285 Assigning Tiller a Service Account

Lecture 286 Ingress-Nginx with Helm

Lecture 287 Quick Note about the Default Backend

Lecture 288 The Result of Ingress-Nginx

Lecture 289 Finally – Deployment!

Lecture 290 Did I Really Type That?

Lecture 291 Verifying Deployment

Lecture 292 A Workflow for Changing in Prod

Lecture 293 Merging a PR for Deployment

Lecture 294 That’s It! What’s Next?

Lecture 295 Completed Code For Google Cloud Deployment

Section 17: HTTPS Setup with Kubernetes

Lecture 296 HTTPS Setup Overview

Lecture 297 Domain Purchase

Lecture 298 Domain Name Setup

Lecture 299 Required Updates for Cert Manager Install

Lecture 300 Cert Manager Install

Lecture 301 How to Wire Up Cert Manager

Lecture 302 Required Update for Issuer

Lecture 303 Issuer Config File

Lecture 304 Required Update for the Certificate

Lecture 305 Certificate Config File

Lecture 306 Deploying Changes

Lecture 307 No Resources Found?

Lecture 308 Verifying the Certificate

Lecture 309 Required Update for the HTTPS Ingress

Lecture 310 Ingress Config for HTTPS

Lecture 311 It Worked!

Lecture 312 Google Cloud Cleanup

Lecture 313 Local Environment Cleanup

Section 18: Local Development with Skaffold

Lecture 314 Awkward Local Development

Lecture 315 Installing Skaffold

Lecture 316 The Skaffold Config File

Lecture 317 Skaffold Sync Update and Example Source Code

Lecture 318 Live Sync Changes

Lecture 319 Automatic Shutdown

Lecture 320 Testing Live Sync with the API Server

Section 19: Extras

Lecture 321 Bonus!

Software engineers looking to deploy their apps easily and quickly

Course Information:

Udemy | English | 22h 9m | 12.37 GB
Created by: Stephen Grider

You Can See More Courses in the Developer >> Greetings from CourseDown.com