Kubernetes Fundamentals in 3 Weeks
Published by O'Reilly Media, Inc.
Get started with terms, architecture, containers, microservices, pods, and common resources
Distributed application architectures are hard. The complexity in building containers and designing microservices to work together across a network can be overwhelming. Given limitations on resources, failing networks, defective software, and fluctuating traffic, you need an orchestrator to handle these variants.
Kubernetes is designed to deal with 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 a result, Kubernetes is quickly becoming the preferred way to deploy and serve distributed, scalable, and resilient applications.
In this three-part series, expert 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.
Week 1: Getting Started with Kubernetes
In Week 1, you’ll explore the most important parts of Kubernetes and learn why it’s become the de facto orchestration platform for distributed computing. You’ll build your Kubernetes vocabulary, discover the benefits the tool offers to developers (no coding required), and break down the architecture toward the aha moment when you understand how the engine works. You’ll get hands-on and learn how to run and distribute applications with this new paradigm and dive into container patterns that developers use to run applications on Kubernetes. You’ll leave with a thorough understanding of Kubernetes and a solid foundation for the more advanced topics ahead.
Week 2: Containers and Microservices
Now that you have an appreciation of the importance of containers as building blocks, you'll explore how to construct containers to behave as first-class objects on Kubernetes. You’ll explore frameworks in various languages to construct microservices-based apps and follow best practices for loading apps with a variety of languages into a container. You’ll navigate the goals of the distillation pattern as you develop your containers and review the techniques and best practices for adding containers to Pods.
Week 3: Pods and Common Resources
There are over 50 standard resource types in Kubernetes, but the most common are Pods. Pods are rich in features and are surrounded with many other supporting resources. This week, you’ll look at the variety of Pod objects, discover how to declare them with the numerous declaration choices, and learn how to start assembling your applications on Kubernetes as a distributed cluster of services.
NOTE: With today’s registration, you’ll be signed up for all three sessions. Although you can attend any of the three sessions individually, we recommend participating in all three weeks and pursuing the skills challenges in between sessions.
Hands-on learning with interactive labs
All exercises are provided as O'Reilly interactive labs—complete development environments that are preconfigured with everything you need. There's nothing to install or configure; just click a link and get started! You can explore, experiment, and tinker without fear of breaking anything. And you can revisit them anytime after class ends to practice and refine your skills.
Skills challenges
At the end of each week, Jonathan Johnson will provide you with a skills challenge—an interactive scenario-based evaluation to help you determine whether you’ve mastered the skills taught in the live training and whether you’re ready to apply these skills in a real-world setting.
To reinforce your learning, we strongly recommend pursuing each skills challenge before the next week of the course. If you’re unable to successfully complete the challenge, try reviewing the video recording of the live training (emailed to you 24 hours after each session) for tips.
What you’ll learn and how you can apply it
By the end of this live, hands-on three-part series, you’ll understand:
Week 1: Getting Started with Kubernetes
- Why Kubernetes has become so important
- 16 key features Kubernetes provides for developers
- The responsibilities of the major Kubernetes control plane components
- How Kubernetes addresses the fallacies of distributed computing
- How Kubernetes targets many types of cluster configurations
- 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
- Channels for learning more from the Kubernetes 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 Resources
- 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 declares 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 and secure Dockerfile
- Write a microservice, leveraging the scaling of Kubernetes
- Explore container best practices and wrap them into Pods
- Build and run REST- and gRPC-based microservices to Kubernetes
Week 3: Pods and Common Resources
- 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 a larger user base and compute needs.
- You’re a team leader who wants to understand the skills and team organization strategies to support delivery of your enterprise applications to a highly available and scaling cloud native target.
- You’re starting to see the importance of being a cloud native engineer and want to know more.
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 preparation:
- No preparation or local installation needed—all exercises will be provided using O’Reilly interactive scenarios. The course exercises can all be found in the Kubernetes Fundamentals in 3 Weeks Scenarios collection.
- Practice the concepts between sessions using the skills challenges and provided interactive scenarios
Recommended follow-up:
- Retry any interactive scenarios that were covered during the course
- Take Kubernetes Intermediate in 3 Weeks (live online training course with Jonathan Johnson)
- Take Kubernetes Microservices Testing Techniques (live online training course with Jonathan Johnson)
- 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)
Schedule
The time frames are only estimates and may vary according to how the class is progressing.
Week 1: Getting Started with Kubernetes
Session overview (15 minutes)
- Presentation: Introduction, orientation, and goals for the week
Kubernetes architecture and community (55 minutes)
- Presentation: The community and spectrum of deployment targets; 16 distributed operating system features you should never code; control plane architecture breakdown; state reconciliation loops
- Q&A
- Break
Running first applications on a distributed cluster (55 minutes)
- Presentation: Declarative manifests schema; Pods, services, and labels; using interactive scenarios
- Interactive scenarios: Tools and techniques to run an application; deploy, scale, and update an application; resilience using RabbitMQ—Helm and chaos
- Q&A
- Break
Putting it into practice (30 minutes)
- Interactive scenarios: Bind configuration contexts and secrets to containers; diagnose events and container logs; access the Kubernetes API
Wrap-up and Q&A (10 minutes)
- Presentation: Week 1 skills challenge
Week 2: Containers and Microservices
Session overview (15 minutes)
- Presentation: Recap of Week 1; discussion on Week 1 skills challenge
Containers (55 minutes)
- Presentation: Rise of containers; the Dockerfile DSL, with 17 instructions; connecting container runtime engines to Kubernetes; tools for building containers
- Interactive scenario: Demystify an OCI container image as just a tarball
- Q&A
- Break
Microservices (55 minutes)
- Presentation: Team organization; space-based architectures; polyglot containers and microframeworks; service communication polyglot protocols
- Interactive scenarios: Take raw Spring Boot to Kubernetes; Spring Boot to Kubernetes
- Q&A
- Break
Distillation pattern and more microservices (40 minutes)
- Presentation: Multistage containers; the distillation pattern
- Interactive scenarios: Build, package, and run a Go application on Kubernetes; connect two Node.js services with gRPC
- Q&A
- Break
Wrap-up and Q&A (10 minutes)
- Presentation: Week 2 skills challenge
Week 3: Pods and Common Resources
Session overview (15 minutes)
- Presentation: Recap of Week 2; discussion on Week 2 skills challenge
Five species of Pods (45 minutes)
- Presentation: Deployment, ReplicaSet, DaemonSet, StatefulSet, Job, and CronJob
- Interactive scenarios: Achieve horizontal Pod scaling automatically; use Job resources on Kubernetes
- Q&A
- Break
Podulation and designs with Pods (55 minutes)
- Presentation: Patterns—sidecar; ambassador; adapter; aggregator; scatter/gather
- Interactive scenario: Explore sidecar containers
- Q&A
- Break
Pod detailing (55 minutes)
- Presentation: Dissect wide spectrum of features for configuring Pods; images, context, probes, volumes, quotas, security, affinity, and init containers
- Interactive scenarios: Experience probes and volumes
Wrap-up and Q&A (15 minutes)
Your Instructor
Jonathan Johnson
Jonathan Johnson is a software architect, presenter, and trainer with four decades of experience in software development and architecture. An independent consultant, he helps organizations adopt and master cloud native technologies, with expertise spanning containers, Java, microservices, Kubernetes, continuous delivery, and distributed computing. Jonathan has developed software across more than 20 product life cycles and a wide range of industries. He’s passionate about helping teams design and build scalable, resilient, and secure systems while sharing his expertise through workshops, presentations, and technical training worldwide.