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

# Conceitos básicos do grupo de conjuntos de dados de domínio (SDK para Java 2.x)
<a name="domain-getting-started-java"></a>

Este tutorial mostra como usar o SDK para Java 2.x para criar um grupo de conjuntos de dados de domínio para o domínio VIDEO\_ON\_DEMAND. Neste tutorial, você cria um recomendador para o caso de uso *principais opções para você*.

Depois de concluir este exercício, exclua os recursos que você criou para evitar cobranças desnecessárias. Para obter mais informações, consulte [Requisitos para excluir recursos do Amazon Personalize](deleting-resources.md). 

## Pré-requisitos
<a name="domain-gs-java-prerequisites"></a>

Este tutorial tem os seguintes pré-requisitos:
+ Conclua os [Pré-requisitos de conceitos básicos](gs-prerequisites.md) para configurar as permissões necessárias e criar os dados de treinamento. Se você também tiver concluído [Conceitos básicos do grupo de conjuntos de dados de domínio (console)](getting-started-console-domain.md), poderá reutilizar os mesmos dados de origem. Se estiver usando seus próprios dados de origem, verifique se eles estão formatados de acordo com os requisitos.
+ Configure as credenciais do SDK for Java 2.x e AWS conforme especificado no procedimento [Configurar AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html) no *Guia do desenvolvedor do AWS SDK for Java 2.x*. 

## Tutorial
<a name="gs-java-domain-tutorial"></a>

Nas etapas a seguir, você vai configurar seu projeto para usar pacotes do Amazon Personalize e criar clientes do SDK para Java 2.x do Amazon Personalize. Em seguida, você vai importar dados, criar um recomendador para o caso de uso *Principais opções para você* e receber recomendações.

### Etapa 1: Configurar seu projeto para usar pacotes do Amazon Personalize
<a name="domain-gs-java-set-up-project"></a>

Depois de concluir as etapas obrigatórias, adicione dependências do Amazon Personalize ao seu arquivo pom.xml e importe pacotes do Amazon Personalize. 

1.  Adicione as dependências a seguir ao arquivo pom.xml. Os números da versão mais recente podem ser diferentes do código de exemplo. 

   ```
   <dependency>
   	<groupId>software.amazon.awssdk</groupId>
   	<artifactId>personalize</artifactId>
   	<version>2.16.83</version>
   </dependency>
   <dependency>
   	<groupId>software.amazon.awssdk</groupId>
   	<artifactId>personalizeruntime</artifactId>
   	<version>2.16.83</version>
   </dependency>
   <dependency>
   	<groupId>software.amazon.awssdk</groupId>
   	<artifactId>personalizeevents</artifactId>
   	<version>2.16.83</version>
   </dependency>
   ```

1.  Adicione as seguintes instruções de importação ao seu projeto. 

   ```
   // import client packages
   import software.amazon.awssdk.services.personalize.PersonalizeClient;
   import software.amazon.awssdk.services.personalizeruntime.PersonalizeRuntimeClient;
   // Amazon Personalize exception package
   import software.amazon.awssdk.services.personalize.model.PersonalizeException;
   // schema packages
   import software.amazon.awssdk.services.personalize.model.CreateSchemaRequest;
   // dataset group packages
   import software.amazon.awssdk.services.personalize.model.CreateDatasetGroupRequest;
   import software.amazon.awssdk.services.personalize.model.DescribeDatasetGroupRequest;
   // dataset packages
   import software.amazon.awssdk.services.personalize.model.CreateDatasetRequest;
   // dataset import job packages
   import software.amazon.awssdk.services.personalize.model.CreateDatasetImportJobRequest;
   import software.amazon.awssdk.services.personalize.model.DataSource;
   import software.amazon.awssdk.services.personalize.model.DatasetImportJob;
   import software.amazon.awssdk.services.personalize.model.DescribeDatasetImportJobRequest;
   // recommender packages
   import software.amazon.awssdk.services.personalize.model.CreateRecommenderRequest;
   import software.amazon.awssdk.services.personalize.model.CreateRecommenderResponse;
   import software.amazon.awssdk.services.personalize.model.DescribeRecommenderRequest;
   // get recommendations packages
   import software.amazon.awssdk.services.personalizeruntime.model.GetRecommendationsRequest;
   import software.amazon.awssdk.services.personalizeruntime.model.GetRecommendationsResponse;
   import software.amazon.awssdk.services.personalizeruntime.model.PredictedItem;
   // Java time utility package
   import java.time.Instant;
   ```

### Etapa 2: Criar clientes do Amazon Personalize
<a name="domain-gs-java-clients"></a>

Depois de adicionar dependências do Amazon Personalize ao seu arquivo pom.xml e importar os pacotes necessários, crie os seguintes clientes do Amazon Personalize:

```
PersonalizeClient personalizeClient = PersonalizeClient.builder()
  .region({{region}})
  .build();

PersonalizeRuntimeClient personalizeRuntimeClient = PersonalizeRuntimeClient.builder() 
  .region({{region}})
  .build();
```

### Etapa 3: Importar dados
<a name="domain-gs-java-import-dataset"></a>

Depois de inicializar seus clientes do Amazon Personalize, importe os dados históricos que você gerou ao concluir [Pré-requisitos de conceitos básicos](gs-prerequisites.md). Para importar os dados históricos para o Amazon Personalize, faça o seguinte:

1.  Salve o esquema Avro a seguir como um arquivo JSON no seu diretório de trabalho. Esse esquema corresponde às colunas no arquivo CSV que você criou ao concluir o [Como criar dados de treinamento (grupo de conjuntos de dados de domínio)](gs-prerequisites.md#gs-data-prep-domain). 

   ```
   {
     "type": "record",
     "name": "Interactions",
     "namespace": "com.amazonaws.personalize.schema",
     "fields": [
         {
             "name": "USER_ID",
             "type": "string"
         },
         {
             "name": "ITEM_ID",
             "type": "string"
         },
         {
             "name": "EVENT_TYPE",
             "type": "string"
         },
         {
             "name": "TIMESTAMP",
             "type": "long"
         }
     ],
     "version": "1.0"
   }
   ```

1. Use o método `createDomainSchema` a seguir para criar um esquema de domínio no Amazon Personalize. Envie as seguintes informações como parâmetros: um cliente do serviço Amazon Personalize, o nome do seu esquema, `VIDEO_ON_DEMAND` para o domínio e o caminho do arquivo JSON do esquema que você criou na etapa anterior. O método retorna o nome do recurso da Amazon (ARN) do novo esquema. Armazene-o para uso posterior. 

   ```
       public static String createDomainSchema(PersonalizeClient personalizeClient, String schemaName, String domain,
               String filePath) {
   
           String schema = null;
           try {
               schema = new String(Files.readAllBytes(Paths.get(filePath)));
           } catch (IOException e) {
               System.out.println(e.getMessage());
           }
   
           try {
               CreateSchemaRequest createSchemaRequest = CreateSchemaRequest.builder()
                       .name(schemaName)
                       .domain(domain)
                       .schema(schema)
                       .build();
   
               String schemaArn = personalizeClient.createSchema(createSchemaRequest).schemaArn();
   
               System.out.println("Schema arn: " + schemaArn);
   
               return schemaArn;
   
           } catch (PersonalizeException e) {
               System.err.println(e.awsErrorDetails().errorMessage());
               System.exit(1);
           }
           return "";
       }
   ```

1. Crie um grupo de conjuntos de dados. Use o método `createDomainDatasetGroup` a seguir para criar um grupo de conjuntos de dados de domínio. Envie as seguintes informações como parâmetros: um cliente do serviço Amazon Personalize, o nome do grupo de conjuntos de dados e `VIDEO_ON_DEMAND` para o domínio. O método retorna o ARN do seu novo grupo de conjuntos de dados. Armazene-o para uso posterior.

   ```
       public static String createDomainDatasetGroup(PersonalizeClient personalizeClient,
               String datasetGroupName,
               String domain) {
   
           try {
               CreateDatasetGroupRequest createDatasetGroupRequest = CreateDatasetGroupRequest.builder()
                       .name(datasetGroupName)
                       .domain(domain)
                       .build();
               return personalizeClient.createDatasetGroup(createDatasetGroupRequest).datasetGroupArn();
           } catch (PersonalizeException e) {
               System.out.println(e.awsErrorDetails().errorMessage());
           }
           return "";
       }
   ```

1. Crie um conjunto de dados de interações com itens. Use o método `createDataset` a seguir para criar um conjunto de dados de interações com itens. Envie as seguintes informações como parâmetros: um cliente do serviço Amazon Personalize, o nome do seu conjunto de dados, o ARN do seu esquema, o ARN do seu grupo de conjuntos de dados e `Interactions` para o tipo de conjunto de dados. O método retorna o ARN do seu novo conjunto de dados. Armazene-o para uso posterior.

   ```
       public static String createDataset(PersonalizeClient personalizeClient,
               String datasetName,
               String datasetGroupArn,
               String datasetType,
               String schemaArn) {
           try {
               CreateDatasetRequest request = CreateDatasetRequest.builder()
                       .name(datasetName)
                       .datasetGroupArn(datasetGroupArn)
                       .datasetType(datasetType)
                       .schemaArn(schemaArn)
                       .build();
   
               String datasetArn = personalizeClient.createDataset(request)
                       .datasetArn();
               System.out.println("Dataset " + datasetName + " created.");
               return datasetArn;
   
           } catch (PersonalizeException e) {
               System.err.println(e.awsErrorDetails().errorMessage());
               System.exit(1);
           }
           return "";
       }
   ```

1. Importe seus dados com um trabalho de importação do conjunto de dados. Use o método `createPersonalizeDatasetImportJob` a seguir para criar um trabalho de importação de conjuntos de dados. 

   Envie as seguintes informações como parâmetros: um cliente do serviço Amazon Personalize, um nome para o trabalho e o ARN do seu conjunto de dados de interações. Envie o caminho do bucket do Amazon S3 (`s3://{{bucket name}}/{{folder name}}/ratings.csv`) onde você salvou os dados de treinamento e o ARN do seu perfil de serviço. Você criou esse perfil como parte de [Pré-requisitos de conceitos básicos](gs-prerequisites.md). O método retorna o ARN do trabalho de importação do seu conjunto de dados. Você também pode guardá-lo para uso posterior. 

   ```
       public static String createPersonalizeDatasetImportJob(PersonalizeClient personalizeClient,
               String jobName,
               String datasetArn,
               String s3BucketPath,
               String roleArn) {
   
           long waitInMilliseconds = 60 * 1000;
           String status;
           String datasetImportJobArn;
   
           try {
               DataSource importDataSource = DataSource.builder()
                       .dataLocation(s3BucketPath)
                       .build();
   
               CreateDatasetImportJobRequest createDatasetImportJobRequest = CreateDatasetImportJobRequest.builder()
                       .datasetArn(datasetArn)
                       .dataSource(importDataSource)
                       .jobName(jobName)
                       .roleArn(roleArn)
                       .build();
   
               datasetImportJobArn = personalizeClient.createDatasetImportJob(createDatasetImportJobRequest)
                       .datasetImportJobArn();
               DescribeDatasetImportJobRequest describeDatasetImportJobRequest = DescribeDatasetImportJobRequest.builder()
                       .datasetImportJobArn(datasetImportJobArn)
                       .build();
   
               long maxTime = Instant.now().getEpochSecond() + 3 * 60 * 60;
   
               while (Instant.now().getEpochSecond() < maxTime) {
   
                   DatasetImportJob datasetImportJob = personalizeClient
                           .describeDatasetImportJob(describeDatasetImportJobRequest)
                           .datasetImportJob();
   
                   status = datasetImportJob.status();
                   System.out.println("Dataset import job status: " + status);
   
                   if (status.equals("ACTIVE") || status.equals("CREATE FAILED")) {
                       break;
                   }
                   try {
                       Thread.sleep(waitInMilliseconds);
                   } catch (InterruptedException e) {
                       System.out.println(e.getMessage());
                   }
               }
               return datasetImportJobArn;
   
           } catch (PersonalizeException e) {
               System.out.println(e.awsErrorDetails().errorMessage());
           }
           return "";
       }
   ```

### Etapa 4: Criar um recomendador
<a name="domain-gs-create-recommender"></a>

Depois que o trabalho de importação do conjunto de dados for concluído, você poderá criar um recomendador. Use o método `createRecommender` a seguir para criar um recomendador. Envie as seguintes informações como parâmetros: um cliente do serviço Amazon Personalize, um nome para o recomendador, o nome do recurso da Amazon (ARN) do seu grupo de conjuntos de dados e `arn:aws:personalize:::recipe/aws-vod-top-picks` para o ARN da fórmula. O método retorna o ARN do seu novo recomendador. Armazene-o para uso posterior.

```
    public static String createRecommender(PersonalizeClient personalizeClient,
            String name,
            String datasetGroupArn,
            String recipeArn) {

        long maxTime = 0;
        long waitInMilliseconds = 30 * 1000; // 30 seconds
        String recommenderStatus = "";

        try {
            CreateRecommenderRequest createRecommenderRequest = CreateRecommenderRequest.builder()
                    .datasetGroupArn(datasetGroupArn)
                    .name(name)
                    .recipeArn(recipeArn)
                    .build();

            CreateRecommenderResponse recommenderResponse = personalizeClient
                    .createRecommender(createRecommenderRequest);
            String recommenderArn = recommenderResponse.recommenderArn();
            System.out.println("The recommender ARN is " + recommenderArn);

            DescribeRecommenderRequest describeRecommenderRequest = DescribeRecommenderRequest.builder()
                    .recommenderArn(recommenderArn)
                    .build();

            maxTime = Instant.now().getEpochSecond() + 3 * 60 * 60;

            while (Instant.now().getEpochSecond() < maxTime) {

                recommenderStatus = personalizeClient.describeRecommender(describeRecommenderRequest).recommender()
                        .status();
                System.out.println("Recommender status: " + recommenderStatus);

                if (recommenderStatus.equals("ACTIVE") || recommenderStatus.equals("CREATE FAILED")) {
                    break;
                }
                try {
                    Thread.sleep(waitInMilliseconds);
                } catch (InterruptedException e) {
                    System.out.println(e.getMessage());
                }
            }
            return recommenderArn;

        } catch (PersonalizeException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }
```

### Etapa 5: Obter recomendações
<a name="domain-gs-java-get-recommendations"></a>

Depois de criar um recomendador, você poderá usá-lo para receber recomendações. Use o método `getRecs` a seguir para obter recomendações para um usuário. Envie como parâmetros um cliente do runtime do Amazon Personalize, um nome do recurso da Amazon (ARN) do recomendador que você criou na etapa anterior e um ID do usuário (por exemplo, `123`). O método exibe a lista de itens recomendados na tela. 

```
    public static void getRecs(PersonalizeRuntimeClient personalizeRuntimeClient, String recommenderArn,
            String userId) {

        try {
            GetRecommendationsRequest recommendationsRequest = GetRecommendationsRequest.builder()
                    .recommenderArn(recommenderArn)
                    .numResults(20)
                    .userId(userId)
                    .build();

            GetRecommendationsResponse recommendationsResponse = personalizeRuntimeClient
                    .getRecommendations(recommendationsRequest);
            List<PredictedItem> items = recommendationsResponse.itemList();

            for (PredictedItem item : items) {
                System.out.println("Item Id is : " + item.itemId());
                System.out.println("Item score is : " + item.score());
            }
        } catch (AwsServiceException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }
```