Sistema automatizado de build distribuído que recebe notificações de commits via webhook, realiza git pull de repositórios GitHub, executa builds utilizando NX, e gera imagens OCI compatíveis usando buildah.

O sistema é composto por microserviços escritos em Go que se comunicam via NATS:

GitHub Webhook → API Service → NATS → Worker Service → Build Pipeline
                                           ├─ Git Service
                                           ├─ NX Service
                                           ├─ Image Service
                                           └─ Cache Service

• API Service: Recebe webhooks do GitHub e expõe API REST para consultas
• Worker Service: Processa builds de forma assíncrona usando pool de workers
• Git Service: Gerencia operações Git (clone, pull, checkout)
• NX Service: Executa builds usando NX com cache inteligente
• Image Service: Constrói imagens OCI usando buildah
• Cache Service: Gerencia cache de código e dependências
• NATS: Message broker para comunicação entre serviços

• ☕ Java (Maven/Gradle)
• 🔷 .NET (NuGet)
• 🐹 Go (Go modules)

• Docker e Docker Compose
• Go 1.21+
• Node.js 18+ (para NX)
• Buildah (para construção de imagens OCI)

1. Clone o repositório:

git clone <repository-url>
cd oci-build-system

2. Configure as variáveis de ambiente:

cp .env.example .env
# Edite .env e configure GITHUB_WEBHOOK_SECRET

3. Inicie os serviços com Docker Compose:

docker-compose up -d

4. Verifique se os serviços estão rodando:

docker-compose ps
curl http://localhost:8080/health

1. Inicie o NATS:

docker run -d -p 4222:4222 -p 8222:8222 nats:latest -js -m 8222

2. Build dos serviços:

nx build api-service
nx build worker-service

3. Execute os serviços:

# Terminal 1
./dist/apps/api-service/api-service

# Terminal 2
./dist/apps/worker-service/worker-service

Execute todos os testes unitários:

nx run-many --target=test --all

Execute testes de um componente específico:

nx test api-service
nx test worker-service
nx test git-service

Os testes de propriedade validam propriedades universais do sistema:

# Executar todos os testes incluindo PBT
nx run-many --target=test --all

# Executar apenas testes de propriedade de um componente
cd libs/git-service && go test -run Property

Os testes de integração usam Robot Framework:

# Instalar dependências
pip install robotframework robotframework-requests

# Executar todos os testes de integração
cd tests/integration
robot .

# Executar suite específica
robot webhook.robot
robot build.robot
robot api.robot

# Gerar relatório de cobertura
nx run-many --target=test --all --codeCoverage

# Visualizar cobertura
go tool cover -html=coverage.out

Gere um secret aleatório para validação de webhooks:

openssl rand -hex 32

1. Acesse as configurações do repositório
2. Vá em Settings → Webhooks → Add webhook
3. Configure:
   • Payload URL: https://seu-dominio.com/webhook
   • Content type: application/json
   • Secret: Cole o secret gerado
   • Events: Selecione "Just the push event"
4. Clique em Add webhook

Adicione o secret no arquivo de configuração ou variável de ambiente:

Via arquivo (apps/api-service/config.yaml):

github:
  webhook_secret: "seu-secret-aqui"

Via variável de ambiente:

export GITHUB_WEBHOOK_SECRET="seu-secret-aqui"

Recebe webhooks do GitHub.

Headers:

• X-Hub-Signature-256: Assinatura HMAC-SHA256 do payload

Response:

{
  "job_id": "uuid",
  "status": "queued"
}

Consulta status de um build específico.

Headers:

• Authorization: Bearer token

Response:

{
  "id": "uuid",
  "repository": {
    "url": "https://github.com/owner/repo",
    "name": "repo",
    "owner": "owner"
  },
  "commit_hash": "abc123",
  "branch": "main",
  "status": "completed",
  "created_at": "2024-01-01T00:00:00Z",
  "duration": 120000000000,
  "phases": [
    {
      "phase": "git_sync",
      "duration": 5000000000,
      "success": true
    }
  ]
}

Lista histórico de builds.

Headers:

• Authorization: Bearer token

Query Parameters:

• limit: Número máximo de resultados (padrão: 50)
• offset: Offset para paginação (padrão: 0)

Health check do serviço.

Response:

{
  "status": "healthy",
  "nats": "connected"
}

Os logs são gerados em formato JSON estruturado:

{
  "level": "info",
  "ts": "2024-01-01T00:00:00Z",
  "msg": "build completed",
  "job_id": "uuid",
  "repository": "owner/repo",
  "duration": 120
}

Visualizar logs em tempo real:

docker-compose logs -f api-service
docker-compose logs -f worker-service

O sistema registra métricas de:

• Duração de cada fase do build
• Taxa de sucesso/falha
• Tamanho do cache
• Número de builds simultâneos

Verifique se o Dockerfile existe no repositório em um dos locais esperados:

• ./Dockerfile
• ./docker/Dockerfile
• ./build/Dockerfile

Verifique se o secret configurado no GitHub corresponde ao configurado no sistema:

# Verificar secret no sistema
docker-compose exec api-service env | grep GITHUB_WEBHOOK_SECRET

Verifique a conectividade com NATS:

# Verificar logs do worker
docker-compose logs worker-service

# Verificar status do NATS
curl http://localhost:8222/varz

Verifique se os volumes estão montados corretamente:

docker-compose exec worker-service ls -la /var/cache/oci-build/

[Adicione sua licença aqui]

[Adicione guia de contribuição aqui]