

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.

# Tutorial: Eine Suchanwendung mit Amazon OpenSearch Service erstellen
<a name="search-example"></a>

Eine gängige Methode, um eine Suchanwendung mit Amazon OpenSearch Service zu erstellen, besteht darin, Webformulare zu verwenden, um Benutzeranfragen an einen Server zu senden. Anschließend können Sie den Server autorisieren, den OpenSearch APIs direkt aufzurufen und den Server Anfragen an den OpenSearch Service senden zu lassen. Wenn Sie clientseitigen Code schreiben möchten, der nicht auf einen Server angewiesen ist, sollten Sie jedoch die Sicherheits- und Leistungsrisiken ausgleichen. OpenSearch APIs Es wird davon abgeraten, unsignierten, öffentlichen Zugriff auf den zuzulassen. Die Benutzer können auf ungesicherte Endpunkte zugreifen oder die Cluster-Leistung durch übermäßig umfangreiche Abfragen (oder zu viele Abfragen) beeinflussen.

In diesem Kapitel wird eine Lösung vorgestellt: Verwenden Sie Amazon API Gateway, um Benutzer auf eine Teilmenge von zu beschränken OpenSearch APIs und Anfragen von API Gateway AWS Lambda to OpenSearch Service zu signieren.

![\[Flussdiagramm der Suchanwendung.\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/search-application-diagram.png)


**Anmerkung**  
Es gilt die standardmäßige API-Gateway- und Lamda-Preisgestaltung, aber innerhalb der begrenzten Nutzung dieses Tutorials sollten die Kosten vernachlässigbar sein.

## Voraussetzungen
<a name="search-example-prereq"></a>

Voraussetzung für dieses Tutorial ist eine OpenSearch Service-Domain. Wenn Sie noch keine haben, folgen Sie den Schritten unter [Erstellen einer OpenSearch Dienstdomäne](gsgcreate-domain.md), um eine zu erstellen.

## Schritt 1: Indizieren von Beispieldaten
<a name="search-example-index"></a>

Laden Sie [sample-movies.zip](samples/sample-movies.zip) herunter, dekomprimieren Sie sie und verwenden Sie die [\$1bulk](https://opensearch.org/docs/latest/api-reference/document-apis/bulk/)-API-Operation zum Hinzufügen der 5 000 Dokumente in den `movies`-Index:

```
POST https://search-my-domain.us-west-1.es.amazonaws.com/_bulk
{ "index": { "_index": "movies", "_id": "tt1979320" } }
{"directors":["Ron Howard"],"release_date":"2013-09-02T00:00:00Z","rating":8.3,"genres":["Action","Biography","Drama","Sport"],"image_url":"http://ia.media-imdb.com/images/M/MV5BMTQyMDE0MTY0OV5BMl5BanBnXkFtZTcwMjI2OTI0OQ@@._V1_SX400_.jpg","plot":"A re-creation of the merciless 1970s rivalry between Formula One rivals James Hunt and Niki Lauda.","title":"Rush","rank":2,"running_time_secs":7380,"actors":["Daniel Brühl","Chris Hemsworth","Olivia Wilde"],"year":2013,"id":"tt1979320","type":"add"}
{ "index": { "_index": "movies", "_id": "tt1951264" } }
{"directors":["Francis Lawrence"],"release_date":"2013-11-11T00:00:00Z","genres":["Action","Adventure","Sci-Fi","Thriller"],"image_url":"http://ia.media-imdb.com/images/M/MV5BMTAyMjQ3OTAxMzNeQTJeQWpwZ15BbWU4MDU0NzA1MzAx._V1_SX400_.jpg","plot":"Katniss Everdeen and Peeta Mellark become targets of the Capitol after their victory in the 74th Hunger Games sparks a rebellion in the Districts of Panem.","title":"The Hunger Games: Catching Fire","rank":4,"running_time_secs":8760,"actors":["Jennifer Lawrence","Josh Hutcherson","Liam Hemsworth"],"year":2013,"id":"tt1951264","type":"add"}
...
```

Beachten Sie, dass es sich bei dem obigen Befehl um einen Beispielbefehl mit einer kleinen Teilmenge der verfügbaren Daten handelt. Um den `_bulk` Vorgang auszuführen, müssen Sie den gesamten Inhalt der `sample-movies` Datei kopieren und einfügen. Weitere Anweisungen finden Sie unter[Option 2: Hochladen mehrerer Dokumente](gsgupload-data.md#gsgmultiple-document).

Sie können auch den folgenden curl-Befehl verwenden, um dasselbe Ergebnis zu erzielen: 

```
curl -XPOST -u 'master-user:master-user-password' 'domain-endpoint/_bulk' --data-binary @bulk_movies.json -H 'Content-Type: application/json'
```

## Schritt 2: Lambda-Funktion erstellen und bereitstellen
<a name="search-example-lambda"></a>

Bevor Sie Ihre API in API Gateway erstellen, erstellen Sie die Lambda-Funktion, an die Anfragen weitergeleitet werden.

### So erstellen Sie die Lambda-Funktion:
<a name="sample-lamdba-python"></a>

In dieser Lösung leitet API Gateway Anfragen an eine Lambda-Funktion weiter, die OpenSearch Service abfragt und Ergebnisse zurückgibt. Da diese Beispielfunktion externe Bibliotheken verwendet, müssen Sie ein Bereitstellungspaket erstellen und es auf Lambda hochladen.

**Erstellen des Bereitstellungspakets**

1. Öffnen Sie eine Eingabeaufforderung und erstellen Sie ein `my-opensearch-function`-Projektverzeichnis. Zum Beispiel unter macOS:

   ```
   mkdir my-opensearch-function
   ```

1. Navigieren Sie zum `my-sourcecode-function`-Projektverzeichnis.

   ```
   cd my-opensearch-function
   ```

1. Kopieren Sie den Inhalt des folgenden Python-Beispielcodes und speichern Sie ihn in einer neuen Datei mit dem Namen`opensearch-lambda.py`. Fügen Sie der Datei Ihre Region und Ihren Host-Endpunkt hinzu.

   ```
   import boto3
   import json
   import requests
   from requests_aws4auth import AWS4Auth
   
   region = '' # For example, us-west-1
   service = 'es'
   credentials = boto3.Session().get_credentials()
   awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token)
   
   host = '' # The OpenSearch domain endpoint with https:// and without a trailing slash
   index = 'movies'
   url = host + '/' + index + '/_search'
   
   # Lambda execution starts here
   def lambda_handler(event, context):
   
       # Put the user query into the query DSL for more accurate search results.
       # Note that certain fields are boosted (^).
       query = {
           "size": 25,
           "query": {
               "multi_match": {
                   "query": event['queryStringParameters']['q'],
                   "fields": ["title^4", "plot^2", "actors", "directors"]
               }
           }
       }
   
       # Elasticsearch 6.x requires an explicit Content-Type header
       headers = { "Content-Type": "application/json" }
   
       # Make the signed HTTP request
       r = requests.get(url, auth=awsauth, headers=headers, data=json.dumps(query))
   
       # Create the response and add some extra content to support CORS
       response = {
           "statusCode": 200,
           "headers": {
               "Access-Control-Allow-Origin": '*'
           },
           "isBase64Encoded": False
       }
   
       # Add the search results to the response
       response['body'] = r.text
       return response
   ```

1. Installieren Sie die externen Bibliotheken in einem neuen `package` Verzeichnis.

   ```
   pip3 install --target ./package boto3
   pip3 install --target ./package requests
   pip3 install --target ./package requests_aws4auth
   ```

1. Erstellen Sie ein Bereitstellungspaket, an dessen Stamm die installierte Bibliothek angefügt ist. Der folgende Befehl generiert eine `my-deployment-package.zip` Datei in Ihrem Projektverzeichnis. 

   ```
   cd package
   zip -r ../my-deployment-package.zip .
   ```

1. Fügen Sie die `opensearch-lambda.py`-Datei dem Stamm der ZIP-Datei hinzu.

   ```
   cd ..
   zip my-deployment-package.zip opensearch-lambda.py
   ```

Weitere Informationen zum Erstellen von Lambda-Funktionen und Bereitstellungspaketen finden Sie unter [Bereitstellen von Python-Lambda-Funktionen mit ZIP-Dateiarchiven](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python-how-to-create-deployment-package.html) im*AWS Lambda -Entwicklerhandbuch* und [Erstellen des Lambda-Bereitstellungspakets](integrations-s3-lambda.md#integrations-s3-lambda-deployment-package) in diesem Leitfaden.

So erstellen Sie Ihre Funktion mit der Lambda-Konsole

1. Navigieren Sie zu [https://console.aws.amazon.com/lambda/Hause](https://console.aws.amazon.com/lambda/home ) zur Lambda-Konsole. Wählen Sie im linken Navigationsbereich **Funktionen** aus.

1. Wählen Sie **Funktion erstellen** aus.

1. Konfigurieren Sie die folgenden Felder:
   + Funktionsname: opensearch-function
   + Laufzeit: Python 3.9
   + Architektur: x86\$164

   Behalten Sie alle anderen Standardoptionen bei und wählen Sie **Funktion erstellen**. 

1. Wählen Sie auf der Seite mit der Funktionsübersicht im Abschnitt „**Codequelle**“ die Dropdownliste „**Von hochladen**“ und wählen Sie „**.zip-Datei**“ aus. **Suchen Sie die `my-deployment-package.zip` Datei, die Sie erstellt haben, und wählen Sie Speichern aus.**

1. Der *Handler* ist die Methode in Ihrem Funktions-Code, die Ereignisse verarbeitet. Wählen Sie unter **Runtime-Einstellungen** die Option **Bearbeiten** und ändern Sie den Namen des Handlers entsprechend dem Namen der Datei in Ihrem Bereitstellungspaket, in der sich die Lambda-Funktion befindet. Da Ihre Datei benannt ist`opensearch-lambda.py`, benennen Sie den Handler in um`opensearch-lambda.lambda_handler`. Weitere Informationen finden Sie unter [Lambda-Funktions-Handler in Python](https://docs.aws.amazon.com/lambda/latest/dg/python-handler.html).

## Schritt 3: Erstellen Sie die API in API Gateway
<a name="search-example-api"></a>

Mit API Gateway können Sie eine eingeschränktere API erstellen und den Prozess der Interaktion mit der OpenSearch `_search` API vereinfachen. Mit API Gateway können Sie Sicherheitsfunktionen wie die Amazon-Cognito-Authentifizierung und die Anforderungsdrosselung aktivieren. Führen Sie die folgenden Schritte aus, um eine API zu erstellen und bereitzustellen:

### Erstellen und Konfigurieren Sie die API
<a name="create-api"></a>

So erstellen Sie Ihre API über die API-Gateway-Konsole

1. Navigieren Sie zu [https://console.aws.amazon.com/apigateway/Hause](https://console.aws.amazon.com/apigateway/home ) zur API Gateway Gateway-Konsole. Wählen Sie im linken Navigationsbereich **APIs**.

1. Suchen Sie die **REST-API** (nicht privat) und wählen Sie **Build** aus.

1. Suchen Sie auf der folgenden Seite nach dem Abschnitt **Neue API erstellen** und stellen Sie sicher, dass **Neue API** ausgewählt ist.

1. Konfigurieren Sie die folgenden Felder:
   + API-Name: **opensearch-api**
   + Beschreibung: **Öffentliche API für die Suche nach einer Amazon OpenSearch Service-Domain**
   + Endpunkttyp: **Regional**

1. Wählen Sie **Create API** (API erstellen) aus. 

1. Wählen Sie **Aktionen** und **Methode erstellen** aus.

1. Wählen Sie im Dropdown-Menü **GET** aus und klicken Sie zur Bestätigung auf das Häkchen.

1. Konfigurieren Sie die folgenden Einstellungen und wählen Sie dann **Speichern**:


| Einstellung | Wert | 
| --- | --- | 
| Integrationstyp | Lambda-Funktion | 
| Lambda-Proxy-Integration verwenden | Ja | 
| Lambda-Region | us-west-1 | 
| Lambda-Funktion | opensearch-lambda | 
| Standardzeitüberschreitung verwenden | Ja | 

### Konfigurieren Sie die Methodenanforderung
<a name="method-request"></a>

Klicken Sie auf **Methodenanforderung** und konfigurieren Sie die folgenden Einstellungen:


| Einstellung | Wert | 
| --- | --- | 
| Autorisierung | NONE | 
| Anforderungs-Validator |  Abfragezeichenfolgeparameter und Header validieren   | 
| API-Schlüssel erforderlich | false | 

Wählen Sie unter **URL-Abfragezeichenfolge-Parameter** die Option **Abfragezeichenfolge hinzufügen** aus und konfigurieren Sie den folgenden Parameter:


| Einstellung | Wert | 
| --- | --- | 
| Name | q | 
| Erforderlich |  Ja  | 

### Stellen Sie die API bereit und Konfigurieren Sie eine Stufe
<a name="deploy-api"></a>

 Mit der API Gateway-Konsole können Sie eine API bereitstellen, indem Sie eine Bereitstellung erstellen und sie mit einer neuen oder bestehenden Stufe verknüpfen. 

1. Wählen Sie **Aktionen** und **Bereitstellen der API** aus.

1. Für **Bereitstellungsstufe**, wählen Sie **Neue Stufe** und nennen Sie die Stufe `opensearch-api-test`.

1. Wählen Sie **Bereitstellen**.

1. Konfigurieren Sie die folgenden Einstellungen im Stufen-Editor und wählen Sie dann **Änderungen speichern**:


| Einstellung | Wert | 
| --- | --- | 
| Drosselung aktivieren | Ja | 
| Rate (Tarif) |  1000  | 
| Burst | 500 | 

Diese Einstellungen konfigurieren eine API, die nur über eine Methode verfügt: eine `GET`-Anforderung an den Endpunkt-Root (`https://some-id.execute-api.us-west-1.amazonaws.com/search-es-api-test`). Die Anforderung erfordert einen einzelnen Parameter (`q`), die Abfragezeichenfolge, nach der gesucht werden soll. Beim Aufruf übergibt die Methode die Anforderung an Lambda, die die `opensearch-lambda`-Funktion ausführt. Weitere Informationen finden Sie unter [Erstellen einer API in Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-create-api.html) und [Bereitstellen einer REST API in Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-deploy-api.html).

## Schritt 4: (Optional) Ändern der Domain-Zugriffsrichtlinie
<a name="search-example-perms"></a>

Ihre OpenSearch Service-Domain muss es der Lambda-Funktion ermöglichen, `GET` Anfragen an den `movies` Index zu stellen. Wenn Ihre Domain eine offene Zugriffsrichtlinie hat, bei der eine abgestufte Zugriffssteuerung aktiviert ist, können Sie sie so wie sie ist belassen: 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "*"
      },
      "Action": "es:*",
      "Resource": "arn:aws:es:us-west-1:123456789012:domain/domain-name/*"
    }
  ]
}
```

------

Alternativ können Sie Ihre Domain-Zugriffsrichtlinie detaillierter gestalten. Beispielsweise gewährt die folgende Richtlinie `opensearch-lambda-role` (erstellt durch Lambda) Schreibzugriff auf den `movies`-Index. Um den genauen Namen der Rolle zu erhalten, die Lambda automatisch erstellt, gehen Sie zur AWS Identity and Access Management (IAM-) Konsole, wählen Sie **Rollen** und suchen Sie nach „Lambda“.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::123456789012:role/service-role/opensearch-lambda-role-1abcdefg"
      },
      "Action": "es:ESHttpGet",
      "Resource": "arn:aws:es:us-west-1:123456789012:domain/domain-name/movies/_search"
    }
  ]
}
```

------

**Wichtig**  
Wenn Sie eine detaillierte Zugriffskontrolle für die Domain aktiviert haben, müssen Sie [die Rolle auch einem Benutzer in OpenSearch Dashboards zuordnen, andernfalls werden Berechtigungsfehler angezeigt](fgac.md#fgac-mapping).

### Berechtigungen für Lambda-Ausführungsrollen konfigurieren
<a name="search-example-lambda-iam"></a>

Neben der Konfiguration der Domänenzugriffsrichtlinie müssen Sie auch sicherstellen, dass die Lambda-Ausführungsrolle über die erforderlichen IAM-Berechtigungen für den Zugriff auf Ihre OpenSearch Service-Domain verfügt. Für die Lambda-Funktion sind je nachdem, ob Sie eine verwaltete Domain oder eine OpenSearch Service Serverless-Sammlung verwenden, bestimmte Berechtigungen erforderlich.

**Für verwaltete OpenSearch Servicedomänen:**

Fügen Sie Ihrer Lambda-Ausführungsrolle die folgende IAM-Richtlinie hinzu, damit sie Anfragen an Ihre OpenSearch Service-Domain stellen kann:

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "es:ESHttpGet",
        "es:ESHttpPost"
      ],
      "Resource": "arn:aws:es:us-west-1:123456789012:domain/domain-name/*"
    }
  ]
}
```

------

**Für OpenSearch Service Serverless-Sammlungen:**

Wenn Sie OpenSearch Service Serverless verwenden, fügen Sie Ihrer Lambda-Ausführungsrolle die folgende IAM-Richtlinie hinzu:

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "aoss:*",
      "Resource": "arn:aws:aoss:us-west-1:123456789012:collection/collection-id"
    }
  ]
}
```

------

So hängen Sie diese Richtlinien an Ihre Lambda-Ausführungsrolle an:

1. Navigieren Sie zur IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)

1. Wählen Sie **Rollen** und suchen Sie nach Ihrer Lambda-Ausführungsrolle (normalerweise benannt`opensearch-lambda-role-xxxxxxxx`).

1. Wählen Sie **Berechtigungen hinzufügen** und dann **Inline-Richtlinie erstellen** aus.

1. Wählen Sie die Registerkarte **JSON** und fügen Sie die entsprechende Richtlinie von oben ein. Ersetzen Sie dabei die Platzhalterwerte durch Ihre tatsächliche Ressource ARNs.

1. Wählen Sie **Richtlinie überprüfen**, geben Sie einen Namen wie `OpenSearchAccess` ein und wählen Sie **Richtlinie erstellen** aus.

**Anmerkung**  
Ohne diese IAM-Berechtigungen erhält Ihre Lambda-Funktion beim Versuch, Ihre OpenSearch Service-Domain abzufragen, die Fehlermeldung „Zugriff verweigert“, auch wenn die Domänenzugriffsrichtlinie die Anfragen zulässt.

Weitere Informationen zu Zugriffsrichtlinien finden Sie unter [Konfigurieren von Zugriffsrichtlinien](createupdatedomains.md#createdomain-configure-access-policies).

## Zuordnen der Lambda-Rolle (bei Verwendung einer differenzierten Zugriffskontrolle)
<a name="search-example-perms-fgac"></a>

Die differenzierte Zugriffskontrolle führt einen zusätzlichen Schritt ein, bevor Sie die Anwendung testen können. Auch wenn Sie die HTTP-Standardauthentifizierung für alle anderen Zwecke verwenden, müssen Sie die Lambda-Rolle einem Benutzer zuordnen, andernfalls werden Berechtigungsfehler angezeigt.

1. Navigieren Sie zur OpenSearch Dashboard-URL für die Domain.

1. Wählen Sie im Hauptmenü **Sicherheit**, **Rollen** und dann den Link zu der Rolle aus`all_access`, der Sie die Lambda-Rolle zuordnen müssen.

1. Wählen Sie **Zugeordnete Benutzer**, **Mapping verwalten**. 

1. Fügen Sie unter **Backend roles** (Backend-Rollen) den Amazon-Ressourcennamen (ARN) der Lambda-Rolle hinzu. Der ARN sollte die Form von haben`arn:aws:iam::123456789123:role/service-role/opensearch-lambda-role-1abcdefg`.

1. Wählen Sie **Zuordnen** und bestätigen Sie, dass der Benutzer oder die Rolle unter **Zugeordnete Benutzer** angezeigt wird.

## Schritt 5: Testen der Webanwendung
<a name="search-example-webpage"></a>

**So testen Sie die Webanwendung**

1. Laden Sie [sample-site.zip](samples/sample-site.zip) herunter, dekomprimieren Sie sie und öffnen Sie `scripts/search.js` in Ihrem bevorzugten Texteditor.

1. Aktualisieren Sie die `apigatewayendpoint` Variable so, dass sie auf Ihren API-Gateway-Endpunkt zeigt, und fügen Sie am Ende des angegebenen Pfads einen Backslash hinzu. Sie können den Endpunkt schnell im API Gateway finden, indem Sie **Phasen** und den Namen der API auswählen. Die `apigatewayendpoint` Variable sollte die Form von/haben. `https://some-id.execute-api.us-west-1.amazonaws.com/opensearch-api-test`

1. Öffnen Sie `index.html` und versuchen Sie, nach *thor*, *house* und einigen anderen Begriffen zu suchen.  
![\[Ein Beispiel für eine Suche nach thor.\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/images/search-ui.png)

### Beheben von CORS-Fehlern
<a name="search-example-cors"></a>

Auch wenn die Lambda-Funktion Inhalte in die Antwort einschließt, um CORS zu unterstützen, kann der folgende Fehler auftreten: 

```
Access to XMLHttpRequest at '<api-gateway-endpoint>' from origin 'null' has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present in the requested resource.
```

Versuchen Sie in diesem Fall Folgendes:

1. [Aktivieren Sie CORS](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-cors-console.html) in der GET-Ressource. Unter **Advanced** legen Sie **Access-Control-Allow-Credentials** auf `'true'` fest.

1. Stellen Sie Ihre API erneut in API Gateway (**Aktionen**,**API bereitstellen**) bereit.

1. Löschen Sie Ihren Lambda-Funktionsauslöser und fügen Sie ihn erneut hinzu. Fügen Sie sie hinzu, fügen Sie sie erneut hinzu, wählen **Sie Auslöser hinzufügen** und erstellen Sie den HTTP-Endpunkt, der Ihre Funktion aufruft. Der Auslöser muss die folgende Konfiguration haben:    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/opensearch-service/latest/developerguide/search-example.html)

## Nächste Schritte
<a name="search-example-next"></a>

Dieses Kapitel ist nur ein Ausgangspunkt zur Demonstration eines Konzepts. Sie sollten die folgenden Änderungen in Erwägung ziehen:
+ Fügen Sie der OpenSearch Service-Domain Ihre eigenen Daten hinzu.
+ Fügen Sie Methoden Ihrer API hinzu.
+ Ändern Sie in der Lambda-Funktion die Suchanfrage oder steigern Sie andere Felder.
+ Gestalten Sie die Ergebnisse unterschiedlich oder ändern Sie `search.js`, um dem Benutzer verschiedene Felder anzuzeigen.