Pular para conteúdo

LAMBDA_INVOKE - Invocar Função Lambda

O que é este Node?

O LAMBDA_INVOKE é o node responsável por executar funções AWS Lambda de forma síncrona ou assíncrona e receber os resultados diretamente no flow.

Por que este Node existe?

Executar código serverless requer invocação remota com credenciais e configuração. O LAMBDA_INVOKE existe para:

  1. Invocação síncrona: Chama Lambda e aguarda resposta (RequestResponse)
  2. Invocação assíncrona: Dispara Lambda sem aguardar (Event)
  3. Dry run: Testa permissões sem executar função (DryRun)
  4. Payload flexível: Envia qualquer JSON como entrada para a função
  5. Resposta estruturada: Retorna statusCode e payload parseado automaticamente

Como funciona internamente?

Quando o LAMBDA_INVOKE é executado, o sistema:

  1. Autentica AWS: Configura credenciais (accessKeyId, secretAccessKey, region)
  2. Cria cliente Lambda: Instancia AWS.Lambda com credenciais
  3. Prepara invocação: Serializa payload como JSON string
  4. Define tipo: RequestResponse (síncrono) ou Event (assíncrono)
  5. Invoca função: Executa lambda.invoke() com FunctionName e Payload
  6. Processa resposta: Parseia Payload retornado e extrai statusCode
  7. Se erro AWS: Lança exceção com detalhes do erro
  8. Se sucesso: Retorna success=true com statusCode e payload parseado

Código interno (aws-executors.service.ts:238-248): 

case 'invoke':
  const invokeResult = await lambda.invoke({
    FunctionName: data.functionName,
    InvocationType: data.invocationType || 'RequestResponse',
    Payload: JSON.stringify(data.payload),
  }).promise();
  return {
    success: true,
    statusCode: invokeResult.StatusCode,
    payload: JSON.parse(invokeResult.Payload as string),
  };

Quando você DEVE usar este Node?

Use LAMBDA_INVOKE sempre que precisar executar lógica serverless da AWS:

Casos de uso

  1. Processamento pesado: "Execute análise de dados na Lambda"
  2. Integrações externas: "Lambda conecta com API de terceiros"
  3. Transformações complexas: "Lambda processa imagem e retorna URL"
  4. Validações avançadas: "Lambda verifica CPF em base externa"
  5. Automações: "Lambda dispara workflow interno da empresa"
  6. Machine Learning: "Lambda executa modelo de predição"

Quando NÃO usar LAMBDA_INVOKE

  • Funções inexistentes: Use AWS Lambda Console para criar a função primeiro
  • Credenciais erradas: Lambda retornará erro 403 Forbidden
  • Timeout curto: RequestResponse tem limite de 15 minutos
  • Payload grande: Máximo 6MB síncrono, 256KB assíncrono

Parâmetros Detalhados

accessKeyId (string, obrigatório)

O que é: Access Key ID da conta AWS com permissão lambda:InvokeFunction.

Como obter: 1. AWS Console → IAM → Users → Security Credentials 2. Create Access Key 3. Salve Access Key ID e Secret Access Key

Flow completo para testar:

{
  "name": "Teste Lambda Invoke - AccessKeyId",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "lambda_1",
      "type": "aws_lambda",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Invocar Lambda",
        "parameters": {
          "operation": "invoke",
          "accessKeyId": "AKIAIOSFODNN7EXAMPLE",
          "secretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
          "region": "us-east-1",
          "functionName": "minha-funcao",
          "invocationType": "RequestResponse",
          "payload": { "chave": "valor" }
        }
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Mostrar Resultado",
        "parameters": {
          "message": "Lambda executada! Status: {{lambda_statusCode}}"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 700, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "lambda_1" },
    { "source": "lambda_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Teste: Substitua credenciais reais. Lambda será invocada.

secretAccessKey (string, obrigatório)

O que é: Secret Access Key correspondente ao Access Key ID.

Segurança: NUNCA commite este valor. Use variáveis de ambiente ou AWS Secrets Manager.

Flow completo para testar:

{
  "name": "Teste Lambda Invoke - SecretAccessKey",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "variable_1",
      "type": "variable",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Configurar Credenciais",
        "parameters": {
          "variables": {
            "aws_key": "AKIAIOSFODNN7EXAMPLE",
            "aws_secret": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
          }
        }
      }
    },
    {
      "id": "lambda_1",
      "type": "aws_lambda",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Invocar Lambda",
        "parameters": {
          "operation": "invoke",
          "accessKeyId": "{{aws_key}}",
          "secretAccessKey": "{{aws_secret}}",
          "region": "us-east-1",
          "functionName": "processar-pedido",
          "payload": { "pedido_id": 123 }
        }
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 700, "y": 100 },
      "data": {
        "label": "Confirmar",
        "parameters": {
          "message": "Pedido processado com sucesso!"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 900, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "variable_1" },
    { "source": "variable_1", "target": "lambda_1" },
    { "source": "lambda_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Teste: Use variáveis para não expor credenciais em logs.

region (string, obrigatório)

O que é: Região AWS onde a função Lambda está hospedada.

Valores comuns: - us-east-1 (Virginia) - us-west-2 (Oregon) - sa-east-1 (São Paulo) - eu-west-1 (Irlanda)

Flow completo para testar:

{
  "name": "Teste Lambda Invoke - Region",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "lambda_1",
      "type": "aws_lambda",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Lambda São Paulo",
        "parameters": {
          "operation": "invoke",
          "accessKeyId": "AKIAIOSFODNN7EXAMPLE",
          "secretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
          "region": "sa-east-1",
          "functionName": "processar-boleto",
          "payload": { "valor": 100.50 }
        }
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Confirmar",
        "parameters": {
          "message": "Lambda executada na região sa-east-1"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 700, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "lambda_1" },
    { "source": "lambda_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Teste: Lambda deve existir na região especificada.

functionName (string, obrigatório)

O que é: Nome ou ARN da função Lambda a ser invocada.

Formatos aceitos: - Nome: minha-funcao - ARN completo: arn:aws:lambda:us-east-1:123456789012:function:minha-funcao - ARN parcial: 123456789012:function:minha-funcao

Flow completo para testar:

{
  "name": "Teste Lambda Invoke - FunctionName",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "input_1",
      "type": "input",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Nome da Função",
        "parameters": {
          "message": "Digite o nome da função Lambda:",
          "variable": "nome_funcao"
        }
      }
    },
    {
      "id": "lambda_1",
      "type": "aws_lambda",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Invocar Lambda Dinâmica",
        "parameters": {
          "operation": "invoke",
          "accessKeyId": "AKIAIOSFODNN7EXAMPLE",
          "secretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
          "region": "us-east-1",
          "functionName": "{{nome_funcao}}",
          "payload": {}
        }
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 700, "y": 100 },
      "data": {
        "label": "Resultado",
        "parameters": {
          "message": "Função {{nome_funcao}} executada!"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 900, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "input_1" },
    { "source": "input_1", "target": "lambda_1" },
    { "source": "lambda_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Teste: Digite nome de Lambda existente na sua conta AWS.

invocationType (string, opcional)

O que é: Tipo de invocação da Lambda.

Valores possíveis: - RequestResponse (padrão): Síncrono - aguarda resposta - Event: Assíncrono - não aguarda resposta - DryRun: Valida permissões sem executar

Padrão: "RequestResponse"

Flow completo para testar (RequestResponse):

{
  "name": "Teste Lambda Invoke - RequestResponse",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "lambda_1",
      "type": "aws_lambda",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Lambda Síncrona",
        "parameters": {
          "operation": "invoke",
          "accessKeyId": "AKIAIOSFODNN7EXAMPLE",
          "secretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
          "region": "us-east-1",
          "functionName": "calcular-frete",
          "invocationType": "RequestResponse",
          "payload": { "cep": "01310-100", "peso": 2.5 }
        }
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Mostrar Frete",
        "parameters": {
          "message": "Frete calculado: R$ {{lambda_payload.valor}}"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 700, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "lambda_1" },
    { "source": "lambda_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Flow completo para testar (Event - Assíncrono):

{
  "name": "Teste Lambda Invoke - Event",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "lambda_1",
      "type": "aws_lambda",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Lambda Assíncrona",
        "parameters": {
          "operation": "invoke",
          "accessKeyId": "AKIAIOSFODNN7EXAMPLE",
          "secretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
          "region": "us-east-1",
          "functionName": "enviar-relatorio-email",
          "invocationType": "Event",
          "payload": { "usuario_id": 456 }
        }
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Confirmar",
        "parameters": {
          "message": "Relatório será enviado em background."
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 700, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "lambda_1" },
    { "source": "lambda_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Teste: - RequestResponse: Flow aguarda resposta da Lambda - Event: Flow continua imediatamente sem aguardar

payload (object, obrigatório)

O que é: Dados JSON enviados como entrada para a função Lambda.

Estrutura: Qualquer objeto JSON válido que sua Lambda espera receber.

Flow completo para testar:

{
  "name": "Teste Lambda Invoke - Payload",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "input_1",
      "type": "input",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Nome do Cliente",
        "parameters": {
          "message": "Digite o nome do cliente:",
          "variable": "nome_cliente"
        }
      }
    },
    {
      "id": "number_1",
      "type": "number",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Valor do Pedido",
        "parameters": {
          "message": "Digite o valor do pedido:",
          "variable": "valor_pedido"
        }
      }
    },
    {
      "id": "lambda_1",
      "type": "aws_lambda",
      "position": { "x": 700, "y": 100 },
      "data": {
        "label": "Processar Pedido",
        "parameters": {
          "operation": "invoke",
          "accessKeyId": "AKIAIOSFODNN7EXAMPLE",
          "secretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
          "region": "us-east-1",
          "functionName": "processar-pedido",
          "payload": {
            "cliente": "{{nome_cliente}}",
            "valor": "{{valor_pedido}}",
            "data": "2025-01-15"
          }
        }
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 900, "y": 100 },
      "data": {
        "label": "Confirmar",
        "parameters": {
          "message": "Pedido processado! ID: {{lambda_payload.pedido_id}}"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 1100, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "input_1" },
    { "source": "input_1", "target": "number_1" },
    { "source": "number_1", "target": "lambda_1" },
    { "source": "lambda_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Teste: Lambda receberá objeto com cliente, valor e data.

Parâmetros

Campo Tipo Obrigatório Descrição
operation string Sim Deve ser "invoke"
accessKeyId string Sim Access Key ID da AWS
secretAccessKey string Sim Secret Access Key da AWS
region string Sim Região AWS (ex: us-east-1)
functionName string Sim Nome ou ARN da função Lambda
invocationType string Não RequestResponse, Event ou DryRun (padrão: RequestResponse)
payload object Sim Objeto JSON enviado para a Lambda

Exemplo 1: Invocar Lambda para Cálculo

Objetivo: Chamar Lambda que calcula desconto e retorna valor final

JSON para Importar

{
  "name": "Calcular Desconto com Lambda",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "number_1",
      "type": "number",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Valor do Produto",
        "parameters": {
          "message": "Digite o valor do produto:",
          "variable": "valor"
        }
      }
    },
    {
      "id": "lambda_1",
      "type": "aws_lambda",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Calcular Desconto",
        "parameters": {
          "operation": "invoke",
          "accessKeyId": "AKIAIOSFODNN7EXAMPLE",
          "secretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
          "region": "us-east-1",
          "functionName": "calcular-desconto",
          "invocationType": "RequestResponse",
          "payload": {
            "valor": "{{valor}}",
            "tipo_cliente": "premium"
          }
        }
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 700, "y": 100 },
      "data": {
        "label": "Mostrar Resultado",
        "parameters": {
          "message": "Valor original: R$ {{valor}}\nDesconto: {{lambda_payload.desconto}}%\nValor final: R$ {{lambda_payload.valor_final}}"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 900, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "number_1" },
    { "source": "number_1", "target": "lambda_1" },
    { "source": "lambda_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Saída esperada: 

Sistema: Digite o valor do produto:
Usuário: 100
Sistema: Valor original: R$ 100
Desconto: 15%
Valor final: R$ 85

Exemplo 2: Disparar Lambda Assíncrona

Objetivo: Enviar notificação por Lambda sem aguardar resposta

JSON para Importar

{
  "name": "Notificar via Lambda Assíncrona",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "input_1",
      "type": "input",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "Mensagem",
        "parameters": {
          "message": "Digite a mensagem para notificação:",
          "variable": "mensagem"
        }
      }
    },
    {
      "id": "lambda_1",
      "type": "aws_lambda",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Enviar Notificação",
        "parameters": {
          "operation": "invoke",
          "accessKeyId": "AKIAIOSFODNN7EXAMPLE",
          "secretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
          "region": "us-east-1",
          "functionName": "enviar-notificacao-push",
          "invocationType": "Event",
          "payload": {
            "mensagem": "{{mensagem}}",
            "usuarios": ["user1", "user2", "user3"]
          }
        }
      }
    },
    {
      "id": "message_1",
      "type": "message",
      "position": { "x": 700, "y": 100 },
      "data": {
        "label": "Confirmar",
        "parameters": {
          "message": "Notificação enviada em background!"
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 900, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "input_1" },
    { "source": "input_1", "target": "lambda_1" },
    { "source": "lambda_1", "target": "message_1" },
    { "source": "message_1", "target": "end_1" }
  ]
}

Saída esperada: 

Sistema: Digite a mensagem para notificação:
Usuário: Promoção de 50% OFF!
Sistema: Notificação enviada em background!

Exemplo 3: Lambda com Condicional

Objetivo: Invocar Lambda e tomar decisão baseada no resultado

JSON para Importar

{
  "name": "Validar Dados com Lambda",
  "nodes": [
    {
      "id": "start_1",
      "type": "start",
      "position": { "x": 100, "y": 100 },
      "data": { "label": "Início" }
    },
    {
      "id": "input_1",
      "type": "input",
      "position": { "x": 300, "y": 100 },
      "data": {
        "label": "CPF",
        "parameters": {
          "message": "Digite o CPF:",
          "variable": "cpf"
        }
      }
    },
    {
      "id": "lambda_1",
      "type": "aws_lambda",
      "position": { "x": 500, "y": 100 },
      "data": {
        "label": "Validar CPF",
        "parameters": {
          "operation": "invoke",
          "accessKeyId": "AKIAIOSFODNN7EXAMPLE",
          "secretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
          "region": "sa-east-1",
          "functionName": "validar-cpf",
          "payload": {
            "cpf": "{{cpf}}"
          }
        }
      }
    },
    {
      "id": "condition_1",
      "type": "condition",
      "position": { "x": 700, "y": 100 },
      "data": {
        "label": "CPF Válido?",
        "parameters": {
          "variable": "lambda_payload.valido",
          "operator": "equals",
          "value": true
        }
      }
    },
    {
      "id": "message_sim",
      "type": "message",
      "position": { "x": 900, "y": 50 },
      "data": {
        "label": "CPF OK",
        "parameters": {
          "message": "CPF válido! Nome: {{lambda_payload.nome}}"
        }
      }
    },
    {
      "id": "message_nao",
      "type": "message",
      "position": { "x": 900, "y": 150 },
      "data": {
        "label": "CPF Inválido",
        "parameters": {
          "message": "CPF inválido ou não encontrado."
        }
      }
    },
    {
      "id": "end_1",
      "type": "end",
      "position": { "x": 1100, "y": 100 },
      "data": { "label": "Fim" }
    }
  ],
  "edges": [
    { "source": "start_1", "target": "input_1" },
    { "source": "input_1", "target": "lambda_1" },
    { "source": "lambda_1", "target": "condition_1" },
    { "source": "condition_1", "target": "message_sim", "label": "true" },
    { "source": "condition_1", "target": "message_nao", "label": "false" },
    { "source": "message_sim", "target": "end_1" },
    { "source": "message_nao", "target": "end_1" }
  ]
}

Saída esperada: 

Sistema: Digite o CPF:
Usuário: 123.456.789-00
Sistema: CPF válido! Nome: João Silva

Resposta do Node

Invocação Síncrona (RequestResponse)

{
  "success": true,
  "statusCode": 200,
  "payload": {
    "resultado": "dados retornados pela Lambda",
    "qualquer_campo": "valor"
  }
}

Invocação Assíncrona (Event)

{
  "success": true,
  "statusCode": 202,
  "payload": null
}

Permissões IAM Necessárias

A Access Key precisa ter a política:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "lambda:InvokeFunction",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:*"
    }
  ]
}

Tipos de Invocação

RequestResponse (Síncrono)

  • Comportamento: Aguarda execução completa da Lambda
  • Timeout: Até 15 minutos
  • Payload máximo: 6 MB
  • Uso: Quando precisa do resultado imediato
  • StatusCode: 200 (sucesso) ou 4xx/5xx (erro)

Event (Assíncrono)

  • Comportamento: Lambda executa em background
  • Timeout: Não afeta o flow
  • Payload máximo: 256 KB
  • Uso: Fire-and-forget (dispara e esquece)
  • StatusCode: 202 (aceito)

DryRun (Validação)

  • Comportamento: Apenas valida permissões
  • Execução: Lambda NÃO é executada
  • Uso: Testar se credenciais têm acesso
  • StatusCode: 204 (sem conteúdo)

Boas Práticas

✅ SIM:

  • Use variáveis para credenciais AWS (nunca hardcode)
  • Configure timeout adequado na Lambda (não no flow)
  • Use RequestResponse quando precisa do resultado
  • Use Event para tarefas longas ou background
  • Trate erros com CONDITION no payload retornado
  • Valide credenciais com DryRun antes de produção

❌ NÃO:

  • Nunca commite accessKeyId/secretAccessKey no código
  • Não use RequestResponse para processos > 15 minutos
  • Não envie payloads > 6MB (RequestResponse) ou > 256KB (Event)
  • Não invoque Lambdas inexistentes (gera erro 404)
  • Não use credenciais sem permissão lambda:InvokeFunction

Dicas

💡 Variáveis de resposta: Lambda retorna em lambda_payload.* (ex: {{lambda_payload.resultado}})

💡 StatusCode: 200=sucesso, 202=assíncrono aceito, 4xx=erro cliente, 5xx=erro Lambda

💡 Logs: Lambda escreve logs no CloudWatch Logs automaticamente

💡 Custos: Invocação é cobrada por tempo de execução e memória usada

💡 Retry automático: Event tem retry automático em caso de falha (RequestResponse não)

Tratamento de Erros

Se Lambda retornar erro, o node lançará exceção:

{
  "error": "Lambda execution error",
  "message": "Task timed out after 3.00 seconds",
  "statusCode": 500
}

Use CONDITION para verificar lambda_payload.error e tratar:

{
  "type": "condition",
  "parameters": {
    "variable": "lambda_payload.error",
    "operator": "exists",
    "value": false
  }
}

Exemplo de Payload Complexo

{
  "payload": {
    "operacao": "processar_pedido",
    "dados": {
      "cliente": {
        "nome": "{{nome_cliente}}",
        "email": "{{email_cliente}}"
      },
      "itens": [
        { "produto_id": 1, "quantidade": 2 },
        { "produto_id": 5, "quantidade": 1 }
      ],
      "pagamento": {
        "metodo": "cartao",
        "parcelas": 3
      }
    },
    "metadata": {
      "origem": "whatsapp",
      "flow_id": "{{flow_id}}"
    }
  }
}

Ambiente Variables na Lambda

Sua função Lambda pode ler variáveis de ambiente:

// Lambda function (Node.js)
exports.handler = async (event) => {
  const apiKey = process.env.API_KEY;
  const dbHost = process.env.DB_HOST;

  // Processar event recebido do flow
  const resultado = await processar(event);

  return {
    statusCode: 200,
    body: JSON.stringify(resultado)
  };
};

Configure no AWS Lambda Console → Configuration → Environment variables.

Próximo Node

→ LAMBDA_LIST - Listar funções Lambda → SQS_SEND - Enviar mensagem SQS → DYNAMODB_PUT - Inserir item DynamoDB