Anfragen mit temporären IAM Benutzeranmeldedaten stellen

Importieren in &S3; AWS-Konto oder ein IAM Benutzer kann temporäre Sicherheitsanmeldedaten anfordern und diese verwenden, um authentifizierte Anfragen an Amazon S3 zu senden. Dieser Abschnitt enthält Beispiele für die Verwendung von AWS SDK for Java,. NETund PHP um temporäre Sicherheitsanmeldedaten zu erhalten und diese zur Authentifizierung Ihrer Anfragen an Amazon S3 zu verwenden.

Java

Ein IAM Benutzer oder ein AWS-Konto kann temporäre Sicherheitsanmeldedaten (sieheSenden von Anforderungen) anfordern, indem AWS SDK for Java und verwenden Sie sie, um auf Amazon S3 zuzugreifen. Diese Anmeldeinformationen laufen nach der angegebenen Sitzungsdauer ab.

Die Sitzungsdauer beträgt standardmäßig eine Stunde. Wenn Sie IAM Benutzeranmeldedaten verwenden, können Sie bei der Anforderung der temporären Sicherheitsanmeldedaten die Dauer von 15 Minuten bis zur maximalen Sitzungsdauer für die Rolle angeben. Weitere Informationen zu temporären Sicherheitsanmeldedaten finden Sie unter Temporäre Sicherheitsanmeldedaten im IAMBenutzerhandbuch. 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.
Rufen Sie die temporären Sicherheitsanmeldedaten 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 temporäre Sicherheitsanmeldedaten mit Ihrem AWS-Konto Sicherheitsanmeldedaten: Die temporären Anmeldeinformationen sind nur für eine Stunde gültig. Sie können die Sitzungsdauer nur angeben, wenn Sie IAM Benutzeranmeldedaten 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.

Wenn Sie das Beispiel mithilfe von IAM Benutzeranmeldedaten testen möchten, müssen Sie einen IAM Benutzer unter Ihrem Namen erstellen AWS-Konto. Weitere Informationen zum Erstellen eines IAM Benutzers finden Sie unter Erstellen Ihrer ersten IAM Benutzer- und Administratorgruppe im IAMBenutzerhandbuch.

Anweisungen zum Erstellen und Testen eines funktionierenden Beispiels finden Sie unter Erste Schritte im AWS SDK for Java Entwicklerhandbuch.



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 Sicherheitsanmeldedaten anfordern mit AWS SDK for .NET und verwenden Sie sie, um auf Amazon S3 zuzugreifen. Diese Anmeldeinformationen laufen nach Ende der Sitzung ab.

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

Erstellen Sie eine Instanz von AWS Security Token Service Kunde,AmazonSecurityTokenServiceClient. Weitere Informationen zum Bereitstellen von Anmeldeinformationen finden Sie unter Entwickeln mit Amazon S3 unter Verwendung der AWS SDKs.
Starten Sie eine Sitzung, indem Sie die GetSessionToken Methode des STS Clients aufrufen, den Sie im vorherigen 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 temporäre Sicherheitsanmeldedaten mit Ihrem AWS-Konto Sicherheitsanmeldedaten, diese Anmeldeinformationen sind nur für eine Stunde gültig. Sie können eine Sitzungsdauer nur angeben, wenn Sie IAM Benutzeranmeldedaten 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.

Informationen zum Einrichten und Ausführen der Codebeispiele finden Sie unter Erste Schritte mit dem AWS SDKfür. NETin der AWS SDKfür. NETLeitfaden für Entwickler.


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

Für weitere Informationen über AWS SDKfür Ruby API gehen Sie zu AWS SDKfür Ruby - Version 2.

Ein IAM Benutzer oder ein AWS-Konto kann temporäre Sicherheitsanmeldedaten mit Version 3 von anfordern AWS SDK for PHP. Es kann dann die temporären Anmeldeinformationen verwenden, um auf Amazon S3 zuzugreifen. Die Anmeldeinformationen laufen mit dem Ende der Sitzung ab.

Anmerkung

Wenn Sie temporäre Sicherheitsanmeldedaten mit Ihrem AWS-Konto Sicherheitsanmeldedaten, die temporären Sicherheitsanmeldedaten sind nur für eine Stunde gültig. Sie können die Sitzungsdauer nur angeben, wenn Sie IAM Benutzeranmeldedaten verwenden, um eine Sitzung anzufordern.

Das folgende PHP Beispiel listet Objektschlüssel im angegebenen Bucket unter 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. Für weitere Informationen über AWS SDKfür Ruby API gehen Sie zu AWS SDKfür Ruby - Version 2.

Wenn Sie das Beispiel mithilfe von IAM Benutzeranmeldedaten testen möchten, müssen Sie einen IAM Benutzer unter Ihrem AWS-Konto. Informationen zum Erstellen eines IAM Benutzers finden Sie unter Erstellen Ihrer ersten IAM Benutzer- und Administratorgruppe im IAMBenutzerhandbuch. Beispiele für das Festlegen der Sitzungsdauer bei Verwendung von IAM Benutzeranmeldedaten zum Anfordern einer Sitzung finden Sie unterAnfragen mit temporären IAM Benutzeranmeldedaten stellen .


 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 Sicherheitsanmeldedaten anfordern mit AWS SDK for Ruby und verwenden Sie sie, um auf Amazon S3 zuzugreifen. Diese Anmeldeinformationen laufen nach Ende der Sitzung ab.

Anmerkung

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, benötigen Sie AWS Anmeldeinformationen, die über die erforderlichen Berechtigungen verfügen, um neue zu erstellen AWS Security Token Service (AWS STS) Clients und listet Amazon S3 S3-Buckets auf.



# 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, 'amzn-s3-demo-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, '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

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

Die Verwendung von AWS-Konto oder IAM Benutzeranmeldedaten

Verwendung temporärer Anmeldeinformationen verbundener Benutzer