Kubernetes Hands-On - Deploy Microservices to the AWS Cloud

28h 23m 41s
English
Paid
June 24, 2024

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.

More

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 Kubernetes Hands-On - Deploy Microservices to the AWS Cloud

Join premium to watch
Go to premium
# Title Duration
1 Introduction to Kubernetes Microservices course 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

Similar courses to Kubernetes Hands-On - Deploy Microservices to the AWS Cloud

Intensive Kubernetes: 2.0

Intensive Kubernetes: 2.0

Duration 18 hours 55 minutes 51 seconds
Mastering Kubernetes

Mastering Kubernetes

Duration 8 hours 38 minutes 39 seconds
Docker and Kubernetes - The Complete Developers Guide

Docker and Kubernetes - The Complete Developers Guide

Duration 12 hours 40 minutes 38 seconds
Master Microservices with Java, Spring, Docker, Kubernetes

Master Microservices with Java, Spring, Docker, Kubernetes

Duration 23 hours 57 minutes 28 seconds
Docker and Kubernetes: The Complete Guide

Docker and Kubernetes: The Complete Guide

Duration 21 hours 32 minutes 42 seconds