Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Anfragen unter Verwendung temporärer Anmeldeinformationen für IAM-Benutzer erstellen
Ein AWS-Konto oder ein IAM-Benutzer kann temporäre Sicherheitsanmeldeinformationen anfordern und diese verwenden, um authentifizierte Anfragen an Amazon S3 zu senden. Dieser Abschnitt enthält Beispiele, wie Sie das AWS SDK für 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 oder mehrere IAM-Benutzer AWS-Konto können mithilfe von temporäre Sicherheitsanmeldeinformationen (siehe[Senden von Anforderungen](MakingRequests.md)) anfordern AWS SDK für Java und diese 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](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) im *IAM-Benutzerhandbuch*. Weitere Informationen zum Senden von Anfragen finden Sie unter [Senden von Anforderungen](MakingRequests.md).
**So rufen Sie temporäre Sicherheitsanmeldeinformationen ab und greifen auf Amazon S3 zu**
1. Erstellen Sie eine Instance der `AWSSecurityTokenService`-Klasse.
1. 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.
1. 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.
1. 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.
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](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) im *IAM-Benutzerhandbuch*.
Anweisungen zum Erstellen und Testen eines funktionierenden Beispiels finden Sie [ im AWS SDK für Java Entwicklerhandbuch unter ](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html) Erste Schritte.
```
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 IAM-Benutzer AWS-Konto kann mithilfe von temporäre Sicherheitsanmeldeinformationen anfordern AWS SDK für .NET und diese für den Zugriff auf Amazon S3 verwenden. Diese Anmeldeinformationen laufen nach Ende der Sitzung 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](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) im *IAM-Benutzerhandbuch*. Weitere Informationen zum Senden von Anfragen finden Sie unter [Senden von Anforderungen](MakingRequests.md).
**So rufen Sie temporäre Sicherheitsanmeldeinformationen ab und greifen auf Amazon S3 zu**
1. Erstellen Sie eine Instanz des AWS -Security-Token-Service Clients,`AmazonSecurityTokenServiceClient`.
1. 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.
1. 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.
1. 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](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) im *IAM-Benutzerhandbuch*. Weitere Informationen zum Senden von Anfragen finden Sie unter [Senden von Anforderungen](MakingRequests.md).
Informationen zum Einrichten und Ausführen der Codebeispiele finden Sie unter [ Getting Started with the AWS SDK for .NET ](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) im *AWS SDK for .NET-Entwicklerhandbuch*.
```
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 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 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 ]
Weitere Informationen zur AWS SDK für Ruby-API finden Sie unter [AWS SDK for Ruby — Version ](https://docs.aws.amazon.com/sdkforruby/api/index.html) 2.
Ein IAM-Benutzer oder ein IAM-Benutzer AWS-Konto kann temporäre Sicherheitsanmeldeinformationen mithilfe von Version 3 von anfordern. AWS SDK für PHP Mit diesen temporären Anmeldeinformationen kann der Benutzer/das Konto dann auf Amazon S3 zugreifen. Die Anmeldeinformationen laufen mit dem Ende der Sitzung 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](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) im *IAM-Benutzerhandbuch*. Weitere Informationen zum Senden von Anfragen finden Sie unter [Senden von Anforderungen](MakingRequests.md).
**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.
**Example**
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 AWS SDK for Ruby API finden Sie unter [AWS SDK for Ruby — Version 2. ](https://docs.aws.amazon.com/sdkforruby/api/index.html)
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](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) 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](#AuthUsingTempSessionToken).
```
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 IAM-Benutzer AWS-Konto kann temporäre Sicherheitsanmeldeinformationen anfordern AWS SDK für Ruby und diese für den Zugriff auf Amazon S3 verwenden. Diese Anmeldeinformationen laufen nach Ende der Sitzung 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](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) im *IAM-Benutzerhandbuch*. Weitere Informationen zum Senden von Anfragen finden Sie unter [Senden von Anforderungen](MakingRequests.md).
**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, benötigen Sie AWS Anmeldeinformationen, die über die erforderlichen Berechtigungen verfügen, um neue AWS -Security-Token-Service (AWS STS) -Clients zu erstellen und Amazon S3-Buckets aufzulisten.
```
# 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)
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)
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
true
rescue StandardError => e
puts "Error while accessing the bucket named '#{bucket_name}': #{e.message}"
end
```
------