DEV Community: OUM NIVRATHI KALE

Create Chaos Experiments Using the LitmusChaos Python SDK

OUM NIVRATHI KALE — Wed, 15 Sep 2021 10:52:02 +0000

Hello, now LitmusChaos is supporting the python experiments…

Let’s see how to create chaos using a python SDK without losing time, step by step.

Before we get started big announcement is LitmusChaos 2.0 is out and litmus-python is also a part if it.

I'm focusing on creating chaos, so if you want to know more about Chaos Engineering then please follow LitmusChaos and details regarding Python SDK litmus-python

Setup python environment (optinal):

python3 -m virtualenv chaos
source chaos/bin/activate
python3 -m pip install -r requirements.txt You may face some errors, if python version is different. Please manually fix it.

Steps to create Chaos:

git clone https://github.com/litmuschaos/litmus-python.git
cd contribute/developer-guide
Now update your attributes.yaml manifest. Like the name, category, etc. but follow: Use _ in names eg: sample_category
Now run: python3 generate_experiment.py -f=attributes.yaml -g="generate-type" -t="type"
- Run both commands
- For Experiment: python3 generate_experiment.py -f=attributes.yaml -g=experiment
- For Charts : python3 generate_experiment.py -f=attributes.yaml -g=chart -t="all"


Note: Replace the -g=<generate-type> placeholder with the appropriate value based on the usecase:

 - experiment: Chaos experiment artifacts belonging to an existing OR new experiment.
 - chart: Just the chaos-chart metadata, i.e., chartserviceversion.yaml

Provide the type of chart in the `-t=<type>` flag. It supports the following values:
 - category: It creates the chart metadata for the category i.e chartserviceversion, package manifests
 - experiment: It creates the chart for the experiment i.e chartserviceversion, engine, rbac, experiment manifests
 - all: it creates both category and experiment charts (default type)
Provide the path of the attribute.yaml manifest in the -f flag.

Check: chaosLib/litmus/, experiments/ and pkg/ directories. Sample chaos has been generated.
Open bin/experiment/experiment.py and

import experiments.sample_category.sample_exec_chaos.experiment.sample_exec_chaos as experiment

(sample_exec_experimet and sample_exec_chaos will be your provided names in attribute.yaml manifest, Default one mentioned everywhere) and add one more elif condition

elif args.name == "chaos":
    experiment.Experiment(clients)

Add directories in setup.py

'chaosLib/litmus/sample_exec_chaos',
'chaosLib/litmus/sample_exec_chaos/lib',
'pkg/sample_category',
'pkg/sample_category/environment',
'pkg/sample_category/types',
'experiments/sample_category',
'experiments/sample_category/sample_exec_chaos',
'experiments/sample_category/sample_exec_chaos/experiment',

I've updated default names.

Let’s come back to root directory litmuschaos/litmus-python to setup environment.
python3 setup.py install (You need to run this every time before running python3 experiment.py -name chaos, Installing all required
prerequisites and setting up directory structure)
Now ready to code, Just open chaosLib/litmus/sample_exec_chaos/lib/ sample_exec_chaos.py and experiments/sample_category/sample_exec_chaos/experiment/sample_exec_chaos.py files and start writing chaos…
Create a sample Nginx deployment that can be used as the application under test (AUT).

kubectl create deployment nginx --image=nginx

Go to pkg/sample_category and open the environment.py or types.py and add/delete/update the required env.

Note:
Add & operator at the end of chaos commands CHAOS_INJECT_COMMAND
example: md5sum /dev/zero &. As we are running chaos commands as a background process in a separate thread.

Go to bin/experiment and run: python3 experiment.py -name chaos. Before this command always run python3 setup.py install in the root directory. Example chaos logs:

time=2021-08-13 11:43:12,392 level=INFO  msg=Experiment Name: chaos
time=2021-08-13 11:43:12,392 level=INFO  msg=[PreReq]: Initialise Chaos Variables for the sample-chaos experiment
time=2021-08-13 11:43:12,393 level=INFO  msg=[PreReq]: Updating the chaos result of sample-chaos experiment (SOT)
time=2021-08-13 11:43:12,867 level=INFO  msg=[Info]: The application information is as follows Namespace=litmus, Label=app=nginx, Ramp Time=0
time=2021-08-13 11:43:12,867 level=INFO  msg=[Status]: Verify that the AUT (Application Under Test) is running (pre-chaos)
time=2021-08-13 11:43:12,867 level=INFO  msg=[status]: Checking whether application containers are in ready state
time=2021-08-13 11:43:12,887 level=INFO  msg=[status]: The Container status are as follows Container : nginx, Pod : nginx-66b6c48dd5-c65kl, Readiness : True
time=2021-08-13 11:43:12,887 level=INFO  msg=[status]: The Container status are as follows Container : nginx, Pod : nginx-66b6c48dd5-p87pc, Readiness : True
time=2021-08-13 11:43:12,887 level=INFO  msg=[status]: The Container status are as follows Container : nginx, Pod : nginx-66b6c48dd5-s5hjs, Readiness : True
time=2021-08-13 11:43:12,887 level=INFO  msg=[status]: Checking whether application pods are in running state
time=2021-08-13 11:43:12,908 level=INFO  msg=[status]: The status of Pods are as follows Pod : nginx-66b6c48dd5-c65kl status : Running
time=2021-08-13 11:43:12,908 level=INFO  msg=[status]: The status of Pods are as follows Pod : nginx-66b6c48dd5-p87pc status : Running
time=2021-08-13 11:43:12,908 level=INFO  msg=[status]: The status of Pods are as follows Pod : nginx-66b6c48dd5-s5hjs status : Running
time=2021-08-13 11:43:12,938 level=INFO  msg=[Info]: chaos candidate of kind: deployment, name: nginx, namespace: litmus
time=2021-08-13 11:43:12,943 level=INFO  msg=[Info]: chaos candidate of kind: deployment, name: nginx, namespace: litmus
time=2021-08-13 11:43:12,947 level=INFO  msg=[Info]: chaos candidate of kind: deployment, name: nginx, namespace: litmus
time=2021-08-13 11:43:12,947 level=INFO  msg=[Chaos]:Number of pods targeted: 3
time=2021-08-13 11:43:12,947 level=INFO  msg=[Info]: Target pods list, ['nginx-66b6c48dd5-c65kl', 'nginx-66b6c48dd5-p87pc', 'nginx-66b6c48dd5-s5hjs']
time=2021-08-13 11:43:12,955 level=INFO  msg=[Chaos]: The Target application details container : nginx, Pod : nginx-66b6c48dd5-c65kl
time=2021-08-13 11:43:12,956 level=INFO  msg=[Chaos]: Waiting for: 10
time=2021-08-13 11:43:22,955 level=INFO  msg=[Chaos]: Time is up for experiment: sample-chaos
time=2021-08-13 11:43:23,155 level=INFO  msg=[Chaos]: The Target application details container : nginx, Pod : nginx-66b6c48dd5-p87pc
time=2021-08-13 11:43:23,164 level=INFO  msg=[Chaos]: Waiting for: 10
time=2021-08-13 11:43:33,155 level=INFO  msg=[Chaos]: Time is up for experiment: sample-chaos
time=2021-08-13 11:43:33,289 level=INFO  msg=[Chaos]: The Target application details container : nginx, Pod : nginx-66b6c48dd5-s5hjs
time=2021-08-13 11:43:33,289 level=INFO  msg=[Chaos]: Waiting for: 10
time=2021-08-13 11:43:43,289 level=INFO  msg=[Chaos]: Time is up for experiment: sample-chaos
time=2021-08-13 11:43:43,405 level=INFO  msg=[Confirmation]: sample-chaos chaos has been injected successfully
time=2021-08-13 11:43:43,405 level=INFO  msg=[Status]: Verify that the AUT (Application Under Test) is running (post-chaos)
time=2021-08-13 11:43:43,405 level=INFO  msg=[status]: Checking whether application containers are in ready state
time=2021-08-13 11:43:43,416 level=INFO  msg=[status]: The Container status are as follows Container : nginx, Pod : nginx-66b6c48dd5-c65kl, Readiness : True
time=2021-08-13 11:43:43,416 level=INFO  msg=[status]: The Container status are as follows Container : nginx, Pod : nginx-66b6c48dd5-p87pc, Readiness : True
time=2021-08-13 11:43:43,416 level=INFO  msg=[status]: The Container status are as follows Container : nginx, Pod : nginx-66b6c48dd5-s5hjs, Readiness : True
time=2021-08-13 11:43:43,416 level=INFO  msg=[status]: Checking whether application pods are in running state
time=2021-08-13 11:43:43,429 level=INFO  msg=[status]: The status of Pods are as follows Pod : nginx-66b6c48dd5-c65kl status : Running
time=2021-08-13 11:43:43,429 level=INFO  msg=[status]: The status of Pods are as follows Pod : nginx-66b6c48dd5-p87pc status : Running
time=2021-08-13 11:43:43,429 level=INFO  msg=[status]: The status of Pods are as follows Pod : nginx-66b6c48dd5-s5hjs status : Running
time=2021-08-13 11:43:43,429 level=INFO  msg=[The End]: Updating the chaos result of sample-chaos experiment (EOT)

Now make sure that you have created all the required charts. In directory experiments/sample_category/sample_exec_chaos/charts

After testing locally now let’s go into production.

Go to the root directory litmuschaos/litmus-python. Build a docker image: docker build -t your-user-name/py-runner:ci . and push it docker push your-user-name/py-runner:ci

Two ways to test it:

1. Use custom way

Refer docs for more details python-sdk

Run the experiment.yml with the desired values in the ENV and appropriate chaosServiceAccount using a custom dev image instead of litmuschaos/litmus-python (say, oumkale/litmus-python:ci) that packages the business logic.

Create a custom image built with the code validated by the previous steps.
Launch the Chaos-Operator:

kubectl apply -f https://litmuschaos.github.io/litmus/litmus-operator-v1.13.8.yaml

Setup the RBAC necessary for the execution of this experiment by applying the generated rbac.yaml.

kubectl apply -f rbac.yaml

Modify the ChaosExperiment manifest (experiment.yaml) with right defaults (env & other attributes, as applicable) & create this CR on the cluster (pointing the .spec.definition.image to the custom one just built).
Modify the ChaosEngine manifest (engine.yaml) with the right app details, run properties & creating this CR to launch the chaos pods.
Verify the experiment status via ChaosResult.

Refer litmus docs for more details on performing each step in this procedure.

Run all the CRs and operator in the single namespace

Example experiment.yaml: Link
Example engine.yaml: Link

N/b: Also use & operator at last if any chaos command is required as an ENV.

Now list the pods in the namespace
If engine pod is running with runner

nginx-chaos-runner                      1/1     Running   0          35s
pod-cpu-hog-exec-2szc9z-rjjkr           1/1     Running   0          33s

See the logs of the engine pod.

2. Using Litmus Portal

Follow this Link for portal setup details.

Open portal and go to Workflows -> Schedule a workflow
Select your agent.
You may select 2nd one experiment from my hub as well.
Use upload YAML. (For workflow example: Link). n/b: Here need to upload argo workflow.
On selecting next-next you will land on this page where you can edit YAML or you may update using UI only on clicking Name, which will land on the next screen.
- Update engine spec.chaosServiceAccount: litmus-admin
Now tune all the ENV and finish
After scheduling workflow you will land on the workflow dashboard.
Open Workflow to see details.

Here Logs, Chaos Results, and details about the experiment have been proved, Hence you have completed creating Chaos and testing on the application.

Note: You can see details in UI, but another way is to describe the following CRs.

kubectl get chaosresult -n litmus
kubectl get chaosengine -n litmus
kubectl get chaosexperiment -n litmus
kubectl get workflow -n litmus

Congratulation You have been successfully Created and Injected Chaos!

Now it's time to raise PR...!

Steps to Include the Chaos Charts/Experiments into the ChartHub:

Send a PR to the litmus-python repo with the modified experiment files, rbac, test deployment & README.
Send a PR to the chaos-charts repo with the modified experiment CR, experiment chartserviceversion, rbac, (category-level) chaos chart chartserviceversion & package.yaml (if applicable).
Contact us on slack for any queries or doubts.

Are you an SRE or a Kubernetes enthusiast? Does Chaos Engineering excite you?

Join the LitmusChaos Community Slack channel by joining the #litmus channel on the Kubernetes (https://slack.k8s.io/) Slack!

References:

Slack
LitmusChaos Website
Litmus ChaosHub
Github Repo Litmus
litmus-python
Connect with us on Slack
chaos-charts
Litmus Chaos YouTube Channel

Banking Failures And Overcoming using LitmusChaos

OUM NIVRATHI KALE — Fri, 13 Aug 2021 13:44:14 +0000

Hey everyone, in this blog, I am going to talk about banking-related failures and how we can overcome them using LitmusChaos.

Have you ever come across a banking failure?

Today due to mobile banking apps, for instance, allow you to deposit checks from the comfort of anywhere. At the same time, you can check your balance, transfer funds, and set up a notification to alert you if you overdraft your account without a need to visit a branch. It is a real time-saver!
But at the same time, if the bank’s server is down or the connection is slow, you would not be able to access your accounts, and it would be difficult to know if your transaction went through.

We will be going through the following topics one by one:

Bank Of Anthos and its relation with LitmusChaos
Bank-Of-Anthos-Resiliency Workflow
Getting Started with Litmus
Injecting Chaos and observing results.
Conclusion, References, and Links.

About Bank Of Anthos and its relation with LitmusChaos

Bank of Anthos is a sample HTTP-based web app that simulates a bank's payment processing network, allowing users to create artificial bank accounts and complete transactions.
Google uses this application to demonstrate how developers can modernize enterprise applications using GCP products.
The architecture of Bank Of Anthos

In LitmusChaos, we have been working and testing our experiments on Bank Of Anthos applications. Chaos Experiments contain the actual chaos details.
We have two scenarios: weak and resilient. Based on that, we will perform our experiment workloads and try to find an effect on the cause.

This workflow allows the execution of the same chaos experiment against two versions of the bank-of-anthos deployment: the weak ones are expected to fail while the resilient ones succeed, essentially highlighting the need for deployment best-practice.

Getting Started with Litmus

Litmus is an open-source Chaos Engineering platform that enables teams to identify weaknesses & potential outages in infrastructures by inducing chaos tests in a controlled way.

Developers & SREs can execute Chaos Engineering with Litmus as it is easy to use, based on modern chaos engineering practices & community collaboration. Litmus is 100% open source & CNCF-hosted.

Litmus takes a cloud-native approach to create, manage and monitor chaos.
Chaos is orchestrated using the following Kubernetes Custom
Resource Definitions (CRDs):

ChaosEngine: A resource to link a Kubernetes application or Kubernetes node to a ChaosExperiment. ChaosEngine is watched by the Chaos-Operator that invokes Chaos-Experiments.
ChaosExperiment: A resource to group the configuration parameters of a chaos experiment. ChaosExperiment CRs are created by the operator when experiments are invoked by ChaosEngine.
ChaosResult: A resource to hold the results of a chaos experiment. The Chaos-exporter reads the results and exports the metrics into a configured Prometheus server.

Chaos experiments are hosted on hub.litmuschaos.io. It is the central hub, where the application developers, vendors share their chaos experiments so that their users can use them to increase the resilience of the applications in production.

Injecting Chaos and observing results:

Pod-network-loss injects chaos to disrupt network connectivity to balancereader & transactionhistory Kubernetes pods.
The application pod should be healthy once the workflow run is complete. Service requests should be served, despite the chaos. This experiment causes loss of access to application replica by injecting packet loss using litmus.

Network loss is done on a balancereader or transactionhistory pod that reads from ledger DB and runs as a single replica deployment and not as a multi-replica in weak scenarios. Due to loss, balancereader and transactionhistory are inaccessible (or Read-Only), resulting in failed requests.

In a single replica deployment, the user is not able to - see the details, add the details or get information. Whereas in two deployments it is possible to add details. The balancereader or transactionhistory details can be added and retrieved via provided APIs.

Checking using the Probe:

The HTTP probe allows developers to specify a URL that the experiment uses to gauge health/service availability (or other custom conditions) as part of the entry/exit criteria. The received status code is then mapped against an expected status. It can be defined at .spec.experiments[].spec.probe, the path inside ChaosEngine.

We have been using HTTP probe again front end URL http://frontend.bank.svc.cluster.local:80 with the probe poll interval of 1 second.

We have been using HTTP probe again front end URL “http://frontend.bank.svc.cluster.local:80” with probe poll interval 1 sec.

- name: "check-frontend-access-url"
  type: "httpProbe"
  httpProbe/inputs:
    url: "http://frontend.bank.svc.cluster.local:80"
    insecureSkipVerify: false
    method:
      get:
        criteria: "=="
        responseCode: "200"
  mode: "Continuous"
  runProperties:
    probeTimeout: 2
    interval: 1
    retry: 2
    probePollingInterval: 1

In a weak scenario, only one replica of the pod is present. After chaos injection, it will be down, and therefore accessibility will not be there, and eventually, it will fail due to frontend access.
In a resilient scenario, two replicas of pods are present. After chaos injection, one will be down. Therefore, one pod is still up for accessibility and will still be there to pass due to frontend access.

The probe will retry for timeout duration for accessibility change. If the termination time exceeds the timeout without accessibility, it will fail.

Litmus Portal

Litmus-Portal provides console and UI experience for managing, monitoring, and events around chaos workflows. Chaos workflows consist of a sequence of experiments run together to achieve the objective of introducing fault into an application or the Kubernetes platform.

Applying k8s manifest

kubectl apply -f https://raw.githubusercontent.com/litmuschaos/litmus/2.0.0-Beta9/docs/2.0.0-Beta/litmus-2.0.0-Beta.yaml

After installation is complete, you can explore every part of the Chaos control plane and predefined workflows.

You will find a similar screen like this.
Open Bank of Anthos predefined workflow to get the details.
Now to schedule a workflow using a control plane, select the option.
You can edit YAML and see the app deployer:

 - name: install-application
      container:
        image: litmuschaos/litmus-app-deployer:latest
        args:
          - -namespace=bank
          - -typeName=resilient
          - -operation=apply
          - -timeout=400
          - -app=bank-of-anthos
          - -scope=cluster

Here, in the application installation step for weak, you can change -typeName=weak that results in a single replica.

Note: Make sure you have passed the correct docker path in the ChaosEngine.
Default:

name: SOCKET_PATH
value: /var/run/docker.sock
- Now let's continue and schedule a workflow.

After the completion of the workflow run, we can see that there is a failure at network loss, that is probe failure due to weak application.

It can be cross-checked by using the UI. http://<frontend-host>:portNo

We can see this in real-world scenarios also where we are unable to check our balance.

Now, let us schedule the workflow again using `-typeName=resilient`

We can see that the application has passed even after network loss. Due to the high availability of replicas, the probe has passed.

Yes, the balance is there, and you can see the logs and Chaos Results below it.
You can see logs and Chaos Results below it.

Conclusion

We have briefly discussed the Bank Of Anthos resilience predefined workflow where the Bank Of Anthos application resiliency and its relationship with LitmusChaos has shown.

The workflow has been discussed in the Introduction Bank Of Anthos Resiliency Workflow. In LitmusChaos, we are continuously working and testing our experiments applications.
Among the different predefined workflows and kubernetes workflows implemented, our 3rd predefined workflow is Bank Of Anthos-Resiliency-Check, which has been elaborated with scenario effects and its causes.

Thank you for reading it till the end. I hope you had a productive time learning about LitmusChaos. Are you an SRE or a Kubernetes enthusiast? Does Chaos Engineering excite you?

Join the LitmusChaos Community Slack channel by joining the #litmus channel on the Kubernetes (https://slack.k8s.io/) Slack!

References and Links

Slack
LitmusChaos
Litmus ChaosHub
Github Repo Litmus
Connect with us on Slack
chaos-charts
Litmus Chaos YouTube Channel

Submit a pull request if you identify any necessary changes.
Do not forget to share these resources with someone you think might need help to learn/explore more about Chaos Engineering.

Litmus - Soaring Heights

OUM NIVRATHI KALE — Tue, 25 Aug 2020 12:18:43 +0000

About LitmusChaos

LitmusChaos provides a complete set of tools required by Kubernetes developers and SREs to carry out chaos tests easily and in Kubernetes-native way. LitmusChaos is a chaos engineering framework for Kubernetes.
The project has “Declarative Chaos” as the fundamental design goal and keeps the community at the center for growing the chaos experiments.

Litmus broadly contains

1.Chaos Operator
2.Chaos CRDs
3.Chaos experiments or the ChaosHub
4.Chaos Scheduler
5.Chaos metric exporter
6.Chaos events exporter
7.Portal

In this blog, we’ll mainly talk about Litmus analytics.

Now, let's have a broad discussion about Analytics.

1.Analytics of Experiments and our Growth
2.Most popular places where Litmus users are located
3.Structure of maps and their dependencies
4.Loading Data and rending basic maps from libraries in React App
5.References and Links

Analytics about users

We are happy to share that our community has been reaching great heights these days, and we are happy to have achieved this milestone, and we are grateful to our users for supporting us always. Recently we have been getting a great response from the users and have a lot of active users. We are trying to expand our resources and our work worldwide.

Note: The above analytics data was noted on 25th Aug 2020.

In the current situation, we are experiencing Operator installed 14k+, Total Experiment Runs 108k+, Total Experiments 35 and Github star 1k+, and counting.

Litmus Growth

The below graph is showing the growth of our Litmus community based on Operator Experiment analytics.

Experiments

Generic: Pod Delete, Container Kill, Pod Network Latency, Pod Network Loss, Pod Network Corruption, Pod CPU Hog, Pod Memory Hog, Disk Fill, Disk Loss, Node CPU Hog, Node Memory Hog, Node Drain, Kubelet Service Kill, Pod Network Duplication, Node Taint, Docker Service Kill, Pod Autoscaler.

Kubernetes: Kubernetes Application Pod, Kubernetes Application Service, Kubernetes Cluster Level Pod - kiam, EC2 Terminate.

OpenEBS: Target Container Failure, Target Network Latency, Target Network Loss, Target Pod Failure, Pool Pod Failure, Pool Container Failure, Pool Network Latency, Pool Network Loss, Control Plane Chaos, cStor Pool Chaos, Pool Disk Loss, NFS Provisioner Kill.

Kafka: Broker Pod Failure, Broker Disk Failure, CoreDns CoreDNS Pod Delete, Cassandra Cassandra Pod Delete.

Most popular places where Litmus users are located

We have now crossed 170+ Cities and 35+ Countries worldwide where Litmus users are located. Currently, the top 10 countries are India, USA, China, Netherlands, France, Ukraine, Germany, Japan, Ireland, and Taiwan.

City Wise Users

Here the worldwide stats including the users from particular cities in the Map are shown.

Country Wise Users

Here you can see our worldwide stats, including the users from particular countries in the Maps.

Structure of maps and their dependencies

To create a Geo map, one needs to have basic React knowledge. We have used React and TypeScript for development.
For the map, I used react-simple-maps for city-wise plotting and react-google-charts for country wise plotting.

My approach was to plot data on Geo map using city wise, so it is good to show dots on the map to have proper visualization.

Loading Data and rending basic maps from libraries in React App and Code

The code structure is :

┬ Litmus-Portal  
├─┬ backend
| └ frontend
|    ├─┬ src
|      └── components
|        ├─┬ GeoMap
│          ├── CityMap.tsx
|          ├── CountryMao.tsx
|          ├── index.ts 
│          └── geo.json

CityMap

The CityMap component will render a map based on the city-wise count of Chaos Experiments. Since I want to customize the projection for markers, so I take advantage of Marker property.

Start by defining an interface for the name, and coordinates & data will be loaded asynchronously once the component mounts (useEffect()). Also, it will fetch geo.json to map the coordinates.
For the projection marker, I am keeping the same color for all with circle opacity.

Required libraries are given below, and geoURL are coordinates of the World Map for mapping purposes.

import React, { useEffect, useState } from 'react';
import { useSelector } from 'react-redux';
import {
  ComposableMap,
  Geographies,
  Geography,
  Marker,
  ZoomableGroup,
} from 'react-simple-maps';
import { RootState } from '../../redux/reducers';
import datageo from './geo.json';
const geoUrl = datageo;

React components have a built-in state object, which stores the properties that belong to the Map component. When the state object changes, the component re-renders.

const [mapData, setMapData] = useState<CityData[]>([]);

  const geoCity = useSelector(
    (state: RootState) => state.communityData.google.geoCity
  );

  useEffect(() => {
    const cityData: CityData[] = [];
    geoCity.map((e) =>
      cityData.push({
        name: e.name,
        coordinates: [parseFloat(e.longitude), parseFloat(e.latitude)],
      })
    );
    setMapData(cityData);

Adding a Map with marker
To show data on each city map, I have added markers event listeners along with Composable Map and Zoomable Group.

     <ComposableMap style={{width: 640, height: 340,}}>
        <ZoomableGroup zoom={1.3}>
          <Geographies geography={geoUrl}>
            {({ geographies }) =>
              geographies.map((geo) => (
                <Geography
                  key={geo.rsmKey}
                  geography={geo}
                  fill="#CFCFCF"
                  stroke="#CFCFCF"
                />
              ))
            }
          </Geographies>
          {mapData &&
            mapData.map(({ name, coordinates }) => (
              <Marker key={`${name}_${coordinates}`} coordinates={coordinates}>
                <g
                  stroke="#858CDD"
                  strokeWidth="2"
                  strokeLinecap="round"
                  strokeLinejoin="round"
                  transform="translate(-12, -24)"
                >
                  <circle cx="12" cy="10" r="4" />
                </g>
              </Marker>
            ))}
        </ZoomableGroup>
      </ComposableMap>

CountryMap

The CountryMap component will render a map based on the country-wise count of Experiments.
The approach is the same as CityMaps only difference is rendering a data country-wise and added hovering effects.

Originally data is stored in states in 2D Array with Columns Country and Users so I have taken the CountryMap variable, which stores the properties that belong to the Map component. When the state object changes, the component re-renders.

const CountryMap = () => {
  const data: string[][] = useSelector(
    (state: RootState) => state.communityData.google.geoCountry
  );
  const parsedData = data.map((item) => [item[0], parseInt(item[1], 10)]);
  parsedData.unshift(['Country', 'Count'])

Showing Gradient
To give users an idea about the intensity of data, we can show a linear gradient with min = minimum of all values and max = maximum of all values.

To show data on the hover of each country, we can add onMouseEnter and onMouseLeave event listeners, which shows the Country and Users from those countries.

   <Chart
        style={{ margin: 'auto' }}
        width="640px"
        height="340px"
        chartType="GeoChart"
        data={parsedData}
        options={{
          colorAxis: { colors: ['#2CCA8F', 'gray', '#5B44BA'] 
        },
          backgroundColor: '#ffffff',
          datalessRegionColor: '#CFCFCF',
          defaultColor: '#CFCFCF',
        }}
        rootProps={{ 'data-testid': '1' }}
      />

We are looking forward to the users contributing to our Litmus Community.

References and Links

LitmusChaos
Litmus ChaosHub
Github Repo Litmus
Connect with us on Slack
Litmus Chaos YouTube Channel

We are happy that we are contributing to the growth of our users and helping them rise and shine along with us.

DEV Community: OUM NIVRATHI KALE

Create Chaos Experiments Using the LitmusChaos Python SDK

Hello, now LitmusChaos is supporting the python experiments…

Steps to create Chaos:

After testing locally now let’s go into production.

Two ways to test it:

1. Use custom way

2. Using Litmus Portal

Congratulation You have been successfully Created and Injected Chaos!

Now it's time to raise PR...!

Are you an SRE or a Kubernetes enthusiast? Does Chaos Engineering excite you?

References:

Banking Failures And Overcoming using LitmusChaos

Hey everyone, in this blog, I am going to talk about banking-related failures and how we can overcome them using LitmusChaos.

We will be going through the following topics one by one:

About Bank Of Anthos and its relation with LitmusChaos

Getting Started with Litmus

Injecting Chaos and observing results:

Checking using the Probe:

Litmus Portal

Applying k8s manifest

Now, let us schedule the workflow again using -typeName=resilient

Conclusion

References and Links

Litmus - Soaring Heights

About LitmusChaos

Litmus broadly contains

In this blog, we’ll mainly talk about Litmus analytics.

Analytics about users

Litmus Growth

Experiments

Most popular places where Litmus users are located

City Wise Users

Country Wise Users

Structure of maps and their dependencies

CityMap

CountryMap

We are looking forward to the users contributing to our Litmus Community.

References and Links

Now, let us schedule the workflow again using `-typeName=resilient`