AWS HubAWS HubSão Paulo operando · 2 eventos no mundo

Agentes de códigoComunidade

Nível de dificuldade: Avançado (4 de 5)

NexOps: agente da Strands e Bedrock responde perguntas sobre infraestrutura AWS por chat

Por AWS Hub8 min de leitura
NexOps: agente da Strands e Bedrock responde perguntas sobre infraestrutura AWS por chat
NexOps: agente da Strands e Bedrock responde perguntas sobre infraestrutura AWS por chat

Quem opera ambientes AWS conhece a rotina: um alerta dispara, e antes de entender a causa é preciso abrir o console do EC2, depois o CloudWatch, depois o CloudTrail, depois o IAM, só para montar o quadro completo. O NexOps, documentado pelo AWS Community Builder autor do repositório strands-cloudops-agent no GitHub (usuário dasanirban834) e publicado como artigo na DEV Community, propõe outra rota: perguntar em português (ou inglês) e deixar um agente buscar a evidência nos serviços certos.

Este é um tutorial de mão na massa para quem desenha e opera infraestrutura, seja no papel de arquiteto de soluções, seja no de DevOps/SRE que também lida com agentes de código em produção e com o deploy da esteira que sustenta esses agentes. O artigo original explica a arquitetura e o fluxo; aqui o foco é reconstruir o caminho prático de implantação, com os pontos onde a configuração padrão do repositório precisa ser revisada antes de ir para produção.

O que você vai construir

O NexOps é um assistente conversacional de CloudOps: uma interface web estática conversa com um backend FastAPI que, a cada requisição de chat, cria um agente novo usando o framework Strands Agents, aponta esse agente para um modelo no Amazon Bedrock e dá a ele um conjunto de ferramentas Python construídas sobre Boto3. Cada ferramenta cobre um recorte específico de um serviço AWS: inventário de EC2, métricas e alarmes do CloudWatch, eventos do CloudTrail, compliance do AWS Config, inspeção de IAM, custo via Cost Explorer, entre outros.

A infraestrutura é toda definida em Terraform: ECS Fargate roda o frontend (NGINX) e o backend (FastAPI/Strands); um Application Load Balancer público atende o frontend; um Application Load Balancer interno recebe o tráfego de chat vindo de uma API HTTP do Amazon API Gateway através de um VPC Link; e o modelo de inferência roda no Bedrock, com us.amazon.nova-micro-v1:0 como BEDROCK_MODEL_ID padrão no código do orquestrador.

Na prática, o caso de uso que a própria fonte descreve é simples: o operador pergunta algo como "liste as instâncias EC2 em execução, com nome e tipo", e o agente escolhe a ferramenta list_ec2_instances, chama a API via Boto3 com a identidade do papel IAM da tarefa ECS, e devolve um resumo com o escopo e a região consultados. O agente não é um executor genérico de comandos AWS: não há ferramenta de escrita em IAM, nem exclusão de recursos, nem shell arbitrário.

Pré-requisitos

Antes de clonar o repositório, é preciso ter pronto:

  • Conta AWS com acesso habilitado ao modelo do Bedrock configurado (us.amazon.nova-micro-v1:0 por padrão, ou outro BEDROCK_MODEL_ID da sua escolha) na região definida em BEDROCK_REGION.
  • Um bucket S3 já existente para armazenar o state do Terraform via backend remoto; os módulos não criam esse bucket, apenas o usam.
  • Papéis IAM que o Terraform busca por lookup (não cria), além do papel de execução do ECS (para pull de imagem no ECR e envio de logs) e do papel de tarefa do backend, que deve receber apenas as permissões de leitura dos serviços cujas ferramentas você vai habilitar (por exemplo ec2:Describe*, cloudwatch:Get* e cloudwatch:List*, iam:Get* e iam:List*, ce:GetCostAndUsage), seguindo o princípio de menor privilégio.
  • Docker, Terraform e a AWS CLI configurados localmente, mais acesso a dois repositórios Amazon ECR (frontend e backend) para publicar as imagens.
  • VPC com subnets privadas para as tarefas ECS e para o caminho interno do backend, já que o tráfego de chat passa por um ALB interno, não exposto à internet.

Passo a passo

  1. Clone o repositório e revise a árvore de pastas: Backend/ concentra o FastAPI, o orquestrador Strands (agent/orchestrator.py) e as ferramentas (tools/); Backend/Backend_Infra/ e Frontend/Frontend_Infra/ têm os módulos Terraform separados.
bash
git clone https://github.com/dasanirban834/strands-cloudops-agent.git
cd strands-cloudops-agent
  1. Configure o backend copiando Backend/.env.example e ajustando as variáveis de modelo. O trecho relevante do orquestrador mostra como essas variáveis viram o modelo Bedrock entregue ao agente:
python
model_id = os.getenv("BEDROCK_MODEL_ID", "us.amazon.nova-micro-v1:0").strip()
bedrock_region = os.getenv("BEDROCK_REGION", os.getenv("AWS_REGION", "us-east-1")).strip()
model = BedrockModel(
 model_id=model_id,
 region_name=bedrock_region,
 max_tokens=int(os.getenv("BEDROCK_MAX_TOKENS", "2048")),
)
return Agent(model=model, tools=TOOLS, system_prompt=SYSTEM_PROMPT, name="cloudops-agent")
  1. Construa a imagem do backend a partir de Backend/Dockerfile.backend, que instala as dependências e sobe o FastAPI com Uvicorn na porta 8000:
dockerfile
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt ./requirements.txt
RUN python -m pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "1"]
  1. Construa a imagem do frontend a partir de Frontend/Dockerfile.frontend. O NGINX serve os arquivos estáticos e faz proxy de /api/chat para o valor de API_GATEWAY_URL injetado no container:
dockerfile
FROM nginx:alpine
COPY cloudopsweb/nginx.conf /etc/nginx/templates/default.conf.template
COPY cloudopsweb/index.html /usr/share/nginx/html/
COPY cloudopsweb/styles.css /usr/share/nginx/html/
COPY cloudopsweb/app.js /usr/share/nginx/html/
EXPOSE 8080
CMD ["nginx", "-g", "daemon off;"]
  1. Antes de publicar as imagens, ajuste os controles operacionais. A fonte é explícita: o Terraform do backend, como está no repositório, já habilita o gate de mutação para uma conta e região específicas e não configura autenticação de produção, além de deixar o CORS da API Gateway apontando para http://localhost. Esses três pontos precisam ser revisados e substituídos por valores do seu ambiente antes de qualquer deploy compartilhado.
  1. Publique as imagens nos repositórios ECR do frontend e do backend (o Terraform já habilita scanning de imagem no push):
bash
aws ecr get-login-password --region sa-east-1 | docker login --username AWS --password-stdin <conta>.dkr.ecr.sa-east-1.amazonaws.com
docker build -t cloudops-backend -f Backend/Dockerfile.backend Backend/
docker tag cloudops-backend:latest <conta>.dkr.ecr.sa-east-1.amazonaws.com/cloudops-backend:latest
docker push <conta>.dkr.ecr.sa-east-1.amazonaws.com/cloudops-backend:latest
  1. Aplique os módulos Terraform, primeiro o do backend e depois o do frontend, revisando os papéis e recursos de rede que são apenas consultados (lookup) e não criados:
bash
cd Backend/Backend_Infra && terraform init && terraform apply
cd ../../Frontend/Frontend_Infra && terraform init && terraform apply
  1. Confira os security groups que o Terraform cria, porque eles definem a topologia de confiança entre frontend, VPC Link e backend:
Security GroupEntrada permitidaPapel
Public-CloudOps-Webapp-LBHTTPS de qualquer origemALB público do frontend
CloudOps-Web-AppTCP 8080 vindo do ALB públicoTarefa ECS do frontend
cloudops-vpc-link-sgHTTPS vindo da tarefa do frontendVPC Link do API Gateway
InternalALBSGHTTPS vindo do VPC LinkALB interno do backend
StrandsAgentSGTCP 8000 vindo do ALB internoTarefa ECS do backend

Testando

Comece pelo endpoint /health do backend: ele responde liveness sem chamar Bedrock nem qualquer API AWS, então é o primeiro sinal de que o container subiu, não de que o agente funciona. Confirme que as tarefas ECS do frontend e do backend ficaram saudáveis nos target groups dos dois ALBs antes de seguir.

Com o frontend acessível pelo ALB público, envie uma pergunta somente de leitura, como no exemplo que a própria documentação usa: pedir a lista de instâncias em execução com nome e tipo. A requisição sai do frontend para a rota de chat do API Gateway, atravessa o VPC Link até o ALB interno e chega ao FastAPI, que monta um agente novo, escolhe a ferramenta list_ec2_instances e devolve o resumo com a região e o escopo verificados.

Se a tarefa de IAM da ECS tiver sido liberada para operações aprovadas de ciclo de vida do EC2 (start_ec2_instance, stop_ec2_instance, reboot_ec2_instance) ou para ações restritas do Systems Manager, teste essas por último e em ambiente que não seja de produção. A fonte descreve que uma ação aceita é reportada como "submetida" até que uma checagem de verificação confirme o estado resultante — então vale repetir a pergunta ao agente depois de alguns segundos para confirmar se a instância realmente parou ou reiniciou.

Vale lembrar que o backend não persiste histórico de conversa entre requisições: cada chat cria um agente do zero, então perguntas de acompanhamento que dependem de contexto anterior não funcionam como em um chat convencional.

Limpando os recursos

Rode terraform destroy nos dois módulos, na ordem inversa da aplicação, para não deixar o ALB interno ou o VPC Link órfãos:

bash
cd Frontend/Frontend_Infra && terraform destroy
cd ../../Backend/Backend_Infra && terraform destroy

Depois, apague as imagens nos repositórios ECR do frontend e do backend (o terraform destroy não remove, por padrão, as imagens já publicadas) e confirme que os grupos de log do CloudWatch Logs associados às tarefas ECS não ficaram ativos sem necessidade. Revise também se o bucket S3 usado como backend remoto do Terraform guarda apenas o state deste projeto antes de decidir apagar objetos dele.

A fonte não traz valores de preço, mas vale o alerta: enquanto as tarefas ECS Fargate, os dois Application Load Balancers e a API Gateway HTTP API estiverem no ar, eles geram cobrança por hora e por uso, fora do Free Tier assim que o ambiente sair do nível experimental — confirme os valores atuais na calculadora de preços da AWS para sa-east-1 antes de deixar o ambiente de pé por muito tempo.

Próximos passos

Antes de expor o NexOps a qualquer cliente que não seja sua própria máquina, troque o CORS da API Gateway, hoje fixado em http://localhost no Terraform do repositório, pelo domínio real do frontend, e ative autenticação de API em vez do modo sem autenticação usado no exemplo. O gate de mutação, hoje habilitado para uma conta e região fixas no código de exemplo, deveria virar uma lista de permissão explícita revisada por quem responde pelo ambiente, incluindo os documentos do Systems Manager liberados.

Quem já opera pipelines de deploy pode tratar os dois módulos Terraform (Backend_Infra e Frontend_Infra) como qualquer outro componente de infraestrutura como código: versionados, com plano revisado em pull request e aplicados por esteira, não manualmente. E para quem pensa em agentes de código como parte permanente da operação, vale avaliar troca de modelo (o BEDROCK_MODEL_ID é só uma variável de ambiente) e observar o custo por invocação do Bedrock conforme o volume de perguntas cresce, já que cada chat aciona uma nova instância de agente.

Fonte: DEV Community — AWS Community Builders

Serviços neste textoAgentes de códigoDeploy

Leve para a sua IA

Decida com o seu assistente, com o contexto deste texto já montado.

1. O que você quer saber

Ver o prompt
Li no AWS Hub: "NexOps: agente da Strands e Bedrock responde perguntas sobre infraestrutura AWS por chat" (https://awshub.com.br/comunidade/nexops-agente-da-strands-e-bedrock-responde-perguntas-sobre-infraestrutura-aws-p).
Resumo: Um projeto open source mostra como montar, com Strands Agents, Amazon Bedrock e Terraform, um assistente que consulta EC2, CloudWatch, IAM e custo em linguagem natural, com permissões controladas pelo IAM.
Serviços: Agentes de código, Deploy

Minha stack: [descreva em uma linha: serviços, linguagem, volume, região]

Isso muda alguma coisa na minha arquitetura? O que eu faria diferente a partir de amanhã?

Newsletter semanal

A semana da AWS, em português

Os lançamentos que importam, o que chegou à região São Paulo e o melhor tutorial da semana. Toda sexta, gratuita.