DevOps Training Icon

Advanced Kubernetes Boot Camp


3 Days Classroom Session   |  
3 Days Live Online
Classroom Registration
Individual:
$2750.00
Group Rate:
$2550.00
(per registrant, 2 or more)
GSA Individual:
$2007.50
Live Online Registration
Live Online:
$2750.00
Private Onsite Package

This course can be tailored to your needs for private, onsite delivery at your location.

Request a Private Onsite Price Quote

Professional Credits

IIBA (CDU)

ASPE is an IIBA Endorsed Education Provider of business analysis training. Select Project Delivery courses offer IIBA continuing development units (CDU) in accordance with IIBA standards.

PMI (PDU)

Select courses offer Leadership (PDU-L), Strategic (PDU-S) and Technical PMI professional development units that vary according to certification. Technical PDUs are available in the following types: ACP, PBA, PfMP, PMP/PgMP, RMP, and SP.

Certification
Overview

Kubernetes’ learning curve can be overwhelming, due to the ecosystem growing more and more each day. There are many advanced concepts, tools, and practices, one must master if they want to take full advantage of all that Kubernetes has to offer. Your initial introduction to pods, deployments, and services were just the beginning of an ongoing learning journey.

In this advanced Kubernetes training course, an experienced technologist will guide you through critical topics around Kubernetes that will help you build enterprise applications. Moreover, you will explore the vast ecosystem from the Cloud Native Computing Foundation (CNCF) for tools and projects available in Kubernetes. Some of the projects you will explore and use are Helm, Telepresence, Istio, Octant, and Vitess. This course is a 50/50 split between theory and practical exercises. In order to fully participate, you must have a basic understanding of Kubernetes and feel comfortable using the command line in a Linux environment.

In this Kubernetes Training Course, You Will Learn How To:

  • Design patterns that you can implement in Kubernetes to build and run scalable systems in production
  • Apply existing security policies in a Kubernetes ecosystem
  • Extend the Kubernetes API to operate systems more easily
  • Develop stateful services using Kubernetes
  • Use Istio in a microservices system
  • Create, deploy, and test scalable and fault-tolerant applications 
  • Work with Telepresence, GitOps, and Flux
Upcoming Dates and Locations
All Live Online times are listed in Eastern Time Guaranteed To Run

There aren’t any public sessions currently scheduled for this course, but if you fill out the form below, we can tell you about how we can bring this course to you!

Course Outline

Part 1: Core Concepts

We’ll go deep into different terms of Kubernetes to understand what it takes to build and run scalable systems in production. There are design patterns that you can implement in Kubernetes to extend an existing application without having to change the source code, like a sidecar pattern.

  1. Kubernetes APIs
  2. Pods, deployments, services, namespaces, daemonsets
  3. Imperative and descriptive manifests
  4. Working with multiple clusters (kubeconfig)
  5. Exercise: Interacting with a Kubernetes cluster using Octan
  6. Kubernetes design patterns
  7. Multi-containers in pods
  8. InitContainers

Part 2: Security Practices and Recommendations

Kubernetes is not secure by default, and there are many considerations that you need to be aware of if before exposing your applications to the public internet. Companies usually have existing security policies, so we’ll cover how these security practices apply in a Kubernetes ecosystem.

  1. Recommended security practices
  2. Authentication and authorization
  3. Patching and upgrading practices
  4. Using secrets with pods (env or volumes)
  5. Secrets with HashiCorp Vault
  6. Networking policies
  7. Admission controls
  8. Exercise: Configuring a secure cluster

Part 3: Extending the Kubernetes API

There are times where we need to extend the Kubernetes API to operate systems more easily. Not everyone will need to build something to extend the Kubernetes API, but it’s very valuable to understand the what, when, and how of custom resource definitions and the operator pattern.

  1. What is a custom resource definition?
  2. Why do you need a custom resource definition?
  3. Exercise: Creating a “Hello World” CRD
  4. What is the operator pattern?
  5. Examples of common operators
  6. What’s the difference between CRDs and operators?
  7. Exercise: Using operators

Part 4: Developing Stateful Services

Stateless services are great for certain use cases, but there are scenarios where an application needs to be able to store data permanently, or at least work with data that is not ephemeral. Databases are one example.

  1. Understanding persistent volumes
  2. Databases in Kubernetes
  3. Exercise: Using Vitess for MySQL

Part 5: Networking in Kubernetes

Understanding how networking works in Kubernetes is important because it will help you to configure networking patterns like service discovery for a microservices architecture. But another concept that is taking more relevance are service meshes. We’ll explore what a service mesh is, and we’ll practice using one of the most popular ones: Istio.

  1. Understanding pod networking communication
  2. Understanding service networking communication
  3. Exposing applications with Ingress controllers
  4. Introduction to service meshes
    • What’s a service mesh?
    • Introduction to Istio
    • Observability with Istio
    • Networking security with Istio
    • Canary releases with Istio
    • Registering external dependencies into the service mesh
    • Exercise: Using Istio in a microservices system

Part 6: Creating Scalable and Fault-Tolerant Applications

Kubernetes has a lot of great features built-in by implementing the controller pattern. But in many cases, our applications need to include small configurations to help Kubernetes make better decisions to support reliable applications. We’ll see what changes are needed in the applications, and then we’ll deploy and test a sample application.

  1. Working with probes
  2. Configuring requests and limits
  3. Configuring scaling policies
  4. Taints and tolerations
  5. Node selectors
  6. Exercise: Configuring and testing autoscaling

Part 7: Development Workflow in Kubernetes

Kubernetes doesn’t have to change the way developers build applications, but they might want to be involved or test in their local workstations when they’re done with their application changes. We’ll discuss some recommended practices and tools.

  1. Toolbox: State of the art
  2. Exercise: Working with Telepresence
  3. Logging and monitoring systems
  4. Continuous integration and continuous delivery
  5. Exercise: Working with GitOps and Flux
  6. Packaging and managing applications with Helm
  7. Troubleshooting applications failure (logs, describe, etc.)

Conclusion: What’s Next for Kubernetes?

We’ll discuss other topics related to Kubernetes that might not fit everyone’s use cases, but that as a Kubernetes user you might want to be aware of. For instance, we’ll talk a little bit about having federated clusters, hybrid workloads, and several important tools from the CNCF.

Who should attend
  • Software Developers
  • Software Engineers
  • DevOps Engineers
  • Frontend Engineers
  • Backend Engineers
  • Full Stack Developers
  • ML/AI Engineers
  • Cloud Engineers
  • Cloud Architect
Pre-Requisites

Students need foundational level knowledge DevOps practices, intermediate Kubernetes experience, and familiarity with working on the command line in a Linux environment.

If you don't meet the above requirements, we strongly encourage you to take our Introduction to Kubernetes course before participating in this course. 

0
1