Kubernetes for Microservices and Managing Distributed Apps
2.4 (2 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
35 students enrolled

Kubernetes for Microservices and Managing Distributed Apps

Learn all about Kubernetes: Develop and operate microservices to deploy, maintain & secure your distributed applications
2.4 (2 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
35 students enrolled
Created by Packt Publishing
Last updated 6/2019
English
English [Auto-generated]
Current price: $139.99 Original price: $199.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 8 hours on-demand video
  • 1 downloadable resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Create a container from your existing source code, and make your application ready to run on any Kubernetes-supported Cloud.
  • Set up and use a modern DevOps workflow that takes care of updating existing deployments when new code is checked into the source code repo.
  • Build resilient, scalable and highly available distributed applications running on any platform on-premise or in the cloud.
  • Secure your distributed applications by using container’s built-in security features.
  • Use Kubernetes secrets to protect confidential data such as passwords and certificates.
  • Monitor and troubleshoot your application running in production and allow the application to self-heal.
  • Update any service of your application at any time without causing downtime using rolling updates, blue-green deployments or canary releases.
  • Avoid cascading failures in your highly distributed application by anticipating failure and coding defensively.
  • Use Docker Compose to simulate a production like an environment on your personal development laptop or workstation.
  • Create a continuous delivery pipeline with the power of Kubernetes.
  • Develop, test and debug code while it is running inside a container.
Course content
Expand all 72 lectures 08:03:09
+ Kubernetes for Developers
27 lectures 03:08:03

This video will give you an overview of the course.

Preview 01:22

The aim of this video is learn the installation process.

  • Get to know the Pre-requisites for the development environment

  • Explore the minikube features

  • Set up your machine

Installation of kubectl, Minikube (Kubernetes), and Docker
07:50

This video is a detailed explanation of Kubernetes.

  • Find out why do we need Containers

  • Explore the use of Kubernetes

  • Take a business case for Kubernetes and Container

What Is Kubernetes and Why Do We Need It?
08:38

Dive deeper into Kubernetes with this video.

  • Get an overview of Kubernetes

  • Learn the master process

  • Study in detail about Node, Pods and Containers

Introduction to Basic Concepts: Nodes, Pods, and Containers
12:11

The aim of this video is to learn the basics to deploy an application.

  • Learn about Replica Sets

  • Explore in depth about deployment and a Deamon Set

  • Get familiarized with Services

Introduction to Basic Concepts : Replica Sets, Deployments and Services
07:19

The aim of this video is to learn the purpose of a Container.

  • Study in detail about a Container

  • Go through the Dockerfile commands

  • Study the techniques to build a Container and to create a base image

What a Container Image Is, How to Build a Container?
12:06

The aim of this video is to learn about running code in a Container.

  • Create the Node.js app

  • Create the Dockerfile

  • Test and run the app and cleanup

Example Code in Node.js Compiled into a Container
08:43

Take another example of running code in a Container.

  • Create the Golang app

  • Create the Dockerfile and run the app

  • Learn the cross compiling techniques

Example Code in Golang Compiled into a Container
05:16

The aim of this video is to learn how to create a Container.

  • Learn the steps for preparation to run Docker in Kubernetes

  • Know more about Docker registry

  • Upload and verify Docker image on Docker Hub

Create Your Images for Use Within Kubernetes – Uploading to a Registry
06:49

The aim of this video is to learn the commands in a Container.

  • Explore how to run commands in Docker

  • Take a look at a few examples

  • Learn how to get logs with the use of examples

Run Commands in Your Container, and Get Debugging Logs, Running on Local Docker
02:39

The aim of this video is to learn how a Pod works.

  • Know more about a Pod’s status field

  • Explore the possible values for Phase

  • Define postStart and preStop handlers

Pod and Deployment Lifecycle, along with Pod Lifecycle Hooks
05:15

The aim of this video is to learn how labels work.

  • Get in-depth knowledge about labels and annotations

  • Learn how to attach label to a node

  • Walk through a labels selectors example

How Labels and Annotations Work with the Kubernetes Infrastructure
05:42

The aim of this video is to learn the techniques for rolling out your Pod.

  • Study in depth about deployment

  • Take a look at the YAML example

  • Scale a deployment

Deployments – Creating a Rollout of Your Pod
07:20

The aim of this video is to learn the techniques for putting storage in your deployment.

  • Learn about Persistent Storage(PV) and persistent Storage Claim (PVC)

  • Create a PV and a PVC

  • Connect the PVC in a Pod

Persistent Storage
08:21

The aim of this video is to learn to add configuration files in the Pod (Docker).

  • Learn environment variables with examples

  • Learn ConfigMap object with examples

Handle Arguments and Configuration Values Like ConfigMap and Environment Variabl
09:28

The aim of this video is to learn to connect your Pod to the internet.

  • Learn more about Ingress

  • Explore in detail about services and its types

  • Connect the service to the outside world with an example

Services – Connecting Your Pod (Deployment) to the Outside World
06:36

The aim of this video is to explain Role and ClusterRole.

  • Learn about Namespace

  • Study in detail about RBAC

  • Explore Role and ClusterRole

Role and ClusterRole and Namespaces
07:22

The aim of this video is to give a detailed explanation on the service account.

  • Learn about service account with an example

  • Connect dervice account for deployment

Creating a Service Account and Binding This into the Deployment (Pod)
03:42

With this video learn to add more roles to one service account.

  • Know more about resource names

  • Learn about aggregrated ClusterRoles

  • Add and view default ClusterRoles

Referring to Resources, Aggregated ClusterRoles
06:23

Here we’ll now put everything together.

  • Create a namespace

  • Create a Role

  • Export the config file

Creating a User for Kubernetes
07:00

The aim of this video is to learn to setup monitoring.

  • Explore Prometheus

  • Set up monitoring with an example

Set Up and Run Prometheus
08:44

The aim of this video is to learn to show graphics for the monitoring.

  • Learn about Grafana

  • Know more about Configmaps

  • Deploy your application

Set Up and Run Grafana from Prometheus to Build Custom Dashboards
09:26

The aim of this video is to learn the logging in to a central service.

  • Study about Sidecar Containers

  • Take a look at an example with 2 sidecars

  • Walk through an example of fluentd

Logging off Your Application Using a Sidecar Container
09:08

What do we do when a Pod service or node doesn’t work?

  • Go through the most important debugging commands

  • Find out more about debugging deployment

  • Debug Pods, Services and Nodes

Troubleshooting the Pod and/or Deployment
11:37

The aim of this video is to create a cluster.

  • Create a cluster at GCE

  • Delete a Cluster

Create a Kubernetes Cluster at GCE
05:12

In this video, we’ll learn to deploy your application

  • Create a deployment

  • Run the application

Deploying Application/Pod in GCE
02:43

This video will give you a brief summary of the course.

  • Review what we’ve learnt so far!

Success
01:11
Test your knowledge
4 questions
+ Develop and Operate Microservices on Kubernetes
19 lectures 01:29:40

This video will give you an overview about the course.

Preview 03:21

Kubernetes is difficult to set up and operate. Minikube offers an easy solution for setting up a local Kubernetes environment for testing and developing.

  • Find and install the appropriate version and build of Minikube

  • Start and stop the Minikube VM

  • Identify and enable required add-ons

Setting Up Minikube
03:21

This video shows the very first steps on deploying a microservice on Kubernetes and also covers some required core principles.

  • Learn about Pods and Nodes

  • Define a Pod using a YAML definition

  • Use kubectl to list and manage Pods

Deploying a Microservice
04:30

Kubernetes Pods are neither resilient nor scalable. This video introduces high-level controllers like ReplicaSets that offer solutions for this.

  • Learn about shortcomings of single Pods and how a ReplicaSet solves them

  • See ReplicaSet resiliency in action

  • Overview on different high-level controllers and when to use them

Service Resiliency and Scalability
04:10

Practical implementation of concepts already shown in 1.4; create resilient and scalable deployments using ReplicaSets.

  • Learn about Labeling

  • Define and create a ReplicaSet

  • Scale a ReplicaSet

Using ReplicaSets
03:22

Kubernetes Pods do not provide a stable network identity that other applications could connect to. Service objects offer a solution to that problem.

  • Learn what problems services solve

  • Define and test a service

  • Learn about LoadBalancer services

Connecting Services
06:34

Kubernetes service only provides simple TCP/UDP forwarding. Ingress controllers offer more sophisticated HTTP request routing features.

  • Learn about service shortcomings and how Ingresses solve them

  • Learn about different ingress controllers

  • Define and test an Ingress definition

HTTP Connectivity with Ingress
05:06

ReplicaSets provide scalable and resilient application deployments; but they do not provide a robust mechanism for providing updates. This problem is solved by Deployment objects.

  • Learn about how ReplicaSets do not provide application updates and how Deployments do

  • Define and test a Deployment with rolling update

  • Learn how to roll back a failed deployment to a previous version

Managing the Application Lifecycle with Deployments
04:01

Up until now, we have only learned how to deploy stateless applications; this section introduces the concept of stateful applications and illuminates under which circumstances you should decide for which kind of storage engine.

  • Learn about Stateful applications

  • Learn about Persistent Volumes

  • Learn about Network Block Devices and Network File Systems

Stateful Services and Storage Drivers
04:27

Managing network volumes is a complex tasks; Kubernetes breaks this down into separately managing PersistentVolumes and PersistentVolumeClaims.

  • Learn about separation of concerns in working with storage volumes

  • Define a PersistentVolume and claim it

  • Define a Pod that uses the PersistentVolume created before

Working with Persistent Volumes
05:47

Manually creating PersistentVolumes is time-consuming and tedious. Automatic Volume Provisioning and Storage Classes offer a solution for this.

  • Learn about Storage Classes and automatic provisioning

  • Define a Storage Class

  • Define a PersistentVolumeClaim using a Storage Class

Automatic Volume Provisioning
03:06

Sometimes you will need to deploy clustered applications in which each instance will require its own private persistent volume. This is often the case when deploying databases. This can be done using StatefulSets.

  • Learn about StatefulSets and Headless Services

  • Define and create a StatefulSet

  • Learn about the exact differences between StatefulSets and ReplicaSets

Using StatefulSets
08:29

Often, your application will require various configuration values. While you could just define these as Pod environment variables, ConfigMaps offer a solution that is easier to manage.

  • Learn about different kinds of configuration data

  • Define a ConfigMap

  • Use a ConfigMap to initialize environment variables in a Pod

Using ConfigMaps
05:24

Using ConfigMaps to manage environment variables is a useful feature – but often, applications require entire configuration files to run. This can also be solved using ConfigMaps.

  • Learn how to store large files in a ConfigMap

  • Use a ConfigMap as a volume in a Pod

  • Learn how to create a ConfigMap from an existing directory containing configuration files

Inject Configuration Files into Pods
04:13

ConfigMaps are great, but not secure. Secrets work similar to ConfigMaps, but are designed to store secret data like password, API keys and other sensitive data.

  • Learn about the difference (and similarities) between ConfigMaps and Secrets

  • Learn how to create a Secret and to use it in a Pod

  • Create a secret from existing files or direct user input

Keeping Secrets
04:51

Typically, you will want to deploy your application automatically from a source code repository as soon as changes are made in the repository. This video will show you how a typical Continuous Delivery pipeline in Kubernetes looks like.

  • Learn what Continuous Integration and Delivery is (in a nutshell)

  • Discuss different possible typical build pipelines

  • Learn about typical caveats and how to solve them

Characteristics of a CI/CD Pipeline
03:55

GitLab is a popular solution for both version control and Continuous Integration and Delivery. This video will show how to implement the deployment pipeline shown earlier using GitLab CI.

  • Learn about GitLab

  • Define a deployment pipeline using GitLab CI

  • See a deployment pipeline in action

Configuring CD with GitLab
05:59

Often, Kubernetes deployments are complex and consist of multiple objects that are difficult to manage manually. This can be made easier using the Helm package manager.

  • Learn about Helm and its basic architecture

  • Define a Helm chart for your application

  • Deploy that Helm chart into your cluster

Setting Up Helm
05:45

This video combines the knowledge from the previous two and shows how to build a continuous delivery pipeline using GitLab CI and Helm.

  • Use Helm in a GitLab CI pipeline

  • Release and deploy a new version of your application

  • Lean back and let GitLab do the rest

Using Helm in CI
03:19
Test your knowledge
5 questions
+ Hands-On Kubernetes and Docker for Distributed Applications
26 lectures 03:25:26

This video provides an overview of the entire course.

Preview 05:35

This video demonstrates the sample solution that is used during the whole video series.

  • Give an architectural overview of the sample application

  • Quickly display the source code pertaining to the sample application

  • Run the application

Introduction to the sample application
06:42

Shows how to author a Dockerfile for the two services of the sample application that are custom built.

  • Explain what a Dockerfile is

  • Author a Dockerfile for the Java-based application service

  • Build the Docker image using the Dockerfile

Authoring a Dockerfile for Each Application Service
08:55

This video shows how to develop, test, and debug line by line a .NET core application that is running in a container whilst the code is edited in a code editor running natively on the developer’s laptop.

  • Create a .NET Core web application in a container

  • Enable edit and continue type development inside the container

  • Author and run unit tests inside a container

Develop, Test and Debug a Service Running in a Container
11:49

This video shows techniques to minimize the size of a Docker image for a Java-based and a .NET core based application service.

  • Explain the benefits of a minimal Docker image

  • Modify an existing Dockerfile to a multi-stage version

  • Build the Docker image using the multi-stage Dockerfile

Minimizing Docker Images Using Multi-Stage Docker Builds
08:38

In this video, Docker Compose is introduced as a tool that is primarily targeted at running, testing, orchestrating, and troubleshooting a multi-container application on the developer’s machine.

  • Describe the main features of the Docker Compose tool

  • Use Docker Compose to run the sample application

  • Use Docker Compose to stop and start individual services

Using Docker Compose to Run and Troubleshoot Our Distributed Application Locally
11:01

This video demonstrates introducing the learner to stateless and stateful services and explain what their key differences are

  • Contrast the two types of services, stateless on one and stateful on the other

  • List the main characteristics of a stateless service

  • List the main characteristics of a stateful service

Stateless versus Stateful Services
04:10

This video explains to the user in some depth why they should create stateless services at all cost

  • Point out that stateless services are easy to implement and scale

  • Discuss that updating stateless services is easy and straight forward

  • Explain that stateless services are the ones that contain most of the business specific logic and algorithms

Why You Should Create Stateless Services at All Costs
03:16

In the video I reason why it is so extremely hard to build stateful services.

  • Explain why we need transactional behavior in a stateful service

  • Reason why availability of a stateful service is paramount

  • Justify why replication is essential for a stateful service

Stateful Services Are Hard - Deal with Persistent State
05:13

This video conveys key ingredients that are needed to build a stateful service that is resilient, scalable, durable and fault tolerant

  • How to make a stateful service scalable

  • How to make a stateful service durable

  • How to make a stateful service fault tolerant and resilient

Build Stateful Services That Are Resilient and Scalable
07:57

Here we list and discuss the considerations that need to be accounted for when talking about storage that is backing a stateful service

  • Categorize the criteria to be considered when selecting storage

  • Explain what latency means in the context of storage

  • Elaborate on availability and cost of storag

Storage Latency versus Storage Availability, versus Storage Cost
07:56

In the first video of the section we are going to explore what sensitive data is, and how we should deal with it in a mission critical, distributed application.

  • Provide motivation for securing our distributed applications

  • Explain what sensitive data is

  • List building blocks of a secure software supply chain

What is Sensitive Data and How to Deal with It?
04:07

This video presents how to define, create and use secrets when running an application service on Kubernetes.

  • Introduce Kubernetes secrets

  • Prepare a simple Kubernetes cluster for development

  • Define and use Kubernetes secrets

Using Kubernetes Secrets
10:44

This section shows techniques one can use when dealing with secrets in development.

  • Recap use of secret on Kubernetes cluster

  • Create temporary dev secrets and map into application container

  • Use temporary dev secrets same way as Kubernetes secrets

Dealing with Secrets in Development
06:48

This video introduces yet another way how developers often have to deal with secrets, namely when they originate in external sources such as AWS IAM, Foxpass or Hashicorp's vault.

  • Retrieve secrets from a Vault instance

  • Use external secrets in application

  • Create entrypoint script for container that retrieves external secrets

How to Use External Secrets Such as HashiCorp’s Vault
06:15

The last video of the section about Securing a Distributed Application teaches how content trust works and how one can sign Docker images.

  • Explain content trust

  • Setting up a trust sandbox

  • Work with content trust

Signing Your Docker Images
09:37

The first video of section 4 discusses why logging is important and explains how an application service can be instrumented to produce logging information.

  • Explain how to log

  • Instrument a Java application with logging capabilities

  • Analyze a Python sample application that logs messages

Logging the Right Way
07:17

This video shows the user how to implement liveness and readiness probes

  • Define the two probes, liveness and readiness

  • Elaborate on how a liveness probe is implemented and configured

  • Repeat the same for the readiness probe

Implementing Health and Availability Checks
08:09

This video describes some techniques commonly used to cope with external services that are not reliable

  • Explain that the applications service depends on other external services

  • Analyze what could possibly go wrong outside of the service

  • Provide a list of coding recommendations

Defensive Coding Techniques to Increase Resiliency
04:12

This video explains ways that allow an application service to be scalable

  • Explain why to use caching extensively

  • Promote asynchronous programming and show code example

  • Discuss additional patterns useful to make services scalable

How to Make Your Services Scalable
08:03

This last video of the section shows how to use the rolling update deployment technique with Kubernetes which allows for zero downtime updates of your application services

  • Show, build and deploy a Python app in version 1.

  • Modify the application to create a version 2

  • Use rolling update to deploy version 2 causing zero downtime

Enabling Zero Downtime Updates
11:07

The first video of section 5 provides a quick review of the main Kubernetes objects such as pods, replica sets, deployments and services.

  • Describe and deploy a simple pod to single node Kubernetes cluster

  • Do the same for ReplicaSet and Deployment

  • Explain and create a Kubernetes service for a Deployment

Quick Review of Kubernetes Pods, ReplicaSets, Deployments, and Services
12:05

This video leads through the definition and use of deployment templates for the various components of our sample application

  • Revisit the architecture of the sample app

  • Introduce Helm and deploy Kubernetes via Helm

  • Define and apply Deployment template for the producer

Creating Kubernetes Deployment Templates
10:04

This video demonstrates some of the main features of Kubernetes as a container orchestrator

  • Explain how to show extensive information about the cluster

  • Deploy, scale and self-heal a service

  • Grow the cluster by adding a node

Using Kubernetes as Orchestrator
11:58

This video shows how the sample application can be deployed into a production ready, fully hosted Kubernetes cluster on Google cloud.

  • Deploy Kafka, ZooKeeper, Schema Registry and KSQL Server using Helm

  • Configure Kafka and deploy the producer

  • Test that the producer is working as expected

Deploying your Application On-Premise or in the Cloud
04:46

The last video of the section introduces two fully hosted Kubernetes offerings in the cloud by Google, called GKE, and by Microsoft, called AKS.

  • Create a hosted cluster in GKE

  • Deploy and test a service on this cluster

  • Create a hosted cluster in AKS

Peek into Two Hosted Kubernetes SaaS Offerings by Microsoft Azure & Google Cloud
09:02
Test your knowledge
5 questions
Requirements
  • A Basic Knowledge of Linux and Docker is assumed.
  • No prior knowledge of Kubernetes is required.
Description

Kubernetes is a powerful tool which helps you in orchestrating, automate, deploy, scale, and manage containerized applications, giving you the freedom to take advantage of on-premise and cloud infrastructures. With Docker containers, your applications can run smoothly without you worrying about the environment where they run!

This comprehensive 3-in-1 Course is packed with step-by-step instructions, working examples and focuses on how to deploy, scale, and maintain your distributed applications with Kubernetes. To begin with, you’ll get an introduction to basic concepts (Nodes, Pods, Replica Sets, Containers, etc) with which you’ll learn to write cloud-native applications that can run anywhere. You’ll create a continuous delivery pipeline with the power of Kubernetes and learn how to troubleshoot your application deployment on Kubernetes. Finally, you’ll build resilient, scalable and highly available distributed applications running on any platform on-premise or in the cloud using Kubernetes and Docker.

By the end of this course, you'll learn all about Kubernetes and Docker to deploy, scale, maintain and secure your distributed applications.

Contents and Overview

This training program includes 3 complete courses, carefully chosen to give you the most comprehensive training possible.

The First Course, Kubernetes for Developers covers how to develop, run, test, and deploy your applications in the cloud. This course will give you detailed instructions, real-world examples, and helpful advice. We will begin by learning to set up the development environment on your local machine. Then move on to package your code into Kubernetes and manage container lifecycles. Once you get a grip on understanding the RBAC Authorization, very easily explore the monitoring techniques with Prometheus and troubleshoot your service account. Finally, you will learn to create a cluster in your Google Cloud Environment and deploy your application in production. By the end of this video, you will develop, run, test, and deploy your application in the cloud, utilizing the power of Kubernetes to its full potential.

The Second Course, Develop and Operate Microservices on Kubernetes, covers how to deploy, scale, and maintain your distributed applications with Kubernetes. The goal of this course is to walk you through the process of getting familiar with Kubernetes and its way of doing things. The course is designed to get you through the process of becoming familiar with the Kubernetes environment in order to be able to deploy, configure, and manage the environment where the services are going to run. You will go through examples based on the author’s real-world experience in working with Kubernetes while building complex distributed architectures. We focus on deploying services that need to store data and learn how Kubernetes Persistent Volumes can be used to create deployments that guarantee data resiliency. Moving on, we learn how to give services access to connection strings, usernames, passwords, and other sensitive information using Kubernetes Secrets. By the end of the course, you will have mastered the best practices and leveraged some of the latest DevOps technologies to increase agility and decrease time-to-market for the services you have built.

The Third Course, Hands-On Kubernetes and Docker for Distributed Applications, covers how to ship and run distributed applications anywhere with Docker. This course shows you how Docker can be used to isolate your application services and their dependencies into a single self-contained unit that can reliably run anywhere. You will learn to build, ship and run distributed applications on any platform using Kubernetes as the orchestrator. By the end of this course, you will be able to use Docker and Kubernetes to build distributed applications that are scalable, resilient, fault-tolerant and secure. Furthermore, you will be able to deploy these applications to any Kubernetes cluster running on any platform on-premise or in the cloud.

By the end of this course, you'll learn all about Kubernetes and Docker to deploy, scale, maintain and secure your distributed applications.

About the Authors

Jan Stomphorst is a senior solution architect with more than 20 years' experience in the automation industry; he creates the best solutions for his customers. He uses advanced technology solutions to help developers create stable continuous pipelines and develop systems for 100% uptime. He is a Docker and Kubernetes expert. He supports several customers with on-premise and in-the-cloud Kubernetes strategies.

Anand Totala is a software developer in India, with a bachelor’s in computer science. He has Programmed in C, C++, Python and well versed with containerization technology and DevOps Tools like Docker, Kubernetes, Jenkins, Ansible, etc. He is also contributing to OpenStack cinder component.

Gabriel N. Schenker has more than 25 years of experience as an independent consultant, architect, leader, trainer, mentor, and developer. Currently, Gabriel works as Senior Curriculum Developer at Confluent after coming from a similar position at Docker. Gabriel has a Ph.D. in Physics, and he is a Docker Captain, a Certified Docker Associate, and an ASP Insider. When not working, Gabriel enjoys time with his wonderful wife Veronicah and his children.

Who this course is for:
  • Software Developers, Architects, DevOps professionals, and experienced Software Engineers who:
  • Want to take advantage of the power of Kubernetes and are interested in running code or applications in a cluster environment.
  • Use Docker and Kubernetes to solve many of the hard problems they run into with distributed applications.
  • Want to keep track of their application components, orchestrate and administrate them in a consistent way.