Deploy e Infraestrutura

Implementador

Estratégia de Deploy

O Prodgy utiliza containers Docker para a maioria dos serviços, com exceção do Assistant (.NET) que roda em uma VM Windows.

Serviço	Método de Deploy	Plataforma Recomendada
API	Container	Azure Container Apps, ECS, Kubernetes
Web	Container ou Static	Azure Static Web Apps, S3 + CloudFront, Vercel
Service	Container	Azure Container Apps, ECS, Kubernetes
Studio	Container	Azure Container Apps, ECS, Kubernetes
Engine	Container	Azure Container Apps, ECS, Kubernetes
Gateway	Container	Azure Container Apps, ECS, Kubernetes
Agentic	Container	Azure Container Apps, ECS, Kubernetes
Assistant	VM Windows	Azure VM, EC2 Windows, bare metal
Docs	Container ou Static	Azure Static Web Apps, Vercel, Netlify

Dockerfiles

Cada serviço possui seu próprio Dockerfile:

Serviço	Arquivo	Imagem Base
API	`apps/api/Dockerfile`	`node:18-alpine`
Web	`apps/web/Dockerfile`	`node:18-alpine`
Service	`apps/service/Dockerfile`	`node:18-alpine`
Studio	`apps/studio/Dockerfile`	`node:18-alpine`
Gateway	`apps/gateway/Dockerfile`	`node:18-alpine`
Agentic	`apps/agentic/Dockerfile`	`node:18-alpine`
Engine	`Dockerfile.engine` (raiz)	`python:3.13-slim`

Build dos Containers

# API
docker build -f apps/api/Dockerfile -t prodgy-api .

# Web
docker build -f apps/web/Dockerfile -t prodgy-web .

# Service
docker build -f apps/service/Dockerfile -t prodgy-service .

# Studio
docker build -f apps/studio/Dockerfile -t prodgy-studio .

# Gateway
docker build -f apps/gateway/Dockerfile -t prodgy-gateway .

# Agentic
docker build -f apps/agentic/Dockerfile -t prodgy-agentic .

# Engine
docker build -f Dockerfile.engine -t prodgy-engine .

Docker Compose (Desenvolvimento Local)

O docker-compose.yml na raiz do projeto configura os serviços auxiliares para desenvolvimento local:

docker compose up -d

Serviços inclusos:

Redis (porta 6379) — broker de filas e cache
Redis Commander (porta 8081) — interface web para monitoramento
Engine (porta 8001) — motor de IA

Pipeline CI/CD

O Prodgy utiliza Azure DevOps Pipelines com detecção automática de mudanças:

Ambientes

Ambiente	Trigger	Branch
Development	Push automático	`main`
Staging	Push automático	`staging`
Production	Tag `v*`	Git tags

Detecção de Mudancas

O pipeline verifica quais serviços foram alterados e faz build/deploy apenas dos afetados:

Mudança em	Serviços Afetados
`apps/api/`	Apenas API
`apps/web/`	Apenas Web
`apps/service/`	Apenas Service
`apps/studio/`	Apenas Studio
`apps/gateway/`	Apenas Gateway
`apps/agentic/`	Apenas Agentic
`apps/engine/` ou `Dockerfile.engine`	Apenas Engine
`apps/assistant/`	Apenas Assistant
`packages/`, `pnpm-lock.yaml`, `turbo.json`	Todos os serviços Node.js

Variáveis por Ambiente

Cada ambiente requer um Variable Group no Azure DevOps com:

azureServiceConnection         # Conexão Azure RM
resourceGroup                  # Resource Group
containerRegistry              # Nome do Container Registry
registryLoginServer            # URL do Registry
apiContainerAppName            # Container App da API
serviceContainerAppName        # Container App do Service
webContainerAppName            # Container App do Web
studioContainerAppName         # Container App do Studio
gatewayContainerAppName        # Container App do Gateway
agenticContainerAppName        # Container App do Agentic
engineContainerAppName         # Container App do Engine
AZURE_STATIC_WEB_APP_API_TOKEN # Token do Static Web App
VM_IP                          # IP da VM Windows (Assistant)
VM_USER                        # Usuário da VM
VM_PASSWORD                    # Senha da VM (segredo)

Deploy do Assistant (VM Windows)

O serviço Assistant requer deploy especial em VM Windows:

O pipeline compila o projeto .NET
Gera um artefato compactado
Conecta na VM via WinRM (PowerShell remoting)
Para o serviço via NSSM
Substitui os arquivos (preservando appsettings.Production.json)
Reinicia o serviço

Checklist de Deploy

Pre-Deploy

Variáveis de ambiente configuradas para o ambiente alvo
Tokens de serviço gerados (únicos por ambiente)
Banco de dados PostgreSQL/Supabase provisionado
Redis provisionado e acessível
DNS configurado para serviços públicos
Certificados SSL emitidos
CORS configurado na API com as origens corretas

Pos-Deploy

Health check dos serviços (API, Engine, Service, Gateway, Agentic)
Teste de autenticação (login, JWT, API tokens)
Teste de comunicação entre serviços
Verificar conexão com banco de dados
Verificar conexão com Redis
Testar Playground (envio de mensagem a um agente)
Verificar logs de cada serviço