Menu da documentação
Painel e análises
Runners gerenciados
Equipe e notificações
Faturamento e planos
Arquivos de workflow
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.
Resumo
- 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.
- 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.
- 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.
- 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.
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.
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.
| Fronteira | Como ela é imposta |
|---|---|
| Um job por máquina | Configuração just-in-time do GitHub (cold start) ou registro com --ephemeral (warm pool) |
| A máquina não pode ser reutilizada | O 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 sobrevive | O volume EBS raiz é criptografado e marcado como delete-on-termination |
| Jobs descontrolados são recolhidos | Um 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 workspace | As instâncias são marcadas com o ID da organização e registradas em um único grupo de runners da organização |
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#
- 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 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#
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.
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.
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.
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#
| Dado | Em repouso | Em trânsito |
|---|---|---|
| Disco raiz do runner | EBS criptografado (gp3), excluído na terminação | n/a |
| Cache de build (S3) | SSE-S3 (AES-256), expiração em 14 dias | TLS |
| Artefatos (S3) | SSE-S3 (AES-256), expiração em 7 dias | TLS |
| Banco de dados da aplicação | Armazenamento criptografado, sem acesso público | TLS |
| Camada de cache / fila | Criptografia em repouso e em trânsito habilitada | TLS |
| Chaves do app | SecureString do Parameter Store | TLS |
| Configurações de runner e tokens de registro (S3) | SSE-S3 (AES-256), excluídos na leitura, expiração em 1 dia | TLS |
| Tráfego de API | n/a | TLS 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 passorun:, e, no GitHub Actions, valores que uma action JavaScript registra comcore.setSecretou::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 deenv:, 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 noenv: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, comoproduction: 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 emenv:(em um scriptrun:, em uma entradawith:, em qualquer outra chave além deif: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 oGITHUB_TOKENemenv:, 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,pwshou um shell personalizado comonode {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 seuif:o pulou, uma action de contêiner que roda umpre-entrypointno 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 peloenv: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,pwshou um shell personalizado comonode {0}), que chama/usr/bin/bashpelo 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); oGITHUB_TOKENem uma forma codificada, a menos que o arquivo de workflow o mapeie noenv:do passo; um valor que o runner não consegue mais encontrar porque um passo seguinte que roda outro shell, chama/usr/bin/bashpelo 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:
| Controle | O que significa |
|---|---|
| Allowlist de sudo | Exatamente 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 pacotes | Os 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 ambiente | Definir 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íveis | Leituras em /etc, /root, /proc, /sys, /var/log, ~/.ssh, ~/.aws e ~/.config/gh são negadas. |
| Sandbox das ferramentas de IA | As 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 residente | Nos 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 desligamento | O 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ósito | Acesso | Permissões |
|---|---|---|
| Executar seus jobs em runners do Latchkey | Leitura e escrita | Runners auto-hospedados da organização |
| Ler dados básicos do repositório | Leitura | Metadados |
| 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ê desabilitou | Leitura e escrita | Actions |
| Remover webhooks que o Latchkey criou em um repositório | Leitura e escrita | Hooks 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 PRs | Leitura e escrita | Workflows, código, pull requests |
| Gravar os checks do Latchkey CI nos seus commits | Leitura e escrita | Checks |
| Ver cada grupo que sua fila de merge cria, para que o Latchkey CI construa aqueles em que um arquivo de workflow roda | Leitura | Filas de merge |
| Registrar o plano do GitHub da sua organização e os minutos de Actions que ela usou | Leitura | Plano da organização, administração da organização |
| Verificar quem está na sua organização | Leitura | Membros |
| Hoje não é usado por nenhum recurso do Latchkey | Leitura e escrita | Administração, hooks da organização |
| Hoje não é usado por nenhum recurso do Latchkey | Leitura | Metadados 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:
- 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.
- Pull requests originados de forks são rejeitados, e um sinal de fork ausente também é rejeitado, em vez de presumido seguro.
- 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.
| Dado | Retenção |
|---|---|
| Seu código-fonte no runner | Destruído junto com a instância ao final do job |
| Objetos do cache de build | 14 dias a partir da última escrita |
Artefatos que um job envia com latchkey artifact | 7 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 dela | Retidos até você excluir o workspace |
| Logs dos jobs do Latchkey CI e da CLI | 7 dias |
A árvore de trabalho que o latchkey run envia para iniciar um job | Excluí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óstico | 90 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 commit | 180 dias |
| Registros de tentativas de autorreparo | 90 dias |
| Registros de correções propostas | 365 dias |
| Os nomes e arquivos dos testes que falharam em um passo de teste que falhou, e as contagens de testes desse passo | 90 dias |
| Com que frequência um teste que falhou no Latchkey CI se mostrou instável, com o nome e o arquivo dele | 90 dias após a última falha do teste |
| Os caminhos dos arquivos que um pull request altera | 90 dias |
| Quais jobs de um pull request nenhuma alteração alcança | 90 dias |
| Os docs e a configuração de CI de um repositório, indexados para a base de conhecimento | Retidos 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 conhecimento | Retidos até você excluir o documento ou o workspace |
| Metadados de execução e de job que alimentam seus painéis | Retidos 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.