or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

index.mdpolicies-tags.mdreplication.mdrotation.mdsecret-management.mdutilities.md
tile.json

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

Java client library for AWS Secrets Manager enabling secure storage, management, and retrieval of secrets.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/com.amazonaws/aws-java-sdk-secretsmanager@1.12.x

To install, run

npx @tessl/cli install tessl/maven-com-amazonaws--aws-java-sdk-secretsmanager@1.12.0

index.mddocs/

AWS Secrets Manager Java SDK

A comprehensive Java SDK for AWS Secrets Manager service providing secure storage and management of sensitive information like database credentials, API keys, and other secrets.

Package Information

<dependency>
    <groupId>com.amazonaws</groupId>
    <artifactId>aws-java-sdk-secretsmanager</artifactId>
    <version>1.12.789</version>
</dependency>
  • API Version: 2017-10-17
  • Service Endpoint: secretsmanager (regional)

Core Imports

// Core service interfaces
import com.amazonaws.services.secretsmanager.AWSSecretsManager;
import com.amazonaws.services.secretsmanager.AWSSecretsManagerAsync;

// Client implementations
import com.amazonaws.services.secretsmanager.AWSSecretsManagerClient;
import com.amazonaws.services.secretsmanager.AWSSecretsManagerAsyncClient;

// Client builders
import com.amazonaws.services.secretsmanager.AWSSecretsManagerClientBuilder;
import com.amazonaws.services.secretsmanager.AWSSecretsManagerAsyncClientBuilder;

// Common model classes
import com.amazonaws.services.secretsmanager.model.*;

// Exception handling
import com.amazonaws.services.secretsmanager.model.AWSSecretsManagerException;
import com.amazonaws.services.secretsmanager.model.ResourceNotFoundException;
import com.amazonaws.services.secretsmanager.model.InvalidParameterException;

Basic Usage

Creating a Client

// Synchronous client with default configuration
AWSSecretsManager client = AWSSecretsManagerClientBuilder.defaultClient();

// Synchronous client with custom region
AWSSecretsManager client = AWSSecretsManagerClientBuilder.standard()
    .withRegion("us-west-2")
    .build();

// Asynchronous client
AWSSecretsManagerAsync asyncClient = AWSSecretsManagerAsyncClientBuilder.standard()
    .withRegion("us-west-2")
    .build();

Simple Secret Operations

// Create a secret
CreateSecretRequest createRequest = new CreateSecretRequest()
    .withName("MySecret")
    .withSecretString("my-secret-value")
    .withDescription("Database password for production");
CreateSecretResult createResult = client.createSecret(createRequest);

// Retrieve a secret value
GetSecretValueRequest getRequest = new GetSecretValueRequest()
    .withSecretId("MySecret");
GetSecretValueResult getResult = client.getSecretValue(getRequest);
String secretValue = getResult.getSecretString();

// Update secret value
UpdateSecretRequest updateRequest = new UpdateSecretRequest()
    .withSecretId("MySecret")
    .withSecretString("new-secret-value");
UpdateSecretResult updateResult = client.updateSecret(updateRequest);

// Delete a secret (with recovery window)
DeleteSecretRequest deleteRequest = new DeleteSecretRequest()
    .withSecretId("MySecret")
    .withRecoveryWindowInDays(30L);
DeleteSecretResult deleteResult = client.deleteSecret(deleteRequest);

Core Service Interfaces

AWSSecretsManager (Synchronous Interface)

public interface AWSSecretsManager {
    // Service endpoint prefix
    String ENDPOINT_PREFIX = "secretsmanager";
    
    // Core secret operations
    CreateSecretResult createSecret(CreateSecretRequest request);
    GetSecretValueResult getSecretValue(GetSecretValueRequest request);
    UpdateSecretResult updateSecret(UpdateSecretRequest request);
    DeleteSecretResult deleteSecret(DeleteSecretRequest request);
    DescribeSecretResult describeSecret(DescribeSecretRequest request);
    ListSecretsResult listSecrets(ListSecretsRequest request);
    
    // Batch operations
    BatchGetSecretValueResult batchGetSecretValue(BatchGetSecretValueRequest request);
    
    // Secret value management
    PutSecretValueResult putSecretValue(PutSecretValueRequest request);
    
    // Version management
    ListSecretVersionIdsResult listSecretVersionIds(ListSecretVersionIdsRequest request);
    UpdateSecretVersionStageResult updateSecretVersionStage(UpdateSecretVersionStageRequest request);
    
    // Rotation operations
    RotateSecretResult rotateSecret(RotateSecretRequest request);
    CancelRotateSecretResult cancelRotateSecret(CancelRotateSecretRequest request);
    
    // Replication operations
    ReplicateSecretToRegionsResult replicateSecretToRegions(ReplicateSecretToRegionsRequest request);
    RemoveRegionsFromReplicationResult removeRegionsFromReplication(RemoveRegionsFromReplicationRequest request);
    StopReplicationToReplicaResult stopReplicationToReplica(StopReplicationToReplicaRequest request);
    RestoreSecretResult restoreSecret(RestoreSecretRequest request);
    
    // Resource policy operations
    GetResourcePolicyResult getResourcePolicy(GetResourcePolicyRequest request);
    PutResourcePolicyResult putResourcePolicy(PutResourcePolicyRequest request);
    DeleteResourcePolicyResult deleteResourcePolicy(DeleteResourcePolicyRequest request);
    ValidateResourcePolicyResult validateResourcePolicy(ValidateResourcePolicyRequest request);
    
    // Tagging operations
    TagResourceResult tagResource(TagResourceRequest request);
    UntagResourceResult untagResource(UntagResourceRequest request);
    
    // Utility operations
    GetRandomPasswordResult getRandomPassword(GetRandomPasswordRequest request);
    
    // Client lifecycle
    void shutdown();
    ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request);
}

AWSSecretsManagerAsync (Asynchronous Interface)

public interface AWSSecretsManagerAsync extends AWSSecretsManager {
    // All synchronous methods plus async variants
    
    // Batch operations
    Future<BatchGetSecretValueResult> batchGetSecretValueAsync(BatchGetSecretValueRequest request);
    Future<BatchGetSecretValueResult> batchGetSecretValueAsync(BatchGetSecretValueRequest request,
        AsyncHandler<BatchGetSecretValueRequest, BatchGetSecretValueResult> asyncHandler);
    
    // Rotation operations
    Future<CancelRotateSecretResult> cancelRotateSecretAsync(CancelRotateSecretRequest request);
    Future<CancelRotateSecretResult> cancelRotateSecretAsync(CancelRotateSecretRequest request,
        AsyncHandler<CancelRotateSecretRequest, CancelRotateSecretResult> asyncHandler);
    Future<RotateSecretResult> rotateSecretAsync(RotateSecretRequest request);
    Future<RotateSecretResult> rotateSecretAsync(RotateSecretRequest request,
        AsyncHandler<RotateSecretRequest, RotateSecretResult> asyncHandler);
    
    // Core secret operations
    Future<CreateSecretResult> createSecretAsync(CreateSecretRequest request);
    Future<CreateSecretResult> createSecretAsync(CreateSecretRequest request,
        AsyncHandler<CreateSecretRequest, CreateSecretResult> asyncHandler);
    Future<DeleteSecretResult> deleteSecretAsync(DeleteSecretRequest request);
    Future<DeleteSecretResult> deleteSecretAsync(DeleteSecretRequest request,
        AsyncHandler<DeleteSecretRequest, DeleteSecretResult> asyncHandler);
    Future<DescribeSecretResult> describeSecretAsync(DescribeSecretRequest request);
    Future<DescribeSecretResult> describeSecretAsync(DescribeSecretRequest request,
        AsyncHandler<DescribeSecretRequest, DescribeSecretResult> asyncHandler);
    Future<GetSecretValueResult> getSecretValueAsync(GetSecretValueRequest request);
    Future<GetSecretValueResult> getSecretValueAsync(GetSecretValueRequest request,
        AsyncHandler<GetSecretValueRequest, GetSecretValueResult> asyncHandler);
    Future<ListSecretsResult> listSecretsAsync(ListSecretsRequest request);
    Future<ListSecretsResult> listSecretsAsync(ListSecretsRequest request,
        AsyncHandler<ListSecretsRequest, ListSecretsResult> asyncHandler);
    Future<UpdateSecretResult> updateSecretAsync(UpdateSecretRequest request);
    Future<UpdateSecretResult> updateSecretAsync(UpdateSecretRequest request,
        AsyncHandler<UpdateSecretRequest, UpdateSecretResult> asyncHandler);
    
    // Secret value management
    Future<PutSecretValueResult> putSecretValueAsync(PutSecretValueRequest request);
    Future<PutSecretValueResult> putSecretValueAsync(PutSecretValueRequest request,
        AsyncHandler<PutSecretValueRequest, PutSecretValueResult> asyncHandler);
    
    // Version management
    Future<ListSecretVersionIdsResult> listSecretVersionIdsAsync(ListSecretVersionIdsRequest request);
    Future<ListSecretVersionIdsResult> listSecretVersionIdsAsync(ListSecretVersionIdsRequest request,
        AsyncHandler<ListSecretVersionIdsRequest, ListSecretVersionIdsResult> asyncHandler);
    Future<UpdateSecretVersionStageResult> updateSecretVersionStageAsync(UpdateSecretVersionStageRequest request);
    Future<UpdateSecretVersionStageResult> updateSecretVersionStageAsync(UpdateSecretVersionStageRequest request,
        AsyncHandler<UpdateSecretVersionStageRequest, UpdateSecretVersionStageResult> asyncHandler);
    
    // Replication operations
    Future<ReplicateSecretToRegionsResult> replicateSecretToRegionsAsync(ReplicateSecretToRegionsRequest request);
    Future<ReplicateSecretToRegionsResult> replicateSecretToRegionsAsync(ReplicateSecretToRegionsRequest request,
        AsyncHandler<ReplicateSecretToRegionsRequest, ReplicateSecretToRegionsResult> asyncHandler);
    Future<RemoveRegionsFromReplicationResult> removeRegionsFromReplicationAsync(RemoveRegionsFromReplicationRequest request);
    Future<RemoveRegionsFromReplicationResult> removeRegionsFromReplicationAsync(RemoveRegionsFromReplicationRequest request,
        AsyncHandler<RemoveRegionsFromReplicationRequest, RemoveRegionsFromReplicationResult> asyncHandler);
    Future<StopReplicationToReplicaResult> stopReplicationToReplicaAsync(StopReplicationToReplicaRequest request);
    Future<StopReplicationToReplicaResult> stopReplicationToReplicaAsync(StopReplicationToReplicaRequest request,
        AsyncHandler<StopReplicationToReplicaRequest, StopReplicationToReplicaResult> asyncHandler);
    Future<RestoreSecretResult> restoreSecretAsync(RestoreSecretRequest request);
    Future<RestoreSecretResult> restoreSecretAsync(RestoreSecretRequest request,
        AsyncHandler<RestoreSecretRequest, RestoreSecretResult> asyncHandler);
    
    // Resource policy operations
    Future<GetResourcePolicyResult> getResourcePolicyAsync(GetResourcePolicyRequest request);
    Future<GetResourcePolicyResult> getResourcePolicyAsync(GetResourcePolicyRequest request,
        AsyncHandler<GetResourcePolicyRequest, GetResourcePolicyResult> asyncHandler);
    Future<PutResourcePolicyResult> putResourcePolicyAsync(PutResourcePolicyRequest request);
    Future<PutResourcePolicyResult> putResourcePolicyAsync(PutResourcePolicyRequest request,
        AsyncHandler<PutResourcePolicyRequest, PutResourcePolicyResult> asyncHandler);
    Future<DeleteResourcePolicyResult> deleteResourcePolicyAsync(DeleteResourcePolicyRequest request);
    Future<DeleteResourcePolicyResult> deleteResourcePolicyAsync(DeleteResourcePolicyRequest request,
        AsyncHandler<DeleteResourcePolicyRequest, DeleteResourcePolicyResult> asyncHandler);
    Future<ValidateResourcePolicyResult> validateResourcePolicyAsync(ValidateResourcePolicyRequest request);
    Future<ValidateResourcePolicyResult> validateResourcePolicyAsync(ValidateResourcePolicyRequest request,
        AsyncHandler<ValidateResourcePolicyRequest, ValidateResourcePolicyResult> asyncHandler);
    
    // Tagging operations
    Future<TagResourceResult> tagResourceAsync(TagResourceRequest request);
    Future<TagResourceResult> tagResourceAsync(TagResourceRequest request,
        AsyncHandler<TagResourceRequest, TagResourceResult> asyncHandler);
    Future<UntagResourceResult> untagResourceAsync(UntagResourceRequest request);
    Future<UntagResourceResult> untagResourceAsync(UntagResourceRequest request,
        AsyncHandler<UntagResourceRequest, UntagResourceResult> asyncHandler);
    
    // Utility operations
    Future<GetRandomPasswordResult> getRandomPasswordAsync(GetRandomPasswordRequest request);
    Future<GetRandomPasswordResult> getRandomPasswordAsync(GetRandomPasswordRequest request,
        AsyncHandler<GetRandomPasswordRequest, GetRandomPasswordResult> asyncHandler);
}

Architecture

The AWS Secrets Manager Java SDK follows standard AWS SDK patterns:

  1. Service Interfaces: Define the contract for operations (AWSSecretsManager, AWSSecretsManagerAsync)
  2. Client Implementations: Provide concrete implementations (AWSSecretsManagerClient, AWSSecretsManagerAsyncClient)
  3. Builders: Configure and create client instances (AWSSecretsManagerClientBuilder)
  4. Request/Response Models: Strongly-typed objects for all API operations
  5. Exception Hierarchy: Structured exception handling for different error conditions

Capabilities

The AWS Secrets Manager SDK provides comprehensive functionality organized into key areas:

Secret Management

Core CRUD operations for secrets including creation, retrieval, updates, deletion, and lifecycle management. Covers both individual and batch operations.

Rotation Management

Automated secret rotation capabilities including rotation configuration, execution, cancellation, and version stage management for seamless credential updates.

Replication Management

Multi-region secret replication for high availability and disaster recovery, including cross-region setup, management, and cleanup operations.

Policies and Tagging

Resource-based access control through IAM policies and organizational management through resource tagging for governance and cost allocation.

Utility Operations

Helper functions including secure random password generation and resource policy validation for enhanced security and compliance.

Exception Handling

All operations can throw AWS Secrets Manager specific exceptions:

// Base exception class
class AWSSecretsManagerException extends AmazonServiceException {
    // Inherits standard AWS error information
}

// Resource-related exceptions
class ResourceNotFoundException extends AWSSecretsManagerException {}
class ResourceExistsException extends AWSSecretsManagerException {}

// Parameter and request validation exceptions
class InvalidParameterException extends AWSSecretsManagerException {}
class InvalidRequestException extends AWSSecretsManagerException {}
class InvalidNextTokenException extends AWSSecretsManagerException {}

// Encryption and security exceptions
class DecryptionFailureException extends AWSSecretsManagerException {}
class EncryptionFailureException extends AWSSecretsManagerException {}

// Policy-related exceptions
class MalformedPolicyDocumentException extends AWSSecretsManagerException {}
class PublicPolicyException extends AWSSecretsManagerException {}

// Quota and precondition exceptions
class LimitExceededException extends AWSSecretsManagerException {}
class PreconditionNotMetException extends AWSSecretsManagerException {}

// Service availability exception
class InternalServiceErrorException extends AWSSecretsManagerException {}

Best Practices

  1. Client Management: Use client builders and reuse client instances across operations
  2. Error Handling: Implement proper exception handling for all service operations
  3. Security: Use IAM roles and policies to control access to secrets
  4. Pagination: Handle pagination for list operations using nextToken
  5. Resource Cleanup: Call shutdown() on clients when done to release resources
  6. Async Operations: Use async clients for high-throughput scenarios

Thread Safety

  • Client instances are thread-safe and can be shared across multiple threads
  • Request and response objects are not thread-safe
  • Async handlers should be designed for concurrent execution