Kubernetes Intermediate in 3 Weeks—with Interactivity
Published by O'Reilly Media, Inc.
Designing with Operators, networking, meshes, security, observability, and CI/CD GitOps pipelines
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 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 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. 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.
We strongly recommend taking Kubernetes Fundamentals in 3 Weeks before attending this intermediate course.
Week 1: Designing with Operators
Increasingly, solutions on Kubernetes follow the Operator pattern, so every Kubernetes developer must get familiar with it. Many architectures, such as Kubeflow, Istio, progressive delivery, queuing and messaging, and data handling, are installed and maintained with Operators.
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 Week 1, you’ll explore some common open source solutions and a few frameworks commonly used to create operators.
Week 2: Networking and Meshes
Your applications are built, you’ve deployed them, and they appear to be running fine. But as you're rolling out new versions of applications, you realize that your feature switches and delivery models are getting stretched. You’re becoming a victim of your own success, and it may be time to consider adding a service mesh.
This week, 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 look at two service meshes you may want to consider adding to your cluster, and you’ll get hands-on exploring some working examples with Istio.
Week 3: CI/CD GitOps Pipelines
Your DevOps team must ensure that your platform is healthy and its delivery system is as frictionless as possible. Fortunately, your continuous integration and delivery pipeline can all be run on Kubernetes. 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 strong team with a variety of skill sets.
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 challenges in between sessions.
Hands-on learning with interactive scenarios
All exercises and labs are provided as O'Reilly interactive scenarios—complete development environments that are preconfigured with everything you need. There's nothing to install or configure; just click a link and get started!
Interactive scenarios are sandboxed, so 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.
Challenges
At the end of each week, Jonathan will provide you with a 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 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: Designing with Operators
- How to extend and enhance the features of the kubectl tools
- How to extend Kubernetes to deliver managed solutions using the Operator pattern
- How to find and use public operators for common architecture solutions
- How Operators differ from installers
Week 2: Networking and Meshes
- When it's appropriate to add a service mesh
- Options provided by different service mesh providers
- Key features to expect from a service mesh
- What to look out for when adding a mesh to your cluster
Week 3: CI/CD GitOps Pipelines
- Why Kubernetes is an ideal platform to host your CI/CD pipelines and testing
- The significance of 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
And you’ll be able to:
Week 1: Designing with Operators
- Install and use helpful kubectl plug-ins
- Write your own kubectl plug-in
- 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
Week 2: Networking and Meshes
- 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
Week 3: CI/CD GitOps 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’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 the challenges and provided interactive scenarios
- Take Kubernetes Fundamentals in 3 Weeks (live online training course with Jonathan Johnson)
Recommended follow-up
- Retry any interactive scenarios that were covered during the course
- Attend scheduled office hours with Jonathan Johnson (link to come)
- 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: Designing with Operators
Session overview (15 minutes)
- Presentation: Introduction, orientation, and goals for the week
Extension opportunity hotspots (45 minutes)
- Presentation: Extension opportunities in and around Kubernetes control plane components; using and exploring kubectl plug-ins
- Interactive scenarios: Experience some helpful kubectl plug-ins; write your own plug-in; use and create Helm charts; write a Python app to use Kubernetes API to invoke chaos
- Break
Operator pattern (55 minutes)
- Presentation: Decomposing the Operator pattern; explore open source Operators available in public repositories; CRDs, controllers, and RBAC; public charts and repositories and community of support
- Interactive scenarios: Custom resource definitions; add etcd to cluster using public operator on OpenShift
- Break
Writing an Operator (55 minutes)
- Presentation: Uncover SDK frameworks for writing operators; OperatorSDK and Kubebuilder and how they are combining; KUDO and its advantages
- Interactive scenario: Create and start an example Operator
Wrap-up and Q&A (10 minutes)
- Presentation: Week 1 skills challenge
Week 2: Networking and Meshes
Session overview (15 minutes)
- Presentation: Recap of Week 1; discussion of Week 1 skills challenge
Cluster networking (55 minutes)
- Presentation: Service discovery; DNS; external services; namespace network policy; common network interface; service and Pod spread topology; EndpointSlices
- Interactive scenarios: Discover and call other services; explore service types; NodePort; ClusterIP; Ingress rules
- Break
Meshing around (55 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
- Break
Exploring Istio (40 minutes)
- Interactive scenarios: Identify slow services with distributed tracing; handle failures with circuit breakers; simulate failures between microservices; install and demonstrate Linkerd
Wrap-up and Q&A (10 minutes)
- Presentation: Week 2 skills challenge
Week 3: CI/CD GitOps Pipelines
Session overview (15 minutes)
- Presentation: Recap of Week 2; discussion on Week 2 skills challenge
Pipeline vitals (20 minutes)
- Presentation: High maturity model goals; using Kubernetes internally for CI/CD; DevOps and GitOps, the spine for productivity; organizing teams around distributed computing; CNCF and Continuous Delivery Foundation; Rube Goldberg pipelines; common GitOps components across phases
Registries (15 minutes)
- Presentation: Registry types—containers, charts, Operators; security scans; buy or build options
Private registry (10 minutes)
- Interactive scenario: Private registry install and usage
- Break
Developer workflows (19 minutes)
- Presentation: Non-GitOps flows; Telepresence, squash, Draft, KSync
Pipeline construction (15 minutes)
- Presentation: Testing techniques; advanced testing with consumer-driven contracts
Static code analysis (15 minutes)
- Interactive scenario: SonarQube on Kubernetes
Tekton pipelines (15 minutes)
- Presentation: Declarative pipelines; Knative and kaniko; container building; relationship with Jenkins X and others
Python with Tekton and kaniko (25 minutes)
- Presentation: Build and run a Python application from scratch
- Interactive scenario: Kubernetes Python pipeline to Kubernetes with Tekton
- Break
Continuous integrations (30 minutes)
- Presentation: Continuous integration needs; Jenkins X, Argo CD, and Flux CD
Continuous delivery (30 minutes)
- Presentation: Deployment versus delivery; delivery models; progressive delivery and relationship with mesh traffic rules; Spinnaker and Flagger
- Break
Administration APIs and tools (10 minutes)
- Kubernetes cluster installers—Cloud, kubeadm, Terraform, and Ansible; infrastructure languages—Metaparticle, Ballerina, and Pulumi; kubeadm and kops; ChatOps
Wrap-up and Q&A (15 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.