Kubernetes Intermediate—with Interactivity
Published by O'Reilly Media, Inc.
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.
We strongly recommend registering for Kubernetes Fundamentals—Two Sessions with Interactivity before attending this intermediate course.
Session 1: Operators and Service Meshes
Kubernetes is a strong platform for running and coordinating large collections of services, containers, and applications, but even with all of its standard resources, Kubernetes can't do everything. Fortunately, Kubernetes is highly configurable and extensible, and the Operator pattern has emerged from this focus on extensibility. In this first session, you’ll explore how to install and control operators. We’ll also look at a few common frameworks to create your own operators.
Increasingly, solutions on Kubernetes follow the Operator pattern, so every Kubernetes developer must get familiar with it. Many architectures, such as Kafka, Kubeflow, Istio, progressive delivery, queuing and messaging, and data handling, are installed and maintained with Operators. A common operator to add to Kubernetes is a service mesh. As your Kubernetes solutions grow you’ll become a victim of your own success, and it may be time to consider adding a service mesh. In the second part of this session, you’ll learn why architects are adding service meshes to their clusters to help solve the growing complexities of connectivity, security, and observability. You’ll get some hand-on experience with exploring a service mesh that you may want to consider adding to your cluster.
Session 2: Observability and CI/CD Pipelines
The complexity of distributing and orchestrating multiple applications onto clusters necessitates the usage of observability and automated CI/CD pipelines. Your DevOps team must ensure that your platform is healthy and its delivery system is as frictionless as possible. Observability encompasses the insightful metrics, logs and tracing produced when applications run on the cluster. Jonathan will explore common operators and dashboards that can be used to help you ensure your applications are healthy and optimally tuned to the cluster and user experience. In this session, you'll learn why Kubernetes is an excellent platform for hosting your continuous tools, pipeline engines, registries, testing, code analysis, security scans, and delivery workflows. You'll leave understanding the latest tools and techniques for pipelining on Kubernetes. Jonathan will also address the importance of a well–trained team with a variety of skill sets to be successful with hosting applications on Kubernetes.
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: Operators and Service Meshes
- The various extension opportunities that Kubernetes presents
- How to extend and enhance the features of the kubectl tools
- How to extend Kubernetes to deliver managed solutions using the Operator pattern
- How Operators differ from installers
- How to find and use public operators for common architecture solutions
- When it's appropriate to add a service mesh
- Options provided by different service mesh providers
- Key features to expect from a service mesh
- When you should not use an operator or a service mesh
Session 2: Observability and CI/CD Pipelines
- The various techniques used to observe metrics, tracing and logs
- Why Kubernetes is an ideal platform to host your CI/CD pipelines and testing
- Using Tekton and Kaniko
- CI/CD on Kubernetes as a reliable stack for releasing commercial applications
- Tools for implementing various delivery models
- How to navigate the decision dilemma of solutions for Kubernetes hosted pipelines
- How to create a maturity model checklist as a guide to move to distributed computing
- How Ingress has evolved with the Gateway API.
And you’ll be able to:
Session 1: Operators and Service Meshes
- Use helpful kubectl plug-ins, or write your own plug-in
- How to use the Kubernetes API as a library
- Decompose the elements of the Operator pattern
- Leverage public Operators
- Understand the differences among common Operator SDK frameworks
- Write your own Operator, complete with controller and custom resources
- Implement progressive delivery techniques
- Understand how meshing systems make all the difference
- Control and monitor traffic between services
- Control application delivery using declarative controllers
- Add mutual TLS between all or select services
- Understand the choices between Ingress and the Gateway API
Session 2: Observability and CI/CD Pipelines
- Run and use a private container registry with Kubernetes
- Run a Tekton pipeline with a kaniko container build
- Run tests as part of your pipelines
- Run static code analysis tools
- Understand common pipeline components assembled on a Kubernetes cluster
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 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’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 Fundamentals—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: Operators and Service Meshes
Session overview (10 minutes)
- Presentation: Introduction, orientation, and goals for the two sessions.
Extension opportunity hotspots (45 minutes)
- Presentation: Extension opportunities in and around Kubernetes control plane components; CNI, CSI, Admission Control, kubectl plug-ins
- Interactive scenarios: Experience some helpful kubectl plug-ins; write your own plug-in; use and create Helm charts;
- Interactive scenarios: Write a Python app to use Kubernetes API to invoke chaos
Operator pattern (45 minutes)
- Presentation: Decomposing the Operator pattern; CRDs, controllers, and RBAC; ArtifactHub for open-source Helm charts and OLM based operators.
- Interactive scenarios: Custom resource definitions and using an operator.
- Break and Q&A (15 minutes)
Cluster networking (30 minutes)
- Presentation: Service discovery; DNS; external services; namespace network policy; common network interface; Networking topology connecting Services with Replicas
- Interactive scenarios: Discover and call other services; explore service types; NodePort; ClusterIP; Ingress rules
Meshing around (50 minutes)
- Presentation: What a mesh provides and what it costs; meshing providers and features—security, traffic routing, traffic policies, observability; deployment models and canaries; Istio architecture and control plane components
- Interactive scenario: Install Istio and demonstrate with example application
Gateway API (30 minutes)
- Presentation: Evolving from Ingress objects to the Gateway API
- Interactive scenario: Install Istio and demonstrate with example application
- Reflection and Q&A (remaining time)
- Labs and challenges for supplemental self-study
Session 2: Observability and CI/CD Pipelines
Session overview (10 minutes)
- Presentation: Recap of session 1. session 2 agenda, review of labs and challenges
Pipeline vitals (40 minutes)
- Presentation: Observability patterns with metrics, tracing and logs. The Metrics API, Prometheus, OpenTracing, unified logging, and other operators.
- Presentation: Security scanning and vulnerability management.
- Interactive scenario: Exploring choices for observability operators
- Break and Q&A (15 minutes)
Static code analysis (20 minutes)
- Presentation: Using Kubernetes in DevOps
- Interactive scenario: SonarQube on Kubernetes
Pipeline vitals (20 minutes)
- Presentation: Assessing your capability model for automation; DevOps and GitOps, the spine for productivity; Conway’s law with organizing teams around distributed computing; CNCF and Continuous Delivery Foundation; Rube Goldberg pipelines; common GitOps components across phases; testing techniques
- Presentation: Registries for containers, charts, operators; security scans; buy or build
- Interactive scenario: Private registry install and usage
Pipelines and Tekton (30 minutes)
- Presentation: Pipeline engines on Kubernetes; Jenkins X, Argo CD, and other engines.
- Presentation: Declarative pipelines; Tekton and kaniko; relationship with Jenkins X and others. Caching and Docker Build Cloud.
- Interactive scenario: Kubernetes Python pipeline to Kubernetes with Tekton.
Progressive delivery techniques (30 minutes)
- Presentation: Deployment versus delivery; delivery models; progressive delivery models and relationship with service meshes; Spinnaker. Argo CD, and Flagger with Flux
- 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.