La AWS SDK para Java 1.x se alcanzó end-of-support el 31 de diciembre de 2025. Le recomendamos que migre a [AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html) para seguir recibiendo nuevas características, mejoras de disponibilidad y actualizaciones de seguridad.
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Usando el AWS SDK para Java
En esta sección se proporciona información general importante sobre la programación, AWS SDK para Java que se aplica a todos los servicios que pueda utilizar con el SDK.
Para obtener información y ejemplos de programación específicos de un servicio (para Amazon EC2, Amazon S3, Amazon SWF, etc.), consulte Ejemplos de [AWS SDK para Java código](prog-services.md).
**Topics**
+ [Mejores prácticas para el AWS desarrollo con AWS SDK para Java](best-practices.md)
+ [Creación de clientes de servicio](creating-clients.md)
+ [Proporcionar credenciales temporales](credentials.md)
+ [Región de AWS Selección](java-dg-region-selection.md)
+ [Tratamiento de excepciones](java-dg-exceptions.md)
+ [Programación asíncrona](basics-async.md)
+ [Registro de llamadas AWS SDK para Java](java-dg-logging.md)
+ [Configuración de los clientes](section-client-configuration.md)
+ [Política de control de acceso](java-dg-access-control.md)
+ [Configurar el TTL de JVM para las búsquedas de nombres DNS](jvm-ttl-dns.md)
+ [Habilitación de métricas para AWS SDK para Java](generating-sdk-metrics.md)
# Mejores prácticas para el AWS desarrollo con AWS SDK para Java
Las siguientes prácticas recomendadas pueden ayudarle a evitar problemas o problemas al desarrollar AWS aplicaciones con AWS SDK para Java. Hemos organizado las prácticas recomendadas por servicio.
## S3
### Evite ResetExceptions
Al cargar objetos Amazon S3 mediante transmisiones (ya sea a través de un `AmazonS3` cliente o`TransferManager`), es posible que se produzcan problemas de conectividad de red o de tiempo de espera. De forma predeterminada, los AWS SDK para Java intentos de reintentar realizar transferencias fallidas marcando el flujo de entrada antes del inicio de la transferencia y restableciéndolo antes de volver a intentarlo.
Si la transmisión no admite marcar y restablecer, el SDK lanza una [ResetException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ResetException.html)cuando hay errores transitorios y los reintentos están habilitados.
**Práctica recomendada**
Le recomendamos que utilice secuencias que admitan operaciones de marcado y restablecimiento.
La forma más fiable de evitar un [ResetException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ResetException.html)es proporcionar datos mediante un [archivo](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/File.html) o [FileInputStream](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/FileInputStream.html), que AWS SDK para Java puedan gestionar sin verse limitados por los límites de marcar y restablecer.
Si la transmisión no es una, [FileInputStream](https://docs.oracle.com/javase/8/docs/api/index.html?java/io/FileInputStream.html)pero admite marcar y restablecer, puedes establecer el límite de marcas mediante el `setReadLimit` método de [RequestClientOptions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/RequestClientOptions.html). Su valor predeterminado es 128 KB. Si se establece el valor límite de lectura en *un byte mayor que el tamaño de la transmisión*, se evitará de forma fiable un [ResetException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ResetException.html).
Por ejemplo, si el tamaño máximo esperado de una secuencia es de 100 000 bytes, defina el límite de lectura en 100 001 (100 000\$11) bytes. Las operaciones de marca y restablecimiento siempre funcionan para 100 000 bytes o menos. Tenga en cuenta que esto puede provocar que algunas secuencias almacenen ese número de bytes en memoria.
# Creación de clientes de servicio
Para realizar solicitudes a Amazon Web Services, primero debe crear un objeto de cliente de servicio. La manera recomendada es utilizar el creador de clientes de servicio.
Cada uno Servicio de AWS tiene una interfaz de servicio con métodos para cada acción en la API de servicio. Por ejemplo, la interfaz de servicio de DynamoDB recibe el nombre. [AmazonDynamoDBClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/AmazonDynamoDBClient.html) Cada interfaz de servicio cuenta con su creador de clientes correspondiente, que puede utilizar para crear una implementación de la interfaz de servicio. [La clase de creación de clientes para DynamoDB se denomina AmazonDynamo DBClient Builder.](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDBClientBuilder.html)
## Obtención de un creador de clientes
Para obtener una instancia del creador de clientes, use el método de fábrica estático `standard`, tal y como se muestra en el siguiente ejemplo.
```
AmazonDynamoDBClientBuilder builder = AmazonDynamoDBClientBuilder.standard();
```
Una vez que tenga un creador, puede personalizar las propiedades del cliente mediante el uso de funciones setter Fluent en la API del compilador. Por ejemplo, puede definir una región personalizada y un proveedor de credenciales personalizado, tal y como se indica a continuación.
```
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.withCredentials(new ProfileCredentialsProvider("myProfile"))
.build();
```
**nota**
Los métodos `withXXX` Fluent devuelven el objeto `builder` para que pueda encadenar fácilmente las llamadas a los métodos y para simplificar la lectura del código. Después de configurar las propiedades que desee, puede llamar al método `build` para crear el cliente. Una vez que se crea un cliente, este es inmutable y todas las llamadas a `setRegion` o `setEndpoint` producirán un error.
Un creador puede crear varios clientes con la misma configuración. Cuando escriba su aplicación, debe ser consciente de que el creador es mutable y no es seguro para subprocesos.
El código siguiente utiliza el creador como una fábrica de instancias de cliente.
```
public class DynamoDBClientFactory {
private final AmazonDynamoDBClientBuilder builder =
AmazonDynamoDBClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.withCredentials(new ProfileCredentialsProvider("myProfile"));
public AmazonDynamoDB createClient() {
return builder.build();
}
}
```
[El generador también expone los setters fluidos para [ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html)y [RequestMetricCollector](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/metrics/RequestMetricCollector.html), y una lista personalizada de RequestHandler 2.](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/handlers/RequestHandler2.html)
A continuación se presenta un ejemplo completo que invalida todas las propiedades configurables.
```
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.withCredentials(new ProfileCredentialsProvider("myProfile"))
.withClientConfiguration(new ClientConfiguration().withRequestTimeout(5000))
.withMetricsCollector(new MyCustomMetricsCollector())
.withRequestHandlers(new MyCustomRequestHandler(), new MyOtherCustomRequestHandler)
.build();
```
## Creación de clientes asíncronos
AWS SDK para Java Tiene clientes asíncronos (o asíncronos) para cada servicio (excepto) y el correspondiente generador de clientes asíncronos para Amazon S3 cada servicio.
### Para crear un cliente de DynamoDB asíncrono con el valor predeterminado ExecutorService
```
AmazonDynamoDBAsync ddbAsync = AmazonDynamoDBAsyncClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.withCredentials(new ProfileCredentialsProvider("myProfile"))
.build();
```
Además de las opciones de configuración que admite el generador de clientes síncronos (o sincronizados), el cliente asíncrono permite configurar una configuración personalizada [ExecutorFactory](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/client/builder/ExecutorFactory.html)para cambiar la que utiliza el cliente asíncrono. `ExecutorService` `ExecutorFactory`es una interfaz funcional, por lo que interopera con las expresiones lambda y las referencias a métodos de Java 8.
### Para crear un cliente asíncrono con un ejecutor personalizado
```
AmazonDynamoDBAsync ddbAsync = AmazonDynamoDBAsyncClientBuilder.standard()
.withExecutorFactory(() -> Executors.newFixedThreadPool(10))
.build();
```
## Usando DefaultClient
Los creador de clientes síncronos y asíncronos tienen otro método de fábrica denominado `defaultClient`. Este método crea un servicio de cliente con la configuración predeterminada, utilizando la cadena de proveedores predeterminada para cargar las credenciales y la región Región de AWS. Si las credenciales o la región no se pueden determinar a partir del entorno en el que se ejecuta la aplicación, la llamada a `defaultClient` produce un error. Consulte [Trabajar con AWS las credenciales](credentials.md) y la [Región de AWS selección](java-dg-region-selection.md) para obtener más información sobre cómo se determinan las credenciales y la región.
### Para crear un cliente de servicio predeterminado
```
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
```
## Ciclo de vida del cliente
Los clientes de servicio del SDK son seguros para subprocesos y, para obtener el mejor rendimiento, deben tratarse como objetos de larga duración. Cada cliente tiene su propio recurso de grupo de conexiones. Cierre los clientes de forma explícita cuando dejen de ser necesarios para evitar que se filtren recursos.
Para cerrar un cliente de forma explícita, llame al método `shutdown`. Después de llamar a `shutdown`, todos los recursos del cliente se liberan y ya no se puede utilizar el cliente.
### Para cerrar un cliente
```
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
ddb.shutdown();
// Client is now unusable
```
# Proporcione credenciales temporales al AWS SDK para Java
Para realizar solicitudes Amazon Web Services, debe proporcionar credenciales AWS temporales para AWS SDK para Java que las utilice cuando llame a los servicios. Puede hacerlo de las siguientes maneras:
+ Utilice la cadena predeterminada de proveedores de credenciales *(recomendado)*.
+ Utilice un proveedor de credenciales específico o una cadena de proveedores (o cree el suyo propio).
+ Proporcione usted mismo las credenciales temporales en código.
## Uso de la cadena predeterminada de proveedores de credenciales
Al inicializar un nuevo cliente de servicio sin proporcionar ningún argumento, AWS SDK para Java intenta encontrar credenciales temporales utilizando la *cadena de proveedores de credenciales predeterminada* implementada por la clase [AWSCredentialsProviderChainDefault](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/DefaultAWSCredentialsProviderChain.html). La cadena predeterminada de proveedores de credenciales busca las credenciales en este orden:
1. **Variables de entorno**: `AWS_ACCESS_KEY_ID`, `AWS_SECRET_KEY` o `AWS_SECRET_ACCESS_KEY` y `AWS_SESSION_TOKEN`. AWS SDK para Java Usa la [EnvironmentVariableCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/EnvironmentVariableCredentialsProvider.html)clase para cargar estas credenciales.
1. **Propiedades del sistema Java**: `aws.accessKeyId`, `aws.secretKey` (pero no `aws.secretAccessKey`) y `aws.sessionToken`. AWS SDK para Java Usa el [SystemPropertiesCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/SystemPropertiesCredentialsProvider.html)para cargar estas credenciales.
1. **Credenciales de Web Identity Token** del entorno o contenedor.
1. **El archivo de perfiles de credenciales predeterminado**, que normalmente se encuentra en `~/.aws/credentials` (la ubicación puede variar según la plataforma) y lo comparten muchos de ellos AWS SDKs y entre ellos. AWS CLI AWS SDK para Java Utiliza el [ProfileCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/profile/ProfileCredentialsProvider.html)para cargar estas credenciales.
Puede crear un archivo de credenciales mediante el `aws configure` comando proporcionado por el AWS CLI, o puede crearlo editando el archivo con un editor de texto. Para obtener información sobre el formato del archivo de credenciales, consulte [Formato del archivo de credenciales de AWS](#credentials-file-format).
1. **Credenciales del contenedor de Amazon ECS**: cargadas desde Amazon ECS si se ha establecido la variable de entorno `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`. AWS SDK para Java Utiliza el [ContainerCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/ContainerCredentialsProvider.html)para cargar estas credenciales. Puede especificar la dirección IP para este valor.
1. **Credenciales de perfil de instancia**: se utilizan en las instancias de EC2 y se entregan a través del servicio de Amazon EC2 metadatos. AWS SDK para Java Utiliza las [InstanceProfileCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/InstanceProfileCredentialsProvider.html)para cargar estas credenciales. Puede especificar la dirección IP para este valor.
**nota**
Las credenciales del perfil de instancia se utilizan únicamente si no se ha establecido `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`. Para obtener más información, consulte [EC2ContainerCredentialsProviderWrapper](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/EC2ContainerCredentialsProviderWrapper.html).
### Utilizar credenciales temporales
Para poder usar credenciales AWS temporales, deben estar configuradas en *al menos una* de las ubicaciones anteriores. Para obtener información sobre la configuración de las credenciales, consulte los siguientes temas:
+ Para especificar credenciales en el *entorno* o en el *archivo de perfiles de credenciales* predeterminado, consulte [Configurar credenciales temporales](setup-credentials.md#setup-credentials-setting).
+ Para establecer *propiedades del sistema* Java, consulte el tutorial [System Properties](http://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html) en el sitio web oficial *Java Tutorials*.
+ Para configurar y usar *las credenciales del perfil de instancia* con sus instancias de EC2, consulte [Uso de funciones de IAM para conceder acceso a AWS los recursos](java-dg-roles.md) en ellas. Amazon EC2
### Configurar un perfil de credenciales alternativo
AWS SDK para Java Utiliza el perfil *predeterminado* de forma predeterminada, pero hay formas de personalizar el perfil que proviene del archivo de credenciales.
Puede usar la variable AWS de entorno Profile para cambiar el perfil cargado por el SDK.
Por ejemplo, en Linux; macOS o Unix ejecutaría el comando siguiente para cambiar el perfil a *myProfile*.
```
export AWS_PROFILE="myProfile"
```
En Windows, usaría el siguiente comando.
```
set AWS_PROFILE="myProfile"
```
La configuración de la variable de `AWS_PROFILE` entorno afecta a la carga de credenciales de todas las herramientas AWS SDKs y compatibles oficialmente (incluidas la AWS CLI y la AWS Tools for Windows PowerShell). Para cambiar únicamente el perfil de una aplicación Java, puede utilizar la propiedad del sistema `aws.profile` en su lugar.
**nota**
La variable de entorno prevalece sobre la propiedad del sistema.
### Configurar una ubicación del archivo de credenciales alternativa
AWS SDK para Java Carga las credenciales AWS temporales automáticamente desde la ubicación predeterminada del archivo de credenciales. Sin embargo, también puede especificar la ubicación estableciendo la variable de entorno `AWS_CREDENTIAL_PROFILES_FILE` con la ruta completa del archivo de credenciales.
Puede utilizar esta función para cambiar temporalmente la ubicación en la que AWS SDK para Java busca su archivo de credenciales (por ejemplo, configurando esta variable con la línea de comandos). También puede establecer la variable de entorno en el entorno del usuario o del sistema para cambiarlo para el usuario o para todo el sistema.
#### Para invalidar la ubicación predeterminada del archivo de credenciales
+ Defina la variable de `AWS_CREDENTIAL_PROFILES_FILE` entorno en la ubicación del archivo de AWS credenciales.
+ En Linux, macOS o Unix, utilice:
```
export AWS_CREDENTIAL_PROFILES_FILE=path/to/credentials_file
```
+ En Windows, use:
```
set AWS_CREDENTIAL_PROFILES_FILE=path/to/credentials_file
```
### Formato de archivo de `Credentials`
Siguiendo las [instrucciones de la configuración básica](signup-create-iam-user.md#setup-temp-creds) de esta guía, el archivo de credenciales debe tener el siguiente formato básico.
```
[default]
aws_access_key_id=
aws_secret_access_key=
aws_session_token=
[profile2]
aws_access_key_id=
aws_secret_access_key=
aws_session_token=
```
El nombre de perfil se especifica entre corchetes (por ejemplo, `[default]`), seguido de los campos configurables en ese perfil como pares de clave-valor. Puede tener varios perfiles en su archivo de `credentials`, que puede añadir o editar mediante `aws configure --profile PROFILE_NAME ` para seleccionar el perfil que se va a configurar.
Puede especificar campos adicionales, como `metadata_service_timeout` y `metadata_service_num_attempts`. Estos no se pueden configurar con la CLI; debe editar el archivo manualmente si desea utilizarlos. Para obtener más información sobre el archivo de configuración y sus campos disponibles, consulte [Configuración del](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) archivo AWS Command Line Interface en la Guía del AWS Command Line Interface usuario.
### Cargar credenciales
Después de definir las credenciales temporales, el SDK las carga mediante la cadena predeterminada de proveedores de credenciales.
Para ello, se crea una instancia de un Servicio de AWS cliente sin proporcionar las credenciales de forma explícita al generador, como se indica a continuación.
```
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.build();
```
## Especificar un proveedor de credenciales o una cadena de proveedores
Puede especificar un proveedor de credenciales diferente de la cadena de proveedores de credenciales *predeterminada* mediante el creador del cliente.
Se proporciona una instancia de un proveedor de credenciales o una cadena de proveedores a un creador de clientes que toma como entrada una interfaz [AWSCredentialsde proveedor](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSCredentialsProvider.html). El siguiente ejemplo muestra cómo utilizar credenciales de *entorno* específicamente.
```
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withCredentials(new EnvironmentVariableCredentialsProvider())
.build();
```
[Para ver la lista completa de proveedores AWS SDK para Java de credenciales y cadenas de proveedores suministrados, consulte **Todas las clases de implementación conocidas** en AWSCredentials Provider.](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSCredentialsProvider.html)
**nota**
Puede utilizar esta técnica para suministrar proveedores de credenciales o cadenas de proveedores que cree utilizando su propio proveedor de credenciales que implemente la `AWSCredentialsProvider` interfaz o subclasificando la clase. [AWSCredentialsProviderChain](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSCredentialsProviderChain.html)
## Especificar explícitamente credenciales temporales
Si la cadena de credenciales predeterminada o un proveedor o cadena de proveedores específicos o personalizados no funcionan para su código, puede configurar credenciales que proporcione explícitamente. Si ha obtenido credenciales temporales utilizando este método AWS STS, utilice este método para especificar las credenciales de acceso. AWS
1. Cree una instancia de la [BasicSessionCredentials](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/BasicSessionCredentials.html)clase y suministre la clave de AWS acceso, la clave AWS secreta y el token de AWS sesión que el SDK utilizará para la conexión.
1. Crea una [AWSStaticCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/AWSStaticCredentialsProvider.html)con el `AWSCredentials` objeto.
1. Configure el creador del cliente con `AWSStaticCredentialsProvider` y compile el cliente.
A continuación se muestra un ejemplo.
```
BasicSessionCredentials awsCreds = new BasicSessionCredentials("access_key_id", "secret_key_id", "session_token");
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withCredentials(new AWSStaticCredentialsProvider(awsCreds))
.build();
```
## Más información
+ [Regístrese AWS y cree un usuario de IAM](signup-create-iam-user.md)
+ [Configure AWS las credenciales y la región para el desarrollo](setup-credentials.md)
+ [Uso de las funciones de IAM para conceder acceso a AWS los recursos en Amazon EC2](java-dg-roles.md)
# Región de AWS Selección
Las regiones le permiten acceder a AWS los servicios que residen físicamente en un área geográfica específica. Esto puede ser útil para evitar redundancias y para que sus datos y aplicaciones se ejecuten cerca del lugar desde donde usted y sus usuarios obtendrán acceso a ellos.
## Comprobación de la disponibilidad del servicio en una región
Para ver si una determinada región Servicio de AWS está disponible en una región, usa el `isServiceSupported` método de la región que quieras usar.
```
Region.getRegion(Regions.US_WEST_2)
.isServiceSupported(AmazonDynamoDB.ENDPOINT_PREFIX);
```
Consulte la documentación de la clase [Regions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/regions/Regions.html) para saber las regiones que puede especificar y use el prefijo de punto de enlace del servicio que desea consultar. Cada prefijo de punto de enlace del servicio se define en la interfaz del servicio. Por ejemplo, el prefijo del DynamoDB punto final se define en la [AmazonDynamobase](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/dynamodbv2/AmazonDynamoDB.html) de datos.
## Selección de una región
A partir de la versión 1.4 del AWS SDK para Java, puedes especificar el nombre de una región y el SDK elegirá automáticamente el punto de conexión adecuado para ti. Para elegir usted mismo el punto de enlace, consulte [Selección de un punto de enlace específico](#region-selection-choose-endpoint).
Para configurar de forma explícita una región, le recomendamos que utilice la enumeración [Regions](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/regions/Regions.html). Esta es una enumeración de todas las regiones disponibles públicamente. Para crear un cliente con una región desde la enumeración, utilice el siguiente código.
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.standard()
.withRegion(Regions.US_WEST_2)
.build();
```
Si la región que intenta utilizar no está en la enumeración `Regions`, puede configurar la región mediante una *cadena* que represente el nombre de la región.
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.standard()
.withRegion("{region_api_default}")
.build();
```
**nota**
Después de compilar un cliente con el creador, este es *inmutable* y la región *no puede modificarse*. Si trabaja con varios Regiones de AWS para el mismo servicio, debe crear varios clientes, uno por región.
## Selección de un punto de enlace específico
Cada AWS cliente se puede configurar para usar un *punto final específico* dentro de una región llamando al `withEndpointConfiguration` método al crear el cliente.
Por ejemplo, para configurar el Amazon S3 cliente para que utilice la región Europa (Irlanda), utilice el siguiente código.
```
AmazonS3 s3 = AmazonS3ClientBuilder.standard()
.withEndpointConfiguration(new EndpointConfiguration(
"https://s3.eu-west-1.amazonaws.com",
"eu-west-1"))
.withCredentials(CREDENTIALS_PROVIDER)
.build();
```
Consulte [Regiones y puntos de enlace](https://docs.aws.amazon.com/general/latest/gr/rande.html) para ver la lista actual de regiones y sus puntos de enlace correspondientes para todos los AWS servicios.
## Determinar automáticamente la región desde el entorno
**importante**
Esta sección solo se aplica cuando se utiliza un [generador de clientes](creating-clients.md) para acceder AWS a los servicios. AWS los clientes creados mediante el constructor de clientes no determinarán automáticamente la región del entorno y, en su lugar, utilizarán la región del SDK *predeterminada* (USEast1).
Cuando se ejecuta en Lambda Amazon EC2 o Lambda, es posible que desee configurar los clientes para que usen la misma región en la que se ejecuta el código. De esta forma, el código se desacopla del entorno en el que se está ejecutando y es más sencillo implementar la aplicación en varias regiones para reducir la latencia o la redundancia.
*Debe utilizar creadores de clientes para que el SDK detecte automáticamente la región en la que se ejecuta el código.*
Para usar la cadena de credential/region proveedores predeterminada para determinar la región a partir del entorno, utilice el `defaultClient` método del creador de clientes.
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();
```
Es lo mismo que usar `standard` seguido de `build`.
```
AmazonEC2 ec2 = AmazonEC2ClientBuilder.standard()
.build();
```
Si no configura explícitamente una región mediante los métodos `withRegion`, el SDK consulta la cadena predeterminada de proveedores de regiones para intentar determinar la región que se va a usar.
### Cadena predeterminada de proveedores de regiones
**A continuación se muestra el proceso de búsqueda de regiones:**
1. Cualquier región explícita establecida mediante `withRegion` o `setRegion` en el propio creador prevalece sobre todas las demás.
1. Se comprueba la variable de entorno `AWS_REGION`. Si se ha establecido, se usa esa región para configurar el cliente.
**nota**
El Lambda contenedor establece esta variable de entorno.
1. El SDK comprueba el archivo de configuración AWS compartido (que normalmente se encuentra en`~/.aws/config`). Si la propiedad *region* está presente, el SDK la utiliza.
+ La variable de entorno `AWS_CONFIG_FILE` se puede utilizar para personalizar la ubicación del archivo de configuración compartida.
+ La variable de entorno `AWS_PROFILE` o la propiedad del sistema `aws.profile` se pueden utilizar para personalizar el perfil que carga el SDK.
1. El SDK intenta usar el servicio de metadatos de la Amazon EC2 instancia para determinar la región de la Amazon EC2 instancia que se está ejecutando actualmente.
1. Si el SDK todavía no ha encontrado una región en ese momento, la creación del cliente produce una excepción.
Al desarrollar AWS aplicaciones, un enfoque habitual consiste en utilizar el *archivo de configuración compartido* (que se describe en la sección [Uso de la cadena de proveedores de credenciales predeterminada](credentials.md#credentials-default)) para establecer la región para el desarrollo local, y utilizar la cadena de proveedores de regiones predeterminada para determinar la región cuando se ejecuta en la AWS infraestructura. Esto simplifica enormemente la creación del cliente y dota de portabilidad a su aplicación.
# Tratamiento de excepciones
Entender cómo y cuándo se AWS SDK para Java producen excepciones es importante para crear aplicaciones de alta calidad mediante el SDK. En las siguientes secciones se describen los diferentes casos de excepciones que produce el SDK y cómo tratarlas correctamente.
## ¿Por qué usar excepciones no controladas?
AWS SDK para Java Utiliza excepciones en tiempo de ejecución (o no comprobadas) en lugar de excepciones comprobadas por los siguientes motivos:
+ Para permitir a los desarrolladores un control minucioso de los errores que desean administrar sin obligarles a abordar casos excepcionales que no les preocupan (o que les obligan a detallar su código en exceso)
+ Para evitar problemas de escalabilidad inherentes a las excepciones controladas en aplicaciones grandes
En general, las excepciones controladas funcionan bien a pequeña escala, pero pueden ser problemáticas cuando las aplicaciones crecen y se vuelven más complejas.
Para obtener más información sobre el uso de excepciones controladas y no controladas, consulte:
+ [Excepciones no controladas: la controversia](http://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html)
+ [The Trouble with Checked Exceptions](http://www.artima.com/intv/handcuffs2.html)
+ [Java's checked exceptions were a mistake (and here's what I would like to do about it)](http://radio-weblogs.com/0122027/stories/2003/04/01/JavasCheckedExceptionsWereAMistake.html)
## AmazonServiceException (y subclases)
[AmazonServiceException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonServiceException.html)es la excepción más común que experimentará al AWS SDK para Java usar. Esta excepción representa una respuesta de error de un servicio de Servicio de AWS. Por ejemplo, si intenta terminar una Amazon EC2 instancia que no existe, EC2 devolverá una respuesta de error y todos los detalles de esa respuesta de error se incluirán en la `AmazonServiceException` que se arroje. En algunos casos, se produce una subclase de `AmazonServiceException` para permitir a los desarrolladores un control minucioso del tratamiento de casos de error a través de bloques de captura.
Cuando encuentres una`AmazonServiceException`, sabrás que tu solicitud se ha enviado correctamente a esa dirección Servicio de AWS , pero que no se ha podido procesar correctamente. Esto puede ser debido a errores en los parámetros de la solicitud o a problemas en el servicio.
`AmazonServiceException` proporciona información como:
+ Código de estado HTTP devuelto
+ Código AWS de error devuelto
+ Mensaje de error detallado del servicio
+ AWS ID de solicitud de la solicitud fallida
`AmazonServiceException`también incluye información sobre si la solicitud fallida fue culpa de la persona que llamó (una solicitud con valores no válidos) o fue culpa Servicio de AWS de la persona que llamó (un error de servicio interno).
## AmazonClientException
[AmazonClientException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonClientException.html)indica que se ha producido un problema en el código del cliente de Java, ya sea al intentar enviar una solicitud AWS o al analizar una respuesta desde AWSél. Un `AmazonClientException` es generalmente más grave que uno e indica un problema importante que impide que el cliente realice llamadas de servicio a AWS los servicios. `AmazonServiceException` Por ejemplo, `AmazonClientException` si no hay ninguna conexión de red disponible cuando se intenta llamar a una operación en uno de los clientes. AWS SDK para Java
# Programación asíncrona
Puede utilizar métodos *síncronos* o *asíncronos* para llamar a las operaciones de los servicios. AWS Los métodos síncronos bloquean la ejecución de los subprocesos hasta que el cliente recibe una respuesta del servicio. Los métodos asíncronos terminan de ejecutarse inmediatamente, devolviendo el control al subproceso que realiza la llamada sin esperar una respuesta.
Como un método asíncrono termina de ejecutarse antes de que haya una respuesta disponible, necesita una forma de obtener la respuesta cuando esté lista. AWS SDK para Java *Proporciona dos formas: *objetos futuros* y métodos de devolución de llamada.*
## Objetos Future de Java
*Los métodos asíncronos AWS SDK para Java devuelven un objeto [Future](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/Future.html) que contiene los resultados de la operación asincrónica en el futuro.*
Llame al método `Future` `isDone()` para saber si el servicio ya ha proporcionado un objeto de respuesta. Cuando la respuesta esté lista, podrá obtener el objeto de respuesta llamando al método `Future` `get()`. Puede utilizar este mecanismo para sondear periódicamente los resultados de las operaciones asíncronas mientras su aplicación sigue trabajando en otras cosas.
Este es un ejemplo de una operación asíncrona que llama a una Lambda función y recibe una que puede contener un objeto. `Future` [InvokeResult](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/lambda/model/InvokeResult.html) El objeto `InvokeResult` solo se recupera cuando `isDone()` es `true`.
```
import com.amazonaws.services.lambda.AWSLambdaAsyncClient;
import com.amazonaws.services.lambda.model.InvokeRequest;
import com.amazonaws.services.lambda.model.InvokeResult;
import java.nio.ByteBuffer;
import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;
public class InvokeLambdaFunctionAsync
{
public static void main(String[] args)
{
String function_name = "HelloFunction";
String function_input = "{\"who\":\"SDK for Java\"}";
AWSLambdaAsync lambda = AWSLambdaAsyncClientBuilder.defaultClient();
InvokeRequest req = new InvokeRequest()
.withFunctionName(function_name)
.withPayload(ByteBuffer.wrap(function_input.getBytes()));
Future future_res = lambda.invokeAsync(req);
System.out.print("Waiting for future");
while (future_res.isDone() == false) {
System.out.print(".");
try {
Thread.sleep(1000);
}
catch (InterruptedException e) {
System.err.println("\nThread.sleep() was interrupted!");
System.exit(1);
}
}
try {
InvokeResult res = future_res.get();
if (res.getStatusCode() == 200) {
System.out.println("\nLambda function returned:");
ByteBuffer response_payload = res.getPayload();
System.out.println(new String(response_payload.array()));
}
else {
System.out.format("Received a non-OK response from {AWS}: %d\n",
res.getStatusCode());
}
}
catch (InterruptedException | ExecutionException e) {
System.err.println(e.getMessage());
System.exit(1);
}
System.exit(0);
}
}
```
## Devoluciones de llamadas asíncronas
Además de utilizar el `Future` objeto Java para supervisar el estado de las solicitudes asincrónicas, el SDK también permite implementar una clase que utilice la interfaz. [AsyncHandler](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/handlers/AsyncHandler.html) `AsyncHandler`proporciona dos métodos a los que se invoca en función de cómo se haya completado la solicitud: y. `onSuccess` `onError`
La principal ventaja del enfoque de la interfaz de devolución de llamada es que se le permite sondear el objeto `Future` para saber si la solicitud se ha completado. El código puede iniciar inmediatamente su siguiente actividad y usar el SDK para llamar a su identificador en el momento oportuno.
```
import com.amazonaws.services.lambda.AWSLambdaAsync;
import com.amazonaws.services.lambda.AWSLambdaAsyncClientBuilder;
import com.amazonaws.services.lambda.model.InvokeRequest;
import com.amazonaws.services.lambda.model.InvokeResult;
import com.amazonaws.handlers.AsyncHandler;
import java.nio.ByteBuffer;
import java.util.concurrent.Future;
public class InvokeLambdaFunctionCallback
{
private class AsyncLambdaHandler implements AsyncHandler
{
public void onSuccess(InvokeRequest req, InvokeResult res) {
System.out.println("\nLambda function returned:");
ByteBuffer response_payload = res.getPayload();
System.out.println(new String(response_payload.array()));
System.exit(0);
}
public void onError(Exception e) {
System.out.println(e.getMessage());
System.exit(1);
}
}
public static void main(String[] args)
{
String function_name = "HelloFunction";
String function_input = "{\"who\":\"SDK for Java\"}";
AWSLambdaAsync lambda = AWSLambdaAsyncClientBuilder.defaultClient();
InvokeRequest req = new InvokeRequest()
.withFunctionName(function_name)
.withPayload(ByteBuffer.wrap(function_input.getBytes()));
Future future_res = lambda.invokeAsync(req, new AsyncLambdaHandler());
System.out.print("Waiting for async callback");
while (!future_res.isDone() && !future_res.isCancelled()) {
// perform some other tasks...
try {
Thread.sleep(1000);
}
catch (InterruptedException e) {
System.err.println("Thread.sleep() was interrupted!");
System.exit(0);
}
System.out.print(".");
}
}
}
```
## Prácticas recomendadas
### Ejecución de la devolución de llamada
Su implementación de `AsyncHandler` se ejecuta dentro del grupo de subprocesos propiedad del cliente asíncrono. El código breve que se ejecuta rápidamente es más apropiado para su implementación de `AsyncHandler`. El código de bloqueo o de ejecución prolongada de sus métodos de identificador puede provocar controversia en el grupo de subprocesos usado por el cliente asíncrono y pueden impedir que el cliente ejecute las solicitudes. Si tiene una tarea de ejecución prolongada que debe iniciarse desde una devolución de llamada, permita que la devolución de llamada ejecute su tarea en un nuevo subproceso o en un grupo de subprocesos administrado por su aplicación.
### Configuración del grupo de subprocesos
Los clientes asíncronos del servidor AWS SDK para Java proporcionan un grupo de subprocesos predeterminado que debería funcionar para la mayoría de las aplicaciones. Puede implementar una personalizada [ExecutorService](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/ExecutorService.html)y pasarla a clientes AWS SDK para Java asíncronos para tener un mayor control sobre la forma en que se administran los grupos de subprocesos.
Por ejemplo, puedes proporcionar una `ExecutorService` implementación que utilice una personalización [ThreadFactory](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/ThreadFactory.html)para controlar el nombre de los subprocesos del grupo o para registrar información adicional sobre el uso de los subprocesos.
### Acceso asíncrono
La [TransferManager](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/services/s3/transfer/TransferManager.html)clase del SDK ofrece soporte asíncrono para trabajar con ellos. Amazon S3`TransferManager`gestiona las cargas y descargas asíncronas, proporciona informes detallados sobre el progreso de las transferencias y admite la devolución de llamadas a distintos eventos.
# Registro de llamadas AWS SDK para Java
AWS SDK para Java Está equipado con [Apache Commons Logging](http://commons.apache.org/proper/commons-logging/guide.html), que es una capa de abstracción que permite el uso de cualquiera de los varios sistemas de registro en tiempo de ejecución.
Los sistemas de registro admitidos incluyen Java Logging Framework y Apache Log4j, entre otros. En este tema se muestra cómo utilizar Log4j. Puede utilizar la funcionalidad de registro del SDK sin necesidad de realizar cambios en el código de la aplicación.
Para obtener más información sobre [Log4j](http://logging.apache.org/log4j/2.x/), consulte el [sitio web de Apache](http://www.apache.org/).
**nota**
Este tema se centra en Log4j 1.x. Log4j2 no admite directamente Apache Commons Logging, pero ofrece un adaptador que dirige automáticamente las llamadas de registro a Log4j2 utilizando la interfaz de Apache Commons Logging. Para obtener más información, consulte [Commons Logging Bridge](https://logging.apache.org/log4j/2.x/log4j-jcl.html) en la documentación de Log4j2.
## Descarga del archivo JAR de Log4J
Para utilizar Log4j con el SDK, debe descargar el archivo JAR de Log4j JAR del sitio web de Apache. El SDK no incluye el archivo JAR. Copie el archivo JAR en una ubicación que esté en el classpath.
Log4j usa un archivo de configuración, log4j.properties. A continuación, se muestran ejemplos de archivos de configuración. Copie este archivo de configuración en un directorio del classpath. El archivo JAR de Log4j y el archivo log4j.properties no necesitan estar en el mismo directorio.
El archivo de configuración log4j.properties especifica propiedades, como el [nivel de registro](http://logging.apache.org/log4j/2.x/manual/configuration.html#Loggers), dónde se envía la salida del registro (por ejemplo, [a un archivo o a la consola](http://logging.apache.org/log4j/2.x/manual/appenders.html)) y el [formato de la salida](http://logging.apache.org/log4j/2.x/manual/layouts.html). El nivel de registro es el detalle de la salida que genera el registrador. Log4j admite el concepto de varias *jerarquías* de registro. El nivel de registro se define de forma independiente para cada jerarquía. Las siguientes dos jerarquías de registro están disponibles en AWS SDK para Java:
+ log4j.logger.com.amazonaws
+ log4j.logger.org.apache.http.wire
## Definición del classpath
El archivo JAR de Log4j y el archivo log4j.properties deben estar en el classpath. Si utiliza [Apache Ant](http://ant.apache.org/manual/), establezca el classpath en el elemento `path` en su archivo Ant. El ejemplo siguiente muestra un elemento de la ruta del archivo Ant para el [ejemplo](https://github.com/aws/aws-sdk-java/blob/master/src/samples/AmazonS3/build.xml) de Amazon S3 incluido en el SDK.
```
```
Si utiliza el IDE de Eclipse, puede establecer el classpath abriendo el menú y yendo a **Project (Proyecto)** \$1 **Properties (Propiedades)** \$1 **Java Build Path (Ruta de compilación de Java)**.
## Errores y advertencias específicos del servicio
Le recomendamos que siempre deje la jerarquía del registrador "com.amazonaws" establecida en "WARN" para identificar los mensajes importantes de las bibliotecas cliente. Por ejemplo, si el Amazon S3 cliente detecta que su aplicación no ha cerrado correctamente `InputStream` y podría estar filtrando recursos, el cliente S3 lo notificará mediante un mensaje de advertencia en los registros. Esto también garantiza que se registren los mensajes si el cliente tiene algún problema con el tratamiento de las solicitudes o respuestas.
El siguiente archivo log4j.properties establece `rootLogger` en WARN, lo que hace que se incluyan los mensajes de advertencia y de error de todos los registradores de la jerarquía "com.amazonaws". Otra opción consiste en establecer de forma explícita el registrador com.amazonaws en WARN.
```
log4j.rootLogger=WARN, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
# Or you can explicitly enable WARN and ERROR messages for the {AWS} Java clients
log4j.logger.com.amazonaws=WARN
```
## Registro de resumen de solicitudes y respuestas
Cada solicitud a an Servicio de AWS genera un identificador de AWS solicitud único que resulta útil si tienes algún problema con la forma en que an Servicio de AWS gestiona una solicitud. AWS IDs Se puede acceder a las solicitudes mediante programación a través de los objetos Exception del SDK para cualquier llamada de servicio fallida, y también se pueden informar a través del nivel de registro DEBUG, en el registrador «com.amazonaws.request».
El siguiente archivo log4j.properties permite obtener un resumen de las solicitudes y respuestas, incluida la solicitud. AWS IDs
```
log4j.rootLogger=WARN, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
# Turn on DEBUG logging in com.amazonaws.request to log
# a summary of requests/responses with {AWS} request IDs
log4j.logger.com.amazonaws.request=DEBUG
```
Este es un ejemplo del resultado del registro.
```
2009-12-17 09:53:04,269 [main] DEBUG com.amazonaws.request - Sending
Request: POST https://rds.amazonaws.com / Parameters: (MaxRecords: 20,
Action: DescribeEngineDefaultParameters, SignatureMethod: HmacSHA256,
AWSAccessKeyId: ACCESSKEYID, Version: 2009-10-16, SignatureVersion: 2,
Engine: mysql5.1, Timestamp: 2009-12-17T17:53:04.267Z, Signature:
q963XH63Lcovl5Rr71APlzlye99rmWwT9DfuQaNznkD, ) 2009-12-17 09:53:04,464
[main] DEBUG com.amazonaws.request - Received successful response: 200, {AWS}
Request ID: 694d1242-cee0-c85e-f31f-5dab1ea18bc6 2009-12-17 09:53:04,469
[main] DEBUG com.amazonaws.request - Sending Request: POST
https://rds.amazonaws.com / Parameters: (ResetAllParameters: true, Action:
ResetDBParameterGroup, SignatureMethod: HmacSHA256, DBParameterGroupName:
java-integ-test-param-group-0000000000000, AWSAccessKeyId: ACCESSKEYID,
Version: 2009-10-16, SignatureVersion: 2, Timestamp:
2009-12-17T17:53:04.467Z, Signature:
9WcgfPwTobvLVcpyhbrdN7P7l3uH0oviYQ4yZ+TQjsQ=, )
2009-12-17 09:53:04,646 [main] DEBUG com.amazonaws.request - Received
successful response: 200, {AWS} Request ID:
694d1242-cee0-c85e-f31f-5dab1ea18bc6
```
## Registro detallado en red
En algunos casos, puede resultar útil ver las solicitudes y respuestas exactas que AWS SDK para Java envían y reciben. No deberías habilitar este registro en los sistemas de producción, ya que escribir solicitudes o respuestas de gran tamaño (por ejemplo, un archivo en el que se está cargando Amazon S3) o respuestas puede ralentizar considerablemente la aplicación. Si realmente necesita acceder a esta información, puede habilitarla temporalmente a través del registrador Apache HttpClient 4. La activación del nivel DEBUG en el registrador `org.apache.http.wire` permite registrar todos los datos de las solicitudes y respuestas.
El siguiente archivo log4j.properties activa el registro completo en Apache HttpClient 4 y solo debe activarse temporalmente, ya que puede tener un impacto significativo en el rendimiento de la aplicación.
```
log4j.rootLogger=WARN, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
# Log all HTTP content (headers, parameters, content, etc) for
# all requests and responses. Use caution with this since it can
# be very expensive to log such verbose data!
log4j.logger.org.apache.http.wire=DEBUG
```
## Registro de métricas de latencia
Si está solucionando problemas y desea ver métricas; por ejemplo, qué proceso está tardando más o si es mayor la latencia del cliente o del servidor, el registrador de latencia puede resultarle muy útil. Para habilitar este registrador, configure el registrador `com.amazonaws.latency` en DEBUG.
**nota**
Este registrador solo está disponible si se habilitan las métricas de SDK. Para obtener más información sobre el paquete de métricas de SDK, consulte [Habilitación de métricas para el AWS SDK para Java](generating-sdk-metrics.md).
```
log4j.rootLogger=WARN, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
log4j.logger.com.amazonaws.latency=DEBUG
```
Este es un ejemplo del resultado del registro.
```
com.amazonaws.latency - ServiceName=[{S3}], StatusCode=[200],
ServiceEndpoint=[https://list-objects-integ-test-test.s3.amazonaws.com],
RequestType=[ListObjectsV2Request], AWSRequestID=[REQUESTID], HttpClientPoolPendingCount=0,
RetryCapacityConsumed=0, HttpClientPoolAvailableCount=0, RequestCount=1,
HttpClientPoolLeasedCount=0, ResponseProcessingTime=[52.154], ClientExecuteTime=[487.041],
HttpClientSendRequestTime=[192.931], HttpRequestTime=[431.652], RequestSigningTime=[0.357],
CredentialsRequestTime=[0.011, 0.001], HttpClientReceiveResponseTime=[146.272]
```
# Configuración de los clientes
AWS SDK para Java Esto le permite cambiar la configuración predeterminada del cliente, lo que resulta útil cuando desea:
+ Conectarse a Internet a través del proxy
+ Cambiar la configuración del transporte HTTP, como el tiempo de espera y los reintentos de solicitud de conexión
+ Especificar sugerencias del tamaño del búfer del socket TCP
## Configuración del proxy
Al crear un objeto de cliente, puede pasar un [ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html)objeto opcional para personalizar la configuración del cliente.
Si se conecta a Internet a través de un servidor proxy, tendrá que configurar las opciones del servidor proxy (host del proxy, puerto y nombre de usuario/contraseña) a través del objeto `ClientConfiguration`.
## Configuración del transporte HTTP
Puede configurar varias opciones de transporte HTTP mediante el [ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html)objeto. De vez en cuando se añaden nuevas opciones; para ver la lista completa de opciones que puede recuperar o configurar, consulte la referencia de la AWS SDK para Java API.
**nota**
Cada uno de los valores configurables tiene un valor predeterminado definido por una constante. Para obtener una lista de los valores constantes de`ClientConfiguration`, consulte [Valores de campo constantes](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/constant-values.html) en la referencia de la AWS SDK para Java API.
### Número máximo de conexiones
Puede establecer el número máximo permitido de conexiones HTTP abiertas mediante [ClientConfiguration. setMaxConnections](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setMaxConnections-int-)método.
**importante**
Para evitar problemas de conexión y un desempeño deficiente, establezca el número máximo de conexiones en el número de conexiones simultáneas. Para ver el valor máximo de conexiones predeterminado, consulta [los valores de campo constantes](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/constant-values.html) en la referencia de la AWS SDK para Java API.
### Tiempos de espera y tratamiento de errores
Puede configurar opciones relacionadas con los tiempos de espera y el tratamiento de errores con conexiones HTTP.
+ **Tiempo de espera de conexión**
El tiempo de espera de conexión es la cantidad de tiempo (en milisegundos) que la conexión HTTP esperará a que se establezca una conexión antes de desistir. El valor predeterminado es 10 000 ms.
Para establecer este valor usted mismo, utilice [ClientConfiguration. setConnectionTimeout](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setConnectionTimeout-int-)método.
+ **Tiempo de vida (TTL) de la conexión**
De forma predeterminada, el SDK intentará volver a utilizar las conexiones HTTP siempre que sea posible. En situaciones en las que no es posible establecer una conexión con un servidor que está fuera de servicio, disponer de un TTL finito puede ayudarle a recuperar la aplicación. Por ejemplo, si configura un TTL de 15 minutos, se asegurará de que aunque tenga establecida una conexión con un servidor que está experimentando problemas, se restablecerá una conexión con un nuevo servidor en un plazo de 15 minutos.
Para configurar el TTL de la conexión HTTP, utilice el método [ClientConfiguration.setConnectionTTL](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setConnectionTTL-long-).
+ **Número máximo de reintentos con error**
El número máximo predeterminado de reintentos para errores recuperables es 3. [Puede establecer un valor diferente mediante. ClientConfiguration setMaxErrorMétodo de reintento](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setMaxErrorRetry-int-).
### Dirección local
[Para establecer la dirección local a la que se enlazará el cliente HTTP, utiliceClientConfiguration. setLocalAddress](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html#setLocalAddress-java.net.InetAddress-).
## Sugerencias del tamaño del búfer del socket TCP
Los usuarios avanzados que deseen ajustar los parámetros TCP de bajo nivel también pueden configurar sugerencias sobre el tamaño del búfer TCP a través del [ClientConfiguration](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/ClientConfiguration.html)objeto. La mayoría de los usuarios nunca necesitarás ajustar estos valores, pero se proporcionan para los usuarios avanzados.
Los tamaños del búfer TCP óptimos para una aplicación dependen en gran medida de la red y de la configuración y funciones del sistema operativo. Por ejemplo, la mayoría de los sistemas operativos modernos proporcionan lógica de ajuste automático para los tamaños del búfer TCP. Esto puede afectar considerablemente al desempeño de las conexiones TCP que se mantienen abiertas el tiempo suficiente para que el ajuste automático optimice los tamaños del búfer.
Los tamaños de búfer grandes (p. ej., 2 MB) permiten al sistema operativo almacenar más datos en memoria sin requerir que el servidor remoto confirme la recepción de esa información y pueden ser especialmente útiles cuando la red tiene alta latencia.
Esto es solo una *sugerencia* y puede que el sistema operativo no la aplique. Cuando se utiliza esta opción, los usuarios deben comprobar siempre los límites y valores predeterminados del sistema operativo. La mayoría de los sistemas operativos tienen un límite máximo de tamaño del búfer TCP configurado y no permiten que se supere ese límite a menos que se aumente explícitamente el límite máximo del tamaño del búfer TCP.
Hay muchos recursos disponibles que le pueden ayudar a configurar los tamaños del búfer TCP y las opciones de TCP específicas del sistema operativo, incluidas las siguientes:
+ [Host Tuning](http://fasterdata.es.net/host-tuning/)
# Política de control de acceso
AWS *las políticas de control de acceso* le permiten especificar controles de acceso detallados en sus recursos. AWS Una política de control de acceso se compone de un conjunto de *instrucciones*, con el siguiente formato:
La *cuenta A* tiene permiso para realizar la *acción B* en el *recurso C* donde se aplica la *condición D*.
Donde:
+ *A* es el *principal*: el Cuenta de AWS que solicita el acceso o la modificación de uno de sus recursos. AWS
+ *B* es la *acción*: la forma en que se accede a un AWS recurso o se lo modifica, por ejemplo, enviando un mensaje a una Amazon SQS cola o almacenando un objeto en un Amazon S3 depósito.
+ *C* es el *recurso*: la AWS entidad a la que el principal quiere acceder, como una Amazon SQS cola o un objeto almacenado. Amazon S3
+ *D* es un *conjunto de condiciones*: las limitaciones opcionales que se especifican para permitir o denegar el acceso al recurso de la entidad principal. Hay muchas condiciones expresivas disponibles, algunas específicas de cada servicio. Por ejemplo, puede utilizar condiciones de fecha para permitir el acceso a los recursos únicamente después o antes de un momento específico.
## Amazon S3 Ejemplo
En el siguiente ejemplo, se muestra una política que permite a cualquier persona acceder a todos los objetos de un depósito, pero restringe el acceso a la carga de objetos a ese depósito a dos tipos Cuenta de AWS específicos (además de la cuenta del propietario del depósito).
```
Statement allowPublicReadStatement = new Statement(Effect.Allow)
.withPrincipals(Principal.AllUsers)
.withActions(S3Actions.GetObject)
.withResources(new S3ObjectResource(myBucketName, "*"));
Statement allowRestrictedWriteStatement = new Statement(Effect.Allow)
.withPrincipals(new Principal("123456789"), new Principal("876543210"))
.withActions(S3Actions.PutObject)
.withResources(new S3ObjectResource(myBucketName, "*"));
Policy policy = new Policy()
.withStatements(allowPublicReadStatement, allowRestrictedWriteStatement);
AmazonS3 s3 = AmazonS3ClientBuilder.defaultClient();
s3.setBucketPolicy(myBucketName, policy.toJson());
```
## Amazon SQS Ejemplo
Un uso común de las políticas es autorizar una Amazon SQS cola para recibir mensajes de un tema de Amazon SNS.
```
Policy policy = new Policy().withStatements(
new Statement(Effect.Allow)
.withPrincipals(Principal.AllUsers)
.withActions(SQSActions.SendMessage)
.withConditions(ConditionFactory.newSourceArnCondition(myTopicArn)));
Map queueAttributes = new HashMap();
queueAttributes.put(QueueAttributeName.Policy.toString(), policy.toJson());
AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();
sqs.setQueueAttributes(new SetQueueAttributesRequest(myQueueUrl, queueAttributes));
```
## Ejemplo de Amazon SNS
Algunos servicios ofrecen condiciones adicionales que pueden utilizarse en las políticas. Amazon SNS establece condiciones para permitir o denegar suscripciones a temas de SNS según el protocolo (por ejemplo, correo electrónico, HTTP, HTTPS Amazon SQS) y el punto final (por ejemplo, dirección de correo electrónico, URL, Amazon SQS ARN) de la solicitud de suscripción a un tema.
```
Condition endpointCondition =
SNSConditionFactory.newEndpointCondition("*@mycompany.com");
Policy policy = new Policy().withStatements(
new Statement(Effect.Allow)
.withPrincipals(Principal.AllUsers)
.withActions(SNSActions.Subscribe)
.withConditions(endpointCondition));
AmazonSNS sns = AmazonSNSClientBuilder.defaultClient();
sns.setTopicAttributes(
new SetTopicAttributesRequest(myTopicArn, "Policy", policy.toJson()));
```
# Configurar el TTL de JVM para las búsquedas de nombres DNS
La máquina virtual de Java (JVM) almacena en caché las búsquedas de nombres DNS. Cuando la JVM convierte un nombre de host en una dirección IP, guarda en caché la dirección IP durante un período de tiempo específico, conocido como TTL. *time-to-live*
Como AWS los recursos utilizan entradas de nombres DNS que cambian de vez en cuando, le recomendamos que configure la JVM con un valor TTL de 5 segundos. Con esto se asegurará de que cuando cambie la dirección IP de un recurso, su aplicación pueda recibir y utilizar la nueva dirección IP del recurso volviendo a consultar el DNS.
En algunas configuraciones de Java, el TTL predeterminado de JVM está establecido de forma que *nunca* se actualicen las entradas DNS hasta que se reinicie la JVM. Por lo tanto, si la dirección IP de un AWS recurso cambia mientras la aplicación aún se está ejecutando, no podrá usar ese recurso hasta que *reinicie manualmente la JVM y se actualice* la información de IP almacenada en caché. En este caso, es fundamental establecer el TTL de la JVM de forma que actualice periódicamente la información de las direcciones IP almacenada en caché.
## Cómo configurar el TTL de JVM
[Para modificar el TTL de la JVM, defina el valor de la propiedad de seguridad networkaddress.cache.ttl.](https://docs.oracle.com/en/java/javase/17/core/java-networking.html#GUID-A680DADB-C4C1-40F1-B568-D9A97C917F5D) Tenga en cuenta que `networkaddress.cache.ttl` es una propiedad de *seguridad, no una propiedad* del sistema, es decir, no se puede configurar con el indicador de línea de comandos. `-D`
### Opción 1: configúrelo mediante programación en su aplicación
Llama al [https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/security/Security.html](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/security/Security.html)principio de la aplicación, antes de crear cualquier cliente AWS del SDK y antes de realizar cualquier solicitud de red:
```
import java.security.Security;
public class MyApplication {
public static void main(String[] args) {
Security.setProperty("networkaddress.cache.ttl", "5");
// ... create SDK clients and run application
}
}
```
### Opción 2: configúrelo en el archivo java.security
Establezca la `networkaddress.cache.ttl` propiedad en el `$JAVA_HOME/jre/lib/security/java.security` archivo para Java 8 o en `$JAVA_HOME/conf/security/java.security` el archivo para Java 11 o superior.
A continuación se ofrece muestra un fragmento de archivo `java.security` que muestra la caché de TTL configurada en 5 segundos.
```
#
# The Java-level namelookup cache policy for successful lookups:
#
# any negative value: caching forever
# any positive value: the number of seconds to cache an address for
# zero: do not cache
#
...
networkaddress.cache.ttl=5
...
```
Todas las aplicaciones que se ejecutan en la JVM representada por la variable de `$JAVA_HOME` entorno utilizan esta configuración.
### Opción 3: Utilice la opción alternativa de propiedades del sistema JDK (línea de comandos)
Si no puede modificar la configuración o el código de seguridad, puede utilizar las propiedades del sistema JDK. Actúan como alternativas si no se ha definido ninguna propiedad de seguridad.
+ `sun.net.inetaddr.ttl`— Controla las búsquedas correctas (TTL positivo)
+ `sun.net.inetaddr.negative.ttl`— Controla las búsquedas fallidas (TTL negativo)
```
java -Dsun.net.inetaddr.ttl=5 -Dsun.net.inetaddr.negative.ttl=1 -jar myapp.jar
```
**nota**
Se trata de propiedades internas del JDK documentadas en la referencia de [Oracle Java 8 Networking Properties como propiedades](https://docs.oracle.com/javase/8/docs/technotes/guides/net/properties.html) privadas que «es posible que no se admitan en futuras versiones». Utilice las opciones 1 y 2 siempre que sea posible.
# Habilitación de métricas para AWS SDK para Java
AWS SDK para Java Pueden generar métricas para la visualización y el monitoreo con [Amazon CloudWatch](https://aws.amazon.com/cloudwatch/) que midan:
+ el rendimiento de su aplicación al acceder AWS
+ el rendimiento de tu JVMs cuando se usa con AWS
+ los detalles del entorno en tiempo de ejecución, como la memoria del montón, el número de subprocesos y los descriptores de archivos abiertos
## Cómo habilitar la generación de métricas de SDK
Debe agregar la siguiente dependencia de Maven para permitir que el SDK envíe métricas a CloudWatch.
```
com.amazonaws
aws-java-sdk-bom
1.12.490*
pom
import
com.amazonaws
aws-java-sdk-cloudwatchmetrics
provided
```
\$1Sustituya el número de versión por la última versión del SDK disponible en [Maven Central](https://central.sonatype.com/artifact/com.amazonaws/aws-java-sdk-bom).
AWS SDK para Java las métricas están *deshabilitadas de forma predeterminada*. Para habilitarlas en el entorno de desarrollo local, incluya una propiedad del sistema que apunte al archivo de credenciales de seguridad de AWS cuando inicie la JVM. Por ejemplo:
```
-Dcom.amazonaws.sdk.enableDefaultMetrics=credentialFile=/path/aws.properties
```
Debe especificar la ruta al archivo de credenciales para que el SDK pueda cargar los puntos de datos recopilados CloudWatch para analizarlos más adelante.
**nota**
Si accedes AWS desde una Amazon EC2 instancia mediante el servicio de metadatos de la Amazon EC2 instancia, no necesitas especificar un archivo de credenciales. En este caso, solo debe especificar:
```
-Dcom.amazonaws.sdk.enableDefaultMetrics
```
*Todas las métricas capturadas por el AWS SDK para Java se encuentran en el espacio de nombres **AWSSDK/Java** y se cargan en la región CloudWatch predeterminada (us-east-1).* Para cambiar la región, especifíquela usando el atributo `cloudwatchRegion` en la propiedad del sistema. Por ejemplo, para establecer la CloudWatch región en *us-east-1*, usa:
```
-Dcom.amazonaws.sdk.enableDefaultMetrics=credentialFile=/path/aws.properties,cloudwatchRegion={region_api_default}
```
Una vez que active la función, cada vez que se reciba una solicitud de servicio AWS desde el AWS SDK para Java, se generarán puntos de datos métricos, se pondrán en cola para obtener un resumen estadístico y se cargarán de forma asíncrona aproximadamente una vez cada minuto. CloudWatch Una vez que se hayan cargado las métricas, puede consultarlas mediante la consola de administración de [Consola de administración de AWS](https://console.aws.amazon.com/console/home) y definir alarmas para posibles problemas como fuga de memoria, fuga de descriptores de archivos, etc.
## Tipos de métricas disponibles
El conjunto predeterminado de métricas se divide en tres categorías principales:
AWS Solicita métricas
+ Cubren áreas como la latencia de la solicitud/respuesta HTTP, el número de solicitudes, las excepciones y los reintentos.
![\[RequestMetric 131111\]](http://docs.aws.amazon.com/es_es/sdk-for-java/v1/developer-guide/images/RequestMetric-131111.png)
Servicio de AWS Métricas
+ Incluya datos Servicio de AWS específicos, como el rendimiento y el recuento de bytes de las cargas y descargas de S3.
![\[ServiceMetric 131111\]](http://docs.aws.amazon.com/es_es/sdk-for-java/v1/developer-guide/images/ServiceMetric-131111.png)
Métricas de la máquina
+ Cubren el entorno en tiempo de ejecución, como la memoria del montón, el número de subprocesos y los descriptores de archivos abiertos.
![\[MachineMetric 131111\]](http://docs.aws.amazon.com/es_es/sdk-for-java/v1/developer-guide/images/MachineMetric-131111.png)
Si desea excluir las métricas de la máquina, añada `excludeMachineMetrics` a la propiedad del sistema:
```
-Dcom.amazonaws.sdk.enableDefaultMetrics=credentialFile=/path/aws.properties,excludeMachineMetrics
```
## Más información
+ Consulte [amazonaws/metrics package summary](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/metrics/package-summary.html) para ver una lista completa de los principales tipos de métricas predefinidas.
+ Obtenga información sobre cómo trabajar con el CloudWatch uso del AWS SDK para Java en los [CloudWatch ejemplos de uso del AWS SDK para Java](examples-cloudwatch.md).
+ Obtenga más información sobre el ajuste del rendimiento en la entrada [del blog Tuning the AWS SDK para Java to Improve Resiliency.](https://aws.amazon.com/blogs/developer/tuning-the-aws-sdk-for-java-to-improve-resiliency)