Class: Aws::Lambda::Client
- Inherits:
-
Seahorse::Client::Base
- Object
- Seahorse::Client::Base
- Aws::Lambda::Client
- Includes:
- ClientStubs
- Defined in:
- gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb
Overview
An API client for Lambda. To construct a client, you need to configure a :region and :credentials.
client = Aws::Lambda::Client.new(
region: region_name,
credentials: credentials,
# ...
)
For details on configuring region and credentials see the developer guide.
See #initialize for a full list of supported configuration options.
Instance Attribute Summary
Attributes inherited from Seahorse::Client::Base
API Operations collapse
-
#add_layer_version_permission(params = {}) ⇒ Types::AddLayerVersionPermissionResponse
Adds permissions to the resource-based policy of a version of an [Lambda layer][1].
-
#add_permission(params = {}) ⇒ Types::AddPermissionResponse
Grants a [principal][1] permission to use a function.
-
#checkpoint_durable_execution(params = {}) ⇒ Types::CheckpointDurableExecutionResponse
Saves the progress of a [durable function][1] execution during runtime.
-
#create_alias(params = {}) ⇒ Types::AliasConfiguration
Creates an [alias][1] for a Lambda Event Function version.
-
#create_capacity_provider(params = {}) ⇒ Types::CreateCapacityProviderResponse
Creates a capacity provider that manages compute resources for Lambda Event Functions.
-
#create_code_signing_config(params = {}) ⇒ Types::CreateCodeSigningConfigResponse
Creates a code signing configuration.
-
#create_event_source_mapping(params = {}) ⇒ Types::EventSourceMappingConfiguration
Creates a mapping between an event source and an Lambda Event Function.
-
#create_function(params = {}) ⇒ Types::FunctionConfiguration
Creates a Lambda Event Function.
-
#create_function_url_config(params = {}) ⇒ Types::CreateFunctionUrlConfigResponse
Creates a Lambda function URL with the specified configuration parameters.
-
#delete_alias(params = {}) ⇒ Struct
Deletes a Lambda Event Function [alias][1].
-
#delete_capacity_provider(params = {}) ⇒ Types::DeleteCapacityProviderResponse
Deletes a capacity provider.
-
#delete_code_signing_config(params = {}) ⇒ Struct
Deletes the code signing configuration.
-
#delete_durable_execution(params = {}) ⇒ Types::DeleteDurableExecutionResponse
Deletes a completed Lambda [durable execution][1] and its data.
-
#delete_event_source_mapping(params = {}) ⇒ Types::EventSourceMappingConfiguration
Deletes an [event source mapping][1].
-
#delete_function(params = {}) ⇒ Types::DeleteFunctionResponse
Deletes a Lambda Event Function.
-
#delete_function_code_signing_config(params = {}) ⇒ Struct
Removes the code signing configuration from the function.
-
#delete_function_concurrency(params = {}) ⇒ Struct
Removes a concurrent execution limit from a Lambda Event Function.
-
#delete_function_event_invoke_config(params = {}) ⇒ Struct
Deletes the configuration for asynchronous invocation for a function, version, or alias.
-
#delete_function_url_config(params = {}) ⇒ Struct
Deletes a Lambda function URL.
-
#delete_layer_version(params = {}) ⇒ Struct
Deletes a version of an [Lambda layer][1].
-
#delete_provisioned_concurrency_config(params = {}) ⇒ Struct
Deletes the provisioned concurrency configuration for a function.
-
#delete_resource_policy(params = {}) ⇒ Struct
Deletes a [resource-based policy][1] from a Lambda resource.
-
#get_account_settings(params = {}) ⇒ Types::GetAccountSettingsResponse
Retrieves details about your account's [limits][1] and usage in an Amazon Web Services Region.
-
#get_alias(params = {}) ⇒ Types::AliasConfiguration
Returns details about a Lambda Event Function [alias][1].
-
#get_capacity_provider(params = {}) ⇒ Types::GetCapacityProviderResponse
Retrieves information about a specific capacity provider, including its configuration, state, and associated resources.
-
#get_code_signing_config(params = {}) ⇒ Types::GetCodeSigningConfigResponse
Returns information about the specified code signing configuration.
-
#get_durable_execution(params = {}) ⇒ Types::GetDurableExecutionResponse
Retrieves detailed information about a specific [durable execution][1], including its current status, input payload, result or error information, and execution metadata such as start time and usage statistics.
-
#get_durable_execution_history(params = {}) ⇒ Types::GetDurableExecutionHistoryResponse
Retrieves the execution history for a [durable execution][1], showing all the steps, callbacks, and events that occurred during the execution.
-
#get_durable_execution_state(params = {}) ⇒ Types::GetDurableExecutionStateResponse
Retrieves the current execution state required for the replay process during [durable function][1] execution.
-
#get_event_source_mapping(params = {}) ⇒ Types::EventSourceMappingConfiguration
Returns details about an event source mapping.
-
#get_function(params = {}) ⇒ Types::GetFunctionResponse
Returns information about a Lambda Event Function or function version, with a link to download the deployment package that's valid for 10 minutes.
-
#get_function_code_signing_config(params = {}) ⇒ Types::GetFunctionCodeSigningConfigResponse
Returns the code signing configuration for the specified function.
-
#get_function_concurrency(params = {}) ⇒ Types::GetFunctionConcurrencyResponse
Returns details about the reserved concurrency configuration for a function.
-
#get_function_configuration(params = {}) ⇒ Types::FunctionConfiguration
Returns the version-specific settings of a Lambda Event Function or version.
-
#get_function_event_invoke_config(params = {}) ⇒ Types::FunctionEventInvokeConfig
Retrieves the configuration for asynchronous invocation for a function, version, or alias.
-
#get_function_recursion_config(params = {}) ⇒ Types::GetFunctionRecursionConfigResponse
Returns your function's [recursive loop detection][1] configuration.
-
#get_function_scaling_config(params = {}) ⇒ Types::GetFunctionScalingConfigResponse
Retrieves the scaling configuration for a Lambda Managed Instances function.
-
#get_function_url_config(params = {}) ⇒ Types::GetFunctionUrlConfigResponse
Returns details about a Lambda function URL.
-
#get_layer_version(params = {}) ⇒ Types::GetLayerVersionResponse
Returns information about a version of an [Lambda layer][1], with a link to download the layer archive that's valid for 10 minutes.
-
#get_layer_version_by_arn(params = {}) ⇒ Types::GetLayerVersionResponse
Returns information about a version of an [Lambda layer][1], with a link to download the layer archive that's valid for 10 minutes.
-
#get_layer_version_policy(params = {}) ⇒ Types::GetLayerVersionPolicyResponse
Returns the permission policy for a version of an [Lambda layer][1].
-
#get_policy(params = {}) ⇒ Types::GetPolicyResponse
Returns the [resource-based IAM policy][1] for a function, version, or alias.
-
#get_provisioned_concurrency_config(params = {}) ⇒ Types::GetProvisionedConcurrencyConfigResponse
Retrieves the provisioned concurrency configuration for a function's alias or version.
-
#get_resource_policy(params = {}) ⇒ Types::GetResourcePolicyResponse
Retrieves the [resource-based policy][1] attached to a Lambda resource.
-
#get_runtime_management_config(params = {}) ⇒ Types::GetRuntimeManagementConfigResponse
Retrieves the runtime management configuration for a function's version.
-
#invoke(params = {}) ⇒ Types::InvocationResponse
Invokes a Lambda Event Function.
-
#invoke_async(params = {}) ⇒ Types::InvokeAsyncResponse
For asynchronous function invocation, use Invoke. -
#invoke_with_response_stream(params = {}) ⇒ Types::InvokeWithResponseStreamResponse
Configure your Lambda Event Functions to stream response payloads back to clients.
-
#list_aliases(params = {}) ⇒ Types::ListAliasesResponse
Returns a list of [aliases][1] for a Lambda Event Function.
-
#list_capacity_providers(params = {}) ⇒ Types::ListCapacityProvidersResponse
Returns a list of capacity providers in your account.
-
#list_code_signing_configs(params = {}) ⇒ Types::ListCodeSigningConfigsResponse
Returns a list of [code signing configurations][1].
-
#list_durable_executions_by_function(params = {}) ⇒ Types::ListDurableExecutionsByFunctionResponse
Returns a list of [durable executions][1] for a specified Lambda function.
-
#list_event_source_mappings(params = {}) ⇒ Types::ListEventSourceMappingsResponse
Lists event source mappings.
-
#list_function_event_invoke_configs(params = {}) ⇒ Types::ListFunctionEventInvokeConfigsResponse
Retrieves a list of configurations for asynchronous invocation for a Lambda Event Function.
-
#list_function_url_configs(params = {}) ⇒ Types::ListFunctionUrlConfigsResponse
Returns a list of Lambda function URLs for the specified function.
-
#list_function_versions_by_capacity_provider(params = {}) ⇒ Types::ListFunctionVersionsByCapacityProviderResponse
Returns a list of function versions that are configured to use a specific capacity provider.
-
#list_functions(params = {}) ⇒ Types::ListFunctionsResponse
Returns a list of Lambda Event Functions, with the version-specific configuration of each.
-
#list_functions_by_code_signing_config(params = {}) ⇒ Types::ListFunctionsByCodeSigningConfigResponse
List the functions that use the specified code signing configuration.
-
#list_layer_versions(params = {}) ⇒ Types::ListLayerVersionsResponse
Lists the versions of an [Lambda layer][1].
-
#list_layers(params = {}) ⇒ Types::ListLayersResponse
Lists [Lambda layers][1] and shows information about the latest version of each.
-
#list_provisioned_concurrency_configs(params = {}) ⇒ Types::ListProvisionedConcurrencyConfigsResponse
Retrieves a list of provisioned concurrency configurations for a function.
-
#list_tags(params = {}) ⇒ Types::ListTagsResponse
Returns a function, event source mapping, or code signing configuration's [tags][1].
-
#list_versions_by_function(params = {}) ⇒ Types::ListVersionsByFunctionResponse
Returns a list of [versions][1] of a Lambda Event Function, with the version-specific configuration of each.
-
#pause_durable_execution(params = {}) ⇒ Struct
Pauses a running [durable execution][1].
-
#publish_layer_version(params = {}) ⇒ Types::PublishLayerVersionResponse
Creates an [Lambda layer][1] from a ZIP archive.
-
#publish_version(params = {}) ⇒ Types::FunctionConfiguration
Creates a [version][1] from the current code and configuration of a Lambda Event Function.
-
#put_function_code_signing_config(params = {}) ⇒ Types::PutFunctionCodeSigningConfigResponse
Update the code signing configuration for the function.
-
#put_function_concurrency(params = {}) ⇒ Types::Concurrency
Sets the maximum number of simultaneous executions for a Lambda Event Function, and reserves capacity for that concurrency level.
-
#put_function_event_invoke_config(params = {}) ⇒ Types::FunctionEventInvokeConfig
Configures options for [asynchronous invocation][1] on a function, version, or alias.
-
#put_function_recursion_config(params = {}) ⇒ Types::PutFunctionRecursionConfigResponse
Sets the [recursive loop detection][1] configuration for a Lambda Event Function.
-
#put_function_scaling_config(params = {}) ⇒ Types::PutFunctionScalingConfigResponse
Sets the scaling configuration for a Lambda Managed Instances function.
-
#put_provisioned_concurrency_config(params = {}) ⇒ Types::PutProvisionedConcurrencyConfigResponse
Adds a provisioned concurrency configuration to a function's alias or version.
-
#put_resource_policy(params = {}) ⇒ Types::PutResourcePolicyResponse
Adds a [resource-based policy][1] to a Lambda resource.
-
#put_runtime_management_config(params = {}) ⇒ Types::PutRuntimeManagementConfigResponse
Sets the runtime management configuration for a function's version.
-
#remove_layer_version_permission(params = {}) ⇒ Struct
Removes a statement from the permissions policy for a version of an [Lambda layer][1].
-
#remove_permission(params = {}) ⇒ Struct
Revokes function-use permission from an Amazon Web Services service or another Amazon Web Services account.
-
#resume_durable_execution(params = {}) ⇒ Struct
Resumes a paused [durable execution][1].
-
#send_durable_execution_callback_failure(params = {}) ⇒ Struct
Sends a failure response for a callback operation in a durable execution.
-
#send_durable_execution_callback_heartbeat(params = {}) ⇒ Struct
Sends a heartbeat signal for a long-running callback operation to prevent timeout.
-
#send_durable_execution_callback_success(params = {}) ⇒ Struct
Sends a successful completion response for a callback operation in a durable execution.
-
#stop_durable_execution(params = {}) ⇒ Types::StopDurableExecutionResponse
Stops a running or paused [durable execution][1].
-
#tag_resource(params = {}) ⇒ Struct
Adds [tags][1] to a function, event source mapping, or code signing configuration.
-
#untag_resource(params = {}) ⇒ Struct
Removes [tags][1] from a function, event source mapping, or code signing configuration.
-
#update_alias(params = {}) ⇒ Types::AliasConfiguration
Updates the configuration of a Lambda Event Function [alias][1].
-
#update_capacity_provider(params = {}) ⇒ Types::UpdateCapacityProviderResponse
Updates the configuration of an existing capacity provider.
-
#update_code_signing_config(params = {}) ⇒ Types::UpdateCodeSigningConfigResponse
Update the code signing configuration.
-
#update_event_source_mapping(params = {}) ⇒ Types::EventSourceMappingConfiguration
Updates an event source mapping.
-
#update_function_code(params = {}) ⇒ Types::FunctionConfiguration
Updates a Lambda Event Function's code.
-
#update_function_configuration(params = {}) ⇒ Types::FunctionConfiguration
Modifies the version-specific settings of a Lambda Event Function.
-
#update_function_event_invoke_config(params = {}) ⇒ Types::FunctionEventInvokeConfig
Updates the configuration for asynchronous invocation for a function, version, or alias.
-
#update_function_url_config(params = {}) ⇒ Types::UpdateFunctionUrlConfigResponse
Updates the configuration for a function URL of a Lambda Event Function.
Instance Method Summary collapse
-
#initialize(options) ⇒ Client
constructor
A new instance of Client.
-
#wait_until(waiter_name, params = {}, options = {}) {|w.waiter| ... } ⇒ Boolean
Polls an API operation until a resource enters a desired state.
Methods included from ClientStubs
#api_requests, #stub_data, #stub_responses
Methods inherited from Seahorse::Client::Base
add_plugin, api, clear_plugins, define, new, #operation_names, plugins, remove_plugin, set_api, set_plugins
Methods included from Seahorse::Client::HandlerBuilder
#handle, #handle_request, #handle_response
Constructor Details
#initialize(options) ⇒ Client
Returns a new instance of Client.
490 491 492 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 490 def initialize(*args) super end |
Instance Method Details
#add_layer_version_permission(params = {}) ⇒ Types::AddLayerVersionPermissionResponse
Adds permissions to the resource-based policy of a version of an Lambda layer. Use this action to grant layer usage permission to other accounts. You can grant permission to a single account, all accounts in an organization, or all Amazon Web Services accounts.
To revoke permission, call RemoveLayerVersionPermission with the statement ID that you specified when you added it.
583 584 585 586 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 583 def (params = {}, = {}) req = build_request(:add_layer_version_permission, params) req.send_request() end |
#add_permission(params = {}) ⇒ Types::AddPermissionResponse
Grants a principal permission to use a function. You can apply the policy at the function level, or specify a qualifier to restrict access to a single version or alias. If you use a qualifier, the invoker must use the full Amazon Resource Name (ARN) of that version or alias to invoke the function. Note: Lambda does not support adding policies to version $LATEST.
To grant permission to another account, specify the account ID as the
Principal. To grant permission to an organization defined in
Organizations, specify the organization ID as the PrincipalOrgID.
For Amazon Web Services services, the principal is a domain-style
identifier that the service defines, such as s3.amazonaws.com or
sns.amazonaws.com. For Amazon Web Services services, you can also
specify the ARN of the associated resource as the SourceArn. If you
grant permission to a service principal without specifying the source,
other accounts could potentially configure resources in their account
to invoke your Lambda function.
This operation adds a statement to a resource-based permissions policy for the function. For more information about function policies, see Using resource-based policies for Lambda.
758 759 760 761 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 758 def (params = {}, = {}) req = build_request(:add_permission, params) req.send_request() end |
#checkpoint_durable_execution(params = {}) ⇒ Types::CheckpointDurableExecutionResponse
Saves the progress of a durable function execution during runtime. This API is used by the Lambda durable functions SDK to checkpoint completed steps and schedule asynchronous operations. You typically don't need to call this API directly as the SDK handles checkpointing automatically.
Each checkpoint operation consumes the current checkpoint token and returns a new one for the next checkpoint. This ensures that checkpoints are applied in the correct order and prevents duplicate or out-of-order state updates.
897 898 899 900 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 897 def checkpoint_durable_execution(params = {}, = {}) req = build_request(:checkpoint_durable_execution, params) req.send_request() end |
#create_alias(params = {}) ⇒ Types::AliasConfiguration
Creates an alias for a Lambda Event Function version. Use aliases to provide clients with a function identifier that you can update to invoke a different version.
You can also map an alias to split invocation requests between two
versions. Use the RoutingConfig parameter to specify a second
version and the percentage of invocation requests that it receives.
1003 1004 1005 1006 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 1003 def create_alias(params = {}, = {}) req = build_request(:create_alias, params) req.send_request() end |
#create_capacity_provider(params = {}) ⇒ Types::CreateCapacityProviderResponse
Creates a capacity provider that manages compute resources for Lambda Event Functions
1127 1128 1129 1130 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 1127 def create_capacity_provider(params = {}, = {}) req = build_request(:create_capacity_provider, params) req.send_request() end |
#create_code_signing_config(params = {}) ⇒ Types::CreateCodeSigningConfigResponse
Creates a code signing configuration. A code signing configuration defines a list of allowed signing profiles and defines the code-signing validation policy (action to be taken if deployment validation checks fail).
1187 1188 1189 1190 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 1187 def create_code_signing_config(params = {}, = {}) req = build_request(:create_code_signing_config, params) req.send_request() end |
#create_event_source_mapping(params = {}) ⇒ Types::EventSourceMappingConfiguration
Creates a mapping between an event source and an Lambda Event Function. Lambda reads items from the event source and invokes the function.
For details about how to configure different event sources, see the following topics.
The following error handling options are available for stream sources (DynamoDB, Kinesis, Amazon MSK, and self-managed Apache Kafka):
BisectBatchOnFunctionError– If the function returns an error, split the batch in two and retry.MaximumRecordAgeInSeconds– Discard records older than the specified age. The default value is infinite (-1). When set to infinite (-1), failed records are retried until the record expiresMaximumRetryAttempts– Discard records after the specified number of retries. The default value is infinite (-1). When set to infinite (-1), failed records are retried until the record expires.OnFailure– Send discarded records to an Amazon SQS queue, Amazon SNS topic, Kafka topic, or Amazon S3 bucket. For more information, see Adding a destination.
The following option is available only for DynamoDB and Kinesis event sources:
ParallelizationFactor– Process multiple batches from each shard concurrently.
^
For information about which configuration parameters apply to each event source, see the following topics.
1735 1736 1737 1738 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 1735 def create_event_source_mapping(params = {}, = {}) req = build_request(:create_event_source_mapping, params) req.send_request() end |
#create_function(params = {}) ⇒ Types::FunctionConfiguration
Creates a Lambda Event Function. To create a function, you need a deployment package and an execution role. The deployment package is a .zip file archive or container image that contains your function code. The execution role grants the function permission to use Amazon Web Services services, such as Amazon CloudWatch Logs for log streaming and X-Ray for request tracing.
If the deployment package is a container image, then you set the
package type to Image. For a container image, the code property must
include the URI of a container image in the Amazon ECR registry. You
do not need to specify the handler and runtime properties.
If the deployment package is a .zip file archive, then you set
the package type to Zip. For a .zip file archive, the code property
specifies the location of the .zip file. You must also specify the
handler and runtime properties. The code in the deployment package
must be compatible with the target instruction set architecture of the
function (x86-64 or arm64). If you do not specify the
architecture, then the default value is x86-64.
When you create a function, Lambda provisions an instance of the
function and its supporting resources. If your function connects to a
VPC, this process can take a minute or so. During this time, you
can't invoke or modify the function. The State, StateReason, and
StateReasonCode fields in the response from GetFunctionConfiguration
indicate when the function is ready to invoke. For more information,
see Lambda function states.
A function has an unpublished version, and can have published versions
and aliases. The unpublished version changes when you update your
function's code and configuration. A published version is a snapshot
of your function code and configuration that can't be changed. An
alias is a named resource that maps to a version, and can be changed
to map to a different version. Use the Publish parameter to create
version 1 of your function from its initial configuration.
The other parameters let you configure version-specific and function-level settings. You can modify version-specific settings later with UpdateFunctionConfiguration. Function-level settings apply to both the unpublished and published versions of the function, and include tags (TagResource) and per-function concurrency limits (PutFunctionConcurrency).
You can use code signing if your deployment package is a .zip file archive. To enable code signing for this function, specify the ARN of a code-signing configuration. When a user attempts to deploy a code package with UpdateFunctionCode, Lambda checks that the code package has a valid signature from a trusted publisher. The code-signing configuration includes set of signing profiles, which define the trusted publishers for this function.
If another Amazon Web Services account or an Amazon Web Services service invokes your function, use AddPermission to grant permission by creating a resource-based Identity and Access Management (IAM) policy. You can grant permissions at the function level, on a version, or on an alias.
To invoke your function directly, use Invoke. To invoke your function in response to events in other Amazon Web Services services, create an event source mapping (CreateEventSourceMapping), or configure a function trigger in the other service. For more information, see Invoking Lambda functions.
2335 2336 2337 2338 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 2335 def create_function(params = {}, = {}) req = build_request(:create_function, params) req.send_request() end |
#create_function_url_config(params = {}) ⇒ Types::CreateFunctionUrlConfigResponse
Creates a Lambda function URL with the specified configuration parameters. A function URL is a dedicated HTTP(S) endpoint that you can use to invoke your function.
2442 2443 2444 2445 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 2442 def create_function_url_config(params = {}, = {}) req = build_request(:create_function_url_config, params) req.send_request() end |
#delete_alias(params = {}) ⇒ Struct
Deletes a Lambda Event Function alias.
2494 2495 2496 2497 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 2494 def delete_alias(params = {}, = {}) req = build_request(:delete_alias, params) req.send_request() end |
#delete_capacity_provider(params = {}) ⇒ Types::DeleteCapacityProviderResponse
Deletes a capacity provider. You cannot delete a capacity provider that is currently being used by Lambda functions.
2547 2548 2549 2550 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 2547 def delete_capacity_provider(params = {}, = {}) req = build_request(:delete_capacity_provider, params) req.send_request() end |
#delete_code_signing_config(params = {}) ⇒ Struct
Deletes the code signing configuration. You can delete the code signing configuration only if no function is using it.
2570 2571 2572 2573 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 2570 def delete_code_signing_config(params = {}, = {}) req = build_request(:delete_code_signing_config, params) req.send_request() end |
#delete_durable_execution(params = {}) ⇒ Types::DeleteDurableExecutionResponse
Deletes a completed Lambda durable execution and its data. The
execution must be in a terminal state (SUCCEEDED, FAILED,
STOPPED, or TIMED_OUT). Otherwise, this operation returns a
ResourceConflictException.
The execution has DELETING status until the deletion finishes. For
more information, see Deleting durable executions.
2609 2610 2611 2612 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 2609 def delete_durable_execution(params = {}, = {}) req = build_request(:delete_durable_execution, params) req.send_request() end |
#delete_event_source_mapping(params = {}) ⇒ Types::EventSourceMappingConfiguration
Deletes an event source mapping. You can get the identifier of a mapping from the output of ListEventSourceMappings.
When you delete an event source mapping, it enters a Deleting state
and might not be completely deleted for several seconds.
2759 2760 2761 2762 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 2759 def delete_event_source_mapping(params = {}, = {}) req = build_request(:delete_event_source_mapping, params) req.send_request() end |
#delete_function(params = {}) ⇒ Types::DeleteFunctionResponse
Deletes a Lambda Event Function. To delete a specific function
version, use the Qualifier parameter. Otherwise, all versions and
aliases are deleted. This doesn't require the user to have explicit
permissions for DeleteAlias.
To delete Lambda event source mappings that invoke a function, use DeleteEventSourceMapping. For Amazon Web Services services and resources that invoke your function directly, delete the trigger in the service where you originally configured it.
2829 2830 2831 2832 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 2829 def delete_function(params = {}, = {}) req = build_request(:delete_function, params) req.send_request() end |
#delete_function_code_signing_config(params = {}) ⇒ Struct
Removes the code signing configuration from the function.
2863 2864 2865 2866 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 2863 def delete_function_code_signing_config(params = {}, = {}) req = build_request(:delete_function_code_signing_config, params) req.send_request() end |
#delete_function_concurrency(params = {}) ⇒ Struct
Removes a concurrent execution limit from a Lambda Event Function.
2906 2907 2908 2909 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 2906 def delete_function_concurrency(params = {}, = {}) req = build_request(:delete_function_concurrency, params) req.send_request() end |
#delete_function_event_invoke_config(params = {}) ⇒ Struct
Deletes the configuration for asynchronous invocation for a function, version, or alias.
To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig.
2961 2962 2963 2964 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 2961 def delete_function_event_invoke_config(params = {}, = {}) req = build_request(:delete_function_event_invoke_config, params) req.send_request() end |
#delete_function_url_config(params = {}) ⇒ Struct
Deletes a Lambda function URL. When you delete a function URL, you can't recover it. Creating a new function URL results in a different URL address.
3001 3002 3003 3004 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 3001 def delete_function_url_config(params = {}, = {}) req = build_request(:delete_function_url_config, params) req.send_request() end |
#delete_layer_version(params = {}) ⇒ Struct
Deletes a version of an Lambda layer. Deleted versions can no longer be viewed or added to functions. To avoid breaking functions, a copy of the version remains in Lambda until no functions refer to it.
3043 3044 3045 3046 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 3043 def delete_layer_version(params = {}, = {}) req = build_request(:delete_layer_version, params) req.send_request() end |
#delete_provisioned_concurrency_config(params = {}) ⇒ Struct
Deletes the provisioned concurrency configuration for a function.
3092 3093 3094 3095 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 3092 def delete_provisioned_concurrency_config(params = {}, = {}) req = build_request(:delete_provisioned_concurrency_config, params) req.send_request() end |
#delete_resource_policy(params = {}) ⇒ Struct
Deletes a resource-based policy from a Lambda resource.
3128 3129 3130 3131 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 3128 def delete_resource_policy(params = {}, = {}) req = build_request(:delete_resource_policy, params) req.send_request() end |
#get_account_settings(params = {}) ⇒ Types::GetAccountSettingsResponse
Retrieves details about your account's limits and usage in an Amazon Web Services Region.
3182 3183 3184 3185 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 3182 def get_account_settings(params = {}, = {}) req = build_request(:get_account_settings, params) req.send_request() end |
#get_alias(params = {}) ⇒ Types::AliasConfiguration
Returns details about a Lambda Event Function alias.
3260 3261 3262 3263 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 3260 def get_alias(params = {}, = {}) req = build_request(:get_alias, params) req.send_request() end |
#get_capacity_provider(params = {}) ⇒ Types::GetCapacityProviderResponse
Retrieves information about a specific capacity provider, including its configuration, state, and associated resources.
3313 3314 3315 3316 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 3313 def get_capacity_provider(params = {}, = {}) req = build_request(:get_capacity_provider, params) req.send_request() end |
#get_code_signing_config(params = {}) ⇒ Types::GetCodeSigningConfigResponse
Returns information about the specified code signing configuration.
3347 3348 3349 3350 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 3347 def get_code_signing_config(params = {}, = {}) req = build_request(:get_code_signing_config, params) req.send_request() end |
#get_durable_execution(params = {}) ⇒ Types::GetDurableExecutionResponse
Retrieves detailed information about a specific durable execution, including its current status, input payload, result or error information, and execution metadata such as start time and usage statistics.
3425 3426 3427 3428 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 3425 def get_durable_execution(params = {}, = {}) req = build_request(:get_durable_execution, params) req.send_request() end |
#get_durable_execution_history(params = {}) ⇒ Types::GetDurableExecutionHistoryResponse
Retrieves the execution history for a durable execution, showing all the steps, callbacks, and events that occurred during the execution. This provides a detailed audit trail of the execution's progress over time.
The history is available while the execution is running and for a retention period after it completes (1-90 days, default 30 days). You can control whether to include execution data such as step results and callback payloads.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
3612 3613 3614 3615 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 3612 def get_durable_execution_history(params = {}, = {}) req = build_request(:get_durable_execution_history, params) req.send_request() end |
#get_durable_execution_state(params = {}) ⇒ Types::GetDurableExecutionStateResponse
Retrieves the current execution state required for the replay process during durable function execution. This API is used by the Lambda durable functions SDK to get state information needed for replay. You typically don't need to call this API directly as the SDK handles state management automatically.
The response contains operations ordered by start sequence number in ascending order. Completed operations with children don't include child operation details since they don't need to be replayed.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
3712 3713 3714 3715 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 3712 def get_durable_execution_state(params = {}, = {}) req = build_request(:get_durable_execution_state, params) req.send_request() end |
#get_event_source_mapping(params = {}) ⇒ Types::EventSourceMappingConfiguration
Returns details about an event source mapping. You can get the identifier of a mapping from the output of ListEventSourceMappings.
3862 3863 3864 3865 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 3862 def get_event_source_mapping(params = {}, = {}) req = build_request(:get_event_source_mapping, params) req.send_request() end |
#get_function(params = {}) ⇒ Types::GetFunctionResponse
Returns information about a Lambda Event Function or function version, with a link to download the deployment package that's valid for 10 minutes. If you specify a function version, only details that are specific to that version are returned.
The following waiters are defined for this operation (see #wait_until for detailed usage):
- function_active_v2
- function_exists
- function_updated_v2
4064 4065 4066 4067 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 4064 def get_function(params = {}, = {}) req = build_request(:get_function, params) req.send_request() end |
#get_function_code_signing_config(params = {}) ⇒ Types::GetFunctionCodeSigningConfigResponse
Returns the code signing configuration for the specified function.
4106 4107 4108 4109 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 4106 def get_function_code_signing_config(params = {}, = {}) req = build_request(:get_function_code_signing_config, params) req.send_request() end |
#get_function_concurrency(params = {}) ⇒ Types::GetFunctionConcurrencyResponse
Returns details about the reserved concurrency configuration for a function. To set a concurrency limit for a function, use PutFunctionConcurrency.
4162 4163 4164 4165 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 4162 def get_function_concurrency(params = {}, = {}) req = build_request(:get_function_concurrency, params) req.send_request() end |
#get_function_configuration(params = {}) ⇒ Types::FunctionConfiguration
Returns the version-specific settings of a Lambda Event Function or version. The output includes only options that can vary between versions of a function. To modify these settings, use UpdateFunctionConfiguration.
To get all of a function's details, including function-level settings, use GetFunction.
The following waiters are defined for this operation (see #wait_until for detailed usage):
- function_active
- function_updated
- published_version_active
4380 4381 4382 4383 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 4380 def get_function_configuration(params = {}, = {}) req = build_request(:get_function_configuration, params) req.send_request() end |
#get_function_event_invoke_config(params = {}) ⇒ Types::FunctionEventInvokeConfig
Retrieves the configuration for asynchronous invocation for a function, version, or alias.
To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig.
4465 4466 4467 4468 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 4465 def get_function_event_invoke_config(params = {}, = {}) req = build_request(:get_function_event_invoke_config, params) req.send_request() end |
#get_function_recursion_config(params = {}) ⇒ Types::GetFunctionRecursionConfigResponse
Returns your function's recursive loop detection configuration.
4497 4498 4499 4500 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 4497 def get_function_recursion_config(params = {}, = {}) req = build_request(:get_function_recursion_config, params) req.send_request() end |
#get_function_scaling_config(params = {}) ⇒ Types::GetFunctionScalingConfigResponse
Retrieves the scaling configuration for a Lambda Managed Instances function.
4537 4538 4539 4540 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 4537 def get_function_scaling_config(params = {}, = {}) req = build_request(:get_function_scaling_config, params) req.send_request() end |
#get_function_url_config(params = {}) ⇒ Types::GetFunctionUrlConfigResponse
Returns details about a Lambda function URL.
4602 4603 4604 4605 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 4602 def get_function_url_config(params = {}, = {}) req = build_request(:get_function_url_config, params) req.send_request() end |
#get_layer_version(params = {}) ⇒ Types::GetLayerVersionResponse
Returns information about a version of an Lambda layer, with a link to download the layer archive that's valid for 10 minutes.
4693 4694 4695 4696 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 4693 def get_layer_version(params = {}, = {}) req = build_request(:get_layer_version, params) req.send_request() end |
#get_layer_version_by_arn(params = {}) ⇒ Types::GetLayerVersionResponse
Returns information about a version of an Lambda layer, with a link to download the layer archive that's valid for 10 minutes.
4777 4778 4779 4780 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 4777 def get_layer_version_by_arn(params = {}, = {}) req = build_request(:get_layer_version_by_arn, params) req.send_request() end |
#get_layer_version_policy(params = {}) ⇒ Types::GetLayerVersionPolicyResponse
Returns the permission policy for a version of an Lambda layer. For more information, see AddLayerVersionPermission.
4816 4817 4818 4819 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 4816 def get_layer_version_policy(params = {}, = {}) req = build_request(:get_layer_version_policy, params) req.send_request() end |
#get_policy(params = {}) ⇒ Types::GetPolicyResponse
Returns the resource-based IAM policy for a function, version, or alias.
4885 4886 4887 4888 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 4885 def get_policy(params = {}, = {}) req = build_request(:get_policy, params) req.send_request() end |
#get_provisioned_concurrency_config(params = {}) ⇒ Types::GetProvisionedConcurrencyConfigResponse
Retrieves the provisioned concurrency configuration for a function's alias or version.
4979 4980 4981 4982 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 4979 def get_provisioned_concurrency_config(params = {}, = {}) req = build_request(:get_provisioned_concurrency_config, params) req.send_request() end |
#get_resource_policy(params = {}) ⇒ Types::GetResourcePolicyResponse
Retrieves the resource-based policy attached to a Lambda resource.
5017 5018 5019 5020 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 5017 def get_resource_policy(params = {}, = {}) req = build_request(:get_resource_policy, params) req.send_request() end |
#get_runtime_management_config(params = {}) ⇒ Types::GetRuntimeManagementConfigResponse
Retrieves the runtime management configuration for a function's
version. If the runtime update mode is Manual, this includes the
ARN of the runtime version and the runtime update mode. If the runtime
update mode is Auto or Function update, this includes the
runtime update mode and null is returned for the ARN. For more
information, see Runtime updates.
5076 5077 5078 5079 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 5076 def get_runtime_management_config(params = {}, = {}) req = build_request(:get_runtime_management_config, params) req.send_request() end |
#invoke(params = {}) ⇒ Types::InvocationResponse
Invokes a Lambda Event Function. You can invoke a function
synchronously (and wait for the response), or asynchronously. By
default, Lambda invokes your function synchronously (i.e.
theInvocationType is RequestResponse). To invoke a function
asynchronously, set InvocationType to Event. Lambda passes the
ClientContext object to your function for synchronous invocations
only.
For synchronous invocations, the maximum payload size is 6 MB. For asynchronous invocations, the maximum payload size is 1 MB.
For synchronous invocation, details about the function response, including errors, are included in the response body and headers. For either invocation type, you can find more information in the execution log and trace.
When an error occurs, your function may be invoked multiple times. Retry behavior varies by error type, client, event source, and invocation type. For example, if you invoke a function asynchronously and it returns an error, Lambda executes the function up to two more times. For more information, see Error handling and automatic retries in Lambda.
For asynchronous invocation, Lambda adds events to a queue before sending them to your function. If your function does not have enough capacity to keep up with the queue, events may be lost. Occasionally, your function may receive the same event multiple times, even if no error occurs. To retain events that were not processed, configure your function with a dead-letter queue.
The status code in the API response doesn't reflect function errors.
Error codes are reserved for errors that prevent your function from
executing, such as permissions errors, quota errors, or issues
with your function's code and configuration. For example, Lambda
returns TooManyRequestsException if running the function would cause
you to exceed a concurrency limit at either the account level
(ConcurrentInvocationLimitExceeded) or function level
(ReservedFunctionConcurrentInvocationLimitExceeded).
For functions with a long timeout, your client might disconnect during synchronous invocation while it waits for a response. Configure your HTTP client, SDK, firewall, proxy, or operating system to allow for long connections with timeout or keep-alive settings.
This operation requires permission for the lambda:InvokeFunction action. For details on how to set up permissions for cross-account invocations, see Granting function access to other accounts.
5284 5285 5286 5287 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 5284 def invoke(params = {}, = {}) req = build_request(:invoke, params) req.send_request() end |
#invoke_async(params = {}) ⇒ Types::InvokeAsyncResponse
Invokes a function asynchronously.
5360 5361 5362 5363 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 5360 def invoke_async(params = {}, = {}) req = build_request(:invoke_async, params) req.send_request() end |
#invoke_with_response_stream(params = {}) ⇒ Types::InvokeWithResponseStreamResponse
Configure your Lambda Event Functions to stream response payloads back to clients. For more information, see Configuring a Lambda function to stream responses.
This operation requires permission for the lambda:InvokeFunction action. For details on how to set up permissions for cross-account invocations, see Granting function access to other accounts.
5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 5565 def invoke_with_response_stream(params = {}, = {}, &block) params = params.dup event_stream_handler = case handler = params.delete(:event_stream_handler) when EventStreams::InvokeWithResponseStreamResponseEvent then handler when Proc then EventStreams::InvokeWithResponseStreamResponseEvent.new.tap(&handler) when nil then EventStreams::InvokeWithResponseStreamResponseEvent.new else msg = "expected :event_stream_handler to be a block or "\ "instance of Aws::Lambda::EventStreams::InvokeWithResponseStreamResponseEvent"\ ", got `#{handler.inspect}` instead" raise ArgumentError, msg end yield(event_stream_handler) if block_given? req = build_request(:invoke_with_response_stream, params) req.context[:event_stream_handler] = event_stream_handler req.handlers.add(Aws::Binary::DecodeHandler, priority: 95) req.send_request(, &block) end |
#list_aliases(params = {}) ⇒ Types::ListAliasesResponse
Returns a list of aliases for a Lambda Event Function.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
5686 5687 5688 5689 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 5686 def list_aliases(params = {}, = {}) req = build_request(:list_aliases, params) req.send_request() end |
#list_capacity_providers(params = {}) ⇒ Types::ListCapacityProvidersResponse
Returns a list of capacity providers in your account.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
5752 5753 5754 5755 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 5752 def list_capacity_providers(params = {}, = {}) req = build_request(:list_capacity_providers, params) req.send_request() end |
#list_code_signing_configs(params = {}) ⇒ Types::ListCodeSigningConfigsResponse
Returns a list of code signing configurations. A request returns
up to 10,000 configurations per call. You can use the MaxItems
parameter to return fewer configurations per call.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
5802 5803 5804 5805 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 5802 def list_code_signing_configs(params = {}, = {}) req = build_request(:list_code_signing_configs, params) req.send_request() end |
#list_durable_executions_by_function(params = {}) ⇒ Types::ListDurableExecutionsByFunctionResponse
Returns a list of durable executions for a specified Lambda function. You can filter the results by execution name, status, and start time range. This API supports pagination for large result sets.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
5906 5907 5908 5909 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 5906 def list_durable_executions_by_function(params = {}, = {}) req = build_request(:list_durable_executions_by_function, params) req.send_request() end |
#list_event_source_mappings(params = {}) ⇒ Types::ListEventSourceMappingsResponse
Lists event source mappings. Specify an EventSourceArn to show only
event source mappings for a single event source.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
6074 6075 6076 6077 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 6074 def list_event_source_mappings(params = {}, = {}) req = build_request(:list_event_source_mappings, params) req.send_request() end |
#list_function_event_invoke_configs(params = {}) ⇒ Types::ListFunctionEventInvokeConfigsResponse
Retrieves a list of configurations for asynchronous invocation for a
Lambda Event Function. To retrieve more configurations, use the
Marker parameter.
To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
6165 6166 6167 6168 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 6165 def list_function_event_invoke_configs(params = {}, = {}) req = build_request(:list_function_event_invoke_configs, params) req.send_request() end |
#list_function_url_configs(params = {}) ⇒ Types::ListFunctionUrlConfigsResponse
Returns a list of Lambda function URLs for the specified function.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
6236 6237 6238 6239 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 6236 def list_function_url_configs(params = {}, = {}) req = build_request(:list_function_url_configs, params) req.send_request() end |
#list_function_versions_by_capacity_provider(params = {}) ⇒ Types::ListFunctionVersionsByCapacityProviderResponse
Returns a list of function versions that are configured to use a specific capacity provider.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
6282 6283 6284 6285 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 6282 def list_function_versions_by_capacity_provider(params = {}, = {}) req = build_request(:list_function_versions_by_capacity_provider, params) req.send_request() end |
#list_functions(params = {}) ⇒ Types::ListFunctionsResponse
Returns a list of Lambda Event Functions, with the version-specific configuration of each. Lambda returns up to 50 functions per call.
Set FunctionVersion to ALL to include all published versions of
each function in addition to the unpublished version.
ListFunctions operation returns a subset of the
FunctionConfiguration fields. To get the additional fields (State,
StateReasonCode, StateReason, LastUpdateStatus,
LastUpdateStatusReason, LastUpdateStatusReasonCode,
RuntimeVersionConfig) for a function or version, use GetFunction.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
6483 6484 6485 6486 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 6483 def list_functions(params = {}, = {}) req = build_request(:list_functions, params) req.send_request() end |
#list_functions_by_code_signing_config(params = {}) ⇒ Types::ListFunctionsByCodeSigningConfigResponse
List the functions that use the specified code signing configuration. You can use this method prior to deleting a code signing configuration, to verify that no functions are using it.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
6527 6528 6529 6530 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 6527 def list_functions_by_code_signing_config(params = {}, = {}) req = build_request(:list_functions_by_code_signing_config, params) req.send_request() end |
#list_layer_versions(params = {}) ⇒ Types::ListLayerVersionsResponse
Lists the versions of an Lambda layer. Versions that have been deleted aren't listed. Specify a runtime identifier to list only versions that indicate that they're compatible with that runtime. Specify a compatible architecture to include only layer versions that are compatible with that architecture.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
6641 6642 6643 6644 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 6641 def list_layer_versions(params = {}, = {}) req = build_request(:list_layer_versions, params) req.send_request() end |
#list_layers(params = {}) ⇒ Types::ListLayersResponse
Lists Lambda layers and shows information about the latest version of each. Specify a runtime identifier to list only layers that indicate that they're compatible with that runtime. Specify a compatible architecture to include only layers that are compatible with that instruction set architecture.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
6750 6751 6752 6753 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 6750 def list_layers(params = {}, = {}) req = build_request(:list_layers, params) req.send_request() end |
#list_provisioned_concurrency_configs(params = {}) ⇒ Types::ListProvisionedConcurrencyConfigsResponse
Retrieves a list of provisioned concurrency configurations for a function.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
6842 6843 6844 6845 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 6842 def list_provisioned_concurrency_configs(params = {}, = {}) req = build_request(:list_provisioned_concurrency_configs, params) req.send_request() end |
#list_tags(params = {}) ⇒ Types::ListTagsResponse
Returns a function, event source mapping, or code signing configuration's tags. You can also view function tags with GetFunction.
6895 6896 6897 6898 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 6895 def (params = {}, = {}) req = build_request(:list_tags, params) req.send_request() end |
#list_versions_by_function(params = {}) ⇒ Types::ListVersionsByFunctionResponse
Returns a list of versions of a Lambda Event Function, with the version-specific configuration of each. Lambda returns up to 50 versions per call.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
7104 7105 7106 7107 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 7104 def list_versions_by_function(params = {}, = {}) req = build_request(:list_versions_by_function, params) req.send_request() end |
#pause_durable_execution(params = {}) ⇒ Struct
Pauses a running durable execution. While an execution is paused, Lambda doesn't invoke your function, but pending operations such as waits and callbacks continue to complete.
If an invocation is in progress, the execution status changes to
PAUSING until the invocation reaches its next checkpoint, and then
changes to PAUSED. This operation returns a successful response
while the execution status is still RUNNING, and the status changes
when Lambda processes the request. For more information about pausing
executions, see Pausing and resuming durable executions.
7163 7164 7165 7166 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 7163 def pause_durable_execution(params = {}, = {}) req = build_request(:pause_durable_execution, params) req.send_request() end |
#publish_layer_version(params = {}) ⇒ Types::PublishLayerVersionResponse
Creates an Lambda layer from a ZIP archive. Each time you call
PublishLayerVersion with the same layer name, a new version is
created.
Add layers to your function with CreateFunction or UpdateFunctionConfiguration.
7314 7315 7316 7317 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 7314 def publish_layer_version(params = {}, = {}) req = build_request(:publish_layer_version, params) req.send_request() end |
#publish_version(params = {}) ⇒ Types::FunctionConfiguration
Creates a version from the current code and configuration of a Lambda Event Function. Use versions to create a snapshot of your function code and configuration that doesn't change.
Lambda doesn't publish a version if the function's configuration and code haven't changed since the last version. Use UpdateFunctionCode or UpdateFunctionConfiguration to update the function before publishing a version.
Clients can invoke versions directly or with an alias. To create an alias, use CreateAlias.
7546 7547 7548 7549 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 7546 def publish_version(params = {}, = {}) req = build_request(:publish_version, params) req.send_request() end |
#put_function_code_signing_config(params = {}) ⇒ Types::PutFunctionCodeSigningConfigResponse
Update the code signing configuration for the function. Changes to the code signing configuration take effect the next time a user tries to deploy a code package to the function.
7594 7595 7596 7597 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 7594 def put_function_code_signing_config(params = {}, = {}) req = build_request(:put_function_code_signing_config, params) req.send_request() end |
#put_function_concurrency(params = {}) ⇒ Types::Concurrency
Sets the maximum number of simultaneous executions for a Lambda Event Function, and reserves capacity for that concurrency level.
Concurrency settings apply to the function as a whole, including all published versions and the unpublished version. Reserving concurrency both ensures that your function has capacity to process the specified number of events simultaneously, and prevents it from scaling beyond that level. Use GetFunction to see the current setting for a function.
Use GetAccountSettings to see your Regional concurrency limit. You can reserve concurrency for as many functions as you like, as long as you leave at least 100 simultaneous executions unreserved for functions that aren't configured with a per-function limit. For more information, see Lambda function scaling.
7670 7671 7672 7673 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 7670 def put_function_concurrency(params = {}, = {}) req = build_request(:put_function_concurrency, params) req.send_request() end |
#put_function_event_invoke_config(params = {}) ⇒ Types::FunctionEventInvokeConfig
Configures options for asynchronous invocation on a function, version, or alias. If a configuration already exists for a function, version, or alias, this operation overwrites it. If you exclude any settings, they are removed. To set one option without affecting existing settings for other options, use UpdateFunctionEventInvokeConfig.
By default, Lambda retries an asynchronous invocation twice if the function returns an error. It retains events in a queue for up to six hours. When an event fails all processing attempts or stays in the asynchronous invocation queue for too long, Lambda discards it. To retain discarded events, configure a dead-letter queue with UpdateFunctionConfiguration.
To send an invocation record to a queue, topic, S3 bucket, function, or event bus, specify a destination. You can configure separate destinations for successful invocations (on-success) and events that fail all processing attempts (on-failure). You can configure destinations in addition to or instead of a dead-letter queue.
7817 7818 7819 7820 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 7817 def put_function_event_invoke_config(params = {}, = {}) req = build_request(:put_function_event_invoke_config, params) req.send_request() end |
#put_function_recursion_config(params = {}) ⇒ Types::PutFunctionRecursionConfigResponse
Sets the recursive loop detection configuration for a Lambda Event Function.
When you configure a Lambda function to output to the same service or resource that invokes the function, it's possible to create an infinite recursive loop. For example, a Lambda function might write a message to an Amazon Simple Queue Service (Amazon SQS) queue, which then invokes the same function. This invocation causes the function to write another message to the queue, which in turn invokes the function again.
Lambda can detect certain types of recursive loops shortly after they
occur. When Lambda detects a recursive loop and your function's
recursive loop detection configuration is set to Terminate, it stops
your function being invoked and notifies you.
7903 7904 7905 7906 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 7903 def put_function_recursion_config(params = {}, = {}) req = build_request(:put_function_recursion_config, params) req.send_request() end |
#put_function_scaling_config(params = {}) ⇒ Types::PutFunctionScalingConfigResponse
Sets the scaling configuration for a Lambda Managed Instances function. The scaling configuration defines the minimum and maximum number of execution environments that can be provisioned for the function, allowing you to control scaling behavior and resource allocation.
7948 7949 7950 7951 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 7948 def put_function_scaling_config(params = {}, = {}) req = build_request(:put_function_scaling_config, params) req.send_request() end |
#put_provisioned_concurrency_config(params = {}) ⇒ Types::PutProvisionedConcurrencyConfigResponse
Adds a provisioned concurrency configuration to a function's alias or version.
8027 8028 8029 8030 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 8027 def put_provisioned_concurrency_config(params = {}, = {}) req = build_request(:put_provisioned_concurrency_config, params) req.send_request() end |
#put_resource_policy(params = {}) ⇒ Types::PutResourcePolicyResponse
Adds a resource-based policy to a Lambda resource. Resource-based policies grant access to other Amazon Web Services accounts, organizations, or services. Resource-based policies apply to a single Lambda resource (for example, a function, function version, or function alias).
This operation replaces any existing policy on the Lambda resource. If you previously added permissions using the AddPermission operation, the new policy overwrites those permissions.
8094 8095 8096 8097 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 8094 def put_resource_policy(params = {}, = {}) req = build_request(:put_resource_policy, params) req.send_request() end |
#put_runtime_management_config(params = {}) ⇒ Types::PutRuntimeManagementConfigResponse
Sets the runtime management configuration for a function's version. For more information, see Runtime updates.
8187 8188 8189 8190 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 8187 def put_runtime_management_config(params = {}, = {}) req = build_request(:put_runtime_management_config, params) req.send_request() end |
#remove_layer_version_permission(params = {}) ⇒ Struct
Removes a statement from the permissions policy for a version of an Lambda layer. For more information, see AddLayerVersionPermission.
8240 8241 8242 8243 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 8240 def (params = {}, = {}) req = build_request(:remove_layer_version_permission, params) req.send_request() end |
#remove_permission(params = {}) ⇒ Struct
Revokes function-use permission from an Amazon Web Services service or another Amazon Web Services account. You can get the ID of the statement from the output of GetPolicy.
8305 8306 8307 8308 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 8305 def (params = {}, = {}) req = build_request(:remove_permission, params) req.send_request() end |
#resume_durable_execution(params = {}) ⇒ Struct
Resumes a paused durable execution. If the pause interrupted an invocation, or an operation completed while the execution was paused, Lambda invokes your function. Otherwise, the execution continues to wait for its pending operations.
If the execution status is PAUSING, this operation cancels the
pause, and the in-progress invocation continues. This operation
returns a successful response while the execution status is still
PAUSED or PAUSING, and the status changes to RUNNING when Lambda
processes the request. For more information about resuming executions,
see Pausing and resuming durable executions.
8358 8359 8360 8361 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 8358 def resume_durable_execution(params = {}, = {}) req = build_request(:resume_durable_execution, params) req.send_request() end |
#send_durable_execution_callback_failure(params = {}) ⇒ Struct
Sends a failure response for a callback operation in a durable execution. Use this API when an external system cannot complete a callback operation successfully.
8392 8393 8394 8395 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 8392 def send_durable_execution_callback_failure(params = {}, = {}) req = build_request(:send_durable_execution_callback_failure, params) req.send_request() end |
#send_durable_execution_callback_heartbeat(params = {}) ⇒ Struct
Sends a heartbeat signal for a long-running callback operation to prevent timeout. Use this API to extend the callback timeout period while the external operation is still in progress.
8416 8417 8418 8419 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 8416 def send_durable_execution_callback_heartbeat(params = {}, = {}) req = build_request(:send_durable_execution_callback_heartbeat, params) req.send_request() end |
#send_durable_execution_callback_success(params = {}) ⇒ Struct
Sends a successful completion response for a callback operation in a durable execution. Use this API when an external system has successfully completed a callback operation.
8445 8446 8447 8448 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 8445 def send_durable_execution_callback_success(params = {}, = {}) req = build_request(:send_durable_execution_callback_success, params) req.send_request() end |
#stop_durable_execution(params = {}) ⇒ Types::StopDurableExecutionResponse
Stops a running or paused durable execution. The execution transitions to STOPPED status and cannot be resumed. Any in-progress operations are terminated.
8489 8490 8491 8492 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 8489 def stop_durable_execution(params = {}, = {}) req = build_request(:stop_durable_execution, params) req.send_request() end |
#tag_resource(params = {}) ⇒ Struct
Adds tags to a function, event source mapping, or code signing configuration.
8535 8536 8537 8538 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 8535 def tag_resource(params = {}, = {}) req = build_request(:tag_resource, params) req.send_request() end |
#untag_resource(params = {}) ⇒ Struct
Removes tags from a function, event source mapping, or code signing configuration.
8578 8579 8580 8581 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 8578 def untag_resource(params = {}, = {}) req = build_request(:untag_resource, params) req.send_request() end |
#update_alias(params = {}) ⇒ Types::AliasConfiguration
Updates the configuration of a Lambda Event Function alias.
8693 8694 8695 8696 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 8693 def update_alias(params = {}, = {}) req = build_request(:update_alias, params) req.send_request() end |
#update_capacity_provider(params = {}) ⇒ Types::UpdateCapacityProviderResponse
Updates the configuration of an existing capacity provider.
8777 8778 8779 8780 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 8777 def update_capacity_provider(params = {}, = {}) req = build_request(:update_capacity_provider, params) req.send_request() end |
#update_code_signing_config(params = {}) ⇒ Types::UpdateCodeSigningConfigResponse
Update the code signing configuration. Changes to the code signing configuration take effect the next time a user tries to deploy a code package to the function.
8829 8830 8831 8832 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 8829 def update_code_signing_config(params = {}, = {}) req = build_request(:update_code_signing_config, params) req.send_request() end |
#update_event_source_mapping(params = {}) ⇒ Types::EventSourceMappingConfiguration
Updates an event source mapping. You can change the function that Lambda invokes, or pause invocation and resume later from the same location.
For details about how to configure different event sources, see the following topics.
The following error handling options are available for stream sources (DynamoDB, Kinesis, Amazon MSK, and self-managed Apache Kafka):
BisectBatchOnFunctionError– If the function returns an error, split the batch in two and retry.MaximumRecordAgeInSeconds– Discard records older than the specified age. The default value is infinite (-1). When set to infinite (-1), failed records are retried until the record expiresMaximumRetryAttempts– Discard records after the specified number of retries. The default value is infinite (-1). When set to infinite (-1), failed records are retried until the record expires.OnFailure– Send discarded records to an Amazon SQS queue, Amazon SNS topic, Kafka topic, or Amazon S3 bucket. For more information, see Adding a destination.
The following option is available only for DynamoDB and Kinesis event sources:
ParallelizationFactor– Process multiple batches from each shard concurrently.
^
For information about which configuration parameters apply to each event source, see the following topics.
9316 9317 9318 9319 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 9316 def update_event_source_mapping(params = {}, = {}) req = build_request(:update_event_source_mapping, params) req.send_request() end |
#update_function_code(params = {}) ⇒ Types::FunctionConfiguration
Updates a Lambda Event Function's code. If code signing is enabled for the function, the code package must be signed by a trusted publisher. For more information, see Configuring code signing for Lambda.
If the function's package type is Image, then you must specify the
code package in ImageUri as the URI of a container image in the
Amazon ECR registry.
If the function's package type is Zip, then you must specify the
deployment package as a .zip file archive. Enter the Amazon S3
bucket and key of the code .zip file location. You can also provide
the function code inline using the ZipFile field.
The code in the deployment package must be compatible with the target
instruction set architecture of the function (x86-64 or arm64).
The function's code is locked when you publish a version. You can't modify the code of a published version, only the unpublished version.
9605 9606 9607 9608 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 9605 def update_function_code(params = {}, = {}) req = build_request(:update_function_code, params) req.send_request() end |
#update_function_configuration(params = {}) ⇒ Types::FunctionConfiguration
Modifies the version-specific settings of a Lambda Event Function.
When you update a function, Lambda provisions an instance of the
function and its supporting resources. If your function connects to a
VPC, this process can take a minute. During this time, you can't
modify the function, but you can still invoke it. The
LastUpdateStatus, LastUpdateStatusReason, and
LastUpdateStatusReasonCode fields in the response from
GetFunctionConfiguration indicate when the update is complete and the
function is processing events with the new configuration. For more
information, see Lambda function states.
These settings can vary between versions of a function and are locked when you publish a version. You can't modify the configuration of a published version, only the unpublished version.
To configure function concurrency, use PutFunctionConcurrency. To grant invoke permissions to an Amazon Web Services account or Amazon Web Services service, use AddPermission.
10080 10081 10082 10083 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 10080 def update_function_configuration(params = {}, = {}) req = build_request(:update_function_configuration, params) req.send_request() end |
#update_function_event_invoke_config(params = {}) ⇒ Types::FunctionEventInvokeConfig
Updates the configuration for asynchronous invocation for a function, version, or alias.
To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig.
10208 10209 10210 10211 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 10208 def update_function_event_invoke_config(params = {}, = {}) req = build_request(:update_function_event_invoke_config, params) req.send_request() end |
#update_function_url_config(params = {}) ⇒ Types::UpdateFunctionUrlConfigResponse
Updates the configuration for a function URL of a Lambda Event Function.
10316 10317 10318 10319 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 10316 def update_function_url_config(params = {}, = {}) req = build_request(:update_function_url_config, params) req.send_request() end |
#wait_until(waiter_name, params = {}, options = {}) {|w.waiter| ... } ⇒ Boolean
Polls an API operation until a resource enters a desired state.
Basic Usage
A waiter will call an API operation until:
- It is successful
- It enters a terminal state
- It makes the maximum number of attempts
In between attempts, the waiter will sleep.
# polls in a loop, sleeping between attempts
client.wait_until(waiter_name, params)
Configuration
You can configure the maximum number of polling attempts, and the delay (in seconds) between each polling attempt. You can pass configuration as the final arguments hash.
# poll for ~25 seconds
client.wait_until(waiter_name, params, {
max_attempts: 5,
delay: 5,
})
Callbacks
You can be notified before each polling attempt and before each
delay. If you throw :success or :failure from these callbacks,
it will terminate the waiter.
started_at = Time.now
client.wait_until(waiter_name, params, {
# disable max attempts
max_attempts: nil,
# poll for 1 hour, instead of a number of attempts
before_wait: -> (attempts, response) do
throw :failure if Time.now - started_at > 3600
end
})
Handling Errors
When a waiter is unsuccessful, it will raise an error. All of the failure errors extend from Waiters::Errors::WaiterFailed.
begin
client.wait_until(...)
rescue Aws::Waiters::Errors::WaiterFailed
# resource did not enter the desired state in time
end
Valid Waiters
The following table lists the valid waiter names, the operations they call,
and the default :delay and :max_attempts values.
| waiter_name | params | :delay | :max_attempts |
|---|---|---|---|
| function_active | #get_function_configuration | 5 | 60 |
| function_active_v2 | #get_function | 1 | 300 |
| function_exists | #get_function | 1 | 20 |
| function_updated | #get_function_configuration | 5 | 60 |
| function_updated_v2 | #get_function | 1 | 300 |
| published_version_active | #get_function_configuration | 5 | 312 |
10436 10437 10438 10439 10440 |
# File 'gems/aws-sdk-lambda/lib/aws-sdk-lambda/client.rb', line 10436 def wait_until(waiter_name, params = {}, = {}) w = waiter(waiter_name, ) yield(w.waiter) if block_given? # deprecated w.wait(params) end |