The following code examples show how to:
- Create an AWS Identity and Access Management (IAM) role that grants Lambda permission to write to logs.
- Create a Lambda function and upload handler code.
- Invoke the function with a single parameter and get results.
- Update the function code and configure its Lambda environment with an environment variable.
- Invoke the function with new parameters and get results. Display the execution log that's returned from the invocation.
- List the functions for your account.
- Delete the IAM role and the Lambda function.
Note
The source code for these examples is in the AWS Code Examples GitHub repository. Have feedback on a code example? Create an Issue in the code examples repo.
For more information, see Create a Lambda function with the console.
SDK for Java 2.x
To learn how to set up and run this example, see GitHub.
public class LambdaScenario {
public static void main(String[] args) throws InterruptedException {
final String usage = "\n" +
"Usage:\n" +
" <functionName> <filePath> <role> <handler> <bucketName> <key> \n\n" +
"Where:\n" +
" functionName - The name of the Lambda function. \n"+
" filePath - The path to the .zip or .jar where the code is located. \n"+
" role - The AWS Identity and Access Management (IAM) service role that has Lambda permissions. \n"+
" handler - The fully qualified method name (for example, example.Handler::handleRequest). \n"+
" bucketName - The Amazon Simple Storage Service (Amazon S3) bucket name that contains the .zip or .jar used to update the Lambda function's code. \n"+
" key - The Amazon S3 key name that represents the .zip or .jar (for example, LambdaHello-1.0-SNAPSHOT.jar)." ;
if (args.length != 6) {
System.out.println(usage);
System.exit(1);
}
String functionName = args[0];
String filePath = args[1];
String role = args[2];
String handler = args[3];
String bucketName = args[4];
String key = args[5];
Region region = Region.US_WEST_2;
LambdaClient awsLambda = LambdaClient.builder()
.region(region)
.credentialsProvider(ProfileCredentialsProvider.create())
.build();
String funArn = createLambdaFunction(awsLambda, functionName, filePath, role, handler);
System.out.println("The AWS Lambda ARN is "+funArn);
// Get the Lambda function.
System.out.println("Getting the " +functionName +" AWS Lambda function.");
getFunction(awsLambda, functionName);
// List the Lambda functions.
System.out.println("Listing all functions.");
LambdaScenario.listFunctions(awsLambda);
System.out.println("*** Sleep for 1 min to get Lambda function ready.");
Thread.sleep(60000);
System.out.println("*** Invoke the Lambda function.");
invokeFunction(awsLambda, functionName);
System.out.println("*** Update the Lambda function code.");
LambdaScenario.updateFunctionCode(awsLambda, functionName, bucketName, key);
System.out.println("*** Sleep for 1 min to get Lambda function ready.");
Thread.sleep(60000);
System.out.println("*** Invoke the Lambda function again with the updated code.");
invokeFunction(awsLambda, functionName);
System.out.println("Update a Lambda function's configuration value.");
updateFunctionConfiguration(awsLambda, functionName, handler);
System.out.println("Delete the AWS Lambda function.");
LambdaScenario.deleteLambdaFunction(awsLambda, functionName);
awsLambda.close();
}
public static String createLambdaFunction(LambdaClient awsLambda,
String functionName,
String filePath,
String role,
String handler) {
try {
LambdaWaiter waiter = awsLambda.waiter();
InputStream is = new FileInputStream(filePath);
SdkBytes fileToUpload = SdkBytes.fromInputStream(is);
FunctionCode code = FunctionCode.builder()
.zipFile(fileToUpload)
.build();
CreateFunctionRequest functionRequest = CreateFunctionRequest.builder()
.functionName(functionName)
.description("Created by the Lambda Java API")
.code(code)
.handler(handler)
.runtime(Runtime.JAVA8)
.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 | FileNotFoundException e) {
System.err.println(e.getMessage());
System.exit(1);
}
return "";
}
public static void getFunction(LambdaClient awsLambda, String functionName) {
try {
GetFunctionRequest functionRequest = GetFunctionRequest.builder()
.functionName(functionName)
.build();
GetFunctionResponse response = awsLambda.getFunction(functionRequest);
System.out.println("The runtime of this Lambda function is " +response.configuration().runtime());
} catch(LambdaException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
public static void listFunctions(LambdaClient awsLambda) {
try {
ListFunctionsResponse functionResult = awsLambda.listFunctions();
List<FunctionConfiguration> list = functionResult.functions();
for (FunctionConfiguration config: list) {
System.out.println("The function name is "+config.functionName());
}
} catch(LambdaException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
public static void invokeFunction(LambdaClient awsLambda, String functionName) {
InvokeResponse res;
try {
// Need a SdkBytes instance for the payload.
JSONObject jsonObj = new JSONObject();
jsonObj.put("inputValue", "2000");
String json = jsonObj.toString();
SdkBytes payload = SdkBytes.fromUtf8String(json) ;
InvokeRequest request = InvokeRequest.builder()
.functionName(functionName)
.payload(payload)
.build();
res = awsLambda.invoke(request);
String value = res.payload().asUtf8String() ;
System.out.println(value);
} catch(LambdaException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
public static void updateFunctionCode(LambdaClient awsLambda, String functionName, String bucketName, String key) {
try {
LambdaWaiter waiter = awsLambda.waiter();
UpdateFunctionCodeRequest functionCodeRequest = UpdateFunctionCodeRequest.builder()
.functionName(functionName)
.publish(true)
.s3Bucket(bucketName)
.s3Key(key)
.build();
UpdateFunctionCodeResponse response = awsLambda.updateFunctionCode(functionCodeRequest) ;
GetFunctionConfigurationRequest getFunctionConfigRequest = GetFunctionConfigurationRequest.builder()
.functionName(functionName)
.build();
WaiterResponse<GetFunctionConfigurationResponse> waiterResponse = waiter.waitUntilFunctionUpdated(getFunctionConfigRequest);
waiterResponse.matched().response().ifPresent(System.out::println);
System.out.println("The last modified value is " +response.lastModified());
} catch(LambdaException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
public static void updateFunctionConfiguration(LambdaClient awsLambda, String functionName, String handler ){
try {
UpdateFunctionConfigurationRequest configurationRequest = UpdateFunctionConfigurationRequest.builder()
.functionName(functionName)
.handler(handler)
.runtime(Runtime.JAVA11 )
.build();
awsLambda.updateFunctionConfiguration(configurationRequest);
} catch(LambdaException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
public static void deleteLambdaFunction(LambdaClient awsLambda, String functionName ) {
try {
DeleteFunctionRequest request = DeleteFunctionRequest.builder()
.functionName(functionName)
.build();
awsLambda.deleteFunction(request);
System.out.println("The "+functionName +" function was deleted");
} catch(LambdaException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
}
- For API details, see the following topics in AWS SDK for Java 2.x API Reference.
SDK for Kotlin
This is prerelease documentation for a feature in preview release. It is subject to change.
To learn how to set up and run this example, see GitHub.
suspend fun main(args: Array<String>) {
val usage = """
Usage:
<functionName> <role> <handler> <bucketName> <updatedBucketName> <key>
Where:
functionName - The name of the AWS Lambda function.
role - The AWS Identity and Access Management (IAM) service role that has AWS Lambda permissions.
handler - The fully qualified method name (for example, example.Handler::handleRequest).
bucketName - The Amazon Simple Storage Service (Amazon S3) bucket name that contains the ZIP or JAR used for the Lambda function's code.
updatedBucketName - The Amazon S3 bucket name that contains the .zip or .jar used to update the Lambda function's code.
key - The Amazon S3 key name that represents the .zip or .jar file (for example, LambdaHello-1.0-SNAPSHOT.jar).
"""
if (args.size != 6) {
println(usage)
exitProcess(1)
}
val functionName = args[0]
val role = args[1]
val handler = args[2]
val bucketName = args[3]
val updatedBucketName = args[4]
val key = args[5]
println("Creating a Lambda function named $functionName.")
val funArn = createScFunction(functionName, bucketName, key, handler, role)
println("The AWS Lambda ARN is $funArn")
// Get a specific Lambda function.
println("Getting the $functionName AWS Lambda function.")
getFunction(functionName)
// List the Lambda functions.
println("Listing all AWS Lambda functions.")
listFunctionsSc()
// Invoke the Lambda function.
println("*** Invoke the Lambda function.")
invokeFunctionSc(functionName)
// Update the AWS Lambda function code.
println("*** Update the Lambda function code.")
updateFunctionCode(functionName, updatedBucketName, key)
// println("*** Invoke the function again after updating the code.")
invokeFunctionSc(functionName)
// Update the AWS Lambda function configuration.
println("Update the run time of the function.")
UpdateFunctionConfiguration(functionName, handler)
// Delete the AWS Lambda function.
println("Delete the AWS Lambda function.")
delFunction(functionName)
}
suspend fun createScFunction(
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.Java8
}
// Create a Lambda function using a waiter
LambdaClient { region = "us-west-2" }.use { awsLambda ->
val functionResponse = awsLambda.createFunction(request)
awsLambda.waitUntilFunctionActive {
functionName = myFunctionName
}
return functionResponse.functionArn.toString()
}
}
suspend fun getFunction(functionNameVal: String) {
val functionRequest = GetFunctionRequest {
functionName = functionNameVal
}
LambdaClient { region = "us-west-2" }.use { awsLambda ->
val response = awsLambda.getFunction(functionRequest)
println("The runtime of this Lambda function is ${response.configuration?.runtime}")
}
}
suspend fun listFunctionsSc() {
val request = ListFunctionsRequest {
maxItems = 10
}
LambdaClient { region = "us-west-2" }.use { awsLambda ->
val response = awsLambda.listFunctions(request)
response.functions?.forEach { function ->
println("The function name is ${function.functionName}")
}
}
}
suspend fun invokeFunctionSc(functionNameVal: String) {
val json = """{"inputValue":"1000"}"""
val byteArray = json.trimIndent().encodeToByteArray()
val request = InvokeRequest {
functionName = functionNameVal
payload = byteArray
logType = LogType.Tail
}
LambdaClient { region = "us-west-2" }.use { awsLambda ->
val res = awsLambda.invoke(request)
println("The function payload is ${res.payload?.toString(Charsets.UTF_8)}")
}
}
suspend fun updateFunctionCode(functionNameVal: String?, bucketName: String?, key: String?) {
val functionCodeRequest = UpdateFunctionCodeRequest {
functionName = functionNameVal
publish = true
s3Bucket = bucketName
s3Key = key
}
LambdaClient { region = "us-west-2" }.use { awsLambda ->
val response = awsLambda.updateFunctionCode(functionCodeRequest)
awsLambda.waitUntilFunctionUpdated {
functionName = functionNameVal
}
println("The last modified value is " + response.lastModified)
}
}
suspend fun UpdateFunctionConfiguration(functionNameVal: String?, handlerVal: String?) {
val configurationRequest = UpdateFunctionConfigurationRequest {
functionName = functionNameVal
handler = handlerVal
runtime = Runtime.Java11
}
LambdaClient { region = "us-west-2" }.use { awsLambda ->
awsLambda.updateFunctionConfiguration(configurationRequest)
}
}
suspend fun delFunction(myFunctionName: String) {
val request = DeleteFunctionRequest {
functionName = myFunctionName
}
LambdaClient { region = "us-west-2" }.use { awsLambda ->
awsLambda.deleteFunction(request)
println("$myFunctionName was deleted")
}
}
- For API details, see the following topics in AWS SDK for Kotlin API reference.
SDK for Python (Boto3)
To learn how to set up and run this example, see GitHub.
Define a Lambda handler that increments a number.
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
def lambda_handler(event, context):
"""
Accepts an action and a single number, performs the specified action on the number,
and returns the result. The only allowable action is 'increment'.
:param event: The event dict that contains the parameters sent when the function
is invoked.
:param context: The context in which the function is called.
:return: The result of the action.
"""
result = None
action = event.get('action')
if action == 'increment':
result = event.get('number', 0) + 1
logger.info('Calculated result of %s', result)
else:
logger.error("%s is not a valid action.", action)
response = {'result': result}
return response
Define a second Lambda handler that performs arithmetic operations.
import logging
import os
logger = logging.getLogger()
# Define a list of Python lambda functions that are called by this AWS Lambda function.
ACTIONS = {
'plus': lambda x, y: x + y,
'minus': lambda x, y: x - y,
'times': lambda x, y: x * y,
'divided-by': lambda x, y: x / y}
def lambda_handler(event, context):
"""
Accepts an action and two numbers, performs the specified action on the numbers,
and returns the result.
:param event: The event dict that contains the parameters sent when the function
is invoked.
:param context: The context in which the function is called.
:return: The result of the specified action.
"""
# Set the log level based on a variable configured in the Lambda environment.
logger.setLevel(os.environ.get('LOG_LEVEL', logging.INFO))
logger.debug('Event: %s', event)
action = event.get('action')
func = ACTIONS.get(action)
x = event.get('x')
y = event.get('y')
result = None
try:
if func is not None and x is not None and y is not None:
result = func(x, y)
logger.info("%s %s %s is %s", x, action, y, result)
else:
logger.error("I can't calculate %s %s %s.", x, action, y)
except ZeroDivisionError:
logger.warning("I can't divide %s by 0!", x)
response = {'result': result}
return response
Create functions that wrap Lambda actions.
class LambdaWrapper:
def __init__(self, lambda_client, iam_resource):
self.lambda_client = lambda_client
self.iam_resource = iam_resource
@staticmethod
def create_deployment_package(source_file, destination_file):
"""
Creates a Lambda deployment package in .zip format in an in-memory buffer. This
buffer can be passed directly to Lambda when creating the function.
:param source_file: The name of the file that contains the Lambda handler
function.
:param destination_file: The name to give the file when it's deployed to Lambda.
:return: The deployment package.
"""
buffer = io.BytesIO()
with zipfile.ZipFile(buffer, 'w') as zipped:
zipped.write(source_file, destination_file)
buffer.seek(0)
return buffer.read()
def get_iam_role(self, iam_role_name):
"""
Get an AWS Identity and Access Management (IAM) role.
:param iam_role_name: The name of the role to retrieve.
:return: The IAM role.
"""
role = None
try:
temp_role = self.iam_resource.Role(iam_role_name)
temp_role.load()
role = temp_role
logger.info("Got IAM role %s", role.name)
except ClientError as err:
if err.response['Error']['Code'] == 'NoSuchEntity':
logger.info("IAM role %s does not exist.", iam_role_name)
else:
logger.error(
"Couldn't get IAM role %s. Here's why: %s: %s", iam_role_name,
err.response['Error']['Code'], err.response['Error']['Message'])
raise
return role
def create_iam_role_for_lambda(self, iam_role_name):
"""
Creates an IAM role that grants the Lambda function basic permissions. If a
role with the specified name already exists, it is used for the demo.
:param iam_role_name: The name of the role to create.
:return: The role and a value that indicates whether the role is newly created.
"""
role = self.get_iam_role(iam_role_name)
if role is not None:
return role, False
lambda_assume_role_policy = {
'Version': '2012-10-17',
'Statement': [
{
'Effect': 'Allow',
'Principal': {
'Service': 'lambda.amazonaws.com'
},
'Action': 'sts:AssumeRole'
}
]
}
policy_arn = 'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'
try:
role = self.iam_resource.create_role(
RoleName=iam_role_name,
AssumeRolePolicyDocument=json.dumps(lambda_assume_role_policy))
logger.info("Created role %s.", role.name)
role.attach_policy(PolicyArn=policy_arn)
logger.info("Attached basic execution policy to role %s.", role.name)
except ClientError as error:
if error.response['Error']['Code'] == 'EntityAlreadyExists':
role = self.iam_resource.Role(iam_role_name)
logger.warning("The role %s already exists. Using it.", iam_role_name)
else:
logger.exception(
"Couldn't create role %s or attach policy %s.",
iam_role_name, policy_arn)
raise
return role, True
def get_function(self, function_name):
"""
Gets data about a Lambda function.
:param function_name: The name of the function.
:return: The function data.
"""
response = None
try:
response = self.lambda_client.get_function(FunctionName=function_name)
except ClientError as err:
if err.response['Error']['Code'] == 'ResourceNotFoundException':
logger.info("Function %s does not exist.", function_name)
else:
logger.error(
"Couldn't get function %s. Here's why: %s: %s", function_name,
err.response['Error']['Code'], err.response['Error']['Message'])
raise
return response
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.8',
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
def delete_function(self, function_name):
"""
Deletes a Lambda function.
:param function_name: The name of the function to delete.
"""
try:
self.lambda_client.delete_function(FunctionName=function_name)
except ClientError:
logger.exception("Couldn't delete function %s.", function_name)
raise
def invoke_function(self, function_name, function_params, get_log=False):
"""
Invokes a Lambda function.
:param function_name: The name of the function to invoke.
:param function_params: The parameters of the function as a dict. This dict
is serialized to JSON before it is sent to Lambda.
:param get_log: When true, the last 4 KB of the execution log are included in
the response.
:return: The response from the function invocation.
"""
try:
response = self.lambda_client.invoke(
FunctionName=function_name,
Payload=json.dumps(function_params),
LogType='Tail' if get_log else 'None')
logger.info("Invoked function %s.", function_name)
except ClientError:
logger.exception("Couldn't invoke function %s.", function_name)
raise
return response
def update_function_code(self, function_name, deployment_package):
"""
Updates the code for a Lambda function by submitting a .zip archive that contains
the code for the function.
:param function_name: The name of the function to update.
:param deployment_package: The function code to update, packaged as bytes in
.zip format.
:return: Data about the update, including the status.
"""
try:
response = self.lambda_client.update_function_code(
FunctionName=function_name, ZipFile=deployment_package)
except ClientError as err:
logger.error(
"Couldn't update function %s. Here's why: %s: %s", function_name,
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
def update_function_configuration(self, function_name, env_vars):
"""
Updates the environment variables for a Lambda function.
:param function_name: The name of the function to update.
:param env_vars: A dict of environment variables to update.
:return: Data about the update, including the status.
"""
try:
response = self.lambda_client.update_function_configuration(
FunctionName=function_name, Environment={'Variables': env_vars})
except ClientError as err:
logger.error(
"Couldn't update function configuration %s. Here's why: %s: %s", function_name,
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
def list_functions(self):
"""
Lists the Lambda functions for the current account.
"""
try:
func_paginator = self.lambda_client.get_paginator('list_functions')
for func_page in func_paginator.paginate():
for func in func_page['Functions']:
print(func['FunctionName'])
desc = func.get('Description')
if desc:
print(f"\t{desc}")
print(f"\t{func['Runtime']}: {func['Handler']}")
except ClientError as err:
logger.error(
"Couldn't list functions. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
Create a function that runs the scenario.
class UpdateFunctionWaiter(CustomWaiter):
"""A custom waiter that waits until a function is successfully updated."""
def __init__(self, client):
super().__init__(
'UpdateSuccess', 'GetFunction',
'Configuration.LastUpdateStatus',
{'Successful': WaitState.SUCCESS, 'Failed': WaitState.FAILURE},
client)
def wait(self, function_name):
self._wait(FunctionName=function_name)
def run_scenario(lambda_client, iam_resource, basic_file, calculator_file, lambda_name):
"""
Runs the scenario.
:param lambda_client: A Boto3 Lambda client.
:param iam_resource: A Boto3 IAM resource.
:param basic_file: The name of the file that contains the basic Lambda handler.
:param calculator_file: The name of the file that contains the calculator Lambda handler.
:param lambda_name: The name to give resources created for the scenario, such as the
IAM role and the Lambda function.
"""
logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
print('-'*88)
print("Welcome to the AWS Lambda getting started with functions demo.")
print('-'*88)
wrapper = LambdaWrapper(lambda_client, iam_resource)
print("Checking for IAM role for Lambda...")
iam_role, should_wait = wrapper.create_iam_role_for_lambda(lambda_name)
if should_wait:
logger.info("Giving AWS time to create resources...")
wait(10)
print(f"Looking for function {lambda_name}...")
function = wrapper.get_function(lambda_name)
if function is None:
print("Zipping the Python script into a deployment package...")
deployment_package = wrapper.create_deployment_package(basic_file, f"{lambda_name}.py")
print(f"...and creating the {lambda_name} Lambda function.")
wrapper.create_function(
lambda_name, f'{lambda_name}.lambda_handler', iam_role, deployment_package)
else:
print(f"Function {lambda_name} already exists.")
print('-'*88)
print(f"Let's invoke {lambda_name}. This function increments a number.")
action_params = {
'action': 'increment',
'number': q.ask("Give me a number to increment: ", q.is_int)}
print(f"Invoking {lambda_name}...")
response = wrapper.invoke_function(lambda_name, action_params)
print(f"Incrementing {action_params['number']} resulted in "
f"{json.load(response['Payload'])}")
print('-'*88)
print(f"Let's update the function to an arithmetic calculator.")
q.ask("Press Enter when you're ready.")
print("Creating a new deployment package...")
deployment_package = wrapper.create_deployment_package(calculator_file, f"{lambda_name}.py")
print(f"...and updating the {lambda_name} Lambda function.")
update_waiter = UpdateFunctionWaiter(lambda_client)
wrapper.update_function_code(lambda_name, deployment_package)
update_waiter.wait(lambda_name)
print(f"This function uses an environment variable to control logging level.")
print(f"Let's set it to DEBUG to get the most logging.")
wrapper.update_function_configuration(
lambda_name, {'LOG_LEVEL': logging.getLevelName(logging.DEBUG)})
actions = ['plus', 'minus', 'times', 'divided-by']
want_invoke = True
while want_invoke:
print(f"Let's invoke {lambda_name}. You can invoke these actions:")
for index, action in enumerate(actions):
print(f"{index + 1}: {action}")
action_params = {}
action_index = q.ask(
"Enter the number of the action you want to take: ",
q.is_int, q.in_range(1, len(actions)))
action_params['action'] = actions[action_index - 1]
print(f"You've chosen to invoke 'x {action_params['action']} y'.")
action_params['x'] = q.ask("Enter a value for x: ", q.is_int)
action_params['y'] = q.ask("Enter a value for y: ", q.is_int)
print(f"Invoking {lambda_name}...")
response = wrapper.invoke_function(lambda_name, action_params, True)
print(f"Calculating {action_params['x']} {action_params['action']} {action_params['y']} "
f"resulted in {json.load(response['Payload'])}")
q.ask("Press Enter to see the logs from the call.")
print(base64.b64decode(response['LogResult']).decode())
want_invoke = q.ask("That was fun. Shall we do it again? (y/n) ", q.is_yesno)
print('-'*88)
if q.ask("Do you want to list all of the functions in your account? (y/n) "):
wrapper.list_functions()
print('-'*88)
if q.ask("Ready to delete the function and role? (y/n) ", q.is_yesno):
for policy in iam_role.attached_policies.all():
policy.detach_role(RoleName=iam_role.name)
iam_role.delete()
print(f"Deleted role {lambda_name}.")
wrapper.delete_function(lambda_name)
print(f"Deleted function {lambda_name}.")
print("\nThanks for watching!")
print('-'*88)
if __name__ == '__main__':
try:
run_scenario(
boto3.client('lambda'), boto3.resource('iam'), 'lambda_handler_basic.py',
'lambda_handler_calculator.py', 'doc_example_lambda_calculator')
except Exception:
logging.exception("Something went wrong with the demo!")
- For API details, see the following topics in AWS SDK for Python (Boto3) API Reference.
For a complete list of AWS SDK developer guides and code examples, see Using Lambda with an AWS SDK. This topic also includes information about getting started and details about previous SDK versions.