O'Reilly logo
live online training icon Live Online training

Building and Managing Kubernetes Applications

Learn how to use the Kubernetes API to define your applications and deploy and manage them in production.

Sébastien Goasguen

In this live online training course, you will learn the current best practices for building and managing your Kubernetes applications. Kubernetes is still a young technology so there are several tools and methods for managing applications including plain YAML, JSON-based manifests with a Jenkins pipeline, Helm charts, and more advanced techniques like the ones based on JSONNET. In this course, we’ll explain each of these techniques and highlight pros and cons so that you can choose the one that best suits your needs and environments.

We’ll also review the different types of workloads and their associated API resources that can run in a Kubernetes cluster. You can manage your Kubernetes applications using either a declarative configuration or an imperative configuration. We’ll walk you through the two different approaches with several examples using the Kubernetes client kubectl.

In this highly interactive course, you’ll use the kubectl client to deploy and manage applications using declarative or imperative configurations. Through hands-on exercises, you’ll also learn to use helm and other techniques like jsonnet templates and Custom Resource Definition (CRD) objects to define and manage your distributed application using the Kubernetes API object within your own environment.

What you'll learn-and how you can apply it

  • You are an application developer and you need to understand how to package your application for Kubernetes deployment.
  • You are an application architect and you want to know how the Kubernetes API objects can help you define your distributed applications and use your container images.
  • You are an application developer and you need to learn how to write a Helm Chart that represents your distributed application.
  • You are an application developer and you want to learn about jsonnet or other templating engine to templatize your Kubernetes manifests.
  • You are a system administrator and you need to know how to run and secure Helm so that applications can be deployed as Charts packages.
  • You are a system administrator and you need to understand how to manage running applications in Kubernetes.
  • You are software engineering team lead and you need to know how to use your CI/CD pipeline to test and deploy applications in a Kubernetes cluster.
  • You are a solutions architect and you want to learn about alternative CD techniques that leverage core Kubernetes API objects.
  • You are a solutions architect and you need to understand the latest trend about application packaging in Kubernetes such as which templating engine to use and which core API objects might help you.

This training course is for you because...

By the end of this live online course, you’ll understand:

  • All the API Objects available to them to define their workloads
  • The difference between imperative and declarative object configuration
  • What is Helm and how to use it

And you’ll be able to:

  • Use declarative and imperative management methods.
  • Create their own Chart repository
  • Use some of the newer packaging solutions (e.g Jsonnet)

Prerequisites

  • Basic understanding of containers
  • Understanding of Kubernetes and beginner level familiarity with the k8s API
  • Familiarity with Linux and continuous integration/continuous deployment a plus
  • Familiarity with text editors, YAML, and JSON formats

Recommended preparation:

Read Chapter 5 (Pods) and Chapter 12 (Deployments) of Kubernetes Up and Running

Introduction to Kubernetes (book)

Materials or downloads required in advance of the course:

Attendees will need access to a Kubernetes cluster, either local or remote. During the course all hands-on demonstration will be done on a local machine using minikube. Therefore the recommended setup is to install the following two tools (minikube and kubectl) and then clone the GitHub repo listed below, which contains example manifests that will be used during the course.

minikube

Kubectl

Git clone

Instructor files on his github repo

About your instructor

  • Sebastien Goasguen is a twenty year open source veteran. A member of the Apache Software Foundation, he worked on Apache CloudStack and Libcloud for several years before diving into the container world. He is the founder of Skippbox, a Kubernetes startup acquired by Bitnami where he currently serves as Senior Director of Cloud Technologies. An avid blogger he enjoys spreading the word about new cutting edge technologies . Sebastien is the author of the O’Reilly Docker Cookbook and 60 Recipes for Apache CloudStack.

Schedule

The timeframes are only estimates and may vary according to how the class is progressing

Segment 1 Intro (5 minutes)

  • Welcome and logistics
  • Check availability of Kubernetes endpoint
  • Intro to application management

Segment 2 Review Kubernetes API Resources (30 minutes)

  • Instructors will review the most important Kubernetes API resources that are used to write applications
  • Attendees will follow along the step-by-step demos/script
  • e.g Deployments, ReplicaSets, StatefulSets, DaemonSets, and Jobs

Segment 3 Declarative vs Imperative Management (15 minutes)

  • Instructors will explain the difference between imperative vs declarative management
  • Instructors will illustrate the differences with several hands-on scenarios where the instructor will manipulate Kubernetes manifests (defining the canonical guestbook application) using the kubectl command line. Attendees will follow along step-by-step using the manifests available on the Github repository.
  • Participants will follow along the step-by-step demos/script

Break (length: 10)

Segment 4 Q&A and Exercise (10 minutes)

  • Q&A session
  • Introduce and discuss exercises that illustrate common use of the Kubernetes API
  • Exercise #1: Deploy a multi-tier Kubernetes application made of a distributed storage backend, a scalable web frontend, and an Ingress resource and highlight the rolling updates and auto-scaling capabilities of Kubernetes.
  • Exercise #2: Use kubectl create, kubectl replace, kubectl apply, and highlight the differences.

Segment 5: Helm and Charts (40 minutes)

  • Instructors will explain the Helm architecture
  • Instructor will show how to write a Chart
  • Instructor will show how to set up a Chart repository
  • Participants will follow along, deploy a chart on their own Kubernetes cluster, write their own chart, and make it available in their own Chart repository.

Break (length: 10 min)

Segment 6: Application Packaging Solutions (60 minutes)

  • Instructors will discuss alternatives to Helm and illustrate some of them (e.g opencompose, jsonnet based manifests, ksonnet based manifests, Ansible playbooks)
  • Instructor will introduce the cutting-edge technologies developed by the Kubernetes community, especially ones that make use of Custom Resource Definitions.
  • Participants will follow along each solution with hands-on exercises that show how to use the aforementioned application formats to create a package of their application and deploy them onto a Kubernetes cluster.
  • Participants will follow step-by-step instructions that illustrate each application definition format.