기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# 도메인 데이터세트 그룹 시작하기
<a name="getting-started-domain"></a>

 이 시작하기 자습서에서는 VIDEO\$1ON\$1DEMAND 도메인의 도메인 데이터세트 그룹을 만들고, CSV 파일에서 상호작용 데이터를 가져온 다음, 가장 적합한 추천 제품 사용 사례를 사용하여 추천자를 생성합니다.** 그런 다음 추천자를 사용하여 사용자를 위한 개인 맞춤형 영화 추천을 받습니다. 이 자습서에서는 600명의 사용자가 제공한 9,700개 영화에 대한 100,000개의 영화 평점으로 구성된 과거 데이터를 사용합니다.

시작하려면 [시작하기 전제 조건](gs-prerequisites.md)을 완료한 다음 Personalize 리소스를 생성하는 방법에 따라, [도메인 데이터세트 그룹 시작하기(콘솔)](getting-started-console-domain.md), [도메인 데이터세트 그룹 시작하기(Python용 SDK(Boto3))](getting-started-domain-python.md), [도메인 데이터세트 그룹 시작하기(Java 2.x용 SDK)](domain-getting-started-java.md)또는 [도메인 데이터세트 그룹 시작하기(JavaScript v3용 SDK)](getting-started-domain-js.md)로 이동합니다.

시작하기 연습을 마쳤을 때 불필요한 요금이 발생하지 않도록 하려면 생성한 리소스를 삭제합니다. 자세한 내용은 [Amazon Personalize 리소스 삭제 요구 사항](deleting-resources.md) 섹션을 참조하세요.

**Topics**
+ [도메인 데이터세트 그룹 시작하기(콘솔)](getting-started-console-domain.md)
+ [도메인 데이터세트 그룹 시작하기(Java 2.x용 SDK)](domain-getting-started-java.md)
+ [도메인 데이터세트 그룹 시작하기(Python용 SDK(Boto3))](getting-started-domain-python.md)
+ [도메인 데이터세트 그룹 시작하기(JavaScript v3용 SDK)](getting-started-domain-js.md)

# 도메인 데이터세트 그룹 시작하기(콘솔)
<a name="getting-started-console-domain"></a>

이 연습에서는 Personalize 콘솔을 사용하여 도메인 데이터세트 그룹과, 지정한 사용자에 대해 추천 영화를 반환하는 추천자를 생성합니다.

이 연습을 시작하기 전에 [시작하기 전제 조건](gs-prerequisites.md)단원을 복습합니다.

시작하기 연습을 마쳤을 때 불필요한 요금이 발생하지 않도록 하려면 생성한 리소스를 삭제합니다. 자세한 내용은 [Amazon Personalize 리소스 삭제 요구 사항](deleting-resources.md) 단원을 참조하십시오.

## 1단계: 도메인 데이터세트 그룹 생성
<a name="getting-started-console-import-dataset-domain"></a>

 이 절차에서는 VIDEO\$1ON\$1DEMAND 도메인의 도메인 데이터 세트 그룹을 만들고, VIDEO\$1ON\$1DEMAND 도메인의 기본 스키마를 사용하여 항목 상호 작용 데이터 세트를 만들고, [학습 데이터 생성(도메인 데이터세트 그룹)](gs-prerequisites.md#gs-data-prep-domain)에서 생성한 항목 상호 작용 데이터를 가져옵니다.

**도메인 데이터세트 그룹을 생성하려면**

1. [https://console.aws.amazon.com/acm-pca/home](https://console.aws.amazon.com/personalize/home)에서 Personalize 콘솔을 열고 계정에 로그인합니다.

1. 탐색 창에서 **데이터세트 그룹 생성**을 선택합니다.

1. **데이터세트 그룹 세부 정보**에서 데이터세트 그룹의 이름을 지정합니다.

1.  **도메인**의 경우 **온디맨드 비디오**를 선택합니다. 선택한 도메인에 따라 데이터를 가져올 때 사용하는 기본 스키마가 결정됩니다. 또한 추천자가 사용할 수 있는 사용 사례도 결정됩니다. 다음과 유사한 화면이 표시되어야 합니다.  
![\[이름 및 도메인 필드가 있는 데이터세트 그룹 생성 페이지를 보여줍니다.\]](http://docs.aws.amazon.com/ko_kr/personalize/latest/dg/images/gs-domain-1-create-dsg.png)

1. **데이터세트 그룹 생성**을 선택합니다. 개요 페이지가 나타납니다. [2단계: 데이터 가져오기](#getting-started-import-data-domain)로 이동합니다.

## 2단계: 데이터 가져오기
<a name="getting-started-import-data-domain"></a>

 이 절차에서는 기본 VIDEO\$1ON\$1DEMAND 도메인 스키마를 사용하여 항목 상호 작용 데이터 세트를 생성합니다. 그런 다음 [학습 데이터 생성(도메인 데이터세트 그룹)](gs-prerequisites.md#gs-data-prep-domain)에서 생성한 항목 상호 작용 데이터를 가져옵니다.

**데이터를 가져오려면**

1. 개요 페이지의 **1단계: 데이터세트 생성 및 데이터 가져오기**를 선택하고 **데이터세트 생성**을 선택한 다음 **항목 상호 작용 데이터세트**를 선택합니다.

1. **Personalize 데이터세트로 직접 데이터 가져오기**를 선택하고 **다음**을 선택합니다.

1. **항목 상호 작용 스키마 구성** 페이지에서 **데이터 세트 이름**에 대해 항목 상호 작용 데이터 세트의 이름을 입력합니다.

1. **데이터세트 스키마**의 경우 **도메인의 기존 기본 스키마를 수정하여 새 도메인 스키마 만들기**를 선택하고 스키마의 이름을 입력합니다. **스키마 정의**가 업데이트되어 VIDEO\$1ON\$1DEMAND 도메인의 기본 스키마가 표시됩니다. 스키마는 변경하지 않고 그대로 둡니다. 다음과 유사한 화면이 표시되어야 합니다.  
![\[데이터세트 및 스키마 필드가 있는 항목 상호 작용 스키마 구성 페이지를 보여줍니다.\]](http://docs.aws.amazon.com/ko_kr/personalize/latest/dg/images/gs-domain-2-create-dataset.png)

1. **다음**을 선택합니다. **항목 상호 작용 데이터 세트 가져오기 작업 구성** 페이지가 나타납니다.

1. **항목 상호 작용 데이터 세트 가져오기 작업 구성** 페이지에서 **데이터 가져오기 소스**를 변경하지 않고 **S3에서 데이터 가져오기**로 그대로 둡니다.

1. **데이터세트 가져오기 작업 이름**의 경우 가져오기 작업 이름을 지정합니다.

1. **데이터 가져오기 소스**의 경우 Amazon Simple Storage Service(S3)에서 데이터가 저장되는 위치를 지정합니다. 다음 구문을 사용합니다.

   **s3://amzn-s3-demo-bucket/<folder path>/<CSV filename>**

1. **IAM 역할**에서 **IAM 서비스 역할**에 대해 **사용자 지정 IAM 역할 ARN 입력**을 선택하고 [Personalize에 대한 IAM 역할 생성](set-up-required-permissions.md#set-up-create-role-with-permissions)에서 생성한 역할의 리소스 이름(ARN)을 입력합니다. 다음과 유사한 화면이 표시되어야 합니다.  
![\[가져오기 작업 필드가 있는 항목 상호 작용 데이터세트 가져오기 작업 구성 페이지를 보여줍니다.\]](http://docs.aws.amazon.com/ko_kr/personalize/latest/dg/images/gs-domain-3-import-job.png)

1. 데이터를 가져오려면 **가져오기 시작**을 선택합니다. 도메인 데이터세트 그룹의 **개요** 페이지가 나타납니다. **데이터세트 설정** 섹션에서 가져오기의 상태를 확인합니다. 상태가 `Interaction data active`이면 [3단계: 추천자 생성](#getting-started-console-create-recommenders)로 이동합니다.

## 3단계: 추천자 생성
<a name="getting-started-console-create-recommenders"></a>

이 절차에서는 VIDEO\$1ON\$1DEMAND 도메인의 가장 적합한 추천 제품 사용 사례에 대한 추천자를 생성합니다.**

**추천자를 생성하려면**

1.  도메인 데이터 세트 그룹에 대한 **개요** 페이지의 **3단계**에서 **온디맨드 비디오 추천자 사용** 탭을 선택하고 **추천자 생성**을 선택합니다.

1. **사용 사례 선택** 페이지에서 **가장 적합한 추천 제품**을 선택하고 **추천자 이름**을 입력합니다. 다음과 유사한 화면이 표시되어야 합니다.  
![\[선택할 수 있는 사용 사례 옵션 목록이 있는 사용 사례 선택 페이지를 보여줍니다.\]](http://docs.aws.amazon.com/ko_kr/personalize/latest/dg/images/gs-domain-4-create-recommender.png)

1. **다음**을 선택합니다.

1. **고급 구성** 페이지의 필드를 변경하지 않고 **다음**을 선택합니다.

1. 추천자 세부 정보를 검토하고 **추천자 생성**을 선택하여 추천자를 생성합니다.

   **추천자** 페이지에서 각 추천자의 상태를 모니터링할 수 있습니다. 추천자 상태가 **Active**이면 이 상태를 사용하여 [4단계: 추천 받기](#getting-started-console-get-recommendations-domain)에서 추천을 받을 수 있습니다.

## 4단계: 추천 받기
<a name="getting-started-console-get-recommendations-domain"></a>

이 절차에서는 이전 단계에서 생성한 추천자를 사용하여 추천을 받습니다.

**추천을 받으려면**

1. 도메인 데이터세트 그룹의 개요 페이지의 탐색 창에서 **추천자**를 선택합니다.

1.  **추천자** 페이지에서 추천자를 선택합니다.

1.  오른쪽 상단에서 **테스트**를 선택합니다.

1. **추천 파라미터**에 사용자 ID를 입력합니다. 다른 필드는 바꾸지 않고 그대로 둡니다.

1. **추천 받기**를 선택합니다. 해당 사용자의 상위 25개 추천이 포함된 표가 나타납니다. 다음과 유사한 화면이 표시되어야 합니다.  
![\[추천 요청에 대한 필드가 있는 추천자 테스트 페이지를 보여줍니다.\]](http://docs.aws.amazon.com/ko_kr/personalize/latest/dg/images/gs-domain-5-get-recc.png)

# 도메인 데이터세트 그룹 시작하기(Java 2.x용 SDK)
<a name="domain-getting-started-java"></a>

이 가이드에서는 Java 2.x용 SDK를 사용하여 VIDEO\$1ON\$1DEMAND 도메인에 대한 도메인 데이터세트 그룹을 생성하는 방법을 보여줍니다. 이 자습서에서는 가장 적합한 추천 제품 사용 사례를 위한 추천자를 생성합니다.**

시작하기 연습을 마쳤을 때 불필요한 요금이 발생하지 않도록 하려면 생성한 리소스를 삭제합니다. 자세한 내용은 [Amazon Personalize 리소스 삭제 요구 사항](deleting-resources.md) 섹션을 참조하세요.

## 사전 조건
<a name="domain-gs-java-prerequisites"></a>

이 자습서를 완료하기 위한 필수 조건 단계는 다음과 같습니다.
+ [시작하기 전제 조건](gs-prerequisites.md)를 완료하여 필요한 권한을 설정하고 학습 데이터를 생성합니다. [도메인 데이터세트 그룹 시작하기(콘솔)](getting-started-console-domain.md)를 완료한 경우에도 동일한 소스 데이터를 재사용할 수 있습니다. 고유한 소스 데이터를 사용하는 경우 필수 조건 단계와 같이 데이터의 형식이 지정되었는지 확인합니다.
+ *AWS SDK for Java 2.x 개발자 안내서*의 [AWS SDK for Java 2.x 설정](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html) 절차에 지정된 대로 Java 2.x용 SDK 환경 및 AWS 보안 인증을 설정합니다.

## 자습서
<a name="gs-java-domain-tutorial"></a>

다음에 이어지는 단계에서는 Personalize 패키지를 사용하도록 프로젝트를 설정하고 Personalize Java 2.x용 SDK 클라이언트를 생성합니다. 그런 다음 데이터를 가져오고, 가장 적합한 추천 제품 사용 사례를 위한 추천자를 생성한 다음 추천을 받습니다.**

### 1단계: Personalize 패키지를 사용하도록 프로젝트 설정
<a name="domain-gs-java-set-up-project"></a>

필수 조건을 완료한 후, Personalize 종속 항목을 pom.xml 파일에 추가하고 Personalize 패키지를 가져옵니다.

1.  pom.xml 파일에 다음 종속 항목을 추가합니다. 최신 버전 번호가 예제 코드와 다를 수 있습니다.

   ```
   <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.  프로젝트에 다음 가져오기 명령문을 추가합니다.

   ```
   // 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;
   ```

### 2단계: Personalize 클라이언트 생성
<a name="domain-gs-java-clients"></a>

Personalize 종속 항목을 pom.xml 파일에 추가하고 필요한 패키지를 가져온 후 다음과 같은 Personalize 클라이언트를 생성합니다.

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

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

### 3단계: 데이터 가져오기
<a name="domain-gs-java-import-dataset"></a>

Personalize 클라이언트를 초기화한 후에는 [시작하기 전제 조건](gs-prerequisites.md)완료 시 생성한 과거 데이터를 가져옵니다. 과거 데이터를 Personalize로 가져오려면 다음과 같이 합니다.

1.  다음 Avro 스키마를 작업 디렉토리에 JSON 파일로 저장합니다. 이 스키마는 [학습 데이터 생성(도메인 데이터세트 그룹)](gs-prerequisites.md#gs-data-prep-domain)을 완료할 때 만든 CSV 파일의 열과 일치합니다.

   ```
   {
     "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. 다음 `createDomainSchema`메서드를 사용하여 Personalize에서 도메인 스키마를 생성합니다. Personalize 서비스 클라이언트, 스키마 이름, 도메인에 대한 `VIDEO_ON_DEMAND`, 이전 단계에서 생성한 스키마 JSON 파일의 파일 경로를 파라미터로 전달합니다. 메서드가 새 스키마의 리소스 이름(ARN)을 반환합니다. 나중에 사용하기 위해 이 ARN을 저장합니다.

   ```
       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. 데이터세트 그룹을 생성합니다. 다음 `createDomainDatasetGroup`메서드를 사용하여 도메인 데이터세트 그룹을 생성합니다. Personalize 서비스 클라이언트, 데이터세트 그룹 이름을 파라미터로 전달하고 도메인에 대해 `VIDEO_ON_DEMAND`을 전달합니다. 메서드가 새 데이터세트 그룹의 ARN을 반환합니다. 나중에 사용하기 위해 이 ARN을 저장합니다.

   ```
       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. 항목 상호 작용 데이터 세트를 생성합니다. 다음 `createDataset` 메서드를 사용하여 항목 상호 작용 데이터 세트를 생성합니다. Personalize 서비스 클라이언트, 데이터세트 이름, 스키마의 ARN, 데이터세트 그룹의 ARN, 데이터세트 유형에 대한 `Interactions`을 파라미터로 전달합니다. 메서드가 새 데이터세트의 ARN을 반환합니다. 나중에 사용하기 위해 이 ARN을 저장합니다.

   ```
       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. 데이터세트 가져오기 작업을 사용하여 데이터를 가져옵니다. 다음 `createPersonalizeDatasetImportJob`메서드를 사용하여 데이터세트 가져오기 작업을 생성합니다.

   Personalize 서비스 클라이언트, 작업 이름, 상호작용 데이터세트의 ARN을 파라미터로 전달합니다. 학습 데이터를 저장한 S3 버킷 경로(`s3://bucket name/folder name/ratings.csv`)와 서비스 역할의 ARN을 전달합니다. [시작하기 전제 조건](gs-prerequisites.md)의 일부로 이 역할을 생성했습니다. 메서드가 데이터세트 가져오기 작업의 ARN을 반환합니다. 나중에 사용할 수 있도록 저장할 수도 있습니다.

   ```
       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 "";
       }
   ```

### 4단계: 추천자 생성
<a name="domain-gs-create-recommender"></a>

데이터세트 가져오기 작업이 완료되면 추천자를 생성할 준비가 된 것입니다. 추천자를 생성하려면 다음 `createRecommender`메서드를 사용합니다. Personalize 서비스 클라이언트, 추천자 이름, 데이터세트 그룹의 리소스 이름(ARN), 레시피 ARN에 대한 `arn:aws:personalize:::recipe/aws-vod-top-picks`을 파라미터로 전달합니다. 메서드가 새 추천자의 ARN을 반환합니다. 나중에 사용하기 위해 이 ARN을 저장합니다.

```
    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 "";
    }
```

### 5단계: 추천 받기
<a name="domain-gs-java-get-recommendations"></a>

추천자를 만든 후에는 이를 사용하여 추천을 받을 수 있습니다. 사용자에 대한 추천을 받으려면 다음 `getRecs`메서드를 사용합니다. Personalize 런타임 클라이언트, 이전 단계에서 생성한 추천자의 리소스 이름(ARN) 및 사용자 ID(예: `123`)를 파라미터로 전달합니다. 메서드가 추천 항목 목록을 화면에 인쇄합니다.

```
    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);
        }
    }
```

# 도메인 데이터세트 그룹 시작하기(Python용 SDK(Boto3))
<a name="getting-started-domain-python"></a>

이 가이드에서는 Python용 SDK(Boto3)를 사용하여 VIDEO\$1ON\$1DEMAND 도메인에 대한 도메인 데이터세트 그룹을 만드는 방법을 보여줍니다. 이 자습서에서는 가장 적합한 추천 제품 사용 사례를 위한 추천자를 생성합니다.**

시작하기 연습을 마쳤을 때 불필요한 요금이 발생하지 않도록 하려면 생성한 리소스를 삭제합니다. 자세한 내용은 [Amazon Personalize 리소스 삭제 요구 사항](deleting-resources.md) 단원을 참조하십시오.

**Topics**
+ [사전 조건](#gs-sdk-domain-prerequisites)
+ [자습서](#gs-python-tutorial)
+ [주피터(IPython) 노트북으로 Personalize API 사용 시작하기](#gs-jupyter-domain-notebook)

## 사전 조건
<a name="gs-sdk-domain-prerequisites"></a>

다음은 이 안내서에서 Python 예제를 사용하기 위한 필수 조건 단계입니다.
+ [시작하기 전제 조건](gs-prerequisites.md)를 완료하여 필요한 권한을 설정하고 학습 데이터를 생성합니다. 고유한 소스 데이터를 사용하는 경우 필수 조건 단계와 같이 데이터의 형식이 지정되었는지 확인합니다.
+ 에 지정된 대로 AWS SDK for Python (Boto3) 환경을 설정합니다[AWS SDKs 설정](aws-personalize-set-up-sdks.md).

## 자습서
<a name="gs-python-tutorial"></a>

다음에 이어지는 단계에서는 환경을 확인하고 Personalize용 Python용 SDK(Boto3) 클라이언트를 생성합니다. 그런 다음 데이터를 가져오고, 가장 적합한 추천 제품 사용 사례를 위한 추천자를 생성한 다음 추천을 받습니다.**

### 1단계: Python 환경을 확인하고 boto3 클라이언트 만들기
<a name="gs-python-domain-verify-environment"></a>

필수 조건을 완료한 후 다음 Python 예제를 실행하여 환경이 올바르게 구성되었는지 확인합니다. 또한 이 코드는 이 자습서에서 사용하는 Personalize boto3 클라이언트를 생성합니다. 환경이 올바르게 구성된 경우 사용 가능한 레시피 목록이 표시되고 이 자습서의 다른 Python 예제를 실행할 수 있습니다.

```
import boto3

personalizeRt = boto3.client('personalize-runtime')
personalize = boto3.client('personalize')

response = personalize.list_recipes()

for recipe in response['recipes']:
    print (recipe)
```

### 2단계: 데이터 가져오기
<a name="getting-started-python-domain-import-dataset"></a>

Personalize boto3 클라이언트를 생성하고 환경을 확인했으면, [시작하기 전제 조건](gs-prerequisites.md)완료 시 생성한 과거 데이터를 가져옵니다. 과거 데이터를 Personalize로 가져오려면 다음과 같이 합니다.

1. 다음 코드를 사용하여 Personalize에서 스키마를 생성합니다. `gs-domain-interactions-schema`을 스키마의 이름으로 바꿉니다.

   ```
   import json
   schema = {
     "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"
   }
   
   create_interactions_schema_response = personalize.create_schema(
       name='gs-domain-interactions-schema',
       schema=json.dumps(schema),
       domain='VIDEO_ON_DEMAND'
   )
   
   interactions_schema_arn = create_interactions_schema_response['schemaArn']
   print(json.dumps(create_interactions_schema_response, indent=2))
   ```

1. 다음 코드를 사용하여 데이터세트 그룹을 생성합니다. `dataset group name`을 데이터세트 그룹의 이름으로 바꿉니다.

   ```
   response = personalize.create_dataset_group(
     name = 'dataset group name',
     domain = 'VIDEO_ON_DEMAND'
   )
   dsg_arn = response['datasetGroupArn']
   
   description = personalize.describe_dataset_group(datasetGroupArn = dsg_arn)['datasetGroup']
   
   print('Name: ' + description['name'])
   print('ARN: ' + description['datasetGroupArn'])
   print('Status: ' + description['status'])
   ```

1. 다음 코드를 사용하여 새 데이터 세트 그룹에 항목 상호 작용 데이터 세트를 만듭니다. 데이터세트에 이름을 지정하고 이전 단계의 `schema_arn`및 `dataset_group_arn`를 입력합니다.

   ```
   response = personalize.create_dataset(
       name = 'interactions-dataset-name',
       schemaArn = interactions_schema_arn,
       datasetGroupArn = dsg_arn,
       datasetType = 'INTERACTIONS'
   )
   
   dataset_arn = response['datasetArn']
   ```

1. 다음 코드를 사용한 데이터세트 가져오기 작업으로 데이터를 가져옵니다. 코드는 describe\$1dataset\$1import\$1job 메서드를 사용하여 작업 상태를 추적합니다.

   작업 이름, 이전 단계의 `dataset_arn`, 학습 데이터를 저장한 S3 버킷 경로(`s3://bucket name/folder name/ratings.csv`), IAM 서비스 역할의 ARN 등을 파라미터로 전달합니다. [시작하기 전제 조건](gs-prerequisites.md)의 일부로 이 역할을 생성했습니다. 버킷에 액세스할 수 있는 권한이 Personalize에 필요합니다. 액세스 권한 부여에 대한 자세한 내용은 [Personalize에 S3 리소스에 대한 액세스 권한 부여](granting-personalize-s3-access.md)단원을 참조하세요.

   ```
   import time
   response = personalize.create_dataset_import_job(
       jobName = 'JobName',
       datasetArn = 'dataset_arn',
       dataSource = {'dataLocation':'s3://amzn-s3-demo-bucket/filename.csv'},
       roleArn = 'role_arn'
   )
   
   dataset_interactions_import_job_arn = response['datasetImportJobArn']
   
   description = personalize.describe_dataset_import_job(
       datasetImportJobArn = dataset_interactions_import_job_arn)['datasetImportJob']
   
   print('Name: ' + description['jobName'])
   print('ARN: ' + description['datasetImportJobArn'])
   print('Status: ' + description['status'])
   
   max_time = time.time() + 3*60*60 # 3 hours
   while time.time() < max_time:
       describe_dataset_import_job_response = personalize.describe_dataset_import_job(
           datasetImportJobArn = dataset_interactions_import_job_arn
       )
       status = describe_dataset_import_job_response["datasetImportJob"]['status']
       print("Interactions DatasetImportJob: {}".format(status))
       
       if status == "ACTIVE" or status == "CREATE FAILED":
           break
           
       time.sleep(60)
   ```

### 4단계: 추천자 생성
<a name="domain-gs-py-create-recommender"></a>

데이터세트 가져오기 작업이 완료되면 추천자를 생성할 준비가 된 것입니다. 추천자를 생성하려면 다음 코드를 사용합니다. 추천자 이름, 데이터세트 그룹의 리소스 이름(ARN), 레시피 ARN에 대한 `arn:aws:personalize:::recipe/aws-vod-top-picks`을 파라미터로 전달합니다. 코드는 describe\$1commender 메서드를 사용하여 추천자의 상태를 추적합니다.

```
import time
create_recommender_response = personalize.create_recommender(
  name = 'gs-python-top-picks',
  recipeArn = 'arn:aws:personalize:::recipe/aws-vod-top-picks',
  datasetGroupArn = dsg_arn     
)
recommender_arn = create_recommender_response['recommenderArn']

print('Recommender ARN:' + recommender_arn)
max_time = time.time() + 3*60*60 # 3 hours
while time.time() < max_time:

    version_response = personalize.describe_recommender(
        recommenderArn = recommender_arn
    )
    status = version_response["recommender"]["status"]

    if status == "ACTIVE":
        print("Creation succeeded for {}".format(recommender_arn))
        
    elif status == "CREATE FAILED":
        print("Creation failed for {}".format(recommender_arn))

    if status == "ACTIVE":
        break
    else:
        print("Recommender creation is still in progress")
        
    time.sleep(60)
```

### 5단계: 추천 받기
<a name="domain-gs-py-get-recommendations"></a>

추천자를 만든 후에는 이를 사용하여 다음 코드를 통해 추천을 받을 수 있습니다. 이전 단계에서 생성한 추천자의 리소스 이름(ARN)과 사용자 ID(예: `123`)를 파라미터로 전달합니다. 메서드가 추천 항목 목록을 인쇄합니다.

```
response = personalizeRt.get_recommendations(
    recommenderArn = "arn:aws:personalize:us-west-2:014025156336:recommender/gs-python-top-picks-89",
    userId = '123'
)
print("Recommended items")
for item in response['itemList']:
    print (item['itemId'])
```

## 주피터(IPython) 노트북으로 Personalize API 사용 시작하기
<a name="gs-jupyter-domain-notebook"></a>

 주피터 노트북으로 도메인 데이터세트 그룹 생성을 시작하려면 [Personalize 샘플](https://github.com/aws-samples/amazon-personalize-samples) 리포지토리의 [notebooks\$1managed\$1domain](https://github.com/aws-samples/amazon-personalize-samples/tree/master/getting_started/notebooks_managed_domains) 폴더에 있는 노트북 시리즈를 복제하거나 다운로드합니다. 노트북에서는 Personalize를 사용하여 학습 데이터를 가져오고, 추천자를 생성하고, 추천을 받는 과정을 안내합니다.

**참고**  
 노트북을 시작하기 전에 [README.md](https://github.com/aws-samples/amazon-personalize-samples/blob/master/getting_started/README.md)의 단계에 따라 환경을 구축해야 합니다 

# 도메인 데이터세트 그룹 시작하기(JavaScript v3용 SDK)
<a name="getting-started-domain-js"></a>

이 가이드에서는 AWS SDK for JavaScriptv3를 사용하여 VIDEO\$1ON\$1DEMAND 도메인에 대한 도메인 데이터세트 그룹을 만드는 방법을 보여줍니다. 이 자습서에서는 가장 적합한 추천 제품 사용 사례를 위한 추천자를 생성합니다.**

 GitHub에서 이 자습서에 사용된 코드를 보려면 AWSSDK 코드 예제 리포지토리에서 [JavaScript v3용 SDK의 Personalize 코드 예제](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/personalize)를 참조하세요.**

시작하기 연습을 마쳤을 때 불필요한 요금이 발생하지 않도록 하려면 생성한 리소스를 삭제합니다. 자세한 내용은 [Amazon Personalize 리소스 삭제 요구 사항](deleting-resources.md) 섹션을 참조하세요.

**Topics**
+ [사전 조건](#gs-js-sdk-domain-prerequisites)
+ [자습서](#domain-gs-js-domain-tutorial)

## 사전 조건
<a name="gs-js-sdk-domain-prerequisites"></a>

이 자습서를 완료하기 위한 필수 조건 단계는 다음과 같습니다.
+ [시작하기 전제 조건](gs-prerequisites.md)를 완료하여 필요한 권한을 설정하고 학습 데이터를 생성합니다. [도메인 데이터세트 그룹 시작하기(콘솔)](getting-started-console-domain.md)를 완료한 경우에도 동일한 소스 데이터를 재사용할 수 있습니다. 고유한 소스 데이터를 사용하는 경우 필수 조건 단계와 같이 데이터의 형식이 지정되었는지 확인합니다.
+ AWS SDK for JavaScript 개발자 안내서의 [JavaScript용 SDK 설정](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-up.html) 절차에 지정된 대로 JavaScript용 SDK 및 AWS보안 인증을 설정합니다.**

## 자습서
<a name="domain-gs-js-domain-tutorial"></a>

다음 단계에서는 필수 종속 항목을 설치합니다. 그런 다음 데이터세트 그룹을 만들고, 데이터를 가져오고, 가장 적합한 추천 제품 사용 사례를 위한 추천자를 생성한 다음 추천을 받습니다.**

Node.js를 사용하는 경우 샘플을 JavaScript 파일로 저장한 다음 `node <fileName.js>`을 실행하여 각 코드 샘플을 실행할 수 있습니다.

### 1단계: Personalize 종속 항목 설치
<a name="domain-gs-js-install-dependencies"></a>

필수 조건을 완료한 후에는 다음과 같은 Personalize 종속 항목을 설치합니다.
+ @aws-sdk/client-personalize
+ @aws-sdk/client-personalize-runtime
+ @aws -sdk/client-personalize-events(이 자습서에서는 선택 사항이지만 추천자를 만든 후 [이벤트를 기록](recording-events.md)하려는 경우 필수)

다음은 사용할 수 있는 `package.json`파일의 예제입니다. Node.js를 사용하여 종속 항목을 설치하려면 `package.json`파일을 저장한 위치로 이동하여 `npm install`를 실행합니다.

```
{
  "name": "personalize-js-project",
  "version": "1.0.0",
  "description": "personalize operations",
  "type": "module",
  "author": "Author Name <email@address.com>",
  "license": "ISC",
  "dependencies": {
    "@aws-sdk/client-personalize": "^3.350.0",
    "@aws-sdk/client-personalize-events": "^3.350.0",
    "@aws-sdk/client-personalize-runtime": "^3.350.0",
    "fs": "^0.0.1-security"
  },
  "compilerOptions": {
    "resolveJsonModule": true,
    "esModuleInterop": true
  }
}
```

### 2단계: Personalize 클라이언트 생성
<a name="domain-gs-js-clients"></a>

종속 항목을 설치한 후 Personalize 클라이언트를 생성합니다. 이 자습서의 코드 샘플에서는 `libs`라는 디렉토리에 `personalizeClients.js`라는 이름의 파일에 클라이언트를 생성한다고 가정합니다.

다음은 `personalizeClient.js`파일의 예제입니다.

```
import { PersonalizeClient } from "@aws-sdk/client-personalize";
import { PersonalizeRuntimeClient } from "@aws-sdk/client-personalize-runtime";
import { PersonalizeEventsClient } from "@aws-sdk/client-personalize-events";
// Set your AWS region.
const REGION = "region"; //e.g. "us-east-1"

const personalizeClient = new PersonalizeClient({ region: REGION});
const personalizeEventsClient = new PersonalizeEventsClient({ region: REGION});
const personalizeRuntimeClient = new PersonalizeRuntimeClient({ region: REGION});

export { personalizeClient, personalizeEventsClient, personalizeRuntimeClient };
```

### 3단계: 데이터 가져오기
<a name="domain-gs-js-import-dataset"></a>

Personalize 클라이언트를 생성한 후에는 [시작하기 전제 조건](gs-prerequisites.md)완료 시 생성한 과거 데이터를 가져옵니다. 과거 데이터를 Personalize로 가져오려면 다음과 같이 합니다.

1.  다음 Avro 스키마를 작업 디렉토리에 JSON 파일로 저장합니다. 이 스키마는 [학습 데이터 생성(도메인 데이터세트 그룹)](gs-prerequisites.md#gs-data-prep-domain)을 완료할 때 만든 CSV 파일의 열과 일치합니다.

   ```
   {
     "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. 다음 `createDomainSchema.js`코드를 사용하여 Personalize에서 도메인 스키마를 생성합니다. `SCHEMA_PATH`을 방금 생성한 schema.json 파일의 경로로 바꿉니다. `createSchemaParam`을 업데이트하여 스키마의 이름을 지정하고 `domain`에 대해 `VIDEO_ON_DEMAND`을 지정합니다.

   ```
   // Get service clients module and commands using ES6 syntax.
   import { CreateSchemaCommand } from "@aws-sdk/client-personalize";
   import { personalizeClient } from "./libs/personalizeClients.js";
   
   // Or, create the client here.
   // const personalizeClient = new PersonalizeClient({ region: "REGION"});
   
   import fs from "node:fs";
   
   const schemaFilePath = "SCHEMA_PATH";
   let mySchema = "";
   
   try {
     mySchema = fs.readFileSync(schemaFilePath).toString();
   } catch (err) {
     mySchema = "TEST"; // for unit tests.
   }
   
   // Set the domain schema parameters.
   export const createDomainSchemaParam = {
     name: "NAME" /* required */,
     schema: mySchema /* required */,
     domain:
       "DOMAIN" /* required for a domain dataset group, specify ECOMMERCE or VIDEO_ON_DEMAND */,
   };
   
   export const run = async () => {
     try {
       const response = await personalizeClient.send(
         new CreateSchemaCommand(createDomainSchemaParam),
       );
       console.log("Success", response);
       return response; // For unit tests.
     } catch (err) {
       console.log("Error", err);
     }
   };
   run();
   ```

1. 다음 `createDomainDatasetGroup.js`코드를 사용하여 Personalize에서 도메인 데이터세트 그룹을 생성합니다. `domainDatasetGroupParams`을 업데이트하여 데이터세트 그룹의 이름을 지정하고 `domain`에 대해 `VIDEO_ON_DEMAND`을 지정합니다.

   ```
   // Get service clients module and commands using ES6 syntax.
   import { CreateDatasetGroupCommand } from "@aws-sdk/client-personalize";
   import { personalizeClient } from "./libs/personalizeClients.js";
   
   // Or, create the client here.
   // const personalizeClient = new PersonalizeClient({ region: "REGION"});
   
   // Set the domain dataset group parameters.
   export const domainDatasetGroupParams = {
     name: "NAME" /* required */,
     domain:
       "DOMAIN" /* required for a domain dsg, specify ECOMMERCE or VIDEO_ON_DEMAND */,
   };
   
   export const run = async () => {
     try {
       const response = await personalizeClient.send(
         new CreateDatasetGroupCommand(domainDatasetGroupParams),
       );
       console.log("Success", response);
       return response; // For unit tests.
     } catch (err) {
       console.log("Error", err);
     }
   };
   run();
   ```

1. 다음 `createDataset.js` 코드를 사용하여 Amazon Personalize에서 항목 상호 작용 데이터 세트를 생성합니다. `createDatasetParam`을 업데이트하여 방금 생성한 데이터세트 그룹 및 스키마의 리소스 이름(ARN)을 지정하고, 데이터세트에 이름을 지정한 다음, `datasetType`에 대해 `Interactions`을 지정합니다.

   ```
   // Get service clients module and commands using ES6 syntax.
   import { CreateDatasetCommand } from "@aws-sdk/client-personalize";
   import { personalizeClient } from "./libs/personalizeClients.js";
   
   // Or, create the client here.
   // const personalizeClient = new PersonalizeClient({ region: "REGION"});
   
   // Set the dataset's parameters.
   export const createDatasetParam = {
     datasetGroupArn: "DATASET_GROUP_ARN" /* required */,
     datasetType: "DATASET_TYPE" /* required */,
     name: "NAME" /* required */,
     schemaArn: "SCHEMA_ARN" /* required */,
   };
   
   export const run = async () => {
     try {
       const response = await personalizeClient.send(
         new CreateDatasetCommand(createDatasetParam),
       );
       console.log("Success", response);
       return response; // For unit tests.
     } catch (err) {
       console.log("Error", err);
     }
   };
   run();
   ```

1. 다음 `createDatasetImportJob.js`코드를 사용하여 데이터를 가져옵니다. `datasetImportJobParam`을 업데이트하여 다음을 지정합니다.
   + 작업 이름을 지정하고 상호작용 데이터세트의 ARN을 지정합니다.
   + `dataLocation`의 경우, 학습 데이터를 저장한 S3 버킷 경로(`s3://https://amzn-s3-demo-bucket.s3.region-code.amazonaws.com/folder name/ratings.csv`)를 지정합니다.
   + `roleArn`의 경우, Personalize 서비스 역할에 대한 리소스 이름을 지정합니다. [시작하기 전제 조건](gs-prerequisites.md)의 일부로 이 역할을 생성했습니다.

   ```
   // Get service clients module and commands using ES6 syntax.
   import { CreateDatasetImportJobCommand } from "@aws-sdk/client-personalize";
   import { personalizeClient } from "./libs/personalizeClients.js";
   
   // Or, create the client here.
   // const personalizeClient = new PersonalizeClient({ region: "REGION"});
   
   // Set the dataset import job parameters.
   export const datasetImportJobParam = {
     datasetArn: "DATASET_ARN" /* required */,
     dataSource: {
       /* required */
       dataLocation: "S3_PATH",
     },
     jobName: "NAME" /* required */,
     roleArn: "ROLE_ARN" /* required */,
   };
   
   export const run = async () => {
     try {
       const response = await personalizeClient.send(
         new CreateDatasetImportJobCommand(datasetImportJobParam),
       );
       console.log("Success", response);
       return response; // For unit tests.
     } catch (err) {
       console.log("Error", err);
     }
   };
   run();
   ```

### 4단계: 추천자 생성
<a name="domain-gs-js-create-recommender"></a>

데이터세트 가져오기 작업이 완료되면 추천자를 생성할 준비가 된 것입니다. 추천자를 생성하려면 다음 `createRecommender.js`코드를 사용합니다. 다음과 같이 `createRecommenderParam`을 업데이트합니다. 추천자 이름을 지정하고, 데이터세트 그룹의 ARN을 지정하고, `recipeArn`에 대해 `arn:aws:personalize:::recipe/aws-vod-top-picks`을 지정합니다.

```
// Get service clients module and commands using ES6 syntax.
import { CreateRecommenderCommand } from "@aws-sdk/client-personalize";
import { personalizeClient } from "./libs/personalizeClients.js";

// Or, create the client here.
// const personalizeClient = new PersonalizeClient({ region: "REGION"});

// Set the recommender's parameters.
export const createRecommenderParam = {
  name: "NAME" /* required */,
  recipeArn: "RECIPE_ARN" /* required */,
  datasetGroupArn: "DATASET_GROUP_ARN" /* required */,
};

export const run = async () => {
  try {
    const response = await personalizeClient.send(
      new CreateRecommenderCommand(createRecommenderParam),
    );
    console.log("Success", response);
    return response; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

### 5단계: 추천 받기
<a name="domain-gs-js-get-recommendations"></a>

추천자를 만든 후에는 이를 사용하여 추천을 받을 수 있습니다. 사용자에 대한 추천을 받으려면 다음 `getRecommendations.js`코드를 사용합니다. `getRecommendationsParam`을 업데이트하여 이전 단계에서 생성한 추천자의 ARN을 지정하고 사용자 ID(예: `123`)를 지정합니다.

```
// Get service clients module and commands using ES6 syntax.
import { GetRecommendationsCommand } from "@aws-sdk/client-personalize-runtime";
import { personalizeRuntimeClient } from "./libs/personalizeClients.js";
// Or, create the client here.
// const personalizeRuntimeClient = new PersonalizeRuntimeClient({ region: "REGION"});

// Set the recommendation request parameters.
export const getRecommendationsParam = {
  recommenderArn: "RECOMMENDER_ARN" /* required */,
  userId: "USER_ID" /* required */,
  numResults: 15 /* optional */,
};

export const run = async () => {
  try {
    const response = await personalizeRuntimeClient.send(
      new GetRecommendationsCommand(getRecommendationsParam),
    );
    console.log("Success!", response);
    return response; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```