Esecuzione di richieste mediante le credenziali temporanee per gli utenti IAM

Un utente IAM Account AWS o un utente IAM può richiedere credenziali di sicurezza temporanee e utilizzarle per inviare richieste autenticate ad Amazon S3. In questa sezione sono riportati esempi sull'utilizzo degli SDK AWS SDK for Java, .NET e PHP per ottenere credenziali di sicurezza temporanee con cui autenticare le richieste ad Amazon S3.

Java

Un utente IAM o un utente Account AWS può richiedere credenziali di sicurezza temporanee (vediEsecuzione di richieste) utilizzando AWS SDK for Java e utilizzarle per accedere ad Amazon S3. Queste credenziali scadono al termine della durata della sessione specificata.

Per default, la sessione dura un'ora. Se si utilizzano le credenziali utente IAM, è possibile specificare la durata della richiesta delle credenziali di protezione temporanee da 15 minuti alla durata massima della sessione per il ruolo. Per ulteriori informazioni sulle credenziali di sicurezza temporanee, consulta la sezione relativa alle credenziali di sicurezza temporanee nella Guida per l'utente IAM. Per ulteriori informazioni sull'esecuzione di richieste, consulta Esecuzione di richieste.

Per ottenere credenziali di sicurezza temporanee e accedere ad Amazon S3

Crea un'istanza della classe AWSSecurityTokenService. Per ulteriori informazioni sulla specifica delle credenziali, consulta Sviluppo con Amazon S3 utilizzando gli SDK AWS.
Recuperare le credenziali di sicurezza temporanee per il ruolo desiderato chiamando il metodo assumeRole() del client Security Token Service (STS).
Creare un pacchetto di credenziali di sicurezza temporanee in un 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 con credenziali scadute, Amazon S3 restituirà un errore.

Nota

Se si ottengono credenziali di sicurezza temporanee utilizzando le credenziali di sicurezza dell' Account AWS , le credenziali temporanee rimarranno valide solo per un'ora. È possibile specificare la durata della sessione solo se si utilizzano le credenziali utente Amazon S3 per richiedere una sessione.

L'esempio seguente elenca un set di chiavi degli oggetti incluse nel bucket specificato. L'esempio ottiene le credenziali di sicurezza temporanee per una sessione e le utilizza per inviare una richiesta autenticata ad Amazon S3.

Per testare l'esempio utilizzando le credenziali di un utente IAM, è necessario creare un utente IAM nell' Account AWS. Per ulteriori informazioni su come creare un utente IAM, consulta Creazione del primo utente IAM e del gruppo di amministratori nella Guida per l'utente di IAM.

Per istruzioni su come creare e testare un esempio funzionante, consulta Getting Started nella AWS SDK for Java Developer Guide.



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 utente IAM o un utente Account AWS può richiedere credenziali di sicurezza temporanee utilizzando AWS SDK for .NET e utilizzarle per accedere ad Amazon S3. Queste credenziali scadono al termine della durata della sessione.

Per ottenere credenziali di sicurezza temporanee e accedere ad Amazon S3

Crea un'istanza del AWS Security Token Service client,. AmazonSecurityTokenServiceClient Per ulteriori informazioni sulla specifica delle credenziali, consulta Sviluppo con Amazon S3 utilizzando gli SDK AWS.
Avviare una sezione richiamando il metodo GetSessionToken del client STS creato nella fase precedente. Le informazioni sulla sessione vengono fornite al metodo tramite un oggetto GetSessionTokenRequest.

Il 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. 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.

Nota

Se si ottengono credenziali di sicurezza temporanee utilizzando le credenziali di sicurezza dell' Account AWS , le credenziali temporanee rimarranno valide solo per un'ora. Puoi specificare la durata di una sessione solo se utilizzi le credenziali utente IAM per richiedere una sessione.

L'esempio di codice C# seguente elenca le chiavi degli oggetti incluse nel bucket specificato. A titolo illustrativo, l'esempio ottiene le credenziali di sicurezza temporanee per una sessione di default della durata di un'ora e le utilizza per inviare una richiesta autenticata ad Amazon S3.

Per informazioni sulla configurazione e l'esecuzione degli esempi di codice, consulta Getting Started with the AWS SDK for .NET nella AWS SDK for .NET Developer Guide.


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

Per ulteriori informazioni sull'API AWS SDK for Ruby, AWS vai a SDK for Ruby - Versione 2.

Un utente IAM o un utente Account AWS può richiedere credenziali di sicurezza temporanee utilizzando la versione 3 di. AWS SDK for PHP Può quindi utilizzare tali credenziali per accedere ad Amazon S3. Le credenziali scadono alla fine della durata della sessione.

Nota

Se si ottengono credenziali di sicurezza temporanee utilizzando le credenziali di sicurezza dell' Account AWS , le credenziali di sicurezza temporanee rimarranno valide solo per un'ora. È possibile specificare la durata della sessione solo se si utilizzano le credenziali utente Amazon S3 per richiedere una sessione.

L'esempio di codice PHP seguente elenca le chiavi degli oggetti incluse nel bucket specificato utilizzando credenziali di sicurezza temporanee. L'esempio ottiene le credenziali di sicurezza temporanee per una sessione di default della durata di un'ora e le utilizza per inviare una richiesta autenticata ad Amazon S3. Per ulteriori informazioni sull'API AWS SDK for Ruby, AWS vai a SDK for Ruby - Versione 2.

Per testare l'esempio utilizzando le credenziali di un utente IAM, è necessario creare un utente IAM nell' Account AWS. Per informazioni su come creare un utente IAM, consulta Creazione del primo utente IAM e del gruppo di amministratori nella Guida per l'utente IAM. Per degli esempi di impostazione della durata della sessione quando si utilizzano le credenziali utente IAM per richiedere una sessione, consulta Esecuzione di richieste mediante le credenziali temporanee per gli utenti 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 utente IAM o un utente Account AWS può richiedere credenziali di sicurezza AWS SDK for Ruby temporanee utilizzandole per accedere ad Amazon S3. Queste credenziali scadono al termine della durata della sessione.

Nota

Se si ottengono credenziali di sicurezza temporanee utilizzando le credenziali di sicurezza dell' Account AWS , le credenziali di sicurezza temporanee rimarranno valide solo per un'ora. Puoi specificare la durata della sessione solo se utilizzi le credenziali utente IAM per richiedere una sessione.

Nel seguente esempio di codice Ruby viene creato un utente temporaneo per elencare le voci in un bucket specificato per un'ora. Per utilizzare questo esempio, devi disporre di AWS credenziali con le autorizzazioni necessarie per creare nuovi AWS Security Token Service (AWS STS) client ed elencare i bucket 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

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 delle nostre Account AWS credenziali utente IAM

Utilizzo delle credenziali temporanee per gli utenti federati