Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Compilazione di una knowledge base mediante connessione a un datastore strutturato
Knowledge Base per Amazon Bedrock consente di effettuare la connessione a datastore strutturati che contengono dati conformi a uno schema predefinito. Esempi di datastore strutturati includono tabelle e database. Knowledge Base per Amazon Bedrock può convertire le query degli utenti in un linguaggio adatto all’estrazione di dati dai datastore strutturati supportati. Possono quindi utilizzare la query convertita per recuperare i dati pertinenti alla query e generare risposte appropriate. Ciò consente di utilizzare direttamente i dati strutturati esistenti senza doverli convertire in un formato diverso o generare query SQL personalizzate.
Dopo aver configurato la knowledge base, è possibile inviare query per recuperare i dati da essa tramite l’operazione [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) o generare risposte dai dati recuperati tramite l’operazione [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). Queste operazioni convertono fondamentalmente le query degli utenti in richieste appropriate per il datastore strutturato collegato alla knowledge base.
È inoltre possibile convertire le query indipendentemente dal recupero dei dati utilizzando l’operazione API [GenerateQuery](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GenerateQuery.html). Questa operazione converte le query in linguaggio naturale in query SQL appropriate all’origine dati interrogata. È possibile utilizzare questa operazione in modo indipendente e inserirla nel flusso di lavoro.
Seleziona un argomento per conoscere i prerequisiti e la procedura per connettere la tua knowledge base a un datastore strutturato.
**Topics**
+ [Configurazione del motore di query e delle autorizzazioni per la creazione di una knowledge base con un datastore strutturato](knowledge-base-prereq-structured.md)
+ [Creazione di una knowledge base connettendola a un datastore strutturato](knowledge-base-structured-create.md)
+ [Sincronizzare il data store strutturato con Knowledge Base per Amazon Bedrock](kb-data-source-structured-sync-ingest.md)
# Configurazione del motore di query e delle autorizzazioni per la creazione di una knowledge base con un datastore strutturato
Questo argomento descrive le autorizzazioni necessarie per connettere la knowledge base a un datastore strutturato. Se prevedi di connettere Knowledge Base per Amazon Bedrock a un datastore strutturato, devi soddisfare i prerequisiti. Per i requisiti generali di autorizzazione da soddisfare, consulta [Configurazione delle autorizzazioni per un utente o un ruolo per creare e gestire le knowledge base](knowledge-base-prereq-permissions-general.md).
**Importante**
L'esecuzione di query SQL arbitrarie può rappresentare un rischio per la sicurezza di qualsiasi Text-to-SQL applicazione. È consigliabile adottare le precauzioni necessarie, ad esempio utilizzare ruoli limitati, database di sola lettura e sandboxing.
Knowledge Base per Amazon Bedrock supporta Amazon Redshift come motore di query per interrogare il tuo datastore. Un motore di query accede ai metadati da un datastore strutturato e li utilizza per generare query SQL. Amazon Redshift è un servizio di data warehouse che utilizza SQL per analizzare dati strutturati in data warehouse, database e data lake.
## Creazione del motore di query Amazon Redshift
Puoi utilizzare Amazon Redshift serverless o Amazon Redshift con provisioning in base al caso d’uso e connetterti a gruppi di lavoro o a cluster per il tuo data warehouse. I dati sottostanti che il motore di Amazon Redshift può interrogare possono essere dati archiviati nativamente in cluster Amazon Redshift o dati che si trovano in modalità predefinita (ad AWS Glue Data Catalog esempio in Amazon S3, tra gli altri).
Se hai già creato un motore di query, puoi ignorare questo prerequisito. Altrimenti, attieniti ai seguenti passaggi per configurare il tuo motore di query Amazon Redshift con provisioning o Amazon Redshift serverless:
**Come configurare un motore di query in Amazon Redshift con provisioning**
1. Segui la procedura riportata in [Fase 1: Creazione di un cluster Amazon Redshift di esempio](https://docs.aws.amazon.com/redshift/latest/gsg/new-user.html#rs-gsg-launch-sample-cluster) nella Guida alle operazioni di base di Amazon Redshift.
1. Annota l’ID cluster.
1. (Opzionale) Per ulteriori informazioni riguardanti snapshot cluster Amazon Redshift allocati, consulta [Cluster Amazon Redshift allocati](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html) nella Guida alla gestione di Amazon Redshift.
**Come configurare un motore di query in Amazon Redshift serverless**
1. Segui solo la procedura di configurazione descritta in [Creazione di un data warehouse con Amazon Redshift serverless](https://docs.aws.amazon.com/redshift/latest/gsg/new-user-serverless.html#serverless-console-resource-creation) nella Guida alle operazioni di base di Amazon Redshift e configuralo con le impostazioni predefinite.
1. Nota l’ARN del gruppo di lavoro.
1. (Opzionale) Per ulteriori informazioni sui gruppi di lavoro Amazon Redshift serverless, consulta [Gruppi di lavoro e namespace](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-workgroup-namespace.html) nella Guida alla gestione di Amazon Redshift.
## Configurazione delle autorizzazioni del motore di query Amazon Redshift
A seconda del motore di query Amazon Redshift che scegli, puoi configurare determinate autorizzazioni. Le autorizzazioni che configuri dipendono dal metodo di autenticazione. La tabella seguente mostra i metodi di autenticazione che possono essere utilizzati per diversi motori di query:
****
| Metodo di autenticazione | Amazon Redshift con provisioning | Amazon Redshift Serverless |
| --- | --- | --- |
| IAM | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/icons/icon-yes.png)Sì | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/icons/icon-yes.png)Sì |
| Nome utente database | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/icons/icon-yes.png)Sì | ![\[Red circular icon with an X symbol, indicating cancellation or denial.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/icons/icon-no.png)No |
| Gestione dei segreti AWS | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/icons/icon-yes.png)Sì | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/icons/icon-yes.png)Sì |
Knowledge Base per Amazon Bedrock utilizza un [ruolo di servizio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) per connettere le knowledge base ai datastore strutturati, recuperare dati da questi datastore e generare query SQL in base alle query degli utenti e alla struttura dei datastore.
**Nota**
Se prevedi di utilizzare il per Console di gestione AWS creare una knowledge base, puoi ignorare questo prerequisito. La console crea un ruolo di servizio di Knowledge Base per Amazon Bedrock con le autorizzazioni appropriate.
Per creare un ruolo di servizio IAM personalizzato con le autorizzazioni appropriate, segui i passaggi in [Creazione di un ruolo per delegare le autorizzazioni a un Servizio AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) e allegare la relazione di attendibilità definita in [Relazione di attendibilità](kb-permissions.md#kb-permissions-trust).
Quindi, aggiungi le autorizzazioni per la knowledge base per accedere al motore di query e ai database di Amazon Redshift. Espandi la sezione applicabile al tuo caso d’uso:
### Il tuo motore di query è Amazon Redshift con provisioning
Allega la seguente policy al ruolo di servizio personalizzato affinché tale ruolo possa accedere ai tuoi dati e generare query utilizzandoli:
------
#### [ 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": "*"
}
]
}
```
------
È inoltre necessario aggiungere le autorizzazioni per consentire al ruolo di servizio di eseguire l’autenticazione al motore di query. Espandi una sezione per visualizzare le autorizzazioni per quel metodo.
------
#### [ IAM ]
Per consentire al tuo ruolo di servizio di eseguire l’autenticazione al motore di query Amazon Redshift con provisioning con IAM, associa la seguente policy al ruolo di servizio personalizzato:
------
#### [ 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 ]
Per eseguire l’autenticazione come un utente del database Amazon Redshift, allega la seguente policy al ruolo di servizio:
------
#### [ 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}"
]
}
]
}
```
------
------
#### [ Gestione dei segreti AWS ]
Per consentire al tuo ruolo di servizio di autenticarsi sul motore di query fornito da Amazon Redshift con Gestione dei segreti AWS un segreto, procedi come segue:
+ Allega al ruolo la policy seguente:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "GetSecretPermissions",
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:${region}:${account}:secret:${secretName}"
]
}
]
}
```
------
### Il tuo motore di query è Amazon Redshift serverless
Le autorizzazioni da allegare dipendono dal metodo di autenticazione utilizzato. Espandi una sezione per visualizzare le autorizzazioni per un metodo.
------
#### [ IAM ]
Per consentire al tuo ruolo di servizio di eseguire l’autenticazione al motore di query Amazon Redshift serverless con IAM, associa la seguente policy al ruolo di servizio personalizzato:
------
#### [ 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"
]
}
]
}
```
------
------
#### [ Gestione dei segreti AWS ]
Per consentire al tuo ruolo di servizio di autenticarsi sul motore di query fornito da Amazon Redshift con Gestione dei segreti AWS un segreto, procedi come segue:
+ Allega al ruolo la policy seguente:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "GetSecretPermissions",
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:${region}:${account}:secret:${secretName}"
]
}
]
}
```
------
## Consenti al ruolo di servizio della knowledge base di accedere al tuo datastore
Assicurati che i tuoi dati siano archiviati in uno dei seguenti [datastore strutturati supportati](knowledge-base-structured-create.md):
+ Amazon Redshift
+ AWS Glue Data Catalog (AWS Lake Formation)
La tabella seguente riassume i metodi di autenticazione disponibili per il motore di query, a seconda del data store in uso:
****
| Metodo di autenticazione | Amazon Redshift | AWS Glue Data Catalog (AWS Lake Formation) |
| --- | --- | --- |
| IAM | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/icons/icon-yes.png)Sì | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/icons/icon-yes.png)Sì |
| Nome utente database | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/icons/icon-yes.png)Sì | ![\[Red circular icon with an X symbol, indicating cancellation or denial.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/icons/icon-no.png)No |
| Gestione dei segreti AWS | ![\[Green circular icon with a white checkmark symbol inside.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/icons/icon-yes.png)Sì | ![\[Red circular icon with an X symbol, indicating cancellation or denial.\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/images/icons/icon-no.png)No |
Per informazioni su come configurare le autorizzazioni per il tuo ruolo di servizio di Knowledge Base per Amazon Bedrock per accedere al datastore e generare query basate su esso, espandi la sezione corrispondente al servizio in cui si trova il datastore:
### Amazon Redshift
Per concedere al ruolo di servizio di Knowledge Base per Amazon Bedrock l’accesso al tuo database Amazon Redshift, utilizza [Amazon Redshift Query Editor v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) ed esegui questi comandi SQL:
1. (Se esegui l'autenticazione con IAM e non è già stato creato un utente per il tuo database) Esegui il comando seguente, che utilizza [CREATE USER per creare un utente](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_USER.html) del database e consentirgli di autenticarsi tramite IAM, sostituendolo *\$1\$1service-role\$1* con il nome del ruolo di servizio Amazon Bedrock Knowledge Bases personalizzato che hai creato:
```
CREATE USER "IAMR:${service-role}" WITH PASSWORD DISABLE;
```
**Importante**
Se utilizzi il ruolo di servizio di Knowledge Base per Amazon Bedrock creato per te nella console e poi [sincronizzi il tuo datastore](kb-data-source-structured-sync-ingest.md) prima di eseguire questa fase, l’utente viene creato, ma la sincronizzazione ha esito negativo perché all’utente non sono state concesse le autorizzazioni per accedere al tuo datastore. Prima della sincronizzazione, devi completare la fase seguente.
1. Concedi a un’identità le autorizzazioni per recuperare informazioni dal tuo database eseguendo il comando [GRANT](https://docs.aws.amazon.com/redshift/latest/dg/r_GRANT.html).
------
#### [ IAM ]
```
GRANT SELECT ON ALL TABLES IN SCHEMA ${schemaName} TO "IAMR:${serviceRole}";
```
------
#### [ Database user ]
```
GRANT SELECT ON ALL TABLES IN SCHEMA ${schemaName} TO "${dbUser}";
```
------
#### [ Gestione dei segreti AWS username ]
```
GRANT SELECT ON ALL TABLES IN SCHEMA ${schemaName} TO "${secretsUsername}";
```
------
**Importante**
Non concedere un accesso `CREATE`, `UPDATE` o `DELETE`. La concessione di queste azioni può comportare una modifica involontaria dei dati.
Per un controllo più preciso sulle tabelle a cui è possibile accedere, puoi sostituire nomi di tabelle `ALL TABLES` specifici con la seguente notazione:. *\$1\$1schemaName\$1* *\$1\$1tableName\$1* Per ulteriori informazioni su questa notazione, consulta la sezione **Oggetti di query** in [Query tra database](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}";
```
------
#### [ Gestione dei segreti AWS username ]
```
GRANT SELECT ON ${schemaName}.${tableName} TO "${secretsUsername}";
```
------
1. Se hai creato un nuovo schema nel database Redshift, esegui il comando seguente per concedere a un’identità le autorizzazioni per il nuovo schema.
```
GRANT USAGE ON SCHEMA ${schemaName} TO "IAMR:${serviceRole}";
```
### AWS Glue Data Catalog
Per concedere al ruolo del servizio Amazon Bedrock Knowledge Bases l'accesso al tuo AWS Glue Data Catalog data store, usa l'[editor di query di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) v2 ed esegui i seguenti comandi SQL:
1. Esegui il comando seguente, che utilizza [CREATE USER](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_USER.html) per creare un utente del database e consentirgli l'autenticazione tramite IAM, sostituendolo *\$1\$1service-role\$1* con il nome del ruolo di servizio Amazon Bedrock Knowledge Bases personalizzato che hai creato:
```
CREATE USER "IAMR:${service-role}" WITH PASSWORD DISABLE;
```
**Importante**
Se utilizzi il ruolo di servizio di Knowledge Base per Amazon Bedrock creato per te nella console e poi [sincronizzi il tuo datastore](kb-data-source-structured-sync-ingest.md) prima di eseguire questa fase, l’utente viene creato, ma la sincronizzazione ha esito negativo perché all’utente non sono state concesse le autorizzazioni per accedere al tuo datastore. Prima della sincronizzazione, devi completare la fase seguente.
1. Concedi a un ruolo di servizio le autorizzazioni per recuperare informazioni dal tuo database eseguendo il comando [GRANT](https://docs.aws.amazon.com/redshift/latest/dg/r_GRANT.html).
```
GRANT USAGE ON DATABASE awsdatacatalog TO "IAMR:${serviceRole}";
```
**Importante**
Non concedere un accesso `CREATE`, `UPDATE` o `DELETE`. La concessione di queste azioni può comportare una modifica involontaria dei dati.
1. Per consentire l'accesso ai tuoi AWS Glue Data Catalog database, assegna le seguenti autorizzazioni al ruolo di servizio:
------
#### [ 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. Concedi le autorizzazioni per il tuo ruolo di servizio tramite AWS Lake Formation (per ulteriori informazioni su Lake Formation e sulla sua relazione con Amazon Redshift, [consulta Fonti di dati per Redshift](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-source.html)) procedendo come segue:
1. Accedi a Console di gestione AWS, e apri la console Lake Formation all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Seleziona **Autorizzazioni dati** nel riquadro di navigazione a sinistra.
1. Concedi le autorizzazioni per il ruolo di servizio che utilizzi per Knowledge Base per Amazon Bedrock.
1. Concedi le autorizzazioni **Describe** e **Select** per i tuoi database e tabelle.
1. A seconda dell'origine dati utilizzata AWS Glue Data Catalog, potrebbe essere necessario aggiungere le autorizzazioni per accedere a tale fonte di dati (per ulteriori informazioni, consulta la sezione [AWS Glue Dipendenza da altro Servizi AWS](https://docs.aws.amazon.com/glue/latest/dg/dependency-on-other-services.html)). Ad esempio, se la tua origine dati si trova in una ubicazione Amazon S3, devi aggiungere la seguente dichiarazione alla policy di cui sopra.
```
{
"Sid": "Statement1",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::${BucketName}",
"arn:aws:s3:::${BucketName}/*"
]
}
```
1. (Facoltativo) Se lo utilizzi AWS KMS per crittografare i dati in Amazon S3 AWS Glue Data Catalog oppure, devi aggiungere le autorizzazioni al ruolo per decrittografare i dati sulla chiave KMS.
```
{
"Action": [
"kms:Decrypt"
],
"Resource": [
"arn:aws:kms:${Region}:${Account}:key/{KmsId}",
"arn:aws:kms:${Region}:${Account}:key/{KmsId}"
],
"Effect": "Allow"
}
```
# Creazione di una knowledge base connettendola a un datastore strutturato
Per connettere una knowledge base a un datastore strutturato, specifica i seguenti componenti:
+
**Configurazione del motore di query**
La configurazione per il servizio di calcolo che eseguirà le query SQL generate. Il motore di query viene utilizzato per convertire le query degli utenti in linguaggio naturale in query SQL che possono essere utilizzate per estrarre dati dal datastore. Puoi scegliere Amazon Redshift come motore di query. Quando scegli questa configurazione, devi specificare:
+ I metadati della connessione di calcolo come l’ID del cluster o l’ARN del gruppo di lavoro a seconda del motore di query scelto.
+ Il metodo di autenticazione per l'utilizzo del motore di query, che può utilizzare un ruolo del servizio IAM con le autorizzazioni appropriate, un utente del database del motore di query o un Gestione dei segreti AWS segreto collegato alle credenziali del database.
+
**Configurazione di archiviazione**
La configurazione per il datastore contenente i tuoi dati. Puoi connetterti ad Amazon Redshift Provisioned o Amazon Redshift Serverless e utilizzare Amazon Redshift o come archivio dati. AWS Glue Data Catalog
+
**(Opzionale) Configurazioni delle query**
È possibile utilizzare configurazioni di query opzionali per migliorare l’accuratezza della generazione di SQL:
+ **Tempo massimo di query**: il periodo di tempo trascorso il quale la query scade.
+ **Descrizioni**: fornisce metadati o informazioni supplementari su tabelle o colonne. Puoi includere descrizioni delle tabelle o delle colonne, note di utilizzo o qualsiasi attributo aggiuntivo. Le descrizioni aggiunte possono migliorare la generazione di query SQL fornendo informazioni e contesto aggiuntivi sulla struttura delle tabelle o delle colonne.
+ **Inclusioni ed esclusioni**: specifica un set di tabelle o colonne da includere o escludere per la generazione SQL. Questo campo è fondamentale se desideri limitare l’ambito delle query SQL a un sottoinsieme definito di tabelle o colonne disponibili. Questa opzione può aiutare a ottimizzare il processo di generazione riducendo i riferimenti a tabelle o colonne non necessari.
Se si specificano le inclusioni, tutte le altre tabelle e colonne vengono ignorate. Se si specificano le esclusioni, le tabelle e le colonne specificate vengono ignorate.
**Nota**
Le inclusioni e le esclusioni non sostituiscono i guardrail e sono destinate esclusivamente a migliorare la precisione del modello.
+ **Query selezionate**: una serie di esempi di domande e risposte predefiniti. Le domande sono scritte come query in linguaggio naturale (NLQ) e le risposte sono le query SQL corrispondenti. Questi esempi aiutano il processo di generazione di SQL fornendo esempi dei tipi di query da generare. Servono come punti di riferimento per migliorare l’accuratezza e la pertinenza degli output di SQL generativo.
Espandi la sezione corrispondente al tuo caso d’uso:
## Eliminare con la console
Per connetterti a un data store strutturato utilizzando il Console di gestione AWS, procedi come segue:
1. Accedi a Console di gestione AWS con un'identità IAM che dispone delle autorizzazioni per utilizzare la console Amazon Bedrock. Quindi, apri la console Amazon Bedrock in [https://console.aws.amazon.com/bedrock.](https://console.aws.amazon.com/bedrock)
1. Nel riquadro di navigazione a sinistra, scegli **Knowledge base**.
1. Nella sezione **Knowledge base**, scegli **Crea**, quindi seleziona **Knowledge base con archivio dati strutturato**.
1. Configura i seguenti dettagli per la knowledge base:
1. (Opzionale) Modifica il nome predefinito e fornisci una descrizione per la tua knowledge base.
1. Seleziona il motore di query da utilizzare per recuperare i dati dal tuo datastore.
1. Scegli un ruolo di servizio IAM con le autorizzazioni appropriate per creare e gestire questa knowledge base. Puoi lasciare che Amazon Bedrock crei il ruolo di servizio oppure puoi scegliere un ruolo personalizzato che hai creato. Per ulteriori informazioni sulla creazione di un ruolo personalizzato, consulta [Configurazione del motore di query e delle autorizzazioni per la creazione di una knowledge base con un datastore strutturato](knowledge-base-prereq-structured.md).
1. (Opzionale) Aggiungi tag da associare alla knowledge base. Per ulteriori informazioni, consulta [Assegnazione di tag alle risorse Amazon Bedrock](tagging.md).
1. Scegli **Next (Successivo)**.
1. Configura il tuo motore di query:
1. Seleziona il servizio in cui hai creato un cluster o un gruppo di lavoro. Scegli il cluster o il gruppo di lavoro da utilizzare.
1. Seleziona il metodo di autenticazione e fornisci i campi necessari.
1. Seleziona il datastore in cui archiviare i metadati. Quindi scegli o immetti il nome del database.
1. (Opzionale) Modifica le configurazioni delle query in base alle esigenze. Fai riferimento alla parte iniziale di questo argomento per ulteriori informazioni sulle diverse configurazioni.
1. Scegli **Next (Successivo)**.
1. Esamina le configurazioni della knowledge base e modifica le sezioni come necessario. Conferma per creare la tua knowledge base.
## Eliminare con l’API
Per connetterti a un data store strutturato utilizzando l'API Amazon Bedrock, invia una [CreateKnowledgeBase](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateKnowledgeBase.html)richiesta a un [endpoint di build Agents for Amazon Bedrock con il seguente](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) corpo di richiesta generale:
```
{
"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"
}
}
```
I seguenti campi sono obbligatori.
****
| Campo | Descrizione di base |
| --- | --- |
| Name | Un nome per la knowledge base |
| roleArn | Un [ruolo di servizio della knowledge base](kb-permissions.md) con autorizzazioni appropriate. È possibile utilizzare la console per creare automaticamente un ruolo di servizio con le autorizzazioni appropriate. |
| knowledgeBaseConfiguration | Contiene le configurazioni per la knowledge base. Per un database strutturato, specifica SQL come type e includi il campo sqlKnowledgeBaseConfiguration. |
I seguenti campi sono opzionali.
****
| Campo | Utilizzo |
| --- | --- |
| description | Per includere una descrizione per la knowledge base. |
| clientToken | Per garantire che la richiesta API venga completata solo una volta. Per ulteriori informazioni, consulta [Garanzia di idempotenza](https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html). |
| tag | Associare tag al flusso. Per ulteriori informazioni, consulta [Assegnazione di tag alle risorse Amazon Bedrock](tagging.md). |
`SQLKnowledgeBaseConfiguration` dipende dal motore di query utilizzato. Per Amazon Redshift, specifica il `type` campo come `REDSHIFT` e includi il `redshiftConfiguration` campo, che corrisponde a un. [RedshiftConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftConfiguration.html) Per il [RedshiftConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftConfiguration.html), configuri i seguenti campi:
### queryEngineConfiguration
Puoi configurare i seguenti tipi di motore di query:
#### Amazon Redshift con provisioning
Se i database Amazon Redshift vengono forniti su nodi di calcolo dedicati, il valore del `queryEngineConfiguration` campo deve essere a [RedshiftQueryEngineConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftQueryEngineConfiguration.html)nel seguente formato:
```
{
"type": "PROVISIONED",
"provisionedConfiguration": {
"clusterIdentifier": "string",
"authConfiguration": [RedshiftProvisionedAuthConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftProvisionedAuthConfiguration.html)
},
}
```
Specifica l’ID del cluster nel campo `clusterIdentifier`. [RedshiftProvisionedAuthConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftProvisionedAuthConfiguration.html)Dipende dal tipo di autorizzazione che stai utilizzando. Seleziona la scheda che corrisponde al tuo metodo di autorizzazione:
------
#### [ IAM role ]
Se autorizzi con il tuo ruolo IAM, devi specificare solo `IAM` come tipo in [RedshiftProvisionedAuthConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftProvisionedAuthConfiguration.html) senza ulteriori campi.
```
{
"type": "IAM"
}
```
------
#### [ Temporary credentials user name ]
Se autorizzi con il nome utente del database, specifica `type` come `USERNAME` e specifica il nome utente nel campo `databaseUser` in `RedshiftProvisionedAuthConfig`:
```
{
"type": "USERNAME",
"databaseUser": "string"
}
```
------
#### [ Gestione dei segreti AWS ]
Se autorizzi con Gestione dei segreti AWS, specifica `type` as `USERNAME_PASSWORD` e specifica l'ARN del segreto `usernamePasswordSecretArn` nel campo in: `RedshiftProvisionedAuthConfig`
```
{
"type": "USERNAME_PASSWORD",
"usernamePasswordSecretArn": "string"
}
```
------
#### Amazon Redshift Serverless
Se utilizzi Amazon Redshift Serverless, il valore del `queryConfiguration` campo deve essere [RedshiftQueryEngineConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftQueryEngineConfiguration.html)nel seguente formato:
```
{
"type": "SERVERLESS",
"serverlessConfiguration": {
"workgroupArn": "string",
"authConfiguration":
}
}
```
Specifica l’ARN del tuo gruppo di lavoro nel campo `workgroupArn`. [RedshiftServerlessAuthConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftServerlessAuthConfiguration.html)Dipende dal tipo di autorizzazione che stai utilizzando. Seleziona la scheda che corrisponde al tuo metodo di autorizzazione:
------
#### [ IAM role ]
Se autorizzi con il tuo ruolo IAM, devi specificare solo `IAM` come tipo in `RedshiftServerlessAuthConfiguration` senza ulteriori campi.
```
{
"type": "IAM"
}
```
------
#### [ Gestione dei segreti AWS ]
Se autorizzi con Gestione dei segreti AWS, specifica `type` as `USERNAME_PASSWORD` e specifica l'ARN del segreto `usernamePasswordSecretArn` nel campo in: `RedshiftServerlessAuthConfiguration`
```
{
"type": "USERNAME_PASSWORD",
"usernamePasswordSecretArn": "string"
}
```
------
### storageConfigurations
Questo campo viene mappato su un array contenente un singolo [RedshiftQueryEngineStorageConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_RedshiftQueryEngineStorageConfiguration.html), il cui formato dipende da dove sono archiviati i dati.
#### AWS Glue Data Catalog
Se i dati sono archiviati in AWS Glue Data Catalog, `RedshiftQueryEngineStorageConfiguration` devono essere nel seguente formato:
```
{
"type": "AWS_DATA_CATALOG",
"awsDataCatalogConfiguration": {
"tableNames": ["string"]
}
}
```
Aggiungi il nome di ogni tabella a cui desideri connettere la tua knowledge base nell’array a cui mappare `tableNames`.
**Nota**
Immetti i nomi delle tabelle nello schema descritto in [Query tra database](https://docs.aws.amazon.com/redshift/latest/dg/cross-database-overview.html) (`${databaseName}.${tableName}`). Puoi includere tutte le tabelle specificando `${databaseName.*}`.
#### Database Amazon Redshift
Se i dati sono archiviati in un database Amazon Redshift, `RedshiftQueryEngineStorageConfiguration` deve essere nel seguente formato:
```
{
"type": "string",
"redshiftConfiguration": {
"databaseName": "string"
}
}
```
Specifica il nome del database Amazon Redshift nel campo `databaseName`.
**Nota**
Immetti i nomi delle tabelle nello schema descritto in [Query tra database](https://docs.aws.amazon.com/redshift/latest/dg/cross-database-overview.html) (`${databaseName}.${tableName}`). Puoi includere tutte le tabelle specificando `${databaseName.*}`.
Se il database è montato tramite Amazon SageMaker AI Lakehouse, il nome del database è nel formato. *\$1\$1db\$1@\$1\$1schema\$1*
### queryGenerationConfiguration
Questo campo corrisponde ai seguenti elementi [QueryGenerationConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationConfiguration.html)che puoi utilizzare per configurare la modalità di interrogazione dei dati:
```
{
"executionTimeoutSeconds": number,
"generationContext": {
"tables": [
{
"name": "string",
"description": "string",
"inclusion": "string",
"columns": [
{
"name": "string",
"description": "string",
"inclusion": "string"
},
...
]
},
...
],
"curatedQueries": [
{
"naturalLanguage": "string",
"sql": "string"
},
...
]
}
}
```
Se desideri che la query scada, specifica la durata del timeout in secondi nel campo `executionTimeoutSeconds`.
Il `generationContext` campo è mappato su un [QueryGenerationContext](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationContext.html)oggetto in cui è possibile configurare tutte le opzioni seguenti necessarie.
**Importante**
Se includi un contesto di generazione, il motore di query fa del suo meglio per applicarlo durante la generazione di SQL. Il contesto di generazione non è deterministico e serve solo a migliorare la precisione del modello. Per garantire l’accuratezza, verifica le query SQL generate.
Per informazioni sui contesti di generazione che puoi includere, espandi le seguenti sezioni:
#### Aggiunta di descrizioni per tabelle o colonne nel database
Per migliorare l’accuratezza della generazione di SQL per l’interrogazione del database, è possibile fornire una descrizione della tabella o della colonna che fornisca un contesto più ampio rispetto a un nome breve di tabella o colonna. Puoi fare quanto segue:
+ Per aggiungere una descrizione per una tabella, includete un [QueryGenerationTable](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationTable.html)oggetto nell'`tables`array. In quell’oggetto, specifica il nome della tabella nel campo `name` e una descrizione nel campo `description`, come nell’esempio seguente:
```
{
"name": "database.schema.tableA",
"description": "Description for Table A"
}
```
+ Per aggiungere una descrizione per una colonna, includete un [QueryGenerationTable](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationTable.html)oggetto nell'`tables`array. In quell'oggetto, specificate il nome della tabella nel `name` campo e includete il `columns` campo, che corrisponde a una matrice di [QueryGenerationColumn](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationColumn.html). Nell’oggetto `QueryGenerationColumn`, specifica il nome della tabella nel campo `name` e una descrizione nel campo `description`, come nell’esempio seguente:
```
{
"name": "database.schema.tableA",
"columns": [
{
"name": "Column A",
"description": "Description for Column A"
}
]
}
```
+ È possibile aggiungere una descrizione sia per una tabella che per una colonna al suo interno, come nell’esempio seguente:
```
{
"name": "database.schema.tableA",
"description": "Description for Table A",
"columns": [
{
"name": "columnA",
"description": "Description for Column A"
}
]
}
```
**Nota**
Immetti i nomi delle tabelle e delle colonne nello schema descritto in [Query tra database](https://docs.aws.amazon.com/redshift/latest/dg/cross-database-overview.html). Se il database è in AWS Glue Data Catalog, il formato è`awsdatacatalog.gluedatabase.table`.
#### Includi o escludi tabelle o colonne nel database
È possibile suggerire tabelle o colonne da includere o escludere durante la generazione di SQL utilizzando il `inclusion` campo negli [QueryGenerationColumn](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationColumn.html)oggetti [QueryGenerationTable](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationTable.html)and. È possibile specificare uno dei seguenti valori nel campo `inclusion`:
+ INCLUDE: solo le tabelle o le colonne specificate vengono incluse come contesto durante la generazione di SQL.
+ EXCLUDE: solo le tabelle o le colonne specificate vengono escluse come contesto durante la generazione di SQL.
È possibile specificare se includere o escludere tabelle o colonne nei seguenti modi:
+ Per includere o escludere una tabella, includete un [QueryGenerationTable](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationTable.html)oggetto nell'`tables`array. In quell’oggetto, specifica il nome della tabella nel campo `name` e se includerlo o escluderlo nel campo `inclusion`, come nell’esempio seguente:
```
{
"name": "database.schema.tableA",
"inclusion": "EXCLUDE"
}
```
Il motore di query non aggiunge `Table A` nel contesto aggiuntivo per la generazione di SQL.
+ Per includere o escludere una colonna, includete un [QueryGenerationTable](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationTable.html)oggetto nell'`tables`array. In quell'oggetto, specificate il nome della tabella nel `name` campo e includete il `columns` campo, che corrisponde a una matrice di [QueryGenerationColumn](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationColumn.html). Nell’oggetto `QueryGenerationColumn`, includi il nome della colonna nel campo `name` e se includerlo o escluderlo nel campo `inclusion`, come nell’esempio seguente:
```
{
"name": "database.schema.tableA",
"columns": [
{
"name": "database.schema.tableA.columnA",
"inclusion": "EXCLUDE"
}
]
}
```
La generazione SQL ignora `Column A` in `Table A` nel contesto durante la generazione di SQL.
+ È possibile combinare tabelle e colonne quando si specificano inclusioni o esclusioni, come nell’esempio seguente:
```
{
"name": "database.schema.tableA",
"inclusion": "INCLUDE",
"columns": [
{
"name": "database.schema.tableA.columnA",
"inclusion": "EXCLUDE"
}
]
}
```
La generazione SQL include `Table A`, ma esclude `Column A` al suo interno quando si aggiunge un contesto per la generazione di SQL.
**Importante**
Le esclusioni di tabelle e colonne non sostituiscono i guardrail. Queste inclusioni ed esclusioni di tabelle e colonne vengono utilizzate come contesto aggiuntivo per il modello da considerare durante la generazione di SQL.
#### Fornisci al motore di query esempi di mappature dal linguaggio naturale alle query SQL.
Per migliorare la precisione di un motore di query nella conversione delle query degli utenti in query SQL, potete fornire degli esempi nel `curatedQueries` campo dell'[QueryGenerationContext](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_QueryGenerationContext.html)oggetto, che corrisponde a una matrice di oggetti. [CuratedQuery](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CuratedQuery.html) Ogni oggetto include i seguenti campi:
+ naturalLanguage: un esempio di query in linguaggio naturale.
+ sql: la query SQL che corrisponde alla query in linguaggio naturale.
# Sincronizzare il data store strutturato con Knowledge Base per Amazon Bedrock
Dopo aver collegato la knowledge base a un data store strutturato, esegui una sincronizzazione per avviare il processo di importazione dei metadati, in modo che i dati possano essere recuperati. I metadati consentono a Knowledge Base per Amazon Bedrock di tradurre i prompt degli utenti in una query per il database connesso.
Ogni volta che apporti modifiche allo schema del database, devi sincronizzarle.
Per sapere come importare i metadati nella knowledge base e sincronizzarli con i dati più recenti, scegli la scheda corrispondente al metodo preferito, quindi segui i passaggi:
------
#### [ Console ]
**Come importare i dati nella knowledge base e sincronizzarli con i dati più recenti**
1. Apri la console Amazon Bedrock all’indirizzo [https://console.aws.amazon.com/bedrock/](https://console.aws.amazon.com/bedrock/).
1. Dal riquadro di navigazione a sinistra, seleziona la tua knowledge base da **Knowledge base**.
1. Nella sezione **Origine dati**, seleziona **Sincronizza** per iniziare il processo di importazione dei metadati. Per interrompere la sincronizzazione di un’origine dati attualmente in corso, seleziona **Interrompi**. Per interrompere la sincronizzazione dell’origine dati, la sincronizzazione dell’origine dati deve essere attualmente in esecuzione. Puoi selezionare nuovamente **Sincronizza** per importare il resto dei tuoi dati.
1. Al termine dell’importazione di dati, se l’operazione è riuscita, viene visualizzato un banner verde di successo.
1. Puoi scegliere un’origine dati per visualizzarne la **cronologia di sincronizzazione**. Seleziona **Visualizza avvisi** per scoprire perché un processo di importazione di dati non è riuscito.
------
#### [ API ]
Per importare i dati nella knowledge base e sincronizzarli con i dati più recenti, invia una richiesta [StartIngestionJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_StartIngestionJob.html) a un [endpoint in fase di compilazione di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt).
Utilizza il `ingestionJobId` restituito nella risposta in una richiesta [GetIngestionJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetIngestionJob.html) a un [endpoint in fase di compilazione di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) per monitorare lo stato del processo di importazione.
Puoi visualizzare le informazioni per tutti i processi di importazione per un’origine dati inviando una richiesta [ListIngestionJobs](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListIngestionJobs.html) a un [endpoint in fase di compilazione di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt).
Per interrompere un processo di importazione dei dati attualmente in esecuzione, invia una richiesta [StopIngestionJobs](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_StopIngestionJob.html) a un [endpoint in fase di compilazione di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Puoi inviare nuovamente una richiesta `StartIngestionJob` per importare il resto dei dati quando è tutto pronto.
------
**Importante**
Se utilizzi il ruolo di servizio di Knowledge Base per Amazon Bedrock creato per te nella console e poi sincronizzi il tuo datastore prima di concedere l’accesso al database al ruolo di autenticazione che utilizzi, la sincronizzazione avrà esito negativo perché all’utente non sono state concesse le autorizzazioni per accedere al tuo datastore. Per informazioni sulla concessione delle autorizzazioni a un ruolo per accedere al tuo datastore, consulta [Consenti al ruolo di servizio della knowledge base di accedere al tuo datastore](knowledge-base-prereq-structured.md#knowledge-base-prereq-structured-db-access).