LambdaComunidade
Nível de dificuldade: Avançado (4 de 5)
Lambda Managed Instances estende execução assíncrona para até 90 minutos
Por quase dez anos, 900 segundos foram o teto duro de qualquer invocação Lambda: se o processamento contínuo passasse disso, a resposta padrão era "use outro serviço". Essa parede se moveu, mas só para um caminho específico: funções rodando em Lambda Managed Instances (LMI), invocadas de forma assíncrona ou via event source mapping, agora podem levar até 90 minutos numa única invocação. Invocações síncronas continuam presas em 15 minutos, não importa o valor do Timeout da função.
O desenvolvedor Avneet Bansal testou o limite na prática e publicou o passo a passo no DEV Community: criou uma função LMI, rodou uma invocação contínua de 20 minutos e confirmou, pelos próprios logs do platform.report, que o comportamento é real. Não é só o anúncio da AWS reproduzido: é o setup inteiro, incluindo as armadilhas que a documentação não deixa óbvias.
Em números
- 90 minutos é o novo teto de execução contínua para invocações assíncronas em funções Lambda Managed Instances, contra os 15 minutos clássicos.
- 15 minutos continua sendo o limite para invocações síncronas (
RequestResponse), mesmo que oTimeoutda função esteja configurado acima disso. - 2048 MB é a memória mínima exigida pela AWS para criar uma função Managed Instances; abaixo disso, a chamada
create_functionfalha com erro de validação. - 1.200.625 milissegundos (cerca de 20 minutos) foi a duração registrada pelo
platform.reportno teste de Bansal, bem além dos 900.000 ms do limite clássico.
O que você vai construir
O roteiro reproduz o experimento de Bansal: uma função Lambda rodando em Managed Instances, com um handler Python que faz trabalho de CPU leve em loop e registra um heartbeat a cada minuto, incluindo context.get_remaining_time_in_millis(). A função é invocada de forma assíncrona (InvocationType="Event") com uma carga que pede 1.200 segundos de execução, cruzando de propósito a antiga marca de 900 segundos.
No fim, você tem nos logs do CloudWatch a prova de que o remaining_ms inicial bate com um Timeout de 1800 segundos (não 900), e o registro final de durationMs no platform.report confirma a duração real da invocação. É esse número, não o anúncio da AWS, que sustenta a alegação do 90 minutos.
Pré-requisitos
- Conta AWS com permissão para criar funções Lambda, roles IAM e capacity providers.
- Duas roles IAM: a execution role de sempre (
AWSLambdaBasicExecutionRole) e uma operator role nova, com a managed policyAWSLambdaManagedEC2ResourceOperatore trust policy paralambda.amazonaws.com. - Uma VPC com subnets e um security group (a VPC default serve para teste).
- AWS CLI configurado e boto3 instalado (
pip install boto3). - Runtime Python 3.13; Bansal rodou os testes na região us-west-2. A fonte não confirma disponibilidade em sa-east-1, então vale checar a lista de regiões do Lambda Managed Instances antes de replicar os passos.
Passo a passo
- Crie a operator role. No IAM, crie uma role com
lambda.amazonaws.comcomo serviço confiável e anexeAWSLambdaManagedEC2ResourceOperator. Essa role é o que permite ao Lambda gerenciar instâncias EC2 em seu nome; não existe equivalente no Lambda clássico. - Crie o capacity provider antes da função. Ele guarda a VPC, a operator role e os requisitos de instância:
lam.create_capacity_provider(
CapacityProviderName="lmi-lab-cp",
VpcConfig={"SubnetIds": subnets, "SecurityGroupIds": [sg]},
PermissionsConfig={"CapacityProviderOperatorRoleArn": operator_role_arn},
InstanceRequirements={"Architectures": ["x86_64"]},
CapacityProviderScalingConfig={"ScalingMode": "Auto"},
)Espere o status mudar para Active antes de prosseguir.
- Crie a função com três ajustes que não existem no Lambda clássico:
Timeoutacima de 900 (o teto assíncrono é 5400 segundos, ou seja, 90 minutos),MemorySizede pelo menos 2048 MB, e o blocoCapacityProviderConfigapontando para o capacity provider:
lam.create_function(
FunctionName="lmi-lab-fn",
Runtime="python3.13",
Role=exec_role_arn,
Handler="lmi_handler.handler",
Code={"ZipFile": zip_bytes},
Timeout=1800,
MemorySize=2048,
CapacityProviderConfig={
"LambdaManagedInstancesCapacityProviderConfig": {"CapacityProviderArn": cp_arn}
},
)- Publique uma versão e provisione capacidade. Uma função clássica fica invocável assim que termina de criar; uma função LMI nasce no estado
ActiveNonInvocablee só aceita chamadas depois que você setaMinExecutionEnvironments:
version = lam.publish_version(FunctionName=FN)["Version"]
lam.put_function_scaling_config(
FunctionName=FN, Qualifier=version,
FunctionScalingConfig={"MinExecutionEnvironments": 1, "MaxExecutionEnvironments": 2},
)Esse put_function_scaling_config logo após o publish_version pode lançar ResourceConflictException de forma transitória; um retry com backoff resolve.
- Invoque a versão publicada, de forma assíncrona. A capacidade está anexada à versão, não ao
$LATEST, e uma chamadaRequestResponsecontinua limitada a 15 minutos independentemente doTimeoutconfigurado:
lam.invoke(
FunctionName="lmi-lab-fn:1",
InvocationType="Event",
Payload=json.dumps({"run_seconds": 1200}).encode(),
)- Saiba que uma mesma instância pode rodar várias invocações ao mesmo tempo. O Lambda clássico roda uma invocação por execution environment; o LMI pode rodar várias, usando processos separados no caso do Python. Variáveis globais não são compartilhadas entre elas, mas
/tmpé compartilhado, então nomes de arquivo temporário devem incluircontext.aws_request_id. Os padrões, se você não ajustar, sãoPerExecutionEnvironmentMaxConcurrencyde 16 eExecutionEnvironmentMemoryGiBPerVCpude 2.0.
Testando
A verificação acontece em duas pontas: os logs da própria função e o estado real da instância EC2 por trás dela.
No CloudWatch, o primeiro heartbeat já confirma o novo teto: remaining_ms começa em 1.799.999, valor impossível numa função clássica (que começaria em no máximo 900.000). Os heartbeats seguintes marcam past_15_min: true a partir do minuto 15, e o registro final do platform.report traz durationMs = 1.200.625.546, uma invocação única faturada por cerca de 20 minutos contínuos, sem encadeamento e sem Step Functions.
A segunda ponta é confirmar que a instância EC2 por trás da invocação realmente existe. Desde abril de 2026, a visibilidade padrão do EC2 esconde instâncias lançadas por serviços gerenciados, incluindo o Lambda Managed Instances, de um describe-instances comum. É preciso o flag --include-managed-resources:
aws ec2 describe-instances --include-managed-resources \
--filters Name=instance-state-name,Values=pending,running \
--query 'Reservations[].Instances[].[InstanceId,InstanceType,State.Name,LaunchTime]' \
--output tableCada instância carrega as tags aws:ec2:managed-launch=lambda-managed-instances e aws:lambda:capacity-provider=<arn>, que identificam a qual capacity provider ela pertence. Sem instance type definido, o Lambda escolhe por você; no teste da fonte, a escolha caiu num m7a.xlarge.
| Tipo de invocação | Limite clássico | Limite com LMI |
|---|---|---|
Síncrona (RequestResponse) | 15 min | 15 min (sem mudança) |
Assíncrona (Event) | 15 min | até 90 min |
| Event source mapping | 15 min | até 90 min |
Limpando os recursos
O LMI fatura por tempo de instância EC2, não por GB-segundo: uma instância provisionada e esquecida continua cobrando mesmo sem nenhuma invocação em andamento. No teste da fonte, uma instância ficou de pé pelo tempo do setup, do run de 20 minutos e do teardown, ficando abaixo de uma hora e custando, segundo a fonte, bem menos de um dólar.
A ordem da limpeza importa:
- Delete a função primeiro; isso desanexa as versões do capacity provider.
- Delete o capacity provider, repetindo a chamada se necessário, porque ele não pode ser removido enquanto houver versão ainda anexada.
- Delete as duas roles IAM e o log group do CloudWatch.
- Se a função foi criada pelo console, apague também a execution role extra que ele cria (algo como
<função>-role-xxxxxxxx) e a policy gerenciadaAWSLambdaBasicExecutionRole-<id>associada a ela, nessa ordem. - Rode de novo o
describe-instances --include-managed-resourcespara confirmar que nada ficourunning.
Não tente terminar a instância EC2 diretamente: é a remoção do capacity provider que faz isso. Segundo a fonte, a função some em cerca de um minuto após o delete-function, e a instância vai para terminated logo depois que a exclusão do capacity provider é aceita. Deixar MinExecutionEnvironments em 1 numa função de teste esquecida é como alguns centavos por hora viram, sem aviso, uma linha na fatura.
Próximos passos
O teto de 90 minutos resolve um problema específico: uma computação contínua que não dá para dividir em etapas, como uma inferência de modelo longa, uma transcodificação de mídia pesada ou um job batch que mantém estado em memória. Para esse formato, o LMI tira do caminho a decisão de migrar para ECS ou Fargate só por causa do timeout.
Não é a ferramenta certa quando a maior parte do tempo é espera, não processamento: uma aprovação humana, um callback, um delay agendado. Nesses casos, Lambda Durable Functions suspende e libera o compute durante a espera em vez de manter uma instância provisionada o tempo todo parada.
| Cenário | Melhor opção |
|---|---|
| Computação contínua, sem espera, até 90 min | Lambda Managed Instances |
| Espera longa entre etapas (aprovação, callback, delay) | Lambda Durable Functions |
| Processamento acima de 90 min ou orquestração complexa | ECS/Fargate ou Step Functions |
Uma forma simples de decidir: se o relógio é longo porque o código está ocupado, é caso de Managed Instances; se é longo porque o código está esperando, é caso de durable functions. Os dois recursos soam parecidos no anúncio ("o Lambda agora roda mais tempo"), mas resolvem problemas bem diferentes por baixo do capô, e escolher o errado significa pagar por instância EC2 ociosa ou reconstruir em outro serviço o que já cabia no Lambda.
Fonte: DEV Community — #aws
Serviços neste textoLambda
Na dúvida sobre qual usar?ECS, EKS ou Lambda?Três perguntas, a comparação e a nossa recomendaçãoLeve 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: "Lambda Managed Instances estende execução assíncrona para até 90 minutos" (https://awshub.com.br/comunidade/lambda-managed-instances-estende-execucao-assincrona-para-ate-90-minutos). Resumo: O Lambda Managed Instances permite invocações assíncronas de até 90 minutos, seis vezes o limite clássico de 15. Um teste publicado no DEV Community comprovou o novo teto rodando uma função Python por 20 minutos sem interrupção. Serviços: Lambda 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ã?