Kubernetes HandsOn Deploy Microservices to the AWS Cloud

Kubernetes HandsOn Deploy Microservices to the AWS Cloud

What you’ll learn

Deploy containers to a Kubernetes Cluster
Run Kubernetes in AWS using either EKS or Kops
Monitor a live Kubernetes cluster using Prometheus and Grafana
Analyse system-wide logs using the ELK Stack (ElasticStack); Kibana and ElasticSearch
Handle Alerts in a Kubernetes cluster by notifying Slack Channels
Understand how Requests and Limits work in Kubernetes
Use Kubernetes Horizontal Pod Autoscaling
Configure Ingress Control on a live Kubernetes deployment
Understand Kubernetes StatefulSets
Integrate Kubernetes with a Continuous Deployment System (CD)
Use Helm to Manage Charts and to Dynamically Update your Kubernetes YAML

Requirements

Some previous knowledge of Docker is useful, but an overview is provided as part of the course
Previous knowledge of AWS is useful for the later sections of the course; however all the concepts are explained in detail and this would serve as a great first project on AWS
We’ll be using the terminal throughout the course so some (basic) familiarity of terminal operations is assumed
You will need a modern computer with at least 8Gb of RAM to run the practical sessions

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.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!As always, I’m here to answer questions and I aim to respond within 48 hours.Good luck!

Overview

Section 1: Introduction

Lecture 1 Introduction to Kubernetes Microservices course

Lecture 2 Code for the course

Lecture 3 Support for Apple M1 ,M2 users

Section 2: Welcome to Kubernetes

Lecture 4 Introducing Kubernetes

Lecture 5 Hands-on Project

Section 3: Installing Minikube for local Kubernetes Development

Lecture 6 Extra note for Linux Users

Lecture 7 If you already have Docker installed…

Lecture 8 Setting up Virtualization

Lecture 9 (Windows 10 Professional Only): Setting up Hyper-V

Lecture 10 Installing kubectl and minikube

Lecture 11 Troubleshooting Minikube

Section 4: (optional) Docker Quickstart

Lecture 12 Docker Overview

Lecture 13 Docker Containers vs Images

Lecture 14 Attention Apple M1/M2 Users!

Lecture 15 Running Containers from DockerHub

Section 5: Kubernetes Pods

Lecture 16 Pods Overview

Lecture 17 Writing a Pod

Lecture 18 Running a Pod

Section 6: Services in Kubernetes

Lecture 19 Important note for Docker Desktop and Driver Users

Lecture 20 Services

Lecture 21 NodePort and ClusterIP

Lecture 22 Pod Selection with Labels

Section 7: Exercise: Deploy ActiveMQ as a Pod and Service to Kubernetes

Lecture 23 Exercise: Deploy ActiveMQ as a Pod and Service

Section 8: Kubernetes ReplicaSets

Lecture 24 ReplicaSets

Lecture 25 Writing a ReplicaSet

Lecture 26 Applying a ReplicaSet to Kubernetes

Section 9: Kubernetes Deployments

Lecture 27 Deployments Overview

Lecture 28 Managing Rollouts

Section 10: Networking and Service Discovery

Lecture 29 Networking Overview in Kubernetes

Lecture 30 A quick note about DNS pods

Lecture 31 Namespaces – kube-system

Lecture 32 Note for M1 Architectures

Lecture 33 Accessing MySQL from a Pod

Lecture 34 Cygwin extra – fixing the terminal with winpty

Lecture 35 If you have a problem with MySql in the next video

Lecture 36 Service Discovery

Lecture 37 Fully Qualified Domain Names (FQDN)

Section 11: Microservice Architectures

Lecture 38 WARNING – possible resource problems!

Lecture 39 An Introduction to Microservices

Lecture 40 Introduction to Microservices Part 2

Lecture 41 Fleetman Microservices – setting the scene

Lecture 42 Deploying the Queue

Lecture 43 Deploying the Position Simulator

Lecture 44 Inspecting Pod Logs

Lecture 45 Deploying the Position Tracker

Lecture 46 Deploying the API Gateway

Lecture 47 Deploying the Webapp

Section 12: Kubernetes Persistence and Volumes

Lecture 48 Persistence

Lecture 49 Upgrading to a Mongo Pod

Lecture 50 Mongo Service

Lecture 51 Expanding the Minikube VM

Lecture 52 Volume Mounts

Lecture 53 Volumes

Lecture 54 PersistentVolumeClaims

Lecture 55 StorageClasses and Binding

Section 13: Running Kubernetes on the AWS Cloud

Lecture 56 Warning

Lecture 57 Getting started with AWS

Lecture 58 Managing a Cluster in the Cloud

Lecture 59 EKS vs Kops – Which to Choose?

Lecture 60 Pricing Differences – EKS vs Kops (prices correct mid 2020)

Lecture 61 Choose Your Own Adventure!

Section 14: KOPS – Running Kubernetes on the AWS Cloud

Lecture 62 This Section is for Kops!

Lecture 63 Introducing Kops – Kubernetes Operations

Lecture 64 Installing the Kops Environment – 2021 Update

Lecture 65 Configuring your first cluster

Lecture 66 Running the Cluster

Section 15: EKS – Running Kubernetes on the AWS Cloud

Lecture 67 This section is for EKS

Lecture 68 Getting started with EKS

Lecture 69 Install eksctl and AWS CLI

Lecture 70 Configure the AWS credentials

Lecture 71 Install kubectl

Lecture 72 Start the cluster

Section 16: Operating your Cluster

Lecture 73 This section is for both EKS and Kops

Lecture 74 Warning for next lecture – possible problems with EBS provisioning

Lecture 75 Provisioning SSD drives with a StorageClass

Lecture 76 Warning – problems with AWS LoadBalancers

Lecture 77 Note for Kops users

Lecture 78 A note for Mac users on Apple silicon

Lecture 79 Deploying the Fleetman Workload to Kubernetes

Lecture 80 Setting up a real Domain Name

Lecture 81 Surviving Node Failure

Lecture 82 Replicating Pods in Kubernetes

Section 17: Deleting the Cluster in Kops

Lecture 83 Deleting the Cluster

Lecture 84 Restarting the Cluster

Section 18: Deleting the Cluster in EKS

Lecture 85 How to delete your EKS cluster

Lecture 86 One last cluster deletion step

Section 19: Extra – how to run Kubernetes in Google Cloud

Lecture 87 How to deploy to Google Cloud Platform

Section 20: Logging a Kubernetes Cluster

Lecture 88 Introducing the ELK / ElasticStack

Lecture 89 Installing the Stack to Kubernetes

Lecture 90 Kibana – first look

Lecture 91 Setting Filters and Refreshes

Lecture 92 Demo: analysing a system failure

Lecture 93 Kibana Dashboards

Section 21: Monitoring a Kubernetes Cluster with Prometheus and Grafana

Lecture 94 Monitoring a Cluster (2020 update)

Lecture 95 Installing the kube-prometheus-stack

Lecture 96 Use the “Classic UI” in the next video

Lecture 97 Using the Prometheus UI

Lecture 98 Introducing Grafana

Lecture 99 (optional) How to Use NodePorts on a Cluster

Section 22: The Alert Manager

Lecture 100 Introducing Alerts – 2020 Update

Lecture 101 Preparing a Slack Channel

Lecture 102 Configuring the AlertManager

Lecture 103 Troubleshoot the alertmanager.yaml config

Lecture 104 Dealing with Firing Alerts

Lecture 105 The AlertManager UI and how to Silence Alerts

Lecture 106 How to handle the Watchdog

Lecture 107 Using PagerDuty

Lecture 108 Case Study

Lecture 109 Case Study: Troubleshooting a “Delinquent” node

Section 23: (Kops only): What Happens If The Master Node Crashes?

Lecture 110 What happens if the Master Node crashes? (Kops clusters only!)

Section 24: Going Further with Kubernetes

Lecture 111 Introduction to the “Advanced Section”

Lecture 112 Code / files for this section

Section 25: Kubernetes Requests and Limits

Lecture 113 Memory requests

Lecture 114 CPU Requests

Lecture 115 Memory and CPU Limits

Section 26: Metrics Profiling in Kubernetes

Lecture 116 Enabling the Metrics Server

Lecture 117 Viewing Metrics on the Dashboard

Lecture 118 Tuning Java Spring Boot Applications, Heap restriction

Lecture 119 Setting reasonable Requests

Section 27: Horizontal Pod Autoscaling

Lecture 120 Update: you will need to modify the yaml file in the next video

Lecture 121 Introducing Replication and Autoscaling

Lecture 122 Testing Autoscaling

Section 28: Readiness and Liveness Probes

Lecture 123 Demo: why readiness probes are needed

Lecture 124 Applying Liveness and Readiness Probes

Section 29: Quality of Service and Eviction

Lecture 125 Understanding the scheduler

Lecture 126 QoS labels

Lecture 127 Evictions

Lecture 128 Pod Priorities

Section 30: Kubernetes ConfigMaps and Secrets

Lecture 129 Creating a ConfigMap

Lecture 130 Consuming a ConfigMap as Environment Variables

Lecture 131 Do changes to a ConfigMap get propagated?

Lecture 132 How to consume multiple environments variables with envFrom

Lecture 133 Mounting ConfigMaps as Volumes

Lecture 134 Creating Secrets

Lecture 135 Using Secrets

Lecture 136 Where have we already used ConfigMaps and Secrets?

Lecture 137 (extra) Using Spring Cloud Kubernetes to Hot Reload ConfigMaps

Section 31: Ingress Controllers

Lecture 138 Introducing Ingress

Lecture 139 Defining Routing Rules

Lecture 140 Adding Routes

Lecture 141 Authentication

Lecture 142 Running Ingress on AWS

Lecture 143 Testing the Ingress Rules

Lecture 144 (Extra) setting up HTTPS with TLS termination at the load balancer

Section 32: Other Workload Types

Lecture 145 Batch Jobs

Lecture 146 Cron Jobs

Lecture 147 DaemonSets

Lecture 148 StatefulSets Overview

Lecture 149 StatefulSets for Database Replication

Lecture 150 Demo: Scaling out a Mongo Database

Section 33: Continuous Deployment on a Kubernetes Cluster

Lecture 151 Notes on this section of the course

Lecture 152 Introducing CI/CD

Lecture 153 Warning – be careful when Forking repositories

Lecture 154 Establishing a GitHub organization

Lecture 155 Setting up a Basic Jenkins System

Lecture 156 Defining a Pipeline

Lecture 157 Update – creating a Personal Access Token from Github

Lecture 158 Another minor update!

Lecture 159 Running a Multibranch Pipeline

Lecture 160 Reviewing Builds

Lecture 161 Notes on GitHub Organizations

Lecture 162 Organization Pipelines

Lecture 163 Continuous Deployment into a Cluster

Section 34: Introducing Helm

Lecture 164 Getting Started with Helm

Lecture 165 How do I Install a Helm Chart

Lecture 166 How to Find Helm Charts

Lecture 167 Installing a Monitoring Stack with Helm

Lecture 168 Working with Chart Values

Lecture 169 Customising values.yaml

Lecture 170 Avoiding Snowflake Clusters!

Lecture 171 Using Helm Pull to Take Control of a Chart

Lecture 172 Generating yaml with “Helm Template”

Lecture 173 Why would you write your own Helm Charts?

Lecture 174 Writing Go Templates for Helm

Lecture 175 Helm Functions and Pipelines

Lecture 176 Flow Control in a Helm Template

Lecture 177 Named Templates

Lecture 178 Inspecting a Professional Helm Chart

Section 35: Goodbye!

Lecture 179 Goodbye!

Lecture 180 Bonus Lecture

Anyone wanting to use Kubernetes on live production projects,We will be using AWS in the later sections of the course (optional); all AWS concepts are explained so this is a great start if you’re new to the cloud, but be aware that AWS do charge for usage.

Course Information:

Udemy | English | 28h 4m | 14.64 GB
Created by: Richard Chesterwood

You Can See More Courses in the Developer >> Greetings from CourseDown.com