Skip to content
  • Sign In
  • Try Now
View all events
Kubernetes

Kubernetes Intermediate in 3 Weeks—with Interactivity

Published by O'Reilly Media, Inc.

Intermediate content levelIntermediate

Designing with Operators, networking, meshes, security, observability, and CI/CD GitOps pipelines

This live event utilizes interactive environmentsThis live event utilizes interactive challenges

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

Recommended follow-up

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.

    linkedinXsearch