使用使用IAM者臨時認證提出要求

同時 AWS 帳戶或者，使用IAM者可以請求臨時安全登入資料，並使用它們將經過驗證的請求傳送至 Amazon S3。本節提供如何使用 AWS SDK for Java，。 NET，並取PHP得臨時安全登入資料，並使用這些登入資料來驗證您向 Amazon S3 的請求。

Java

使IAM用者或 AWS 帳戶可以請求臨時安全登入資料 (請參閱提出要求) AWS SDK for Java 並使用它們來訪問 Amazon S3。這些登入資料會在指定的工作階段使用期限之後到期。

工作階段使用期限預設是一小時。如果您使用使用IAM者認證，您可以指定要求暫時安全登入資料的持續時間 (從 15 分鐘到角色的工作階段持續時間上限)。如需有關臨時安全登入資料的詳細資訊，請參閱IAM使用者指南中的「暫時安全登入如需提出請求的詳細資訊，請參閱提出要求。

取得暫時性安全登入資料並存取 Amazon S3

建立 AWSSecurityTokenService 類別的執行個體。如需提供登入資料的資訊，請參閱「使用開發 AWS 套件使用 Amazon S3 進行開發」。
呼叫安全性權杖 Service (STS) 用戶端的assumeRole()方法，擷取所需角色的臨時安全性登入資料。
將暫時安全登入資料封裝至 BasicSessionCredentials 物件。您可以使用此物件，將暫時性安全登入資料提供給 Amazon S3 用戶端。
使用暫時性安全登入資料建立 AmazonS3Client 類別的執行個體。您可以使用此用戶端，將請求傳送給 Amazon S3。如果使用過期的登入資料傳送請求，Amazon S3 將會傳回錯誤。

注意

如果您使用您的取得臨時安全登入資料 AWS 帳戶安全憑據，臨時憑據僅有一小時有效。只有在使用使用IAM者認證要求工作階段時，才能指定工作階段持續時間。

下列範例會列出所指定儲存貯體中的一組物件金鑰。此範例會取得工作階段的臨時安全登入資料，然後使用這些登入資料將透過身分驗證的請求傳送給 Amazon S3。

如果您想要使用使用IAM者認證來測試範例，您必須在 IAM AWS 帳戶。如需有關如何建立IAM使用者的詳細資訊，請參閱《使用指南》中的〈建立您的第一個IAM使用IAM者和管理員群組〉。

如需有關建立和測試工作範例的指示，請參閱《 AWS SDK for Java 開發人員指南。



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

使IAM用者或 AWS 帳戶可以使用要求臨時安全登入資料 AWS SDK for .NET 並使用它們來訪問 Amazon S3。這些登入資料會在工作階段使用期限之後到期。

取得暫時性安全登入資料並存取 Amazon S3

建立的執行個體 AWS Security Token Service 客戶端，AmazonSecurityTokenServiceClient。如需提供登入資料的資訊，請參閱「使用開發 AWS 套件使用 Amazon S3 進行開發」。
透過呼叫您在上一個步驟中建立的STS用戶端GetSessionToken方法來啟動工作階段。您可以使用 GetSessionTokenRequest 物件，將工作階段資訊提供給此方法。

此方法會傳回暫時性安全登入資料。
將暫時安全登入資料封裝至 SessionAWSCredentials 物件執行個體。您可以使用此物件，將暫時性安全登入資料提供給 Amazon S3 用戶端。
傳入暫時性安全登入資料，以建立 AmazonS3Client 類別執行個體。您可以使用此用戶端，將請求傳送給 Amazon S3。如果使用過期的登入資料傳送請求，Amazon S3 會傳回錯誤。

注意

如果您使用您的取得臨時安全登入資料 AWS 帳戶安全登入資料，這些認證只有一小時有效。只有在使用使用IAM者認證要求工作階段時，才能指定工作階段持續時間。

下列 C# 範例會列出指定儲存貯體中的物件金鑰。為了方便說明，該範例會取得預設一小時工作階段的暫時性安全登入資料，然後使用這些登入資料將透過身分驗證的請求傳送給 Amazon S3。

如果您想要使用使用IAM者認證來測試範例，您必須在 IAM AWS 帳戶。如需有關如何建立IAM使用者的詳細資訊，請參閱《使用指南》中的〈建立您的第一個IAM使用IAM者和管理員群組〉。如需提出請求的詳細資訊，請參閱提出要求。

如需有關設定和執行程式碼範例的詳細資訊，請參閱 AWS SDK對於. NET在 AWS SDK對於. NET開發人員指南。


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

如需有關的更多資訊 AWS SDK對於紅寶石API，請轉到 AWS SDK對於紅寶石-版本 2 。

使IAM用者或 AWS 帳戶可以使用的版本 3 請求臨時安全憑據 AWS SDK for PHP。然後，它可以使用臨時登入資料存取 Amazon S3。該登入資料會在工作階段使用期限到期時到期。

注意

如果您使用您的取得臨時安全登入資料 AWS 帳戶安全憑據，臨時安全憑據僅有一小時有效。只有在使用使用IAM者認證要求工作階段時，才能指定工作階段持續時間。

下列PHP範例會使用暫時安全性認證列出指定值區中的物件金鑰。此範例會取得預設一小時工作階段的暫時性安全登入資料，然後使用這些登入資料將透過身分驗證的請求傳送給 Amazon S3。如需有關的更多資訊 AWS SDK對於紅寶石API，請轉到 AWS SDK對於紅寶石-版本 2 。

如果您想要使用使用IAM者認證來測試範例，您必須在下方建立使用IAM者 AWS 帳戶。如需有關如何建立IAM使用者的資訊，請參閱《使用指南》中的〈建立您的第一個IAM使用IAM者和管理員群組〉。如需在使用使用IAM者認證要求工作階段時設定工作階段持續時間的範例，請參閱使用使用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

使IAM用者或 AWS 帳戶可以使用請求臨時安全憑據 AWS SDK for Ruby 並使用它們來訪問 Amazon S3。這些登入資料會在工作階段使用期限之後到期。

注意

如果您使用您的取得臨時安全登入資料 AWS 帳戶安全憑據，臨時安全憑據僅有一小時有效。只有當您使用使用IAM者認證要求工作階段時，才能指定工作階段持續時間。

下列 Ruby 範例會建立暫時使用者有一小時的時間可列出指定儲存貯體中的項目。要使用此示例，您必須具有 AWS 具有建立新的必要權限的認證 AWS Security Token Service (AWS STS）客戶端，並列出 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, '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

使用使用IAM者臨時認證提出要求

取得暫時性安全登入資料並存取 Amazon S3

注意

取得暫時性安全登入資料並存取 Amazon S3

注意

注意

注意

相關資源