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

Alias and Version Management

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

Comprehensive version control and alias management for Lambda functions, enabling immutable versioning, traffic splitting, and deployment strategies through function aliases and version publishing.

Capabilities

Version Publishing

Creates an immutable version from the current function code and configuration.

/**
 * Creates an immutable version from current function code and configuration
 * @param request Version publishing parameters including function name and description
 * @return PublishVersionResult containing version configuration details
 * @throws ServiceException if service encounters an error
 * @throws ResourceNotFoundException if function does not exist
 * @throws InvalidParameterValueException if parameters are invalid
 */
PublishVersionResult publishVersion(PublishVersionRequest request);

public class PublishVersionRequest {
    /** Function name (required) - name, ARN, or partial ARN */
    private String functionName;
    /** SHA256 hash of ZIP file (optional) - ensures version consistency */
    private String codeSha256;
    /** Version description (optional) - up to 256 characters */
    private String description;
    /** Whether to publish function (optional, default: false) */
    private Boolean revisionId;
}

public class PublishVersionResult {
    /** Function name */
    private String functionName;
    /** Function ARN */
    private String functionArn;
    /** Runtime environment */
    private Runtime runtime;
    /** IAM role ARN */
    private String role;
    /** Function handler */
    private String handler;
    /** SHA256 of function code */
    private String codeSha256;
    /** Function code size in bytes */
    private Long codeSize;
    /** Function description */
    private String description;
    /** Timeout in seconds */
    private Integer timeout;
    /** Memory size in MB */
    private Integer memorySize;
    /** Last modified timestamp */
    private String lastModified;
    /** Version number */
    private String version;
    /** VPC configuration */
    private VpcConfigResponse vpcConfig;
    /** Dead letter queue configuration */
    private DeadLetterConfig deadLetterConfig;
    /** Environment variables */
    private EnvironmentResponse environment;
    /** KMS key ARN */
    private String kmsKeyArn;
    /** X-Ray tracing configuration */
    private TracingConfigResponse tracingConfig;
    /** Function state */
    private State state;
    /** State reason */
    private String stateReason;
    /** State reason code */
    private StateReasonCode stateReasonCode;
    /** Last update status */
    private LastUpdateStatus lastUpdateStatus;
    /** Last update status reason */
    private String lastUpdateStatusReason;
    /** Architecture */
    private Architecture architecture;
}

List Function Versions

Lists all versions for a specific function.

/**
 * Lists all versions for a specific function
 * @param request Version listing parameters including function name and pagination
 * @return ListVersionsByFunctionResult containing version list and pagination info
 * @throws ServiceException if service encounters an error
 * @throws ResourceNotFoundException if function does not exist
 */
ListVersionsByFunctionResult listVersionsByFunction(ListVersionsByFunctionRequest request);

public class ListVersionsByFunctionRequest {
    /** 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 ListVersionsByFunctionResult {
    /** Pagination marker for next page */
    private String nextMarker;
    /** List of function versions */
    private List<FunctionConfiguration> versions;
}

Alias Creation

Creates a function alias with optional traffic splitting support.

/**
 * Creates a function alias with traffic splitting capabilities
 * @param request Alias creation parameters including name, version, and traffic weights
 * @return CreateAliasResult containing alias configuration details
 * @throws ServiceException if service encounters an error
 * @throws ResourceConflictException if alias already exists
 * @throws InvalidParameterValueException if parameters are invalid
 */
CreateAliasResult createAlias(CreateAliasRequest request);

public class CreateAliasRequest {
    /** Function name (required) - name, ARN, or partial ARN */
    private String functionName;
    /** Alias name (required) - 1-128 characters, pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+) */
    private String name;
    /** Function version (required) - version number or $LATEST */
    private String functionVersion;
    /** Alias description (optional) - up to 256 characters */
    private String description;
    /** Additional version weights for traffic splitting (optional) */
    private Map<String, Double> additionalVersionWeights;
    /** Routing configuration (optional) */
    private AliasRoutingConfiguration routingConfig;
}

public class CreateAliasResult {
    /** Alias ARN */
    private String aliasArn;
    /** Alias name */
    private String name;
    /** Function version */
    private String functionVersion;
    /** Alias description */
    private String description;
    /** Additional version weights */
    private Map<String, Double> additionalVersionWeights;
    /** Routing configuration */
    private AliasRoutingConfiguration routingConfig;
    /** Revision ID */
    private String revisionId;
}

public class AliasRoutingConfiguration {
    /** Additional version weights for traffic routing */
    private Map<String, Double> additionalVersionWeights;
}

Alias Updates

Updates existing alias configuration including version and traffic weights.

/**
 * Updates existing alias configuration
 * @param request Alias update parameters including name, version, and traffic weights
 * @return UpdateAliasResult containing updated alias configuration
 * @throws ServiceException if service encounters an error
 * @throws ResourceNotFoundException if alias does not exist
 * @throws InvalidParameterValueException if parameters are invalid
 */
UpdateAliasResult updateAlias(UpdateAliasRequest request);

public class UpdateAliasRequest {
    /** Function name (required) - name, ARN, or partial ARN */
    private String functionName;
    /** Alias name (required) */
    private String name;
    /** Function version (optional) - version number or $LATEST */
    private String functionVersion;
    /** Alias description (optional) */
    private String description;
    /** Additional version weights (optional) */
    private Map<String, Double> additionalVersionWeights;
    /** Routing configuration (optional) */
    private AliasRoutingConfiguration routingConfig;
    /** Revision ID for optimistic locking (optional) */
    private String revisionId;
}

public class UpdateAliasResult {
    /** Alias ARN */
    private String aliasArn;
    /** Alias name */
    private String name;
    /** Function version */
    private String functionVersion;
    /** Alias description */
    private String description;
    /** Additional version weights */
    private Map<String, Double> additionalVersionWeights;
    /** Routing configuration */
    private AliasRoutingConfiguration routingConfig;
    /** Revision ID */
    private String revisionId;
}

Alias Retrieval

Retrieves configuration details for a specific alias.

/**
 * Retrieves alias configuration details
 * @param request Alias retrieval parameters including function and alias names
 * @return GetAliasResult containing alias configuration
 * @throws ServiceException if service encounters an error
 * @throws ResourceNotFoundException if alias does not exist
 */
GetAliasResult getAlias(GetAliasRequest request);

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

public class GetAliasResult {
    /** Alias ARN */
    private String aliasArn;
    /** Alias name */
    private String name;
    /** Function version */
    private String functionVersion;
    /** Alias description */
    private String description;
    /** Additional version weights */
    private Map<String, Double> additionalVersionWeights;
    /** Routing configuration */
    private AliasRoutingConfiguration routingConfig;
    /** Revision ID */
    private String revisionId;
}

Alias Deletion

Deletes a function alias.

/**
 * Deletes a function alias
 * @param request Alias deletion parameters including function and alias names
 * @return DeleteAliasResult indicating successful deletion
 * @throws ServiceException if service encounters an error
 * @throws ResourceNotFoundException if alias does not exist
 */
DeleteAliasResult deleteAlias(DeleteAliasRequest request);

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

public class DeleteAliasResult {
    // Empty result indicating successful deletion
}

Alias Listing

Lists all aliases for a specific function.

/**
 * Lists all aliases for a specific function
 * @param request Alias listing parameters including function name and pagination
 * @return ListAliasesResult containing alias list and pagination info
 * @throws ServiceException if service encounters an error
 * @throws ResourceNotFoundException if function does not exist
 */
ListAliasesResult listAliases(ListAliasesRequest request);

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

public class ListAliasesResult {
    /** Pagination marker for next page */
    private String nextMarker;
    /** List of function aliases */
    private List<AliasConfiguration> aliases;
}

public class AliasConfiguration {
    /** Alias ARN */
    private String aliasArn;
    /** Alias name */
    private String name;
    /** Function version */
    private String functionVersion;
    /** Alias description */
    private String description;
    /** Additional version weights */
    private Map<String, Double> additionalVersionWeights;
    /** Routing configuration */
    private AliasRoutingConfiguration routingConfig;
    /** Revision ID */
    private String revisionId;
}

Usage Examples

Publishing a Version

AWSLambda lambdaClient = AWSLambdaClientBuilder.defaultClient();

PublishVersionRequest request = new PublishVersionRequest()
    .withFunctionName("my-function")
    .withDescription("Production release v1.2.0")
    .withCodeSha256("abc123def456..."); // Optional: ensure specific code version

PublishVersionResult result = lambdaClient.publishVersion(request);
System.out.println("Published version: " + result.getVersion());

Creating an Alias with Traffic Splitting

// Create alias with 90% traffic to version 2, 10% to version 1
Map<String, Double> weights = new HashMap<>();
weights.put("1", 0.1);

CreateAliasRequest request = new CreateAliasRequest()
    .withFunctionName("my-function")
    .withName("live")
    .withFunctionVersion("2")
    .withDescription("Production alias")
    .withAdditionalVersionWeights(weights);

CreateAliasResult result = lambdaClient.createAlias(request);
System.out.println("Created alias ARN: " + result.getAliasArn());

Gradually Shifting Traffic

// Shift traffic from version 1 to version 2 (50/50 split)
Map<String, Double> newWeights = new HashMap<>();
newWeights.put("1", 0.5);

UpdateAliasRequest request = new UpdateAliasRequest()
    .withFunctionName("my-function")
    .withName("live")
    .withFunctionVersion("2")
    .withAdditionalVersionWeights(newWeights);

UpdateAliasResult result = lambdaClient.updateAlias(request);

Listing Function Versions

ListVersionsByFunctionRequest request = new ListVersionsByFunctionRequest()
    .withFunctionName("my-function")
    .withMaxItems(10);

ListVersionsByFunctionResult result = lambdaClient.listVersionsByFunction(request);
for (FunctionConfiguration version : result.getVersions()) {
    System.out.println("Version " + version.getVersion() + 
                      ": " + version.getDescription());
}

Exception Handling

Common exceptions when working with aliases and versions:

ResourceNotFoundException: Function or alias does not exist
ResourceConflictException: Alias name already exists during creation
InvalidParameterValueException: Invalid function name, alias name, or version
ServiceException: General service errors
TooManyRequestsException: Rate limiting exceeded
ResourceNotReadyException: Function is not ready for version publishing

Best Practices

Version Management

Use meaningful descriptions when publishing versions
Include code SHA256 hash to ensure version consistency
Implement automated version publishing in CI/CD pipelines
Keep version history manageable by periodically reviewing old versions

Alias Strategy

Use aliases for environment separation (dev, staging, prod)
Implement blue-green deployments using traffic splitting
Use descriptive alias names that indicate their purpose
Monitor traffic distribution when using weighted routing

Traffic Splitting

Start with small traffic percentages for canary deployments
Monitor metrics and error rates during traffic shifts
Use CloudWatch alarms to automatically rollback on errors
Gradually increase traffic to new versions based on success metrics

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