Implementar DevOps não é sobre instalar Jenkins e torcer pro melhor. É sobre criar um fluxo que permita sua equipe entregar software de forma confiável e rápida. Vou te mostrar como a gente estrutura um pipeline CI/CD completo aqui na Bolsoni Tech.
Por onde começar
Antes de sair instalando ferramentas, você precisa mapear seu fluxo atual. Quantos ambientes você tem? Como o código chega em produção hoje? Quais são os gargalos?
Um cliente nosso levava 3 semanas pra fazer um deploy simples. O problema não era técnico, era processo. Eles tinham 15 aprovações manuais e nenhuma automação.
Defina seus ambientes primeiro:
- Development: onde os devs trabalham
- Staging: espelho da produção pra testes
- Production: onde seus usuários estão
Estruturando o pipeline
Um pipeline CI/CD básico tem 4 etapas essenciais: build, test, deploy staging e deploy production. Vamos usar GitLab CI como exemplo prático.
stages:
- build
- test
- deploy-staging
- deploy-production
variables:
DOCKER_IMAGE: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
build:
stage: build
script:
- docker build -t $DOCKER_IMAGE .
- docker push $DOCKER_IMAGE
only:
- develop
- main
unit-tests:
stage: test
script:
- docker run --rm $DOCKER_IMAGE npm test
coverage: '/Coverage: \d+\.\d+%/'
deploy-staging:
stage: deploy-staging
script:
- kubectl set image deployment/app app=$DOCKER_IMAGE -n staging
only:
- develop
deploy-production:
stage: deploy-production
script:
- kubectl set image deployment/app app=$DOCKER_IMAGE -n production
only:
- main
when: manualInfraestrutura como código
Não adianta automatizar deploy se sua infraestrutura é criada na mão. Use Terraform pra versionar tudo.
resource "aws_ecs_cluster" "main" {
name = "production-cluster"
setting {
name = "containerInsights"
value = "enabled"
}
}
resource "aws_ecs_service" "app" {
name = "app-service"
cluster = aws_ecs_cluster.main.id
task_definition = aws_ecs_task_definition.app.arn
desired_count = 2
deployment_configuration {
maximum_percent = 200
minimum_healthy_percent = 100
}
}Guarde seus states do Terraform no S3 com lock no DynamoDB. Nunca deixe state local quando tem mais de uma pessoa mexendo na infra.
Testes automatizados
Pipeline sem testes é entrega rápida de bugs. Implemente pelo menos três camadas:
Testes unitários: rodam a cada commit
#!/bin/bash
npm test -- --coverage --watchAll=false
if [ $? -ne 0 ]; then
echo "Testes falharam"
exit 1
fiTestes de integração: validam APIs e banco
Testes de aceitação: simulam fluxos reais com Cypress ou Selenium
Pro staging, a gente sempre roda smoke tests depois do deploy:
#!/bin/bash
echo "Testando health check..."
curl -f https://staging.app.com/health || exit 1
echo "Testando login..."
response=$(curl -s -w "%{http_code}" -X POST https://staging.app.com/login -d '{"user":"test","pass":"123"}')
if [[ $response != *"200" ]]; then
exit 1
fiMonitoramento e observabilidade
Deploy sem monitoramento é tiro no escuro. Configure Grafana, Prometheus e alertas desde o primeiro dia.
Crie dashboards pra métricas críticas:
- Tempo de resposta das APIs
- Taxa de erro por endpoint
- Uso de CPU e memória
- Throughput de requests
Configure alertas no Slack ou Teams quando algo quebrar. A gente usa essa query no Prometheus pra detectar problemas:
groups:
- name: app.rules
rules:
- alert: HighErrorRate
expr: rate(http_requests_total{status=~"5.."}[5m]) > 0.1
for: 2m
annotations:
summary: "Alta taxa de erro na aplicação"
description: "{{ $labels.instance }} está com {{ $value }} erros por segundo"Segurança no pipeline
Integre verificações de segurança direto no CI. Use ferramentas como Snyk pra dependencies e SonarQube pra code quality.
security-scan:
stage: test
script:
- snyk test --severity-threshold=high
- sonar-scanner -Dsonar.projectKey=$CI_PROJECT_NAME
allow_failure: falseRollback automático
Quando algo der errado em produção, você precisa voltar rápido. Configure health checks que detectem problemas e façam rollback automático.
#!/bin/bash
echo "Aguardando deploy estabilizar..."
sleep 30
for i in {1..5}; do
if curl -f https://app.com/health; then
echo "Deploy OK"
exit 0
fi
echo "Tentativa $i falhou, aguardando..."
sleep 10
done
echo "Deploy falhou, fazendo rollback"
kubectl rollout undo deployment/app -n productionCaso real
Recentemente ajudamos uma fintech a reduzir o tempo de deploy de 4 horas pra 15 minutos. O segredo foi automatizar os testes de regressão que eles faziam manualmente e criar ambientes efêmeros pra cada feature branch.
Usamos AWS ECS com Fargate pra escalar automaticamente e Terraform pra gerenciar tudo. O resultado: 10x mais deploys por semana com zero incidentes de produção.
Lembre-se: DevOps é jornada, não destino. Comece simples, meça resultados e melhore continuamente. A automação tem que resolver problemas reais, não criar complexidade desnecessária.
