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
React and Django: A Practical Guide with Docker
Sources: udemy
Learn how to create an Admin App using React and Django Rest Framework. Django 3.1, React Typescript, Redux, Docker, Authentication and Authorisation, Upload Im
6 hours 50 minutes 20 seconds
Devops Fundamentals - CI/CD with AWS +Docker+Ansible+Jenkins
Sources: udemy
Lets get into Devops World from Scratch with real time Hands On Projects to build Solutions for CI/CD through Jenkins with deploying Docker Containerized apps
8 hours 46 minutes 37 seconds
DevOps Deployment Automation with Terraform, AWS and Docker
Sources: udemy
Welcome to the advanced course on how to set up a deployment automation that’s capable of handling millions of users! In this course you will learn some of the most in-demand sk...
10 hours 59 minutes 9 seconds
Microservices with NodeJS, React, Typescript and Kubernetes
Sources: udemy
In building large scale applications intended for growth, microservices architecture is the go-to solution. One issue for Javascript and NodeJS learners is the
97 hours 19 minutes 16 seconds