

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.

# So bauen Sie eine Wissensdatenbank durch eine Verbindung zu einem strukturierten Datenspeicher auf
<a name="knowledge-base-build-structured"></a>

Mit Wissensdatenbanken für Amazon Bedrock können Sie eine Verbindung zu strukturierten Datenspeicher mit Daten herstellen, die einem vordefinierten Schema entsprechen. Beispiele für strukturierte Daten sind Tabellen und Datenbanken. Wissensdatenbanken für Amazon Bedrock kann Benutzeranfragen in eine Sprache konvertieren, die für das Extrahieren von Daten aus unterstützten strukturierten Datenspeichern geeignet ist. Dann kann eine konvertierte Abfrage verwendet werden, um für die Abfrage relevante Daten abzurufen und entsprechende Antworten zu generieren. So können Sie die vorhandenen strukturierten Daten direkt verwenden, ohne sie in ein anderes Format konvertieren oder eigene SQL-Abfragen generieren zu müssen.

Nachdem Sie Ihre Wissensdatenbank eingerichtet haben, können Sie Abfragen einreichen, um während des [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_Retrieve.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_Retrieve.html)-Vorgangs Daten aus der Wissensdatenbank abzurufen oder anhand der abgerufenen Daten im Rahmen des [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_RetrieveAndGenerate.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_RetrieveAndGenerate.html)-Vorgangs Antworten generieren. Bei diesen Vorgängen werden die Benutzeranfragen in Anfragen umgewandelt, die für den mit der Wissensdatenbank verbundenen strukturierten Datenspeicher geeignet sind.

Optional können Sie auch Abfragen unabhängig vom Abrufen von Daten mithilfe der API-Operation [GenerateQuery](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GenerateQuery.html) konvertieren. Dieser Vorgang konvertiert Abfragen in natürlicher Sprache in SQL-Abfragen, die für die abgefragte Datenquelle geeignet sind. Sie können diesen Vorgang unabhängig verwenden und in Ihren Workflow einfügen.

Wählen Sie ein Thema aus, um mehr über die Voraussetzungen und den Prozess für die Verbindung Ihrer Wissensdatenbank mit einem strukturierten Datenspeicher zu erfahren.

**Topics**
+ [Einrichten Ihrer Abfrage-Engine und der Berechtigungen zum Erstellen einer Wissensdatenbank mit strukturiertem Datenspeicher](knowledge-base-prereq-structured.md)
+ [Erstellen einer Wissensdatenbank durch Herstellen einer Verbindung mit einem strukturierten Datenspeicher](knowledge-base-structured-create.md)
+ [So synchronisieren Sie Ihren strukturierten Datenspeicher mit Ihrer Amazon-Bedrock-Wissensdatenbank](kb-data-source-structured-sync-ingest.md)

# Einrichten Ihrer Abfrage-Engine und der Berechtigungen zum Erstellen einer Wissensdatenbank mit strukturiertem Datenspeicher
<a name="knowledge-base-prereq-structured"></a>

In diesem Thema werden die Berechtigungen beschrieben, die Sie benötigen, um Ihre Wissensdatenbank mit einem strukturierten Datenspeicher zu verbinden. Wenn Sie planen, eine Amazon-Bedrock-Wissensdatenbank mit einem strukturierten Datenspeicher zu verbinden, müssen Sie die Voraussetzungen erfüllen. Informationen zu den allgemeinen Genehmigungsanforderungen, die erfüllt werden müssen, finden Sie unter [Einrichten von Berechtigungen für einen Benutzer oder eine Rolle zum Erstellen und Verwalten von Wissensdatenbanken](knowledge-base-prereq-permissions-general.md).

**Wichtig**  
Die Ausführung beliebiger SQL-Abfragen kann ein Sicherheitsrisiko für jede Text-to-SQL Anwendung darstellen. Es wird empfohlen, bei Bedarf Vorsichtsmaßnahmen zu treffen, z. B. eingeschränkte Rollen, schreibgeschützte Datenbanken und Sandboxes zu verwenden.

Amazon-Bedrock-Wissensdatenbanken unterstützen Amazon Redshift als Abfrage-Engines für die Abfrage Ihres Datenspeichers. Eine Abfrage-Engine greift auf Metadaten aus einem strukturierten Datenspeicher zu und verwendet die Metadaten, um SQL-Abfragen zu generieren. Amazon Redshift ist ein Data-Warehouse-Service, der mithilfe von SQL strukturierte Daten aus Data Warehouses, Datenbanken und Data Lakes analysiert.

## Erstellen einer Abfrage-Engine in Amazon Redshift
<a name="kb-query-engine-setup-create"></a>

Sie können je nach Anwendungsfall Amazon Redshift Serverless oder Amazon Redshift Provisioned verwenden und eine Verbindung mit Arbeitsgruppen oder Clustern für Ihr Data Warehouse herstellen. Bei den zugrunde liegenden Daten, die die Amazon Redshift Redshift-Engine abfragen kann, kann es sich um Daten handeln, die nativ in Amazon Redshift Redshift-Clustern gespeichert sind, oder um Daten, die sich unter dem Standard befinden AWS Glue Data Catalog (z. B. in Amazon S3).

Wenn Sie bereits eine Abfrage-Engine erstellt haben, können Sie diese Voraussetzung überspringen. Andernfalls führen Sie die folgenden Schritte aus, um Ihre Abfrage-Engine von Amazon Redshift Provisioned oder Amazon Redshift Serverless einzurichten:

**So richten Sie eine Abfrage-Engine in Amazon Redshift Provisioned ein**

1. Folgen Sie den Schritten in [Schritt 1: Erstellen eines Amazon-Redshift-Beispielclusters](https://docs.aws.amazon.com/redshift/latest/gsg/new-user.html#rs-gsg-launch-sample-cluster) im Handbuch Erste Schritte mit Amazon Redshift.

1. Notieren Sie sich die Cluster-ID.

1. (Optional) Weitere Informationen über Cluster, die von Amazon Redshift bereitgestellt werden, finden Sie unter [Von Amazon Redshift bereitgestellte Cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html) im Amazon-Redshift-Verwaltungshandbuch.

**So richten Sie eine Abfrage-Engine in Amazon Redshift Serverless ein**

1. Folgen Sie nur dem Einrichtungsverfahren unter [Erstellen eines Data Warehouse mit Amazon Redshift Serverless](https://docs.aws.amazon.com/redshift/latest/gsg/new-user-serverless.html#serverless-console-resource-creation) im Handbuch Erste Schritte mit Amazon Redshift und konfigurieren Sie es mit den Standardeinstellungen.

1. Notieren Sie sich den ARN der Arbeitsgruppe.

1. (Optional) Weitere Informationen zu Arbeitsgruppen von Amazon Redshift Serverless finden Sie unter [Arbeitsgruppen und Namespaces](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-workgroup-namespace.html) im Amazon-Redshift-Verwaltungshandbuch.

## Konfigurieren von Berechtigungen für die Abfrage-Engine von Amazon Redshift
<a name="kb-query-engine-setup-redshift-permissions"></a>

Abhängig von der Abfrage-Engine von Amazon Redshift können Sie bestimmte Berechtigungen konfigurieren. Die von Ihnen konfigurierten Berechtigungen hängen von der Authentifizierungsmethode ab. Die folgende Tabelle zeigt die Authentifizierungsmethoden, die für verschiedene Abfrage-Engines verwendet werden können:


****  

| Authentifizierungsmethode | Amazon Redshift Provisioned | Amazon Redshift Serverless | 
| --- | --- | --- | 
| IAM | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/icons/icon-yes.png)Ja | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/icons/icon-yes.png)Ja | 
| Datenbankbenutzername | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/icons/icon-yes.png)Ja | ![\[Red circular icon with an X symbol, indicating cancellation or denial.\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/icons/icon-no.png)Nein | 
| AWS Secrets Manager | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/icons/icon-yes.png)Ja | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/icons/icon-yes.png)Ja | 

Wissensdatenbanken für Amazon Bedrock verwendet eine [Servicerolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html), um Wissensdatenbanken mit strukturierten Datenspeichern zu verbinden, Daten aus diesen Datenspeichern abzurufen und SQL-Abfragen auf der Grundlage von Benutzerabfragen und der Struktur der Datenspeicher zu generieren.

**Anmerkung**  
Wenn Sie planen, mit dem eine Wissensdatenbank AWS-Managementkonsole zu erstellen, können Sie diese Voraussetzung überspringen. Die Konsole erstellt eine Servicerolle von Wissensdatenbanken für Amazon Bedrock mit den entsprechenden Berechtigungen.

Wenn Sie eine benutzerdefinierte IAM-Servicerolle mit den entsprechenden Berechtigungen erstellen möchten, folgen Sie den Schritten unter [Erstellen einer Rolle, um Berechtigungen an einen AWS-Service zu delegieren](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) und hängen Sie die unter [Vertrauensstellung](kb-permissions.md#kb-permissions-trust) definierte Vertrauensstellung an.

Fügen Sie anschließend Berechtigungen für Ihre Wissensdatenbank hinzu, um auf Ihre Abfrage-Engine und Datenbanken von Amazon Redshift zuzugreifen. Erweitern Sie den Abschnitt, der auf Ihren Anwendungsfall zutrifft:

### Ihre Abfrage-Engine wird von Amazon Redshift bereitgestellt
<a name="w2aac28c10c27c13c11c15b1"></a>

Fügen Sie Ihrer benutzerdefinierten Servicerolle die folgende Richtlinie an, damit sie auf Ihre Daten zugreifen und damit Abfragen generieren kann:

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "RedshiftDataAPIStatementPermissions",
            "Effect": "Allow",
            "Action": [
                "redshift-data:GetStatementResult",
                "redshift-data:DescribeStatement",
                "redshift-data:CancelStatement"
            ],
            "Resource": [
                "*"
            ],
            "Condition": {
                "StringEquals": {
                    "redshift-data:statement-owner-iam-userid": "${aws:userid}"
                }
            }
        },
        {
            "Sid": "RedshiftDataAPIExecutePermissions",
            "Effect": "Allow",
            "Action": [
                "redshift-data:ExecuteStatement"
            ],
            "Resource": [
                "arn:aws:redshift:us-east-1:123456789012:cluster:${Cluster}"
            ]
        },
        {
            "Sid": "SqlWorkbenchAccess",
            "Effect": "Allow",
            "Action": [
                "sqlworkbench:GetSqlRecommendations",
                "sqlworkbench:PutSqlGenerationContext",
                "sqlworkbench:GetSqlGenerationContext",
                "sqlworkbench:DeleteSqlGenerationContext"
            ],
            "Resource": "*"
        },
        {
            "Sid": "GenerateQueryAccess",
            "Effect": "Allow",
            "Action": [
                "bedrock:GenerateQuery"
            ],
            "Resource": "*"
        }
    ]
}
```

------

Sie müssen außerdem Berechtigungen hinzufügen, damit sich Ihre Servicerolle bei der Abfrage-Engine authentifizieren kann. Erweitern Sie einen Abschnitt, um die Berechtigungen für diese Methode zu sehen.

------
#### [ IAM ]

Fügen Sie Ihrer benutzerdefinierten Servicerolle die folgende Richtlinie an, damit sie sich bei Ihrer von Amazon Redshift bereitgestellten Abfrage-Engine mit IAM authentifizieren kann:

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "GetCredentialsWithFederatedIAMCredentials",
            "Effect": "Allow",
            "Action": "redshift:GetClusterCredentialsWithIAM",
            "Resource": [
                "arn:aws:redshift:us-east-1:123456789012:dbname:Cluster/database"
            ]
        }
    ]
}
```

------

------
#### [ Database user ]

Zum Authentifizieren als Amazon-Redshift-Datenbankbenutzer fügen Sie der Servicerolle die folgende Richtlinie an:

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "GetCredentialsWithClusterCredentials",
            "Effect": "Allow",
            "Action": [
                "redshift:GetClusterCredentials"
            ],
            "Resource": [
                "arn:aws:redshift:us-east-1:123456789012:dbuser:${cluster}/${dbuser}",
                "arn:aws:redshift:us-east-1:123456789012:dbname:${cluster}/${database}"
            ]
        }
    ]
}
```

------

------
#### [ AWS Secrets Manager ]

Gehen Sie wie folgt vor, damit sich Ihre Servicerolle bei Ihrer von Amazon Redshift bereitgestellten Abfrage-Engine mit einem AWS Secrets Manager geheimen Schlüssel authentifizieren kann:
+ Fügen Sie der Rolle die folgende Richtlinie hinzu:

  ```
  {
      "Version": "2012-10-17",		 	 	 
      "Statement": [
          {
              "Sid": "GetSecretPermissions",
              "Effect": "Allow",
              "Action": [
                  "secretsmanager:GetSecretValue"
              ],
              "Resource": [
                  "arn:aws:secretsmanager:${region}:${account}:secret:${secretName}"
              ]
          }
      ]
  }
  ```

------

### Ihre Abfrage-Engine ist Amazon Redshift Serverless
<a name="w2aac28c10c27c13c11c15b3"></a>

Die Berechtigungen zum Anhängen richten sich nach Ihrer Authentifizierungsmethode. Erweitern Sie einen Abschnitt, um die Berechtigungen für eine Methode zu sehen.

------
#### [ IAM ]

Fügen Sie Ihrer benutzerdefinierten Servicerolle die folgende Richtlinie an, damit sie sich bei Ihrer Abfrage-Engine von Amazon Redshift Serverless mit IAM authentifizieren kann:

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "RedshiftServerlessGetCredentials",
            "Effect": "Allow",
            "Action": "redshift-serverless:GetCredentials",
            "Resource": [
                "arn:aws:redshift-serverless:us-east-1:123456789012:workgroup/WorkgroupId"
            ]
        }
    ]
}
```

------

------
#### [ AWS Secrets Manager ]

Gehen Sie wie folgt vor, damit sich Ihre Servicerolle bei Ihrer von Amazon Redshift bereitgestellten Abfrage-Engine mit einem AWS Secrets Manager geheimen Schlüssel authentifizieren kann:
+ Fügen Sie der Rolle die folgende Richtlinie hinzu:

  ```
  {
      "Version": "2012-10-17",		 	 	 
      "Statement": [
          {
              "Sid": "GetSecretPermissions",
              "Effect": "Allow",
              "Action": [
                  "secretsmanager:GetSecretValue"
              ],
              "Resource": [
                  "arn:aws:secretsmanager:${region}:${account}:secret:${secretName}"
              ]
          }
      ]
  }
  ```

------

## Zulassen, dass die Wissensdatenbank-Servicerolle auf Ihren Datenspeicher zugreift
<a name="knowledge-base-prereq-structured-db-access"></a>

Stellen Sie sicher, dass Ihre Daten in einem der folgenden [unterstützten strukturierten Datenspeicher](knowledge-base-structured-create.md) abgelegt sind:
+ Amazon Redshift
+ AWS Glue Data Catalog (AWS Lake Formation)

In der folgenden Tabelle sind die Authentifizierungsmethoden zusammengefasst, die je nach Datenspeicher für die Abfrage-Engine verfügbar sind:


****  

| Authentifizierungsmethode | Amazon Redshift | AWS Glue Data Catalog (AWS Lake Formation) | 
| --- | --- | --- | 
| IAM | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/icons/icon-yes.png)Ja | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/icons/icon-yes.png)Ja | 
| Datenbankbenutzername | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/icons/icon-yes.png)Ja | ![\[Red circular icon with an X symbol, indicating cancellation or denial.\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/icons/icon-no.png)Nein | 
| AWS Secrets Manager | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/icons/icon-yes.png)Ja | ![\[Red circular icon with an X symbol, indicating cancellation or denial.\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/images/icons/icon-no.png)Nein | 

Informationen darüber, wie Sie Berechtigungen für Ihre Servicerolle von Wissensdatenbanken für Amazon Bedrock einrichten, um auf Ihren Datenspeicher zuzugreifen und darauf basierende Abfragen zu generieren, finden Sie, indem Sie den Abschnitt erweitern, der dem Service entspricht, in dem sich Ihr Datenspeicher befindet:

### Amazon Redshift
<a name="w2aac28c10c27c13c13c13b1"></a>

Wenn Sie Ihrer Servicerolle von Wissensdatenbanken für Amazon Bedrock Zugriff auf Ihre Amazon-Redshift-Datenbank gewähren möchten, verwenden Sie [Amazon Redshift Query Editor V2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) und führen Sie die folgenden SQL-Befehle aus:

1. (Wenn Sie sich mit IAM authentifizieren und noch kein Benutzer für Ihre Datenbank erstellt wurde) Führen Sie den folgenden Befehl aus, der CREATE USER verwendet, um einen [Datenbankbenutzer zu erstellen](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_USER.html) und ihm die Authentifizierung über IAM zu ermöglichen, und *\$1\$1service-role\$1* ersetzen Sie ihn durch den Namen der benutzerdefinierten Amazon Bedrock Knowledge Bases-Servicerolle, die Sie erstellt haben:

   ```
   CREATE USER "IAMR:${service-role}" WITH PASSWORD DISABLE;
   ```
**Wichtig**  
Wenn Sie die für Sie in der Konsole erstellte Servicerolle von Wissensdatenbanken für Amazon Bedrock verwenden und dann [Ihren Datenspeicher synchronisieren](kb-data-source-structured-sync-ingest.md), bevor Sie diesen Schritt ausführen, wird der Benutzer für Sie erstellt. Die Synchronisierung schlägt jedoch fehl, da dem Benutzer keine Zugriffsberechtigungen für Ihren Datenspeicher erteilt wurden. Vor der Synchronisierung müssen Sie den folgenden Schritt ausführen.

1. Erteilen Sie einer Identität Berechtigungen zum Abrufen von Informationen aus Ihrer Datenbank, indem Sie den Befehl [GRANT](https://docs.aws.amazon.com/redshift/latest/dg/r_GRANT.html) ausführen.

------
#### [ IAM ]

   ```
   GRANT SELECT ON ALL TABLES IN SCHEMA ${schemaName} TO "IAMR:${serviceRole}";
   ```

------
#### [ Database user ]

   ```
   GRANT SELECT ON ALL TABLES IN SCHEMA ${schemaName} TO "${dbUser}";
   ```

------
#### [ AWS Secrets Manager username ]

   ```
   GRANT SELECT ON ALL TABLES IN SCHEMA ${schemaName} TO "${secretsUsername}";
   ```

------
**Wichtig**  
Gewähren Sie keinen Zugriff für `CREATE`, `UPDATE` oder `DELETE`. Wenn Sie diese Aktionen zulassen, kann dies zu unbeabsichtigten Änderungen Ihrer Daten führen.

   Für eine genauere Kontrolle der Tabellen, auf die zugegriffen werden kann, können Sie `ALL TABLES` bestimmte Tabellennamen durch die folgende Notation ersetzen:. *\$1\$1schemaName\$1* *\$1\$1tableName\$1* Weitere Informationen zu dieser Notation finden Sie im Abschnitt **Abfrageobjekte** unter [Datenbankübergreifende Abfragen](https://docs.aws.amazon.com/redshift/latest/dg/cross-database-overview.html).

------
#### [ IAM ]

   ```
   GRANT SELECT ON ${schemaName}.${tableName} TO "IAMR:${serviceRole}";
   ```

------
#### [ Database user ]

   ```
   GRANT SELECT ON ${schemaName}.${tableName} TO "${dbUser}";
   ```

------
#### [ AWS Secrets Manager username ]

   ```
   GRANT SELECT ON ${schemaName}.${tableName} TO "${secretsUsername}";
   ```

------

1. Wenn Sie ein neues Schema in der Redshift-Datenbank erstellt haben, führen Sie den folgenden Befehl aus, um eine Identitätsberechtigung für das neue Schema zu erteilen.

   ```
   GRANT USAGE ON SCHEMA ${schemaName} TO "IAMR:${serviceRole}";
   ```

### AWS Glue Data Catalog
<a name="w2aac28c10c27c13c13c13b3"></a>

Um Ihrer Amazon Bedrock Knowledge Bases-Servicerolle Zugriff auf Ihren AWS Glue Data Catalog Datenspeicher zu gewähren, verwenden Sie den [Amazon Redshift Query Editor v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) und führen Sie die folgenden SQL-Befehle aus:

1. Führen Sie den folgenden Befehl aus, der [CREATE USER](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_USER.html) verwendet, um einen Datenbankbenutzer zu erstellen und ihm die Authentifizierung über IAM zu ermöglichen. *\$1\$1service-role\$1* Ersetzen Sie ihn durch den Namen der benutzerdefinierten Amazon Bedrock Knowledge Bases-Servicerolle, die Sie erstellt haben:

   ```
   CREATE USER "IAMR:${service-role}" WITH PASSWORD DISABLE;
   ```
**Wichtig**  
Wenn Sie die für Sie in der Konsole erstellte Servicerolle von Wissensdatenbanken für Amazon Bedrock verwenden und dann [Ihren Datenspeicher synchronisieren](kb-data-source-structured-sync-ingest.md), bevor Sie diesen Schritt ausführen, wird der Benutzer für Sie erstellt. Die Synchronisierung schlägt jedoch fehl, da dem Benutzer keine Zugriffsberechtigungen für Ihren Datenspeicher erteilt wurden. Vor der Synchronisierung müssen Sie den folgenden Schritt ausführen.

1. Erteilen Sie der Servicerolle Berechtigungen zum Abrufen von Informationen aus Ihrer Datenbank, indem Sie den folgenden [GRANT](https://docs.aws.amazon.com/redshift/latest/dg/r_GRANT.html)-Befehl ausführen:

   ```
   GRANT USAGE ON DATABASE awsdatacatalog TO "IAMR:${serviceRole}";
   ```
**Wichtig**  
Gewähren Sie keinen Zugriff für `CREATE`, `UPDATE` oder `DELETE`. Wenn Sie diese Aktionen zulassen, kann dies zu unbeabsichtigten Änderungen Ihrer Daten führen.

1. Um den Zugriff auf Ihre AWS Glue Data Catalog Datenbanken zu ermöglichen, fügen Sie der Servicerolle die folgenden Berechtigungen zu:

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "VisualEditor0",
               "Effect": "Allow",
               "Action": [
                   "glue:GetDatabases",
                   "glue:GetDatabase",
                   "glue:GetTables",
                   "glue:GetTable",
                   "glue:GetPartitions",
                   "glue:GetPartition",
                   "glue:SearchTables"
               ],
               "Resource": [
                   "arn:aws:glue:us-east-1:123456789012:table/${DatabaseName}/${TableName}",
                   "arn:aws:glue:us-east-1:123456789012:database/${DatabaseName}",
                   "arn:aws:glue:us-east-1:123456789012:catalog"
               ]
           }
       ]
   }
   ```

------

1. Erteilen Sie Ihrer Servicerolle Berechtigungen über AWS Lake Formation (weitere Informationen zu Lake Formation und seiner Beziehung zu Amazon Redshift finden Sie unter [Datenquellen für Redshift](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-source.html)), indem Sie wie folgt vorgehen:

   1. Melden Sie sich bei an AWS-Managementkonsole und öffnen Sie die Lake Formation Formation-Konsole unter [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).

   1. Wählen Sie im linken Navigationsbereich **Datenberechtigungen** aus.

   1. Erteilen Sie der Servicerolle, die Sie für Wissensdatenbanken für Amazon Bedrock verwenden, Berechtigungen.

   1. Erteilen Sie Berechtigungen zum **Beschreiben** und **Auswählen** für Ihre Datenbanken und Tabellen.

1. Abhängig von der Datenquelle, die Sie verwenden AWS Glue Data Catalog, müssen Sie möglicherweise Berechtigungen für den Zugriff auf diese Datenquelle hinzufügen (weitere Informationen finden Sie unter [AWS Glue Abhängigkeit von anderen AWS-Services](https://docs.aws.amazon.com/glue/latest/dg/dependency-on-other-services.html)). Wenn sich Ihre Datenquelle beispielsweise an einem Amazon-S3-Speicherort befindet, müssen Sie der obigen Richtlinie die folgende Anweisung hinzufügen.

   ```
   {
       "Sid": "Statement1",
       "Effect": "Allow",
       "Action": [
           "s3:ListBucket",
           "s3:GetObject"
       ],
       "Resource": [
           "arn:aws:s3:::${BucketName}",
           "arn:aws:s3:::${BucketName}/*"
       ]
   }
   ```

1. (Optional) Wenn Sie AWS KMS die Daten in Amazon S3 oder verschlüsseln AWS Glue Data Catalog, müssen Sie der Rolle Berechtigungen hinzufügen, um die Daten auf dem KMS-Schlüssel zu entschlüsseln.

   ```
   {
       "Action": [
           "kms:Decrypt"
       ],
       "Resource": [
           "arn:aws:kms:${Region}:${Account}:key/{KmsId}",
           "arn:aws:kms:${Region}:${Account}:key/{KmsId}"
       ],
       "Effect": "Allow"
   }
   ```

# Erstellen einer Wissensdatenbank durch Herstellen einer Verbindung mit einem strukturierten Datenspeicher
<a name="knowledge-base-structured-create"></a>

Zum Verbinden einer Wissensdatenbank mit einem strukturierten Datenspeicher geben Sie die folgenden Komponenten an:
+ 

**Konfiguration der Abfrage-Engine**  
Hierbei handelt es sich um die Konfiguration für den Computing-Service, der die generierten SQL-Abfragen ausführt. Die Abfrage-Engine wird eingesetzt, um Benutzerabfragen in natürlicher Sprache in SQL-Abfragen zu konvertieren, die zum Extrahieren von Daten aus Ihrem Datenspeicher verwendet werden können. Sie können Amazon Redshift als Abfrage-Engine auswählen. Bei der Auswahl dieser Konfiguration müssen Sie Folgendes angeben:
  + Die Metadaten der Computing-Verbindung wie die Cluster-ID oder der Arbeitsgruppen-ARN, je nach ausgewählter Abfrage-Engine.
  + Die Authentifizierungsmethode für die Verwendung der Abfrage-Engine. Dabei kann es sich um eine IAM-Dienstrolle mit den entsprechenden Berechtigungen, einen Datenbankbenutzer der Abfrage-Engine oder einen AWS Secrets Manager geheimen Schlüssel handeln, der mit Ihren Datenbankanmeldedaten verknüpft ist.
+ 

**Speicherkonfiguration**  
Dies ist die Konfiguration für den Datenspeicher, der Ihre Daten enthält. Sie können eine Verbindung zu Amazon Redshift Provisioned oder Amazon Redshift Serverless herstellen und Amazon Redshift oder AWS Glue Data Catalog als Ihren Datenspeicher verwenden.
+ 

**(Optional) Abfragekonfigurationen**  
Sie können optionale Abfragekonfigurationen verwenden, um die Korrektheit der SQL-Generierung zu verbessern:
  + **Maximale Abfragezeit** – Die Zeitspanne, nach der die Abfrage das Zeitlimit überschreitet
  + **Beschreibungen** – Stellt Metadaten oder zusätzliche Informationen zu Tabellen oder Spalten bereit. Sie können Beschreibungen der Tabellen oder Spalten, Nutzungshinweise oder zusätzliche Attribute hinzufügen. Die von Ihnen hinzugefügten Beschreibungen können die Generierung von SQL-Abfragen verbessern, indem sie zusätzlichen Kontext und Informationen zur Struktur der Tabellen oder Spalten bereitstellen.
  + **Einschlüsse und Ausschlüsse** – Gibt eine Gruppe von Tabellen oder Spalten an, die bei der SQL-Generierung ein- oder ausgeschlossen werden sollen. Dieses Feld ist wichtig, wenn Sie den Umfang von SQL-Abfragen auf eine definierte Teilmenge verfügbarer Tabellen oder Spalten beschränken möchten. Diese Option kann dazu beitragen, den Generierungsprozess zu optimieren, indem unnötige Tabellen- oder Spaltenverweise reduziert werden.

    Wenn Sie Einschlüsse angeben, werden alle anderen Tabellen und Spalten ignoriert. Wenn Sie Ausschlüsse angeben, werden die von Ihnen angegebenen Tabellen und Spalten ignoriert.
**Anmerkung**  
Ein- und Ausschlüsse sind kein Ersatz für den Integritätsschutz und dienen lediglich der Verbesserung der Modellgenauigkeit.
  + **Kuratierte Abfragen** – Eine Reihe vordefinierter Fragen- und Antwortbeispiele. Fragen werden als Abfragen in natürlicher Sprache (NLQ) geschrieben und die Antworten sind die entsprechenden SQL-Abfragen. Diese Beispiele unterstützen den SQL-Generierungsprozess, indem sie Beispiele für die Arten von Abfragen bereitstellen, die generiert werden sollten. Sie dienen als Referenzpunkte, um die Korrektheit und Relevanz der Ausgaben generativer SQL zu verbessern.

Erweitern Sie den Abschnitt, der Ihrem Anwendungsfall entspricht:

## Verwenden der Konsole
<a name="knowledge-base-structured-create-console"></a>

Gehen Sie wie folgt vor, um mithilfe von eine Verbindung zu einem strukturierten Datenspeicher herzustellen: AWS-Managementkonsole

1. Melden Sie sich bei der AWS-Managementkonsole mit einer IAM-Identität an, die berechtigt ist, die Amazon Bedrock-Konsole zu verwenden. Öffnen Sie dann die Amazon Bedrock-Konsole unter [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).

1. Wählen Sie im linken Navigationsbereich **Wissensdatenbank** aus.

1. Wählen Sie im Abschnitt **Wissensdatenbanken** die Option **Erstellen** und dann **Wissensdatenbank mit strukturiertem Datenspeicher** aus.

1. Richten Sie die folgenden Details für die Wissensdatenbank ein:

   1. (Optional) Ändern Sie den Standardnamen und geben Sie eine Beschreibung für Ihre Wissensdatenbank ein.

   1. Wählen Sie die Abfrage-Engine aus, die zum Abrufen von Daten aus Ihrem Datenspeicher verwendet werden soll.

   1. Wählen Sie eine IAM-Servicerolle mit den entsprechenden Berechtigungen aus, um diese Wissensdatenbank zu erstellen und zu verwalten. Sie können die Servicerolle von Amazon Bedrock erstellen lassen oder eine benutzerdefinierte Rolle auswählen, die Sie angelegt haben. Weitere Informationen zum Erstellen einer Rolle finden Sie unter [Einrichten Ihrer Abfrage-Engine und der Berechtigungen zum Erstellen einer Wissensdatenbank mit strukturiertem Datenspeicher](knowledge-base-prereq-structured.md).

   1. (Optional) Fügen Sie Tags hinzu, die Ihrer Wissensdatenbank zugeordnet werden sollen. Weitere Informationen finden Sie unter [Markieren von Amazon-Bedrock-Ressourcen](tagging.md).

   1. Wählen Sie **Weiter** aus.

1. Konfigurieren Sie Ihre Abfrage-Engine:

   1. Wählen Sie den Service aus, in dem Sie einen Cluster oder eine Arbeitsgruppe erstellt haben. Wählen Sie anschließend den Cluster oder die Arbeitsgruppe aus, der bzw. die verwendet werden soll.

   1. Wählen Sie die Authentifizierungsmethode aus und geben Sie Werte in die erforderlichen Felder ein.

   1. Wählen Sie den Datenspeicher aus, in dem Ihre Metadaten gespeichert werden sollen. Wählen Sie dann den Namen Ihrer Datenbank aus oder geben Sie ihn ein.

   1. (Optional) Ändern Sie die Abfragekonfigurationen nach Bedarf. Weitere Informationen zu den verschiedenen Konfigurationen finden Sie am Anfang dieses Themas.

   1. Wählen Sie **Weiter** aus.

1. Überprüfen Sie Ihre Wissensdatenbank-Konfigurationen und bearbeiten Sie die Abschnitte nach Bedarf. Bestätigen Sie den Vorgang, um Ihre Wissensdatenbank zu erstellen.

## Verwenden der API
<a name="knowledge-base-structured-create-api"></a>

Um mithilfe der Amazon Bedrock API eine Verbindung zu einem strukturierten Datenspeicher herzustellen, senden Sie eine [CreateKnowledgeBase](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateKnowledgeBase.html)Anfrage mit einem [Build-Time-Endpunkt Agents for Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) mit dem folgenden allgemeinen Anfragetext:

```
{
    "name": "string",
    "roleArn": "string",
    "knowledgeBaseConfiguration": {
        "type": "SQL",
        "sqlKnowledgeBaseConfiguration": [SqlKnowledgeBaseConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_SqlKnowledgeBaseConfiguration.html)
    },
    "description": "string",
    "clientToken": "string",
    "tags": {
        "string": "string"
    }
}
```

Die folgenden Felder sind erforderlich.


****  

| Feld | Grundlegende Beschreibung | 
| --- | --- | 
| Name | Ein Name für die Wissensdatenbank | 
| roleArn | Eine [Wissensdatenbank-Servicerolle](kb-permissions.md) mit den entsprechenden Berechtigungen. Sie können die Konsole für das automatische Erstellen einer Servicerolle mit den entsprechenden Berechtigungen verwenden. | 
| knowledgeBaseConfiguration | Enthält Konfigurationen für die Wissensdatenbank. Geben Sie bei einer strukturierten Datenbank als type SQL an und schließen Sie das Feld sqlKnowledgeBaseConfiguration ein. | 

Die folgenden Felder sind optional.


****  

| Feld | Verwenden Sie | 
| --- | --- | 
| description | Hiermit fügen Sie eine Beschreibung für die Wissensdatenbank hinzu. | 
| clientToken | Zur Sicherstellung, dass die API-Anfrage nur einmal durchgeführt wird. Weitere Informationen finden Sie unter [Sicherstellen von Idempotenz](https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html). | 
| tags | So ordnen Sie Tags zu einem Flow hinzu. Weitere Informationen finden Sie unter [Markieren von Amazon-Bedrock-Ressourcen](tagging.md). | 

Der Wert `SQLKnowledgeBaseConfiguration` hängt von der von Ihnen verwendeten Abfrage-Engine ab. Geben Sie für Amazon Redshift das `type` Feld als an `REDSHIFT` und schließen Sie das `redshiftConfiguration` Feld ein, das a zugeordnet ist [RedshiftConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftConfiguration.html). Für die [RedshiftConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftConfiguration.html)konfigurieren Sie die folgenden Felder:

### queryEngineConfiguration
<a name="w2aac28c10c27c15b9b3c17b1"></a>

Sie können die folgenden Arten von Abfrage-Engines konfigurieren:

#### Amazon Redshift Provisioned
<a name="w2aac28c10c27c15b9b3c17b1b5b1"></a>

Wenn Ihre Amazon Redshift Redshift-Datenbanken auf dedizierten Rechenknoten bereitgestellt werden, sollte der Wert des `queryEngineConfiguration` Felds a [RedshiftQueryEngineConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftQueryEngineConfiguration.html)im folgenden Format sein:

```
{
    "type": "PROVISIONED",
    "provisionedConfiguration": {
        "clusterIdentifier": "string",
        "authConfiguration": [RedshiftProvisionedAuthConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftProvisionedAuthConfiguration.html)
    },
}
```

Geben Sie die ID des Clusters in das Feld `clusterIdentifier` ein. Das [RedshiftProvisionedAuthConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftProvisionedAuthConfiguration.html)hängt von der Art der Autorisierung ab, die Sie verwenden. Wählen Sie die Registerkarte aus, die Ihrer Autorisierungsmethode entspricht:

------
#### [ IAM role ]

Wenn Sie die Autorisierung mit Ihrer IAM-Rolle vornehmen, müssen Sie in der [RedshiftProvisionedAuthConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftProvisionedAuthConfiguration.html) nur `IAM` als Typ ohne zusätzliche Felder angeben.

```
{
    "type": "IAM"
}
```

------
#### [ Temporary credentials user name ]

Wenn Sie die Autorisierung mit dem Datenbankbenutzernamen durchführen, legen Sie für `type` `USERNAME` fest und geben Sie den Benutzernamen in das Feld `databaseUser` in der `RedshiftProvisionedAuthConfig` an:

```
{
    "type": "USERNAME",
    "databaseUser": "string"
}
```

------
#### [ AWS Secrets Manager ]

Wenn Sie mit autorisieren AWS Secrets Manager, geben Sie `type` as `USERNAME_PASSWORD` und den ARN des Geheimnisses in das `usernamePasswordSecretArn` Feld ein: `RedshiftProvisionedAuthConfig`

```
{
    "type": "USERNAME_PASSWORD",
    "usernamePasswordSecretArn": "string"
}
```

------

#### Amazon Redshift Serverless
<a name="w2aac28c10c27c15b9b3c17b1b5b3"></a>

Wenn Sie Amazon Redshift Serverless verwenden, sollte der Wert des `queryConfiguration` Felds a [RedshiftQueryEngineConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftQueryEngineConfiguration.html)im folgenden Format sein:

```
{
    "type": "SERVERLESS",
    "serverlessConfiguration": {
        "workgroupArn": "string",
        "authConfiguration": 
    }
}
```

Geben Sie den ARN Ihrer Arbeitsgruppe in das Feld `workgroupArn` ein. Das [RedshiftServerlessAuthConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftServerlessAuthConfiguration.html)hängt von der Art der Autorisierung ab, die Sie verwenden. Wählen Sie die Registerkarte aus, die Ihrer Autorisierungsmethode entspricht:

------
#### [ IAM role ]

Wenn Sie die Autorisierung mit Ihrer IAM-Rolle vornehmen, müssen Sie in der `RedshiftServerlessAuthConfiguration` nur `IAM` als Typ ohne zusätzliche Felder angeben.

```
{
    "type": "IAM"
}
```

------
#### [ AWS Secrets Manager ]

Wenn Sie mit autorisieren AWS Secrets Manager, geben Sie `type` as `USERNAME_PASSWORD` und den ARN des Geheimnisses in das `usernamePasswordSecretArn` Feld ein: `RedshiftServerlessAuthConfiguration`

```
{
    "type": "USERNAME_PASSWORD",
    "usernamePasswordSecretArn": "string"
}
```

------

### storageConfigurations
<a name="w2aac28c10c27c15b9b3c17b3"></a>

Dieses Feld ist einem Array zugeordnet, das ein einzelnes Feld enthält [RedshiftQueryEngineStorageConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftQueryEngineStorageConfiguration.html), dessen Format davon abhängt, wo Ihre Daten gespeichert sind.

#### AWS Glue Data Catalog
<a name="w2aac28c10c27c15b9b3c17b3b5b1"></a>

Wenn Ihre Daten in gespeichert sind AWS Glue Data Catalog, `RedshiftQueryEngineStorageConfiguration` sollten sie das folgende Format haben:

```
{
    "type": "AWS_DATA_CATALOG",
    "awsDataCatalogConfiguration": {
        "tableNames": ["string"]
    }
}
```

Fügen Sie den Namen jeder Tabelle, mit der Sie Ihre Wissensdatenbank verbinden möchten, in das Array ein, dem `tableNames` zugeordnet ist.

**Anmerkung**  
Geben Sie Tabellennamen in dem unter [Datenbankübergreifende Abfragen](https://docs.aws.amazon.com/redshift/latest/dg/cross-database-overview.html) (`${databaseName}.${tableName}`) beschriebenen Muster ein. Sie können alle Tabellen einbeziehen, indem Sie `${databaseName.*}` angeben.

#### Amazon-Redshift-Datenbanken
<a name="w2aac28c10c27c15b9b3c17b3b5b3"></a>

Wenn Ihre Daten in einer Amazon-Redshift-Datenbank gespeichert sind, sollte die `RedshiftQueryEngineStorageConfiguration` das folgende Format haben:

```
{
    "type": "string",
    "redshiftConfiguration": {
        "databaseName": "string"
    }
}
```

Geben Sie den Namen Ihrer Amazon-Redshift-Datenbank in das Feld `databaseName` ein.

**Anmerkung**  
Geben Sie Tabellennamen in dem unter [Datenbankübergreifende Abfragen](https://docs.aws.amazon.com/redshift/latest/dg/cross-database-overview.html) (`${databaseName}.${tableName}`) beschriebenen Muster ein. Sie können alle Tabellen einbeziehen, indem Sie `${databaseName.*}` angeben.

Wenn Ihre Datenbank über Amazon SageMaker AI Lakehouse bereitgestellt wird, hat der Datenbankname das folgende Format*\$1\$1db\$1@\$1\$1schema\$1*.

### queryGenerationConfiguration
<a name="w2aac28c10c27c15b9b3c17b5"></a>

Dieses Feld entspricht dem Folgenden [QueryGenerationConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationConfiguration.html), mit dem Sie konfigurieren können, wie Ihre Daten abgefragt werden:

```
{
    "executionTimeoutSeconds": number,
    "generationContext": {
        "tables": [
            {
                "name": "string",
                "description": "string",
                "inclusion": "string",
                "columns": [
                    {
                        "name": "string",
                        "description": "string",
                        "inclusion": "string"
                    },
                    ...
                ]
            },
            ...
        ],
        "curatedQueries": [
            {
                "naturalLanguage": "string",
                "sql": "string"
            },
            ...
        ]
    }
}
```

Wenn Sie möchten, dass für die Abfrage ein Timeout ausgeführt wird, geben Sie im Feld `executionTimeoutSeconds` die Dauer des Timeouts in Sekunden an.

Das `generationContext` Feld ist einem [QueryGenerationContext](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationContext.html)Objekt zugeordnet, in dem Sie beliebig viele der folgenden Optionen konfigurieren können.

**Wichtig**  
Wenn Sie einen Generierungskontext einbeziehen, versucht die Abfrage-Engine so gut wie möglich, ihn bei der SQL-Generierung anzuwenden. Der Generierungskontext ist nicht deterministisch und dient nur der Verbesserung der Modellgenauigkeit. Wenn Sie die Genauigkeit sicherstellen möchten, überprüfen Sie die generierten SQL-Abfragen.

Erweitern Sie die folgenden Abschnitte, um Informationen zu Generierungskontexten, die Sie einbeziehen können, zu erhalten:

#### Hinzufügen von Beschreibungen für Tabellen oder Spalten in der Datenbank
<a name="w2aac28c10c27c15b9b3c17b5c15b1"></a>

Zur Verbesserung der Genauigkeit der SQL-Generierung für Datenbankabfragen können Sie eine Beschreibung für die Tabelle oder Spalte angeben, die mehr Kontext bietet als ein kurzer Tabellen- oder Spaltenname. Sie haben die folgenden Möglichkeiten:
+ Um eine Beschreibung für eine Tabelle hinzuzufügen, fügen Sie ein [QueryGenerationTable](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationTable.html)Objekt in das `tables` Array ein. Geben Sie in diesem Objekt den Namen der Tabelle im Feld `name` und eine Beschreibung im Feld `description` an, wie im folgenden Beispiel gezeigt:

  ```
  {
      "name": "database.schema.tableA",
      "description": "Description for Table A"
  }
  ```
+ Um eine Beschreibung für eine Spalte hinzuzufügen, fügen Sie ein [QueryGenerationTable](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationTable.html)Objekt in das `tables` Array ein. Geben Sie in diesem Objekt den Namen der Tabelle im `name` Feld an und schließen Sie das `columns` Feld ein, das einem Array von zugeordnet ist [QueryGenerationColumn](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationColumn.html). Geben Sie in einem `QueryGenerationColumn`-Objekt den Namen der Tabelle im Feld `name` und eine Beschreibung im Feld `description` an, wie im folgenden Beispiel gezeigt:

  ```
  {
      "name": "database.schema.tableA",
      "columns": [
          {
              "name": "Column A",
              "description": "Description for Column A"
          }
      ]
  }
  ```
+ Sie können eine Beschreibung sowohl für eine Tabelle als auch für eine Spalte hinzufügen, wie im folgenden Beispiel gezeigt:

  ```
  {
      "name": "database.schema.tableA",
      "description": "Description for Table A",
      "columns": [
          {
              "name": "columnA",
              "description": "Description for Column A"
          }
      ]
  }
  ```
**Anmerkung**  
Geben Sie Tabellen- und Spaltennamen in dem unter [Datenbankübergreifende Abfragen](https://docs.aws.amazon.com/redshift/latest/dg/cross-database-overview.html) beschriebenen Muster ein. Wenn sich Ihre Datenbank in befindet AWS Glue Data Catalog, ist das Format`awsdatacatalog.gluedatabase.table`.

#### Ein- oder Ausschließen von Tabellen oder Spalten in die bzw. aus der Datenbank
<a name="w2aac28c10c27c15b9b3c17b5c15b3"></a>

Mithilfe des `inclusion` Felds in den [QueryGenerationColumn](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationColumn.html)Objekten und können Sie Tabellen oder Spalten vorschlagen, die beim Generieren von SQL ein [QueryGenerationTable](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationTable.html)- oder ausgeschlossen werden sollen. Sie können einen der folgenden Werte im Feld `inclusion` angeben:
+ INCLUDE – Nur die von Ihnen angegebenen Tabellen oder Spalten werden bei der SQL-Generierung als Kontext eingeschlossen.
+ EXCLUDE – Die von Ihnen angegebenen Tabellen oder Spalten werden bei der SQL-Generierung als Kontext ausgeschlossen.

Sie haben folgende Möglichkeiten, um anzugeben, ob Tabellen oder Spalten ein- oder ausgeschlossen werden sollen:
+ Um eine Tabelle ein- oder auszuschließen, schließen Sie ein [QueryGenerationTable](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationTable.html)Objekt in das `tables` Array ein. Geben Sie in diesem Objekt den Namen der Tabelle im Feld `name` und die Angabe, ob die Tabelle ein- oder ausgeschlossen werden soll, im Feld `inclusion` an, wie im folgenden Beispiel gezeigt:

  ```
  {
      "name": "database.schema.tableA",
      "inclusion": "EXCLUDE"
  }
  ```

  Die Abfrage-Engine fügt dem zusätzlichen Kontext für die SQL-Generierung `Table A` nicht hinzu.
+ Um eine Spalte ein- oder auszuschließen, schließen Sie ein [QueryGenerationTable](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationTable.html)Objekt in das `tables` Array ein. Geben Sie in diesem Objekt den Namen der Tabelle im `name` Feld an und schließen Sie das `columns` Feld ein, das einem Array von zugeordnet ist [QueryGenerationColumn](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationColumn.html). Geben Sie in einem `QueryGenerationColumn`-Objekt den Namen der Spalte im Feld `name` und die Angabe, ob die Spalte ein- oder ausgeschlossen werden soll, im Feld `inclusion` an, wie im folgenden Beispiel gezeigt:

  ```
  {
      "name": "database.schema.tableA",
      "columns": [
          {
              "name": "database.schema.tableA.columnA",
              "inclusion": "EXCLUDE"
          }
      ]
  }
  ```

  Die SQL-Generierung ignoriert `Column A` in `Table A` in dem Kontext, wenn SQL generiert wird.
+ Sie können Tabellen und Spalten kombinieren, wenn Sie Einschlüsse oder Ausschlüsse angeben, wie im folgenden Beispiel gezeigt:

  ```
  {
      "name": "database.schema.tableA",
      "inclusion": "INCLUDE",
      "columns": [
          {
              "name": "database.schema.tableA.columnA",
              "inclusion": "EXCLUDE"
          }
      ]
  }
  ```

  Die SQL-Generierung schließt `Table A` ein, schließt darin jedoch `Column A` aus, wenn Kontext für die SQL-Generierung hinzugefügt wird.

**Wichtig**  
Ausschlüsse für Tabellen und Spalten sind kein Ersatz für den Integritätsschutz. Diese Ein- und Ausschlüsse für Tabellen und Spalten werden als zusätzlicher Kontext für das Modell verwendet, der bei der Generierung von SQL berücksichtigt werden muss.

#### Angeben von Beispielen für Zuordnungen natürlicher Sprache zu SQL-Abfragen für die Abfrage-Engine
<a name="w2aac28c10c27c15b9b3c17b5c15b5"></a>

Um die Genauigkeit einer Abfrageengine bei der Konvertierung von Benutzerabfragen in SQL-Abfragen zu verbessern, können Sie ihr Beispiele in dem `curatedQueries` Feld im [QueryGenerationContext](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationContext.html)Objekt zur Verfügung stellen, das einem Array von [CuratedQuery](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CuratedQuery.html)Objekten zugeordnet ist. Jedes Objekt enthält die folgenden Felder:
+ naturalLanguage – Ein Beispiel für eine Abfrage in natürlicher Sprache
+ sql – Die SQL-Abfrage, die der Abfrage in natürlicher Sprache entspricht

# So synchronisieren Sie Ihren strukturierten Datenspeicher mit Ihrer Amazon-Bedrock-Wissensdatenbank
<a name="kb-data-source-structured-sync-ingest"></a>

Nachdem Sie Ihre Wissensdatenbank mit einem strukturierten Datenspeicher verbunden haben, führen Sie eine Synchronisierung durch, um den Metadaten-Aufnahmeprozess zu starten, damit Daten abgerufen werden können. Die Metadaten ermöglichen Wissensdatenbanken für Amazon Bedrock, Benutzer-Prompts in eine Abfrage für die verbundene Datenbank zu übersetzen.

Wann immer Sie Änderungen an Ihrem Datenbankschema vornehmen, müssen Sie die Änderungen synchronisieren.

Wählen Sie die Registerkarte für Ihre bevorzugte Methode aus, um zu erfahren, wie Sie Ihre Metadaten in Ihre Wissensdatenbank aufnehmen und mit Ihren neuesten Daten synchronisieren, und führen Sie dann die folgenden Schritte aus:

------
#### [ Console ]

**So nehmen Sie Ihre Daten in Ihre Wissensdatenbank auf und synchronisieren sie mit Ihren neuesten Daten**

1. Öffnen Sie die Amazon-Bedrock-Konsole unter [https://console.aws.amazon.com/bedrock/](https://console.aws.amazon.com/bedrock/).

1. Klicken Sie im linken Navigationsbereich auf **Wissensdatenbank** und wählen Sie Ihre Wissensdatenbank aus.

1. Wählen Sie im Abschnitt **Datenquelle** die Option **Synchronisieren** aus, um mit der Metadatenaufnahme zu beginnen. Klicken Sie auf **Stopp**, um eine laufende Datenquellensynchronisierung zu stoppen. Eine Datenquelle muss gerade synchronisiert werden, um die Synchronisierung zu stoppen. Sie können erneut **Synchronisieren** auswählen, um den Rest Ihrer Daten aufzunehmen.

1. Wenn die Datenaufnahme abgeschlossen ist, wird ein grünes Banner angezeigt, wenn sie erfolgreich war.

1. Sie können eine Datenquelle auswählen, um deren **Synchronisierungsverlauf** anzuzeigen. Wählen Sie **Warnungen anzeigen** aus, um zu sehen, warum ein Datenerfassungsauftrag fehlgeschlagen ist.

------
#### [ API ]

Um Ihre Daten in Ihre Wissensdatenbank aufzunehmen und mit Ihren neuesten Daten zu synchronisieren, senden Sie eine [StartIngestionJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_StartIngestionJob.html)-Anfrage an einen [Build-Time-Endpunkt für Agenten für Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt).

Verwenden Sie die in der Antwort zurückgegebene `ingestionJobId` in einer [GetIngestionJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetIngestionJob.html)-Anfrage mit einem [Build-Time-Endpunkt für Agenten für Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt), um den Status des Aufnahmeauftrags nachzuverfolgen.

Sie können Informationen zu allen Aufnahmeaufträgen für eine Datenquelle anzeigen, indem Sie eine [ListIngestionJobs](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListIngestionJobs.html)-Anfrage mit einem [Build-Time-Endpunkt für Agenten für Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) senden.

Um einen Datenerfassungsauftrag zu beenden, der gerade ausgeführt wird, senden Sie eine [StopIngestionJobs](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_StopIngestionJob.html)-Anfrage mit einem [Build-Time-Endpunkt für Agenten für Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Sie können erneut eine `StartIngestionJob`-Anfrage senden, um den Rest Ihrer Daten aufzunehmen, wenn Sie bereit sind.

------

**Wichtig**  
Wenn Sie die für Sie in der Konsole erstellte Servicerolle für Wissensdatenbanken für Amazon Bedrock verwenden und anschließend Ihren Datenspeicher synchronisieren, bevor Sie Ihrer Datenbank Zugriff auf die von Ihnen verwendete Authentifizierungsrolle gewähren, schlägt die Synchronisierung fehl, da dem Benutzer keine Berechtigungen zum Zugriff auf Ihren Datenspeicher erteilt wurden. Informationen zur Erteilung von Zugriffsberechtigungen für eine Rolle, um auf Ihren Datenspeicher zuzugreifen, finden Sie unter [Zulassen, dass die Wissensdatenbank-Servicerolle auf Ihren Datenspeicher zugreift](knowledge-base-prereq-structured.md#knowledge-base-prereq-structured-db-access).