

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.

# Uso de roles de IAM para conceder acceso a recursos de Amazon EC2 en AWS
<a name="java-dg-roles"></a>

Todas las solicitudes a Amazon Web Services (AWS) deben firmarse criptográficamente mediante credenciales emitidas por AWS. Puede utilizar *roles de IAM* como un método sencillo para conceder acceso seguro a los recursos de AWS desde sus instancias de Amazon EC2.

En este tema se proporciona información acerca de cómo utilizar los roles de con aplicaciones del SDK de Java que se ejecutan en Amazon EC2. Para obtener más información sobre los roles de IAM consulte [Roles de IAM para Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) en la Guía del usuario de Amazon EC2 para instancias de Linux. 

## Cadena predeterminada de proveedores y perfiles de instancias EC2
<a name="default-provider-chain"></a>

Si su aplicación crea un cliente de AWS utilizando el constructor predeterminado, el cliente buscará las credenciales mediante la *cadena predeterminada de proveedores de credenciales*, en el orden siguiente:

1. En las propiedades del sistema Java: `aws.accessKeyId` y `aws.secretKey`.

1. En las variables de entorno del sistema: `AWS_ACCESS_KEY_ID` y `AWS_SECRET_ACCESS_KEY`.

1. En el archivo de credenciales (la ubicación de este archivo varía en función de la plataforma).

1. Las credenciales entregadas a través del servicio de contenedor de Amazon EC2 si se establece la variable de entorno `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` y el administrador de seguridad tiene permiso para acceder a la variable.

1. En las *credenciales del perfil de la instancia*, que residen en los metadatos de la instancia asociadas con la función de IAM para la instancia EC2.

1. Credenciales de Web Identity Token del entorno o contenedor.

El paso *credenciales del perfil de la instancia* en la cadena predeterminada de proveedores solo está disponible cuando la aplicación se ejecuta en una instancia Amazon EC2, pero es el método más sencillo y más seguro cuando se trabaja con instancias Amazon EC2. También puede pasar una instancia de [InstanceProfileCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/InstanceProfileCredentialsProvider.html) directamente al constructor del cliente para obtener las credenciales del perfil de la instancia sin recorrer toda la cadena predeterminada de proveedores.

Por ejemplo:

```
AmazonS3 s3 = AmazonS3ClientBuilder.standard()
              .withCredentials(new InstanceProfileCredentialsProvider(false))
              .build();
```

Cuando se utiliza este enfoque, el SDK recupera las credenciales temporales de AWS que tienen los mismos permisos que los asociados al rol de IAM asociado a la instancia Amazon EC2 en su perfil de instancia. Aunque estas credenciales son temporales y acaban caducando, `InstanceProfileCredentialsProvider` las actualiza periódicamente para que sigan permitiendo el acceso a AWS.

**importante**  
La actualización automática de las credenciales *solo* se realiza cuando utiliza el constructor del cliente predeterminado, que crea su propio `InstanceProfileCredentialsProvider` como parte de la cadena predeterminada de proveedores, o cuando pasa una instancia de `InstanceProfileCredentialsProvider` directamente al constructor del cliente. Si utiliza otro método para obtener o pasar credenciales del perfil de la instancia, usted es responsable de comprobar y actualizar las credenciales que hayan caducado.

Si el constructor del cliente no encuentra las credenciales con la cadena de proveedores de credenciales, produce una excepción [AmazonClientException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonClientException.html).

## Tutorial: Uso de roles de IAM para instancias EC2
<a name="roles-walkthrough"></a>

El siguiente tutorial muestra cómo recuperar un objeto de Amazon S3 mediante un rol de IAM para administrar el acceso.

### Creación de un rol de IAM
<a name="java-dg-create-the-role"></a>

Cree un rol de IAM que conceda acceso de solo lectura a Amazon S3.

1. Abra la [consola de IAM](https://console.aws.amazon.com/iam/home).

1. En el panel de navegación, seleccione **Roles** y después **Create New Role (Crear nuevo rol)**.

1. Escriba un nombre para la función y, a continuación, seleccione **Next Step (Paso siguiente)**. Recuerde este nombre, ya que lo necesitará cuando lance su instancia Amazon EC2.

1. En la página **Seleccionar tipo de rol**, en **Roles de Servicio de AWS**, seleccione **Amazon EC2**.

1. En la página **Definir permisos**, bajo **Seleccionar plantilla de política**, seleccione **Acceso de solo lectura de Amazon S3** y después **Siguiente paso**.

1. En la página **Review (Revisar)**, seleccione **Create Role (Crear rol)**.

### Lanzar una instancia EC2 y especificar el rol de IAM
<a name="java-dg-launch-ec2-instance-with-instance-profile"></a>

Puede lanzar una instancia de Amazon EC2 con un rol de IAM mediante la consola de Amazon EC2 o el AWS SDK para Java.
+ Para lanzar una instancia de Amazon EC2 mediante la consola, siga las instrucciones de [Introducción a las instancias de Linux de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html) en la Guía del usuario de instancias de Linux.

  Cuando llegue a la página **Revisar lanzamiento de instancia**, seleccione **Editar detalles de la instancia**. En **Rol de IAM**, elija el rol de IAM que creó anteriormente. Complete el procedimiento siguiendo las instrucciones.
**nota**  
Deberá crear o usar un grupo de seguridad y un par de claves existentes para conectarse a la instancia.
+ Para lanzar una instancia de Amazon EC2 con un rol de IAM mediante el AWS SDK para Java, consulte Amazon EC2Ejecución de una instancia de .

### Creación de una aplicación
<a name="java-dg-remove-the-credentials"></a>

Vamos a compilar la aplicación de ejemplo para que se ejecute en la instancia EC2. En primer lugar, cree el directorio que va a usar para almacenar los archivos del tutorial (por ejemplo, `GetS3ObjectApp`).

A continuación, copie las bibliotecas de AWS SDK para Java en el directorio recién creado. Si ha descargado AWS SDK para Java en su directorio `~/Downloads`, puede copiarlos utilizando los siguientes comandos:

```
cp -r ~/Downloads/aws-java-sdk-{1.7.5}/lib .
cp -r ~/Downloads/aws-java-sdk-{1.7.5}/third-party .
```

Abra un nuevo archivo, llámelo `GetS3Object.java`y añada el siguiente código:

```
import java.io.*;

import com.amazonaws.auth.*;
import com.amazonaws.services.s3.*;
import com.amazonaws.services.s3.model.*;
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;

public class GetS3Object {
  private static final String bucketName = "text-content";
  private static final String key = "text-object.txt";

  public static void main(String[] args) throws IOException
  {
    AmazonS3 s3Client = AmazonS3ClientBuilder.defaultClient();

    try {
      System.out.println("Downloading an object");
      S3Object s3object = s3Client.getObject(
          new GetObjectRequest(bucketName, key));
      displayTextInputStream(s3object.getObjectContent());
    }
    catch(AmazonServiceException ase) {
      System.err.println("Exception was thrown by the service");
    }
    catch(AmazonClientException ace) {
      System.err.println("Exception was thrown by the client");
    }
  }

  private static void displayTextInputStream(InputStream input) throws IOException
  {
    // Read one text line at a time and display.
    BufferedReader reader = new BufferedReader(new InputStreamReader(input));
    while(true)
    {
      String line = reader.readLine();
      if(line == null) break;
      System.out.println( "    " + line );
    }
    System.out.println();
  }
}
```

Abra un nuevo archivo, llámelo `build.xml`y añada las líneas siguientes:

```
<project name="Get {S3} Object" default="run" basedir=".">
  <path id="aws.java.sdk.classpath">
    <fileset dir="./lib" includes="**/*.jar"/>
    <fileset dir="./third-party" includes="**/*.jar"/>
    <pathelement location="lib"/>
    <pathelement location="."/>
  </path>

  <target name="build">
  <javac debug="true"
    includeantruntime="false"
    srcdir="."
    destdir="."
    classpathref="aws.java.sdk.classpath"/>
  </target>

  <target name="run" depends="build">
    <java classname="GetS3Object" classpathref="aws.java.sdk.classpath" fork="true"/>
  </target>
</project>
```

Compile y ejecute el programa modificado. Tenga en cuenta que no hay credenciales almacenadas en el programa. Por lo tanto, a menos que ya haya especificado las credenciales de AWS, el código producirá una `AmazonServiceException`. Por ejemplo:

```
$ ant
Buildfile: /path/to/my/GetS3ObjectApp/build.xml

build:
  [javac] Compiling 1 source file to /path/to/my/GetS3ObjectApp

run:
   [java] Downloading an object
   [java] AmazonServiceException

BUILD SUCCESSFUL
```

### Transferir el programa compilado a la instancia EC2
<a name="java-dg-transfer-compiled-program-to-ec2-instance"></a>

Transfiera el programa a su instancia Amazon EC2 mediante la copia segura (** `` **), junto con las bibliotecas de AWS SDK para Java. La secuencia de comandos debe ser similar a la siguiente.

```
scp -p -i {my-key-pair}.pem GetS3Object.class ec2-user@{public_dns}:GetS3Object.class
scp -p -i {my-key-pair}.pem build.xml ec2-user@{public_dns}:build.xml
scp -r -p -i {my-key-pair}.pem lib ec2-user@{public_dns}:lib
scp -r -p -i {my-key-pair}.pem third-party ec2-user@{public_dns}:third-party
```

**nota**  
En función de la distribución Linux que haya utilizado, el *nombre de usuario* podría ser "ec2-user", "root" o "ubuntu". Para obtener el nombre DNS público de la instancia, abra la [consola de EC2](https://console.aws.amazon.com/ec2/home) y busque el valor de **Public DNS (DNS público)** en la pestaña **Description (Descripción)** (por ejemplo, `ec2-198-51-100-1.compute-1.amazonaws.com`).

En los comandos anteriores:
+  `GetS3Object.class` es el programa compilado
+  `build.xml` es el archivo ant que se utiliza para compilar y ejecutar el programa
+ los directorios `lib` y `third-party` son las carpetas de las bibliotecas de AWS SDK para Java correspondientes.
+ El modificador `-r` indica que `scp` debe realizar una copia recursiva de todo el contenido de los directorios `library` y `third-party` en la distribución de AWS SDK para Java.
+ El modificador `-p` indica que `scp` deben conservar los permisos de los archivos de código fuente cuando se copien en el destino.
**nota**  
El conmutador `-p` solo funciona en Linux, macOS o Unix. Si va a copiar archivos de Windows, es posible que tenga que corregir los permisos del archivo en su instancia mediante el siguiente comando:

```
chmod -R u+rwx GetS3Object.class build.xml lib third-party
```

### Ejecutar el programa de ejemplo en la instancia EC2
<a name="java-dg-run-the-program"></a>

Para ejecutar el programa, conéctese a la instancia Amazon EC2. Para obtener más información, consulte [Conexión con su instancia de Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) en la Guía del usuario de Amazon EC2 para instancias de Linux.

Si ** ` ant ` ** no está disponible en la instancia, instálelo con el siguiente comando:

```
sudo yum install ant
```

A continuación, ejecute el programa mediante `ant` del siguiente modo:

```
ant run
```

El programa escribirá el contenido del objeto de Amazon S3 en la ventana de comandos.