Docker and Kubernetes – The Complete Developers Guide

Course Curriculum

Chapter 1: Introduction

Lecture 1: What We'll Learn

Lecture 2: Some Stuff We Need to Download

Lecture 3: Installing Docker Desktop

Lecture 4: Docker Desktop for Windows User

Chapter 2: What is Docker

Lecture 1: A Little Analogy

Lecture 2: Relating Our Analogy to Docker

Chapter 3: Dockerfiles, Containers and Images

Lecture 1: Building a Small Node App

Lecture 2: Running Our Node App Locally

Lecture 3: Creating a Dockerfile

Lecture 4: We are Really Building an Image

Lecture 5: Understanding the Rest of the Dockerfile

Lecture 6: Building an Image and Running a Container

Lecture 7: Port Mapping

Lecture 8: Rebuilding Our Image

Lecture 9: Syncing Our Code with Bind Mounts

Lecture 10: Using Anonymous Volumes

Lecture 11: It's Not Docker's Fault!

Lecture 12: Ignoring Files with Docker Ignore

Lecture 13: Docker Layering and Caching

Chapter 4: Optional Challenge – Dockerizing an App

Lecture 1: The Challenge

Lecture 2: The Solution

Chapter 5: Deploying a Containerized Application

Lecture 1: An Intro to Control Plane

Lecture 2: Viewing Our GVC

Lecture 3: Pushing Our Image to an Image Repository

Lecture 4: Running a Workload

Lecture 5: Killing Our Deployment

Chapter 6: Multi Containers and Network Communications

Lecture 1: Application Overview

Lecture 2: How to Handle Multiple Component Applications

Lecture 3: Going Through the Starter Code

Lecture 4: Pulling Images From an Image Repository

Lecture 5: Building our Node Image and Running the Container

Lecture 6: Connecting Our Containers Through Localhost

Lecture 7: Utilizing the Container's IP Address

Lecture 8: Introducing Docker Networks

Lecture 9: Dockerizing Our React App

Lecture 10: Running into a Little Issue

Lecture 11: Client Side Rendering is the Problem

Lecture 12: Optimizing Our Workflow with Volumes

Chapter 7: Docker Compose for Multi Container Apps

Lecture 1: An Intro to Docker Compose

Lecture 2: A Little About YAML Syntax

Lecture 3: Writing the MongoDB Configuration

Lecture 4: Setting Environment Variables

Lecture 5: docker-compose up and docker-compose down

Lecture 6: Setting Up the Backend Container

Lecture 7: Testing the Integration

Lecture 8: Setting Up the Frontend Container

Chapter 8: Deploying to AWS with ECS

Lecture 1: Our Deployment Workflow

Lecture 2: Writing the Dockerfile

Lecture 3: Running the Container Locally

Lecture 4: Create an Image Repository and Downloading the AWS CLI

Lecture 5: IAM for Access Management

Lecture 6: Pushing Our Image to the Registry

Lecture 7: Creating an ECS Cluster

Lecture 8: Creating a Task Definition

Lecture 9: Running the Task with a ECS Service

Lecture 10: Configuring the Inbound Rules of Our Security Group

Chapter 9: Automating Our Workflows with a CI/CD Pipeline

Lecture 1: Redeploying Changes in the Codebase

Lecture 2: The Issues with a Manual Process

Lecture 3: The Solution is Automation

Lecture 4: Understanding a Production Grade Workflow

Lecture 5: Pushing Our Code to GitHub

Lecture 6: Creating a Pull Request

Lecture 7: Building the Integration Pipeline

Lecture 8: Setting up Branch Protection Rules (Not Really)

Lecture 9: Setting Up AWS Credentials in GitHub Actions

Lecture 10: Building and Pushing Our Image to ECR

Lecture 11: My Bad Everyone

Lecture 12: Downloading and Updating the task-definition.json File

Lecture 13: Deploying the Task Definition

Lecture 14: Fixing Our Deployment Issue

Lecture 15: The Major Issue with This Solution

Lecture 16: Blue/Green Deployments is the Optimal Solution

Lecture 17: Tearing Down the ECS Cluster

Chapter 10: Multi Container Deployment to AWS ECS

Lecture 1: Multi Container Deployment

Lecture 2: The Need for NGINX

Lecture 3: Multi Stage Dockerfile

Lecture 4: The Issues With Using a Database Container

Lecture 5: Setting Up Our Codebase for Deployment

Lecture 6: Pushing Our Image to AWS ECR

Lecture 7: Defining a Multi Container Task Defintion

Lecture 8: Adding Environment Variables

Lecture 9: Updating the Task Definition

Chapter 11: Time for Kubernetes

Lecture 1: Our New (Much Larger) Project

Lecture 2: Can We Just Do the Same Thing?

Lecture 3: Kubernetes to the Rescue

Lecture 4: Communication via Kubectl

Lecture 5: Installing Kubernetes

Chapter 12: Understanding Pods

Lecture 1: Writing Our First Manifest File