Skip to main content
CF

Kubernetes Hands-On - Deploy Microservices to the AWS Cloud

28h 23m 41s
English
Paid

Kubernetes is one of the hottest topics right now, and engineers with Kubernetes skills are in big demand. Enhance your skillset with this comprehensive course!

Course Overview

This course is a prime opportunity to engage with a real Kubernetes project and elevate your skills to a professional level. Throughout the course, you'll tackle realistic project requirements, but there's no need for prior coding experience or familiarity with a specific programming language. Pre-prepared Docker images will be at your disposal, and your task is to deploy these using Kubernetes.

Microservices Architecture

The system uses a Microservice-based architecture, and during the course, we will delve into the design decisions and trade-offs essential for managing these complex systems. Although the course is not centered on designing Microservices, there will be discussions around the topic to provide context as we work on deploying a production cluster.

Analyzing System Performance

We'll also explore how developers' mistakes can affect code by analyzing the runtime performance of the cluster, offering real-world troubleshooting experience.

Course Structure

Local Development: You can complete the initial phase of the course on your local machine (PC/Mac/Laptop).

Cloud Deployment

The second phase, starting from Chapter 13, transitions to the AWS Cloud. You will need a real AWS account to proceed, wherein we will set up monitoring using the ELK/Elastic Stack and perform monitoring with Prometheus and Grafana.

AWS Elastic Kubernetes Service (EKS) and Kops

The course now supports EKS, the AWS Elastic Kubernetes Service. We also cover an alternative system called Kops, explaining the pros and cons of each method in detail.

Intended Audience

This course is designed for a diverse audience including DevOps engineers, developers, and even those new to the field. Basic knowledge of computers and some command-line experience is sufficient to get started.

Cost and AWS Account Information

An AWS account is required to work independently on the system. If you're unfamiliar with AWS, the course has you covered. However, please be aware that Amazon charges for using their services. The estimated cost is no more than 10 USD, assuming careful resource management. It’s essential to delete your Kubernetes cluster post-session to avoid additional charges. This small investment can significantly boost your career prospects.

If you prefer to avoid these costs, you can still gain a lot by watching the AWS lecture videos included in this course.

About the Author: Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

Watch Online 148 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 148 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Introduction to Kubernetes Microservices course
All Course Lessons (148)
#Lesson TitleDurationAccess
1
Introduction to Kubernetes Microservices course Demo
03:06
2
Introducing Kubernetes
08:34
3
Hands-on Project
02:50
4
Options for Installing Kubernetes
12:27
5
Installing Docker Desktop for Kubernetes
02:22
6
Running Kubernetes Inside Docker Desktop
11:01
7
Using Minikube (as an alternative)
12:46
8
Choosing a Minikube Driver
25:02
9
Docker Overview
02:47
10
Docker Containers vs Images
13:22
11
Running Containers from DockerHub
12:45
12
Pods Overview
09:14
13
Writing a Pod
05:07
14
Running a Pod
10:55
15
Services
07:32
16
NodePort and ClusterIP
12:11
17
Pod Selection with Labels
15:03
18
Exercise: Deploy ActiveMQ as a Pod and Service
10:05
19
ReplicaSets
10:45
20
Writing a ReplicaSet
10:06
21
Applying a ReplicaSet to Kubernetes
10:55
22
Deployments Overview
12:09
23
Managing Rollouts
12:25
24
Networking Overview in Kubernetes
08:19
25
Namespaces - kube-system
09:35
26
Accessing MySQL from a Pod
07:16
27
Cygwin extra - fixing the terminal with winpty
04:53
28
Service Discovery
07:28
29
Fully Qualified Domain Names (FQDN)
03:28
30
An Introduction to Microservices
15:19
31
Introduction to Microservices Part 2
10:41
32
Fleetman Microservices - setting the scene
13:39
33
Deploying the Queue
12:39
34
Deploying the Position Simulator
07:57
35
Inspecting Pod Logs
05:41
36
Deploying the Position Tracker
11:08
37
Deploying the API Gateway
04:50
38
Deploying the Webapp
06:41
39
Persistence
12:01
40
Upgrading to a Mongo Pod
13:49
41
Mongo Service
06:23
42
Expanding the Minikube VM
02:51
43
Volume Mounts
09:27
44
Volumes
14:26
45
PersistentVolumeClaims
16:27
46
StorageClasses and Binding
09:25
47
Getting started with AWS
10:59
48
Managing a Cluster in the Cloud
09:13
49
EKS vs Kops - Which to Choose?
09:40
50
Pricing Differences - EKS vs Kops (prices correct mid 2020)
08:19
51
Introducing Kops - Kubernetes Operations
10:16
52
Installing the Kops Environment - 2021 Update
18:40
53
Configuring your first cluster
20:05
54
Running the Cluster
14:04
55
Getting started with EKS
13:13
56
Install eksctl and AWS CLI
06:06
57
Configure the AWS credentials
13:25
58
Install kubectl
04:29
59
Start the cluster
04:30
60
Provisioning SSD drives with a StorageClass
12:53
61
Deploying the Fleetman Workload to Kubernetes
13:18
62
Setting up a real Domain Name
04:03
63
Surviving Node Failure
10:10
64
Replicating Pods in Kubernetes
11:04
65
Deleting the Cluster
10:29
66
Restarting the Cluster
05:36
67
How to delete your EKS cluster
07:07
68
Introducing the ELK / ElasticStack
15:41
69
Installing the Stack to Kubernetes
16:07
70
Kibana - first look
09:02
71
Setting Filters and Refreshes
05:02
72
Demo: analysing a system failure
05:16
73
Kibana Dashboards
15:26
74
Monitoring a Cluster (2020 update)
05:32
75
Installing the kube-prometheus-stack
15:17
76
Using the Prometheus UI
17:20
77
Introducing Grafana
21:53
78
(optional) How to Use NodePorts on a Cluster
17:30
79
Introducing Alerts
11:48
80
Preparing a Slack Channel
10:16
81
Configuring the AlertManager
15:18
82
Troubleshoot the alertmanager.yaml config
16:41
83
Dealing with Firing Alerts
16:33
84
The AlertManager UI and how to Silence Alerts
09:25
85
How to handle the Watchdog
14:32
86
Using PagerDuty
17:12
87
Case Study: Troubleshooting a "Delinquent" node
13:03
88
What happens if the Master Node crashes? (Kops clusters only!)
10:35
89
Introduction to the "Advanced Section"
02:41
90
Memory requests
20:41
91
CPU Requests
07:07
92
Memory and CPU Limits
14:50
93
Enabling the Metrics Server
14:26
94
Viewing Metrics on the Dashboard
16:43
95
Tuning Java Spring Boot Applications, Heap restriction
22:54
96
Setting reasonable Requests
07:43
97
Introducing Replication and Autoscaling
31:00
98
Testing Autoscaling
07:30
99
Demo: why readiness probes are needed
12:02
100
Applying Liveness and Readiness Probes
08:57
101
Understanding the scheduler
15:38
102
QoS labels
04:59
103
Evictions
12:04
104
Pod Priorities
12:41
105
Creating a ConfigMap
07:34
106
Consuming a ConfigMap as Environment Variables
05:30
107
Do changes to a ConfigMap get propagated?
06:38
108
How to consume multiple environments variables with envFrom
03:33
109
Mounting ConfigMaps as Volumes
09:19
110
Creating Secrets
08:12
111
Using Secrets
08:07
112
Where have we already used ConfigMaps and Secrets?
09:40
113
Introducing Ingress
12:08
114
Defining Routing Rules
15:21
115
Adding Routes
04:05
116
Authentication
15:12
117
Running Ingress on AWS
14:07
118
Testing the Ingress Rules
08:58
119
Batch Jobs
22:28
120
Cron Jobs
09:25
121
DaemonSets
06:25
122
StatefulSets Overview
22:22
123
StatefulSets for Database Replication
09:58
124
Demo: Scaling out a Mongo Database
21:39
125
Introducing CI/CD
11:13
126
Establishing a GitHub organization
10:45
127
Setting up a Basic Jenkins System
15:08
128
Defining a Pipeline
18:11
129
Running a Multibranch Pipeline
05:19
130
Reviewing Builds
10:21
131
Organization Pipelines
09:33
132
Continuous Deployment into a Cluster
16:18
133
Getting Started with Helm
09:22
134
How do I Install a Helm Chart
14:38
135
How to Find Helm Charts
10:49
136
Installing a Monitoring Stack with Helm
14:02
137
Working with Chart Values
16:15
138
Customising values.yaml
16:01
139
Avoiding Snowflake Clusters!
11:57
140
Using Helm Pull to Take Control of a Chart
16:52
141
Generating yaml with "Helm Template"
07:25
142
Why would you write your own Helm Charts?
10:07
143
Writing Go Templates for Helm
26:53
144
Helm Functions and Pipelines
14:20
145
Flow Control in a Helm Template
12:23
146
Named Templates
21:36
147
Inspecting a Professional Helm Chart
24:41
148
Goodbye!
01:55
Unlock unlimited learning

Get instant access to all 147 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What are the prerequisites for enrolling in this course?
This course does not require prior coding experience or familiarity with any specific programming language. The course uses pre-prepared Docker images, so students can focus on deploying these using Kubernetes without needing to write code.
What will I build during the course?
Students will engage with a real Kubernetes project, deploying a microservices-based architecture. This includes deploying components such as the Queue, Position Simulator, Position Tracker, API Gateway, and Webapp. The course emphasizes deploying a production cluster and setting up monitoring systems in the AWS Cloud.
Who is the target audience for this course?
This course is intended for individuals looking to enhance their skills in Kubernetes, especially those interested in cloud deployment and managing microservices. It is suitable for beginners since no prior coding skills are necessary.
What specific tools or platforms will I work with?
The course uses Kubernetes for managing containerized applications and Docker for container creation. For cloud deployment, AWS services are utilized, and students will work with tools such as Minikube, ELK/Elastic Stack, Prometheus for monitoring, and kubectl for managing clusters.
What topics are not covered in this course?
While the course discusses microservices, it does not focus on designing them from scratch. The primary focus is on deploying existing microservices and managing their runtime performance rather than on software development itself.
How much time should I expect to commit to this course?
The course comprises 148 lessons, which can be completed at your own pace. Since the runtime is not specified, students should expect to commit several hours per week to fully engage with both the local development and cloud deployment phases.
How will the skills learned in this course be applicable to other careers or courses?
Skills acquired in this course, such as deploying Kubernetes clusters, managing microservices, and setting up cloud-based monitoring, are highly transferable to careers in cloud engineering, DevOps, and IT infrastructure management. These skills can also serve as a foundation for advanced courses in cloud architecture and system performance optimization.