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
By connecting students all over the world to the best instructors, Udemy is helping individuals reach their goals and pursue their dreams. Udemy is the leading global marketplace for teaching and learning, connecting millions of students to the skills they need to succeed. Udemy helps organizations of all kinds prepare for the ever-evolving future of work. Our curated collection of top-rated business and technical courses gives companies, governments, and nonprofits the power to develop in-house expertise and satisfy employees’ hunger for learning and development.

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