Envoi de demandes à l'aide des informations d'identification temporaires des utilisateurs IAM

Un Compte AWS ou un utilisateur IAM peut demander des informations d'identification de sécurité temporaires et les utiliser pour envoyer des demandes authentifiées à Amazon S3. Cette section fournit des exemples d'utilisation des kits AWS SDK for Java SDK pour Java, .NET, and PHP afin d'obtenir des informations d'identification de sécurité temporaires et de les utiliser pour authentifier vos demandes à Amazon S3.

Java

Un utilisateur IAM ou un Compte AWS peut demander des informations d'identification de sécurité temporaires (veuillez consulter Demandes) à l'aide du kit AWS SDK for Java et les utiliser pour accéder à Amazon S3. Ces informations d'identification expirent à la fin de session spécifiée.

Par défaut, la session dure une heure. Si vous utilisez les informations d'identification des utilisateurs IAM, vous pouvez spécifier la durée (de 15 minutes à la durée maximale de session pour le rôle) lors de la demande d'informations d'identification de sécurité temporaires. Pour en savoir plus sur les informations d'identification de sécurité temporaires, veuillez consulter Informations d'identification de sécurité temporaires dans le Guide de l'utilisateur IAM. Pour plus d'informations sur la création de demandes, consultez Demandes.

Pour obtenir des informations d'identification de sécurité temporaires et accéder à Amazon S3

Créez une instance de la classe AWSSecurityTokenService. Pour en savoir plus sur les informations d'identification, consultez Développer avec Amazon S3 à l'aide des kits SDK AWS et des explorateurs.
Récupérez les informations d'identification de sécurité temporaires pour le rôle souhaité en appelant la méthode assumeRole() du client STS (Security Token Service).
Regroupez les informations d'identification de sécurité temporaires dans un objet BasicSessionCredentials. Vous utilisez cet objet pour fournir les informations d'identification de sécurité temporaires à votre client Amazon S3.
Créez une instance de la classe AmazonS3Client à l'aide des informations d'identification de sécurité temporaires. Vous envoyez des demandes à Amazon S3 grâce à ce client. Si vous envoyez des demandes à l'aide d'informations d'identification expirées, Amazon S3 renvoie une erreur.

Note

Si vous obtenez les informations d'identification de sécurité temporaires à l'aide des informations d'identification de sécurité du Compte AWS, les informations d'identification de sécurité temporaires ne sont valides que pendant une heure. Vous pouvez spécifier la durée de session uniquement si vous utilisez les informations d'identification des utilisateurs IAM pour demander une session.

L'exemple suivant répertorie un ensemble de clés d'objet dans le compartiment spécifié. L'exemple obtient les informations d'identification de sécurité temporaires pour une session et les utilise pour envoyer une demande authentifiée à Amazon S3.

Si vous souhaitez tester l'exemple à l'aide des informations d'identification de l'utilisateur IAM, vous devez créer un utilisateur IAM sous votre Compte AWS. Pour de plus amples informations sur la création d'un utilisateur IAM, veuillez consulter Création de votre premier groupe d'utilisateurs et d'administrateurs IAM dans le Guide de l'utilisateur IAM.

Pour obtenir les instructions sur la création et le test d'un exemple pratique, consultez Test des exemples de code Java 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 utilisateur IAM ou un Compte AWS peut demander des informations d'identification de sécurité temporaires à l'aide du kit AWS SDK for .NET et les utiliser pour accéder à Amazon S3. Ces informations d'identification expirent à la fin de la session.

Pour obtenir des informations d'identification de sécurité temporaires et accéder à Amazon S3

Créez une instance du client AWS Security Token Service, AmazonSecurityTokenServiceClient. Pour en savoir plus sur les informations d'identification, consultez Développer avec Amazon S3 à l'aide des kits SDK AWS et des explorateurs.
Lancez une session en appelant la méthode GetSessionToken du client STS que vous avez créé dans l'étape précédente. Vous fournissez des informations de session à cette méthode grâce à un objet GetSessionTokenRequest.

La méthode renvoie les informations d'identification de sécurité temporaires.
Regroupez les informations d'identification de sécurité temporaires dans une instance de l'objet SessionAWSCredentials. Vous utilisez cet objet pour fournir les informations d'identification de sécurité temporaires à votre client Amazon S3.
Créez une instance de la classe AmazonS3Client en fournissant les informations d'identification de sécurité temporaires. Vous envoyez des demandes à Amazon S3 grâce à ce client. Si vous envoyez des demandes à l'aide d'informations d'identification expirées, Amazon S3 renvoie une erreur.

Note

Si vous obtenez les informations d'identification de sécurité temporaires à l'aide des informations d'identification de sécurité de votre Compte AWS, ces informations d'identification de sécurité temporaires ne sont valides que pendant une heure. Vous pouvez spécifier une durée de session uniquement si vous utilisez les informations d'identification des utilisateurs IAM pour demander une session.

L'exemple C# suivant répertorie les clés d'objet dans le compartiment spécifié. À titre d'illustration, l'exemple obtient des informations d'identification de sécurité temporaires pour une session d'une heure par défaut et les utilise pour envoyer une demande authentifiée à Amazon S3.

Pour obtenir les instructions sur la création et le test d'un exemple pratique, consultez Exécution des exemples de code .NET 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

Cet exemple part du principe que vous suivez déjà les instructions pour Utilisation du kit AWS SDK for PHP et exécution d'exemples PHP et que le kit AWS SDK for PHP est correctement installé.

Un utilisateur IAM ou un compte Compte AWS peuvent demander des informations d'identification de sécurité temporaires avec la version 3 du kit AWS SDK for PHP. Puis, il utilise les informations d'identification temporaires pour accéder à Amazon S3. Les informations d'identification expirent à la fin de la session.

Note

Si vous obtenez des informations d'identification de sécurité temporaires grâce aux informations d'identification de sécurité du Compte AWS, les informations d'identification de sécurité temporaires ne sont valides que pendant une heure. Vous pouvez spécifier la durée de session uniquement si vous utilisez les informations d'identification des utilisateurs IAM pour demander une session.

L'exemple de PHP suivant liste les clés d'objet dans le compartiment spécifié grâce aux informations d'identification de sécurité temporaires. L'exemple obtient des informations d'identification de sécurité temporaires pour une session d'une heure par défaut, et les utilise pour envoyer une demande authentifiée à Amazon S3. Pour en savoir plus sur l'exécution des exemples PHP dans ce guide, consultez Exécution d'exemples PHP.

Si vous souhaitez tester l'exemple à l'aide des informations d'identification de l'utilisateur IAM, vous devez créer un utilisateur IAM sous votre. Compte AWS Pour plus d'informations sur la création d'un utilisateur IAM, consultez la section Création de votre premier utilisateur IAM et de votre premier groupe d'administrateurs dans le guide de l'utilisateur IAM. Pour obtenir des exemples de configuration de la durée de la session lors de l’utilisation des informations d’identification des utilisateurs IAM pour demander une session, veuillez consulter Envoi de demandes à l'aide des informations d'identification temporaires des utilisateurs 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 utilisateur IAM ou un Compte AWS peuvent demander des informations d'identification de sécurité temporaires à l'aide du kit AWS SDK for Ruby, et les utiliser pour accéder à Amazon S3. Ces informations d'identification expirent à la fin de la session.

Note

Si vous obtenez des informations d'identification de sécurité temporaires grâce aux informations d'identification de sécurité de votre Compte AWS, les informations d'identification de sécurité temporaires ne sont valides que pendant une heure. Vous pouvez spécifier une durée de session uniquement si vous utilisez les informations d'identification des utilisateurs IAM pour demander une session.

L'exemple de code Ruby suivant crée un utilisateur temporaire afin de répertorier les éléments d'un compartiment spécifié pendant une heure. Pour utiliser cet exemple, vous devez avoir les informations d'identification AWS qui ont les autorisations nécessaires pour créer de nouveaux clients AWS Security Token Service (AWS STS) et répertorier les compartiments 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

Ressources connexes

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Utilisation du Compte AWS ou des informations d'identification de l'utilisateur IAM

Utilisation des informations d'identification temporaires de l'utilisateur fédéré