Docker and Kubernetes - The Complete Developers Guide
12h 40m 38s
English
Free
Course description
In this course we will take you from a Docker and Kubernetes novice to job ready engineer. This course is loaded with diagrams and practical examples so that you can truly understand and utilize Docker and Kubernetes in great depth. We will be containerize five projects, each one getting more and more complex. We need end this course by containerizing a multi component microservice application with Kubernetes and eventually deploying it to AWS.
Read more about the course
By the end of this course, you should have multiple practical example to show off your knowledge!
Here are a list of thing you will learn in this course:
What are Docker containers and why would we want to use it
How to build docker images and run docker containers
How to connect to a container from our host machine
How to persistent data inside of a database container
How to build a multi-component application with docker-compose
Understand the benefits and powers of Kubernetes
Understand the many different Kubernetes objects
Understand how a Kubernetes Cluster is structured
How to containerize a multi-component application with Kubernetes
How to push and pull images from image repositories
How to deploy a containerized application to AWS ECS and AWS EKS
How to build a production ready CI/CD Pipeline
I really hope you enjoy this course and learn a ton from it!
Watch Online
0:00 0:00
| # | Lesson Title | Duration |
|---|---|---|
| 1 | What We'll Learn | 03:26 |
| 2 | Some Stuff We Need to Download | 03:12 |
| 3 | Installing Docker Desktop | 03:15 |
| 4 | A Little Analogy | 05:49 |
| 5 | Relating Our Analogy to Docker | 07:28 |
| 6 | Building a Small Node App | 06:17 |
| 7 | Running Our Node App Locally | 05:48 |
| 8 | Creating a Dockerfile | 03:39 |
| 9 | We are Really Building an Image | 05:29 |
| 10 | Understanding the Rest of the Dockerfile | 08:21 |
| 11 | Building an Image and Running a Container | 06:55 |
| 12 | Port Mapping | 04:18 |
| 13 | Rebuilding Our Image | 06:15 |
| 14 | Syncing Our Code with Bind Mounts | 04:38 |
| 15 | Using Anonymous Volumes | 07:03 |
| 16 | It's Not Docker's Fault! | 09:19 |
| 17 | Ignoring Files with Docker Ignore | 06:18 |
| 18 | Docker Layering and Caching | 07:34 |
| 19 | The Challenge | 05:17 |
| 20 | The Solution | 10:13 |
| 21 | An Intro to Control Plane | 05:57 |
| 22 | Viewing Our GVC | 03:35 |
| 23 | Pushing Our Image to an Image Repository | 07:40 |
| 24 | Running a Workload | 02:53 |
| 25 | Killing Our Deployment | 00:47 |
| 26 | Application Overview | 02:43 |
| 27 | How to Handle Multiple Component Applications | 04:58 |
| 28 | Going Through the Starter Code | 03:48 |
| 29 | Pulling Images From an Image Repository | 06:43 |
| 30 | Building our Node Image and Running the Container | 04:20 |
| 31 | Connecting Our Containers Through Localhost | 09:51 |
| 32 | Utilizing the Container's IP Address | 05:20 |
| 33 | Introducing Docker Networks | 06:00 |
| 34 | Dockerizing Our React App | 02:59 |
| 35 | Running into a Little Issue | 04:40 |
| 36 | Client Side Rendering is the Problem | 05:30 |
| 37 | Optimizing Our Workflow with Volumes | 17:07 |
| 38 | An Intro to Docker Compose | 03:54 |
| 39 | A Little About YAML Syntax | 04:32 |
| 40 | Writing the MongoDB Configuration | 04:44 |
| 41 | Setting Environment Variables | 05:13 |
| 42 | docker-compose up and docker-compose down | 03:30 |
| 43 | Setting Up the Backend Container | 10:40 |
| 44 | Testing the Integration | 01:43 |
| 45 | Setting Up the Frontend Container | 05:44 |
| 46 | Our Deployment Workflow | 03:31 |
| 47 | Writing the Dockerfile | 06:22 |
| 48 | Running the Container Locally | 03:02 |
| 49 | Create an Image Repository and Downloading the AWS CLI | 11:23 |
| 50 | IAM for Access Management | 10:28 |
| 51 | Pushing Our Image to the Registry | 04:03 |
| 52 | Creating an ECS Cluster | 07:13 |
| 53 | Creating a Task Definition | 04:15 |
| 54 | Running the Task with a ECS Service | 03:11 |
| 55 | Configuring the Inbound Rules of Our Security Group | 04:16 |
| 56 | Redeploying Changes in the Codebase | 07:56 |
| 57 | The Issues with a Manual Process | 02:10 |
| 58 | The Solution is Automation | 01:21 |
| 59 | Understanding a Production Grade Workflow | 08:06 |
| 60 | Pushing Our Code to GitHub | 02:45 |
| 61 | Creating a Pull Request | 05:11 |
| 62 | Building the Integration Pipeline | 10:05 |
| 63 | Setting up Branch Protection Rules (Not Really) | 02:17 |
| 64 | Setting Up AWS Credentials in GitHub Actions | 11:21 |
| 65 | Building and Pushing Our Image to ECR | 11:49 |
| 66 | My Bad Everyone | 02:38 |
| 67 | Downloading and Updating the task-definition.json File | 10:11 |
| 68 | Deploying the Task Definition | 07:41 |
| 69 | Fixing Our Deployment Issue | 04:24 |
| 70 | The Major Issue with This Solution | 04:56 |
| 71 | Blue/Green Deployments is the Optimal Solution | 04:21 |
| 72 | Tearing Down the ECS Cluster | 01:59 |
| 73 | Multi Container Deployment | 02:08 |
| 74 | The Need for NGINX | 04:06 |
| 75 | Multi Stage Dockerfile | 07:20 |
| 76 | The Issues With Using a Database Container | 05:50 |
| 77 | Setting Up Our Codebase for Deployment | 04:27 |
| 78 | Pushing Our Image to AWS ECR | 04:24 |
| 79 | Defining a Multi Container Task Defintion | 06:46 |
| 80 | Adding Environment Variables | 05:07 |
| 81 | Updating the Task Definition | 04:30 |
| 82 | Our New (Much Larger) Project | 08:15 |
| 83 | Can We Just Do the Same Thing? | 04:28 |
| 84 | Kubernetes to the Rescue | 02:57 |
| 85 | Communication via Kubectl | 03:57 |
| 86 | Installing Kubernetes | 01:33 |
| 87 | Writing Our First Manifest File | 04:50 |
| 88 | Containers Run in Pods | 05:35 |
| 89 | Selecting Kubernetes Objects With the apiVersion | 02:17 |
| 90 | Understanding the Rest of the Manifest File | 09:04 |
| 91 | Running Our Pod | 02:54 |
| 92 | Writing a Service Manifest File | 04:19 |
| 93 | How the NodePort Service Works | 09:31 |
| 94 | Creating the Node and Mongo Pods | 09:16 |
| 95 | ClusterIP Service for Internal Communication | 09:06 |
| 96 | What Happens if the Pod Crashes? | 04:37 |
| 97 | Deployments to the Rescue | 07:50 |
| 98 | Dissecting the Manifest File | 04:21 |
| 99 | Creating the Frontend Store ClusterIP | 04:15 |
| 100 | Creating the Deployment and ClusterIP For the Products API | 05:39 |
| 101 | Creating the MongoDB Deployment | 03:51 |
| 102 | Running All the Manifest Files | 06:43 |
| 103 | Deployment for the Notifications API | 08:26 |
| 104 | Deployment and ClusterIP for RabbitMQ | 05:14 |
| 105 | Checking if Everything Works | 02:20 |
| 106 | Adding Environment Variables to Our Code | 04:46 |
| 107 | Defining Environment Variables | 07:35 |
| 108 | ConfigMaps for Commonly Used Environment Variables | 08:32 |
| 109 | Hide Environment Variables With Secrets | 11:24 |
| 110 | The Need for an Ingress Service | 06:33 |
| 111 | Writing Some Ingress Configuration | 05:50 |
| 112 | Manually Testing Out Our App | 11:52 |
| 113 | Understanding the Ingress Configuration | 08:09 |
| 114 | Our Data is Not Persisting! | 02:38 |
| 115 | A Reminder on Volumes | 02:51 |
| 116 | Kubernetes Volumes Are Not the Solution | 02:53 |
| 117 | Persistent Volumes, for well... Persistent Data | 01:06 |
| 118 | Persistent Volume Claims | 02:16 |
| 119 | Writing the Config and Applying the PVC | 09:19 |
| 120 | The Deployment Process | 07:46 |
| 121 | Creating a EKS Cluster with Eksctl | 05:19 |
| 122 | Understanding Kubectl Context | 06:03 |
| 123 | Creating the Twilio Secret in Prod | 04:18 |
| 124 | Adding an AWS Ingress Load Balancer | 02:40 |
| 125 | Defining the Host Domain | 05:36 |
| 126 | Applying the Rest of Our Configuration | 04:30 |
| 127 | Testing Our Deployed App! | 02:50 |
| 128 | Updating Our Production Cluster | 07:00 |
| 129 | The Steps Our CD Pipeline Needs to Take | 04:19 |
| 130 | Creating a GitHub Repository | 07:12 |
| 131 | Starting Our Deployment Workflow | 11:39 |
| 132 | Building and Pushing Our Image to DockerHub | 08:05 |
| 133 | Completing Our Pipeline By Updating Our Cluster | 07:03 |
| 134 | It Worked! | 01:15 |
| 135 | Deleting Our Cluster | 01:03 |
Comments
0 commentsWant to join the conversation?
Sign in to commentSimilar courses
Docker and Kubernetes: The Complete Guide
Sources: udemy, Stephen Grider
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 drama...
21 hours 32 minutes 42 seconds
DevOps Project - 2022: CI/CD with Jenkins Ansible Kubernetes
Sources: udemy
If you know various DevOps tools like git, Jenkins, Maven, Ansible, Docker, and Kubernetes and are not sure how collaboratively does it work? Or you would like
6 hours 8 minutes 11 seconds
Containers Under the Hood
Sources: udemy
Take your knowledge in Containers and Linux to the next level. You don't need to be a Containers or Linux pro. We will start from the basics. How does this course differ from ot...
11 hours 25 minutes 14 seconds
The complete guide to running Java in Docker and Kubernetes
Sources: udemy
If you need to learn how to run, tune, and maintain JVM applications that run in Docker and/or Kubernetes then this is the course for you. This course is very different from oth...
4 hours 39 minutes 16 seconds