Realizar solicitudes con credenciales temporales de usuario federado

Puede solicitar credenciales de seguridad temporales y proporcionarlas a sus usuarios federados o aplicaciones que necesitan acceso a sus recursos de AWS. En esta sección, se proporcionan ejemplos de cómo puede utilizar el SDK de AWS para obtener credenciales de seguridad temporales para sus usuarios federados o aplicaciones y enviar solicitudes autenticadas a Amazon S3 con esas credenciales. Para ver una lista de los SDK de AWS disponibles, consulte Código de muestra y bibliotecas.

nota

Tanto la Cuenta de AWS como un usuario de IAM pueden solicitar credenciales de seguridad temporales para usuarios federados. Sin embargo, para mayor seguridad, solo un usuario de IAM con los permisos necesarios debe solicitar estas credenciales temporales para asegurarse de que el usuario federado obtenga al menos los permisos del usuario de IAM que realiza la solicitud. En algunas aplicaciones, puede resultarle útil crear un usuario de IAM con permisos específicos con el único fin de proporcionar credenciales de seguridad temporales a sus usuarios federados y aplicaciones.

Java

nota

Para mayor seguridad, cuando solicite las credenciales de seguridad temporales para usuarios federados y aplicaciones, recomendamos que use un usuario de IAM específico que solo tenga los permisos de acceso necesarios. El usuario temporal creado nunca puede obtener más permisos que el usuario de IAM que solicitó las credenciales de seguridad temporales. Para obtener más información, consulte Preguntas frecuentes de AWS Identity and Access Management.

Para proporcionar credenciales de seguridad y utilizar una solicitud autenticada para obtener acceso a recursos, haga lo siguiente:

Cree una instancia de la clase AWSSecurityTokenServiceClient. Para obtener información acerca de cómo proporcionar las credenciales, consulte Mediante AWS SDK for Java.
Inicie una sesión utilizando el método getFederationToken() del cliente Security Token Service (STS). Proporcione información acerca de la sesión, como el nombre de usuario y una política de IAM que desee adjuntar a las credenciales temporales. Puede proporcionar una duración de sesión opcional. Este método devuelve sus credenciales de seguridad temporales.
Empaquete las credenciales de seguridad temporales en una instancia del 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.

En el siguiente ejemplo se enumeran las claves del bucket de S3 especificado. En el ejemplo obtiene las credenciales de seguridad temporales para una sesión de dos horas para su usuario federado y utiliza las credenciales para enviar solicitudes autenticadas a Amazon S3. Para ejecutar el ejemplo, debe crear un usuario de IAM con una política adjuntada que permita al usuario solicitar credenciales de seguridad temporales y generar una lista de sus recursos de AWS. La siguiente política lo cumple:


{
  "Statement":[{
      "Action":["s3:ListBucket",
        "sts:GetFederationToken*"
      ],
      "Effect":"Allow",
      "Resource":"*"
    }
  ]
}

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.

Después de crear un usuario de IAM y asociarle la política anterior, puede ejecutar el ejemplo siguiente. 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.policy.Policy;
import com.amazonaws.auth.policy.Resource;
import com.amazonaws.auth.policy.Statement;
import com.amazonaws.auth.policy.Statement.Effect;
import com.amazonaws.auth.policy.actions.S3Actions;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
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.Credentials;
import com.amazonaws.services.securitytoken.model.GetFederationTokenRequest;
import com.amazonaws.services.securitytoken.model.GetFederationTokenResult;

import java.io.IOException;

public class MakingRequestsWithFederatedTempCredentials {

    public static void main(String[] args) throws IOException {
        Regions clientRegion = Regions.DEFAULT_REGION;
        String bucketName = "*** Specify bucket name ***";
        String federatedUser = "*** Federated user name ***";
        String resourceARN = "arn:aws:s3:::" + bucketName;

        try {
            AWSSecurityTokenService stsClient = AWSSecurityTokenServiceClientBuilder
                    .standard()
                    .withCredentials(new ProfileCredentialsProvider())
                    .withRegion(clientRegion)
                    .build();

            GetFederationTokenRequest getFederationTokenRequest = new GetFederationTokenRequest();
            getFederationTokenRequest.setDurationSeconds(7200);
            getFederationTokenRequest.setName(federatedUser);

            // Define the policy and add it to the request.
            Policy policy = new Policy();
            policy.withStatements(new Statement(Effect.Allow)
                    .withActions(S3Actions.ListObjects)
                    .withResources(new Resource(resourceARN)));
            getFederationTokenRequest.setPolicy(policy.toJson());

            // Get the temporary security credentials.
            GetFederationTokenResult federationTokenResult = stsClient.getFederationToken(getFederationTokenRequest);
            Credentials sessionCredentials = federationTokenResult.getCredentials();

            // Package the session credentials as a BasicSessionCredentials
            // object for an Amazon S3 client object to use.
            BasicSessionCredentials basicSessionCredentials = new BasicSessionCredentials(
                    sessionCredentials.getAccessKeyId(),
                    sessionCredentials.getSecretAccessKey(),
                    sessionCredentials.getSessionToken());
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .withCredentials(new AWSStaticCredentialsProvider(basicSessionCredentials))
                    .withRegion(clientRegion)
                    .build();

            // To verify that the client works, send a listObjects request using
            // the temporary security credentials.
            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

Puede proporcionar credenciales de seguridad temporales para sus usuarios federados y aplicaciones, de modo que estos puedan enviar solicitudes autenticadas a fin de obtener acceso a sus recursos de AWS. Al solicitar estas credenciales temporales, debe proporcionar un nombre de usuario y una política de IAM que describa los permisos de recursos que desea otorgar. De forma predeterminada, la sesión dura una hora. Puede solicitar las credenciales de seguridad temporales para usuarios federados y aplicaciones para establecer un valor de duración distinto de forma explícita. Para obtener información acerca del envío de solicitudes autenticadas, consulte Realizar solicitudes.

nota

Cuando solicite las credenciales de seguridad temporales para usuarios federados y aplicaciones, para mayor seguridad le sugerimos que use un usuario de IAM específico que solo tenga los permisos de acceso necesarios. El usuario temporal creado nunca puede obtener más permisos que el usuario de IAM que solicitó las credenciales de seguridad temporales. Para obtener más información, consulte Preguntas frecuentes de AWS Identity and Access Management.

Siga estas instrucciones:

Cree una instancia del cliente de AWS Security Token Service, clase AmazonSecurityTokenServiceClient. Para obtener información acerca de cómo proporcionar las credenciales, consulte Mediante AWS SDK for .NET.
Inicie sesión utilizando el método GetFederationToken del cliente STS. Tiene que proporcionar información acerca de la sesión, como el nombre de usuario y una política de IAM que desee adjuntar a las credenciales temporales. También tiene la posibilidad de proporcionar una duración de sesión. Este método devuelve sus 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 proporcionando las credenciales de seguridad temporales. Use este cliente para enviar solicitudes a Amazon S3. Si envía las solicitudes con las credenciales vencidas, Amazon S3 devolverá un error.

En el siguiente ejemplo de C# se enumeran las claves del bucket especificado. En el ejemplo se obtienen las credenciales de seguridad temporales para una sesión de dos horas para el usuario federado (User1) y se utilizan las credenciales para enviar solicitudes autenticadas a Amazon S3.

Para este ejercicio cree un usuario de IAM con permisos mínimos. Con las credenciales de este usuario de IAM, solicite credenciales temporales para otros usuarios. Este ejemplo solo enumera los objetos de un bucket específico. Cree un usuario de IAM con la siguiente política asociada:
```
{
  "Statement":[{
      "Action":["s3:ListBucket",
        "sts:GetFederationToken*"
      ],
      "Effect":"Allow",
      "Resource":"*"
    }
  ]
}
```
La política permite al usuario de IAM solicitar las credenciales de seguridad temporales y el permiso de acceso solo para mostrar sus recursos de AWS. Para obtener más información acerca de cómo crear un usuario de IAM, consulte Creación del grupo de usuarios y administradores de IAM en la Guía del usuario de IAM.
Use las credenciales de seguridad del usuario de IAM para probar el siguiente ejemplo. En el ejemplo se envía una solicitud autenticada a Amazon S3 con las credenciales de seguridad temporales. En el ejemplo se especifica la siguiente política cuando se solicitan las credenciales de seguridad temporales para el usuario federado (User1), que restringe el acceso para mostrar los objetos de un bucket específico (YourBucketName). Debe actualizar la política y proporcionar su propio nombre de bucket existente.
```
{
  "Statement":[
    {
      "Sid":"1",
      "Action":["s3:ListBucket"],
      "Effect":"Allow", 
      "Resource":"arn:aws:s3:::YourBucketName"
    }
  ]
}
```

Actualice la siguiente muestra y proporcione el nombre de bucket que especificó en la política de acceso del usuario federado anterior. Para obtener instrucciones acerca de cómo crear y probar 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 TempFederatedCredentialsTest
    {
        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 client;

        public static void Main()
        {
            ListObjectsAsync().Wait();
        }

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

                // Create a client by providing temporary security credentials.
                using (client = new AmazonS3Client(bucketRegion))
                {
                    ListObjectsRequest listObjectRequest = new ListObjectsRequest();
                    listObjectRequest.BucketName = bucketName;

                    ListObjectsResponse response = await client.ListObjectsAsync(listObjectRequest);
                    List<S3Object> objects = response.S3Objects;
                    Console.WriteLine("Object count = {0}", objects.Count);

                    Console.WriteLine("Press any key to continue...");
                    Console.ReadKey();
                }
            }
            catch (AmazonS3Exception e)
            {
                Console.WriteLine("Error encountered ***. Message:'{0}' when writing an object", e.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
            }
        }

        private static async Task<SessionAWSCredentials> GetTemporaryFederatedCredentialsAsync()
        {
            AmazonSecurityTokenServiceConfig config = new AmazonSecurityTokenServiceConfig();
            AmazonSecurityTokenServiceClient stsClient =
                new AmazonSecurityTokenServiceClient(
                                             config);

            GetFederationTokenRequest federationTokenRequest =
                                     new GetFederationTokenRequest();
            federationTokenRequest.DurationSeconds = 7200;
            federationTokenRequest.Name = "User1";
            federationTokenRequest.Policy = @"{
               ""Statement"":
               [
                 {
                   ""Sid"":""Stmt1311212314284"",
                   ""Action"":[""s3:ListBucket""],
                   ""Effect"":""Allow"",
                   ""Resource"":""arn:aws:s3:::" + bucketName + @"""
                  }
               ]
             }
            ";

            GetFederationTokenResponse federationTokenResponse =
                        await stsClient.GetFederationTokenAsync(federationTokenRequest);
            Credentials credentials = federationTokenResponse.Credentials;

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

PHP

En este tema, se explica cómo usar clases de la versión 3 de AWS SDK for PHP a fin de solicitar credenciales de seguridad temporales para usuarios federados y aplicaciones, y utilizarlas para obtener acceso a recursos almacenados en Amazon S3. Se parte de la base de que usted ya sigue las instrucciones para Uso del AWS SDK for PHP y ejecución de ejemplos de PHP y ha instalado AWS SDK for PHP correctamente.

Puede proporcionar credenciales de seguridad temporales a sus usuarios federados y aplicaciones para que puedan enviar solicitudes autenticadas a fin de obtener acceso a sus recursos de AWS. Al solicitar estas credenciales temporales, debe proporcionar un nombre de usuario y una política de IAM que describa los permisos de recursos que desea otorgar. Estas credenciales caducan cuando finaliza la duración de la sesión. De forma predeterminada, la sesión durará una hora. Puede solicitar las credenciales de seguridad temporales para usuarios federados y aplicaciones para establecer explícitamente otro valor para la duración. 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 sobre cómo proporcionar credenciales de seguridad temporales a sus usuarios federados y sus aplicaciones, consulte Realizar solicitudes.

Para mayor seguridad, cuando solicite las credenciales de seguridad temporales para usuarios federados y aplicaciones, recomendamos que use un usuario de IAM específico que solo tenga los permisos de acceso necesarios. El usuario temporal creado nunca puede obtener más permisos que el usuario de IAM que solicitó las credenciales de seguridad temporales. Para obtener más información sobre la federación de identidad, consulte Preguntas frecuentes de AWS Identity and Access Management.

Para obtener información acerca de la ejecución de ejemplos de PHP en esta guía, consulte Ejecución de ejemplos de PHP.

ejemplo

En el siguiente ejemplo de PHP se enumeran las claves del bucket especificado. En el ejemplo se obtienen las credenciales de seguridad temporales para una sesión de una hora para el usuario federado (User1). A continuación, use las credenciales de seguridad temporales para enviar solicitudes autenticadas a Amazon S3.

Para mayor seguridad, cuando solicite las credenciales temporales para otros usuarios, utilice las credenciales de seguridad de un usuario de IAM que tenga permisos para solicitar credenciales de seguridad temporales. Para asegurarse de que el usuario de IAM otorga solo los permisos específicos de la aplicación mínimos al usuario federado, también puede limitar los permisos de acceso a este usuario de IAM. En este ejemplo solo se enumera objetos de un bucket específico. Cree un usuario de IAM con la siguiente política asociada:


{
  "Statement":[{
      "Action":["s3:ListBucket",
        "sts:GetFederationToken*"
      ],
      "Effect":"Allow",
      "Resource":"*"
    }
  ]
}

La política permite al usuario de IAM solicitar las credenciales de seguridad temporales y el permiso de acceso solo para mostrar sus recursos 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.

Ahora puede utilizar las credenciales de seguridad del usuario de IAM para probar el siguiente ejemplo. En el ejemplo se envía una solicitud autenticada a Amazon S3 con las credenciales de seguridad temporales. Cuando solicite las credenciales de seguridad temporales para el usuario federado (User1), el ejemplo especifica la política siguiente, que restringe el acceso para enumerar los objetos de un bucket específico. Actualice la política con el nombre de su bucket.


{
  "Statement":[
    {
      "Sid":"1",
      "Action":["s3:ListBucket"],
      "Effect":"Allow", 
      "Resource":"arn:aws:s3:::YourBucketName"
    }
  ]
}

En el siguiente ejemplo, al especificar el recurso de política, reemplace YourBucketName por el nombre del bucket.


 require 'vendor/autoload.php';

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

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

// In real applications, the following code is part of your trusted code. It has
// the security credentials that you use to obtain temporary security credentials.
$sts = new StsClient([
    'version' => 'latest',
    'region' => 'us-east-1'
]);

// Fetch the federated credentials.
$sessionToken = $sts->getFederationToken([
    'Name'              => 'User1',
    'DurationSeconds'    => '3600',
    'Policy'            => json_encode([
        'Statement' => [
            'Sid'              => 'randomstatementid' . time(),
            'Action'           => ['s3:ListBucket'],
            'Effect'           => 'Allow',
            'Resource'         => 'arn:aws:s3:::' . $bucket
        ]
    ])
]);

// The following will be part of your less trusted code. You provide temporary
// security credentials so the code can send authenticated requests to Amazon S3.

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

try {
    $result = $s3->listObjects([
        'Bucket' => $bucket
    ]);
} catch (S3Exception $e) {
    echo $e->getMessage() . PHP_EOL;
}

Ruby

Puede proporcionar credenciales de seguridad temporales para sus usuarios federados y aplicaciones, de modo que estos puedan enviar solicitudes autenticadas a fin de obtener acceso a sus recursos de AWS. Al solicitar estas credenciales temporales al servicio de IAM, debe proporcionar un nombre de usuario y una política de IAM que describa los permisos de recursos que desea conceder. De forma predeterminada, la sesión durará una hora. Sin embargo, si solicita las credenciales temporales con las credenciales de usuario de IAM, puede solicitar las credenciales de seguridad temporales para usuarios federados y aplicaciones para establecer un valor de duración distinto de forma explícita. Para obtener más información sobre cómo proporcionar credenciales de seguridad temporales para sus usuarios federados y sus aplicaciones, consulte Realizar solicitudes.

nota

Para mayor seguridad, cuando solicita las credenciales de seguridad temporales para usuarios federados y aplicaciones, se recomienda utilizar un usuario de IAM específico que solo tenga los permisos de acceso necesarios. El usuario temporal creado nunca puede obtener más permisos que el usuario de IAM que solicitó las credenciales de seguridad temporales. Para obtener más información, consulte Preguntas frecuentes de AWS Identity and Access Management.

ejemplo

En el siguiente ejemplo de código Ruby se permite que un usuario federado con un conjunto limitado de permisos enumere las clave en el bucket especificado.


# Prerequisites:
#  - An existing Amazon S3 bucket.

require "aws-sdk-s3"
require "aws-sdk-iam"
require "json"

# Checks to see whether a user exists in IAM; otherwise,
# creates the user.
#
# @param iam [Aws::IAM::Client] An initialized IAM client.
# @param user_name [String] The user's name.
# @return [Aws::IAM::Types::User] The existing or new user.
# @example
#   iam = Aws::IAM::Client.new(region: 'us-west-2')
#   user = get_user(iam, 'my-user')
#   exit 1 unless user.user_name
#   puts "User's name: #{user.user_name}"
def get_user(iam, user_name)
  puts "Checking for a user with the name '#{user_name}'..."
  response = iam.get_user(user_name: user_name)
  puts "A user with the name '#{user_name}' already exists."
  return response.user
# If the user doesn't exist, create them.
rescue Aws::IAM::Errors::NoSuchEntity
  puts "A user with the name '#{user_name}' doesn't exist. Creating this user..."
  response = iam.create_user(user_name: user_name)
  iam.wait_until(:user_exists, user_name: user_name)
  puts "Created user with the name '#{user_name}'."
  return response.user
rescue StandardError => e
  puts "Error while accessing or creating the user named '#{user_name}': #{e.message}"
end

# Gets temporary AWS credentials for an IAM user with the specified permissions.
#
# @param sts [Aws::STS::Client] An initialized AWS STS client.
# @param duration_seconds [Integer] The number of seconds for valid credentials.
# @param user_name [String] The user's name.
# @param policy [Hash] The access policy.
# @return [Aws::STS::Types::Credentials] AWS credentials for API authentication.
# @example
#   sts = Aws::STS::Client.new(region: 'us-west-2')
#   credentials = get_temporary_credentials(sts, duration_seconds, user_name,
#     {
#       'Version' => '2012-10-17',
#       'Statement' => [
#         'Sid' => 'Stmt1',
#         'Effect' => 'Allow',
#         'Action' => 's3:ListBucket',
#         'Resource' => 'arn:aws:s3:::doc-example-bucket'
#       ]
#     }
#   )
#   exit 1 unless credentials.access_key_id
#   puts "Access key ID: #{credentials.access_key_id}"
def get_temporary_credentials(sts, duration_seconds, user_name, policy)
  response = sts.get_federation_token(
    duration_seconds: duration_seconds,
    name: user_name,
    policy: policy.to_json
  )
  return response.credentials
rescue StandardError => e
  puts "Error while getting federation token: #{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

# Example usage:
def run_me
  region = "us-west-2"
  user_name = "my-user"
  bucket_name = "doc-example-bucket"

  iam = Aws::IAM::Client.new(region: region)
  user = get_user(iam, user_name)

  exit 1 unless user.user_name

  puts "User's name: #{user.user_name}"
  sts = Aws::STS::Client.new(region: region)
  credentials = get_temporary_credentials(sts, 3600, user_name,
    {
      "Version" => "2012-10-17",
      "Statement" => [
        "Sid" => "Stmt1",
        "Effect" => "Allow",
        "Action" => "s3:ListBucket",
        "Resource" => "arn:aws:s3:::#{bucket_name}"
      ]
    }
  )

  exit 1 unless credentials.access_key_id

  puts "Access key ID: #{credentials.access_key_id}"
  s3_client = Aws::S3::Client.new(region: region, credentials: credentials)

  exit 1 unless list_objects_in_bucket?(s3_client, bucket_name)
end

run_me if $PROGRAM_NAME == __FILE__

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 temporales de usuario de IAM

Realizar solicitudes con la API REST