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á.
# Conectores de fontes de dados personalizados
Use uma fonte de dados personalizada quando você tiver um repositório que o Amazon Kendra ainda não fornece um conector de fonte de dados para ele. Você pode usá-lo para ver as mesmas métricas de histórico de execução que as fontes de dados do Amazon Kendra fornecem, mesmo quando não é possível usar as fontes de dados do Amazon Kendra para sincronizar os repositórios. Use isso para criar uma experiência consistente de monitoramento de sincronização entre fontes de dados do Amazon Kendra e fontes personalizadas. [Especificamente, use uma fonte de dados personalizada para ver as métricas de sincronização de um conector de fonte de dados criado usando as APIs [BatchputDocument e BatchDeleteDocument](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BatchPutDocument.html).](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BatchDeleteDocument.html)
Para solucionar problemas do conector da fonte de dados do Amazon Kendra, consulte [Solucionar problemas de origens de dados](troubleshooting-data-sources.md).
Ao criar uma fonte de dados personalizada, você tem controle total sobre como os documento indexados são selecionados. O Amazon Kendra fornece apenas informações métricas sobre o que pode ser usado para monitorar as tarefas de sincronização da origem dos dados. Você deve criar e executar o crawler que determina os documentos indexados pela fonte de dados.
Especifique o título principal dos documentos usando o objeto [Documento](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Document.html) e `_source_uri` em [DocumentAttribute](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DocumentAttribute.html) para incluir `DocumentTitle` e `DocumentURI` na resposta do resultado da `Query`.
Você cria um identificador para a fonte de dados personalizada usando o console ou a API [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html). Para usar o console, dê um nome à sua fonte de dados e, opcionalmente, uma descrição e tags de recursos. Depois que a fonte de dados é criada, um ID da fonte de dados é exibida. Copie esse ID para usar ao sincronizar a fonte de dados com o índice.
![\[Form for specifying data source details, including name, description, and optional tags.\]](http://docs.aws.amazon.com/pt_br/kendra/latest/dg/images/CustomDataSource.png)
Também é possível criar uma fonte de dados personalizada usando a API `CreateDataSource`. A API retorna um ID para ser usado quando ao sincronizar a fonte de dados. Ao usar a API `CreateDataSource` para criar uma fonte de dados personalizada, não é possível definir os parâmetros `Configuration`, `RoleArn` ou `Schedule`. Se você definir esses parâmetros, Amazon Kendra retornará uma exceção do `ValidationException`.
Para usar uma fonte de dados personalizada, crie um aplicativo responsável pela atualização do índice do Amazon Kendra. O aplicativo depende de um crawler criado por você. O crawler lê os documentos em seu repositório e determina quais devem ser enviados para Amazon Kendra. O aplicativo deve executar as seguintes etapas:
1. Rastreie o repositório e faça uma lista dos documentos no repositório que foram adicionados, atualizados ou excluídos.
1. Chame a API [StartDataSourceSyncJob](https://docs.aws.amazon.com/kendra/latest/APIReference/API_StartDataSourceSyncJob.html) para sinalizar que um trabalho de sincronização está sendo iniciado. Forneça um ID da fonte de dados para identificar a fonte de dados que está sincronizando. o Amazon Kendra retorna um ID de execução para identificar um trabalho de sincronização específico.
1. Chame a API [BatchDeleteDocument](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BatchDeleteDocument.html) para remover documentos do índice. Forneça o ID da fonte de dados e o ID de execução para identificar a fonte de dados que está sendo sincronizada e o trabalho ao qual essa atualização está associada.
1. Chame a API [StopDataSourceSyncJob](https://docs.aws.amazon.com/kendra/latest/APIReference/API_StopDataSourceSyncJob.html) para sinalizar o fim do trabalho de sincronização. Depois de chamar a API `StopDataSourceSyncJob`, o ID de execução associado não é mais válido.
1. Chame a API [ListDataSourceSyncJobs](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ListDataSourceSyncJobs.html) com os identificadores de índice e fonte de dados para listar os trabalhos de sincronização da fonte de dados e ver as métricas dos trabalhos de sincronização.
Depois de finalizar um trabalho de sincronização, você pode iniciar um novo trabalho de sincronização. Pode haver um período de tempo até que todos os documentos enviados sejam adicionados ao índice. Use a API `ListDataSourceSyncJobs` para ver o status da tarefa de sincronização. Se o `Status` retornado para o trabalho de sincronização for `SYNCING_INDEXING`, alguns documentos ainda estão sendo indexados. Você pode iniciar um novo trabalho de sincronização quando o status do trabalho anterior for `FAILED` ou `SUCCEEDED`.
Depois de chamar a API `StopDataSourceSyncJob`, você não pode usar um identificador de trabalho de sincronização em uma chamada para as APIs `BatchPutDocument` ou `BatchDeleteDocument`. Se você fizer isso, todos os documentos enviados serão retornados na mensagem de resposta `FailedDocuments` da API.
## Atributos obrigatórios
Quando você envia um documento para Amazon Kendra usar a API `BatchPutDocument`, cada documento exige dois atributos para identificar a fonte de dados e a execução de sincronização à qual ela pertence. Você deve fornecer os dois seguintes atributos para mapear documentos da sua fonte de dados personalizada corretamente para um índice do Amazon Kendra:
+ `_data_source_id`: o identificador da fonte de dados. Ele é retornado quando você cria a fonte de dados com o console ou a API `CreateDataSource`.
+ `_data_source_sync_job_execution_id`: o identificador da execução da sincronização. Ele é retornado quando você inicia a sincronização do índice com a API `StartDataSourceSyncJob`.
Veja a seguir o JSON necessário para indexar um documento usando uma fonte de dados personalizada.
```
{
"Documents": [
{
"Attributes": [
{
"Key": "_data_source_id",
"Value": {
"StringValue": "data source identifier"
}
},
{
"Key": "_data_source_sync_job_execution_id",
"Value": {
"StringValue": "sync job identifier"
}
}
],
"Blob": "document content",
"ContentType": "content type",
"Id": "document identifier",
"Title": "document title"
}
],
"IndexId": "index identifier",
"RoleArn": "IAM role ARN"
}
```
Ao remover um documento do índice usando a API `BatchDeleteDocument`, especifique os dois campos a seguir no parâmetro `DataSourceSyncJobMetricTarget`:
+ `DataSourceId`: o identificador da fonte de dados. Ele é retornado quando você cria a fonte de dados com o console ou a API `CreateDataSource`.
+ `DataSourceSyncJobId`: o identificador da execução da sincronização. Ele é retornado quando você inicia a sincronização do índice com a API `StartDataSourceSyncJob`.
Veja a seguir o JSON necessário para excluir um documento do índice usando API `BatchDeleteDocument`.
```
{
"DataSourceSyncJobMetricTarget": {
"DataSourceId": "data source identifier",
"DataSourceSyncJobId": "sync job identifier"
},
"DocumentIdList": [
"document identifier"
],
"IndexId": "index identifier"
}
```
## Visualizar métricas
Depois que um trabalho de sincronização for concluído, use a API [DataSourceSyncJobMetrics para obter as métricas](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DataSourceSyncJobMetrics.html) associadas ao trabalho de sincronização. Use ela para monitorar as sincronizações de fontes de dados personalizadas.
Se você enviar o mesmo documento várias vezes, seja como parte da API `BatchPutDocument`, da `BatchDeleteDocument` API ou se o documento for enviado para adição e exclusão, o documento será contado apenas uma vez nas métricas.
+ `DocumentsAdded`: o número de documentos enviados usando a API `BatchPutDocument` associada a esse trabalho de sincronização adicionados ao índice pela primeira vez. Se um documento for enviado para adição mais de uma vez em uma sincronização, ele será contabilizado apenas uma vez nas métricas.
+ `DocumentsDeleted`: o número de documentos enviados usando a API `BatchDeleteDocument` associada a esse trabalho de sincronização excluídos pelo índice.. Se um documento for enviado para exclusão mais de uma vez em uma sincronização, ele será contabilizado apenas uma vez nas métricas.
+ `DocumentsFailed`: o número de documentos associados a essa tarefa de sincronização que falharam na indexação. Esses são documentos que foram aceitos por Amazon Kendra para indexação, mas que não puderam ser indexados ou excluídos. Se um documento não for aceito por Amazon Kendra, o identificador do documento será retornado na propriedade de resposta `FailedDocuments` das APIs `BatchPutDocument` e `BatchDeleteDocument`.
+ `DocumentsModified`: o número de documentos modificados e enviados usando a API `BatchPutDocument` associada a esse trabalho de sincronização modificados no índice Amazon Kendra.
O Amazon Kendra também emite métricas do Amazon CloudWatch ao indexar documentos. Para obter mais informações, consulte [Monitoramento do Amazon Kendra com o Amazon CloudWatch](https://docs.aws.amazon.com/kendra/latest/dg/cloudwatch-metrics.html).
O Amazon Kendra não retorna a métrica `DocumentsScanned` para fontes de dados personalizadas. Ele também emite as métricas CloudWatch listadas no documento [Métricas para fontes de dados do Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/cloudwatch-metrics.html#cloudwatch-metrics-data-source).
## Saiba mais
Para saber mais sobre a integração do Amazon Kendra com a fonte de dados, consulte:
+ [Adicionar fontes de dados personalizadas ao Amazon Kendra](https://aws.amazon.com/blogs/machine-learning/adding-custom-data-sources-to-amazon-kendra/)
# Fontes de dados personalizadas (Java)
O código a seguir fornece um exemplo de implementação de uma fonte de dados personalizada usando Java. Primeiro, o programa cria uma fonte de dados personalizada e depois sincroniza os documentos recém-adicionados ao índice com a fonte de dados personalizada.
O código a seguir demonstra a criação e o uso de uma fonte de dados personalizada. Ao usar uma fonte de dados personalizada no aplicativo, não é necessário criar uma nova fonte de dados (processo único) toda vez que o índice é sincronizado com a fonte de dados. Você usa o ID do índice e o ID da fonte de dados para sincronizar os dados.
```
package com.amazonaws.kendra;
import java.util.concurrent.TimeUnit;
import software.amazon.awssdk.services.kendra.KendraClient;
import csoftware.amazon.awssdk.services.kendra.model.BatchPutDocumentRequest;
import csoftware.amazon.awssdk.services.kendra.model.BatchPutDocumentResponse;
import software.amazon.awssdk.services.kendra.model.CreateDataSourceRequest;
import software.amazon.awssdk.services.kendra.model.CreateDataSourceResponse;
import software.amazon.awssdk.services.kendra.model.DataSourceType;
import software.amazon.awssdk.services.kendra.model.Document;
import software.amazon.awssdk.services.kendra.model.ListDataSourceSyncJobsRequest;
import software.amazon.awssdk.services.kendra.model.ListDataSourceSyncJobsResponse;
import software.amazon.awssdk.services.kendra.model.StartDataSourceSyncJobRequest;
import software.amazon.awssdk.services.kendra.model.StartDataSourceSyncJobResponse;
import software.amazon.awssdk.services.kendra.model.StopDataSourceSyncJobRequest;
import software.amazon.awssdk.services.kendra.model.StopDataSourceSyncJobResponse;
public class SampleSyncForCustomDataSource {
public static void main(String[] args) {
KendraClient kendra = KendraClient.builder().build();
String myIndexId = "yourIndexId";
String dataSourceName = "custom data source";
String dataSourceDescription = "Amazon Kendra custom data source connector"
// Create custom data source
CreateDataSourceRequest createDataSourceRequest = CreateDataSourceRequest
.builder()
.indexId(myIndexId)
.name(dataSourceName)
.description(dataSourceDescription)
.type(DataSourceType.CUSTOM)
.build();
CreateDataSourceResponse createDataSourceResponse = kendra.createDataSource(createDataSourceRequest);
System.out.println(String.format("Response of creating data source: %s", createDataSourceResponse));
// Get the data source ID from createDataSourceResponse
String dataSourceId = createDataSourceResponse.Id();
// Wait for the custom data source to become active
System.out.println(String.format("Waiting for Amazon Kendra to create the data source %s", dataSourceId));
// You can use the DescribeDataSource API to check the status
DescribeDataSourceRequest describeDataSourceRequest = DescribeDataSourceRequest
.builder()
.indexId(myIndexId)
.id(dataSourceId)
.build();
while (true) {
DescribeDataSourceResponse describeDataSourceResponse = kendra.describeDataSource(describeDataSourceRequest);
DataSourceStatus status = describeDataSourceResponse.status();
System.out.println(String.format("Creating data source. Status: %s", status));
if (status != DataSourceStatus.CREATING) {
break;
}
TimeUnit.SECONDS.sleep(60);
}
// Start syncing yor data source by calling StartDataSourceSyncJob and providing your index ID
// and your custom data source ID
System.out.println(String.format("Synchronize the data source %s", dataSourceId));
StartDataSourceSyncJobRequest startDataSourceSyncJobRequest = StartDataSourceSyncJobRequest
.builder()
.indexId(myIndexId)
.id(dataSourceId)
.build();
StartDataSourceSyncJobResponse startDataSourceSyncJobResponse = kendra.startDataSourceSyncJob(startDataSourceSyncJobRequest);
// Get the sync job execution ID from startDataSourceSyncJobResponse
String executionId = startDataSourceSyncJobResponse.ExecutionId();
System.out.println(String.format("Waiting for the data source to sync with the index %s for execution ID %s", indexId, startDataSourceSyncJobResponse.executionId()));
// Add 2 documents uploaded to S3 bucket to your index using the BatchPutDocument API
// The added documents should sync with your custom data source
Document pollyDoc = Document
.builder()
.s3Path(
S3Path.builder()
.bucket("amzn-s3-demo-bucket")
.key("what_is_Amazon_Polly.docx")
.build())
.title("What is Amazon Polly?")
.id("polly_doc_1")
.build();
Document rekognitionDoc = Document
.builder()
.s3Path(
S3Path.builder()
.bucket("amzn-s3-demo-bucket")
.key("what_is_amazon_rekognition.docx")
.build())
.title("What is Amazon rekognition?")
.id("rekognition_doc_1")
.build();
BatchPutDocumentRequest batchPutDocumentRequest = BatchPutDocumentRequest
.builder()
.indexId(myIndexId)
.documents(pollyDoc, rekognitionDoc)
.build();
BatchPutDocumentResponse result = kendra.batchPutDocument(batchPutDocumentRequest);
System.out.println(String.format("BatchPutDocument result: %s", result));
// Once custom data source synced, stop the sync job using the StopDataSourceSyncJob API
StopDataSourceSyncJobResponse stopDataSourceSyncJobResponse = kendra.stopDataSourceSyncJob(
StopDataSourceSyncJobRequest()
.indexId(myIndexId)
.id(dataSourceId)
);
// List your sync jobs
ListDataSourceSyncJobsRequest listDataSourceSyncJobsRequest = ListDataSourceSyncJobsRequest
.builder()
.indexId(myIndexId)
.id(dataSourceId)
.build();
while (true) {
ListDataSourceSyncJobsResponse listDataSourceSyncJobsResponse = kendra.listDataSourceSyncJobs(listDataSourceSyncJobsRequest);
DataSourceSyncJob job = listDataSourceSyncJobsResponse.history().get(0);
System.out.println(String.format("Status: %s", job.status()));
}
}
}
```