Skip to Content
View all events

Kubernetes Microservices Testing Techniques

Published by O'Reilly Media, Inc.

Advanced content levelAdvanced

Fundamentals of chaos testing and consumer-driven contracts

This live event utilizes interactive environments

Most developers are aware of unit testing techniques used during the early phases of application development, but testing should happen during all phases of an application lifecycle to better reflect the end user’s experience of a service in distributed cloud clusters, where any number of things can go wrong that weren’t anticipated in preproduction testing.

Join expert Jonathan Johnson to explore two different types of testing that you may want to add to your cloud deployment strategies: consumer-driven contracts (CDC), which focus on the consumer’s perspective rather than the developer’s, and chaos experimentation, which allows for failure testing in a production environment. You’ll use the Pact open source software project’s set of tools to write and run CDC tests on Kubernetes and you’ll get hands-on with a few chaos engines to learn how to design and run experiments on Kubernetes.

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.

What you’ll learn and how you can apply it

By the end of this live online course, you’ll understand:

  • The importance of applying many testing techniques across all phases of an app’s lifecycle
  • How to change your perspective on testing using consumer-driven contract testing
  • How to apply chaos testing experiments as you develop and roll applications into production
  • The array of engine choices for chaos testing on Kubernetes

And you’ll be able to:

  • Understand the fundamentals of CDC testing using Pact
  • Write consumer-driven contracts to strengthen your microservices
  • Create chaos experiments and control the “blast radius”
  • Implement chaos experiments with different open source tools

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 general application development using Java and Linux
  • A basic understanding of packaging applications into containers
  • A basic understanding of running application on Kubernetes

Recommended preparation:

Recommended follow-up:

Schedule

The time frames are only estimates and may vary according to how the class is progressing.

Distributed computing testing (30 minutes)

  • Presentation: Introduction, overview of distributed computing testing (see the spectrum in a graphic by Cindy Sridharan here)

Consumer-driven contracts (90 minutes)

  • Presentation: About consumer-driven contracts and the Pact OSS project
  • Interactive scenario: Consumer-Driven Contracts with Kubernetes
  • Q&A
  • Break

Chaos engineering (90 minutes)

  • Presentation: Chaos engineering through experimentation
  • Interactive scenarios: Pure Chaos, KubeInvaders, Kube Monkey, Chaos Mesh, and Litmus

Wrap-up and Q&A (30 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.

linkedinXsearch

Skill covered

Kubernetes