O'Reilly logo
live online training icon Live Online training

Kubernetes in Three Weeks: Part l

enter image description here

Get started with terms, architecture, containers, microservices, applications and patterns

Topic: System Administration
Jonathan Johnson

Distributed application architectures are hard. The complexity in building containers and designing microservices to work together across a network can be overwhelming. To successfully manage limitations on resources, failing networks, defective software, and fluctuating traffic, you need an orchestrator.

Kubernetes is designed to handle these complexities, so you don’t have to. Essentially a distributed operating system for your data center, you give Kubernetes containers, and it makes sure that they remain available and responsive. As such, Kubernetes is quickly becoming the preferred way to serve distributed, scalable, and resilient applications.

Jonathan Johnson walks you through Kubernetes building blocks to demonstrate how the tool actually works. You may already understand containers—the tricky part is getting a whole set of containers and services to consistently work together and run reliably. In this three-part series, you’ll get comfortable designing, deploying, managing, and updating a coordinated set of applications running on Kubernetes.

Although you can attend any of the three courses individually, we recommend pursuing the entire series, in this order: Week 1: Getting Started with Kubernetes—Introduction, terminology, architecture, and first apps Week 2: Containers and Microservices—Packaging and running apps Week 3: Applications and Patterns—Patterns for apps leveraging Kubernetes

Week 1: Getting Started with Kubernetes

In this first course, you’ll explore the most important parts of Kubernetes. Jonathan will explain why it’s become the de facto orchestration platform for distributed computing, introduce Kubernetes terminology, and cover the benefits to developers (no coding required)—all while breaking down the architecture to get you to the aha moment when you understand how the engine works. You’ll then get hands-on as you learn how to run and distribute applications on this new paradigm. Once you see how it all works, you’ll dive into container patterns that developers use to run applications on Kubernetes. At the end of this course, you’ll have a thorough understanding of Kubernetes and a solid foundation for the more advanced topics that come later in this series.

Week 2: Containers and Microservices

Now that you understand how Kubernetes works, you’ll learn the importance of containers. This course will show you how to construct containers to behave as first-class objects on Kubernetes. You’ll explore frameworks in various languages to construct microservice-based apps as well as best practices for loading apps with a variety of languages into a container. You’ll focus on how to follow the distillation pattern. Jonathan will conclude by reviewing the techniques and best practices for adding containers to Pods so Kubernetes can bin pack them efficiently.

Week 3: Applications and Patterns

This course extends what you learned about the fundamentals of building containers and running them on Kubernetes. You know how to use the tools—now you need to think like an architect. You have a pile of virtual LEGO blocks in front of you; it’s time to start building. You may be surprised that many domain patterns in more traditional architectures (like object-oriented) often translate well to Kubernetes. With help from Jonathan, you’ll move your thinking from single memory and thread pools to distributed pools. There are many patterns to explore.

_NOTE: With today’s registration, you’ll be automatically signed up for all three sessions in the Kubernetes in Three Weeks: Part I series.

You might also be interested is registering for Kubernetes Part II on November 15-24

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

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

Week 1: Getting Started with Kubernetes

  • How Kubernetes functions as a state engine
  • How to write a declarative manifest that makes up your application
  • How to deliver, run, observe, and update applications on Kubernetes

Week 2: Containers and Microservices

  • How to build containers that follow best practices for Kubernetes
  • How to use tools to write, build, publish, and run containers
  • 12-factor applications
  • How to debug containers

Week 3: Applications and Patterns

  • Architecture patterns applied on Kubernetes
  • Various types of containers and Pod incarnations
  • When you should (and shouldn’t) put more than one container in a Pod
  • Data management best practices

And you’ll be able to:

Week 1: Getting Started with Kubernetes

  • Run your first applications on Kubernetes
  • Explore the administration tools
  • Navigate the various resources that make up Kubernetes
  • Assemble multiple application containers into a solution set
  • Scale and observe the health of services

Week 2: Containers and Microservices

  • Bundle applications into containers
  • Deploy different architectures all on Kubernetes
  • Write a microservice leveraging the scaling of Kuberentes
  • Explore container best practices and wrap them into Pods

Week 3: Applications and Patterns

  • Think like an architect while leveraging distributed resources
  • Design solutions with Pods
  • Implement massive scaling

This training course is for you because...

  • You’re a software engineer who wants to understand what it takes to move your applications to a distributed platform.
  • You’re a solutions architect who wants to see how various architecture topologies can be deployed to your data center machines.
  • You work with various languages and containers but want to coordinate them into a larger and more reliable offering for your customers.
  • You need to decompose your application into more modular components to ease the business needs for faster feature releases and updates.
  • You need to scale your application to a larger data center to address larger user base and compute needs.
  • You’re a team leader who wants to understand the skills and team organization to support delivery of your enterprise applications to a highly available and scaling cloud native target.
  • You want to better understand the role and skills of a cloud native engineer.


  • A working knowledge of Linux
  • A basic understanding of continuous integration and continuous development (CI/CD)
  • Experience writing applications in a variety of languages

Recommended follow-up:

About your instructor

  • Jonathan Johnson is an independent software architect focused on helping others unpack the riches in the cloud native and Kubernetes ecosystems. Jonathan is halfway into his second score of engineering commercial software, driven by his desire to design helpful software to move us forward. His applications began with laboratory instrument software and managing its data. Jonathan was enticed by the advent of object-oriented design to develop personal banking software. Banking soon turned to the internet, and enterprise applications took off. Java exploded onto the scene, and since then he’s inhabited that ecosystem. At 454 Life Sciences and Roche Diagnostics, Jonathan returned to laboratory software and leveraged Java-based state machines and enterprise services to manage the terabytes of data flowing out of DNA sequencing instruments. Then as a hands-on architect at Thermo Fisher Scientific, he applied the advantages of microservices, containers, and Kubernetes to the company’s laboratory management platform. Jonathan enjoys comparing and sharing his adventures with peers—particularly ways to modernize application architectures while adhering to the fundamentals of high modularity and low coupling.


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


Introduction and orientation (15 minutes)

Why go distributed? (15 minutes)

  • Presentation: The rise of machines and big data; Why is distributed computing so hard?; the fallacies of distributed computing; Do you need Kubernetes?

Rise from the community (15 minutes)

  • Presentation: What is Kubernetes?; expected progression from the rise of containers; What is cloud native?; the CNCF; key contributors and governance; agnostic Kubernetes targets; KaaS; the significance of DevOps; why Kubernetes has de facto killed other orchestration tools

Key features (10 minutes)

  • Presentation: A distributed operating system; 15 hard things you don’t have to code
  • Break (5 minutes)

Architecture (20 minutes)

  • Presentation: Terminology; diagram of components; the state machine and its reconciliation loops; scheduler, controller, etcd; kubelets and container runtimes

Kubernetes manifests (10 minutes)

  • Presentation: Declarative manifest schema; Pods, services, and labels; why it's not always easy

First app (10 minutes)

  • Katacoda interactive exercise: Deploy an application on Kubernetes—Hello, World, deployment, Pod, service, kubectl, and rollout

RabbitMQ (15 minutes)

  • Katacoda interactive exercise: Run a basic configuration of RabbitMQ on Kubernetes—Helm charts, dashboard, resilience, and StatefulSet
  • Break (5 minutes)

Pods to services communication (10 minutes)

  • Katacoda interactive exercise: Find and call other services—DNS, services, service discovery, and kubectl review

Observability basics (15 minutes)

  • Katacoda interactive exercise: Learn basic techniques for observing the state of Kubernetes using metrics—admin REST API, logs, events, resources, and health

Kubernetes API scenario (15 minutes)

  • Katacoda interactive exercise: Use the Kubernetes API

ConfigMaps and Secrets scenario (15 minutes)

  • Katacoda interactive exercise: Bind contexts to container

Volumes (15 minutes)

  • Katacoda interactive exercise: Mount volumes; work with ephemeral and persistent data

Services and Ingress (20 minutes)

  • Katacoda interactive exercise: Use types, access, and proxies

Minikube orientation (10 minutes)

  • Katacoda interactive exercise: Install, configure, and use Minikube

Wrap-up and Q&A (15 minutes)


Introduction, orientation, and recap (10 minutes)

Containers (20 minutes)

  • Presentation: The rise of containers; architecture and terminology; base containers; container registries; Dockerfile; standards—OCI, CRI, and image formats; container runtime engines—Docker, CRI-O, etc.

Deploying your first Docker container (10 minutes)

  • Katacoda interactive exercise: Run your first existing container, use Redis, and connect to a volume

Building container images (15 minutes)

  • Katacoda interactive exercise: Build an image based on your requirements—Dockerfile, 17 commands, and build, tag, push, and pull containers

Multistage Dockerfile scenario (10 minutes)

  • Presentation: A Rust application compiled to binary in a container Break (5 minutes)

Decomposing an image binary scenario (5 minutes)

  • Presentation: Tar of tars with a manifest, OCI specification

Docker with Spring Boot (15 minutes)

  • Katacoda interactive exercise: Build and run a Java application from scratch, using modern Java, jlink, and GraalVM

Buildah/Podman with Kotlin (10 minutes)

  • Katacoda interactive exercise: Build and run a Kotlin application from scratch

Img with Node.js (10 minutes)

  • Katacoda interactive exercise: Build and run a Node.js application from scratch

kaniko with Python (10 minutes)

  • Presentation: Build and run a Python application from scratch
  • Break (5 minutes)

Building microservices (20 minutes)

  • Presentation: Architecture; high cohesion and low coupling; language frameworks; datastores; APIs with Rest, gRPC, and GraphQL; header meta information and correlation IDs; OpenAPI (Swagger) and Hydra; the distillation pattern; observability; semantic versioning; 12-factor apps; best practices for containers and microservices

Probes (15 minutes)

  • Presentation: Liveness; readiness; startup

Resource quotas (CPU, memory) (10 minutes)

  • Presentation: CPU; memory; Pods and namespaces

Wrap-up and Q&A (10 minutes)


Introduction, orientation, and recap (10 minutes)

Kubernetes patterns (30 minutes)

  • Presentation: Architecture styles; microservices

Thinking like an architect (15 minutes)

  • Presentation: Ambassador; adapter; aggregator; scatter/gather
  • Break (5 minutes)

Pod patterns (15 minutes)

  • Presentation: Pod formulations—deployments, ReplicaSets, DaemonSets, StatefulSets, jobs, multiple Pods per container

Sidecars (10 minutes)

  • Katacoda interactive exercise: Put two containers in a Pod to achieve the sidecar pattern

Horizontal Pod Autoscalar (15 minutes)

  • Katacoda interactive exercise: Learn how to achieve horizontal Pod scaling automatically—metrics server, quotas

Jobs (15 minutes)

  • Katacoda interactive exercise: Explore Job resources on Kubernetes
  • Break (5 minutes)

More container patterns (15 minutes)

  • Presentation: Data stores; init containers; ephemeral containers; PodPresets; micro-frontends

Helm usage and authoring (15 minutes)

  • Katacoda interactive exercise: Learn how to use most of the features in Helm—architecture, version 3, the CLI tool, public charts, chart registries, creating charts, dependencies, testing, and dry run

Explore multi-Pod application (15 minutes)

  • Katacoda interactive exercise: Deploy, run, and inspect a multi-Pod instance

Wrap-up and Q&A (15 minutes)