CODEWITHSUNDEEP
node.jsamazon-web-servicesaws-lambdaaws-api-gateway
Silver
Silver

Reputation: 5091

Can an AWS Lambda function call another

I have 2 Lambda functions - one that produces a quote and one that turns a quote into an order. I'd like the Order lambda function to call the Quote function to regenerate the quote, rather than just receive it from an untrusted client.

I've looked everywhere I can think of - but can't see how I'd go about chaining or calling the functions...surely this exists!

Upvotes: 470

Views: 331119

Answers (24)

praty
praty

Reputation: 1121

2024 answer using aws sdk for javascript v3

AWS announced end of support for aws sdk v3 effective September 8 2025 - reference here.

You can invoke a 2nd lambda function from your lambda using the following:

const { InvokeCommand, LambdaClient, LogType } = require("@aws-sdk/client-lambda");
// import {InvokeCommand, LambdaClient, LogType} from "@aws-sdk/client-lambda";

const client = new LambdaClient({ region: "eu-west-2" });  // replace with your region
const command = new InvokeCommand({
  FunctionName: "my-second-lambda",   // replace with your function name
  Payload: JSON.stringify(payload),   // replace with your stringified payload
  LogType: LogType.Tail,
});

const { Payload, LogResult } = await client.send(command);
const result = Buffer.from(Payload).toString();
const logs = Buffer.from(LogResult, "base64").toString();

Note that this is a synchronous call where the first lambda will wait for the 2nd lambda's response before exiting. For asynchronous calls, where the first lambda fires and forgets add InvocationType: 'Event' to the command.

const command = new InvokeCommand({
  FunctionName: "my-second-lambda",
  Payload: JSON.stringify(payload),
  LogType: LogType.Tail,
  InvocationType: 'Event'    // for calling the 2nd lambda asynchronously
});

Reference here - https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/javascript_lambda_code_examples.html

Upvotes: 0

Jamil Noyda
Jamil Noyda

Reputation: 3649

for calling another lambda function you can use lambda destinations feature. enter image description here

from aws documentation

AWS Lambda Destinations gives you more visibility and control of function execution results. This helps you build better event-driven applications, reducing code, and using Lambda’s native failure handling controls.

There are no additional costs for enabling Lambda Destinations. However, calls made to destination target services may be charged.

ref: https://aws.amazon.com/blogs/compute/introducing-aws-lambda-destinations/

you can even put this in to sam yaml file to aws cloudformation template.

Upvotes: 0

jj3pa
jj3pa

Reputation: 37

I just noticed this older than I thought. You could have the lambdas have certain roles. So the order Lambda would need to have the regenerate-quote role. You could separate out the quote lambda to generate the original quote and then regenerate it. I think there would be some difference It doesn't sound like you need the regenerateQuote function to return back to the order lambda. You could use EventBridge to call the regenerate-quote lambda from the order lambda.

Upvotes: 0

adamkonrad
adamkonrad

Reputation: 7122

You should chain your Lambda functions via SNS. This approach provides good performance, latency and scalability for minimal effort.

Your first Lambda publishes messages to your SNS topic and the second Lambda is subscribed to this topic. As soon as messages arrive in the topic, the second Lambda is executed with the message as its input parameter.

See Invoking Lambda functions using Amazon SNS notifications.

You can also use this approach to Invoke cross-account Lambda functions via SNS.

Upvotes: 166

Leonardo Soares Bezerra
Leonardo Soares Bezerra

Reputation: 21

You might consider use the Service AWS Step Function, this allow to you orchestrate many lambdas sharing a common space of variables and data.

https://aws.amazon.com/pt/step-functions/

here there an example of a state machine:

enter image description here

Upvotes: 1

Hardik Shah
Hardik Shah

Reputation: 63

if you want to use a lambda function dependent on another lambda function. you can use the [State Machine] https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-state-machine-structure.html this will help you run the lambda function in sequence or based on the result of another lambda function. It also allows you to integrate other AWS Services also

Upvotes: 0

Santhosh V
Santhosh V

Reputation: 85

Calling another function from one function is considered as antipattern in server less. Its well explained here.

Better implementaion is either use queue to publish the message and consume in another lambda or use step function as described by Black

Upvotes: 0

Chenna V
Chenna V

Reputation: 10513

Here's a sample code for 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().isoformat()}
    invoke_response = lambda_client.invoke(FunctionName="another_lambda_",
                                           InvocationType='Event',
                                           Payload=json.dumps(msg))
    print(invoke_response)

Btw, you would need to add a policy like this to your lambda role as well

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

Upvotes: 110

picsoung
picsoung

Reputation: 6538

I found a way using the 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);
  }
});

You can find the doc here: http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Lambda.html

Upvotes: 500

Mateen Kiani
Mateen Kiani

Reputation: 3293

Here is how you can do it in javascript/typescript without having to install complete aws-sdk package.

import { InvokeCommand, LambdaClient, LogType } from "@aws-sdk/client-lambda";

const client = new LambdaClient({
    region: "US-EAST-1"
});

const payload = JSON.stringify({
  data: "your input"
})

const command = new InvokeCommand({
  FunctionName: "your function name",
  Payload: payload,
  LogType: LogType.Tail,
});

const { Payload } = await client.send(command);
const response: any = Payload;
const result = Buffer.from(response).toString();

return result;

Upvotes: 1

Trilok Nagvenkar
Trilok Nagvenkar

Reputation: 956

This solution is done using boto3 and Python:

import boto3
import json

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

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

Upvotes: 19

Black
Black

Reputation: 10407

There are a lot of answers, but none is stressing that calling another lambda function is not recommended solution for synchronous calls and the one that you should be using is really Step Functions

Reasons why it is not recommended solution:

  • you are paying for both functions when they are waiting for each other
  • your code is responsible for retrials

You can also use it for quite complex logic, such as parallel steps and catch failures. Every execution is also being logged out which makes debugging much simpler.

Upvotes: 10

Shaun Taylor
Shaun Taylor

Reputation: 326

You can trigger Lambda functions directly from other Lambda functions directly in an asynchronous manner.

https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#invocation-async-destinations

Upvotes: 0

lalit gangwar
lalit gangwar

Reputation: 401

Here is the python example of calling another lambda function and gets its response. There is two invocation type 'RequestResponse' and 'Event'. Use 'RequestResponse' if you want to get the response of lambda function and use 'Event' to invoke lambda function asynchronously. So both ways asynchronous and synchronous are available. 

    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)

Upvotes: 3

nnrales
nnrales

Reputation: 1519

Others pointed out to use SQS and Step Functions. But both these solutions add additional cost. Step Function state transitions are supposedly very expensive.

AWS lambda offers some retry logic. Where it tries something for 3 times. I am not sure if that is still valid when you trigger it use the API.

Upvotes: 3

Sunil Kapil
Sunil Kapil

Reputation: 1040

Amazon has introduced steps functions in AWS lambda in 2016. I think, now it's more convenient to use steps function as it's really easy to use them. You can build a state machine with two lambda functions as:

  • to produces a quote
  • turns a quote into an order

You can easily do that as below:

Here you can have first state for produces a quote and another to turns into order

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

Steps functions makes it really easy to write multiple lambda functions and run in sequence or in parallel. You can get more information about lambda steps functions here: Steps Functions

Upvotes: 12

dustinnoe
dustinnoe

Reputation: 725

Since this question was asked, Amazon has released Step Functions (https://aws.amazon.com/step-functions/).

One of the core principles behind AWS Lambda is that you can focus more on business logic and less on the application logic that ties it all together. Step functions allows you to orchestrate complex interactions between functions without having to write the code to do it.

Upvotes: 56

Suyash
Suyash

Reputation: 525

In java, we can do as follows :

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

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

InvokeResult invokeResult = awsLambdaAsync.invoke(invokeRequest);

Here, payload is your stringified java object which needs to be passed as Json object to another lambda in case you need to pass some information from calling lambda to called lambda.

Upvotes: 6

Loufs
Loufs

Reputation: 1656

Kind of a roundabout solution but I just call the API endpoint for my lambda functions when I need to chain them. This allows you to decide while coding if you want them to be asynchronous or not.

In case you don't want to setup a POST request you can just setup a simple GET request with a couple, or none at all, query string parameters for easy event passing.

-- Edit --

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

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

Upvotes: 1

Ben Iggulden
Ben Iggulden

Reputation: 469

I was looking at cutting out SNS until I saw this in the Lambda client docs (Java version):

Client for accessing AWS Lambda. All service calls made using this client are blocking, and will not return until the service call completes.

So SNS has an obvious advantage: it's asynchronous. Your lambda won't wait for the subsequent lambda to complete.

Upvotes: 13

Lewen
Lewen

Reputation: 1823

I'm having the same problem but the Lambda function that I implement will insert an entry in DynamoDB, so my solution uses DynamoDB Triggers.

I make the DB invoke a Lambda function for every insert/update in the table, so this separates the implementation of two Lambda functions.

Documentation is here: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.Lambda.html

Here is a guided walkthrough: https://aws.amazon.com/blogs/aws/dynamodb-update-triggers-streams-lambda-cross-region-replication-app/

Upvotes: 2

antonio
antonio

Reputation: 487

I was working with the answer provided by blueskin but I could not read the Payload response because the InvocationType='Event' is async, so I changed as InvocationType='RequestResponse' and now all works good.

Upvotes: 5

Neil
Neil

Reputation: 8634

You can invoke lambda function directly (at least via Java) by using AWSLambdaClient as described in the AWS' blog post.

Upvotes: 2

Mike
Mike

Reputation: 678

You might be able to make use of the Async.js Waterfall feature - see the bottom part of the big code chunk in Step 3 of this document for an example:

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

Upvotes: 3

Related Questions