Uma função do AWS Lambda pode chamar outra

Eu tenho 2 funções Lambda - uma que produz uma cotação e outra que transforma uma cotação em um pedido. Gostaria que a função lambda Order chame a função Quote para gerar novamente a cotação, em vez de apenas recebê-la de um cliente não confiável.

Eu procurei em todos os lugares em que consigo pensar - mas não consigo ver como eu encadear ou chamar as funções ... certamente isso existe!

Eu encontrei uma maneira de usar o aws-sdk.

var aws = require('aws-sdk');
var lambda = new aws.Lambda({
  region: 'us-west-2' //change to your region
});

lambda.invoke({
  FunctionName: 'name_of_your_lambda_function',
  Payload: JSON.stringify(event, null, 2) // pass params
}, function(error, data) {
  if (error) {
    context.done('error', error);
  }
  if(data.Payload){
   context.succeed(data.Payload)
  }
});

Você pode encontrar o documento aqui: http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Lambda.html

Você deve encadear sua Lambda functionsvia SNS. Essa abordagem fornece bom desempenho, latência e escalabilidade para um esforço mínimo.

O seu primeiro Lambdapublica mensagens para o seu SNS Topice o segundo Lambdaestá inscrito neste tópico. Assim que as mensagens chegam ao tópico, o segundo Lambdaé executado com a mensagem, como parâmetro de entrada.

Consulte Chamando funções do Lambda usando notificações do Amazon SNS .

Você também pode usar essa abordagem para invocar funções Lambda entre contas via SNS .

aqui está um código de exemplo para python,

from boto3 import client as boto3_client
from datetime import datetime
import json

lambda_client = boto3_client('lambda')

def lambda_handler(event, context):
    msg = {"key":"new_invocation", "at": datetime.now()}
    invoke_response = lambda_client.invoke(FunctionName="another_lambda_",
                                           InvocationType='Event',
                                           Payload=json.dumps(msg))
    print(invoke_response)

Aliás, você também precisará adicionar uma política como essa à sua função lambda

   {
        "Sid": "Stmt1234567890",
        "Effect": "Allow",
        "Action": [
            "lambda:InvokeFunction"
        ],
        "Resource": "*"
    }

Desde que essa pergunta foi feita, a Amazon lançou as Step Functions ( https://aws.amazon.com/step-functions/ ).

Um dos princípios fundamentais por trás do AWS Lambda é que você pode se concentrar mais na lógica de negócios e menos na lógica do aplicativo que une tudo isso. As funções de etapa permitem orquestrar interações complexas entre funções sem precisar escrever o código para fazê-lo.

Esta solução é feita usando boto3 e Python:

import boto3
import json

invokeLambda = boto3.client('lambda', region_name='eu-west-1')

def lambda_handler(event, context):
    invokeLambda.invoke(FunctionName = 'function_name', InvocationType = 'RequestResponse', Payload = json.dumps(event))

    return True

Eu estava pensando em cortar o SNS até ver isso nos documentos do cliente Lambda (versão Java) :

Cliente para acessar o AWS Lambda. Todas as chamadas de serviço feitas usando esse cliente estão bloqueando e não retornarão até que a chamada de serviço seja concluída.

Portanto, o SNS tem uma vantagem óbvia: é assíncrono. Seu lambda não esperará a conclusão do lambda subsequente.

A Amazon introduziu funções de etapas no AWS lambda em 2016. Acho que agora é mais conveniente usar a função de etapas, pois é muito fácil usá-las. Você pode construir uma máquina de estado com duas funções lambda como:

• produz uma cotação
• transforma uma cotação em um pedido

Você pode fazer isso facilmente como abaixo:

Aqui você pode ter o primeiro estado para produz uma cotação e outro para se transformar em ordem

{
  Comment: "Produce a quote and turns into an order",
  StartAt: "ProduceQuote",
  States: {
    ProduceQuote: {
      "Type": Task,
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:ProduceQuote",
      "next": TurnsToOrder
    }
    TurnsToOrder: {
      Type: Task,
      Resource: "arn:aws:lambda:us-east-1:123456789012:function:ProduceQuote",
      end: true
    }
  }
}

As funções de etapas facilitam a gravação de várias funções lambda e a execução em sequência ou em paralelo. Você pode obter mais informações sobre as funções das etapas lambda aqui: Funções das etapas

Eu estava trabalhando com a resposta fornecida pelo blueskin, mas não consegui ler a resposta da Carga útil, porque o InvocationType = 'Event' é assíncrono , então mudei como InvocationType = 'RequestResponse' e agora tudo funciona bem.

Em java, podemos fazer o seguinte:

AWSLambdaAsync awsLambdaAsync = AWSLambdaAsyncClientBuilder.standard().withRegion("us-east-1").build();

InvokeRequest invokeRequest = new InvokeRequest();
invokeRequest.withFunctionName("youLambdaFunctionNameToCall").withPayload(payload);

InvokeResult invokeResult = awsLambdaAsync.invoke(invokeRequest); 

Aqui, a carga útil é seu objeto java com string que precisa ser passado como objeto Json para outro lambda, caso você precise passar algumas informações da chamada lambda para a chamada lambda.

Você pode usar o recurso Async.js Waterfall - veja a parte inferior do grande bloco de código na Etapa 3 deste documento para obter um exemplo:

https://aws.amazon.com/blogs/compute/better-together-amazon-ecs-and-aws-lambda/

Você pode invocar a função lambda diretamente (pelo menos via Java) usando AWSLambdaClientconforme descrito na postagem do blog da AWS .

Estou tendo o mesmo problema, mas a função Lambda que eu implemento insere uma entrada no DynamoDB, então minha solução usa os gatilhos do DynamoDB.

Eu faço o banco de dados invocar uma função Lambda para cada inserção / atualização na tabela, portanto, isso separa a implementação de duas funções Lambda.

A documentação está aqui: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.Lambda.html

Aqui está uma explicação guiada: https://aws.amazon.com/blogs/aws/dynamodb-update-triggers-streams-lambda-cross-region-replication-app/

Tipo de solução rotatória, mas eu apenas chamo o ponto de extremidade da API para minhas funções lambda quando preciso encadeá-las. Isso permite que você decida durante a codificação se deseja que eles sejam assíncronos ou não.

Caso você não queira configurar uma solicitação POST, basta configurar uma solicitação GET simples com alguns ou nenhum parâmetro de string de consulta para facilitar a passagem de eventos.

- Editar -

Consulte: https://docs.aws.amazon.com/apigateway/api-reference/making-http-requests/

e: http://docs.aws.amazon.com/lambda/latest/dg/with-on-demand-https-example.html

Outros apontaram para usar SQS e Step Functions. Mas essas duas soluções adicionam custos adicionais. As transições de estado da função Step são supostamente muito caras.

O AWS lambda oferece alguma lógica de nova tentativa. Onde tenta algo por 3 vezes. Não tenho certeza se isso ainda é válido quando você o aciona usando a API.

Aqui está o exemplo python de chamar outra função lambda e obtém sua resposta. Existem dois tipos de chamada 'RequestResponse' e 'Event' . Use 'RequestResponse' se desejar obter a resposta da função lambda e use 'Event' para chamar a função lambda de forma assíncrona. Portanto, os dois modos assíncrono e síncrono estão disponíveis.

    lambda_response = lambda_client.invoke(
                FunctionName = lambda_name,
                InvocationType = 'RequestResponse',
                Payload = json.dumps(input)
                )
    resp_str = lambda_response['Payload'].read()
    response = json.loads(resp_str)

Você pode definir o ambiente AWS_REGION.

assert(process.env.AWS_REGION, 'Missing AWS_REGION env (eg. ap-northeast-1)');
const aws = require('aws-sdk');
const lambda = new aws.Lambda();