tessl/maven-com-amazonaws--aws-java-sdk-lambda

AWS Java SDK client for communicating with AWS Lambda Service for function management, invocation, and resource control

—

Pending

Overview

Eval results

Files

Concurrency and Performance Management

Name: tessl/maven-com-amazonaws--aws-java-sdk-lambda
Author: tessl

Comprehensive concurrency control and performance optimization for Lambda functions through reserved concurrency limits and provisioned concurrency configurations to manage scaling behavior and reduce cold start latency.

Capabilities

Function Concurrency Management

Controls the maximum number of concurrent executions for a function through reserved concurrency allocation.

Set Function Concurrency

Sets reserved concurrency for a function, limiting maximum concurrent executions.

/**
 * Sets reserved concurrency limit for function to control maximum concurrent executions
 * @param request Concurrency configuration parameters including function name and limit
 * @return PutFunctionConcurrencyResult containing concurrency configuration details
 * @throws ServiceException if service encounters an error
 * @throws ResourceNotFoundException if function does not exist
 * @throws InvalidParameterValueException if concurrency value is invalid
 * @throws ResourceConflictException if function is being updated
 */
PutFunctionConcurrencyResult putFunctionConcurrency(PutFunctionConcurrencyRequest request);

public class PutFunctionConcurrencyRequest {
    /** Function name (required) - name, ARN, or partial ARN */
    private String functionName;
    /** Reserved concurrency limit (required) - 0 to throttle, 1+ to reserve */
    private Integer reservedConcurrencyExecutions;
}

public class PutFunctionConcurrencyResult {
    /** Reserved concurrency limit */
    private Integer reservedConcurrencyExecutions;
}

Get Function Concurrency

Retrieves the current concurrency configuration for a function.

/**
 * Retrieves function concurrency configuration
 * @param request Concurrency retrieval parameters including function name
 * @return GetFunctionConcurrencyResult containing concurrency settings
 * @throws ServiceException if service encounters an error
 * @throws ResourceNotFoundException if function does not exist
 */
GetFunctionConcurrencyResult getFunctionConcurrency(GetFunctionConcurrencyRequest request);

public class GetFunctionConcurrencyRequest {
    /** Function name (required) - name, ARN, or partial ARN */
    private String functionName;
}

public class GetFunctionConcurrencyResult {
    /** Reserved concurrency limit */
    private Integer reservedConcurrencyExecutions;
}

Delete Function Concurrency

Removes reserved concurrency limit, allowing function to use account's unreserved concurrency pool.

/**
 * Removes function concurrency limit, returning to shared concurrency pool
 * @param request Concurrency removal parameters including function name
 * @return DeleteFunctionConcurrencyResult indicating successful removal
 * @throws ServiceException if service encounters an error
 * @throws ResourceNotFoundException if function does not exist
 * @throws ResourceConflictException if function is being updated
 */
DeleteFunctionConcurrencyResult deleteFunctionConcurrency(DeleteFunctionConcurrencyRequest request);

public class DeleteFunctionConcurrencyRequest {
    /** Function name (required) - name, ARN, or partial ARN */
    private String functionName;
}

public class DeleteFunctionConcurrencyResult {
    // Empty result indicating successful removal
}

Provisioned Concurrency Management

Manages pre-warmed execution environments to reduce cold start latency for function versions and aliases.

Set Provisioned Concurrency

Configures provisioned concurrency for a function version or alias.

/**
 * Configures provisioned concurrency for alias or version to reduce cold starts
 * @param request Provisioned concurrency configuration parameters
 * @return PutProvisionedConcurrencyConfigResult containing configuration details and status
 * @throws ServiceException if service encounters an error
 * @throws ResourceNotFoundException if function, version, or alias does not exist
 * @throws InvalidParameterValueException if configuration parameters are invalid
 * @throws ResourceConflictException if configuration is being updated
 */
PutProvisionedConcurrencyConfigResult putProvisionedConcurrencyConfig(PutProvisionedConcurrencyConfigRequest request);

public class PutProvisionedConcurrencyConfigRequest {
    /** Function name (required) - name, ARN, or partial ARN */
    private String functionName;
    /** Function version or alias (required) - cannot be $LATEST */
    private String qualifier;
    /** Provisioned concurrency amount (required) - minimum pre-warmed instances */
    private Integer provisionedConcurrencyExecutions;
}

public class PutProvisionedConcurrencyConfigResult {
    /** Requested provisioned concurrency */
    private Integer requestedProvisionedConcurrencyExecutions;
    /** Available provisioned concurrency */
    private Integer availableProvisionedConcurrencyExecutions;
    /** Allocated provisioned concurrency */
    private Integer allocatedProvisionedConcurrencyExecutions;
    /** Configuration status */
    private ProvisionedConcurrencyStatus status;
    /** Status reason */
    private String statusReason;
    /** Last modified timestamp */
    private String lastModified;
}

public enum ProvisionedConcurrencyStatus {
    IN_PROGRESS,
    READY,
    FAILED
}

Get Provisioned Concurrency Configuration

Retrieves provisioned concurrency configuration and status.

/**
 * Retrieves provisioned concurrency configuration and current status
 * @param request Configuration retrieval parameters including function and qualifier
 * @return GetProvisionedConcurrencyConfigResult containing configuration details
 * @throws ServiceException if service encounters an error
 * @throws ResourceNotFoundException if configuration does not exist
 * @throws ProvisionedConcurrencyConfigNotFoundException if no configuration exists
 */
GetProvisionedConcurrencyConfigResult getProvisionedConcurrencyConfig(GetProvisionedConcurrencyConfigRequest request);

public class GetProvisionedConcurrencyConfigRequest {
    /** Function name (required) - name, ARN, or partial ARN */
    private String functionName;
    /** Function version or alias (required) */
    private String qualifier;
}

public class GetProvisionedConcurrencyConfigResult {
    /** Requested provisioned concurrency */
    private Integer requestedProvisionedConcurrencyExecutions;
    /** Available provisioned concurrency */
    private Integer availableProvisionedConcurrencyExecutions;
    /** Allocated provisioned concurrency */
    private Integer allocatedProvisionedConcurrencyExecutions;
    /** Configuration status */
    private ProvisionedConcurrencyStatus status;
    /** Status reason */
    private String statusReason;
    /** Last modified timestamp */
    private String lastModified;
}

Delete Provisioned Concurrency Configuration

Removes provisioned concurrency configuration for a function version or alias.

/**
 * Removes provisioned concurrency configuration
 * @param request Configuration removal parameters including function and qualifier
 * @return DeleteProvisionedConcurrencyConfigResult indicating successful removal
 * @throws ServiceException if service encounters an error
 * @throws ResourceNotFoundException if configuration does not exist
 * @throws ResourceConflictException if configuration is being updated
 */
DeleteProvisionedConcurrencyConfigResult deleteProvisionedConcurrencyConfig(DeleteProvisionedConcurrencyConfigRequest request);

public class DeleteProvisionedConcurrencyConfigRequest {
    /** Function name (required) - name, ARN, or partial ARN */
    private String functionName;
    /** Function version or alias (required) */
    private String qualifier;
}

public class DeleteProvisionedConcurrencyConfigResult {
    // Empty result indicating successful removal
}

List Provisioned Concurrency Configurations

Lists all provisioned concurrency configurations for a function.

/**
 * Lists all provisioned concurrency configurations for function
 * @param request Configuration listing parameters including function name and pagination
 * @return ListProvisionedConcurrencyConfigsResult containing configuration list
 * @throws ServiceException if service encounters an error
 * @throws ResourceNotFoundException if function does not exist
 */
ListProvisionedConcurrencyConfigsResult listProvisionedConcurrencyConfigs(ListProvisionedConcurrencyConfigsRequest request);

public class ListProvisionedConcurrencyConfigsRequest {
    /** Function name (required) - name, ARN, or partial ARN */
    private String functionName;
    /** Pagination marker (optional) */
    private String marker;
    /** Maximum items to return (optional, range: 1-50) */
    private Integer maxItems;
}

public class ListProvisionedConcurrencyConfigsResult {
    /** Provisioned concurrency configurations */
    private List<ProvisionedConcurrencyConfigListItem> provisionedConcurrencyConfigs;
    /** Pagination marker for next page */
    private String nextMarker;
}

public class ProvisionedConcurrencyConfigListItem {
    /** Function ARN */
    private String functionArn;
    /** Requested provisioned concurrency */
    private Integer requestedProvisionedConcurrencyExecutions;
    /** Available provisioned concurrency */
    private Integer availableProvisionedConcurrencyExecutions;
    /** Allocated provisioned concurrency */
    private Integer allocatedProvisionedConcurrencyExecutions;
    /** Configuration status */
    private ProvisionedConcurrencyStatus status;
    /** Status reason */
    private String statusReason;
    /** Last modified timestamp */
    private String lastModified;
}

Usage Examples

Setting Reserved Concurrency

AWSLambda lambdaClient = AWSLambdaClientBuilder.defaultClient();

// Reserve 100 concurrent executions for critical function
PutFunctionConcurrencyRequest request = new PutFunctionConcurrencyRequest()
    .withFunctionName("critical-processing-function")
    .withReservedConcurrencyExecutions(100);

PutFunctionConcurrencyResult result = lambdaClient.putFunctionConcurrency(request);
System.out.println("Reserved concurrency: " + result.getReservedConcurrencyExecutions());

Throttling Function Executions

// Set reserved concurrency to 0 to throttle all executions
PutFunctionConcurrencyRequest throttleRequest = new PutFunctionConcurrencyRequest()
    .withFunctionName("maintenance-function")
    .withReservedConcurrencyExecutions(0);

lambdaClient.putFunctionConcurrency(throttleRequest);
System.out.println("Function throttled - all executions will be rejected");

Configuring Provisioned Concurrency

// Configure provisioned concurrency for production alias
PutProvisionedConcurrencyConfigRequest request = new PutProvisionedConcurrencyConfigRequest()
    .withFunctionName("latency-sensitive-api")
    .withQualifier("PROD")
    .withProvisionedConcurrencyExecutions(25);

PutProvisionedConcurrencyConfigResult result = lambdaClient.putProvisionedConcurrencyConfig(request);
System.out.println("Status: " + result.getStatus());
System.out.println("Requested: " + result.getRequestedProvisionedConcurrencyExecutions());

// Wait for provisioned concurrency to be ready
while (!ProvisionedConcurrencyStatus.READY.equals(result.getStatus())) {
    Thread.sleep(5000);
    
    GetProvisionedConcurrencyConfigRequest statusRequest = new GetProvisionedConcurrencyConfigRequest()
        .withFunctionName("latency-sensitive-api")
        .withQualifier("PROD");
    
    GetProvisionedConcurrencyConfigResult statusResult = lambdaClient.getProvisionedConcurrencyConfig(statusRequest);
    result.setStatus(statusResult.getStatus());
    System.out.println("Current status: " + result.getStatus());
}

Monitoring Concurrency Usage

// Check current concurrency configuration
GetFunctionConcurrencyRequest concurrencyRequest = new GetFunctionConcurrencyRequest()
    .withFunctionName("my-function");

try {
    GetFunctionConcurrencyResult concurrencyResult = lambdaClient.getFunctionConcurrency(concurrencyRequest);
    System.out.println("Reserved concurrency: " + concurrencyResult.getReservedConcurrencyExecutions());
} catch (ResourceNotFoundException e) {
    System.out.println("No reserved concurrency configured - using unreserved pool");
}

// List all provisioned concurrency configurations
ListProvisionedConcurrencyConfigsRequest listRequest = new ListProvisionedConcurrencyConfigsRequest()
    .withFunctionName("my-function");

ListProvisionedConcurrencyConfigsResult listResult = lambdaClient.listProvisionedConcurrencyConfigs(listRequest);
for (ProvisionedConcurrencyConfigListItem config : listResult.getProvisionedConcurrencyConfigs()) {
    System.out.println("Qualifier: " + extractQualifier(config.getFunctionArn()));
    System.out.println("Available: " + config.getAvailableProvisionedConcurrencyExecutions() + 
                      "/" + config.getRequestedProvisionedConcurrencyExecutions());
    System.out.println("Status: " + config.getStatus());
}

Scaling Strategy Implementation

public class ConcurrencyManager {
    private final AWSLambda lambdaClient;
    
    public ConcurrencyManager(AWSLambda lambdaClient) {
        this.lambdaClient = lambdaClient;
    }
    
    /**
     * Implement blue-green deployment with provisioned concurrency
     */
    public void deployWithProvisionedConcurrency(String functionName, String newVersion) {
        // Configure provisioned concurrency for new version
        PutProvisionedConcurrencyConfigRequest newVersionConfig = 
            new PutProvisionedConcurrencyConfigRequest()
                .withFunctionName(functionName)
                .withQualifier(newVersion)
                .withProvisionedConcurrencyExecutions(50);
        
        lambdaClient.putProvisionedConcurrencyConfig(newVersionConfig);
        
        // Wait for provisioned concurrency to be ready
        waitForProvisionedConcurrencyReady(functionName, newVersion);
        
        // Update alias to point to new version (traffic shift)
        UpdateAliasRequest aliasUpdate = new UpdateAliasRequest()
            .withFunctionName(functionName)
            .withName("PROD")
            .withFunctionVersion(newVersion);
        
        lambdaClient.updateAlias(aliasUpdate);
        
        // Clean up old version's provisioned concurrency after successful deployment
        // (implementation depends on your retention policy)
    }
    
    private void waitForProvisionedConcurrencyReady(String functionName, String qualifier) {
        GetProvisionedConcurrencyConfigRequest request = 
            new GetProvisionedConcurrencyConfigRequest()
                .withFunctionName(functionName)
                .withQualifier(qualifier);
        
        while (true) {
            try {
                GetProvisionedConcurrencyConfigResult result = lambdaClient.getProvisionedConcurrencyConfig(request);
                if (ProvisionedConcurrencyStatus.READY.equals(result.getStatus())) {
                    break;
                } else if (ProvisionedConcurrencyStatus.FAILED.equals(result.getStatus())) {
                    throw new RuntimeException("Provisioned concurrency failed: " + result.getStatusReason());
                }
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("Interrupted while waiting", e);
            }
        }
    }
}

Exception Handling

Common exceptions when managing concurrency:

ResourceNotFoundException: Function, version, or alias does not exist
ResourceConflictException: Function is being updated or configuration conflict
InvalidParameterValueException: Invalid concurrency values or qualifier
ProvisionedConcurrencyConfigNotFoundException: No provisioned concurrency configuration exists
ServiceException: General service errors
TooManyRequestsException: Rate limiting exceeded

Best Practices

Reserved Concurrency

Monitor account-level concurrent execution limits
Reserve concurrency for critical functions to ensure availability
Use throttling (concurrency = 0) for maintenance or emergency stops
Consider regional limits when setting reserved concurrency

Provisioned Concurrency

Use for latency-sensitive applications with predictable traffic
Configure provisioned concurrency on stable versions/aliases, not $LATEST
Monitor utilization to optimize provisioned concurrency levels
Consider cost implications - provisioned concurrency incurs charges even when idle

Performance Optimization

Combine reserved and provisioned concurrency for critical workloads
Use CloudWatch metrics to monitor concurrency usage and cold starts
Implement gradual scaling during traffic spikes
Test performance impact of concurrency configurations

Cost Management

Right-size provisioned concurrency based on actual usage patterns
Use Auto Scaling or custom logic to adjust provisioned concurrency dynamically
Monitor costs and utilization through CloudWatch and billing reports
Clean up unused provisioned concurrency configurations

Install with Tessl CLI

npx tessl i tessl/maven-com-amazonaws--aws-java-sdk-lambda

docs

account-settings.md

alias-version-management.md

client-management.md

concurrency-performance.md

event-source-mapping.md

function-invocation.md

function-management.md

function-url-management.md

high-level-invocation.md

index.md

layer-management.md

permissions-policies.md

runtime-management.md

security-code-signing.md

tagging.md

waiters-polling.md

tile.json