Kubernetes in 3 Weeks: Part 1—Containers, Microservices, Pods, and Common Objects
Published by O'Reilly Media, Inc.
Get started with terms, architecture, containers, microservices, applications, and patterns
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.
In the first of this three-part series, Jonathan Johnson walks you through Kubernetes building blocks to demonstrate how the tool actually works. Over three sessions, you’ll explore the basics of Kubernetes, learn how to construct containers, discover how to add them to Pods, and more.
You may already understand containers—the tricky part is getting a whole set of containers and services to consistently work together and run reliably. Join in to learn how.
With today’s registration, you’ll be signed up for all three sessions in Part I.
Series overview: These sessions are part of nine weeks of Kubernetes training, grouped into three parts. You can register for each part individually, but we recommend pursuing the whole series in this order:
Part I: Containers, Microservices, Pods, and Common Objects
Part II: Application Patterns, Observability, Extensibility, and Operators
Part III: Service Meshing, Serverless, and CI/CD Pipelines
By the end of Part III, you’ll be comfortable designing, deploying, managing, monitoring, and updating a coordinated set of applications running on 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 run them efficiently.
Week 3: Pods and Common Objects
There are just over 50 standard resource kinds in Kubernetes. The most common resources are Pods. Pods are rich in features and are surrounded with many other supporting resources. In Week 3, you’ll look at the variety of Pod objects and how to declare them with the numerous declaration choices. With this knowledge you’ll start to understand how you can start assembling your applications on Kubernetes as a distributed cluster of services.
Hands-on learning with interactive scenarios
Every session of this course uses O'Reilly interactive scenarios—complete development environments that are preconfigured with everything you need. No need to install or configure anything; just click a link. And interactive scenarios are sandboxed, so you can tinker and explore without fear of breaking anything.
All exercises and labs are provided as interactive scenarios, which you can also revisit anytime after class ends to practice and refine your skills.
Skills Challenges
At the end of each week, Jonathan will provide you with a Skills Challenge—an interactive scenario-based evaluation to help you determine:
- Whether you’ve mastered the skills taught in course
- Whether you’re ready to apply these skills in a real-world setting
To reinforce your learning, we strongly recommend pursuing each challenge before the next week of the course. If you’re unable to successfully complete a challenge, review the video recording of the training course (emailed to you 24 hours after each session) and work through the other scenarios used that week.
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 live event 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.
Prerequisites
- 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:
- Retry any scenarios that were covered and discussed during class
- Read The Phoenix Project (book)
- Read Building Microservices (book)
- Read Monolith to Microservices (book)
- Read Kubernetes: Up and Running, second edition (book)
- Read Kubernetes Patterns (book)
- Read Fundamentals of Software Architecture (book)
- Read Kubernetes Best Practices (book)
- Explore interactive scenarios on containers
- Explore interactive scenarios on Kubernetes
Schedule
The time frames 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 who concentrates on helping others unpack the riches in the cloud native and Kubernetes ecosystems. He’s halfway into his second score of engineering commercial software, driven by his desire to design helpful software to move business forward. He began with laboratory instrument software and was enticed by the advent of object-oriented design to develop personal banking software. Java exploded onto the scene, and since then Jonathan 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. As a hands-on architect at Thermo Fisher Scientific, he applied the advantages of microservices, containers, and Kubernetes to its 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.