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.
# Abrufen von Amazon S3-Anforderungs-IDs für AWS Support
Wann immer Sie Kontakt aufnehmen AWS Support , weil Sie in Amazon S3 auf Fehler oder unerwartetes Verhalten gestoßen sind, müssen Sie die Anforderungs-IDs angeben, die der fehlgeschlagenen Aktion zugeordnet sind. AWS Support verwendet diese Anforderungs-IDs, um die aufgetretenen Probleme zu lösen.
Anfrage-IDs werden paarweise vergeben. Sie werden in jeder von Amazon S3 verarbeiteten Antwort zurückgegeben (auch in den fehlerhaften). Der Zugriff darauf erfolgt über Verbose-Protokolle. Es gibt eine Reihe gängiger Methoden, um Ihre Anforderungs-IDs abzurufen, darunter S3-Serverzugriffsprotokolle und AWS CloudTrail -ereignisse oder Datenereignisse.
Nachdem Sie diese Protokolle wiederhergestellt haben, kopieren Sie diese beiden Werte und behalten Sie sie bei, da Sie sie benötigen, wenn Sie Kontakt aufnehmen AWS Support. Informationen zur Kontaktaufnahme finden Sie AWS Support unter [ Kontakt AWS](https://aws.amazon.com/contact-us/) oder in der [AWS Support Dokumentation](https://aws.amazon.com/documentation/aws-support/).
**Topics**
+ [Verwendung der AWS CLI um Anfrage-IDs zu erhalten](#cli-request-id)
+ [Verwenden von Windows PowerShell zum Abrufen von Anforderungs-IDs](#powershell-request-id)
+ [Verwenden AWS CloudTrail Datenereignisse zum Abrufen von Anforderungs-IDs](#cloudtrail-request-id)
+ [Abrufen der Anforderungs-IDs mithilfe der S3-Server-Zugriffsprotokollierung](#server-access-log-request-id)
+ [Abrufen der Anforderungs-IDs mithilfe von HTTP](#http-request-id)
+ [Abrufen der Anforderungs-IDs mithilfe eines Webbrowsers](#browser-request-id)
+ [Verwendung der AWS SDKs zum Abrufen von Anforderungs-IDs](#sdk-request-ids)
## Verwendung der AWS CLI um Anfrage-IDs zu erhalten
Um Ihre Anforderungs-IDs zu erhalten, wenn Sie die AWS Command Line Interface (AWS CLI) verwenden, fügen `--debug` Sie Ihrem Befehl hinzu. Zum Beispiel solltest du `x-amz-request-id` und `x-amz-id-2` im Debug-Log wie unten gezeigt sehen:
```
...
2025-04-30 14:35:28,572 - MainThread - botocore.parsers - DEBUG - Response headers: {'x-amz-id-2': 'a+zm50vDJH3LLmCiXvwEo0u0PtPS/qCJaBvB2ZMH9dzyzTiJhiLZkBFFoRfsPfOKztUKT/garCI=', 'x-amz-request-id': 'N4NMN0MJ4VDFZMX9', 'Date': 'Wed, 30 Apr 2025 21:35:29 GMT', 'Content-Type': 'application/xml', 'Transfer-Encoding': 'chunked', 'Server': 'AmazonS3'}
...
```
## Verwenden von Windows PowerShell zum Abrufen von Anforderungs-IDs
Informationen zum Wiederherstellen von Protokollen mit Windows PowerShell finden Sie unter [ Response Logging in AWS Tools for Windows PowerShell](https://aws.amazon.com/blogs/developer/response-logging-in-aws-tools-for-windows-powershell/) im *AWS Developer Tools-Blog*.
## Verwenden AWS CloudTrail Datenereignisse zum Abrufen von Anforderungs-IDs
Ein Amazon S3-Bucket, der mit CloudTrail Datenereignissen konfiguriert ist, um API-Operationen auf S3-Objektebene zu protokollieren, bietet detaillierte Informationen über Aktionen, die von einem Benutzer, einer Rolle oder einem AWS Dienst in Amazon S3 ausgeführt werden. Sie können S3-Anforderungs-IDs identifizieren, indem Sie CloudTrail Ereignisse mit Athena abfragen.
Weitere Informationen finden Sie unter [ Identifizieren von Amazon S3-Anfragen mithilfe CloudTrail ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/cloudtrail-request-identification.html) im * Amazon Simple Storage Service-Benutzerhandbuch. *
## Abrufen der Anforderungs-IDs mithilfe der S3-Server-Zugriffsprotokollierung
Ein Amazon-S3-Bucket, der für die S3-Server-Zugriffsprotokollierung konfiguriert ist, stellt detaillierte Aufzeichnungen zu allen an den Bucket gesendeten Anforderungen bereit. Sie können S3-Anforderungs-IDs identifizieren, indem Sie die Serverzugriffsprotokolle mit Athena abfragen.
Weitere Informationen finden Sie unter [ Abfragen von Zugriffsprotokollen für Anfragen mithilfe Amazon Athena](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-s3-access-logs-to-identify-requests.html#querying-s3-access-logs-for-requests) im * Amazon Simple Storage Service-Benutzerhandbuch*.
## Abrufen der Anforderungs-IDs mithilfe von HTTP
Sie können Ihre Anfrage-IDs `x-amz-request-id` und `x-amz-id-2` ermitteln, indem Sie die Abschnitte einer HTTP-Anfrage protokollieren, bevor sie die Zielanwendung erreicht. Es gibt verschiedene Tools von Drittanbietern, mit denen Verbose-Protokolle für HTTP-Anfragen wiederhergestellt werden können. Wählen Sie ein Tool, dem Sie vertrauen, führen Sie es aus und überwachen Sie den Port, über den Ihr Amazon-S3-Datenverkehr läuft, während Sie eine weitere Amazon-S3-HTTP-Anforderung senden.
Bei HTTP-Anforderungen sieht das Paar der Anforderungs-IDs wie in den folgenden Beispielen gezeigt aus:
```
x-amz-request-id: 79104EXAMPLEB723
x-amz-id-2: IOWQ4fDEXAMPLEQM+ey7N9WgVhSnQ6JEXAMPLEZb7hSQDASK+Jd1vEXAMPLEa3Km
```
**Anmerkung**
HTTPS-Anfragen werden in den meisten Paketerfassungen verschlüsselt und verborgen.
## Abrufen der Anforderungs-IDs mithilfe eines Webbrowsers
Die meisten Webbrowser beinhalten Entwickler-Tools, mit denen Sie Anforderungs-Header anzeigen können.
Für auf einem Webbrowser basierte Anfragen, die einen Fehler zurückgeben, sieht das Paar der Anfrage-IDs wie in den folgenden Beispielen gezeigt aus.
```
AccessDeniedAccess Denied
79104EXAMPLEB723IOWQ4fDEXAMPLEQM+ey7N9WgVhSnQ6JEXAMPLEZb7hSQDASK+Jd1vEXAMPLEa3Km
```
Zeigen Sie die HTTP-Anforderungs-Header mithilfe der Entwickler-Tools zu Ihrem Browser an, um das Paar der Anforderungs-IDs aus erfolgreichen Anforderungen abzurufen.
## Verwendung der AWS SDKs zum Abrufen von Anforderungs-IDs
Die folgenden Abschnitte enthalten Informationen zur Konfiguration der Protokollierung mithilfe verschiedener AWS SDKs.
**Anmerkung**
Sie können zwar die ausführliche Protokollierung für jede Anfrage und Antwort aktivieren, empfehlen jedoch nicht, die Protokollierung in Produktionssystemen zu aktivieren, da umfangreiche Anfragen oder Antworten eine Anwendung erheblich verlangsamen können.
Bei AWS SDK-Anfragen sieht das Paar von Anforderungs-IDs wie folgt aus:
```
Status Code: 403, AWS Service: Amazon S3, AWS Request ID: 79104EXAMPLEB723
AWS Error Code: AccessDenied AWS Error Message: Access Denied
S3 Extended Request ID: IOWQ4fDEXAMPLEQM+ey7N9WgVhSnQ6JEXAMPLEZb7hSQDASK+Jd1vEXAMPLEa3Km
```
------
#### [ C\+\+ ]
Der Loggertyp und die Ausführlichkeit werden bei der SDK-Initialisierung im Argument angegeben. `SDKOptions` Im folgenden Beispiel wird die Ausführlichkeitsstufe als angegeben. `LogLevel::Debug`
Der Standard-Logger schreibt in das Dateisystem und die Datei wird nach der folgenden Konvention benannt. `aws_sdk_YYYY-MM-DD-HH.log` Der Logger erstellt zu jeder Stunde eine neue Datei.
```
Aws::SDKOptions options;
options.loggingOptions.logLevel = Aws::Utils::Logging::LogLevel::Debug;
Aws::InitAPI(options);
// ...
Aws::ShutdownAPI(options);
```
Weitere Informationen finden Sie unter [ Wie aktiviere ich die Protokollierung? ](https://github.com/aws/aws-sdk-cpp/wiki#how-do-i-turn-on-logging)im *AWS SDK für C\+\+-Wiki auf GitHub*.
------
#### [ Go ]
Sie können die Protokollierung mithilfe von SDK for Go konfigurieren. Weitere Informationen finden Sie [ im *AWS SDK für Go v2-Entwicklerhandbuch unter*](https://docs.aws.amazon.com/sdk-for-go/v2/developer-guide/configure-logging.html) Logging.
------
#### [ Java ]
Sie können die Protokollierung für bestimmte Anfragen oder Antworten aktivieren, um nur relevante Header abzufangen und zurückzugeben. Dazu importieren Sie die Klasse `com.amazonaws.services.s3.S3ResponseMetadata`. Anschließend können Sie die Anforderung in einer Variablen speichern, bevor Sie die eigentliche Anforderung ausführen. Rufen Sie `getCachedResponseMetadata(AmazonWebServiceRequest request).getRequestID()` auf, um die protokollierte Anforderung oder Antwort zu erhalten.
```
PutObjectRequest req = new PutObjectRequest(bucketName, key, createSampleFile());
s3.putObject(req);
S3ResponseMetadata md = s3.getCachedResponseMetadata(req);
System.out.println("Host ID: " + md.getHostId() + " RequestID: " + md.getRequestId());
```
Alternativ können Sie eine Verbose-Protokollierung jeder Java-Anfrage und -Antwort verwenden. Weitere Informationen finden Sie unter [Verbose-Protokollierung des Netzwerkverkehrs](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/java-dg-logging.html#sdk-net-logging-verbose) im *Entwicklerhandbuch zu AWS SDK für Java *.
------
#### [ JavaScript ]
Der AWS SDK für JavaScript hat einen eingebauten Logger, sodass Sie API-Aufrufe, die Sie damit tätigen, protokollieren können. Um den Logger einzuschalten und Logeinträge in der Konsole zu drucken, fügen Sie Ihrem Code die folgende Anweisung hinzu:
```
AWS.config.logger = console;
```
Weitere Informationen finden Sie [ im *AWS SDK für JavaScript Entwicklerhandbuch unter*](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/logging-sdk-calls.html) Logging AWS SDK für JavaScript Calls.
------
#### [ Kotlin ]
Mit dem AWS SDK für Kotlin können Sie den Protokollmodus für Nachrichten auf Wire-Level-Ebene mithilfe von Code- oder Umgebungseinstellungen angeben. Sie können den Protokollmodus für HTTP-Anfragen und HTTP-Antworten festlegen.
Um zusätzliche Protokollierung zu aktivieren, legen Sie die `logMode` Eigenschaft fest, wenn Sie einen Service-Client erstellen:
```
import aws.smithy.kotlin.runtime.client.LogMode
// ...
val client = S3Client {
// ...
logMode = LogMode.LogRequestWithBody + LogMode.LogResponse
}
```
Alternativ können Sie den Protokollmodus mithilfe einer Umgebungsvariablen festlegen:
```
export SDK_LOG_MODE=LogRequestWithBody|LogResponse
```
Weitere Informationen finden Sie [ im *AWS SDK für Kotlin Entwicklerhandbuch unter*](https://docs.aws.amazon.com/sdk-for-kotlin/latest/developer-guide/logging.html) Logging.
------
#### [ .NET ]
Sie können die Protokollierung mit dem konfigurieren, SDK für .NET indem Sie das integrierte `System.Diagnostics` Protokollierungstool verwenden. Weitere Informationen finden Sie im * Blogbeitrag [ Logging with the SDK für .NET](https://aws.amazon.com/blogs/developer/logging-with-the-aws-sdk-for-net/) *AWS Developer.
**Anmerkung**
Standardmäßig enthält das zurückgegebene Protokoll nur Fehlerinformationen. Zum Abrufen der Anforderungs-IDs muss der Konfigurationsdatei `AWSLogMetrics` (und optional `AWSResponseLogging`) hinzugefügt werden.
------
#### [ PHP ]
Sie können Debug-Informationen, einschließlich der über die Leitung gesendeten Daten, abrufen, indem Sie die Debug-Option `true` in einem Client-Konstruktor auf setzen.
```
$s3Client = new Aws\S3\S3Client([
'region' => 'us-standard',
'version' => '2006-03-01',
'debug' => true
]);
```
Weitere Informationen finden Sie unter [Wie kann ich sehen, welche Daten übertragen wurden?](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/faq.html#how-can-i-see-what-data-is-sent-over-the-wire) im *Entwicklerhandbuch zum AWS SDK für PHP *.
------
#### [ Python (Boto3) ]
Mit dem AWS SDK für Python (Boto3) können Sie bestimmte Antworten protokollieren. Sie können diese Funktion verwenden, um nur die relevanten Header zu erfassen. Der folgende Code zeigt, wie Teile der Antwort in einer Datei protokolliert werden:
```
import logging
import boto3
logging.basicConfig(filename='logfile.txt', level=logging.INFO)
logger = logging.getLogger(__name__)
s3 = boto3.resource('s3')
response = s3.Bucket(bucket_name).Object(object_key).put()
logger.info("HTTPStatusCode: %s", response['ResponseMetadata']['HTTPStatusCode'])
logger.info("RequestId: %s", response['ResponseMetadata']['RequestId'])
logger.info("HostId: %s", response['ResponseMetadata']['HostId'])
logger.info("Date: %s", response['ResponseMetadata']['HTTPHeaders']['date'])
```
Sie können auch Ausnahmen abfangen und relevante Informationen protokollieren, wenn eine Ausnahme ausgelöst wird. Weitere Informationen finden Sie unter [Erkennen nützlicher Informationen in Fehlerantworten](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/error-handling.html#discerning-useful-information-from-error-responses) in der *API-Referenz zum AWS SDK für Python (Boto)*.
Darüber hinaus können Sie Boto3 mit dem folgenden Code für die Ausgabe ausführlicher Debugging-Protokolle konfigurieren:
```
import logging
import boto3
boto3.set_stream_logger('', logging.DEBUG)
```
Weitere Informationen finden Sie unter [set\_stream\_logger](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/core/boto3.html#boto3.set_stream_logger) in der *API-Referenz zum AWS SDK für Python (Boto)*.
------
#### [ Ruby ]
Sie können Ihre Anforderungs-IDs mit dem SDK für Ruby Version 3 abrufen. Sie können das HTTP-Wire-Logging in Ihrem Client mit dem folgenden Code aktivieren:
```
s3 = Aws::S3::Client.new(http_wire_trace: true)
```
**Anmerkung**
Die Drahtprotokollierung kann vertrauliche Informationen enthalten, wie z. B. Ihre Zugangsschlüssel-ID. Vertrauliche Informationen sollten bereinigt werden, bevor sie an den Support weitergegeben AWS werden.
Die Anforderungs-ID des Anforderungskontextobjekts finden Sie auch in der Anforderungsantwort oder im Fehler:
```
# Finding the request ID from an error:
begin
s3.put_object(bucket: 'bucket', key: 'key', body: 'test')
rescue Aws::S3::Errors::ServiceError => e
puts e.context[:request_id]
puts e.context[:s3_host_id]
end
# Finding the request ID from a successful call:
resp = s3.put_object(bucket: 'bucket', key: 'key', body: 'test')
puts resp.context[:request_id]
puts resp.context[:s3_host_id]
```
Weitere Informationen finden Sie im *AWS SDK für Ruby Entwicklerhandbuch * unter [ Debuggen mithilfe von Wire-Trace-Informationen von einem AWS SDK für Ruby Client](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/debugging.html).
------
#### [ Rust ]
Um die Protokollierung zu aktivieren, fügen Sie die `tracing-subscriber` Crate hinzu und initialisieren Sie sie in Ihrer Rust-Anwendung.
Fügen Sie die Tracing-Bibliothek zu Ihrer Datei hinzu: `Cargo.toml`
```
tracing-subscriber = { version = "0.3", features = ["env-filter"] }
```
Initialisieren Sie dann in Ihrem Rust-Code den Logger in der Hauptfunktion, bevor Sie eine SDK-Operation aufrufen:
```
tracing_subscriber::fmt::init();
```
Weitere Informationen finden Sie unter [ Konfiguration und Verwendung der Protokollierung AWS SDK für Rust](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/logging.html) im *AWS SDK für Rust Entwicklerhandbuch*.
------