Esecuzione di richieste mediante le credenziali temporanee per gli utenti federati

È possibile richiedere credenziali di sicurezza temporanee e fornirle agli utenti o alle applicazioni federati che devono accedere al AWS risorse. Questa sezione fornisce esempi di come è possibile utilizzare AWS SDKper ottenere credenziali di sicurezza temporanee per gli utenti o le applicazioni federati e inviare richieste autenticate ad Amazon S3 utilizzando tali credenziali. Per un elenco di quelli disponibili AWS SDKs, vedi Codice di esempio e librerie.

Nota

Entrambi i Account AWS e un IAM utente può richiedere credenziali di sicurezza temporanee per gli utenti federati. Tuttavia, per una maggiore sicurezza, solo un IAM utente con le autorizzazioni necessarie dovrebbe richiedere queste credenziali temporanee per garantire che l'utente federato ottenga al massimo le autorizzazioni dell'utente richiedente. IAM In alcune applicazioni, potrebbe essere opportuno creare un IAM utente con autorizzazioni specifiche al solo scopo di concedere credenziali di sicurezza temporanee agli utenti e alle applicazioni federati.

Java

È possibile fornire credenziali di sicurezza temporanee per gli utenti e le applicazioni federati in modo che possano inviare richieste autenticate per accedere ai AWS risorse. Quando si richiedono queste credenziali temporanee, è necessario fornire un nome utente e una IAM politica che descriva le autorizzazioni per le risorse che si desidera concedere. Per default, la sessione dura un'ora. In fase di richiesta delle credenziali di sicurezza temporanee per utenti federati e applicazioni, è possibile impostare in modo esplicito un valore di durata diverso.

Nota

Per una maggiore sicurezza quando si richiedono credenziali di sicurezza temporanee per utenti e applicazioni federati, si consiglia di utilizzare un IAM utente dedicato con solo le autorizzazioni di accesso necessarie. L'utente temporaneo che crei non potrà mai ottenere più autorizzazioni IAM dell'utente che ha richiesto le credenziali di sicurezza temporanee. Per ulteriori informazioni, consulta AWS Identity and Access Management FAQs .

Per fornire credenziali di sicurezza e inviare una richiesta autenticata per accedere alle risorse, procedere come segue:

Crea un'istanza della classe AWSSecurityTokenServiceClient.
Avvia una sessione chiamando il getFederationToken() metodo del client Security Token Service (STS). Fornite le informazioni sulla sessione, tra cui il nome utente e una IAM policy, che desiderate allegare alle credenziali temporanee. È possibile specificare una durata della sessione opzionale. Questo metodo restituisce le credenziali di sicurezza temporanee.
Creare un pacchetto di credenziali di sicurezza temporanee in un'istanza dell'oggetto BasicSessionCredentials. Tale oggetto viene utilizzato per specificare le credenziali di sicurezza temporanee per il client Amazon S3.
Creare un'istanza della classe AmazonS3Client utilizzando le credenziali di sicurezza temporanee. Le richieste vengono inviate ad Amazon S3 con questo client. In caso di invio di richieste mediante l'utilizzo di credenziali scadute, Amazon S3 restituisce un errore.

L'esempio elenca le chiavi nel bucket S3 specificato. Nell'esempio, è necessario ottenere le credenziali di sicurezza temporanee per l'utente federato per una sessione della durata di due ore e utilizzare le credenziali per inviare richieste autenticate ad Amazon S3. Per eseguire l'esempio, è necessario creare un IAM utente con una politica allegata che consenta all'utente di richiedere credenziali di sicurezza temporanee ed elencare le AWS risorse. Questa policy esegue quanto segue:


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

Per ulteriori informazioni su come creare un IAM utente, vedere Creazione del primo IAM utente e gruppo di amministratori nella Guida per l'IAMutente.

Dopo aver creato un IAM utente e aver allegato la politica precedente, è possibile eseguire l'esempio seguente. Per istruzioni sulla creazione e sul test di un esempio funzionante, consulta la Guida introduttiva in AWS SDK for Java Guida per gli sviluppatori.



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

È possibile fornire credenziali di sicurezza temporanee per gli utenti e le applicazioni federati in modo che possano inviare richieste autenticate di accesso al AWS risorse. Quando si richiedono queste credenziali temporanee, è necessario fornire un nome utente e una IAM politica che descriva le autorizzazioni per le risorse che si desidera concedere. Per impostazione predefinita, la sessione dura un'ora. In fase di richiesta delle credenziali di sicurezza temporanee per utenti federati e applicazioni, è possibile impostare in modo esplicito un valore di durata diverso. Per informazioni sull'invio di richieste autenticate, consulta Esecuzione di richieste.

Nota

Quando si richiedono credenziali di sicurezza temporanee per utenti e applicazioni federati, per una maggiore sicurezza, si consiglia di utilizzare un IAM utente dedicato con solo le autorizzazioni di accesso necessarie. L'utente temporaneo che crei non potrà mai ottenere più autorizzazioni IAM dell'utente che ha richiesto le credenziali di sicurezza temporanee. Per ulteriori informazioni, consulta AWS Identity and Access Management FAQs .

Esegui le operazioni indicate di seguito:

Crea un'istanza di AWS Security Token Service cliente, AmazonSecurityTokenServiceClient classe.
Inizia una sessione chiamando il GetFederationToken metodo del STS client. È necessario fornire informazioni sulla sessione, incluso il nome utente e una IAM politica da allegare alle credenziali temporanee. Eventualmente, è possibile specificare una durata della sessione. Questo metodo restituisce le credenziali di sicurezza temporanee.
Creare un pacchetto di credenziali di sicurezza temporanee in un'istanza dell'oggetto SessionAWSCredentials. Tale oggetto viene utilizzato per specificare le credenziali di sicurezza temporanee per il client Amazon S3.
Creare un'istanza della classe AmazonS3Client passando le credenziali di sicurezza temporanee. Con questo client, le richieste vengono inviate ad Amazon S3. In caso di invio di richieste mediante l'utilizzo di credenziali scadute, Amazon S3 restituisce un errore.

L'esempio C# seguente elenca le chiavi incluse nel bucket specificato. Nell'esempio, è necessario ottenere le credenziali di sicurezza temporanee per l'utente federato (User1) per una sessione della durata di due ore e utilizzare le credenziali per inviare richieste autenticate a Amazon S3.

Per questo esercizio, creerai un IAM utente con autorizzazioni minime. Utilizzando le credenziali di questo IAM utente, richiedi credenziali temporanee per altri utenti. In questo esempio sono elencati solo gli oggetti di un bucket specifico. Crea un IAM utente con la seguente politica allegata:
```
{
  "Statement":[{
      "Action":["s3:ListBucket",
        "sts:GetFederationToken*"
      ],
      "Effect":"Allow",
      "Resource":"*"
    }
  ]
}
```
La policy consente all'IAMutente di richiedere credenziali di sicurezza temporanee e autorizzazioni di accesso solo per elencare i AWS risorse. Per ulteriori informazioni su come creare un IAM utente, vedere Creazione del gruppo di IAM utenti e amministratori nella Guida per l'IAMutente.
Utilizzate le credenziali di sicurezza IAM dell'utente per testare l'esempio seguente. Nell'esempio vengono inviate richieste autenticate ad Amazon S3 mediante le credenziali di sicurezza temporanee. Nell'esempio è specificata la seguente policy durante la richiesta di credenziali di sicurezza temporanee per l'utente federato (User1) con accesso limitato agli elenchi di oggetti di un bucket specifico (YourBucketName). Occorre specificare la policy e fornire il nome del bucket esistente.
```
{
  "Statement":[
    {
      "Sid":"1",
      "Action":["s3:ListBucket"],
      "Effect":"Allow", 
      "Resource":"arn:aws:s3:::YourBucketName"
    }
  ]
}
```

Aggiorna il seguente esempio e fornire il nome del bucket specificato nella precedente policy di accesso dell'utente federato. Per informazioni sulla configurazione e l'esecuzione degli esempi di codice, consulta Getting Started with the AWS SDKper. NETnel AWS SDKper. NETGuida per gli sviluppatori.


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

Questo argomento spiega come utilizzare le classi della versione 3 di AWS SDK for PHP per richiedere credenziali di sicurezza temporanee per utenti e applicazioni federati e utilizzarle per accedere alle risorse archiviate in Amazon S3. Per ulteriori informazioni su AWS SDKper RubyAPI, vai a AWS SDKper Ruby - Versione 2.

È possibile fornire credenziali di sicurezza temporanee agli utenti e alle applicazioni federati in modo che possano inviare richieste autenticate per accedere ai AWS risorse. Quando si richiedono queste credenziali temporanee, è necessario fornire un nome utente e una IAM politica che descriva le autorizzazioni per le risorse che si desidera concedere. Queste credenziali scadono alla scadenza della durata della sessione. Per default, la sessione dura un'ora. In fase di richiesta delle credenziali di sicurezza temporanee per utenti federati e applicazioni, è possibile impostare in modo esplicito un valore di durata diverso. Per ulteriori informazioni sulle credenziali di sicurezza temporanee, vedere Credenziali di sicurezza temporanee nella Guida per l'utente. IAM Per ulteriori informazioni sulla specifica delle credenziali di sicurezza temporanee alle applicazioni e agli utenti federati, consulta Esecuzione di richieste.

Per una maggiore sicurezza quando si richiedono credenziali di sicurezza temporanee per utenti e applicazioni federati, si consiglia di utilizzare un IAM utente dedicato con solo le autorizzazioni di accesso necessarie. L'utente temporaneo che crei non potrà mai ottenere più autorizzazioni IAM dell'utente che ha richiesto le credenziali di sicurezza temporanee. Per informazioni sulla federazione delle identità, vedere AWS Identity and Access Management FAQs.

Per ulteriori informazioni su AWS SDKper RubyAPI, vai a AWS SDKper Ruby - Versione 2.

Esempio

L'PHPesempio seguente elenca le chiavi nel bucket specificato. Nell'esempio, è necessario ottenere le credenziali di sicurezza temporanee per l'utente federato (User1) per una sessione della durata di un'ora. Poi si utilizzano le credenziali di sicurezza temporanee per inviare richieste autenticate ad Amazon S3.

Per una maggiore sicurezza quando si richiedono credenziali temporanee per altri, si utilizzano le credenziali di sicurezza di un IAM utente che dispone delle autorizzazioni per richiedere credenziali di sicurezza temporanee. Per garantire che l'IAMutente conceda solo le autorizzazioni minime specifiche dell'applicazione all'utente federato, puoi anche limitare le autorizzazioni di accesso di questo utente. IAM In questo esempio sono elencati solo gli oggetti di un bucket specifico. Crea un utente con la seguente politica allegataIAM:


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

La policy consente all'IAMutente di richiedere credenziali di sicurezza temporanee e autorizzazioni di accesso solo per elencare i AWS risorse. Per ulteriori informazioni su come creare un IAM utente, vedere Creazione del primo IAM utente e gruppo di amministratori nella Guida per l'IAMutente.

È ora possibile utilizzare le credenziali di sicurezza IAM dell'utente per testare l'esempio seguente. Nell'esempio viene inviata una richiesta autenticata ad Amazon S3 mediante credenziali di sicurezza temporanee. Durante la richiesta di credenziali di sicurezza temporanee per l'utente federato (User1), nell'esempio è specificata la seguente policy, con accesso limitato agli oggetti dell'elenco di un bucket specifico. Aggiornare la policy con il nome del bucket.


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

Nell'esempio che segue, quando specifichi la risorsa della policy, è necessario sostituire YourBucketName con il nome del tuo 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

È possibile fornire credenziali di sicurezza temporanee per gli utenti e le applicazioni federati in modo che possano inviare richieste autenticate per accedere ai AWS risorse. Quando si richiedono credenziali temporanee al IAM servizio, è necessario fornire un nome utente e una IAM politica che descriva le autorizzazioni per le risorse che si desidera concedere. Per default, la sessione dura un'ora. Tuttavia, se si richiedono credenziali temporanee utilizzando credenziali IAM utente, è possibile impostare in modo esplicito un valore di durata diverso quando si richiedono le credenziali di sicurezza temporanee per utenti e applicazioni federati. Per ulteriori informazioni sulle credenziali di sicurezza temporanee per le applicazioni e gli utenti federati, consulta Esecuzione di richieste.

Nota

Per una maggiore sicurezza quando richiedi credenziali di sicurezza temporanee per utenti e applicazioni federati, potresti voler utilizzare un utente dedicato con solo le autorizzazioni di accesso necessarie. IAM L'utente temporaneo che crei non potrà mai ottenere più autorizzazioni IAM dell'utente che ha richiesto le credenziali di sicurezza temporanee. Per ulteriori informazioni, consulta AWS Identity and Access Management FAQs .

Esempio

Nel seguente esempio di codice Ruby consente a un utente con una serie limitata di autorizzazione per visualizzare le chiavi nel bucket specificato.


# 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:::amzn-s3-demo-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, 'amzn-s3-demo-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 = "amzn-s3-demo-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__

Risorse correlate

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Utilizzo di credenziali temporanee per gli utenti IAM

Effettuare richieste utilizzando il REST API