Kubernetes Hands-On - Deploy Microservices to the AWS Cloud

28h 23m 41s
English
Paid

Course description

Kubernetes is one of the hottest topics right now, and engineers with Kubernetes skills are in big demand.

Get those skills with this course! It's is a great chance to work on a real Kubernetes project, and to get yourself to a high professional standard on real projects. All the way through the course you'll be working on realistic requirements - but you don't need to be a coder or know any particular programming language - I've prepared for you a set of Docker images, and your job is to use Kubernetes to get these images running.

The system is a Microservice-based architecture, and along the way, we'll look at design decisions and trade-offs you need to make when managing these complex systems. Note the course isn't about how to design Microservices (although we'll certainly be talking about that); the development work is done and we need to get the system running on a production cluster.

We'll also discover that the developers have made some bad mistakes in their code, by analyzing the run time performance of the cluster!

You can do the first part of the course on your local development computer (PC/Mac/Laptop). The second part (from Chapter 13 onwards) moves to the cloud. You'll use a real AWS account, and we go-ahead to set up monitoring with the ELK/Elastic Stack and monitor with Prometheus and Grafana.

Read more about the course

The course now supports EKS, the AWS Elastic Kubernetes Service, but we also show how to use the alternative system, called Kops. The pros and cons of each are explained in detail.

I've designed this course for a wide audience - whether you're a DevOps engineer, a developer, or if you're quite new to the whole field, I'll explain everything along the way. Just some basic knowledge of working with computers, and maybe a bit of command-line experience will suffice.

You will need an AWS account for a part of the course if you want to work on the system yourself. If you're new to AWS then don't worry, I've got you covered -but Amazon will charge you for running the system (as with all/most cloud providers). Expect to pay no more than around 10USD for this (this is a safe overestimate), but you are expected to manage this spend yourself and you must delete your Kubernetes cluster at the end of your session. Don't let that put you off, it's a great investment.

You can absolutely just watch the AWS videos if you'd prefer not to incur these costs - you will still learn plenty!

Watch Online

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

Watch Online Kubernetes Hands-On - Deploy Microservices to the AWS Cloud

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

Comments

0 comments

Want to join the conversation?

Sign in to comment

Similar courses

Intensive Kubernetes: 2.0

Intensive Kubernetes: 2.0

Sources: ardanlabs.com
Intensive Kubernetes: 2.0 is a course designed for those looking to become experts in container management and orchestration using Kubernetes.
18 hours 55 minutes 51 seconds
Docker and Kubernetes - The Complete Developers Guide

Docker and Kubernetes - The Complete Developers Guide

Sources: udemy
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 under...
12 hours 40 minutes 38 seconds
Microservices with NodeJS, React, Typescript and Kubernetes

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
95 hours 13 minutes 4 seconds
Master Microservices with Java, Spring, Docker, Kubernetes

Master Microservices with Java, Spring, Docker, Kubernetes

Sources: udemy
'Master Microservices with Spring, Docker, Kubernetes' course will help in understanding about microservices architecture and how to build it using SpringBoot
23 hours 57 minutes 28 seconds