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.
# Integrationsanfrage in API Gateway einrichten
Führen Sie die folgenden erforderlichen und optionalen Schritte aus, um eine Integrationsanforderung einzurichten:
1. Wählen Sie einen Integrationstyp aus, um festzulegen, wie Methodenanforderungsdaten an das Backend übergeben werden.
1. Geben Sie für alle Integrationen außerdem dem Integrationstyp `MOCK` eine HTTP-Methode und die URI des gewählten Integrationsendpunkts an.
1. Für Integrationen mit Lambda-Funktionen und anderen AWS Serviceaktionen richten Sie eine IAM-Rolle mit den erforderlichen Berechtigungen ein, damit API Gateway das Backend in Ihrem Namen aufruft.
1. Richten Sie für Nicht-Proxy-Integrationen die erforderlichen Parameter-Mappings ein, um vordefinierte Methodenanforderungs-Parameter den entsprechenden Integrationsanforderungs-Parametern zuzuordnen.
1. Richten Sie für Nicht-Proxy-Integrationen die erforderlichen Inhalts-Mappings ein, um den Inhalt der eingehenden Methodenanforderung eines bestimmten Inhaltstyps gemäß der angegebenen Mapping-Vorlage zuzuordnen.
1. Geben Sie für Nicht-Proxy-Integrationen die Bedingung an, unter der die eingehenden Methodenanforderungsdaten unverändert an das Backend übergeben werden.
1. Legen Sie optional fest, wie Typumwandlungen für binäre Nutzlasten verarbeitet werden sollen.
1. Deklarieren Sie optional einen Cache-Namespace-Namen und Cache-Schlüsselparameter, um API-Caching zu aktivieren.
Zur Durchführung dieser Aufgaben müssen Sie eine API Gateway-[Integrations](https://docs.aws.amazon.com/apigateway/latest/api/API_Integration.html)-Ressource erstellen und entsprechende Eigenschaftswerte festlegen. Sie können dazu die API Gateway Gateway-Konsole, AWS CLI Befehle, ein AWS SDK oder die API Gateway Gateway-REST-API verwenden.
**Topics**
+ [Grundlegende Aufgaben einer API-Integrationsanforderung](integration-request-basic-setup.md)
+ [Auswählen eines API Gateway-API-Integration](api-gateway-api-integration-types.md)
+ [Einrichten der Proxy-Integration mit einer Proxy-Ressource](api-gateway-set-up-simple-proxy.md)
+ [API-Integrationsanfrage über die API Gateway-Konsole einrichten](how-to-method-settings-console.md)
# Grundlegende Aufgaben einer API-Integrationsanforderung
Eine Integrationsanforderung ist eine HTTP-Anfrage, die API Gateway an das Backend sendet. Dabei werden die vom Client gesendeten Anfragedaten übergeben und gegebenenfalls umgewandelt. Die HTTP-Methode (oder Verb) und URI der Integrationsanforderung werden vom Backend, also dem Integrationsendpunkt, vorgegeben. Sie können, müssen aber nicht identisch mit der HTTP-Methode und URI der Methodenanforderung übereinstimmen.
Wenn eine Lambda-Funktion eine Datei zurückgibt, die von Amazon S3 abgerufen wurde, können Sie diesen Vorgang beispielsweise intuitiv als `GET`-Methodenanfrage für den Client bereitstellen, obwohl die entsprechende Integrationsanfrage festlegt, dass eine `POST`-Anfrage zum Aufruf der Lambda-Funktion verwendet wird. Bei einem HTTP-Endpunkt ist es wahrscheinlich, dass für die Methodenanforderung und die entsprechende Integrationsanforderung dasselbe HTTP-Verb verwendet wird. Dies ist jedoch nicht erforderlich. Sie können die folgende Methodenanforderung integrieren:
```
GET /{var}?query=value
Host: api.domain.net
```
Mit der folgenden Integrationsanforderung:
```
POST /
Host: service.domain.com
Content-Type: application/json
Content-Length: ...
{
path: "{var}'s value",
type: "value"
}
```
Als API-Entwickler können Sie beliebige HTTP-Verben und URIs für eine Methodenanforderung verwenden, die Ihre Anforderungen erfüllt. Dabei müssen jedoch die Anforderungen des Integrationsendpunkts erfüllt werden. Wenn die Methodenanforderungsdaten sich von den Daten der Integrationsanforderung unterscheiden, können Sie den Unterschied dadurch ausgleichen, dass Sie das Mapping der Methodenanforderungsdaten zu den Integrationsanforderungsdaten angeben.
In den vorherigen Beispielen werden die Werte für die Pfadvariable (`{var}`) und den Abfrageparameter (`query`) der `GET`-Methodenanforderung in Werte der Nutzlasteigenschaften der Integrationsanforderung `path` und `type` zugeordnet. Auch der Header und Inhalt der Anforderungsdaten können zugeordnet werden. Diese werden in [Parameterzuordnung für REST APIs in API Gateway](rest-api-parameter-mapping.md) beschrieben.
Beim Einrichten der HTTP- oder HTTP-Proxy-Integrationsanforderung weisen Sie die URL des Backend-HTTP-Endpunkts als URI-Wert der Integrationsanforderung zu. In der PetStore API hat die Methodenanforderung zum Abrufen einer Seite mit Haustieren beispielsweise den folgenden URI für die Integrationsanforderung:
```
http://petstore-demo-endpoint.execute-api.com/petstore/pets
```
Beim Einrichten der Lambda- oder Lambda-Proxy-Integration weisen Sie den Amazon-Ressourcennamen (ARN) für den Aufruf der Lambda-Funktion als URI-Wert der Integrationsanforderung zu. Der ARN hat das folgende Format:
```
arn:aws:apigateway:api-region:lambda:path//2015-03-31/functions/arn:aws:lambda:lambda-region:account-id:function:lambda-function-name/invocations
```
Der Teil nach `arn:aws:apigateway:api-region:lambda:path/` (`/2015-03-31/functions/arn:aws:lambda:lambda-region:account-id:function:lambda-function-name/invocations`) ist der REST-API-URI-Pfad der Lambda-[Aufruf](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html)-Aktion. Wenn Sie die API Gateway-Konsole zum Einrichten der Lambda-Integration verwenden, erstellt API Gateway den ARN und weist ihn der Integrations-URI zu, nachdem Sie aufgefordert wurden, den `lambda-function-name` aus einer Region auszuwählen.
Wenn die Integrationsanforderung mit einer anderen AWS Dienstaktion eingerichtet wird, ist der Integrationsanforderungs-URI ebenfalls ein ARN, ähnlich der Integration mit der `Invoke` Lambda-Aktion. Für die Integration mit der [GetBucket](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html)Aktion von Amazon S3 ist die Integrationsanforderungs-URI beispielsweise ein ARN mit dem folgenden Format:
```
arn:aws:apigateway:api-region:s3:path/{bucket}
```
Die Integrationsanforderungs-URI entspricht der Pfadkonvention zur Festlegung der Aktion, wobei `{bucket}` der Platzhalter für einen Bucket-Namen ist. Alternativ kann auf eine AWS Serviceaktion anhand ihres Namens verwiesen werden. Mit dem Aktionsnamen sieht die Integrationsanforderungs-URI für die `GetBucket`-Aktion für Amazon S3 wie folgt aus:
```
arn:aws:apigateway:api-region:s3:action/GetBucket
```
In der aktionsbasierten Integrationsanforderungs-URI muss der Bucket-Name (`{bucket}`) im Inhalt der Integrationsanforderung (`{ Bucket: "{bucket}" }`) im Eingabeformat der `GetBucket`-Aktion festgelegt werden.
Für AWS Integrationen müssen Sie auch [Anmeldeinformationen](https://docs.aws.amazon.com/apigateway/latest/api/API_Integration.html#credentials) konfigurieren, damit API Gateway die integrierten Aktionen aufrufen kann. Sie können eine neue IAM-Rolle erstellen oder eine vorhandene IAM-Rolle auswählen, mit der API Gateway die Aktion aufruft, und dann die Rolle mit ihrem ARN angeben. Hier ein Beispiel für diesen ARN:
```
arn:aws:iam::account-id:role/iam-role-name
```
Die IAM-Rolle muss eine Richtlinie enthalten, in der die Berechtigung für die auszuführende Aktion gewährt wird. Außerdem muss API Gateway (in der Vertrauensbeziehung der Rolle) als vertrauenswürdige Entität deklariert sein, um die Rolle übernehmen zu können. Solche Berechtigungen können für die Aktion selbst gewährt werden. Sie werden als ressourcenbasierte Berechtigungen bezeichnet. Für die Lambda-Integration können Sie die Lambda-Aktion [addPermission](https://docs.aws.amazon.com/lambda/latest/dg/API_AddPermission.html) aufrufen, um die ressourcenbasierten Berechtigungen festzulegen, und dann `credentials` in der API Gateway-Integrationsanforderung auf Null festlegen.
Wir haben die Grundlagen der Integrationseinrichtung besprochen. Die erweiterten Einstellungen umfassen die Möglichkeit des Mapping der Methodenanforderungsdaten zu den Integrationsanforderungsdaten. Weitere Informationen finden Sie unter [Datentransformationen für REST APIs in API Gateway](rest-api-data-transformations.md).
# Auswählen eines API Gateway-API-Integration
Die Wahl des API-Integrationstyps erfolgt gemäß dem verwendeten Typs des Integrationsendpunkts und der Übergabemethode von Daten an und von dem Integrationsendpunkt. Für eine Lambda-Funktion können Sie die Lambda-Proxy-Integration oder die benutzerdefinierte Lambda-Integration verwenden. Für einen HTTP-Endpunkt können Sie die HTTP-Proxy-Integration oder die benutzerdefinierte HTTP-Integration verwenden. Für eine AWS Dienstaktion steht Ihnen nur die AWS Integration des Nicht-Proxy-Typs zur Verfügung. API Gateway unterstützt auch die Mock-Integration, bei der API Gateway als Integrationsendpunkt dient, um auf eine Methodenanfragen zu antworten.
Die benutzerdefinierte Lambda-Integration ist ein Sonderfall der AWS Integration, bei dem der Integrationsendpunkt der [funktionsaufrufenden Aktion des Lambda-Service](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html) entspricht.
Programmgesteuert wählen Sie einen Integrationstyp durch Festlegen der Eigenschaft [https://docs.aws.amazon.com/apigateway/latest/api/API_Integration.html#type](https://docs.aws.amazon.com/apigateway/latest/api/API_Integration.html#type) für die Ressource [https://docs.aws.amazon.com/apigateway/latest/api/API_Integration.html](https://docs.aws.amazon.com/apigateway/latest/api/API_Integration.html) aus. Für die Lambda-Proxy-Integration ist der Wert `AWS_PROXY`. Für die benutzerdefinierte Lambda-Integration und alle anderen AWS -Integrationen lautet er `AWS`. Für die HTTP-Proxy-Integration und die HTTP-Integration ist der Wert `HTTP_PROXY` bzw. `HTTP`. Für die Pseudo-Integration ist der `type`-Wert `MOCK`.
Die Lambda-Proxy-Integration unterstützt eine vereinfachte Integrationseinrichtung mit einer einzigen Lambda-Funktion. Die Einrichtung ist einfach und kann um das Backend erweitert werden, ohne die vorhandene Einrichtung zu beeinträchtigen. Aus diesen Gründen wird sie für die Integration mit einer Lambda-Funktion dringend empfohlen.
Mit der benutzerdefinierten Lambda-Integration können Sie dagegen konfigurierte Mapping-Vorlagen für verschiedene Integrationsendpunkte mit vergleichbaren Anfragen für die Ein- und Ausgabedatenformate wiederverwenden. Die Einrichtung ist aufwändiger und wird für erweiterte Anwendungsszenarios empfohlen.
Ebenso ist die Integrationseinrichtung für die HTTP-Proxy-Integration optimiert und kann um das Backend erweitert werden, ohne die bestehende Einrichtung zu beeinträchtigen. Die benutzerdefinierte HTTP-Integration ist aufwändiger einzurichten, kann jedoch in Form von konfigurierten Mapping-Vorlagen für andere Integrationsendpunkte wiederverwendet werden.
In der folgenden Liste sind die unterstützten Integrationstypen zusammengefasst:
+ `AWS`: Mit diesem Integrationstyp kann eine API AWS -Service-Aktionen festlegen. Bei der `AWS`-Integration müssen Sie sowohl die Integrationsanforderung als auch die Integrationsantwort konfigurieren und die erforderlichen Daten-Mappings von der Methodenanforderung zur Integrationsanforderung sowie von der Integrationsantwort zur Methodenantwort einrichten.
+ `AWS_PROXY`: Mit diesem Integrationstyp lassen sich API-Methoden in die Lambda-Funktionsaufrufaktion integrieren. Die Einrichtung ist flexibel, vielseitig und optimiert. Die Integration stützt sich auf direkte Interaktionen zwischen dem Client und der integrierten Lambda-Funktion.
Bei diesem, auch als Lambda-Proxy-Integration bezeichneten Integrationstyp, legen Sie weder die Integrationsanforderung noch die Integrationsantwort fest. API Gateway übergibt die eingehende Anfrage vom Client als Eingabe an die Backend-Lambda-Funktion. Die integrierte Lambda-Funktion übernimmt die [Eingabe in diesem Format](set-up-lambda-proxy-integrations.md#api-gateway-simple-proxy-for-lambda-input-format) und analysiert die Eingabe aus allen verfügbaren Quellen, darunter Anfrage-Header, URL-Pfadvariablen, Abfragezeichenfolge-Parameter und anwendbarer Inhalt. Die Funktion gibt das Ergebnis in diesem [Ausgabeformat](set-up-lambda-proxy-integrations.md#api-gateway-simple-proxy-for-lambda-output-format) zurück.
Dies ist der bevorzugte Integrationstyp zum Aufrufen einer Lambda-Funktion über API Gateway und gilt nicht für andere AWS Dienstaktionen, einschließlich Lambda-Aktionen außer der funktionsaufrufenden Aktion.
+ `HTTP`: Dieser Integrationstyp stellt eine API als HTTP-Endpunkte im Backend dar. Bei diesem, auch als benutzerdefinierte HTTP-Integration bezeichneten `HTTP`-Integrationstyp, müssen Sie sowohl die Integrationsanforderung als auch die Integrationsantwort konfigurieren. Sie müssen die erforderlichen Daten-Mappings von der Methodenanforderung zur Integrationsanforderung und von der Integrationsantwort zur Methodenantwort einrichten.
+ `HTTP_PROXY`: Die HTTP-Proxy-Integration ermöglicht einem Client den Zugriff auf HTTP-Endpunkte des Backend über eine optimierte Integrationseinrichtung mit einer einzigen API-Methode. Sie legen keine Integrationsanforderung oder Integrationsantwort fest. Amazon API Gateway übergibt die eingehende Anfrage des Clients an den HTTP-Endpunkt und übergibt die ausgehende Antwort vom HTTP-Endpunkt an den Client.
+ `MOCK`: Bei diesem Integrationstyp kann API Gateway eine Antwort zurückgeben, ohne die Anfrage weiter an das Backend zu senden. Dies ist für API-Test hilfreich, da Sie so die Integrationseinrichtung testen können, ohne dass Ihnen für die Nutzung des Backends Kosten entstehen, oder gemeinsam eine API entwickeln können.
Bei der gemeinsamen Entwicklung kann ein Team den Entwicklungsvorgang isolieren, indem es Simulationen von API-Komponenten anderer Teams über `MOCK`-Integrationen einrichtet. Dieser Integrationstyp wird auch verwendet, um CORS-Header zum Zulassen des CORS-Zugriffs durch die API-Methode zurückzugeben. Die API Gateway-Konsole integriert die `OPTIONS`-Methode zur Unterstützung von CORS sogar mit einer Mock-Integration. [Gateway-Antworten](api-gateway-gatewayResponse-definition.md#customize-gateway-responses) sind weitere Beispiele für Pseudo-Integrationen.
# Einrichten der Proxy-Integration mit einer Proxy-Ressource
Um eine Proxy-Integration in eine API Gateway-API mit einer [Proxy-Ressource](api-gateway-method-settings-method-request.md#api-gateway-proxy-resource) einzurichten, führen Sie die folgenden Aufgaben aus:
+ Erstellen Sie eine Proxyressource mit der gierigen Pfadvariable `{proxy+}`.
+ Legen Sie auf der Proxy-Ressource die Methode `ANY` fest.
+ Integrieren Sie die Ressource und die Methode mithilfe des HTTP- oder Lambda-Integrationstyps mit einem Backend.
**Anmerkung**
Gierige Pfadvariablen, `ANY`-Methoden und Proxy-Integrationstypen sind unabhängige Funktionen, auch wenn sie häufig gemeinsam verwendet werden. Sie können eine bestimmte HTTP-Methode auf einer gierigen Ressource konfigurieren oder Nicht-Proxy-Integrationstypen auf eine Proxy-Ressource anwenden.
API Gateway setzt bestimmte Beschränkungen und Limitierungen durch, wenn Methoden mit einer Lambda-Proxy-Integration oder einer HTTP-API-Integration behandelt werden. Details hierzu finden Sie unter [Wichtige Hinweise zu Amazon API Gateway](api-gateway-known-issues.md).
**Anmerkung**
Bei der Verwendung einer Proxy-Integration mit einem Pass-Through gibt API Gateway den Standard-`Content-Type:application/json`-Header zurück, wenn der Inhaltstyp eines Payloads nicht spezifiziert ist.
Eine Proxy-Ressource ist am leistungsstärksten, wenn sie mit der HTTP-Proxy-Integration oder der Lambda-Proxy-[Integration](https://docs.aws.amazon.com/apigateway/latest/api/API_Integration.html) in ein Backend integriert ist.
## HTTP-Proxy-Integration mit einer Proxy-Ressource
Die HTTP-Proxy-Integration, die in der REST-API des API Gateways mit `HTTP_PROXY` festgelegt ist, dient der Integration einer Methodenanfrage mit einem HTTP-Backend-Endpunkt. Bei diesem Integrationstyp übergibt API Gateway die gesamte Anfrage und Antwort einfach zwischen dem Frontend und dem Backend. Dabei gelten bestimmte [Einschränkungen und Begrenzungen](api-gateway-known-issues.md).
**Anmerkung**
Die HTTP-Proxy-Integration unterstützt mehrwertige Header und Abfragezeichenfolgen.
Beim Anwenden der HTTP-Proxy-Integration auf eine Proxy-Ressource können Sie die API so einrichten, dass entweder ein Teil der oder die gesamte Endpunkthierarchie des HTTP-Backends mit einer einzigen Integrationseinrichtung bereitgestellt wird. Angenommen, das Backend der Website ist in mehrere Strukturknoten-Branches eines Stammknotens (`/site`) aufgeteilt: `/site/a0/a1/.../aN`, `/site/b0/b1/.../bM` usw. Wenn Sie die Methode `ANY` für eine Proxy-Ressource von `/api/{proxy+}` mit den Backend-Endpunkten mit den URL-Pfaden von `/site/{proxy}` integrieren, kann eine einzelne Integrationsanforderung alle HTTP-Vorgänge (GET, POST usw.) für beliebige von `[a0, a1, ..., aN, b0, b1, ...bM, ...]` unterstützen. Wenn Sie eine Proxy-Integration stattdessen auf eine bestimmte HTTP-Methode anwenden, z. B. `GET`, funktioniert die resultierende Integrationsanforderung mit den angegebenen Vorgängen (d. h. `GET`) auf jedem dieser Backend-Knoten.
## Lambda-Proxy-Integration mit einer Proxy-Ressource
Die Lambda-Proxy-Integration, in der API Gateway-REST-API mit `AWS_PROXY` festgelegt ist, dient der Integration einer Methodenanfrage mit einer Lambda-Funktion im Backend. Bei diesem Integrationstyp wendet API Gateway eine Standard-Mapping-Vorlage, um die gesamte Anfrage an die Lambda-Funktion zu senden, und wandelt die Ausgabe der Lambda-Funktion in HTTP-API-Antworten um.
Ebenso können Sie die Lambda-Proxy-Integration auf eine Proxy-Ressource von `/api/{proxy+}` anwenden, um eine einzelne Integration einzurichten, sodass eine Backend-Lambda-Funktion individuell auf Änderungen an einer der API-Ressourcen unter `/api` reagiert.
# API-Integrationsanfrage über die API Gateway-Konsole einrichten
Die Einrichtung einer API-Methode definiert die Methode und beschreibt ihr Verhalten. Um eine Methode einzurichten, müssen Sie Folgendes angeben: eine Ressource, einschließlich des Roots (`GET`/`POST`), auf der die Methode bereitgestellt wird, eine HTTP-Methode (GET, POST usw.) und wie diese in das Ziel-Backend integriert wird. Die Methodenanforderung und -antwort geben die Regeln für den Austausch mit der aufrufenden App vor. Sie legen fest, welche Parameter die API empfangen kann und wie die Antwort aussieht.
In den folgenden Verfahren wird beschrieben, wie die API-Gateway-Konsole zum Erstellen einer Integrationsanforderung verwendet wird.
**Topics**
+ [Einrichten einer Lambda-Integration](#how-to-method-settings-console-lambda)
+ [Einrichten von HTTP-Integrationen](#how-to-method-settings-console-http)
+ [Richten Sie eine AWS Serviceintegration ein](#how-to-method-settings-console-aws)
+ [Einrichten von Mock-Integrationen](#how-to-method-settings-console-mock)
## Einrichten einer Lambda-Integration
Verwenden Sie eine Lambda-Funktionsintegration, um Ihre API in eine Lambda-Funktion zu integrieren. Auf API-Ebene ist dies ein `AWS`-Integrationstyp, wenn Sie eine Nicht-Proxy-Integration erstellen, oder ein `AWS_PROXY`-Integrationstyp, wenn Sie eine Proxy-Integration erstellen.
**Einrichten einer Integrationsmethode**
1. Wählen Sie im Bereich **Resources** (Ressourcen) die Option **Create method** (Methode erstellen) aus.
1. Wählen Sie als **Method type** (Methodentyp) eine HTTP-Methode aus.
1. Für **Integrationstyp** wählen Sie **Lambda-Funktion** aus.
1. Um eine Lambda-Proxyintegration zu verwenden, aktivieren Sie **Lambda proxy integration** (Lambda-Proxyintegration). Weitere Informationen zum Erstellen von Lambda-Proxy-Integrationen finden Sie unter [API Gateway Lambda-Proxy-Integration kennenlernen](set-up-lambda-proxy-integrations.md#api-gateway-create-api-as-simple-proxy).
1. Geben Sie für **Lambda function** (Lambda-Funktion) den Namen der Funktion ein.
Wenn Sie eine Lambda-Funktion in einer anderen Region als Ihrer API verwenden, wählen Sie die Region aus dem Dropdownmenü aus und geben Sie den Namen der Lambda-Funktion ein. Wenn Sie eine kontoübergreifende Lambda-Funktion verwenden, geben Sie die Funktion ARN ein.
1. Wenn Sie die Standardzeitüberschreitung von 29 Sekunden verwenden möchten, lassen Sie das Kontrollkästchen **Default timeout** (Standardzeitüberschreitung) aktiviert. Wenn Sie einen benutzerdefinierten Zeitüberschreitungswert festlegen möchten, wählen Sie **Default timeout** (Standardzeitüberschreitung) aus und geben Sie einen Zeitüberschreitungswert zwischen `50` und `29000` Millisekunden ein.
1. (Optional) Sie können die Einstellungen für die Methodenanforderung mithilfe der folgenden Dropdownmenüs konfigurieren. Wählen Sie **Einstellungen für Methodenanfragen** und konfigurieren Sie Ihre Methodenanforderung. Weitere Informationen finden Sie in Schritt 2 von [Bearbeiten einer API-Gateway-Methodenanforderung in der API-Gateway-Konsole](how-to-set-up-method-using-console.md#how-to-method-settings-callers-console).
Sie können Ihre Einstellungen für Methodenanfragen auch konfigurieren, nachdem Sie Ihre Methode erstellt haben.
1. Wählen Sie **Methode erstellen** aus.
## Einrichten von HTTP-Integrationen
Verwenden Sie eine HTTP-Integration, um Ihre API in einen HTTP-Endpunkt zu integrieren. Auf der API-Ebene ist dies der `HTTP` Integrationstyp.
**Einrichten von HTTP-Integrationen**
1. Wählen Sie im Bereich **Resources** (Ressourcen) die Option **Create method** (Methode erstellen) aus.
1. Wählen Sie als **Method type** (Methodentyp) eine HTTP-Methode aus.
1. Wählen Sie unter **Integrationstyp** die Option **HTTP** aus.
1. Um eine HTTP-Proxyintegration zu verwenden, aktivieren Sie **HTTP proxy integration** (HTTP-Proxyintegration). Weitere Informationen zu HTTP-Proxyintegrationen finden Sie unter [HTTP-Proxy-Integrationen in API Gateway einrichten](setup-http-integrations.md#api-gateway-set-up-http-proxy-integration-on-proxy-resource).
1. Wählen Sie als **HTTP method** die HTTP-Methode aus, die am ehesten der Methode im HTTP-Backend entspricht.
1. Geben Sie als **Endpoint URL** (Endpunkt-URL) die URL des HTTP-Backends ein, das diese Methode verwenden soll.
1. Wählen Sie für **Content handling** (Inhaltsbehandlung) ein Verhalten bei der Inhaltsbehandlung aus.
1. Wenn Sie die Standardzeitüberschreitung von 29 Sekunden verwenden möchten, lassen Sie das Kontrollkästchen **Default timeout** (Standardzeitüberschreitung) aktiviert. Wenn Sie einen benutzerdefinierten Zeitüberschreitungswert festlegen möchten, wählen Sie **Default timeout** (Standardzeitüberschreitung) aus und geben Sie einen Zeitüberschreitungswert zwischen `50` und `29000` Millisekunden ein.
1. (Optional) Sie können die Einstellungen für die Methodenanforderung mithilfe der folgenden Dropdownmenüs konfigurieren. Wählen Sie **Einstellungen für Methodenanfragen** und konfigurieren Sie Ihre Methodenanforderung. Weitere Informationen finden Sie in Schritt 2 von [Bearbeiten einer API-Gateway-Methodenanforderung in der API-Gateway-Konsole](how-to-set-up-method-using-console.md#how-to-method-settings-callers-console).
Sie können Ihre Einstellungen für Methodenanfragen auch konfigurieren, nachdem Sie Ihre Methode erstellt haben.
1. Wählen Sie **Methode erstellen** aus.
## Richten Sie eine AWS Serviceintegration ein
Verwenden Sie eine AWS Serviceintegration, um Ihre API direkt in einen AWS Dienst zu integrieren. Auf der API-Ebene ist dies der `AWS` Integrationstyp.
Gehen Sie zum Einrichten einer API Gateway wie folgt vor:
+ Erstellen Sie eine neue Lambda-Funktion.
+ Legen Sie eine Ressourcenberechtigung für die Lambda-Funktion fest.
+ Führen Sie alle anderen Lambda-Serviceaktionen aus.
Sie müssen den **AWS -Service wählen.**
**Um eine AWS Serviceintegration einzurichten**
1. Wählen Sie im Bereich **Resources** (Ressourcen) die Option **Create method** (Methode erstellen) aus.
1. Wählen Sie als **Method type** (Methodentyp) eine HTTP-Methode aus.
1. Wählen Sie unter **Integrationstyp** die Option **AWS -Service** aus.
1. Wählen Sie unter **AWS Region** die AWS Region aus, die diese Methode zum Aufrufen der Aktion verwenden soll.
1. Wählen Sie für **AWS Service** den AWS Dienst aus, den Sie mit dieser Methode aufrufen möchten.
1. Geben Sie für **AWS Subdomain** die Subdomain ein, die AWS vom Service verwendet wird. Normalerweise bleibt dieses Feld leer. Einige AWS -Services können Subdomänen als Teil des Hosts unterstützen. Weitere Informationen über die Verfügbarkeit und gegebenenfalls Details finden Sie in der Service-Dokumentation.
1. Wählen Sie als **HTTP method** die der Aktion entsprechende HTTP-Methode aus. **Informationen zum HTTP-Methodentyp finden Sie in der API-Referenzdokumentation für den AWS Dienst, den Sie für den Dienst ausgewählt haben.AWS **
1. Wählen Sie unter **Action type** (Aktionstyp) entweder **Use action name** (Aktionsnamen verwenden) aus, um eine API-Aktion zu verwenden, oder **Use path override** (Pfadüberschreibung verwenden), um einen benutzerdefinierten Ressourcenpfad zu verwenden. Verfügbare Aktionen und benutzerdefinierte Ressourcenpfade finden Sie in der API-Referenzdokumentation für den AWS Dienst, den Sie für den **AWS Dienst** ausgewählt haben.
1. Geben Sie entweder einen **Action name** (Aktionsnamen) oder eine **Path override** (Pfadüberschreibung) ein.
1. Geben Sie unter **Execution Role** (Ausführungsrolle) den ARN der IAM-Rolle ein, die die Methode zum Aufrufen der Aktion verwendet.
Zum Erstellen einer IAM-Rolle können Sie die Anweisungen in [Schritt 1: Erstellen Sie die AWS Service-Proxy-Ausführungsrolle](getting-started-aws-proxy.md#getting-started-aws-proxy-add-roles) anpassen. Geben Sie eine Zugriffsrichtlinie mit der gewünschten Anzahl von Aktions- und Ressourcenanweisungen an. Weitere Informationen finden Sie unter [Funktionsweise von Amazon API Gateway mit IAM](security_iam_service-with-iam.md).
Die Syntax der Aktions- und Ressourcenanweisungen finden Sie in der Dokumentation des AWS Dienstes, den Sie für den **AWS Dienst** ausgewählt haben.
Für die Vertrauensbeziehung der IAM-Rolle geben Sie Folgendes an, wodurch API Gateway in der Lage ist, im Namen Ihres AWS -Kontos aktiv zu werden:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "apigateway.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Wenn Sie die Standardzeitüberschreitung von 29 Sekunden verwenden möchten, lassen Sie das Kontrollkästchen **Default timeout** (Standardzeitüberschreitung) aktiviert. Wenn Sie einen benutzerdefinierten Zeitüberschreitungswert festlegen möchten, wählen Sie **Default timeout** (Standardzeitüberschreitung) aus und geben Sie einen Zeitüberschreitungswert zwischen `50` und `29000` Millisekunden ein.
1. (Optional) Sie können die Einstellungen für die Methodenanforderung mithilfe der folgenden Dropdownmenüs konfigurieren. Wählen Sie **Einstellungen für Methodenanfragen** und konfigurieren Sie Ihre Methodenanforderung. Weitere Informationen finden Sie in Schritt 2 von [Bearbeiten einer API-Gateway-Methodenanforderung in der API-Gateway-Konsole](how-to-set-up-method-using-console.md#how-to-method-settings-callers-console).
Sie können Ihre Einstellungen für Methodenanfragen auch konfigurieren, nachdem Sie Ihre Methode erstellt haben.
1. Wählen Sie **Methode erstellen** aus.
## Einrichten von Mock-Integrationen
Wählen Sie **Mock** aus, wenn API Gateway als Backend fungieren soll, um statische Antworten zurückzugeben. Auf der API-Ebene ist dies der `MOCK` Integrationstyp. Normalerweise können Sie die `MOCK` Integration verwenden, wenn Ihre API noch nicht finalisiert ist, Sie aber API-Antworten erzeugen möchten, um abhängigen Teams Tests zu ermöglichen. Für die `OPTION`-Methode legt API Gateway die `MOCK`-Integration als Standard fest, um CORS-fähige Header für die angewandte API-Ressource zurückzugeben.
**Einrichten einer Integrationsmethode**
1. Wählen Sie im Bereich **Resources** (Ressourcen) die Option **Create method** (Methode erstellen) aus.
1. Wählen Sie als **Method type** (Methodentyp) eine HTTP-Methode aus.
1. Wählen Sie unter **Integrationstyp** die Option **Mock** aus.
1. (Optional) Sie können die Einstellungen für die Methodenanforderung mithilfe der folgenden Dropdownmenüs konfigurieren. Wählen Sie **Einstellungen für Methodenanfragen** und konfigurieren Sie Ihre Methodenanforderung. Weitere Informationen finden Sie in Schritt 2 von [Bearbeiten einer API-Gateway-Methodenanforderung in der API-Gateway-Konsole](how-to-set-up-method-using-console.md#how-to-method-settings-callers-console).
Sie können Ihre Einstellungen für Methodenanfragen auch konfigurieren, nachdem Sie Ihre Methode erstellt haben.
1. Wählen Sie **Methode erstellen** aus.