Skip to content
O'Reilly home

Kubernetes in 3 Weeks: Part 1—Containers, Microservices, Pods, and Common Objects

enter image description here enter image description here

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

This event has ended.

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 and a distributed operating system
  • How to write a declarative manifest that makes up your application
  • How to run, scale, observe, and update applications on Kubernetes
  • 16 key features Kubernetes provides for developers
  • The responsibilities of the major Kubernetes control plane components
  • Why Kubernetes has become so important
  • How Kubernetes addresses the fallacies of distributed computing
  • How Kubernetes targets many types of cluster configurations
  • Channels for learning more from the community

Week 2: Containers and Microservices

  • The relationship between container runtime engines and Kubernetes
  • 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
  • Microservice frameworks and communication protocols

Week 3: Pods and Common Objects

  • Five Pod constructs: Deployments, ReplicaSets, DaemonSets, Jobs, and CronJobs
  • Patterns for multiple containers per Pod
  • How to think like an architect when designing Pods
  • How other resources help Pods during their lifecycles
  • How to declare resource usage and monitoring probes

And you’ll be able to:

Week 1: Getting Started with Kubernetes

  • Deploy, run, observe, scale, and update your first applications
  • Use the important tools like kubectl, Helm, and the dashboard
  • Perform create, read, update, and delete operations to control resources
  • Navigate the various resources that make up Kubernetes
  • Write and deploy declarative manifest YAMLs to declare an application
  • Find and run O’Reilly interactive scenarios

Week 2: Containers and Microservices

  • Bundle applications written in various languages into containers
  • Write an efficient, secure Dockerfile
  • Write a microservice leveraging the scaling of Kuberentes
  • Explore container best practices and wrap them into Pods
  • Build and run REST- and gRPC-based microservices to Kubernetes

Week 3: Pods and Common Objects

  • Write YAMLs for five Pod constructs
  • Map configurations and secrets to your applications
  • Connect volumes to stateful applications
  • Run Jobs in serial and parallel
  • Run a sidecar container
  • Design initialization containers
  • Implement massive scaling based on activity demands

This 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:


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

Week 1: Getting Started with Kubernetes (4 hours—extended)

  • Session overview (15 minutes)
  • Presentation: Introduction, orientation, and goals

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 (15 minutes)

  • Presentation: 16 key features you should never 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 (15 minutes)

  • Presentation: Declarative manifest schema; Pods, services, and labels

Kubernetes demonstration (20 minutes)

  • Presentation: Introduction to interactive scenarios; using Kubernetes
  • Interactive scenario: Deploy an application on Kubernetes—Hello, World!, deployment, Pod, service, kubectl, and dashboard

Kubernetes first apps (20 minutes)

  • Interactive scenario: Deploy an application on Kubernetes—deployments, Pods, services, YAMLs, scaling application, update rollout and rollbacks

Break (5 minutes)

RabbitMQ (15 minutes)

  • Interactive scenario: Run a basic configuration of RabbitMQ on Kubernetes—Helm introduction, resilience, and StatefulSet; chaos experiment

ConfigMaps and secrets scenario (15 minutes)

  • Interactive scenario: Bind contexts to containers

Volumes (15 minutes)

  • Interactive scenario: Mount volumes; work with ephemeral and persistent data

Pods-to-services communication (10 minutes)

  • Interactive scenario: Find and call other services—DNS, services, service discovery, and kubectl review

Services and ingress (15 minutes)

  • Interactive scenario: Use types, access, and proxies

Kubernetes API scenario (15 minutes)

  • Interactive scenario: Use the Kubernetes API

Wrap-up and Q&A (10 minutes)

Week 2: Containers and Microservices

Session overview (10 minutes)

  • Presentation: Introduction, recap, and goals

Containers (20 minutes)

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

Building container images (15 minutes)

  • Interactive scenario: Build an image based on your requirements—Dockerfile, 17 commands, and build, tag, push, pull, and run containers

Spring Boot to Kubernetes (15 minutes)

  • Interactive scenario: Build, package, and run a Java application on Kubernetes

Decomposing an image binary scenario (10 minutes)

  • Interactive scenario: Tar of tars with a manifest, OCI specification

Break (5 minutes)

Container image build tools (20 minutes)

  • Presentation: Choices of tools that build container images

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

Multistage Dockerfiles (5 minutes)

  • Presentation: Recommended multistage for distillation

Break (5 minutes)

Go apps to Kubernetes (15 minutes)

  • Interactive scenario: Build, package, and run a Go application on Kubernetes

Node.js to Kubernetes (15 minutes)

  • Interactive scenario: Two Node.js apps communicate with gRPC on Kubernetes

Java app distilled to Kubernetes (15 minutes)

  • Interactive scenario: Distilled JRE app in container with GraalVM on Kubernetes

Wrap-up and Q&A (10 minutes)

Week 3: Pods and Common Objects

Session overview (10 minutes)

  • Presentation: Introduction, recap, and goals

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 (15 minutes)

  • Interactive scenario: Put two containers in a Pod to achieve the sidecar pattern; deploy, run, and inspect a multi-Pod instance

Horizontal Pod Autoscalar (15 minutes)

  • Interactive scenario: Learn how to achieve horizontal Pod scaling automatically—metrics server, quotas

Jobs (15 minutes)

  • Interactive scenario: Explore Job resources on Kubernetes

Break (5 minutes)

More container patterns (15 minutes)

  • Presentation: Datastores; init containers; ephemeral containers; PodPresets; micro-frontends

Volumes (15 minutes)

  • Presentation: Ephemeral mounts; persistent volumes; CSI storage options
  • Interactive scenario: Microservices with persistent storage

Probes (10 minutes)

  • Presentation: Liveness; readiness; startup

Resource quotas (10 minutes)

  • Presentation: CPU; memory; Pods and namespaces

Wrap-up and Q&A (5 minutes)

Your Instructor

  • Jonathan Johnson

    Jonathan Johnson is an independent software architect with a concentration 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 has 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 their 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.

Start your free 10-day trial

Get started

Want to learn more at events like these?

Get full access to O'Reilly online learning for 10 days—free.

  • checkmark50k+ videos, live online training, learning paths, books, and more.
  • checkmarkBuild playlists of content to share with friends and colleagues.
  • checkmarkLearn anywhere with our iOS and Android apps.
Start Free TrialNo credit card required.