Pular para o conteúdo

Do commit à produção, com política e evidência

Software Delivery · Runtime, CI/CD e implantação

O Compute runtime publica aplicações em contêiner na nuvem a partir de um arquivo de configuração, guarda cada revisão e deixa voltar para a anterior. Em volta dele, o ciclo inteiro: build e teste em executores isolados ou no seu runner, registro de artefatos com proveniência, canary e blue-green, entrega no seu cluster Kubernetes, releases com portões, infraestrutura e banco revisados antes de mudar, e a governança que congela, exige aprovação de outra pessoa e pede o chamado de mudança. Cada funcionalidade aparece abaixo com o que faz e os limites dela.

Prévia
Destinos de deploy

O problema

O que este produto resolve

Times pequenos perdem dias configurando onde rodar um serviço que deveria levar uma tarde para subir.

Quando algo dá errado, falta o básico: qual versão está no ar, quem mudou, como voltar e quanto aquilo está custando.

E cada etapa da entrega costuma morar numa ferramenta diferente, com regra de aprovação própria: o build num lugar, a imagem em outro, a infraestrutura num terceiro, e ninguém consegue mostrar o caminho inteiro de uma mudança.

atualizado em

Quem usa e para quê

Perfis típicos, sem nomes de clientes. Cada uso leva o status da funcionalidade que o atende.

  • Time de produto de uma startupPublicar uma API interna ou um modelo em GPU sem montar servidor, com teto de gasto por workspace e volta de revisão.Compute runtime
  • Time de plataformaPromover uma release por dev, staging e produção, com janela, testes, scan e aprovação antes de cada ambiente.Release Orchestration
  • Time de plataforma com gestão de mudançasCongelar implantações na data crítica e exigir chamado de mudança aprovado antes de cada implantação.Deployment Governance

Funcionalidades

O que o produto faz

Contratação pela conta, em autoatendimento.

  • Compute runtime

    Execução de aplicações em CPU e GPU na nuvem, com revisões, volta de revisão, logs e segredos.

  • Pipelines

    Build e teste em executores isolados (Node, Python e Go) ou no runner próprio, com matriz, gatilhos por push, pull request e agenda, variáveis e segredos, relatórios JUnit, cobertura e política de teste. Quarentena de teste instável com prazo, divisão dos testes pela duração e seleção pelo que mudou; causa provável da falha, explicação por IA do passo que falhou, resumo do build, grafo dos estágios, tempo de cada passo e testes falhos e mais lentos na execução. Aprovação que pausa a execução (política ou estágio approval), com quem aprova, prazo e decisão pela tela, pela API e por aviso nos webhooks; cache de dependências no executor gerenciado por workspace, repositório e lockfile, por URL assinada. Build de imagem a partir do Dockerfile (Kaniko, sem Docker socket nem modo privilegiado) com push por digest para o Artifact Registry do workspace, cache de camadas no registro e scan de imagem como portão. O executor gerenciado atende repositórios públicos e privados do GitHub, pelo GitHub App da AIUBY ou por token.

  • Progressive Delivery

    Canary e blue-green no Compute pelo split de tráfego do Cloud Run: degraus com tempo de observação, verificação por saúde da revisão, taxa de erro, latência e incidentes, volta automática do tráfego no aborto, aprovação pela política antes dos 100% e janela de mudança.

  • Kubernetes & GitOps

    Entrega no cluster Kubernetes do cliente a partir de uma pasta de manifests (YAML + kustomization.yaml com imagens e réplicas) num repositório conectado: um agente instalado no cluster busca o estado desejado por HTTPS de saída e aplica só Deployments, Services e ConfigMaps do namespace do ambiente, sem a AIUBY guardar credencial do cluster. Commit novo na branch do ambiente vira diff e rollout rolling ou canary por réplicas, com prontidão relatada pelo agente, incidentes, checagem manual, política, regras de manifest e janela de mudança, relato de divergência (drift), gerador de aplicações por lista de ambientes e rollouts de produção no DORA. Helm não é renderizado (commite a saída do helm template); não há canary por tráfego (service mesh/ingress).

  • Release Orchestration

    Release como conjunto de aplicações promovido por ambientes em ordem (dev, staging, produção), com portões antes de cada um: congelamento, janela de mudança, política como código, suíte E2E passando, scan sem achado crítico aberto, fila por recurso, migração do banco aplicada no commit e aprovação; linha do tempo com cada portão, rollout e decisão; rastreio por item do Jira; aprovar e voltar pela tela, pela API e pela CLI (aiuby releases get, approve e rollback). Vale para as aplicações de Kubernetes & GitOps; o Compute não entra na release.

  • Deployment Governance

    Congelamento de implantações por período com alvos Compute, Kubernetes e pipelines, que nenhuma aprovação fura; política antes de cada implantação do Compute com pedido de aprovação preso à revisão e ao hash da configuração; quem pede não aprova, chave de API nunca aprova; mínimo de N aprovações e grupo de aprovadores; chamado de mudança no Jira ou no ServiceNow como condição; tela com a fila do workspace e os congelamentos; eventos nos webhooks, inclusive no Slack.

  • Delivery Controls

    Travas entre o código e a produção: firewall de dependências conferido pelo CI e pelo proxy npm, proveniência de artefatos, registro de módulos de IaC e plan pedido pelo pipeline, quarentena, divisão e seleção de testes, fila por recurso e portão de banco nas releases, gerador de aplicações por ambiente e rastreio de itens do Jira, com cada regra e bloqueio na auditoria.

  • Repositories

    Repositórios do GitHub conectados ao workspace com token só leitura (inclusive privados) e ligados ao grafo, ao CI e aos scanners; status checks do pipeline publicados no commit, que a proteção de branch do GitHub pode exigir; busca de código full-text na branch padrão pela tela, pela API e pela CLI aiuby-repo. A AIUBY não hospeda Git.

  • Infrastructure as Code

    Plan e apply gerenciados com OpenTofu no executor isolado da AIUBY: workspaces de IaC (repositório, diretório, variáveis herdadas do ambiente, conjuntos de entrada e papéis de quem roda e de quem aprova), state sempre no seu backend S3 ou GCS com lock, identidade federada de curta duração na sua nuvem (AWS e GCP), plan avaliado pelo IaC Review e pela política do ambiente, apply só de um plan revisado (pelo hash) e com aprovação humana, fila por workspace e drift agendado só leitura. Também: custo estimado por preço de lista, raio de impacto com os serviços do grafo, dependências entre workspaces, registro de módulos versionados, plan pedido pelo pipeline, plan comentado no pull request, workspaces efêmeros com prazo e drift que vira tarefa do Code Automation. Não guarda state nem plan, não cria os papéis na sua nuvem, não importa recursos e não roda Terraform (só OpenTofu).

  • Database DevOps

    Registro dos bancos por ambiente (sem endereço de conexão nem credencial guardados pela AIUBY), histórico das migrações que o CI ou o runner aplicou e relatou, portão antes de aplicar (rollback exigido, check de migrações liberado, ordem de promoção e conteúdo trocado), diferença de schema entre ambientes por retratos do CI ou do conector de dados com TLS verificado e eventos de banco na auditoria. O runner próprio do cliente aplica changelogs Flyway ou Liquibase em SQL depois que outra pessoa aprova o plano pelo hash, desfazendo o lote se uma migração falhar; migração escrita por IA passa pelas regras SQL e pela revisão de outra pessoa. A plataforma não simula o SQL.

  • IaC Review

    Análise de mudanças Terraform/OpenTofu no CI: lê os .tf do PR ou, de preferência, o JSON do plan gerado no seu CI com as suas credenciais; aponta destruição, recriação, segredo no código, 0.0.0.0/0 e bucket público, estima o impacto, detecta drift contra o último apply registrado e decide pela política do ambiente (aprovação na tela). A plataforma não executa terraform, não guarda state nem o plan.

  • Database Migration Review

    Análise de migrações SQL no CI (Postgres; MySQL básico), sem conectar ao seu banco: DROP, TRUNCATE, troca de tipo com reescrita, NOT NULL sem DEFAULT, índice sem CONCURRENTLY, renomeação, expand e contract na mesma entrega e falta de rollback, com decisão pela política do ambiente. Não aplica migração nem compara schema entre ambientes.

  • Self-hosted Runner

    Runner próprio do cliente (VM ou Kubernetes), agente pull com uma chave por runner, que executa os jobs do CI com até 4 serviços auxiliares, cache de dependências e de build por ferramenta, plugins de etapa de catálogo fechado e medição de CPU e memória, além de playbooks do Ansible e da aplicação de migrações aprovadas, com a credencial do alvo só na máquina dele. Pull request de fork é bloqueado antes do despacho.

  • Artifact Registry

    Repositórios Docker e npm por workspace no Google Artifact Registry da AIUBY (São Paulo), com credencial de push/pull de 15 minutos por conta de serviço restrita à organização, catálogo com digest, tags, tamanho, data e quem publicou, vínculo com repositório e commit no grafo, proveniência presa à execução, ao commit e ao digest, firewall de dependências com proxy npm, retenção por política auditada, eventos de versão publicada e removida, log de acesso por repositório e portão de implantação do Compute que recusa imagem sem scan ou sem assinatura verificada quando o workspace exige. Assinatura do cosign verificada com a chave pública ECDSA P-256 do workspace (sem keyless nem registro de transparência). Maven e PyPI não são atendidos.

CLI

Do terminal ao ar

O caminho pela CLI pública, com uma chave de API do workspace. Implantar pede saldo, teto mensal de Compute definido e o escopo "Implantar no Compute".

  1. npm install -g @aiuby-ia/cli

    Instala a CLI.

  2. aiuby login

    Guarda a chave de API; ela não aparece na tela nem fica no histórico.

  3. aiuby init fastapi-http minha-api

    Copia um template de partida com o aiuby.toml.

  4. aiuby config validate

    Confere o aiuby.toml sem usar a rede.

  5. aiuby apps create

    Cadastra a aplicação com a primeira revisão; não implanta.

  6. aiuby deploy --dry-run minha-api

    Mostra o plano, sem criar nada.

  7. aiuby deploy minha-api

    Implanta a revisão atual e acompanha até ficar em execução.

  8. aiuby logs minha-api

    Últimas linhas de log da implantação.

  9. aiuby rollback minha-api 3

    Grava uma revisão nova com a configuração da revisão 3.

Compute runtime

Ver todos os comandos na documentação

Prévia

O que está em validação

Existe no código e está em validação interna. Ainda não está aberta a clientes; quando abrir, a equipe AIUBY libera organização por organização.

  • Prévia

    Destinos de deploy

    Entrega do artefato aprovado pelo CI (imagem por digest ou commit) fora do Compute: AWS ECS na conta do cliente por papel com ExternalId, sem guardar chave; servidor Linux com agente que busca as ordens por HTTPS de saída e volta sozinho se a saúde falhar; e Vercel, pelo commit aprovado, com volta para o deployment anterior. Cada entrega fica na auditoria.

Como funciona

Do começo ao registro

  1. Construa e teste

    A cada push, build e testes rodam num executor isolado, com matriz, relatórios JUnit, cobertura e o diagnóstico de quem falhou.

  2. Guarde o artefato

    A imagem vai para o registro do workspace com credencial de 15 minutos; o catálogo mostra digest, assinatura e quem publicou.

  3. Revise infraestrutura e banco

    O plan de Terraform ou OpenTofu e as migrações SQL passam por regras e pela política do ambiente antes de qualquer apply.

  4. Implante

    Um arquivo de configuração diz imagem, hardware, variáveis e réplicas. Cada implantação, pela área logada ou pela CLI pública, gera uma revisão nova.

  5. Libere aos poucos

    A revisão nova recebe tráfego em degraus, com saúde, taxa de erro, latência e incidentes observados; sinal ruim devolve o tráfego à estável.

  6. Promova por ambientes

    A release avança de dev a produção com janela, política, testes, scan e aprovação antes de cada ambiente, numa linha do tempo só.

Funcionalidades

Funcionalidade por funcionalidade

O que cada uma faz, como funciona, um exemplo tirado da documentação e o que ela não faz. O selo de cada bloco vem do catálogo.

Compute runtime

Sua aplicação em contêiner no ar, com revisão que volta

O Compute runtime executa aplicações em contêiner na nuvem a partir de um arquivo aiuby.toml, que diz a imagem, a porta, o hardware (CPU ou GPU) e as réplicas. Cada mudança de configuração vira uma revisão numerada, e nenhuma é apagada.

Antes de implantar, o plano mostra o que seria criado e o que impede a implantação. No ar, a aplicação recebe um endereço, logs, segredos cifrados e um teto mensal de gasto no workspace.

Como funciona

  • Implantação pela área logada, pela CLI pública (@aiuby-ia/cli) ou pela API, com chaves de escopos separados para ler, gerenciar e implantar.
  • Revisões que não mudam depois de gravadas: voltar grava uma revisão nova com a configuração da escolhida, e a volta fica na auditoria.
  • CPU em São Paulo, com até 3 réplicas que sobem conforme chegam requisições e voltam a zero quando a aplicação fica ociosa.
  • GPU com uma placa por aplicação: NVIDIA L4 (24 GB) ou NVIDIA RTX PRO 6000 (96 GB), na máquina exata de cada uma.
  • Segredos gravados por tela, CLI ou API, cifrados no banco (AES-256-GCM) e entregues à aplicação como variável de ambiente; o valor não volta por tela, API, log nem auditoria.
  • Endereço público ou protegido por token de acesso de 1 hora, emitido pela plataforma só para aquela aplicação.
Pela CLI Do template à aplicação no ar, com logs e volta para a configuração da revisão 3.
aiuby init fastapi-http minha-api   # copia um template de partida
cd minha-api
aiuby config validate               # confere o aiuby.toml, sem usar a rede
aiuby apps create                   # cadastra; não implanta
aiuby deploy --dry-run minha-api    # mostra o plano
aiuby deploy minha-api
aiuby logs minha-api
aiuby rollback minha-api 3

O que não faz

  • Roda só imagem de contêiner; não faz build a partir do código-fonte.
  • Não tem volumes nem domínios próprios.
  • Não passa de 3 réplicas em CPU nem de 1 réplica com GPU, e não mantém réplica mínima acima de zero.
  • Não oferece GPU no Brasil: as placas ficam na Europa (Bélgica e Holanda).

Pipelines

Build e teste a cada mudança, com o motivo da falha

Pipelines roda o build e os testes de um repositório em executores isolados, um por job, com imagens de Node 22, Python 3.12 e Go 1.26, ou no runner próprio do cliente. A definição é um JSON versionado com estágios, dependências entre eles, matriz, condição por branch ou evento, variáveis e segredos. No executor gerenciado, o cache de dependências (npm, pip e Go) fica guardado por workspace, repositório e hash do lockfile e chega ao job por URL assinada de curta duração.

Cada execução devolve o resultado de cada passo, os testes lidos dos relatórios JUnit e a cobertura (lcov ou Cobertura). Quando algo falha, a execução aponta o passo, o código de saída, o fim do log, os testes que quebraram e a causa provável por regra, e quem administra pode pedir ali mesmo a explicação por IA do passo que falhou; o build pode deixar um resumo próprio em .aiuby/summary.md, mostrado como texto.

Como funciona

  • Disparo manual, por push (com filtro de caminhos), por pull request ou agendado, com webhook do GitHub de assinatura conferida; pull request de fork nunca recebe segredo.
  • Política de teste por estágio: cobertura mínima de linhas e exigência de testes no JUnit fazem o job falhar mesmo com os passos verdes.
  • Teste instável detectado quando o mesmo teste passa e falha no mesmo commit, com quarentena de até 90 dias que só releva falhas desses testes; divisão dos testes em N partes de duração parecida e seleção pelo que mudou.
  • Política como código avaliada antes de qualquer job existir (ação ci.run) e ao salvar o pipeline; congelamento com alvo em pipelines recusa push, agenda e disparo manual.
  • Aprovação que pausa: quando a política pede aprovação, ou num estágio approval da definição, a execução espera a decisão de quem pode aprovar, com prazo; aprova ou recusa pela tela ou pela API, o pedido chega aos webhooks (inclusive no Slack) com o link, e quem disparou não aprova a própria execução.
  • Build de imagem a partir do Dockerfile, sem Docker socket nem modo privilegiado, com push por digest para o registro do workspace e scan da imagem como portão.
Definição do pipeline Dois estágios: o de teste espera o build, roda em duas combinações da matriz e publica JUnit e cobertura.
{
  "version": 1,
  "on": { "manual": true, "push": { "branches": ["main", "release/*"] } },
  "stages": [
    { "name": "build", "image": "node22", "steps": [{ "name": "install", "run": "npm ci", "timeout": 300 }] },
    { "name": "test", "image": "node22", "needs": ["build"], "matrix": { "shard": ["1", "2"] },
      "env": { "NODE_ENV": "test" },
      "steps": [{ "name": "install", "run": "npm ci" }, { "name": "test", "run": "npm test -- --shard=$MATRIX_SHARD/2" }],
      "reports": { "junit": ["reports/*.xml"], "coverage": { "format": "lcov", "path": "coverage/lcov.info" } } }
  ]
}

O que não faz

  • Só repositórios do GitHub; o privado precisa do GitHub App da AIUBY instalado nele ou de um token de leitura no Cortex.
  • Aceita só as três imagens da lista (node22, python312 e go126) no executor gerenciado, com até 16 jobs por execução e tarefa de até 15 minutos.
  • No executor gerenciado, o cache cobre npm, pip e Go e só é gravado por disparo confiável (pull request lê, não grava); os demais presets, como Maven e Gradle, são do runner próprio.
  • A causa provável sai de regras sobre o log, sem modelo de IA; a explicação por IA é pedida passo a passo, conta no consumo de IA do workspace e é sugestão, sem mudar o código nem o pipeline.

Progressive Delivery

Versão nova recebe tráfego aos poucos e recua sozinha

Progressive Delivery libera uma revisão nova do Compute em canary ou blue-green, pelo split de tráfego do Cloud Run. No canary, a revisão sobe ao lado da estável com 0% e avança por degraus (o padrão é 10%, 50% e 100%), cada um observado por um tempo antes do próximo. No blue-green, a candidata ganha um endereço próprio para verificação e recebe 100% de uma vez.

Em cada degrau a plataforma lê a saúde da revisão, a taxa de erro, a latência p95 e os incidentes abertos do serviço. Sinal ruim aborta: o tráfego volta inteiro para a revisão estável.

Como funciona

  • Limiares configuráveis por rollout: taxa máxima de erro, latência p95 máxima, mínimo de requisições para julgar e aborto por incidente.
  • Checagem manual opcional: o rollout pausa antes de cada promoção até uma pessoa promover.
  • Antes dos 100%, a política como código decide (ação compute.rollout.promote, por ambiente): pode exigir aprovação de dono ou admin do workspace, ou negar.
  • Janela de mudança do workspace (dias, horário e fuso): fora dela nenhuma promoção acontece, nem a manual. Abortar sempre pode.
  • Pausar, retomar, promover e abortar pela área logada, pela API e pela CLI, com cada comando na auditoria.
  • O aborto pode abrir um incidente ligado ao serviço, e o grafo de entrega registra estratégia, degrau e percentual de cada implantação.
Pela API Inicia um canary em três degraus, com cinco minutos de observação em cada um, e exige aprovação antes dos 100% em produção.
POST /api/platform/compute/apps/{app}/rollout
{"strategy": "canary", "steps": [10, 50, 100], "observeSeconds": 300, "manualGate": false, "environment": "production"}

# regra de política: produção só chega a 100% com aprovação
{ "id": "aprovar-100", "action": "compute.rollout.promote", "scope": "environment:production",
  "effect": "needs_approval", "reason": "Produção exige aprovação" }

O que não faz

  • Exige a aplicação em execução e a revisão nova na mesma região: trocar CPU por GPU muda de região e usa a implantação direta.
  • Erro e latência só são julgados com o mínimo de requisições no degrau (20 por padrão); com menos, o degrau passa e o motivo registra a falta de tráfego.
  • Chave de API não aprova a promoção: só uma pessoa dona ou admin do workspace.
  • Vale para aplicações do Compute; no cluster Kubernetes do cliente, o canary é por réplicas, em Kubernetes & GitOps.

Kubernetes & GitOps

O commit na branch do ambiente vira rollout no seu cluster

Kubernetes & GitOps entrega no cluster Kubernetes do cliente a partir de uma pasta de manifests num repositório conectado: arquivos YAML mais um kustomization.yaml com imagens e réplicas. A plataforma renderiza, confere, calcula a diferença contra a versão no ar e conduz o rollout.

Um agente instalado no cluster busca o estado desejado por HTTPS de saída e aplica só no namespace do ambiente. A AIUBY não guarda credencial do cluster e não existe canal de comando: a resposta ao agente é só uma lista de objetos, que ele confere de novo, localmente, com a mesma política.

Como funciona

  • Rollout rolling ou canary por réplicas (estável e candidata lado a lado), com degraus, prontidão relatada pelo agente, aborto por incidente e checagem manual.
  • Política como código e janela de mudança antes dos 100%; regras de manifest do cliente na política barram o sync e o estágio de release; abortar devolve o cluster à versão estável.
  • Gerador de aplicações: um modelo e a lista de ambientes viram uma aplicação por ambiente, cada uma criada pelas mesmas regras.
  • Lista fechada de tipos (Deployment, Service e ConfigMap) e de campos: pod sem token da API do cluster, sem root, sem acesso ao host e no perfil restricted; Secret no Git é recusado.
  • Divergência (drift) relatada a cada ciclo em réplicas, imagem, ConfigMap, portas e seletor; reaplicar é opção do agente.
  • Rollouts em ambiente de produção entram no DORA do Engineering Intelligence: frequência, taxa de falha e lead time pelo commit.
kustomization.yaml da aplicação O subconjunto aceito: recursos da pasta, troca de imagem e número de réplicas. Qualquer outro campo é recusado com o nome dele.
resources:            # arquivos .yaml da própria pasta (até 30; sem "..", sem endereço remoto, sem pastas)
  - api.yaml
  - config.yaml
images:               # mesma regra do kustomize: casa pelo nome, sem tag nem digest
  - name: registro.exemplo/acme/api
    newTag: "1.4.2"   # ou newName, ou digest: sha256:...
replicas:
  - name: api
    count: 4

O que não faz

  • Não renderiza Helm: quem usa Helm commita a saída do helm template na pasta do ambiente.
  • Do kustomize, aceita só resources, images e replicas; patches, bases e geradores do kustomize são recusados.
  • Não entrega Ingress, Job, StatefulSet, Secret nem volume persistente: só Deployment, Service e ConfigMap.
  • O canary é por proporção de réplicas, aproximado; não há canary por tráfego (service mesh ou ingress) nem leitura de taxa de erro e latência do cluster.

Release Orchestration

Uma release, vários ambientes, um portão antes de cada um

Release Orchestration trata a release como um conjunto de aplicações promovido por ambientes em ordem, por exemplo dev, staging e produção. Um estágio só começa com todos os portões abertos: congelamento, janela de mudança, política como código, suíte E2E passando, scan sem achado crítico aberto, fila do recurso, migração do banco e aprovação.

A release é presa ao conteúdo. Na criação, a referência é resolvida para o SHA do commit, e todos os estágios renderizam desse SHA, mesmo que a branch ande depois. A aprovação grava o digest dos manifests renderizados, e o estágio só sobe exatamente esse digest.

Como funciona

  • Testes, scan e migração valem só para o commit da release: resultado de outro commit não abre o portão.
  • Fila por recurso: o estágio espera o rollout de outra origem nas mesmas aplicações e a release mais antiga no mesmo ambiente, por ordem de chegada; aprovação não fura a fila.
  • Portão de banco: o estágio só sobe quando a migração do banco indicado foi aplicada, sem violação, no commit da release.
  • Quatro olhos: quem criou a release não aprova. Em ambiente de produção, só uma pessoa que administra o workspace aprova, na tela.
  • Portões conferidos de novo na mesma transação que abre os rollouts; congelamento segura o estágio e nenhuma aprovação passa por cima.
  • Linha do tempo única com cada portão, rollout e decisão, e rastreio pela chave do Jira: execuções de CI, pull requests e releases que citam o item.
Pela CLI Os códigos de saída deixam um job de CI esperar a aprovação ou parar quando um portão fecha.
aiuby releases get <release>                # --json; saída 0 concluída, 7 em andamento ou aguardando aprovação, 6 portão fechado, 1 falhou ou desfeita
aiuby releases approve <release>            # chave com delivery:approve; produção só na tela
aiuby releases rollback <release> --reason "erro no checkout"   # chave com delivery:rollback

O que não faz

  • Vale para as aplicações de Kubernetes & GitOps; aplicações do Compute não participam da release.
  • Criar a release é pela tela: API e CLI consultam, aprovam e voltam.
  • Chave de API não aprova ambiente de produção nem estágio em que a política pede aprovação de pessoa.
  • O portão de testes lê a suíte Playwright do Test Automation; não lê resultado de outras ferramentas de teste.

Deployment Governance

Congelar, aprovar a quatro olhos e exigir chamado de mudança

A governança de implantação decide quem pode colocar o quê no ar e quando. Um congelamento por período recusa implantação no Compute, segura o estágio das releases do Kubernetes e barra execução de pipeline por push, agenda ou disparo manual, conforme os alvos escolhidos. Nenhuma aprovação passa por cima de um congelamento: só cancelar, e o cancelamento fica no histórico.

Antes de cada implantação do Compute, a política como código (ação compute.deploy) responde se pode, se nega ou se precisa de aprovação. O pedido de aprovação fica preso à aplicação, à revisão e ao hash da configuração, e só outra pessoa decide. A regra do workspace pode exigir um mínimo de aprovações, um grupo de aprovadores e um chamado de mudança aprovado no Jira ou no ServiceNow.

Como funciona

  • Congelamento de até 90 dias, para todas as aplicações ou uma lista, com alvos Compute, Kubernetes e pipelines; pull request continua rodando, porque verifica e não entrega.
  • Quem pediu não aprova, nem quem criou a chave que pediu; chave de API nunca aprova. Aprovado vale 24 horas e é consumido por uma única implantação.
  • Mínimo de N aprovações com voto único por pessoa e grupo de aprovadores; uma recusa decide, e congelamento e política que nega vencem.
  • Chamado de mudança como condição: enquanto o chamado não for aprovado no Jira ou no ServiceNow, ninguém aprova na AIUBY; recusado lá, recusa aqui.
  • Tela com a fila de pedidos do workspace inteiro ("x de N"), aprovar e recusar com nota, e congelamentos em vigor, agendados e no histórico.
  • Cada pedido, decisão e congelamento vira evento nos webhooks assinados, inclusive no formato do Slack.
Congelamento e regra de aprovação Congela os três alvos no período e exige aprovação de uma pessoa para toda implantação feita por chave de API.
POST /api/platform/compute/freezes
{"name": "...", "startsAt": "...", "endsAt": "...", "apps": [], "targets": ["compute", "k8s", "pipelines"]}

{ "id": "ci-aprova", "action": "compute.deploy", "scope": "app:*", "effect": "needs_approval",
  "conditions": [{ "path": "byCredential", "op": "eq", "value": true }], "reason": "Implantação por chave exige aprovação" }

O que não faz

  • Aprovar não implanta: quem pediu implanta de novo dentro do prazo.
  • O chamado de mudança e o quórum valem para os pedidos de implantação do Compute; nas releases do Kubernetes vale a aprovação da release.
  • O congelamento é por período absoluto, sem recorrência, e não segura o sync GitOps fora de release.
  • Criar e cancelar congelamento é só de pessoa que administra, pela tela ou pela sessão; chave de API não congela.

Delivery Controls

Cada passo da entrega conferido antes de seguir

Os controles de entrega são as travas que ficam entre o código e a produção, fora das grandes etapas. Eles decidem se uma dependência pode ser instalada, de onde veio um artefato, qual versão de um módulo de infraestrutura é usada, em que ordem releases disputam o mesmo ambiente e quais testes contam.

Tudo usa o que a plataforma registra: o histórico JUnit do CI, as execuções de pipeline, o registro de artefatos, o IaC gerenciado e o registro de bancos. Cada regra nova e cada bloqueio entram na auditoria com nome próprio.

Como funciona

  • Firewall de dependências por ecossistema e pacote, conferido pelo CI antes de instalar e aplicado também no proxy npm.
  • Proveniência: versão do registro presa à execução bem-sucedida, ao commit e ao digest.
  • Módulos de IaC versionados e imutáveis, e plan de IaC pedido pelo pipeline no commit da execução; o apply segue com aprovação.
  • Testes: quarentena com prazo, divisão em N partes pela duração e seleção pelo que mudou.
  • Releases: fila por recurso, portão de banco e gerador de aplicações por lista de ambientes.
  • Rastreio de um item do Jira: execuções de CI, pull requests e releases que citam a chave.

Exemplo de uso

Depois de um pacote malicioso publicado no npm, o time de plataforma cria uma regra que bloqueia o pacote em todas as versões. O CI recusa a instalação com o motivo, o proxy npm esconde a versão do metadado e a auditoria mostra cada tentativa. Na mesma semana, uma release de produção espera na fila porque outra release mais antiga ocupa o mesmo ambiente, e só sobe depois que a migração do banco aparece aplicada no commit dela.

O que não faz

  • O firewall não usa expressão regular: casa nome exato ou prefixo.
  • A seleção de testes é por nome; arquivo sem teste relacionado manda rodar tudo, e a quarentena dura no máximo 90 dias.
  • O plan pedido pelo pipeline não aplica nada.
  • O gerador de aplicações cria as aplicações uma vez; não as mantém sincronizadas com a lista depois.

Repositories

Seus repositórios do GitHub conectados, pesquisáveis e com status

Repositories reúne o que a plataforma faz com os repositórios do GitHub conectados ao workspace. A conexão usa um token só leitura do próprio workspace, que também abre repositório privado, e liga cada repositório ao grafo de entrega, ao Pipelines e aos scanners. O código continua no GitHub: a AIUBY não hospeda Git, e clone e push seguem lá.

Com a opção ligada no pipeline, cada execução publica o estado no commit como status check aiuby/<pipeline>, que a proteção de branch do GitHub pode exigir antes do merge. A busca de código indexa os arquivos de texto da branch padrão e responde com as linhas que casam, pela tela, pela API e por uma CLI de repositório.

Como funciona

  • Status do commit de pendente a sucesso, falha ou erro, enviado por uma fila própria com novas tentativas: a chamada ao GitHub nunca segura a execução do CI.
  • Busca full-text na branch padrão, com o repositório e as linhas que casam; o índice baixa só o que mudou desde a última leitura.
  • Ficam de fora do índice node_modules, vendor, dist, build e arquivos acima de 200 KB, com até 3.000 arquivos por repositório.
  • CLI aiuby-repo, sem dependências, com chave de leitura da engenharia: lista os repositórios conectados e busca por texto, com filtro de repositório.
  • Cada repositório conectado alimenta as métricas de PR do Engineering Intelligence e o rastreio de itens do Jira citados em commits e pull requests.

Exemplo de uso

Um time quer que a branch principal só aceite merge com o build verde da AIUBY. Liga os status checks no pipeline e marca aiuby/build como obrigatório na proteção de branch do GitHub. Na investigação de um bug, a pessoa de plataforma roda aiuby-repo search "createInvoice" e vê em quais repositórios e linhas a função aparece, sem clonar nada.

O que não faz

  • Não hospeda o código: os repositórios continuam no GitHub.
  • O resultado volta ao GitHub como status de commit, não como check run com anotações por linha.
  • A busca cobre só a branch padrão e é por texto, sem entender símbolos da linguagem.
  • A conexão, os status checks e a busca atendem só repositórios do GitHub.

Infrastructure as Code

Plan e apply com aprovação, state no seu bucket

Infrastructure as Code executa tofu plan e tofu apply (OpenTofu) no executor isolado da AIUBY, com a identidade de nuvem e o backend de state do cliente. Um workspace de IaC junta repositório, branch ou tag, diretório, ambiente, backend, identidade e variáveis, com papéis de quem roda e de quem aprova, variáveis herdadas do ambiente e conjuntos de entrada aplicados em ordem.

O plan é avaliado pelo IaC Review e pela política do ambiente e depois descartado: ficam os achados, o impacto, a decisão e o hash. O apply só acontece de um plan revisado, pelo hash, no commit exato do plan e com aprovação humana. O pipeline pode pedir o plan do próprio commit, e o resultado pode voltar como comentário no pull request.

Como funciona

  • State sempre no backend S3 ou GCS do cliente, com lock; identidade federada de curta duração, com papéis de plan e de apply obrigatoriamente diferentes.
  • Aprovação por pessoa que administra o workspace e que não pediu o plan; obrigatória em produção e em todo pedido feito por chave de API. Um plan vale 24 horas e aplica no máximo uma vez.
  • Fila por workspace de IaC: até 3 execuções esperando a vez, promovidas em ordem quando a anterior termina.
  • Workspaces efêmeros com state próprio e prazo de até 7 dias, para testar uma mudança sem tocar no ambiente fixo.
  • Registro de módulos com versão imutável presa ao commit, usada como fonte git::...?ref=<sha>; serviços do grafo no raio de impacto do plan.
  • Drift agendado ou sob demanda, só leitura; o drift detectado pode virar tarefa do Code Automation no repositório do IaC, com plano aprovado por uma pessoa antes de qualquer patch.
Pela CLI A chave com o escopo iac:run dispara e acompanha; não aprova nem cadastra. Plan bloqueado sai com código 6 e aguardando aprovação com 7.
aiuby iac plan --workspace <slug> --wait
aiuby iac runs <id>
aiuby iac apply <id> --plan-hash <hash> --wait

# drift, só leitura
aiuby iac plan --workspace <slug> --drift

O que não faz

  • Não roda Terraform: só OpenTofu.
  • Não cria os papéis na nuvem do cliente e não importa recursos; o custo é estimativa por preço de lista, não a fatura.
  • Atende AWS e GCP, com backend S3 ou GCS; Azure e outros backends não são atendidos.
  • Workspace efêmero vencido com recursos aplicados não é destruído sozinho: fica marcado para uma pessoa destruir.

Database DevOps

O que foi aplicado em cada banco, com portão antes de aplicar

Database DevOps registra os bancos do cliente por ambiente e o histórico das migrações aplicadas. O CI pergunta ao portão antes de aplicar, aplica com a ferramenta que a equipe usa e relata o resultado; a AIUBY não guarda endereço de conexão nem credencial do banco.

Para Flyway e Liquibase em SQL, o runner próprio do cliente lê o changelog da branch de cada ambiente, monta o plano com o hash do que vai rodar e aplica depois que outra pessoa aprova; se uma migração falha, desfaz as que entraram no lote. Uma migração também pode ser escrita por IA a partir de um pedido: ela passa pelas regras SQL e só segue com a revisão de outra pessoa que administra.

Como funciona

  • Regras por banco: rollback exigido em toda migração, check de migrações liberado e ordem de promoção (a versão precisa estar aplicada no ambiente anterior).
  • Portão antes de aplicar com o motivo de cada recusa, inclusive versão aplicada antes com outro conteúdo.
  • Histórico por banco: versão, estado (aplicada, desfeita, falhou), commit, quem relatou e as regras descumpridas; versões do ambiente anterior ausentes no seguinte, lado a lado.
  • Diferença de schema entre dois bancos (tabelas, colunas, índices e chave primária), a partir de retratos enviados pelo CI ou lidos pelo conector de dados com TLS verificado, só o catálogo e nunca linhas.
  • Aplicação pelo runner com aprovação presa ao hash do plano; congelamento e política que nega vencem a aprovação.
  • O mesmo registro abre o portão de banco das releases: o estágio só sobe com a migração aplicada no commit da release.
No CI, pela API v1 Chave com o escopo db:report para o portão e o relato, e db:read para a leitura. O portão não aplica nada: responde se pode.
# antes de aplicar
POST /api/v1/db/migrations/gate
{"database":"contas-prod","migrations":[{"version":"V12","hasRollback":true,"checkId":"<id>"}]}

# depois de aplicar com a sua ferramenta
POST /api/v1/db/migrations
{"database":"contas-prod","version":"V12","hasRollback":true,"commit":"<sha>"}

GET /api/v1/db/schema-diff?from=contas-stg&to=contas-prod

O que não faz

  • Não simula o SQL; quem executa é o CI ou o runner do cliente, com a conexão guardada só lá.
  • O histórico é o que o CI e o runner relatam; migração aplicada por fora deles não aparece.
  • A migração escrita por IA nunca é aplicada sem a revisão de uma pessoa diferente de quem pediu.
  • A análise de risco do SQL no CI é outra funcionalidade: Database Migration Review.

IaC Review

A mudança de infraestrutura perigosa para no CI, com o motivo

IaC Review analisa mudanças de Terraform e OpenTofu no CI. Lê os arquivos .tf do PR ou, de preferência, o JSON do plan que o CI do cliente gerou com as credenciais dele, e devolve achados, impacto e a decisão da política do ambiente.

O plan é analisado em memória e só os achados são gravados, com valores de segredo redigidos. O CI recebe um portão: segue, segue com aviso, espera aprovação na tela ou é bloqueado.

Como funciona

  • Nove regras: recurso removido, force_destroy, prevent_destroy retirado, troca de classe de banco ou cache, entrada 0.0.0.0/0, bucket público, segredo literal, recriação e deletion_protection desligada.
  • Só conta o que é novo em relação à base, com severidade maior quando o recurso guarda dado ou a porta é administrativa ou de banco.
  • Nota de risco de 0 a 100 e impacto do plan: o que cria, altera, remove e recria.
  • Decisão pela política como código (ação iac.apply, por ambiente), sempre a mais restritiva entre o portão base e a política.
  • Drift: o CI registra o apply, e um plan seguinte com mudança fora do código, ou com mudanças no mesmo commit do apply registrado, é marcado.
  • Aprovação na tela por quem administra o workspace, nunca por quem pediu, com justificativa.
No pipeline Códigos de saída: 0 liberado (inclui aviso), 6 bloqueado, 7 aguardando aprovação.
terraform plan -out plan.out
terraform show -json plan.out > plan.json
aiuby iac check --env production --workspace core --commit "$GITHUB_SHA" --plan plan.json infra/*.tf --base origin/main

# depois do apply feito pelo CI, registra a base do drift
aiuby iac applied --env production --workspace core --commit $SHA

O que não faz

  • Não executa terraform, não guarda state nem o plan e não acessa a nuvem do cliente.
  • Sem o JSON do plan, a leitura é textual: não resolve variáveis, count, for_each, blocos dynamic nem módulos remotos.
  • Não escreve comentário nem check no PR e não estima custo em dinheiro.
  • O drift depende de um plan agendado no CI do cliente: não há leitura direta da nuvem.

Database Migration Review

O DROP sem volta aparece no PR, não em produção

Database Migration Review analisa os arquivos de migração SQL no CI, sem conectar ao banco do cliente. Aponta as operações que derrubam dado, travam tabela ou quebram a versão anterior da aplicação, e decide pela política do ambiente.

O resultado é o mesmo portão das revisões de infraestrutura: o CI segue, segue com aviso, espera aprovação na tela ou é bloqueado, com a nota de risco e cada achado explicado.

Como funciona

  • Treze regras para Postgres: DROP de tabela e de coluna, TRUNCATE, troca de tipo com reescrita, NOT NULL sem DEFAULT, índice sem CONCURRENTLY, renomeação, FK ou CHECK sem NOT VALID, trava longa e UPDATE ou DELETE sem WHERE, entre outras.
  • Expand e contract na mesma entrega e migração sem rollback são acusados, quando a mudança tem arquivos de volta ou o pedido exige.
  • Tabelas grandes declaradas no pedido sobem a severidade dos achados nelas.
  • Seções e arquivos de volta (down, rollback) não são avaliados como destrutivos, e tabela criada na mesma migração não acusa índice nem constraint.
  • Decisão pela política como código (ação db.migrate, por ambiente), com aprovação na tela por quem administra, nunca por quem pediu.
No pipeline Analisa as migrações novas em relação à base, exige arquivo de volta e espera até dez minutos pela aprovação.
aiuby db check --env production db/migrations/*.sql --base origin/main --large-tables orders,events --require-rollback --wait 600

O que não faz

  • Não aplica migração e não compara schema entre ambientes.
  • Não conecta ao banco: o tamanho de tabela é só o que o pedido declara.
  • A cobertura de MySQL é básica, e procedimentos (blocos DO) não são analisados.

Self-hosted Runner

Jobs do CI na sua rede, com cache e medição

O runner próprio é um agente que roda numa VM ou num cluster Kubernetes do cliente e busca trabalho na AIUBY por HTTPS de saída, com uma chave só dele. Um estágio do pipeline com runsOn vai para o runner que tem aqueles rótulos; as variáveis seguem cifradas por job e o resultado volta pelo mesmo retorno assinado do executor gerenciado.

O mesmo runner executa playbooks do Ansible (com --check --diff por padrão) e aplica migrações aprovadas de Flyway e Liquibase, com a credencial do alvo guardada só na máquina dele. A AIUBY manda o que rodar; a conexão com o banco e com os servidores nunca passa por ela.

Como funciona

  • Uma chave por runner: revogar o runner revoga a chave, e o job pego fica preso a ele e à organização.
  • Pull request de fork é bloqueado antes do despacho e nunca chega ao runner; pull request só lê o cache, que só disparo confiável grava, no escopo da branch.
  • Até 4 serviços auxiliares (como um Postgres) na mesma rede do job, e CPU e memória de cada build.
  • Cache por ferramenta: npm, pnpm, yarn, pip, Go, Maven e Gradle, com teto de 500 MB por workspace.
  • Plugins de etapa num catálogo fechado: os parâmetros viram variáveis PLUGIN_ e nunca entram no comando.
  • A migração só roda depois da aprovação de outra pessoa presa ao hash do plano, numa transação, e o lote é desfeito se uma falhar.

Exemplo de uso

Um time com banco e serviços numa rede privada cadastra um runner com os rótulos linux e docker e aponta o estágio de testes para ele. O teste de integração sobe um Postgres ao lado do job, o cache do npm encurta a instalação, o GitHub mostra o resultado no commit e a migração revisada sai pelo mesmo runner, sem a senha do banco passar pela AIUBY.

O que não faz

  • O executor do job é a imagem de CI da AIUBY rodando no Docker do runner; ações do GitHub não rodam como etapa.
  • O cache fica no banco da plataforma, com teto por workspace; não há cache remoto de Gradle ou Bazel.
  • O runner não é uma instalação da plataforma inteira na sua rede: a AIUBY continua sendo o plano de controle.

Artifact Registry

Imagens e pacotes com dono, origem provada e retenção

Artifact Registry dá a cada workspace repositórios Docker e npm no Google Artifact Registry da AIUBY, em São Paulo, a mesma região do Compute. O acesso é por credencial de push ou pull de 15 minutos, emitida para uma conta de serviço restrita aos repositórios da organização.

O catálogo mostra cada versão com digest, tags, tamanho, data e quem publicou, e liga o artefato ao repositório e ao commit no grafo. A proveniência prende uma versão (imagem, pacote ou modelo de IA) à execução de pipeline bem-sucedida que a produziu, ao commit e ao digest. Na implantação do Compute, um portão recusa a imagem sem scan ou sem assinatura verificada quando o workspace exige.

Como funciona

  • Um repositório na nuvem por repositório da plataforma, com permissão só nele: o token de uma organização não abre o repositório de outra.
  • Assinatura do cosign verificada com a chave pública ECDSA P-256 do workspace: assinatura de outra imagem, de outra chave ou adulterada fica marcada como inválida.
  • Firewall de dependências: regras por ecossistema e pacote (nome exato ou prefixo), conferidas pelo CI antes de instalar, com cada bloqueio na auditoria.
  • Proxy npm: o npm do time aponta para a AIUBY, que busca no registro público, guarda por workspace e esconde a versão bloqueada pelo firewall.
  • Retenção por política (últimas N versões, sem tag depois de X dias), sem apagar a mais recente nem imagem em uso; versão publicada ou removida vira evento nos webhooks.
  • Log de acesso por repositório lido do Cloud Logging, e repositórios e contas apagados na nuvem quando a organização é encerrada.
Publicar uma imagem A credencial vale 15 minutos e só abre os repositórios da própria organização.
aiuby artifacts login
echo "$AIUBY_REGISTRY_TOKEN" | docker login -u oauth2accesstoken --password-stdin https://southamerica-east1-docker.pkg.dev
docker push southamerica-east1-docker.pkg.dev/<projeto>/<repositório>/api:1.2.0

O que não faz

  • Atende Docker e npm; Maven e PyPI não são atendidos, nem no proxy.
  • A verificação do cosign é com chave: não confere keyless, registro de transparência nem o formato novo de bundle.
  • A proveniência é um registro da plataforma, não um atestado assinado.
  • O isolamento entre workspaces da mesma organização é lógico: a credencial é da conta da organização.
Prévia

Destinos de deploy

O commit aprovado chega à sua nuvem, servidor ou Vercel

Prévia: em validação interna; quando abrir, a liberação é por organização.

Destinos de deploy levam o artefato que o CI aprovou (a imagem pelo digest, ou o commit) para fora do Compute: um serviço no ECS da conta AWS do cliente, um servidor Linux comum ou um projeto na Vercel. O destino recebe só o que passou pelos portões do pipeline.

Na AWS, o cliente cria um papel a partir de um modelo CloudFormation fornecido pela AIUBY, com um ExternalId único da organização; a AIUBY assume esse papel por pouco tempo e não guarda chave da conta. No servidor, um agente instalado com um comando busca as ordens por HTTPS de saída, sem porta aberta.

Como funciona

  • AWS: a imagem é copiada para o ECR do cliente com o mesmo digest e implantada no ECS Fargate; saúde ruim na entrega para o deployment e volta à versão anterior.
  • Servidor Linux: o agente puxa a imagem pelo digest, troca o contêiner, confere a saúde e volta sozinho para o anterior se ela falhar.
  • Vercel: a AIUBY cria o deployment de produção do commit aprovado, acompanha até ficar pronto e devolve o tráfego ao deployment anterior se a saúde falhar.
  • Voltar para a versão anterior também é uma ação na tela e na API, com o motivo registrado.
  • Cada entrega, volta e troca de credencial fica na auditoria; o token da Vercel vai cifrado ao banco.

Exemplo de uso

Um time com a aplicação na AWS conecta a conta pelo modelo CloudFormation, cadastra o serviço como destino e passa a ter cada commit aprovado pelo CI, pelo scan e pelos testes implantado no ECS, com volta automática se a saúde cair.

O que não faz

  • Na AWS, implanta só no ECS Fargate.
  • No servidor, exige Linux com systemd e Docker.
  • Na Vercel, o build é feito pela própria Vercel a partir do commit aprovado, não pela imagem do CI.

Governança e segurança

Regras que o código impõe

  • Segredos do Compute cifrados antes de ir ao banco; o valor nunca volta por tela, API, log ou auditoria.
  • Teto mensal de Compute por workspace: ao chegar nele, a aplicação é parada em poucos minutos, em vez de gerar conta surpresa.
  • Implantação paga só com conta pré-paga com saldo e teto definido; o endereço da aplicação pode exigir token de acesso.
  • A promoção a 100% passa pela política como código e pela janela de mudança do workspace. Fora da janela nada é promovido; abortar sempre pode.
  • Quem pede não aprova: a implantação do Compute com aprovação, a release e o apply de infraestrutura exigem uma segunda pessoa, e em produção a aprovação é sempre de uma pessoa, nunca de chave de API.
  • Congelamento por período para Compute, Kubernetes e pipelines: nenhuma aprovação passa por cima. A regra pode exigir N aprovações, um grupo de aprovadores e chamado de mudança aprovado no Jira ou no ServiceNow.
  • Pull request de fork nunca chega ao runner próprio nem recebe segredo; dependência bloqueada pelo firewall é recusada no CI e no proxy npm.
  • State e plan de infraestrutura não são guardados pela AIUBY; a execução usa identidade federada de curta duração na nuvem do cliente, com papéis de plan e de apply diferentes.
  • No Kubernetes, o agente só faz conexão de saída e aplica uma lista fechada de tipos no namespace do ambiente; a AIUBY não guarda credencial do cluster.

Integrações

Com o que se conecta

Só integrações que existem no código. Cada uma leva o status da funcionalidade que a usa.

  • Google Cloud RunExecução das aplicações do Compute runtime, em CPU e GPU.Compute runtime
  • CLI públicaImplantar, ver logs, gravar segredos e conferir a cobrança pelo terminal (@aiuby-ia/cli).Compute runtime
  • GitHubPush na branch dispara o pipeline, com webhook de assinatura conferida.Pipelines
  • Cloud MonitoringTaxa de erro e latência p95 da revisão candidata em cada degrau do rollout.Progressive Delivery
  • KubernetesAgente no cluster do cliente, com RBAC mínimo no namespace do ambiente.Kubernetes & GitOps
  • OpenTofuPlan e apply gerenciados, com state em S3 ou GCS do cliente.Infrastructure as Code
  • AWS e Google CloudIdentidade federada por OIDC para as execuções de infraestrutura, sem chave de longa duração.Infrastructure as Code
  • TerraformLeitura dos arquivos .tf e do JSON do plan gerado no CI do cliente.IaC Review
  • Postgres e MySQLAnálise dos arquivos de migração SQL, sem conexão ao banco.Database Migration Review
  • Docker e npmRepositórios por workspace no Google Artifact Registry, em São Paulo.Artifact Registry
  • cosignAssinatura de imagem verificada com a chave pública do workspace.Artifact Registry
  • GitHub status checksResultado do pipeline publicado no commit, exigível pela proteção de branch.Repositories
  • Jira e ServiceNowChamado de mudança aprovado como condição da aprovação de implantação.Deployment Governance
  • SlackEventos de implantação e de CI pelos webhooks, no formato do Slack.Deployment Governance
  • AnsiblePlaybooks rodados pelo runner próprio, com --check --diff por padrão.Self-hosted Runner
  • Flyway e LiquibaseChangelogs SQL aplicados pelo runner depois da aprovação pelo hash.Database DevOps

Perguntas frequentes

Respostas diretas

O que já dá para usar hoje?

Disponível: Compute runtime, Pipelines, Progressive Delivery, Kubernetes & GitOps, Release Orchestration, Deployment Governance, Delivery Controls, Repositories, Infrastructure as Code, Database DevOps, IaC Review, Database Migration Review, Self-hosted Runner, Artifact Registry. Prévia: Destinos de deploy. Contratação pela conta, em autoatendimento.

Dá para rodar dentro da rede da minha empresa?

Disponível: Compute runtime, Kubernetes & GitOps. No Compute runtime, não: ele roda no Google Cloud, numa conta operada pela AIUBY. Para entregar no seu próprio cluster, o caminho é Kubernetes & GitOps: um agente instalado no cluster busca o estado desejado por HTTPS de saída e aplica só no namespace do ambiente, sem a AIUBY guardar credencial do cluster.

O Software Delivery faz build e teste dos meus repositórios?

Disponível: Pipelines, Self-hosted Runner, Repositories. Pipelines roda build e testes em executores isolados, com imagens de Node, Python e Go, matriz, segredos, relatórios JUnit, cobertura e política de teste, por push, pull request, agenda ou disparo manual, e constrói a imagem a partir do Dockerfile com push para o registro do workspace. O executor gerenciado atende repositório público e privado do GitHub. Para rodar na sua rede, com serviços auxiliares e cache, o estágio vai para o runner próprio; o resultado volta como status check no commit do GitHub.

Como o Compute é cobrado?

Disponível: Compute runtime. Pelo tempo em uso de cada réplica e pela saída de rede, do saldo pré-pago, sem mensalidade. Em CPU, aplicação parada ou ociosa não custa; com GPU, a cobrança é por minuto de instância ligada, ociosa ou não. O preço por hora de cada tamanho está na página de preços e acompanha o câmbio; o valor do dia aparece na sua conta antes de implantar, e o teto mensal do workspace limita o total. Sem conta pré-paga com saldo e teto definido, a implantação é recusada com o motivo.

A AIUBY acessa a minha nuvem, o meu cluster ou o meu banco?

Disponível: IaC Review, Database Migration Review, Infrastructure as Code, Kubernetes & GitOps. Nas revisões de CI, não: o IaC Review lê os arquivos do PR ou o JSON do plan que o seu CI gerou, e o Database Migration Review lê os arquivos SQL, sem conectar ao banco. Na infraestrutura gerenciada, o plan e o apply rodam com uma identidade federada de curta duração que a sua nuvem autoriza, e o state fica no seu bucket. No Kubernetes, quem aplica é o agente dentro do seu cluster.

Funciona com Terraform e com Helm?

Disponível: IaC Review, Infrastructure as Code, Kubernetes & GitOps. O IaC Review analisa mudanças de Terraform e de OpenTofu. O plan e o apply gerenciados rodam só OpenTofu, não Terraform. Helm não é renderizado: quem usa Helm commita a saída do helm template na pasta do ambiente, e do kustomize valem só resources, images e replicas.

Quem aprova uma mudança em produção?

Disponível: Deployment Governance, Progressive Delivery, Release Orchestration, Infrastructure as Code. Sempre uma pessoa que administra o workspace, e nunca quem pediu. Na implantação do Compute, a política decide se precisa de aprovação, e a regra pode exigir N aprovações, um grupo e o chamado de mudança aprovado no Jira ou no ServiceNow; durante um congelamento, nada passa. No rollout do Compute, a política decide se os 100% exigem aprovação. Na release, quem criou não aprova, e a aprovação vale para o conteúdo exato que foi revisado. No apply de infraestrutura, a aprovação é obrigatória em produção e em todo pedido feito por chave de API. Não há modelo de IA decidindo promoção, aprovação nem apply.

Onde ficam os dados da minha aplicação?

Disponível: Compute runtime, Artifact Registry, Infrastructure as Code. As aplicações do Compute rodam no Google Cloud, na região de São Paulo. As imagens e os pacotes do registro de artefatos ficam na mesma região. Configuração, revisões e registros de implantação ficam na plataforma da AIUBY; os segredos vão cifrados ao banco. State de infraestrutura fica sempre no seu backend.

Funciona junto com

  • Security TestingO scan do commit é um portão da release: achado crítico aberto segura a promoção para o ambiente seguinte.
  • Incident ManagementIncidente aberto no serviço durante um rollout aborta a promoção, e o aborto pode abrir um incidente ligado ao serviço.

Software Delivery

Contratação pela conta, em autoatendimento.