Amazon DynamoDB Client
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). |
The Quarkus extension supports the traditional DynamoDB client as well as the enhanced client.
It supports two programming models:
-
Blocking access using URL Connection HTTP client (by default) or the Apache HTTP Client
-
Asynchronous programming based on JDK’s
CompletableFuture
objects and the Netty HTTP client (by default) or the AWS CRT-based 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 17+ installed with
JAVA_HOME
configured appropriately -
an IDE
-
Apache Maven 3.8.1+
-
An AWS Account to access the DynamoDB service
-
Optionally, Docker for your system to run DynamoDB locally for testing purposes
Provision DynamoDB locally via Dev Services
The easiest way to start working with DynamoDB is to run a local instance using Dev Services.
Provision DynamoDB locally manually
You can also set up a local version of DynamoDB manually, first start a local instance as a container:
docker run --publish 4566:8000 amazon/dynamodb-local:1.19.0 -jar DynamoDBLocal.jar -inMemory -sharedDb
This starts a DynamoDB instance that is accessible on port 4566
.
You can check if it’s working with aws dynamodb list-tables --endpoint-url http://localhost:4566
.
{
"TableNames": []
}
You should see the output above in your terminal. That’s it, DynamoDB runs locally.
Have a look at the Setting Up DynamoDB Local guide for other options to run DynamoDB.
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:
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 amazon-dynamodb-quickstart
directory.
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:3.15.0:create \
-DprojectGroupId=org.acme \
-DprojectArtifactId=amazon-dynamodb-quickstart \
-DclassName="org.acme.dynamodb.FruitResource" \
-Dpath="/fruits" \
-Dextensions="resteasy-reactive-jackson,amazon-dynamodb"
cd amazon-dynamodb-quickstart
This command generates a Maven structure importing the RESTEasy Reactive/JAX-RS and DynamoDB Client extensions.
After this, the amazon-dynamodb
extension has been added to your pom.xml
as well as the Mutiny support for RESTEasy.
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);
}
}
The @RegisterForReflection annotation instructs Quarkus to keep the class and its members during the native compilation. More details about the @RegisterForReflection annotation can be found on the native application tips page.
|
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 final static String FRUIT_TABLE_NAME = "QuarkusFruits";
protected ScanRequest scanRequest() {
return ScanRequest.builder().tableName(FRUIT_TABLE_NAME)
.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(FRUIT_TABLE_NAME)
.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(FRUIT_TABLE_NAME)
.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 jakarta.enterprise.context.ApplicationScoped;
import jakarta.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 void add(Fruit fruit) {
dynamoDB.putItem(putRequest(fruit));
}
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 jakarta.inject.Inject;
import jakarta.ws.rs.Consumes;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.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(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
DynamoDB 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 java.net.URLConnection
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 HTTP client instead, configure it as follows:
quarkus.dynamodb.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>
If you want to use the AWS CRT-based HTTP client instead, configure it as follows:
quarkus.dynamodb.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>
If you’re going to use a local DynamoDB instance, configure it as follows:
quarkus.dynamodb.endpoint-override=http://localhost:4566
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.secretAccessKey
-
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 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
-
Next steps
Packaging
Packaging your application is as simple as ./mvnw clean package
.
It can be run with java -jar target/quarkus-app/quarkus-run.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.stream.Collectors;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import io.smallrye.mutiny.Uni;
import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
@ApplicationScoped
public class FruitAsyncService extends AbstractService {
@Inject
DynamoDbAsyncClient dynamoDB;
public Uni<List<Fruit>> findAll() {
return Uni.createFrom().completionStage(() -> dynamoDB.scan(scanRequest()))
.onItem().transform(res -> res.items().stream().map(Fruit::from).collect(Collectors.toList()));
}
public Uni<Void> add(Fruit fruit) {
return Uni.createFrom().completionStage(() -> dynamoDB.putItem(putRequest(fruit))).replaceWithVoid();
}
public Uni<Fruit> get(String name) {
return Uni.createFrom().completionStage(() -> dynamoDB.getItem(getRequest(name)))
.onItem().transform(resp -> Fruit.from(resp.item()));
}
}
In the previous code, we create Uni
instances from the CompletionStage
objects returned by the asynchronous DynamoDB client, and then transform the emitted item.
Then, create an asynchronous REST resource that consumes this async service:
package org.acme.dynamodb;
import java.util.List;
import jakarta.inject.Inject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.Path;
import io.smallrye.mutiny.Uni;
@Path("/async-fruits")
public class FruitAsyncResource {
@Inject
FruitAsyncService service;
@GET
public Uni<List<Fruit>> getAll() {
return service.findAll();
}
@GET
@Path("{name}")
public Uni<Fruit> getSingle(String name) {
return service.get(name);
}
@POST
public Uni<List<Fruit>> add(Fruit fruit) {
return service.add(fruit)
.onItem().ignore().andSwitchTo(this::getAll);
}
}
And add 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.dynamodb.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>
DynamoDB enhanced client
The DynamoDB enhanced client is part of the AWS SDK for Java version 2 and makes the mapping between DynamoDB Tables and Java beans very easy.
The Enhanced Client requires a TableSchema which can be generated from a bean class annotated with DynamoDbBean
or DynamoDbImmutable
or generated from code.
By default, TableSchemas generated from bean classes are registered and cached at startup. You don’t need to explicitely instantiate them at class-load time.
It has both a sync and an async variants.
To use the enhanced client, add the quarkus-amazon-dynamodb-enhanced
extension to your pom.xml
:
<dependency>
<groupId>io.quarkiverse.amazonservices</groupId>
<artifactId>quarkus-amazon-dynamodb-enhanced</artifactId>
</dependency>
The Fruit
bean would look like this:
package org.acme.dynamodb;
import java.util.Map;
import java.util.Objects;
import io.quarkus.runtime.annotations.RegisterForReflection;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbAttribute;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
@RegisterForReflection
@DynamoDbBean
public class Fruit {
private String name;
private String description;
public Fruit() {
}
@DynamoDbPartitionKey
@DynamoDbAttribute(AbstractService.FRUIT_NAME_COL)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@DynamoDbAttribute(AbstractService.FRUIT_DESC_COL)
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);
}
}
Note that you don’t need to add @RegisterForReflection
anymore.
The FruitSyncService
would need to use the DynamoDbEnhancedClient
as well as create a TableSchema
:
package org.acme.dynamodb;
import java.util.List;
import java.util.stream.Collectors;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
import software.amazon.awssdk.enhanced.dynamodb.Key;
import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
@ApplicationScoped
public class FruitSyncService extends AbstractService {
private DynamoDbTable<Fruit> fruitTable;
@Inject
FruitEnhancedSyncService(DynamoDbEnhancedClient dynamoEnhancedClient) {
fruitTable = dynamoEnhancedClient.table(FRUIT_TABLE_NAME,
TableSchema.fromClass(Fruit.class));
}
public List<Fruit> findAll() {
return fruitTable.scan().items().stream().collect(Collectors.toList());
}
public List<Fruit> add(Fruit fruit) {
fruitTable.putItem(fruit);
return findAll();
}
public Fruit get(String name) {
Key partitionKey = Key.builder().partitionValue(name).build();
return fruitTable.getItem(partitionKey);
}
}
The same goes for the asynchronous version with DynamoDbEnhanceAsyncdClient
:
package org.acme.dynamodb;
import java.util.List;
import java.util.stream.Collectors;
import io.smallrye.mutiny.Multi;
import io.smallrye.mutiny.Uni;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import mutiny.zero.flow.adapters.AdaptersToFlow;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbAsyncTable;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedAsyncClient;
import software.amazon.awssdk.enhanced.dynamodb.Key;
import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
@ApplicationScoped
public class FruitAsyncService extends AbstractService {
private DynamoDbAsyncTable<Fruit> fruitTable;
@Inject
FruitEnhancedAsyncService(DynamoDbEnhancedAsyncClient dynamoEnhancedAsyncClient) {
fruitTable = dynamoEnhancedAsyncClient.table(FRUIT_TABLE_NAME,
TableSchema.fromClass(Fruit.class));
}
public Uni<List<Fruit>> findAll() {
return Multi.createFrom().publisher(AdaptersToFlow.publisher(fruitTable.scan().items())).collect().asList();
}
public Uni<Void> add(Fruit fruit){
return Uni.createFrom().completionStage(() -> fruitTable.putItem(fruit));
}
public Uni<Fruit> get(String name) {
Key partitionKey = Key.builder().partitionValue(name).build();
return Uni.createFrom().completionStage(() -> fruitTable.getItem(partitionKey));
}
}
Resource classes remain unchanged.
Alternatively, if you only need to use the DynamoDbTable instance, you can inject it directly with a @NamedDynamoDbTable
annotation.
The synchronous version would be :
package org.acme.dynamodb;
import java.util.List;
import java.util.stream.Collectors;
import io.quarkiverse.amazon.dynamodb.enhanced.runtime.NamedDynamoDbTable;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
import software.amazon.awssdk.enhanced.dynamodb.Key;
@ApplicationScoped
public class FruitSyncService extends AbstractService {
@Inject
@NamedDynamoDbTable(FRUIT_TABLE_NAME)
DynamoDbTable<Fruit> fruitTable;
public List<Fruit> findAll() {
return fruitTable.scan().items().stream().collect(Collectors.toList());
}
public List<Fruit> add(Fruit fruit) {
fruitTable.putItem(fruit);
return findAll();
}
public Fruit get(String name) {
Key partitionKey = Key.builder().partitionValue(name).build();
return fruitTable.getItem(partitionKey);
}
}
And the asynchronous version :
package org.acme.dynamodb;
import java.util.List;
import io.quarkiverse.amazon.dynamodb.enhanced.runtime.NamedDynamoDbTable;
import io.smallrye.mutiny.Multi;
import io.smallrye.mutiny.Uni;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import mutiny.zero.flow.adapters.AdaptersToFlow;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbAsyncTable;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedAsyncClient;
import software.amazon.awssdk.enhanced.dynamodb.Key;
import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
@ApplicationScoped
public class FruitEnhancedAsyncService extends AbstractService {
@Inject
@NamedDynamoDbTable(FRUIT_TABLE_NAME)
private DynamoDbAsyncTable<Fruit> fruitTable;
public Uni<List<Fruit>> findAll() {
return Multi.createFrom().publisher(AdaptersToFlow.publisher(fruitTable.scan().items())).collect().asList();
}
public Uni<Void> add(Fruit fruit){
return Uni.createFrom().completionStage(() -> fruitTable.putItem(fruit));
}
public Uni<Fruit> get(String name) {
Key partitionKey = Key.builder().partitionValue(name).build();
return Uni.createFrom().completionStage(() -> fruitTable.getItem(partitionKey));
}
}
You can find more information about the DynamoDB enhanced client in the AWS documentation:
Configuration Reference
Configuration property fixed at build time - All other configuration properties are overridable at runtime
Configuration property |
Type |
Default |
---|---|---|
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 Environment variable: |
list of string |
|
boolean |
|
|
SyncClientType |
|
|
AsyncClientType |
|
|
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. For all services but Cognito, the local AWS stack will be provided by LocalStack. Otherwise, it will be provided by Moto Environment variable: |
boolean |
|
Indicates if the LocalStack container managed by Dev Services is shared. When shared, Quarkus looks for running containers using label-based service discovery. If a matching container is found, it is used, and so a second one is not started. Otherwise, Dev Services starts a new container. The discovery uses the Sharing is not supported for the Cognito extension. Environment variable: |
boolean |
|
Indicates if shared LocalStack services managed by Dev Services should be isolated. When true, the service will be started in its own container and the value of the Environment variable: |
boolean |
|
The value of the This property is used when you need multiple shared LocalStack instances. Environment variable: |
string |
|
Map<String,String> |
||
boolean |
|
|
Type |
Default |
|
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: |
||
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: |
||
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: |
boolean |
|
Type |
Default |
|
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:
See Environment variable: |
Region |
|
Configure the credentials provider that should be used to authenticate with AWS. Available values:
Environment variable: |
AwsCredentialsProviderType |
|
Type |
Default |
|
Whether this provider should fetch credentials asynchronously in the background. If this is Environment variable: |
boolean |
|
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: |
boolean |
|
Type |
Default |
|
string |
||
string |
||
string |
||
Type |
Default |
|
The name of the profile that should be used by this credentials provider. If not specified, the value in Environment variable: |
string |
|
Type |
Default |
|
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: |
boolean |
|
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: |
|
|
The maximum size of the output that can be returned by the external process before an exception is raised. Environment variable: |
|
|
The command that should be executed to retrieve credentials. Command and parameters are seperated list entries. Environment variable: |
list of string |
|
Type |
Default |
|
string |
||
Type |
Default |
|
|
||
|
||
TLS key managers provider type. Available providers:
Environment variable: |
TlsKeyManagersProviderType |
|
path |
||
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: |
string |
|
string |
||
TLS trust managers provider type. Available providers:
Environment variable: |
TlsTrustManagersProviderType |
|
path |
||
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: |
string |
|
string |
||
Type |
Default |
|
|
||
|
||
int |
|
|
boolean |
|
|
Whether the idle connections in the connection pool should be closed asynchronously. When enabled, connections left idling for longer than Environment variable: |
boolean |
|
boolean |
|
|
boolean |
|
|
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: |
||
string |
||
string |
||
string |
||
string |
||
boolean |
||
list of string |
||
Type |
Default |
|
|
||
int |
|
|
boolean |
|
|
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: |
||
string |
||
string |
||
Type |
Default |
|
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: |
int |
|
int |
|
|
|
||
|
||
|
||
|
||
The maximum amount of time that a connection should be allowed to remain open while idle. Currently has no effect if Environment variable: |
|
|
Whether the idle connections in the connection pool should be closed. When enabled, connections left idling for longer than Environment variable: |
boolean |
|
boolean |
|
|
Protocol |
|
|
SslProviderType |
||
long |
|
|
int |
|
|
Sets the period that the Netty client will send This setting is only respected when the HTTP/2 protocol is used. Environment variable: |
|
|
boolean |
|
|
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: |
||
list of string |
||
TLS key managers provider type. Available providers:
Environment variable: |
TlsKeyManagersProviderType |
|
path |
||
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: |
string |
|
string |
||
TLS trust managers provider type. Available providers:
Environment variable: |
TlsTrustManagersProviderType |
|
path |
||
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: |
string |
|
string |
||
boolean |
|
|
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 Environment variable: |
int |
|
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 Environment variable: |
string |
|
Whether the default thread pool should be used to complete the futures returned from the HTTP client request. When disabled, futures will be completed on the Netty event loop thread. Environment variable: |
boolean |
|
About the Duration format
To write duration values, use the standard You can also use a simplified format, starting with a number:
In other cases, the simplified format is translated to the
|
About the MemorySize format
A size configuration option recognizes strings in this format (shown as a regular expression): If no suffix is given, assume bytes. |
Configuration property fixed at build time - All other configuration properties are overridable at runtime
Configuration property |
Type |
Default |
---|---|---|
list of string |
||
Whether a
Environment variable: |
boolean |
|