Membuat permintaan menggunakan kredensial sementara pengguna IAM

Pengguna IAM Akun AWS atau IAM dapat meminta kredensil keamanan sementara dan menggunakannya untuk mengirim permintaan yang diautentikasi ke Amazon S3. Bagian ini memberikan contoh cara menggunakan AWS SDK for Java, .NET, dan PHP untuk memperoleh kredensial keamanan sementara dan menggunakannya untuk mengautentikasi permintaan Anda ke Amazon S3.

Java

Pengguna IAM atau pengguna Akun AWS dapat meminta kredensil keamanan sementara (lihatMembuat permintaan) menggunakan AWS SDK for Java dan menggunakannya untuk mengakses Amazon S3. Kredensial ini berakhir setelah durasi sesi yang ditentukan.

Secara default, durasi sesi adalah satu jam. Jika Anda menggunakan kredensial pengguna IAM, Anda dapat menentukan durasi saat meminta kredensial keamanan sementara dari 15 menit hingga durasi sesi maksimum untuk peran tersebut. Untuk informasi selengkapnya tentang kredensial keamanan sementara, lihat Kredensial Keamanan Sementara dalam Panduan Pengguna IAM. Untuk informasi selengkapnya tentang membuat permintaan, lihat Membuat permintaan.

Untuk mendapatkan kredensial keamanan sementara dan mengakses Amazon S3

Buat instans dari kelas AWSSecurityTokenService. Untuk informasi tentang memberikan kredensial, lihat Mengembangkan dengan Amazon S3 menggunakan SDK AWS.
Ambil kredensial keamanan sementara untuk peran yang diinginkan dengan memanggil metode assumeRole() klien Security Token Service (STS).
Kemas kredensial keamanan sementara menjadi objek BasicSessionCredentials. Anda menggunakan objek ini untuk menyediakan kredensial keamanan sementara kepada klien Amazon S3.
Buat instans kelas AmazonS3Client dengan menggunakan kredensial keamanan sementara. Anda mengirim permintaan ke Amazon S3 menggunakan klien ini. Jika Anda mengirim permintaan menggunakan kredensial kedaluwarsa, Amazon S3 akan menampilkan pesan kesalahan.

catatan

Jika Anda memperoleh kredensial keamanan sementara menggunakan kredensial keamanan Akun AWS Anda, kredensial sementara hanya berlaku selama satu jam. Anda dapat menentukan durasi sesi hanya jika Anda menggunakan kredensial pengguna IAM untuk meminta sesi.

Contoh berikut ini mencantumkan serangkaian kunci objek dalam bucket yang ditentukan. Contoh tersebut memperoleh kredensial keamanan sementara untuk suatu sesi dan menggunakannya untuk mengirim permintaan terautentikasi ke Amazon S3.

Jika Anda ingin menguji sampel menggunakan kredensial pengguna IAM, Anda harus membuat pengguna IAM di bawah Akun AWS Anda. Untuk informasi selengkapnya tentang cara membuat pengguna IAM, lihat Membuat Grup Pengguna dan Administrator IAM Pertama Anda dalam Panduan Pengguna IAM.

Untuk petunjuk cara membuat dan menguji sampel yang berfungsi, lihat Memulai di Panduan AWS SDK for Java Pengembang.



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

Pengguna IAM atau pengguna Akun AWS dapat meminta kredensil keamanan sementara menggunakan AWS SDK for .NET dan menggunakannya untuk mengakses Amazon S3. Kredensial ini berakhir setelah durasi sesi.

Untuk mendapatkan kredensial keamanan sementara dan mengakses Amazon S3

Buat contoh AWS Security Token Service klien,AmazonSecurityTokenServiceClient. Untuk informasi tentang memberikan kredensial, lihat Mengembangkan dengan Amazon S3 menggunakan SDK AWS.
Mulai sesi dengan memanggil metode GetSessionToken klien STS yang Anda buat pada langkah sebelumnya. Anda memberikan informasi sesi untuk metode ini menggunakan objek GetSessionTokenRequest.

Metode tersebut mengembalikan kredensial keamanan sementara Anda.
Kemas kredensial keamanan sementara dalam instans objek SessionAWSCredentials. Anda menggunakan objek ini untuk menyediakan kredensial keamanan sementara kepada klien Amazon S3.
Buat instans kelas AmazonS3Client dengan memasukkan kredensial keamanan sementara. Anda mengirim permintaan ke Amazon S3 menggunakan klien ini. Jika Anda mengirim permintaan menggunakan kredensial kedaluwarsa, Amazon S3 akan menampilkan pesan kesalahan.

catatan

Contoh C# berikut mencantumkan kunci objek dalam bucket yang ditentukan. Sebagai ilustrasi, contoh tersebut memperoleh kredensial keamanan sementara untuk sesi default satu jam dan menggunakannya untuk mengirim permintaan terautentikasi ke Amazon S3.

Untuk informasi tentang menyiapkan dan menjalankan contoh kode, lihat Memulai SDK for .NET di AWSAWS SDK for .NET Developer Guide.


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

Untuk informasi selengkapnya tentang AWS SDK for Ruby API, AWS buka SDK for Ruby - Versi 2.

Pengguna IAM atau Akun AWS dapat meminta kredensil keamanan sementara menggunakan versi 3 dari file. AWS SDK for PHP Itu kemudian dapat menggunakan kredensial sementara untuk mengakses Amazon S3. Kredensial berakhir saat durasi sesi berakhir.

catatan

Jika Anda memperoleh kredensial keamanan sementara menggunakan kredensial keamanan Akun AWS Anda, kredensial keamanan sementara hanya berlaku selama satu jam. Anda dapat menentukan durasi sesi hanya jika Anda menggunakan kredensial pengguna IAM untuk meminta sesi.

Contoh PHP berikut ini mencantumkan kunci objek dalam bucket tertentu menggunakan kredensial keamanan sementara. Contoh tersebut memperoleh kredensial keamanan sementara untuk sesi satu jam default, dan menggunakannya untuk mengirim permintaan terautentikasi ke Amazon S3. Untuk informasi selengkapnya tentang AWS SDK for Ruby API, AWS buka SDK for Ruby - Versi 2.

Jika Anda ingin menguji contoh menggunakan kredensial pengguna IAM, Anda harus membuat pengguna IAM di bawah Akun AWS Anda. Untuk informasi tentang cara membuat pengguna IAM, lihat Membuat Grup Pengguna dan Administrator IAM Pertama Anda dalam Panduan Pengguna IAM. Untuk contoh dari pengaturan durasi sesi saat menggunakan kredensial pengguna IAM untuk meminta sesi, lihat Membuat permintaan menggunakan kredensial sementara pengguna 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

Pengguna IAM atau pengguna Akun AWS dapat meminta kredensil keamanan sementara menggunakan AWS SDK for Ruby dan menggunakannya untuk mengakses Amazon S3. Kredensial ini berakhir setelah durasi sesi.

catatan

Contoh Ruby berikut membuat pengguna sementara untuk mencantumkan item dalam bucket tertentu selama satu jam. Untuk menggunakan contoh ini, Anda harus memiliki AWS kredensil yang memiliki izin yang diperlukan untuk membuat klien new AWS Security Token Service (AWS STS), dan mencantumkan bucket 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

Sumber daya terkait

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Menggunakan Akun AWS atau kredensil pengguna IAM

Menggunakan kredensial sementara pengguna gabungan