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à.
# Tutorial Amazon OpenSearch Service
Questo capitolo include diversi start-to-finish tutorial per lavorare con Amazon OpenSearch Service, tra cui come migrare al servizio, creare una semplice applicazione di ricerca e creare una visualizzazione nelle dashboard. OpenSearch
**Topics**
+ [Tutorial: creazione e ricerca di documenti in Amazon OpenSearch Service](quick-start.md)
+ [Tutorial: migrazione ad Amazon Service OpenSearch](migration.md)
+ [Tutorial: creazione di un'applicazione di ricerca con Amazon OpenSearch Service](search-example.md)
+ [Tutorial: visualizzazione delle chiamate all'assistenza clienti con OpenSearch Service e dashboard OpenSearch](walkthrough.md)
# Tutorial: creazione e ricerca di documenti in Amazon OpenSearch Service
In questo tutorial, imparerai come creare e cercare un documento in Amazon OpenSearch Service. Aggiungi dati a un indice sotto forma di documento JSON. OpenSearch Il servizio crea un indice attorno al primo documento aggiunto.
Questo tutorial spiega come effettuare richieste HTTP per creare documenti, generare automaticamente un ID per un documento ed eseguire ricerche di base e avanzate sui documenti.
**Nota**
Questo tutorial utilizza un dominio con accesso aperto. Per il massimo livello di sicurezza, ti consigliamo di inserire il dominio all'interno di un cloud privato virtuale (VPC).
## Prerequisiti
Di seguito sono elencati i requisiti per questo tutorial:
+ Devi avere un Account AWS.
+ È necessario disporre di un dominio OpenSearch di servizio attivo.
## Aggiunta di un documento a un indice
Per aggiungere un documento a un indice, puoi utilizzare qualsiasi strumento HTTP, come [Postman](https://www.getpostman.com/), CURL o OpenSearch la console Dashboards. Questi esempi presuppongono che tu stia utilizzando la console per sviluppatori in Dashboards. OpenSearch Se utilizzi uno strumento diverso, modificalo di conseguenza fornendo l'URL completo e le credenziali, se necessario.
**Per aggiungere un documento a un indice**
1. Vai all'URL delle OpenSearch dashboard per il tuo dominio. Puoi trovare l'URL nella dashboard del dominio nella console di OpenSearch servizio. L'URL segue il seguente formato:
```
domain-endpoint/_dashboards/
```
1. Accedi utilizzando il nome utente e la password principali.
1. Apri il pannello di navigazione a sinistra e scegli **Strumenti di sviluppo**.
1. Il verbo HTTP per creare una nuova risorsa è PUT, e si utilizza per creare un nuovo documento e indice. Immettere il seguente comando nella console:
```
PUT fruit/_doc/1
{
"name":"strawberry",
"color":"red"
}
```
La richiesta `PUT` crea un indice denominato *frutta* e aggiunge un singolo documento all'indice con un ID pari a 1. Viene generata la risposta seguente:
```
{
"_index" : "fruit",
"_type" : "_doc",
"_id" : "1",
"_version" : 1,
"result" : "created",
"_shards" : {
"total" : 2,
"successful" : 2,
"failed" : 0
},
"_seq_no" : 0,
"_primary_term" : 1
}
```
## Creazione generata automaticamente IDs
OpenSearch Il servizio può generare automaticamente un ID per i tuoi documenti. Il comando da generare IDs utilizza una richiesta POST anziché una richiesta PUT e non richiede alcun ID di documento (rispetto alla richiesta precedente).
Inserisci la seguente richiesta nella console degli sviluppatori:
```
POST veggies/_doc
{
"name":"beet",
"color":"red",
"classification":"root"
}
```
Questa richiesta crea un indice denominato *verdure* e aggiunge il documento all'indice. Viene generata la risposta seguente:
```
{
"_index" : "veggies",
"_type" : "_doc",
"_id" : "3WgyS4IB5DLqbRIvLxtF",
"_version" : 1,
"result" : "created",
"_shards" : {
"total" : 2,
"successful" : 2,
"failed" : 0
},
"_seq_no" : 0,
"_primary_term" : 1
}
```
Nota quel `_id` campo aggiuntivo nella risposta, che indica che un ID è stato creato automaticamente.
**Nota**
Non fornisci nulla dopo `_doc` nell'URL, dove normalmente va l'ID. Poiché stai creando un documento con un ID generato, non ne fornisci ancora uno. È riservato agli aggiornamenti.
## Aggiornamento di un documento con un comando POST
Per aggiornare un documento, si utilizza un comando `POST` HTTP con il numero di ID.
In primo luogo, creare un documento con un ID di `42`:
```
POST fruits/_doc/42
{
"name":"banana",
"color":"yellow"
}
```
Quindi usa quell'ID per aggiornare il documento:
```
POST fruits/_doc/42
{
"name":"banana",
"color":"yellow",
"classification":"berries"
}
```
Questo comando aggiorna il documento con il nuovo campo `classification`. Viene generata la risposta seguente:
```
{
"_index" : "fruits",
"_type" : "_doc",
"_id" : "42",
"_version" : 2,
"result" : "updated",
"_shards" : {
"total" : 2,
"successful" : 2,
"failed" : 0
},
"_seq_no" : 1,
"_primary_term" : 1
}
```
**Nota**
Se si tenta di aggiornare un documento che non esiste, OpenSearch Service crea il documento.
## Esecuzione di operazioni in blocco
Puoi utilizzare il l’operazione API `POST _bulk` per eseguire più azioni su uno o più indici in una richiesta. I comandi di azione in blocco assumono il formato seguente:
```
POST /_bulk
\n
\n
\n
\n
```
Ogni azione richiede due righe di JSON. Innanzitutto, fornisci la descrizione o i metadati dell'azione. Nella riga successiva, fornisci i dati. Ogni parte è separata da una nuova riga (\$1n). Una descrizione dell'azione per un inserto potrebbe essere simile alla seguente:
```
{ "create" : { "_index" : "veggies", "_type" : "_doc", "_id" : "7" } }
```
E la riga successiva che contiene i dati potrebbe essere simile alla seguente:
```
{ "name":"kale", "color":"green", "classification":"leafy-green" }
```
Nel loro insieme, i metadati e i dati rappresentano una singola azione in un'operazione di blocco. È possibile eseguire molte operazioni in un'unica richiesta, ad esempio:
```
POST /_bulk
{ "create" : { "_index" : "veggies", "_id" : "35" } }
{ "name":"kale", "color":"green", "classification":"leafy-green" }
{ "create" : { "_index" : "veggies", "_id" : "36" } }
{ "name":"spinach", "color":"green", "classification":"leafy-green" }
{ "create" : { "_index" : "veggies", "_id" : "37" } }
{ "name":"arugula", "color":"green", "classification":"leafy-green" }
{ "create" : { "_index" : "veggies", "_id" : "38" } }
{ "name":"endive", "color":"green", "classification":"leafy-green" }
{ "create" : { "_index" : "veggies", "_id" : "39" } }
{ "name":"lettuce", "color":"green", "classification":"leafy-green" }
{ "delete" : { "_index" : "vegetables", "_id" : "1" } }
```
Si noti che l'ultima azione è `delete`. Non ci sono dati che seguono l’azione `delete`.
## Ricerca di documenti
Ora che i dati sono presenti nel cluster, è possibile cercarli. Ad esempio, potresti voler cercare tutte le verdure con la radice o ottenere il numero di tutte le verdure a foglia verde o trovare il numero di errori registrati all'ora.
**Ricerche base**
Una ricerca di base è simile a questa:
```
GET veggies/_search?q=name:l*
```
La richiesta genera una risposta JSON che contiene il documento sulla lattuga.
**Ricerca avanzata**
È possibile eseguire ricerche più avanzate fornendo le opzioni di query come JSON nel corpo della richiesta:
```
GET veggies/_search
{
"query": {
"term": {
"name": "lettuce"
}
}
}
```
Questo esempio produce anche una risposta JSON con il documento sulla lattuga.
**Ordinamento**
È possibile eseguire più query di questo tipo utilizzando l'ordinamento. Innanzitutto, è necessario ricreare l'indice, poiché la mappatura automatica dei campi ha scelto tipi che non possono essere ordinati per impostazione predefinita. Inviare le richieste seguenti per eliminare e ricreare l'indice:
```
DELETE /veggies
PUT /veggies
{
"mappings":{
"properties":{
"name":{
"type":"keyword"
},
"color":{
"type":"keyword"
},
"classification":{
"type":"keyword"
}
}
}
}
```
Quindi ripopolare l'indice con i dati:
```
POST /_bulk
{ "create" : { "_index" : "veggies", "_id" : "7" } }
{ "name":"kale", "color":"green", "classification":"leafy-green" }
{ "create" : { "_index" : "veggies", "_id" : "8" } }
{ "name":"spinach", "color":"green", "classification":"leafy-green" }
{ "create" : { "_index" : "veggies", "_id" : "9" } }
{ "name":"arugula", "color":"green", "classification":"leafy-green" }
{ "create" : { "_index" : "veggies", "_id" : "10" } }
{ "name":"endive", "color":"green", "classification":"leafy-green" }
{ "create" : { "_index" : "veggies", "_id" : "11" } }
{ "name":"lettuce", "color":"green", "classification":"leafy-green" }
```
Ora puoi cercare con un ordinamento. Questa richiesta aggiunge un ordinamento crescente in base alla classificazione:
```
GET veggies/_search
{
"query" : {
"term": { "color": "green" }
},
"sort" : [
"classification"
]
}
```
## Risorse correlate
Per maggiori informazioni, consulta le seguenti risorse:
+ [Guida introduttiva ad Amazon OpenSearch Service](gsg.md)
+ [Indicizzazione dei dati in Amazon Service OpenSearch](indexing.md)
+ [Ricerca di dati in Amazon OpenSearch Service](searching.md)
# Tutorial: migrazione ad Amazon Service OpenSearch
Gli snapshot degli indici sono un modo popolare per migrare da un cluster Elasticsearch legacy OpenSearch o autogestito ad Amazon Service. OpenSearch In generale, il processo consiste nei seguenti passaggi:
1. Acquisire uno snapshot del cluster esistente e caricare lo snapshot in un bucket Amazon S3.
1. Crea un dominio di servizio. OpenSearch
1. Concedi al OpenSearch Servizio le autorizzazioni per accedere al bucket e assicurati di disporre delle autorizzazioni per lavorare con le istantanee.
1. Ripristina l'istantanea nel dominio del servizio. OpenSearch
Questa procedura dettagliata fornisce passaggi più dettagliati e opzioni alternative, ove applicabile.
## Acquisizione e caricamento dello snapshot
Sebbene sia possibile utilizzare il plug-in [repository-s3](https://docs.opensearch.org/latest/opensearch/snapshot-restore/#amazon-s3) per scattare istantanee direttamente su S3, è necessario installare il plug-in su ogni nodo, modificare `opensearch.yml` (o `elasticsearch.yml` se si utilizza un cluster Elasticsearch), riavviare ogni nodo, aggiungere le credenziali e infine scattare l'istantanea. AWS Il plugin è una grande opzione per l'uso continuo o per la migrazione di cluster più grandi.
Per i cluster più piccoli, un approccio monouso consiste nello scattare un'istantanea del file system [condivisa](https://docs.opensearch.org/latest/opensearch/snapshot-restore/#shared-file-system) e quindi utilizzarla per caricarla su S3. AWS CLI Se si dispone già di uno snapshot, andare al passaggio 4.
****Per acquisire uno snapshot e caricarlo in Amazon S3****
1. Aggiungi l'impostazione `path.repo` a `opensearch.yml` (o `Elasticsearch.yml`) su tutti i nodi e quindi riavvia ogni nodo.
```
path.repo: ["/my/shared/directory/snapshots"]
```
1. Registra un [repository di snapshot](https://opensearch.org/docs/latest/opensearch/snapshot-restore/#register-repository); questa operazione è necessaria prima di acquisire uno snapshot. Un repository è solo un percorso di storage: un file system condiviso, Amazon S3, File system distribuito Hadoop (HDFS) ecc. In questo caso, utilizzeremo un file system condiviso ("fs"):
```
PUT _snapshot/my-snapshot-repo-name
{
"type": "fs",
"settings": {
"location": "/my/shared/directory/snapshots"
}
}
```
1. Acquisire lo snapshot:
```
PUT _snapshot/my-snapshot-repo-name/my-snapshot-name
{
"indices": "migration-index1,migration-index2,other-indices-*",
"include_global_state": false
}
```
1. Installare [AWS CLI](https://aws.amazon.com/cli/) ed eseguire `aws configure` per aggiungere le credenziali.
1. Passare alla directory snapshot. Quindi eseguire i seguenti comandi per creare un nuovo bucket S3 e caricare il contenuto della directory snapshot in quel bucket:
```
aws s3 mb s3://amzn-s3-demo-bucket --region us-west-2
aws s3 sync . s3://amzn-s3-demo-bucket --sse AES256
```
A seconda delle dimensioni dello snapshot e della velocità della connessione Internet, questa operazione può richiedere un po' di tempo.
## Creare un dominio
Sebbene la console sia il modo più semplice per creare un dominio, in questo caso il terminale è già aperto e installato. AWS CLI Modificare il seguente comando per creare un dominio che si adatti alle proprie esigenze:
```
aws opensearch create-domain \
--domain-name migration-domain \
--engine-version OpenSearch_1.0 \
--cluster-config InstanceType=c5.large.search,InstanceCount=2 \
--ebs-options EBSEnabled=true,VolumeType=gp2,VolumeSize=100 \
--node-to-node-encryption-options Enabled=true \
--encryption-at-rest-options Enabled=true \
--domain-endpoint-options EnforceHTTPS=true,TLSSecurityPolicy=Policy-Min-TLS-1-2-2019-07 \
--advanced-security-options Enabled=true,InternalUserDatabaseEnabled=true,MasterUserOptions='{MasterUserName=master-user,MasterUserPassword=master-user-password}' \
--access-policies '{"Version": "2012-10-17", "Statement":[{"Effect":"Allow","Principal": {"AWS": "arn:aws:iam::aws-region:user/UserName"},"Action":["es:ESHttp*"],"Resource":"arn:aws:es:aws-region:111122223333:domain/migration-domain/*"}]}' \
--region aws-region
```
Così com'è, il comando crea un dominio accessibile a Internet con due nodi di dati, ciascuno con 100 GiB di archiviazione. Consente inoltre il [controllo granulare degli accessi](fgac.md) con l'autenticazione di base HTTP e tutte le impostazioni di crittografia. Usa la console OpenSearch di servizio se hai bisogno di una configurazione di sicurezza più avanzata, come un VPC.
Prima di eseguire il comando, modificare il nome di dominio, le credenziali dell'utente master e il numero di account. Specificate la stessa Regione AWS che avete usato per il bucket S3 e una OpenSearch/Elasticsearch versione compatibile con la vostra istantanea.
**Importante**
Gli snapshot sono compatibili con le versioni successive e solo con una versione principale. Ad esempio, non è possibile ripristinare un'istantanea da un file 1. OpenSearch cluster *x* su un Elasticsearch 7. cluster *x*, solo un OpenSearch 1. *x* o 2. cluster *x*. Anche la versione minore conta. Non è possibile ripristinare un'istantanea da un cluster 5.3.3 autogestito su un dominio di servizio OpenSearch 5.3.2. Ti consigliamo di scegliere la versione più recente di Elasticsearch supportata dalla OpenSearch tua istantanea. Per una tabella delle versioni compatibili, consultare [Utilizzo di uno snapshot per migrare i dati](snapshot-based-migration.md).
## Fornire le autorizzazioni al bucket S3.
[Nella console AWS Identity and Access Management (IAM), [crea un ruolo](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html) con le seguenti autorizzazioni e relazioni di fiducia.](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-managingrole_edit-trust-policy) Durante la creazione del ruolo, scegliere **S3** come **Servizio AWS **. Assegnare un nome al ruolo `OpenSearchSnapshotRole` in modo che sia facile da trovare.
**Autorizzazioni**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Action": [
"s3:ListBucket"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
},
{
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}
```
------
**Relazione di attendibilità**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"Service": "es.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Quindi assegna al tuo ruolo IAM personale le autorizzazioni per assumere `OpenSearchSnapshotRole`. Creare la policy seguente e [collegarla](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) alla propria identità.
**Autorizzazioni**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::123456789012:role/OpenSearchSnapshotRole"
}
]
}
```
------
### Mappa il ruolo dello snapshot nelle OpenSearch dashboard (se utilizzi un controllo granulare degli accessi)
Se è stato abilitato il [controllo granulare degli accessi](fgac.md#fgac-mapping), anche se si utilizza l'autenticazione di base HTTP per tutti gli altri scopi, poter utilizzare gli snapshot sarà necessario mappare il ruolo `manage_snapshots` al ruolo IAM.
**Come concedere all'identità le autorizzazioni per l'utilizzo degli snapshot**
1. Accedi ai dashboard utilizzando le credenziali dell'utente principale che hai specificato quando hai creato il dominio del servizio. OpenSearch Puoi trovare l'URL delle dashboard nella console di servizio. OpenSearch Presenta il formato `https://domain-endpoint/_dashboards/`.
1. Dal menu principale scegliere **Sicurezza**, **Ruoli** e selezionare il ruolo **manage\$1snapshots**.
1. Scegliere **Utenti mappati**, **Gestisci mappatura**.
1. Aggiungere l'ARN del dominio del ruolo IAM personale nel campo appropriato. L'ARN deve avere uno dei seguenti formati:
```
arn:aws:iam::123456789123:user/user-name
```
```
arn:aws:iam::123456789123:role/role-name
```
1. Seleziona **Map** (Mappa) e verifica che il ruolo sia visualizzato in **Mapped users** (Utenti mappati).
## Ripristino dello snapshot
A questo punto, hai due modi per accedere al tuo dominio di OpenSearch servizio: l'autenticazione di base HTTP con le credenziali dell'utente principale o l' AWS autenticazione tramite le tue credenziali IAM. Poiché le istantanee utilizzano Amazon S3, che non ha il concetto di utente principale, devi utilizzare le tue credenziali IAM per registrare l'archivio di snapshot nel tuo dominio di servizio. OpenSearch
**La maggior parte dei linguaggi di programmazione dispone di librerie che facilitano la firma delle richieste, ma l'approccio più semplice consiste nell'utilizzare uno strumento come [Postman](https://www.postman.com/downloads/) e inserire le credenziali IAM nella sezione Autorizzazione.**
![\[Postman interface showing Authorization settings for AWS API request with Signature type.\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/migration2.png)
**Ripristinare lo snapshot**
1. Indipendentemente da come si sceglie di firmare le richieste, il primo passo è registrare il repository:
```
PUT _snapshot/my-snapshot-repo-name
{
"type": "s3",
"settings": {
"bucket": "amzn-s3-demo-bucket",
"region": "us-west-2",
"role_arn": "arn:aws:iam::123456789012:role/OpenSearchSnapshotRole"
}
}
```
1. Quindi elencare lo snapshot nel repository e trovare quello che si desidera ripristinare. A questo punto, continuare a usare Postman o passare a uno strumento come [curl](https://curl.haxx.se/).
**Sintassi abbreviata**
```
GET _snapshot/my-snapshot-repo-name/_all
```
**curl**
```
curl -XGET -u 'master-user:master-user-password' https://domain-endpoint/_snapshot/my-snapshot-repo-name/_all
```
1. Ripristinare lo snapshot:
**Sintassi abbreviata**
```
POST _snapshot/my-snapshot-repo-name/my-snapshot-name/_restore
{
"indices": "migration-index1,migration-index2,other-indices-*",
"include_global_state": false
}
```
**curl**
```
curl -XPOST -u 'master-user:master-user-password' https://domain-endpoint/_snapshot/my-snapshot-repo-name/my-snapshot-name/_restore \
-H 'Content-Type: application/json' \
-d '{"indices":"migration-index1,migration-index2,other-indices-*","include_global_state":false}'
```
1. Infine, verifica che gli indici siano ripristinati come previsto.
**Sintassi abbreviata**
```
GET _cat/indices?v
```
**curl**
```
curl -XGET -u 'master-user:master-user-password' https://domain-endpoint/_cat/indices?v
```
A questo punto, la migrazione è completa. Puoi configurare i tuoi client per utilizzare il nuovo endpoint OpenSearch Service, [ridimensionare il dominio](sizing-domains.md) in base al tuo carico di lavoro, controllare il numero di shard per i tuoi indici, passare a un utente [master IAM](fgac.md#fgac-concepts) o iniziare a creare visualizzazioni nelle dashboard. OpenSearch
# Tutorial: creazione di un'applicazione di ricerca con Amazon OpenSearch Service
Un modo comune per creare un'applicazione di ricerca con Amazon OpenSearch Service consiste nell'utilizzare moduli Web per inviare le richieste degli utenti a un server. Quindi puoi autorizzare il server a OpenSearch APIs chiamarlo direttamente e fare in modo che il server invii richieste al OpenSearch servizio. Se desideri scrivere codice lato client che non si basa su un server, tuttavia, devi compensare per i rischi di sicurezza e prestazioni. Consentire l'accesso pubblico non firmato a OpenSearch APIs è sconsigliabile. Gli utenti possono accedere a endpoint non protetti o influire sulle prestazioni del cluster tramite query eccessivamente estese (o troppe query).
Questo capitolo presenta una soluzione: usa Amazon API Gateway per limitare gli utenti a un sottoinsieme di OpenSearch APIs e AWS Lambda firmare le richieste da API Gateway to OpenSearch Service.
![\[Diagramma di flusso dell'applicazione di ricerca.\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/search-application-diagram.png)
**Nota**
Si applicano i prezzi standard di API Gateway e Lambda, ma entro l'uso limitato di questo tutorial, i costi dovrebbero essere trascurabili.
## Prerequisiti
Un prerequisito per questo tutorial è un dominio di OpenSearch servizio. Se non ne hai già uno, segui i passaggi in [Creare un dominio di OpenSearch servizio](gsgcreate-domain.md) per crearne uno.
## Fase 1: Indicizzazione dei dati di esempio
Scaricare [sample-movies.zip](samples/sample-movies.zip), decomprimerlo e utilizzare l'operazione dell'API [\$1bulk](https://opensearch.org/docs/latest/api-reference/document-apis/bulk/) per aggiungere i 5.000 documenti all'indice `movies`:
```
POST https://search-my-domain.us-west-1.es.amazonaws.com/_bulk
{ "index": { "_index": "movies", "_id": "tt1979320" } }
{"directors":["Ron Howard"],"release_date":"2013-09-02T00:00:00Z","rating":8.3,"genres":["Action","Biography","Drama","Sport"],"image_url":"http://ia.media-imdb.com/images/M/MV5BMTQyMDE0MTY0OV5BMl5BanBnXkFtZTcwMjI2OTI0OQ@@._V1_SX400_.jpg","plot":"A re-creation of the merciless 1970s rivalry between Formula One rivals James Hunt and Niki Lauda.","title":"Rush","rank":2,"running_time_secs":7380,"actors":["Daniel Brühl","Chris Hemsworth","Olivia Wilde"],"year":2013,"id":"tt1979320","type":"add"}
{ "index": { "_index": "movies", "_id": "tt1951264" } }
{"directors":["Francis Lawrence"],"release_date":"2013-11-11T00:00:00Z","genres":["Action","Adventure","Sci-Fi","Thriller"],"image_url":"http://ia.media-imdb.com/images/M/MV5BMTAyMjQ3OTAxMzNeQTJeQWpwZ15BbWU4MDU0NzA1MzAx._V1_SX400_.jpg","plot":"Katniss Everdeen and Peeta Mellark become targets of the Capitol after their victory in the 74th Hunger Games sparks a rebellion in the Districts of Panem.","title":"The Hunger Games: Catching Fire","rank":4,"running_time_secs":8760,"actors":["Jennifer Lawrence","Josh Hutcherson","Liam Hemsworth"],"year":2013,"id":"tt1951264","type":"add"}
...
```
Nota che quanto sopra è un comando di esempio con un piccolo sottoinsieme dei dati disponibili. Per eseguire l'`_bulk`operazione, è necessario copiare e incollare l'intero contenuto del `sample-movies` file. Per ulteriori istruzioni, vedere[Opzione 2: Caricamento di più documenti](gsgupload-data.md#gsgmultiple-document).
Puoi anche usare il seguente comando curl per ottenere lo stesso risultato:
```
curl -XPOST -u 'master-user:master-user-password' 'domain-endpoint/_bulk' --data-binary @bulk_movies.json -H 'Content-Type: application/json'
```
## Fase 2: Creare e distribuire la funzione Lambda
Prima di creare l'API in API Gateway, crea la funzione Lambda a cui passa le richieste.
### Creazione della funzione Lambda
In questa soluzione, API Gateway passa le richieste a una funzione Lambda, che interroga il OpenSearch servizio e restituisce i risultati. Poiché questa funzione di esempio utilizza librerie esterne, è necessario creare un pacchetto di distribuzione e caricarlo su Lambda.
**Per creare il pacchetto di implementazione**
1. Apri un prompt dei comandi e crea una directory di progetto `my-opensearch-function`. Ad esempio, su macOS:
```
mkdir my-opensearch-function
```
1. Passa alla directory del progetto `my-sourcecode-function`.
```
cd my-opensearch-function
```
1. Copia il contenuto del seguente codice Python di esempio e salvalo in un nuovo file denominato. `opensearch-lambda.py` Aggiungi la tua regione e l'endpoint host al file.
```
import boto3
import json
import requests
from requests_aws4auth import AWS4Auth
region = '' # For example, us-west-1
service = 'es'
credentials = boto3.Session().get_credentials()
awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token)
host = '' # The OpenSearch domain endpoint with https:// and without a trailing slash
index = 'movies'
url = host + '/' + index + '/_search'
# Lambda execution starts here
def lambda_handler(event, context):
# Put the user query into the query DSL for more accurate search results.
# Note that certain fields are boosted (^).
query = {
"size": 25,
"query": {
"multi_match": {
"query": event['queryStringParameters']['q'],
"fields": ["title^4", "plot^2", "actors", "directors"]
}
}
}
# Elasticsearch 6.x requires an explicit Content-Type header
headers = { "Content-Type": "application/json" }
# Make the signed HTTP request
r = requests.get(url, auth=awsauth, headers=headers, data=json.dumps(query))
# Create the response and add some extra content to support CORS
response = {
"statusCode": 200,
"headers": {
"Access-Control-Allow-Origin": '*'
},
"isBase64Encoded": False
}
# Add the search results to the response
response['body'] = r.text
return response
```
1. Installa le librerie esterne in una nuova `package` directory.
```
pip3 install --target ./package boto3
pip3 install --target ./package requests
pip3 install --target ./package requests_aws4auth
```
1. Crea un pacchetto di implementazione con le librerie installate nella directory principale. Il comando seguente genera un `my-deployment-package.zip` file nella directory del progetto.
```
cd package
zip -r ../my-deployment-package.zip .
```
1. Aggiungi il file `opensearch-lambda.py` alla radice del file .zip.
```
cd ..
zip my-deployment-package.zip opensearch-lambda.py
```
Per ulteriori informazioni sulla creazione di funzioni Lambda e sui pacchetti di implementazione, consultare [Implementa funzioni Lambda per Python con gli archivi di file .zip](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python-how-to-create-deployment-package.html) nella *Guida per gli sviluppatori di AWS Lambda * e [Creazione il pacchetto di implementazione Lambda](integrations-s3-lambda.md#integrations-s3-lambda-deployment-package) in questa guida.
Per creare la tua funzione utilizzando la console Lambda
1. [Accedi alla console Lambda a casahttps://console.aws.amazon.com/lambda/.](https://console.aws.amazon.com/lambda/home ) Nel riquadro di navigazione a sinistra, scegli **Funzioni**.
1. Seleziona **Crea funzione**.
1. Configura i campi seguenti:
+ Nome della funzione: opensearch-function
+ Runtime: Python 3.9
+ Architettura: x86\$164
Mantieni tutte le altre opzioni predefinite e scegli **Crea** funzione.
1. Nella sezione **Codice sorgente** della pagina di riepilogo della funzione, scegli il menu **a discesa Carica da** e seleziona il **file.zip.** **Individua il `my-deployment-package.zip` file che hai creato e scegli Salva.**
1. Il *gestore* è il metodo nel codice della funzione che elabora gli eventi. In **Impostazioni di runtime**, scegli **Modifica e modifica** il nome del gestore in base al nome del file nel pacchetto di distribuzione in cui si trova la funzione Lambda. Poiché il file ha un nome`opensearch-lambda.py`, rinomina il gestore in. `opensearch-lambda.lambda_handler` Per ulteriori informazioni, consulta [Gestore della funzione Lambda in Python](https://docs.aws.amazon.com/lambda/latest/dg/python-handler.html).
## Fase 3: Creare l'API in API Gateway
L'utilizzo di API Gateway consente di creare un'API più limitata e semplifica il processo di interazione con l' OpenSearch `_search`API. API Gateway consente inoltre di abilitare caratteristiche di sicurezza come l'autenticazione di Amazon Cognito e la limitazione delle richieste. Completare la procedura seguente per creare e implementare un'API:
### Creazione e configurazione dell'API
Come creare l'API utilizzando la console API Gateway
1. Accedi alla console API Gateway da [https://console.aws.amazon.com/apigateway/casa](https://console.aws.amazon.com/apigateway/home ). Nel riquadro di navigazione a sinistra, scegli **APIs**.
1. Individuare **REST API** (non privato) e scegliere **Crea**.
1. Nella pagina seguente, individua la sezione **Crea nuova API** e assicurati che sia selezionata **Nuova API**.
1. Configura i campi seguenti:
+ Nome API: **opensearch-api**
+ Descrizione: **API pubblica per la ricerca di un dominio Amazon OpenSearch Service**
+ Tipo di endpoint: **regionale**
1. Seleziona **Create API** (Crea API).
1. Scegliere **Operazioni** quindi **Crea metodo**.
1. Selezionare **GET** nel menu a discesa e fare clic sul segno di spunta per confermare.
1. Configurare le impostazioni seguenti, quindi scegliere **Salva**:
| Impostazione | Valore |
| --- | --- |
| Tipo di integrazione | Funzione Lambda |
| Utilizzo dellintegrazione proxy Lambda | Sì |
| Regione Lambda | us-west-1 |
| funzione Lambda | opensearch-lambda |
| Utilizzo del timeout di default | Sì |
### Configurazione della richiesta del metodo
Scegliere **Richiesta metodo** e configurare le impostazioni seguenti:
| Impostazione | Valore |
| --- | --- |
| Autorizzazione | NONE |
| Convalidatore di richieste | Convalida dei parametri e delle intestazioni delle stringhe di query |
| Chiave API richiesta | false |
In **Parametri della stringa di query URL**, scegli **Aggiungi stringa di query** e configura il seguente parametro:
| Impostazione | Valore |
| --- | --- |
| Nome | q |
| Richiesto | Sì |
### Implementazione dell'API e configurazione di una fase
La console API Gateway consente di distribuire un'API creando una distribuzione e associandola a una fase nuova o esistente.
1. Scegliere **Operazioni** e **Implementa API**.
1. Per **Fase di implementazione**, scegliere **Nuova fase** e nominare la fase `opensearch-api-test`.
1. Seleziona **Implementa**.
1. Configurare le seguenti impostazioni nell'editor della fase, quindi scegliere **Salva modifiche**:
| Impostazione | Valore |
| --- | --- |
| Abilitazione della limitazione | Sì |
| Tariffa | 1000 |
| Burst | 500 |
Queste impostazioni configurano un'API che dispone di un solo metodo: una richiesta `GET` alla root dell'endpoint (`https://some-id.execute-api.us-west-1.amazonaws.com/search-es-api-test`). La richiesta richiede un singolo parametro (`q`), la stringa di query da ricercare. Quando viene chiamato, il metodo passa la richiesta a Lambda, che esegue la funzione `opensearch-lambda`. Per ulteriori informazioni, consultare [Creazione di un'API in Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-create-api.html) e [Implementazione di una REST API in Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-deploy-api.html).
## Fase 4: (facoltativa) Modifica della policy di accesso al dominio
Il dominio del OpenSearch servizio deve consentire alla funzione Lambda di effettuare `GET` richieste all'`movies`indice. Se il dominio ha una policy di accesso aperto con il controllo granulare degli accessi abilitato, è possibile lasciarlo così com'è:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "*"
},
"Action": "es:*",
"Resource": "arn:aws:es:us-west-1:123456789012:domain/domain-name/*"
}
]
}
```
------
In alternativa, è possibile scegliere di rendere la policy di accesso al dominio più granulare. Per esempio, la policy minima seguente consente a `opensearch-lambda-role` (creato tramite Lambda) l'accesso in lettura all'indice `movies`: Per ottenere il nome esatto del ruolo creato automaticamente da Lambda, vai alla console AWS Identity and Access Management (IAM), scegli **Ruoli** e cerca «lambda».
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:role/service-role/opensearch-lambda-role-1abcdefg"
},
"Action": "es:ESHttpGet",
"Resource": "arn:aws:es:us-west-1:123456789012:domain/domain-name/movies/_search"
}
]
}
```
------
**Importante**
Se hai abilitato il controllo granulare degli accessi per il dominio, devi anche [mappare il ruolo a un utente](fgac.md#fgac-mapping) nelle OpenSearch dashboard, altrimenti vedrai errori di autorizzazione.
### Configurare le autorizzazioni del ruolo di esecuzione Lambda
Oltre a configurare la policy di accesso al dominio, devi anche assicurarti che il ruolo di esecuzione Lambda disponga delle autorizzazioni IAM necessarie per accedere OpenSearch al tuo dominio di servizio. La funzione Lambda richiede autorizzazioni specifiche a seconda che si stia utilizzando un dominio gestito o una raccolta OpenSearch Service Serverless.
**Per i domini di servizio gestiti OpenSearch :**
Allega la seguente policy IAM al tuo ruolo di esecuzione Lambda per consentirgli di effettuare richieste al tuo dominio di OpenSearch servizio:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"es:ESHttpGet",
"es:ESHttpPost"
],
"Resource": "arn:aws:es:us-west-1:123456789012:domain/domain-name/*"
}
]
}
```
------
**Per le raccolte OpenSearch Service Serverless:**
Se utilizzi OpenSearch Service Serverless, collega la seguente policy IAM al tuo ruolo di esecuzione Lambda:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "aoss:*",
"Resource": "arn:aws:aoss:us-west-1:123456789012:collection/collection-id"
}
]
}
```
------
Per allegare queste policy al tuo ruolo di esecuzione Lambda:
1. Accedi alla console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Scegli **Ruoli** e cerca il tuo ruolo di esecuzione Lambda (chiamato `opensearch-lambda-role-xxxxxxxx` in genere).
1. Scegli **Aggiungi autorizzazioni**, quindi **Crea politica in linea**.
1. Scegli la scheda **JSON** e incolla la politica appropriata dall'alto, sostituendo i valori segnaposto con la tua risorsa effettiva. ARNs
1. **Scegli **Review policy**, fornisci un nome simile e scegli `OpenSearchAccess` Crea policy.**
**Nota**
Senza queste autorizzazioni IAM, la funzione Lambda riceverà l'errore «Accesso negato» quando tenta di interrogare OpenSearch il dominio del servizio, anche se la policy di accesso al dominio consente le richieste.
Per ulteriori informazioni sulle policy di accesso a , consulta [Configurazione delle policy di accesso](createupdatedomains.md#createdomain-configure-access-policies).
## Mappatura del ruolo Lambda (se si utilizza il controllo granulare degli accessi)
Il controllo granulare degli accessi introduce un passaggio aggiuntivo prima che sia possibile testare l'applicazione. Anche se si utilizza l'autenticazione di base HTTP per tutti gli altri scopi, è necessario mappare il ruolo Lambda all'utente, altrimenti si riceveranno errori di autorizzazione.
1. Vai all'URL delle OpenSearch dashboard per il dominio.
1. Dal menu principale, scegli **Sicurezza**, **Ruoli** e seleziona il link al `all_access` ruolo a cui devi mappare il ruolo Lambda.
1. Scegliere **Utenti mappati**, **Gestisci mappatura**.
1. In **Backend roles** (Ruoli di backend), aggiungi il nome della risorsa Amazon (ARN) del ruolo Lambda. L'ARN dovrebbe assumere la forma di. `arn:aws:iam::123456789123:role/service-role/opensearch-lambda-role-1abcdefg`
1. Selezionare **Mappa** e confermare che l'utente o il ruolo venga visualizzato in **Utenti mappati**.
## Fase 5: Test dell'applicazione Web
**Per testare l'applicazione Web**
1. Scaricare [sample-site.zip](samples/sample-site.zip), decomprimerlo e aprire `scripts/search.js` nell'editor di testo preferito.
1. Aggiorna la `apigatewayendpoint` variabile in modo che punti all'endpoint API Gateway e aggiungi una barra rovesciata alla fine del percorso specificato. Puoi trovare rapidamente l'endpoint in API Gateway scegliendo **Stages** (Fasi) e selezionando il nome dell'API. La `apigatewayendpoint` variabile deve assumere la forma di /. `https://some-id.execute-api.us-west-1.amazonaws.com/opensearch-api-test`
1. Aprire `index.html` e provare a eseguire la ricerca di *thor*, *house* e qualche altro termine.
![\[Una ricerca di esempio per thor.\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/search-ui.png)
### Risoluzione degli errori CORS
Anche se la funzione Lambda include contenuti nella risposta per il supporto di CORS, è comunque possibile che venga visualizzato il seguente errore:
```
Access to XMLHttpRequest at '' from origin 'null' has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present in the requested resource.
```
In tal caso, prova quanto seguente:
1. [Abilita CORS](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-cors-console.html) sulla risorsa GET. In **Advanced** (Avanzati), imposta **Access-Control-Allow-Credentials** a `'true'`.
1. Ridistribuisci la tua API in API Gateway (**Actions** (Operazioni),**Deploy API** (Distribuzione dell'API)).
1. Elimina e aggiungi nuovamente la tua attivazione della funzione Lambda. Aggiungila nuovamente, scegli **Aggiungi trigger** e crea l'endpoint HTTP che richiama la tua funzione. Il trigger deve avere la seguente configurazione:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/search-example.html)
## Fasi successive
Questo capitolo è solo un punto di partenza per dimostrare un concetto. Potresti valutare se apportare le seguenti modifiche:
+ Aggiungi i tuoi dati al dominio del servizio. OpenSearch
+ Aggiungere metodi all'API.
+ Nella funzione Lambda, modificare la query di ricerca o potenziare campi diversi.
+ Utilizzare uno stile diverso per i risultati o modificare `search.js` per visualizzare campi diversi all'utente.
# Tutorial: visualizzazione delle chiamate all'assistenza clienti con OpenSearch Service e dashboard OpenSearch
Questo capitolo è un'analisi completa della seguente situazione: un'azienda riceve un numero di chiamate al servizio di assistenza clienti e desidera analizzarle. Qual è l'argomento di ogni chiamata? Quante sono state positive? Quante sono state negative? In che modo i responsabili possono cercare o analizzare le trascrizioni di queste chiamate?
Un flusso di lavoro manuale potrebbe coinvolgere dipendenti che ascoltano le registrazioni, annotano l'oggetto di ciascuna chiamata e decidono se l'interazione con il cliente è stata positiva.
Tale processo sarebbe estremamente impegnativo. Considerando un tempo medio di 10 minuti per chiamata, ogni dipendente potrebbe ascoltare solo 48 chiamate al giorno. Ad eccezione di eventuali distorsioni umane, i dati generati sarebbero altamente accurati, ma la *quantità* di dati sarebbe minima: solo l'oggetto della chiamata e un Boolean se il cliente è soddisfatto oppure no. Qualcosa di più complesso, come una trascrizione completa, potrebbe richiedere una grande quantità di tempo.
Utilizzando [Amazon S3](https://aws.amazon.com/s3/), Amazon [Transcribe[, Amazon](https://aws.amazon.com/comprehend/)](https://aws.amazon.com/transcribe/) Comprehend e Amazon Service OpenSearch , puoi automatizzare un processo simile con pochissimo codice e ottenere molti più dati. Ad esempio, è possibile ottenere una trascrizione completa della chiamata, le parole chiave dalla trascrizione e un "sentiment" della chiamata (positivo, negativo, neutro o misto). Quindi puoi utilizzare OpenSearch e OpenSearch Dashboards per cercare e visualizzare i dati.
Sebbene sia possibile utilizzare questa procedura dettagliata così com'è, l'intento è quello di stimolare idee su come arricchire i documenti JSON prima di indicizzarli in Service. OpenSearch
**Costi stimati**
In generale, l'esecuzione della procedura indicata in questo scenario avrebbe un costo inferiore a \$12. La procedura guidata utilizza le risorse seguenti:
+ Bucket S3 con meno di 100 MB trasferiti e memorizzati
Per ulteriori informazioni, consultare [Amazon S3 Pricing](https://aws.amazon.com/s3/pricing/).
+ OpenSearch Dominio di servizio con un'`t2.medium`istanza e 10 GiB di storage EBS per diverse ore
Per ulteriori informazioni, consulta la pagina [dei prezzi OpenSearch di Amazon Service](https://aws.amazon.com/elasticsearch-service/pricing/).
+ Chiamate multiple ad Amazon Transcribe
Per ulteriori informazioni, consultare [Prezzi di Amazon Transcribe](https://aws.amazon.com/transcribe/pricing/).
+ Diverse chiamate di elaborazione del linguaggio naturale ad Amazon Comprehend
Per ulteriori informazioni, consultare [Prezzi di Amazon Comprehend](https://aws.amazon.com/comprehend/pricing/).
**Topics**
+ [Fase 1: Configurazione dei prerequisiti](#walkthrough-prereq)
+ [Fase 2: Copia del codice di esempio](#walkthrough-script)
+ [(Facoltativo) Fase 3: Indicizzazione dei dati di esempio](#walkthrough-sample-data)
+ [Fase 4: Analisi e visualizzazione dei dati](#walkthrough-analysis)
+ [Fase 5: Pulizia delle risorse e fasi successive](#walkthrough-next-steps)
## Fase 1: Configurazione dei prerequisiti
Prima di procedere, devi disporre delle risorse indicate di seguito.
****
| Prerequisito | Description |
| --- | --- |
| Bucket Amazon S3 | Per ulteriori informazioni, consulta [Creazione di un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) nella Guida per l'utente di Amazon Simple Storage Service. |
| OpenSearch Dominio del servizio | Destinazione per i dati. Per ulteriori informazioni, consulta [Creazione di domini OpenSearch di servizio](createupdatedomains.md#createdomains). |
Se non si dispone già di queste risorse, è possibile crearle utilizzando i comandi AWS CLI seguenti:
```
aws s3 mb s3://my-transcribe-test --region us-west-2
```
```
aws opensearch create-domain --domain-name my-transcribe-test --engine-version OpenSearch_1.0 --cluster-config InstanceType=t2.medium.search,InstanceCount=1 --ebs-options EBSEnabled=true,VolumeType=standard,VolumeSize=10 --access-policies '{"Version": "2012-10-17", "Statement":[{"Effect":"Allow","Principal":{"AWS":"arn:aws:iam::123456789012:root"},"Action":"es:*","Resource":"arn:aws:es:us-west-2:123456789012:domain/my-transcribe-test/*"}]}' --region us-west-2
```
**Nota**
Questi comandi utilizzano la regione `us-west-2`, ma è possibile usare qualsiasi regione supportata da Amazon Comprehend. Per ulteriori informazioni consulta [Riferimenti generali di AWS](https://docs.aws.amazon.com/general/latest/gr/rande.html#comprehend_region).
## Fase 2: Copia del codice di esempio
1. Copiare e incollare il seguente codice di esempio Python 3 in un nuovo file denominato `call-center.py`:
```
import boto3
import datetime
import json
import requests
from requests_aws4auth import AWS4Auth
import time
import urllib.request
# Variables to update
audio_file_name = '' # For example, 000001.mp3
bucket_name = '' # For example, my-transcribe-test
domain = '' # For example, https://search-my-transcribe-test-12345.us-west-2.es.amazonaws.com
index = 'support-calls'
type = '_doc'
region = 'us-west-2'
# Upload audio file to S3.
s3_client = boto3.client('s3')
audio_file = open(audio_file_name, 'rb')
print('Uploading ' + audio_file_name + '...')
response = s3_client.put_object(
Body=audio_file,
Bucket=bucket_name,
Key=audio_file_name
)
# # Build the URL to the audio file on S3.
# # Only for the us-east-1 region.
# mp3_uri = 'https://' + bucket_name + '.s3.amazonaws.com/' + audio_file_name
# Get the necessary details and build the URL to the audio file on S3.
# For all other regions.
response = s3_client.get_bucket_location(
Bucket=bucket_name
)
bucket_region = response['LocationConstraint']
mp3_uri = 'https://' + bucket_name + '.s3-' + bucket_region + '.amazonaws.com/' + audio_file_name
# Start transcription job.
transcribe_client = boto3.client('transcribe')
print('Starting transcription job...')
response = transcribe_client.start_transcription_job(
TranscriptionJobName=audio_file_name,
LanguageCode='en-US',
MediaFormat='mp3',
Media={
'MediaFileUri': mp3_uri
},
Settings={
'ShowSpeakerLabels': True,
'MaxSpeakerLabels': 2 # assumes two people on a phone call
}
)
# Wait for the transcription job to finish.
print('Waiting for job to complete...')
while True:
response = transcribe_client.get_transcription_job(TranscriptionJobName=audio_file_name)
if response['TranscriptionJob']['TranscriptionJobStatus'] in ['COMPLETED', 'FAILED']:
break
else:
print('Still waiting...')
time.sleep(10)
transcript_uri = response['TranscriptionJob']['Transcript']['TranscriptFileUri']
# Open the JSON file, read it, and get the transcript.
response = urllib.request.urlopen(transcript_uri)
raw_json = response.read()
loaded_json = json.loads(raw_json)
transcript = loaded_json['results']['transcripts'][0]['transcript']
# Send transcript to Comprehend for key phrases and sentiment.
comprehend_client = boto3.client('comprehend')
# If necessary, trim the transcript.
# If the transcript is more than 5 KB, the Comprehend calls fail.
if len(transcript) > 5000:
trimmed_transcript = transcript[:5000]
else:
trimmed_transcript = transcript
print('Detecting key phrases...')
response = comprehend_client.detect_key_phrases(
Text=trimmed_transcript,
LanguageCode='en'
)
keywords = []
for keyword in response['KeyPhrases']:
keywords.append(keyword['Text'])
print('Detecting sentiment...')
response = comprehend_client.detect_sentiment(
Text=trimmed_transcript,
LanguageCode='en'
)
sentiment = response['Sentiment']
# Build the Amazon OpenSearch Service URL.
id = audio_file_name.strip('.mp3')
url = domain + '/' + index + '/' + type + '/' + id
# Create the JSON document.
json_document = {'transcript': transcript, 'keywords': keywords, 'sentiment': sentiment, 'timestamp': datetime.datetime.now().isoformat()}
# Provide all details necessary to sign the indexing request.
credentials = boto3.Session().get_credentials()
awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, 'opensearchservice', session_token=credentials.token)
# Index the document.
print('Indexing document...')
response = requests.put(url, auth=awsauth, json=json_document, headers=headers)
print(response)
print(response.json())
```
1. Aggiornare le prime sei variabili.
1. Installare i pacchetti necessari utilizzando i comandi seguenti:
```
pip install boto3
pip install requests
pip install requests_aws4auth
```
1. Inserisci il tuo MP3 nella stessa directory `call-center.py` ed esegui lo script. Di seguito è riportato un output di esempio:
```
$ python call-center.py
Uploading 000001.mp3...
Starting transcription job...
Waiting for job to complete...
Still waiting...
Still waiting...
Still waiting...
Still waiting...
Still waiting...
Still waiting...
Still waiting...
Detecting key phrases...
Detecting sentiment...
Indexing document...
{u'_type': u'call', u'_seq_no': 0, u'_shards': {u'successful': 1, u'failed': 0, u'total': 2}, u'_index': u'support-calls4', u'_version': 1, u'_primary_term': 1, u'result': u'created', u'_id': u'000001'}
```
`call-center.py` esegue una serie di operazioni:
1. Lo script carica un file audio (in questo caso, un MP3, ma Amazon Transcribe supporta diversi formati) nel tuo bucket S3.
1. Invia l'URL del file audio ad Amazon Transcribe e attende il completamento del processo di trascrizione.
Il tempo necessario per completare il processo di trascrizione dipende dalla durata del file audio. Supponiamo siano minuti, non secondi.
**Suggerimento**
Per migliorare la qualità della trascrizione, è possibile configurare un [vocabolario personalizzato](https://docs.aws.amazon.com/transcribe/latest/dg/API_CreateVocabulary.html) per Amazon Transcribe.
1. Una volta completato il processo di trascrizione, lo script estrae la trascrizione, la riduce a 5.000 caratteri e la invia ad Amazon Comprehend per l'analisi del sentiment e delle parole chiave.
1. Infine, lo script aggiunge la trascrizione completa, le parole chiave, il sentimento e il timestamp corrente a un documento JSON e lo indicizza in Service. OpenSearch
**Suggerimento**
[LibriVox](https://librivox.org/)dispone di audiolibri di dominio pubblico che puoi usare per i test.
## (Facoltativo) Fase 3: Indicizzazione dei dati di esempio
Se non si dispone di un gruppo di registrazioni di chiamate (chi le ha, effettivamente?) è possibile [indicizzare](indexing.md) i documenti campione in [sample-calls.zip](samples/sample-calls.zip), con un risultato simile a quello prodotto da `call-center.py`.
1. Creare un file denominato `bulk-helper.py`:
```
import boto3
from opensearchpy import OpenSearch, RequestsHttpConnection
import json
from requests_aws4auth import AWS4Auth
host = '' # For example, my-test-domain.us-west-2.es.amazonaws.com
region = '' # For example, us-west-2
service = 'es'
bulk_file = open('sample-calls.bulk', 'r').read()
credentials = boto3.Session().get_credentials()
awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token)
search = OpenSearch(
hosts = [{'host': host, 'port': 443}],
http_auth = awsauth,
use_ssl = True,
verify_certs = True,
connection_class = RequestsHttpConnection
)
response = search.bulk(bulk_file)
print(json.dumps(response, indent=2, sort_keys=True))
```
1. Aggiornare le prime due variabili per `host` e `region`.
1. Installare il pacchetto necessario utilizzando il seguente comando:
```
pip install opensearch-py
```
1. Scaricare e decomprimere [sample-calls.zip](samples/sample-calls.zip).
1. Posizionare `sample-calls.bulk` nella stessa directory di `bulk-helper.py` ed eseguire lo script helper. Di seguito è riportato un output di esempio:
```
$ python bulk-helper.py
{
"errors": false,
"items": [
{
"index": {
"_id": "1",
"_index": "support-calls",
"_primary_term": 1,
"_seq_no": 42,
"_shards": {
"failed": 0,
"successful": 1,
"total": 2
},
"_type": "_doc",
"_version": 9,
"result": "updated",
"status": 200
}
},
...
],
"took": 27
}
```
## Fase 4: Analisi e visualizzazione dei dati
Ora che hai alcuni dati in OpenSearch Service, puoi visualizzarli utilizzando i dashboard. OpenSearch
1. Accedi a `https://search-domain.region.es.amazonaws.com/_dashboards`.
1. Prima di poter utilizzare le OpenSearch dashboard, è necessario un modello di indice. Dashboards usa modelli di indice per limitare l'analisi a uno o più indici. Per abbinare l'indice `support-calls` creato da `call-center.py`, passare a **Gestione degli stack**, **Modelli di indice** e definire un modello di indice di `support*`, quindi scegliere **Approfondimenti**.
1. In **Time Filter field name (Nome campo Filtro tempo)**, scegliere **timestamp**.
1. Ora è possibile iniziare a creare le visualizzazioni. Scegliere **Visualize (Visualizza)**, quindi aggiungere una nuova visualizzazione.
1. Scegliere il grafico a torta e il modello dell'indice `support*`.
1. La visualizzazione predefinita è di base, quindi scegliere **Split Slices (Dividi sezioni)** per creare una visualizzazione più interessante.
Per **Aggregation (Aggregazione)** scegliere **Terms (Termini)**. In **Field (Campo)**, scegliere **sentiment.keyword**. Quindi selezionare **Apply changes (Applica modifiche)** e poi **Save (Salva)**.
![\[Configurazione di esempio per un grafico a torta di Dashboards.\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/sentiment-pie-chart.png)
1. Tornare alla pagina **Visualize (Visualizza)** e aggiungere un'altra visualizzazione. Questa volta, scegliere il grafico a barre orizzontali.
1. Scegliere **Split Series (Dividi serie)**.
Per **Aggregation (Aggregazione)** scegliere **Terms (Termini)**. In **Field (Campo)**, scegliere **keywords.keyword** e modificare **Size (Dimensioni)** in 20. Quindi selezionare **Apply Changes (Applica modifiche)** e poi **Save (Salva)**.
![\[Configurazione di esempio per un grafico a barre orizzontali di Dashboards.\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/keyword-bar-chart.png)
1. Tornare alla pagina **Visualize (Visualizza)** e aggiungere una visualizzazione finale, un grafico a barre verticali.
1. Scegliere **Split Series (Dividi serie)**. In **Aggregation (Aggregazione)**, scegliere **Date Histogram (Istogramma date)**. In **Field (Campo)**, scegliere **timestamp** e modificare **Interval (Intervallo)** in **Daily (Giornaliero)**.
1. Scegliere **Metrics & Axes (Parametri e assi)** e cambiare **Mode (Modalità)** in **normal (normale)**.
1. Selezionare **Apply Changes (Applica modifiche)** e poi **Save (Salva)**.
![\[Configurazione di esempio per un grafico a barre verticali di Dashboards.\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/timestamp-bar-chart-2.png)
1. Ora che si dispone di tre visualizzazioni, è possibile aggiungerle a una visualizzazione di Dashboards. Scegliere **Dashboard (Pannello di controllo)**, creare un pannello di controllo e aggiungere le visualizzazioni.
![\[Visualizzazione di Dashboards di esempio.\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/dashboard-2.png)
## Fase 5: Pulizia delle risorse e fasi successive
Per evitare addebiti inutili, elimina il bucket S3 e OpenSearch il dominio di servizio. Per ulteriori informazioni, consulta [Delete a Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-or-empty-bucket.html#delete-bucket) nella *Amazon Simple Storage Service User Guide* e [Delete an OpenSearch Service domain](gsgdeleting.md) in questa guida.
Le trascrizioni richiedono molto meno spazio su disco rispetto ai file. MP3 Potresti riuscire ad abbreviare il MP3 periodo di conservazione, ad esempio da tre mesi di registrazioni delle chiamate a un mese, conservare anni di trascrizioni e comunque risparmiare sui costi di archiviazione.
Puoi anche automatizzare il processo di trascrizione utilizzando and AWS Step Functions Lambda, aggiungere metadati aggiuntivi prima dell'indicizzazione o creare visualizzazioni più complesse per adattarle al tuo caso d'uso esatto.