Última revisão: maio de 2026
Uma referência rápida dos padrões arquiteturais que o exame DVA-C02 avalia. Leia de cima a baixo ou pule para uma seção.
Alvo de invocação estável enquanto você implanta novo código Lambda.
Publique versões numeradas e imutáveis; exponha um alias que aponta para uma versão. Os chamadores invocam o ARN do alias.
Por quê: Versões são snapshots congelados de código + configuração; aliases fornecem indireção para que os chamadores nunca invoquem `$LATEST` diretamente.
Implantação gradual de uma nova versão do Lambda com rollback automático em caso de erros.
Alias com roteamento de versão ponderado (por exemplo, 90/10). CodeDeploy `LambdaCanary10Percent5Minutes` ou `LambdaLinear*` move o tráfego e monitora alarmes do CloudWatch.
Por quê: O roteamento de tráfego integrado + rollback acionado por alarmes remove a lógica de canary codificada manualmente.
Injetar configurações (URL do DB, feature flags) sem reimplementações.
Variáveis de ambiente Lambda. Criptografadas em repouso com KMS; referencie um CMK personalizado para criptografia adicional em trânsito na recuperação.
Compartilhar NumPy / pandas / runtime comum em várias Lambdas.
Empacote como uma Lambda Layer; até 5 layers por função, total de 250 MB descompactado. ARN versionado por layer.
Lambda síncrona sensível à latência - sem cold starts permitidos.
Concorrência Provisionada no alias. Pré-inicializa N ambientes de execução; paga por GB-segundo.
Por quê: Elimina cold start a um custo previsível. Defina o auto-scaling do aplicativo no alias para se ajustar à carga.
Lambda Java ou Python com código de inicialização pesado; precisa de um cold start rápido sem pagar por Provisioned Concurrency.
Habilite SnapStart em uma versão publicada. A AWS tira um snapshot do runtime inicializado e o retoma a partir dele.
Por quê: Gratuito para Java; cobrado por restauração para Python/.NET. Reduz cold starts de segundos para <1s sem custo de ociosidade.
Lambda precisa consumir um stream do Kinesis / DynamoDB Stream / fila SQS / tópico MSK.
Mapeamento de fonte de evento (baseado em pull). Lambda consulta; tamanho do lote + janela máxima de lote ajustam throughput vs latência. Falha → DLQ via destino On-Failure.
Por quê: Para fontes pull, o serviço não pode invocar Lambda diretamente; o mapeamento é o adaptador de polling do Lambda.
Roteamento de sucesso/falha de Lambda assíncrona sem DLQ do Lambda.
Destinos OnSuccess / OnFailure na função. Alvos: SNS, SQS, EventBridge, outra Lambda. Inclui contexto de invocação.
Por quê: Destinos capturam o evento completo + resposta; o DLQ legado captura apenas o payload do evento.
Escolha o tipo de API Gateway para uma nova API REST.
HTTP API: mais barata, mais rápida, autenticação JWT integrada, mais simples. REST API: recursos completos (templates de mapeamento, validadores de requisição, WAF, private endpoints, X-Ray, cache de API).
Por quê: Prefira HTTP API, a menos que você precise de um recurso exclusivo da REST. As APIs WebSocket são um produto separado para tempo real com estado.
Promover alterações de API de dev → test → prod sem reimplantar APIs separadas.
Estágios em uma única API. Implante um estágio para publicar; variáveis de estágio contêm valores específicos do ambiente, como nomes de alias Lambda.
A Lambda de backend espera um formato diferente do que o cliente envia.
Template de mapeamento de requisição/resposta (apenas REST API). VTL com `$input`, `$context`, `$util` para transformar JSON.
Por quê: Templates de mapeamento são executados no API Gateway - sem salto extra para Lambda, sem latência ou custo adicionais.
Validar um token personalizado (não Cognito, não IAM) antes de rotear a requisição.
Autorizador Lambda. O tipo TOKEN lê um cabeçalho; o tipo REQUEST lê o contexto completo da requisição. Retorna política IAM + principalId. Cacheado por identidade para TTL.
Validar um JWT de Cognito User Pool em cada requisição.
Autorizador de Cognito User Pool (REST) ou autorizador JWT (HTTP). O API Gateway valida o token; nenhuma Lambda é necessária.
Por quê: A validação nativa é mais barata e rápida do que um autorizador Lambda para o caso comum de JWT.
Controlar/limitar um consumidor de API parceiro.
Plano de Uso + Chave de API. O plano vincula chaves a um estágio com limite de taxa (req/seg) + burst + cota (req/dia ou mês).
Reduzir a carga do backend para requisições GET repetidas.
Cache de nível de estágio (REST API). TTL configurável; chave de cache derivada do método + path + parâmetros de consulta/cabeçalho selecionados.
Atualizar um item somente se uma pré-condição for verdadeira (por exemplo, status == "PENDING").
PutItem/UpdateItem com `ConditionExpression`. A falha levanta `ConditionalCheckFailedException`.
Por quê: A verificação no lado do servidor evita condições de corrida de leitura-modificação-escrita sem bloqueio.
Tudo ou nada em múltiplos itens do DynamoDB.
`TransactWriteItems` / `TransactGetItems`. Até 100 itens / 4 MB; 2× o custo de WCU/RCU de escritas/leituras normais.
Incrementar um contador sem leitura-modificação-escrita.
UpdateExpression `ADD count :inc`. O servidor aplica o delta atomicamente.
Iterar um grande conjunto de resultados de consulta/scan.
`LastEvaluatedKey` da resposta → `ExclusiveStartKey` na próxima chamada até estar ausente. Limite via parâmetro `Limit`.
Precisa de um padrão de acesso adicional além da chave primária.
GSI: chave de partição + ordenação alternativa, eventualmente consistente, capacidade separada, pode ser adicionada a qualquer momento. LSI: mesma chave de partição, chave de ordenação alternativa, opção de consistência forte, deve ser criada na criação da tabela.
Indexar apenas itens que possuem um atributo específico (por exemplo, apenas pedidos ATIVOS).
Índice esparso: omita o atributo nos itens que você deseja excluir. Itens sem o atributo indexado não aparecem no GSI/LSI.
Leitura/escrita em massa de muitos itens.
`BatchGetItem` (até 100 itens / 16 MB) e `BatchWriteItem` (até 25 itens / 16 MB). Não atômico; falhas parciais são retornadas em `UnprocessedItems`.
Evitar atualizações perdidas de escritores concorrentes.
Atributo de versão + `ConditionExpression: version = :v`. Escritas com falha são repetidas lendo novamente.
Acionar ações downstream a cada alteração do DynamoDB.
DynamoDB Streams + mapeamento de fonte de evento Lambda. Visualização do stream: NEW_IMAGE / OLD_IMAGE / NEW_AND_OLD_IMAGES / KEYS_ONLY.
O navegador faz upload/download diretamente para o S3 sem o seu servidor atuar como proxy de bytes.
SDK `getSignedUrl` para GET ou PUT. Expiração de até 7 dias quando assinado por um usuário IAM (sigv4); mais curto para sessões derivadas de role.
Por quê: Libera largura de banda do seu backend; a URL é uma capacidade temporária com escopo para um objeto + método.
Fazer upload de um arquivo grande (≫100 MB) de forma confiável a partir do SDK.
`CreateMultipartUpload` → `UploadPart` paralelo → `CompleteMultipartUpload`. O gerenciador de transferência de alto nível do SDK lida com o dimensionamento das partes automaticamente.
Por quê: Obrigatório para >5 GB; recomendado para ≥100 MB. Partes com falha são re-carregadas independentemente. Defina o ciclo de vida para abortar multiparts incompletos para recuperar armazenamento.
Executar código quando um objeto é criado/excluído no S3.
Notificações de Eventos S3 → Lambda / SNS / SQS / EventBridge. Filtre por prefixo e sufixo.
Aplicativo de navegador busca do S3 entre origens (`fetch('https://bucket.s3...')`); o preflight CORS falha.
Configure as regras CORS do bucket: origens permitidas, métodos (GET/PUT), cabeçalhos e cabeçalhos expostos.
Filtrar linhas de um objeto CSV/JSON/Parquet de 50 GB sem baixá-lo.
S3 Select com SQL. Retorna apenas as linhas correspondentes; pague pela varredura + bytes retornados.
Autenticar um usuário de um cliente móvel/web público sem enviar a senha.
Cognito User Pool com fluxo `USER_SRP_AUTH`. O cliente calcula a prova SRP; o backend nunca vê a senha. Retorna tokens de ID + acesso + refresh.
Usuário federado (Google/Apple/Cognito UP) precisa de credenciais temporárias da AWS para chamar APIs da AWS diretamente de um aplicativo móvel.
Cognito Identity Pool. Troca token de provedor de identidade → role IAM → credenciais temporárias da AWS via STS.
Por quê: User Pools autenticam usuários; Identity Pools os autorizam a recursos da AWS.
Escolha um tipo de fluxo de trabalho do Step Functions.
Standard: longa duração (≤1 ano), exatamente uma vez, $0.025/1k transições, histórico completo. Express: ≤5 min, pelo menos uma vez ou no máximo uma vez, cobrado por requisição + duração; para ETL/streaming de alto volume.
A etapa do fluxo de trabalho falha; desejo tentar novamente com backoff e rotear para um estado de recuperação.
Array `Retry` (por estado, com `BackoffRate` + `MaxAttempts`) e `Catch` para roteamento de falha terminal. Corresponda por `ErrorEquals` (por exemplo, `States.TaskFailed`, nomes de erros personalizados).
Aplicar o mesmo fluxo de trabalho a cada item em um array, com limite de concorrência.
Estado Map com `ItemsPath` e `MaxConcurrency`. Distributed Map lida com mais de 10k itens com entrada suportada por S3.
Acionar Lambda em um cron schedule ou eventos de entrada correspondentes.
Regra do EventBridge. Agendamento: `rate(...)` ou `cron(...)`. Padrão: filtro de evento JSON; corresponde a fonte, tipo de detalhe, campos de detalhe.
Encaminhar eventos de SQS / Kinesis / DynamoDB Streams / MSK para um alvo com filtro + transformação opcionais.
EventBridge Pipes. Fonte → Filtro → Enriquecimento (Lambda/Step Functions) → Alvo. Nenhuma Lambda necessária para os casos simples.
Processar mensagens estritamente em ordem por cliente, com deduplicação.
Fila SQS FIFO. `MessageGroupId` particiona a ordenação (paralelismo por grupo); `MessageDeduplicationId` (ou dedup baseado em conteúdo) descarta duplicatas em 5 minutos.
O consumidor puxa uma mensagem, mas trava antes de excluí-la.
Mensagem oculta por VisibilityTimeout segundos, então reaparece para reentrega. Ajuste para o tempo de processamento esperado mais longo + buffer.
Por quê: Muito curto → processamento duplicado. Muito longo → recuperação lenta em caso de falha. ChangeMessageVisibility estende em trânsito se necessário.
Um evento deve atingir múltiplos consumidores (Lambdas / filas SQS / endpoints HTTP).
Tópico SNS com múltiplos assinantes. As políticas de filtro de assinatura roteiam apenas mensagens correspondentes por assinante.
Ajustar a capacidade do Kinesis Data Streams para throughput de escrita.
Cada shard = 1 MB/s ou 1000 registros/s de entrada, 2 MB/s de saída. Adicione shards (split) ou use o modo On-Demand para auto-scaling.
O código em EC2 / tarefa ECS / Lambda precisa de acesso à AWS - sem chaves embutidas.
Anexe uma role IAM via perfil de instância (EC2) ou role de tarefa/execução (ECS/Lambda). O SDK puxa credenciais temporárias do serviço de metadados; auto-rotaciona.
Acesso entre contas a partir de código de aplicativo ou CLI.
`sts:AssumeRole` do principal chamador. A política de confiança da role alvo lista o chamador como um `Principal`. Retorna credenciais temporárias (máximo 12 horas).
AssumeRole entre contas está falhando - a permissão parece correta.
Ambos devem ser configurados: a política de confiança na role alvo lista o chamador como Principal; a política de identidade do chamador permite `sts:AssumeRole` no ARN da role alvo.
Por quê: Confiança = quem pode assumir. Permissão = o que podem fazer uma vez assumido. Qualquer um faltando → AccessDenied.
Política que concede aos usuários acesso apenas à sua própria pasta no S3.
Use `${aws:username}` ou `${aws:PrincipalTag/X}` em ARNs de recurso: `arn:aws:s3:::bucket/${aws:username}/*`.
Permitir que uma equipe gerencie roles IAM por conta própria, mas limite as permissões que podem conceder.
Política de limite de permissão na role criadora da equipe. Qualquer role que eles criem com o limite tem a interseção da política de identidade + limite como permissões efetivas.
Restringir uma ação por IP de origem / VPC / região / MFA.
`Condition` da política: `aws:SourceIp`, `aws:SourceVpc`, `aws:SourceVpce`, `aws:RequestedRegion`, `aws:MultiFactorAuthPresent`.
Cliente SPA / móvel vs serviço do lado do servidor chamando Cognito.
Clientes públicos (SPA, móvel) → cliente de aplicativo sem secret. Clientes confidenciais (servidor) → cliente de aplicativo com secret; o cliente deve incluir `SECRET_HASH` (HMAC de username + clientId).
Distinguir token de ID do Cognito vs token de Acesso vs token de Refresh.
ID = claims de identidade do usuário (consumir no cliente). Acesso = autorização com escopo para APIs. Refresh = obter novos tokens de ID/acesso. Todos são JWTs, exceto Refresh.
UI de login/cadastro pronta para uso sem construir formulários.
Cognito Hosted UI. Fluxo de código de autorização OAuth2: redirecionar para `/oauth2/authorize` → URL de callback com `code` → troca em `/oauth2/token`.
Criptografar um pequeno segredo (≤4 KB) diretamente com KMS.
`kms:Encrypt` retorna um blob de texto cifrado contendo o ARN da chave. `kms:Decrypt` recupera o texto puro se o chamador tiver permissão e (se especificado) o `EncryptionContext` corresponder.
Criptografar dados grandes com KMS sem atingir o limite de criptografia direta de 4 KB.
Criptografia de envelope. `GenerateDataKey` retorna DEK em texto puro + DEK criptografado; criptografa dados localmente com DEK, armazena DEK criptografado ao lado, descarta DEK em texto puro.
Por quê: KMS impõe controle de acesso sobre o pequeno DEK; a criptografia em massa acontece localmente na velocidade da linha.
Conceder a outro principal acesso com tempo limitado a uma CMK sem editar a política da chave.
Crie uma concessão `kms:CreateGrant` com escopo de operações + beneficiário. Revogue com `RetireGrant`.
Referenciar uma chave KMS indiretamente para que a CMK subjacente possa girar sem alterações no código.
Use `alias/my-key` (ou `arn:aws:kms:region:acct:alias/my-key`). Atualize o alias para apontar para uma nova CMK; os consumidores continuam funcionando.
Escolha um armazenamento de credenciais.
Secrets Manager: rotação integrada, integração nativa com RDS/Redshift/DocumentDB, $0.40/segredo/mês. Parameter Store SecureString: tier gratuito (Standard), sem rotação integrada, caminhos `/app/env/key` estratificados.
Rotacionar credenciais do RDS automaticamente.
Rotação nativa do Secrets Manager (Lambda gerenciada) para Aurora/RDS/DocumentDB/Redshift. O padrão master/user usa um segredo mestre separado para rotacionar o segredo do usuário.
Armazenar um valor de configuração com criptografia KMS em repouso no Parameter Store.
Tipo de parâmetro SecureString. Especifique `--key-id` para uma CMK personalizada; caso contrário, usa `aws/ssm`. Descriptografar requer `kms:Decrypt` na CMK.
Restringir o acesso ao CloudFront a usuários autenticados.
URLs assinadas (recurso único) ou cookies assinados (múltiplos recursos, SPAs/streaming). Assine com um par de chaves do CloudFront armazenado como uma chave pública em um grupo de chaves do CloudFront.
Escolha a criptografia do lado do servidor S3.
SSE-S3 (AES-256 gerenciado, padrão), SSE-KMS (CMK, auditoria via CloudTrail, política de chave), SSE-C (chaves fornecidas pelo cliente, você gerencia), DSSE-KMS (camada dupla para alta conformidade).
Encontrar roles/políticas que concedem acesso fora da conta ou são excessivamente permissivas.
IAM Access Analyzer. Descobertas sobre acesso externo; geração de políticas a partir do histórico do CloudTrail para dimensionamento de privilégio mínimo.
Variável de ambiente Lambda contém um valor sensível.
Lambda criptografa variáveis de ambiente em repouso com KMS por padrão. Para controle em trânsito/na descriptografia, configure uma CMK personalizada e use os assistentes de Criptografia no console para enviar texto cifrado pré-criptografado.
Navegador → API Gateway com cabeçalho `Authorization` é bloqueado pelo preflight.
Adicione método OPTIONS (integração mock). Permita `Authorization` em `Access-Control-Allow-Headers`; permita chamadores em `Access-Control-Allow-Origin`.
Assinar uma requisição HTTP personalizada para um serviço AWS a partir de código não-SDK.
Sigv4: derive a chave de assinatura de secret + data + região + serviço; canonicalize a requisição; assine; adicione os cabeçalhos `Authorization`, `X-Amz-Date`, `X-Amz-Security-Token`.
Assumir uma role ampla, mas restringir o escopo para uma sessão específica.
`AssumeRole` com `Policy` (política de sessão inline) restringe ainda mais as permissões efetivas: intersecção da role + política de sessão.
Acesso S3 negado mesmo que a política IAM o permita.
Ambas, a política de bucket e a política de identidade, são avaliadas. Uma negação explícita em qualquer lugar prevalece. As configurações de Bloqueio de Acesso Público também podem substituir a permissão.
Construir um pipeline CI/CD: source → build → test → deploy com aprovação manual de produção.
Estágios do CodePipeline, cada um com uma ou mais ações. Ação de Aprovação Manual entre Test e Deploy. Source = CodeCommit / GitHub / S3 / ECR.
Definir etapas de build para o CodeBuild.
`buildspec.yml` na raiz do repositório. Fases: `install`, `pre_build`, `build`, `post_build`. Saídas: `artifacts.files`, `cache.paths`. Variáveis de ambiente via `env.variables` ou referências do Parameter Store/Secrets Manager.
Mover o tráfego Lambda 10% e depois 100% com auto-rollback em caso de alarmes.
CodeDeploy com `LambdaCanary10Percent5Minutes` / `10Percent10Minutes` / `10Percent15Minutes` / `10Percent30Minutes`. Configure alarmes do CloudWatch no DeploymentGroup.
Implantação gradual do Lambda em incrementos iguais.
`LambdaLinear10PercentEvery1Minute` / `2Minutes` / `3Minutes` / `10Minutes`. Cada incremento move +10% até 100%.
Implantação blue/green para um serviço ECS atrás de um ALB.
CodeDeploy Compute Platform = ECS. Cria conjunto de tarefas green; ALB move listener para grupo de destino green; aprovação manual opcional antes da troca de tráfego e antes de terminar o blue.
Atualizar uma frota EC2 sem tempo de inatividade total da frota.
Implantação in-place com configurações `OneAtATime` / `HalfAtATime` / `AllAtOnce`. Hooks do Auto Scaling Group pausam novos lançamentos de instância durante a implantação.
Hospedar repositórios Git dentro da AWS com acesso controlado por IAM.
CodeCommit. Autenticação: chaves SSH por usuário IAM, credenciais Git HTTPS por usuário IAM, ou auxiliar de credenciais da AWS CLI. Gatilhos via SNS / Lambda em push.
Escolha uma ferramenta IaC para um aplicativo serverless.
CDK: linguagens de programação (TS/Python/Java/Go/.NET), constructs de aplicativo completos, padrões multi-recurso. SAM: extensão YAML de CFN, focado em serverless, mais simples. Ambos compilam para CloudFormation.
Definir uma stack Lambda + API Gateway + DynamoDB com YAML mínimo.
`Transform: AWS::Serverless-2016-10-31`. Recursos: `AWS::Serverless::Function`, `Api`, `SimpleTable`. `sam build` → `sam deploy --guided`.
Estruturar o código CDK.
`App` contém uma ou mais `Stack`s. Cada Stack contém constructs (L1/L2/L3). `cdk synth` → template CFN. `cdk deploy` implanta via CFN.
Escolha o nível de construct do CDK.
L1 = CFN puro (`CfnXxx`). L2 = wrappers curados com padrões seguros (mais comum). L3 = padrões combinando múltiplos recursos para arquiteturas completas (por exemplo, `LambdaRestApi`).
Pré-visualizar alterações antes de aplicar a uma stack do CloudFormation.
`create-change-set` → revisar JSON de adições/modificações/substituições → `execute-change-set`. Ações de substituição causam recriação de recurso.
A atualização da stack falha no meio.
O CloudFormation faz rollback automático, a menos que `DisableRollback` seja verdadeiro. Preso em `UPDATE_ROLLBACK_FAILED`? Use `ContinueUpdateRollback` com `ResourcesToSkip`.
Prevenir atualização acidental de um recurso crítico (ex: DB RDS) durante atualizações de stack.
Política de stack: JSON negando `Update:Replace` e `Update:Delete` no ID lógico do recurso. Ignore com override explícito em uma atualização específica.
Reutilizar infraestrutura entre stacks.
Stacks aninhadas (`AWS::CloudFormation::Stack` com `TemplateURL`) para reutilização pertencente a um pai. Cross-stack via Outputs + `Fn::ImportValue` para acoplamento mais forte entre stacks separadas.
Injetar um valor do Parameter Store ou segredo do Secrets Manager em um template CFN.
`{{resolve:ssm:/path/to/param}}`, `{{resolve:ssm-secure:/path}}`, `{{resolve:secretsmanager:secret-id:SecretString:json-key}}`. Resolvido no momento da implantação.
Escolha a política de implantação do Elastic Beanstalk.
All-at-once (mais rápido, tempo de inatividade), Rolling (sem instâncias extras, capacidade parcial), Rolling com lote adicional (sem perda de capacidade, custo extra), Immutable (novo ASG, mais seguro), Blue/Green (ambiente separado, troca de CNAMEs).
Personalizar ambiente Elastic Beanstalk (pacotes, arquivos, comandos de container).
YAML `.ebextensions/*.config` no pacote de origem. Plataformas mais recentes: scripts de shell `.platform/hooks/...` para o ciclo de vida prebuild/predeploy/postdeploy.
Precisa de um artefato Lambda estável e nunca mutável.
Publique uma versão numerada. Código + a maioria das configurações (memória, tempo limite, variáveis de ambiente, layers) congelam. `$LATEST` é mutável; versões numeradas não são.
Enviar uma imagem Docker para ECR para ECS / EKS / Lambda.
`aws ecr get-login-password | docker login` → `docker tag` → `docker push`. Imagens de container Lambda: imagem puxada uma vez na implantação; a imagem marcada deve estar na mesma região.
Executar um batch único vs um serviço web de longa duração no ECS.
RunTask = tarefa única, completa e sai. Serviço = mantém N tarefas desejadas, reinicia falhas, integra-se com ALB/NLB.
Reduzir o custo computacional para workloads ECS tolerantes a falhas.
Provedor de capacidade Fargate Spot. Misture com Fargate regular via pesos e base. As tarefas podem ser interrompidas com aviso de 2 minutos.
Rastrear uma requisição que se dispersa entre Lambda → DynamoDB → HTTP externo.
Segmentos X-Ray por salto de serviço, subsegmentos para chamadas downstream. O mapa de serviço visualiza topologia + latência. As regras de amostragem limitam o volume.
Anexar dados pesquisáveis vs de referência a um trace do X-Ray.
Anotações: indexadas, filtráveis no console (ex: `customerId`, `tier`). Metadados: não indexados, formato livre (corpo da requisição, corpo da resposta para depuração).
O custo do X-Ray está alto em produção.
Regra de amostragem personalizada. Padrão: 1 requisição/s inicial + 5% das adicionais. As regras correspondem por serviço / caminho da URL / método.
Consultar logs do Lambda por erros na última hora, agrupados por buckets de 5 minutos.
CloudWatch Logs Insights: `fields @timestamp, @message | filter @message like /ERROR/ | stats count() by bin(5m)`.
Gerar uma métrica personalizada a partir de um padrão de log (ex: contagem de `OutOfMemoryError`).
Filtro de métrica no grupo de logs. O padrão corresponde a eventos de log; o filtro cria uma métrica personalizada do CloudWatch na qual você pode configurar um alarme.
Emitir métricas personalizadas do Lambda sem uma chamada de API `PutMetricData` separada.
Embedded Metric Format: escreva JSON estruturado para stdout; o CloudWatch analisa logs e cria métricas. Mais barato e assíncrono.
Por quê: Desacopla o caminho da métrica do caminho da requisição; sem latência de API ou permissão IAM extra.
O aplicativo emite métricas personalizadas de alta resolução a cada segundo.
`PutMetricData` com `StorageResolution=1` para granularidade de 1 segundo. A resolução padrão é de 60 segundos; alta resolução custa mais.
Cold starts do Lambda atingem metas de latência p99.
Provisioned Concurrency para carga previsível. SnapStart para código Java/Python com inicialização pesada. Dependências leves, use ARM/Graviton, mova inicialização pesada para fora do handler.
Escolher a memória do Lambda para melhor custo/latência.
A memória também escala CPU + rede. Use a máquina de estado AWS Lambda Power Tuning para varrer a memória e encontrar o ponto ideal para sua workload.
Invocação longa do Lambda atinge limite máximo de 15 minutos.
Decomponha em Step Functions; descarregue para Fargate (longa duração) ou Batch (HPC). O máximo do Lambda é de 900 segundos; não negociável.
`TooManyRequestsException` do Lambda; limite de concorrência atingido.
Concorrência reservada por função (limites + reservas) ou solicite aumento do limite no nível da conta. Invocações assíncronas são enfileiradas e retentadas; invocações síncronas geram erro.
DynamoDB retorna `ProvisionedThroughputExceededException`.
CloudWatch `WriteThrottleEvents` / `ReadThrottleEvents`. Mude para o modo On-Demand, aumente a capacidade provisionada ou corrija uma partição quente com um design de chave melhor.
Uma chave de partição recebe tráfego desproporcional; throttling sob baixa carga agregada.
Redesenhe a chave de partição com alta cardinalidade. Para escritas: prefixe com shard aleatório (ex: `shard#user`); para leituras: scatter-gather através de shards.
Precisa de latência de leitura do DynamoDB em microssegundos sem alterar a lógica do aplicativo.
Cluster DAX + SDK DAX como substituto para o SDK do DynamoDB. Leituras servidas do cache em memória; escritas write-through para a tabela.
Escolha uma estratégia de cache para ElastiCache / DAX.
Carregamento lento (cache miss → DB → popular cache): apenas cacheia dados solicitados, mas propenso a dados desatualizados. Write-through (escreve no cache + DB em cada escrita): sempre atualizado, mas as escritas têm custo extra. TTL limita a obsolescência de qualquer forma.
API Gateway retorna 429 Too Many Requests.
Nível de conta padrão: 10.000 req/seg + 5.000 de burst. Overrides por estágio e por método; throttling por chave via Planos de Uso para controle de nível de parceiro.
Erros transitórios do serviço AWS durante tráfego intenso.
O SDK da AWS tenta novamente automaticamente com backoff exponencial + jitter. Configure `RetryMode = adaptive` ou `standard`; ajuste `maxAttempts`.
CloudFront serve conteúdo desatualizado após uma implantação.
Invalide caminhos (`/index.html`, `/*`) - cobrado por caminho acima de 1000/mês gratuito. Melhor: nomes de arquivo versionados (`app.abc123.js`) para que o cache seja naturalmente ignorado.