Pular para o conteúdo principal

Cache de autenticação de runners

Toda requisição que um runner envia ao servidor carrega seu token, e o servidor precisa transformar esse token em um registro de runner antes de poder fazer qualquer outra coisa. Os runners consultam o servidor a cada poucos segundos e relatam o progresso a cada segundo enquanto um job é executado, portanto, sem um cache, cada uma dessas requisições custaria uma consulta ao banco de dados. O cache de runners responde à maioria delas a partir da memória.

Um nó único mantém o cache em sua própria memória. No modo HA isso não é suficiente: se você editar um runner no nó A, o nó B não pode continuar servindo o registro antigo. Por isso, no modo HA o cache fica no Redis e é compartilhado por todos os nós, e uma alteração feita por meio de qualquer nó fica visível para todos eles de uma só vez.

nota

Este cache não é a ação Limpar cache da página Runners. Essa ação pede ao próprio runner que exclua os diretórios de trabalho em sua máquina.

O que é armazenado em cache e por quanto tempo​

O valor armazenado em cache é o registro do runner sem suas tags e sem o token. O token nunca chega ao Redis: a chave é derivada de um hash SHA-256 do token, e o campo do token é apagado antes de o registro ser armazenado.

Uma entrada vive por no máximo 30 segundos. Na prática, ela é descartada muito antes, porque toda alteração feita por meio do Semaphore invalida o cache imediatamente:

  • Criar, atualizar, excluir ou registrar novamente um runner, ou excluir um projeto, descarta todos os runners em cache em todos os nós.
  • Um heartbeat de runner descarta apenas a entrada daquele runner, de modo que o horário de "visto pela última vez" armazenado permanece atualizado sem tocar nos demais. Um heartbeat é gravado no máximo uma vez por intervalo equivalente a um terço de runners.offline_timeout_sec, limitado a 45 segundos; com o tempo limite padrão de 120 segundos, isso é a cada 40 segundos.

A expiração de 30 segundos só importa para alterações feitas por fora do Semaphore, por exemplo editando a tabela runner diretamente ou restaurando um backup.

Como as gravações obsoletas são evitadas​

Uma consulta que não encontra a entrada no cache lê o runner do banco de dados e depois o armazena. Entre esses dois passos, outro nó pode alterar o runner. Para garantir que a consulta nunca armazene em cache o que leu antes da alteração, o cache mantém um contador que cresce a cada invalidação. A consulta lembra o valor do contador que viu antes de ir ao banco de dados, e a gravação é rejeitada se o contador tiver avançado nesse meio-tempo. Cada passo é executado como um único script Lua no Redis, de modo que o contador e a entrada são lidos e gravados juntos.

Chaves do Redis​

ChaveTipoFinalidade
ha:runner:genstring, inteiroO contador. Cresce em um a cada invalidação, seja de todo o cache ou de um único runner.
ha:runner:invstring, inteiroValor do contador na última invalidação completa. Ele faz parte de toda chave de entrada, portanto uma invalidação completa torna todas as entradas existentes inacessíveis de uma só vez; elas então expiram por conta própria.
ha:runner:token:<inv>:<sha256(token)>string, binárioO registro do runner em cache. Expira após 30 s.
ha:runner:forgot:<sha256(token)>string, inteiroValor do contador no último heartbeat deste runner. Uma consulta iniciada antes do heartbeat não pode armazenar o registro anterior ao heartbeat. Expira após 30 s.

O painel do Cluster informa o número de chaves ha:runner:token:* como o tamanho do cache de runners.

Comportamento em caso de problemas no Redis​

O cache nunca faz uma requisição de runner falhar. Toda operação de cache é limitada a 500 milissegundos; se o Redis estiver lento ou inacessível, a consulta é tratada como uma falha de cache e vai ao banco de dados, e nada é armazenado. O único caso do qual é preciso estar ciente é uma invalidação que falha porque o Redis está fora do ar no momento em que um runner é alterado: os outros nós podem então servir o registro antigo até que ele expire, no máximo 30 segundos depois. A falha é registrada no nível de erro.