DynamoDB is a scalable AWS managed NoSQL database. It supports both key-value and document data models, that enables to have a flexible schema for your data. This extension provides functionality that allows the client to communicate with the service when running in Quarkus. You can find more information about DynamoDB at the Amazon DynamoDB website.
The DynamoDB 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). Keep in mind it’s actively developed and does not support yet all the features available in SDK 1.x such as Document APIs or Object Mappers |
The Quarkus extension supports two programming models:
-
Blocking access using the Apache HTTP Client
-
Asynchronous programming based on JDK’s
CompletableFuture
objects and the Netty HTTP client.
In this guide, we see how you can get your REST services to use the DynamoDB locally and on AWS.
Prerequisites
To complete this guide, you need:
-
JDK 1.8+ installed with
JAVA_HOME
configured appropriately -
an IDE
-
Apache Maven 3.5.3+
-
An AWS Account to access the DynamoDB service
-
Optionally, Docker for your system to run DynamoDB locally for testing purposes
Setup DynamoDB locally
The easiest way to start working with DynamoDB is to run a local instance as a container.
docker run --publish 8000:8000 amazon/dynamodb-local:1.11.477 -jar DynamoDBLocal.jar -inMemory -sharedDb
This starts a DynamoDB instance that is accessible on port 8000
.
You can check it’s running by accessing the web shell on http://localhost:8000/shell
.
Have a look at the Setting Up DynamoDB Local guide for other options to run DynamoDB.
Open http://localhost:8000/shell
in your browser.
Copy and paste the following code to the shell and run it:
var params = {
TableName: 'QuarkusFruits',
KeySchema: [{ AttributeName: 'fruitName', KeyType: 'HASH' }],
AttributeDefinitions: [{ AttributeName: 'fruitName', AttributeType: 'S', }],
ProvisionedThroughput: { ReadCapacityUnits: 1, WriteCapacityUnits: 1, }
};
dynamodb.createTable(params, function(err, data) {
if (err) ppJson(err);
else ppJson(data);
});
Set up Dynamodb on AWS
Before you can use the AWS SDKs with DynamoDB, you must get an AWS access key ID and secret access key. For more information, see Setting Up DynamoDB (Web Service).
We recommend to use the AWS CLI to provision the table:
aws dynamodb create-table --table-name QuarkusFruits \
--attribute-definitions AttributeName=fruitName,AttributeType=S \
--key-schema AttributeName=fruitName,KeyType=HASH \
--provisioned-throughput ReadCapacityUnits=1,WriteCapacityUnits=1
Solution
The application built here allows to manage elements (fruits) stored in Amazon DynamoDB.
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 dynamodb-client
directory.
Creating the Maven project
First, we need a new project. Create a new project with the following command:
mvn io.quarkus:quarkus-maven-plugin:0.23.2:create \
-DprojectGroupId=org.acme \
-DprojectArtifactId=dynamodb-client \
-DclassName="org.acme.dynamodb.FruitResource" \
-Dpath="/fruits" \
-Dextensions="resteasy-jsonb,dynamodb"
This command generates a Maven structure importing the RESTEasy/JAX-RS and DynamoDB Client extensions.
After this, the amazon-dynamodb
extension has been added to your pom.xml
.
Creating JSON REST service
In this example, we will create an application to manage a list of fruits. The example application will demonstrate the two programming models supported by the extension.
First, let’s create the Fruit
bean as follows:
package org.acme.dynamodb;
import java.util.Map;
import java.util.Objects;
import io.quarkus.runtime.annotations.RegisterForReflection;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
@RegisterForReflection
public class Fruit {
private String name;
private String description;
public Fruit() {
}
public static Fruit from(Map<String, AttributeValue> item) {
Fruit fruit = new Fruit();
if (item != null && !item.isEmpty()) {
fruit.setName(item.get(AbstractService.FRUIT_NAME_COL).s());
fruit.setDescription(item.get(AbstractService.FRUIT_DESC_COL).s());
}
return fruit;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Fruit)) {
return false;
}
Fruit other = (Fruit) obj;
return Objects.equals(other.name, this.name);
}
@Override
public int hashCode() {
return Objects.hash(this.name);
}
}
Nothing fancy. One important thing to note is that having a default constructor is required by the JSON serialization layer. The static from
method creates a bean based on the Map
object provided by the DynamoDB client response.
Now create a org.acme.dynamodb.AbstractService
that will consist of helper methods that prepare DynamoDB request objects for reading and adding items to the table.
package org.acme.dynamodb;
import java.util.HashMap;
import java.util.Map;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.GetItemRequest;
import software.amazon.awssdk.services.dynamodb.model.PutItemRequest;
import software.amazon.awssdk.services.dynamodb.model.ScanRequest;
public abstract class AbstractService {
public final static String FRUIT_NAME_COL = "fruitName";
public final static String FRUIT_DESC_COL = "fruitDescription";
public String getTableName() {
return "QuarkusFruits";
}
protected ScanRequest scanRequest() {
return ScanRequest.builder().tableName(getTableName())
.attributesToGet(FRUIT_NAME_COL, FRUIT_DESC_COL).build();
}
protected PutItemRequest putRequest(Fruit fruit) {
Map<String, AttributeValue> item = new HashMap<>();
item.put(FRUIT_NAME_COL, AttributeValue.builder().s(fruit.getName()).build());
item.put(FRUIT_DESC_COL, AttributeValue.builder().s(fruit.getDescription()).build());
return PutItemRequest.builder()
.tableName(getTableName())
.item(item)
.build();
}
protected GetItemRequest getRequest(String name) {
Map<String, AttributeValue> key = new HashMap<>();
key.put(FRUIT_NAME_COL, AttributeValue.builder().s(name).build());
return GetItemRequest.builder()
.tableName(getTableName())
.key(key)
.attributesToGet(FRUIT_NAME_COL, FRUIT_DESC_COL)
.build();
}
}
Then, create a org.acme.dynamodb.FruitSyncService
that will be the business layer of our application and stores/loads the fruits from DynamoDB using the synchronous client.
package org.acme.dynamodb;
import java.util.List;
import java.util.stream.Collectors;
import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
@ApplicationScoped
public class FruitSyncService extends AbstractService {
@Inject
DynamoDbClient dynamoDB;
public List<Fruit> findAll() {
return dynamoDB.scanPaginator(scanRequest()).items().stream()
.map(Fruit::from)
.collect(Collectors.toList());
}
public List<Fruit> add(Fruit fruit) {
dynamoDB.putItem(putRequest(fruit));
return findAll();
}
public Fruit get(String name) {
return Fruit.from(dynamoDB.getItem(getRequest(name)).item());
}
}
Now, edit the org.acme.dynamodb.FruitResource
class as follows:
package org.acme.dynamodb;
import java.util.List;
import javax.inject.Inject;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
@Path("/fruits")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class FruitResource {
@Inject
FruitSyncService service;
@GET
public List<Fruit> getAll() {
return service.findAll();
}
@GET
@Path("{name}")
public Fruit getSingle(@PathParam("name") String name) {
return service.get(name);
}
@POST
public List<Fruit> add(Fruit fruit) {
service.add(fruit);
return getAll();
}
}
The implementation is pretty straightforward and you just need to define your endpoints using the JAX-RS annotations and use the FruitSyncService
to list/add new fruits.
Configuring DynamoDB clients
Both DynamoDB clients (sync and async) are configurable via the application.properties
file that can be provided in the src/main/resources
directory.
If you’re going to use a local DynamoDB instance, configure it as follows:
quarkus.dynamodb.endpoint-override=http://localhost:8000
quarkus.dynamodb.aws.region=eu-central-1
quarkus.dynamodb.aws.credentials.type=STATIC
quarkus.dynamodb.aws.credentials.static-provider.access-key-id=test-key
quarkus.dynamodb.aws.credentials.static-provider.secret-access-key=test-secret
-
quarkus.dynamodb.aws.region
- It’s required by the client, but since you’re using a local DynamoDB instance you can pick any valid AWS region. -
quarkus.dynamodb.aws.credentials.type
- SetSTATIC
credentials provider with any values foraccess-key-id
andsecret-access-key
-
quarkus.dynamodb.endpoint-override
- Override the DynamoDB client to use a local instance instead of an AWS service
If you want to work with an AWS account, you’d need to set it with:
quarkus.dynamodb.aws.region=<YOUR_REGION>
quarkus.dynamodb.aws.credentials.type=DEFAULT
-
quarkus.dynamodb.aws.region
you should set it to the region where you provisioned the DynamoDB table, -
quarkus.dynamodb.aws.credentials.type
- use theDEFAULT
credentials provider chain that looks for credentials in this order: -
Java System Properties -
aws.accessKeyId
andaws.secretKey
-
Environment Variables -
AWS_ACCESS_KEY_ID
andAWS_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 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
-
Next steps
Packaging
Packaging your application is as simple as ./mvnw clean package
.
It can be run with java -jar target/dynamodb-client-1.0-SNAPSHOT-runner.jar
.
With GraalVM installed, you can also create a native executable binary: ./mvnw clean package -Dnative
.
Depending on your system, that will take some time.
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.dynamodb.FruitAsyncService
that will be similar to our FruitSyncService
but using an asynchronous programming model.
package org.acme.dynamodb;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
@ApplicationScoped
public class FruitAsyncService extends AbstractService {
@Inject
DynamoDbAsyncClient dynamoDB;
public CompletableFuture<List<Fruit>> findAll() {
return dynamoDB.scan(scanRequest())
.thenApply(res -> res.items().stream().map(Fruit::from).collect(Collectors.toList()));
}
public CompletableFuture<List<Fruit>> add(Fruit fruit) {
return dynamoDB.putItem(putRequest(fruit)).thenCompose(ret -> findAll());
}
public CompletableFuture<Fruit> get(String name) {
return dynamoDB.getItem(getRequest(name)).thenApply(resp -> Fruit.from(resp.item()));
}
}
And an asynchronous REST resource:
package org.acme.dynamodb;
import java.util.List;
import java.util.concurrent.CompletionStage;
import javax.inject.Inject;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
@Path("/async-fruits")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class FruitAsyncResource {
@Inject
FruitAsyncService service;
@GET
public CompletionStage<List<Fruit>> getAll() {
return service.findAll();
}
@GET
@Path("{name}")
public CompletionStage<Fruit> getSingle(@PathParam("name") String name) {
return service.get(name);
}
@POST
public CompletionStage<List<Fruit>> add(Fruit fruit) {
service.add(fruit);
return getAll();
}
}
Configuration Reference
Summary
Configuration property fixed at build time - ️ Configuration property overridable at runtime
Configuration property | Type | Default | Lifecycle |
---|---|---|---|
quarkus.dynamodb.enable-endpoint-discovery Enable DynamoDB service endpoint discovery. |
boolean |
|
|
quarkus.dynamodb.endpoint-override The endpoint URI with which the SDK should communicate. |
|||
quarkus.dynamodb.api-call-timeout The amount of time to allow the client to complete the execution of an API call. |
|||
quarkus.dynamodb.api-call-attempt-timeout The amount of time to wait for the HTTP request to complete before giving up and timing out. |
|||
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. |
class name |
||
An Amazon Web Services region that hosts DynamoDB. |
Region |
||
quarkus.dynamodb.aws.credentials.type Configure the credentials provider that should be used to authenticate with AWS. |
|
|
|
quarkus.dynamodb.aws.credentials.default-provider.async-credential-update-enabled Whether this provider should fetch credentials asynchronously in the background. |
boolean |
|
|
quarkus.dynamodb.aws.credentials.default-provider.reuse-last-provider-enabled Whether the provider should reuse the last successful credentials provider in the chain. |
boolean |
|
|
quarkus.dynamodb.aws.credentials.static-provider.access-key-id AWS Access key id. |
string |
||
quarkus.dynamodb.aws.credentials.static-provider.secret-access-key AWS Secret access key. |
string |
||
quarkus.dynamodb.aws.credentials.profile-provider.profile-name The name of the profile that should be used by this credentials provider. |
string |
||
quarkus.dynamodb.aws.credentials.process-provider.async-credential-update-enabled Whether the provider should fetch credentials asynchronously in the background. |
boolean |
|
|
quarkus.dynamodb.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. |
|
||
quarkus.dynamodb.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. |
|
||
quarkus.dynamodb.aws.credentials.process-provider.command The command that should be executed to retrieve credentials. |
string |
||
quarkus.dynamodb.sync-client.connection-timeout The maximum amount of time to establish a connection before timing out. |
|
||
quarkus.dynamodb.sync-client.connection-acquisition-timeout The amount of time to wait when acquiring a connection from the pool before giving up and timing out. |
|
||
quarkus.dynamodb.sync-client.connection-max-idle-time The maximum amount of time that a connection should be allowed to remain open while idle. |
|
||
quarkus.dynamodb.sync-client.connection-time-to-live The maximum amount of time that a connection should be allowed to remain open, regardless of usage frequency. |
|||
quarkus.dynamodb.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. |
|
||
quarkus.dynamodb.sync-client.max-connections The maximum number of connections allowed in the connection pool. |
int |
|
|
quarkus.dynamodb.sync-client.expect-continue-enabled Whether the client should send an HTTP expect-continue handshake before each request. |
boolean |
|
|
quarkus.dynamodb.sync-client.use-idle-connection-reaper Whether the idle connections in the connection pool should be closed asynchronously. |
boolean |
|
|
quarkus.dynamodb.sync-client.proxy.enabled Enable HTTP proxy. |
boolean |
|
|
quarkus.dynamodb.sync-client.proxy.endpoint The endpoint of the proxy server that the SDK should connect through. |
|||
quarkus.dynamodb.sync-client.proxy.username The username to use when connecting through a proxy. |
string |
||
quarkus.dynamodb.sync-client.proxy.password The password to use when connecting through a proxy. |
string |
||
quarkus.dynamodb.sync-client.proxy.ntlm-domain For NTLM proxies - the Windows domain name to use when authenticating with the proxy. |
string |
||
quarkus.dynamodb.sync-client.proxy.ntlm-workstation For NTLM proxies - the Windows workstation name to use when authenticating with the proxy. |
string |
||
quarkus.dynamodb.sync-client.proxy.preemptive-basic-authentication-enabled Whether to attempt to authenticate preemptively against the proxy server using basic authentication. |
boolean |
||
quarkus.dynamodb.sync-client.proxy.non-proxy-hosts The hosts that the client is allowed to access without going through the proxy. |
string |
||
quarkus.dynamodb.sync-client.tls-managers-provider.type TLS managers provider type. |
|
|
|
quarkus.dynamodb.sync-client.tls-managers-provider.file-store.path Path to the key store. |
path |
||
quarkus.dynamodb.sync-client.tls-managers-provider.file-store.type Key store type. |
string |
||
quarkus.dynamodb.sync-client.tls-managers-provider.file-store.password Key store password. |
string |
||
quarkus.dynamodb.async-client.max-concurrency The maximum number of allowed concurrent requests. |
int |
|
|
quarkus.dynamodb.async-client.max-pending-connection-acquires The maximum number of pending acquires allowed. |
int |
|
|
quarkus.dynamodb.async-client.read-timeout The amount of time to wait for a read on a socket before an exception is thrown. |
|
||
quarkus.dynamodb.async-client.write-timeout The amount of time to wait for a write on a socket before an exception is thrown. |
|
||
quarkus.dynamodb.async-client.connection-timeout The amount of time to wait when initially establishing a connection before giving up and timing out. |
|
||
quarkus.dynamodb.async-client.connection-acquisition-timeout The amount of time to wait when acquiring a connection from the pool before giving up and timing out. |
|
||
quarkus.dynamodb.async-client.connection-time-to-live The maximum amount of time that a connection should be allowed to remain open, regardless of usage frequency. |
|||
quarkus.dynamodb.async-client.connection-max-idle-time The maximum amount of time that a connection should be allowed to remain open while idle. |
|
||
quarkus.dynamodb.async-client.use-idle-connection-reaper Whether the idle connections in the connection pool should be closed. |
boolean |
|
|
quarkus.dynamodb.async-client.protocol The HTTP protocol to use. |
|
|
|
quarkus.dynamodb.async-client.max-http2-streams The maximum number of concurrent streams for an HTTP/2 connection. |
int |
|
|
quarkus.dynamodb.async-client.ssl-provider The SSL Provider to be used in the Netty client. |
|
||
quarkus.dynamodb.async-client.proxy.enabled Enable HTTP proxy. |
boolean |
|
|
quarkus.dynamodb.async-client.proxy.endpoint The endpoint of the proxy server that the SDK should connect through. |
|||
quarkus.dynamodb.async-client.proxy.non-proxy-hosts The hosts that the client is allowed to access without going through the proxy. |
string |
||
quarkus.dynamodb.async-client.tls-managers-provider.type TLS managers provider type. |
|
|
|
quarkus.dynamodb.async-client.tls-managers-provider.file-store.path Path to the key store. |
path |
||
quarkus.dynamodb.async-client.tls-managers-provider.file-store.type Key store type. |
string |
||
quarkus.dynamodb.async-client.tls-managers-provider.file-store.password Key store password. |
string |
||
quarkus.dynamodb.async-client.event-loop.override Enable the custom configuration of the Netty event loop group. |
boolean |
|
|
quarkus.dynamodb.async-client.event-loop.number-of-threads Number of threads to use for the event loop group. |
int |
||
quarkus.dynamodb.async-client.event-loop.thread-name-prefix The thread name prefix for threads created by this thread factory used by event loop group. |
string |
Details
quarkus.dynamodb.enable-endpoint-discovery
-
Enable DynamoDB service endpoint discovery.
Type:
boolean
Defaults to:
false
quarkus.dynamodb.endpoint-override
-
The endpoint URI with which the SDK should communicate. If not specified, an appropriate endpoint to be used for DynamoDB service and region.
Type:
URI
quarkus.dynamodb.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.
quarkus.dynamodb.api-call-attempt-timeout
quarkus.dynamodb.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.Type:
class name
quarkus.dynamodb.aws.region
-
An Amazon Web Services region that hosts DynamoDB.
It overrides region provider chain with static value of region with which the DynamoDB 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.Type:
Region
-
quarkus.dynamodb.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
andaws.secretKey
-
Environment Variables -
AWS_ACCESS_KEY_ID
andAWS_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 thetatic-provider
section of the config. -
system-property
- it loads credentials from theaws.accessKeyId
,aws.secretAccessKey
andaws.sessionToken
system properties. -
env-variable
- it loads credentials from theAWS_ACCESS_KEY_ID
,AWS_SECRET_ACCESS_KEY
andAWS_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. -
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.
Accepted values:
default
,static
,system-property
,env-variable
,profile
,container
,instance-profile
,process
,anonymous
Defaults to:
default
-
quarkus.dynamodb.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.Type:
boolean
Defaults to:
false
quarkus.dynamodb.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.
Type:
boolean
Defaults to:
true
quarkus.dynamodb.aws.credentials.static-provider.access-key-id
-
AWS Access key id
Type:
string
quarkus.dynamodb.aws.credentials.static-provider.secret-access-key
-
AWS Secret access key
Type:
string
quarkus.dynamodb.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 oraws.profile
system property is used and defaults todefault
name.Type:
string
quarkus.dynamodb.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.
Type:
boolean
Defaults to:
false
quarkus.dynamodb.aws.credentials.process-provider.credential-refresh-threshold
quarkus.dynamodb.aws.credentials.process-provider.process-output-limit
quarkus.dynamodb.aws.credentials.process-provider.command
-
The command that should be executed to retrieve credentials.
Type:
string
quarkus.dynamodb.sync-client.connection-timeout
quarkus.dynamodb.sync-client.connection-acquisition-timeout
quarkus.dynamodb.sync-client.connection-max-idle-time
quarkus.dynamodb.sync-client.connection-time-to-live
quarkus.dynamodb.sync-client.socket-timeout
quarkus.dynamodb.sync-client.max-connections
-
The maximum number of connections allowed in the connection pool. Each built HTTP client has its own private connection pool.
Type:
int
Defaults to:
50
quarkus.dynamodb.sync-client.expect-continue-enabled
-
Whether the client should send an HTTP expect-continue handshake before each request.
Type:
boolean
Defaults to:
true
quarkus.dynamodb.sync-client.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.dynamodb.sync-client.connection-max-idle-time
will be closed. This will not close connections currently in use.Type:
boolean
Defaults to:
true
quarkus.dynamodb.sync-client.proxy.enabled
-
Enable HTTP proxy
Type:
boolean
Defaults to:
false
quarkus.dynamodb.sync-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.
Type:
URI
quarkus.dynamodb.sync-client.proxy.username
-
The username to use when connecting through a proxy.
Type:
string
quarkus.dynamodb.sync-client.proxy.password
-
The password to use when connecting through a proxy.
Type:
string
quarkus.dynamodb.sync-client.proxy.ntlm-domain
-
For NTLM proxies - the Windows domain name to use when authenticating with the proxy.
Type:
string
quarkus.dynamodb.sync-client.proxy.ntlm-workstation
-
For NTLM proxies - the Windows workstation name to use when authenticating with the proxy.
Type:
string
quarkus.dynamodb.sync-client.proxy.preemptive-basic-authentication-enabled
-
Whether to attempt to authenticate preemptively against the proxy server using basic authentication.
Type:
boolean
quarkus.dynamodb.sync-client.proxy.non-proxy-hosts
-
The hosts that the client is allowed to access without going through the proxy.
Type:
string
quarkus.dynamodb.sync-client.tls-managers-provider.type
-
TLS 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 standardjavax.net.ssl.keyStore
,javax.net.ssl.keyStorePassword
, andjavax.net.ssl.keyStoreType
properties defined by the JSSE. -
file-store
- Provider that loads a the key store from a file.
Accepted values:
none
,system-property
,file-store
Defaults to:
system-property
-
quarkus.dynamodb.sync-client.tls-managers-provider.file-store.path
-
Path to the key store.
Type:
path
quarkus.dynamodb.sync-client.tls-managers-provider.file-store.type
-
Key store type. See the KeyStore section in the Java Cryptography Architecture Standard Algorithm Name Documentation for information about standard keystore types.
Type:
string
quarkus.dynamodb.sync-client.tls-managers-provider.file-store.password
-
Key store password
Type:
string
quarkus.dynamodb.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.
Type:
int
Defaults to:
50
quarkus.dynamodb.async-client.max-pending-connection-acquires
-
The maximum number of pending acquires allowed. Once this exceeds, acquire tries will be failed.
Type:
int
Defaults to:
10000
quarkus.dynamodb.async-client.read-timeout
quarkus.dynamodb.async-client.write-timeout
quarkus.dynamodb.async-client.connection-timeout
quarkus.dynamodb.async-client.connection-acquisition-timeout
quarkus.dynamodb.async-client.connection-time-to-live
quarkus.dynamodb.async-client.connection-max-idle-time
quarkus.dynamodb.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.dynamodb.async-client.connection-max-idle-time
will be closed. This will not close connections currently in use.Type:
boolean
Defaults to:
true
quarkus.dynamodb.async-client.protocol
-
The HTTP protocol to use.
Accepted values:
http1-1
,http2
Defaults to:
http1-1
quarkus.dynamodb.async-client.max-http2-streams
-
The maximum number of concurrent streams for an HTTP/2 connection. This setting is only respected when the HTTP/2 protocol is used. 0 means unlimited.
Type:
int
Defaults to:
0
quarkus.dynamodb.async-client.ssl-provider
-
The SSL Provider to be used in the Netty client. Default is
OPENSSL
if available,JDK
otherwise.Accepted values:
jdk
,openssl
,openssl-refcnt
quarkus.dynamodb.async-client.proxy.enabled
-
Enable HTTP proxy.
Type:
boolean
Defaults to:
false
quarkus.dynamodb.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.
Type:
URI
quarkus.dynamodb.async-client.proxy.non-proxy-hosts
-
The hosts that the client is allowed to access without going through the proxy.
Type:
string
quarkus.dynamodb.async-client.tls-managers-provider.type
-
TLS 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 standardjavax.net.ssl.keyStore
,javax.net.ssl.keyStorePassword
, andjavax.net.ssl.keyStoreType
properties defined by the JSSE. -
file-store
- Provider that loads a the key store from a file.
Accepted values:
none
,system-property
,file-store
Defaults to:
system-property
-
quarkus.dynamodb.async-client.tls-managers-provider.file-store.path
-
Path to the key store.
Type:
path
quarkus.dynamodb.async-client.tls-managers-provider.file-store.type
-
Key store type. See the KeyStore section in the Java Cryptography Architecture Standard Algorithm Name Documentation for information about standard keystore types.
Type:
string
quarkus.dynamodb.async-client.tls-managers-provider.file-store.password
-
Key store password
Type:
string
quarkus.dynamodb.async-client.event-loop.override
-
Enable the custom configuration of the Netty event loop group.
Type:
boolean
Defaults to:
false
quarkus.dynamodb.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.Type:
int
quarkus.dynamodb.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
Type:
string
About the Duration format
The format for durations uses the standard You can also provide duration values starting with a number.
In this case, if the value consists only of a number, the converter treats the value as seconds.
Otherwise, |
About the MemorySize format
A size configuration option recognises string in this format (shown as a regular expression): |