Operação e Deploy

from contextlib import asynccontextmanager

_active_tasks: set[asyncio.Task] = set()
_shutting_down = False


@asynccontextmanager
async def lifespan(app):
    yield
    global _shutting_down
    _shutting_down = True
    if _active_tasks:
        logger.info("Aguardando %d task(s) ativas...", len(_active_tasks))
        # 25s de timeout: deixa margem para overhead após as tasks terminarem.
        # stop_timeout no task definition deve ser 120s — bem acima disso.
        await asyncio.wait(_active_tasks, timeout=25.0)


@app.post("/agents/invoke")
async def invoke(body: InvokeRequest):
    if _shutting_down:
        raise HTTPException(status_code=503, detail="Em manutenção.")
    task = asyncio.current_task()
    _active_tasks.add(task)
    try:
        return await run_agent(body.thread_id, body.input)
    finally:
        _active_tasks.discard(task)

resource "aws_ecs_task_definition" "agent" {
  container_definitions = jsonencode([{
    name        = "agent"
    stopTimeout = 120  # segundos entre SIGTERM e SIGKILL — deve ser >= max exec time
  }])
}

resource "aws_lb_target_group" "agent" {
  deregistration_delay = 100  # ALB drena conexões antes de remover o target
  # Deve ser ligeiramente menor que stop_timeout — deixa o processo terminar limpo
  health_check { path = "/health"; interval = 10; healthy_threshold = 2 }
}

resource "aws_ecs_service" "agent" {
  deployment_controller { type = "CODE_DEPLOY" }
  load_balancer {
    target_group_arn = aws_lb_target_group.blue.arn
    container_name   = "agent"; container_port = 8000
  }
  # lifecycle: CodeDeploy gerencia a alternância — Terraform não deve interferir
  lifecycle { ignore_changes = [task_definition, load_balancer] }
}

resource "aws_lb_target_group" "blue" {
  name                 = "agent-blue"; port = 8000
  protocol             = "HTTP"; target_type = "ip"; vpc_id = var.vpc_id
  deregistration_delay = 100
  health_check { path = "/health"; interval = 10 }
}

resource "aws_lb_target_group" "green" {
  name                 = "agent-green"; port = 8000
  protocol             = "HTTP"; target_type = "ip"; vpc_id = var.vpc_id
  deregistration_delay = 100
  health_check { path = "/health"; interval = 10 }
}

# Listener de produção: tráfego real → BLUE (CodeDeploy alterna para GREEN)
resource "aws_lb_listener" "prod" {
  load_balancer_arn = aws_lb.main.arn; port = 443; protocol = "HTTPS"
  default_action { type = "forward"; target_group_arn = aws_lb_target_group.blue.arn }
}

# Listener de teste: smoke tests acessam GREEN antes da troca
resource "aws_lb_listener" "test" {
  load_balancer_arn = aws_lb.main.arn; port = 8080; protocol = "HTTP"
  default_action { type = "forward"; target_group_arn = aws_lb_target_group.green.arn }
}

resource "aws_codedeploy_deployment_group" "agent" {
  deployment_config_name = "CodeDeployDefault.ECSAllAtOnce"
  ecs_service { cluster_name = aws_ecs_cluster.main.name; service_name = aws_ecs_service.agent.name }
  load_balancer_info {
    target_group_pair_info {
      prod_traffic_route { listener_arns = [aws_lb_listener.prod.arn] }
      test_traffic_route { listener_arns = [aws_lb_listener.test.arn] }
      target_group { name = aws_lb_target_group.blue.name }
      target_group { name = aws_lb_target_group.green.name }
    }
  }
  auto_rollback_configuration {
    enabled = true
    events  = ["DEPLOYMENT_FAILURE", "DEPLOYMENT_STOP_ON_ALARM"]
  }
}

version: 0.0
Resources:
  - TargetService:
      Type: AWS::ECS::Service
      Properties:
        TaskDefinition: "<TASK_DEFINITION>"
        LoadBalancerInfo:
          ContainerName: "agent"
          ContainerPort: 8000
Hooks:
  - BeforeAllowTraffic: "SmokTestsHook"   # valida GREEN antes da troca
  - AfterAllowTraffic: "MonitoringHook"    # monitora métricas pós-troca

import httpx, sys

TEST_ENDPOINT = "http://alb-dns:8080"  # test listener — acessa GREEN diretamente

checks = [
    ("/health",                200),
    ("/health/circuit-breakers", 200),
    ("/health/bulkheads",      200),
]

for path, expected in checks:
    resp = httpx.get(f"{TEST_ENDPOINT}{path}", timeout=10)
    if resp.status_code != expected:
        print(f"FAIL: {path} → {resp.status_code} (esperado {expected})")
        sys.exit(1)
    print(f"OK: {path}")

print("Smoke tests passaram. Liberando tráfego para GREEN.")

resource "aws_codedeploy_deployment_group" "canary" {
  # 10% do tráfego por 5 minutos, depois 100% se métricas OK
  deployment_config_name = "CodeDeployDefault.ECSCanary10Percent5Minutes"

  auto_rollback_configuration {
    enabled = true
    events  = ["DEPLOYMENT_FAILURE", "DEPLOYMENT_STOP_ON_ALARM"]
  }

  alarm_configuration {
    enabled = true
    alarms  = [aws_cloudwatch_metric_alarm.error_rate.name,
               aws_cloudwatch_metric_alarm.p99_latency.name]
  }
}

resource "aws_cloudwatch_metric_alarm" "error_rate" {
  alarm_name          = "agent-5xx-canary"
  metric_name         = "HTTPCode_Target_5XX_Count"
  namespace           = "AWS/ApplicationELB"
  comparison_operator = "GreaterThanThreshold"
  evaluation_periods  = 2; period = 60; statistic = "Sum"; threshold = 10
}

resource "aws_cloudwatch_metric_alarm" "p99_latency" {
  alarm_name          = "agent-p99-canary"
  metric_name         = "TargetResponseTime"
  namespace           = "AWS/ApplicationELB"
  comparison_operator = "GreaterThanThreshold"
  evaluation_periods  = 2; period = 60; extended_statistic = "p99"; threshold = 3
}

resource "aws_ecs_service" "agent" {
  deployment_controller { type = "ECS" }

  # circuit_breaker: rollback automático se health checks falharem.
  # Evita que uma versão quebrada continue sendo deployada.
  deployment_circuit_breaker { enable = true; rollback = true }

  # Com desired_count=3:
  # maximum_percent=150 → pode ter até 4 tasks durante o deploy
  # minimum_healthy_percent=100 → nunca cai abaixo de 3 tasks saudáveis
  deployment_maximum_percent         = 150
  deployment_minimum_healthy_percent = 100
}

# No booking-agent v2: sinaliza que espera v2
headers = {
    "Authorization":   f"Bearer {token}",
    "X-API-Version":   "v2",
    "X-Min-API-Version": "v1",  # aceita v1 também — backward compat
}

# No search-agent v2: responde com a versão solicitada
@app.post("/search/invoke")
async def search_invoke(request: Request, body: SearchRequest):
    requested = request.headers.get("X-API-Version", "v1")
    result    = await run_search_graph(body)
    # Suporta v1 e v2 durante a janela de migração.
    # Após booking-agent v2 estável e nenhum v1 em produção: remova o branch v1.
    return format_response_v1(result) if requested == "v1" else format_response_v2(result)

jobs:
  deploy-booking-v2:
    steps:
      - name: Deploy booking-agent v2
        run: aws deploy create-deployment --deployment-group booking-agent-dg ...
      - name: Aguarda estabilização (15min)
        run: sleep 900
      - name: Valida métricas
        run: python scripts/validate_metrics.py --service booking-agent

  deploy-search-v2:
    needs: deploy-booking-v2  # só após consumidor estável
    steps:
      - name: Deploy search-agent v2
        run: aws deploy create-deployment --deployment-group search-agent-dg ...
      - name: Aguarda estabilização (15min)
        run: sleep 900

  remove-v1-compat:
    needs: deploy-search-v2
    steps:
      - name: Deploy search-agent v2.1 (remove compat v1)
        run: aws deploy create-deployment --deployment-group search-agent-dg ...