Mô tả

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 Pipelines

Of 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 required

  • Build your own custom images tailored to your applications

  • Master the Docker CLI to inspect and debug running containers

  • Understand how Docker works behind the scenes, and what a container is

  • Build a CI + CD pipeline from scratch with Github, Travis CI, and AWS

  • Automatically deploy your code when it is pushed to Github!

  • Build a complex multi-container application from scratch and deploy it to AWS

  • Understand the purpose and theory of Kubernetes

  • Deploy a production-ready Kubernetes Cluster to Google Cloud

Bạn sẽ học được gì

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!

Yêu cầu

  • 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

Nội dung khoá học

19 sections

Dive Into Docker!

11 lectures
Finished Code and Diagrams
00:39
Join Our Community!
00:07
Why Use Docker?
03:43
What is Docker?
02:53
Docker for Mac/Windows
01:57
Installing Docker on macOS
01:10
Installing Docker with WSL on Windows 10/11
02:13
Installing Docker on Linux
01:55
Using the Docker Client
05:03
But Really...What's a Container?
08:30
How's Docker Running on Your Computer?
02:44

Manipulating Containers with the Docker Client

14 lectures
Docker Run in Detail
01:54
Overriding Default Commands
05:12
Listing Running Containers
04:09
Container Lifecycle
05:16
Restarting Stopped Containers
03:43
Removing Stopped Containers
01:39
Retrieving Log Outputs
02:33
Stopping Containers
05:21
Multi-Command Containers
04:16
Executing Commands in Running Containers
02:53
The Purpose of the IT Flag
04:35
Getting a Command Prompt in a Container
04:06
Starting with a Shell
02:13
Container Isolation
03:09

Building Custom Images Through Docker Server

11 lectures
Creating Docker Images
02:36
Buildkit for Docker Desktop
01:09
Building a Dockerfile
04:51
Dockerfile Teardown
02:41
What's a Base Image?
05:40
The Build Process in Detail
11:09
A Brief Recap
03:24
Rebuilds with Cache
07:02
Tagging an Image
04:26
Quick Note for Windows Users
00:14
Manual Image Generation with Docker Commit
05:00

Making Real Projects with Docker

11 lectures
Project Outline
02:35
Node Server Setup
05:03
Reminder on Buildkit
00:27
A Few Planned Errors
05:12
Base Image Issues
07:50
A Few Missing Files
03:18
Copying Build Files
04:50
Container Port Mapping
07:26
Specifying a Working Directory
07:52
Unnecessary Rebuilds
04:16
Minimizing Cache Busting and Rebuilds
04:58

Docker Compose with Multiple Local Containers

11 lectures
App Overview
03:57
App Server Starter Code
06:43
Assembling a Dockerfile
03:12
Introducing Docker Compose
05:31
Docker Compose Files
06:02
Networking with Docker Compose
05:00
Docker Compose Commands
04:38
Stopping Docker Compose Containers
02:34
Container Maintenance with Compose
02:53
Automatic Container Restarts
09:21
Container Status with Docker Compose
02:21

Creating a Production-Grade Workflow

23 lectures
Development Workflow
01:28
Flow Specifics
06:32
Docker's Purpose
01:50
Project Generation
03:25
More on Project Generation
00:59
Necessary Commands
05:09
Creating the Dev Dockerfile
03:42
Duplicating Dependencies
01:29
Starting the Container
02:50
Docker Volumes
06:53
WSL and Windows Users Must Read Before Next Lecture
03:59
Bookmarking Volumes
04:50
Shorthand with Docker Compose
04:22
Overriding Dockerfile Selection
02:02
Do We Need Copy?
02:51
Executing Tests
03:38
Live Updating Tests
04:54
Docker Compose for Running Tests
05:45
Shortcomings on Testing
08:30
Need for Nginx
03:07
Multi-Step Docker Builds
06:54
Implementing Multi-Step Builds
07:05
Running Nginx
02:27

Continuous Integration and Deployment with AWS

20 lectures
Services Overview
03:04
Github Setup
03:57
Important Info About Travis and Account Registration
00:55
Travis CI Setup
04:17
Travis YML File Configuration
07:39
A Touch More Travis Setup
04:14
Automatic Build Creation
03:30
AWS Elastic Beanstalk
01:42
Elastic Beanstalk Setup and Configuration
02:49
More on Elastic Beanstalk
02:25
Travis Config for Deployment
08:46
Required Update for IAM User and Keys
00:50
Automated Deployments
07:17
Exposing Ports Through the Dockerfile
03:56
Workflow With Github
03:59
Redeploy on Pull Request Merge
02:01
Deployment Wrapup
02:03
Environment Cleanup
00:24
AWS Configuration Cheat Sheet
03:54
Finished Project Code with Updates Applied
00:07

Building a Multi-Container Application

14 lectures
Single Container Deployment Issues
03:02
Application Overview
04:30
A Quick Note
00:15
Application Architecture
05:11
Worker Process Setup
11:41
Express API Setup
05:19
Important Update for pgClient and Table Query
00:40
Connecting to Postgres
07:36
More Express API Setup
12:20
Generating the React App
01:16
Fetching Data in the React App
06:31
Rendering Logic in the App
08:29
Exporting the Fib Class
00:26
Routing in the React App
04:36

"Dockerizing" Multiple Services

19 lectures
Checkpoint Files
00:13
Checkpoint Catchup
02:39
Expected Output for Latest Create React App Versions
00:27
Dockerizing a React App - Again!
06:41
Dockerizing Generic Node Apps
03:47
Postgres Database Required Fixes and Updates
00:13
Adding Postgres as a Service
07:05
Docker-compose Config
06:17
Environment Variables with Docker Compose
10:20
Required Worker Environment Variables
00:15
The Worker and Client Services
03:42
Nginx Path Routing
09:41
Routing with Nginx
11:12
Building a Custom Nginx Image
05:38
Starting Up Docker Compose
01:50
Nginx connect() failed - Connection refused while connecting to upstream
00:15
Troubleshooting Startup Bugs
03:22
WebSocket connection to 'ws://localhost:3000/ws' failed
00:26
Opening Websocket Connections
03:51

A Continuous Integration Workflow for Multiple Images

11 lectures
Production Multi-Container Deployments
05:39
Production Dockerfiles
06:05
Multiple Nginx Instances
05:23
Nginx fix for React Router
00:18
Altering Nginx's Listen Port
04:53
Cleaning Up Tests
01:11
Travis Configuration Setup
08:45
Fix for Failing Travis Builds
00:22
Github and Travis CI Setup
04:08
Pushing Images to Docker Hub
07:34
Successful Image Building
01:49

Multi-Container Deployments to AWS

24 lectures
Multi-Container Definition Files
04:29
Finding Docs on Container Definitions
03:09
Adding Container Definitions to DockerRun
05:45
More Container Definitions
05:18
Forming Container Links
07:47
Creating the Elastic Beanstalk Environment
02:01
AWS Configuration Cheat Sheet - Updated for new UI
05:21
Managed Data Service Providers
10:44
Overview of AWS VPC's and Security Groups
09:21
RDS Database Creation
06:31
ElastiCache Redis Creation
04:11
Creating a Custom Security Group
04:18
Applying Security Groups to Resources
04:59
Setting Environment Variables
07:55
IAM Keys for Deployment
05:12
Travis Keys Update
00:19
Travis Deploy Script
03:20
Container Memory Allocations
04:10
Verifying Deployment
02:56
A Quick App Change
01:29
Making Changes
00:57
Cleaning Up AWS Resources
05:05
AWS Configuration Cheat Sheet
05:21
Finished Project Code with Updates Applied
00:14

Onwards to Kubernetes!

16 lectures
The Why's and What's of Kubernetes
08:06
Kubernetes in Development and Production
05:47
Docker Desktop's Kubernetes Setup and Installation - macOS
01:00
Minikube Install and Setup Info - macOS
01:28
Docker Desktop's Kubernetes Setup and Installation - Windows
01:09
Minikube Setup on Windows
00:15
Minikube Setup on Linux
00:58
Mapping Existing Knowledge
07:37
Quick Note to Prevent an Error
00:37
Adding Configuration Files
06:51
Object Types and API Versions
06:55
Running Containers in Pods
09:19
Service Config Files in Depth
13:37
Connecting to Running Containers
10:24
The Entire Deployment Flow
13:02
Imperative vs Declarative Deployments
13:36

Maintaining Sets of Containers with Deployments

18 lectures
Updating Existing Objects
06:10
Declarative Updates in Action
07:04
Limitations in Config Updates
02:55
Running Containers with Deployments
06:03
Quick Note to Prevent an Error
00:09
Deployment Configuration Files
03:18
Walking Through the Deployment Config
04:23
Applying a Deployment
06:22
Why Use Services?
05:19
Scaling and Changing Deployments
06:31
Updating Deployment Images
03:57
Rebuilding the Client Image
02:59
Triggering Deployment Updates
12:24
Imperatively Updating a Deployment's Image
07:24
Reminder for Docker Desktop's Kubernetes Users
00:12
Multiple Docker Installations
05:37
Reconfiguring Docker CLI
05:57
Why Mess with Docker in the Node?
05:05

A Multi-Container App with Kubernetes

30 lectures
The Path to Production
05:12
Checkpoint Files
00:18
A Quick Checkpoint
04:35
Recreating the Deployment
05:29
NodePort vs ClusterIP Services
03:41
The ClusterIP Config
03:52
Applying Multiple Files with Kubectl
04:18
Express API Deployment Config
06:02
Cluster IP for the Express API
03:08
Combining Config Into Single Files
05:59
The Worker Deployment
04:36
Reapplying a Batch of Config Files
04:51
Creating and Applying Redis Config
07:26
Important Note about Expected Postgres Error
00:59
Last Set of Boring Config!
06:14
The Need for Volumes with Databases
07:18
Kubernetes Volumes
05:17
Volumes vs Persistent Volumes
02:59
Persistent Volumes vs Persistent Volume Claims
09:21
Claim Config Files
02:56
Persistent Volume Access Modes
03:31
Where Does Kubernetes Allocate Persistent Volumes?
07:42
Designating a PVC in a Pod Template
06:09
Applying a PVC
02:22
Defining Environment Variables
04:08
Adding Environment Variables to Config
05:44
Creating an Encoded Secret
09:25
Postgres Environment Variable Fix
00:14
Passing Secrets as Environment Variables
05:53
Environment Variables as Strings
02:17

Handling Traffic with Ingress Controllers

14 lectures
Load Balancer Services
04:14
A Quick Note on Ingresses
03:32
One Other Quick Note!
01:37
Behind the Scenes of Ingress
05:17
More Behind the Scenes of Ingress
06:37
Optional Reading on Ingress Nginx
00:09
Docker Driver and Ingress - IMPORTANT
00:37
Setting Up Ingress Locally with Docker Desktop
00:17
Setting Up Ingress Locally with Minikube
02:06
Ingress v1 API Update + "this.state.seenIndexes.map..." + 404 errors
00:52
Creating the Ingress Configuration
07:00
Testing Ingress Locally
02:50
The Minikube Dashboard
03:28
Docker Desktop's Kubernetes Dashboard
01:17

Kubernetes Production Deployment

40 lectures
The Deployment Process
05:49
Google Cloud vs AWS for Kubernetes
04:53
Creating a Git Repo
03:59
Linking the Github Repo to Travis
01:35
Free Google Cloud Credits
00:18
Creating a Google Cloud Project
01:59
Linking a Billing Account
02:11
Updated GKE creation steps for new Google Cloud UI
01:08
Kubernetes Engine Init
01:47
Creating a Cluster with Google Cloud
04:47
Don't Forget to Cleanup!
00:14
Kubernetes Dashboard on Google Cloud
04:33
Travis Deployment Overview
05:04
Installing the Google Cloud SDK
05:44
Updated Service Account steps for new GCP UI
00:49
Generating a Service Account
05:29
Ruby Version Fix
00:17
Running Travis CLI in a Container
09:17
Travis Login Issues, "iv undefined" or "repository not known"
00:54
Encrypting a Service Account File
07:54
More Google Cloud CLI Config
04:39
Fix For Failing Travis Builds
00:17
Running Tests with Travis
06:18
Custom Deployment Providers
03:49
Unique Deployment Images
08:33
Unique Tags for Built Images
07:47
Updating the Deployment Script
07:50
Configuring the GCloud CLI on Cloud Console
05:34
Creating a Secret on Google Cloud
02:24
Helm Setup
06:14
Important - Updated Ingress Installation with Helm
00:16
Ingress-Nginx with Helm
01:56
The Result of Ingress-Nginx
03:47
Finally - Deployment!
03:30
Did I Really Type That?
00:45
Verifying Deployment
05:20
A Workflow for Changing in Prod
04:29
Merging a PR for Deployment
01:01
That's It! What's Next?
01:37
Completed Code For Google Cloud Deployment
00:03

HTTPS Setup with Kubernetes

18 lectures
HTTPS Setup Overview
05:35
Domain Purchase
02:17
Domain Name Setup
03:30
Required Updates for Cert Manager Install
00:25
Cert Manager Install
01:57
How to Wire Up Cert Manager
05:58
Required Update for Issuer
00:13
Issuer Config File
05:07
Required Update for the Certificate
00:17
Certificate Config File
05:18
Deploying Changes
03:15
No Resources Found?
00:12
Verifying the Certificate
03:54
Required Update for the HTTPS Ingress
00:04
Ingress Config for HTTPS
06:49
It Worked!
02:51
Google Cloud Cleanup
00:20
Local Environment Cleanup
00:38

Local Development with Skaffold

7 lectures
Awkward Local Development
03:54
Installing Skaffold
01:59
The Skaffold Config File
06:43
Skaffold Sync Update and Example Source Code
01:19
Live Sync Changes
05:02
Automatic Shutdown
05:07
Testing Live Sync with the API Server
05:29

Extras

1 lectures
Bonus!
00:33

Đánh giá của học viên

Chưa có đánh giá
Course Rating
5
0%
4
0%
3
0%
2
0%
1
0%

Bình luận khách hàng

Viết Bình Luận

Bạn đánh giá khoá học này thế nào?

image

Đăng ký get khoá học Udemy - Unica - Gitiho giá chỉ 50k!

Get khoá học giá rẻ ngay trước khi bị fix.