Anforderungen unter Verwendung temporärer Anmeldeinformationen verbundener Benutzer

Sie können temporäre Sicherheitsanmeldeinformationen anfordern und Sie für Ihre verbundenen Benutzer oder Anwendungen bereitstellen, die Zugriff auf Ihrer AWS-Ressourcen benötigen. Dieser Abschnitt enthält Beispiele dafür, wie Sie das AWS-SDK dazu verwenden können, temporäre Sicherheitsanmeldeinformationen für Ihre verbundenen Benutzer oder Anwendungen zu erlangen und mithilfe dieser Anmeldeinformationen authentifizierte Anfragen an Amazon S3 zu senden. Die Liste der verfügbaren AWS-SDKs finden Sie unter Sample Code and Libraries (Beispiel-Code und Bibliotheken).

Anmerkung

Sowohl das AWS-Konto als auch ein IAM-Benutzer können temporäre Sicherheitsanmeldeinformationen für verbundene Benutzer anfordern. Jedoch sollte aus Sicherheitsgründen nur ein IAM-Benutzer mit den notwendigen Berechtigungen diese temporären Anmeldeinformationen anfordern, um sicherzustellen, dass der verbundene Benutzer höchstens die Berechtigungen des anfragenden IAM-Benutzers erhält. In einigen Anwendungen kann es nützlich sein, einen IAM-Benutzer mit den spezifischen Berechtigungen nur zu dem Zweck zu erstellen, temporäre Sicherheitsanmeldeinformationen für Ihre verbundenen Benutzer und Anwendungen zu erteilen.

Java

Anmerkung

Zur Gewährleistung zusätzlicher Sicherheit beim Anfordern temporärer Sicherheitsanmeldeinformationen für verbundene Benutzer und Anwendungen empfehlen wir die Verwendung eines dedizierten IAM-Benutzers mit nur den dazu benötigten Zugriffsberechtigungen. Der temporäre Benutzer, den Sie erstellen, darf nie mehr Berechtigungen erhalten als der IAM-Benutzer, der die temporären Sicherheitsanmeldeinformationen angefordert hat. Weitere Informationen finden Sie unter AWS Identity and Access Management: Häufig gestellte Fragen.

Gehen Sie zum Bereitstellen von Sicherheitsanmeldeinformationen und zum Senden einer authentifizierten Anfrage für den Zugriff auf Ressourcen wie folgt vor:

Erstellen Sie eine Instance der AWSSecurityTokenServiceClient-Klasse. Weitere Informationen zum Bereitstellen von Anmeldeinformationen finden Sie unter Verwendung der AWS SDK for Java.
Starten Sie mit dem Aufruf der Methode getFederationToken() des Security Token Service (STS)-Clients eine Sitzung. Stellen Sie Sitzungsinformationen wie beispielsweise den Benutzernamen und eine IAM-Richtlinie bereit, die Sie den temporären Anmeldeinformationen anfügen möchten. Optional können Sie eine Sitzungsdauer angeben. Diese Methode gibt Ihre temporären Sicherheitsanmeldeinformationen zurück.
Bündeln Sie die temporären Sicherheitsanmeldeinformationen in einer Instance des Objekts BasicSessionCredentials. 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 der Anfragen abgelaufene Anmeldeinformationen verwenden, gibt Amazon S3 einen Fehler zurück.

Das folgende Beispiel listet die Schlüssel im angegebenen S3-Bucket auf. In dem Beispiel erhalten Sie temporäre Sicherheitsanmeldeinformationen für eine zweistündige Sitzung für Ihren verbundenen Benutzer und verwenden sie, um authentifizierte Anfragen an Amazon S3 zu senden. Zum Ausführen des Beispiels müssen Sie einen IAM-Benutzer mit einer zugeordneten Richtlinie erstellen, die es dem Benutzer ermöglicht, temporäre Sicherheitsanmeldeinformationen anzufordern und Ihre AWS-Ressourcen aufzulisten. Dies wird mit der folgenden Richtlinie erreicht:


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

Weitere Informationen zum Erstellen eines IAM-Benutzers finden Sie unter Erstellen Ihrer ersten IAM-Benutzer- und Administratorengruppe im IAM-Benutzerhandbuch.

Nachdem ein IAM-Benutzer erstellt und die vorhergehende Richtlinie angefügt wurde, können Sie das folgende Beispiel ausführen. 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.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

Sie können temporäre Sicherheitsanmeldeinformationen für Ihre verbundenen Benutzer und Anwendungen bereitstellen, sodass sie für den Zugriff auf Ihre AWS-Ressourcen authentifizierte Anfragen senden können. Wenn Sie diese temporären Anmeldeinformationen anfordern, müssen Sie einen Benutzernamen und eine IAM-Richtlinie bereitstellen, mit der die Ressourcenberechtigungen beschrieben wird, die Sie erteilen möchten. Standardmäßig beträgt die Dauer einer Sitzung eine Stunde. Sie können explizit einen anderen Wert für die Dauer angeben, wenn Sie temporäre Sicherheitsanmeldeinformationen für verbundene Benutzer und Anwendungen anfordern. Informationen zum Senden authentifizierter Anfragen finden Sie unter Senden von Anforderungen.

Anmerkung

Wenn temporäre Sicherheitsanmeldeinformationen für verbundene Benutzer und Anwendungen angefordert werden, empfehlen wir, für zusätzliche Sicherheit einen dedizierten IAM-Benutzer mit nur den dazu benötigten Zugriffsberechtigungen zu verwenden. Der temporäre Benutzer, den Sie erstellen, darf nie mehr Berechtigungen erhalten als der IAM-Benutzer, der die temporären Sicherheitsanmeldeinformationen angefordert hat. Weitere Informationen finden Sie unter AWS Identity and Access Management: Häufig gestellte Fragen.

Dazu führen Sie die folgenden Schritte aus:

Sie erstellen eine Instance des AWS Security Token Service-Clients, Klasse AmazonSecurityTokenServiceClient. Weitere Informationen zum Bereitstellen von Anmeldeinformationen finden Sie unter Verwendung der AWS SDK for .NET.
Starten Sie eine Sitzung durch Aufruf der Methode GetFederationToken des STS-Clients. Sie müssen Sitzungsinformationen bereitstellen, wie beispielsweise den Benutzernamen und eine IAM-Richtlinie, die Sie den temporären Anmeldeinformationen zuordnen wollen. Optional können Sie eine Sitzungsdauer angeben. Diese 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 AmazonS3Client-Klasse, indem Sie die temporären Sicherheitsanmeldeinformationen übergeben. Sie verwenden diesen Client zum Senden von Anfragen an Amazon S3. Wenn Sie beim Senden der Anfragen abgelaufene Anmeldeinformationen verwenden, gibt Amazon S3 einen Fehler zurück.

Das folgende C#-Beispiel listet die Schlüssel im angegebenen Bucket auf. In dem Beispiel erhalten Sie temporäre Sicherheitsanmeldeinformationen für eine zweistündige Sitzung für Ihren verbundenen Benutzer (User1) und verwenden sie, um authentifizierte Anfragen an Amazon S3 zu senden.

In dieser Übung erstellen Sie einen IAM-Benutzer mit minimalen Berechtigungen. Unter Verwendung der Anmeldeinformationen dieses IAM-Benutzers fordern Sie temporäre Anmeldeinformationen für andere an. Dieses Beispiel listet nur die Objekte in einem bestimmgen Bucket auf. Erstellen Sie einen IAM-Benutzer, dem die folgenden Richtlinie zugeordnet ist:
```
{
  "Statement":[{
      "Action":["s3:ListBucket",
        "sts:GetFederationToken*"
      ],
      "Effect":"Allow",
      "Resource":"*"
    }
  ]
}
```
Die Richtlinie gestattet dem IAM-Benutzer, temporäre Sicherheitsanmeldeinformationen anzufordern, und erteilt ihm nur Zugriffsberechtigungen, um Ihre AWS-Ressourcen aufzulisten. Weitere Informationen zum Erstellen eines IAM-Benutzers finden Sie unter Erstellen Ihrer IAM-Benutzer- und Administratorengruppe im IAM-Benutzerhandbuch.
Verwenden Sie die Sicherheitsanmeldeinformationen des IAM-Benutzers, um das folgende Beispiel zu testen. Das Beispiel sendet unter Verwendung temporärer Sicherheitsanmeldeinformationen eine authentifizierte Anfrage an Amazon S3. Das Beispiel gibt die folgende Richtlinie an, wenn temporäre Sicherheitsanmeldeinformationen für den verbundenen Benutzer (User1) angefordert werden, womit der Zugriff auf eine Auflistung der Objekte in einem spezifischen Bucket eingeschränkt wird (YourBucketName). Sie müssen die Richtlinie aktualisieren, indem Sie Ihren eigenen bestehenden Bucket-Namen angeben.
```
{
  "Statement":[
    {
      "Sid":"1",
      "Action":["s3:ListBucket"],
      "Effect":"Allow", 
      "Resource":"arn:aws:s3:::YourBucketName"
    }
  ]
}
```

Aktualisieren Sie das folgende Beispiel und geben Sie den Bucket-Namen an, den Sie in der vorherigen Zugriffsrichtlinie für verbundene Benutzer angegeben haben. 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 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

Dieses Thema beschreibt, wie Sie Klassen aus Version 3 des AWS SDK for PHP verwenden, um temporäre Sicherheitsanmeldeinformationen für verbundene Benutzer und Anwendungen anzufordern und damit auf in Amazon S3 gespeicherte Ressourcen zuzugreifen. Es wird vorausgesetzt, dass Sie den Anleitungen für Verwenden von AWS SDK for PHP und Ausführen von PHP-Beispielen folgen und der AWS SDK for PHP ordnungsgemäß installiert ist.

Sie können temporäre Sicherheitsanmeldeinformationen für Ihre verbundenen Benutzer und Anwendungen bereitstellen, sodass sie für den Zugriff auf Ihre AWS-Ressourcen authentifizierte Anfragen senden können. Wenn Sie diese temporären Anmeldeinformationen anfordern, müssen Sie einen Benutzernamen und eine IAM-Richtlinie bereitstellen, mit der die Ressourcenberechtigungen beschrieben wird, die Sie erteilen möchten. Diese Anmeldeinformationen laufen mit dem Ende der Sitzung ab. Die Sitzungsdauer beträgt standardmäßig eine Stunde. Sie können explizit einen anderen Wert für die Dauer angeben, wenn Sie temporäre Sicherheitsanmeldeinformationen für verbundene Benutzer und Anwendungen anfordern. Weitere Informationen zu temporären Anmeldeinformationen finden Sie unter Temporäre Sicherheitsanmeldeinformationen im IAM-Benutzerhandbuch. Informationen zum Bereitstellen temporärer Sicherheitsanmeldeinformationen für Ihre verbundenen Benutzer und Anwendungen finden Sie unter Senden von Anforderungen.

Für zusätzliche Sicherheit beim Anfordern temporärer Sicherheitsanmeldeinformationen für verbundene Benutzer und Anwendungen empfehlen wir die Verwendung eines dedizierten IAM-Benutzers mit nur den dazu benötigten Zugriffsberechtigungen. Der temporäre Benutzer, den Sie erstellen, darf nie mehr Berechtigungen erhalten als der IAM-Benutzer, der die temporären Sicherheitsanmeldeinformationen angefordert hat. Weitere Informationen über Identitätsverbunde finden Sie unter den Häufig gestellten Fragen zu AWS Identity and Access Management.

Weitere Informationen zur Ausführung der PHP-Beispiele in dieser Anleitung finden Sie unter PHP-Beispiele ausführen.

Beispiel

Das folgende PHP-Beispiel listet Schlüssel im angegebenen Bucket auf. In dem Beispiel erhalten Sie temporäre Sicherheitsanmeldeinformationen für eine einstündige Sitzung für Ihren verbundenen Benutzer (User1). Sie verwenden die temporären Sicherheitsanmeldeinformationen dann zum Senden authentifizierter Anfragen an Amazon S3.

Verwenden Sie zur Gewährleistung zusätzlicher Sicherheit beim Anfordern temporärer Anmeldeinformationen für andere die Sicherheitsanmeldeinformationen eines IAM-Benutzers, der über die Berechtigung zum Anfordern temporärer Sicherheitsanmeldeinformationen verfügt. Um sicherzustellen, dass der IAM-Benutzer dem verbundenen Benutzer nur die anwendungsspezifischen Mindestberechtigungen gewährt, können Sie auch die Zugriffsberechtigungen dieses IAM-Benutzers einschränken. Dieses Beispiel listet nur Objekte in einem bestimmten Bucket auf. Erstellen Sie einen IAM-Benutzer, dem die folgenden Richtlinie zugeordnet ist:


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

Die Richtlinie gestattet dem IAM-Benutzer, temporäre Sicherheitsanmeldeinformationen anzufordern, und erteilt ihm nur Zugriffsberechtigungen, um Ihre AWS-Ressourcen aufzulisten. Weitere Informationen zum Erstellen eines IAM-Benutzers finden Sie unter Erstellen Ihrer ersten IAM-Benutzer- und Administratorengruppe im IAM-Benutzerhandbuch.

Jetzt können Sie die Sicherheitsanmeldeinformationen des IAM-Benutzers verwenden, um das folgende Beispiel zu testen. Das Beispiel sendet unter Verwendung temporärer Sicherheitsanmeldeinformationen eine authentifizierte Anfrage an Amazon S3. Wenn temporäre Sicherheitsanmeldeinformationen für den verbundenen Benutzer (User1) angefordert werden, gibt das Beispiel die folgenden Richtlinie an, womit der Zugriff auf eine Auflistung der Objekte in einem bestimmten Bucket eingeschränkt wird. Aktualisieren Sie die Richtlinie mit Ihrem Bucket-Namen.


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

Ersetzen Sie im folgenden Beispiel bei der Angabe der Richtlinien-Ressource YourBucketName durch den Namen Ihres Buckets:


 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

Sie können temporäre Sicherheitsanmeldeinformationen für Ihre verbundenen Benutzer und Anwendungen bereitstellen, sodass sie für den Zugriff auf Ihre AWS-Ressourcen authentifizierte Anfragen senden können. Wenn Sie diese temporären Anmeldeinformationen vom IAM-Service anfordern, müssen Sie einen Benutzernamen und eine IAM-Richtlinie bereitstellen, mit der die Ressourcenberechtigungen beschrieben werden, die Sie erteilen möchten. Die Sitzungsdauer beträgt standardmäßig eine Stunde. Wenn Sie temporäre Sicherheitsanmeldeinformationen unter Verwendung von IAM-Benutzer-Anmeldeinformationen anfordern, können Sie explizit einen anderen Wert für die Gültigkeitsdauer festlegen, wenn Sie die temporären Sicherheitsanmeldeinformationen für verbundene Benutzer und Anwendungen anfordern. Informationen zu temporären Sicherheitsanmeldeinformationen für Ihre verbundenen Benutzer und Anwendungen finden Sie unter Senden von Anforderungen.

Anmerkung

Verwenden Sie zur Gewährleistung zusätzlicher Sicherheit beim Anfordern temporärer Sicherheitsanmeldeinformationen für verbundene Benutzer und Anwendungen einen dedizierten IAM-Benutzer mit nur den dazu benötigten Zugriffsberechtigungen. Der temporäre Benutzer, den Sie erstellen, darf nie mehr Berechtigungen erhalten als der IAM-Benutzer, der die temporären Sicherheitsanmeldeinformationen angefordert hat. Weitere Informationen finden Sie unter AWS Identity and Access Management: Häufig gestellte Fragen.

Beispiel

Das folgende Ruby-Codebeispiel gestattet es einem verbundenen Benutzer mit einem limitierten Satz von Berechtigungen Schlüssel im angegebenen Bucket aufzulisten.


# 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:::doc-example-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, '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

# Example usage:
def run_me
  region = "us-west-2"
  user_name = "my-user"
  bucket_name = "doc-example-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__

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 temporärer IAM-Benutzer-Anmeldeinformationen

Senden von Anforderungen unter Verwendung der REST-API