Delve into Kubernetes Chaos Engineering to discover system limits, simulate adverse effects, and improve resiliency. Learn about fault tolerance, high availability, and running experiments in a Kubernetes cluster.

Let’s face it, bad things happen in software engineering, often when you least expect it. Servers go down, there are spikes in traffic, you receive networking errors. Luckily, you can avoid these problems. Enter chaos engineering.
Chaos engineering is where you try to find the limits of a system and simulate adverse effects that might happen. These simulations then help you to determine the best way to improve your system and build up its resiliency.
This course is divided into various sections to get you used to the different types of experiments you can run in chaos engineering. You will start by learning how to destroy application instances in order to show you the importance of scaling, fault tolerance, and high availability.
You will then dive deep into other types of experiments such as destroying a network, draining and deleting nodes, and testing availability. Towards the end of the course, you will learn how to run experiments in a Kubernetes cluster.

The DevOps Toolkit: Kubernetes Chaos Engineering

# Inspecting the definition of `terminate-pod.yaml`

We're finally there. We can finally create some chaos. We are about to destroy stuff.

Let's take a look at the first definition that we are going to use. It is located in the `chaos` directory, in the file `terminate-pod.yaml`.


The output is as follows.

```yaml
version: 1.0.0
title: What happens if we terminate a Pod?
description: If a Pod is terminated, a new one should be created in its places.
tags:
- k8s
- pod
method:
- type: action
  name: terminate-pod
  provider:
    type: python
    module: chaosk8s.pod.actions
    func: terminate_pods
    arguments:
      label_selector: app=go-demo-8
      rand: true
      ns: go-demo-8
```

What do we have there? We have `version`, `title`, `description`, and `tags`. They're all informative. They do not influence how an experiment is executed. They just provide additional information to whoever would like to know what that experiment is about. 

## `title`

The `title`, for example, says `what happens if we terminate a Pod?`. That's a valid question. 

## `description`

The `description` is a statement that `if a pod is terminated, a new one should be created in its place`. 

## `tags`

We also have tags that are, again, optional. They're letting us know that the experiment is about `k8s` (Kubernetes), and it is about a `pod`.

## `method`

The real action is happening in the `method`. That section specifies the activities that we want to perform. They can be actions or probes. For now, we're going to focus only on actions.

We have only one `action` that we're going to perform. We're calling it `terminate-pod`. Within that `action`, there is a `provider` that is of type `python`. There could be theoretically other types, but since Chaos Toolkit uses Python, in most cases, the `type` will be `python`.

The `module` matches the plugin that we installed before (`chaosk8s`). We're also specifying that we want to do something with a `pod` and that something is `actions`. Hence, the full name of the module is `chaosk8s.pod.actions`.

The main thing is the function (`func`). Whenever you're in doubt, consult the output of the `discover` command, and you'll see types of functions you can use within that module. In our case, we're going to use the function called `terminate_pods`.

In this, and in most other cases, functions require some arguments. We're using `label_selector` which specifies that we’re going to terminate a Pod that matches the `app=go-demo-8` label. It could be any other label as long as there is at least one pod that matches it.

We also have the argument `rand`, short for random, set to `true`. If more Pods match that `label_selector`, a random one will be terminated.

Finally, there is the `ns` argument, which specifies the Namespace.

All in all, we want to terminate a Pod in the `go-demo-8` Namespace that has the matching label `app=go-demo-8`. If there is more than one Pod with these criteria, it should select a random one to destroy.

# Running `terminate-pod.yaml`

Now that we have seen the definition, we can run it and see what we’ll get.


In this lesson, we will define terminate-pod.yaml and run it to destroy instances. We will also inspect the outcome.

Introduction To Kubernetes Chaos Engineering

Defining Requirements

Destroying Application Instances

Experimenting with Application Availability

Obstructing and Destroying Network

Draining and Deleting Nodes

Creating Chaos Experiment Reports

Running Chaos Experiments Inside a Kubernetes Cluster

Executing Random Chaos

What’s Next?

Terminating Application Instances

Inspecting the definition of `terminate-pod.yaml`