Une fonction AWS Lambda peut-elle en appeler une autre

J'ai 2 fonctions Lambda - une qui produit un devis et une qui transforme un devis en commande. J'aimerais que la fonction Order lambda appelle la fonction Quote pour régénérer le devis, plutôt que de simplement le recevoir d'un client non fiable.

J'ai regardé partout où je peux penser - mais je ne vois pas comment j'allais enchaîner ou appeler les fonctions ... ça existe sûrement!

J'ai trouvé un moyen d'utiliser le 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)
  }
});

Vous pouvez trouver le document ici: http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Lambda.html

Vous devez enchaîner votre Lambda functionsvia SNS. Cette approche offre de bonnes performances, une latence et une évolutivité pour un effort minimal.

Votre premier Lambdapublie des messages sur votre SNS Topicet le second Lambdaest abonné à ce sujet. Dès que des messages arrivent dans le sujet, le second Lambdaest exécuté avec le message comme paramètre d'entrée.

Voir Appel de fonctions Lambda à l'aide de notifications Amazon SNS .

Vous pouvez également utiliser cette approche pour appeler des fonctions Lambda inter-comptes via SNS .

voici un exemple de code pour 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)

Btw, vous devez également ajouter une stratégie comme celle-ci à votre rôle lambda

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

Depuis que cette question a été posée, Amazon a publié Step Functions ( https://aws.amazon.com/step-functions/ ).

L'un des principes fondamentaux derrière AWS Lambda est que vous pouvez vous concentrer davantage sur la logique métier et moins sur la logique d'application qui relie tout cela. Les fonctions d'étape vous permettent d'orchestrer des interactions complexes entre les fonctions sans avoir à écrire le code pour le faire.

Cette solution se fait en utilisant boto3 et 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

Je cherchais à couper SNS jusqu'à ce que je voie cela dans les documents du client Lambda (version Java) :

Client pour accéder à AWS Lambda. Tous les appels de service effectués à l'aide de ce client sont bloquants et ne reviendront pas avant la fin de l'appel de service.

SNS a donc un avantage évident: il est asynchrone. Votre lambda n'attendra pas la fin de la lambda suivante.

Amazon a introduit les fonctions étapes dans AWS lambda en 2016. Je pense qu'il est désormais plus pratique d'utiliser la fonction étapes car il est vraiment facile de les utiliser. Vous pouvez créer une machine à états avec deux fonctions lambda comme:

• produire un devis
• transforme un devis en commande

Vous pouvez facilement le faire comme ci-dessous:

Ici, vous pouvez avoir un premier état pour produire un devis et un autre pour se transformer en ordre

{
  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
    }
  }
}

Les fonctions Steps facilitent l'écriture de plusieurs fonctions lambda et leur exécution en séquence ou en parallèle. Vous pouvez obtenir plus d'informations sur les fonctions d'étapes lambda ici: Fonctions d'étapes

Je travaillais avec la réponse fournie par blueskin mais je n'ai pas pu lire la réponse Payload car l' InvocationType = 'Event' est asynchrone , j'ai donc changé en InvocationType = 'RequestResponse' et maintenant tout fonctionne bien.

En java, nous pouvons faire comme suit:

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

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

InvokeResult invokeResult = awsLambdaAsync.invoke(invokeRequest); 

Ici, la charge utile est votre objet java stratifié qui doit être transmis en tant qu'objet Json à un autre lambda au cas où vous auriez besoin de transmettre certaines informations de l'appel de lambda à lambda appelé.

Vous pourrez peut-être utiliser la fonctionnalité Async.js Waterfall - voir la partie inférieure du gros morceau de code à l'étape 3 de ce document pour un exemple:

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

Vous pouvez appeler la fonction lambda directement (au moins via Java) en utilisant AWSLambdaClientcomme décrit dans le blog « AWS après .

J'ai le même problème mais la fonction Lambda que j'implémente insérera une entrée dans DynamoDB, donc ma solution utilise les déclencheurs DynamoDB.

Je fais invoquer la base de données une fonction Lambda pour chaque insertion / mise à jour dans le tableau, donc cela sépare l'implémentation de deux fonctions Lambda.

La documentation est ici: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.Lambda.html

Voici une procédure pas à pas guidée: https://aws.amazon.com/blogs/aws/dynamodb-update-triggers-streams-lambda-cross-region-replication-app/

Une sorte de solution détournée mais j'appelle simplement le point de terminaison API de pour mes fonctions lambda lorsque j'ai besoin de les enchaîner. Cela vous permet de décider lors du codage si vous souhaitez qu'ils soient asynchrones ou non.

Dans le cas où vous ne souhaitez pas configurer une demande POST, vous pouvez simplement configurer une simple demande GET avec quelques paramètres de chaîne de requête, voire aucun, pour un passage facile des événements.

-- Éditer --

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

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

D'autres ont souligné l'utilisation de SQS et des fonctions pas à pas. Mais ces deux solutions ajoutent un coût supplémentaire. Les transitions d'état de fonction d'étape sont censées être très coûteuses.

AWS lambda propose une logique de nouvelle tentative. Où il essaie quelque chose 3 fois. Je ne sais pas si cela est toujours valide lorsque vous le déclenchez en utilisant l'API.

Voici l'exemple python d'appeler une autre fonction lambda et obtient sa réponse. Il existe deux types d'appel «RequestResponse» et «Event» . Utilisez «RequestResponse» si vous souhaitez obtenir la réponse de la fonction lambda et utilisez «Event» pour appeler la fonction lambda de manière asynchrone. Les deux modes asynchrones et synchrones sont donc disponibles.

    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)

Vous pouvez définir l'environnement 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();