As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Tutoriais OpenSearch do Amazon Service
Este capítulo inclui vários start-to-finish tutoriais para trabalhar com o Amazon OpenSearch Service, incluindo como migrar para o serviço, criar um aplicativo de pesquisa simples e criar uma visualização em painéis. OpenSearch
**Topics**
+ [Tutorial: Criação e pesquisa de documentos no Amazon OpenSearch Service](quick-start.md)
+ [Tutorial: Migração para o Amazon Service OpenSearch](migration.md)
+ [Tutorial: Criando um aplicativo de pesquisa com o Amazon OpenSearch Service](search-example.md)
+ [Tutorial: Visualizando chamadas de suporte ao cliente com OpenSearch serviços e painéis OpenSearch](walkthrough.md)
# Tutorial: Criação e pesquisa de documentos no Amazon OpenSearch Service
Neste tutorial, você aprende a criar e pesquisar um documento no Amazon OpenSearch Service. Você adiciona dados a um índice na forma de um documento JSON. OpenSearch O serviço cria um índice em torno do primeiro documento que você adiciona.
Este tutorial explica como fazer solicitações HTTP para criar documentos, gerar automaticamente um ID para um documento e realizar pesquisas básicas e avançadas em seus documentos.
**nota**
Este tutorial usa um domínio com acesso aberto. Para obter o mais alto nível de segurança, recomendamos colocar o domínio em uma nuvem privada virtual (VPC).
## Pré-requisitos
Este tutorial tem os seguintes pré-requisitos:
+ Você deve ter um Conta da AWS.
+ Você deve ter um domínio OpenSearch de serviço ativo.
## Adicionar um documento a um índice
Para adicionar um documento a um índice, você pode usar qualquer ferramenta HTTP, como [Postman](https://www.getpostman.com/), cURL ou OpenSearch o console Dashboards. Esses exemplos pressupõem que você esteja usando o console do desenvolvedor em OpenSearch painéis. Se você estiver usando uma ferramenta diferente, ajuste adequadamente fornecendo o URL completo e as credenciais, se necessário.
**Para adicionar um documento a um índice**
1. Navegue até o URL dos OpenSearch painéis do seu domínio. Você pode encontrar o URL no painel do domínio no console OpenSearch de serviço. O URL segue este formato:
```
domain-endpoint/_dashboards/
```
1. Faça login usando o nome de usuário principal e a senha.
1. Abra o painel de navegação esquerdo e escolha **Ferramentas de desenvolvimento**.
1. O verbo HTTP para criar um novo recurso é PUT. É ele que deve ser usado para criar um novo documento e um índice. Insira o seguinte comando no console:
```
PUT fruit/_doc/1
{
"name":"strawberry",
"color":"red"
}
```
A solicitação `PUT` cria um índice chamado *fruit* e adiciona um único documento ao índice com um ID de 1. Ele produz a seguinte resposta:
```
{
"_index" : "fruit",
"_type" : "_doc",
"_id" : "1",
"_version" : 1,
"result" : "created",
"_shards" : {
"total" : 2,
"successful" : 2,
"failed" : 0
},
"_seq_no" : 0,
"_primary_term" : 1
}
```
## Criação gerada automaticamente IDs
OpenSearch O serviço pode gerar automaticamente uma identificação para seus documentos. O comando a ser gerado IDs usa uma solicitação POST em vez de uma solicitação PUT e não requer ID de documento (em comparação com a solicitação anterior).
Insira a seguinte solicitação no console do desenvolvedor:
```
POST veggies/_doc
{
"name":"beet",
"color":"red",
"classification":"root"
}
```
Essa solicitação cria um índice chamado *veggies* e adiciona o documento ao índice. Ele produz a seguinte resposta:
```
{
"_index" : "veggies",
"_type" : "_doc",
"_id" : "3WgyS4IB5DLqbRIvLxtF",
"_version" : 1,
"result" : "created",
"_shards" : {
"total" : 2,
"successful" : 2,
"failed" : 0
},
"_seq_no" : 0,
"_primary_term" : 1
}
```
Observe o campo adicional `_id` na resposta, que indica que um ID foi criado automaticamente.
**nota**
Você não acrescenta nada depois de `_doc` no URL, onde o ID normalmente é adicionado. Como está criando um documento com um ID gerado, você ainda não fornece um. Isso está reservado para atualizações.
## Atualizar um documento com um comando POST
Para atualizar um documento, use um comando HTTP `POST` com o número do ID.
Primeiro, crie um documento com ID `42`:
```
POST fruits/_doc/42
{
"name":"banana",
"color":"yellow"
}
```
Em seguida, use esse ID para atualizar o documento:
```
POST fruits/_doc/42
{
"name":"banana",
"color":"yellow",
"classification":"berries"
}
```
Esse comando atualiza o documento com o novo campo `classification`. Ele produz a seguinte resposta:
```
{
"_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 você tentar atualizar um documento que não existe, o OpenSearch Service cria o documento.
## Executar ações em massa
Você pode usar a operação da API `POST _bulk` para executar várias ações em um ou mais índices em uma solicitação. Os comandos de ação em massa têm o seguinte formato:
```
POST /_bulk
\n
\n
\n
\n
```
Cada ação requer duas linhas de JSON. Primeiro, é necessário fornecer a descrição ou os metadados da ação. Na próxima linha, você deve fornecer os dados. Cada parte é separada por uma nova linha (\$1n). Uma descrição de ação de uma inserção pode ser semelhante a esta:
```
{ "create" : { "_index" : "veggies", "_type" : "_doc", "_id" : "7" } }
```
E a próxima linha contendo os dados pode ter a seguinte aparência:
```
{ "name":"kale", "color":"green", "classification":"leafy-green" }
```
Juntos, os metadados e os dados representam uma única ação em uma operação em massa. Você pode realizar várias operações em uma solicitação, 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 a última ação é `delete`. Não há dados seguindo a ação `delete`.
## Pesquisando documentos
Agora que os dados existem no seu cluster, você pode procurá-los. Por exemplo, talvez você queira pesquisar todos os tubérculos ou obter uma contagem de todas as folhas verdes ou encontrar o número de erros registrados por hora.
**Pesquisas básicas**
Uma pesquisa básica é semelhante a esta:
```
GET veggies/_search?q=name:l*
```
A solicitação produz uma resposta JSON que contém o documento lettuce.
**Pesquisas avançadas**
É possível realizar pesquisas mais avançadas fornecendo as opções de consulta como JSON no corpo da solicitação:
```
GET veggies/_search
{
"query": {
"term": {
"name": "lettuce"
}
}
}
```
Este exemplo também produz uma resposta JSON com o documento lettuce.
**Classificar**
É possível executar mais desse tipo de consulta usando a classificação. Primeiro, é necessário recriar o índice, porque o mapeamento automático de campo escolheu tipos que não podem ser classificados por padrão. Envie as seguintes solicitações para excluir e recriar o índice:
```
DELETE /veggies
PUT /veggies
{
"mappings":{
"properties":{
"name":{
"type":"keyword"
},
"color":{
"type":"keyword"
},
"classification":{
"type":"keyword"
}
}
}
}
```
Em seguida, preencha novamente o índice com dados:
```
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" }
```
Agora você pode pesquisar com uma classificação. Esta solicitação adiciona uma classificação crescente:
```
GET veggies/_search
{
"query" : {
"term": { "color": "green" }
},
"sort" : [
"classification"
]
}
```
## Recursos relacionados
Para saber mais, consulte os seguintes recursos:
+ [Começando a usar o Amazon OpenSearch Service](gsg.md)
+ [Indexação de dados no Amazon Service OpenSearch](indexing.md)
+ [Pesquisando dados no Amazon OpenSearch Service](searching.md)
# Tutorial: Migração para o Amazon Service OpenSearch
Os instantâneos de índice são uma forma popular de migrar de um cluster Elasticsearch autogerenciado OpenSearch ou legado para o Amazon Service. OpenSearch Em termos gerais, o processo consiste nas seguintes etapas:
1. Faça um snapshot do cluster existente e carregue do snapshot para um bucket do Amazon S3.
1. Crie um domínio OpenSearch de serviço.
1. Conceda ao OpenSearch serviço permissões para acessar o bucket e garanta que você tenha permissões para trabalhar com snapshots.
1. Restaure o instantâneo no domínio do OpenSearch Serviço.
Esta demonstração fornece etapas mais detalhadas e opções alternativas, quando aplicável.
## Obter e carregar do snapshot
Embora você possa usar o plug-in [repository-s3](https://docs.opensearch.org/latest/opensearch/snapshot-restore/#amazon-s3) para tirar instantâneos diretamente no S3, você precisa instalar o plug-in em cada nó, ajustar `opensearch.yml` (ou `elasticsearch.yml` se estiver usando um cluster do Elasticsearch), reiniciar cada nó, adicionar suas credenciais e, finalmente, tirar o instantâneo. AWS O plug-in é uma ótima opção para uso contínuo ou para migrar clusters maiores.
Para clusters menores, uma abordagem única é tirar um [instantâneo do sistema de arquivos compartilhado](https://docs.opensearch.org/latest/opensearch/snapshot-restore/#shared-file-system) e, em seguida, usá-lo AWS CLI para carregá-lo no S3. Se você já tiver um snapshot, avance para a etapa 4.
****Para obter um snapshot e carregar no Amazon S3****
1. Adicione a configuração `path.repo` ao `opensearch.yml` (ou ao `Elasticsearch.yml`) em todos os nós e, em seguida, reinicie cada nó.
```
path.repo: ["/my/shared/directory/snapshots"]
```
1. Registre um [repositório de snapshots](https://opensearch.org/docs/latest/opensearch/snapshot-restore/#register-repository), o que é obrigatório para poder tirar um snapshot. Um repositório é apenas um local de armazenamento: um sistema de arquivos compartilhados, o Amazon S3, o Sistema de Arquivos Distribuído do Hadoop (HDFS) etc. Nesse caso, usaremos um sistema de arquivos compartilhados (“fs”):
```
PUT _snapshot/my-snapshot-repo-name
{
"type": "fs",
"settings": {
"location": "/my/shared/directory/snapshots"
}
}
```
1. Faça o snapshot:
```
PUT _snapshot/my-snapshot-repo-name/my-snapshot-name
{
"indices": "migration-index1,migration-index2,other-indices-*",
"include_global_state": false
}
```
1. Instale a [AWS CLI](https://aws.amazon.com/cli/), e execute `aws configure` para adicionar suas credenciais.
1. Navegue até o diretório de snapshots. Depois disso, execute os seguintes comandos para criar um novo bucket do S3 e carregar do conteúdo do diretório de snapshots para esse bucket:
```
aws s3 mb s3://amzn-s3-demo-bucket --region us-west-2
aws s3 sync . s3://amzn-s3-demo-bucket --sse AES256
```
Dependendo do tamanho do snapshot e da velocidade da sua conexão com a Internet, essa operação pode demorar um pouco.
## Criar um domínio
Embora o console seja a maneira mais fácil de criar um domínio, nesse caso, você já tem o terminal aberto e AWS CLI instalado. Modifique o seguinte comando para criar um domínio que atenda às suas necessidades:
```
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
```
Da maneira em que se encontra, o comando cria um domínio acessível à Internet com dois nós de dados, cada um com 100 GiB de armazenamento. Ele também habilita o [controle de acesso refinado](fgac.md) com autenticação básica de HTTP e todas as configurações de criptografia. Use o console OpenSearch de serviço se precisar de uma configuração de segurança mais avançada, como uma VPC.
Antes de emitir o comando, altere o nome do domínio, as credenciais do usuário mestre e o número da conta. Especifique o mesmo Região da AWS que você usou para o bucket do S3 e uma OpenSearch/Elasticsearch versão compatível com seu snapshot.
**Importante**
Os snapshots são compatíveis somente com versões posteriores e somente com uma versão principal. Por exemplo, você não pode restaurar um snapshot de um OpenSearch 1. cluster *x* em um Elasticsearch 7. cluster *x*, somente OpenSearch 1. *x* ou 2. cluster *x.* A versão secundária também é importante. Você não pode restaurar um snapshot de um cluster 5.3.3 autogerenciado em um domínio de serviço OpenSearch 5.3.2. Recomendamos escolher a versão mais recente OpenSearch ou o Elasticsearch compatível com seu snapshot. Para obter uma tabela de versões compatíveis, consulte [Como usar um snapshot para migrar dados](snapshot-based-migration.md).
## Conceder permissões para o bucket do S3
No console AWS Identity and Access Management (IAM), [crie uma função](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html) com as seguintes permissões e [relação de confiança](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-managingrole_edit-trust-policy). Ao criar a função, escolha **S3** como o **Serviço da AWS **. Nomeie a função como `OpenSearchSnapshotRole` para que ela seja fácil de encontrar.
**Permissões**
------
#### [ 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/*"
]
}
]
}
```
------
**Relação de confiança**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"Service": "es.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Em seguida, dê ao seu perfil do IAM pessoal permissões para assumir `OpenSearchSnapshotRole`. Crie a seguinte política e [anexe-a](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) à sua identidade:
**Permissões**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::123456789012:role/OpenSearchSnapshotRole"
}
]
}
```
------
### Mapeie a função de snapshot em OpenSearch painéis (se estiver usando controle de acesso refinado)
Se você habilitou o [controle de acesso detalhado](fgac.md#fgac-mapping), mesmo se usar a autenticação básica HTTP para todos os outros fins, precisará mapear o perfil do `manage_snapshots` para o seu perfil do IAM para poder trabalhar com snapshots.
**Para conceder à sua identidade permissões para trabalhar com snapshots**
1. Faça login nos painéis usando as credenciais de usuário mestre que você especificou ao criar o domínio do OpenSearch Serviço. Você pode encontrar o URL dos painéis no console de OpenSearch serviço. Ele segue o formato `https://domain-endpoint/_dashboards/`.
1. No menu principal, escolha **Segurança**, **Funções** e selecione a função **manage\$1snapshots**.
1. Escolha **Usuários mapeados** e **Gerenciar mapeamento**.
1. Adicione o ARN do domínio do seu perfil do IAM pessoal no campo apropriado. O ARN assume um dos seguintes formatos:
```
arn:aws:iam::123456789123:user/user-name
```
```
arn:aws:iam::123456789123:role/role-name
```
1. Selecione **Mapa** e confirme se o perfil aparece em **Usuários mapeados**.
## Restaure o snapshot
Neste momento, você tem duas maneiras de acessar seu domínio de OpenSearch serviço: autenticação básica HTTP com suas credenciais de usuário mestre ou AWS autenticação usando suas credenciais do IAM. Como os snapshots usam o Amazon S3, que não tem nenhum conceito do usuário principal, você deve usar suas credenciais do IAM para registrar o repositório de snapshots com seu domínio de serviço. OpenSearch
A maioria das linguagens de programação tem bibliotecas para ajudar com a assinatura de solicitações, mas a abordagem mais simples é usar uma ferramenta como o [Postman ](https://www.postman.com/downloads/)e colocar suas credenciais do IAM na seção **Autorização** .
![\[Postman interface showing Authorization settings for AWS API request with Signature type.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/migration2.png)
**Como restaurar o snapshot**
1. Independentemente de como você optar por assinar suas solicitações, a primeira etapa é registrar o repositório:
```
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. Depois disso, liste os snapshots no repositório e encontre o que deseja restaurar. Neste momento, é possível continuar usando o Postman ou alternar para uma ferramenta como o [curl](https://curl.haxx.se/).
**Abreviatura**
```
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. Restaure o snapshot.
**Abreviatura**
```
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. Por fim, verifique se seus índices foram restaurados conforme o esperado.
**Abreviatura**
```
GET _cat/indices?v
```
**curl**
```
curl -XGET -u 'master-user:master-user-password' https://domain-endpoint/_cat/indices?v
```
Neste momento, a migração está concluída. Você pode configurar seus clientes para usar o novo endpoint de OpenSearch serviço, [redimensionar o domínio](sizing-domains.md) de acordo com sua carga de trabalho, verificar a contagem de fragmentos de seus índices, mudar para um [usuário mestre do IAM](fgac.md#fgac-concepts) ou começar a criar visualizações em painéis. OpenSearch
# Tutorial: Criando um aplicativo de pesquisa com o Amazon OpenSearch Service
Uma forma comum de criar um aplicativo de pesquisa com o Amazon OpenSearch Service é usar formulários da web para enviar consultas de usuários a um servidor. Em seguida, você pode autorizar o servidor a ligar OpenSearch APIs diretamente para o e fazer com que o servidor envie solicitações ao OpenSearch Serviço. No entanto, se desejar escrever um código do lado do cliente que não dependa de um servidor, é necessário compensar os riscos de segurança e performance. Não é aconselhável permitir o acesso público não assinado ao OpenSearch APIs . Os usuários podem acessar endpoints não seguros ou afetar a performance do cluster por meio de consultas excessivamente amplas (ou muitas consultas).
Este capítulo apresenta uma solução: use o Amazon API Gateway para restringir os usuários a um subconjunto do OpenSearch APIs e AWS Lambda assinar solicitações do API Gateway para o OpenSearch Service.
![\[Diagrama de fluxo do aplicativo de pesquisa.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/search-application-diagram.png)
**nota**
Os preços padrão do API Gateway e do Lambda se aplicam, mas dentro do uso limitado desse tutorial, os custos devem ser insignificantes.
## Pré-requisitos
Um pré-requisito para este tutorial é um domínio de OpenSearch serviço. Se você ainda não tiver um, siga as etapas em [Criar um domínio OpenSearch de serviço](gsgcreate-domain.md) para criar um.
## Etapa 1: Indexar dados de exemplo
Faça download de [sample-movies.zip](samples/sample-movies.zip) e use a operação da API [\$1bulk](https://opensearch.org/docs/latest/api-reference/document-apis/bulk/) para adicionar os 5.000 documentos ao í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"}
...
```
Observe que o exemplo acima é um comando com um pequeno subconjunto dos dados disponíveis. Para executar a operação `_bulk`, você precisa copiar e colar todo o conteúdo do arquivo `sample-movies`. Para obter instruções adicionais, consulte [Opção 2: carregar vários documentos](gsgupload-data.md#gsgmultiple-document).
Também é possível usar o seguinte comando do curl para obter o mesmo resultado:
```
curl -XPOST -u 'master-user:master-user-password' 'domain-endpoint/_bulk' --data-binary @bulk_movies.json -H 'Content-Type: application/json'
```
## Etapa 2: criar e implantar a função do Lambda
Antes de criar sua API no API Gateway, crie a função do Lambda para a qual ela passará as solicitações.
### Criar a função do Lambda
Nessa solução, o API Gateway passa solicitações para uma função Lambda, que consulta o OpenSearch Serviço e retorna os resultados. Como essa função de exemplo usa bibliotecas externas, é necessário criar um pacote de implantação e carregar para o Lambda.
**Para criar o pacote de implantação**
1. Abra um prompt de comando e crie um diretório de projeto do `my-opensearch-function`. Por exemplo, no macOS:
```
mkdir my-opensearch-function
```
1. Navegue até o diretório de projeto do `my-sourcecode-function`.
```
cd my-opensearch-function
```
1. Copie o conteúdo do seguinte código Python de exemplo e salve-o em um novo arquivo chamado `opensearch-lambda.py`. Adicione sua região e o endpoint do host ao arquivo.
```
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 a biblioteca externa em um novo diretório de `package`.
```
pip3 install --target ./package boto3
pip3 install --target ./package requests
pip3 install --target ./package requests_aws4auth
```
1. Crie um pacote de implantação com a biblioteca instalada na raiz. O seguinte comando gera um arquivo `my-deployment-package.zip` no diretório do projeto.
```
cd package
zip -r ../my-deployment-package.zip .
```
1. Adicione o arquivo `opensearch-lambda.py` à raiz do arquivo zip.
```
cd ..
zip my-deployment-package.zip opensearch-lambda.py
```
Para saber mais sobre a criação de funções do Lambda e pacotes de implantação, consulte [Implantar funções do Lambda em Python com arquivos .zip](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python-how-to-create-deployment-package.html) no *Guia do desenvolvedor do AWS Lambda * e [Criar o pacote de implantação do Lambda](integrations-s3-lambda.md#integrations-s3-lambda-deployment-package) neste guia.
Para criar sua função usando o console do Lambda
1. [Navegue até o console Lambda em casahttps://console.aws.amazon.com/lambda/.](https://console.aws.amazon.com/lambda/home ) No painel de navegação à esquerda, escolha **Funções**.
1. Selecione **Criar função**.
1. Configure os campos a seguir.
+ Nome da função: opensearch-function
+ Runtime: Python 3.9
+ Arquitetura: x86\$164
Mantenha todas as outras opções padrão e escolha **Criar função**.
1. Na seção **Fonte do código** da página de resumo da função, escolha **Carregar** no menu suspenso e selecione **.zip. file**. Localize o arquivo `my-deployment-package.zip` que você criou e escolha **Salvar**.
1. O *manipulador* é o método no código da sua função que processa eventos. Em **Configurações do Runtime**, escolha **Editar** e altere o nome do manipulador de acordo com o nome do arquivo no pacote de implantação onde a função do Lambda está localizada Como seu arquivo se chama `opensearch-lambda.py`, renomeie o manipulador para `opensearch-lambda.lambda_handler`. Para saber mais, consulte [Manipulador de função do Lambda em Python](https://docs.aws.amazon.com/lambda/latest/dg/python-handler.html).
## Etapa 3: Criar a API no Gateway da API
O uso do API Gateway permite criar uma API mais limitada e simplifica o processo de interação com a OpenSearch `_search` API. O API Gateway também permite ativar recursos de segurança, como a autenticação do Amazon Cognito e a limitação de solicitações. Execute as seguintes etapas para criar e implantar uma API:
### Criar e configurar a API
Para criar sua API usando o console do API Gateway
1. Navegue até o console do API Gateway em [https://console.aws.amazon.com/apigateway/casa](https://console.aws.amazon.com/apigateway/home ). No painel de navegação esquerdo, escolha **APIs**.
1. Localize a **API REST** (não privada) e escolha **Compilar**.
1. Na página seguinte, localize a seção **Criar nova API** e verifique se a opção **Nova API** está selecionada.
1. Configure os campos a seguir.
+ Nome da API: **opensearch-api**
+ Descrição: **API pública para pesquisar um domínio do Amazon OpenSearch Service**
+ Tipo do endpoint: **Regional**
1. Selecione **Criar API**.
1. Escolha **Ações** e **Criar método**.
1. Select **GET** no menu suspenso e clique na marca de seleção para confirmar.
1. Defina as seguintes configurações e escolha **Salvar**:
| Configuração | Valor |
| --- | --- |
| Tipo de integração | Função do Lambda |
| Usar a integração de proxy do Lambda | Sim |
| Região do Lambda | us-west-1 |
| Função do Lambda | opensearch-lambda |
| Usar o tempo limite padrão | Sim |
### Configurar a solicitação de método
Escolha **Solicitação de métodot** e defina as seguintes configurações:
| Configuração | Valor |
| --- | --- |
| Autorização | NONE |
| Validador da solicitação | Validar parâmetros e cabeçalhos da string de consulta |
| Chave da API necessária | false |
Em **Parâmetros da string de consulta do URL)**, escolha **Adicionar string de consulta** e configure o seguinte parâmetro:
| Configuração | Valor |
| --- | --- |
| Nome | q |
| Obrigatório | Sim |
### Implante a API e configure um estágio
O console do API Gateway permite que você implante uma API criando uma implantação e associando-a a um estágio novo ou existente.
1. Escolha **Ações** e **Implantar API**.
1. Para **Estágio da implantação)**, escolha **Novo estágio** e atribua o nome `opensearch-api-test` ao estágio.
1. Escolha **Implantar**.
1. Defina as seguintes configurações no editor de estágios e, em seguida, escolha **Salvar alterações**:
| Configuração | Valor |
| --- | --- |
| Habilitar controle de utilização | Sim |
| Taxa | 1000 |
| Intermitência | 500 |
Essas definições configuram uma API que possui apenas um método: uma solicitação `GET` para a raiz do endpoint (`https://some-id.execute-api.us-west-1.amazonaws.com/search-es-api-test`). A solicitação requer um único parâmetro (`q`), a string de consulta a ser pesquisada. Quando chamado, o método passa a solicitação para o Lambda, que executa a função `opensearch-lambda`. Para saber mais, consulte [Criação de uma API no Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-create-api.html) e [Implantação de uma API REST no Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-deploy-api.html).
## Etapa 4: (opcional) modificar a política de acesso ao domínio
Seu domínio OpenSearch de serviço deve permitir que a função Lambda faça `GET` solicitações ao `movies` índice. Se o domínio tiver uma política de acesso aberto com controle de acesso refinado habilitado, você pode deixar como está:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "*"
},
"Action": "es:*",
"Resource": "arn:aws:es:us-west-1:123456789012:domain/domain-name/*"
}
]
}
```
------
Ou você pode escolher tornar a política de acesso ao domínio mais granular. Por exemplo, a política mínima a seguir fornece à `opensearch-lambda-role` (criada por meio do Lambda) acesso de leitura ao índice `movies`. Para obter o nome exato da função que o Lambda cria automaticamente, acesse o console AWS Identity and Access Management (IAM), escolha **Roles** e pesquise por “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 você tiver um controle de acesso refinado habilitado para o domínio, também precisará [mapear a função para um usuário](fgac.md#fgac-mapping) nos OpenSearch painéis, caso contrário, você verá erros de permissão.
### Configurar as permissões do perfil de execução do Lambda
Além de configurar a política de acesso ao domínio, você também deve garantir que a função de execução do Lambda tenha as permissões de IAM necessárias para acessar OpenSearch seu domínio de serviço. A função Lambda requer permissões específicas, dependendo se você está usando um domínio gerenciado ou uma coleção OpenSearch Service Serverless.
**Para domínios OpenSearch de serviço gerenciados:**
Anexe a seguinte política do IAM à sua função de execução do Lambda para permitir que ela faça solicitações ao seu domínio de OpenSearch serviço:
------
#### [ 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 coleções OpenSearch Service Serverless:**
Se você estiver usando o OpenSearch Service Serverless, anexe a seguinte política do IAM à sua função de execução do Lambda:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "aoss:*",
"Resource": "arn:aws:aoss:us-west-1:123456789012:collection/collection-id"
}
]
}
```
------
Para anexar essas políticas ao perfil de execução do Lambda:
1. Navegue até o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Escolha **Perfis** e pesquise o perfil de execução do Lambda (normalmente denominado `opensearch-lambda-role-xxxxxxxx`).
1. Selecione **Adicionar permissões** e depois **Criar política em linha**.
1. Escolha a guia **JSON** e cole a política apropriada acima, substituindo os valores do espaço reservado pelo seu recurso real. ARNs
1. Escolha **Revisar política**, forneça um nome como `OpenSearchAccess` e escolha **Criar política**.
**nota**
Sem essas permissões do IAM, sua função Lambda receberá erros de “Acesso negado” ao tentar consultar seu domínio de OpenSearch serviço, mesmo que a política de acesso ao domínio permita as solicitações.
Para saber mais sobre políticas de acesso, consulte [Configuração de políticas de acesso](createupdatedomains.md#createdomain-configure-access-policies).
## Mapeamento da função do Lambda (se estiver usando um controle de acesso minucioso)
O controle de acesso minucioso introduz uma etapa adicional antes de testar a aplicação. Mesmo se você usar a autenticação básica do HTTP para todos os outros fins, será necessário mapear a função do Lambda para um usuário. Caso contrário, você receberá erros de permissões.
1. Navegue até o URL dos OpenSearch painéis do domínio.
1. No menu principal, escolha **Segurança**, **Funções** e selecione o link para `all_access`, a função para a qual precisa mapear a função do Lambda.
1. Escolha **Usuários mapeados** e **Gerenciar mapeamento**.
1. Em **Funções de backend**, adicione o nome do recurso da Amazon (ARN) da função do Lambda. O ARN deve assumir a forma de `arn:aws:iam::123456789123:role/service-role/opensearch-lambda-role-1abcdefg`.
1. Selecione **Mapa** e confirme se o usuário ou função aparece em **Usuários mapeados**.
## Etapa 5: Testar a aplicação Web
**Para testar o aplicativo web**
1. Faça download do [sample-site.zip](samples/sample-site.zip), descompacte-o e abra `scripts/search.js` em seu editor de texto de preferência.
1. Atualize a variável `apigatewayendpoint` para apontar para o endpoint do API Gateway Você pode encontrar rapidamente o endpoint no API Gateway escolhendo **Estágios** e selecionando o nome da API. A variável `apigatewayendpoint` deve assumir a forma de `https://some-id.execute-api.us-west-1.amazonaws.com/opensearch-api-test`.
1. Abra `index.html` e tente executar pesquisas para *thor*, *casa* e alguns outros termos.
![\[Um exemplo de pesquisa por thor.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/search-ui.png)
### Solucionar erros CORS
Mesmo que a função do Lambda inclua conteúdo na resposta para ser compatível com o CORS, você ainda pode ver o seguinte erro:
```
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.
```
Se isso acontecer, tente o seguinte:
1. [Habilite o CORS](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-cors-console.html) no recurso GET. Em **Avançado**, defina **Access-Control-Allow-Credentials** como `'true'`.
1. Reimplante a API no API Gateway [**Ações**, **Implantar API**].
1. Exclua e torne a adicionar o acionador da função do Lambda. Adicione readicionar, escolha **Adicionar acionador** e crie o endpoint HTTP que invoca sua função. O acionador deve ter a seguinte configuração:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/search-example.html)
## Próximas etapas
Este capítulo é apenas um ponto de partida para demonstrar um conceito. Você pode considerar as seguintes modificações:
+ Adicione seus próprios dados ao domínio do OpenSearch Serviço.
+ Adicionar métodos à API.
+ Na função do Lambda, modifique a consulta de pesquisa ou incremente campos diferentes.
+ Estilize os resultados de maneira diferente ou modifique `search.js` para exibir campos diferentes para o usuário.
# Tutorial: Visualizando chamadas de suporte ao cliente com OpenSearch serviços e painéis OpenSearch
Este capítulo é uma descrição completa da seguinte situação: uma empresa recebe um determinado número de chamadas de suporte ao cliente e quer analisá-las. O que é o assunto de cada chamada? Quantas eram positivas? Quantas eram negativas? Como os gerentes podem pesquisar ou revisar as transcrições dessas chamadas?
Um fluxo de trabalho manual pode envolver funcionários ouvindo gravações, anotando o assunto de cada chamada e decidindo se a interação do cliente foi positiva.
Esse processo seria extremamente trabalhoso. Supondo um tempo médio de 10 minutos por chamada, cada funcionário escutaria apenas 48 chamadas por dia. Independentemente do viés humano, os dados que eles geram seriam altamente precisos, mas a *quantidade* de dados seria mínima: apenas o assunto da chamada e um booliano para saber se o cliente estava ou não satisfeito. Qualquer coisa mais complexa, como uma transcrição completa, tomaria uma quantidade imensa de tempo.
Usando o [Amazon S3](https://aws.amazon.com/s3/), o [Amazon Transcribe](https://aws.amazon.com/transcribe/)[, o Amazon](https://aws.amazon.com/comprehend/) Comprehend e o Amazon Service OpenSearch , você pode automatizar um processo similar com muito pouco código e acabar com muito mais dados. Por exemplo, você pode obter uma transcrição completa da chamada, as palavras-chave da transcrição e um “sentimento” global da chamada (positivo, negativo, neutro ou misto). Em seguida, você pode usar OpenSearch OpenSearch painéis para pesquisar e visualizar os dados.
Embora você possa usar esse passo a passo no estado em que se encontra, a intenção é gerar ideias sobre como enriquecer seus documentos JSON antes de indexá-los no Service. OpenSearch
**Custos estimados**
Em geral, executar as etapas desta demonstração devem custar menos de US\$1 2. A demonstração usa os seguintes recursos:
+ Bucket do S3 com menos de 100 MB transferidos e armazenados
Para saber mais, consulte [Definição de preços do Amazon S3](https://aws.amazon.com/s3/pricing/).
+ OpenSearch Domínio de serviço com uma `t2.medium` instância e 10 GiB de armazenamento EBS por várias horas
Para saber mais, consulte [Amazon OpenSearch Service Pricing](https://aws.amazon.com/elasticsearch-service/pricing/).
+ Várias chamadas para o Amazon Transcribe
Para saber mais, consulte [Preços do Amazon Transcribe](https://aws.amazon.com/transcribe/pricing/).
+ Várias chamadas de processamento de linguagem natural para o Amazon Comprehend
Para saber mais, consulte [Preços do Amazon Comprehend](https://aws.amazon.com/comprehend/pricing/).
**Topics**
+ [Etapa 1: Configurar os pré-requisitos](#walkthrough-prereq)
+ [Etapa 2: Copiar código de exemplo](#walkthrough-script)
+ [(Opcional) Etapa 3: Indexar dados de exemplo](#walkthrough-sample-data)
+ [Etapa 4: Analisar e visualizar seus dados](#walkthrough-analysis)
+ [Etapa 5: Limpar recursos e próximas etapas](#walkthrough-next-steps)
## Etapa 1: Configurar os pré-requisitos
Para continuar, você deve ter os recursos a seguir.
****
| Pré-requisito | Description |
| --- | --- |
| Bucket do Amazon S3. | Para saber mais, consulte [Creating a Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) (Criar um bucket) no Manual do usuário do Amazon Simple Storage Service. |
| OpenSearch Domínio do serviço | O destino dos dados. Para obter mais informações, consulte [Criação OpenSearch de domínios de serviço](createupdatedomains.md#createdomains). |
Se você ainda não tiver esses recursos, poderá criá-los usando os seguintes comandos do 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**
Esses comandos usam a região `us-west-2`, mas você pode usar qualquer região compatível com o Amazon Comprehend. Para saber mais, consulte o [Referência geral da AWS](https://docs.aws.amazon.com/general/latest/gr/rande.html#comprehend_region).
## Etapa 2: Copiar código de exemplo
1. Copie e cole o código de exemplo Python 3 a seguir em um novo arquivo chamado `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. Atualize as primeiras seis variáveis.
1. Instale os pacotes exigidos usando os seguintes comandos:
```
pip install boto3
pip install requests
pip install requests_aws4auth
```
1. Coloque seu MP3 no mesmo diretório `call-center.py` e execute o script. Uma saída de exemplo se segue:
```
$ 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` executa uma série de operações:
1. O script carrega um arquivo de áudio (nesse caso, um MP3, mas o Amazon Transcribe suporta vários formatos) para seu bucket do S3.
1. Ele envia o URL do arquivo de áudio para o Amazon Transcribe e aguarda até que o trabalho de transcrição termine.
O tempo para concluir o trabalho de transcrição depende do tamanho do arquivo de áudio. Considere minutos, não segundos.
**dica**
Para melhorar a qualidade da transcrição, você pode configurar um [vocabulário personalizado](https://docs.aws.amazon.com/transcribe/latest/dg/API_CreateVocabulary.html) para o Amazon Transcribe.
1. Depois que o trabalho de transcrição for concluído, o script extrairá a transcrição, a deixará com 5.000 caracteres e a enviará para o Amazon Comprehend para uma análise de palavras-chave e sentimento.
1. Por fim, o script adiciona a transcrição completa, as palavras-chave, o sentimento e o registro de data e hora atual a um documento JSON e o indexa no Service. OpenSearch
**dica**
[LibriVox](https://librivox.org/)tem audiolivros de domínio público que você pode usar para testes.
## (Opcional) Etapa 3: Indexar dados de exemplo
Se você não tiver várias gravações de chamadas à disposição — e quem tem? — poderá [indexar](indexing.md) os documentos de exemplo em [sample-calls.zip](samples/sample-calls.zip), os quais são comparáveis àqueles produzidos pelo `call-center.py`.
1. Crie um arquivo chamado `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. Atualize as primeiras duas variáveis para `host` e `region`.
1. Instale o pacote exigido usando o seguinte comando:
```
pip install opensearch-py
```
1. Faça download e descompacte [sample-calls.zip](samples/sample-calls.zip).
1. Coloque `sample-calls.bulk` no mesmo diretório que `bulk-helper.py` e execute o auxiliar. Uma saída de exemplo se segue:
```
$ 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
}
```
## Etapa 4: Analisar e visualizar seus dados
Agora que você tem alguns dados no OpenSearch Service, você pode visualizá-los usando OpenSearch painéis.
1. Acesse `https://search-domain.region.es.amazonaws.com/_dashboards`.
1. Antes de usar os OpenSearch painéis, você precisa de um padrão de índice. O Dashboard usa padrões de índice para restringir sua análise a um ou mais índices. Para corresponder ao índice `support-calls` criado por `call-center.py`, vá para **Stack Management** (Gerenciamento de pilhas), **Index Patterns** (Padrões de índice) e definir um padrão de índice de `support*`. Em seguida, escolha **Next step** (Próxima etapa).
1. Para o **nome de campo Filtro de tempo**, escolha **timestamp**.
1. Agora, você pode começar a criar visualizações. Escolha **Visualizar** e, em seguida, adicione uma nova visualização.
1. Escolha o gráfico de pizza e o padrão de índice `support*`.
1. A visualização padrão é básica. Portanto, escolha **Dividir fatias** para criar uma visualização mais interessante.
Em **Aggregation**, escolha **Terms**. Em **Campo**, escolha **sentiment.keyword**. Em seguida, escolha **Aplicar alterações** e **Salvar**.
![\[Exemplo de configuração para um gráfico de pizza do Dashboards.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/sentiment-pie-chart.png)
1. Volte para a página **Visualizar** e adicione outra visualização. Dessa vez, escolha o gráfico de barras horizontais.
1. Selecione **Dividir séries**.
Em **Aggregation**, escolha **Terms**. Em **Campo**, escolha **keywords.keyword** e altere **Tamanho** para 20. Em seguida, escolha **Aplicar alterações** e **Salvar**.
![\[Exemplo de configuração para um gráfico de barras horizontais do Dashboards.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/keyword-bar-chart.png)
1. Volte para a página **Visualizar** e adicione uma visualização final, um gráfico de barras verticais.
1. Selecione **Dividir séries**. Em **Agregação**, escolha **Histograma de data**. Em **Campo**, escolha **timestamp** e altere **Intervalo** para **Diariamente**.
1. Escolha **Métricas e eixos** e altere **Modo** para **normal**.
1. Escolha **Aplicar alterações** e **Salvar**.
![\[Exemplo de configuração para um gráfico de barras verticais do Dashboards.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/timestamp-bar-chart-2.png)
1. Agora que você tem três visualizações, poderá adicioná-las a uma visualização do Dashboards. Escolha **Painel**, crie um painel e adicione suas visualizações.
![\[Visualização de exemplo do Dashboards.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/dashboard-2.png)
## Etapa 5: Limpar recursos e próximas etapas
Para evitar cobranças desnecessárias, exclua o bucket do S3 e o domínio do OpenSearch serviço. Para saber mais, consulte [Excluir um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-or-empty-bucket.html#delete-bucket) no *Guia do usuário do Amazon Simple Storage Service* e [Excluir um domínio de OpenSearch serviço](gsgdeleting.md) neste guia.
As transcrições exigem muito menos espaço em disco do que MP3 os arquivos. Talvez você consiga reduzir sua janela de MP3 retenção — por exemplo, de três meses de gravações de chamadas para um mês — reter anos de transcrições e ainda economizar nos custos de armazenamento.
Você também pode automatizar o processo de transcrição usando o AWS Step Functions Lambda, adicionar metadados adicionais antes da indexação ou criar visualizações mais complexas para se adequar ao seu caso de uso exato.