Pular para o conteúdo
Página inicial da Latchkey
Comece grátis
Menu da documentação

Arquitetura de segurança

Como o Latchkey isola cada job de CI: VMs dedicadas de uso único, nenhuma rede de entrada, credenciais efêmeras, criptografia em repouso e em trânsito, e as restrições sob as quais o agente de autorreparo é executado.

job por máquina virtual
1
destruída depois que ele termina
regras de rede de entrada
0
runners não aceitam conexões
padrão de sudo permitido
1
para o agente de autorreparo
retenção do cache de build
14d
90 dias para registros de autorreparo

Resumo

  1. Cada job recebe sua própria máquina virtual EC2, que executa exatamente um job e é então destruída, junto com seu disco criptografado.
  2. Os runners acessam a internet pelo próprio endereço IPv4 público, por trás de um security group com zero regras de entrada, então um runner não aceita conexões de entrada.
  3. As credenciais de runner são just-in-time e de uso único (um runner do GitHub Actions lê as suas uma vez, por um link efêmero que só ele recebe, e as apaga), e nenhum runner carrega um papel de instância da AWS.
  4. O agente de autorreparo roda como um usuário não root por trás de uma allowlist de sudo com uma única entrada, e suas ferramentas de IA são executadas em um sandbox de negação por padrão.

Esta página foi escrita para uma revisão de segurança. Ela descreve como a plataforma de runners é realmente construída - a fronteira de isolamento, o que sai da máquina, como as credenciais são tratadas e o que o agente de autorreparo tem e não tem permissão de fazer. Para o que o GitHub App pode ler e escrever nos seus repositórios, veja Segurança e permissões do GitHub.

segurança · um job em três fronteiras

Um job atravessa três fronteiras de confiança. No GitHub, o job entra na fila e um webhook assinado é enviado. O plano de controle do Latchkey verifica a assinatura do webhook, inicia uma máquina só para esse job, emite uma configuração just-in-time válida para um job e a guarda criptografada, legível apenas por um link de curta duração dado só àquela máquina. A VM do runner, que não aceita nenhuma conexão de entrada, inicia, lê a configuração uma vez, a apaga, se registra para exatamente um job, roda o job sozinha e é encerrada com o disco criptografado apagado.

FIG. 7.3-ACada travessia é autenticada e limitada a um job: a credencial é lida uma vez e apagada, e a máquina que a usou desaparece quando o job termina.

Isolamento: um job, uma máquina#

O Latchkey não compartilha uma máquina entre jobs. Cada job roda em uma máquina virtual EC2 dedicada (classe m6a, Ubuntu 24.04 LTS) lançada para aquele job. Seu job não é um contêiner compartilhando um kernel com outro inquilino, e não é um processo em um host compartilhado de longa duração.

O uso único é imposto na camada de registro do GitHub, não apenas por convenção. Runners de cold start se registram com uma configuração just-in-time, que o GitHub aceita para exatamente um job. Runners de warm pool se registram com a flag --ephemeral, que faz o mesmo. Nos dois casos, a instância é configurada para terminar no desligamento, então não pode ser reutilizada mesmo que algo dê errado.

FronteiraComo ela é imposta
Um job por máquinaConfiguração just-in-time do GitHub (cold start) ou registro com --ephemeral (warm pool)
A máquina não pode ser reutilizadaO comportamento de desligamento iniciado pela instância é definido como terminar, tanto no launch template quanto no caminho de lançamento direto
O disco não sobreviveO volume EBS raiz é criptografado e marcado como delete-on-termination
Jobs descontrolados são recolhidosUm processo de limpeza termina instâncias que passam da vida útil de 4 horas do runner (teto rígido de 8 horas) no Latchkey on GH; um job do Latchkey CI ou da CLI termina, o mais tardar, no seu próprio limite de tempo
Runners são vinculados a um único workspaceAs instâncias são marcadas com o ID da organização e registradas em um único grupo de runners da organização
01
Lançar
Uma instância EC2 dedicada inicializa para um job específico
02
Registrar
Configuração just-in-time, válida para exatamente um job
03
Ler uma vez
O runner busca sua credencial e a apaga imediatamente
04
Executar
Seu job roda sozinho na máquina
05
Terminar
A instância desliga; o comportamento de desligamento é terminar
06
Destruir
O volume raiz criptografado é excluído junto com a instância

Grupos de runners são criados com visibility: selected e uma lista explícita de repositórios, então um runner registrado para o seu workspace só recebe jobs dos repositórios que você habilitou.

O que roda como root, e por que isso está contido#

Dentro da sua própria VM, seu job tem controle total: o usuário runner tem sudo sem senha e acesso ao Docker. Isso é normal em CI - builds instalam pacotes e executam contêineres - e é seguro justamente porque o raio de alcance é uma única máquina de vida curta, sem rede de entrada, que é destruída ao final do job. Preferimos afirmar isso claramente a insinuar um sandbox que não existe. O único lugar onde um sandbox existe de fato é um pull request vindo de um fork no Latchkey CI: os passos dele rodam sem sudo, sem Docker e com uma rede fixa, como diz a seção Rede. No GitHub Actions, um job de um pull request vindo de um fork tem o mesmo controle total que qualquer outro job, restaura o seu cache de dependências sem salvar nele e não usa o seu cache de camadas do Docker.

Rede#

O que está bloqueado
  • Um runner acessa a internet pelo próprio endereço IPv4 público, usado apenas para as conexões que o próprio runner abre e diferente para cada máquina, então não há um endereço fixo para colocar em uma allowlist
  • O security group do runner tem zero regras de entrada e é a fronteira - nada na internet consegue abrir uma conexão com um runner
  • IMDSv2 é obrigatório, com o limite de hops definido como 1, para que um contêiner em rede bridge não consiga ler os metadados da instância através do host
  • Nenhum runner carrega um papel de instância da AWS, então o serviço de metadados da instância não guarda nenhuma credencial da AWS que um job possa pegar. Toda credencial que um runner do Latchkey CI mantém é de curta duração e emitida pelo plano de controle, seja para a própria máquina, sem nomear nenhum workspace, seja para o único job que ele executa.
  • O tráfego para o S3 e o DynamoDB na mesma região do runner continua nos gateway endpoints da VPC; as demais chamadas de API da AWS, incluindo o S3 e o DynamoDB em outras regiões, vão do endereço público do runner até o endpoint público de cada serviço
  • Um WAF (limitação de taxa, AWS Common Rule Set, Known Bad Inputs) fica na frente das aplicações web
O que o seu build ainda consegue alcançar
  • O tráfego de saída é aberto, porque a CI precisa alcançar npm, PyPI, Docker Hub, sua nuvem e seus próprios serviços
  • Trate qualquer segredo que você exponha a um job como alcançável por esse job - o mesmo modelo dos runners hospedados pelo GitHub
  • A única exceção é um pull request vindo de um fork no Latchkey CI: os passos dele alcançam o GitHub e um conjunto fixo de registros públicos de pacotes, e nada mais

O tráfego de um runner criado após nossa mudança de rede em 3 de novembro de 2026 não passa pelos nossos gateways NAT, e nenhum flow log registra as conexões dele. O que um passo imprime, incluindo qualquer host ou endereço que ele mencione, ainda pode ser guardado no log do job e no registro do reparo. Os gateways NAT transportam o tráfego do nosso próprio plano de controle e o de um runner criado antes dessa mudança, até esse runner terminar; eles registram os endereços remotos que essas conexões de saída alcançam e os bytes que elas transportam, e as tentativas de conexão feitas aos gateways a partir da internet, em totais de até dez minutos, sem conteúdo de pacotes e sem portas. O registro é mantido por 14 dias e excluído em até três dias depois disso. Somente nossos operadores o leem, para investigar o custo de rede, e uma cópia feita por um operador é excluída em até 14 dias.

Credenciais e segredos#

01
As credenciais de runner são emitidas por job

Uma configuração de runner just-in-time é gerada para um único job e guardada, criptografada, como um objeto privado com escopo daquela instalação e daquele job. Só a máquina iniciada para o job recebe o link assinado que a lê, e o link expira em 30 minutos.

02
O runner a lê uma vez e depois a apaga

Na inicialização, a instância a busca uma vez por esse link e a apaga na hora por um segundo link, porque ela contém material de chave; o que uma exclusão com falha deixar expira em um dia. Os tokens de registro de warm pool são entregues e apagados do mesmo jeito, e cada um é emitido para a sua própria máquina e nunca fica em cache.

03
O acesso ao GitHub é de curta duração

O GitHub App assina um JWT com sua chave privada e o troca por um installation access token de curta duração a cada operação. Não existe nenhum token do GitHub de longa duração armazenado em um runner.

04
Os segredos da plataforma ficam fora do alcance dos runners

A chave privada do GitHub App fica no Parameter Store como um SecureString. Nenhum runner carrega um papel de instância, e nenhum runner lê nenhum segredo da plataforma do Secrets Manager nem do Parameter Store.

No Latchkey CI, um segredo que um passo lê é ocultado no log do job onde quer que o seu valor apareça inteiro: como o próprio valor, como o seu base64 padrão (com preenchimento, com ou sem uma quebra de linha no final, e da forma como o base64 o quebra em 76 colunas) e como o corpo da sua string JSON. O mascaramento acontece onde o log é gravado, antes que qualquer chunk seja cortado ou enviado, a partir do momento em que o primeiro passo que nomeia o segredo o busca, e o mesmo mascaramento cobre tudo o que o autorreparo lê e envia para fora do runner. Um valor com menos de 28 bytes nunca é entregue, porque não poderia ser ocultado. O que ainda pode aparecer: uma linha de um valor de várias linhas impressa sozinha, uma parte de um valor ou um valor em outra codificação.

Os deploys rodam no Latchkey CI e se autenticam na AWS por assunção de papel via OIDC com o token de identidade do Latchkey do job, e os workflows que ainda rodam no GitHub Actions se autenticam da mesma forma com o token do GitHub. Não há chaves de acesso AWS de longa duração na CI. As chaves de API da integração MCP são armazenadas apenas como um hash SHA-256 - a chave em texto puro é exibida uma vez na criação e nunca é persistida.

Criptografia#

DadoEm repousoEm trânsito
Disco raiz do runnerEBS criptografado (gp3), excluído na terminaçãon/a
Cache de build (S3)SSE-S3 (AES-256), expiração em 14 diasTLS
Artefatos (S3)SSE-S3 (AES-256), expiração em 7 diasTLS
Banco de dados da aplicaçãoArmazenamento criptografado, sem acesso públicoTLS
Camada de cache / filaCriptografia em repouso e em trânsito habilitadaTLS
Chaves do appSecureString do Parameter StoreTLS
Configurações de runner e tokens de registro (S3)SSE-S3 (AES-256), excluídos na leitura, expiração em 1 diaTLS
Tráfego de APIn/aTLS 1.2 no mínimo no domínio da API

Isolamento do cache de build#

Os objetos de cache são armazenados no S3 sob um prefixo de chave derivado do ID da sua organização, e o ID do inquilino é injetado pelo control plane a partir da requisição do job - um job não pode se declarar outro inquilino definindo uma variável de ambiente. Os objetos expiram após 14 dias. Dentro da sua organização, menos jobs podem escrever no cache do que podem lê-lo. No GitHub Actions, só um job de um run iniciado por push, pull_request, schedule, workflow_dispatch ou merge_group salva nos seus caches, e nunca um de um pull request vindo de um fork ou de um run que o Dependabot iniciou ou reexecutou; qualquer outro job restaura deles e não pode salvar. No Latchkey CI, um job salva caches de dependências só na sua própria branch, pull request ou tag, as outras branches leem o que a branch padrão salvou, e um job de um pull request vindo de um fork não recebe cache.

O que sai do runner#

Dois tipos de dados saem da máquina, e vale ser preciso sobre o segundo.

  • Metadados de execução e de job: nomes, tempos, status, labels e o arquivo de workflow, a partir dos quais o dashboard e o AI Insight são construídos.
  • Saída do passo que falhou. Quando um passo falha, o autorreparo captura a saída padrão e a saída de erro dele e guarda até 1 MiB de cada uma no registro do reparo por 90 dias, para que a falha possa ser diagnosticada e, quando pertinente, transformada em uma correção proposta. Quando a etapa de IA dele roda, o final dessa saída vai para o nosso provedor de modelo de IA, junto com os arquivos do job que ele lê. De um passo de teste que falhou, o runner também envia os nomes e arquivos dos testes que falharam e as contagens de testes do passo, depois das remoções abaixo, e o Latchkey os guarda por 90 dias. No Latchkey CI, os nomes e arquivos são guardados para distinguir um teste instável de um teste quebrado.

O que o runner remove antes de o autorreparo enviar ou guardar a saída#

  • Valores que um passo registra com ::add-mask:: (ou com o antigo ##[add-mask]) enquanto roda em bash, o shell padrão de um passo run:, e, no GitHub Actions, valores que uma action JavaScript registra com core.setSecret ou ::add-mask:: antes do passo que falhou, mostrados como ***. As formas em base64 e as formas com escape (entre aspas, JSON, codificação percentual e XML) também são removidas, assim como um pedaço de um valor cortado na borda da saída capturada, quando esse pedaço chega a 8 caracteres.
  • Segredos em um formato conhecido, mostrados como [REDACTED:<type>]: chaves privadas; tokens e chaves do GitHub, GitLab, Anthropic, OpenAI, Google, Stripe, AWS, Slack, SendGrid, npm, RubyGems, Square, Docker Hub, Shopify, DigitalOcean, NuGet, Mailgun e Vault; JWTs; valores de autorização Bearer, Token e Basic; a senha em uma string de conexão; uma chave de acesso secreta da AWS em uma linha de comando; assinaturas de URLs assinadas; chaves de contas de armazenamento do Azure; e chaves de DSN do Sentry. Um texto que só se parece com um desses, como uma senha de teste em uma string de conexão ou uma fixture de teste com formato de JWT, também é removido.
  • No Latchkey CI, os valores dos segredos que o seu job usa.
  • No GitHub Actions, o valor de cada segredo que o arquivo de workflow mapeia no ambiente do passo que falhou como uma única referência ${{ secrets.NAME }} em uma entrada de env:, no nível do workflow, do job ou do passo, com só texto fixo em volta, mostrado como ***. As formas dele em base64 e com escape também são removidas.
  • Se a saída de um passo contém um valor registrado dividido entre dois campos de um documento JSON, o documento inteiro é removido.
  • O conteúdo de um PR de autorreparo nunca é alterado. O Latchkey não abre o pull request quando a mudança proposta contém um dos segredos do Latchkey CI do job, ou um valor de 8 ou mais caracteres que ele ocultou com ::add-mask:: ou que o arquivo de workflow mapeia de um segredo no env: do passo, do jeito que está escrito ou nas suas formas em base64 ou com escape. A única exceção é um valor de menos de 24 caracteres sem nenhum dígito, como production: do jeito que está escrito, ele só bloqueia o pull request onde nenhuma letra ASCII, dígito ou sublinhado encosta em qualquer uma das suas pontas, e as formas codificadas dele o bloqueiam em qualquer lugar. O Latchkey também não abre o pull request quando uma linha que a mudança escreve contém um destes marcadores, a menos que essa linha contenha mais do que marcadores e apareça inteira em uma linha do seu arquivo de workflow.
  • Se um job oculta mais de 10.000 valores com ::add-mask::, ou valores longos demais para o runner guardar, ou se a saída dele passa dos 64 MiB que o runner entrega ao autorreparo, ou se o runner descobre que perdeu um valor que um passo ocultou, ou se o mascaramento da saída falha, o autorreparo não o diagnostica: nada é enviado ao nosso provedor de modelo de IA nem guardado. No Latchkey CI, o autorreparo não roda em um passo que começa depois que o seu job passa a ter mais de 64 valores para o serviço de reparo do runner ocultar (os seus segredos, as suas configurações de serviço de 28 bytes ou mais e as credenciais que o Latchkey entrega aos seus passos), então nada desse passo é enviado ao nosso provedor de modelo de IA nem guardado pelo autorreparo; o log do job continua ocultando cada um desses valores. No GitHub Actions, ele também não diagnostica um passo que falhou quando o arquivo de workflow, no nível superior ou no job que falhou, usa um segredo em qualquer lugar que não seja um mapeamento simples em env: (em um script run:, em uma entrada with:, em qualquer outra chave além de if: ou dentro de uma expressão maior), quando um valor mapeado não confere com o arquivo, quando o arquivo chama um workflow reutilizável, quando o passo que falhou roda dentro de uma composite action e o arquivo mapeia um segredo que não seja o GITHUB_TOKEN em env:, quando um passo listado antes dele no job, ou qualquer passo da composite action em que ele roda, é uma action de contêiner, roda em um shell que não seja o bash (shell: python, sh, pwsh ou um shell personalizado como node {0}), chama o bash pelo caminho, como /usr/bin/bash, ou usa uma action cujo arquivo o autorreparo não consegue ler (um passo listado antes dele conta mesmo quando o seu if: o pulou, uma action de contêiner que roda um pre-entrypoint no início do job conta onde quer que esteja listada, e o autorreparo julga uma action do repositório pelo arquivo dela no commit em que o workflow rodou e uma action de outro repositório pelo arquivo dela como está no runner quando o passo falha), ou quando o runner não consegue ler o arquivo inteiro como ele rodou: em um job sem checkout do repositório, ou quando o arquivo passa de 1 MiB, não é YAML válido ou não contém o job.
  • Não é removido: um segredo sem formato conhecido que um passo imprime sem ocultá-lo com ::add-mask::, quando o passo não o recebeu pelo env: do arquivo de workflow, como um que um passo anterior escreveu em $GITHUB_ENV, em uma saída de passo ou em um arquivo; um valor ocultado só em um passo que roda outro shell (shell: python, sh, pwsh ou um shell personalizado como node {0}), que chama /usr/bin/bash pelo caminho ou que é uma action de contêiner (uma action que roda no próprio contêiner Docker), e é por isso que o autorreparo não diagnostica um passo que falha depois de um passo que ele lê como um desses; um valor ocultado só por uma action JavaScript em um runner que atualizou o software de runner do GitHub antes de rodar o seu job, o que um runner faz sempre que o GitHub já lançou uma versão mais nova que a da imagem do runner do Latchkey a partir da qual ele foi iniciado (o log do próprio GitHub continua ocultando esse valor); o GITHUB_TOKEN em uma forma codificada, a menos que o arquivo de workflow o mapeie no env: do passo; um valor que o runner não consegue mais encontrar porque um passo seguinte que roda outro shell, chama /usr/bin/bash pelo caminho ou é uma action apagou os arquivos em que ele guarda os valores ocultos no diretório temporário do job, ou apagou as anotações dele sobre um valor perdido por falta de espaço em disco ou por um erro de disco; e um valor impresso só em outra codificação, como hex ou base64 seguro para URL.

Como o agente de autorreparo é restringido#

O autorreparo é a parte em que um revisor deve pressionar mais forte, porque é o único componente que altera um job em execução. Veja exatamente o que ele pode fazer.

  • Ele roda como o usuário runner, não como root, na forma de um serviço systemd.
  • Ele escuta em um socket de domínio Unix com permissões restritas ao grupo. Não tem listener TCP nem superfície de rede.
  • Ele é invocado apenas por um shim nos scripts de passo do próprio agente do runner, e todos os demais comandos passam direto, sem alteração, com duas exceções. No GitHub Actions, o shim também fica no lugar do Node.js que o runner traz para as actions JavaScript, onde guarda os comandos ::add-mask:: que uma action imprime e repassa a saída da action byte a byte, sem invocar o agente. E em todo runner, antes de o autorreparo reexecutar um passo, o shim copia os relatórios de teste e os arquivos de saída de teste que o passo deixou no diretório de trabalho do job, como as capturas de tela e os traces do Playwright, para o diretório temporário do job, onde só o usuário do job pode lê-los; quando o próprio agente reexecuta o passo, ele chama o shim para isso como o usuário do job.
  • Ele falha aberto: se o agente atinge o tempo limite, recusa ou dá erro, um comando que falhou continua falhando. Um reparador quebrado não pode quebrar o seu build.

As operações privilegiadas que ele pode executar são definidas por allowlist, não por filtragem:

ControleO que significa
Allowlist de sudoExatamente um padrão ancorado é permitido - um apt-get install não interativo de um único pacote. Qualquer outra coisa começando com sudo é rejeitada antes de o processo ser criado.
Allowlist de pacotesOs pacotes instaláveis vêm de uma lista definida em tempo de compilação, aplicada de forma independente em dois estágios, porque um dos estágios monta comandos a partir de saída de build não confiável.
Piso de segurança do ambienteDefinir LD_PRELOAD, LD_LIBRARY_PATH, PATH, BASH_ENV ou ENV é negado, assim como metacaracteres de shell e substituição de comandos.
Negação de caminhos sensíveisLeituras em /etc, /root, /proc, /sys, /var/log, ~/.ssh, ~/.aws e ~/.config/gh são negadas.
Sandbox das ferramentas de IAAs ferramentas do estágio 3 rodam dentro de um sandbox baseado em bubblewrap que começa negando tudo por padrão - sem rede, sem caminhos de escrita - e é ampliado por ferramenta até o conjunto mínimo necessário.
Nenhuma chave de IA residenteNos runners do Latchkey CI e do GitHub Actions, o passo de raciocínio usa uma credencial de modelo que o plano de controle emite para aquele único reparo, então não há nenhuma chave de API de modelo de longa duração em uma máquina que executa o seu código.
Interruptor de desligamentoO autorreparo pode ser desativado por workspace.

O que o GitHub App pode acessar#

As permissões abaixo estão agrupadas pelo propósito, em vez de uma lista plana, para que você veja o motivo ao lado de cada concessão. As duas últimas linhas são permissões que o app tem e que hoje nenhum recurso do Latchkey usa.

PropósitoAcessoPermissões
Executar seus jobs em runners do LatchkeyLeitura e escritaRunners auto-hospedados da organização
Ler dados básicos do repositórioLeituraMetadados
Ler suas execuções e logs, disparar um workflow quando você ou seu agente de código pedir e cancelar uma execução que espera em um repositório que você desabilitouLeitura e escritaActions
Remover webhooks que o Latchkey criou em um repositórioLeitura e escritaHooks de repositório
Ler workflows, documentação e arquivos, ler um pull request e a lista de arquivos que ele altera e propor correções como PRsLeitura e escritaWorkflows, código, pull requests
Gravar os checks do Latchkey CI nos seus commitsLeitura e escritaChecks
Ver cada grupo que sua fila de merge cria, para que o Latchkey CI construa aqueles em que um arquivo de workflow rodaLeituraFilas de merge
Registrar o plano do GitHub da sua organização e os minutos de Actions que ela usouLeituraPlano da organização, administração da organização
Verificar quem está na sua organizaçãoLeituraMembros
Hoje não é usado por nenhum recurso do LatchkeyLeitura e escritaAdministração, hooks da organização
Hoje não é usado por nenhum recurso do LatchkeyLeituraMetadados de artefatos

Alterações nos seus repositórios#

O Latchkey nunca faz push na sua branch padrão. Toda alteração é um pull request que você revisa, e o caminho de escrita é restringido de três formas:

  1. O caminho do arquivo precisa ser resolvido como editável contra um manifesto por repositório. Caminhos sem correspondência são, por padrão, não editáveis - a verificação falha fechada.
  2. Pull requests originados de forks são rejeitados, e um sinal de fork ausente também é rejeitado, em vez de presumido seguro.
  3. Uma correção proposta precisa corresponder à sua assinatura de falha nos logs capturados, ou é suprimida.

Segurança operacional#

  • As imagens de runner são reconstruídas a partir da imagem mais recente do Ubuntu 24.04, com todas as atualizações pendentes do sistema operacional aplicadas, quando uma release do Latchkey muda o que elas contêm. Não há uma cadência fixa, e um runner não aplica sozinho nenhuma atualização do sistema operacional enquanto roda.
  • Nenhum runner carrega um papel de instância da AWS. A única sessão da AWS que o Latchkey emite para um runner é de curta duração e cobre apenas o cache de build e as imagens de contêiner, então ela não consegue ler as tags de nenhuma instância nem alcançar onde as credenciais de runner ficam guardadas, e nenhum runner consegue ler as credenciais de outro.
  • O acesso ao painel e à API é autenticado por um autorizador JWT no API gateway. Os papéis de workspace são Owner, Admin e Member, com os owners protegidos contra remoção ou rebaixamento.

Retenção de dados#

O que o Latchkey armazena, e por quanto tempo.

DadoRetenção
Seu código-fonte no runnerDestruído junto com a instância ao final do job
Objetos do cache de build14 dias a partir da última escrita
Artefatos que um job envia com latchkey artifact7 dias a partir do envio
Valores que um job do Latchkey CI registra em outputs:, para os jobs que precisam dele na execução e em qualquer nova execução delaRetidos até você excluir o workspace
Logs dos jobs do Latchkey CI e da CLI7 dias
A árvore de trabalho que o latchkey run envia para iniciar um jobExcluída quando o job termina, ou por uma expiração de 2 dias se essa exclusão falhar. O que o autorreparo lê dela fica no registro do reparo por 90 dias
Saída do passo que falhou, capturada para diagnóstico90 dias
A primeira linha do comando de um passo que falhou e até as últimas 20 linhas da saída dele, quando um workflow falha no Latchkey CI, mas passa no GitHub Actions no mesmo commit180 dias
Registros de tentativas de autorreparo90 dias
Registros de correções propostas365 dias
Os nomes e arquivos dos testes que falharam em um passo de teste que falhou, e as contagens de testes desse passo90 dias
Com que frequência um teste que falhou no Latchkey CI se mostrou instável, com o nome e o arquivo dele90 dias após a última falha do teste
Os caminhos dos arquivos que um pull request altera90 dias
Quais jobs de um pull request nenhuma alteração alcança90 dias
Os docs e a configuração de CI de um repositório, indexados para a base de conhecimentoRetidos enquanto o repositório estiver habilitado, e removidos quando você o desabilita. Se ele deixar de estar disponível para o Latchkey de outra forma, removidos na primeira limpeza semanal pelo menos 90 dias depois, exceto nos casos descritos abaixo da tabela
Documentos que você envia para a base de conhecimentoRetidos até você excluir o documento ou o workspace
Metadados de execução e de job que alimentam seus painéisRetidos até você excluir o workspace

Documentos da base de conhecimento indexados a partir de um repositório. Um repositório deixa de estar disponível para o Latchkey quando é removido do acesso do GitHub App (que é também como o Latchkey vê um repositório excluído no GitHub) ou quando o GitHub App é desinstalado. Os 90 dias contam a partir da primeira dessas interrupções, e só devolver o repositório ao acesso do GitHub App os reinicia: um repositório devolvido mas não habilitado de novo conta os 90 dias a partir de quando foi devolvido, ou da última alteração que o Latchkey registrou para ele, como uma renomeação ou a desinstalação do GitHub App, se for posterior. Uma suspensão do GitHub App não inicia, por si só, os 90 dias. Um arquivo excluído do repositório é removido na primeira limpeza semanal pelo menos 90 dias depois que o Latchkey indexa o repositório novamente e constata que ele não existe mais, ou junto com o repositório, se isso vier antes. Um documento de um repositório interrompido, exceto um arquivo que o Latchkey constatou que não existe mais, é retido além dos 90 dias enquanto um repositório habilitado do mesmo workspace tiver o nome com que o documento foi indexado, com as mesmas maiúsculas e minúsculas, até que o Latchkey tenha a cópia própria desse arquivo do repositório habilitado ou indexe esse repositório por completo depois do início dos 90 dias do repositório interrompido. Quando os registros do Latchkey não conseguem mostrar que um repositório foi interrompido, os documentos dele são retidos até você desabilitá-lo ou excluir o workspace. Documentos indexados antes de o Latchkey registrar de qual repositório cada documento veio são retidos até você excluí-los ou excluir o workspace, ou até você desabilitar um repositório enquanto ele tiver o nome com que foram indexados, com as mesmas maiúsculas e minúsculas. Uma interrupção que ocorre enquanto o Latchkey indexa o repositório pode remover alguns dos documentos dele na hora e deixar alguns escritos nesses minutos contando os 90 dias a partir de quando foram escritos.

Desabilitar um repositório interrompe a coleta para ele. Excluir o seu workspace remove os dados dele. Se você precisa de uma janela de retenção específica para a sua organização, peça e conversaremos a respeito.

Reportando uma vulnerabilidade#

Envie um e-mail para security@latchkey.dev. Por favor, não abra uma issue pública no GitHub para um relato de segurança.

Q.01Meu código-fonte permanece no runner depois do job?

Não. A instância e seu volume raiz criptografado são destruídos quando o job termina. Nada do que você fez checkout sobrevive, além das entradas de cache de build que você habilitou explicitamente, que expiram após 14 dias, dos artefatos que um job envia com latchkey artifact, que expiram 7 dias após o envio, das saídas que um job registra quando é concluído com sucesso, que ficam guardadas até você excluir o workspace, do que o autorreparo leu dos seus arquivos, que o registro do reparo guarda por 90 dias, e do conteúdo dos arquivos de uma correção proposta, guardado por 365 dias.

Q.02O job de outro cliente consegue ver o meu?

Não. Cada job roda em sua própria máquina virtual, registrada para um único workspace e destruída após esse único job. Os runners não têm acesso de rede de entrada.

Q.03O agente de autorreparo pode executar comandos arbitrários no meu build?

Não. As ações privilegiadas são definidas por allowlist em vez de filtradas: um único padrão de sudo permitido, uma lista fixa de pacotes, negação de variáveis de ambiente que possibilitam injeção de código e um sandbox de negação por padrão para o estágio de ferramentas de IA. Se o agente falhar por qualquer motivo, um comando que falhou continua falhando.

Q.04Meus segredos de build são visíveis para o Latchkey?

Podem ser. Como qualquer runner, um runner do Latchkey recebe os segredos do GitHub Actions que o seu job referencia, injetados pelo GitHub em tempo de execução, e é destruído quando o job termina. O Latchkey nunca chama a API do GitHub para obter os valores deles. Quando o autorreparo diagnostica um passo que falhou, a saída do passo é capturada antes de o GitHub mascará-la: o final dela vai para o nosso provedor de modelo de IA e até 1 MiB dela fica guardado por 90 dias. O runner primeiro remove os valores que um passo em bash ocultou com ::add-mask::, qualquer segredo em um formato conhecido e todo segredo que o arquivo de workflow mapeia no env: do passo, e o autorreparo não diagnostica um passo cujo arquivo de workflow usa um segredo de outra forma. Assim, um segredo sem formato conhecido só está nos dois quando chegou ao passo por outro caminho e o passo o imprimiu sem ocultar. Padrões conhecidos de segredos são removidos de novo quando essa saída é servida.