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.
# Uso de proveedores de credenciales en el AWS SDK for Java 2.x
La función de un proveedor de credenciales en el AWS SDK for Java 2.x es obtener y suministrar credenciales a los Servicio de AWS clientes del SDK. El SDK utiliza las credenciales que obtiene para autenticarse en el servicio mediante la firma criptográfica de cada solicitud. Las credenciales suelen consistir en claves de acceso: un ID de clave de acceso y una clave de acceso secreta juntas.
Cuando utilizas credenciales temporales, que se utilizan cuando configuras la configuración del [proveedor de tokens de SSO](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config) o configuras tu tiempo de ejecución para que [asuma una función de IAM (AWS Identity and Access Management)](https://docs.aws.amazon.com/sdkref/latest/guide/access-assume-role.html#credOrSourceAssumeRole), por ejemplo, se añade un token de sesión a las claves de acceso, lo que proporciona un acceso a los recursos por tiempo limitado. AWS
En este tema se describen varias formas de permitir que el SDK acceda a las credenciales.
**Topics**
+ [Trabajo de desarrollo interactivo](credentials-temporary.md)
+ [Cadena predeterminada de proveedores de credenciales](credentials-chain.md)
+ [Almacenamiento en caché de las credenciales](credential-caching.md)
+ [Especificación de un determinado proveedor de credenciales](credentials-providers.md)
+ [Uso de perfiles de configuración compartidos](credentials-profiles.md)
+ [Uso de un proceso externo](credentials-process.md)
+ [Suministro de credenciales en código](credentials-explicit.md)
+ [Lectura de credenciales de roles de IAM en Amazon EC2](ec2-iam-roles.md)
# Acceda a las credenciales para el trabajo de desarrollo interactivo mediante AWS SDK for Java 2.x
Para aumentar la seguridad, se AWS recomienda configurar el SDK para Java para que [utilice credenciales temporales en lugar de credenciales](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) de larga duración. Las credenciales temporales consisten en claves de acceso (id de clave de acceso y clave de acceso secreta) y un token de sesión.
Dispone de varios métodos para trabajar con credenciales temporales. El método que utilice y, por tanto, la configuración que proporcione al SDK dependen de su caso de uso.
Cuando realice trabajos de desarrollo interactivo con el SDK de Java, le recomendamos que utilice las credenciales de inicio de sesión de AWS la consola.
## Utilizar credenciales de inicio de sesión de la consola
Puede usar sus credenciales de inicio de sesión AWS de Management Console actuales para acceder a AWS los servicios mediante programación. Tras un flujo de autenticación basado en un navegador, AWS genera credenciales temporales que funcionan en todas las herramientas de desarrollo locales, como el SDK for Java 2.x AWS CLI y el SDK for Java 2.x.
Con este proceso, puede autenticarse con las credenciales raíz creadas durante la configuración inicial de la cuenta, un usuario de IAM o una identidad federada de su proveedor de identidad, y este gestiona AWS CLI automáticamente las credenciales temporales por usted. Este enfoque mejora la seguridad al eliminar la necesidad de almacenar localmente las credenciales a largo plazo.
Al ejecutar el comando `aws login`, puede seleccionar una de las sesiones de consola activas o iniciar sesión mediante el flujo de autenticación basado en el navegador, lo que generará credenciales temporales automáticamente. El SDK for Java 2.x actualizará automáticamente estas credenciales durante un máximo de 12 horas.
**importante**
Además de la configuración que establezca en el archivo de configuración compartido que funciona para todos los proyectos, cada proyecto Java individual requiere la siguiente dependencia en el archivo Maven`pom.xml`:
```
software.amazon.awssdk
signin
```
La `signin` dependencia proporciona el código que permite al SDK para Java 2.x acceder a las credenciales de inicio de sesión de la consola y utilizarlas.
Para obtener más información sobre los requisitos previos para iniciar y cerrar sesión, consulte [Iniciar sesión para el desarrollo AWS local con credenciales de consola](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sign-in.html) en la Guía de referencia del *AWS SDK y las herramientas*.
## Single-sign-on Enfoque
Al realizar trabajos de desarrollo interactivo con el SDK de Java, también puede utilizar el enfoque de inicio de sesión único. Este método requiere los siguientes recursos:
+ [Configuración a través del IAM Identity Center](get-started-auth.md#setup-auth)
+ [Configure un perfil en el archivo de configuración AWS compartido](get-started-auth.md#setup-credentials)
+ usar AWS CLI y [ejecutar un comando](get-started-auth.md#setup-login-sso) para iniciar sesión y crear una sesión activa
### Configuración del Identity Center de IAM
Al configurar el SDK para utilizar el acceso de inicio de sesión único al IAM Identity Center, tal como se describe en [Descripción general de la configuración](setup.md#setup-overview) de esta guía, el SDK utiliza las credenciales temporales.
El SDK utiliza el token de acceso al IAM Identity Center para acceder al rol de IAM definido con la configuración `sso_role_name` del archivo `config`. El SDK asume este rol de IAM y recupera las credenciales temporales para firmar solicitudes de Servicio de AWS .
Para obtener más información sobre cómo el SDK obtiene las credenciales temporales de la configuración, consulte la sección Cómo [entender la autenticación del IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html) de la Guía de referencia sobre herramientas AWS SDKs y herramientas.
**importante**
Además de la configuración que establezca en el archivo de `config` compartido que funciona para todos los proyectos, cada proyecto de Java individual requiere las siguientes dependencias en el archivo `pom.xml`de Maven:
```
software.amazon.awssdk
sso
software.amazon.awssdk
ssooidc
```
Las dependencias `sso` y `ssooidc` proporcionan el código que permite que el SDK para Java 2.x acceda a credenciales temporales.
### Recupere las credenciales temporales del portal de AWS acceso
Como alternativa a la configuración de inicio de sesión único del IAM Identity Center, puede copiar y utilizar las credenciales temporales disponibles en el AWS portal de acceso. Puede utilizar las credenciales temporales en un perfil o como valores para las propiedades del sistema y las variables de entorno.
**Configurar un archivo local de credenciales para las credenciales temporales**
1. [Crear un archivo de credenciales compartido](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html).
1. En el archivo de credenciales, pegue el siguiente texto de marcador de posición hasta que pegue las credenciales temporales que funcionen.
```
[default]
aws_access_key_id=
aws_secret_access_key=
aws_session_token=
```
1. Guarde el archivo. El archivo `~/.aws/credentials` debería existir ahora en su sistema de desarrollo local. Este archivo contiene el [perfil [predeterminado]](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile) que el SDK para Java utiliza si no se especifica un perfil con nombre específico.
1. [Inicie sesión en el portal de acceso AWS](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosignin.html)
1. Siga estas instrucciones que aparecen en el apartado [Actualización manual de credenciales](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials) para copiar las credenciales del rol de IAM del portal de AWS acceso.
1. Para el paso 2 de las instrucciones vinculadas, elija `Access keys` como nombre del rol de IAM que le concede acceso para sus necesidades de desarrollo. **Este rol suele tener un nombre similar **PowerUserAccess**al de Desarrollador.**
1. En el cuadro de diálogo modal, seleccione su sistema operativo y copie el contenido de **Añadir un perfil al archivo de credenciales de AWS **.
1. Pegue las credenciales copiadas en su archivo `credentials` local y elimine el nombre del perfil generado. Su archivo debería parecerse a lo siguiente.
```
[default]
aws_access_key_id=AKIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token=IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
1. Guarde el archivo `credentials`.
Cuando el SDK para Java cree un cliente de servicio, accederá a estas credenciales temporales y las utilizará para cada solicitud. La configuración del rol de IAM elegido en el paso 5a determina el [tiempo de validez de las credenciales temporales](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosessionduration.html). La duración máxima es de doce horas.
Cuando las credenciales temporales caduquen, repita los pasos del 4 al 7.
# Cadena de proveedores de credenciales predeterminada en el AWS SDK for Java 2.x
La cadena de proveedores de credenciales predeterminada busca AWS SDK for Java 2.x automáticamente las AWS credenciales en una secuencia predefinida de ubicaciones, lo que permite a las aplicaciones autenticarse Servicios de AWS sin especificar explícitamente las fuentes de credenciales.
La clase implementa la cadena de proveedores de credenciales predeterminada. [DefaultCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/DefaultCredentialsProvider.html) Delega secuencialmente en otros proveedores de credenciales las implementaciones que comprueban la configuración en varias ubicaciones. El primer proveedor de credenciales que puede encontrar todos los elementos de configuración necesarios hace que la cadena finalice.
Para usar la cadena de proveedores de credenciales predeterminados para proporcionar las credenciales temporales, cree un compilador de clientes de servicio, pero no especifique un proveedor de credenciales. El siguiente fragmento de código crea una `DynamoDbClient` que utiliza la cadena de proveedores de credenciales predeterminados para localizar y recuperar los valores de configuración.
```
// Any external Region configuration is overridden.
// The SDK uses the default credentials provider chain because no specific credentials provider is specified.
Region region = Region.US_WEST_2;
DynamoDbClient ddb =
DynamoDbClient.builder()
.region(region)
.build();
```
## Orden de recuperación de la configuración de credenciales
La cadena predeterminada de proveedores de credenciales del SDK para Java 2.x busca la configuración en su entorno mediante una secuencia predefinida.
1. Propiedades del sistema Java
+ El SDK usa la [SystemPropertyCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/SystemPropertyCredentialsProvider.html)clase para cargar credenciales temporales desde las propiedades del sistema `aws.accessKeyId``aws.secretAccessKey`, y `aws.sessionToken` Java.
**nota**
Para obtener información sobre cómo configurar las propiedades del sistema Java, consulte el tutorial *Propiedades del sistema* en el sitio web oficial de [tutoriales de Java](https://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html).
1. Variables de entorno
+ El SDK usa la [EnvironmentVariableCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/EnvironmentVariableCredentialsProvider.html)clase para cargar credenciales temporales de las variables de `AWS_SESSION_TOKEN` entorno `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`, y.
1. Token de identidad web y ARN del rol de IAM
+ El SDK usa la [WebIdentityTokenFileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/WebIdentityTokenFileCredentialsProvider.html)clase para cargar las credenciales asumiendo un rol mediante un token de identidad web.
+ El proveedor de credenciales busca las siguientes variables de entorno o propiedades del sistema JVM:
+ `AWS_WEB_IDENTITY_TOKEN_FILE or aws.webIdentityTokenFile`
+ `AWS_ROLE_ARN` o `aws.roleArn`
+ `AWS_ROLE_SESSION_NAME` o `aws.roleSessionName` (opcional)
+ Una vez que el SDK adquiere los valores, llama al AWS Security Token Service (STS) y utiliza las credenciales temporales que devuelve para firmar las solicitudes.
+ Los entornos de ejecución, como Amazon Elastic Kubernetes Service (EKS), ponen automáticamente a disposición los tokens de identidad web, lo que permite AWS SDKs a las aplicaciones obtener credenciales temporales. AWS
1. Los archivos compartidos `credentials` y `config`
+ El SDK los utiliza [ProfileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProfileCredentialsProvider.html)para cargar la configuración de inicio de sesión único o las credenciales temporales del `[default]` perfil de IAM Identity Center en los archivos AND compartidos. `credentials` `config`
La guía de referencia de AWS SDKs and Tools contiene [información detallada](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html#idccredres) sobre cómo funciona el SDK para Java con el token de inicio de sesión único del IAM Identity Center para obtener las credenciales temporales que el SDK utiliza para llamar. Servicios de AWS
**nota**
Los `config` archivos `credentials` y los comparten varias AWS SDKs herramientas. Para obtener más información, consulte [The. aws/credentials and .aws/config](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html)archivos en la Guía de referencia de AWS SDKs and Tools.
+ Dado que un perfil de los archivos compartidos `credentials` y `config` puede contener muchos conjuntos distintos de ajustes, el `ProfileCredentialsProvider` delega en otros proveedores la tarea de buscar los ajustes en el perfil de `[default]`:
+ **Credenciales de token de identidad web** (clase `WebIdentityTokenCredentialsProvider`): cuando el perfil contiene `role_arn` y `web_identity_token_file`.
+ **Credenciales de SSO** (clase`SsoCredentialsProvider`): cuando el perfil contiene propiedades relacionadas con SSO, como `sso_role_name`, `sso_account_id`.
+ **Credenciales basadas en roles con perfil de origen** (clase `StsAssumeRoleCredentialsProvider`): cuando el perfil contiene `role_arn` y `source_profile`.
+ **Credenciales basadas en roles con origen de credenciales** (clase `StsAssumeRoleWithSourceCredentialsProvider`): cuando el perfil contiene `role_arn` y `credential_source`.
+ Cuando `credential_source = Environment`: utiliza una cadena de `SystemPropertyCredentialsProvider` y `EnvironmentVariableCredentialsProvider`
+ Cuando `credential_source = Ec2InstanceMetadata`: utiliza `InstanceProfileCredentialsProvider`
+ Cuando `credential_source = EcsContainer`: utiliza `ContainerCredentialsProvider`
+ **Credenciales de inicio de sesión en la consola** (clase`LoginCredentialsProvider`): cuando el perfil contiene `login_session`
+ **Credenciales de proceso** (clase `ProcessCredentialsProvider`): cuando el perfil contiene `credential_process`.
+ **Credenciales de sesión** (clase `StaticSessionCredentialsProvider`): cuando el perfil contiene `aws_access_key_id`, `aws_secret_access_key` y `aws_session_token`.
+ **Credenciales básicas** (clase `StaticCredentialsProvider`): cuando el perfil contiene `aws_access_key_id` y `aws_secret_access_key`.
1. Amazon ECS credenciales del contenedor
+ El SDK usa la [ContainerCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ContainerCredentialsProvider.html)clase para cargar credenciales temporales mediante las siguientes variables de entorno:
1. `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` o `AWS_CONTAINER_CREDENTIALS_FULL_URI`
1. `AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE` o `AWS_CONTAINER_AUTHORIZATION_TOKEN`
El agente contenedor de ECS establece automáticamente la variable de entorno `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`, que apunta al punto de conexión de credenciales de ECS. Las demás variables de entorno suelen configurarse en escenarios específicos en los que no se utiliza el punto de conexión de credenciales de ECS estándar.
1. Amazon EC2 credenciales proporcionadas por el rol de IAM de instancia
+ El SDK usa la [InstanceProfileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/InstanceProfileCredentialsProvider.html)clase para cargar credenciales temporales desde el Amazon EC2 servicio de metadatos.
1. Si el SDK no encuentra los ajustes de configuración necesarios siguiendo todos los pasos enumerados anteriormente, lanza una excepción con una salida similar a la siguiente:
```
software.amazon.awssdk.core.exception.SdkClientException: Unable to load credentials from any of the providers
in the chain AwsCredentialsProviderChain(credentialsProviders=[SystemPropertyCredentialsProvider(),
EnvironmentVariableCredentialsProvider(), WebIdentityTokenCredentialsProvider(), ProfileCredentialsProvider(),
ContainerCredentialsProvider(), InstanceProfileCredentialsProvider()])
```
## Uso del `DefaultCredentialsProvider` in código
Puede utilizar explícitamente la cadena de proveedores de credenciales predeterminados en el código. Esto equivale funcionalmente a no especificar ningún proveedor de credenciales, ya que el SDK usa `DefaultCredentialsProvider` de forma predeterminada. Sin embargo, su uso explícito puede hacer que el código sea más legible y autodocumentado. Muestra claramente su intención de utilizar la cadena de credenciales predeterminadas.
```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
public class ExplicitDefaultCredentialsExample {
public static void main(String[] args) {
// Explicitly create the DefaultCredentialsProvider.
DefaultCredentialsProvider defaultCredentialsProvider = DefaultCredentialsProvider
.builder().build();
// Use it with any service client.
S3Client s3Client = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(defaultCredentialsProvider)
.build();
// Now you can use the client with the default credentials chain.
s3Client.listBuckets();
}
}
```
Al crear el proveedor de credenciales predeterminado, puede proporcionar más configuraciones:
```
DefaultCredentialsProvider customizedProvider = DefaultCredentialsProvider.builder()
.profileName("custom-profile") // Use a specific profile if the chain gets to the `ProfileCredentialsProvider` stage.
.asyncCredentialUpdateEnabled(true) // Enable async credential updates.
.build();
```
Este método le brinda más control y, al mismo tiempo, le brinda la comodidad de la cadena de credenciales predeterminadas.
# Almacenamiento en caché de credenciales en el AWS SDK for Java 2.x
AWS SDK for Java 2.x Implementa el almacenamiento en caché de credenciales para mejorar el rendimiento y reducir las llamadas a las fuentes de credenciales. En esta sección se explica cómo funciona el almacenamiento en caché de credenciales y cómo puede configurarlo para sus aplicaciones.
## Descripción del almacenamiento en caché de proveedores de credenciales
Los proveedores de credenciales del SDK para Java 2.x utilizan diferentes estrategias de almacenamiento en caché:
+ **Almacenamiento interno de credenciales en caché**: muchos proveedores almacenan en caché las credenciales que recuperan.
+ **Actualización automática**: los proveedores con credenciales almacenadas en caché implementan mecanismos de actualización.
### Proveedores con almacenamiento interno de credenciales en caché
Los siguientes proveedores de credenciales almacenan internamente credenciales en caché, incluso cuando se crean nuevas instancias:
+ **Proveedor de credenciales del perfil de instancia**: almacena en caché las credenciales del servicio de metadatos de Amazon EC2.
+ **Proveedor de credenciales del contenedor**: almacena en caché las credenciales del punto de conexión de metadatos del contenedor.
+ **Proveedores basados en STS**: almacenan en caché las credenciales temporales de AWS Security Token Service (STS).
+ **Proveedores de tokens de identidad web**: almacenan en caché las credenciales obtenidas de los tokens de identidad web.
+ **Proveedor de credenciales de procesos**: almacena en caché las credenciales de procesos externos.
### Proveedores sin almacenamiento interno en caché
Los siguientes proveedores no implementan el almacenamiento interno en caché:
+ **Proveedor de credenciales de variables de entorno**
+ **Proveedor de credenciales de propiedades del sistema**
+ **Proveedor de credenciales estáticas**
## Configuración del almacenamiento en caché de credenciales
Puede personalizar el comportamiento del almacenamiento en caché al crear proveedores de credenciales:
### Tiempo de obsolescencia
Controla cuándo se consideran obsoletas las credenciales y deben actualizarse:
```
.staleTime(Duration.ofMinutes(2)) // Consider stale 2 minutes before expiration.
```
### Tiempo de captura previa
Determina cuándo empezar a actualizar las credenciales antes de que caduquen:
```
.prefetchTime(Duration.ofMinutes(10)) // Start refresh 10 minutes before expiration.
```
### Actualizaciones asincrónicas
Habilita la actualización de credenciales en segundo plano:
```
.asyncCredentialUpdateEnabled(true) // Refresh credentials in background thread.
```
### Duración de la sesión
En el caso de los proveedores basados en STS, controla el tiempo que permanecen válidas las credenciales temporales:
```
.refreshRequest(r -> r.durationSeconds(3600)) // 1 hour session.
```
## Ejemplo de configuración de credenciales de almacenamiento en caché
Como ejemplo de configuración del almacenamiento en caché para la implementación de proveedores de credenciales, es recomendable que el SDK utilice un subproceso en segundo plano para recuperar previamente (por adelantado) las credenciales antes de que caduquen. De esta forma, puede evitar la llamada bloqueante que recupera credenciales nuevas.
A continuación se muestra un ejemplo que crea un `[StsAssumeRoleCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsAssumeRoleCredentialsProvider.html)` que utiliza un subproceso en segundo plano para capturar previamente credenciales estableciendo la propiedad `[asyncCredentialUpdateEnabled](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsCredentialsProvider.BaseBuilder.html#asyncCredentialUpdateEnabled(java.lang.Boolean))` en `true` en el compilador:
```
StsAssumeRoleCredentialsProvider provider = StsAssumeRoleCredentialsProvider.builder()
.refreshRequest(r -> r
.roleArn("arn:aws:iam::111122223333:role/example-role")
.roleSessionName("example-session")
.durationSeconds(3600)) // 1 hour session
.staleTime(Duration.ofMinutes(5)) // Consider stale 5 minutes before expiration
.prefetchTime(Duration.ofMinutes(10)) // Start refresh 10 minutes before expiration
.asyncCredentialUpdateEnabled(true) // Refresh in background
.build();
S3Client s3 = S3Client.builder()
.credentialsProvider(provider)
.build();
```
Cuando se invoca una operación `s3Client` por primera vez, `[AssumeRoleRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/model/AssumeRoleRequest.html)` se envía una al AWS Security Token Service (STS). STS devuelve credenciales temporales que son válidas durante 15 minutos (900 segundos). La instancia `s3Client` usa las credenciales almacenadas en caché hasta que llegue el momento de actualizarlas antes de que transcurran 15 minutos. De forma predeterminada, el SDK intenta recuperar las credenciales nuevas para una nueva sesión entre 5 minutos y 1 minuto antes de la fecha de caducidad de la sesión actual. La ventana de captura previa se puede configurar mediante las propiedades `[prefetchTime](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsCredentialsProvider.BaseBuilder.html#prefetchTime(java.time.Duration))` y `[staleTime](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsCredentialsProvider.BaseBuilder.html#staleTime(java.time.Duration))`.
Puede configurar de forma similar los siguientes proveedores de credenciales basados en sesiones:
+ `StsWebIdentityTokenFileCredentialsProvider`
+ `StsGetSessionTokenCredentialsProvider`
+ `StsGetFederationTokenCredentialsProvider`
+ `StsAssumeRoleWithWebIdentityCredentialsProvider`
+ `StsAssumeRoleWithSamlCredentialsProvider`
+ `StsAssumeRoleCredentialsProvider`
+ `DefaultCredentialsProvider` (cuando delega en el proveedor de credenciales que usa sesiones)
+ `ProcessCredentialsProvider`
+ `WebIdentityTokenFileCredentialsProvider`
+ `ContainerCredentialsProvider`
+ `InstanceProfileCredentialsProvider`
Comprender el almacenamiento en caché de credenciales le ayuda a optimizar el rendimiento y la fiabilidad de su aplicación al trabajar con ella. Servicios de AWS
# Especifique un proveedor de credenciales específico en el AWS SDK for Java 2.x
Si bien la cadena de proveedores de credenciales predeterminados es práctica en muchos escenarios, especificar los proveedores de credenciales de forma explícita le permite tener un mayor control sobre el comportamiento, el rendimiento y la seguridad de la autenticación.
Entre los motivos para especificar un proveedor de credenciales se incluyen los siguientes:
+ La cadena de proveedores predeterminados comprueba varias fuentes de forma secuencial, lo que puede aumentar la latencia:
```
// The default provider chain checks might check multiple sources until it finds
// sufficient configuration.
S3Client s3Client = S3Client.builder().build();
// You can specify exactly where to look.
S3Client optimizedClient = S3Client.builder()
.credentialsProvider(InstanceProfileCredentialsProvider.create())
.build();
```
+ Debe utilizar ubicaciones no estándar para acceder a la configuración de credenciales:
```
// Use configuration from a custom file location.
S3Client s3Client = S3Client.builder()
.credentialsProvider(ProfileCredentialsProvider.builder()
.profileFile(ProfileFile.builder()
.content(Paths.get("/custom/path/to/configuration/file"))
.type(ProfileFile.Type.CONFIGURATION) // Expects all non-default profiles to be prefixed with "profile".
.build())
.profileName("custom")
.build())
.build();
```
+ Utilice credenciales diferentes para diferentes clientes de servicio. Por ejemplo, si la aplicación necesita acceder a varias AWS cuentas o usar permisos diferentes para distintos servicios:
```
// S3 client using one set of credentials.
S3Client s3Client = S3Client.builder()
.credentialsProvider(ProfileCredentialsProvider.create("s3-readonly"))
.build();
// DynamoDB client using different credentials.
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("dynamodb-admin"))
.build();
```
+ Controle el comportamiento de actualización de credenciales:
```
// Create a provider with custom refresh behavior.
StsAssumeRoleCredentialsProvider customRefreshProvider =
StsAssumeRoleCredentialsProvider.builder()
.refreshRequest(AssumeRoleRequest.builder()
.roleArn("arn:aws:iam::123456789012:role/my-role")
.roleSessionName("custom-session")
.build())
.stsClient(StsClient.create())
.asyncCredentialUpdateEnabled(true) // Use a background thread to prefetch credentials.
.build();
S3Client s3Client = S3Client.builder()
.credentialsProvider(customRefreshProvider)
.build();
```
# Utilice perfiles de configuración AWS compartidos en el AWS SDK for Java 2.x
Utilizando el archivo compartido de `credentials` y `config`, puede configurar varios perfiles. Esto posibilita que su aplicación utilice varios conjuntos de configuración de credenciales. El perfil `[default]` se mencionó anteriormente. El SDK usa la [ProfileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProfileCredentialsProvider.html)clase para cargar la configuración de los perfiles definidos en el `credentials` archivo compartido.
El siguiente fragmento de código muestra cómo crear un cliente de servicio que utilice la configuración definida como parte del perfil denominado `my_profile`.
```
Region region = Region.US_WEST_2;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.credentialsProvider(ProfileCredentialsProvider.create("my_profile"))
.build();
```
## Establecer un perfil predeterminado diferente
Para establecer como predeterminado un perfil distinto del perfil `[default]` para su aplicación, defina la variable de entorno `AWS_PROFILE` con el nombre de su perfil personalizado.
Para establecer esta variable en Linux, MacOS, o Unix, utilice `export`:
```
export AWS_PROFILE="other_profile"
```
Para establecer estas variables en Windows, utilice `set`:
```
set AWS_PROFILE="other_profile"
```
Como alternativa, defina la propiedad del sistema Java `aws.profile` con el nombre del perfil.
## Volver a cargar credenciales del perfil
Puede configurar cualquier proveedor de credenciales que tenga un método `profileFile()` en su generador para volver a cargar las credenciales del perfil. Estas clases de perfiles de credenciales son: `ProfileCredentialsProvider`, `DefaultCredentialsProvider`, `InstanceProfileCredentialsProvider` y `ProfileTokenProvider.`
**nota**
La recarga de credenciales de perfil solo funciona con los siguientes ajustes en el archivo de perfil: `aws_access_key_id`, `aws_secret_access_key` y `aws_session_token`.
Los ajustes de `region`, `sso_session`, `sso_account_id` y `source_profile` no se tienen en cuenta.
Para configurar un proveedor de credenciales compatible para volver a cargar la configuración del perfil, proporcione una instancia del [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/profiles/ProfileFileSupplier.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/profiles/ProfileFileSupplier.html) al método de creación del `profileFile()`. El siguiente ejemplo de código demuestra un `ProfileCredentialsProvider` que recarga la configuración de credenciales desde el perfil `[default]`.
```
ProfileCredentialsProvider provider = ProfileCredentialsProvider
.builder()
.profileFile(ProfileFileSupplier.defaultSupplier())
.build();
// Set up a service client with the provider instance.
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.region(Region.US_EAST_1)
.credentialsProvider(provider)
.build();
/*
Before dynamoDbClient makes a request, it reloads the credentials settings
by calling provider.resolveCredentials().
*/
```
Cuando se llama a `ProfileCredentialsProvider.resolveCredentials()`, el SDK para Java vuelve a cargar la configuración. `ProfileFileSupplier.defaultSupplier()` es una de las [diversas implementaciones prácticas](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/profiles/ProfileFileSupplier.html) de `ProfileFileSupplier` ofrecidas por el SDK. Si su caso lo requiere, puede proporcionar su propia implementación.
En el ejemplo siguiente, se muestra el uso del método de conveniencia `ProfileFileSupplier.reloadWhenModified()`. `reloadWhenModified()` toma un parámetro `Path`, lo que le da flexibilidad a la hora de designar el archivo de origen de la configuración en lugar de la ubicación estándar `~/.aws/credentials` (o `config`).
La configuración se volverá a cargar cuando `resolveCredentials()` se invoque solo si el SDK determina que el contenido del archivo se ha modificado.
```
Path credentialsFilePath = ...
ProfileCredentialsProvider provider = ProfileCredentialsProvider
.builder()
.profileFile(ProfileFileSupplier.reloadWhenModified(credentialsFilePath, ProfileFile.Type.CREDENTIALS))
.profileName("my-profile")
.build();
/*
A service client configured with the provider instance calls provider.resolveCredential()
before each request.
*/
```
El método `ProfileFileSupplier.aggregate()` combina el contenido de varios archivos de configuración. Usted decide si un archivo se vuelve a cargar por cada llamada a `resolveCredentials()` o si la configuración de un archivo se fija en el momento en que se leyó por primera vez.
El siguiente ejemplo muestra un `DefaultCredentialsProvider` que combina la configuración de dos archivos que contienen la configuración del perfil. El SDK vuelve a cargar la configuración del archivo al que apunta la variable `credentialsFilePath` cada vez que se llama a `resolveCredentials()` y cambia la configuración. La configuración del objeto `profileFile` sigue siendo la misma.
```
Path credentialsFilePath = ...;
ProfileFile profileFile = ...;
DefaultCredentialsProvider provider = DefaultCredentialsProvider
.builder()
.profileFile(ProfileFileSupplier.aggregate(
ProfileFileSupplier.reloadWhenModified(credentialsFilePath, ProfileFile.Type.CREDENTIALS),
ProfileFileSupplier.fixedProfileFile(profileFile)))
.profileName("my-profile")
.build();
/*
A service client configured with the provider instance calls provider.resolveCredential()
before each request.
*/
```
# Cargue las credenciales de un proceso externo mediante el AWS SDK for Java 2.x
**aviso**
A continuación se describe un método para obtener credenciales de un proceso externo. Esto resulta potencialmente peligroso, así que proceda con precaución. Recomendamos utilizar otros proveedores de credenciales si es posible. Si usa esta opción, es recomendable asegurarse de que el archivo `config` esté lo más bloqueado posible siguiendo las prácticas recomendadas de seguridad del sistema operativo.
Asegúrese de que su herramienta de credenciales personalizadas no escriba ninguna información secreta en ella`StdErr`. SDKs y AWS CLI puede capturar y registrar dicha información, lo que podría exponerla a usuarios no autorizados.
Con el SDK para Java 2.x, puede adquirir credenciales temporales de un proceso externo para casos de uso personalizados. Hay dos formas de configurar esta funcionalidad.
## Usar la configuración de `credential_process`
Si tiene un método que proporciona credenciales temporales, puede integrarlo añadiendo la configuración de `credential_process` como parte de una definición de perfil en el archivo `config`. El valor que especifique debe utilizar la ruta completa al archivo de comandos. Si la ruta del archivo contiene espacios, debe escribirla entre comillas.
El SDK llama al comando exactamente como se especifica y, a continuación, lee los datos JSON desde `stdout`.
Los ejemplos siguientes muestran el uso de esta configuración para las rutas de archivos sin espacios y las rutas de archivos con espacios.
------
#### [ Linux/macOS ]
**Sin espacios en la ruta del archivo**
```
[profile process-credential-profile]
credential_process = /path/to/credential/file/credential_file.sh --custom-command custom_parameter
```
**Con espacios en la ruta del archivo**
```
[profile process-credential-profile]
credential_process = "/path/with/space to/credential/file/credential_file.sh" --custom-command custom_parameter
```
------
#### [ Windows ]
**Sin espacios en la ruta del archivo**
```
[profile process-credential-profile]
credential_process = C:\Path\To\credentials.cmd --custom_command custom_parameter
```
**Con espacios en la ruta del archivo**
```
[profile process-credential-profile]
credential_process = "C:\Path\With Space To\credentials.cmd" --custom_command custom_parameter
```
------
El siguiente fragmento de código muestra cómo crear un cliente de servicio que utilice la configuración definida como parte del perfil denominado `process-credential-profile`.
```
Region region = Region.US_WEST_2;
S3Client s3Client = S3Client.builder()
.region(region)
.credentialsProvider(ProfileCredentialsProvider.create("process-credential-profile"))
.build();
```
Para obtener información detallada sobre el uso de un proceso externo como fuente de credenciales temporales, consulte la [sección sobre credenciales de procesos](https://docs.aws.amazon.com/sdkref/latest/guide/feature-process-credentials.html) de la Guía de referencia sobre herramientas AWS SDKs y herramientas.
## Utilizar un `ProcessCredentialsProvider`.
Como alternativa al uso de la configuración del archivo `config`, puede usar los `[ProcessCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProcessCredentialsProvider.html)` del SDK para cargar credenciales temporales mediante Java.
Los siguientes ejemplos muestran varias versiones de cómo especificar un proceso externo utilizando el `ProcessCredentialsProvider` y configurando un cliente de servicio que utilice las credenciales temporales.
------
#### [ Linux/macOS ]
**Sin espacios en la ruta del archivo**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("/path/to/credentials.sh optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
**Con espacios en la ruta del archivo**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("/path\\ with\\ spaces\\ to/credentials.sh optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
------
#### [ Windows ]
**Sin espacios en la ruta del archivo**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("C:\\Path\\To\\credentials.exe optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
**Con espacios en la ruta del archivo**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("\"C:\\Path\\With Spaces To\\credentials.exe\" optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
------
## Uso IAM Roles Anywhere en autenticación
[IAM Roles Anywhere](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/introduction.html) le permite obtener AWS credenciales temporales para cargas de trabajo Servicio de AWS que se ejecutan fuera de él. AWS Permite el acceso seguro a recursos de AWS desde entornos locales o de otro tipo en la nube.
Antes de poder autenticar las solicitudes con IAM Roles Anywhere, debe recopilar la información necesaria y descargar la [herramienta ayudante de credenciales](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/credential-helper.html). Siga las instrucciones de [Introducción](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/getting-started.html) de la Guía del usuario de IAM Roles Anywhere para crear los artefactos necesarios.
El SDK para Java no tiene un proveedor de credenciales dedicado para recuperar credenciales temporales de IAM Roles Anywhere, pero puede utilizar la herramienta ayudante de credenciales junto con una de las opciones para [recuperar credenciales de un proceso externo](#credentials-process).
### Uso del ajuste `credential_process` en un perfil
En el siguiente fragmento del archivo de AWS configuración compartido, se muestra un nombre de perfil `roles_anywhere` que utiliza la configuración: `credential_process`
```
[profile roles_anywhere]
credential_process = ./aws_signing_helper credential-process \
--certificate /path/to/certificate \
--private-key /path/to/private-key \
--trust-anchor-arn arn:aws:rolesanywhere:region:account:trust-anchor/TA_ID \
--profile-arn arn:aws:rolesanywhere:region:account:profile/PROFILE_ID \
--role-arn arn:aws:iam::account:role/role-name-with-path
```
Debe reemplazar el texto que se muestra en rojo por sus valores después de haber ensamblado todos los artefactos. El primer elemento de la configuración, `aws_signing_helper` es el ejecutable de la herramienta ayudante de credenciales y `credential-process` es el comando.
Al configurar un cliente de servicio para que use el perfil `roles_anywhere`, como se muestra en el siguiente código, el SDK almacena en caché las credenciales temporales y las actualiza antes de que caduquen:
```
S3Client s3Client = S3Client.builder()
.credentialsProvider(ProfileCredentialsProvider.builder()
.profileName("roles_anywhere").build())
.build();
```
### Configuración de un `ProcessCredentialsProvider`
Como se muestra a continuación, puede utilizar un método de solo código con el `ProcessCredentialsProvider` en lugar de utilizar la configuración del perfil:
```
ProcessCredentialsProvider processCredentialsProvider = ProcessCredentialsProvider.builder()
.command("""
./aws_signing_helper credential-process \
--certificate /path/to/certificate \
--private-key /path/to/private-key \
--trust-anchor-arn arn:aws:rolesanywhere:region:account:trust-anchor/TA_ID \
--profile-arn arn:aws:rolesanywhere:region:account:profile/PROFILE_ID \
--role-arn arn:aws:iam::account:role/role-name-with-path
""").build();
S3Client s3Client = S3Client.builder()
.credentialsProvider(processCredentialsProvider)
.build();
```
Reemplace el texto que se muestra en rojo por sus valores después de haber ensamblado todos los artefactos.
# Proporcione las credenciales en código mediante el AWS SDK for Java 2.x
Si la cadena de credenciales predeterminada o un proveedor o cadena de proveedores específicos o personalizados no funcionan para su código, puede proporcionar mediante código las credenciales temporales que desee. Pueden ser [credenciales de rol de IAM](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html), tal como [se describió anteriormente](credentials-temporary.md#credentials-temporary-from-portal), o credenciales temporales recuperadas de AWS Security Token Service ()AWS STS. Si ha obtenido credenciales temporales utilizando AWS STS, entréguelas a un Servicio de AWS cliente, tal y como se muestra en el siguiente ejemplo de código.
1. Asuma un rol llamando a `StsClient.assumeRole()`.
1. Cree un [StaticCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/StaticCredentialsProvider.html)objeto y suministre el `AwsSessionCredentials` objeto.
1. Configure el compilador del cliente con `StaticCredentialsProvider` y compile el cliente.
En el siguiente ejemplo, se crea un cliente de servicio Amazon S3 con las credenciales temporales devueltas AWS STS por un rol asumido por IAM.
```
// The AWS IAM Identity Center identity (user) who executes this method does not have permission to list buckets.
// The identity is configured in the [default] profile.
public static void assumeRole(String roleArn, String roleSessionName) {
// The IAM role represented by the 'roleArn' parameter can be assumed by identities in two different accounts
// and the role permits the user to only list buckets.
// The SDK's default credentials provider chain will find the single sign-on settings in the [default] profile.
// The identity configured with the [default] profile needs permission to call AssumeRole on the STS service.
try {
Credentials tempRoleCredentials;
try (StsClient stsClient = StsClient.create()) {
AssumeRoleRequest roleRequest = AssumeRoleRequest.builder()
.roleArn(roleArn)
.roleSessionName(roleSessionName)
.build();
AssumeRoleResponse roleResponse = stsClient.assumeRole(roleRequest);
tempRoleCredentials = roleResponse.credentials();
}
// Use the following temporary credential items for the S3 client.
String key = tempRoleCredentials.accessKeyId();
String secKey = tempRoleCredentials.secretAccessKey();
String secToken = tempRoleCredentials.sessionToken();
// List all buckets in the account associated with the assumed role
// by using the temporary credentials retrieved by invoking stsClient.assumeRole().
StaticCredentialsProvider staticCredentialsProvider = StaticCredentialsProvider.create(
AwsSessionCredentials.create(key, secKey, secToken));
try (S3Client s3 = S3Client.builder()
.credentialsProvider(staticCredentialsProvider)
.build()) {
List buckets = s3.listBuckets().buckets();
for (Bucket bucket : buckets) {
System.out.println("bucket name: " + bucket.name());
}
}
} catch (StsException | S3Exception e) {
logger.error(e.getMessage());
System.exit(1);
}
}
```
## Conjunto de permisos
El siguiente conjunto de permisos, definido en, AWS IAM Identity Center permite a la identidad (usuario) realizar las dos operaciones siguientes
1. La `GetObject` operación del Amazon Simple Storage Service.
1. La operación `AssumeRole` del AWS Security Token Service.
Sin asumir el rol, fallaría el método `s3.listBuckets()` que se muestra en el ejemplo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"sts:AssumeRole"
],
"Resource": [
"*"
]
}
]
}
```
------
## Rol asumido
### Política de permisos del rol asumidos
La política de permisos siguiente está asociada al rol que se asume en el ejemplo anterior. Esta política de permisos permite enumerar todos los buckets de la misma cuenta que el rol.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListAllMyBuckets"
],
"Resource": [
"*"
]
}
]
}
```
------
### Política de confianza del rol asumido
La política de permisos siguiente está asociada al rol que se asume en el ejemplo anterior. La política permite que las identidades (usuarios) de dos cuentas asuman el rol.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:root",
"arn:aws:iam::555555555555:root"
]
},
"Action": "sts:AssumeRole",
"Condition": {}
}
]
}
```
------
# Lectura de credenciales de roles de IAM en Amazon EC2 mediante el SDK para Java 2.x
Puede utilizar una función de IAM para administrar las credenciales temporales de las aplicaciones que se ejecutan en una instancia EC2 y que realizan solicitudes a la API AWS CLI . AWS Es preferible hacerlo de este modo a almacenar claves de acceso en la instancia de EC2. Para asignar un AWS rol a una instancia EC2 y ponerlo a disposición de todas sus aplicaciones, debe crear un perfil de instancia adjunto a la instancia. Un perfil de instancia contiene el rol y permite a los programas que se ejecutan en la instancia de EC2 obtener credenciales temporales. Para obtener más información, consulte [Uso de un rol de IAM para conceder permisos a aplicaciones que se ejecutan en instancias Amazon EC2](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html) en la *Guía del usuario de IAM*.
En este tema se proporciona información sobre cómo configurar la aplicación Java para que se ejecute en una instancia EC2 y permitir que adquiera las AWS SDK for Java 2.x credenciales del IAM rol.
## Adquisición de credenciales de roles de IAM desde el entorno
Si la aplicación crea un cliente de AWS servicio mediante el `create` método (o `builder().build()` los métodos), el SDK para Java utiliza la *cadena de proveedores de credenciales predeterminada*. La cadena de proveedores de credenciales predeterminados busca en el entorno de ejecución elementos de configuración que el SDK pueda intercambiar por credenciales temporales. En la sección [Cadena de proveedores de credenciales predeterminada en el AWS SDK for Java 2.x](credentials-chain.md) se describe el proceso de búsqueda completo.
El último paso de la cadena de proveedores predeterminada solo está disponible cuando la aplicación se ejecuta en una Amazon EC2 instancia. En este paso, el SDK utiliza un `InstanceProfileCredentialsProvider` para leer el rol de IAM definido en el perfil de la instancia EC2. A continuación, el SDK adquiere las credenciales temporales para ese rol de IAM.
Aunque estas credenciales son temporales y acaban caducando, un `InstanceProfileCredentialsProvider` las actualiza periódicamente para que sigan permitiendo el acceso a AWS.
## Adquisición de credenciales de roles de IAM mediante programación
Como alternativa a la cadena de proveedores de credenciales predeterminados que eventualmente utiliza un `InstanceProfileCredentialsProvider` en EC2, puede configurar un cliente de servicio de forma explícita con un `InstanceProfileCredentialsProvider`. Este método se muestra en el fragmento de código siguiente.
```
S3Client s3 = S3Client.builder()
.credentialsProvider(InstanceProfileCredentialsProvider.create())
.build();
```
## Adquisición segura de credenciales de roles de IAM
De forma predeterminada, las instancias de EC2 ejecutan [IMDS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html) (Instance Metadata Service), que permite al `InstanceProfileCredentialsProvider` de los SDK acceder a información como el rol de IAM que se ha configurado. Las instancias de EC2 ejecutan dos versiones del IMDS de forma predeterminada:
+ Instance Metadata Service, versión 1 (IMDSv1): un request/response método
+ Instance Metadata Service, versión 2 (IMDSv2): un método orientado a la sesión
[IMDSv2 es un enfoque más seguro](https://aws.amazon.com/blogs/security/defense-in-depth-open-firewalls-reverse-proxies-ssrf-vulnerabilities-ec2-instance-metadata-service/) que. IMDSv1
De forma predeterminada, el SDK de Java primero IMDSv2 intenta obtener el rol de IAM, pero si no lo consigue, lo intenta IMDSv1. Sin embargo, dado que IMDSv1 es menos seguro, se AWS recomienda usar IMDSv2 únicamente e inhabilitar el SDK para que no lo intente IMDSv1.
Para utilizar un enfoque más seguro, deshabilite el uso del SDK IMDSv1 proporcionando una de las siguientes configuraciones con un valor de`true`.
+ Variable de entorno: `AWS_EC2_METADATA_V1_DISABLED`
+ Propiedad del sistema JVM: aws.`disableEc2MetadataV1`
+ Ajuste del archivo de configuración compartido: `ec2_metadata_v1_disabled`
Si se establece una de estas configuraciones en`true`, el SDK no carga las credenciales del rol de IMDS IMDSv1 si se produce un error en la IMDSv2 llamada inicial.