Programar um experimento

Nesta página, descrevemos como programar experimentos no Fault Injection Testing e como usar serviços de programação externos para automatizar os testes de resiliência.

Ao programar experimentos, você pode automatizar os processos de teste e executar experimentos durante períodos que minimizam o impacto nos usuários, como:

  • Horários de pico ou janelas de manutenção planejadas.
  • Dias de jogos ou exercícios de engenharia do caos programados regularmente.
  • Pipelines de teste automatizados (CI/CD) para verificar a resiliência antes da implantação.

A programação de experimentos ajuda a estabelecer a validação contínua da tolerância a falhas dos sistemas sem exigir intervenção manual para cada execução.

Como os experimentos programados funcionam

O Fault Injection Testing não inclui um serviço de programação integrado. Em vez disso, você programa experimentos integrando o Fault Injection Testing a um serviço de programação externo, como o Cloud Scheduler.

Para programar um experimento, configure o programador externo para chamar a API Fault Injection Testing ou executar um comando gcloud em um horário específico. Para oferecer suporte a essa integração, o Fault Injection Testing fornece o parâmetro startOnCreateEnabled. Quando definido como true, esse parâmetro informa ao sistema para iniciar o experimento automaticamente logo após a criação.

Como selecionar destinos para experimentos programados

Os recursos de destino de um experimento programado são definidos no modelo de experimento, não na configuração de programação. Veja como o Fault Injection Testing processa os destinos:

  • Ao criar um modelo de experimento, você define o tipo de falha e os critérios de seleção dos recursos de destino. Os exemplos de recursos incluem instâncias de VM específicas, recursos com tags correspondentes ou recursos em uma zona específica.
  • Ao configurar o programador externo, o payload da API faz referência ao modelo de experimento.
  • No horário programado, o programador externo aciona a criação do experimento. Em seguida, o Fault Injection Testing avalia as regras de seleção de destino no modelo naquele momento para determinar quais recursos são afetados.

Se o modelo segmentar VMs com base em uma tag, o experimento programado afetará as VMs que tiverem essa tag no momento exato em que o experimento for executado.

Configurar um experimento programado

Antes de continuar, verifique se você tem o papel roles/faulttesting.operator ou roles/faulttesting.admin.

Configurar uma programação usando o Google Cloud console e o Cloud Scheduler

Embora não seja possível criar programações diretamente no console do Fault Injection Testing, ele fornece os parâmetros necessários para configurar um job no Cloud Scheduler.

  1. No Google Cloud console, acesse a página Modelos de experimento.
  2. Selecione um modelo para conferir os detalhes.

  3. Na página de detalhes, anote o seguinte:

    • O payload JSON, que inclui "startOnCreateEnabled": true.
    • O URL do endpoint de API REST para criar um experimento.

    Você vai usá-los no Cloud Scheduler.

  4. No Google Cloud console, acesse a página Cloud Scheduler e clique em Criar job.

  5. Defina a programação e o fuso horário do job.

  6. Em Tipo de destino, selecione HTTP.

  7. Defina o URL como o URL do endpoint de API REST na página de detalhes Modelos de experimento.

  8. Defina o método HTTP como POST.

  9. No campo Corpo, insira o payload JSON:

    {
  "experimentTemplate": "projects/PROJECT_ID/locations/REGION/experimentTemplates/TEMPLATE_ID",
  "startOnCreateEnabled": true,
  "description": "DESCRIPTION"
}

  10. Configure a autenticação para o job. Consulte as práticas recomendadas para recomendações de conta de serviço.

  11. Clique em Criar.

Configurar uma programação usando a Google Cloud CLI

Se você estiver usando scripts ou ferramentas que executam comandos de shell, poderá programar experimentos configurando o Cloud Scheduler ou seu próprio programador para executar o comando gcloud alpha fault-testing experiments create com a flag --start-on-create-enabled.

Execute o comando a seguir para criar e iniciar imediatamente uma instância de experimento:

gcloud alpha fault-testing experiments create EXPERIMENT_ID \
    --experiment-template=TEMPLATE_ID \
    --location=REGION \
    --start-on-create-enabled \
    [--description="DESCRIPTION"] \
    [--project=PROJECT_ID]
  • EXPERIMENT_ID: um identificador exclusivo para a execução do experimento. Como esse comando é automatizado, o script precisa gerar um ID exclusivo para cada execução. Por exemplo, você pode anexar um carimbo de data/hora: scheduled-exp-$(date +%s).
  • TEMPLATE_ID: o ID do modelo de experimento pré-configurado.
  • REGION: aregião em que Google Cloud o experimento é executado.
  • --start-on-create-enabled: essa flag informa ao Fault Injection Testing para iniciar o experimento imediatamente após a criação.
  • DESCRIPTION: (opcional) uma descrição da execução do experimento.
  • PROJECT_ID: (opcional) o Google Cloud ID do projeto.

Gerenciar execuções de experimentos

Cada execução programada cria uma instância de experimento nova e distinta. É possível gerenciar essas instâncias usando os comandos a seguir:

  • Para listar todas as execuções de experimentos:

    gcloud alpha fault-testing experiments list --location=REGION

  • Para conferir detalhes de uma execução específica:

    gcloud alpha fault-testing experiments describe EXPERIMENT_ID --location=REGION

  • Para interromper um experimento em execução:

    gcloud alpha fault-testing experiments stop EXPERIMENT_ID --location=REGION

Práticas recomendadas

Ao programar experimentos, considere as seguintes práticas recomendadas:

  • Usar uma conta de serviço dedicada. Ao configurar o programador (como o Cloud Scheduler), associe-o a uma conta de serviço dedicada. Conceda a essa conta de serviço apenas as permissões mínimas necessárias para gerenciar experimentos, como roles/faulttesting.operator ou roles/faulttesting.admin no seu projeto.
  • Gerar IDs de experimentos exclusivos. Ao acionar experimentos usando scripts, verifique se o script gera um ID de experimento exclusivo para cada execução para evitar conflitos de nomes de recursos.
  • Usar nomes ou descrições descritivos. Cada execução programada cria uma nova instância de experimento. Ela não reinicia nem substitui experimentos anteriores. Use nomes ou descrições descritivos para ajudar a rastrear as execuções até a programação.
  • Monitorar falhas de programação. Os acionadores externos podem falhar devido a problemas de rede, expiração de credenciais ou cotas de API. Configure o monitoramento e os alertas nos jobs do programador para notificar se um job não for executado ou receber uma resposta de erro.
  • Coordenar com janelas de exclusão. Verifique se os experimentos programados não se sobrepõem às janelas de exclusão ativas. Se um experimento programado for acionado durante uma janela de exclusão, o Fault Injection Testing vai bloquear a execução, e o experimento não será iniciado.