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. # Cross-Origin Resource Sharing (CORS) verwenden Cross-Origin Resource Sharing (CORS) bestimmt für Client-Webanwendungen, die in einer Domain geladen sind, eine Möglichkeit zur Interaktion mit Ressourcen in einer anderen Domain. Mit CORS-Unterstützung können Sie umfassende clientseitige Webanwendungen mit Amazon S3 erstellen und selektiven ursprungsübergreifenden Zugriff auf Ihre Amazon-S3-Ressourcen zulassen. Dieser Abschnitt bietet eine Übersicht über CORS. In den Unterthemen wird beschrieben, wie Sie CORS mithilfe der Amazon S3 S3-Konsole oder programmgesteuert mithilfe der Amazon S3 S3-REST-API und der aktivieren können. AWS SDKs ## Cross-Origin Resource Sharing: Szenarien in Anwendungsfällen Es folgen typische Beispielszenarien für den Einsatz von CORS. **Szenario 1** Szenario 1: Angenommen, Sie hosten eine Website in einem Amazon-S3-Bucket mit dem Namen `website`, wie in [Hosten einer statischen Website mit Amazon S3](WebsiteHosting.md) beschrieben. Ihre Benutzer laden den Website-Endpunkt: ``` http://website.s3-website.us-east-1.amazonaws.com ``` Jetzt möchten Sie JavaScript auf den Webseiten, die in diesem Bucket gespeichert sind, verwenden, um authentifizierte GET- und PUT-Anfragen für denselben Bucket stellen zu können, indem Sie den Amazon S3 S3-API-Endpunkt für den Bucket verwenden. `website.s3.us-east-1.amazonaws.com` Ein Browser würde diese Anfragen normalerweise blockieren, aber mit CORS können Sie Ihren Bucket so konfigurieren, dass Anfragen JavaScript aus verschiedenen Quellen explizit aktiviert werden. `website.s3-website.us-east-1.amazonaws.com` **Szenario 2** Angenommen, Sie möchten eine Web-Schriftart aus Ihrem S3-Bucket hosten. Auch hier erfordern Browser eine CORS-Prüfung (auch als Preflight-Check bezeichnet) für das Laden von Web-Schriftarten. Sie würden den Bucket, der die Web-Schriftart hostet, deshalb so konfigurieren, dass jeder Ursprung diese Anfragen machen kann. ## Wie wertet Amazon S3 die CORS-Konfiguration für einen Bucket aus? Wenn Amazon S3 eine Preflight-Anfrage von einem Browser erhält, wertet es die CORS-Konfiguration für den Bucket aus und verwendet die erste `CORSRule`-Regel, die mit der eingehenden Browser-Anfrage übereinstimmt, um eine ursprungsübergreifende Anfrage zuzulassen. Für die Übereinstimmung mit einer Regel müssen die folgenden Bedingungen erfüllt sei: + Der `Origin`-Header in einer CORS-Anfrage an Ihren Bucket muss den Ursprüngen im Element `AllowedOrigins` Ihrer CORS-Konfiguration entsprechen. + Die HTTP-Methoden, die in der `Access-Control-Request-Method` einer CORS-Anfrage an Ihren Bucket angegeben sind, müssen der oder den Methoden entsprechen, die im Element `AllowedMethods` Ihrer CORS-Konfiguration aufgeführt sind. + Die im Header `Access-Control-Request-Headers` einer Preflight-Anfrage aufgeführten Header müssen den Headern im Element `AllowedHeaders` Ihrer CORS-Konfiguration entsprechen. **Anmerkung** Die Richtlinien ACLs und gelten weiterhin, wenn Sie CORS in Ihrem Bucket aktivieren. ## So unterstützt Object Lambda Access Point CORS Wenn S3 Object Lambda eine Anforderung von einem Browser empfängt oder die Anforderung einen `Origin`-Header enthält, fügt S3 Object Lambda immer das Header-Feld `"AllowedOrigins":"*"` hinzu. Weitere Informationen zur Verwendung von CORS finden Sie in den folgenden Themen. **Topics** + [Cross-Origin Resource Sharing: Szenarien in Anwendungsfällen](#example-scenarios-cors) + [Wie wertet Amazon S3 die CORS-Konfiguration für einen Bucket aus?](#cors-eval-criteria) + [So unterstützt Object Lambda Access Point CORS](#cors-olap-cors) + [Elemente einer CORS-Konfiguration](ManageCorsUsing.md) + [Cross-Origin Resource Sharing (CORS) konfigurieren](enabling-cors-examples.md) + [Testen von CORS](testing-cors.md) + [CORS-Fehlerbehebung](cors-troubleshooting.md) # Elemente einer CORS-Konfiguration Um Ihren Bucket so zu konfigurieren, dass er ursprungsübergreifende Anfragen zulässt, erstellen Sie eine CORS-Konfiguration. Die CORS-Konfiguration ist ein Dokument mit Elementen, die die Ursprünge, die auf Ihren Bucket zugreifen dürfen, die Vorgänge (HTTP-Methoden), die die einzelnen Ursprünge unterstützen, sowie weitere operationsspezifische Informationen identifizieren. Sie können der Konfiguration bis zu 100 Regeln hinzufügen. Sie können dem Bucket die CORS-Konfiguration als `cors`-Subressource hinzufügen. Wenn Sie CORS in der S3-Konsole konfigurieren, müssen Sie JSON verwenden, um eine CORS-Konfiguration zu erstellen. Die neue S3-Konsole unterstützt nur JSON CORS-Konfigurationen. Weitere Informationen über die CORS-Konfiguration und die darin enthaltenen Elemente finden Sie in den folgenden Themen. Anweisungen zum Hinzufügen einer CORS-Konfiguration finden Sie unter [Cross-Origin Resource Sharing (CORS) konfigurieren](enabling-cors-examples.md). **Wichtig** In der S3-Konsole muss die CORS-Konfiguration JSON sein. **Topics** + [`AllowedMethods`-Element](#cors-allowed-methods) + [`AllowedOrigins`-Element](#cors-allowed-origin) + [`AllowedHeaders`-Element](#cors-allowed-headers) + [`ExposeHeaders`-Element](#cors-expose-headers) + [`MaxAgeSeconds`-Element](#cors-max-age) + [Beispiele für CORS-Konfigurationen](#cors-example-1) ## `AllowedMethods`-Element In der CORS-Konfiguration können Sie die folgenden Werte für das `AllowedMethods`-Element angeben. + GET + PUT + POST + DELETE + HEAD ## `AllowedOrigins`-Element Im `AllowedOrigins`-Element geben Sie die Ursprünge an, über die Sie domänenübergreifende Anfragen erlauben möchten, z. B. ` http://www.example.com`. Die Ursprungszeichenfolge darf nur ein `*`-Platzhalterzeichen enthalten, wie beispielsweise `http://*.example.com`. Optional können Sie `*` als Ursprung angeben, sodass alle Ursprünge ursprungsübergreifende Anfragen senden dürfen. Sie können auch `https` angeben, um nur sichere Ursprünge zuzulassen. ## `AllowedHeaders`-Element Das `AllowedHeaders`-Element gibt an, welche Header in einer Preflight-Anfrage durch den `Access-Control-Request-Headers`-Header erlaubt sind. Jeder Header-Name im `Access-Control-Request-Headers`-Header muss mit einem entsprechenden Eintrag in dem Element übereinstimmen. Amazon S3 sendet nur die zulässigen angeforderten Header in einer Antwort. Eine Liste mit Beispielen für Header, die in Anfragen an Amazon S3 verwendet werden können, finden Sie unter [Häufig verwendete Anforderungsheader](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTCommonRequestHeaders.html) im *API-Referenzhandbuch zum Amazon Simple Storage Service*. Jede AllowedHeaders Zeichenfolge in Ihrer Konfiguration kann höchstens ein Platzhalterzeichen (\$1) enthalten. Beispielsweise aktiviert `x-amz-*` alle für Amazon spezifischen Header. ## `ExposeHeaders`-Element Jedes `ExposeHeader` Element identifiziert einen Header in der Antwort, auf den Kunden von ihren Anwendungen (z. B. von einem JavaScript `XMLHttpRequest` Objekt) aus zugreifen können sollen. Eine Liste der gängigen Amazon-S3-Antwortheader finden Sie unter [Häufig verwendete Anforderungsheader](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTCommonResponseHeaders.html) im *API-Referenzhandbuch zum Amazon Simple Storage Service*. ## `MaxAgeSeconds`-Element Das `MaxAgeSeconds`-Element gibt die Zeit in Sekunden an, wie lange Ihr Browser die Antwort auf eine Preflight-Anfrage zwischenspeichern kann, wie nach der Ressource, der HTTP-Methode und dem Ursprung identifiziert. ## Beispiele für CORS-Konfigurationen Statt über einen Amazon-S3-Website-Endpunkt auf eine Website zuzugreifen, können Sie Ihre eigen Domäne verwenden, wie beispielsweise `example1.com`, um Ihren Inhalt bereitzustellen. Weitere Informationen zur Verwendung Ihrer eigenen Domäne finden Sie unter [Tutorial: Konfigurieren einer statischen Website mithilfe einer benutzerdefinierten bei Route 53 registrierten Domäne](website-hosting-custom-domain-walkthrough.md). Die folgende Beispielkonfiguration für CORS umfasst drei Regeln, die als `CORSRule`-Elemente angegeben sind: + Die erste Regel gestattet ursprungsübergreifende PUT-, POST- und DELETE-Anfragen vom Ursprung `http://www.example1.com`. Die Regel gestattet auch alle Header in einer Preflight-OPTIONS-Anfrage durch den `Access-Control-Request-Headers`-Header. Als Antwort auf Preflight-OPTIONS-Anfragen gibt Amazon S3 angeforderte Header zurück. + Die zweite Regel gestattet dieselben ursprungsübergreifenden Anfragen wie die erste Regel, aber sie bezieht sich auf einen anderen Ursprung, `http://www.example2.com`. + Die dritte Regel gestattet ursprungsübergreifende GET-Anfragen von allen Ursprüngen. Das Platzhalterzeichen `*` bezieht sich auf alle Ursprünge. ------ #### [ JSON ] ``` [ { "AllowedHeaders": [ "*" ], "AllowedMethods": [ "PUT", "POST", "DELETE" ], "AllowedOrigins": [ "http://www.example1.com" ], "ExposeHeaders": [] }, { "AllowedHeaders": [ "*" ], "AllowedMethods": [ "PUT", "POST", "DELETE" ], "AllowedOrigins": [ "http://www.example2.com" ], "ExposeHeaders": [] }, { "AllowedHeaders": [], "AllowedMethods": [ "GET" ], "AllowedOrigins": [ "*" ], "ExposeHeaders": [] } ] ``` ------ #### [ XML ] ``` http://www.example1.com PUT POST DELETE * http://www.example2.com PUT POST DELETE * * GET ``` ------ Die CORS-Konfiguration unterstützt auch optionale Konfigurationsparameter, wie in der folgenden CORS-Konfiguration gezeigt. In diesem Beispiel gestattet die folgende CORS-Konfiguration ursprungsübergreifende PUT-, POST- und DELETE-Anfragen vom Ursprung `http://www.example.com`. ------ #### [ JSON ] ``` [ { "AllowedHeaders": [ "*" ], "AllowedMethods": [ "PUT", "POST", "DELETE" ], "AllowedOrigins": [ "http://www.example.com" ], "ExposeHeaders": [ "x-amz-server-side-encryption", "x-amz-request-id", "x-amz-id-2" ], "MaxAgeSeconds": 3000 } ] ``` ------ #### [ XML ] ``` http://www.example.com PUT POST DELETE * 3000 x-amz-server-side-encryption x-amz-request-id x-amz-id-2 ``` ------ Das `CORSRule`-Element in der obigen Konfiguration beinhaltet die folgenden optionalen Elemente: + `MaxAgeSeconds` – Gibt den Zeitraum in Sekunden an (in diesem Beispiel 3000), für den der Browser eine Amazon-S3-Antwort auf eine Preflight-OPTIONS-Anfrage für die angegebene Ressource zwischenspeichert. Durch die Zwischenspeicherung der Antwort muss der Browser keine Preflight-Anfragen an Amazon S3 senden, wenn die ursprüngliche Anfrage wiederholt werden soll. + `ExposeHeaders`— Identifiziert die Antwort-Header (in diesem Beispiel, `x-amz-server-side-encryption``x-amz-request-id`, und`x-amz-id-2`), auf die Kunden von ihren Anwendungen aus zugreifen können (z. B. von einem JavaScript `XMLHttpRequest` Objekt aus). # Cross-Origin Resource Sharing (CORS) konfigurieren Cross-Origin Resource Sharing (CORS) bestimmt für Client-Webanwendungen, die in einer Domain geladen sind, eine Möglichkeit zur Interaktion mit Ressourcen in einer anderen Domain. Mit CORS-Unterstützung können Sie umfassende clientseitige Webanwendungen mit Amazon S3 erstellen und selektiven ursprungsübergreifenden Zugriff auf Ihre Amazon-S3-Ressourcen zulassen. In diesem Abschnitt erfahren Sie, wie Sie CORS mithilfe der Amazon S3 S3-Konsole, der Amazon S3 S3-REST-API und der AWS SDKs aktivieren. Um Ihren Bucket so zu konfigurieren, dass er ursprungsübergreifende Anfragen zulässt, fügen Sie dem Bucket eine CORS-Konfiguration hinzu. Eine CORS-Konfiguration ist ein Dokument, das Regeln, die die Ursprünge identifizieren, die den Zugriff auf Ihren Bucket zulassen, die Vorgänge (HTTP-Methoden), die die einzelnen Ursprünge unterstützen, sowie weitere operationsspezifische Informationen definiert. In der S3-Konsole muss die CORS-Konfiguration ein JSON-Dokument sein. Beispiele für CORS-Konfigurationen in JSON und XML finden Sie unter [Elemente einer CORS-Konfiguration](ManageCorsUsing.md). ## Verwenden der S3-Konsole Dieser Abschnitt erklärt, wie Sie die Amazon-S3-Konsole verwenden, um einem S3-Bucket CORS (Cross-Origin Resource Sharing) hinzuzufügen. Wenn Sie CORS im Bucket aktivieren, gelten weiterhin die Zugriffskontrolllisten (ACLs) und andere Richtlinien für Zugriffsberechtigungen. **Wichtig** In der S3-Konsole muss die CORS-Konfiguration JSON sein. Beispiele für CORS-Konfigurationen in JSON und XML finden Sie unter [Elemente einer CORS-Konfiguration](ManageCorsUsing.md). **So fügen Sie einem S3-Bucket eine CORS-Konfiguration hinzu:** 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/). 1. Wählen Sie im linken Navigationsbereich **Allzweck-Buckets** aus. 1. Wählen Sie in der Liste Buckets den Namen des Buckets aus, für den Sie eine Bucket-Richtlinie erstellen wollen. 1. Wählen Sie **Permissions (Berechtigungen)**. 1. Wählen Sie im Abschnitt **Cross-Origin Resource Sharing (CORS)** die Option **Edit (Bearbeiten)** aus. 1. Geben Sie in das Textfeld **CORS configuration editor** eine neue CORS-Konfiguration ein, fügen Sie dort eine kopierte Konfiguration ein oder bearbeiten Sie eine vorhandene Konfiguration. Die CORS-Konfiguration ist eine JSON-Datei. Der Text, den Sie in den Editor eingeben, muss gültiges JSON sein. Weitere Informationen finden Sie unter [Elemente einer CORS-Konfiguration](ManageCorsUsing.md). 1. Wählen Sie **Save Changes (Änderungen speichern)**. **Anmerkung** Amazon S3 zeigt den Amazon Resource Name (ARN) für den Bucket neben dem Titel **CORS configuration editor** an. Weitere Informationen zu ARNs finden Sie unter [Amazon Resource Names (ARNs) und AWS Service Namespaces](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) in der. *Allgemeine Amazon Web Services-Referenz* ## Mit dem AWS SDKs Sie können das AWS SDK verwenden, um Cross-Origin Resource Sharing (CORS) für einen Bucket zu verwalten. Weitere Informationen über CORS finden Sie unter [Cross-Origin Resource Sharing (CORS) verwenden](cors.md). Im Folgenden sind einige Beispiele aufgeführt: + Erstellt eine CORS-Konfiguration und legt die Konfiguration für einen Bucket fest. + Ruft die Konfiguration ab und ändert sie durch Hinzufügen einer Regel ab + Fügt die abgeänderte Konfiguration dem Bucket hinzu + Löscht die Konfiguration ------ #### [ Java ] **Example** **Example** Anweisungen zum Erstellen und Testen eines funktionierenden Beispiels finden Sie unter [Erste Schritte](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html) im AWS SDK für Java Entwicklerhandbuch. ``` import com.amazonaws.AmazonServiceException; import com.amazonaws.SdkClientException; 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.BucketCrossOriginConfiguration; import com.amazonaws.services.s3.model.CORSRule; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class CORS { public static void main(String[] args) throws IOException { Regions clientRegion = Regions.DEFAULT_REGION; String bucketName = "*** Bucket name ***"; // Create two CORS rules. List rule1AM = new ArrayList(); rule1AM.add(CORSRule.AllowedMethods.PUT); rule1AM.add(CORSRule.AllowedMethods.POST); rule1AM.add(CORSRule.AllowedMethods.DELETE); CORSRule rule1 = new CORSRule().withId("CORSRule1").withAllowedMethods(rule1AM) .withAllowedOrigins(Arrays.asList("http://*.example.com")); List rule2AM = new ArrayList(); rule2AM.add(CORSRule.AllowedMethods.GET); CORSRule rule2 = new CORSRule().withId("CORSRule2").withAllowedMethods(rule2AM) .withAllowedOrigins(Arrays.asList("*")).withMaxAgeSeconds(3000) .withExposedHeaders(Arrays.asList("x-amz-server-side-encryption")); List rules = new ArrayList(); rules.add(rule1); rules.add(rule2); // Add the rules to a new CORS configuration. BucketCrossOriginConfiguration configuration = new BucketCrossOriginConfiguration(); configuration.setRules(rules); try { AmazonS3 s3Client = AmazonS3ClientBuilder.standard() .withCredentials(new ProfileCredentialsProvider()) .withRegion(clientRegion) .build(); // Add the configuration to the bucket. s3Client.setBucketCrossOriginConfiguration(bucketName, configuration); // Retrieve and display the configuration. configuration = s3Client.getBucketCrossOriginConfiguration(bucketName); printCORSConfiguration(configuration); // Add another new rule. List rule3AM = new ArrayList(); rule3AM.add(CORSRule.AllowedMethods.HEAD); CORSRule rule3 = new CORSRule().withId("CORSRule3").withAllowedMethods(rule3AM) .withAllowedOrigins(Arrays.asList("http://www.example.com")); rules = configuration.getRules(); rules.add(rule3); configuration.setRules(rules); s3Client.setBucketCrossOriginConfiguration(bucketName, configuration); // Verify that the new rule was added by checking the number of rules in the // configuration. configuration = s3Client.getBucketCrossOriginConfiguration(bucketName); System.out.println("Expected # of rules = 3, found " + configuration.getRules().size()); // Delete the configuration. s3Client.deleteBucketCrossOriginConfiguration(bucketName); System.out.println("Removed CORS configuration."); // Retrieve and display the configuration to verify that it was // successfully deleted. configuration = s3Client.getBucketCrossOriginConfiguration(bucketName); printCORSConfiguration(configuration); } 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(); } } private static void printCORSConfiguration(BucketCrossOriginConfiguration configuration) { if (configuration == null) { System.out.println("Configuration is null."); } else { System.out.println("Configuration has " + configuration.getRules().size() + " rules\n"); for (CORSRule rule : configuration.getRules()) { System.out.println("Rule ID: " + rule.getId()); System.out.println("MaxAgeSeconds: " + rule.getMaxAgeSeconds()); System.out.println("AllowedMethod: " + rule.getAllowedMethods()); System.out.println("AllowedOrigins: " + rule.getAllowedOrigins()); System.out.println("AllowedHeaders: " + rule.getAllowedHeaders()); System.out.println("ExposeHeader: " + rule.getExposedHeaders()); System.out.println(); } } } } ``` ------ #### [ .NET ] **Example** 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 Developer Guide*. ``` using Amazon; using Amazon.S3; using Amazon.S3.Model; using System; using System.Collections.Generic; using System.Threading.Tasks; namespace Amazon.DocSamples.S3 { class CORSTest { 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() { s3Client = new AmazonS3Client(bucketRegion); CORSConfigTestAsync().Wait(); } private static async Task CORSConfigTestAsync() { try { // Create a new configuration request and add two rules CORSConfiguration configuration = new CORSConfiguration { Rules = new System.Collections.Generic.List { new CORSRule { Id = "CORSRule1", AllowedMethods = new List {"PUT", "POST", "DELETE"}, AllowedOrigins = new List {"http://*.example.com"} }, new CORSRule { Id = "CORSRule2", AllowedMethods = new List {"GET"}, AllowedOrigins = new List {"*"}, MaxAgeSeconds = 3000, ExposeHeaders = new List {"x-amz-server-side-encryption"} } } }; // Add the configuration to the bucket. await PutCORSConfigurationAsync(configuration); // Retrieve an existing configuration. configuration = await RetrieveCORSConfigurationAsync(); // Add a new rule. configuration.Rules.Add(new CORSRule { Id = "CORSRule3", AllowedMethods = new List { "HEAD" }, AllowedOrigins = new List { "http://www.example.com" } }); // Add the configuration to the bucket. await PutCORSConfigurationAsync(configuration); // Verify that there are now three rules. configuration = await RetrieveCORSConfigurationAsync(); Console.WriteLine(); Console.WriteLine("Expected # of rulest=3; found:{0}", configuration.Rules.Count); Console.WriteLine(); Console.WriteLine("Pause before configuration delete. To continue, click Enter..."); Console.ReadKey(); // Delete the configuration. await DeleteCORSConfigurationAsync(); // Retrieve a nonexistent configuration. configuration = await RetrieveCORSConfigurationAsync(); } catch (AmazonS3Exception e) { Console.WriteLine("Error encountered on server. 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); } } static async Task PutCORSConfigurationAsync(CORSConfiguration configuration) { PutCORSConfigurationRequest request = new PutCORSConfigurationRequest { BucketName = bucketName, Configuration = configuration }; var response = await s3Client.PutCORSConfigurationAsync(request); } static async Task RetrieveCORSConfigurationAsync() { GetCORSConfigurationRequest request = new GetCORSConfigurationRequest { BucketName = bucketName }; var response = await s3Client.GetCORSConfigurationAsync(request); var configuration = response.Configuration; PrintCORSRules(configuration); return configuration; } static async Task DeleteCORSConfigurationAsync() { DeleteCORSConfigurationRequest request = new DeleteCORSConfigurationRequest { BucketName = bucketName }; await s3Client.DeleteCORSConfigurationAsync(request); } static void PrintCORSRules(CORSConfiguration configuration) { Console.WriteLine(); if (configuration == null) { Console.WriteLine("\nConfiguration is null"); return; } Console.WriteLine("Configuration has {0} rules:", configuration.Rules.Count); foreach (CORSRule rule in configuration.Rules) { Console.WriteLine("Rule ID: {0}", rule.Id); Console.WriteLine("MaxAgeSeconds: {0}", rule.MaxAgeSeconds); Console.WriteLine("AllowedMethod: {0}", string.Join(", ", rule.AllowedMethods.ToArray())); Console.WriteLine("AllowedOrigins: {0}", string.Join(", ", rule.AllowedOrigins.ToArray())); Console.WriteLine("AllowedHeaders: {0}", string.Join(", ", rule.AllowedHeaders.ToArray())); Console.WriteLine("ExposeHeader: {0}", string.Join(", ", rule.ExposeHeaders.ToArray())); } } } } ``` ------ ## Verwenden der REST-API Sie können die AWS-Managementkonsole verwenden, um eine CORS-Konfiguration für Ihren Bucket zu erstellen. Falls in Ihrer Anwendung erforderlich, können Sie auch direkt REST-Anfragen senden. In den folgenden Abschnitten der *API-Referenz zum Amazon Simple Storage Service* werden die REST-API-Aktionen im Zusammenhang mit der CORS-Konfiguration beschrieben: + [PutBucketCors](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTcors.html) + [GetBucketCors](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETcors.html) + [DeleteBucketCors](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketDELETEcors.html) + [OPTIONS-Objekt](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTOPTIONSobject.html) # Testen von CORS Um Ihre CORS-Konfiguration zu testen, können Sie mit der `OPTIONS`-Methode eine CORS-Preflight-Anfrage senden, sodass der Server antworten kann, falls das Senden der Anfrage akzeptiert wird. Wenn Amazon S3 eine Preflight-Anfrage erhält, wertet S3 die CORS-Konfiguration für den Bucket aus und verwendet die erste `CORSRule`-Regel, die der eingehenden Browser-Anfrage entspricht, um eine ursprungsübergreifende Anfrage zuzulassen. Für die Übereinstimmung mit einer Regel müssen die folgenden Bedingungen erfüllt sei: + Der `Origin`-Header in einer CORS-Anfrage an Ihren Bucket muss den Ursprüngen im Element `AllowedOrigins` Ihrer CORS-Konfiguration entsprechen. + Die HTTP-Methoden, die in der `Access-Control-Request-Method` einer CORS-Anfrage an Ihren Bucket angegeben sind, müssen der oder den Methoden entsprechen, die im Element `AllowedMethods` Ihrer CORS-Konfiguration aufgeführt sind. + Die im Header `Access-Control-Request-Headers` einer Preflight-Anfrage aufgeführten Header müssen den Headern im Element `AllowedHeaders` Ihrer CORS-Konfiguration entsprechen. Im Folgenden finden Sie eine CORS-Beispielkonfiguration. Informationen zum Erstellen einer CORS-Konfiguration finden Sie unter [Konfigurieren von CORS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enabling-cors-examples.html). Weitere Beispiele für eine CORS-Konfiguration finden Sie unter [Elemente einer CORS-Konfiguration](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ManageCorsUsing.html). Anleitungen zur Konfiguration und Fehlerbehebung von CORS-Regeln finden Sie unter [Wie konfiguriere ich CORS in Amazon S3 und bestätige die CORS-Regeln mit cURL](https://repost.aws/knowledge-center/s3-configure-cors)? im AWS re:Post Knowledge Center. ------ #### [ JSON ] ``` [ { "AllowedHeaders": [ "Authorization" ], "AllowedMethods": [ "GET", "PUT", "POST", "DELETE" ], "AllowedOrigins": [ "http://www.example1.com" ], "ExposeHeaders": [ "x-amz-meta-custom-header" ] } ] ``` ------ Um die CORS-Konfiguration zu testen, können Sie mit dem folgenden CURL-Befehl eine `OPTIONS`-Preflight-Prüfung senden. CURL ist ein Befehlszeilentool für die Interaktion mit S3. Weitere Informationen finden Sie unter [CURL](https://curl.se/). ``` curl -v -X OPTIONS \ -H "Origin: http://www.example1.com" \ -H "Access-Control-Request-Method: PUT" \ -H "Access-Control-Request-Headers: Authorization" \ -H "Access-Control-Expose-Headers: x-amz-meta-custom-header"\ "http://bucket_name.s3.amazonaws.com/object_prefix_name" ``` Im obigen Beispiel wird der `curl -v -x OPTIONS`-Befehl verwendet, um eine Preflight-Anfrage an S3 zu senden und abzufragen, ob S3 es erlaubt, eine `PUT`-Anforderung für ein Objekt vom übergreifenden Ursprung `http://www.example1.com` zu senden. Die Header `Access-Control-Request-Headers` und `Access-Control-Expose-Headers` sind optional. + Als Antwort auf den Header `Access-Control-Request-Method` in der `OPTIONS`-Preflight-Anfrage gibt Amazon S3 die Liste der zulässigen Methoden zurück, wenn die angeforderten Methoden entsprechen. + Als Antwort auf den Header `Access-Control-Request-Headers` in der `OPTIONS`-Preflight-Anfrage gibt Amazon S3 die Liste der zulässigen Header zurück, wenn die angeforderten Header entsprechen. + Als Antwort auf den Header `Access-Control-Expose-Headers` in der `OPTIONS`-Preflight-Anfrage gibt Amazon S3 eine Liste der zulässigen Header zurück, wenn die angeforderten Header den zulässigen Headern entsprechen, auf die über im Browser ausgeführte Skripts zugegriffen werden kann. **Anmerkung** Wenn beim Senden einer Preflight-Anfrage einer der CORS-Anforderungs-Header nicht zulässig ist, wird keiner der CORS-Antwort-Header zurückgegeben. Als Antwort auf die `OPTIONS`-Preflight-Anfrage erhalten Sie die Antwort `200 OK`. Allgemeine Fehlercodes, die Sie beim Testen von CORS erhalten können, und weitere Informationen zur Lösung von Problemen rund um CORS finden Sie unter [CORS-Fehlerbehebung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/cors-troubleshooting.html). ``` < HTTP/1.1 200 OK < Date: Fri, 12 Jul 2024 00:23:51 GMT < Access-Control-Allow-Origin: http://www.example1.com < Access-Control-Allow-Methods: GET, PUT, POST, DELETE < Access-Control-Allow-Headers: Authorization < Access-Control-Expose-Headers: x-amz-meta-custom-header < Access-Control-Allow-Credentials: true < Vary: Origin, Access-Control-Request-Headers, Access-Control-Request-Method < Server: AmazonS3 < Content-Length: 0 ``` # CORS-Fehlerbehebung Die folgenden Themen können bei der Behebung von allgemeinen Problemen mit CORS in Bezug auf S3 hilfreich sein. **Topics** + [Fehler 403 Forbidden – CORS ist für diesen Bucket nicht aktiviert](#cors-not-enabled) + [Fehler 403 Forbidden – Diese CORS-Anfrage ist nicht zulässig](#cors-not-enabled) + [Header nicht in der CORS-Antwort gefunden](#Headers-not-found) + [Überlegungen zu CORS in S3-Proxy-Integrationen](#cors-in-proxy) ## Fehler 403 Forbidden: CORS ist für diesen Bucket nicht aktiviert Der Fehler `403 Forbidden` tritt auf, wenn eine ursprungsübergreifende Anfrage an Amazon S3 gesendet wird, CORS jedoch nicht in Ihrem S3-Bucket konfiguriert ist. Fehler: HTTP/1.1 403 Forbidden CORS Response: CORS is not enabled for this bucket. Die CORS-Konfiguration ist ein Dokument oder eine Richtlinien mit Regeln, die die Ursprünge, die auf Ihren Bucket zugreifen dürfen, die Vorgänge (HTTP-Methoden), die die einzelnen Ursprünge unterstützen, sowie weitere operationsspezifische Informationen identifizieren. Erfahren [Sie, wie Sie CORS auf S3 mithilfe der Amazon S3 S3-Konsole und der REST-API konfigurieren](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enabling-cors-examples.html). AWS SDKs Weitere Informationen zu CORS und Beispiele für eine CORS-Konfiguration finden Sie unter [Elemente von CORS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ManageCorsUsing.html#cors-example-1). ## Fehler 403 Forbidden: Diese CORS-Anfrage ist nicht zulässig Sie erhalten den Fehler `403 Forbidden`, wenn eine CORS-Regel in Ihrer CORS-Konfiguration nicht den Daten in Ihrer Anfrage entspricht. Fehler: HTTP/1.1 403 Forbidden CORS Response: This CORS request is not allowed. Daher kann der Fehler `403 Forbidden` aus mehreren Gründen auftreten: + Ursprung ist nicht zulässig. + Methoden sind nicht zulässig. + Angeforderte Header sind nicht zulässig. Für jede von Amazon S3 erhaltene Anfrage benötigen Sie eine CORS-Regel in Ihrer CORS-Konfiguration, die den Daten in Ihrer Anfrage entspricht. ### Ursprung ist nicht zulässig Der `Origin`-Header in einer CORS-Anfrage an Ihren Bucket muss den Ursprüngen im Element `AllowedOrigins` Ihrer CORS-Konfiguration entsprechen. Ein Platzhalterzeichen (`"*"`) im Element `AllowedOrigins` würde allen HTTP-Methoden entsprechen. Weitere Informationen zum Aktualisieren des Elements `AllowedOrigins` finden Sie unter [Cross-Origin Resource Sharing (CORS) konfigurieren](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enabling-cors-examples.html). Wenn beispielsweise nur die Domain `http://www.example1.com` im Element `AllowedOrigins` enthalten ist, würde eine von der Domain `http://www.example2.com` gesendete CORS-Anfrage den Fehler `403 Forbidden` erhalten. Das folgende Beispiel zeigt einen Teil einer CORS-Konfiguration, der die Domäne `http://www.example1.com` im Element `AllowedOrigins` enthält. ``` "AllowedOrigins":[ "http://www.example1.com" ] ``` Damit eine von der Domain `http://www.example2.com` gesendete CORS-Anfrage erfolgreich ist, muss die Domain `http://www.example2.com` in das Element `AllowedOrigins` der CORS-Konfiguration aufgenommen werden. ``` "AllowedOrigins":[ "http://www.example1.com" "http://www.example2.com" ] ``` ### Methoden sind nicht zulässig Die HTTP-Methoden, die in der `Access-Control-Request-Method` einer CORS-Anfrage an Ihren Bucket angegeben sind, müssen der oder den Methoden entsprechen, die im Element `AllowedMethods` Ihrer CORS-Konfiguration aufgeführt sind. Ein Platzhalterzeichen (`"*"`) in `AllowedMethods` würde allen HTTP-Methoden entsprechen. Weitere Informationen zum Aktualisieren des Elements `AllowedOrigins` finden Sie unter [Cross-Origin Resource Sharing (CORS) konfigurieren](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enabling-cors-examples.html). In einer CORS-Konfiguration können Sie im Element `AllowedMethods` die folgenden Methoden angeben: + `GET` + `PUT` + `POST` + `DELETE` + `HEAD` Das folgende Beispiel zeigt einen Teil einer CORS-Konfiguration, der die Methode `GET` im Element `AllowedMethods` enthält. Nur Anfragen, die die Methode `GET` enthalten, wären erfolgreich. ``` "AllowedMethods":[ "GET" ] ``` Wenn eine HTTP-Methode (z. B. `PUT`) in einer CORS-Anfrage verwendet wurde oder in einer Preflight-CORS-Anfrage an Ihren Bucket enthalten war, die Methode jedoch nicht in Ihrer CORS-Konfiguration vorhanden ist, führt die Anfrage zu einem Fehler des Typs `403 Forbidden`. Um diese CORS- oder CORS-Preflight-Anfrage zuzulassen, muss die Methode `PUT` zu Ihrer CORS-Konfiguration hinzugefügt werden. ``` "AllowedMethods":[ "GET" "PUT" ] ``` ### Angeforderte Header sind nicht zulässig Die im Header `Access-Control-Request-Headers` einer Preflight-Anfrage aufgeführten Header müssen den Headern im Element `AllowedHeaders` Ihrer CORS-Konfiguration entsprechen. Eine Liste mit üblichen Headern, die in Anforderungen an Amazon S3 verwendet werden können, finden Sie unter [Häufig verwendete Anforderungsheader](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTCommonRequestHeaders.html). Weitere Informationen zum Aktualisieren des Elements `AllowedHeaders` finden Sie unter [Cross-Origin Resource Sharing (CORS) konfigurieren](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enabling-cors-examples.html). Das folgende Beispiel zeigt einen Teil einer CORS-Konfiguration, der den Header `Authorization` im Element `AllowedHeaders` enthält. Nur Anfragen für den Header `Authorization` wären erfolgreich. ``` "AllowedHeaders": [ "Authorization" ] ``` Wenn ein Header (z. B. `Content-MD5`) in einer CORS-Anfrage enthalten war, jedoch nicht in Ihrer CORS-Konfiguration vorhanden ist, führt die Anfrage zu einem Fehler des Typs `403 Forbidden`. Um diese CORS-Anfrage zuzulassen, muss der Header `Content-MD5` zu Ihrer CORS-Konfiguration hinzugefügt werden. Wenn Sie sowohl den Header `Authorization` als auch den Header `Content-MD5` in einer CORS-Anfrage an Ihren Bucket übergeben möchten, stellen Sie sicher, dass beide Header im Element `AllowedHeaders` Ihrer CORS-Konfiguration enthalten sind. ``` "AllowedHeaders": [ "Authorization" "Content-MD5" ] ``` ## Header nicht in der CORS-Antwort gefunden Das Element `ExposeHeaders` Ihrer CORS-Konfiguration identifiziert, welche Antwort-Header Sie für Skripts und Anwendungen, die in Browsern ausgeführt werden, als Antwort auf eine CORS-Anfrage zugänglich machen möchten. Wenn Ihre in Ihrem S3-Bucket gespeicherten Objekte benutzerdefinierte Metadaten (z. B.`x-amz-meta-custom-header`) zusammen mit den Antwortdaten haben, könnte dieser benutzerdefinierte Header zusätzliche Metadaten oder Informationen enthalten, auf die Sie über Ihren JavaScript clientseitigen Code zugreifen möchten. Standardmäßig blockieren Browser jedoch aus Sicherheitsgründen den Zugriff auf benutzerdefinierte Header. Damit Ihre Client-Seite auf benutzerdefinierte Header zugreifen JavaScript kann, müssen Sie den Header in Ihre CORS-Konfiguration aufnehmen. Im folgenden Beispiel ist der Header `x-amz-meta-custom-header1` im Element `ExposeHeaders` enthalten. Der Header `x-amz-meta-custom-header2` ist nicht im Element `ExposeHeaders` enthalten und fehlt in der CORS-Konfiguration. In der Antwort würden nur die im Element `ExposeHeaders` enthaltenen Werte zurückgegeben werden. Hätte die Anfrage den Header `x-amz-meta-custom-header2` im Header `Access-Control-Expose-Headers` enthalten, würde die Antwort trotzdem `200 OK` zurückgeben. Es würde jedoch nur der zulässige Header, z. B. `x-amz-meta-custom-header`, zurückgegeben und in der Antwort angezeigt werden. ``` "ExposeHeaders": [ "x-amz-meta-custom-header1" ] ``` Um sicherzustellen, dass alle Header in der Antwort erscheinen, fügen Sie dem Element `ExposeHeaders` Ihrer CORS-Konfiguration alle zulässigen Header hinzu, wie unten gezeigt. ``` "ExposeHeaders": [ "x-amz-meta-custom-header1", "x-amz-meta-custom-header2" ] ``` ## Überlegungen zu CORS in S3-Proxy-Integrationen Wenn bei Ihnen Fehler auftreten und Sie die CORS-Konfiguration in Ihrem S3-Bucket bereits überprüft haben und die Cross-Origin-Anfrage an Proxys wie gesendet wird, versuchen Sie Folgendes: AWS CloudFront + Konfigurieren Sie die Einstellungen so, dass die Methode `OPTIONS` für HTTP-Anfragen zulässig ist. + Konfigurieren Sie den Proxy so, dass er die folgenden Header weiterleitet: `Origin`, `Access-Control-Request-Headers` und `Access-Control-Request-Method`. + Konfigurieren Sie die Proxyeinstellungen so, dass der Origin-Header in den Cache-Schlüssel aufgenommen wird. Dies ist wichtig, da das Zwischenspeichern von Proxys, die den Origin-Header nicht in ihrem Cache-Schlüssel enthalten, zwischengespeicherte Antworten bereitstellen kann, die nicht die entsprechenden CORS-Header für unterschiedliche Ursprünge enthalten. Einige Proxys bieten vordefinierte Features für CORS-Anfragen. In können Sie beispielsweise eine Richtlinie konfigurieren CloudFront, die die Header enthält die CORS-Anforderungen (Cross-Origin Resource Sharing) aktivieren, wenn der Ursprung ein Amazon S3 Bucket ist. Diese Richtlinie hat folgende Einstellungen: + Header, die in Ursprungsanfragen enthalten sind: `Origin` `Access-Control-Request-Headers` `Access-Control-Request-Method` + **Cookies, die in Ursprungsanfragen enthalten sind:** Keine + **Abfragezeichenfolgen, die in Ursprungsanforderungen enthalten sind:** Keine Weitere Informationen finden Sie unter [Steuern von Anfragen mit Ursprung mithilfe einer Richtlinie](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/controlling-origin-requests.htm) und [Verwenden von Richtlinien für verwaltete Anfragen mit Ursprung](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html#managed-origin-request-policy-cors-s3) im *CloudFront Entwicklerhandbuch*.