Kubernetes Fundamentals in 2 Weeks—with Interactivity
Published by O'Reilly Media, Inc.
Get started with terms, architecture, containers, microservices, pods, and common resources
Distributed application architectures are hard. The complexity of building containers and designing microservices to work together across a network can be overwhelming. Given evolving software, limitations on resources, and networking fallacies, you need an orchestrator to manage these variants. Kubernetes is designed to deal with these complexities so you don’t have to. Essentially a distributed operating system where you provide Kubernetes containers, and it ensures that they remain available and responsive. As a result, Kubernetes has become the preferred way to deploy and serve distributed, scalable, and resilient cloud native applications. In this two-part series, expert Jonathan Johnson walks you through Kubernetes building blocks to demonstrate how the tool actually works. In the sessions, you’ll explore the basics of Kubernetes and how to deploy and connect your applications across a distributed application plane. You may already understand containers—the tricky part is getting a whole set of containers and services to run reliably and consistently together. Join in to learn how.
Session 1: Getting Started with Kubernetes
In this first session, 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 used to assemble applications on Kubernetes. You’ll leave with a thorough understanding of Kubernetes and a solid foundation for the more advanced topics ahead.
Session 2: Building Cloud Native Applications
Given 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 using different 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. There are over 50 built-in resource types in Kubernetes, and the most common are Pods. Pods are rich in features and are surrounded by many other supporting resources. In this session, you’ll look at the variety of Pod objects, discover how to declare them with the numerous configurations and learn how to start assembling your applications on Kubernetes as a distributed cluster of services.
Hands-on learning
Note: With today’s registration, you’ll be signed up for two sessions. We recommend participating in both sessions and pursuing the interactive labs and challenges in the days between and after the sessions.
Interactive labs
Hands-on labs are integrated throughout the course to provide practical experience. 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.
Interactive challenges
At the end of the first session, Jonathan Johnson will offer you a few skills challenges—an interactive scenario-based evaluation to help you determine whether you’ve acquired 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 the provided interactive labs. If you’re unable to complete the challenges, 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:
Session 1: Getting Started with Kubernetes
- Why Kubernetes has become so important
- 16 key features Kubernetes provides for developers
- The responsibilities of the core 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 declarative manifests that define your application
- How to run, scale, observe, and update applications on Kubernetes
- The relationship between container runtime engines and Kubernetes
- Channels for learning more from the Kubernetes community
Session 2: Building Cloud Native Applications
- How to build containers that follow best practices for Kubernetes
- How to use tools to write, build, publish, and run containers
- 12-factor applications
- Discover common Pod and container debug techniques
- Microservice frameworks and communication protocols
- Five workloads for Pods: Deployments, ReplicaSets, Jobs, CronJobs, and DaemonSets
- Understand the connections of a Service to a scaled group of Pods
- Composite patterns for multiple containers per Pod
- Considerations when using Pods as distributed applications
- How other resources help Pods during their lifecycles
- How to declare resource usage and monitoring probes
And you’ll be able to:
Session 1: Getting Started with Kubernetes
- Deploy, run, observe, scale, and update your first applications
- Use 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
- Connect a Service to a Deployment of replicated Pods
- Find and run O’Reilly interactive scenarios
Session 2: Building Cloud Native Applications
- Bundle applications written in various languages into containers
- Write an efficient and secure Dockerfile
- Write a microservice and scale it on Kubernetes
- Explore container best practices and wrap them into Pods
- Connecting Restful and gRPC-based microservices
- Compose YAML manifests for the five Pod workloads
- Map configurations and secrets to your applications
- Managing data persistence to databases and volumes
- Run Jobs in serial and parallel
- Design initialization and sidecar containers
- Implement massive scaling based on activity demands
- Troubleshoot common runtime issues
This live event is for you because...
- You are responsible for delivering cloud native applications.
- You’re a software engineer who wants to understand what it takes to move your applications to a cloud native, 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 the 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
- Practice the concepts between sessions using challenges and provided interactive scenarios
Recommended follow-up:
- Retry any interactive scenarios that were covered during the course
- Take Kubernetes Intermediate—Two Sessions with Interactivity (live online training course with Jonathan Johnson)
- Take [Kubernetes Microservices Testing Techniques](https://learning.oreilly.com/search/?query= Kubernetes%20Microservices%20Testing%20Techniques&formats=live%20online%20training&publishers=O%27Reilly%20Media%2C%20Inc.&sort=relevance) (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)
- 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.
Session 1: Getting Started with Kubernetes
Session overview (10 minutes)
- Presentation: Introduction, orientation, and goals for the two sessions.
Kubernetes architecture and community (45 minutes)
- Presentation: The cloud native community and spectrum of deployment targets; 16 distributed operating system features you should never code; control plane architecture breakdown; state reconciliation loops
Running first applications on a distributed cluster (50 minutes)
- Presentation: Declarative manifests schema; Pods, Services, Namespaces, and Labels
- Interactive scenarios: First Kubernetes applications
- Interactive scenarios: Tools and techniques to run an application; deploy, scale, and update an application; resilience using RabbitMQ—Helm and chaos
- Break and Q&A (15 minutes)
From source to containers to Kubernetes (50 minutes)
- Presentation: Rise of containers; the Dockerfile DSL, with 17 instructions; connecting container runtime engines to Kubernetes; tools for building containers
- Presentation: Multistage containers; the distillation pattern
- Interactive scenarios: Build, package, and run a Go application on Kubernetes
- Interactive scenarios: Connect two Node.js services with gRPC
- Interactive scenarios: Spring Boot to Kubernetes
- Interactive scenarios: Pods to other Services
Five workload types with Pods (50 minutes)
- Presentation: Deployment, ReplicaSet, DaemonSet, StatefulSet, Job, and CronJob
- Interactive scenarios: Achieve horizontal Pod scaling automatically; use Job resources on Kubernetes
- Presentation: Team organization; space-based architectures; polyglot containers and microframeworks; service communication polyglot protocols
- Reflection and Q&A (remaining time)
- Labs and challenges for supplemental self-study
Session 2: Building Cloud Native Applications
Session overview (10 minutes)
- Presentation: Recap of session 1. session 2 agenda, review of labs and challenges
Designing with Pods (50 minutes)
- Presentation: Patterns—init, sidecar; ambassador; adapter; aggregator; scatter/gather
- Interactive scenario: Explore sidecar containers
Services connected to replicas (45 minutes)
- Presentation: Service discovery, load balancing, IPs, ports, and the five service types
- Interactive scenario: Service Types
- Break and Q&A (15 minutes)
Context and state (40 minutes)
- Presentation: Contexts and Volumes
- Interactive scenarios: ConfigMaps and Secrets
- Interactive scenarios: Volumes
Pod detailing (40 minutes)
- Presentation: Explore the Pod specifications;
- Twelve-factor apps, images, context, probes, volumes, quotas, security, affinity
- Interactive scenarios: Probes and volumes
Pod troubleshooting (30 minutes)
- Presentation: What can go wrong?
- Interactive scenarios: Common troubleshooting and debugging techniques
- Reflection and Q&A (time remaining)
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.