Creación de un experimento de caos que use un error de Chaos Mesh con la CLI de Azure

Artículo
05/02/2024

Puede usar un experimento de caos para comprobar que la aplicación es resistente a los errores provocando esos errores en un entorno controlado. En este artículo, provocará errores de pod de Azure Kubernetes Service (AKS) periódicos en un espacio de nombres mediante un experimento de caos y Azure Chaos Studio. La ejecución de este experimento puede ayudarle a defenderse contra la falta de disponibilidad del servicio cuando hay errores esporádicos.

Chaos Studio usa Chaos Mesh, una plataforma gratuita de ingeniería de caos de código abierto para Kubernetes para insertar errores en un clúster de AKS. Los errores de Chaos Mesh son errores directos de servicio que requieren que Chaos Mesh esté instalado en el clúster de AKS. Estos mismos pasos se pueden usar para configurar y ejecutar un experimento para cualquier error de Chaos Mesh de AKS.

Requisitos previos

Suscripción a Azure. Si no tiene una suscripción a Azure, cree una cuenta gratuita de Azure antes de empezar.
Un clúster de AKS con grupos de nodos de Linux. Si no tiene un clúster de AKS, consulte el inicio rápido de AKS que usa la CLI de Azure, Azure PowerShell o Azure Portal.

Limitaciones

Puede usar errores de Chaos Mesh con clústeres privados mediante la configuración de la inserción de VNet en Chaos Studio. Los comandos emitidos en el clúster privado, incluidos los pasos de este artículo para configurar Chaos Mesh, deben seguir las instrucciones del clúster privado. Entre los métodos recomendados se incluyen la conexión desde una máquina virtual en la misma red virtual o mediante la característica de invocación de comandos de AKS.
Los errores de Chaos Mesh de AKS solo se admiten en grupos de nodos de Linux.
Actualmente, los errores de Chaos Mesh no funcionan si el clúster de AKS tiene cuentas locales deshabilitadas.
Si el clúster de AKS está configurado para permitir solo intervalos IP autorizados, debe permitir los intervalos IP de Chaos Studio. Puede encontrarlos consultando la ChaosStudioetiqueta de servicio con la API de detección de etiquetas de servicio o los archivos JSON descargables.

Apertura de Azure Cloud Shell

Azure Cloud Shell es un shell interactivo gratuito que puede usar para ejecutar los pasos de este artículo. Tiene las herramientas comunes de Azure preinstaladas y configuradas para usarlas en la cuenta.

Para abrir Cloud Shell, seleccione Probarlo en la esquina superior derecha de un bloque de código. También puede abrir Cloud Shell en una pestaña independiente desde Bash. Seleccione Copiar para copiar los bloques de código, péguelos en Cloud Shell y, luego, seleccione Entrar para ejecutarlos.

Si prefiere instalar y usar la CLI en un entorno local, para este tutorial se requiere la versión 2.0.30 de la CLI de Azure o una versión posterior. Ejecute az --version para encontrar la versión. Si necesita instalarla o actualizarla, vea Instalación de la CLI de Azure.

Nota:

Estas instrucciones usan un terminal de Bash en Azure Cloud Shell. Es posible que algunos comandos no funcionen tal como se describe si la CLI se ejecuta localmente o en un terminal de PowerShell.

Configuración de Chaos Mesh en el clúster de AKS

Para poder ejecutar errores de Chaos Mesh en Chaos Studio, debe instalar Chaos Mesh en el clúster de AKS.

Ejecute los siguientes comandos en una ventana de Cloud Shell donde tenga la suscripción activa establecida para que sea la suscripción donde se implementa el clúster de AKS. Reemplace $RESOURCE_GROUP y $CLUSTER_NAME por el grupo de recursos y asigne un nombre al recurso del clúster.

az aks get-credentials -g $RESOURCE_GROUP -n $CLUSTER_NAME
helm repo add chaos-mesh https://charts.chaos-mesh.org
helm repo update
kubectl create ns chaos-testing
helm install chaos-mesh chaos-mesh/chaos-mesh --namespace=chaos-testing --set chaosDaemon.runtime=containerd --set chaosDaemon.socketPath=/run/containerd/containerd.sock

Ejecute el siguiente comando para comprobar que los pods de Chaos Mesh están instalados:
```
kubectl get po -n chaos-testing
```

Debe ver una salida similar al siguiente ejemplo (un chaos-controller-manager y uno o varios chaos-daemons):

NAME                                        READY   STATUS    RESTARTS   AGE
chaos-controller-manager-69fd5c46c8-xlqpc   1/1     Running   0          2d5h
chaos-daemon-jb8xh                          1/1     Running   0          2d5h
chaos-dashboard-98c4c5f97-tx5ds             1/1     Running   0          2d5h

También puede usar las instrucciones de instalación en el sitio web de Chaos Mesh.

Habilitación de Chaos Studio en el clúster de AKS

Chaos Studio no puede insertar errores en un recurso a menos que ese recurso se agregue primero a Chaos Studio. Para agregar un recurso a Chaos Studio, cree un destino y funcionalidades en el recurso. Los clústeres de AKS solo tienen un tipo de destino (service-direct), pero otros recursos pueden tener hasta dos tipos de destino. Un tipo de destino es para errores directos del servicio. Otro tipo de destino es para errores basados en agente. Cada tipo de error de Chaos Mesh se representa como una funcionalidad como PodChaos, NetworkChaos e IOChaos.

Cree un destino reemplazando $SUBSCRIPTION_ID, $resourceGroupName y $AKS_CLUSTER_NAME por las cadenas pertinentes del clúster de AKS que va a agregar.

az rest --method put --url "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$resourceGroupName/providers/Microsoft.ContainerService/managedClusters/$AKS_CLUSTER_NAME/providers/Microsoft.Chaos/targets/Microsoft-AzureKubernetesServiceChaosMesh?api-version=2024-01-01" --body "{\"properties\":{}}"

Cree las funcionalidades en el destino reemplazando $SUBSCRIPTION_ID, $resourceGroupName y $AKS_CLUSTER_NAME por las cadenas pertinentes del clúster de AKS que va a agregar.

Reemplace $CAPABILITY por el "Nombre de funcionalidad" del error que va a agregar.

az rest --method put --url "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$resourceGroupName/providers/Microsoft.ContainerService/managedClusters/$AKS_CLUSTER_NAME/providers/Microsoft.Chaos/targets/Microsoft-AzureKubernetesServiceChaosMesh/capabilities/$CAPABILITY?api-version=2024-01-01"  --body "{\"properties\":{}}"

Este es un ejemplo de cómo habilitar la funcionalidad PodChaos para la referencia:

az rest --method put --url "https://management.azure.com/subscriptions/b65f2fec-d6b2-4edd-817e-9339d8c01dc4/resourceGroups/myRG/providers/Microsoft.ContainerService/managedClusters/myCluster/providers/Microsoft.Chaos/targets/Microsoft-AzureKubernetesServiceChaosMesh/capabilities/PodChaos-2.1?api-version=2024-01-01"  --body "{\"properties\":{}}"

Esto debe hacerse con cada* capacidad que quiera habilitar en el clúster.

Ahora ha agregado correctamente el clúster de AKS a Chaos Studio.

Creación de un experimento

Ahora puede crear el experimento. Un experimento de caos define las acciones que se desean realizar en los recursos de destino. Las acciones se organizan y ejecutan en pasos secuenciales. El experimento de caos también define las acciones que se desean realizar en las ramas, que se ejecutan en paralelo.

Crear jsonSpec de Chaos Mesh:
1. Consulte la documentación de Chaos Mesh para ver un tipo de error, por ejemplo, el tipo PodChaos.
2. Formule la configuración de YAML para ese tipo de error mediante la documentación de Chaos Mesh.
```
apiVersion: chaos-mesh.org/v1alpha1
kind: PodChaos
metadata:
  name: pod-failure-example
  namespace: chaos-testing
spec:
  action: pod-failure
  mode: all
  duration: '600s'
  selector:
    namespaces:
      - default
```
3. Quite cualquier YAML fuera de spec, incluido el nombre de la propiedad de especificación. Quite la sangría de los detalles de la especificación. El parámetro duration no es necesario, pero se usa si se proporciona. En este caso, quítelo.
```
action: pod-failure
mode: all
selector:
  namespaces:
    - default
```
4. Use un convertidor de YAML a JSON como este para convertir el YAML de Chaos Mesh a JSON y minimizarlo.
```
{"action":"pod-failure","mode":"all","selector":{"namespaces":["default"]}}
```
5. Use una herramienta de escape de cadena JSON como esta para escapar de la especificación JSON o cambiar las comillas dobles a comillas simples.
```
{\"action\":\"pod-failure\",\"mode\":\"all\",\"selector\":{\"namespaces\":[\"default\"]}}
```
```
{'action':'pod-failure','mode':'all','selector':{'namespaces':['default']}}
```

Cree el JSON del experimento a partir del siguiente ejemplo de JSON. Modifique el JSON para que corresponda con el experimento que quiere ejecutar mediante la API de creación de experimento, la biblioteca de errores y el jsonSpec creado en el paso anterior.

{
  "location": "centralus",
  "identity": {
    "type": "SystemAssigned"
  },
  "properties": {
    "steps": [
      {
        "name": "AKS pod kill",
        "branches": [
          {
            "name": "AKS pod kill",
            "actions": [
              {
                "type": "continuous",
                "selectorId": "Selector1",
                "duration": "PT10M",
                "parameters": [
                  {
                      "key": "jsonSpec",
                      "value": "{\"action\":\"pod-failure\",\"mode\":\"all\",\"selector\":{\"namespaces\":[\"default\"]}}"
                  }
                ],
                "name": "urn:csci:microsoft:azureKubernetesServiceChaosMesh:podChaos/2.1"
              }
            ]
          }
        ]
      }
    ],
    "selectors": [
      {
        "id": "Selector1",
        "type": "List",
        "targets": [
          {
            "type": "ChaosTarget",
            "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myRG/providers/Microsoft.ContainerService/managedClusters/myCluster/providers/Microsoft.Chaos/targets/Microsoft-AzureKubernetesServiceChaosMesh"
          }
        ]
      }
    ]
  }
}

Cree el experimento mediante la CLI de Azure. Reemplace $SUBSCRIPTION_ID, $RESOURCE_GROUP y $EXPERIMENT_NAME por las propiedades del experimento. Asegúrese de haber guardado y cargado el JSON del experimento. Actualice experiment.json con el nombre del archivo JSON.
```
az rest --method put --uri https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Chaos/experiments/$EXPERIMENT_NAME?api-version=2023-11-01 --body @experiment.json
```
Cada experimento crea una identidad administrada asignada por el sistema correspondiente. Observe el id. principal de esta identidad en la respuesta del paso siguiente.

Conceder permiso al experimento al clúster de AKS

Al crear un experimento de caos, Chaos Studio crea una identidad administrada asignada por el sistema que ejecuta errores en los recursos de destino. Esta identidad debe tener los permisos adecuados en el recurso de destino para que el experimento se ejecute correctamente.

Recupere $EXPERIMENT_PRINCIPAL_ID mediante la ejecución del comando siguiente y la copia de PrincipalID desde la respuesta. Reemplace $SUBSCRIPTION_ID, $RESOURCE_GROUP y $EXPERIMENT_NAME por las propiedades del experimento.

az rest --method get --uri https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Chaos/experiments/$EXPERIMENT_NAME?api-version=2024-01-01

Proporcione al experimento acceso a los recursos mediante el siguiente comando. Reemplace $EXPERIMENT_PRINCIPAL_ID por el id. principal del paso anterior. Reemplace $SUBSCRIPTION_ID, $resourceGroupName y $AKS_CLUSTER_NAME por las cadenas pertinentes del clúster de AKS.

az role assignment create --role "Azure Kubernetes Service Cluster Admin Role" --assignee-object-id $EXPERIMENT_PRINCIPAL_ID --scope subscriptions/$SUBSCRIPTION_ID/resourceGroups/$resourceGroupName/providers/Microsoft.ContainerService/managedClusters/$AKS_CLUSTER_NAME

Ejecutar el experimento

Ahora ya puede ejecutar el experimento. Para ver el efecto, se recomienda abrir la información general del clúster de AKS e ir a Información en una pestaña independiente del explorador. Los datos dinámicos del recuento de pods activos muestran el efecto de ejecutar el experimento.

Inicie el experimento mediante la CLI de Azure. Reemplace $SUBSCRIPTION_ID, $RESOURCE_GROUP y $EXPERIMENT_NAME por las propiedades del experimento.

az rest --method post --uri https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Chaos/experiments/$EXPERIMENT_NAME/start?api-version=2024-01-01

La respuesta incluye una dirección URL de estado que puede usar para consultar el estado del experimento mientras se ejecuta.

Pasos siguientes

Ahora que ha ejecutado un experimento directo del servicio de Chaos Mesh de AKS, está listo para:

Share via