Anfragen unter Verwendung temporärer Anmeldeinformationen für IAM-Benutzer erstellen

Ein AWS-Konto- oder IAM-Benutzer kann temporäre Sicherheitsanmeldeinformationen beantragen und damit authentifizierte Anfragen an Amazon S3 senden. Dieser Abschnitt enthält Beispiele, wie Sie das AWS SDK for Java, .NET und PHP verwenden können, um temporäre Sicherheitsanmeldeinformationen zu erhalten und diese zur Authentifizierung Ihrer Anfragen an Amazon S3 zu verwenden.

Java

Ein IAM-Benutzer oder ein AWS-Konto kann temporäre Sicherheitsanmeldeinformationen (siehe Senden von Anforderungen) über das AWS SDK for Java anfordern und sie für den Zugriff auf Amazon S3 verwenden. Diese Anmeldeinformationen laufen nach der angegebenen Sitzungsdauer ab.

Die Sitzungsdauer beträgt standardmäßig eine Stunde. Wenn Sie IAM-Benutzer-Anmeldeinformationen verwenden, können Sie als Dauer, nach der die temporären Sicherheitsanmeldeinformationen angefordert werden sollen, eine Zeitspanne zwischen 15 Minuten und der maximalen Sitzungsdauer für die Rolle angeben. Weitere Informationen zu temporären Anmeldeinformationen finden Sie unter Temporäre Sicherheitsanmeldeinformationen im IAM-Benutzerhandbuch. Weitere Informationen zum Senden von Anfragen finden Sie unter Senden von Anforderungen.

So rufen Sie temporäre Sicherheitsanmeldeinformationen ab und greifen auf Amazon S3 zu

Erstellen Sie eine Instance der AWSSecurityTokenService-Klasse. Weitere Informationen zum Bereitstellen von Anmeldeinformationen finden Sie unter Entwickeln mit Amazon S3 unter Verwendung der AWS-SDKs und Explorer.
Rufen Sie die temporären Sicherheitsanmeldeinformationen für die gewünschte Rolle ab, indem Sie die assumeRole()-Methode des Security Token Service (STS) -Clients aufrufen.
Bündeln Sie die temporären Sicherheitsanmeldeinformationen in einem BasicSessionCredentials-Objekt. Sie verwenden dieses Objekt, um die temporären Sicherheitsanmeldeinformationen für Ihren Amazon-S3-Client bereitzustellen.
Erstellen Sie mit den temporären Sicherheitsanmeldeinformationen eine Instance der AmazonS3Client-Klasse. Mit diesem Client senden Sie Anfragen an Amazon S3. Wenn Sie beim Senden von Anfragen abgelaufene Anmeldeinformationen verwenden, gibt Amazon S3 einen Fehler zurück.

Anmerkung

Wenn Sie unter Verwendung der Sicherheitsanmeldeinformationen Ihres AWS-Konto temporäre Sicherheitsanmeldeinformationen erhalten haben, sind sie nur eine Stunde lang gültig. Sie können eine Sitzungsdauer nur dann festlegen, wenn Sie IAM-Benutzer-Anmeldeinformationen verwenden, um eine Sitzung anzufordern.

Das folgende Beispiel listet einen Satz von Objektschlüsseln im angegebenen Bucket auf. Das Beispiel fordert temporäre Sicherheitsanmeldeinformationen für eine Sitzung an, die dann zum Senden einer authentifizierten Anfrage an Amazon S3 verwendet werden.

Anweisungen zum Erstellen und Testen eines funktionierenden Beispiels finden Sie unter Testen der Java-Codebeispiele für 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

Ein IAM-Benutzer oder ein AWS-Konto kann temporäre Sicherheitsanmeldeinformationen über das AWS SDK for .NET anfordern und sie für den Zugriff auf Amazon S3 verwenden. Diese Anmeldeinformationen laufen nach Ende der Sitzung ab.

So rufen Sie temporäre Sicherheitsanmeldeinformationen ab und greifen auf Amazon S3 zu

Erstellen Sie eine Instance des AWS Security Token Service-Clients, AmazonSecurityTokenServiceClient. Weitere Informationen zum Bereitstellen von Anmeldeinformationen finden Sie unter Entwickeln mit Amazon S3 unter Verwendung der AWS-SDKs und Explorer.
Starten Sie eine Sitzung durch Aufruf der Methode GetSessionToken des STS-Clients, den Sie im vorigen Schritt erstellt haben. Sie stellen für diese Methode Sitzungsdaten mithilfe eines GetSessionTokenRequest-Objekts bereit.

Die Methode gibt Ihre temporären Sicherheitsanmeldeinformationen zurück.
Bündeln Sie die temporären Sicherheitsanmeldeinformationen in einer Instance des Objekts SessionAWSCredentials. Sie verwenden dieses Objekt, um die temporären Sicherheitsanmeldeinformationen für Ihren Amazon-S3-Client bereitzustellen.
Erstellen Sie eine Instance der Klasse AmazonS3Client, indem Sie die temporären Sicherheitsanmeldeinformationen übergeben. Mit diesem Client senden Sie Anfragen an Amazon S3. Wenn Sie beim Senden der Anfragen abgelaufene Anmeldeinformationen verwenden, gibt Amazon S3 einen Fehler zurück.

Anmerkung

Wenn Sie unter Verwendung der Sicherheitsanmeldeinformationen Ihres AWS-Konto temporäre Sicherheitsanmeldeinformationen erhalten haben, sind diese Anmeldeinformationen nur eine Stunde lang gültig. Sie können die Sitzungsdauer nur dann festlegen, wenn Sie IAM-Benutzer-Anmeldeinformationen verwenden, um eine Sitzung anzufordern.

Das folgende C#-Beispiel listet Objektschlüssel im angegebenen Bucket auf. Zur Veranschaulichung fordert das Beispiel temporäre Sicherheitsanmeldeinformationen für die standardmäßige, einstündige Sitzung an, die dann zum Senden einer authentifizierten Anfrage an Amazon S3 verwendet werden.

Wenn Sie das Beispiel mit IAM-Benutzer-Anmeldeinformationen testen möchten, müssen Sie einen IAM-Benutzer unter Ihrem AWS-Konto erstellen. Weitere Informationen zum Erstellen eines IAM-Benutzers finden Sie unter Erstellen Ihrer ersten IAM-Benutzer- und Administratorengruppe im IAM-Benutzerhandbuch. Weitere Informationen zum Senden von Anfragen finden Sie unter Senden von Anforderungen.

Anweisungen zum Erstellen und Testen eines funktionierenden Beispiels finden Sie unter Ausführen der .NET-Codebeispiele für 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

Dieses Beispiel setzt voraus, dass Sie die Anweisungen für Verwenden von AWS SDK for PHP und Ausführen von PHP-Beispielen befolgen und das AWS SDK for PHP ordnungsgemäß installiert ist.

Ein IAM–Benutzer oder ein AWS-Konto können unter Verwendung von Version 3 des AWS SDK for PHP temporäre Sicherheitsanmeldeinformationen anfordern. Mit diesen temporären Anmeldeinformationen kann der Benutzer/das Konto dann auf Amazon S3 zugreifen. Die Anmeldeinformationen laufen mit dem Ende der Sitzung ab.

Anmerkung

Wenn Sie unter Verwendung Ihrer AWS-Konto-Sicherheitsanmeldeinformationen temporäre Sicherheitsanmeldeinformationen erhalten haben, sind sie lediglich eine Stunde lang gültig. Sie können eine Sitzungsdauer nur dann festlegen, wenn Sie IAM-Benutzer-Anmeldeinformationen verwenden, um eine Sitzung anzufordern.

Das folgende PHP-Beispiel listet die Objektschlüssel im angegebenen Bucket bei Verwendung temporärer Sicherheitsanmeldeinformationen auf. Das Beispiel fordert temporäre Sicherheitsanmeldeinformationen für eine standardmäßige, einstündige Sitzung an, die dann zum Senden einer authentifizierten Anfrage an Amazon S3 verwendet werden. Weitere Informationen zur Ausführung der PHP-Beispiele in dieser Anleitung finden Sie unter PHP-Beispiele ausführen.

Wenn Sie das Beispiel mit IAM-Benutzer-Anmeldeinformationen testen möchten, müssen Sie einen IAM-Benutzer unter Ihrem AWS-Konto erstellen. Weitere Informationen zum Erstellen eines IAM-Benutzers finden Sie unter Erstellen Ihrer ersten IAM-Benutzer und Administratorengruppe im IAM-Benutzerhandbuch. Ein Beispiel für das Festlegen der Sitzungsdauer beim Anfordern einer Sitzung mit IAM-Benutzer-Anmeldeinformationen finden Sie unter Anfragen unter Verwendung temporärer Anmeldeinformationen für IAM-Benutzer erstellen .


 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

Ein IAM-Benutzer oder ein AWS-Konto kann temporäre Sicherheitsanmeldeinformationen über das AWS SDK for Ruby anfordern und sie für den Zugriff auf Amazon S3 verwenden. Diese Anmeldeinformationen laufen nach Ende der Sitzung ab.

Anmerkung

Wenn Sie unter Verwendung Ihrer AWS-Konto-Sicherheitsanmeldeinformationen temporäre Sicherheitsanmeldeinformationen erhalten haben, sind sie lediglich eine Stunde lang gültig. Sie können die Sitzungsdauer nur dann festlegen, wenn Sie IAM-Benutzer-Anmeldeinformationen verwenden, um eine Sitzung anzufordern.

Das folgende Ruby-Beispiel erstellt einen temporären Benutzer, damit dieser für eine Stunde die Elemente in einem bestimmten Bucket auflisten kann. Um dieses Beispiel verwenden zu können, müssen Sie über AWS-Anmeldeinformationen mit den notwendigen Berechtigungen zum Erstellen neuer AWS Security Token Service (AWS STS) Clients und zum Auflisten von Amazon-S3-Buckets verfügen.



# 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

Zugehörige Ressourcen

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Verwendung von Anmeldeinformationen von AWS-Konto oder von IAM-Benutzern

Verwendung temporärer Anmeldeinformationen verbundener Benutzer