Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Tutoriales OpenSearch de Amazon Service
En este capítulo se incluyen varios start-to-finish tutoriales para trabajar con Amazon OpenSearch Service, que incluyen cómo migrar al servicio, crear una aplicación de búsqueda sencilla y crear una visualización en los OpenSearch paneles de control.
**Topics**
+ [Tutorial: Creación y búsqueda de documentos en Amazon OpenSearch Service](quick-start.md)
+ [Tutorial: Migración a Amazon Service OpenSearch](migration.md)
+ [Tutorial: Creación de una aplicación de búsqueda con Amazon OpenSearch Service](search-example.md)
+ [Tutorial: Visualización de las llamadas de atención al cliente con el OpenSearch servicio y los paneles OpenSearch](walkthrough.md)
# Tutorial: Creación y búsqueda de documentos en Amazon OpenSearch Service
En este tutorial, aprenderás a crear y buscar un documento en Amazon OpenSearch Service. Los datos se añaden a un índice en forma de documento JSON. OpenSearch El servicio crea un índice alrededor del primer documento que se agrega.
Este tutorial explica cómo llevar a cabo solicitudes HTTP para crear documentos, generar automáticamente un ID para un documento y hacer búsquedas básicas y avanzadas en los documentos.
**nota**
En este tutorial, se utiliza un dominio de acceso abierto. Para obtener el máximo nivel de seguridad, es recomendable que coloque su dominio dentro de una nube privada virtual (VPC).
## Requisitos previos
Este tutorial tiene los requisitos previos siguientes:
+ Debe tener un Cuenta de AWS.
+ Debe tener un dominio de OpenSearch servicio activo.
## Adición de un documento a un índice
Para añadir un documento a un índice, puede utilizar cualquier herramienta HTTP, como [Postman](https://www.getpostman.com/), cURL o OpenSearch la consola Dashboards. En estos ejemplos se supone que está utilizando la consola de desarrollador en Dashboards. OpenSearch Si utiliza una herramienta diferente, ajústela según corresponda proporcionando la URL completa y las credenciales, si es necesario.
**Para agregar un documento a un índice**
1. Navega hasta la URL de los OpenSearch paneles de control de tu dominio. Puedes encontrar la URL en el panel de control del dominio, en la consola OpenSearch de servicio. La URL tiene este formato:
```
domain-endpoint/_dashboards/
```
1. Inicie sesión con su nombre de usuario y contraseña principales.
1. Abra el panel de navegación izquierdo y elija **Herramientas para desarrolladores**.
1. El verbo HTTP para crear un nuevo recurso es PUT, que es lo que se utiliza para crear un nuevo documento e índice. Ingrese el siguiente comando en la consola:
```
PUT fruit/_doc/1
{
"name":"strawberry",
"color":"red"
}
```
La solicitud `PUT` crea un índice llamado *fruit* (fruta) y agrega un solo documento al índice con un ID de 1. Produce la siguiente respuesta:
```
{
"_index" : "fruit",
"_type" : "_doc",
"_id" : "1",
"_version" : 1,
"result" : "created",
"_shards" : {
"total" : 2,
"successful" : 2,
"failed" : 0
},
"_seq_no" : 0,
"_primary_term" : 1
}
```
## La creación se genera automáticamente IDs
OpenSearch El servicio puede generar automáticamente una identificación para sus documentos. El comando que se genera IDs utiliza una solicitud POST en lugar de una solicitud PUT y no requiere ningún identificador de documento (en comparación con la solicitud anterior).
Ingrese la siguiente solicitud en la consola para desarrolladores:
```
POST veggies/_doc
{
"name":"beet",
"color":"red",
"classification":"root"
}
```
Esta solicitud crea un índice denominado *veggies* (verduras) y agrega el documento al índice. Produce la siguiente respuesta:
```
{
"_index" : "veggies",
"_type" : "_doc",
"_id" : "3WgyS4IB5DLqbRIvLxtF",
"_version" : 1,
"result" : "created",
"_shards" : {
"total" : 2,
"successful" : 2,
"failed" : 0
},
"_seq_no" : 0,
"_primary_term" : 1
}
```
Tenga en cuenta el campo `_id` adicional de la respuesta, que indica que se creó un ID automáticamente.
**nota**
No proporcione nada después de `_doc` en la URL, donde normalmente va el ID. Como va a crear un documento con un ID generado, aún no debe proporcionar uno. Eso está reservado para actualizaciones.
## Actualización de un documento con un comando POST
Para actualizar un documento, se utiliza un comando `POST` de HTTP con el número de ID.
En primer lugar, cree un documento con un ID de `42`:
```
POST fruits/_doc/42
{
"name":"banana",
"color":"yellow"
}
```
A continuación, utilice ese ID para actualizar el documento:
```
POST fruits/_doc/42
{
"name":"banana",
"color":"yellow",
"classification":"berries"
}
```
Este comando actualiza el documento con el nuevo campo `classification`. Produce la siguiente respuesta:
```
{
"_index" : "fruits",
"_type" : "_doc",
"_id" : "42",
"_version" : 2,
"result" : "updated",
"_shards" : {
"total" : 2,
"successful" : 2,
"failed" : 0
},
"_seq_no" : 1,
"_primary_term" : 1
}
```
**nota**
Si intenta actualizar un documento que no existe, OpenSearch Service lo crea.
## Ejecución de acciones por lotes
Puede utilizar la operación de la API de `POST _bulk` para llevar a cabo varias acciones en uno o más índices en una solicitud. Los comandos de acción por lotes tienen el siguiente formato:
```
POST /_bulk
\n
\n
\n
\n
```
Cada acción requiere dos líneas de JSON. Primero, debe proporcionar la descripción de la acción o los metadatos. En la línea siguiente, debe proporcionar los datos. Cada parte está separada por una nueva línea (\$1n). La descripción de una acción de una inserción podría verse de la siguiente manera:
```
{ "create" : { "_index" : "veggies", "_type" : "_doc", "_id" : "7" } }
```
La línea siguiente que contiene los datos podría verse de la siguiente manera:
```
{ "name":"kale", "color":"green", "classification":"leafy-green" }
```
En conjunto, los metadatos y los datos representan una sola acción en una operación masiva. Puede llevar a cabo muchas operaciones en una sola solicitud, como esta:
```
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" } }
```
Observe que la última acción es `delete`. No hay datos después de la acción `delete`.
## Búsqueda de documentos
Ya que existen datos en el clúster, puede buscarlos. Por ejemplo, es posible que quiera buscar todos los tubérculos, obtener un recuento de todos los vegetales de hoja verde o encontrar la cantidad de errores registrados por hora.
**Búsquedas básicas**
Una búsqueda básica tiene un aspecto similar a este:
```
GET veggies/_search?q=name:l*
```
La solicitud produce una respuesta JSON que contiene el documento de lechuga.
**Búsquedas avanzadas**
Puede hacer búsquedas más avanzadas si proporciona las opciones de consulta como JSON en el cuerpo de la solicitud:
```
GET veggies/_search
{
"query": {
"term": {
"name": "lettuce"
}
}
}
```
Este ejemplo también produce una respuesta JSON con el documento de lechuga.
**Ordenar**
Puede llevar a cabo más consultas de este tipo mediante la acción de ordenar. En primer lugar, debe volver a crear el índice porque la asignación automática de campos eligió tipos que no se pueden ordenar de forma predeterminada. Envíe las siguientes solicitudes para eliminar y volver a crear el índice:
```
DELETE /veggies
PUT /veggies
{
"mappings":{
"properties":{
"name":{
"type":"keyword"
},
"color":{
"type":"keyword"
},
"classification":{
"type":"keyword"
}
}
}
}
```
A continuación, rellene el índice con datos:
```
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" }
```
Ya puede buscar con un orden. Esta solicitud agrega un orden ascendente por clasificación:
```
GET veggies/_search
{
"query" : {
"term": { "color": "green" }
},
"sort" : [
"classification"
]
}
```
## Recursos relacionados
Para obtener más información, consulte los siguientes recursos:
+ [Cómo empezar a usar Amazon OpenSearch Service](gsg.md)
+ [Indexación de datos en Amazon Service OpenSearch](indexing.md)
+ [Búsqueda de datos en Amazon OpenSearch Service](searching.md)
# Tutorial: Migración a Amazon Service OpenSearch
Las instantáneas de índice son una forma popular de migrar de un clúster de Elasticsearch heredado OpenSearch o autogestionado a Amazon Service. OpenSearch En términos generales, el proceso consta de los siguientes pasos:
1. Tome una instantánea del clúster existente y cargue la instantánea en un bucket de Amazon S3.
1. Crea un dominio de servicio. OpenSearch
1. Conceda permisos al OpenSearch Servicio para acceder al depósito y asegúrese de tener permisos para trabajar con las instantáneas.
1. Restaure la instantánea en el dominio del OpenSearch servicio.
Este tutorial proporciona pasos más detallados y opciones alternativas, cuando corresponda.
## Tomar y cargar la instantánea
Si bien puedes usar el complemento [repository-s3](https://docs.opensearch.org/latest/opensearch/snapshot-restore/#amazon-s3) para tomar instantáneas directamente en S3, debes instalar el complemento en cada nodo, realizar ajustes `opensearch.yml` (o `elasticsearch.yml` si usas un clúster de Elasticsearch), reiniciar cada nodo, añadir tus AWS credenciales y, finalmente, tomar la instantánea. El complemento es una gran opción para uso continuo o para migrar clústeres más grandes.
En el caso de los clústeres más pequeños, una solución única consiste en tomar una [instantánea del sistema de archivos compartido](https://docs.opensearch.org/latest/opensearch/snapshot-restore/#shared-file-system) y, a continuación, utilizarla para subirla a S3. AWS CLI Si ya tiene una instantánea, vaya al paso 4.
****Cómo tomar una instantánea y cargarla a Amazon S3****
1. Agregue la configuración `path.repo` a `opensearch.yml` (o `Elasticsearch.yml`) en todos los nodos y, a continuación, reinicie cada nodo.
```
path.repo: ["/my/shared/directory/snapshots"]
```
1. Registre un [repositorio de instantáneas](https://opensearch.org/docs/latest/opensearch/snapshot-restore/#register-repository), necesario antes de tomar una instantánea. Un repositorio es solo una ubicación de almacenamiento: un sistema de archivos compartido, Amazon S3, un sistema de archivos distribuido de Hadoop (HDFS), etc. En este caso, utilizaremos un sistema de archivos compartido (“fs”):
```
PUT _snapshot/my-snapshot-repo-name
{
"type": "fs",
"settings": {
"location": "/my/shared/directory/snapshots"
}
}
```
1. Tomar la instantánea:
```
PUT _snapshot/my-snapshot-repo-name/my-snapshot-name
{
"indices": "migration-index1,migration-index2,other-indices-*",
"include_global_state": false
}
```
1. Instale la [AWS CLI](https://aws.amazon.com/cli/) y ejecute `aws configure` para agregar sus credenciales.
1. Desplácese hasta el directorio de instantáneas. A continuación, ejecute los siguientes comandos para crear un nuevo bucket de S3 y cargar el contenido del directorio de instantáneas en ese bucket:
```
aws s3 mb s3://amzn-s3-demo-bucket --region us-west-2
aws s3 sync . s3://amzn-s3-demo-bucket --sse AES256
```
En función del tamaño de la instantánea y la velocidad de su conexión a internet, esta operación puede tardar un tiempo.
## Crear un dominio
Aunque la consola es la forma más sencilla de crear un dominio, en este caso ya tienes el terminal abierto e AWS CLI instalado. Modifique el siguiente comando para crear un dominio que se ajuste a sus necesidades:
```
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
```
Tal como está, el comando crea un dominio accesible a Internet con dos nodos de datos, cada uno con 100 GiB de almacenamiento. También habilita el [control de acceso detallado](fgac.md) con autenticación básica HTTP y toda la configuración de cifrado. Utilice la consola de OpenSearch servicio si necesita una configuración de seguridad más avanzada, como una VPC.
Antes de ejecutar el comando, cambie el nombre de dominio, las credenciales del usuario maestro y el número de cuenta. Especifique la misma Región de AWS que utilizó para el bucket de S3 y una OpenSearch/Elasticsearch versión que sea compatible con la instantánea.
**importante**
Las instantáneas solo son compatibles con versiones posteriores y solo con una versión principal. Por ejemplo, no puede restaurar una instantánea a partir de un OpenSearch 1. *x* clúster en un Elasticsearch 7. *x* clúster, solo un OpenSearch 1. *x* o 2. cúmulo *x*. La versión secundaria también importa. No puede restaurar una instantánea de un clúster 5.3.3 autogestionado en un dominio de servicio 5.3.2 OpenSearch . Te recomendamos que elijas la versión más reciente de Elasticsearch OpenSearch compatible con tu instantánea. Para obtener una tabla de versiones compatibles, consulte [Uso de una instantánea para migrar datos](snapshot-based-migration.md).
## Conceda permisos al bucket de S3.
[En la consola AWS Identity and Access Management (IAM), [cree un rol](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html) con los siguientes permisos y relación de confianza.](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-managingrole_edit-trust-policy) Al crear un rol, elija **S3** como el **Servicio de AWS **. Asigne al rol el nombre `OpenSearchSnapshotRole` para que sea fácil de encontrar.
**Permisos**
------
#### [ 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/*"
]
}
]
}
```
------
**Relación de confianza**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"Service": "es.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Después, conceda permisos a su rol de IAM personal para asumir `OpenSearchSnapshotRole`. Cree la siguiente política y [adjúntela](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) a su identidad.
**Permisos**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::123456789012:role/OpenSearchSnapshotRole"
}
]
}
```
------
### Asigne la función de instantánea en los OpenSearch paneles de control (si utiliza un control de acceso detallado)
Si ha habilitado el [control de acceso detallado](fgac.md#fgac-mapping), incluso si utiliza autenticación HTTP básica para todos los demás fines, debe asignar el rol `manage_snapshots` al rol de IAM para poder trabajar con instantáneas.
**Para otorgar permisos a la identidad a fin de trabajar con instantáneas**
1. Inicie sesión en Dashboards con las credenciales de usuario maestro que especificó al crear el dominio del servicio. OpenSearch Puede encontrar la URL de los paneles en la consola de OpenSearch servicio. Adopta el formato `https://domain-endpoint/_dashboards/`.
1. En el menú principal, seleccione **Seguridad**, **Roles** y seleccione el rol **manage\$1snapshots**.
1. Seleccione **Usuarios asignados**, **Administrar mapeo**.
1. Agregue el ARN del dominio de su rol de IAM personal en el campo apropiado. El ARN está en uno de los siguientes formatos:
```
arn:aws:iam::123456789123:user/user-name
```
```
arn:aws:iam::123456789123:role/role-name
```
1. Seleccione **Asignar** y confirme que el rol aparece en **Usuarios asignados**.
## Restaurar la instantánea
En este momento, tiene dos formas de acceder a su dominio de OpenSearch servicio: mediante la autenticación básica HTTP con sus credenciales de usuario maestro o mediante la AWS autenticación con sus credenciales de IAM. Como las instantáneas utilizan Amazon S3, que no tiene el concepto de usuario maestro, debe utilizar sus credenciales de IAM para registrar el repositorio de instantáneas en su dominio de OpenSearch servicio.
La mayoría de los lenguajes de programación tienen bibliotecas para ayudar con las solicitudes de firma, pero el enfoque más simple es utilizar una herramienta como [Postman](https://www.postman.com/downloads/) y poner sus credenciales de IAM en la sección **Autorización**.
![\[Postman interface showing Authorization settings for AWS API request with Signature type.\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/migration2.png)
**Para restaurar la instantánea**
1. Independientemente de cómo elija firmar sus solicitudes, el primer paso es registrar el repositorio:
```
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. A continuación, enumere las instantáneas en el repositorio y busque la que desea restaurar. En este punto, puede continuar utilizando Postman o cambiar a una herramienta como [curl](https://curl.haxx.se/).
**Abreviado**
```
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. Restaurare la instantánea.
**Abreviado**
```
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. Finalmente, verifique que sus índices se restablecieron como se esperaba.
**Abreviado**
```
GET _cat/indices?v
```
**curl**
```
curl -XGET -u 'master-user:master-user-password' https://domain-endpoint/_cat/indices?v
```
En este punto, la migración está completa. Puede configurar sus clientes para que usen el nuevo punto de enlace del OpenSearch servicio, [cambiar el tamaño del dominio](sizing-domains.md) para adaptarlo a su carga de trabajo, comprobar el número de fragmentos de sus índices, cambiar a un [usuario maestro de IAM](fgac.md#fgac-concepts) o empezar a crear visualizaciones en los paneles. OpenSearch
# Tutorial: Creación de una aplicación de búsqueda con Amazon OpenSearch Service
Una forma habitual de crear una aplicación de búsqueda con Amazon OpenSearch Service consiste en utilizar formularios web para enviar las consultas de los usuarios a un servidor. Luego, puedes autorizar al servidor a que lo llame OpenSearch APIs directamente y hacer que el servidor envíe las solicitudes al OpenSearch Servicio. Pero si desea escribir un código del lado del cliente que no dependa de un servidor, debe compensar los riesgos de seguridad y rendimiento. No es aconsejable permitir el acceso público y sin firma al OpenSearch APIs . Los usuarios pueden acceder a puntos de conexión no protegidos o influir en el rendimiento del clúster a través de consultas demasiado complejas (o demasiadas consultas).
En este capítulo se presenta una solución: utilice Amazon API Gateway para restringir a los usuarios a un subconjunto de ellos OpenSearch APIs y AWS Lambda para firmar las solicitudes de API Gateway al OpenSearch servicio.
![\[Diagrama de flujo de la aplicación de búsqueda.\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/search-application-diagram.png)
**nota**
Se aplican precios estándar de API Gateway y Lambda, pero dentro del uso limitado de este tutorial, los costos deben ser insignificantes.
## Requisitos previos
Un requisito previo para este tutorial es un dominio OpenSearch de servicio. Si aún no tiene uno, siga los pasos que se indican en [Crear un dominio de OpenSearch servicio](gsgcreate-domain.md) para crear uno.
## Paso 1: Indexe los datos de muestra
Descargue [sample-movies.zip](samples/sample-movies.zip), descomprímalo y utilice la operación [\$1bulk](https://opensearch.org/docs/latest/api-reference/document-apis/bulk/) de la API para agregar 5000 documentos al índice `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"}
...
```
Tenga en cuenta que lo anterior es un comando de ejemplo con un pequeño subconjunto de datos disponibles. Para realizar la operación `_bulk`, debe copiar y pegar todo el contenido del archivo `sample-movies`. Para obtener más instrucciones, consulte [Opción 2: cargar varios documentos](gsgupload-data.md#gsgmultiple-document).
También puede utilizar el siguiente comando curl para conseguir el mismo resultado:
```
curl -XPOST -u 'master-user:master-user-password' 'domain-endpoint/_bulk' --data-binary @bulk_movies.json -H 'Content-Type: application/json'
```
## Paso 2: crear e implementar una función de Lambda
Antes de crear su API en API Gateway, cree la función de Lambda a la que pasa las solicitudes.
### Crear la función de Lambda
En esta solución, API Gateway pasa las solicitudes a una función de Lambda, que consulta el OpenSearch servicio y devuelve los resultados. Dado que esta función de ejemplo utiliza bibliotecas externas, debe crear un paquete de implementación y cargarlo en Lambda.
**Creación del paquete de implementación**
1. Abra un símbolo del sistema y cree un directorio del proyecto `my-opensearch-function`. Por ejemplo, en macOS:
```
mkdir my-opensearch-function
```
1. Desplácese hasta el directorio del proyecto `my-sourcecode-function`.
```
cd my-opensearch-function
```
1. Copie el contenido del siguiente código Python de ejemplo y guárdelo en un nuevo archivo denominado `opensearch-lambda.py`. Añada su región y el punto de conexión del host al archivo.
```
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. Instale las bibliotecas externas en un nuevo directorio `package`.
```
pip3 install --target ./package boto3
pip3 install --target ./package requests
pip3 install --target ./package requests_aws4auth
```
1. Cree un paquete de implementación con las bibliotecas instaladas en la raíz. El siguiente comando genera un archivo `my-deployment-package.zip` en el directorio de su proyecto.
```
cd package
zip -r ../my-deployment-package.zip .
```
1. Agregue el archivo `opensearch-lambda.py` a la raíz del archivo zip.
```
cd ..
zip my-deployment-package.zip opensearch-lambda.py
```
Para obtener más información sobre cómo crear funciones de Lambda y paquetes de implementación, consulte [Deploy Python Lambda functions with .zip file archives](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python-how-to-create-deployment-package.html) en la *Guía para desarrolladores de AWS Lambda * y [Crear el paquete de implementación de Lambda](integrations-s3-lambda.md#integrations-s3-lambda-deployment-package) en esta guía.
Cómo crear la función usando la consola de Lambda
1. [Diríjase a la consola Lambda de su https://console.aws.amazon.com/lambda/ casa.](https://console.aws.amazon.com/lambda/home ) En el panel de navegación izquierdo, seleccione **Funciones**.
1. Seleccione **Crear función**.
1. Configure los siguientes campos:
+ Nombre de función: opensearch-function
+ Tiempo de ejecución: Python 3.9
+ Arquitectura: x86\$164
Mantenga todas las demás opciones predeterminadas y elija **Crear función**.
1. En la sección **Código fuente** de la página de resumen de la función, seleccione el menú desplegable **Cargar desde** y seleccione el **archivo .zip**. Busque el archivo `my-deployment-package.zip` que ha creado y seleccione **Guardar**.
1. El *controlador* es el método de su código de función que procesa eventos. En **Configuración de tiempo de ejecución**, seleccione **Editar** y cambie el nombre del controlador de acuerdo con el nombre del archivo en el paquete de implementación donde se encuentra la función de Lambda. Como el archivo se denomina `opensearch-lambda.py`, cambie el nombre del controlador a `opensearch-lambda.lambda_handler`. Para más información, consulte [Controlador de funciones de Lambda en Python](https://docs.aws.amazon.com/lambda/latest/dg/python-handler.html).
## Paso 3: crear la API en API Gateway
El uso de API Gateway le permite crear una API más limitada y simplifica el proceso de interacción con la OpenSearch `_search` API. API Gateway le permite habilitar las características de seguridad, como la autenticación de Amazon Cognito y la limitación controlada. Realice los siguientes pasos para crear e implementar una API:
### Crear y configurar la API
Para crear una API mediante la consola de API Gateway
1. Dirígete a la consola de API Gateway en [https://console.aws.amazon.com/apigateway/casa](https://console.aws.amazon.com/apigateway/home ). En el panel de navegación izquierdo, selecciona **APIs**.
1. Localice **API de REST** (no privado) y elija **Crear**.
1. En la siguiente página, busque la sección **Crear nueva API** y asegúrese de que **Nueva API** esté seleccionada.
1. Configure los siguientes campos:
+ Nombre de la API: **opensearch-api**
+ Descripción: **API pública para buscar un dominio OpenSearch de Amazon Service**
+ Tipo de punto de conexión: **Regional**
1. Seleccione **Crear API**.
1. Seleccione **Acciones** y **Crear método**.
1. Seleccione **GET** (Obtener) en el menú desplegable y haga clic en la marca de verificación para confirmar.
1. Configure los siguientes ajustes y, a continuación, elija **Guardar**:
| Opción | Valor |
| --- | --- |
| Tipo de integración | Función de Lambda |
| Usar integración de proxy de Lambda | Sí |
| Región de Lambda | us-west-1 |
| Función de Lambda | opensearch-lambda |
| Usar tiempo de espera predeterminado | Sí |
### Configuración de la solicitud de método
Seleccione **Solicitud de método** y configure los siguientes ajustes:
| Opción | Valor |
| --- | --- |
| Autorización | NONE |
| Validador de solicitud | Validar parámetros de cadena de consulta y encabezados |
| Clave de API requerida | falso |
En **Parámetros de cadena de consulta de URL**, seleccione **Añadir cadena de consulta** y configure el siguiente parámetro:
| Opción | Valor |
| --- | --- |
| Name | q |
| Obligatorio | Sí |
### Implemente la API y configure una etapa
La consola de API Gateway le permite implementar una API creando una implementación y asociándola a una etapa nueva o una existente.
1. Seleccione **Acciones** e **Implementar API**.
1. Para **Etapa de implementación** elija **Nueva etapa** y nombre la etapa `opensearch-api-test`.
1. Seleccione **Implementar**.
1. Configure los siguientes ajustes en el editor de etapas y, a continuación, elija **Guardar los cambios**:
| Opción | Valor |
| --- | --- |
| Habilitar limitación controlada | Sí |
| Tarifa | 1 000 |
| Ráfagas | 500 |
Estos ajustes configuran una API que solo tiene un método: una solicitud `GET` al punto de conexión raíz (`https://some-id.execute-api.us-west-1.amazonaws.com/search-es-api-test`). La solicitud requiere un solo parámetro (`q`), la cadena de consulta que se busca. Cuando se llama, el método pasa la solicitud a Lambda, que ejecuta la función `opensearch-lambda`. Para más información, consulte [Creación de una API en Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-create-api.html) e [Implementación de una API de REST en Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-deploy-api.html).
## Paso 4: (opcional) modificar la política de acceso a dominios
Su dominio de OpenSearch servicio debe permitir que la función Lambda realice `GET` solicitudes al `movies` índice. Si su dominio tiene una política de acceso abierto con control de acceso detallado habilitado, puede dejarlo tal cual:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "*"
},
"Action": "es:*",
"Resource": "arn:aws:es:us-west-1:123456789012:domain/domain-name/*"
}
]
}
```
------
Como alternativa, puede elegir hacer su política de acceso a dominio más detallada. Por ejemplo, la siguiente política mínima proporciona acceso de lectura a `opensearch-lambda-role` (creado a través de Lambda) al índice `movies`. Para obtener el nombre exacto del rol que Lambda crea automáticamente, vaya a la consola AWS Identity and Access Management (IAM), elija **Roles** y busque «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**
Si ha habilitado un control de acceso detallado para el dominio, también debe asignar la [función a un usuario en los](fgac.md#fgac-mapping) OpenSearch paneles; de lo contrario, aparecerán errores de permisos.
### Configure los permisos del rol de ejecución de Lambda
Además de configurar la política de acceso al dominio, también debe asegurarse de que la función de ejecución de Lambda tenga los permisos de IAM necesarios para acceder a su OpenSearch dominio de servicio. La función Lambda requiere permisos específicos en función de si se utiliza un dominio gestionado o una colección de OpenSearch Service Serverless.
**Para los dominios de OpenSearch servicios gestionados:**
Adjunte la siguiente política de IAM a su función de ejecución de Lambda para que pueda realizar solicitudes a OpenSearch su dominio de servicio:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"es:ESHttpGet",
"es:ESHttpPost"
],
"Resource": "arn:aws:es:us-west-1:123456789012:domain/domain-name/*"
}
]
}
```
------
**Para las colecciones de OpenSearch Service Serverless:**
Si utiliza OpenSearch Service Serverless, adjunte la siguiente política de IAM a su función de ejecución de Lambda:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "aoss:*",
"Resource": "arn:aws:aoss:us-west-1:123456789012:collection/collection-id"
}
]
}
```
------
Para adjuntar estas políticas a su rol de ejecución de Lambda:
1. Vaya a la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Elija **Funciones** y busque su función de ejecución de Lambda (normalmente denominada `opensearch-lambda-role-xxxxxxxx`).
1. Elija **Agregar permisos** y luego **Crear política insertada**.
1. Elija la pestaña **JSON** y pegue la política correspondiente de arriba, sustituyendo los valores de los marcadores de posición por su recurso real. ARNs
1. Elija **Revisar política**, escriba un nombre como `OpenSearchAccess` y seleccione **Crear política**.
**nota**
Sin estos permisos de IAM, la función Lambda recibirá errores de «Acceso denegado» al intentar consultar OpenSearch el dominio del servicio, incluso si la política de acceso al dominio permite las solicitudes.
Para obtener más información sobre las políticas de acceso, consulte [Configurar políticas de acceso](createupdatedomains.md#createdomain-configure-access-policies).
## Asigne el rol de Lambda (si utiliza un control de acceso detallado)
El control de acceso detallado presenta un paso adicional antes de poder probar la aplicación. Incluso si utiliza la autenticación básica HTTP para todos los demás fines, es necesario asignar el rol de Lambda a un usuario, de lo contrario verá errores de permisos.
1. Navegue hasta la URL del OpenSearch panel de control del dominio.
1. En el menú principal, seleccione **Seguridad**, **Roles** y elija el enlace a `all_access`, el rol al que necesita asignar el rol de Lambda.
1. Seleccione **Usuarios asignados**, **Administrar mapeo**.
1. En **Roles de backend**, agregue el nombre de recurso de Amazon (ARN) del rol de Lambda. El ARN debe adoptar la forma de `arn:aws:iam::123456789123:role/service-role/opensearch-lambda-role-1abcdefg`.
1. Seleccione **Asignar** y confirme que el usuario o el rol aparecen en **Usuarios asignados**.
## Paso 5: Pruebe la aplicación web
**Para probar la aplicación web**
1. Descargue [sample-site.zip](samples/sample-site.zip), descomprímalo y abra `scripts/search.js` en el editor de texto de su elección.
1. Actualice la variable `apigatewayendpoint` para que apunte al punto de conexión de API Gateway y añada una barra oblicua al final de la ruta en cuestión. Puede encontrar rápidamente el punto de conexión en API Gateway seleccionando **Etapas** y seleccionando el nombre de la API. La variable `apigatewayendpoint` debe adoptar la forma de `https://some-id.execute-api.us-west-1.amazonaws.com/opensearch-api-test`/.
1. Abra `index.html` e intente ejecutar búsquedas de *thor*, *house* y algunos otros términos.
![\[A continuación se muestra un ejemplo de la búsqueda de thor.\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/search-ui.png)
### Solucionar errores de CORS
Aunque la función de Lambda incluye contenido en la respuesta para admitir CORS, es posible que aparezca el siguiente error:
```
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.
```
Si esto sucede, pruebe lo siguiente:
1. [Habilitar CORS](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-cors-console.html) en el recurso GET. En **Avanzado**, configure **Access-Control-Allow-Credentials** en `'true'`.
1. Vuelva a implementar su API en API Gateway (**Acciones**, **Implementar API**).
1. Elimine y vuelva a agregar el activador de la función de Lambda. Agregue volver a añadirlo, seleccione **Agregar desencadenador** y cree el punto de conexión HTTP que invoca su función. El desencadenador debe tener la siguiente configuración:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/search-example.html)
## Siguientes pasos
Este capítulo es solo un punto de partida para demostrar un concepto. Podría considerar las siguientes modificaciones:
+ Agregue sus propios datos al dominio del OpenSearch servicio.
+ Agregue métodos a su API.
+ En la función de Lambda, modifique la consulta de búsqueda o aumente los diferentes campos.
+ Aplique un estilo diferente a los resultados o modifique `search.js` para mostrar diferentes campos al usuario.
# Tutorial: Visualización de las llamadas de atención al cliente con el OpenSearch servicio y los paneles OpenSearch
Este capítulo es un tutorial completo de la siguiente situación: el servicio de atención al cliente de una empresa recibe llamadas y quiere analizarlas. ¿Cuál es el tema de cada llamada? ¿Cuántas fueron positivas? ¿Cuántas negativas? ¿Cómo los gerentes pueden buscar o revisar las transcripciones de estas llamadas?
Un flujo de trabajo manual puede implicar que los empleados escuchen las grabaciones, apunten el tema de cada llamada y decidan si la interacción con el cliente fue positiva.
Dicho proceso requeriría mucho esfuerzo y trabajo. Suponiendo un tiempo medio de 10 minutos por llamada, cada empleado podría escuchar solo 48 llamadas al día. Salvo sesgo humano, los datos que generan sería de alta precisión, pero la *cantidad* de datos sería mínima: tan solo el tema de la llamada y un valor booleano para determinar si el cliente quedó satisfecho. Cualquier información más compleja, como, por ejemplo, una transcripción completa, requeriría gran cantidad de tiempo.
Con [Amazon S3](https://aws.amazon.com/s3/), [Amazon Transcribe](https://aws.amazon.com/transcribe/), [Amazon Comprehend](https://aws.amazon.com/comprehend/) y OpenSearch Amazon Service, puede automatizar un proceso similar con muy poco código y obtener muchos más datos. Por ejemplo, puede obtener una transcripción completa de la llamada, palabras clave de la transcripción, y un "sentimiento" general de la llamada (positiva, negativa, neutra o mixta). Luego, puede usar OpenSearch los OpenSearch paneles de control para buscar y visualizar los datos.
Si bien puedes usar este tutorial tal como está, la intención es generar ideas sobre cómo enriquecer tus documentos JSON antes de indexarlos en Service. OpenSearch
**Costo estimado:**
En general, seguir los pasos que se indican en este tutorial debería costar menos de 2 USD. En este tutorial se utilizan los siguientes recursos:
+ bucket de S3 con menos de 100 MB transferidos y almacenados
Para obtener más información, consulte [Precios de Amazon S3](https://aws.amazon.com/s3/pricing/).
+ OpenSearch Dominio de servicio con una `t2.medium` instancia y 10 GiB de almacenamiento de EBS durante varias horas
Para obtener más información, consulta los [precios OpenSearch de Amazon Service](https://aws.amazon.com/elasticsearch-service/pricing/).
+ Varias llamadas a Amazon Transcribe
Para obtener más información, consulte [Precios de Amazon Transcribe](https://aws.amazon.com/transcribe/pricing/).
+ Varias llamadas de procesamiento de lenguaje natural a Amazon Comprehend
Para obtener más información, consulte [Precios de Amazon Comprehend](https://aws.amazon.com/comprehend/pricing/).
**Topics**
+ [Paso 1: configure los requisitos previos](#walkthrough-prereq)
+ [Paso 2: copie el código de muestra](#walkthrough-script)
+ [(Opcional) Paso 3: indexe los datos de ejemplo](#walkthrough-sample-data)
+ [Paso 4: analice y visualice sus datos](#walkthrough-analysis)
+ [Paso 5: elimine recursos y pasos siguientes](#walkthrough-next-steps)
## Paso 1: configure los requisitos previos
Antes de continuar, debe contar con los siguientes recursos.
****
| Requisito previo | Description (Descripción) |
| --- | --- |
| Bucket de Amazon S3 | Para obtener más información, consulte [Creación de un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) en la Guía del usuario de Amazon Simple Storage Service. |
| OpenSearch Dominio de servicio | El destino de los datos. Para obtener más información, consulte [Creación de dominios OpenSearch de servicio](createupdatedomains.md#createdomains). |
Si aún no tiene estos recursos, puede crearlos utilizando los siguientes comandos de la AWS CLI :
```
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**
Estos comandos utilizan la región `us-west-2`, pero puede utilizar cualquier región que admita Amazon Comprehend. Para obtener más información, consulte [Referencia general de AWS](https://docs.aws.amazon.com/general/latest/gr/rande.html#comprehend_region).
## Paso 2: copie el código de muestra
1. Copie y pegue el siguiente código de muestra de Python 3 en un archivo nuevo denominado `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. Actualice las seis variables iniciales.
1. Instale los paquetes necesarios mediante los siguientes comandos:
```
pip install boto3
pip install requests
pip install requests_aws4auth
```
1. Colóquelo MP3 en el mismo directorio `call-center.py` y ejecute el script. A continuación se indica un ejemplo de salida:
```
$ 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` realiza una serie de operaciones:
1. El script carga un archivo de audio (en este caso, un MP3, pero Amazon Transcribe admite varios formatos) a su bucket de S3.
1. Envía la URL del archivo de audio a Amazon Transcribe y espera que realice la tarea de transcripción.
El tiempo necesario para terminar el trabajo de transcripción depende de la duración del archivo de audio. Supongamos que tomará minutos, no segundos.
**sugerencia**
Para mejorar la calidad de la transcripción, puede configurar un [vocabulario personalizado](https://docs.aws.amazon.com/transcribe/latest/dg/API_CreateVocabulary.html) para Amazon Transcribe.
1. Una vez que el trabajo de transcripción termina, el script extrae la transcripción, la recorta a 5 000 caracteres y envía a Amazon Comprehend para identificar palabras clave y analizar el sentimiento.
1. Por último, el script agrega la transcripción completa, las palabras clave, el sentimiento y la marca de tiempo actual a un documento JSON y lo indexa en Service. OpenSearch
**sugerencia**
[LibriVox](https://librivox.org/)tiene audiolibros de dominio público que puede usar para realizar pruebas.
## (Opcional) Paso 3: indexe los datos de ejemplo
Si no tiene a mano varias grabaciones de llamadas, y no es algo muy frecuente, puede [indexar](indexing.md) los documentos de muestra en [sample-calls.zip](samples/sample-calls.zip), que son comparables a lo que produce `call-center.py`.
1. Cree un archivo denominado `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. Actualice las dos variables iniciales para `host` y `region`.
1. Instale el paquete necesario mediante el siguiente comando:
```
pip install opensearch-py
```
1. Descargue y descomprima [sample-calls.zip](samples/sample-calls.zip).
1. Guarde `sample-calls.bulk` en el mismo directorio que `bulk-helper.py` y ejecute el ayudante. A continuación se indica un ejemplo de salida:
```
$ 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
}
```
## Paso 4: analice y visualice sus datos
Ahora que tiene algunos datos en OpenSearch Service, puede visualizarlos mediante los OpenSearch paneles de control.
1. Vaya a `https://search-domain.region.es.amazonaws.com/_dashboards`.
1. Para poder usar los OpenSearch paneles, necesita un patrón de índice. Dashboards utiliza patrones de índice para limitar su análisis a uno o más índices. Para que coincida con el `support-calls`índice que`call-center.py` cree, diríjase a **Pila de administración**, **Patrones**, y defina un patrón de índice de `support*`. y luego elija **Paso siguiente**.
1. En **Time Filter field name (Nombre de campo Filtro de tiempo)**, elija **timestamp (marca temporal)**.
1. Ahora pude comenzar a crear visualizaciones. Seleccione **Visualize (Visualizar)** y añada una nueva visualización.
1. Seleccione el gráfico circular y el patrón de índice `support*`.
1. El valor predeterminado de visualización es básico. Si quiere crear una visualización más interesante, elija **Split Slices (Sectores divididos)**.
Para **Aggregation (Agregación)**, elija **Terms (Términos)**. En **Field (Campo)**, elija **sentiment.keyword**. Seleccione **Apply changes (Aplicar cambios)** y **Save (Guardar)**.
![\[Ejemplo de configuración para gráfico circular de Dashboards.\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/sentiment-pie-chart.png)
1. Vuelva a la página **Visualizar** y agregue otra visualización. Esta vez, elija el gráfico de barras horizontales.
1. Seleccione **Split Series (Series divididas)**.
Para **Aggregation (Agregación)**, elija **Terms (Términos)**. En **Field (Campo)**, elija **keywords.keyword** y cambie el valor de **Size (Tamaño)** a 20. Seleccione **Apply Changes (Aplicar cambios)** y **Save (Guardar)**.
![\[Ejemplo de configuración para gráfico de barras horizontales de Dashboards.\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/keyword-bar-chart.png)
1. Vuelva a la página **Visualizar** y agregue una última visualización, un gráfico de barras verticales.
1. Seleccione **Split Series (Series divididas)**. En **Aggregation (Agregación)**, elija **Date Histogram (Histograma de fecha)**. En **Field (Campo)**, elija **timestamp (marca temporal)** y cambie **Interval (Intervalo)** a **Daily (Diario)**.
1. Seleccione **Metrics & Axes (Métricas y ejes)** y cambie **Mode (Modo)** a **normal**.
1. Seleccione **Apply Changes (Aplicar cambios)** y **Save (Guardar)**.
![\[Ejemplo de configuración para gráfico de barras verticales de Dashboards.\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/timestamp-bar-chart-2.png)
1. Ahora que tiene tres visualizaciones, puede añadirlas a un panel de Dashboards. Seleccione **Dashboard (Panel)**, cree un panel y añada sus visualizaciones.
![\[Visualización de paneles de ejemplo.\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/dashboard-2.png)
## Paso 5: elimine recursos y pasos siguientes
Para evitar cargos innecesarios, elimine el bucket de S3 y el dominio OpenSearch de servicio. Para obtener más información, consulta [Eliminar un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-or-empty-bucket.html#delete-bucket) en la *Guía del usuario de Amazon Simple Storage Service* y [Eliminar un dominio de OpenSearch servicio](gsgdeleting.md) en esta guía.
Las transcripciones requieren mucho menos espacio en disco que MP3 los archivos. Es posible que pueda acortar el período de MP3 retención (por ejemplo, de tres meses de grabaciones de llamadas a un mes), conservar años de transcripciones y, aun así, ahorrar en costos de almacenamiento.
También puede automatizar el proceso de transcripción con AWS Step Functions Lambda, añadir metadatos adicionales antes de la indexación o crear visualizaciones más complejas que se adapten a su caso de uso exacto.