Realización de solicitudes con las credenciales temporales de usuario de IAM

Una Cuenta de AWS o un usuario de IAM puede solicitar las credenciales de seguridad temporales y utilizarlas para enviar solicitudes autenticadas a Amazon S3. En esta sección, se proporcionan ejemplos sobre cómo utilizar AWS SDK for Java, .NET y PHP para obtener las credenciales de seguridad temporales y utilizarlas con el fin de autenticar las solicitudes para Amazon S3.

Java

Un usuario de IAM o una Cuenta de AWS pueden solicitar credenciales de seguridad temporales (consulte Realizar solicitudes) mediante AWS SDK for Java y utilizarlas para obtener acceso a Amazon S3. Estas credenciales caducan cuando termine la sesión especificada.

De forma predeterminada, la sesión durará una hora. Si utiliza credenciales de usuario de IAM, puede especificar la duración al solicitar las credenciales de seguridad temporales desde 15 minutos hasta la duración máxima de sesión del rol. Para obtener más información acerca de las credenciales de seguridad temporales, consulte Credenciales de seguridad temporales en la guía del usuario de IAM. Para obtener más información acerca de la realización de solicitudes, consulte Realizar solicitudes.

Para obtener credenciales de seguridad temporales y acceso a Amazon S3

Cree una instancia de la clase AWSSecurityTokenService. Para obtener información acerca de cómo proporcionar las credenciales, consulte Desarrollo con Amazon S3 mediante los SDK de AWS y los exploradores.
Recupere las credenciales de seguridad temporales para el rol deseado al llamar al método assumeRole() del cliente de Security Token Service (STS).
Empaquete las credenciales de seguridad temporales en un objeto BasicSessionCredentials. Utilice este objeto para proporcionar las credenciales de seguridad temporales al cliente de Amazon S3.
Cree una instancia de la clase AmazonS3Client usando las credenciales de seguridad temporales. Envíe las solicitudes a Amazon S3 con este cliente. Si envía las solicitudes con las credenciales vencidas, Amazon S3 devolverá un error.

nota

Si obtiene las credenciales de seguridad temporales con las credenciales de seguridad de su Cuenta de AWS, las credenciales de seguridad temporales tendrán validez durante una hora únicamente. Puede especificar la duración de la sesión solo si utiliza las credenciales del usuario de IAM para solicitar una sesión.

En el siguiente ejemplo se muestra un conjunto de claves de objeto del bucket especificado. En el ejemplo se obtienen credenciales de seguridad temporales para una sesión y se utilizan para enviar una solicitud autenticada a Amazon S3.

Si desea probar el ejemplo con las credenciales de usuario de IAM, debe crear un usuario de IAM en la Cuenta de AWS. Para obtener más información acerca de cómo crear un usuario de IAM, consulte Creación del primer grupo de usuarios y administradores de IAM en la Guía del usuario de IAM.

Para obtener instrucciones sobre la creación y comprobación de una muestra funcional, consulte Prueba de los ejemplos de código de Java de Amazon S3.



import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicSessionCredentials;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.ObjectListing;
import com.amazonaws.services.securitytoken.AWSSecurityTokenService;
import com.amazonaws.services.securitytoken.AWSSecurityTokenServiceClientBuilder;
import com.amazonaws.services.securitytoken.model.AssumeRoleRequest;
import com.amazonaws.services.securitytoken.model.AssumeRoleResult;
import com.amazonaws.services.securitytoken.model.Credentials;

public class MakingRequestsWithIAMTempCredentials {
    public static void main(String[] args) {
        String clientRegion = "*** Client region ***";
        String roleARN = "*** ARN for role to be assumed ***";
        String roleSessionName = "*** Role session name ***";
        String bucketName = "*** Bucket name ***";

        try {
            // Creating the STS client is part of your trusted code. It has
            // the security credentials you use to obtain temporary security credentials.
            AWSSecurityTokenService stsClient = AWSSecurityTokenServiceClientBuilder.standard()
                    .withCredentials(new ProfileCredentialsProvider())
                    .withRegion(clientRegion)
                    .build();

            // Obtain credentials for the IAM role. Note that you cannot assume the role of
            // an AWS root account;
            // Amazon S3 will deny access. You must use credentials for an IAM user or an
            // IAM role.
            AssumeRoleRequest roleRequest = new AssumeRoleRequest()
                    .withRoleArn(roleARN)
                    .withRoleSessionName(roleSessionName);
            AssumeRoleResult roleResponse = stsClient.assumeRole(roleRequest);
            Credentials sessionCredentials = roleResponse.getCredentials();

            // Create a BasicSessionCredentials object that contains the credentials you
            // just retrieved.
            BasicSessionCredentials awsCredentials = new BasicSessionCredentials(
                    sessionCredentials.getAccessKeyId(),
                    sessionCredentials.getSecretAccessKey(),
                    sessionCredentials.getSessionToken());

            // Provide temporary security credentials so that the Amazon S3 client
            // can send authenticated requests to Amazon S3. You create the client
            // using the sessionCredentials object.
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .withCredentials(new AWSStaticCredentialsProvider(awsCredentials))
                    .withRegion(clientRegion)
                    .build();

            // Verify that assuming the role worked and the permissions are set correctly
            // by getting a set of object keys from the bucket.
            ObjectListing objects = s3Client.listObjects(bucketName);
            System.out.println("No. of Objects: " + objects.getObjectSummaries().size());
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }
}

.NET

Un usuario de IAM o una Cuenta de AWS pueden solicitar credenciales de seguridad temporales mediante AWS SDK for .NET y utilizarlas para obtener acceso a Amazon S3. Estas credenciales caducan cuando termine la sesión.

Para obtener credenciales de seguridad temporales y acceso a Amazon S3

Cree una instancia del cliente de AWS Security Token Service. AmazonSecurityTokenServiceClient. Para obtener información acerca de cómo proporcionar las credenciales, consulte Desarrollo con Amazon S3 mediante los SDK de AWS y los exploradores.
Inicie una sesión utilizando el método GetSessionToken del cliente de STS que creó en el paso anterior. Proporcione información acerca de la sesión para este método con un objeto GetSessionTokenRequest.

El método devuelve las credenciales de seguridad temporales.
Empaquete las credenciales de seguridad temporales en una instancia del objeto SessionAWSCredentials. Utilice este objeto para proporcionar las credenciales de seguridad temporales al cliente de Amazon S3.
Cree una instancia de la clase AmazonS3Client al proporcionar las credenciales de seguridad temporales. Envíe las solicitudes a Amazon S3 con este cliente. Si envía las solicitudes con las credenciales vencidas, Amazon S3 devolverá un error.

nota

Si obtiene las credenciales de seguridad temporales con las credenciales de seguridad de su Cuenta de AWS, esas credenciales tendrán validez durante una hora únicamente. Puede especificar la duración de una sesión solo si utiliza las credenciales de usuario de IAM para solicitar una sesión.

En el siguiente ejemplo de código C# se muestran las claves de objeto del bucket especificado. A modo de ilustración, en el ejemplo se obtienen las credenciales de seguridad temporales para una sesión predeterminada de una hora y se utilizan para enviar una solicitud autenticada a Amazon S3.

Para obtener instrucciones sobre la creación y comprobación de un ejemplo funcional, consulte Ejecución de ejemplos de código .NET de Amazon S3.


using Amazon;
using Amazon.Runtime;
using Amazon.S3;
using Amazon.S3.Model;
using Amazon.SecurityToken;
using Amazon.SecurityToken.Model;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace Amazon.DocSamples.S3
{
    class TempCredExplicitSessionStartTest
    {
        private const string bucketName = "*** bucket name ***";
        // Specify your bucket region (an example region is shown).
        private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
        private static IAmazonS3 s3Client;
        public static void Main()
        {
            ListObjectsAsync().Wait();
        }

        private static async Task ListObjectsAsync()
        {
            try
            {
                // Credentials use the default AWS SDK for .NET credential search chain. 
                // On local development machines, this is your default profile.
                Console.WriteLine("Listing objects stored in a bucket");
                SessionAWSCredentials tempCredentials = await GetTemporaryCredentialsAsync();

                // Create a client by providing temporary security credentials.
                using (s3Client = new AmazonS3Client(tempCredentials, bucketRegion))
                {
                    var listObjectRequest = new ListObjectsRequest
                    {
                        BucketName = bucketName
                    };
                    // Send request to Amazon S3.
                    ListObjectsResponse response = await s3Client.ListObjectsAsync(listObjectRequest);
                    List<S3Object> objects = response.S3Objects;
                    Console.WriteLine("Object count = {0}", objects.Count);
                }
            }
            catch (AmazonS3Exception s3Exception)
            {
                Console.WriteLine(s3Exception.Message, s3Exception.InnerException);
            }
            catch (AmazonSecurityTokenServiceException stsException)
            {
                Console.WriteLine(stsException.Message, stsException.InnerException);
            }
        }

        private static async Task<SessionAWSCredentials> GetTemporaryCredentialsAsync()
        {
            using (var stsClient = new AmazonSecurityTokenServiceClient())
            {
                var getSessionTokenRequest = new GetSessionTokenRequest
                {
                    DurationSeconds = 7200 // seconds
                };

                GetSessionTokenResponse sessionTokenResponse =
                              await stsClient.GetSessionTokenAsync(getSessionTokenRequest);

                Credentials credentials = sessionTokenResponse.Credentials;

                var sessionCredentials =
                    new SessionAWSCredentials(credentials.AccessKeyId,
                                              credentials.SecretAccessKey,
                                              credentials.SessionToken);
                return sessionCredentials;
            }
        }
    }
}

PHP

En este ejemplo, se da por sentado que está familiarizado con las instrucciones para Uso del AWS SDK for PHP y ejecución de ejemplos de PHP y ha instalado AWS SDK for PHP adecuadamente.

Tanto un usuario de IAM como una Cuenta de AWS pueden solicitar credenciales de seguridad temporales mediante la versión 3 de AWS SDK for PHP. A continuación, puede usar las credenciales temporales para acceder a Amazon S3. Las credenciales caducan cuando finaliza la duración de la sesión.

nota

Si obtiene las credenciales de seguridad temporales con las credenciales de seguridad de su Cuenta de AWS, estas tendrán validez durante una hora únicamente. Puede especificar la duración de la sesión solo si utiliza las credenciales del usuario de IAM para solicitar una sesión.

En el siguiente ejemplo de PHP se muestran las claves de objeto del bucket especificado con las credenciales de seguridad temporales. En el ejemplo se obtienen credenciales de seguridad temporales para una sesión predeterminada de una hora y se utilizan para enviar una solicitud autenticada a Amazon S3. Para obtener información acerca de la ejecución de ejemplos de PHP en esta guía, consulte Ejecución de ejemplos de PHP.

Si desea probar el ejemplo con las credenciales de usuario de IAM, debe crear un usuario de IAM en la Cuenta de AWS. Para obtener información acerca de cómo crear un usuario de IAM, consulte Creación del primer grupo de usuarios y administradores de IAM en la Guía del usuario de IAM. Para obtener ejemplos de configuración de la duración de la sesión con las credenciales de usuario de IAM para solicitar una sesión, consulte Realización de solicitudes con las credenciales temporales de usuario de IAM .


 require 'vendor/autoload.php';

use Aws\S3\Exception\S3Exception;
use Aws\S3\S3Client;
use Aws\Sts\StsClient;

$bucket = '*** Your Bucket Name ***';

$sts = new StsClient([
    'version' => 'latest',
    'region' => 'us-east-1'
]);

$sessionToken = $sts->getSessionToken();

$s3 = new S3Client([
    'region' => 'us-east-1',
    'version' => 'latest',
    'credentials' => [
        'key'    => $sessionToken['Credentials']['AccessKeyId'],
        'secret' => $sessionToken['Credentials']['SecretAccessKey'],
        'token'  => $sessionToken['Credentials']['SessionToken']
    ]
]);

$result = $s3->listBuckets();

try {
    // Retrieve a paginator for listing objects.
    $objects = $s3->getPaginator('ListObjects', [
        'Bucket' => $bucket
    ]);

    echo "Keys retrieved!" . PHP_EOL;

    // List objects
    foreach ($objects as $object) {
        echo $object['Key'] . PHP_EOL;
    }
} catch (S3Exception $e) {
    echo $e->getMessage() . PHP_EOL;
}

Ruby

Un usuario de IAM o una Cuenta de AWS pueden solicitar credenciales de seguridad temporales mediante AWS SDK for Ruby y utilizarlas para obtener acceso a Amazon S3. Estas credenciales caducan cuando termine la sesión.

nota

El siguiente ejemplo de código Ruby crea un usuario temporal para mostrar los elementos en un bucket especificado durante una hora. Para utilizar este ejemplo, debe tener credenciales de AWS con los permisos necesarios para crear nuevos clientes de AWS Security Token Service (AWS STS) y mostrar buckets de Amazon S3.



# Prerequisites:
# - A user in AWS Identity and Access Management (IAM). This user must
#   be able to assume the following IAM role. You must run this code example
#   within the context of this user.
# - An existing role in IAM that allows all of the Amazon S3 actions for all of the
#   resources in this code example. This role must also trust the preceding IAM user.
# - An existing S3 bucket.

require "aws-sdk-core"
require "aws-sdk-s3"
require "aws-sdk-iam"

# Checks whether a user exists in IAM.
#
# @param iam [Aws::IAM::Client] An initialized IAM client.
# @param user_name [String] The user's name.
# @return [Boolean] true if the user exists; otherwise, false.
# @example
#   iam_client = Aws::IAM::Client.new(region: 'us-west-2')
#   exit 1 unless user_exists?(iam_client, 'my-user')
def user_exists?(iam_client, user_name)
  response = iam_client.get_user(user_name: user_name)
  return true if response.user.user_name
rescue Aws::IAM::Errors::NoSuchEntity
  # User doesn't exist.
rescue StandardError => e
  puts "Error while determining whether the user " \
    "'#{user_name}' exists: #{e.message}"
end

# Creates a user in IAM.
#
# @param iam_client [Aws::IAM::Client] An initialized IAM client.
# @param user_name [String] The user's name.
# @return [AWS:IAM::Types::User] The new user.
# @example
#   iam_client = Aws::IAM::Client.new(region: 'us-west-2')
#   user = create_user(iam_client, 'my-user')
#   exit 1 unless user.user_name
def create_user(iam_client, user_name)
  response = iam_client.create_user(user_name: user_name)
  return response.user
rescue StandardError => e
  puts "Error while creating the user '#{user_name}': #{e.message}"
end

# Gets a user in IAM.
#
# @param iam_client [Aws::IAM::Client] An initialized IAM client.
# @param user_name [String] The user's name.
# @return [AWS:IAM::Types::User] The existing user.
# @example
#   iam_client = Aws::IAM::Client.new(region: 'us-west-2')
#   user = get_user(iam_client, 'my-user')
#   exit 1 unless user.user_name
def get_user(iam_client, user_name)
  response = iam_client.get_user(user_name: user_name)
  return response.user
rescue StandardError => e
  puts "Error while getting the user '#{user_name}': #{e.message}"
end

# Checks whether a role exists in IAM.
#
# @param iam_client [Aws::IAM::Client] An initialized IAM client.
# @param role_name [String] The role's name.
# @return [Boolean] true if the role exists; otherwise, false.
# @example
#   iam_client = Aws::IAM::Client.new(region: 'us-west-2')
#   exit 1 unless role_exists?(iam_client, 'my-role')
def role_exists?(iam_client, role_name)
  response = iam_client.get_role(role_name: role_name)
  return true if response.role.role_name
rescue StandardError => e
  puts "Error while determining whether the role " \
    "'#{role_name}' exists: #{e.message}"
end

# Gets credentials for a role in IAM.
#
# @param sts_client [Aws::STS::Client] An initialized AWS STS client.
# @param role_arn [String] The role's Amazon Resource Name (ARN).
# @param role_session_name [String] A name for this role's session.
# @param duration_seconds [Integer] The number of seconds this session is valid.
# @return [AWS::AssumeRoleCredentials] The credentials.
# @example
#   sts_client = Aws::STS::Client.new(region: 'us-west-2')
#   credentials = get_credentials(
#     sts_client,
#     'arn:aws:iam::123456789012:role/AmazonS3ReadOnly',
#     'ReadAmazonS3Bucket',
#     3600
#   )
#   exit 1 if credentials.nil?
def get_credentials(sts_client, role_arn, role_session_name, duration_seconds)
  Aws::AssumeRoleCredentials.new(
    client: sts_client,
    role_arn: role_arn,
    role_session_name: role_session_name,
    duration_seconds: duration_seconds
  )
rescue StandardError => e
  puts "Error while getting credentials: #{e.message}"
end

# Checks whether a bucket exists in Amazon S3.
#
# @param s3_client [Aws::S3::Client] An initialized Amazon S3 client.
# @param bucket_name [String] The name of the bucket.
# @return [Boolean] true if the bucket exists; otherwise, false.
# @example
#   s3_client = Aws::S3::Client.new(region: 'us-west-2')
#   exit 1 unless bucket_exists?(s3_client, 'doc-example-bucket')
def bucket_exists?(s3_client, bucket_name)
  response = s3_client.list_buckets
  response.buckets.each do |bucket|
    return true if bucket.name == bucket_name
  end
rescue StandardError => e
  puts "Error while checking whether the bucket '#{bucket_name}' " \
    "exists: #{e.message}"
end

# Lists the keys and ETags for the objects in an Amazon S3 bucket.
#
# @param s3_client [Aws::S3::Client] An initialized Amazon S3 client.
# @param bucket_name [String] The bucket's name.
# @return [Boolean] true if the objects were listed; otherwise, false.
# @example
#   s3_client = Aws::S3::Client.new(region: 'us-west-2')
#   exit 1 unless list_objects_in_bucket?(s3_client, 'doc-example-bucket')
def list_objects_in_bucket?(s3_client, bucket_name)
  puts "Accessing the contents of the bucket named '#{bucket_name}'..."
  response = s3_client.list_objects_v2(
    bucket: bucket_name,
    max_keys: 50
  )

  if response.count.positive?
    puts "Contents of the bucket named '#{bucket_name}' (first 50 objects):"
    puts "Name => ETag"
    response.contents.each do |obj|
      puts "#{obj.key} => #{obj.etag}"
    end
  else
    puts "No objects in the bucket named '#{bucket_name}'."
  end
  return true
rescue StandardError => e
  puts "Error while accessing the bucket named '#{bucket_name}': #{e.message}"
end

Recursos relacionados

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Uso de credenciales de usuario de IAM o Cuenta de AWS

Usar credenciales temporales de usuario federado