

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.

# ML-Inferenz-Pipelines in Amazon OpenSearch Serverlos

Das `ml_inference` Prozessor in Amazon OpenSearch Serverless ist ein Allzweckprozessor, der ein konfiguriertes Modell für maschinelles Lernen aufruft und die Ein- und Ausgaben des Modells Dokumenten- oder Abfragefeldern zuordnet. Sie steuern das Mapping mit dem `input_map` und `output_map` Parameter, die die Dokument- oder Abfragefelder angeben, die die Modelleingabe liefern, und die Felder, die die Modellausgabe empfangen.

Im Gegensatz zu speziell entwickelten Prozessoren für maschinelles Lernen wie `text_embedding`, `text_image_embedding`, und `sparse_encoding`, die jeweils einen einzelnen Modelltyp unterstützen, die `ml_inference` Prozessor funktioniert mit jedem konfigurierten Modell. Er kann auch sowohl in Ingest-Pipelines als auch in Such-Pipelines ausgeführt werden, sodass Sie während der Indizierung, vor der Ausführung einer Abfrage oder nach der Rückgabe von Ergebnissen Modellinferenz anwenden können. Verwenden Sie den `ml_inference` Prozessor, wenn Sie ein Modell oder ein Eingabe- und Ausgabe-Mapping benötigen, das die speziell entwickelten Prozessoren nicht bieten. Eine vollständige Konzeptdokumentation finden Sie unter [ML-Inferenzprozessor](https://docs.opensearch.org/latest/ingest-pipelines/processors/ml-inference/) auf dem *OpenSearch Dokumentation* Webseite.

Sie können die verwenden `ml_inference` Prozessor zur Unterstützung von Workflows wie den folgenden:
+ Semantische Suche
+ Retrieval-augmented Generierung (RAG)
+ Multimodale Suche
+ Zusammenfassung der Ergebnisse
+ Anreicherung von Abfragen

**Topics**
+ [Voraussetzungen](#serverless-ml-inference-prerequisites)
+ [Beispiel: Richten Sie ein Amazon Titan-Einbettungsmodell ein](#serverless-ml-inference-model-setup)
+ [Passen Sie den Prozessor an Ihr Modell an](#serverless-ml-inference-match-model)
+ [Verwendung von ml\_inference in einer Ingest-Pipeline](#serverless-ml-inference-ingest)
+ [Verwenden von ml\_inference in einer Suchpipeline](#serverless-ml-inference-search)
+ [Preisgestaltung](#serverless-ml-inference-pricing)
+ [Erforderliche Berechtigungen](#serverless-ml-inference-permissions)
+ [Fehlerbehebung](#serverless-ml-inference-troubleshooting)
+ [Weitere Informationen](#serverless-ml-inference-more-info)

## Voraussetzungen
<a name="serverless-ml-inference-prerequisites"></a>

Bevor Sie das verwenden `ml_inference` Prozessor, vervollständigen Sie die folgenden Schritte:
+ **Erstellen Sie eine Vektor-Suchsammlung.** OpenSearch Serverless unterstützt die `ml_inference` Prozessor für Sammlungen mit Vektorsuche (Typ `VECTORSEARCH`) in einem NextGen Sammlungsgruppe. OpenSearch Serverless akzeptiert nur Modelle mit einem `function_name` von `remote`. Informationen zum Erstellen der Sammlungsgruppe finden Sie unter [Erstellen Sie eine Sammlungsgruppe](serverless-collection-groups-procedures.md#collection-groups-create). Informationen zum Erstellen der Sammlung finden Sie unter [Arbeiten mit Vektor-Suchsammlungen](serverless-vector-search.md). Aktivieren Sie Standby-Replikate sowohl für die Sammlungsgruppe als auch für die Sammlung.

  Folgendes AWS CLI Beispiel erstellt eine NextGen Sammlungsgruppe und darin eine Vektor-Suchsammlung. Ersetzen {{my-collection-group}} und {{my-collection}} mit deinen eigenen Namen.

  ```
  aws opensearchserverless create-collection-group \
      --name {{my-collection-group}} \
      --generation NEXTGEN \
      --standby-replicas ENABLED \
      --capacity-limits maxIndexingCapacityInOCU={{8}},maxSearchCapacityInOCU={{8}}
  
  aws opensearchserverless create-collection \
      --name {{my-collection}} \
      --type VECTORSEARCH \
      --collection-group-name {{my-collection-group}} \
      --standby-replicas ENABLED
  ```
+ **Konfigurieren und implementieren Sie ein Remote-Modell.** Der Prozessor ruft ein konfiguriertes und bereitgestelltes Remote-Modell auf, auf das Sie anhand seiner Modell-ID verweisen. Ein Beispiel zur Einrichtung eines Amazon Titan-Einbettungsmodells finden Sie unter [Beispiel: Richten Sie ein Amazon Titan-Einbettungsmodell ein](#serverless-ml-inference-model-setup). Weitere Informationen finden Sie unter [Machine Learning auf Amazon OpenSearch Serverless konfigurieren](serverless-configure-machine-learning.md).
+ **Unterschreiben Sie Ihre Anfragen.** Unterschreiben Sie jede Anfrage an den Sammelendpunkt mit AWS Signaturversion 4 mit dem Dienstnamen `aoss`. Weitere Informationen finden Sie unter [Signieren von HTTP-Anforderungen mit anderen Clients](serverless-clients.md#serverless-signing).

## Beispiel: Richten Sie ein Amazon Titan-Einbettungsmodell ein
<a name="serverless-ml-inference-model-setup"></a>

Die Beispiele in diesem Thema verwenden ein Amazon Titan Text Embeddings V2-Modell in Amazon Bedrock. Mit den folgenden Schritten erstellen Sie den Connector und das Modell in Ihrer Sammlung.

1. Erstellen Sie eine IAM-Rolle, die OpenSearch Serverless geht davon aus, Amazon Bedrock anzurufen. Die Vertrauensrichtlinie der Rolle muss Folgendes zulassen `ml.opensearchservice.amazonaws.com` Service Principal, und die Berechtigungsrichtlinie der Rolle muss Folgendes zulassen `bedrock:InvokeModel` auf dem Modell. Der Principal, der den Connector erstellt, benötigt außerdem `iam:PassRole` in dieser Rolle.

1. Erstellen Sie den Connector. Ersetzen {{region}} mit dem AWS-Region des Amazon Bedrock-Modells, {{account-id}} mit deinem AWS Konto-ID und {{bedrock-role}} mit dem Namen der Rolle aus dem vorherigen Schritt.

   ```
   POST /_plugins/_ml/connectors/_create
   {
     "name": "Amazon Bedrock Titan Text Embeddings V2",
     "description": "Connector for amazon.titan-embed-text-v2:0",
     "version": 1,
     "protocol": "aws_sigv4",
     "parameters": {
       "region": "{{region}}",
       "service_name": "bedrock",
       "model": "amazon.titan-embed-text-v2:0"
     },
     "credential": {
       "roleArn": "arn:aws:iam::{{account-id}}:role/{{bedrock-role}}"
     },
     "actions": [
       {
         "action_type": "predict",
         "method": "POST",
         "url": "https://bedrock-runtime.${parameters.region}.amazonaws.com/model/${parameters.model}/invoke",
         "headers": {
           "content-type": "application/json",
           "x-amz-content-sha256": "required"
         },
         "request_body": "{ \"inputText\": \"${parameters.inputText}\" }",
         "post_process_function": "connector.post_process.bedrock.embedding"
       }
     ]
   }
   ```

   Die Antwort enthält die Connector-ID. Die `post_process_function` Die Einstellung gibt die Einbettung zurück `$.inference_results[0].output[0].data`, das ist der Pfad, den die Beispiele in diesem Thema verwenden.

1. Registrieren Sie das Modell mit dem Connector. Ersetzen {{my-connector-id}} mit der Connector-ID aus dem vorherigen Schritt.

   ```
   POST /_plugins/_ml/models/_register
   {
     "name": "titan-embed-text-v2",
     "function_name": "remote",
     "description": "Amazon Titan Text Embeddings V2",
     "connector_id": "{{my-connector-id}}"
   }
   ```

   Die Antwort enthält die Modell-ID.

1. Stellen Sie das Modell bereit. Ersetzen {{my-model-id}} mit der Modell-ID aus dem vorherigen Schritt.

   ```
   POST /_plugins/_ml/models/{{my-model-id}}/_deploy
   ```

1. Testen Sie das Modell mit der Prognose-API, wie unter gezeigt [Passen Sie den Prozessor an Ihr Modell an](#serverless-ml-inference-match-model).

Für diese Schritte sind die folgenden Berechtigungen auf dem erforderlich `model` Ressourcentyp: `aoss:CreateMLResource` um den Connector zu erstellen und das Modell zu registrieren, `aoss:UpdateMLResource` um es bereitzustellen, und `aoss:ExecuteMLResource` um die Prognose-API aufzurufen. Ein Beispiel für eine Datenzugriffsrichtlinie, die diese Berechtigungen gewährt, finden Sie unter [Berechtigungen für Machine Learning konfigurieren](serverless-configure-machine-learning.md#serverless-configure-machine-learning-permissions).

## Passen Sie den Prozessor an Ihr Modell an
<a name="serverless-ml-inference-match-model"></a>

Der `ml_inference` Der Prozessor kennt die Form Ihres Modells nicht. Du erzählst es mit `input_map` und `output_map`. Wenn diese nicht mit der Prognose-API des Modells übereinstimmen, schlägt der Prozessor fehl oder schreibt den falschen Wert. Testen Sie das Modell zuerst mit der Prognose-API und kopieren Sie dann die Parameternamen und den Ausgabepfad in Ihre Pipeline.

Die folgende Tabelle zeigt, woher die einzelnen Teile des Mappings stammen.


| Mapping (Zuordnung) | Womit muss es übereinstimmen | 
| --- | --- | 
| Geben Sie ein input\_map | Ein Parametername in der Prognoseanforderung, der ein ${parameters.{{name}}} Platzhalter im Konnektor request\_body. | 
| Wert in input\_map | Das Dokumentfeld oder das Abfragefeld, das den Wert liefert. | 
| Geben Sie ein output\_map | Der Name des Feldes, das die Modellausgabe empfängt. | 
| Wert in output\_map | Ein JSON-Pfad in die Prognoseantwort, zum Beispiel $.inference\_results[0].output[0].data. | 

Im folgenden Beispiel wird die Prognose-API für ein Texteinbettungsmodell aufgerufen. Das `inputText` Der Parameter ist derselbe Name, den das Beispiel für die Ingest-Pipeline als Schlüssel verwendet `input_map`. Ersetzen {{my-model-id}} mit der ID Ihres bereitgestellten Modells.

```
POST /_plugins/_ml/models/{{my-model-id}}/_predict
{
  "parameters": {
    "inputText": "Example document text"
  }
}
```

Das Modell gibt eine Antwort wie die folgende zurück. Das `data` Das Array ist aus Gründen der Lesbarkeit gekürzt.

```
{
  "inference_results": [
    {
      "output": [
        {
          "name": "sentence_embedding",
          "data_type": "FLOAT32",
          "shape": [1024],
          "data": [0.0123, -0.0456, 0.0789]
        }
      ],
      "status_code": 200
    }
  ]
}
```

Die Einbettung erfolgt in der `data` Array der ersten Ausgabe. Der JSON-Pfad `$.inference_results[0].output[0].data` wählt ihn aus. Dies ist der Pfad, den das Beispiel für eine Ingest-Pipeline verwendet `output_map`.

**Anmerkung**  
Diese Antwortform gilt, wenn der Amazon Titan-Einbettungsstecker gesetzt wird `post_process_function` zu `connector.post_process.bedrock.embedding`. Ohne eine Nachbearbeitungsfunktion ist der Vektor bei `$.inference_results[0].output[0].dataAsMap.embedding` stattdessen. Informationen zur Einrichtung des Connectors finden Sie unter [Machine Learning auf Amazon OpenSearch Serverless konfigurieren](serverless-configure-machine-learning.md).

**Wichtig**  
Die Anforderungsparameter und die Antwortform hängen vom Modell und seinem Anschluss ab. Wenn Sie ein anderes Modell verwenden, sollten Sie die Pfade aus den Beispielen in diesem Thema nicht wiederverwenden. Führen Sie die Prognose-API für Ihr Modell aus und lesen Sie die Pfade aus der Antwort ab.

Beispielsweise hat ein großes Sprachmodell, das seine Rohantwort zurückgibt, eine andere Form. Der Text ist verschachtelt in `dataAsMap` Objekt, und der Parameter, den Sie senden, ist nach dem Connector-Platzhalter benannt und nicht nach `inputText`.

```
POST /_plugins/_ml/models/{{my-llm-model-id}}/_predict
{
  "parameters": {
    "messages": "[{\"role\":\"user\",\"content\":[{\"text\":\"Summarize: Example text\"}]}]"
  }
}
```

```
{
  "inference_results": [
    {
      "output": [
        {
          "name": "response",
          "dataAsMap": {
            "output": {
              "message": {
                "role": "assistant",
                "content": [
                  {
                    "text": "A short summary of the example text."
                  }
                ]
              }
            },
            "stopReason": "end_turn"
          }
        }
      ],
      "status_code": 200
    }
  ]
}
```

Für diese Antwort lautet der JSON-Pfad `$.inference_results[0].output[0].dataAsMap.output.message.content[0].text`. Die genaue Struktur unter `dataAsMap` ist die Antwort Ihres Modellanbieters, daher unterscheidet sie sich zwischen Anbietern und Modellen.

Gehen Sie wie folgt vor, um den Prozessor auf ein anderes Modell umzustellen:

1. Suchen Sie die Parameternamen in der `request_body` des Steckers des Modells. Jeder `${parameters.{{name}}}` Platzhalter ist ein Name, den Sie als Schlüssel verwenden können `input_map`.

1. Rufen Sie die Prognose-API mit einem Beispielwert für jeden Parameter auf.

1. Lesen Sie die Prognoseantwort und schreiben Sie den JSON-Pfad zu dem Wert, den Sie behalten möchten.

1. Aktualisieren `model_id`, `input_map`, und `output_map` in der Pipeline.

1. Führen Sie das aus `_simulate` API für ein Beispieldokument, um zu bestätigen, dass das Ausgabefeld den erwarteten Wert hat.

**Anmerkung**  
Die Prognose-API erfordert die `aoss:ExecuteMLResource` Erlaubnis für die Modellressource. Weitere Informationen finden Sie unter [Machine Learning auf Amazon OpenSearch Serverless konfigurieren](serverless-configure-machine-learning.md).

## Verwendung von ml\_inference in einer Ingest-Pipeline
<a name="serverless-ml-inference-ingest"></a>

In einer Ingest-Pipeline ist die `ml_inference` Der Prozessor führt während der Indizierung eine Modellinferenz durch. Eine übliche Anwendung besteht darin, Vektoreinbettungen aus einem Textfeld zu generieren, sodass Sie eine semantische Suche in Ihren Daten ausführen können. Das `input_map` ordnet der Modelleingabe ein Dokumentfeld zu, und `output_map` schreibt die Modellausgabe in ein neues Feld.

Das folgende Beispiel erstellt eine Pipeline, die die sendet `text` fügt ein Feld in das Modell ein und schreibt die zurückgegebene Einbettung in ein `embedding` Feld. Ersetzen {{my-pipeline}} mit dem Namen Ihrer Pipeline und {{my-model-id}} mit der ID Ihres bereitgestellten Modells.

```
PUT _ingest/pipeline/{{my-pipeline}}
{
  "description": "Generates embeddings with a configured model",
  "processors": [
    {
      "ml_inference": {
        "model_id": "{{my-model-id}}",
        "full_response_path": true,
        "input_map": [
          {
            "inputText": "text"
          }
        ],
        "output_map": [
          {
            "embedding": "$.inference_results[0].output[0].data"
          }
        ]
      }
    }
  ]
}
```

Die Anfrage gibt die folgende Antwort zurück:

```
{
  "acknowledged": true
}
```

Die `output_map` Pfad wurzelt in `inference_results` da `full_response_path` ist eingestellt auf `true`. Bei dieser Einstellung wird der Ausgabepfad anhand der vollständigen Modellantwort bewertet. Weitere Informationen finden Sie unter [ML-Inferenzprozessor](https://docs.opensearch.org/latest/ingest-pipelines/processors/ml-inference/) auf dem *OpenSearch Dokumentation* Webseite.

Bevor Sie die Pipeline auf Live-Traffic anwenden, können Sie sie anhand von Beispieldokumenten mit dem `_simulate` Endpunkt. Um die Modellinferenz automatisch für jedes Dokument auszuführen, das in einem Index indexiert ist, legen Sie den `index.default_pipeline` Einstellung, wenn Sie den Index erstellen. Sie können die Pipeline auch in einer einzelnen Indexierungsanforderung angeben mit `pipeline` Abfrageparameter. Weitere Informationen zum Erstellen, Simulieren und Anwenden von Ingest-Pipelines finden Sie unter [Pipelines in Amazon aufnehmen OpenSearch Serverlos](serverless-ingest-pipelines.md).

Im folgenden Beispiel wird ein Dokument indexiert und die Pipeline ausgeführt. Ersetzen {{my-index}} mit dem Namen Ihres Indexes und {{my-pipeline}} mit dem Namen Ihrer Pipeline.

```
POST {{my-index}}/_doc?pipeline={{my-pipeline}}
{
  "text": "Example document text"
}
```

Die Antwort bestätigt, dass das Dokument indexiert wurde:

```
{
  "_index": "my-index",
  "_id": "93VTg6EBtHTIBjFym5yW",
  "_version": 1,
  "result": "created",
  "_shards": {
    "total": 0,
    "successful": 0,
    "failed": 0
  },
  "_seq_no": 0,
  "_primary_term": 0
}
```

**Anmerkung**  
Der Zielindex muss für die Vektorsuche konfiguriert sein. Aktivieren `index.knn` und ordnen Sie das Ausgabefeld zu (zum Beispiel `embedding`) als `knn_vector` Feld mit einer Dimension, die Ihrem Modell entspricht.

## Verwenden von ml\_inference in einer Suchpipeline
<a name="serverless-ml-inference-search"></a>

In einer Suchpipeline ist der `ml_inference` Der Prozessor führt die Modellinferenz als Teil einer Abfrage aus. Ein Suchanforderungsprozessor transformiert oder schreibt die Abfrage neu, bevor sie ausgeführt wird. Ein Prozessor für Suchanfragen reichert die Ergebnisse an, bevor Sie sie erhalten. Um eine Suchpipeline auszuführen, senden Sie die Anfrage mit `search_pipeline` Abfrageparameter. Ersetzen {{my-index}} mit dem Namen Ihres Indexes und {{my-pipeline}} mit dem Namen Ihrer Pipeline.

```
POST {{my-index}}/_search?search_pipeline={{my-pipeline}}
```

Um eine Suchpipeline zu erstellen oder zu aktualisieren, senden Sie den Hauptteil der Pipeline an `_search/pipeline` Endpunkt, wie die Beispiele in den folgenden Abschnitten zeigen.

**Anmerkung**  
Es kann einige Minuten dauern, bis eine neu erstellte Suchpipeline wirksam wird, auch wenn die Erstellungsanforderung erneut gesendet wurde `"acknowledged": true`. Bis dahin schlagen Suchanfragen, die auf die Pipeline verweisen, mit einem `Pipeline {{my-pipeline}} is not defined` Fehler. Versuchen Sie die Anfrage nach einer kurzen Wartezeit erneut.

### Prozessor für Suchanfragen
<a name="serverless-ml-inference-search-request"></a>

Sie verwenden zuvor einen Suchanforderungsprozessor, um eine eingehende Anfrage neu zu schreiben OpenSearch Serverless führt ihn aus. Das folgende Beispiel verwendet den Text von `match` query, generiert daraus einen Vektor mit einem konfigurierten Modell und schreibt die Anfrage in eine k-NN-Abfrage um mit `query_template` Parameter. OpenSearch Serverless ersetzt den `${query_vec}` Platzhalter in der Vorlage mit der Modellausgabe `output_map` erfasst. Ersetzen {{my-model-id}} mit der ID Ihres bereitgestellten Modells.

```
PUT /_search/pipeline/{{my-pipeline}}
{
  "request_processors": [
    {
      "ml_inference": {
        "model_id": "{{my-model-id}}",
        "full_response_path": true,
        "query_template": "{\"size\":2,\"_source\":[\"text\"],\"query\":{\"knn\":{\"embedding\":{\"vector\":${query_vec},\"k\":2}}}}",
        "input_map": [
          {
            "inputText": "query.match.text.query"
          }
        ],
        "output_map": [
          {
            "query_vec": "$.inference_results[0].output[0].data"
          }
        ],
        "ignore_missing": true
      }
    }
  ]
}
```

Einstellen `full_response_path` zu `true` so dass die `output_map` Der JSON-Pfad wird anhand der vollständigen Modellantwort aufgelöst. Auf diese Weise können Sie denselben Ausgabepfad verwenden, den Sie aus der Prognose-API-Antwort gelesen haben.

Stellen Sie ein `ignore_missing` zu `true` wenn das Quellfeld fehlen könnte. Eine Abfrage, die das zugeordnete Feld nicht enthält, z. B. eine `match_all` Die Abfrage wird dann unverändert weitergeleitet, anstatt dass sie fehlschlägt. Der Prozessor schreibt Abfragen, die das Feld enthalten, immer noch neu.

### Prozessor für Suchanfragen
<a name="serverless-ml-inference-search-response"></a>

Ein Suchantwortprozessor wird ausgeführt, nachdem eine Abfrage zurückgegeben wurde, sodass Sie jeden Treffer anreichern oder zusammenfassen können. Im folgenden Beispiel wird der gesendet `text` Feld jedes Treffers an ein konfiguriertes Modell und schreibt die Modellausgabe in ein `text_vec` Feld. Set `one_to_one` zu `true` sodass der Prozessor das Modell bei jedem Suchtreffer einmal ausführt. Die Standardeinstellung ist `false`, wodurch alle Treffer in einer einzigen Anforderung an das Modell gesendet werden, und Modelle, die einen einzelnen Eingabewert erwarten, lehnen diese Anforderung ab. Ersetzen {{my-model-id}} mit der ID Ihres bereitgestellten Modells.

```
PUT /_search/pipeline/{{my-pipeline}}
{
  "response_processors": [
    {
      "ml_inference": {
        "model_id": "{{my-model-id}}",
        "full_response_path": true,
        "input_map": [
          {
            "inputText": "text"
          }
        ],
        "output_map": [
          {
            "text_vec": "$.inference_results[0].output[0].data"
          }
        ],
        "one_to_one": true
      }
    }
  ]
}
```

Um die Ergebnisse mit einem großen Sprachmodell zusammenzufassen, fügen Sie eine `model_config` Objekt, das die Model-Eingabeaufforderung enthält, und setzen `one_to_one` zu `true` sodass der Prozessor jeden Suchtreffer separat zusammenfasst. Die Eingabeaufforderung kann über einen Vorlagenparameter auf die zugeordnete Eingabe verweisen, z. B. `${parameters.context}`. Das `output_map` Der Pfad in diesem Beispiel entspricht einem Modell, das seine Rohantwort zurückgibt. Weitere Informationen finden Sie unter [Passen Sie den Prozessor an Ihr Modell an](#serverless-ml-inference-match-model). Ersetzen {{my-model-id}} mit der ID Ihres bereitgestellten Modells.

```
PUT /_search/pipeline/{{my-pipeline}}
{
  "response_processors": [
    {
      "ml_inference": {
        "model_id": "{{my-model-id}}",
        "full_response_path": true,
        "input_map": [
          {
            "context": "text"
          }
        ],
        "output_map": [
          {
            "summary": "$.inference_results[0].output[0].dataAsMap.output.message.content[0].text"
          }
        ],
        "model_config": {
          "messages": "[{\"role\":\"user\",\"content\":[{\"text\":\"Summarize the following text: ${parameters.context}\"}]}]"
        },
        "one_to_one": true
      }
    }
  ]
}
```

## Preisgestaltung
<a name="serverless-ml-inference-pricing"></a>

Die `ml_inference` Der Prozessor wird auf dem Computer ausgeführt, der die Anforderungen Ihrer Sammlung verarbeitet. In einer Ingest-Pipeline zählt deren Verarbeitung zur Indizierung OpenSearch Compute Units (OCUs) für Ihre Sammlung. In einer Suchpipeline zählt ihre Verarbeitung auf die Such-OCUs, genau wie andere Indexierungs- und Suchaktivitäten. Pipelines mit mehr Prozessoren oder mit rechenintensiven Prozessoren verbrauchen mehr Kapazität als einfache Pipelines. Weitere Informationen zur Skalierung und Abrechnung der Kapazität finden Sie unter [Verwaltung von Kapazitätsgrenzen für Amazon OpenSearch Serverlos](serverless-scaling.md) und [Amazon OpenSearch Preisgestaltung für Dienstleistungen](https://aws.amazon.com/opensearch-service/pricing/).

Der Prozessor ruft auch das von Ihnen konfigurierte Remote-Modell auf, und der Modellanbieter berechnet die Modellinferenz separat.

## Erforderliche Berechtigungen
<a name="serverless-ml-inference-permissions"></a>

Verwaltung der Such- und Ingest-Pipelines, die eine enthalten `ml_inference` Der Prozessor entspricht den folgenden OpenSearch Richtlinienberechtigungen für serverlosen Datenzugriff. Die Berechtigungen gelten für `collection` Ressourcentyp.
+ `aoss:CreateCollectionItems` — Erstellen oder aktualisieren Sie eine Pipeline.
+ `aoss:DescribeCollectionItems` — Pipelines abrufen, auflisten und simulieren.
+ `aoss:DeleteCollectionItems` — Löscht eine Pipeline.

Der Prozessor ruft auch das Modell auf, das Sie konfiguriert haben. Die Berechtigungen für Datenzugriffsrichtlinien, die ein Principal zum Erstellen und Ausführen von Modellen benötigt, finden Sie unter [Machine Learning auf Amazon OpenSearch Serverless konfigurieren](serverless-configure-machine-learning.md).

**Wichtig**  
Der Principal, der eine Anfrage über die Pipeline sendet, benötigt die `aoss:ExecuteMLResource` Genehmigung für das Modell. Dies gilt für die Indizierung von Dokumenten, die ausgeführt werden `_simulate`, und suchen. Ohne diese Erlaubnis schlagen diese Anfragen mit einem fehl `Forbidden` Fehler, der die fehlende Berechtigung nicht benennt.

Das folgende Beispiel für eine Datenzugriffsrichtlinie gewährt einem Hauptbenutzer die Berechtigung, Pipelines in einer Sammlung zu verwalten und die Modelle in dieser Sammlung auszuführen. Ersetzen {{collection-name}} mit dem Namen deiner Sammlung, {{account-id}} mit deinem AWS Konto-ID und {{role-name}} mit dem Namen der IAM-Rolle, die die Pipelines verwaltet und verwendet.

```
[
    {
        "Description": "Manage pipelines and run models",
        "Rules": [
            {
                "ResourceType": "collection",
                "Resource": ["collection/{{collection-name}}"],
                "Permission": [
                    "aoss:CreateCollectionItems",
                    "aoss:DescribeCollectionItems",
                    "aoss:DeleteCollectionItems"
                ]
            },
            {
                "ResourceType": "model",
                "Resource": ["model/{{collection-name}}/*"],
                "Permission": [
                    "aoss:ExecuteMLResource"
                ]
            }
        ],
        "Principal": [
            "arn:aws:iam::{{account-id}}:role/{{role-name}}"
        ]
    }
]
```

Für die vollständige Zuordnung von OpenSearch API-Operationen zu OpenSearch Serverlose Berechtigungen, siehe [Unterstützte Operationen und Plugins in Amazon OpenSearch Serverless](serverless-genref.md).

## Fehlerbehebung
<a name="serverless-ml-inference-troubleshooting"></a>

Wenn eine Anfrage, die eine verwendet `ml_inference` Pipeline schlägt fehl mit einem `Forbidden` Fehler, überprüfen Sie die folgenden häufigen Ursachen:
+ Der aufrufende Prinzipal hat nicht `aoss:ExecuteMLResource` auf dem Modell. Fügen Sie eine hinzu `model` Regel zur Datenzugriffsrichtlinie, wie unter [Erforderliche Berechtigungen](#serverless-ml-inference-permissions).
+ Die Datenzugriffsrichtlinie gewährt dem Principal nicht die Index- oder Sammlungsberechtigungen für den Vorgang, wie z. B. das Schreiben von Dokumenten, das Suchen oder das Erstellen von Pipelines.
+ Die Anfrage ist mit dem Dienstnamen signiert `es` statt `aoss`.
+ Die Netzwerkrichtlinie für die Sammlung erlaubt keinen Zugriff von der Quelle der Anfrage aus.

Wenn eine Suchanfrage mit einem fehlschlägt `Pipeline {{my-pipeline}} is not defined` Fehler direkt nach dem Erstellen der Pipeline. Warten Sie ein paar Minuten und versuchen Sie es erneut. Weitere Informationen finden Sie unter [Verwenden von ml\_inference in einer Suchpipeline](#serverless-ml-inference-search).

## Weitere Informationen
<a name="serverless-ml-inference-more-info"></a>

Für weitere Informationen über `ml_inference` Prozessor finden Sie im Folgenden:
+ Die Referenz zum Ingest-Pipeline-Prozessor finden Sie unter [ML-Inferenzprozessor](https://docs.opensearch.org/latest/ingest-pipelines/processors/ml-inference/) auf dem *OpenSearch Dokumentation* Webseite.
+ Die Referenz zum Prozessor für Suchanfragen finden Sie unter [Prozessor für ML-Inferenz-Suchanfragen](https://docs.opensearch.org/latest/search-plugins/search-pipelines/ml-inference-search-request/) auf dem *OpenSearch Dokumentation* Webseite.
+ Die Referenz zum Search-Response-Prozessor finden Sie unter [Prozessor für ML-Inferenz-Suchantantworten](https://docs.opensearch.org/latest/search-plugins/search-pipelines/ml-inference-search-response/) auf dem *OpenSearch Dokumentation* Webseite.
+ Ein praktisches Beispiel für die Zusammenfassung von Rezensionen und die semantische Suche finden Sie unter [Einführung in ML-Inferenzprozessoren in OpenSearch: Zusammenfassung und semantische Suche überprüfen](https://opensearch.org/blog/introduction-to-ml-inference-processors-in-opensearch-review-summarization-and-semantic-search/) auf der *OpenSearch* Blog.