AWS Systems Manager Client

AWS Systems Manager (formerly Amazon EC2 Systems Manager, or SSM) is a service that you can use to view and control your infrastructure on AWS and in hybrid environments. One of the most useful features of SSM for microservices is the Parameter Store, which provides secure, hierarchical storage for configuration data management and secrets management.

For more information, see the AWS Systems Manager documentation.

The extension is based on AWS Java SDK 2.x. It’s a major rewrite of the 1.x code base that offers two programming models (Blocking & Async).

The Quarkus extension supports two programming models:

  • Blocking access using URL Connection HTTP client (by default), the Apache 5.x HTTP client, the Apache HTTP client (deprecated) or the AWS CRT-based HTTP client

  • Asynchronous programming based on JDK’s CompletableFuture objects and the Netty HTTP client or the AWS CRT-based HTTP client

In this guide, we see how you can get your REST services to use AWS Systems Manager locally and on AWS.

Prerequisites

To complete this guide, you need:

  • JDK 21+ installed with JAVA_HOME configured appropriately

  • an IDE

  • Apache Maven 3.8.1+

  • Docker, to run AWS Systems Manager locally with Dev Services and to run the tests

  • Optionally, GraalVM or Mandrel installed to build a native executable

No AWS account is required: Dev Services and the local Floci container provide everything you need. You only need an AWS account and the AWS Command Line Interface if you want to deploy to AWS.

Start Floci automatically with Dev Services

The easiest way to start working with AWS Systems Manager is to run a local instance using Dev Services. Dev Services starts a Floci container in dev and test modes, and configures the client to use it, so you don’t need an AWS account.

The container listens on a random port, so you never hard-code an endpoint. It is labelled quarkus-dev-service-floci and shared between the Quarkus applications running in dev mode. Refer to Dev Services for Amazon Services for the provider selection, the container configuration and the init scripts.

Start Floci manually

You can also start a Floci container yourself:

docker run --rm --name floci --publish 4566:4566 -d floci/floci:latest-compat

This starts a Floci instance that is accessible on port 4566. Floci exposes all the services it emulates on this single endpoint.

The latest-compat image ships the AWS CLI, already configured to target the local endpoint. Run the provisioning commands of this guide inside the container, with docker exec floci aws …​. You do not need to install or configure the AWS CLI on your host.

You can check the region, the credentials and the endpoint used inside the container:

docker exec floci env | grep AWS_

The CLI uses the region us-east-1, the credentials test / test, and the endpoint http://localhost:4566 seen from inside the container. An application running on the host reaches Floci at http://localhost:4566; an application running in another container must use the container name, for example http://floci:4566, and the containers must share a Docker network.

Solution

The application built here allows to store and retrieve parameters using the SSM parameter store.

It uses the synchronous client first, then the asynchronous client in Going asynchronous.

We recommend that you follow the instructions in the next sections and create the application step by step. However, you can go right to the completed example.

Clone the Git repository: git clone https://github.com/quarkusio/quarkus-quickstarts.git, or download an archive.

The solution is located in the amazon-ssm-quickstart directory.

Walkthrough

Creating the Maven project

First, we need a new project. Create a new project with the following command:

mvn io.quarkus.platform:quarkus-maven-plugin:4.0.0.Beta2:create \
    -DprojectGroupId=org.acme \
    -DprojectArtifactId=amazon-ssm-quickstart \
    -DclassName="org.acme.ssm.QuarkusSsmSyncResource" \
    -Dpath="/sync" \
    -Dextensions="rest-jackson,amazon-ssm"
cd amazon-ssm-quickstart

This command generates a Maven structure importing the Quarkus REST and AWS Systems Manager Client extensions. After this, the amazon-ssm extension has been added to your pom.xml, along with quarkus-rest and quarkus-rest-jackson.

The AWS Systems Manager extensions are a component of the Quarkus platform, and the generated pom.xml already imports their BOM through it, which is the recommended setup.

Due to differing release schedules, the Quarkus platform may not include the latest Quarkus Amazon Services release. If you need features from a newer release, replace the generated quarkus-amazon-services-bom import with the Quarkus Amazon Services BOM:

<dependency>
    <groupId>io.quarkiverse.amazonservices</groupId>
    <artifactId>quarkus-amazon-services-bom</artifactId>
    <version>4.0.0.Beta5</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

The command also generates a QuarkusSsmSyncResourceTest class and a QuarkusSsmSyncResourceIT class that call the hello endpoint of the generated resource. The next section replaces that resource: delete these two files, or update them to match the endpoints you create.

Creating the REST resource

Let’s start with an abstract org.acme.ssm.QuarkusSsmResource class to provide the common functionality we will need for both the synchronous and asynchronous exposures.

package org.acme.ssm;

import static java.lang.Boolean.TRUE;
import static java.util.stream.Collectors.toMap;

import java.util.Map;
import java.util.stream.Collector;

import jakarta.annotation.PostConstruct;

import org.eclipse.microprofile.config.inject.ConfigProperty;

import software.amazon.awssdk.services.ssm.model.GetParameterRequest;
import software.amazon.awssdk.services.ssm.model.GetParametersByPathRequest;
import software.amazon.awssdk.services.ssm.model.Parameter;
import software.amazon.awssdk.services.ssm.model.ParameterType;
import software.amazon.awssdk.services.ssm.model.PutParameterRequest;

public abstract class QuarkusSsmResource {

    @ConfigProperty(name = "parameters.path") (1)
    String parametersPath;

    @PostConstruct (2)
    void normalizePath() {
        if (!parametersPath.startsWith("/")) {
            parametersPath = "/" + parametersPath;
        }
        if (!parametersPath.endsWith("/")) {
            parametersPath = parametersPath + "/";
        }
    }

    protected Collector<Parameter, ?, Map<String, String>> parametersToMap() { (3)
        return toMap(p -> p.name().substring(parametersPath.length()), Parameter::value);
    }

    protected GetParametersByPathRequest generateGetParametersByPathRequest() {
        return GetParametersByPathRequest.builder() (4)
                .path(parametersPath)
                .withDecryption(TRUE)
                .build();
    }

    protected PutParameterRequest generatePutParameterRequest(String name, String value, boolean secure) {
        return PutParameterRequest.builder() (5)
                .name(parametersPath + name)
                .value(value)
                .type(secure ? ParameterType.SECURE_STRING : ParameterType.STRING)
                .overwrite(TRUE)
                .build();
    }

    protected GetParameterRequest generateGetParameterRequest(String name) {
        return GetParameterRequest.builder() (6)
                .name(parametersPath + name)
                .withDecryption(TRUE)
                .build();
    }
}
1 Inject a configured path under which to store parameters
2 Ensure the path starts and ends with /
3 Collect parameters into a map of simple names and values
4 Generate a request for all parameters under the configured path
5 Generate a request to set a specific parameter
6 Generate a request to get a specific parameter value

Now, we can extend the class and create the synchronous implementation in the org.acme.ssm.QuarkusSsmSyncResource class.

package org.acme.ssm;

import java.util.Map;

import jakarta.inject.Inject;
import jakarta.ws.rs.Consumes;
import jakarta.ws.rs.DefaultValue;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.PUT;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

import org.jboss.resteasy.reactive.RestQuery;

import software.amazon.awssdk.services.ssm.SsmClient;

@Path("/sync")
public class QuarkusSsmSyncResource extends QuarkusSsmResource {

    @Inject (1)
    SsmClient ssm;

    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public Map<String, String> getParameters() {
        return ssm.getParametersByPath(generateGetParametersByPathRequest())
                .parameters().stream().collect(parametersToMap());
    }

    @PUT
    @Path("/{name}")
    @Consumes(MediaType.TEXT_PLAIN)
    public void setParameter(String name,
            @RestQuery @DefaultValue("false") boolean secure,
            String value) {

        ssm.putParameter(generatePutParameterRequest(name, value, secure));
    }

    @GET
    @Path("/{name}")
    @Produces(MediaType.TEXT_PLAIN)
    public String getParameter(String name) {
        return ssm.getParameter(generateGetParameterRequest(name))
                .parameter().value();
    }
}
1 Inject the client provided by the amazon-ssm extension

Using the Amazon SSM SDK, we can easily store and retrieve arbitrary name/value pairs, and we can optionally store the values in a secure manner.

Configuring AWS Systems Manager clients

Both AWS Systems Manager clients (sync and async) are configurable via the application.properties file that can be provided in the src/main/resources directory. Additionally, you need to add to the classpath a proper implementation of the sync client. By default, the extension uses the URL connection HTTP client, so you need to add a URL connection client dependency to the pom.xml file:

<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>url-connection-client</artifactId>
</dependency>

If you want to use the Apache 5.x HTTP client instead, configure it as follows:

quarkus.ssm.sync-client.type=apache5

And add the following dependency to the application pom.xml:

<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>apache5-client</artifactId>
</dependency>

If you want to use the Apache HTTP client instead, configure it as follows:

quarkus.ssm.sync-client.type=apache

And add the following dependency to the application pom.xml:

<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>apache-client</artifactId>
</dependency>

The AWS SDK has deprecated the Apache HTTP client in favor of the Apache 5.x HTTP client, which is a drop-in replacement: prefer apache5. The build logs a warning when the Apache HTTP client is used. Set quarkus.aws.sync-client.apache-deprecation-warning=false to disable it, see Deprecated Apache HTTP client.

If you want to use the AWS CRT-based HTTP client instead, configure it as follows:

quarkus.ssm.sync-client.type=aws-crt

And add the following dependency to the application pom.xml:

<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>aws-crt-client</artifactId>
</dependency>

Use Dev Services

With Dev Services, there is nothing to configure: in dev and test modes, Dev Services starts Floci and configures the endpoint, the region and the credentials of the clients.

Use a manually started Floci

If you started Floci yourself, configure the client to use it as follows:

quarkus.ssm.endpoint-override=http://localhost:4566 (1)

quarkus.ssm.aws.region=us-east-1 (2)
quarkus.ssm.aws.credentials.type=static (3)
quarkus.ssm.aws.credentials.static-provider.access-key-id=test-key
quarkus.ssm.aws.credentials.static-provider.secret-access-key=test-secret
1 Override the AWS Systems Manager client to use Floci instead of the actual AWS service. When it is set, Dev Services does not start a local stack for AWS Systems Manager.
2 Floci defaults to us-east-1
3 The static credentials provider lets you set the access-key-id and secret-access-key directly

Use your AWS account

If you want to work with an AWS account, you need an AWS account with access to AWS Systems Manager and the AWS Command Line Interface, then remove or comment out the endpoint-override and the static credentials properties of the previous section. By default, the AWS Systems Manager client uses the default credentials provider chain that looks for credentials in this order:

  • Java System Properties - aws.accessKeyId and aws.secretAccessKey

  • Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY

  • Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI

  • Credentials delivered through the Amazon ECS if the AWS_CONTAINER_CREDENTIALS_RELATIVE_URI environment variable is set and the security manager has permission to access the variable,

  • Instance profile credentials delivered through the Amazon EC2 metadata service

And the region from your AWS CLI profile will be used.

Without endpoint-override, Dev Services starts a local stack for AWS Systems Manager in dev and test modes, and the client uses it instead of your AWS account. Removing the endpoint-override is therefore not enough to use your AWS account in these modes: also disable Dev Services for AWS Systems Manager:

quarkus.ssm.devservices.enabled=false

Dev Services never starts in production mode.

Set the parameters path

Set the path under which the application stores and reads its parameters:

parameters.path=/quarkus/is/awesome/

Run the application in Dev Mode

Run the application in dev mode with:

./mvnw clean quarkus:dev

If you use Dev Services, it starts a Floci container and configures the AWS Systems Manager clients to use it. The Dev Services card of the Dev UI, at http://localhost:8080/q/dev-ui, shows the container and the endpoint it exposes.

  • Store a plain and a secure parameter with the synchronous client:

curl -XPUT -H"Content-type: text/plain" "http://localhost:8080/sync/secure?secure=true" -d"stored as cipher text"
curl -XPUT -H"Content-type: text/plain" "http://localhost:8080/sync/plain" -d"stored as plain text"

  • List the parameters:

curl http://localhost:8080/sync

You should see output like this:

{"plain":"stored as plain text","secure":"stored as cipher text"}

Next steps

Packaging

Packaging your application is as simple as ./mvnw clean package. It can then be run with java -jar target/quarkus-app/quarkus-run.jar.

With GraalVM or Mandrel installed, you can also create a native executable binary:

./mvnw clean package -Dnative

Without GraalVM or Mandrel, build the native executable inside a container:

./mvnw clean package -Dnative -Dquarkus.native.container-build=true

Depending on your system, that will take some time. Run the native executable with ./target/amazon-ssm-quickstart-1.0.0-SNAPSHOT-runner.

Dev Services does not start in production mode, so you need to make sure that your application.properties file is configured to use your AWS account or a local stack. To use a local Floci instance, pass the endpoint and the credentials on the command line: 
java \
    -Dquarkus.ssm.endpoint-override=http://localhost:4566 \
    -Dquarkus.ssm.aws.region=us-east-1 \
    -Dquarkus.ssm.aws.credentials.type=static \
    -Dquarkus.ssm.aws.credentials.static-provider.access-key-id=test-key \
    -Dquarkus.ssm.aws.credentials.static-provider.secret-access-key=test-secret \
    -jar target/quarkus-app/quarkus-run.jar

See the Packaging applications guide for more details.

Going asynchronous

Thanks to the AWS SDK v2.x used by the Quarkus extension, you can use the asynchronous programming model out of the box.

Create a org.acme.ssm.QuarkusSsmAsyncResource REST resource that will be similar to our QuarkusSsmSyncResource but using an asynchronous programming model.

package org.acme.ssm;

import java.util.Map;

import jakarta.inject.Inject;
import jakarta.ws.rs.Consumes;
import jakarta.ws.rs.DefaultValue;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.PUT;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

import org.jboss.resteasy.reactive.RestQuery;

import io.smallrye.mutiny.Uni;
import software.amazon.awssdk.services.ssm.SsmAsyncClient;

@Path("/async")
public class QuarkusSsmAsyncResource extends QuarkusSsmResource {

    @Inject
    SsmAsyncClient ssm;

    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public Uni<Map<String, String>> getParameters() {
        return Uni.createFrom().completionStage(ssm.getParametersByPath(generateGetParametersByPathRequest()))
                .onItem().transform(r -> r.parameters().stream().collect(parametersToMap()));
    }

    @PUT
    @Path("/{name}")
    @Consumes(MediaType.TEXT_PLAIN)
    public Uni<Void> setParameter(String name,
            @RestQuery @DefaultValue("false") boolean secure,
            String value) {

        return Uni.createFrom().completionStage(ssm.putParameter(generatePutParameterRequest(name, value, secure)))
                .onItem().transform(r -> null);
    }

    @GET
    @Path("/{name}")
    @Produces(MediaType.TEXT_PLAIN)
    public Uni<String> getParameter(String name) {
        return Uni.createFrom().completionStage(ssm.getParameter(generateGetParameterRequest(name)))
                .onItem().transform(r -> r.parameter().value());
    }
}

Note that the SsmAsyncClient behaves just like the SsmClient, but returns CompletionStage objects which we use to create Uni instances, and then transform the emitted item.

To enable the asynchronous client, you also need to add the Netty HTTP client dependency to the pom.xml:

<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>netty-nio-client</artifactId>
</dependency>

If you want to use the AWS CRT-based HTTP client instead, configure it as follows:

quarkus.ssm.async-client.type=aws-crt

And add the following dependency to the application pom.xml:

<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>aws-crt-client</artifactId>
</dependency>

Quarkus dev mode picks up the new resource, and restarts by itself when pom.xml changes: if the application is still running, wait a few seconds, then call it again. Otherwise, run it again with ./mvnw quarkus:dev.

  • Call the same endpoints with the asynchronous client, replacing sync with async in the URLs.

Going further

You have built a Quarkus application that uses AWS Systems Manager, developed locally against Dev Services and ready to run on your AWS account. You are all set to build great applications with AWS Systems Manager, with the fast startup, the low memory footprint and the developer joy of Quarkus.

To go further:

Using AWS Systems Manager Parameter Store as a Quarkus Config Source

Load application properties from SSM parameters. See Configuration from AWS to compare providers, read properties in your application and configure AWS access.

Load parameters by path or name

Create parameter /myapp/prod/db/url with value jdbc:postgresql://database.example.com:5432/myapp. Enable the source and select its parent path:

quarkus.ssm.config.enabled=true
quarkus.ssm.config.path=/myapp/prod/

The db.url property contains that JDBC URL. Nested parameters are included and SecureString values are decrypted by default; use recursive=false or with-decryption=false under quarkus.ssm.config to change those settings.

To select only this parameter, replace path with an explicit name:

quarkus.ssm.config.enabled=true
quarkus.ssm.config.names[0]=/myapp/prod/db/url

The property is then myapp.prod.db.url, because explicit selections retain the full name. You can also combine paths and explicit names. Grant ssm:GetParametersByPath for path selections or ssm:GetParameters for explicit names, plus appropriate KMS decrypt permissions for SecureString values. An empty selection fails startup by default; quarkus.ssm.config.fail-on-missing-config=false skips the source instead.

Named paths and prefixes

quarkus.ssm.config.enabled=true
quarkus.ssm.config.entries.database.path=/myapp/prod
quarkus.ssm.config.entries.database.prefix=myapp
quarkus.ssm.config.entries.database.format=auto
quarkus.ssm.config.entries.database.recursive=true

# Optional shorthand: prefix -> path, inheriting source-wide format/recursive settings
quarkus.ssm.config.path."shared"=/common/prod

/myapp/prod/db/url exposes myapp.db.url; the entry name database is not a prefix. The scalar path, prefix shortcuts, named entries and explicit names can be combined.

How configuration keys are exposed

  • Path selections use names relative to the loaded path: /myapp/prod/db/url loaded from /myapp/prod exposes db.url, plus any configured prefix.

  • Explicit names use the full name: /myapp/prod/url exposes myapp.prod.url.

  • / becomes .. For relative path naming only, complete index segments such as 0 become [0]: /myapp/prod/servers/0/name loaded from /myapp/prod exposes servers[0].name.

  • Document values are decoded under that parameter key. For example, explicit name /myapp/db containing {"connection":{"host":"db.example.com"}} exposes myapp.db.connection.host.

For format behavior, including JSON arrays/scalars, empty documents and raw fallback, see Formats, prefixes and property names. quarkus.ssm.config.format supplies the default; entries.<name>.format overrides it.

Path-selected keys are now relative by default. For /myapp/prod/db/url, the key changes from myapp.prod.db.url to db.url. To preserve full parameter names, set quarkus.ssm.config.key-naming=full. Alternatively, replace path=/myapp/prod with path."myapp.prod"=/myapp/prod to restore the old prefix explicitly. Explicit names are unaffected. For values previously interpreted using equals-sign detection, explicitly set quarkus.ssm.config.format=properties.

Optional polling

Set quarkus.ssm.config.update-interval=30S to re-fetch the selection after startup (default PT0S, minimum one second). If a read fails or an explicitly selected name is missing, the previous values remain available. Deleting a parameter under a selected path removes its properties after a successful complete refresh of that path. Use dynamic configuration lookups to observe refreshed values.

Resolve individual parameters with expressions

myapp.api-key=${ssm::/myapp/api-key}
# SSM version/label selectors and full ARNs are supported
myapp.previous-key=${ssm::/myapp/api-key:3}
myapp.database.password=${ssm::/myapp/database#/password}
quarkus.ssm.expression.cache-ttl=5M

If /myapp/api-key contains example-key, myapp.api-key returns example-key. The JSON example reads the password field of /myapp/database. Grant ssm:GetParameter and the appropriate KMS decrypt permission; values are decrypted. See individual-value examples for JSON Pointer syntax, caching and failure behavior; config.enabled is not required.

Supply credentials to a datasource

Follow the datasource example, installing the SSM extension instead of Secrets Manager. Store {"username":"app_user","password":"database-password"} in parameter /prod/database, then use these settings with your datasource URL and JDBC driver:

quarkus.ssm.credentials-provider.db.parameter-name=/prod/database
quarkus.ssm.credentials-provider.db.format=json

quarkus.datasource.credentials-provider=db
quarkus.datasource.credentials-provider-name=ssm-credentials-provider

New physical connections authenticate as app_user with the stored password, provided the database accepts those credentials. For a password-only document, set quarkus.ssm.credentials-provider.db.format=raw and keep quarkus.datasource.username=app_user locally. Alternatively, select individual raw parameters instead of parameter-name:

quarkus.ssm.credentials-provider.db.parameters.password=/prod/database-password
# Optional; omit to use quarkus.datasource.username
quarkus.ssm.credentials-provider.db.parameters.user=/prod/database-user
# Optional, false by default, including for a single document
quarkus.ssm.credentials-provider.db.batch-retrieval=true

Grant ssm:GetParameter by default, or ssm:GetParameters when enabling batching; there is no automatic fallback if batching is denied or unsupported. SecureString values also require the appropriate KMS decrypt permissions. Names, full ARNs and :version/:label selectors are supported; pinning a version prevents following later updates.

See credential formats and field selection and connection recycling when configuring rotation.

Configuration Reference

Configuration property fixed at build time - All other configuration properties are overridable at runtime

Configuration property

Type

Default

quarkus.ssm.interceptors

List of execution interceptors that will have access to read and modify the request and response objects as they are processed by the AWS SDK.

The list should consists of class names which implements software.amazon.awssdk.core.interceptor.ExecutionInterceptor interface. Classes will be attempted to be loaded via CDI first, and if no CDI beans are available, then the constructor with no parameters will be invoked to instantiate each class.

Environment variable: QUARKUS_SSM_INTERCEPTORS

list of string

quarkus.ssm.telemetry.enabled

OpenTelemetry AWS SDK instrumentation will be enabled if the OpenTelemetry extension is present and this value is true.

Environment variable: QUARKUS_SSM_TELEMETRY_ENABLED

boolean

true when quarkus-opentelemetry is present, false otherwise

quarkus.ssm.sync-client.type

Type of the sync HTTP client implementation

Environment variable: QUARKUS_SSM_SYNC_CLIENT_TYPE

url, apache, apache5, aws-crt

url

quarkus.ssm.async-client.type

Type of the async HTTP client implementation

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_TYPE

netty, aws-crt

netty

quarkus.ssm.devservices.enabled

If a local AWS stack should be used. (default to true) If this is true and endpoint-override is not configured then a local AWS stack will be started and will be used instead of the given configuration. The local AWS stack is provided by the stack provider configured with provider.

Environment variable: QUARKUS_SSM_DEVSERVICES_ENABLED

boolean

quarkus.ssm.devservices.container-properties."container-properties"

Generic properties that are pass for additional container configuration.

Environment variable: QUARKUS_SSM_DEVSERVICES_CONTAINER_PROPERTIES__CONTAINER_PROPERTIES_

Map<String,String>

quarkus.ssm.devservices.provider

The dev services stack provider to use for this service. If not specified, the global setting from quarkus.aws.devservices.provider is used. Supported values: "floci", "localstack", "ministack", "moto"

This allows per-service override of the global stack selection.

Environment variable: QUARKUS_SSM_DEVSERVICES_PROVIDER

floci, localstack, ministack, moto

quarkus.ssm.config.enabled

Whether to enable the AWS Systems Manager Parameter Store ConfigSource (quarkus.ssm.config).

Environment variable: QUARKUS_SSM_CONFIG_ENABLED

boolean

false

quarkus.ssm.config.fail-on-missing-config

Fail startup if configuration cannot be loaded completely, including missing resources, access or decoding errors.

Environment variable: QUARKUS_SSM_CONFIG_FAIL_ON_MISSING_CONFIG

boolean

true

quarkus.ssm.config.ordinal

Config source ordinal; higher values take precedence. Defaults between .env and application.properties.

Environment variable: QUARKUS_SSM_CONFIG_ORDINAL

int

270

quarkus.ssm.config.path

Parameter Store path passed to software.amazon.awssdk.services.ssm.model.GetParametersByPathRequest. When set, all parameters under this path are loaded (subject to recursive()).

Environment variable: QUARKUS_SSM_CONFIG_PATH

string

quarkus.ssm.config.path."prefixed-paths"

Additional paths keyed by their configuration prefix, alongside the legacy scalar path.

Environment variable: QUARKUS_SSM_CONFIG_PATH__PREFIXED_PATHS_

Map<String,String>

quarkus.ssm.config.key-naming

Path key naming. Relative is the default; full preserves the complete parameter name. Explicit names always use full names.

Environment variable: QUARKUS_SSM_CONFIG_KEY_NAMING

relative, full

relative

quarkus.ssm.config.names

Individual parameter names (full paths, for example /myapp/prod/db/url) passed to software.amazon.awssdk.services.ssm.model.GetParametersRequest. Batched in groups of ten per AWS limit.

You can combine this with path(); the merged result is exposed as configuration keys.

Environment variable: QUARKUS_SSM_CONFIG_NAMES

list of string

quarkus.ssm.config.format

Format of each parameter value. Auto detects JSON objects and arrays, otherwise preserving the raw value. Use properties for Java properties documents; equals signs alone never select a format. YAML requires the quarkus-config-yaml extension.

Environment variable: QUARKUS_SSM_CONFIG_FORMAT

auto, raw, json, properties, yaml

auto

quarkus.ssm.config.recursive

When using path(), whether to load parameters in sub-paths recursively.

Environment variable: QUARKUS_SSM_CONFIG_RECURSIVE

boolean

true

quarkus.ssm.config.with-decryption

Whether to decrypt SecureString parameters when fetching values.

Environment variable: QUARKUS_SSM_CONFIG_WITH_DECRYPTION

boolean

true

quarkus.ssm.config.update-interval

Interval between polling for configuration updates after the initial fetch.

Set to or greater than PT1S to enable periodic polling.

Environment variable: QUARKUS_SSM_CONFIG_UPDATE_INTERVAL

Duration 

PT0S

quarkus.ssm.expression.cache-ttl

Successful expression reads are cached for this duration. Zero disables caching; negative durations are rejected.

Environment variable: QUARKUS_SSM_EXPRESSION_CACHE_TTL

Duration 

5M

quarkus.ssm.config.entries."entries".path

Parameter Store hierarchy to load.

Environment variable: QUARKUS_SSM_CONFIG_ENTRIES__ENTRIES__PATH

string

required

quarkus.ssm.config.entries."entries".prefix

Optional prefix prepended to the exposed keys.

Environment variable: QUARKUS_SSM_CONFIG_ENTRIES__ENTRIES__PREFIX

string

quarkus.ssm.config.entries."entries".format

Value format; defaults to the source-wide format.

Environment variable: QUARKUS_SSM_CONFIG_ENTRIES__ENTRIES__FORMAT

auto, raw, json, properties, yaml

quarkus.ssm.config.entries."entries".recursive

Load nested parameters; defaults to the source-wide recursive setting.

Environment variable: QUARKUS_SSM_CONFIG_ENTRIES__ENTRIES__RECURSIVE

boolean

quarkus.ssm.credentials-provider."credentials-provider".parameter-name

Parameter name or ARN containing a credential document. Mutually exclusive with parameters.

Environment variable: QUARKUS_SSM_CREDENTIALS_PROVIDER__CREDENTIALS_PROVIDER__PARAMETER_NAME

string

quarkus.ssm.credentials-provider."credentials-provider".format

Document format: json (default), properties, yaml (requires quarkus-config-yaml), or raw (password only). The auto format is not supported for credentials.

Environment variable: QUARKUS_SSM_CREDENTIALS_PROVIDER__CREDENTIALS_PROVIDER__FORMAT

auto, raw, json, properties, yaml

json

quarkus.ssm.credentials-provider."credentials-provider".username-key

Document field containing the username; an empty setting omits the username. Missing fields are also omitted.

Environment variable: QUARKUS_SSM_CREDENTIALS_PROVIDER__CREDENTIALS_PROVIDER__USERNAME_KEY

string

username

quarkus.ssm.credentials-provider."credentials-provider".password-key

Required password field in a JSON, properties or YAML document.

Environment variable: QUARKUS_SSM_CREDENTIALS_PROVIDER__CREDENTIALS_PROVIDER__PASSWORD_KEY

string

password

quarkus.ssm.credentials-provider."credentials-provider".parameters."parameters"

Individual raw parameters keyed by Quarkus credential name: password (required) and user (optional).

Environment variable: QUARKUS_SSM_CREDENTIALS_PROVIDER__CREDENTIALS_PROVIDER__PARAMETERS__PARAMETERS_

Map<String,String>

quarkus.ssm.credentials-provider."credentials-provider".batch-retrieval

Use GetParameters instead of individual GetParameter calls, requiring its IAM permission. No fallback.

Environment variable: QUARKUS_SSM_CREDENTIALS_PROVIDER__CREDENTIALS_PROVIDER__BATCH_RETRIEVAL

boolean

false

quarkus.ssm.config.update-interval-minutes

This property is deprecated.

Interval in minutes between reloads after the initial fetch. Set greater than 0 to enable polling.

Environment variable: QUARKUS_SSM_CONFIG_UPDATE_INTERVAL_MINUTES

int

0

AWS SDK client configurations

Type

Default

quarkus.ssm.endpoint-override

quarkus.ssm."client-name".endpoint-override

The endpoint URI with which the SDK should communicate.

If not specified, an appropriate endpoint to be used for the given service and region.

Environment variable: QUARKUS_SSM_ENDPOINT_OVERRIDE

URI

quarkus.ssm.api-call-timeout

quarkus.ssm."client-name".api-call-timeout

The amount of time to allow the client to complete the execution of an API call.

This timeout covers the entire client execution except for marshalling. This includes request handler execution, all HTTP requests including retries, unmarshalling, etc.

This value should always be positive, if present.

Environment variable: QUARKUS_SSM_API_CALL_TIMEOUT

Duration 

quarkus.ssm.api-call-attempt-timeout

quarkus.ssm."client-name".api-call-attempt-timeout

The amount of time to wait for the HTTP request to complete before giving up and timing out.

This value should always be positive, if present.

Environment variable: QUARKUS_SSM_API_CALL_ATTEMPT_TIMEOUT

Duration 

quarkus.ssm.advanced.use-quarkus-scheduled-executor-service

quarkus.ssm."client-name".advanced.use-quarkus-scheduled-executor-service

Whether the Quarkus thread pool should be used for scheduling tasks such as async retry attempts and timeout task.

When disabled, the default sdk behavior is to create a dedicated thread pool for each client, resulting in competition for CPU resources among these thread pools.

Environment variable: QUARKUS_SSM_ADVANCED_USE_QUARKUS_SCHEDULED_EXECUTOR_SERVICE

boolean

true

AWS services configurations

Type

Default

quarkus.ssm.aws.region

quarkus.ssm."client-name".aws.region

An Amazon Web Services region that hosts the given service.

It overrides region provider chain with static value of region with which the service client should communicate.

If not set, region is retrieved via the default providers chain in the following order:

  • aws.region system property

  • region property from the profile file

  • Instance profile file

See software.amazon.awssdk.regions.Region for available regions.

Environment variable: QUARKUS_SSM_AWS_REGION

Region

quarkus.ssm.aws.credentials.type

quarkus.ssm."client-name".aws.credentials.type

Configure the credentials provider that should be used to authenticate with AWS.

Available values:

  • default - the provider will attempt to identify the credentials automatically using the following checks:

    • Java System Properties - aws.accessKeyId and aws.secretAccessKey

    • Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY

    • Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI

    • Credentials delivered through the Amazon EC2 container service if AWS_CONTAINER_CREDENTIALS_RELATIVE_URI environment variable is set and security manager has permission to access the variable.

    • Instance profile credentials delivered through the Amazon EC2 metadata service

  • static - the provider that uses the access key and secret access key specified in the static-provider section of the config.

  • system-property - it loads credentials from the aws.accessKeyId, aws.secretAccessKey and aws.sessionToken system properties.

  • env-variable - it loads credentials from the AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY and AWS_SESSION_TOKEN environment variables.

  • profile - credentials are based on AWS configuration profiles. This loads credentials from a profile file, allowing you to share multiple sets of AWS security credentials between different tools like the AWS SDK for Java and the AWS CLI.

  • container - It loads credentials from a local metadata service. Containers currently supported by the AWS SDK are Amazon Elastic Container Service (ECS) and AWS Greengrass

  • instance-profile - It loads credentials from the Amazon EC2 Instance Metadata Service.

  • process - Credentials are loaded from an external process. This is used to support the credential_process setting in the profile credentials file. See Sourcing Credentials From External Processes for more information.

  • custom - Credentials are loaded from a registered bean of type AwsCredentialsProvider matching the specified name.

  • anonymous - It always returns anonymous AWS credentials. Anonymous AWS credentials result in un-authenticated requests and will fail unless the resource or API’s policy has been configured to specifically allow anonymous access.

Environment variable: QUARKUS_SSM_AWS_CREDENTIALS_TYPE

default, static, system-property, env-variable, profile, container, instance-profile, process, custom, anonymous

default

Default credentials provider configuration

Type

Default

quarkus.ssm.aws.credentials.default-provider.async-credential-update-enabled

quarkus.ssm."client-name".aws.credentials.default-provider.async-credential-update-enabled

Whether this provider should fetch credentials asynchronously in the background.

If this is true, threads are less likely to block, but additional resources are used to maintain the provider.

Environment variable: QUARKUS_SSM_AWS_CREDENTIALS_DEFAULT_PROVIDER_ASYNC_CREDENTIAL_UPDATE_ENABLED

boolean

false

quarkus.ssm.aws.credentials.default-provider.reuse-last-provider-enabled

quarkus.ssm."client-name".aws.credentials.default-provider.reuse-last-provider-enabled

Whether the provider should reuse the last successful credentials provider in the chain.

Reusing the last successful credentials provider will typically return credentials faster than searching through the chain.

Environment variable: QUARKUS_SSM_AWS_CREDENTIALS_DEFAULT_PROVIDER_REUSE_LAST_PROVIDER_ENABLED

boolean

true

Static credentials provider configuration

Type

Default

quarkus.ssm.aws.credentials.static-provider.access-key-id

quarkus.ssm."client-name".aws.credentials.static-provider.access-key-id

AWS Access key id

Environment variable: QUARKUS_SSM_AWS_CREDENTIALS_STATIC_PROVIDER_ACCESS_KEY_ID

string

quarkus.ssm.aws.credentials.static-provider.secret-access-key

quarkus.ssm."client-name".aws.credentials.static-provider.secret-access-key

AWS Secret access key

Environment variable: QUARKUS_SSM_AWS_CREDENTIALS_STATIC_PROVIDER_SECRET_ACCESS_KEY

string

quarkus.ssm.aws.credentials.static-provider.session-token

quarkus.ssm."client-name".aws.credentials.static-provider.session-token

AWS Session token

Environment variable: QUARKUS_SSM_AWS_CREDENTIALS_STATIC_PROVIDER_SESSION_TOKEN

string

AWS Profile credentials provider configuration

Type

Default

quarkus.ssm.aws.credentials.profile-provider.profile-name

quarkus.ssm."client-name".aws.credentials.profile-provider.profile-name

The name of the profile that should be used by this credentials provider.

If not specified, the value in AWS_PROFILE environment variable or aws.profile system property is used and defaults to default name.

Environment variable: QUARKUS_SSM_AWS_CREDENTIALS_PROFILE_PROVIDER_PROFILE_NAME

string

Process credentials provider configuration

Type

Default

quarkus.ssm.aws.credentials.process-provider.async-credential-update-enabled

quarkus.ssm."client-name".aws.credentials.process-provider.async-credential-update-enabled

Whether the provider should fetch credentials asynchronously in the background.

If this is true, threads are less likely to block when credentials are loaded, but additional resources are used to maintain the provider.

Environment variable: QUARKUS_SSM_AWS_CREDENTIALS_PROCESS_PROVIDER_ASYNC_CREDENTIAL_UPDATE_ENABLED

boolean

false

quarkus.ssm.aws.credentials.process-provider.credential-refresh-threshold

quarkus.ssm."client-name".aws.credentials.process-provider.credential-refresh-threshold

The amount of time between when the credentials expire and when the credentials should start to be refreshed.

This allows the credentials to be refreshed *before* they are reported to expire.

Environment variable: QUARKUS_SSM_AWS_CREDENTIALS_PROCESS_PROVIDER_CREDENTIAL_REFRESH_THRESHOLD

Duration 

15S

quarkus.ssm.aws.credentials.process-provider.process-output-limit

quarkus.ssm."client-name".aws.credentials.process-provider.process-output-limit

The maximum size of the output that can be returned by the external process before an exception is raised.

Environment variable: QUARKUS_SSM_AWS_CREDENTIALS_PROCESS_PROVIDER_PROCESS_OUTPUT_LIMIT

MemorySize 

1M

quarkus.ssm.aws.credentials.process-provider.command

quarkus.ssm."client-name".aws.credentials.process-provider.command

The command that should be executed to retrieve credentials. Command and parameters are seperated list entries.

Environment variable: QUARKUS_SSM_AWS_CREDENTIALS_PROCESS_PROVIDER_COMMAND

list of string

Custom credentials provider configuration

Type

Default

quarkus.ssm.aws.credentials.custom-provider.name

quarkus.ssm."client-name".aws.credentials.custom-provider.name

The name of custom AwsCredentialsProvider bean.

Environment variable: QUARKUS_SSM_AWS_CREDENTIALS_CUSTOM_PROVIDER_NAME

string

Sync HTTP transport configurations

Type

Default

quarkus.ssm.sync-client.connection-timeout

The maximum amount of time to establish a connection before timing out.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_CONNECTION_TIMEOUT

Duration 

2S

quarkus.ssm.sync-client.socket-timeout

The amount of time to wait for data to be transferred over an established, open connection before the connection is timed out.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_SOCKET_TIMEOUT

Duration 

30S

quarkus.ssm.sync-client.tls-key-managers-provider.type

TLS key managers provider type.

Available providers:

  • none - Use this provider if you don’t want the client to present any certificates to the remote TLS host.

  • system-property - Provider checks the standard javax.net.ssl.keyStore, javax.net.ssl.keyStorePassword, and javax.net.ssl.keyStoreType properties defined by the JSSE.

  • file-store - Provider that loads the key store from a file.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_TLS_KEY_MANAGERS_PROVIDER_TYPE

none, system-property, file-store

system-property

quarkus.ssm.sync-client.tls-key-managers-provider.file-store.path

Path to the key store.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_TLS_KEY_MANAGERS_PROVIDER_FILE_STORE_PATH

path

quarkus.ssm.sync-client.tls-key-managers-provider.file-store.type

Key store type.

See the KeyStore section in the https://docs.oracle.com/javase/8/docs/technotes/guides/security/StandardNames.html#KeyStore[Java Cryptography Architecture Standard Algorithm Name Documentation] for information about standard keystore types.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_TLS_KEY_MANAGERS_PROVIDER_FILE_STORE_TYPE

string

quarkus.ssm.sync-client.tls-key-managers-provider.file-store.password

Key store password

Environment variable: QUARKUS_SSM_SYNC_CLIENT_TLS_KEY_MANAGERS_PROVIDER_FILE_STORE_PASSWORD

string

quarkus.ssm.sync-client.tls-trust-managers-provider.type

TLS trust managers provider type.

Available providers:

  • trust-all - Use this provider to disable the validation of servers certificates and therefore trust all server certificates.

  • system-property - Provider checks the standard javax.net.ssl.keyStore, javax.net.ssl.keyStorePassword, and javax.net.ssl.keyStoreType properties defined by the JSSE.

  • file-store - Provider that loads the key store from a file.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_TLS_TRUST_MANAGERS_PROVIDER_TYPE

trust-all, system-property, file-store

system-property

quarkus.ssm.sync-client.tls-trust-managers-provider.file-store.path

Path to the key store.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_TLS_TRUST_MANAGERS_PROVIDER_FILE_STORE_PATH

path

quarkus.ssm.sync-client.tls-trust-managers-provider.file-store.type

Key store type.

See the KeyStore section in the https://docs.oracle.com/javase/8/docs/technotes/guides/security/StandardNames.html#KeyStore[Java Cryptography Architecture Standard Algorithm Name Documentation] for information about standard keystore types.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_TLS_TRUST_MANAGERS_PROVIDER_FILE_STORE_TYPE

string

quarkus.ssm.sync-client.tls-trust-managers-provider.file-store.password

Key store password

Environment variable: QUARKUS_SSM_SYNC_CLIENT_TLS_TRUST_MANAGERS_PROVIDER_FILE_STORE_PASSWORD

string

Apache HTTP client specific configurations

Type

Default

quarkus.ssm.sync-client.apache.connection-acquisition-timeout

The amount of time to wait when acquiring a connection from the pool before giving up and timing out.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_APACHE_CONNECTION_ACQUISITION_TIMEOUT

Duration 

10S

quarkus.ssm.sync-client.apache.connection-max-idle-time

The maximum amount of time that a connection should be allowed to remain open while idle.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_APACHE_CONNECTION_MAX_IDLE_TIME

Duration 

60S

quarkus.ssm.sync-client.apache.connection-time-to-live

The maximum amount of time that a connection should be allowed to remain open, regardless of usage frequency.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_APACHE_CONNECTION_TIME_TO_LIVE

Duration 

quarkus.ssm.sync-client.apache.max-connections

The maximum number of connections allowed in the connection pool.

Each built HTTP client has its own private connection pool.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_APACHE_MAX_CONNECTIONS

int

50

quarkus.ssm.sync-client.apache.expect-continue-enabled

Whether the client should send an HTTP expect-continue handshake before each request.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_APACHE_EXPECT_CONTINUE_ENABLED

boolean

true

quarkus.ssm.sync-client.apache.use-idle-connection-reaper

Whether the idle connections in the connection pool should be closed asynchronously.

When enabled, connections left idling for longer than quarkus..sync-client.connection-max-idle-time will be closed. This will not close connections currently in use.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_APACHE_USE_IDLE_CONNECTION_REAPER

boolean

true

quarkus.ssm.sync-client.apache.tcp-keep-alive

Configure whether to enable or disable TCP KeepAlive.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_APACHE_TCP_KEEP_ALIVE

boolean

false

quarkus.ssm.sync-client.apache.proxy.enabled

Enable HTTP proxy

Environment variable: QUARKUS_SSM_SYNC_CLIENT_APACHE_PROXY_ENABLED

boolean

false

quarkus.ssm.sync-client.apache.proxy.endpoint

The endpoint of the proxy server that the SDK should connect through.

Currently, the endpoint is limited to a host and port. Any other URI components will result in an exception being raised.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_APACHE_PROXY_ENDPOINT

URI

quarkus.ssm.sync-client.apache.proxy.username

The username to use when connecting through a proxy.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_APACHE_PROXY_USERNAME

string

quarkus.ssm.sync-client.apache.proxy.password

The password to use when connecting through a proxy.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_APACHE_PROXY_PASSWORD

string

quarkus.ssm.sync-client.apache.proxy.ntlm-domain

For NTLM proxies - the Windows domain name to use when authenticating with the proxy.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_APACHE_PROXY_NTLM_DOMAIN

string

quarkus.ssm.sync-client.apache.proxy.ntlm-workstation

For NTLM proxies - the Windows workstation name to use when authenticating with the proxy.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_APACHE_PROXY_NTLM_WORKSTATION

string

quarkus.ssm.sync-client.apache.proxy.preemptive-basic-authentication-enabled

Whether to attempt to authenticate preemptively against the proxy server using basic authentication.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_APACHE_PROXY_PREEMPTIVE_BASIC_AUTHENTICATION_ENABLED

boolean

quarkus.ssm.sync-client.apache.proxy.non-proxy-hosts

The hosts that the client is allowed to access without going through the proxy.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_APACHE_PROXY_NON_PROXY_HOSTS

list of string

AWS CRT-based HTTP client specific configurations

Type

Default

quarkus.ssm.sync-client.crt.connection-max-idle-time

The maximum amount of time that a connection should be allowed to remain open while idle.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_CRT_CONNECTION_MAX_IDLE_TIME

Duration 

60S

quarkus.ssm.sync-client.crt.max-concurrency

The maximum number of allowed concurrent requests.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_CRT_MAX_CONCURRENCY

int

50

quarkus.ssm.sync-client.crt.connection-acquisition-timeout

The amount of time to wait when initially establishing a connection before giving up and timing out.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_CRT_CONNECTION_ACQUISITION_TIMEOUT

Duration 

10S

quarkus.ssm.sync-client.crt.proxy.enabled

Enable HTTP proxy

Environment variable: QUARKUS_SSM_SYNC_CLIENT_CRT_PROXY_ENABLED

boolean

false

quarkus.ssm.sync-client.crt.proxy.endpoint

The endpoint of the proxy server that the SDK should connect through.

Currently, the endpoint is limited to a host and port. Any other URI components will result in an exception being raised.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_CRT_PROXY_ENDPOINT

URI

quarkus.ssm.sync-client.crt.proxy.username

The username to use when connecting through a proxy.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_CRT_PROXY_USERNAME

string

quarkus.ssm.sync-client.crt.proxy.password

The password to use when connecting through a proxy.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_CRT_PROXY_PASSWORD

string

quarkus.ssm.sync-client.crt.tcp-keep-alive.enabled

Configure whether to enable or disable TCP KeepAlive.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_CRT_TCP_KEEP_ALIVE_ENABLED

boolean

false

quarkus.ssm.sync-client.crt.tcp-keep-alive.keep-alive-interval

Time between TCP keepalive packets being sent to the peer.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_CRT_TCP_KEEP_ALIVE_KEEP_ALIVE_INTERVAL

Duration 

75MS

quarkus.ssm.sync-client.crt.tcp-keep-alive.keep-alive-timeout

Time to wait for a keepalive response before considering the connection timed out.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_CRT_TCP_KEEP_ALIVE_KEEP_ALIVE_TIMEOUT

Duration 

7200MS

quarkus.ssm.sync-client.crt.tcp-keep-alive.keep-alive-probes

Number of keepalive probes allowed to fail before the connection is considered lost.

Environment variable: QUARKUS_SSM_SYNC_CLIENT_CRT_TCP_KEEP_ALIVE_KEEP_ALIVE_PROBES

int

9

Async HTTP transport configurations

Type

Default

quarkus.ssm.async-client.max-concurrency

The maximum number of allowed concurrent requests.

For HTTP/1.1 this is the same as max connections. For HTTP/2 the number of connections that will be used depends on the max streams allowed per connection.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_MAX_CONCURRENCY

int

50

quarkus.ssm.async-client.max-pending-connection-acquires

The maximum number of pending acquires allowed.

Once this exceeds, acquire tries will be failed.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_MAX_PENDING_CONNECTION_ACQUIRES

int

10000

quarkus.ssm.async-client.read-timeout

The amount of time to wait for a read on a socket before an exception is thrown.

Specify 0 to disable.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_READ_TIMEOUT

Duration 

30S

quarkus.ssm.async-client.write-timeout

The amount of time to wait for a write on a socket before an exception is thrown.

Specify 0 to disable.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_WRITE_TIMEOUT

Duration 

30S

quarkus.ssm.async-client.connection-timeout

The amount of time to wait when initially establishing a connection before giving up and timing out.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_CONNECTION_TIMEOUT

Duration 

10S

quarkus.ssm.async-client.connection-acquisition-timeout

The amount of time to wait when acquiring a connection from the pool before giving up and timing out.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_CONNECTION_ACQUISITION_TIMEOUT

Duration 

2S

quarkus.ssm.async-client.connection-time-to-live

The maximum amount of time that a connection should be allowed to remain open, regardless of usage frequency.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_CONNECTION_TIME_TO_LIVE

Duration 

quarkus.ssm.async-client.connection-max-idle-time

The maximum amount of time that a connection should be allowed to remain open while idle.

Currently has no effect if quarkus..async-client.use-idle-connection-reaper is false.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_CONNECTION_MAX_IDLE_TIME

Duration 

5S

quarkus.ssm.async-client.use-idle-connection-reaper

Whether the idle connections in the connection pool should be closed.

When enabled, connections left idling for longer than quarkus..async-client.connection-max-idle-time will be closed. This will not close connections currently in use.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_USE_IDLE_CONNECTION_REAPER

boolean

true

quarkus.ssm.async-client.tcp-keep-alive

Configure whether to enable or disable TCP KeepAlive. Applicable only to netty-nio client.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_TCP_KEEP_ALIVE

boolean

false

AWS CRT-based HTTP client specific configurations

Type

Default

quarkus.ssm.async-client.crt.connection-max-idle-time

The maximum amount of time that a connection should be allowed to remain open while idle.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_CRT_CONNECTION_MAX_IDLE_TIME

Duration 

60S

quarkus.ssm.async-client.crt.max-concurrency

The maximum number of allowed concurrent requests.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_CRT_MAX_CONCURRENCY

int

50

quarkus.ssm.async-client.crt.connection-acquisition-timeout

The amount of time to wait when initially establishing a connection before giving up and timing out.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_CRT_CONNECTION_ACQUISITION_TIMEOUT

Duration 

10S

quarkus.ssm.async-client.crt.proxy.enabled

Enable HTTP proxy

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_CRT_PROXY_ENABLED

boolean

false

quarkus.ssm.async-client.crt.proxy.endpoint

The endpoint of the proxy server that the SDK should connect through.

Currently, the endpoint is limited to a host and port. Any other URI components will result in an exception being raised.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_CRT_PROXY_ENDPOINT

URI

quarkus.ssm.async-client.crt.proxy.username

The username to use when connecting through a proxy.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_CRT_PROXY_USERNAME

string

quarkus.ssm.async-client.crt.proxy.password

The password to use when connecting through a proxy.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_CRT_PROXY_PASSWORD

string

quarkus.ssm.async-client.crt.tcp-keep-alive.enabled

Configure whether to enable or disable TCP KeepAlive.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_CRT_TCP_KEEP_ALIVE_ENABLED

boolean

false

quarkus.ssm.async-client.crt.tcp-keep-alive.keep-alive-interval

Time between TCP keepalive packets being sent to the peer.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_CRT_TCP_KEEP_ALIVE_KEEP_ALIVE_INTERVAL

Duration 

75MS

quarkus.ssm.async-client.crt.tcp-keep-alive.keep-alive-timeout

Time to wait for a keepalive response before considering the connection timed out.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_CRT_TCP_KEEP_ALIVE_KEEP_ALIVE_TIMEOUT

Duration 

7200MS

quarkus.ssm.async-client.crt.tcp-keep-alive.keep-alive-probes

Number of keepalive probes allowed to fail before the connection is considered lost.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_CRT_TCP_KEEP_ALIVE_KEEP_ALIVE_PROBES

int

9

quarkus.ssm.async-client.protocol

The HTTP protocol to use.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_PROTOCOL

http1-1, http2

http1-1

quarkus.ssm.async-client.ssl-provider

The SSL Provider to be used in the Netty client.

Default is OPENSSL if available, JDK otherwise.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_SSL_PROVIDER

jdk, openssl, openssl-refcnt

quarkus.ssm.async-client.http2.max-streams

The maximum number of concurrent streams for an HTTP/2 connection.

This setting is only respected when the HTTP/2 protocol is used.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_HTTP2_MAX_STREAMS

long

4294967295

quarkus.ssm.async-client.http2.initial-window-size

The initial window size for an HTTP/2 stream.

This setting is only respected when the HTTP/2 protocol is used.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_HTTP2_INITIAL_WINDOW_SIZE

int

1048576

quarkus.ssm.async-client.http2.health-check-ping-period

Sets the period that the Netty client will send PING frames to the remote endpoint to check the health of the connection. To disable this feature, set a duration of 0.

This setting is only respected when the HTTP/2 protocol is used.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_HTTP2_HEALTH_CHECK_PING_PERIOD

Duration 

5

quarkus.ssm.async-client.proxy.enabled

Enable HTTP proxy.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_PROXY_ENABLED

boolean

false

quarkus.ssm.async-client.proxy.endpoint

The endpoint of the proxy server that the SDK should connect through.

Currently, the endpoint is limited to a host and port. Any other URI components will result in an exception being raised.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_PROXY_ENDPOINT

URI

quarkus.ssm.async-client.proxy.non-proxy-hosts

The hosts that the client is allowed to access without going through the proxy.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_PROXY_NON_PROXY_HOSTS

list of string

quarkus.ssm.async-client.tls-key-managers-provider.type

TLS key managers provider type.

Available providers:

  • none - Use this provider if you don’t want the client to present any certificates to the remote TLS host.

  • system-property - Provider checks the standard javax.net.ssl.keyStore, javax.net.ssl.keyStorePassword, and javax.net.ssl.keyStoreType properties defined by the JSSE.

  • file-store - Provider that loads the key store from a file.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_TLS_KEY_MANAGERS_PROVIDER_TYPE

none, system-property, file-store

system-property

quarkus.ssm.async-client.tls-key-managers-provider.file-store.path

Path to the key store.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_TLS_KEY_MANAGERS_PROVIDER_FILE_STORE_PATH

path

quarkus.ssm.async-client.tls-key-managers-provider.file-store.type

Key store type.

See the KeyStore section in the https://docs.oracle.com/javase/8/docs/technotes/guides/security/StandardNames.html#KeyStore[Java Cryptography Architecture Standard Algorithm Name Documentation] for information about standard keystore types.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_TLS_KEY_MANAGERS_PROVIDER_FILE_STORE_TYPE

string

quarkus.ssm.async-client.tls-key-managers-provider.file-store.password

Key store password

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_TLS_KEY_MANAGERS_PROVIDER_FILE_STORE_PASSWORD

string

quarkus.ssm.async-client.tls-trust-managers-provider.type

TLS trust managers provider type.

Available providers:

  • trust-all - Use this provider to disable the validation of servers certificates and therefore trust all server certificates.

  • system-property - Provider checks the standard javax.net.ssl.keyStore, javax.net.ssl.keyStorePassword, and javax.net.ssl.keyStoreType properties defined by the JSSE.

  • file-store - Provider that loads the key store from a file.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_TLS_TRUST_MANAGERS_PROVIDER_TYPE

trust-all, system-property, file-store

system-property

quarkus.ssm.async-client.tls-trust-managers-provider.file-store.path

Path to the key store.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_TLS_TRUST_MANAGERS_PROVIDER_FILE_STORE_PATH

path

quarkus.ssm.async-client.tls-trust-managers-provider.file-store.type

Key store type.

See the KeyStore section in the https://docs.oracle.com/javase/8/docs/technotes/guides/security/StandardNames.html#KeyStore[Java Cryptography Architecture Standard Algorithm Name Documentation] for information about standard keystore types.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_TLS_TRUST_MANAGERS_PROVIDER_FILE_STORE_TYPE

string

quarkus.ssm.async-client.tls-trust-managers-provider.file-store.password

Key store password

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_TLS_TRUST_MANAGERS_PROVIDER_FILE_STORE_PASSWORD

string

quarkus.ssm.async-client.event-loop.override

Enable the custom configuration of the Netty event loop group. This option is only available when using Quarkus 3.x. With Quarkus 4, the AWS SDK always uses its own event loop.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_EVENT_LOOP_OVERRIDE

boolean

quarkus.ssm.async-client.event-loop.number-of-threads

Number of threads to use for the event loop group.

If not set, the default Netty thread count is used (which is double the number of available processors unless the io.netty.eventLoopThreads system property is set).

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_EVENT_LOOP_NUMBER_OF_THREADS

int

quarkus.ssm.async-client.event-loop.thread-name-prefix

The thread name prefix for threads created by this thread factory used by event loop group.

The prefix will be appended with a number unique to the thread factory and a number unique to the thread.

If not specified it defaults to aws-java-sdk-NettyEventLoop

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_EVENT_LOOP_THREAD_NAME_PREFIX

string

quarkus.ssm.async-client.advanced.use-future-completion-thread-pool

Whether the default thread pool should be used to complete the futures returned from the HTTP client request.

When disabled, HTTP attempt completion is not offloaded to the Quarkus worker pool. Vert.x context propagation, when applicable, independently dispatches the final result to a Vert.x event loop.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_ADVANCED_USE_FUTURE_COMPLETION_THREAD_POOL

boolean

true

quarkus.ssm.async-client.advanced.vertx-context-propagation

Whether the final results of async calls made from a Vert.x event loop are delivered on the caller’s context.

When enabled, a call made from a Vert.x event loop is completed on the caller’s context. Calls made from workers (including @Blocking endpoints), virtual threads or other threads keep the SDK’s completion behavior, as configured by use-future-completion-thread-pool.

When disabled, the SDK completion behavior is kept, including the use-future-completion-thread-pool setting.

This only applies when the Quarkus Vert.x extension is present.

Environment variable: QUARKUS_SSM_ASYNC_CLIENT_ADVANCED_VERTX_CONTEXT_PROPAGATION

boolean

true
About the Duration format

To write duration values, use the standard java.time.Duration format. See the Duration#parse() Java API documentation for more information.

You can also use a simplified format, starting with a number:

  • If the value is only a number, it represents time in seconds.

  • If the value is a number followed by ms, it represents time in milliseconds.

In other cases, the simplified format is translated to the java.time.Duration format for parsing:

  • If the value is a number followed by h, m, or s, it is prefixed with PT.

  • If the value is a number followed by d, it is prefixed with P.
About the MemorySize format

A size configuration option recognizes strings in this format (shown as a regular expression): [0-9]+[KkMmGgTtPpEeZzYy]?.

If no suffix is given, assume bytes.