

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à.

# Nozioni di base
<a name="getting-started"></a>

Questa sezione mostra come creare una fonte di dati e aggiungere i documenti a un Amazon Kendra indice. Vengono fornite istruzioni per la AWS console AWS CLI, un programma Python che utilizza e un programma Java che utilizza il. AWS SDK per Python (Boto3) AWS SDK per Java

**Topics**
+ [Prerequisiti](gs-prerequisites.md)
+ [Guida introduttiva alla Amazon Kendra console](gs-console.md)
+ [Nozioni di base (AWS CLI)](gs-cli.md)
+ [Nozioni di base (AWS SDK per Python (Boto3))](gs-python.md)
+ [Nozioni di base (AWS SDK per Java)](gs-java.md)
+ [Guida introduttiva a un'origine Amazon S3 dati (console)](getting-started-s3.md)
+ [Guida introduttiva a un'origine dati per database MySQL (console)](getting-started-mysql.md)
+ [Guida introduttiva a un'origine di AWS IAM Identity Center identità (console)](getting-started-aws-sso.md)

# Prerequisiti
<a name="gs-prerequisites"></a>

I passaggi seguenti sono i prerequisiti per gli esercizi iniziali. I passaggi mostrano come configurare il tuo account, creare un IAM ruolo che Amazon Kendra autorizzi a effettuare chiamate per tuo conto e indicizzare i documenti da un Amazon S3 bucket. Un bucket S3 viene utilizzato come esempio, ma puoi utilizzare altre fonti di dati che lo supportano. Amazon Kendra Vedi Fonti di [dati](https://docs.aws.amazon.com/kendra/latest/dg/hiw-data-source.html).

## Iscriviti a un Account AWS
<a name="sign-up-for-aws"></a>

Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno.

**Per iscriverti a un Account AWS**

1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup)

1. Segui le istruzioni online.

   Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono.

   Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L’utente root dispone dell’accesso a tutte le risorse e tutti i Servizi AWS nell’account. Come best practice di sicurezza, assegna l’accesso amministrativo a un utente e utilizza solo l’utente root per eseguire [attività che richiedono l’accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**.

## Crea un utente con accesso amministrativo
<a name="create-an-admin"></a>

Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane.

**Proteggi i tuoi Utente root dell'account AWS**

1.  Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password.

   Per informazioni sull’accesso utilizzando un utente root, consulta la pagina [Accedere come utente root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) nella *Guida per l’utente di Accedi ad AWS *.

1. Abilita l’autenticazione a più fattori (MFA) per l’utente root.

   Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*.

**Crea un utente con accesso amministrativo**

1. Abilita il Centro identità IAM.

   Per istruzioni, consulta [Abilitazione del AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l’utente di AWS IAM Identity Center *.

1. Nel Centro identità IAM, assegna l’accesso amministrativo a un utente.

   Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*.

**Accesso come utente amministratore**
+ Per accedere come utente del Centro identità IAM, utilizza l’URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l’utente del Centro identità IAM.

  Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*.

**Assegnazione dell’accesso ad altri utenti**

1. Nel Centro identità IAM, crea un set di autorizzazioni conforme alla best practice per l’applicazione di autorizzazioni con il privilegio minimo.

   Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l’utente di AWS IAM Identity Center *.

1. Assegna al gruppo prima gli utenti e poi l’accesso con autenticazione unica (Single Sign-On).

   Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) nella *Guida per l’utente di AWS IAM Identity Center *.
+ Se utilizzi un bucket S3 contenente documenti da testare Amazon Kendra, crea un bucket S3 nella stessa regione che stai utilizzando. Amazon Kendra Per istruzioni, consulta [Creazione e configurazione di un bucket S3 nella Guida per l'utente](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-configure-bucket.html) di *Amazon Simple Storage Service*.

  Carica i tuoi documenti nel tuo bucket S3. Per istruzioni, consulta [Caricamento, download e gestione di oggetti](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-download-objects.html) nella *Guida per l'utente di Amazon Simple Storage Service*.

  Se utilizzi un'altra fonte di dati, devi disporre di un sito attivo e delle credenziali per connetterti all'origine dati.

Se utilizzi la console per iniziare, inizia con[Guida introduttiva alla Amazon Kendra console](gs-console.md).

## Amazon Kendra risorse: AWS CLI, SDK, console
<a name="gs-prereq-cli-sdk"></a>

Sono necessarie alcune autorizzazioni se utilizzi CLI, SDK o la console.

Per utilizzarlo Amazon Kendra per la CLI, l'SDK o la console, devi disporre delle autorizzazioni necessarie per creare e gestire risorse Amazon Kendra per tuo conto. [A seconda del caso d'uso, queste autorizzazioni includono l'accesso all' Amazon Kendra API stessa, AWS KMS keys se desideri crittografare i dati tramite una directory CMK personalizzata, Identity Center se desideri integrare o creare un'esperienza di AWS IAM Identity Center ricerca.](https://docs.aws.amazon.com/kendra/latest/dg/deploying-search-experience-no-code.html) [Per un elenco completo delle autorizzazioni per diversi casi d'uso, consulta i ruoli.IAM](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html)

Innanzitutto, devi assegnare le seguenti autorizzazioni al tuo utente IAM.

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

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "Stmt1644430853544",
      "Action": [
        "kms:CreateGrant",
        "kms:DescribeKey"
      ],
      "Effect": "Allow",
      "Resource": "*"
    },
    {
      "Sid": "Stmt1644430878150",
      "Action": "kendra:*",
      "Effect": "Allow",
      "Resource": "*"
    },
    {
      "Sid": "Stmt1644430973706",
      "Action": [
        "sso:AssociateProfile",
        "sso:CreateManagedApplicationInstance",
        "sso:DeleteManagedApplicationInstance",
        "sso:DisassociateProfile",
        "sso:GetManagedApplicationInstance",
        "sso:GetProfile",
        "sso:ListDirectoryAssociations",
        "sso:ListProfileAssociations",
        "sso:ListProfiles"
      ],
      "Effect": "Allow",
      "Resource": "*"
    },
    {
      "Sid": "Stmt1644430999558",
      "Action": [
        "sso-directory:DescribeGroup",
        "sso-directory:DescribeGroups",
        "sso-directory:DescribeUser",
        "sso-directory:DescribeUsers"
      ],
      "Effect": "Allow",
      "Resource": "*"
    },
    {
      "Sid": "Stmt1644431025960",
      "Action": [
        "identitystore:DescribeGroup",
        "identitystore:DescribeUser",
        "identitystore:ListGroups",
        "identitystore:ListUsers"
      ],
      "Effect": "Allow",
      "Resource": "*"
    }
  ]
}
```

------

In secondo luogo, se utilizzi la CLI o l'SDK, devi anche creare un IAM ruolo e una policy per l'accesso. Amazon CloudWatch Logs Se si utilizza la console, non è necessario creare un IAM ruolo e una politica a tale scopo. Lo crei come parte della procedura della console.

**Per creare un IAM ruolo e una politica per l' AWS CLI SDK che consentano di accedere Amazon Kendra Amazon CloudWatch Logs a.**

1. Accedi a Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Dal menu a sinistra, scegli **Policies**, quindi scegli **Crea policy**.

1. Scegli **JSON** e sostituisci la politica predefinita con la seguente:

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "cloudwatch:PutMetricData"
               ],
               "Resource": "*",
               "Condition": {
                   "StringEquals": {
                       "cloudwatch:namespace": "AWS/Kendra"
                   }
               }
           },
           {
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogGroups"
               ],
               "Resource": "*"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "logs:CreateLogGroup"
               ],
               "Resource": [
                   "arn:aws:logs:us-east-1:123456789012:log-group:/aws/kendra/*"
               ]
           },
           {
               "Effect": "Allow",
               "Action": [
                   "logs:DescribeLogStreams",
                   "logs:CreateLogStream",
                   "logs:PutLogEvents"
               ],
               "Resource": [
                   "arn:aws:logs:us-east-1:123456789012:log-group:/aws/kendra/*:log-stream:*"
               ]
           }
       ]
   }
   ```

------

1. Scegliere **Esamina policy**.

1. Assegna un nome alla politica "KendraPolicyForGettingStartedIndex" e quindi scegli **Crea politica**.

1. Dal menu a sinistra, scegli **Ruoli**, quindi scegli **Crea ruolo**.

1. Scegli **Un altro AWS account**, quindi digita l'ID del tuo **account in ID account**. Scegli **Successivo: autorizzazioni**.

1. Scegli la politica che hai creato sopra, quindi scegli **Avanti: Tag**

1. Non aggiungere alcun tag. Scegli **Prossimo: Rivedi**.

1. Assegna un nome al ruolo "KendraRoleForGettingStartedIndex" e quindi scegli **Crea ruolo**.

1. Trova il ruolo che hai appena creato. Scegli il nome del ruolo per aprire il riepilogo. Scegli **Relazioni di fiducia**, quindi scegli **Modifica relazione di fiducia**.

1. Sostituisci la relazione di fiducia esistente con la seguente:

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
         {
           "Effect": "Allow",
           "Principal": {
             "Service": "kendra.amazonaws.com"
           },
           "Action": "sts:AssumeRole"
         }
       ]
   }
   ```

------

1. Scegliere **Update trust Policy** (Aggiorna policy di attendibilità).

In terzo luogo, se utilizzi an Amazon S3 per archiviare i tuoi documenti o utilizzi S3 per eseguire dei test Amazon Kendra, devi anche creare un IAM ruolo e una policy per accedere al tuo bucket. Se utilizzi un'altra fonte di dati, consulta i [IAM ruoli per le fonti di dati](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds).

**Per creare un IAM ruolo e una politica che consentano di Amazon Kendra accedere e indicizzare il tuo Amazon S3 bucket.**

1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Dal menu a sinistra, scegli **Policies**, quindi scegli **Crea policy**.

1. Scegli **JSON** e sostituisci la politica predefinita con la seguente:

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Action": [
                   "s3:GetObject"
               ],
               "Resource": [
                   "arn:aws:s3:::bucket name/*"
               ],
               "Effect": "Allow"
           },
           {
               "Action": [
                   "s3:ListBucket"
               ],
               "Resource": [
                   "arn:aws:s3:::bucket name"
               ],
               "Effect": "Allow"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "kendra:BatchPutDocument",
                   "kendra:BatchDeleteDocument"
               ],
               "Resource": "arn:aws:kendra:us-east-1:123456789012:index/*"
           }
       ]
   }
   ```

------

1. Scegliere **Esamina policy**.

1. Assegna un nome alla politica KendraPolicyForGettingStartedDataSource "" e quindi scegli **Crea politica**.

1. Dal menu a sinistra, scegli **Ruoli**, quindi scegli **Crea ruolo**.

1. Scegli **Un altro AWS account**, quindi digita l'ID del tuo **account in ID account**. Scegli **Successivo: autorizzazioni**.

1. Scegli la politica che hai creato sopra, quindi scegli **Avanti: Tag**

1. Non aggiungere alcun tag. Scegli **Prossimo: Rivedi**.

1. Assegna un nome al ruolo KendraRoleForGettingStartedDataSource "", quindi scegli **Crea ruolo**.

1. Trova il ruolo che hai appena creato. Scegli il nome del ruolo per aprire il riepilogo. Scegli **Relazioni di fiducia**, quindi scegli **Modifica relazione di fiducia**.

1. Sostituisci la relazione di fiducia esistente con la seguente:

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
         {
           "Effect": "Allow",
           "Principal": {
             "Service": "kendra.amazonaws.com"
           },
           "Action": "sts:AssumeRole"
         }
       ]
   }
   ```

------

1. Scegliere **Update trust Policy** (Aggiorna policy di attendibilità).

A seconda di come desideri utilizzare l' Amazon Kendra API, esegui una delle seguenti operazioni.
+ [Nozioni di base (AWS CLI)](gs-cli.md)
+ [Nozioni di base (AWS SDK per Java)](gs-java.md)
+ [Nozioni di base (AWS SDK per Python (Boto3))](gs-python.md)

# Guida introduttiva alla Amazon Kendra console
<a name="gs-console"></a>

Le procedure seguenti mostrano come creare e testare un Amazon Kendra indice utilizzando la AWS console. Nelle procedure si creano un indice e un'origine dati per un indice. Infine, testate il vostro indice effettuando una richiesta di ricerca. 

**Passaggio 1: creare un indice (console)**

1. Accedi alla console di AWS gestione e apri la Amazon Kendra console all'indirizzo [https://console.aws.amazon.com/kendra/](https://console.aws.amazon.com/kendra/).

1. Seleziona **Crea indice** nella sezione **Indici.**

1. Nella pagina **Specificare i dettagli dell'indice**, assegna un nome e una descrizione all'indice.

1. In **IAM Ruolo**, scegli **Crea un nuovo ruolo**, quindi assegna un nome al ruolo. Il IAM ruolo avrà il prefisso "AmazonKendra-».

1. Lascia tutti gli altri campi ai valori predefiniti. Scegli **Next (Successivo)**.

1. **Nella pagina **Configura il controllo dell'accesso utente**, scegli Avanti.**

1. Nella pagina dei **dettagli del provisioning**, scegli **Developer edition**.

1. Scegli **Crea** per creare il tuo indice.

1. Attendi la creazione dell'indice. Amazon Kendra fornisce l'hardware per l'indice. Questa operazione può richiedere del tempo.<a name="gs-data-source"></a>

**Passaggio 2: aggiungere un'origine dati a un indice (console)**

1. Visualizza le [fonti di dati](https://docs.aws.amazon.com/kendra/latest/dg/data-source.html) disponibili a cui Amazon Kendra connetterti e indicizzare i tuoi documenti.

1. Nel riquadro di navigazione, seleziona **Origini dati**, quindi seleziona **Aggiungi origine dati** per l'origine dati scelta.

1. Segui i passaggi per configurare l'origine dati.<a name="gs-search"></a>

**Passaggio 3: Per cercare un indice (console)**

1. Nel riquadro di navigazione, scegli l'opzione per cercare nell'indice.

1. Inserisci un termine di ricerca appropriato per il tuo indice. Vengono **visualizzati i risultati principali** **e i risultati principali del documento**.

# Nozioni di base (AWS CLI)
<a name="gs-cli"></a>

La procedura seguente mostra come creare un Amazon Kendra indice utilizzando AWS CLI. La procedura crea un'origine dati, un indice, ed esegue una query sull'indice.

**Per creare un Amazon Kendra indice (CLI)**

1. Fai il. [Prerequisiti](gs-prerequisites.md)

1. Immettete il seguente comando per creare un indice.

   ```
   aws kendra create-index \
    --name cli-getting-started-index \
    --description "Index for CLI getting started guide." \
    --role-arn arn:aws:iam::account id:role/KendraRoleForGettingStartedIndex
   ```

1.  Amazon Kendra Attendi la creazione dell'indice. Controlla lo stato di avanzamento usando il seguente comando. Quando il campo dello stato è`ACTIVE`, vai al passaggio successivo.

   ```
   aws kendra describe-index \
    --id index id
   ```

1. Al prompt dei comandi, inserisci il seguente comando per creare un'origine dati.

   ```
   aws kendra create-data-source \
    --index-id index id \
    --name data source name \
    --role-arn arn:aws:iam::account id:role/KendraRoleForGettingStartedDataSource \
    --type S3 \
    --configuration '{"S3Configuration":{"BucketName":"S3 bucket name"}}'
   ```

   Se ti connetti alla tua fonte di dati utilizzando uno schema modello, configura lo schema del modello.

   ```
   aws kendra create-data-source \
    --index-id index id \
    --name data source name \
    --role-arn arn:aws:iam::account id:role/KendraRoleForGettingStartedDataSource \
    --type TEMPLATE \
    --configuration '{"TemplateConfiguration":{"Template":{JSON schema}}}'
   ```

1. La creazione dell'origine dati richiederà Amazon Kendra un po' di tempo. Inserisci il seguente comando per verificare lo stato di avanzamento. Quando lo stato è`ACTIVE`, vai al passaggio successivo.

   ```
   aws kendra describe-data-source \
    --id data source ID \
    --index-id index ID
   ```

1. Immettere il seguente comando per sincronizzare la fonte di dati.

   ```
   aws kendra start-data-source-sync-job \
    --id data source ID \
    --index-id index ID
   ```

1. Amazon Kendra indicizzerà la tua fonte di dati. Il tempo necessario dipende dal numero di documenti. È possibile controllare lo stato del processo di sincronizzazione utilizzando il comando seguente. Quando lo stato è`ACTIVE`, vai al passaggio successivo.

   ```
   aws kendra describe-data-source \
    --id data source ID \
    --index-id index ID
   ```

1. Immettete il seguente comando per creare una query.

   ```
   aws kendra query \
    --index-id index ID \
    --query-text "search term"
   ```

   I risultati della ricerca vengono visualizzati in formato JSON.

# Nozioni di base (AWS SDK per Python (Boto3))
<a name="gs-python"></a>

Il seguente programma è un esempio di utilizzo Amazon Kendra in un programma Python. Il programma esegue le seguenti azioni:

1. Crea un nuovo indice utilizzando l'[CreateIndex](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateIndex.html)operazione.

1. Attende il completamento della creazione dell'indice. Utilizza l'[DescribeIndex](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeIndex.html)operazione per monitorare lo stato dell'indice.

1. Una volta che l'indice è attivo, crea una fonte di dati utilizzando l'[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)operazione.

1. Attende il completamento della creazione dell'origine dati. Utilizza l'[DescribeDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeDataSource.html)operazione per monitorare lo stato della fonte di dati.

1. Quando l'origine dati è attiva, sincronizza l'indice con il contenuto dell'origine dati utilizzando l'[StartDataSourceSyncJob](https://docs.aws.amazon.com/kendra/latest/APIReference/API_StartDataSourceSyncJob.html)operazione.

```
import boto3
from botocore.exceptions import ClientError
import pprint
import time

kendra = boto3.client("kendra")

print("Create an index.")

# Provide a name for the index
index_name = "python-getting-started-index"
# Provide an optional decription for the index
description = "Getting started index"
# Provide the IAM role ARN required for indexes
index_role_arn = "arn:aws:iam::${accountId}:role/KendraRoleForGettingStartedIndex"

try:
    index_response = kendra.create_index(
        Description = description,
        Name = index_name,
        RoleArn = index_role_arn
    )

    pprint.pprint(index_response)

    index_id = index_response["Id"]

    print("Wait for Amazon Kendra to create the index.")

    while True:
        # Get the details of the index, such as the status
        index_description = kendra.describe_index(
            Id = index_id
        )
        # When status is not CREATING quit.
        status = index_description["Status"]
        print(" Creating index. Status: "+status)
        time.sleep(60)
        if status != "CREATING":
            break

    print("Create an S3 data source.")
    
    # Provide a name for the data source
    data_source_name = "python-getting-started-data-source"
    # Provide an optional description for the data source
    data_source_description = "Getting started data source."
    # Provide the IAM role ARN required for data sources
    data_source_role_arn = "arn:aws:iam::${accountId}:role/KendraRoleForGettingStartedDataSource"
    # Provide the data source connection information 
    S3_bucket_name = "S3-bucket-name"
    data_source_type = "S3"
    # Configure the data source
    configuration = {"S3Configuration":
        {
            "BucketName": S3_bucket_name
        }
    }
    
    """
    If you connect to your data source using a template schema, 
    configure the template schema
    configuration = {"TemplateConfiguration":
        {
            "Template": {JSON schema}
        }
    }
    """
    
    data_source_response = kendra.create_data_source(
        Name = data_source_name,
        Description = data_source_name,
        RoleArn = data_source_role_arn,
        Type = data_source_type,
        Configuration = configuration,
        IndexId = index_id
    )

    pprint.pprint(data_source_response)

    data_source_id = data_source_response["Id"]

    print("Wait for Amazon Kendra to create the data source.")

    while True:
        # Get the details of the data source, such as the status
        data_source_description = kendra.describe_data_source(
            Id = data_source_id,
            IndexId = index_id
        )
        # If status is not CREATING, then quit
        status = data_source_description["Status"]
        print(" Creating data source. Status: "+status)
        time.sleep(60)
        if status != "CREATING":
            break

    print("Synchronize the data source.")

    sync_response = kendra.start_data_source_sync_job(
        Id = data_source_id,
        IndexId = index_id
    )

    pprint.pprint(sync_response)

    print("Wait for the data source to sync with the index.")

    while True:

        jobs = kendra.list_data_source_sync_jobs(
            Id = data_source_id,
            IndexId = index_id
        )

        # For this example, there should be one job
        status = jobs["History"][0]["Status"]

        print(" Syncing data source. Status: "+status)
        if status != "SYNCING":
            break
        time.sleep(60)

except  ClientError as e:
        print("%s" % e)

print("Program ends.")
```

# Nozioni di base (AWS SDK per Java)
<a name="gs-java"></a>

Il seguente programma è un esempio di utilizzo Amazon Kendra in un programma Java. Il programma esegue le seguenti azioni:

1. Crea un nuovo indice utilizzando l'[CreateIndex](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateIndex.html)operazione.

1. Attende il completamento della creazione dell'indice. Utilizza l'[DescribeIndex](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeIndex.html)operazione per monitorare lo stato dell'indice.

1. Una volta che l'indice è attivo, crea una fonte di dati utilizzando l'[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)operazione.

1. Attende il completamento della creazione dell'origine dati. Utilizza l'[DescribeDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeDataSource.html)operazione per monitorare lo stato della fonte di dati.

1. Quando l'origine dati è attiva, sincronizza l'indice con il contenuto dell'origine dati utilizzando l'[StartDataSourceSyncJob](https://docs.aws.amazon.com/kendra/latest/APIReference/API_StartDataSourceSyncJob.html)operazione.

```
package com.amazonaws.kendra;

import java.util.concurrent.TimeUnit;
import software.amazon.awssdk.services.kendra.KendraClient;
import software.amazon.awssdk.services.kendra.model.CreateDataSourceRequest;
import software.amazon.awssdk.services.kendra.model.CreateDataSourceResponse;
import software.amazon.awssdk.services.kendra.model.CreateIndexRequest;
import software.amazon.awssdk.services.kendra.model.CreateIndexResponse;
import software.amazon.awssdk.services.kendra.model.DataSourceConfiguration;
import software.amazon.awssdk.services.kendra.model.DataSourceStatus;
import software.amazon.awssdk.services.kendra.model.DataSourceSyncJob;
import software.amazon.awssdk.services.kendra.model.DataSourceSyncJobStatus;
import software.amazon.awssdk.services.kendra.model.DataSourceType;
import software.amazon.awssdk.services.kendra.model.DescribeDataSourceRequest;
import software.amazon.awssdk.services.kendra.model.DescribeDataSourceResponse;
import software.amazon.awssdk.services.kendra.model.DescribeIndexRequest;
import software.amazon.awssdk.services.kendra.model.DescribeIndexResponse;
import software.amazon.awssdk.services.kendra.model.IndexStatus;
import software.amazon.awssdk.services.kendra.model.ListDataSourceSyncJobsRequest;
import software.amazon.awssdk.services.kendra.model.ListDataSourceSyncJobsResponse;
import software.amazon.awssdk.services.kendra.model.S3DataSourceConfiguration;
import software.amazon.awssdk.services.kendra.model.StartDataSourceSyncJobRequest;
import software.amazon.awssdk.services.kendra.model.StartDataSourceSyncJobResponse;


public class CreateIndexAndDataSourceExample {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("Create an index");

        String indexDescription = "Getting started index for Kendra";
        String indexName = "java-getting-started-index";
        String indexRoleArn = "arn:aws:iam::<your AWS account ID>:role/<name of an IAM role>";

        System.out.println(String.format("Creating an index named %s", indexName));
        KendraClient kendra = KendraClient.builder().build();

        CreateIndexRequest createIndexRequest = CreateIndexRequest
            .builder()
            .description(indexDescription)
            .name(indexName)
            .roleArn(indexRoleArn)
            .build();
        CreateIndexResponse createIndexResponse = kendra.createIndex(createIndexRequest);
        System.out.println(String.format("Index response %s", createIndexResponse));

        String indexId = createIndexResponse.id();

        System.out.println(String.format("Waiting until the index with index ID %s is created", indexId));
        while (true) {
            DescribeIndexRequest describeIndexRequest = DescribeIndexRequest.builder().id(indexId).build();
            DescribeIndexResponse describeIndexResponse = kendra.describeIndex(describeIndexRequest);
            IndexStatus status = describeIndexResponse.status();
            if (status != IndexStatus.CREATING) {
                break;
            }

            TimeUnit.SECONDS.sleep(60);
        }

        System.out.println("Creating an S3 data source");
        String dataSourceName = "java-getting-started-data-source";
        String dataSourceDescription = "Getting started data source";
        String s3BucketName = "amzn-s3-demo-bucket";
        String dataSourceRoleArn = "arn:aws:iam::<your AWS account ID>:role/<name of an IAM role>";

        CreateDataSourceRequest createDataSourceRequest = CreateDataSourceRequest
            .builder()
            .indexId(indexId)
            .name(dataSourceName)
            .description(dataSourceDescription)
            .roleArn(dataSourceRoleArn)
            .type(DataSourceType.S3)
            .configuration(
                DataSourceConfiguration
                    .builder()
                    .s3Configuration(
                        S3DataSourceConfiguration
                            .builder()
                            .bucketName(s3BucketName)
                            .build()
                    ).build()
            ).build();

        CreateDataSourceResponse createDataSourceResponse = kendra.createDataSource(createDataSourceRequest);
        System.out.println(String.format("Response of creating data source: %s", createDataSourceResponse));

        String dataSourceId = createDataSourceResponse.id();
        System.out.println(String.format("Waiting for Kendra to create the data source %s", dataSourceId));
        DescribeDataSourceRequest describeDataSourceRequest = DescribeDataSourceRequest
            .builder()
            .indexId(indexId)
            .id(dataSourceId)
            .build();

        while (true) {
            DescribeDataSourceResponse describeDataSourceResponse = kendra.describeDataSource(describeDataSourceRequest);

            DataSourceStatus status = describeDataSourceResponse.status();
            System.out.println(String.format("Creating data source. Status: %s", status));
            if (status != DataSourceStatus.CREATING) {
                break;
            }

            TimeUnit.SECONDS.sleep(60);
        }

        System.out.println(String.format("Synchronize the data source %s", dataSourceId));
        StartDataSourceSyncJobRequest startDataSourceSyncJobRequest = StartDataSourceSyncJobRequest
            .builder()
            .indexId(indexId)
            .id(dataSourceId)
            .build();
        StartDataSourceSyncJobResponse startDataSourceSyncJobResponse = kendra.startDataSourceSyncJob(startDataSourceSyncJobRequest);
        System.out.println(String.format("Waiting for the data source to sync with the index %s for execution ID %s", indexId, startDataSourceSyncJobResponse.executionId()));

        // For this particular list, there should be just one job
        ListDataSourceSyncJobsRequest listDataSourceSyncJobsRequest = ListDataSourceSyncJobsRequest
            .builder()
            .indexId(indexId)
            .id(dataSourceId)
            .build();

        while (true) {
            ListDataSourceSyncJobsResponse listDataSourceSyncJobsResponse = kendra.listDataSourceSyncJobs(listDataSourceSyncJobsRequest);
            DataSourceSyncJob job = listDataSourceSyncJobsResponse.history().get(0);
            System.out.println(String.format("Syncing data source. Status: %s", job.status()));

            if (job.status() != DataSourceSyncJobStatus.SYNCING) {
                break;
            }

            TimeUnit.SECONDS.sleep(60);

        }

        System.out.println("Index setup is complete");
    }
}
```

# Guida introduttiva a un'origine Amazon S3 dati (console)
<a name="getting-started-s3"></a>

Puoi usare la Amazon Kendra console per iniziare a usare un Amazon S3 bucket come archivio dati. Quando usi la console, specifichi tutte le informazioni di connessione necessarie per indicizzare il contenuto del bucket. Per ulteriori informazioni, consulta [Amazon S3](data-source-s3.md).

Utilizza la seguente procedura per creare un'origine dati di base del bucket S3 utilizzando la configurazione predefinita. La procedura presuppone che tu abbia creato un indice seguendo i passaggi del passaggio 1 di. [Guida introduttiva alla Amazon Kendra console](gs-console.md)

**Per creare un'origine dati con bucket S3 utilizzando la console Amazon Kendra**

1. [Accedi a Console di gestione AWS e apri la Amazon Kendra console a casahttps://console.aws.amazon.com/kendra/.](https://console.aws.amazon.com/kendra/home)

1. Dall'elenco degli indici, scegli l'indice a cui desideri aggiungere l'origine dati.

1. Scegli **Aggiungi fonti di dati**.

1. Dall'elenco dei connettori delle sorgenti dati, scegli **Amazon S3**.

1. Nella pagina **Definisci gli attributi**, assegna alla fonte di dati un nome e, facoltativamente, una descrizione. Lascia vuoto il campo **Tag**. Seleziona **Successivo** per continuare.

1. Nel campo **Inserisci la posizione dell'origine dati**, inserisci il nome del bucket S3 che contiene i tuoi documenti. **Puoi inserire direttamente il nome oppure puoi cercarlo scegliendo Sfoglia.** Il bucket deve trovarsi nella stessa regione dell'indice.

1. Nel **IAM ruolo** scegli **Crea un nuovo ruolo** e quindi digita il nome del ruolo. Per ulteriori informazioni, consulta [IAM i ruoli per le fonti di Amazon S3 dati](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-ds-s3).

1. Nella sezione **Imposta la pianificazione dell'esecuzione della sincronizzazione**, scegli **Esegui su richiesta**.

1. Seleziona **Successivo** per continuare.

1. Nella pagina **Rivedi e crea**, esamina i dettagli della tua fonte di dati S3. Se desideri apportare modifiche, scegli il pulsante **Modifica** accanto all'elemento che desideri modificare. Quando sei soddisfatto delle tue scelte, scegli **Crea per creare** la tua fonte di dati S3.

Dopo aver scelto **Crea**, Amazon Kendra inizia a creare l'origine dati. La creazione dell'origine dati può richiedere diversi minuti. Al termine, lo stato dell'origine dati cambia da **Creazione** a **Attiva**.

Dopo aver creato l'origine dati, è necessario sincronizzare l' Amazon Kendra indice con l'origine dati. Scegli **Sincronizza ora** per avviare il processo di sincronizzazione. La sincronizzazione dell'origine dati può richiedere da alcuni minuti a diverse ore, a seconda del numero e delle dimensioni dei documenti.

# Guida introduttiva a un'origine dati per database MySQL (console)
<a name="getting-started-mysql"></a>

Puoi usare la Amazon Kendra console per iniziare a utilizzare un database MySQL come fonte di dati. Quando si utilizza la console, si specificano le informazioni di connessione necessarie per indicizzare il contenuto di un database MySQL. Per ulteriori informazioni, consulta [Using a database data source](https://docs.aws.amazon.com/kendra/latest/dg/data-source-database.html) (Utilizzo di un'origine dati del database).

È necessario prima creare un database MySQL, quindi è possibile creare una fonte di dati per il database.

Utilizzare la procedura seguente per creare un database MySQL di base. La procedura presuppone che sia già stato creato un indice dopo il passaggio 1 di. [Guida introduttiva alla Amazon Kendra console](gs-console.md)

**Per creare un database MySQL**

1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).

1. Dal pannello di navigazione, scegli **Gruppi di sottoreti**, quindi scegli **Crea gruppo di sottorete DB**.

1. Assegna un nome al gruppo e scegli il tuo Virtual Private Cloud (VPC). Per ulteriori informazioni sulla configurazione di un VPC, [consulta Amazon Kendra Configurazione per l'utilizzo](https://docs.aws.amazon.com/kendra/latest/dg/vpc-configuration.html) di un VPC.

1. Aggiungi le sottoreti private del tuo VPC. Le tue sottoreti private sono quelle che non sono collegate al tuo NAT. Scegli **Create** (Crea).

1. **Dal riquadro di navigazione, scegli **Database, quindi scegli Crea database**.**

1. Utilizza i seguenti parametri per creare il database. Lasciate tutti gli altri parametri ai valori predefiniti.
   + **Opzioni del motore** — MySQL
   + **Modelli: livello gratuito**
   + **Impostazioni delle credenziali**: immetti e conferma una password
   + In **Connettività**, scegli Configurazione di **connettività aggiuntiva**. Effettua le seguenti scelte.
     + **Gruppo di sottoreti**: scegliere il gruppo di sottoreti creato nel passaggio 4.
     + Gruppo di **sicurezza VPC: scegli il gruppo** che contiene le regole in entrata e in uscita che hai creato nel tuo VPC. Ad esempio, **DataSourceSecurityGroup**. Per ulteriori informazioni sulla configurazione di un VPC, [consulta Amazon Kendra Configurazione per l'utilizzo](https://docs.aws.amazon.com/kendra/latest/dg/vpc-configuration.html) di un VPC.
   + In **Configurazione aggiuntiva**, imposta il nome del database **iniziale** su. **content**

1. Scegliere **Crea database**.

1. Dall'elenco dei database, scegli il tuo nuovo database. Prendi nota dell'endpoint del database.

1. Dopo aver creato il database, è necessario creare una tabella per contenere i documenti. La creazione di una tabella non rientra nell'ambito di queste istruzioni. Quando create la tabella, tenete presente quanto segue:
   + Nome del database: **content**
   + Nome della tabella— **documents**
   + Colonne: **ID****Title**,**Body**, e**LastUpdate**. Se lo desideri, puoi includere colonne aggiuntive.

Ora che hai creato il tuo database MySQL, puoi creare una fonte di dati per il database.

**Per creare un'origine dati MySQL**

1. [Accedi a Console di gestione AWS e apri la Amazon Kendra console da casahttps://console.aws.amazon.com/kendra/.](https://console.aws.amazon.com/kendra/home)

1. Dal pannello di navigazione, scegli **Indici**, quindi scegli il tuo indice.

1. Scegli **Aggiungi fonti di dati**, quindi scegli **Amazon RDS.**

1. Digita un nome e una descrizione per l'origine dati, quindi scegli **Avanti**.

1. Scegli **MySQL**.

1. In **Accesso alla connessione**, inserisci le seguenti informazioni:
   + **Endpoint**: l'endpoint del database creato in precedenza.
   + **Porta**: il numero di porta per il database. Per MySQL, l'impostazione predefinita è 3306.
   + **Tipo di autenticazione****: scegli Nuovo.**
   + **Nuovo nome segreto del contenitore: un nome** per il Secrets Manager contenitore per le credenziali del database.
   + **Nome utente**: il nome di un utente con accesso amministrativo al database.
   + **Password**: la password per l'utente, quindi scegli **Salva** autenticazione.
   + **Nome del database** —**content**.
   + **Nome della tabella** —**documents**.
   + **Ruolo IAM**: scegli **Crea un nuovo ruolo**, quindi digita un nome per il ruolo.

1. Nella **configurazione Column** inserisci quanto segue:
   + **ID del documento, nome della colonna**: **ID**
   + **Titolo del documento, nome della colonna**: **Title**
   + **Nome della colonna di dati del documento**: **Body**

1. In **Rilevamento delle modifiche alle colonne**, inserisci quanto segue:
   + **Colonne di rilevamento delle modifiche**: **LastUpdate**

1. In **Configura VPC e gruppo di sicurezza fornisci quanto** segue:
   + In **Virtual Private Cloud (VPC), scegli il tuo VPC**.
   + In **Sottoreti**, scegli le sottoreti private che hai creato nel tuo VPC.
   + Nei **gruppi di sicurezza VPC**, scegli il gruppo di sicurezza che contiene le regole in entrata e in uscita che hai creato nei tuoi database VPC per MySQL. Ad esempio, **DataSourceSecurityGroup**.

1. **In **Imposta la pianificazione dell'esecuzione della sincronizzazione, scegli Esegui** **su richiesta, quindi scegli Avanti**.**

1. Nella **mappatura dei campi dell'origine dati**, scegli **Avanti**.

1. Controlla la configurazione della tua fonte di dati per assicurarti che sia corretta. Quando sei sicuro che tutto sia corretto, scegli **Crea**.

# Guida introduttiva a un'origine di AWS IAM Identity Center identità (console)
<a name="getting-started-aws-sso"></a>

Una fonte di AWS IAM Identity Center identità contiene informazioni sui tuoi utenti e gruppi. Ciò è utile per configurare il filtro contestuale degli utenti, in cui Amazon Kendra filtra i risultati di ricerca per diversi utenti in base all'accesso dell'utente o del relativo gruppo ai documenti.

Per creare una fonte di identità IAM Identity Center, devi attivare IAM Identity Center e creare un'organizzazione in AWS Organizations. Quando attivi IAM Identity Center e crei un'organizzazione per la prima volta, per impostazione predefinita viene utilizzata automaticamente la directory Identity Center come origine dell'identità. Puoi passare ad Active Directory (gestito o autogestito da Amazon) o a un provider di identità esterno come fonte di identità. A tal fine, devi seguire le linee guida corrette: consulta [Modifica della fonte di identità di IAM Identity Center](https://docs.aws.amazon.com/kendra/latest/dg/changing-aws-sso-source.html). Puoi avere una sola fonte di identità per organizzazione.

Affinché agli utenti e ai gruppi vengano assegnati diversi livelli di accesso ai documenti, è necessario includere gli utenti e i gruppi nell'elenco di controllo degli accessi quando si inseriscono documenti nell'indice. Ciò consente agli utenti e ai gruppi di cercare documenti Amazon Kendra in base al loro livello di accesso. Quando si effettua una query, l'ID utente deve corrispondere esattamente al nome utente in IAM Identity Center.

È inoltre necessario concedere le autorizzazioni necessarie per utilizzare IAM Identity Center con Amazon Kendra. Per ulteriori informazioni, consulta [IAM i ruoli per IAM Identity Center](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-aws-sso).

**Per configurare una fonte di identità IAM Identity Center**

1. Apri la [console Centro identità IAM](https://console.aws.amazon.com/singlesignon).

1. Scegli **Abilita IAM Identity Center**, quindi scegli **Crea AWS organizzazione**.

   La directory Identity Center viene creata per impostazione predefinita e ti viene inviata un'e-mail per verificare l'indirizzo e-mail associato all'organizzazione.

1. Per aggiungere un gruppo all' AWS organizzazione, nel riquadro di navigazione, scegli **Gruppi**.

1. Nella **pagina Gruppi**, scegli **Crea gruppo** e inserisci un nome e una descrizione del gruppo nella finestra di dialogo. Scegli **Create** (Crea).

1. Per aggiungere un utente alle tue Organizzazioni, nel riquadro di navigazione, scegli **Utenti**.

1. Nella pagina **Users (Utenti)**, scegliere **Add user (Aggiungi utente)**. In **User details (Dettagli utente)** specificare tutti i campi obbligatori. In **Password** scegliere **Send an email to the user (Invia un messaggio e-mail all'utente)**. Scegli **Next (Successivo)**.

1. Per aggiungere un utente a un gruppo, scegli **Gruppi** e seleziona un gruppo.

1. Nella pagina **Dettagli**, in **Membri del gruppo**, scegli **Aggiungi utente**.

1. Nella pagina **Aggiungi utenti al gruppo**, seleziona l'utente che desideri aggiungere come membro del gruppo. Puoi selezionare più utenti da aggiungere a un gruppo.

1. Per sincronizzare l'elenco di utenti e gruppi con IAM Identity Center, modifica la fonte di identità in Active Directory o provider di identità esterno.

   La directory Identity Center è la fonte di identità predefinita e richiede l'aggiunta manuale di utenti e gruppi utilizzando questa fonte se non disponi di un elenco personale gestito da un provider. Per modificare la fonte di identità, devi seguire le linee guida corrette in merito: consulta [Modifica della fonte di identità di IAM Identity Center](https://docs.aws.amazon.com/kendra/latest/dg/changing-aws-sso-source.html).

**Nota**  
Se utilizzi Active Directory o un provider di identità esterno come fonte di identità, devi mappare gli indirizzi e-mail degli utenti ai nomi utente di IAM Identity Center quando specifichi il protocollo System for Cross-domain Identity Management (SCIM). Per ulteriori informazioni, consulta la [guida IAM Identity Center su SCIM per abilitare IAM](https://docs.aws.amazon.com/singlesignon/latest/userguide/scim-profile-saml.html) Identity Center.

Dopo aver configurato la fonte di identità IAM Identity Center, puoi attivarla nella console quando crei o modifichi l'indice. Vai a **Controllo dell'accesso degli utenti** nelle impostazioni dell'indice e modifica le impostazioni per consentire il recupero delle informazioni sui gruppi di utenti da IAM Identity Center.

Puoi anche attivare IAM Identity Center utilizzando l'[UserGroupResolutionConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserGroupResolutionConfiguration.html)oggetto. Fornisci l'`UserGroupResolutionMode`annuncio `AWS_SSO` e crei un IAM ruolo che autorizza a chiamare`sso:ListDirectoryAssociations`,`sso-directory:SearchUsers`,`sso-directory:ListGroupsForUser`,`sso-directory:DescribeGroups`.

**avvertimento**  
Amazon Kendra attualmente non supporta l'utilizzo `UserGroupResolutionConfiguration` con un account di membro AWS dell'organizzazione per la fonte di identità IAM Identity Center. È necessario creare l'indice nell'account di gestione dell'organizzazione per poterlo utilizzare`UserGroupResolutionConfiguration`.

Di seguito è riportata una panoramica su come configurare un'origine dati con `UserGroupResolutionConfiguration` un controllo dell'accesso degli utenti per filtrare i risultati della ricerca in base al contesto dell'utente. Ciò presuppone che tu abbia già creato un indice e un IAM ruolo per gli indici. Crei un indice e fornisci il IAM ruolo utilizzando l'API. [CreateIndex](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateIndex.html)

**Configurazione di un'origine dati con `UserGroupResolutionConfiguration` filtro del contesto utente**

1. Crea un [IAM ruolo](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html#iam-roles-aws-sso) che dia il permesso di accedere alla tua fonte di identità IAM Identity Center.

1. Configura [https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserGroupResolutionConfiguration.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserGroupResolutionConfiguration.html)impostando la modalità su `AWS_SSO` e chiama [UpdateIndex](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateIndex.html)per aggiornare l'indice per utilizzare IAM Identity Center.

1. Se desideri utilizzare il controllo dell'accesso utente basato su token per filtrare i risultati della ricerca in base al contesto dell'utente, imposta su `USER_TOKEN` Quando [UserContextPolicy](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateIndex.html#Kendra-UpdateIndex-request-UserContextPolicy)chiami. `UpdateIndex` Altrimenti, Amazon Kendra esegue la scansione dell'elenco di controllo degli accessi per ciascuno dei tuoi documenti per la maggior parte dei connettori di origini dati. Puoi anche filtrare i risultati della ricerca in base al contesto dell'utente nell'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) fornendo informazioni su utenti e gruppi in. `UserContext` È inoltre possibile mappare gli utenti ai rispettivi gruppi [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)in modo da fornire l'ID utente solo quando si invia la query.

1. Crea un [IAM ruolo](https://docs.aws.amazon.com//kendra/latest/dg/iam-roles.html#iam-roles-ds) che autorizzi l'accesso alla tua fonte di dati.

1. [Configura](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DataSourceConfiguration.html) la tua fonte di dati. È necessario fornire le informazioni di connessione richieste per connettersi alla fonte dati.

1. Crea una fonte di dati utilizzando l'[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API. Fornisci l'`DataSourceConfiguration`oggetto, che include `TemplateConfiguration` l'ID dell'indice, il IAM ruolo dell'origine dati, il tipo di origine dati, e assegna un nome all'origine dati. Puoi anche aggiornare la tua fonte di dati.

# Modifica della fonte di identità di IAM Identity Center
<a name="changing-aws-sso-source"></a>

**avvertimento**  
La modifica della fonte di identità nelle **impostazioni** di IAM Identity Center potrebbe influire sulla conservazione delle informazioni su utenti e gruppi. Per eseguire questa operazione in sicurezza, si consiglia di consultare la sezione [Considerazioni per la modifica della fonte di identità](https://docs.aws.amazon.com/singlesignon/latest/userguide/manage-your-identity-source-considerations.html). Quando si modifica la fonte di identità, viene generato un nuovo ID di origine dell'identità. Verifica di utilizzare l'ID corretto prima di attivare la `AWS_SSO` modalità [UserGroupResolutionConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserGroupResolutionConfiguration.html).

**Per modificare la fonte di identità di IAM Identity Center**

1. Apri la console [IAM Identity Center>](https://console.aws.amazon.com/singlesignon).

1. Seleziona **Impostazioni**.

1. **Nella pagina **Impostazioni**, in **Identity source**, scegli Cambia.**

1. Nella pagina **Cambia origine identità**, seleziona la tua fonte di identità preferita, quindi scegli **Avanti**.