Offline Installation

This document describes how to install Chaos Mesh in an offline environment.

Prerequisites

Before deploying Chaos Mesh, make sure the following items have been installed:

  • Kubernetes version >= 1.12
  • RBAC enabled (optional)
  • Docker

Prepare the installation file

To install Chaos Mesh offline, you need to get the installation images via an internet connection. Take the steps below:

  1. Specify the version you want to install:

    1. export CHAOS_MESH_VERSION="v1.1.0"
  1. > **Note:**
  2. > 
  3. > It is recommended that you use a stable release, or you can set the version to `latest` if you want to experience the latest features that are under development.

  1. Archive the docker images of Chaos Mesh:

    1. docker pull pingcap/chaos-mesh:${CHAOS_MESH_VERSION}
    2. docker pull pingcap/chaos-daemon:${CHAOS_MESH_VERSION}
    3. docker pull pingcap/chaos-dashboard:${CHAOS_MESH_VERSION}
    4. docker pull pingcap/coredns:v0.2.0
  1. ```
  2. docker save -o ./image-chaos-mesh pingcap/chaos-mesh:${CHAOS_MESH_VERSION}
  3. docker save -o ./image-chaos-daemon pingcap/chaos-daemon:${CHAOS_MESH_VERSION}
  4. docker save -o ./image-chaos-dashboard pingcap/chaos-dashboard:${CHAOS_MESH_VERSION}
  5. docker save -o ./image-chaos-coredns pingcap/coredns:v0.2.0
  6. ```

  1. Download the Chaos Mesh repository to your local:

    1. wget "https://github.com/chaos-mesh/chaos-mesh/archive/${CHAOS_MESH_VERSION}.zip"
  1. Or you can download the latest unstable version:
  3. ```
  4. wget https://github.com/chaos-mesh/chaos-mesh/archive/master.zip
  5. ```
  1. the ./image-chaos-mesh, ./image-chaos-daemon, ./image-chaos-dashboard, and {CHAOS_MESH_VERSION}.zip into the offline environment.

Install Chaos Mesh offline

Now that you already have the image and repo archive files in the offline environment, start installing Chaos Mesh.

  1. Specify the version you are going to install in the offline environment:

    1. export CHAOS_MESH_VERSION="v1.1.0"

  1. Load the image from the archive files:

    1. docker load -i ./image-chaos-mesh
    2. docker load -i ./image-chaos-daemon
    3. docker load -i ./image-chaos-dashboard
    4. docker load -i ./image-chaos-coredns

  1. Push the Chaos Mesh images. You can choose to push them to Docker Registry or Docker Hub.

    • Push images to Docker Registry

      a. Set the Docker Registry variable, for example:

      1. export DOCKER_REGISTRY=localhost:5000
  1.     b. Tag these images with `$DOCKER_REGISTRY`:
  3.     ```
  4.     export CHAOS_MESH_IMAGE=$DOCKER_REGISTRY/pingcap/chaos-mesh:${CHAOS_MESH_VERSION}
  5.     export CHAOS_DAEMON_IMAGE=$DOCKER_REGISTRY/pingcap/chaos-daemon:${CHAOS_MESH_VERSION}
  6.     export CHAOS_DASHBOARD_IMAGE=$DOCKER_REGISTRY/pingcap/chaos-dashboard:${CHAOS_MESH_VERSION}
  7.     export CHAOS_COREDNS_IMAGE=$DOCKER_REGISTRY/pingcap/coredns:v0.2.0
  8.     docker image tag pingcap/chaos-mesh:${CHAOS_MESH_VERSION} $CHAOS_MESH_IMAGE
  9.     docker image tag pingcap/chaos-daemon:${CHAOS_MESH_VERSION} $CHAOS_DAEMON_IMAGE
  10.     docker image tag pingcap/chaos-dashboard:${CHAOS_MESH_VERSION} $CHAOS_DASHBOARD_IMAGE
  11.     docker image tag pingcap/coredns:v0.2.0 $CHAOS_COREDNS_IMAGE
  12.     ```
  16.     c. Push these images to Docker Registry:
  18.     ```
  19.     docker push $CHAOS_MESH_IMAGE
  20.     docker push $CHAOS_DAEMON_IMAGE
  21.     docker push $CHAOS_DASHBOARD_IMAGE
  22.     docker push $CHAOS_COREDNS_IMAGE
  23.     ```
  27.     > **Note:**
  28.     > 
  29.     > If the Docker Registry can only work locally, you need to load and push these images on each K8s node.
  31. -   Push images to Docker Hub
  33.     a. Set the Docker Hub variable, for example:
  35.     ```
  36.     export DOCKER_HUB=hub
  37.     ```
  41.     b. Tag these images with `$DOCKER_REGISTRY`:
  43.     ```
  44.     export CHAOS_MESH_IMAGE=$DOCKER_HUB/chaos-mesh:${CHAOS_MESH_VERSION}
  45.     export CHAOS_DAEMON_IMAGE=$DOCKER_HUB/chaos-daemon:${CHAOS_MESH_VERSION}
  46.     export CHAOS_DASHBOARD_IMAGE=$DOCKER_HUB/chaos-dashboard:${CHAOS_MESH_VERSION}
  47.     export CHAOS_COREDNS_IMAGE=$DOCKER_HUB/coredns:v0.2.0
  48.     docker image tag pingcap/chaos-mesh:${CHAOS_MESH_VERSION} $CHAOS_MESH_IMAGE
  49.     docker image tag pingcap/chaos-daemon:${CHAOS_MESH_VERSION} $CHAOS_DAEMON_IMAGE
  50.     docker image tag pingcap/chaos-dashboard:${CHAOS_MESH_VERSION} $CHAOS_DASHBOARD_IMAGE
  51.     docker image tag pingcap/coredns:v0.2.0 $CHAOS_COREDNS_IMAGE
  52.     ```
  56.     c. Push these images to Docker Registry:
  58.     ```
  59.     docker push $CHAOS_MESH_IMAGE
  60.     docker push $CHAOS_DAEMON_IMAGE
  61.     docker push $CHAOS_DASHBOARD_IMAGE
  62.     docker push $CHAOS_COREDNS_IMAGE
  63.     ```

  1. Install Chaos Mesh offline with the following steps:

    a. Unzip the repo archive files to a path:

    1. unzip ${CHAOS_MESH_VERSION}.zip -d chaos-mesh && cd chaos-mesh/*/
  1. b. Create a namespace for installing Chaos Mesh:
  3. ```
  4. kubectl create namespace chaos-testing
  5. ```
  9. c. Install Chaos Mesh by helm:
  11. ```
  12. helm install chaos-mesh helm/chaos-mesh  --namespace=chaos-testing \
  13.    --set dashboard.create=true \
  14.    --set dnsServer.create=true \
  15.    --set chaosDaemon.image=$CHAOS_DAEMON_IMAGE \
  16.    --set controllerManager.image=$CHAOS_MESH_IMAGE \
  17.    --set dashboard.image=$CHAOS_DASHBOARD_IMAGE \
  18.    --set dnsServer.image=${CHAOS_COREDNS_IMAGE}
  19. ```
  23. d. Check whether Chaos Mesh pods are installed:
  25. ```
  26. kubectl get pods --namespace chaos-testing -l app.kubernetes.io/instance=chaos-mesh
  27. ```
  31. Expected output:
  33. ```
  34. NAME                                        READY   STATUS    RESTARTS   AGE
  35. chaos-controller-manager-6d6d95cd94-kl8gs   1/1     Running   0          3m40s
  36. chaos-daemon-5shkv                          1/1     Running   0          3m40s
  37. chaos-dashboard-d998856f6-vgrjs             1/1     Running   0          3m40s
  38. ```
  42. After executing the above commands, you should be able to see the output indicating that all Chaos Mesh pods are up and running. Otherwise, check the current environment according to the prompt message or create an [issue](https://github.com/chaos-mesh/chaos-mesh/issues) for help.