Use CreateFunction with an AWS SDK or CLI (original) (raw)
The following code examples show how to use CreateFunction.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code example:
.NET
SDK for .NET
/// <summary>
/// Creates a new Lambda function.
/// </summary>
/// <param name="functionName">The name of the function.</param>
/// <param name="s3Bucket">The Amazon Simple Storage Service (Amazon S3)
/// bucket where the zip file containing the code is located.</param>
/// <param name="s3Key">The Amazon S3 key of the zip file.</param>
/// <param name="role">The Amazon Resource Name (ARN) of a role with the
/// appropriate Lambda permissions.</param>
/// <param name="handler">The name of the handler function.</param>
/// <returns>The Amazon Resource Name (ARN) of the newly created
/// Lambda function.</returns>
public async Task<string> CreateLambdaFunctionAsync(
string functionName,
string s3Bucket,
string s3Key,
string role,
string handler)
{
// Defines the location for the function code.
// S3Bucket - The S3 bucket where the file containing
// the source code is stored.
// S3Key - The name of the file containing the code.
var functionCode = new FunctionCode
{
S3Bucket = s3Bucket,
S3Key = s3Key,
};
var createFunctionRequest = new CreateFunctionRequest
{
FunctionName = functionName,
Description = "Created by the Lambda .NET API",
Code = functionCode,
Handler = handler,
Runtime = Runtime.Dotnet6,
Role = role,
};
var reponse = await _lambdaService.CreateFunctionAsync(createFunctionRequest);
return reponse.FunctionArn;
}
- For API details, seeCreateFunction in AWS SDK for .NET API Reference.
C++
SDK for C++
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region in which the bucket was created (overrides config file).
// clientConfig.region = "us-east-1";
Aws::Lambda::LambdaClient client(clientConfig);
Aws::Lambda::Model::CreateFunctionRequest request;
request.SetFunctionName(LAMBDA_NAME);
request.SetDescription(LAMBDA_DESCRIPTION); // Optional.
#if USE_CPP_LAMBDA_FUNCTION
request.SetRuntime(Aws::Lambda::Model::Runtime::provided_al2);
request.SetTimeout(15);
request.SetMemorySize(128);
// Assume the AWS Lambda function was built in Docker with same architecture
// as this code.
#if defined(__x86_64__)
request.SetArchitectures({Aws::Lambda::Model::Architecture::x86_64});
#elif defined(__aarch64__)
request.SetArchitectures({Aws::Lambda::Model::Architecture::arm64});
#else
#error "Unimplemented architecture"
#endif // defined(architecture)
#else
request.SetRuntime(Aws::Lambda::Model::Runtime::python3_9);
#endif
request.SetRole(roleArn);
request.SetHandler(LAMBDA_HANDLER_NAME);
request.SetPublish(true);
Aws::Lambda::Model::FunctionCode code;
std::ifstream ifstream(INCREMENT_LAMBDA_CODE.c_str(),
std::ios_base::in | std::ios_base::binary);
if (!ifstream.is_open()) {
std::cerr << "Error opening file " << INCREMENT_LAMBDA_CODE << "." << std::endl;
#if USE_CPP_LAMBDA_FUNCTION
std::cerr
<< "The cpp Lambda function must be built following the instructions in the cpp_lambda/README.md file. "
<< std::endl;
#endif
deleteIamRole(clientConfig);
return false;
}
Aws::StringStream buffer;
buffer << ifstream.rdbuf();
code.SetZipFile(Aws::Utils::ByteBuffer((unsigned char *) buffer.str().c_str(),
buffer.str().length()));
request.SetCode(code);
Aws::Lambda::Model::CreateFunctionOutcome outcome = client.CreateFunction(
request);
if (outcome.IsSuccess()) {
std::cout << "The lambda function was successfully created. " << seconds
<< " seconds elapsed." << std::endl;
break;
}
else {
std::cerr << "Error with CreateFunction. "
<< outcome.GetError().GetMessage()
<< std::endl;
deleteIamRole(clientConfig);
return false;
}
- For API details, seeCreateFunction in AWS SDK for C++ API Reference.
CLI
AWS CLI
To create a Lambda function
The following create-function example creates a Lambda function named my-function.
aws lambda create-function \
--function-name my-function \
--runtime nodejs18.x \
--zip-file fileb://my-function.zip \
--handler my-function.handler \
--role arn:aws:iam::123456789012:role/service-role/MyTestFunction-role-tges6bf4
Contents of my-function.zip:
This file is a deployment package that contains your function code and any dependencies.Output:
{
"TracingConfig": {
"Mode": "PassThrough"
},
"CodeSha256": "PFn4S+er27qk+UuZSTKEQfNKG/XNn7QJs90mJgq6oH8=",
"FunctionName": "my-function",
"CodeSize": 308,
"RevisionId": "873282ed-4cd3-4dc8-a069-d0c647e470c6",
"MemorySize": 128,
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:my-function",
"Version": "$LATEST",
"Role": "arn:aws:iam::123456789012:role/service-role/MyTestFunction-role-zgur6bf4",
"Timeout": 3,
"LastModified": "2023-10-14T22:26:11.234+0000",
"Handler": "my-function.handler",
"Runtime": "nodejs18.x",
"Description": ""
}For more information, see AWS Lambda Function Configuration in the AWS Lambda Developer Guide.
- For API details, seeCreateFunction in AWS CLI Command Reference.
Go
SDK for Go V2
import (
"bytes"
"context"
"encoding/json"
"errors"
"log"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/lambda"
"github.com/aws/aws-sdk-go-v2/service/lambda/types"
)
// FunctionWrapper encapsulates function actions used in the examples.
// It contains an AWS Lambda service client that is used to perform user actions.
type FunctionWrapper struct {
LambdaClient *lambda.Client
}
// CreateFunction creates a new Lambda function from code contained in the zipPackage
// buffer. The specified handlerName must match the name of the file and function
// contained in the uploaded code. The role specified by iamRoleArn is assumed by
// Lambda and grants specific permissions.
// When the function already exists, types.StateActive is returned.
// When the function is created, a lambda.FunctionActiveV2Waiter is used to wait until the
// function is active.
func (wrapper FunctionWrapper) CreateFunction(ctx context.Context, functionName string, handlerName string,
iamRoleArn *string, zipPackage *bytes.Buffer) types.State {
var state types.State
_, err := wrapper.LambdaClient.CreateFunction(ctx, &lambda.CreateFunctionInput{
Code: &types.FunctionCode{ZipFile: zipPackage.Bytes()},
FunctionName: aws.String(functionName),
Role: iamRoleArn,
Handler: aws.String(handlerName),
Publish: true,
Runtime: types.RuntimePython39,
})
if err != nil {
var resConflict *types.ResourceConflictException
if errors.As(err, &resConflict) {
log.Printf("Function %v already exists.\n", functionName)
state = types.StateActive
} else {
log.Panicf("Couldn't create function %v. Here's why: %v\n", functionName, err)
}
} else {
waiter := lambda.NewFunctionActiveV2Waiter(wrapper.LambdaClient)
funcOutput, err := waiter.WaitForOutput(ctx, &lambda.GetFunctionInput{
FunctionName: aws.String(functionName)}, 1*time.Minute)
if err != nil {
log.Panicf("Couldn't wait for function %v to be active. Here's why: %v\n", functionName, err)
} else {
state = funcOutput.Configuration.State
}
}
return state
}
- For API details, seeCreateFunction in AWS SDK for Go API Reference.
Java
SDK for Java 2.x
/**
* Creates a new Lambda function in AWS using the AWS Lambda Java API.
*
* @param awsLambda the AWS Lambda client used to interact with the AWS Lambda service
* @param functionName the name of the Lambda function to create
* @param key the S3 key of the function code
* @param bucketName the name of the S3 bucket containing the function code
* @param role the IAM role to assign to the Lambda function
* @param handler the fully qualified class name of the function handler
* @return the Amazon Resource Name (ARN) of the created Lambda function
*/
public static String createLambdaFunction(LambdaClient awsLambda,
String functionName,
String key,
String bucketName,
String role,
String handler) {
try {
LambdaWaiter waiter = awsLambda.waiter();
FunctionCode code = FunctionCode.builder()
.s3Key(key)
.s3Bucket(bucketName)
.build();
CreateFunctionRequest functionRequest = CreateFunctionRequest.builder()
.functionName(functionName)
.description("Created by the Lambda Java API")
.code(code)
.handler(handler)
.runtime(Runtime.JAVA17)
.role(role)
.build();
// Create a Lambda function using a waiter
CreateFunctionResponse functionResponse = awsLambda.createFunction(functionRequest);
GetFunctionRequest getFunctionRequest = GetFunctionRequest.builder()
.functionName(functionName)
.build();
WaiterResponse<GetFunctionResponse> waiterResponse = waiter.waitUntilFunctionExists(getFunctionRequest);
waiterResponse.matched().response().ifPresent(System.out::println);
return functionResponse.functionArn();
} catch (LambdaException e) {
System.err.println(e.getMessage());
System.exit(1);
}
return "";
}
- For API details, seeCreateFunction in AWS SDK for Java 2.x API Reference.
JavaScript
SDK for JavaScript (v3)
const createFunction = async (funcName, roleArn) => {
const client = new LambdaClient({});
const code = await readFile(`${dirname}../functions/${funcName}.zip`);
const command = new CreateFunctionCommand({
Code: { ZipFile: code },
FunctionName: funcName,
Role: roleArn,
Architectures: [Architecture.arm64],
Handler: "index.handler", // Required when sending a .zip file
PackageType: PackageType.Zip, // Required when sending a .zip file
Runtime: Runtime.nodejs16x, // Required when sending a .zip file
});
return client.send(command);
};
- For API details, seeCreateFunction in AWS SDK for JavaScript API Reference.
Kotlin
SDK for Kotlin
suspend fun createNewFunction(
myFunctionName: String,
s3BucketName: String,
myS3Key: String,
myHandler: String,
myRole: String,
): String? {
val functionCode =
FunctionCode {
s3Bucket = s3BucketName
s3Key = myS3Key
}
val request =
CreateFunctionRequest {
functionName = myFunctionName
code = functionCode
description = "Created by the Lambda Kotlin API"
handler = myHandler
role = myRole
runtime = Runtime.Java17
}
LambdaClient { region = "us-east-1" }.use { awsLambda ->
val functionResponse = awsLambda.createFunction(request)
awsLambda.waitUntilFunctionActive {
functionName = myFunctionName
}
return functionResponse.functionArn
}
}
- For API details, seeCreateFunction in AWS SDK for Kotlin API reference.
PHP
SDK for PHP
public function createFunction($functionName, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>r</mi><mi>o</mi><mi>l</mi><mi>e</mi><mo separator="true">,</mo></mrow><annotation encoding="application/x-tex">role, </annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">ro</span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">e</span><span class="mpunct">,</span></span></span></span>bucketName, $handler)
{
//This assumes the Lambda function is in an S3 bucket.
return <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi><mi>h</mi><mi>i</mi><mi>s</mi><mo>−</mo><mo>></mo><mi>c</mi><mi>u</mi><mi>s</mi><mi>t</mi><mi>o</mi><mi>m</mi><mi>W</mi><mi>a</mi><mi>i</mi><mi>t</mi><mi>e</mi><mi>r</mi><mo stretchy="false">(</mo><mi>f</mi><mi>u</mi><mi>n</mi><mi>c</mi><mi>t</mi><mi>i</mi><mi>o</mi><mi>n</mi><mo stretchy="false">(</mo><mo stretchy="false">)</mo><mi>u</mi><mi>s</mi><mi>e</mi><mo stretchy="false">(</mo></mrow><annotation encoding="application/x-tex">this->customWaiter(function () use (</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7778em;vertical-align:-0.0833em;"></span><span class="mord mathnormal">t</span><span class="mord mathnormal">hi</span><span class="mord mathnormal">s</span><span class="mord">−</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">></span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">c</span><span class="mord mathnormal">u</span><span class="mord mathnormal">s</span><span class="mord mathnormal">t</span><span class="mord mathnormal">o</span><span class="mord mathnormal">mWai</span><span class="mord mathnormal">t</span><span class="mord mathnormal" style="margin-right:0.02778em;">er</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.10764em;">f</span><span class="mord mathnormal">u</span><span class="mord mathnormal">n</span><span class="mord mathnormal">c</span><span class="mord mathnormal">t</span><span class="mord mathnormal">i</span><span class="mord mathnormal">o</span><span class="mord mathnormal">n</span><span class="mopen">(</span><span class="mclose">)</span><span class="mord mathnormal">u</span><span class="mord mathnormal">se</span><span class="mopen">(</span></span></span></span>functionName, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>r</mi><mi>o</mi><mi>l</mi><mi>e</mi><mo separator="true">,</mo></mrow><annotation encoding="application/x-tex">role, </annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">ro</span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">e</span><span class="mpunct">,</span></span></span></span>bucketName, $handler) {
return $this->lambdaClient->createFunction([
'Code' => [
'S3Bucket' => $bucketName,
'S3Key' => $functionName,
],
'FunctionName' => $functionName,
'Role' => $role['Arn'],
'Runtime' => 'python3.9',
'Handler' => "$handler.lambda_handler",
]);
});
}
- For API details, seeCreateFunction in AWS SDK for PHP API Reference.
PowerShell
Tools for PowerShell V4
Example 1: This example creates a new C# (dotnetcore1.0 runtime) function named MyFunction in AWS Lambda, providing the compiled binaries for the function from a zip file on the local file system (relative or absolute paths may be used). C# Lambda functions specify the handler for the function using the designation AssemblyName::Namespace.ClassName::MethodName. You should replace the assembly name (without .dll suffix), namespace, class name and method name parts of the handler spec appropriately. The new function will have environment variables 'envvar1' and 'envvar2' set up from the provided values.
Publish-LMFunction -Description "My C# Lambda Function" `
-FunctionName MyFunction `
-ZipFilename .\MyFunctionBinaries.zip `
-Handler "AssemblyName::Namespace.ClassName::MethodName" `
-Role "arn:aws:iam::123456789012:role/LambdaFullExecRole" `
-Runtime dotnetcore1.0 `
-Environment_Variable @{ "envvar1"="value";"envvar2"="value" }
Output:
CodeSha256 : /NgBMd...gq71I=
CodeSize : 214784
DeadLetterConfig :
Description : My C# Lambda Function
Environment : Amazon.Lambda.Model.EnvironmentResponse
FunctionArn : arn:aws:lambda:us-west-2:123456789012:function:ToUpper
FunctionName : MyFunction
Handler : AssemblyName::Namespace.ClassName::MethodName
KMSKeyArn :
LastModified : 2016-12-29T23:50:14.207+0000
MemorySize : 128
Role : arn:aws:iam::123456789012:role/LambdaFullExecRole
Runtime : dotnetcore1.0
Timeout : 3
Version : $LATEST
VpcConfig :Example 2: This example is similar to the previous one except the function binaries are first uploaded to an Amazon S3 bucket (which must be in the same region as the intended Lambda function) and the resulting S3 object is then referenced when creating the function.
Write-S3Object -BucketName amzn-s3-demo-bucket -Key MyFunctionBinaries.zip -File .\MyFunctionBinaries.zip
Publish-LMFunction -Description "My C# Lambda Function" `
-FunctionName MyFunction `
-BucketName amzn-s3-demo-bucket `
-Key MyFunctionBinaries.zip `
-Handler "AssemblyName::Namespace.ClassName::MethodName" `
-Role "arn:aws:iam::123456789012:role/LambdaFullExecRole" `
-Runtime dotnetcore1.0 `
-Environment_Variable @{ "envvar1"="value";"envvar2"="value" }
- For API details, seeCreateFunction in AWS Tools for PowerShell Cmdlet Reference (V4).
Python
SDK for Python (Boto3)
class LambdaWrapper:
def __init__(self, lambda_client, iam_resource):
self.lambda_client = lambda_client
self.iam_resource = iam_resource
def create_function(
self, function_name, handler_name, iam_role, deployment_package
):
"""
Deploys a Lambda function.
:param function_name: The name of the Lambda function.
:param handler_name: The fully qualified name of the handler function. This
must include the file name and the function name.
:param iam_role: The IAM role to use for the function.
:param deployment_package: The deployment package that contains the function
code in .zip format.
:return: The Amazon Resource Name (ARN) of the newly created function.
"""
try:
response = self.lambda_client.create_function(
FunctionName=function_name,
Description="AWS Lambda doc example",
Runtime="python3.9",
Role=iam_role.arn,
Handler=handler_name,
Code={"ZipFile": deployment_package},
Publish=True,
)
function_arn = response["FunctionArn"]
waiter = self.lambda_client.get_waiter("function_active_v2")
waiter.wait(FunctionName=function_name)
logger.info(
"Created function '%s' with ARN: '%s'.",
function_name,
response["FunctionArn"],
)
except ClientError:
logger.error("Couldn't create function %s.", function_name)
raise
else:
return function_arn
- For API details, seeCreateFunction in AWS SDK for Python (Boto3) API Reference.
Ruby
SDK for Ruby
class LambdaWrapper
attr_accessor :lambda_client, :cloudwatch_client, :iam_client
def initialize
@lambda_client = Aws::Lambda::Client.new
@cloudwatch_client = Aws::CloudWatchLogs::Client.new(region: 'us-east-1')
@iam_client = Aws::IAM::Client.new(region: 'us-east-1')
@logger = Logger.new($stdout)
@logger.level = Logger::WARN
end
# Deploys a Lambda function.
#
# @param function_name: The name of the Lambda function.
# @param handler_name: The fully qualified name of the handler function.
# @param role_arn: The IAM role to use for the function.
# @param deployment_package: The deployment package that contains the function code in .zip format.
# @return: The Amazon Resource Name (ARN) of the newly created function.
def create_function(function_name, handler_name, role_arn, deployment_package)
response = @lambda_client.create_function({
role: role_arn.to_s,
function_name: function_name,
handler: handler_name,
runtime: 'ruby2.7',
code: {
zip_file: deployment_package
},
environment: {
variables: {
'LOG_LEVEL' => 'info'
}
}
})
@lambda_client.wait_until(:function_active_v2, { function_name: function_name }) do |w|
w.max_attempts = 5
w.delay = 5
end
response
rescue Aws::Lambda::Errors::ServiceException => e
@logger.error("There was an error creating #{function_name}:\n #{e.message}")
rescue Aws::Waiters::Errors::WaiterFailed => e
@logger.error("Failed waiting for #{function_name} to activate:\n #{e.message}")
end
- For API details, seeCreateFunction in AWS SDK for Ruby API Reference.
Rust
SDK for Rust
/**
* Create a function, uploading from a zip file.
*/
pub async fn create_function(&self, zip_file: PathBuf) -> Result<String, anyhow::Error> {
let code = self.prepare_function(zip_file, None).await?;
let key = code.s3_key().unwrap().to_string();
let role = self.create_role().await.map_err(|e| anyhow!(e))?;
info!("Created iam role, waiting 15s for it to become active");
tokio::time::sleep(Duration::from_secs(15)).await;
info!("Creating lambda function {}", self.lambda_name);
let _ = self
.lambda_client
.create_function()
.function_name(self.lambda_name.clone())
.code(code)
.role(role.arn())
.runtime(aws_sdk_lambda::types::Runtime::Providedal2)
.handler("_unused")
.send()
.await
.map_err(anyhow::Error::from)?;
self.wait_for_function_ready().await?;
self.lambda_client
.publish_version()
.function_name(self.lambda_name.clone())
.send()
.await?;
Ok(key)
}
/**
* Upload function code from a path to a zip file.
* The zip file must have an AL2 Linux-compatible binary called `bootstrap`.
* The easiest way to create such a zip is to use `cargo lambda build --output-format Zip`.
*/
async fn prepare_function(
&self,
zip_file: PathBuf,
key: Option<String>,
) -> Result<FunctionCode, anyhow::Error> {
let body = ByteStream::from_path(zip_file).await?;
let key = key.unwrap_or_else(|| format!("{}_code", self.lambda_name));
info!("Uploading function code to s3://{}/{}", self.bucket, key);
let _ = self
.s3_client
.put_object()
.bucket(self.bucket.clone())
.key(key.clone())
.body(body)
.send()
.await?;
Ok(FunctionCode::builder()
.s3_bucket(self.bucket.clone())
.s3_key(key)
.build())
}
- For API details, seeCreateFunction in AWS SDK for Rust API reference.
SAP ABAP
SDK for SAP ABAP
TRY.
lo_lmd->createfunction(
iv_functionname = iv_function_name
iv_runtime = `python3.9`
iv_role = iv_role_arn
iv_handler = iv_handler
io_code = io_zip_file
iv_description = 'AWS Lambda code example' ).
MESSAGE 'Lambda function created.' TYPE 'I'.
CATCH /aws1/cx_lmdcodesigningcfgno00.
MESSAGE 'Code signing configuration does not exist.' TYPE 'E'.
CATCH /aws1/cx_lmdcodestorageexcdex.
MESSAGE 'Maximum total code size per account exceeded.' TYPE 'E'.
CATCH /aws1/cx_lmdcodeverification00.
MESSAGE 'Code signature failed one or more validation checks for signature mismatch or expiration.' TYPE 'E'.
CATCH /aws1/cx_lmdinvalidcodesigex.
MESSAGE 'Code signature failed the integrity check.' TYPE 'E'.
CATCH /aws1/cx_lmdinvparamvalueex.
MESSAGE 'The request contains a non-valid parameter.' TYPE 'E'.
CATCH /aws1/cx_lmdresourceconflictex.
MESSAGE 'Resource already exists or another operation is in progress.' TYPE 'E'.
CATCH /aws1/cx_lmdresourcenotfoundex.
MESSAGE 'The requested resource does not exist.' TYPE 'E'.
CATCH /aws1/cx_lmdserviceexception.
MESSAGE 'An internal problem was encountered by the AWS Lambda service.' TYPE 'E'.
CATCH /aws1/cx_lmdtoomanyrequestsex.
MESSAGE 'The maximum request throughput was reached.' TYPE 'E'.
ENDTRY.
- For API details, seeCreateFunction in AWS SDK for SAP ABAP API reference.
Swift
SDK for Swift
import AWSClientRuntime
import AWSLambda
import Foundation
do {
// Read the Zip archive containing the AWS Lambda function.
let zipUrl = URL(fileURLWithPath: path)
let zipData = try Data(contentsOf: zipUrl)
// Create the AWS Lambda function that runs the specified code,
// using the name given on the command line. The Lambda function
// will run using the Amazon Linux 2 runtime.
_ = try await lambdaClient.createFunction(
input: CreateFunctionInput(
code: LambdaClientTypes.FunctionCode(zipFile: zipData),
functionName: name,
handler: "handle",
role: roleArn,
runtime: .providedal2
)
)
} catch {
return false
}
- For API details, seeCreateFunction in AWS SDK for Swift API reference.
Did this page help you? - Yes
Thanks for letting us know we're doing a good job!
If you've got a moment, please tell us what we did right so we can do more of it.
Did this page help you? - No
Thanks for letting us know this page needs work. We're sorry we let you down.
If you've got a moment, please tell us how we can make the documentation better.