AWS Builder Center
Observabilidade, CI/CD e Estratégias de Deploy: O Que Todo Senior .NET AWS Precisa Dominar

Observabilidade, CI/CD e Estratégias de Deploy: O Que Todo Senior .NET AWS Precisa Dominar

Feature Toggles, Blue/Green, Canary Deployments, Terraform, GitHub Actions e monitoramento com CloudWatch, Grafana e X-Ray.

Senior Software Engineer .NET/AWS

PARTE 3 — Observabilidade, CI/CD e Estratégias de Deploy: O Que Todo Senior .NET AWS Precisa Dominar

Infraestrutura como Código com Terraform

Infraestrutura gerenciada manualmente no console AWS é uma dívida técnica silenciosa. Terraform transforma a infraestrutura em código versionável, revisável e reproduzível:
hcl
# main.tf — ECS Service para API .NET
resource "aws_ecs_service" "orders_api" {
name = "orders-api"
cluster = aws_ecs_cluster.main.id
task_definition = aws_ecs_task_definition.orders_api.arn
desired_count = 2
launch_type = "FARGATE"

network_configuration {
subnets = var.private_subnet_ids
security_groups = [aws_security_group.orders_api.id]
assign_public_ip = false
}

load_balancer {
target_group_arn = aws_lb_target_group.orders_api.arn
container_name = "orders-api"
container_port = 8080
}
}
A estrutura recomendada para projetos AWS com Terraform separa ambientes por workspace e mantém módulos reutilizáveis:
infra/
├── modules/
│ ├── ecs-service/
│ ├── rds/
│ └── api-gateway/
├── environments/
│ ├── staging/
│ └── production/
└── main.tf

CI/CD com GitHub Actions

Um pipeline maduro para .NET na AWS cobre build, testes, análise de segurança e deploy — tudo automatizado e bloqueante:
yaml
name: Deploy Orders API

on:
push:
branches: [main]

jobs:
build-and-test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4

- name: Setup .NET 8
uses: actions/setup-dotnet@v4
with:
dotnet-version: '8.0.x'

- name: Restore & Build
run: dotnet build --configuration Release

- name: Run Tests
run: dotnet test --configuration Release --collect:"XPlat Code Coverage"

deploy:
needs: build-and-test
runs-on: ubuntu-latest
steps:
- name: Configure AWS Credentials
uses: aws-actions/configure-aws-credentials@v4
with:
role-to-assume: ${{ secrets.AWS_DEPLOY_ROLE_ARN }}
aws-region: us-east-1

- name: Build & Push to ECR
run: |
aws ecr get-login-password | docker login --username AWS \
--password-stdin $ECR_REGISTRY
docker build -t orders-api .
docker tag orders-api:latest $ECR_REGISTRY/orders-api:$GITHUB_SHA
docker push $ECR_REGISTRY/orders-api:$GITHUB_SHA

- name: Deploy to ECS
run: |
aws ecs update-service \
--cluster production \
--service orders-api \
--force-new-deployment

Estratégias de deploy: Blue/Green, Canary e A/B

Deployar em produção sem estratégia é o maior risco operacional de um time de engenharia. As três abordagens principais têm casos de uso distintos:
Blue/Green: dois ambientes idênticos. O tráfego é transferido inteiramente do ambiente atual (Blue) para o novo (Green) em um único switch. Rollback é instantâneo — basta reverter o switch. No AWS CodeDeploy com ECS, isso é configurável nativamente.
Canary: o novo código recebe uma porcentagem pequena do tráfego (ex.: 5%) antes do rollout completo. Permite detectar erros em produção real com impacto mínimo. No API Gateway, o stage canary funciona assim:
aws apigateway update-stage \
--rest-api-id abc123 \
--stage-name production \
--patch-operations \
op=replace,path=/canarySettings/percentTraffic,value=5
A/B Testing: diferente do Canary (que é sobre segurança de deploy), A/B é sobre validação de hipóteses de produto. Usuários do segmento A veem a versão atual; segmento B veem a nova. Feature Toggles + CloudWatch são a combinação correta para medir qual versão performa melhor.

Observabilidade: CloudWatch, X-Ray, Grafana e Splunk

Um sistema não observável é um sistema não operável. A stack de observabilidade AWS-nativa para .NET cobre três pilares:
Logs estruturados com CloudWatch:
// Serilog → CloudWatch
Log.Logger = new LoggerConfiguration()
.Enrich.WithProperty("Service", "orders-api")
.Enrich.WithProperty("Environment", env)
.WriteTo.AmazonCloudWatch(new CloudWatchSinkOptions {
LogGroupName = "/dotnet/orders-api",
TextFormatter = new JsonFormatter()
})
.CreateLogger();
Rastreamento distribuído com X-Ray: instrumentar o SDK do X-Ray no .NET adiciona trace IDs propagados automaticamente entre serviços, SQS, DynamoDB e Lambda — permitindo visualizar exatamente onde uma requisição passou e quanto tempo levou em cada salto.
Dashboards com Grafana: o Amazon Managed Grafana conecta diretamente a CloudWatch, X-Ray e Prometheus. Um dashboard de saúde de microsserviços deve cobrir no mínimo: latência p50/p95/p99, taxa de erro por endpoint, throughput (req/s), utilização de CPU/memória por container e profundidade de filas SQS.
Splunk e AppDynamics entram quando o requisito é correlacionar logs de sistemas heterogêneos (não apenas AWS) ou quando a empresa já tem investimento consolidado nessas plataformas para APM.

O perfil completo: o que conecta tudo isso

A jornada de um desenvolvedor .NET sênior na AWS não é sobre conhecer cada serviço isoladamente — é sobre conectar as peças. Clean Architecture garante que o código de negócio não vaza para a infraestrutura. DDD garante que as fronteiras de serviço fazem sentido para o negócio. Mensageria com SQS/SNS/Kafka garante que os serviços se comunicam sem acoplamento. Terraform garante que a infraestrutura é reproduzível. GitHub Actions garante que o código chega à produção de forma segura. E observabilidade com CloudWatch, X-Ray e Grafana garante que o que está em produção pode ser entendido e corrigido rapidamente.
Esse conjunto de habilidades não surge de tutoriais isolados. Surge da prática em sistemas reais, com pressão de produção, decisões de arquitetura com trade-offs reais e retrospectivas honestas sobre o que funcionou e o que não funcionou.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article