View a markdown version of this page

Automatize a geração de eventos de teste do Lambda usando o Amazon Bedrock AgentCore - Recomendações da AWS
ResumoPré-requisitos e limitaçõesArquiteturaFerramentasPráticas recomendadasÉpicosSolução de problemasRecursos relacionados

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Automatize a geração de eventos de teste do Lambda usando o Amazon Bedrock AgentCore

Ishita Gupta e Kriti Gupta, Amazon Web Services

Resumo

Esse padrão oferece uma AI-powered abordagem para gerar automaticamente casos de teste abrangentes para AWS Lambda funções usando os recursos generativos de IA do Amazon Bedrock. Esse padrão implementa uma arquitetura de três agentes (Analyzer, Generator e Validator) implantada no Amazon Bedrock AgentCore que analisa o código real da função Lambda para extrair input/output padrões e gera cenários de teste positivos, negativos e extremos com dados realistas.

A arquitetura estabelece um fluxo de trabalho inteligente em que o Analyzer Agent busca e analisa o código Lambda usando o Amazon Bedrock, o Generator Agent cria casos de teste com base nos padrões aprendidos e o Validator Agent garante a qualidade por meio da desduplicação e classificação. Um armazenamento de DynamoDB-based memória da Amazon permite o aprendizado contínuo a partir do feedback do usuário, melhorando a precisão da geração de testes ao longo do tempo. O Amazon Cognito fornece autenticação segura de usuários com autorização de API baseada em JSON Web Token (JWT). O Amazon Bedrock Guardrails fornece filtragem imediata de ataques, redação de informações confidenciais e fiscalização da segurança de conteúdo em todas as chamadas de API do Amazon Bedrock. Principais recursos:

  • Multi-Language Suporte: funções Python, Java, C# e Ruby Lambda JavaScript/TypeScript

  • Fragmentação inteligente de código: divide automaticamente grandes bases de código em blocos gerenciáveis para análise

  • Processamento paralelo: a API Amazon Bedrock simultânea exige uma geração de testes mais rápida (5 trabalhadores simultâneos para análise de código, geração de testes paralelos por bloco)

  • Target-Specific Análise: concentre-se em funções, classes ou arquivos específicos dentro do código Lambda

  • Aprendizado de padrões: armazenamento DynamoDB-based de memória Amazon com armazenamento de padrões global e específico para o alvo

  • Evitar rejeição: aprende com casos de teste rejeitados para evitar erros comuns

  • Mecanismo de continuação: lida com respostas incompletas do Amazon Bedrock com continuação automática.

  • Ignorar padrões: exclua arquivos de teste, dependências e arquivos não codificados da análise.

  • Implantação sem servidor: é executada no Amazon Bedrock com autenticação AgentCore Cognito-based

  • Proteções de segurança: Amazon Bedrock Guardrails para filtragem imediata de ataques, redação de informações de identificação pessoal (PII), segurança de conteúdo e bloqueio de tópicos negado em todas as chamadas de IA

    Esse padrão é ideal para equipes de desenvolvimento e organizações que desejam acelerar os testes do Lambda, melhorar a cobertura dos testes e manter a alta qualidade do código por meio da geração de AI-assisted testes. Esse padrão usa os serviços gerenciados da AWS para simplificar a criação de testes, melhorar a qualidade por meio do aprendizado e escalar para atender às crescentes necessidades de testes.

Pré-requisitos e limitações

Pré-requisitos

Para implementar esse padrão com sucesso, verifique se o seguinte está em vigor:

  • Uma conta ativa da AWS — uma conta da AWS com permissões para acessar funções do Lambda, invocar modelos do Amazon Bedrock, criar tabelas do DynamoDB, gerenciar grupos de usuários do Cognito e implantar agentes do Amazon Bedrock. AgentCore

  • Acesso ao modelo Amazon Bedrock — Anthropic Claude Sonnet 4 (us.anthropic.claude-sonnet-4-6) habilitado em sua região da AWS. Para obter instruções de configuração, consulte Acesso ao modelo na documentação do Amazon Bedrock.

  • Um ambiente de desenvolvimento que consiste em:

    - Python 3.11 ou superior

    - AWS CLI instalada e configurada

    - Git para clonar o repositório

  • Funções do AWS Lambda — Pelo menos uma função do Lambda implantada com código-fonte acessível para análise. A função deve incluir arquivos de origem (.py, .js, .java, .cs, .rb) no pacote de implantação, não apenas o bytecode compilado.

  • Tempos de execução do Lambda compatíveis:

    - Python 3.x (todas as versões)

    - Node.js (JavaScript/TypeScript)

    - Java 8, 11, 17, 21 (requer arquivos de origem.java no pacote de implantação)

    - .NET Core/.NET 6+ (C#) (requer arquivos de origem.cs no pacote de implantação)

    - Rubi 2.7, 3.2

Limitações

  • Isso requer acesso ao modelo Amazon Bedrock na região us-east-1 para Claude Sonnet 4.6. As funções do AWS Lambda podem estar em qualquer região.

  • Os dados de padrões no Amazon DynamoDB expiram após 90 dias (configuráveis via Time to Live (TTL)) para manter a relevância e controlar os custos.

  • As funções Java e C# Lambda devem incluir arquivos de origem (.java, .cs) nos pacotes de implantação. Compiled-only pacotes (.class, .dll) não podem ser analisados.

  • O sistema implementa a limitação de taxa na memória por usuário (5 solicitações por 60 segundos). Para implantações distribuídas com várias AgentCore instâncias, a limitação de taxa precisaria ser transferida para o DynamoDB ou Redis para manter a consistência.

  • Alguns serviços da AWS não estão disponíveis em todas as regiões da AWS. Para conferir a disponibilidade de uma região, consulte AWS Services by Region. Para endpoints específicos, consulte a página Cotas e endpoints de serviços e clique no link correspondente ao serviço desejado.

Versões do produto

Arquitetura

Arquitetura de destino

O diagrama a seguir mostra a arquitetura e o fluxo de trabalho desse padrão:

Nesse fluxo de trabalho:

  1. O usuário fornece informações: o desenvolvedor interage com a interface do usuário Streamlit (app.py) em execução local, fornece o nome da função Lambda, instruções personalizadas opcionais para geração de testes, filtro de destino para focar em functions/classes /files específicos e ignora padrões para excluir arquivos de teste ou dependências.

  2. Autenticação Cognito: o aplicativo autentica a solicitação com o Cognito e retorna o JWT (ID/Access token) para o Streamlit.

  3. AgentCore Invocação de API: o Streamlit invoca a AgentCore API com Bearer Token + payload (nome da função, filtros, instruções, ignorar padrões).

  4. Validação do JWT: a AgentCore API valida o JWT usando a assinatura do token Cognito.

  5. Roteamento de solicitações: a AgentCore API encaminha a solicitação para o fluxo de trabalho do Lambda Test Generator (AgentCore Runtime).

  6. Solicitação de análise de código: o Analyzer Agent inicia uma solicitação para buscar o código e os metadados da função Lambda de destino.

  7. Autenticação da AWS para acesso ao Lambda: o Boto3 se autentica com a AWS usando a função de AgentCore execução, solicitando permissões de acesso de leitura.

  8. Recuperação e processamento de código do AWS Lambda: a função IAM autoriza o acesso e busca o código da função Lambda como um arquivo ZIP, extrai arquivos de origem, filtra dependências (node_modules, venv etc.) e arquivos que não são de código, aplica padrões de ignorar definidos pelo usuário e divide o código em partes gerenciáveis.

  9. Autenticação Amazon Bedrock: o cliente Boto3 Amazon Bedrock se autentica com o AWS IAM para acesso ao Amazon Bedrock, solicitando permissões de invocação do modelo para usar o Anthropic Claude Sonnet 4.6.

  10. AI-Powered Análise de código: a função IAM autoriza e envia blocos de código para o Amazon Bedrock (us-east-1) usando o Anthropic Claude Sonnet 4 (us.anthropic.claude-sonnet-4-6) com o Amazon Bedrock Guardrail aplicado para filtragem imediata de ataques e segurança de conteúdo. O Amazon Bedrock realiza análises aprimoradas de Regex + LLM para extrair padrões de entrada reais (por exemplo, evento ['body'], cabeçalhos ['Authorization']), padrões de saída (por exemplo, StatusCode, estrutura do corpo de resposta), dependências, padrões de tratamento de erros e casos extremos do código.

  11. Os resultados da análise são empacotados: o Analyzer Agent empacota os resultados da análise em um AnalysisResult objeto contendo blocos de código, padrões de entrada, padrões de saída, dependências, padrões de erro e metadados e os passa para o Generator Agent.

  12. Início do processo de geração de testes: o Generator Agent recebe os resultados da análise e inicia uma solicitação para gerar casos de teste, primeiro consultando o armazenamento de memória do DynamoDB em busca de padrões históricos com os quais aprender.

  13. Autenticação do Amazon DynamoDB para acesso à memória: o cliente Boto3 do DynamoDB se autentica com o AWS IAM para obter permissões de acesso de leitura para recuperar padrões armazenados.

  14. Os padrões históricos são recuperados do banco de dados: a função IAM autoriza e consulta a tabela de armazenamento de memória do DynamoDB (lambda-testcase-memory) para buscar padrões previamente aceitos e padrões rejeitados (testes falhados com motivos de rejeição) para a função específica do Lambda.

  15. Autenticação Amazon Bedrock para geração de testes: o cliente Boto3 Amazon Bedrock se autentica novamente com o AWS IAM para acessar o Amazon Bedrock para gerar casos de teste.

  16. Geração de casos de teste de IA: a função IAM autoriza e envia resultados de análise combinados com padrões de memória para o Amazon Bedrock. O Amazon Bedrock gera esquemas de casos de teste com eventos de entrada realistas com base em padrões de código reais, criando testes positivos (35%), testes negativos (35%) e casos extremos (30%). A geração acontece por bloco em paralelo para maior eficiência, aplica padrões aprendidos da memória, evita padrões rejeitados e gera blocos, se necessário, para grandes bases de código. Todas as chamadas Bedrock converse () incluem GuardRailConfig para filtragem imediata de ataques, redação de PII e aplicação de tópicos negados.

  17. A validação do teste começa: o Generator Agent passa os casos de teste candidatos gerados ao Validator Agent para controle de qualidade, desduplicação e seleção final.

  18. O processo de validação está configurado: o Validator Agent recebe candidatos ao teste e inicia o processo de validação, solicitando acesso ao armazenamento de memória do DynamoDB para pontuação e validação.

  19. Autenticação do DynamoDB para validação: o cliente Boto3 do DynamoDB se autentica com o AWS IAM para acesso de leitura aos padrões de memória de consulta para pontuação de validação.

  20. A qualidade do teste é avaliada: a função do IAM autoriza e usa o armazenamento de memória do DynamoDB para pontuar os casos de teste com base nas taxas de sucesso de padrões anteriores, na cobertura de funções e na complexidade do código. O Validator realiza validação estrutural, desduplicação usando hashing de padrões, pontuação de qualidade com aumento de confiança para funções de manipulador e tratamento de erros, seleção de diversidade para cobrir diferentes partes e tipos de teste e seleciona os N principais casos de teste da mais alta qualidade e mais diversos.

  21. Casos de teste finais retornados para AgentCore: O Validator Agent retorna os casos de teste finais validados com metadados (pontuações de confiança, descrições, eventos de entrada, categorias) para o orquestrador principal, que os formata e os retorna à API Amazon Bedrock AgentCore

  22. Resultados entregues à interface do usuário: a AgentCore API retorna os testes gerados de volta à interface do usuário do Streamlit para exibição com resumo da análise, metadados de geração e detalhes do caso de teste.

  23. O usuário analisa e fornece feedback: o desenvolvedor analisa os casos de teste exibidos na Streamlit UI, avalia cada teste quanto à qualidade e relevância, aceita casos de teste bons ou rejeita os ruins com motivos específicos de rejeição (missing_auth_headers, wrong_status_code, unrealistic_data, missing_required_fields, incorrect_event_source, etc.) e notas personalizadas opcionais explicando a rejeição e, em seguida, envia feedback.

  24. O feedback é enviado ao sistema: o Streamlit UI envia o feedback coletado (accepted/rejected status, motivos de rejeição, notas personalizadas) para a AgentCore API (save_feedback).

  25. AgentCore roteia feedback: a AgentCore API chama o agente Validator, que contém lógica para armazenar feedback no DynamoDB.

  26. O processo de armazenamento de feedback começa: o Validator Agent inicia o processo para armazenar o feedback.

  27. O acesso de gravação do DynamoDB é autenticado: o cliente Boto3 do DynamoDB se autentica com o AWS IAM (função de AgentCore execução) para obter permissões de acesso de gravação para armazenar padrões de feedback.

  28. Os padrões de aprendizado são armazenados: a função do IAM autoriza e armazena o feedback do usuário na tabela de armazenamento de memória do DynamoDB. Cada padrão é armazenado com uma chave de partição composta (function_name #target_function ou function_name #GLOBAL), chave de classificação composta (FEEDBACK# accepted/rejected #PATTERN #hash), hash de padrão para desduplicação, tipo de teste, estrutura do padrão de entrada, status do feedback, motivo da rejeição (se rejeitado), notas personalizadas, contagem de uso, taxa de sucesso, timestamp e TTL de 90 dias para limpeza automática. Esses dados armazenados permitem que o sistema aprenda com o feedback do usuário e melhore a geração futura de testes.

Automação e escala

Esse padrão é escalado automaticamente usando os serviços gerenciados pela AWS. O Amazon Bedrock gerencia a inferência de IA sob demanda com uma janela de contexto de 200 mil tokens e 64 mil saídas de tokens por chamada, e o Amazon DynamoDB usa o faturamento sob demanda que se ajusta automaticamente aos padrões de tráfego. O sistema usa processamento paralelo para acelerar, o Agente Analisador faz 5 chamadas Bedrock simultâneas para analisar blocos de código (ThreadPoolExecutor com max_workers=5), enquanto o Agente Gerador processa blocos em paralelo com 5 trabalhadores simultâneos. Um mecanismo de continuação processa respostas incompletas por meio da repetição automática de solicitações. A limitação de taxa (5 solicitações por 60 segundos por usuário) evita o abuso de custos causado por chamadas excessivas da API Bedrock.

A otimização de custos inclui TTL-based limpeza que remove padrões com mais de 90 dias, consultas de chave composta com begins_with () para pesquisas instantâneas sem digitalizações de tabela e BatchWriteItem operações que reduzem as operações de gravação do DynamoDB em aproximadamente 90%. O desempenho depende do tamanho da função, funções pequenas (menos de 10 arquivos) geram 10 casos de teste em 30 a 60 segundos, funções médias (10 a 50 arquivos) levam de 1 a 3 minutos e funções grandes (mais de 50 arquivos) levam de 3 a 5 minutos, embora o uso de filtros de destino para focar em seções específicas do código reduza o tempo em 50 a 70%.

Ferramentas

Serviços da AWS

  • Amazon Bedrock — Fornece recursos generativos de IA por meio do Anthropic Claude Sonnet 4 para análise de código, geração de testes, validação e resumo de rejeição. Sempre usa a região us-east-1 para acesso ao modelo.

  • Amazon Bedrock AgentCore — Fornece tempo de execução de agente sem servidor para implantar e hospedar o back-end de geração de testes com escalabilidade, autorização e observabilidade automáticas. OAuth-based CloudWatch

  • Amazon Bedrock Guardrails — Fornece filtragem de ML-based segurança em todas as chamadas da API Bedrock, incluindo detecção imediata de ataques (ALTA intensidade), filtragem de conteúdo, anonimização de PII (e-mail, telefone, nome), bloqueio de keys/private keys/JWT tokens de acesso da AWS e imposição de tópicos negados (geração de código de exploração, saída de código-fonte bruto). Implantado via CloudFormation.

  • AWS CloudFormation — Automatiza o provisionamento completo da infraestrutura, incluindo tabela do DynamoDB, pool de usuários do Cognito, Amazon Bedrock Guardrail com controle de versão e função de execução do IAM para. AgentCore

  • Amazon Cognito — Fornece autenticação de usuário com inscrição por e-mail, emissão de token JWT e autorização segura de API para o back-end. AgentCore

  • Amazon DynamoDB — Armazena padrões de teste aceitos e rejeitados com estatísticas de uso para aprendizado e aprimoramento contínuos. Usa chaves compostas (function_target, pattern_sk) para consultas de varredura zero e armazenamento de padrões específicos do destino.

  • AWS Lambda — Fonte do código da função para análise, a GetFunction API recupera o código e a configuração. A ferramenta oferece suporte aos tempos de execução Python Node.js, Java, .NET e Ruby.

Outras ferramentas

  • Python 3.11+ — Ambiente de execução para orquestração de aplicativos e agentes.

  • Streamlit — interface de Web-based usuário para autenticação, geração de testes, coleta de feedback e monitoramento do status do sistema.

  • Boto3 — SDK da AWS para Python para interagir com os serviços Lambda, Amazon Bedrock, DynamoDB e Cognito.

Repositório de código

O código desse padrão está disponível no Github - Lambda Test Event Generator.

Práticas recomendadas

Esse padrão implementa as seguintes práticas recomendadas:

  • Usa políticas de IAM com menos privilégios para acesso ao AWS Lambda (somente leitura), Amazon Bedrock (invocar), Amazon DynamoDB () e Amazon Cognito (autenticação). query/write

  • Implemente o aprendizado de padrões específicos do alvo com recurso global para melhorar a precisão do teste.

  • Ative o DynamoDB TTL para limpeza automática de padrões antigos (90 dias) para controlar os custos de armazenamento.

  • Use consultas de varredura zero com chaves compostas (function_target, pattern_sk) para recuperação rápida de padrões.

  • Aplique padrões de ignorar para excluir arquivos de teste, dependências e arquivos não codificados da análise.

  • Use fragmentação de código em vários idiomas com análise de Árvore de Sintaxe Abstrata (AST) (Python) e padrões regex (Java, C#, JS, Ruby).

  • Armazene padrões com valores reais (não apenas estrutura) para uma verdadeira desduplicação.

  • Implante o back-end no Amazon Bedrock AgentCore para escalabilidade sem servidor e infraestrutura gerenciada.

  • Autentique usuários por meio do Amazon Cognito com a validação do token JWT em cada solicitação de API.

  • Aplique o Amazon Bedrock Guardrails em todas as chamadas converse () para filtragem imediata de ataques, redação de PII, bloqueio de dados confidenciais (chaves da AWS, chaves privadas, JWTs) e imposição de tópicos negados.

  • Limpe os resultados da análise antes de retornar aos usuários - todos os fragmentos brutos do código-fonte são removidos das respostas, garantindo que o código-fonte do Lambda nunca saia do limite do tempo de execução. AgentCore

  • Valide todas as entradas da API com padrões regex e limites de comprimento (nome da função com máximo de 170 caracteres, instruções personalizadas com máximo de 2.000 caracteres, máximo de 50 padrões de ignoração) para evitar injeção e abuso.

  • Implemente uma limitação de taxa por usuário (5 solicitações por 60 segundos) para evitar o abuso de custos causado por chamadas excessivas da API Bedrock.

  • Limpe as mensagens de erro antes de devolvê-las aos usuários — caminhos de arquivos internos, detalhes do SDK da AWS e informações de infraestrutura nunca são expostos nas respostas de erro.

Considere as seguintes melhores práticas adicionais:

  • Forneça motivos específicos de feedback ao rejeitar casos de teste para melhorar a precisão do aprendizado.

  • Gere testes iterativamente (2 a 3 vezes) para a mesma função para permitir que o sistema aprenda e melhore.

  • Forneça instruções personalizadas quando precisar de cenários de teste ou formatos de dados específicos.

  • Ative o IAM Access Analyzer para monitorar as permissões de recursos e identificar acessos não intencionais.

  • Comece com pequenas funções do Lambda para entender o sistema antes de analisar grandes bases de código.

  • Analise as políticas do IAM regularmente e remova as permissões não utilizadas.

  • Use políticas de senha fortes e habilite o Cognito AdvancedSecurityMode para detecção de ameaças.

Épicos

TarefaDescriptionHabilidades necessárias

Clonar o repositório.

Clone o GitHub repositório em seu sistema local e navegue até o diretório do projeto:

git clone https://github.com/aws-samples/sample-lambda-test-event-generator.git

cd sample-lambda-test-event-generator

Esse repositório contém o aplicativo, o CloudFormation modelo e os arquivos de configuração do Python.

Desenvolvedor de aplicativos

Configure as credenciais da AWS.

Configure suas credenciais da AWS para permitir que a CLI da AWS interaja com sua conta da AWS e para permitir que o aplicativo acesse as funções do Lambda que você deseja testar.

Você pode fazer isso usando o comando de configuração da AWS CLI:

aws configure

Quando solicitado, forneça as seguintes informações:

  • ID da chave de acesso da AWS: sua chave de acesso da AWS

  • Chave de acesso secreta da AWS: sua chave de acesso secreta da AWS

  • Nome da região padrão: a região da AWS em que você deseja implantar os recursos (por exemplo,us-east-1)

  • Formato de saída padrão: o formato de saída preferido (por exemplo,json)

Desenvolvedor de aplicativos
TarefaDescriptionHabilidades necessárias

Implante a infraestrutura usando CloudFormation.

  1. Implante a infraestrutura completa de back-end (funções do DynamoDB, Cognito e IAM) usando o modelo fornecido. CloudFormation Execute o seguinte comando em sua CLI:

    aws cloudformation create-stack \
      --stack-name lambda-test-generator-infra \
      --template-body file://cloudformation/complete-infrastructure.yaml \
      --capabilities CAPABILITY_NAMED_IAM \
      --region us-east-1

  2. Aguarde a conclusão da implantação da pilha:

    aws cloudformation wait stack-create-complete \
      --stack-name lambda-test-generator-infra \
      --region us-east-1

  3. Recupere todas as saídas:

    aws cloudformation describe-stacks \
      --stack-name lambda-test-generator-infra \
      --query 'Stacks[0].Outputs' \
      --output table

O que é criado:

  • Tabela do DynamoDB com TTL habilitado, recuperação pontual e criptografia no lado do servidor.

  • Pool de usuários do Cognito com autenticação de e-mail, AdvancedSecurityMode ENFORCED, MFA opcional (TOTP) e criação de usuários somente para administradores.

  • Amazon Bedrock Guardrail com filtragem imediata de ataques, redação de PII, filtragem de conteúdo e bloqueio de tópicos negados.

  • Função de execução do IAM para políticas AgentCore com menos privilégios, incluindo a base: permissão. ApplyGuardrail

nota

A pilha cria todos os recursos necessários. Certifique-se de que o CloudFormation modelo seja concluído com êxito antes de prosseguir para a próxima etapa.

Desenvolvedor de aplicativos

Exporte variáveis de configuração.

Exporte todos os valores das saídas da CloudFormation pilha como variáveis de ambiente:

export AGENTCORE_ROLE_ARN=$(aws cloudformation describe-stacks \
      --stack-name lambda-test-generator-infra \
      --query 'Stacks[0].Outputs[?OutputKey==`AgentCoreExecutionRoleArn`].OutputValue' \
      --output text)

export DISCOVERY_URL=$(aws cloudformation describe-stacks \
      --stack-name lambda-test-generator-infra \
      --query 'Stacks[0].Outputs[?OutputKey==`DiscoveryUrl`].OutputValue' \
      --output text)

export CLIENT_ID=$(aws cloudformation describe-stacks \
      --stack-name lambda-test-generator-infra \
      --query 'Stacks[0].Outputs[?OutputKey==`ClientId`].OutputValue' \
      --output text)

export DYNAMODB_TABLE=$(aws cloudformation describe-stacks \
      --stack-name lambda-test-generator-infra \
      --query 'Stacks[0].Outputs[?OutputKey==`DynamoDBTableName`].OutputValue' \
      --output text)

export COGNITO_POOL_ID=$(aws cloudformation describe-stacks \
      --stack-name lambda-test-generator-infra \
      --query 'Stacks[0].Outputs[?OutputKey==`UserPoolId`].OutputValue' \
      --output text)

export BEDROCK_GUARDRAIL_ID=$(aws cloudformation describe-stacks \
  --stack-name lambda-test-generator-infra \
  --query 'Stacks[0].Outputs[?OutputKey==`BedrockGuardrailId`].OutputValue' \
  --output text)

export BEDROCK_GUARDRAIL_VERSION=$(aws cloudformation describe-stacks \
  --stack-name lambda-test-generator-infra \
  --query 'Stacks[0].Outputs[?OutputKey==`BedrockGuardrailVersion`].OutputValue' \
  --output text)

Essas variáveis são usadas nas etapas subsequentes para AgentCore configuração e criação do arquivo.env.

Administrador da AWS
TarefaDescriptionHabilidades necessárias

Crie um ambiente virtual.

  1. Crie e ative um ambiente virtual Python para isolar as dependências do projeto:

    python3 -m venv venv

source venv/bin/activate

  2. Instale os pacotes Python necessários a partir do arquivo de requisitos:

    pip install -r requirements.txt

    Isso instala todas as bibliotecas necessárias, incluindo boto3 para AWS SDK, python-dotenv para configuração do ambiente, bedrock-agentcore-runtime para integração e Streamlit para a interface do usuário. AgentCore

    nota

    O ambiente virtual deve ser ativado (usandosource venv/bin/activate) toda vez que você abre uma nova sessão de terminal para executar o aplicativo.

Desenvolvedor de aplicativos

Configure e implante AgentCore.

  • Configure o AgentCore agente:

    agentcore configure \
  --entrypoint main.py \
  --name lambda_test_generator \
  --requirements-file requirements.txt \
  --region us-east-1 \
  --execution-role $AGENTCORE_ROLE_ARN

  • Quando solicitado:

    1. Tipo de implantação: 1 (implantação direta de código - sem necessidade de Docker)

    2. Versão do Python: 2 (PYTHON_3_11 ou selecione sua versão específica do Python)

    3. Bucket S3: pressione Enter (criação automática)

    4. Autorizador OAuth: sim

    5. URL de descoberta: cole o valor $DISCOVERY_URL

    6. IDs de cliente: cole o valor $CLIENT_ID

    7. Público: Pressione Enter (deixe em branco)

    8. Escopos: pressione Enter (deixe em branco)

    9. Reivindicações personalizadas: pressione Enter (deixe em branco)

    10. Cabeçalhos de solicitação: sim

    11. Cabeçalhos: Autorização

    12. Memória: s (pular - usando o DynamoDB)

  • Implante o agente:

    agentcore deploy \
  --env DYNAMODB_TABLE_NAME=$DYNAMODB_TABLE \
  --env AWS_REGION=us-east-1 \
  --env BEDROCK_GUARDRAIL_ID=$BEDROCK_GUARDRAIL_ID \
  --env BEDROCK_GUARDRAIL_VERSION=$BEDROCK_GUARDRAIL_VERSION

  • Obtenha o ID AgentCore de tempo de execução e o endpoint:

    RUNTIME_ID=$(agentcore status | grep "Agent ARN:" | sed 's/.*runtime\///' | sed 's/[│ ].*//')
AGENTCORE_ENDPOINT="https://bedrock-agentcore-runtime.us-east-1.amazonaws.com/agents/${RUNTIME_ID}/endpoints/DEFAULT"
Desenvolvedor de aplicativos

Crie um arquivo.env para desenvolvimento local.

Crie um arquivo.env no diretório raiz do projeto com todos os valores de configuração:

cat > .env << EOF
AWS_REGION=us-east-1
DYNAMODB_TABLE_NAME=$DYNAMODB_TABLE
COGNITO_POOL_ID=$COGNITO_POOL_ID
COGNITO_CLIENT_ID=$CLIENT_ID
COGNITO_REGION=us-east-1
AGENTCORE_ENDPOINT=$AGENTCORE_ENDPOINT
BEDROCK_GUARDRAIL_ID=$BEDROCK_GUARDRAIL_ID
BEDROCK_GUARDRAIL_VERSION=$BEDROCK_GUARDRAIL_VERSION
EOF

Teste a conectividade com os serviços da AWS:

aws dynamodb describe-table --table-name $DYNAMODB_TABLE
aws bedrock list-foundation-models --region us-east-1

Ambos os comandos devem retornar respostas bem-sucedidas. Se você encontrar erros de permissão, verifique se as políticas do IAM estão configuradas corretamente.

Desenvolvedor de aplicativos
TarefaDescriptionHabilidades necessárias

Crie um novo usuário do Cognito.

O grupo de usuários do Cognito é configurado com a criação de usuários somente para administradores para fins de segurança, portanto, os usuários não podem se registrar automaticamente. Crie um usuário por meio da AWS CLI usando o Cognito Pool ID e o Client ID exportados das saídas da CloudFormation pilha. Crie um novo usuário (user@example.comsubstitua pelo seu e-mail):

aws cognito-idp admin-create-user \
  --user-pool-id $COGNITO_POOL_ID \
  --username user@example.com \
  --user-attributes Name=email,Value=user@example.com Name=email_verified,Value=true \
  --temporary-password '[PASSWORD]!' \
  --region us-east-1

Defina uma senha permanente (mínimo de 8 caracteres, deve incluir maiúsculas, minúsculas e um número):

aws cognito-idp admin-set-user-password \
  --user-pool-id $COGNITO_POOL_ID \
  --username user@example.com \
  --password '[PASSWORD]!' \
  --permanent \
  --region us-east-1

Use essas credenciais para fazer login por meio da interface do usuário do Streamlit na próxima etapa.

Desenvolvedor de aplicativos
TarefaDescriptionHabilidades necessárias

Inicie o Streamlit UI.

Iniciar o aplicativo

streamlit run app.py

A interface do usuário abrirá no seu navegador padrão em http://localhost:8501

Faça login com as credenciais criadas na etapa anterior

Desenvolvedor de aplicativos

Configurar opções de geração

Na interface do usuário, configure as seguintes opções:

  1. Nome da função Lambda ou ARN: insira o identificador da função Lambda de destino

  2. Filtro de destino (opcional): especifique uma função, classe ou arquivo para focar (por exemplo,validate_user,UserService,auth.py)

  3. Ignorar padrões (opcional): adicione padrões de arquivo ou pasta para excluir, um por linha:

    • tests/- Ignore o diretório de testes

    • *.test.js- Ignorar arquivos de teste

    • mock_data/- Ignore dados simulados

  4. Instruções personalizadas (opcional): adicione requisitos de teste específicos

Desenvolvedor de aplicativos

Gere casos de teste.

Clique no botão “Gerar casos de teste”. O sistema vai:

  1. Autentique-se AgentCore usando o token Cognito JWT.

  2. Obtenha o código Lambda da AWS.

  3. Aplique padrões de ignorar para excluir arquivos indesejados.

  4. Codifique o código usando estratégias específicas do idioma.

  5. Aplique o filtro de destino, se especificado.

  6. Analise o código com o Amazon Bedrock.

  7. Consulte o DynamoDB para obter padrões aprendidos.

  8. Gere casos de teste.

  9. Valide e classifique os casos de teste.

Desenvolvedor de aplicativos

Revise os testes gerados.

Analise cada caso de teste gerado, que inclui:

  • Tipo: Positivo (entradas válidas), Negativo (entradas inválidas) ou Borda (condições de contorno)

  • Descrição: O que o teste valida

  • Dados de teste: a carga útil real do evento de teste

DevOps engenheiro, desenvolvedor de aplicativos

Forneça feedback.

Para cada caso de teste, forneça feedback:

Para aceitar um caso de teste:

  • Clique no botão “Aceitar”

Para rejeitar um caso de teste:

  1. Clique no botão “Rejeitar”

  2. Selecione um motivo de rejeição no menu suspenso ou adicione um motivo personalizado

  3. Clique no botão “Enviar rejeição”

Engenheiro de testes

Salve o feedback na memória.

Depois de analisar todos os casos de teste:

  1. Clique no botão “Salvar todos os comentários na memória”

  2. O sistema valida que todos os casos rejeitados apresentaram os motivos

  3. O feedback é enviado para a AgentCore API, que encaminha para o Validator Agent.

  4. O feedback é armazenado em lote no DynamoDB com hash padrão para desduplicação.

  5. Veja o resumo do feedback mostrando as accepted/rejected contagens

Engenheiro de testes

Repita para melhorar.

Gere testes mais 2 a 3 vezes para a mesma função para melhorar a qualidade:

  • O sistema recupera padrões aprendidos do DynamoDB

  • A qualidade melhora a cada iteração com base no seu feedback

  • Use o filtro de destino para testes focados em componentes específicos

  • Use padrões de ignorar para excluir código irrelevante e melhorar a qualidade da geração

nota

O sistema de aprendizagem se torna mais eficaz com o uso repetido. Cada ciclo de feedback ajuda a IA a entender suas preferências de teste e gerar casos de teste mais relevantes para suas funções do Lambda.

Desenvolvedor de aplicativos
TarefaDescriptionHabilidades necessárias

Invoque a AgentCore API diretamente.

Para automação e integração, invoque o AgentCore back-end diretamente usando chamadas de API com autenticação Cognito.

Obtenha um token Cognito:

TOKEN=$(agentcore identity get-cognito-inbound-token)

Invoque a geração de teste:

agentcore invoke --bearer-token "$TOKEN" '{"action": "generate_test_cases", "function_name": "your-lambda-function", "num_test_cases": 10,"custom_instructions": "Focus on authentication scenarios", "target_filter": "validate_user","ignore_patterns": ["tests/", "*.test.js"] }'

Ou usando curl:

curl -X POST "$AGENTCORE_ENDPOINT" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "action": "generate_test_cases", "function_name": "your-lambda-function", "num_test_cases": 10}'
Desenvolvedor de aplicativos
TarefaDescriptionHabilidades necessárias

Monitore os padrões do DynamoDB e acompanhe os custos.

  1. Consulte a tabela do DynamoDB para revisar os padrões aceitos e entender o que o sistema aprendeu:

    aws dynamodb query \
  --table-name $DYNAMODB_TABLE \
  --key-condition-expression "function_target = :ft AND begins_with(pattern_sk, :prefix)" \
  --expression-attribute-values '{":ft":{"S":"my-function#GLOBAL"},":prefix":{"S":"FEEDBACK#accepted"}}'

    my-functionSubstitua pelo nome real da função do Lambda para visualizar padrões específicos dessa função.

  2. Acompanhe o consumo de recursos para otimizar os custos:

    • AWS Cost Explorer: monitore os gastos gerais com os serviços Bedrock, DynamoDB e Lambda

    • Amazon Bedrock: analise o uso de tokens e as métricas de chamadas de API no console Bedrock

    • DynamoDB: verifique as métricas de solicitação, a capacidade consumida e o uso do armazenamento.

    • AgentCore: Monitore as métricas de tempo de execução do agente e a contagem de invocações em CloudWatch

  3. Use CloudWatch os registros para diagnosticar problemas e monitorar o comportamento do sistema:

    • AgentCore registros: 

      aws logs tail /aws/bedrock-agentcore/runtimes/lambda_test_generator --follow

    • Erros do aplicativo: analise os erros e exceções no nível do aplicativo

    • Respostas da API Bedrock: analise as respostas do modelo de IA e o consumo de tokens

    • Operações do DynamoDB: monitore read/write padrões e eventos de limitação

nota

O monitoramento regular ajuda a identificar oportunidades de otimização de custos e garante que o sistema continue aprendendo de forma eficaz. A configuração TTL em sua tabela do DynamoDB limpa automaticamente padrões antigos, ajudando a gerenciar os custos de armazenamento ao longo do tempo.

Administrador da AWS
TarefaDescriptionHabilidades necessárias

Exclua os recursos implantados.

Para remover todos os recursos implantados:

Exclua o AgentCore agente:

agentcore destroy

Exclua a CloudFormation pilha (exclui a tabela do DynamoDB, o grupo de usuários do Cognito e a função do IAM):

aws cloudformation delete-stack 
\ --stack-name lambda-test-generator-infra 
\ --region us-east-1
Administrador da AWS

Solução de problemas

ProblemaSolução

Erro de “Acesso negado” ao buscar o código Lambda

  • Verifique se as permissões do IAM incluem lambda:GetFunction e lambda:GetFunctionConfiguration para a função Lambda de destino

  • Verifique suas credenciais da AWS CLI

    aws sts get-caller-identity

“Erros de gravação do DynamoDB”

  • Verifique se o nome da tabela em seu .env arquivo corresponde ao nome da tabela implantada

  • Verifique as CloudFormation saídas:

    aws cloudformation describe-stacks --stack-name lambda-test-generator-infra --query 'Stacks[0].Outputs[?OutputKey=DynamoDBTableName].OutputValue' --output text

  • Ou verifique diretamente:

    aws dynamodb describe-table --table-name $DYNAMODB_TABLE

Nenhum caso de teste gerado

Possíveis causas e soluções:

  • O código da função Lambda não está acessível: verifique as permissões do IAM para acesso ao Lambda

  • O pacote de implantação do Lambda contém apenas código compilado: .class .dll arquivos sem arquivos de origem não podem ser analisados

  • Todos os arquivos filtrados por padrões ignorados: revise e ajuste seus padrões ignorados

  • As instruções personalizadas são muito restritivas: simplifique ou remova as instruções personalizadas

  • Verifique se a função Lambda existe:

    aws lambda get-function --function-name <name>

Java/C# O Lambda mostra “Nenhum código-fonte encontrado”

Os Lambdas Java e C# exigem arquivos de origem no pacote de implantação:

Java (Maven):

  1. Adicionar configuração de inclusão de origem a pom.xml (consultedocs/JAVA_SETUP.md)

  2. Reconstrua e reimplante sua função do Lambda

C# (.NET):

  1. Incluir .cs arquivos na configuração de compilação (consultedocs/CSHARP_SETUP.md)

  2. Reconstrua e reimplante sua função do Lambda

Erros de gravação do DynamoDB

  • Verifique as permissões e o status da tabela do DynamoDB:

  • Verifique se a política do IAM inclui dynamodb:PutItem e dynamodb:BatchWriteItem

  • Verifique o status da tabela: 

    aws dynamodb describe-table --table-name $DYNAMODB_TABLE

    O nome da tabela inclui o sufixo do nome da pilha. Use o valor de suas CloudFormation saídas ou do arquivo.env.

  • Ative o CloudWatch Logs for DynamoDB para ver mensagens de erro detalhadas

Geração lenta de testes

Otimize a velocidade de geração:

  1. Use o filtro de destino para se concentrar em funções específicas (50 a 70% mais rápido)

  2. Adicione padrões de ignorar para excluir arquivos de teste, dependências e código irrelevante

  3. Reduza o tamanho do código filtrando arquivos desnecessários antes da análise

AgentCore: “Agente não encontrado”

Verifique se o agente está implantado:

agentcore status

agentcore configure list

AgentCore: “Permissão negada” em tempo de execução

Verifique se a função de execução tem políticas corretas:

aws iam list-role-policies --role-name agentcore-exec-lambda-test-generator-infra

Cognito: “Nome de usuário ou senha inválidos”

Verifique se suas credenciais estão corretas. Você pode criar um novo usuário usando o fluxo “Criar conta” da interface do usuário do Streamlit ou por meio da AWS CLI:

aws cognito-idp admin-create-user --user-pool-id <POOL_ID> --username <username> --temporary-password '<password>' --region us-east-1
aws cognito-idp admin-set-user-password --user-pool-id <POOL_ID> --username <username> --password '<password>' --permanent --region us-east-1

Aviso de “Bedrock Guardrail não configurado” nos registros

Verifique se as variáveis de BEDROCK_GUARDRAIL_VERSION ambiente BEDROCK_GUARDRAIL_ID e de ambiente estão definidas na AgentCore implantação.

Verifique as CloudFormation saídas: 

aws cloudformation describe-stacks --stack-name lambda-test-generator-infra --query 'Stacks[0].Outputs[?OutputKey==`BedrockGuardrailId`].OutputValue' --output text

Erro “Limite de taxa excedido”

O sistema limita a 5 solicitações por 60 segundos por usuário. Aguarde o tempo indicado antes de tentar novamente. Para uso em produção com maiores necessidades de produtividade, ajuste RATE_LIMIT_MAX_REQUESTS e RATE_LIMIT_WINDOW constantes em main.py.

Recursos relacionados

Documentação da AWS