

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

# 자습서: Apache Spark와 통합하여 데이터 가져오기 또는 내보내기
<a name="spark-integrating"></a>

Apache Spark는 대규모 데이터 분석을 위한 오픈 소스 엔진입니다. Apache Spark를 사용하면 Amazon Keyspaces에 저장된 데이터에 대한 분석을 보다 효율적으로 수행할 수 있습니다. 또한 Amazon Keyspaces를 사용하여 Spark의 분석 데이터에 대한 일관된 한 자리 밀리초 단위 읽기 액세스 권한을 애플리케이션에 제공할 수 있습니다. 오픈 소스 Spark Cassandra 커넥터는 Amazon Keyspaces와 Spark 간의 데이터 읽기 및 쓰기를 간소화합니다.

Spark Cassandra 커넥터에 대한 Amazon Keyspaces의 지원은 완전관리형 서버리스 데이터베이스 서비스를 사용하여 Spark 기반 분석 파이프라인에서 Cassandra 워크로드 실행을 간소화합니다. Amazon Keyspaces를 사용하면 Spark가 테이블과 동일한 기본 인프라 리소스를 놓고 경쟁하는 것에 대해 걱정할 필요가 없습니다. Amazon Keyspaces 테이블은 애플리케이션 트래픽에 따라 자동으로 확장 및 축소됩니다.

다음 자습서는 Spark Cassandra 커넥터를 사용하여 Amazon Keyspaces에 데이터를 읽고 쓰는 데 필요한 단계와 모범 사례를 안내합니다. 이 자습서에서는 Spark Cassandra 커넥터를 사용하여 파일에서 데이터를 로드하고 Amazon Keyspaces 테이블에 데이터를 기록하여 Amazon Keyspaces로 데이터를 마이그레이션하는 방법을 보여 줍니다. 그런 다음 자습서에서는 Spark Cassandra 커넥터를 사용하여 Amazon Keyspaces에서 데이터를 다시 읽는 방법을 보여 줍니다. 이렇게 하면 Spark 기반 분석 파이프라인에서 Cassandra 워크로드를 실행할 수 있습니다.

**Topics**
+ [Spark Cassandra 커넥터를 사용하여 Amazon Keyspaces에 연결하기 위한 사전 요구 사항](spark-tutorial-prerequisites.md)
+ [1단계: Apache Cassandra Spark 커넥터와의 통합을 위한 Amazon Keyspaces 구성](spark-tutorial-step1.md)
+ [2단계: Apache Cassandra Spark 커넥터 구성](spark-tutorial-step2.md)
+ [3단계: 애플리케이션 구성 파일 생성](spark-tutorial-step3.md)
+ [4단계: Amazon Keyspaces에서 원본 데이터 및 대상 테이블 준비](spark-tutorial-step4.md)
+ [5단계: Apache Cassandra Spark 커넥터를 사용하여 Amazon Keyspaces 데이터 쓰기 및 읽기](spark-tutorial-step5.md)
+ [Amazon Keyspaces와 함께 Spark Cassandra 커넥터를 사용할 때 발생하는 일반적인 오류 문제 해결](spark-tutorial-step6.md)

# Spark Cassandra 커넥터를 사용하여 Amazon Keyspaces에 연결하기 위한 사전 요구 사항
<a name="spark-tutorial-prerequisites"></a>

Spark Cassandra 커넥터를 사용하여 Amazon Keyspaces에 연결하기 전에 다음을 설치했는지 확인해야 합니다. Amazon Keyspaces와 Spark Cassandra 커넥터의 호환성은 다음 권장 버전을 통해 테스트되었습니다.
+ Java 버전 8
+ Scala 2.12
+ Spark 3.4
+ Cassandra 커넥터 2.5 이상
+ Cassandra 드라이버 4.12

1. Scala를 설치하려면 [https://www.scala-lang.org/download/scala2.html](https://www.scala-lang.org/download/scala2.html)에서 지침을 따르세요.

1. Spark 3.4.1을 설치하려면 이 예제를 따르세요.

   ```
   curl -o spark-3.4.1-bin-hadoop3.tgz -k https://dlcdn.apache.org/spark/spark-3.4.1/spark-3.4.1-bin-hadoop3.tgz
   
   # now to untar
   tar -zxvf spark-3.4.1-bin-hadoop3.tgz
   
   # set this variable.
   export SPARK_HOME=$PWD/spark-3.4.1-bin-hadoop3
   ```
   ```

# 1단계: Apache Cassandra Spark 커넥터와의 통합을 위한 Amazon Keyspaces 구성
<a name="spark-tutorial-step1"></a>

이 단계에서는 계정의 파티셔너가 Apache Spark 커넥터와 호환되는지 확인하고 필요한 IAM 권한을 설정합니다. 다음 모범 사례는 테이블에 충분한 읽기/쓰기 용량을 프로비저닝하는 데 도움이 됩니다.

1. `Murmur3Partitioner` 파티셔너가 계정의 기본 파티셔너인지 확인합니다. 이 파티셔너는 Spark Cassandra 커넥터와 호환됩니다. 파티셔너와 파티셔너 변경 방법에 대한 자세한 내용은 [Amazon Keyspaces에서 파티셔너 사용하기](working-with-partitioners.md) 섹션을 참조하세요.

1. Apache Spark와 함께 인터페이스 VPC 엔드포인트를 사용하여 Amazon Keyspaces에 대한 IAM 권한을 설정합니다.
   + 아래 나열된 IAM 정책 예제에 나와 있는 것처럼 사용자 테이블에 읽기/쓰기 권한과 시스템 테이블에 대한 읽기 권한을 할당합니다.
   + [VPC 엔드포인트](https://docs.aws.amazon.com/keyspaces/latest/devguide/vpc-endpoints.html)를 통해 Spark로 Amazon Keyspaces에 액세스하는 클라이언트의 경우 system.peers 테이블을 사용 가능한 인터페이스 VPC 엔드포인트로 채워야 합니다.

   ```
   {
      "Version":"2012-10-17",		 	 	 
      "Statement":[
         {
            "Effect":"Allow",
            "Action":[
               "cassandra:Select",
               "cassandra:Modify"
            ],
            "Resource":[
               "arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/table/mytable",
               "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system*"
            ]
         },
         {
            "Sid":"ListVPCEndpoints",
            "Effect":"Allow",
            "Action":[
               "ec2:DescribeNetworkInterfaces",
               "ec2:DescribeVpcEndpoints"
            ],
            "Resource":"*"
         }
      ]
   }
   ```

1. Amazon Keyspaces 테이블에 Spark Cassandra 커넥터의 트래픽을 지원할 수 있는 충분한 읽기/쓰기 처리량 용량을 구성하려면 다음 모범 사례를 고려합니다.
   + 시나리오를 테스트하는 데 도움이 되도록 온디맨드 용량 사용을 시작합니다.
   + 프로덕션 환경의 테이블 처리량 비용을 최적화하려면 커넥터의 트래픽에 속도 제한기를 사용하고 자동 크기 조정을 통해 프로비저닝된 용량을 사용하도록 테이블을 구성합니다. 자세한 내용은 [Amazon Keyspaces 오토 스케일링으로 처리량 용량 자동 관리](autoscaling.md) 단원을 참조하십시오.
   + Cassandra 드라이버와 함께 제공되는 고정 속도 제한기를 사용할 수 있습니다. [AWS 샘플](https://github.com/aws-samples) 리포지토리에 [Amazon Keyspaces에 맞게 조정된 몇 가지 속도 제한기](https://github.com/aws-samples/amazon-keyspaces-java-driver-helpers)가 있습니다.
   + 용량 관리에 대한 자세한 내용은 [Amazon Keyspaces의 읽기/쓰기 용량 모드 구성](ReadWriteCapacityMode.md) 섹션을 참조하세요.

# 2단계: Apache Cassandra Spark 커넥터 구성
<a name="spark-tutorial-step2"></a>

Apache Spark는 다양한 방식으로 구성할 수 있는 범용 컴퓨팅 플랫폼입니다. Amazon Keyspaces와 통합되도록 Spark 및 Spark Cassandra 커넥터를 구성하려면 다음 섹션에 설명된 최소 구성 설정으로 시작한 다음 나중에 워크로드에 맞게 크기를 늘리는 것이 좋습니다.
+ **Spark 파티션 크기를 8MB보다 작게 생성합니다.**

  Spark에서 *파티션*은 병렬로 실행할 수 있는 원자 데이터 청크를 나타냅니다. Spark Cassandra 커넥터를 사용하여 Amazon Keyspaces에 데이터를 쓰는 경우 Spark 파티션이 작을수록 작업에서 기록할 레코드 양도 줄어듭니다. Spark 작업에서 오류가 여러 번 발생하는 경우 지정된 재시도 횟수를 모두 사용한 후에는 작업이 실패합니다. 큰 작업을 재생하고 많은 데이터를 재처리하지 않으려면 Spark 파티션의 크기를 작게 유지합니다.
+ **재시도 횟수가 많고 실행자당 동시 쓰기 횟수를 적게 사용합니다.**

  Amazon Keyspaces는 작업 제한 시간이 초과되면 용량 부족 오류를 Cassandra 드라이버에 반환합니다. Spark Cassandra 커넥터가 `MultipleRetryPolicy`를 사용하여 요청을 투명하게 재시도하기 때문에 구성된 제한 시간 기간을 변경하여 용량 부족으로 인한 시간 초과를 해결할 수 없습니다. 재시도 횟수가 드라이버의 연결 풀에 과부하를 주지 않도록 하려면 실행자당 동시 쓰기 횟수를 줄이고 재시도 횟수가 많아야 합니다. 다음 코드 조각은 이에 대한 예입니다.

  ```
  spark.cassandra.query.retry.count = 500
  spark.cassandra.output.concurrent.writes = 3
  ```
+ **총 처리량을 세분화하여 여러 Cassandra 세션에 분배합니다.**
  + Cassandra Spark 커넥터는 각 Spark 실행기에 대해 하나의 세션을 생성합니다. 이 세션을 필요한 처리량과 필요한 연결 수를 결정하는 규모의 단위라고 생각하면 됩니다.
  + 실행자당 코어 수와 작업당 코어 수를 정의할 때는 낮은 수준에서 시작하여 필요에 따라 늘립니다.
  + 일시적 오류가 발생하는 경우에도 처리할 수 있도록 Spark 작업 실패를 설정합니다. 애플리케이션의 트래픽 특성 및 요구 사항을 숙지한 후에는 `spark.task.maxFailures`를 제한된 값으로 설정하는 것이 좋습니다.
  + 예를 들어 다음 구성에서는 실행자당, 세션별로 두 개의 동시 작업을 처리할 수 있습니다.

    ```
    spark.executor.instances = configurable -> number of executors for the session.
    spark.executor.cores = 2 -> Number of cores per executor.
    spark.task.cpus = 1 -> Number of cores per task.
    spark.task.maxFailures = -1
    ```
+ **일괄 처리를 끕니다.**
  +  임의 액세스 패턴을 개선하려면 일괄 처리를 해제하는 것이 좋습니다. 다음 코드 조각은 이에 대한 예입니다.

    ```
    spark.cassandra.output.batch.size.rows = 1 (Default = None)
    spark.cassandra.output.batch.grouping.key = none (Default = Partition)
    spark.cassandra.output.batch.grouping.buffer.size = 100 (Default = 1000)
    ```
+ **`SPARK_LOCAL_DIRS`를 충분한 공간이 있는 빠른 로컬 디스크로 설정합니다.**
  + 기본적으로 Spark는 맵 출력 파일과 복원력이 있는 분산 데이터 세트(RDD)를 `/tmp ` 폴더에 저장합니다. Spark 호스트의 구성에 따라 이로 인해 *디바이스에 남은 공간 없음* 스타일 오류가 발생할 수 있습니다.
  + `SPARK_LOCAL_DIRS` 환경 변수를 `/example/spark-dir`이라는 디렉터리로 설정하려면 다음 명령을 사용할 수 있습니다.

    ```
    export SPARK_LOCAL_DIRS=/example/spark-dir
    ```

# 3단계: 애플리케이션 구성 파일 생성
<a name="spark-tutorial-step3"></a>

Amazon Keyspaces와 함께 오픈 소스 Spark Cassandra 커넥터를 사용하려면 DataStax Java 드라이버에 연결하는 데 필요한 설정이 포함된 애플리케이션 구성 파일을 제공해야 합니다. 서비스별 자격 증명 또는 SigV4 플러그인을 사용하여 연결할 수 있습니다.

아직 수행하지 않은 경우 TLS 연결을 생성하는 데 사용된 디지털 인증서를 trustStore 파일로 변환해야 합니다. Java 드라이버 연결 자습서의 [시작하기 전 준비 사항](using_java_driver.md#using_java_driver.BeforeYouBegin)에서 세부 단계를 따를 수 있습니다. trustStore 파일 경로와 암호는 애플리케이션 구성 파일을 생성할 때 필요하므로 기록해 둡니다.

## SigV4 인증을 사용하여 연결
<a name="appconfig.sigv4"></a>

이 섹션에서는 AWS 자격 증명 및 SigV4 플러그인으로 연결할 때 사용할 수 있는 예제 `application.conf` 파일을 보여줍니다. 아직 생성하지 않은 경우 IAM 액세스 키(액세스 키 ID 및 보안 액세스 키)를 생성하여 AWS 구성 파일 또는 환경 변수로 저장해야 합니다. 자세한 지침은 [Cassandra 클라이언트 드라이버용 AWS CLI, AWS SDK 또는 Amazon Keyspaces SigV4 플러그인에 필요한 자격 증명](SigV4_credentials.md) 섹션을 참조하세요.

다음 예제에서는 trustStore 파일의 파일 경로를 바꾸고 암호를 바꿉니다.

```
datastax-java-driver {
        basic.contact-points = ["cassandra.us-east-1.amazonaws.com:9142"]
        basic.load-balancing-policy {
            class = DefaultLoadBalancingPolicy
            local-datacenter = us-east-1
            slow-replica-avoidance = false
        }
        basic.request {
              consistency = LOCAL_QUORUM
        }
        advanced {
                auth-provider = {
                   class = software.aws.mcs.auth.SigV4AuthProvider
                   aws-region = us-east-1
                 }
            ssl-engine-factory {
                class = DefaultSslEngineFactory
                truststore-path = "path_to_file/cassandra_truststore.jks"
                truststore-password = "password"
        hostname-validation=false
            }
   }
        advanced.connection.pool.local.size = 3   
}
```

이 구성 파일을 `/home/user1/application.conf`로 업데이트하고 저장합니다. 다음 예제는 이 경로를 사용합니다.

## 서비스별 자격 증명으로 연결
<a name="appconfig.ssc"></a>

 이 섹션에서는 서비스별 자격 증명을 사용하여 연결할 때 사용할 수 있는 예제 `application.conf` 파일을 보여 줍니다. Amazon Keyspaces에 대해 서비스별 자격 증명을 생성하지 않았다면 이를 생성해야 합니다. 자세한 지침은 [Amazon Keyspaces에 프로그래밍 방식으로 액세스하기 위한 서비스별 자격 증명 만들기](programmatic.credentials.ssc.md) 섹션을 참조하세요.

다음 예제에서 `username` 및 `password`를 고유한 자격 증명으로 바꿉니다. 또한 trustStore 파일의 파일 경로를 바꾸고 암호를 바꿉니다.

```
datastax-java-driver {
        basic.contact-points = ["cassandra.us-east-1.amazonaws.com:9142"]
        basic.load-balancing-policy {
            class = DefaultLoadBalancingPolicy
            local-datacenter = us-east-1
        }
        basic.request {
              consistency = LOCAL_QUORUM
        }
        advanced {
            auth-provider = {
            class = PlainTextAuthProvider
                    username = "username"
                    password = "password"
                    aws-region = "us-east-1"
            }
            ssl-engine-factory {
                class = DefaultSslEngineFactory
                truststore-path = "path_to_file/cassandra_truststore.jks"
                truststore-password = "password"
                hostname-validation=false
            }
            metadata = {
                schema {
                     token-map.enabled = true
                }
            }
        }    
}
```

코드 예제와 함께 사용할 수 있도록 이 구성 파일을 `/home/user1/application.conf`로 업데이트하고 저장합니다.

## 고정 속도로 연결
<a name="appconfig.fixedrate"></a>

Spark 실행자당 고정 속도를 적용하려면 요청 조절기를 정의하면 됩니다. 이 요청 조절기는 초당 요청 속도를 제한합니다. Spark Cassandra 커넥터는 실행자당 Cassandra 세션을 배포합니다. 다음 공식을 사용하면 테이블에 대해 일관된 처리량을 달성하는 데 도움이 될 수 있습니다.

```
max-request-per-second * numberOfExecutors = total throughput against a table
```

이 예제를 이전에 만든 애플리케이션 구성 파일에 추가할 수 있습니다.

```
datastax-java-driver {
  advanced.throttler {
    class = RateLimitingRequestThrottler

    max-requests-per-second = 3000
    max-queue-size = 30000
    drain-interval = 1 millisecond
  }
}
```

# 4단계: Amazon Keyspaces에서 원본 데이터 및 대상 테이블 준비
<a name="spark-tutorial-step4"></a>

이 단계에서는 샘플 데이터와 Amazon Keyspaces 테이블을 사용하여 소스 파일을 생성합니다.

1. 소스 파일을 생성합니다. 다음 옵션 중 하나를 선택할 수 있습니다.
   + 이 자습서에서는 이름 `keyspaces_sample_table.csv`가 있는 쉼표로 구분된 값(CSV) 파일을 데이터 마이그레이션의 원본 파일로 사용합니다. 제공된 샘플 파일에는 이름이 `book_awards`인 테이블에 대한 몇 개의 데이터 행이 포함되어 있습니다.

     1. 다음 아카이브 파일 [samplemigration.zip](samples/samplemigration.zip)에 포함된 샘플 CSV 파일(`keyspaces_sample_table.csv`)을 다운로드합니다. 아카이브의 압축을 풀고 `keyspaces_sample_table.csv`의 경로를 기록해 둡니다.
   + 자체 CSV 파일을 따라 Amazon Keyspaces에 데이터를 쓰려면 데이터가 무작위로 지정되었는지 확인하십시오. 데이터베이스에서 직접 읽거나 플랫 파일로 내보내는 데이터는 일반적으로 파티션과 프라이머리 키를 기준으로 정렬됩니다. 정렬된 데이터를 Amazon Keyspaces로 가져오면 Amazon Keyspaces 파티션의 더 작은 세그먼트에 데이터가 기록되어 트래픽이 고르지 않게 분산될 수 있습니다. 이로 인해 성능이 저하되고 오류율이 높아질 수 있습니다.

     반대로 데이터를 무작위화하면 트래픽을 파티션 전체에 더 균등하게 분산하여 Amazon Keyspaces의 기본 제공 로드 밸런싱 기능을 활용할 수 있습니다. 데이터를 랜덤화하는 데 사용할 수 있는 다양한 도구가 있습니다. 오픈소스 도구인 [Shuf](https://en.wikipedia.org/wiki/Shuf)를 사용하는 예제는 데이터 마이그레이션 자습서에서 [2단계: DSBulk를 사용하여 업로드할 데이터 준비](dsbulk-upload-prepare-data.md) 섹션을 참조하세요. 다음은 데이터를 `DataFrame`으로 셔플하는 방법을 보여 주는 예제입니다.

     ```
     import org.apache.spark.sql.functions.randval
     shuffledDF = dataframe.orderBy(rand())
     ```

1. Amazon Keyspaces에서 대상 키스페이스 및 테이블을 생성합니다.

   1. 를 사용하여 Amazon Keyspaces에 연결합니다`cqlsh-expansion`. `cqlsh-expansion` 설치 지침은 [`cqlsh-expansion`을 사용하여 Amazon Keyspace에 접속](programmatic.cqlsh.md#using_cqlsh) 섹션을 확인하세요.

      다음 예제의 서비스 엔드포인트를 고유한 값으로 바꿉니다.

      ```
      cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
      ```

   1. 다음 예제와 같이 이름 `catalog`를 사용하여 새 키스페이스를 생성합니다.

      ```
      CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
      ```

   1. 새 키스페이스가 사용 가능 상태가 되면 다음 코드를 사용하여 대상 테이블 `book_awards`를 생성합니다. 비동기 리소스 생성 및 리소스가 사용 가능한지 확인하는 방법에 대한 자세한 내용은 [Amazon Keyspaces에서 키스페이스 생성 상태 확인](keyspaces-create.md) 섹션을 참조하세요.

      ```
      CREATE TABLE catalog.book_awards (
         year int,
         award text,
         rank int, 
         category text,
         book_title text,
         author text, 
         publisher text,
         PRIMARY KEY ((year, award), category, rank)
         );
      ```

# 5단계: Apache Cassandra Spark 커넥터를 사용하여 Amazon Keyspaces 데이터 쓰기 및 읽기
<a name="spark-tutorial-step5"></a>

이 단계에서는 먼저 샘플 파일의 데이터를 Spark Cassandra 커넥터를 사용하여 `DataFrame`으로 로드합니다. 다음으로 `DataFrame`의 데이터를 Amazon Keyspaces 테이블에 작성합니다. 예를 들어 이 부분을 독립적으로 사용하여 데이터를 Amazon Keyspaces 테이블로 마이그레이션할 수도 있습니다. 마지막으로 Spark Cassandra 커넥터를 사용하여 테이블의 데이터를 `DataFrame`으로 읽습니다. 예를 들어 이 부분을 독립적으로 사용하여 Amazon Keyspaces 테이블에서 데이터를 읽고 Apache Spark로 데이터 분석을 수행할 수도 있습니다.

1. 다음 예제와 같이 Spark Shell을 시작합니다. 이 예제에서는 SigV4 인증을 사용하고 있습니다.

   ```
   ./spark-shell --files application.conf --conf spark.cassandra.connection.config.profile.path=application.conf --packages software.aws.mcs:aws-sigv4-auth-cassandra-java-driver-plugin:4.0.5,com.datastax.spark:spark-cassandra-connector_2.12:3.1.0 --conf spark.sql.extensions=com.datastax.spark.connector.CassandraSparkExtensions
   ```

1. 다음 코드를 사용하여 Spark Cassandra 커넥터를 가져옵니다.

   ```
   import org.apache.spark.sql.cassandra._
   ```

1. CSV 파일에서 데이터를 읽고 `DataFrame`에 저장하려면 다음 코드 예제를 사용할 수 있습니다.

   ```
   var df = spark.read.option("header","true").option("inferSchema","true").csv("keyspaces_sample_table.csv")
   ```

   다음 명령을 사용하여 결과를 표시할 수 있습니다.

   ```
   scala> df.show();
   ```

   결과는 다음과 비슷해야 합니다.

   ```
   +----------------+----+-----------+----+------------------+--------------------+-------------+
   |           award|year|   category|rank|            author|          book_title|    publisher|
   +----------------+----+-----------+----+------------------+--------------------+-------------+
   |Kwesi Manu Prize|2020|    Fiction|   1|        Akua Mansa|   Where did you go?|SomePublisher|
   |Kwesi Manu Prize|2020|    Fiction|   2|       John Stiles|           Yesterday|Example Books|
   |Kwesi Manu Prize|2020|    Fiction|   3|        Nikki Wolf|Moving to the Cha...| AnyPublisher|
   |            Wolf|2020|Non-Fiction|   1|       Wang Xiulan|    History of Ideas|Example Books|
   |            Wolf|2020|Non-Fiction|   2|Ana Carolina Silva|       Science Today|SomePublisher|
   |            Wolf|2020|Non-Fiction|   3| Shirley Rodriguez|The Future of Sea...| AnyPublisher|
   |     Richard Roe|2020|    Fiction|   1| Alejandro Rosalez|         Long Summer|SomePublisher|
   |     Richard Roe|2020|    Fiction|   2|       Arnav Desai|             The Key|Example Books|
   |     Richard Roe|2020|    Fiction|   3|     Mateo Jackson|    Inside the Whale| AnyPublisher|
   +----------------+----+-----------+----+------------------+--------------------+-------------+
   ```

   다음 예제와 같이 `DataFrame`에서 데이터의 스키마를 확인할 수 있습니다.

   ```
   scala> df.printSchema
   ```

   결과는 다음과 같아야 합니다.

   ```
   root
   |-- award: string (nullable = true)
   |-- year: integer (nullable = true)
   |-- category: string (nullable = true)
   |-- rank: integer (nullable = true)
   |-- author: string (nullable = true)
   |-- book_title: string (nullable = true)
   |-- publisher: string (nullable = true)
   ```

1. 다음 명령을 사용하여 Amazon Keyspaces 테이블에 `DataFrame`의 데이터를 씁니다.

   ```
   df.write.cassandraFormat("book_awards", "catalog").mode("APPEND").save()
   ```

1. 데이터가 저장되었는지 확인하려면 다음 예제와 같이 데이터를 데이터 프레임으로 다시 읽을 수 있습니다.

   ```
   var newDf = spark.read.cassandraFormat("book_awards", "catalog").load()
   ```

   그러면 현재 데이터 프레임에 포함된 데이터를 표시할 수 있습니다.

   ```
   scala> newDf.show()
   ```

   해당 명령의 결과는 다음과 같아야 합니다.

   ```
   +--------------------+------------------+----------------+-----------+-------------+----+----+
   |          book_title|            author|           award|   category|    publisher|rank|year|
   +--------------------+------------------+----------------+-----------+-------------+----+----+
   |         Long Summer| Alejandro Rosalez|     Richard Roe|    Fiction|SomePublisher|   1|2020|
   |    History of Ideas|       Wang Xiulan|            Wolf|Non-Fiction|Example Books|   1|2020|
   |   Where did you go?|        Akua Mansa|Kwesi Manu Prize|    Fiction|SomePublisher|   1|2020|
   |    Inside the Whale|     Mateo Jackson|     Richard Roe|    Fiction| AnyPublisher|   3|2020|
   |           Yesterday|       John Stiles|Kwesi Manu Prize|    Fiction|Example Books|   2|2020|
   |Moving to the Cha...|        Nikki Wolf|Kwesi Manu Prize|    Fiction| AnyPublisher|   3|2020|
   |The Future of Sea...| Shirley Rodriguez|            Wolf|Non-Fiction| AnyPublisher|   3|2020|
   |       Science Today|Ana Carolina Silva|            Wolf|Non-Fiction|SomePublisher|   2|2020|
   |             The Key|       Arnav Desai|     Richard Roe|    Fiction|Example Books|   2|2020|
   +--------------------+------------------+----------------+-----------+-------------+----+----+
   ```

# Amazon Keyspaces와 함께 Spark Cassandra 커넥터를 사용할 때 발생하는 일반적인 오류 문제 해결
<a name="spark-tutorial-step6"></a>

Amazon Virtual Private Cloud를 사용하고 Amazon Keyspaces에 연결하는 경우 Spark 커넥터를 사용할 때 발생하는 가장 일반적인 오류는 다음과 같은 구성 문제로 인해 발생합니다.
+ VPC에서 사용되는 IAM 사용자 또는 역할에는 Amazon Keyspaces의 `system.peers` 테이블에 액세스하는 데 필요한 권한이 없습니다. 자세한 내용은 [인터페이스 VPC 엔드포인트 정보로 `system.peers` 테이블 항목 채우기](vpc-endpoints.md#system_peers) 단원을 참조하십시오.
+ IAM 사용자 또는 역할에는 사용자 테이블에 대한 필수 읽기/쓰기 권한과 Amazon Keyspaces의 시스템 테이블에 대한 읽기 액세스 권한이 없습니다. 자세한 내용은 [1단계: Apache Cassandra Spark 커넥터와의 통합을 위한 Amazon Keyspaces 구성](spark-tutorial-step1.md) 단원을 참조하십시오.
+ Java 드라이버 구성은 SSL/TLS 연결을 생성할 때 호스트 이름 확인을 비활성화하지 않습니다. 예제는 [2단계: 드라이버 구성](using_java_driver.md#java_tutorial.driverconfiguration) 섹션을 참조하세요.

자세한 연결 문제 해결 단계는 [VPC 엔드포인트 연결이 제대로 작동하지 않음](troubleshooting.connecting.md#troubleshooting.connection.vpce) 섹션을 참조하세요.

또한 Amazon CloudWatch 지표를 사용하면 Amazon Keyspaces의 Spark Cassandra 커넥터 구성과 관련된 문제를 해결하는 데 도움이 될 수 있습니다. CloudWatch와 함께 Amazon Keyspaces를 사용하는 방법에 대한 자세한 내용은 [Amazon CloudWatch를 사용하여 Amazon Keyspaces 모니터링](monitoring-cloudwatch.md) 섹션을 참조하세요.

다음 섹션에서는 Spark Cassandra 커넥터를 사용할 때 관찰할 수 있는 가장 유용한 지표를 설명합니다.

**PerConnectionRequestRateExceeded**  
Amazon Keyspaces에는 연결당 초당 3,000개의 요청 할당량이 있습니다. 각 Spark 실행자는 Amazon Keyspaces와 연결을 설정합니다. 재시도를 여러 번 실행하면 연결당 요청 속도 할당량이 소진될 수 있습니다. 이 할당량을 초과하면 Amazon Keyspaces는 CloudWatch에서 `PerConnectionRequestRateExceeded` 지표를 내보냅니다.  
다른 시스템 또는 사용자 오류와 함께 PerConnectionRequestRateExceeded 이벤트가 나타나는 경우 Spark에서 연결당 할당된 요청 수를 초과하여 여러 번 재시도를 실행하고 있는 것일 수 있습니다.  
다른 오류가 없는 `PerConnectionRequestRateExceeded` 이벤트가 표시되면 처리량을 늘리기 위해 드라이버 설정에서 연결 수를 늘리거나 Spark 작업의 실행자 수를 늘려야 할 수 있습니다.

**StoragePartitionThroughputCapacityExceeded**  
Amazon Keyspaces의 할당량은 파티션당 초당 1,000개의 WCU 또는 WRU/초당 3,000개의 RCU 또는 RRU입니다. `StoragePartitionThroughputCapacityExceeded` CloudWatch 이벤트가 표시되는 경우 로드 시 데이터가 무작위화되지 않았음을 의미할 수 있습니다. 데이터 셔플 방법에 대한 예는 [4단계: Amazon Keyspaces에서 원본 데이터 및 대상 테이블 준비](spark-tutorial-step4.md) 섹션을 참조하세요.

## 일반적인 오류 및 경고
<a name="common_errors_warnings"></a>

Amazon Virtual Private Cloud를 사용하고 있고 Amazon Keyspaces에 연결하는 경우 Cassandra 드라이버는 `system.peers` 테이블의 제어 노드 자체에 대한 경고 메시지를 발행할 수 있습니다. 자세한 내용은 [일반적인 오류 및 경고](vpc-endpoints.md#vpc_troubleshooting) 단원을 참조하십시오. 이 경고는 무시해도 됩니다.