Share via

Criar um experimento de caos que usa uma falha do Chaos Mesh com a CLI do Azure

  • Artigo

Você pode usar um experimento de caos para verificar se seu aplicativo é resiliente a falhas, causando essas falhas em um ambiente controlado. Neste artigo, você causa falhas periódicas do pod do Serviço Kubernetes do Azure (AKS) em um namespace usando um experimento de caos e o Azure Chaos Studio. A execução deste experimento pode ajudá-lo a se defender contra a indisponibilidade do serviço quando há falhas esporádicas.

O Chaos Studio usa o Chaos Mesh, uma plataforma de engenharia de caos gratuita e de código aberto para o Kubernetes, para injetar falhas em um cluster AKS. As falhas do Chaos Mesh são falhas diretas de serviço que exigem que o Chaos Mesh seja instalado no cluster AKS. Você pode usar essas mesmas etapas para configurar e executar um experimento para qualquer falha do AKS Chaos Mesh.

Pré-requisitos

Limitações

  • Você pode usar falhas do Chaos Mesh com clusters privados configurando a injeção de VNet no Chaos Studio. Todos os comandos emitidos para o cluster privado, incluindo as etapas neste artigo para configurar o Chaos Mesh, precisam seguir as diretrizes do cluster privado. Os métodos recomendados incluem conectar-se a partir de uma VM na mesma rede virtual ou usar o recurso de invocação de comando AKS.
  • As falhas do AKS Chaos Mesh só são suportadas em pools de nós Linux.
  • Atualmente, as falhas do Chaos Mesh não funcionam se o cluster AKS tiver contas locais desabilitadas.
  • Se o cluster AKS estiver configurado para permitir apenas intervalos de IP autorizados, você precisará permitir os intervalos de IP do Chaos Studio. Você pode encontrá-los consultando a ChaosStudioetiqueta de serviço com a API de descoberta de marca de serviço ou arquivos JSON baixáveis.

Abrir o Azure Cloud Shell

O Azure Cloud Shell é um shell interativo gratuito que você pode usar para executar as etapas neste artigo. Tem as ferramentas comuns do Azure pré-instaladas e configuradas para utilização com a sua conta.

Para abrir o Cloud Shell, selecione Experimente no canto superior direito de um bloco de código. Você também pode abrir o Cloud Shell em uma guia separada do navegador indo para Bash. Selecione Copiar para copiar os blocos de código, cole-o no Cloud Shell e selecione Enter para executá-lo.

Se você preferir instalar e usar a CLI localmente, este tutorial requer a CLI do Azure versão 2.0.30 ou posterior. Executar az --version para localizar a versão. Se precisar de instalar ou atualizar, veja Install Azure CLI (Instalar o Azure CLI).

Nota

Estas instruções usam um terminal Bash no Cloud Shell. Alguns comandos podem não funcionar como descrito se você executar a CLI localmente ou em um terminal do PowerShell.

Configurar o Chaos Mesh no seu cluster AKS

Antes de executar falhas do Chaos Mesh no Chaos Studio, você deve instalar o Chaos Mesh no cluster AKS.

  1. Execute os seguintes comandos em uma janela do Cloud Shell onde você tem a assinatura ativa definida para ser a assinatura onde seu cluster AKS está implantado. Substitua $RESOURCE_GROUP e $CLUSTER_NAME pelo grupo de recursos e nome do recurso de cluster.

    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

  2. Verifique se os pods Chaos Mesh estão instalados executando o seguinte comando:

    kubectl get po -n chaos-testing

Você deve ver uma saída semelhante ao exemplo a seguir (um chaos-controller-manager e um ou mais 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

Você também pode usar as instruções de instalação no site Chaos Mesh.

Habilite o Chaos Studio no seu cluster AKS

O Chaos Studio não pode injetar falhas em um recurso, a menos que esse recurso seja adicionado ao Chaos Studio primeiro. Para adicionar um recurso ao Chaos Studio, crie um destino e recursos no recurso. Os clusters AKS têm apenas um tipo de destino (service-direct), mas outros recursos podem ter até dois tipos de destino. Um tipo de destino é para falhas diretas de serviço. Outro tipo de destino é para falhas baseadas em agente. Cada tipo de falha Chaos Mesh é representado como uma capacidade como PodChaos, NetworkChaos e IOChaos.

  1. Crie um destino substituindo $SUBSCRIPTION_ID, $resourceGroupNamee $AKS_CLUSTER_NAME com as cadeias de caracteres relevantes do cluster AKS que você está adicionando.

    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\":{}}"

  2. Crie os recursos no destino substituindo $SUBSCRIPTION_ID, $resourceGroupNamee $AKS_CLUSTER_NAME com as cadeias de caracteres relevantes do cluster AKS que você está adicionando.

Substitua $CAPABILITYpelo "Nome da capacidade" da falha que você está adicionando.

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\":{}}"

Aqui está um exemplo de como ativar o PodChaos recurso para sua referência:

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\":{}}"

Esta etapa deve ser feita para cada recurso* que você deseja habilitar no cluster.

Agora você adicionou com sucesso seu cluster AKS ao Chaos Studio.

Criar uma experimentação

Agora você pode criar seu experimento. Um experimento de caos define as ações que você deseja tomar em relação aos recursos de destino. As ações são organizadas e executadas em etapas sequenciais. O experimento do caos também define as ações que você deseja tomar contra ramificações, que são executadas em paralelo.

  1. Crie uma malha jsonSpecdo caos :

    1. Consulte a documentação do Chaos Mesh para obter um tipo de falha, por exemplo, o tipo PodChaos.

    2. Formule a configuração do YAML para esse tipo de falha usando a documentação do 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. Remova qualquer YAML fora do spec, incluindo o nome da propriedade spec. Remova o recuo dos detalhes da especificação. O duration parâmetro não é necessário, mas é usado se fornecido. Neste caso, remova-o.

      action: pod-failure
mode: all
selector:
  namespaces:
    - default

    4. Use um conversor YAML para JSON como este para converter o Chaos Mesh YAML para JSON e minimizá-lo.

      {"action":"pod-failure","mode":"all","selector":{"namespaces":["default"]}}

    5. Use uma ferramenta de escape de cadeia de caracteres JSON como esta para escapar da especificação JSON ou altere as aspas duplas para aspas simples.

      {\"action\":\"pod-failure\",\"mode\":\"all\",\"selector\":{\"namespaces\":[\"default\"]}}

      {'action':'pod-failure','mode':'all','selector':{'namespaces':['default']}}

  2. Crie seu experimento JSON começando com o seguinte exemplo de JSON. Modifique o JSON para corresponder ao experimento que você deseja executar usando a API Create Experiment, a biblioteca de falhas e a jsonSpec criada na etapa 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"
          }
        ]
      }
    ]
  }
}

  3. Crie o experimento usando a CLI do Azure. Substitua $SUBSCRIPTION_ID, $RESOURCE_GROUPe $EXPERIMENT_NAME pelas propriedades do seu experimento. Certifique-se de que guardou e carregou a sua experiência JSON. Atualize experiment.json com seu nome de arquivo 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 cria uma identidade gerenciada atribuída ao sistema correspondente. Observe a ID principal dessa identidade na resposta para a próxima etapa.

Dê permissão ao experimento para seu cluster AKS

Quando você cria um experimento de caos, o Chaos Studio cria uma identidade gerenciada atribuída ao sistema que executa falhas contra seus recursos de destino. Essa identidade deve receber permissões apropriadas para o recurso de destino para que o experimento seja executado com êxito.

  1. Recupere o $EXPERIMENT_PRINCIPAL_ID executando o seguinte comando e copiando o PrincipalID da resposta. Substitua $SUBSCRIPTION_ID, $RESOURCE_GROUPe $EXPERIMENT_NAME pelas propriedades do seu 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
  1. Dê ao experimento acesso aos seus recursos usando o comando a seguir. Substitua $EXPERIMENT_PRINCIPAL_ID pelo ID principal da etapa anterior. Substitua $SUBSCRIPTION_ID, $resourceGroupNamee $AKS_CLUSTER_NAME com as cadeias de caracteres relevantes do cluster 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

Execute a sua experiência

Agora você está pronto para executar seu experimento. Para ver o efeito, recomendamos que você abra a visão geral do cluster AKS e vá para Insights em uma guia separada do navegador. Os dados em tempo real para o Ative Pod Count mostram o efeito da execução do experimento.

  1. Inicie o experimento usando a CLI do Azure. Substitua $SUBSCRIPTION_ID, $RESOURCE_GROUPe $EXPERIMENT_NAME pelas propriedades do seu 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

  2. A resposta inclui uma URL de status que você pode usar para consultar o status do experimento à medida que o experimento é executado.

Próximos passos

Agora que você executou um experimento direto de serviço AKS Chaos Mesh, está pronto para: