Docker and Kubernetes - The Complete Developers Guide

12:40:38 Inglés Free 22/05/2024 135 videos

Descripción del curso

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.

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!

Curriculum

Section 1: Module 1

02 - What We'll Learn 03:26
03 - Some Stuff We Need to Download 03:12
04 - Installing Docker Desktop 03:15
05 - A Little Analogy 05:49
06 - Relating Our Analogy to Docker 07:28
07 - Building a Small Node App 06:17
08 - Running Our Node App Locally 05:48
09 - Creating a Dockerfile 03:39
10 - We are Really Building an Image 05:29
11 - Understanding the Rest of the Dockerfile 08:21
12 - Building an Image and Running a Container 06:55
13 - Port Mapping 04:18
14 - Rebuilding Our Image 06:15
15 - Syncing Our Code with Bind Mounts 04:38
16 - Using Anonymous Volumes 07:03
17 - It's Not Docker's Fault! 09:19
18 - Ignoring Files with Docker Ignore 06:18
19 - Docker Layering and Caching 07:34
20 - The Challenge 05:17
21 - The Solution 10:13
22 - An Intro to Control Plane 05:57
23 - Viewing Our GVC 03:35
24 - Pushing Our Image to an Image Repository 07:40
25 - Running a Workload 02:53
26 - Killing Our Deployment 00:47
27 - Application Overview 02:43
28 - How to Handle Multiple Component Applications 04:58
29 - Going Through the Starter Code 03:48
30 - Pulling Images From an Image Repository 06:43
31 - Building our Node Image and Running the Container 04:20
32 - Connecting Our Containers Through Localhost 09:51
33 - Utilizing the Container's IP Address 05:20
34 - Introducing Docker Networks 06:00
35 - Dockerizing Our React App 02:59
36 - Running into a Little Issue 04:40
37 - Client Side Rendering is the Problem 05:30
38 - Optimizing Our Workflow with Volumes 17:07
39 - An Intro to Docker Compose 03:54
40 - A Little About YAML Syntax 04:32
41 - Writing the MongoDB Configuration 04:44
42 - Setting Environment Variables 05:13
43 - docker-compose up and docker-compose down 03:30
44 - Setting Up the Backend Container 10:40
45 - Testing the Integration 01:43
46 - Setting Up the Frontend Container 05:44
47 - Our Deployment Workflow 03:31
48 - Writing the Dockerfile 06:22
49 - Running the Container Locally 03:02
50 - Create an Image Repository and Downloading the AWS CLI 11:23
51 - IAM for Access Management 10:28
52 - Pushing Our Image to the Registry 04:03
53 - Creating an ECS Cluster 07:13
54 - Creating a Task Definition 04:15
55 - Running the Task with a ECS Service 03:11
56 - Configuring the Inbound Rules of Our Security Group 04:16
57 - Redeploying Changes in the Codebase 07:56
58 - The Issues with a Manual Process 02:10
59 - The Solution is Automation 01:21
60 - Understanding a Production Grade Workflow 08:06
61 - Pushing Our Code to GitHub 02:45
62 - Creating a Pull Request 05:11
63 - Building the Integration Pipeline 10:05
64 - Setting up Branch Protection Rules (Not Really) 02:17
65 - Setting Up AWS Credentials in GitHub Actions 11:21
66 - Building and Pushing Our Image to ECR 11:49
67 - My Bad Everyone 02:38
68 - Downloading and Updating the task-definition.json File 10:11
69 - Deploying the Task Definition 07:41
70 - Fixing Our Deployment Issue 04:24
71 - The Major Issue with This Solution 04:56
72 - Blue/Green Deployments is the Optimal Solution 04:21
73 - Tearing Down the ECS Cluster 01:59
74 - Multi Container Deployment 02:08
75 - The Need for NGINX 04:06
76 - Multi Stage Dockerfile 07:20
77 - The Issues With Using a Database Container 05:50
78 - Setting Up Our Codebase for Deployment 04:27
79 - Pushing Our Image to AWS ECR 04:24
80 - Defining a Multi Container Task Defintion 06:46
81 - Adding Environment Variables 05:07
82 - Updating the Task Definition 04:30
83 - Our New (Much Larger) Project 08:15
84 - Can We Just Do the Same Thing? 04:28
85 - Kubernetes to the Rescue 02:57
86 - Communication via Kubectl 03:57
87 - Installing Kubernetes 01:33
88 - Writing Our First Manifest File 04:50
89 - Containers Run in Pods 05:35
90 - Selecting Kubernetes Objects With the apiVersion 02:17
91 - Understanding the Rest of the Manifest File 09:04
92 - Running Our Pod 02:54
93 - Writing a Service Manifest File 04:19
94 - How the NodePort Service Works 09:31
95 - Creating the Node and Mongo Pods 09:16
96 - ClusterIP Service for Internal Communication 09:06
97 - What Happens if the Pod Crashes? 04:37
98 - Deployments to the Rescue 07:50
99 - Dissecting the Manifest File 04:21
100 - Creating the Frontend Store ClusterIP 04:15
101 - Creating the Deployment and ClusterIP For the Products API 05:39
102 - Creating the MongoDB Deployment 03:51
103 - Running All the Manifest Files 06:43
104 - Deployment for the Notifications API 08:26
105 - Deployment and ClusterIP for RabbitMQ 05:14
106 - Checking if Everything Works 02:20
107 - Adding Environment Variables to Our Code 04:46
108 - Defining Environment Variables 07:35
109 - ConfigMaps for Commonly Used Environment Variables 08:32
110 - Hide Environment Variables With Secrets 11:24
111 - The Need for an Ingress Service 06:33
112 - Writing Some Ingress Configuration 05:50
113 - Manually Testing Out Our App 11:52
114 - Understanding the Ingress Configuration 08:09
115 - Our Data is Not Persisting! 02:38
116 - A Reminder on Volumes 02:51
117 - Kubernetes Volumes Are Not the Solution 02:53
118 - Persistent Volumes, for well... Persistent Data 01:06
119 - Persistent Volume Claims 02:16
120 - Writing the Config and Applying the PVC 09:19
121 - The Deployment Process 07:46
122 - Creating a EKS Cluster with Eksctl 05:19
123 - Understanding Kubectl Context 06:03
124 - Creating the Twilio Secret in Prod 04:18
125 - Adding an AWS Ingress Load Balancer 02:40
126 - Defining the Host Domain 05:36
127 - Applying the Rest of Our Configuration 04:30
128 - Testing Our Deployed App! 02:50
129 - Updating Our Production Cluster 07:00
130 - The Steps Our CD Pipeline Needs to Take 04:19
131 - Creating a GitHub Repository 07:12
132 - Starting Our Deployment Workflow 11:39
133 - Building and Pushing Our Image to DockerHub 08:05
134 - Completing Our Pipeline By Updating Our Cluster 07:03
135 - It Worked! 01:15
136 - Deleting Our Cluster 01:03

About the Instructor

udemy

$0.00

$8.00

Que esta incluido?

Streaming Multiplataforma
Acceso de por vida
Soporte al cliente
Actualizaciones gratuitas