Compartilhar 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-as em um ambiente controlado. Neste artigo, você causará falhas periódicas de pod do AKS (Serviço de Kubernetes do Azure) em um namespace usando um experimento de caos e o Azure Chaos Studio. A execução desse 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 software livre para o Kubernetes injetar falhas em um cluster do AKS. As falhas do Chaos Mesh são falhas diretas de serviço que requerem que o Chaos Mesh seja instalado no cluster AKS. Você pode usar essas mesmas etapas para configurar e executar um experimento para qualquer falha da Malha do Caos do AKS.

Pré-requisitos

Limitações

Abrir o Azure Cloud Shell

O Azure Cloud Shell é um shell interativo gratuito que pode ser usado para executar as etapas neste artigo. Ele tem ferramentas do Azure instaladas e configuradas para usar com sua conta.

Para abrir o Cloud Shell, selecione Experimentar 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 até Bash. Selecione Copiar para copiar os blocos de código, cole-o no Cloud Shell e selecione Enter para executá-lo.

Se preferir instalar e usar a CLI localmente, este tutorial exigirá a CLI do Azure versão 2.0.30 ou posterior. Execute az --version para encontrar a versão. Se você precisa instalar ou atualizar, consulte Instalar a CLI do Azure.

Observação

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

Configurar Chaos Mesh no cluster do AKS

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

  1. Execute os comandos a seguir em uma janela do Cloud Shell em que você tem a assinatura ativa definida para ser a assinatura em que o cluster do AKS é implantado. Substitua $RESOURCE_GROUP e $CLUSTER_NAME pelo grupo de recursos e o nome do seu 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 do Chaos Mesh estão instalados executando o seguinte comando:

    kubectl get po -n chaos-testing

Você deverá 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 do Chaos Mesh.

Habilitar o Chaos Studio no cluster do AKS

O Chaos Studio não pode injetar falhas em um recurso, a menos que esse recurso seja adicionado primeiro ao Chaos Studio. Para adicionar um recurso ao Chaos Studio, crie um destino e funcionalidades no recurso. Os clusters do AKS têm apenas um tipo de destino (serviço direto), 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 de Malha do Chaos é representado como uma funcionalidade como PodChaos, NetworkChaos e IOChaos.

  1. Crie um destino substituindo $SUBSCRIPTION_ID, $resourceGroupName e $AKS_CLUSTER_NAME pelas cadeias de caracteres relevantes do cluster do 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, $resourceGroupName e $AKS_CLUSTER_NAME pelas cadeias de caracteres relevantes do cluster do AKS que você está adicionando.

Substitua $CAPABILITY pelo "Nome da Funcionalidade" 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\":{}}"

Veja um exemplo de como habilitar a funcionalidade de PodChaos 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* funcionalidade que você deseja habilitar no cluster.

Agora você adicionou com êxito o cluster do AKS ao Chaos Studio.

Criar uma experiência

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

  1. Criar uma malha de caos jsonSpec:

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

    2. Formular a configuração YAML para esse tipo de falha usando a documentação da Malha do Chaos.

      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 de especificação. Remova o recuo dos detalhes da especificação. O parâmetro duration não é necessário, mas é usado se fornecido. Nesse caso, remova-o.

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

    4. Use um conversor YAML para JSON como este para converter o YAML do Chaos Mesh em 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 o JSON do experimento começando com o exemplo JSON a seguir. Modifique o JSON para corresponder ao experimento que você deseja executar usando a API de Criação de Experimento, a biblioteca de falhase o jsonSpec criado 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.2"
              }
            ]
          }
        ]
      }
    ],
    "selectors": [
      {
        "id": "Selector1",
        "type": "List",
        "targets": [
          {
            "type": "ChaosTarget",
            "id": "/subscriptions/bbbb1b1b-cc2c-dd3d-ee4e-ffffff5f5f5f/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_GROUP e $EXPERIMENT_NAME com as propriedades do experimento. Verifique se você salvou e carregou o JSON do experimento. 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 pelo sistema correspondente. Observe a ID da entidade de segurança dessa identidade na resposta para a próxima etapa.

Conceder permissão de experimento ao cluster do AKS

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

  1. Recupere o $EXPERIMENT_PRINCIPAL_ID executando o comando a seguir e copiando o PrincipalID da resposta. Substitua $SUBSCRIPTION_ID, $RESOURCE_GROUP e $EXPERIMENT_NAME com as propriedades do 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ê acesso ao experimento aos seus recursos usando os comandos a seguir. Substitua $EXPERIMENT_PRINCIPAL_ID pela ID da entidade de segurança da etapa anterior. Substitua $SUBSCRIPTION_ID, $resourceGroupName e $AKS_CLUSTER_NAME pelas cadeias de caracteres relevantes do cluster do AKS.
az role assignment create --role "Azure Kubernetes Service RBAC Admin Role" --assignee-principal-type "ServicePrincipal" --assignee-object-id $EXPERIMENT_PRINCIPAL_ID --scope subscriptions/$SUBSCRIPTION_ID/resourceGroups/$resourceGroupName/providers/Microsoft.ContainerService/managedClusters/$AKS_CLUSTER_NAME

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

Se você preferir criar funções personalizadas em vez das funções integradas do AKS, siga as instruções na página de Tipos de recursos com suporte e atribuições de função para o Chaos Studio para listar as operações de controle de acesso baseado em função necessárias para uma falha específica e adicioná-las a uma função personalizada criada manualmente.

Executar o experimento

Agora você está pronto para executar seu experimento. Para ver o efeito, recomendamos que você abra sua visão geral do cluster do AKS e vá para Insights em uma guia separada do navegador. Os dados dinâmicos da Contagem de Pods Ativos mostram o efeito da execução do experimento.

  1. Inicie o experimento usando a CLI do Azure. Substitua $SUBSCRIPTION_ID, $RESOURCE_GROUP e $EXPERIMENT_NAME com as propriedades do 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 ele é executado.

Próximas etapas

Agora que você executou um experimento direto de serviço da Malha do Caos do AKS, está pronto para: