

신중한 고려 끝에 Amazon Kinesis Data Analytics for SQL 애플리케이션을 중단하기로 결정했습니다.

1. **2025년 9월 1**일부터 Amazon Kinesis Data Analytics for SQL 애플리케이션에 대한 버그 수정은 제공되지 않습니다. 곧 중단될 예정이므로 지원이 제한될 예정이기 때문입니다.

2. **2025년 10월 15**일부터 새 Kinesis Data Analytics for SQL 애플리케이션을 생성할 수 없습니다.

3. **2026년 1월 27**일부터 애플리케이션이 삭제됩니다. Amazon Kinesis Data Analytics for SQL 애플리케이션을 시작하거나 작동할 수 없게 됩니다. 그 시점부터 Amazon Kinesis Data Analytics for SQL에 대한 지원을 더 이상 이용할 수 없습니다. 자세한 내용은 [Amazon Kinesis Data Analytics for SQL 애플리케이션 단종](discontinuation.md) 단원을 참조하십시오.

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

# Amazon Kinesis Data Analytics for SQL 애플리케이션: 작동 방식
<a name="how-it-works"></a>

**참고**  
2023년 9월 12일 이후에는 Kinesis Data Analytics for SQL의 기존 사용자가 아닌 경우, Kinesis Data Firehose를 소스로 사용하여 새 애플리케이션을 생성할 수 없습니다. 자세한 설명은 [제한](https://docs.aws.amazon.com//kinesisanalytics/latest/dev/limits.html)을 참조하십시오.

Amazon Kinesis Data Analytics에서 *애플리케이션*은 사용자 계정에서 생성할 수 있는 기본 리소스입니다. AWS Management Console 또는 Kinesis Data Analytics API를 사용하여 애플리케이션을 생성하고 관리할 수 있습니다. Kinesis Data Analytics는 애플리케이션 관리용 API 작업을 제공합니다. API 작업 목록은 [작업](API_Operations.md) 섹션을 참조하십시오.

Kinesis Data Analytics 애플리케이션은 실시간으로 스트리밍 데이터를 연속적으로 읽고 처리합니다. SQL을 사용하여 애플리케이션 코드를 작성하여 수신 스트리밍 데이터를 처리하고 출력을 생성합니다. 그러면, Kinesis Data Analytics가 출력을 구성 목적지에 작성합니다. 다음 다이어그램은 일반적인 애플리케이션 아키텍처를 보여 줍니다.

![\[데이터 분석 애플리케이션, 스트리밍 입력 소스, 참조 데이터 및 애플리케이션 출력을 보여주는 다이어그램\]](http://docs.aws.amazon.com/ko_kr/kinesisanalytics/latest/dev/images/kinesis-app.png)


각 애플리케이션은 명칭, 설명, 버전 ID 및 상태를 갖습니다. 애플리케이션을 처음 생성하면 Amazon Kinesis Data Analytics가 버전 ID를 할당합니다. 임의의 애플리케이션 구성을 업데이트하면 이 버전 ID도 업데이트됩니다. 예를 들어 입력 구성을 추가하거나, 참조 데이터 소스를 추가 또는 삭제하거나, 출력 구성을 추가 또는 삭제하거나, 애플리케이션 코드를 업데이트하면 Kinesis Data Analytics 가 현재 애플리케이션 버전 ID를 업데이트합니다. 또한 Kinesis Data Analytics는 애플리케이션이 생성되고 마지막으로 업데이트된 시기에 대한 타임스탬프를 유지합니다.

이러한 기본 속성에 더해, 각 애플리케이션은 다음으로 구성됩니다:
+ **입력** – 애플리케이션의 스트리밍 소스입니다. Kinesis 데이터 스트림 또는 Firehose 데이터 전송 스트림을 스트리밍 소스로 선택할 수 있습니다. 입력 구성에서 스트리밍 소스를 애플리케이션 내 입력 스트림에 매핑합니다. 애플리케이션 내 스트림은 지속적으로 업데이트되는 표와 같습니다. 이 표에서 `SELECT` 및 `INSERT SQL` 작업을 수행할 수 있습니다. 중간 쿼리 결과를 저장하도록 애플리케이션 코드에서 애플리케이션 내 스트림을 추가로 생성할 수 있습니다.

   

  선택적으로 스트리밍 소스를 복수의 애플리케이션 내 스트림에 분할하여 처리량을 향상시킬 수 있습니다. 자세한 정보는 [한도](limits.md) 및 [애플리케이션 입력 구성](how-it-works-input.md) 섹션을 참조하십시오.

   

  Amazon Kinesis Data Analytics는 각 애플리케이션 스트림 내에 [타임스탬프와 ROWTIME 열](timestamps-rowtime-concepts.md)이라는 타임스탬프 열을 제공합니다. 시간 기반 윈도우 쿼리에서 이 열을 사용할 수 있습니다. 자세한 설명은 [윈도우 모드 쿼리](windowed-sql.md) 섹션을 참조하십시오.

   

  선택적으로 참조 데이터 소스를 구성하여 애플리케이션 내에서의 입력 데이터 스트림을 보강할 수 있습니다. 그 결과물이 애플리케이션 내 참조 표입니다. 참조 데이터는 S3 버킷에 객체로 저장해야 합니다. 애플리케이션이 시작하면 Amazon Kinesis Data Analytics이 Amazon S3 객체를 읽고 애플리케이션 내 표를 생성합니다. 자세한 설명은 [애플리케이션 입력 구성](how-it-works-input.md) 섹션을 참조하십시오.

   
+ **애플리케이션 코드** – 입력을 처리하고 출력을 생산하는 일련의 SQL 문입니다. 애플리케이션 내 스트림과 참조 표에 대해 SQL 문을 작성할 수 있습니다. JOIN 쿼리를 작성하여 이 두 소스의 데이터를 결합할 수도 있습니다.

   

  Kinesis Data Analytics에서 지원되는 SQL 언어 요소에 대한 자세한 설명은 [Amazon Kinesis Data Analytics SQL 참조](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/analytics-sql-reference.html)를 참고하십시오.

   

  가장 간단한 형태의 애플리케이션 코드는 스트리밍 입력에서 선택하여 결과를 스트리밍 출력에 삽입하는 단일 SQL 문이 될 수 있습니다. 또한, 하나의 출력이 다음 SQL 문의 입력으로 공급되는 일련의 SQL 문이 될 수도 있습니다. 뿐만 아니라 입력 스트림을 여러 스트림으로 분할하는 애플리케이션 코드를 작성할 수 있습니다. 그런 다음 추가 쿼리를 적용하여 이러한 스트림을 처리할 수 있습니다. 자세한 설명은 [애플리케이션 코드](how-it-works-app-code.md) 섹션을 참조하십시오.

   
+ **출력** – 애플리케이션 내 코드에서 쿼리 결과가 애플리케이션 내 스트림으로 향합니다. 중간 결과를 보관하도록 애플리케이션 코드에서 하나 이상의 애플리케이션 내 스트림을 추가로 생성할 수 있습니다. 그런 다음 애플리케이션 출력(애플리케이션 내 출력 스트림이라고도 함)을 외부 대상에 보관하는 애플리케이션 내 스트림에 데이터를 유지하도록 애플리케이션 출력을 선택적으로 구성할 수 있습니다. 외부 대상은 Kinesis 데이터 스트림 또는 Firehose 전송 스트림이 될 수 있습니다. 이러한 목적지에 대해 다음을 참조하십시오:
  + Amazon S3, Amazon Redshift 또는 Amazon OpenSearch Service (OpenSearch Service)에 결과를 작성하도록 Firehose 전송 스트림을 구성할 수 있습니다.

     
  + 애플리케이션 출력을 Amazon S3 또는 Amazon Redshift로 맞춤 목적지로 할 수도 있습니다. 이렇게 하려면 출력 구성에서 Kinesis 데이터 스트림을 목적지로 지정해야 합니다. 그런 다음 스트림을 폴링하고 Lambda 함수를 호출 AWS Lambda 하도록를 구성합니다. 사용자의 Lambda 함수 코드는 스트림 데이터를 입력으로 수신합니다. Lambda 함수 코드에서 수신 데이터를 맞춤 대상에 작성할 수 있습니다. 자세한 내용은 [ Amazon Kinesis Data Analytics AWS Lambda 에서 사용을](https://docs.aws.amazon.com/lambda/latest/dg/with-kinesis.html) 참조하세요.

  자세한 내용은 [애플리케이션 출력 구성](how-it-works-output.md) 단원을 참조하십시오.

또한 다음 사항에 유의하십시오:
+ Amazon Kinesis Data Analytics는 스트리밍 소스로부터 오는 레코드를 읽고 애플리케이션 출력을 외부 대상에 작성할 수 있는 권한이 필요합니다. IAM 역할을 사용하여 그와 같은 권한을 부여합니다.

   
+ Kinesis Data Analytics는 각 애플리케이션의애플리케이션 내 오류 스트림을 자동으로 제공합니다. 애플리케이션이 특정 레코드를 처리하는 동안 문제가 발생할 경우(예: 유형 불일치 또는 지연 도착) 해당 레코드는 오류 스트림에 작성됩니다. 추가 평가를 위해 오류 스트림 데이터가 외부 목적지 향하도록 애플리케이션 출력을 Kinesis Data Analytics로 가도록 구성할 수 있습니다. 자세한 설명은 [오류 처리](error-handling.md) 섹션을 참조하십시오.

   
+ Amazon Kinesis Data Analytics는 애플리케이션 출력 레코드가 구성 목적지에 작성되도록 합니다. 애플리케이션 중단을 경험하더라도 '최소 1회' 처리 및 전송 모델을 사용합니다. 자세한 설명은 [애플리케이션 출력을 외부 대상에 유지하기 위한 전송 모델](failover-checkpoint.md) 섹션을 참조하십시오.

**Topics**
+ [애플리케이션 입력 구성](how-it-works-input.md)
+ [애플리케이션 코드](how-it-works-app-code.md)
+ [애플리케이션 출력 구성](how-it-works-output.md)
+ [오류 처리](error-handling.md)
+ [처리량 증가를 위해 애플리케이션 용량을 자동으로 확장 또는 축소](how-it-works-autoscaling.md)
+ [태그 지정 사용](how-tagging.md)

# 애플리케이션 입력 구성
<a name="how-it-works-input"></a>

Amazon Kinesis Data Analytics 애플리케이션이 단일 스트리밍 소스로부터 입력을 수신할 수도 있고, 선택적으로 하나의 참조 데이터 소스를 사용할 수도 있습니다. 자세한 설명은 [Amazon Kinesis Data Analytics for SQL 애플리케이션: 작동 방식](how-it-works.md) 섹션을 참조하십시오. 이 주제 섹션에서는 애플리케이션 입력 소스에 대해 설명합니다.

**Topics**
+ [스트리밍 소스 구성](#source-streaming)
+ [참조 소스 구성](#source-reference)
+ [JSONPath로 작업하기](about-json-path.md)
+ [스트리밍 소스 요소를 SQL 입력 열에 매핑하기](sch-mapping.md)
+ [스트리밍 데이터에 대해 스키마 검색 기능 사용](sch-dis.md)
+ [정적 데이터에 대해 스키마 검색 기능 사용](sch-dis-ref.md)
+ [Lambda 함수를 사용하여 데이터 사전 처리](lambda-preprocessing.md)
+ [입력 스트림 병렬화를 통한 처리량 증대](input-parallelism.md)

## 스트리밍 소스 구성
<a name="source-streaming"></a>

애플리케이션을 생성할 때 스트리밍 소스를 지정합니다. 애플리케이션을 만든 후 입력을 수정할 수도 있습니다. Amazon Kinesis Data Analytics는 애플리케이션에 다음과 같은 스트리밍 소스를 지원합니다.
+ Kinesis 데이터 스트림 
+ Firehose 전송 스트림

**참고**  
2023년 9월 12일 이후에는 Kinesis Data Analytics for SQL의 기존 사용자가 아닌 경우, Kinesis Data Firehose를 소스로 사용하여 새 애플리케이션을 생성할 수 없습니다. `KinesisFirehoseInput`과 함께 Kinesis Data Analytics for SQL 애플리케이션을 사용하는 기존 고객은 Kinesis Data Analytics를 사용하여 기존 계정 내에서 `KinesisFirehoseInput`와 함께 애플리케이션을 계속 추가할 수 있습니다. 기존 고객이 Kinesis Data Analytics for SQL 애플리케이션을 `KinesisFirehoseInput`과 함께 사용하여 새 계정을 생성하려는 경우 서비스 한도 증가 양식을 통해 사례를 생성할 수 있습니다. 자세한 정보는 [AWS Support Center](https://console.aws.amazon.com/support/home#/) 섹션을 참조하십시오. 프로덕션으로 승격하기 전에 항상 새 애플리케이션을 테스트하는 것이 좋습니다.

**참고**  
Kinesis 데이터 스트림이 암호화되었다면 Kinesis Data Analytics는 추가 구성 없이도 암호화된 시스템 내의 데이터에 액세스할 수 있습니다. Kinesis Data Analytics는 Kinesis Data Streams에서 읽은 암호화되지 않은 데이터는 저장하지 않습니다. 자세한 설명은 [Kinesis Data Streams을 위한 서버측 암호화란 무엇인가?](https://docs.aws.amazon.com/streams/latest/dev/what-is-sse.html)를 참조하십시오.

Kinesis Data Analytics는 새로운 데이터에 대해 스트리밍 소스를 지속적으로 폴링하여 입력 구성에 따라 애플리케이션 내 스트림에서 수집합니다.

**참고**  
애플리케이션의 입력으로 Kinesis 스트림을 추가해도 스트림의 데이터에는 영향을 미치지 않습니다. Firehose 전송 스트림을 비롯한 다른 리소스도 동일한 Kinesis 스트림에 액세스하면 Firehose 전송 스트림과 Kinesis Data Analytics 애플리케이션 모두 동일한 데이터를 수신합니다. 그러나 처리량 및 조절이 영향을 받을 수 있습니다.

그러면 애플리케이션 코드가 이를 애플리케이션 내 스트림에서 쿼리할 수 있습니다. 입력 구성의 일부로 다음을 제공합니다:
+ **스트리밍 소스** – 스트림의 Amazon 리소스 이름(ARN)과 Kinesis Data Analytics가 사용자를 대신하여 스트림에 액세스할 수 있는 권한을 주는 IAM 역할을 제공합니다.
+ **애플리케이션 내 스트림 명칭의 접두사** – 애플리케이션을 시작할 때 Kinesis Data Analytics가 지정 애플리케이션 내 스트림을 생성합니다. 그러면 애플리케이션 코드에서 이 명칭을 사용하여 애플리케이션 내 스트림에 액세스합니다.

  선택적으로 스트리밍 소스를 복수의 애플리케이션 내 스트림에 매핑할 수 있습니다. 자세한 설명은 [한도](limits.md) 섹션을 참조하십시오. 이 경우 Amazon Kinesis Data Analytics가 다음과 같은 명칭을 지니는 지정된 수의 애플리케이션 내 스트림을 생성합니다: *접두사*`_001`, *접두사*`_002`와 *접두사*`_003`. 기본 설정으로 Kinesis Data Analytics는 스트리밍 소스를 *접두사*`_001`라고 하는 하나의 애플리케이션 내 스트림에 매핑합니다.

  애플리케이션 내 스트림에 행을 삽입할 수 있는 속도에는 한도가 있습니다. 따라서 Kinesis Data Analytics는 그와 같은 애플리케이션 내 스트림을 여러 개 지원하므로 레코드를 훨씬 더 빠른 속도로 애플리케이션에 가져올 수 있습니다. 애플리케이션이 스트리밍 소스에서 데이터를 따라 잡지 못할 경우 병렬 처리 단위를 추가하여 성능을 개선할 수 있습니다.
+ **스키마 매핑** – 스트리밍 소스의 레코드 형식(JSON, CSV)에 대해 명시합니다. 또한 스트림 내 각 레코드를 생성되는 애플리케이션 내 스트림 내 열로 매핑하는 방식에 대해서도 설명합니다. 여기에 열 명칭과 데이터 유형을 입력합니다.

**참고**  
Kinesis Data Analytics는 입력 애플리케이션 내 스트림을 생성할 때 식별자(스트림 명칭 및 열 명칭) 주위에 물음표를 추가합니다. 이 스트림 및 열을 쿼리할 때는 대소문자를 똑같이 구분하여 따옴표로 지정해야 합니다. 식별자에 대한 자세한 설명은 *Amazon Managed Service for Apache Flink SQL 참조*에서 [식별자](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sql-reference-identifiers.html)를 참조하십시오.

Amazon Kinesis Data Analytics 콘솔에서 애플리케이션을 생성하고 입력을 구성할 수 있습니다. 그런 다음에는 콘솔이 필요한 API 호출을 수행합니다. 새 애플리케이션 API를 생성하거나 기존 애플리케이션에 입력 구성을 추가할 때 애플리케이션 입력을 구성할 수 있습니다. 자세한 정보는 [CreateApplication](API_CreateApplication.md) 및 [AddApplicationInput](API_AddApplicationInput.md) 섹션을 참조하십시오. 다음은 `Createapplication` API 요청 본문의 입력 구성 부분입니다.

```
 "Inputs": [
        {
            "InputSchema": {
                "RecordColumns": [
                    {
                        "Mapping": "string",
                        "Name": "string",
                        "SqlType": "string"
                    }
                ],
                "RecordEncoding": "string",
                "RecordFormat": {
                    "MappingParameters": {
                        "CSVMappingParameters": {
                            "RecordColumnDelimiter": "string",
                            "RecordRowDelimiter": "string"
                        },
                        "JSONMappingParameters": {
                            "RecordRowPath": "string"
                        }
                    },
                    "RecordFormatType": "string"
                }
            },
            "KinesisFirehoseInput": {
                "ResourceARN": "string",
                "RoleARN": "string"
            },
            "KinesisStreamsInput": {
                "ResourceARN": "string",
                "RoleARN": "string"
            },
            "Name": "string"
        }
    ]
```

## 참조 소스 구성
<a name="source-reference"></a>

또한 필요에 따라 기존 애플리케이션에 참조 데이터 소스를 추가하여 스트리밍 소스에서 들어오는 데이터를 보강할 수 있습니다. 참조 데이터는 Amazon S3 버킷에 객체로 저장해야 합니다. 애플리케이션이 시작되면 Amazon Kinesis Data Analytics이 Amazon S3 객체를 읽고 애플리케이션 내 참조 표를 생성합니다. 그러면 애플리케이션 코드에서 이를 애플리케이션 내 스트림에 조인할 수 있습니다.

지원되는 형식(CSV, JSON)을 사용하여 참조 데이터를 Amazon S3 객체에 저장합니다. 예를 들어, 애플리케이션이 주식 주문에 대한 분석을 수행한다고 가정해 보겠습니다. 스트리밍 소스에 대해 다음이 레코드 형식을 취합니다.

```
Ticker, SalePrice, OrderId

AMZN     $700        1003
XYZ      $250        1004
...
```

이 경우, 참조 데이터 소스를 유지하여 회사 명칭과 같은 각 주식 티커에 관한 상세 정보를 제공하는 것을 고려할 수 있을 것입니다.

```
Ticker, Company
AMZN, Amazon
XYZ, SomeCompany
...
```

API 또는 콘솔을 사용하여 애플리케이션 참조 데이터 소스를 추가할 수 있습니다. Amazon Kinesis Data Analytics는 참조 데이터 소스를 관리하기 위해 다음과 같은 API 작업을 제공합니다.
+  [AddApplicationReferenceDataSource](API_AddApplicationReferenceDataSource.md)
+ [UpdateApplication](API_UpdateApplication.md)

콘솔을 사용하여 참조 데이터를 추가하는 방법에 대한 자세한 설명은 [예: 참조 데이터를 Kinesis Data Analytics 애플리케이션에 추가](app-add-reference-data.md) 섹션을 참조하십시오.

다음 사항에 유의하세요.
+ 애플리케이션이 실행 중이면 Kinesis Data Analytics는 애플리케이션 내 참조 표를 생성한 다음 바로 참조 표를 로드합니다.
+ 애플리케이션이 실행 중이 아니면 (예: 대기 모드에 있을 때) Kinesis Data Analytics는 업데이트된 입력 구성만 저장합니다. 애플리케이션 실행이 시작되면 Kinesis Data Analytics가 참조 표를 애플리케이션에 표로 로드합니다.

Kinesis Data Analytics가 애플리케이션 내 참조 표를 생성한 후 데이터를 새로 고치려고 한다고 가정해 보겠습니다. 아마도 Amazon S3 객체를 업데이트했거나 다른 Amazon S3 객체를 사용하려 하려고 할 것입니다. 이 경우, [UpdateApplication](API_UpdateApplication.md)을 명시적으로 호출하거나, 콘솔에서 **작업**, **참조 데이터 표 동기화**를 선택할 수 있습니다. Kinesis Data Analytics는 애플리케이션 내 참조 표를 자동으로 새로 고치지 않습니다.

참조 데이터 소스로 생성할 수 있는 Amazon S3 객체의 크기에는 한도가 있습니다. 자세한 설명은 [한도](limits.md) 섹션을 참조하십시오. 객체 크기가 한도를 초과하는 경우 Kinesis Data Analytics는 데이터를 로드할 수 없습니다. 실행 중에 애플리케이션 상태는 표시되지만, 데이터는 읽혀지지 않습니다.

참조 데이터 소스를 추가할 때 다음의 정보를 제공합니다.
+ **S3 버킷 및 객체 키 명칭** – 버킷 명칭 및 객체 키 외에도 Kinesis Data Analytics가 사용자를 대신하여 객체를 읽을 권한을 줄 IAM 역할도 제공합니다.
+ **애플리케이션 내 참조 표 명칭** – Kinesis Data Analytics가 이 애플리케이션 내 표를 생성하고 Amazon S3 객체를 읽어서 표를 채웁니다. 이는 애플리케이션 코드에서 지정한 표 명칭입니다.
+ **스키마 매핑** – 레코드 형식(JSON, CSV), Amazon S3 객체에 저장된 데이터의 인코딩을 기술합니다. 각 데이터 요소가 애플리케이션 내 참조 표에 있는 열에 어떻게 매핑되는지도 기술합니다.

다음은 `AddApplicationReferenceDataSource` API 요청의 요청 본문입니다.

```
{
    "applicationName": "string",
    "CurrentapplicationVersionId": number,
    "ReferenceDataSource": {
        "ReferenceSchema": {
            "RecordColumns": [
                {
                    "IsDropped": boolean,
                    "Mapping": "string",
                    "Name": "string",
                    "SqlType": "string"
                }
            ],
            "RecordEncoding": "string",
            "RecordFormat": {
                "MappingParameters": {
                    "CSVMappingParameters": {
                        "RecordColumnDelimiter": "string",
                        "RecordRowDelimiter": "string"
                    },
                    "JSONMappingParameters": {
                        "RecordRowPath": "string"
                    }
                },
                "RecordFormatType": "string"
            }
        },
        "S3ReferenceDataSource": {
            "BucketARN": "string",
            "FileKey": "string",
            "ReferenceRoleARN": "string"
        },
        "TableName": "string"
    }
}
```

# JSONPath로 작업하기
<a name="about-json-path"></a>

**참고**  
2023년 9월 12일 이후에는 Kinesis Data Analytics for SQL의 기존 사용자가 아닌 경우, Kinesis Data Firehose를 소스로 사용하여 새 애플리케이션을 생성할 수 없습니다. 자세한 설명은 [제한](https://docs.aws.amazon.com//kinesisanalytics/latest/dev/limits.html)을 참조하십시오.

JSONPath는 JSON 객체의 요소를 쿼리하는 표준화된 방법입니다. JSONPath는 경로 표현식을 사용하여 JSON 문서에서 요소, 중첩된 요소 및 배열을 탐색합니다. JSON에 대한 자세한 설명은 [JSON 소개](http://www.json.org/)를 참조하십시오.

Amazon Kinesis Data Analytics는 애플리케이션의 소스 스키마에 JSONPath 표현식을 사용하여 스트리밍 소스에서 JSON 형식의 데이터가 포함된 데이터 요소를 식별합니다.

스트리밍 데이터를 애플리케이션의 입력 스트림에 매핑하는 방법에 대한 자세한 설명은 [스트리밍 소스 요소를 SQL 입력 열에 매핑하기](sch-mapping.md) 섹션을 참조하십시오.

## JSONPath로 JSON 요소에 액세스하기
<a name="about-json-path-elements"></a>

JSONPath 표현식을 사용하여 JSON 형식 데이터의 다양한 요소에 액세스하는 방법을 알아볼 수 있습니다. 이 섹션의 예에서는 소스 스트림에 다음 JSON 레코드가 포함된 것으로 가정합니다.

```
{
  "customerName":"John Doe",
  "address":
  {
    "streetAddress":
    [
      "number":"123",
      "street":"AnyStreet"
    ],
    "city":"Anytown"
  }
  "orders":
  [
    { "orderId":"23284", "itemName":"Widget", "itemPrice":"33.99" },
    { "orderId":"63122", "itemName":"Gadget", "itemPrice":"22.50" },
    { "orderId":"77284", "itemName":"Sprocket", "itemPrice":"12.00" }
  ]
}
```

### JSON 요소에 액세스
<a name="about-json-path-firstlevel"></a>

JSONPath를 사용하여 JSON 데이터에 있는 요소를 쿼리하려면 다음의 구문을 사용합니다. 여기에서, `$`는 데이터 계층의 루트를 나타내고 `elementName`은 쿼리에 대한 요소 노드의 명칭입니다.

```
$.elementName
```

다음 표현식은 앞의 JSON 예제에 있는 `customerName` 요소를 쿼리하는 것이다.

```
$.customerName
```

앞의 표현식은 앞선 JSON 레코드로부터 다음을 반환합니다.

```
John Doe
```

**참고**  
경로 표현식은 대/소문자를 구분합니다. 표현식 `$.customername`은 앞선 JSON 예로부터 `null`을 반환합니다.

**참고**  
경로 표현식에서 지정한 위치에 요소가 나타나지 않을 경우, 표현식은 `null`을 반환합니다. 다음 표현식은 앞선 JSON 예로부터 `null`을 반환하는데, 일치하는 요소가 없기 때문입니다.  

```
$.customerId
```

### 중첩된 JSON 요소에 대한 액세스
<a name="about-json-path-nested"></a>

중첩된 JSON 요소를 쿼리하려면 다음 문구를 사용합니다.

```
$.parentElement.element
```

다음 표현식은 앞의 JSON 예제에 있는 `city` 요소를 쿼리하는 것이다.

```
$.address.city
```

앞의 표현식은 앞선 JSON 레코드로부터 다음을 반환합니다.

```
Anytown
```

다음 문구를 사용하여 하위 요소를 쿼리할 수 있습니다.

```
$.parentElement.element.subElement
```

다음 표현식은 앞의 JSON 예제에 있는 `street` 요소를 쿼리하는 것이다.

```
$.address.streetAddress.street
```

앞의 표현식은 앞선 JSON 레코드로부터 다음을 반환합니다.

```
AnyStreet
```

### 배열 액세스
<a name="about-json-path-arrays"></a>

다음과 같은 방법으로 JSON 배열의 데이터에 액세스할 수 있습니다.
+ 배열의 모든 요소를 단일 행으로 검색합니다.
+ 배열의 각 요소를 별도의 행으로 검색합니다.

#### 배열의 모든 요소를 단일 행으로 검색
<a name="about-json-path-arrays-row"></a>

배열의 전체 콘텐츠를 단일 행으로 쿼리하려면 다음의 구문을 사용합니다.

```
$.arrayObject[0:]
```

다음 표현식은 이 섹션에 사용된 위의 JSON 예에 있는 `orders` 요소의 전체 콘텐츠를 쿼리합니다. 단일 열 단일 행에 있는 배열 콘텐츠를 반환합니다.

```
$.orders[0:]
```

앞의 표현식은 이 섹션에 사용된 예 JSON 레코드로부터 다음을 반환합니다.

```
[{"orderId":"23284","itemName":"Widget","itemPrice":"33.99"},{"orderId":"61322","itemName":"Gadget","itemPrice":"22.50"},{"orderId":"77284","itemName":"Sprocket","itemPrice":"12.00"}]
```

#### 배열의 모든 요소를 별도의 행으로 검색
<a name="about-json-path-arrays-separate"></a>

배열의 개별 요소를 별도의 행으로 쿼리하려면 다음의 구문을 사용합니다.

```
$.arrayObject[0:].element
```

다음 표현식은 위의 JSON 예에 있는 `orderId` 요소를 쿼리하는 것으로 각 배열 요소를 별도의 행으로 반환합니다.

```
$.orders[0:].orderId
```

위의 표현식은 앞에 나온 JSON 레코드로부터 다음을 반환합니다. 이때 각 데이터 항목은 별도의 행으로 반환됩니다.


****  

|  | 
| --- |
|  23284  | 
|  63122  | 
|  77284  | 

**참고**  
비배열 요소를 쿼리하는 표현식이 개별 배열 요소를 쿼리하는 스키마에 포함되어 있는 경우, 비배열 요소는 해당 배열에 있는 각 요소에 대해 반복됩니다. 예를 들어, 위의 JSON 예에 대한 스키마가 다음의 표현식을 포함하고 있다고 가정해 보겠습니다.  
\$1.customerName
\$1.orders[0:].orderID
이 경우, 예 입력 스트림 요소로부터 반환된 데이터 행은 다음과 비슷할 것입니다. 이때 모든 `orderId` 요소에 대해 `name` 요소가 반복됩니다.  


****  

|  |  | 
| --- |--- |
|  John Doe  |  23284  | 
|  John Doe  |  63122  | 
|  John Doe  |  77284  | 

**참고**  
Amazon Kinesis Data Analytics에서 배열 표현식에는 다음 제한이 적용됩니다:  
배열 표현식에서는 한 가지 레벨의 역참조만 지원됩니다. 다음의 표현식 형식은 지원되지 않습니다.  

  ```
  $.arrayObject[0:].element[0:].subElement
  ```
한 가지 배열만 스키마에서 평면화할 수 있습니다. 복수의 어레이가 참조되어 – 어레이에 모든 요소가 포함된 하나의 행으로 반환될 수 있습니다. 그러나 하나의 어레이만 개별 행으로 반환되는 요소의 각각을 가질 수 있습니다.  
다음 형식의 요소를 포함하는 스키마는 유효합니다. 이 형식은 두 번째 어레이의 콘텐츠를 단일 열로 반환합니다. 첫 번째 어레이에 있는 모든 요소에 대해 반복됩니다.  

  ```
  $.arrayObjectOne[0:].element
  $.arrayObjectTwo[0:]
  ```
다음 형식의 요소를 포함하는 스키마는 유효하지 않습니다.  

  ```
  $.arrayObjectOne[0:].element
  $.arrayObjectTwo[0:].element
  ```

## 기타 고려 사항
<a name="about-json-path-other"></a>

JSONPath 작업 시 추가적인 고려 사항은 다음과 같습니다.
+ 애플리케이션 스키마의 JSONPath 표현식에 있는 개별 요소가 배열에 액세스하지 않는 경우, 처리된 각 JSON 레코드에 대해 애플리케이션의 입력 스트림에 단일 행이 생성됩니다.
+ 배열을 평면화할 때(즉, 해당 요소가 개별 행으로 반환됨) 누락된 요소가 있을 경우 애플리케이션 내 스트림에 null 값이 생성됩니다.
+ 배열은 항상 하나 이상의 행에 대해 평면화됩니다. 어떤 값도 반환되지 않는 경우(즉, 어레이가 비어 있거나 요소에 대한 쿼리가 없는 경우) 모든 null 값인 단일 행이 반환됩니다.

  다음 표현식은 앞선 JSON 예로부터 null 값을 지닌 레코드를 반환하는데, 지정된 경로에 일치하는 요소가 없기 때문입니다.

  ```
  $.orders[0:].itemId
  ```

  앞의 표현식은 앞선 JSON 예 레코드로부터 다음을 반환합니다.  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/kinesisanalytics/latest/dev/about-json-path.html)

## 관련 항목
<a name="about-json-path.Related"></a>
+ [JSON 소개](http://www.json.org/)

# 스트리밍 소스 요소를 SQL 입력 열에 매핑하기
<a name="sch-mapping"></a>

**참고**  
2023년 9월 12일 이후에는 Kinesis Data Analytics for SQL의 기존 사용자가 아닌 경우, Kinesis Data Firehose를 소스로 사용하여 새 애플리케이션을 생성할 수 없습니다. 자세한 설명은 [한도](https://docs.aws.amazon.com//kinesisanalytics/latest/dev/limits.html)를 참조하십시오.

Amazon Kinesis Data Analytics에서는 표준 SQL을 사용하여 JSON 또는 CSV 형식의 스트리밍 데이터를 처리하고 분석할 수 있습니다.
+ 스트리밍 CSV 데이터를 처리하고 분석하려면 입력 스트림의 열에 대해 열 명칭과 데이터 유형을 할당합니다. 애플리케이션이 입력 스트림에서 열 정의에 따라 순서대로 열을 하나씩 가져옵니다.

  애플리케이션 입력 스트림에 있는 열을 모두 포함할 필요는 없지만 소스 스트림에서 열을 건너뛸 수는 없습니다. 예를 들어, 5개 요소를 포함하는 입력 스트림으로부터 첫 3개 열을 가져올 수 있으나 1번, 2번 및 4번 열만을 가져올 수는 없습니다.
+ 스트리밍 JSON 데이터를 처리하고 분석하려면 JSONPath 표현식을 사용하여 JSON 요소를 스트리밍 소스로부터 입력 스트림의 SQL 열로 매핑합니다. Amazon Kinesis Data Analytics에서 JSONPath을 사용하는 방법은 [JSONPath로 작업하기](about-json-path.md)을 참조하십시오. SQL 표에 있는 열은 JSON 유형으로부터 매핑된 데이터 유형을 가집니다. 지원되는 데이터 유형은 [데이터 유형](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sql-reference-data-types.html) 섹션을 참조하십시오. JSON 데이터의 SQL 데이터 변환에 관한 상세 내용은 [JSON 데이터 유형을 SQL 데이터 유형으로 매핑하기](#sch-mapping-datatypes) 섹션을 참조하십시오.

입력 스트림 구성 방법에 관한 자세한 정보는 [애플리케이션 입력 구성](how-it-works-input.md) 섹션을 참조하십시오.

## JSON 데이터를 SQL 열에 매핑하기
<a name="sch-mapping-json"></a>

 AWS Management Console 또는 Kinesis Data Analytics API를 사용하여 JSON 요소를 입력 열에 매핑할 수 있습니다.
+ 콘솔을 사용하여 요소를 열에 매핑하는 방법은 [스키마 편집기로 작업](console-summary-edit-schema.md)을 참조하십시오.
+ Kinesis Data Analytics API를 사용하여 요소를 열에 매핑하는 방법은 다음 섹션을 참조하십시오.

JSON 요소를 애플리케이션 내 입력 스트림에 있는 열에 매핑하려면 각 열에 대해 다음의 정보가 스키마에 필요합니다.
+ **소스 표현식:** 열의 데이터 위치를 식별하는 JSONPath 식입니다.
+ **열 명칭:** SQL 쿼리에서 데이터를 참조하는 데 사용하는 명칭입니다.
+ **데이터 형식: **열의 SQL 데이터 형식입니다.

## API 사용
<a name="sf-map-api"></a>

스트리밍 소스의 요소를 입력 열로 매핑할 때 Kinesis Data Analytics API [CreateApplication](API_CreateApplication.md) 작업을 사용할 수 있습니다. 애플리케이션 내 스트림을 생성하기 위해서는 SQL에 사용되는 스키마화된 버전으로 데이터를 변환할 스키마를 지정합니다. [CreateApplication](API_CreateApplication.md) 작업은 단일 스트리밍 소스로부터 입력을 수신하도록 애플리케이션을 구성합니다. JSON 요소 또는 CSV 열을 SQL 열로 매핑하려면 [SourceSchema](API_SourceSchema.md) `RecordColumns` 어레이에서 [RecordColumn](API_RecordColumn.md)을 생성합니다. [RecordColumn](API_RecordColumn.md) 객체에는 다음의 스키마가 있습니다.

```
{ 
    "Mapping": "String",
    "Name": "String",
    "SqlType": "String"
}
```

[RecordColumn](API_RecordColumn.md) 객체에 있는 필드는 다음의 값을 가집니다.
+ `Mapping`: 입력 스트림에서 데이터의 위치를 식별하는 JSONPath 표현식입니다. CSV 형식의 소스 스트림에 대한 입력 스키마의 경우는 이 값이 존재하지 않습니다.
+ `Name`: 애플리케이션 내 SQL 데이터 스트림에 있는 열의 명칭입니다.
+ `SqlType`: 애플리케이션 내 SQL 데이터 스트림에 있는 데이터의 유형입니다.

### JSON 입력 스키마 예
<a name="sf-map-api-json-example"></a>

다음 예는 JSON 스키마에 대한 `InputSchema` 값의 형식을 보여 줍니다.

```
"InputSchema": {
    "RecordColumns": [
        {
            "SqlType": "VARCHAR(4)",
            "Name": "TICKER_SYMBOL",
            "Mapping": "$.TICKER_SYMBOL"
        },
        {
            "SqlType": "VARCHAR(16)",
            "Name": "SECTOR",
            "Mapping": "$.SECTOR"
        },
        {
            "SqlType": "TINYINT",
            "Name": "CHANGE",
            "Mapping": "$.CHANGE"
        },
        {
            "SqlType": "DECIMAL(5,2)",
            "Name": "PRICE",
            "Mapping": "$.PRICE"
        }
    ],
    "RecordFormat": {
        "MappingParameters": {
            "JSONMappingParameters": {
                "RecordRowPath": "$"
            }
        },
        "RecordFormatType": "JSON"
    },
    "RecordEncoding": "UTF-8"
}
```

### CSV 입력 스키마 예
<a name="sf-map-api-csv-example"></a>

다음 예는 CSV(쉼표로 분리된 값) 형식 스키마에 대한 `InputSchema` 값의 형식을 보여 줍니다.

```
"InputSchema": {
    "RecordColumns": [
        {
            "SqlType": "VARCHAR(16)",
            "Name": "LastName"
        },
        {
            "SqlType": "VARCHAR(16)",
            "Name": "FirstName"
        },
        {
            "SqlType": "INTEGER",
             "Name": "CustomerId"
        }
    ],
    "RecordFormat": {
        "MappingParameters": {
            "CSVMappingParameters": {
                "RecordColumnDelimiter": ",",
                "RecordRowDelimiter": "\n"
            }
        },
        "RecordFormatType": "CSV"
    },
    "RecordEncoding": "UTF-8"
}
```

## JSON 데이터 유형을 SQL 데이터 유형으로 매핑하기
<a name="sch-mapping-datatypes"></a>

JSON 데이터 유형은 애플리케이션의 입력 스키마에 따라 상응하는 SQL 데이터 유형으로 변환됩니다. 지원되는 SQL 데이터 형식에 관한 자세한 설명은 [데이터 유형](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sql-reference-data-types.html)을 참조하십시오. Amazon Kinesis Data Analytics는 다음 규칙에 따라 JSON 데이터 유형을 SQL 데이터 유형으로 변환합니다.

### Null 리터럴
<a name="sch-mapping-datatypes-null"></a>

JSON 입력 스트림에 있는 null 리터럴(`"City":null`)은 대상의 데이터 유형에 상관없이 SQL null로 변환됩니다.

### 부울 리터럴
<a name="sch-mapping-datatypes-boolean"></a>

JSON 입력 스트림에 있는 부울 리터럴(`"Contacted":true`)은 다음과 같이 SQL 데이터로 변환됩니다.
+ 숫자(DECIMAL, INT 등): `true`는 1로, `false`는 0으로 변환.
+ 이진수(BINARY 또는 VARBINARY): 
  + `true`: 결과는 가장 낮은 비트 세트를 가지며 남은 비트는 정리됩니다.
  + `false`: 결과의 모든 비트가 정리됩니다.

  VARBINARY로 변환하면 길이가 1바이트인 값이 도출됩니다.
+ 부울: 상응하는 SQL 부울 값으로 변환됩니다.
+ 문자(CHAR 또는 VARCHAR): 상응하는 문자열 값으로 변환됩니다(`true` 또는 `false`). 값은 필드의 길이에 맞게 잘립니다.
+ 날짜/시간(DATE, TIME 또는 TIMESTAMP): 변환이 실패하면 강제 변환 오류가 오류 스트림에 기록됩니다.

### 숫자
<a name="sch-mapping-datatypes-number"></a>

JSON 입력 스트림에 있는 숫자 리터럴(`"CustomerId":67321`)은 다음과 같이 SQL 데이터로 변환됩니다.
+ 숫자(DECIMAL, INT 등): 직접 변환됩니다. 변환된 값이 대상 데이터 유형의 크기 또는 정밀도를 초과하는 경우(즉, `123.4`를 INT로 변환하는 경우), 변환이 실패하고 강제 변환 오류가 오류 스트림에 기록됩니다.
+ 이진수(BINARY 또는 VARBINARY): 변환이 실패하고 강제 변환 오류가 오류 스트림에 기록됩니다.
+ BOOLEAN: 
  + `0`: `false`로 변환됩니다.
  + 기타 모든 수: `true`로 변환됩니다.
+ 문자(CHAR 또는 VARCHAR): 숫자의 문자열 표현으로 변환됩니다.
+ 날짜/시간(DATE, TIME 또는 TIMESTAMP): 변환이 실패하면 강제 변환 오류가 오류 스트림에 기록됩니다.

### 문자열
<a name="sch-mapping-datatypes-string"></a>

JSON 입력 스트림에 있는 문자열 값(`"CustomerName":"John Doe"`)은 다음과 같이 SQL 데이터로 변환됩니다.
+ 수치(DECIMAL, INT 등): Amazon Kinesis Data Analytics는 값을 대상 데이터 유형으로 변환합니다. 값을 변환할 수 없는 경우, 변환이 실패하고 강제 변환 오류가 오류 스트림에 기록됩니다.
+ 이진수(BINARY 또는 VARBINARY): 소스 스트링이 유효한 이진 리터럴(즉, 짝수 f를 지닌 `X'3F67A23A'`)인 경우 값은 대상 데이터 유형으로 변환됩니다. 그렇지 않은 경우 변환이 실패하고 강제 변환 오류가 오류 스트림에 기록됩니다.
+ 부울: 소스 스트링이 `"true"`인 경우, `true`로 변환됩니다. 이 비교는 대/소문자를 구분하지 않습니다. 그렇지 않은 경우, `false`로 변환됩니다.
+ 문자(CHAR 또는 VARCHAR): 입력에서 문자열 값으로 변환됩니다. 값이 대상 데이터 유형보다 더 긴 경우, 잘려지고 오류 스트림에 오류가 기록되지 않습니다.
+ 날짜/시간(DATE, TIME 또는 TIMESTAMP): 소스 스트링이 대상 값으로 변환할 수 있는 형식인 경우 값은 변환됩니다. 그렇지 않은 경우 변환이 실패하고 강제 변환 오류가 오류 스트림에 기록됩니다.

  유효한 날짜/시간 형식은 다음과 같습니다.
  + "1992-02-14"
  + "1992-02-14 18:35:44.0"

### 어레이 또는 객체
<a name="sch-mapping-datatypes-array"></a>

JSON 입력 스트림에 있는 어레이 또는 객체가 다음과 같이 SQL 데이터로 변환됩니다.
+ 문자(CHAR 또는 VARCHAR): 어레이 또는 객체의 소스 텍스트로 변환됩니다. [배열 액세스](about-json-path.md#about-json-path-arrays) 섹션을 참조하십시오.
+ 기타 모든 데이터 유형: 변환이 실패하고 강제 변환 오류가 오류 스트림에 기록됩니다.

JSON 어레이의 예는 [JSONPath로 작업하기](about-json-path.md)를 참조하십시오.

## 관련 항목
<a name="sch-mapping.Related"></a>
+ [애플리케이션 입력 구성](how-it-works-input.md)
+ [데이터 형식](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sql-reference-data-types.html)
+ [스키마 편집기로 작업](console-summary-edit-schema.md)
+ [CreateApplication](API_CreateApplication.md)
+ [RecordColumn](API_RecordColumn.md)
+ [SourceSchema](API_SourceSchema.md)

# 스트리밍 데이터에 대해 스키마 검색 기능 사용
<a name="sch-dis"></a>

**참고**  
2023년 9월 12일 이후에는 Kinesis Data Analytics for SQL의 기존 사용자가 아닌 경우, Kinesis Data Firehose를 소스로 사용하여 새 애플리케이션을 생성할 수 없습니다. 자세한 설명은 [제한](https://docs.aws.amazon.com//kinesisanalytics/latest/dev/limits.html)을 참조하십시오.

스트리밍 입력 상의 레코드가 어떻게 애플리케이션 내 스트림으로 매핑되는지 설명하는 입력 스키마를 제공하는 것은 복잡하고 오류가 발생하기 쉽습니다. [DiscoverInputSchema](API_DiscoverInputSchema.md)API(*검색 API*)를 사용하여 스키마를 유추할 수 있습니다. API는 스트리밍 소스 상의 랜덤 레코드 샘플을 사용하여 스키마를 유추할 수 있습니다(즉, 열 명칭, 데이터 유형, 수신 데이터에서의 데이터 요소 위치).

**참고**  
검색 API를 사용하여 Amazon S3에 저장된 파일에서 스키마를 생성하려면 [정적 데이터에 대해 스키마 검색 기능 사용](sch-dis-ref.md)을 참조하십시오.

콘솔은 Discovery API를 사용하여 지정된 스트리밍 소스에 대한 스키마를 생성합니다. 콘솔을 사용하면 열 추가 또는 삭제, 열 명칭 또는 데이터 유형 변경 등을 포함하여 스키마를 업데이트할 수 있습니다. 그러나 유효하지 않은 스키마를 생성하지 않도록 주의하여 변경합니다.

애플리케이션 내 스트림에 대한 스키마를 완료한 후에 문자열 및 날짜/시간 값을 조작하는 데 사용할 수 있는 함수가 있습니다. 결과로 얻은 애플리케이션 내 스트림에서 열 작업을 수행할 때 이들 함수를 애플리케이션 코드에서 사용할 수 있습니다. 자세한 설명은 [예: DateTime 값 변환](app-string-datetime-manipulation.md) 섹션을 참조하십시오.

## 스키마 검색 시 열 명칭 지정
<a name="sch-dis-column-names"></a>

스키마 검색 시에 Amazon Kinesis Data Analytics는 다음의 경우를 제외하고 스트리밍 입력 소스로부터 원래 열 명칭을 최대한 많이 보존하려 시도합니다:
+ 소스 스트림 열 명칭은 예약된 SQL 키워드(`TIMESTAMP`, `USER`, `VALUES` 또는 `YEAR`)입니다.
+ 소스 스트림 열 명칭은 지원되지 않는 문자를 포함합니다. 글자, 숫자 및 밑줄 문자( \$1 )만 지원됩니다.
+ 소스 스트림 열 명칭은 숫자로 시작합니다.
+ 소스 스트림 열 명칭은 100자보다 더 깁니다.

열의 명칭이 재지정되는 경우 재지정된 스키마 열 명칭은 `COL_`로 시작합니다. 일부 경우, 예를 들어 명칭 전체가 지원되지 않는 문자인 경우 원래 열 명칭 중 어느 것도 유지되지 않을 수 있습니다. 그와 같은 경우 열의 명칭이 `COL_#`로 지정되는데, 여기서 \$1는 열 순서에서 열의 자리를 나타내는 숫자입니다.

검색이 완료된 후 콘솔을 사용하여 열 추가 또는 삭제, 열 명칭, 데이터 유형 또는 데이터 크기 변경 등을 포함하여 스키마를 업데이트할 수 있습니다.

### 검색의 예-열 명칭 제안
<a name="sch-dis-column-names-examples"></a>


****  

| 소스 스트림 열 명칭 | 검색-열 명칭 제안 | 
| --- | --- | 
|  USER  |  COL\$1USER  | 
|  USER@DOMAIN  |  COL\$1USERDOMAIN  | 
|  @@  |  COL\$10  | 

## 스키마 검색 문제
<a name="sch-dis-when-fails"></a>

Kinesis Data Analytics가 특정 스트리밍 소스에 대한 스키마를 유추할 수 없다면 어떻게 되는가?

Kinesis Data Analytics는 UTF-8 인코딩된 CSV 및 JSON과 같은 일반적인 형식에 대해 스키마를 유추합니다. Kinesis Data Analytics는 맞춤 열 및 행 구분자를 사용하여 모든 UTF-8 인코딩 레코드 (애플리케이션 로그 및 레코드와 같은 원시 텍스트 포함) 를 지원합니다. Kinesis Data Analytics가 스키마를 유추하지 못한다면 콘솔에서 스키마 편집기를 사용하거나 API를 사용하여 스키마를 수동으로 정의할 수 있습니다.

 (데이터가 스키마 편집기를 사용하여 지정할 수 있는) 패턴에 따르지 않는 경우, 스키마를 단일 유형 열 VARCHAR(N)로 정의할 수 있습니다. 여기서 N은 레코드가 포함할 것으로 예상하는 최대 문자 수입니다. 거기에서 문자열 및 날짜 시간 조작을 통해 데이터가 애플리케이션 내 스트림 안에 포함된 후에 데이터를 구성할 수 있습니다. 예를 보려면 [예: DateTime 값 변환](app-string-datetime-manipulation.md) 섹션을 참조하십시오.

# 정적 데이터에 대해 스키마 검색 기능 사용
<a name="sch-dis-ref"></a>

**참고**  
2023년 9월 12일 이후에는 Kinesis Data Analytics for SQL의 기존 사용자가 아닌 경우, Kinesis Data Firehose를 소스로 사용하여 새 애플리케이션을 생성할 수 없습니다. 자세한 설명은 [제한](https://docs.aws.amazon.com//kinesisanalytics/latest/dev/limits.html)을 참조하십시오.

스키마 검색 기능은 스트림의 데이터나 Amazon S3 버킷에 저장된 정적 파일의 데이터로부터 스키마를 생성할 수 있습니다. 참조 목적으로 Kinesis Data Analytics 애플리케이션용 스키마를 생성하는 경우나 실시간 스트리밍 데이터를 사용할 수 없는 경우를 가정해 보겠습니다. 참조 데이터 또는 스트리밍의 필요 형식으로 된 데이터 샘플을 포함하는 정적 파일에 대해 스키마 검색 기능을 사용할 수 있습니다. Kinesis Data Analytics는 Amazon S3 버킷에 저장된 JSON 또는 CSV 파일의 샘플 데이터에 대해 스키마 검색을 실행할 수 있습니다. 데이터 파일에 대해 스키마 검색을 사용할 때는 콘솔을 사용하거나 [DiscoverInputSchema](API_DiscoverInputSchema.md) API를 지정된 `S3Configuration` 파라미터와 함께 사용합니다.

## 콘솔을 사용하여 스키마 검색 실행
<a name="sch-dis-ref-console"></a>

콘솔을 사용하여 정적 파일에 대해 검색을 실행하려면 다음을 수행합니다.

1. 참조 데이터 객체를 S3 버킷에 추가합니다.

1. Kinesis Data Analytics 콘솔의 애플리케이션 기본 페이지에서 **참조 데이터 연결**을 선택합니다.

1. 참조 데이터가 포함된 Amazon S3 객체에 액세스하기 위한 버킷, 경로 및 IAM 역할 데이터를 제공합니다.

1. **Discover schema(스키마 발견)**를 선택합니다.

콘솔에서 참조 데이터를 추가하고 스키마를 검색하는 방법에 대한 자세한 설명은 [예: 참조 데이터를 Kinesis Data Analytics 애플리케이션에 추가](app-add-reference-data.md) 섹션을 참조하십시오.

## API를 사용하여 스키마 검색 실행
<a name="sch-dis-ref-api"></a>

API를 사용하여 정적 파일에 대해 검색을 실행하려면 `S3Configuration` 구조를 포함하는 API에 다음 정보를 제공합니다.
+ `BucketARN`: 파일을 포함하는 Amazon S3 버킷의 Amazon 리소스 이름(ARN). Amazon S3 버킷 ARN의 형식은 [Amazon 리소스 이름(ARN) 및 Amazon Service Namespaces: Amazon Simple Storage Service(Amazon S3)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-s3)를 참조하십시오.
+ `RoleARN`: `AmazonS3ReadOnlyAccess` 정책이 적용되는 IAM 역할의 ARN. 역할에 정책을 추가하는 방법에 대한 자세한 설명은 [역할 수정](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_modify.html)을 참조하십시오.
+ `FileKey`: 객체의 파일 명칭입니다.

**`DiscoverInputSchema` API를 사용하여 Amazon S3 객체에서 스키마를 생성하려면**

1. 를 AWS CLI 설정했는지 확인합니다. 자세한 설명은 시작하기 섹션의 [2단계: AWS Command Line Interface (AWS CLI) 설정](setup-awscli.md) 항목을 참조하십시오.

1. 다음 콘텐츠를 가진 `data.csv`이라는 파일을 생성합니다:

   ```
   year,month,state,producer_type,energy_source,units,consumption
   2001,1,AK,TotalElectricPowerIndustry,Coal,ShortTons,47615
   2001,1,AK,ElectricGeneratorsElectricUtilities,Coal,ShortTons,16535
   2001,1,AK,CombinedHeatandPowerElectricPower,Coal,ShortTons,22890
   2001,1,AL,TotalElectricPowerIndustry,Coal,ShortTons,3020601
   2001,1,AL,ElectricGeneratorsElectricUtilities,Coal,ShortTons,2987681
   ```

1. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)에서 Amazon S3 콘솔에 로그인하십시오.

1. Amazon S3 버킷을 생성하고 생성된 파일을 업로드합니다. 생성된 버킷의 ARN을 메모해 둡니다. Amazon S3 버킷 생성 및 파일 업로드 방법에 대한 자세한 설명은 [Amazon Simple Storage 서비스 시작하기](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html)를 참조하십시오.

1. IAM 콘솔([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/))을 엽니다. `AmazonS3ReadOnlyAccess` 정책을 사용하여 역할을 생성합니다. 새 역할의 ARN을 기록합니다. 역할 생성에 대한 자세한 설명은 [Amazon 서비스에 권한 위임 역할 생성](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html)을 참조하십시오. 역할에 정책을 추가하는 방법에 대한 자세한 설명은 [역할 수정](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_modify.html)을 참조하십시오.

1. 에서 다음 `DiscoverInputSchema` 명령을 실행하여 Amazon S3 버킷 및 IAM 역할의 ARN을 AWS CLI대체합니다. ARNs 

   ```
   $aws kinesisanalytics discover-input-schema --s3-configuration '{ "RoleARN": "arn:aws:iam::123456789012:role/service-role/your-IAM-role", "BucketARN": "arn:aws:s3:::your-bucket-name", "FileKey": "data.csv" }' 
   ```

1. 응답은 다음과 유사해 보입니다.

   ```
   {
       "InputSchema": {
           "RecordEncoding": "UTF-8",
           "RecordColumns": [
               {
                   "SqlType": "INTEGER",
                   "Name": "COL_year"
               },
               {
                   "SqlType": "INTEGER",
                   "Name": "COL_month"
               },
               {
                   "SqlType": "VARCHAR(4)",
                   "Name": "state"
               },
               {
                   "SqlType": "VARCHAR(64)",
                   "Name": "producer_type"
               },
               {
                   "SqlType": "VARCHAR(4)",
                   "Name": "energy_source"
               },
               {
                   "SqlType": "VARCHAR(16)",
                   "Name": "units"
               },
               {
                   "SqlType": "INTEGER",
                   "Name": "consumption"
               }
           ],
           "RecordFormat": {
               "RecordFormatType": "CSV",
               "MappingParameters": {
                   "CSVMappingParameters": {
                       "RecordRowDelimiter": "\r\n",
                       "RecordColumnDelimiter": ","
                   }
               }
           }
       },
       "RawInputRecords": [
           "year,month,state,producer_type,energy_source,units,consumption\r\n2001,1,AK,TotalElectricPowerIndustry,Coal,ShortTons,47615\r\n2001,1,AK,ElectricGeneratorsElectricUtilities,Coal,ShortTons,16535\r\n2001,1,AK,CombinedHeatandPowerElectricPower,Coal,ShortTons,22890\r\n2001,1,AL,TotalElectricPowerIndustry,Coal,ShortTons,3020601\r\n2001,1,AL,ElectricGeneratorsElectricUtilities,Coal,ShortTons,2987681"
       ],
       "ParsedInputRecords": [
           [
               null,
               null,
               "state",
               "producer_type",
               "energy_source",
               "units",
               null
           ],
           [
               "2001",
               "1",
               "AK",
               "TotalElectricPowerIndustry",
               "Coal",
               "ShortTons",
               "47615"
           ],
           [
               "2001",
               "1",
               "AK",
               "ElectricGeneratorsElectricUtilities",
               "Coal",
               "ShortTons",
               "16535"
           ],
           [
               "2001",
               "1",
               "AK",
               "CombinedHeatandPowerElectricPower",
               "Coal",
               "ShortTons",
               "22890"
           ],
           [
               "2001",
               "1",
               "AL",
               "TotalElectricPowerIndustry",
               "Coal",
               "ShortTons",
               "3020601"
           ],
           [
               "2001",
               "1",
               "AL",
               "ElectricGeneratorsElectricUtilities",
               "Coal",
               "ShortTons",
               "2987681"
           ]
       ]
   }
   ```

# Lambda 함수를 사용하여 데이터 사전 처리
<a name="lambda-preprocessing"></a>

**참고**  
2023년 9월 12일 이후에는 Kinesis Data Analytics for SQL의 기존 사용자가 아닌 경우, Kinesis Data Firehose를 소스로 사용하여 새 애플리케이션을 생성할 수 없습니다. 자세한 설명은 [제한](https://docs.aws.amazon.com//kinesisanalytics/latest/dev/limits.html)을 참조하십시오.

스트림의 데이터에 형식 변환, 변환, 보강 또는 필터링이 필요한 경우 AWS Lambda 함수를 사용하여 데이터를 사전 처리할 수 있습니다. 애플리케이션 SQL 코드가 실행되기 전에 또는 애플리케이션이 데이터 스트림에서 스키마를 생성하기 전에 이 작업을 수행할 수 있습니다.

Lambda 함수를 사용하여 레코드를 사전 처리하면 다음과 같은 경우에 유용합니다:
+ 다른 형식 (예: KPL 또는 GZIP)의 레코드를 Kinesis Data Analytics가 분석할 수 있는 형식으로 변환. Kinesis Data Analytics는 현재 JSON 또는 CSV 데이터 형식을 지원합니다.
+ 집계, 변칙 검색 등과 같은 작업을 위해 액세스하기 쉬운 형식으로 데이터 확장. 예를 들어, 여러 데이터 값을 하나의 문자열에 함께 저장할 경우 데이터를 별도 열로 확장할 수 있습니다.
+ 다른 Amazon 서비스 (예: 외삽, 오류 수정 등)의 데이터 강화.
+ 레코드 필드에 복잡한 문자열 변환 적용
+ 데이터 정리를 위해 데이터 필터링

## Lambda 함수를 사용하여 레코드 사전 처리
<a name="lambda-preprocessing-use"></a>

Kinesis Data Analytics 애플리케이션을 생성할 때 **소스에 연결** 페이지에서 Lambda 사전 처리를 활성화합니다.

**Kinesis Data Analytics 애플리케이션에서 Lambda 함수를 사용하여 레코드를 사전 처리하려면**

1. 에 로그인 AWS Management Console 하고 [ https://console.aws.amazon.com/kinesisanalytics](https://console.aws.amazon.com/kinesisanalytics) Managed Service for Apache Flink 콘솔을 엽니다.

1. 애플리케이션의 **소스에 연결** 페이지의 **사전 처리 기록 AWS Lambda** 항목 섹션에서 **활성화**를 선택합니다.

1. 이미 생성된 Lambda 함수를 사용하려면 Lambda 함수 드롭다운 목록에서 함수를 선택합니다.

1. Lambda 사전 처리 템플릿 중 하나에서 새 Lambda 함수를 생성하려면 드롭다운 목록에서 해당 템플릿을 선택합니다. 그런 다음 **View <template name> in Lambda(Lambda에서 <템플릿 명칭> 보기)**를 선택하여 함수를 편집합니다.

1. 새 Lambda 함수를 생성하려면 **새로운 생성**을 선택합니다. Lambda 함수 생성에 관한 정보는 *AWS Lambda 개발자 가이드*의 [HelloWorld Lambda 함수 생성 및 콘솔 탐색](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html)을 참조하십시오.

1. 사용할 Lambda 함수의 버전을 선택합니다. 최신 버전을 사용하려면 [**\$1LATEST**]를 선택합니다.

레코드 사전 처리를 위해 Lambda 함수를 선택하거나 생성할 경우 애플리케이션 SQL 코드가 실행되거나 애플리케이션에서 레코드로부터 스키마를 생성하기 이전에 레코드가 사전 처리됩니다.

## Lambda 사전 처리 권한
<a name="lambda-preprocessing-policy"></a>

Lambda 사전 처리를 사용하려면 애플리케이션의 IAM 역할에 다음과 같은 권한 정책이 필요합니다.

```
     {
       "Sid": "UseLambdaFunction",
       "Effect": "Allow",
       "Action": [
           "lambda:InvokeFunction",
           "lambda:GetFunctionConfiguration"
       ],
       "Resource": "<FunctionARN>"
   }
```

## Lambda 사전 처리 지표
<a name="lambda-preprocessing-metrics"></a>

Amazon CloudWatch를 사용하여 Lambda 간접 호출 수, 처리된 바이트 수, 성공 및 실패 등을 모니터링할 수 있습니다. Kinesis Data Analytics Lambda 사전 처리에서 발생되는 CloudWatch 지표에 대한 자세한 설명은 [Amazon Kinesis Analytics 지표](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aka-metricscollected.html)를 참조하십시오.

## Kinesis 생산자 라이브러리와 AWS Lambda 함께 사용
<a name="lambda-preprocessing-deaggregation"></a>

[Kinesis Producer Library](https://docs.aws.amazon.com/streams/latest/dev/developing-producers-with-kpl.html)(KPL)는 사용자 형식의 작은 레코드를 최대 1MB의 큰 레코드로 집계하여 Amazon Kinesis Data Streams 처리량을 효율적으로 활용할 수 있게 합니다. Java용 Kinesis Client Library(KCL)은 이러한 레코드의 분해를 지원합니다. 그러나를 스트림의 소비자 AWS Lambda 로 사용할 때는 특수 모듈을 사용하여 레코드를 분해해야 합니다.

필요한 프로젝트 코드와 지침을 얻으려면 GitHub에서 [AWS Lambda를 위한 Kinesis Producer Library Deaggregation 모듈](https://github.com/awslabs/kinesis-deaggregation)을 참조하십시오. 이 프로젝트의 구성 요소를 사용하여 Java, Node.js 및 Python AWS Lambda 에서 내에서 KPL 직렬화된 데이터를 처리할 수 있습니다. [복수의 언어 KCL 애플리케이션](https://github.com/awslabs/amazon-kinesis-client/blob/master/amazon-kinesis-client-multilang/src/main/java/software/amazon/kinesis/multilang/package-info.java)의 일부로 이러한 구성 요소를 사용할 수 있습니다.

## 데이터 사전 처리 이벤트 입력 데이터 모델/레코드 응답 모델
<a name="lambda-preprocessing-data-model"></a>

레코드를 사전 처리하려면 Lambda 함수가 필수 이벤트 입력 데이터 및 레코드 응답 모델을 준수해야 합니다.

### 이벤트 입력 데이터 모델
<a name="lambda-preprocessing-request-model"></a>

Kinesis Data Analytics는 Kinesis 데이터 스트림 또는 Firehose 전송 스트림에서 데이터를 연속적으로 읽습니다. 추출하는 각각의 배치 레코드의 경우 서비스가 Lambda 함수에 전달되는 방법을 관리합니다. 함수에서는 레코드 목록을 입력으로 수신합니다. 함수 내에서 목록을 반복하고 비즈니스 로직을 적용하여 사전 처리 요구 사항(예: 데이터 포맷 변환 또는 강화)을 충족합니다.

사전 처리 함수에 대한 입력 모델은 데이터가 Kinesis 데이터 스트림에서 수신되었는지 Firehose 전송 스트림에서 수신되었는지에 따라 조금씩 달라집니다.

소스가 Firehose 전송 스트림인 경우 이벤트 입력 데이터 모델은 다음과 같습니다.

**Kinesis Data Firehose 요청 데이터 모델**


| 필드 | 설명 | 
| --- | --- | 
| 필드 | 설명 | 
| --- | --- | 
| 필드 | 설명 | 
| --- | --- | 
| invocationId | Lambda 간접 호출 ID(임의의 GUID) | 
| applicationArn | Kinesis Data Analytics 애플리케이션 Amazon 리소스 이름(ARN) | 
| streamArn | 전송 스트림 ARN | 
| 레코드 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/kinesisanalytics/latest/dev/lambda-preprocessing.html)  | 
| recordId | 레코드 ID(임의 GUID) | 
| kinesisFirehoseRecordMetadata |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/kinesisanalytics/latest/dev/lambda-preprocessing.html)  | 
| data | Base64 인코딩된 소스 레코드 페이로드 | 
| approximateArrivalTimestamp | 전송 스트림 레코드의 대략적인 도착 시간 | 

다음 예는 Firehose 전송 스트림의 입력을 보여 줍니다.

```
{
   "invocationId":"00540a87-5050-496a-84e4-e7d92bbaf5e2",
   "applicationArn":"arn:aws:kinesisanalytics:us-east-1:12345678911:application/lambda-test",
   "streamArn":"arn:aws:firehose:us-east-1:AAAAAAAAAAAA:deliverystream/lambda-test",
   "records":[
      {
         "recordId":"49572672223665514422805246926656954630972486059535892482",
         "data":"aGVsbG8gd29ybGQ=",
         "kinesisFirehoseRecordMetadata":{
            "approximateArrivalTimestamp":1520280173
         }
      }
   ]
}
```

소스가 Kinesis 데이터 스트림인 경우 이벤트 입력 데이터 모델은 다음과 같습니다:

**Kinesis 스트림 요청 데이터 모델**


| 필드 | 설명 | 
| --- | --- | 
| 필드 | 설명 | 
| --- | --- | 
| 필드 | 설명 | 
| --- | --- | 
| invocationId | Lambda 간접 호출 ID(임의의 GUID) | 
| applicationArn | Kinesis Data Analytics 애플리케이션 ARN | 
| streamArn | 전송 스트림 ARN | 
| 레코드 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/kinesisanalytics/latest/dev/lambda-preprocessing.html)  | 
| recordId | Kinesis 레코드 시퀀스 번호를 기반으로 하는 레코드 ID | 
| kinesisStreamRecordMetadata |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/kinesisanalytics/latest/dev/lambda-preprocessing.html)  | 
| 데이터 | Base64 인코딩된 소스 레코드 페이로드 | 
| sequenceNumber | Kinesis 스트림 레코드의 시퀀스 번호 | 
| partitionKey | Kinesis 스트림 레코드의 파티션 키 | 
| shardId | ShardId Kinesis 스트림 레코드의 | 
| approximateArrivalTimestamp | 전송 스트림 레코드의 대략적인 도착 시간 | 

다음 예는 Kinesis 데이터 스트림의 입력을 보여 줍니다.

```
{
  "invocationId": "00540a87-5050-496a-84e4-e7d92bbaf5e2",
  "applicationArn": "arn:aws:kinesisanalytics:us-east-1:12345678911:application/lambda-test",
  "streamArn": "arn:aws:kinesis:us-east-1:AAAAAAAAAAAA:stream/lambda-test",
  "records": [
    {
      "recordId": "49572672223665514422805246926656954630972486059535892482",
      "data": "aGVsbG8gd29ybGQ=",
      "kinesisStreamRecordMetadata":{
            "shardId" :"shardId-000000000003",
            "partitionKey":"7400791606",
            "sequenceNumber":"49572672223665514422805246926656954630972486059535892482",
            "approximateArrivalTimestamp":1520280173
         }
    }
  ]
}
```

### 레코드 응답 모델
<a name="lambda-preprocessing-response-model"></a>

Lambda 함수에 전송되는 Lambda 사전 처리 함수(레코드 ID 포함)에서 반환된 모든 레코드가 반환되어야 합니다. 이러한 레코드는 다음 파라미터가 포함되어 있어야 하며 그렇지 않으면 Kinesis Data Analytics가 이를 거부하고 데이터 사전 처리 실패로 간주합니다. 레코드의 데이터 페이로드 부분을 사전 처리 요구 사항에 맞게 변환할 수 있습니다.

**응답 데이터 모델**


| 필드 | 설명 | 
| --- | --- | 
| 레코드 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/kinesisanalytics/latest/dev/lambda-preprocessing.html)  | 
| recordId | 레코드 ID는 간접 호출 중에 Kinesis Data Analytics에서 Lambda로 전달됩니다. 변환된 레코드에는 동일한 레코드 ID가 포함되어야 합니다. 원래 레코드의 ID와 변환된 레코드의 ID 간 불일치는 데이터 사전 처리 실패로 간주됩니다. | 
| result | 레코드의 데이터 변환 상태입니다. 가능한 값은 다음과 같습니다.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/kinesisanalytics/latest/dev/lambda-preprocessing.html)  | 
| data | base64 인코딩 후 변환된 데이터 페이로드입니다. 각 데이터 페이로드는 애플리케이션 수집 데이터 형식이 JSON인 경우 여러 JSON 문서를 포함할 수 있습니다. 또는 애플리케이션 수집 데이터 형식이 CSV인 경우 여러 CSV 행(각 행에서 지정된 행 구분 기호 사용)을 포함할 수 있습니다. Kinesis Data Analytics 서비스가 여러 JSON 문서 또는 동일한 데이터 페이로드 내 CSV 행에서 데이터를 구문 분석하고 처리합니다. | 

다음 예는 Lambda 함수의 출력을 보여 줍니다.

```
{
  "records": [
    {
      "recordId": "49572672223665514422805246926656954630972486059535892482",
      "result": "Ok",
      "data": "SEVMTE8gV09STEQ="
    }
  ]
}
```

## 일반 데이터 사전 처리 기능
<a name="lambda-preprocessing-failures"></a>

다음은 사전 처리에 실패할 수 있는 일반적인 이유입니다.
+ Lambda 함수에 전송되는 배치 레코드 (레코드 ID 포함) 전체가 서비스에 반환 되지는 않습니다.
+ 응답에 레코드 ID, 상태 또는 데이터 페이로드 필드가 없습니다. `Dropped` 또는 `ProcessingFailed` 레코드에 대해 데이터 페이로드 필드는 선택 사항입니다.
+ Lambda 함수 제한 시간이 데이터를 사전 처리하는 데 충분하지 않습니다.
+ Lambda 함수 응답이 AWS Lambda 서비스에서 부여한 응답 한도를 초과합니다.

데이터 사전 처리에 실패한 경우 Kinesis Data Analytics는 동일한 레코드 세트에 대해 호출을 성공할 때까지 계속 재시도합니다. 다음 CloudWatch 지표를 모니터링하면 실패의 원인을 알 수 있습니다.
+ Kinesis Data Analytics 애플리케이션 `MillisBehindLatest`: 애플리케이션이 스트리밍 소스에서 읽어오는 시간이 얼마나 뒤처져 있는 지를 나타냅니다.
+ Kinesis Data Analytics 애플리케이션 `InputPreprocessing` CloudWatch 지표: 통계 중에서 성공 횟수와 실패 횟수를 나타냅니다. 자세한 설명은 [Amazon Kinesis Analytics 지표](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aka-metricscollected.html)를 참조하십시오.
+ AWS Lambda 함수 CloudWatch 지표 및 로그.

# 사전 처리용 Lambda 함수 생성
<a name="lambda-preprocessing-functions"></a>

Amazon Kinesis Data Analytics 애플리케이션은 애플리케이션으로 수집되는 레코드를 사전 처리하는 데 Lambda 함수를 사용할 수 있습니다. Kinesis Data Analytics는 콘솔에서 데이터 사전 처리를 위한 출발점으로 사용할 수 있는 다음과 같은 템플릿을 제공합니다.

**Topics**
+ [Node.js에서 Lambda 사전 처리 함수 생성](#lambda-preprocessing-functions-nodejs)
+ [Python에서 사전 처리 함수 생성](#lambda-preprocessing-functions-python)
+ [Java에서 사전 처리 함수 생성](#lambda-preprocessing-functions-java)
+ [.NET에서 Lambda 사전 처리 함수 생성](#lambda-preprocessing-functions-net)

## Node.js에서 Lambda 사전 처리 함수 생성
<a name="lambda-preprocessing-functions-nodejs"></a>

Node.js에서 Lambda 사전 처리 함수 생성에 사용할 아래의 템플릿은 Kinesis Data Analytics 콘솔에서 사용할 수 있습니다.


| Lambda 창사진 | 언어 및 버전 | 설명 | 
| --- | --- | --- | 
| 일반 Kinesis Data Analytics 입력 처리  | Node.js 6.10 |  Kinesis Data Analytics는 JSON 또는 CSV 레코드를 입력으로 수신한 다음 사전 처리 상태로 반환하는 사전 처리 프로세서를 기록합니다. 이 프로세서를 맞춤 변환 로직에 대한 시작점으로 사용합니다.  | 
| 압축된 입력 처리 | Node.js 6.10 | Kinesis Data Analytics는 압축된(GZIP 또는 Deflate 압축) JSON 또는 CSV 레코드를 입력으로 수신하고 압축 해제된 레코드를 처리 상태로 반환하는 사전 처리 프로세서를 기록합니다. | 

## Python에서 사전 처리 함수 생성
<a name="lambda-preprocessing-functions-python"></a>

Python에서 Lambda 사전 처리 함수를 생성하기 위한 아래의 템플릿은 콘솔에서 사용할 수 있습니다:


| Lambda 청사진 | 언어 및 버전 | 설명 | 
| --- | --- | --- | 
| 일반 Kinesis Analytics 입력 처리  | Python 2.7 |  Kinesis Data Analytics는 JSON 또는 CSV 레코드를 입력으로 수신한 다음 사전 처리 상태로 반환하는 사전 처리 프로세서를 기록합니다. 이 프로세서를 맞춤 변환 로직에 대한 시작점으로 사용합니다.  | 
| KPL 입력 처리 | Python 2.7 | Kinesis Data Analytics는 JSON의 Kinesis Producer Library (KPL) 집합 또는 CSV 레코드를 입력으로 수신한 다음 처리 상태와 함께 분리된 기록 반환을 기록합니다. | 

## Java에서 사전 처리 함수 생성
<a name="lambda-preprocessing-functions-java"></a>

Java에서 레코드 사전 처리용 Lambda 함수를 생성하려면 [Java 이벤트](https://github.com/aws/aws-lambda-java-libs/tree/master/aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events) 클래스를 사용하십시오.

다음 코드는 Java를 사용하여 레코드를 사전 처리하는 Lambda 함수 샘플입니다:

```
public class LambdaFunctionHandler implements
        RequestHandler<KinesisAnalyticsStreamsInputPreprocessingEvent, KinesisAnalyticsInputPreprocessingResponse> {

    @Override
    public KinesisAnalyticsInputPreprocessingResponse handleRequest(
            KinesisAnalyticsStreamsInputPreprocessingEvent event, Context context) {
        context.getLogger().log("InvocatonId is : " + event.invocationId);
        context.getLogger().log("StreamArn is : " + event.streamArn);
        context.getLogger().log("ApplicationArn is : " + event.applicationArn);

        List<KinesisAnalyticsInputPreprocessingResponse.Record> records = new ArrayList<KinesisAnalyticsInputPreprocessingResponse.Record>();
        KinesisAnalyticsInputPreprocessingResponse response = new KinesisAnalyticsInputPreprocessingResponse(records);

        event.records.stream().forEach(record -> {
            context.getLogger().log("recordId is : " + record.recordId);
            context.getLogger().log("record aat is :" + record.kinesisStreamRecordMetadata.approximateArrivalTimestamp);
             // Add your record.data pre-processing logic here.                               
            // response.records.add(new Record(record.recordId, KinesisAnalyticsInputPreprocessingResult.Ok, <preprocessedrecordData>));
        });
        return response;
    }

}
```

## .NET에서 Lambda 사전 처리 함수 생성
<a name="lambda-preprocessing-functions-net"></a>

.NET에서 레코드 사전 처리용 Lambda 함수를 생성하려면 [.NET 이벤트](https://github.com/aws/aws-lambda-dotnet/tree/master/Libraries/src/Amazon.Lambda.KinesisAnalyticsEvents) 클래스를 사용합니다.

다음 코드는 C\$1을 사용하여 레코드를 사전 처리하는 Lambda 함수 예입니다:

```
public class Function
    {
        public KinesisAnalyticsInputPreprocessingResponse FunctionHandler(KinesisAnalyticsStreamsInputPreprocessingEvent evnt, ILambdaContext context)
        {
            context.Logger.LogLine($"InvocationId: {evnt.InvocationId}");
            context.Logger.LogLine($"StreamArn: {evnt.StreamArn}");
            context.Logger.LogLine($"ApplicationArn: {evnt.ApplicationArn}");

            var response = new KinesisAnalyticsInputPreprocessingResponse
            {
                Records = new List<KinesisAnalyticsInputPreprocessingResponse.Record>()
            };

            foreach (var record in evnt.Records)
            {
                context.Logger.LogLine($"\tRecordId: {record.RecordId}");
                context.Logger.LogLine($"\tShardId: {record.RecordMetadata.ShardId}");
                context.Logger.LogLine($"\tPartitionKey: {record.RecordMetadata.PartitionKey}");
                context.Logger.LogLine($"\tRecord ApproximateArrivalTime: {record.RecordMetadata.ApproximateArrivalTimestamp}");
                context.Logger.LogLine($"\tData: {record.DecodeData()}");

                // Add your record preprocessig logic here.

                var preprocessedRecord = new KinesisAnalyticsInputPreprocessingResponse.Record
                {
                    RecordId = record.RecordId,
                    Result = KinesisAnalyticsInputPreprocessingResponse.OK
                };
                preprocessedRecord.EncodeData(record.DecodeData().ToUpperInvariant());
                response.Records.Add(preprocessedRecord);
            }
            return response;
        }
    }
```

.NET에서 사전 처리 및 목적지용 Lambda 함수 생성에 대한 자세한 설명은 [https://github.com/aws/aws-lambda-dotnet/tree/master/Libraries/src/Amazon.Lambda.KinesisAnalyticsEvents](https://github.com/aws/aws-lambda-dotnet/tree/master/Libraries/src/Amazon.Lambda.KinesisAnalyticsEvents)를 참조하십시오.

# 입력 스트림 병렬화를 통한 처리량 증대
<a name="input-parallelism"></a>

**참고**  
2023년 9월 12일 이후에는 Kinesis Data Analytics for SQL의 기존 사용자가 아닌 경우, Kinesis Data Firehose를 소스로 사용하여 새 애플리케이션을 생성할 수 없습니다. 자세한 설명은 [한도](https://docs.aws.amazon.com//kinesisanalytics/latest/dev/limits.html)를 참조하십시오.

Amazon Kinesis Data Analytics 애플리케이션은 복수의 애플리케이션 내 입력 스트림을 지원하여 애플리케이션의 용량을 단일 애플리케이션 내 입력 스트림의 처리량 이상으로 확장할 수 있습니다. 애플리케이션 내 입력 스트림에 대한 자세한 설명은 [Amazon Kinesis Data Analytics for SQL 애플리케이션: 작동 방식](how-it-works.md) 섹션을 참조하십시오.

대부분의 경우 Amazon Kinesis Data Analytics는 애플리케이션에 피드되는 Kinesis 스트림 또는 Firehose 소스 스트림의 용량을 처리하도록 애플리케이션의 규모를 조정합니다. 그러나 소스 스트림의 처리량이 단일 애플리케이션 내 입력 스트림의 처리량을 초과하는 경우 애플리케이션이 사용하는 애플리케이션 내 입력 스트림의 수를 명시적으로 늘릴 수 있습니다. `InputParallelism` 파라미터를 사용하여 그렇게 합니다.

`InputParallelism` 파라미터가 1보다 클 경우 Amazon Kinesis Data Analytics는 소스 스트림의 파티션을 애플리케이션 내 스트림 간에 균등하게 분할합니다. 예를 들어, 소스 스트림의 샤드 수가 50개이고 `InputParallelism`을 `2`로 설정한 경우, 각각의 애플리케이션 내 입력 스트림은 25개의 소스 스트림 샤드로부터 입력을 수신합니다.

애플리케이션 내 수를 늘릴 경우 애플리케이션이 각 스트림에서 데이터에 명시적으로 액세스해야 합니다. 코드에서 복수의 애플리케이션 내 스트림에 액세스하는 것에 대한 정보는 [Amazon Kinesis Data Analytics 애플리케이션에서 별도의 애플리케이션 내 스트림에 액세스하는 방법](#input-parallelism-code-example) 을 참조하십시오.

Kinesis 데이터 스트림과 Firehose 샤드가 둘 다 동일한 방식으로 애플리케이션 내 스트림 간에 분할되지만, 애플리케이션에 표시되는 방식은 다릅니다.
+ Kinesis 데이터 스트림의 레코드에는 레코드의 소스 샤드를 식별하는 데 사용 가능한 `shard_id` 필드가 포함됩니다.
+ Firehose 전송 스트림의 레코드는 레코드의 소스 샤드 또는 파티션을 식별하는 필드를 포함하지 않습니다. Firehose가 이 정보를 애플리케이션에서 추상화하기 때문입니다.

## 애플리케이션 내 입력 스트림 수를 증대해야 할지 여부에 대한 평가
<a name="input-parallelism-evaluating"></a>

대부분의 경우 단일 애플리케이션 내 입력 스트림은 입력 스트림의 복잡성 및 데이터 크기에 따라 단일 소스 스트림의 처리량을 처리할 수 있습니다. Amazon CloudWatch에서 `InputBytes` 및 `MillisBehindLatest`의 지표를 모니터링하여 애플리케이션 내 입력 스트림의 증가 여부를 판단할 수 있습니다.

`InputBytes` 지표가 100MB/초보다 큰 경우 (또는 커질 것으로 예상하는 경우) `MillisBehindLatest`가 증가하고 애플리케이션 문제의 영향이 증가할 수 있습니다. 이를 해결하기 위해 애플리케이션에 대한 다음의 언어 선택을 권장합니다.
+ 100MB/초 이상으로 애플리케이션 규모 조정이 필요한 경우 복수의 스트림과 Kinesis Data Analytics for SQL 애플리케이션를 사용하십시오.
+ 단일 스트림과 애플리케이션을 사용하려는 경우 [Java 애플리케이션용 Kinesis Data Analytics](/managed-flink/latest/java/what-is.html)를 사용하십시오.

`MillisBehindLatest` 지표가 다음 특성 중 하나라도 가지고 있을 경우 애플리케이션의 `InputParallelism` 설정을 늘려야 합니다.
+ `MillisBehindLatest` 지표가 점진적으로 증가하여 애플리케이션이 스트림에서의 최신 데이터보다 뒤쳐지고 있음을 나타냅니다.
+ `MillisBehindLatest` 지표가 지속적으로 1000(1초)을 초과합니다.

다음에 해당하는 경우 애플리케이션의 `InputParallelism` 설정을 늘릴 필요가 없습니다.
+ `MillisBehindLatest` 지표가 점진적으로 감소하여 애플리케이션이 스트림에서의 최신 데이터를 따라잡고 있음을 나타냅니다.
+ `MillisBehindLatest` 지표가 1000(1초) 아래입니다.

CloudWatch에 대한 자세한 정보는 [Amazon CloudWatch 사용자 가이드](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)를 참조하십시오.

## 복수의 애플리케이션 내 입력 스트림 구현
<a name="input-parallelism-implementing"></a>

애플리케이션을 생성할 때 [CreateApplication](API_CreateApplication.md)을 사용하여 애플리케이션 내 입력 스트림의 수를 설정할 수 있습니다. 애플리케이션을 생성한 후에 [UpdateApplication](API_UpdateApplication.md)을 사용하여 이 수를 설정합니다.

**참고**  
Amazon Kinesis Data Analytics API 또는 AWS CLI를 사용해서만 `InputParallelism` 설정값을 설정할 수 있습니다. 를 사용하여이 설정을 설정할 수 없습니다 AWS Management Console. 설정에 대한 자세한 내용은 단원을 AWS CLI참조하십시오[2단계: AWS Command Line Interface (AWS CLI) 설정](setup-awscli.md).

### 새 애플리케이션의 입력 스트림 수 설정
<a name="input-parallelism-implementing-create"></a>

다음 예는 `CreateApplication` API 작업을 사용하여 새 애플리케이션의 입력 스트림 수를 2로 설정하는 방법을 보여줍니다.

`CreateApplication`에 대한 자세한 정보는 [CreateApplication](API_CreateApplication.md) 섹션을 참조하세요.

```
{
   "ApplicationCode": "<The SQL code the new application will run on the input stream>",
   "ApplicationDescription": "<A friendly description for the new application>",
   "ApplicationName": "<The name for the new application>",
   "Inputs": [ 
    { 
      "InputId": "ID for the new input stream",
      "InputParallelism": { 
        "Count": 2
    }],
   "Outputs": [ ... ],
	}]
}
```

### 기존 애플리케이션의 입력 스트림 수 설정
<a name="input-parallelism-implementing-update"></a>

다음 예는 `UpdateApplication` API 작업을 사용하여 기존 애플리케이션의 입력 스트림 수를 2로 설정하는 방법을 보여 줍니다.

`Update_Application`에 대한 자세한 정보는 [UpdateApplication](API_UpdateApplication.md) 섹션을 참조하세요.

```
{
   "InputUpdates": [ 
      { 
         "InputId": "yourInputId",
         "InputParallelismUpdate": { 
            "CountUpdate": 2
         }
      }
   ],
}
```

## Amazon Kinesis Data Analytics 애플리케이션에서 별도의 애플리케이션 내 스트림에 액세스하는 방법
<a name="input-parallelism-code-example"></a>

애플리케이션에서 복수의 애플리케이션 내 입력 스트림을 사용하려면 각기 다른 스트림에서 명시적으로 선택해야 합니다. 다음의 코드 예는 시작하기 자습서에서 생성한 애플리케이션에서 복수의 입력 스트림을 쿼리하는 방법을 보여 줍니다.

다음 예에서는 각 소스 스트림은 [수](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sql-reference-count.html)를 사용하여 우선 집계된 후 `in_application_stream001`라는 단일 애플리케이션 내 스트림으로 결합됩니다. 소스 스트림을 미리 집계하면 결합된 애플리케이션 내 스트림이 과부하 없이 복수의 스트림에서 발생하는 트래픽을 처리하는 데 도움이 됩니다.

**참고**  
이 예를 실행하여 두 애플리케이션 내 입력 스트림으로부터 결과를 얻으려면 소스 스트림에 있는 샤드의 수와 애플리케이션의 `InputParallelism` 파라미터를 둘 다 업데이트합니다.

```
CREATE OR REPLACE STREAM in_application_stream_001 (
    ticker VARCHAR(64),
    ticker_count INTEGER
);

CREATE OR REPLACE PUMP pump001 AS 
INSERT INTO in_application_stream_001
SELECT STREAM ticker_symbol, COUNT(ticker_symbol)
FROM source_sql_stream_001
GROUP BY STEP(source_sql_stream_001.rowtime BY INTERVAL '60' SECOND),
    ticker_symbol; 
        
CREATE OR REPLACE PUMP pump002 AS 
INSERT INTO in_application_stream_001
SELECT STREAM ticker_symbol, COUNT(ticker_symbol)
FROM source_sql_stream_002
GROUP BY STEP(source_sql_stream_002.rowtime BY INTERVAL '60' SECOND),
    ticker_symbol;
```

위의 코드 예는 다음과 비슷한 결과를 `in_application_stream001`에 출력합니다:

![\[Table showing ROWTIME, TICKER, and TICKER_COUNT columns with sample data entries.\]](http://docs.aws.amazon.com/ko_kr/kinesisanalytics/latest/dev/images/input-parallelism-results.png)


## 추가 고려 사항
<a name="input-parallelism-considerations"></a>

복수의 입력 스트림을 사용하는 경우 다음에 유의해야 합니다.
+ 애플리케이션 내 입력 스트림의 최대 수는 64입니다.
+ 애플리케이션 내 입력 스트림은 애플리케이션 입력 스트림의 샤드 간에 균등하게 분배됩니다.
+ 애플리케이션 내 스트림 추가에 따른 성능상 이득은 선형적으로 증가하지 않습니다. 즉, 애플리케이션 내 스트림을 두 배로 늘린다고 처리량이 두 배가 되지는 않습니다. 행 크기가 일반적인 경우, 각 애플리케이션 내 스트림은 초당 약 5,000\$115,000개의 행을 처리할 수 있습니다. 애플리케이션 내 스트림 수를 10으로 늘리면 초당 20,000\$130,000 정도의 처리량을 확보할 수 있습니다. 처리 속도는 입력 스트림 필드의 수, 데이터 유형 및 데이터 크기에 좌우됩니다.
+ 일부 집계 함수(예: [AVG](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sql-reference-avg.html))는 여러 샤드에 분할된 입력 스트림에 적용할 경우 예상치 못한 결과를 산출할 수 있습니다. 샤드를 집계 스트림에 결합하기 전에 개별 샤드에 대한 집계 작업을 실행해야 하기 때문에 결과를 레코드가 더 많이 포함된 것에 대해 가감해야 할 수 있습니다.
+ 입력 스트림 수를 늘린 후에도 계속해서 성능 저하가 일어나면 (`MillisBehindLatest`의 지표가 높게) Kinesis 처리 단위(KPU)의 한도에 이른 것일 수도 있습니다. 자세한 설명은 [처리량 증가를 위해 애플리케이션 용량을 자동으로 확장 또는 축소](how-it-works-autoscaling.md) 섹션을 참조하십시오.

# 애플리케이션 코드
<a name="how-it-works-app-code"></a>

애플리케이션 코드는 입력을 처리하고 출력을 생성하는 일련의 SQL 문입니다. 이 SQL 문은 애플리케이션 내 스트림과 참조 표로 운영됩니다. 자세한 설명은 [Amazon Kinesis Data Analytics for SQL 애플리케이션: 작동 방식](how-it-works.md) 섹션을 참조하십시오.

Kinesis Data Analytics에서 지원되는 SQL 언어 요소에 대한 자세한 설명은 [Amazon Kinesis Data Analytics SQL 참조](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/analytics-sql-reference.html)를 참조하십시오.

관계형 데이터베이스에서 INSERT 문을 통해 레코드를 추가하고 SELECT 문을 통해 데이터를 쿼리하는 표 작업을 수행합니다. Amazon Kinesis Data Analytics에서는 스트림을 사용합니다. SQL 문을 작성하여 이들 스트림을 쿼리할 수 있습니다. 하나의 애플리케이션 내 스트림을 쿼리한 결과는 항상 또 다른 애플리케이션 내 스트림으로 전송됩니다. 복잡한 분석을 수행할 때는 여러 개의 애플리케이션 내 스트림을 생성하여 중간 분석 결과를 유지할 수 있습니다. 그리고 끝으로 최종 분석 결과를(하나 이상의 애플리케이션 내 스트림으로부터) 외부 대상에 유지하도록 애플리케이션 출력을 구성합니다. 요약하자면, 애플리케이션 코드 작성의 일반적인 패턴은 다음과 같습니다.
+ INSERT 문 맥락에서는 항상 SELECT 문이 사용됩니다. 즉, 행을 선택할 때 결과를 다른 애플리케이션 내 스트림에 삽입합니다.
+ 펌프 맥락에서는 항상 INSERT 문이 사용됩니다. 즉, 펌프를 사용하여 애플리케이션 내 스트림에 작성합니다.



다음 예 애플리케이션 코드는 하나의 애플리케이션 내 스트림(SOURCE\$1SQL\$1STREAM\$1001)으로부터 레코드를 읽고 이를 또 다른 애플리케이션 내 스트림(DESTINATION\$1SQL\$1STREAM)에 기록합니다. 다음과 같이 펌프를 사용하여 레코드를 애플리케이션 내 스트림에 삽입할 수 있습니다.

```
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (ticker_symbol VARCHAR(4), 
                                                   change DOUBLE, 
                                                   price DOUBLE);
-- Create a pump and insert into output stream.
CREATE OR REPLACE PUMP "STREAM_PUMP" AS 

  INSERT INTO "DESTINATION_SQL_STREAM" 
    SELECT STREAM ticker_symbol, change,price
    FROM   "SOURCE_SQL_STREAM_001";
```

**참고**  
스트림 명칭 및 열 명칭에 대해 지정하는 식별자는 표준 SQL 규칙에 따릅니다. 예를 들어 식별자 앞뒤로 따옴표를 사용하는 경우 식별자는 대소문자를 구분합니다. 따옴표를 사용하지 않는 경우에는 기본적으로 식별자는 대문자입니다. 식별자에 대한 자세한 설명은 *Amazon Managed Service for Apache Flink SQL 참조*에서 [식별자](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sql-reference-identifiers.html)를 참조하십시오.

애플리케이션 코드는 복수의 SQL 문으로 구성될 수 있습니다. 예시:
+ 한 SQL 문의 결과가 다음 SQL 문으로 전달되는 경우 SQL 쿼리를 순차적으로 작성할 수 있습니다.
+ 서로 독립적으로 실행하는 SQL 문도 작성할 수 있습니다. 예를 들어, 동일한 애플리케이션 내 스트림을 쿼리하지만 다른 애플리케이션 내 스트림으로 출력을 전송하는 두 개의 SQL 문을 작성할 수 있습니다. 그런 다음 새로 생성된 애플리케이션 내 스트림을 독립적으로 쿼리할 수 있습니다.

애플리케이션 내 스트림을 생성하여 중간 결과를 저장할 수 있습니다. 펌프를 사용하여 데이터를 애플리케이션 내 스트림에 삽입합니다. 자세한 설명은 [애플리케이션 내 스트림과 펌프](streams-pumps.md) 섹션을 참조하십시오.

애플리케이션 내 참조 표를 추가하는 경우 SQL을 작성하여 애플리케이션 내 스트림 및 참조 표에 있는 데이터를 조인할 수 있습니다. 자세한 설명은 [예: 참조 데이터를 Kinesis Data Analytics 애플리케이션에 추가](app-add-reference-data.md) 섹션을 참조하십시오.

애플리케이션의 출력 구성에 따라 Amazon Kinesis Data Analytics는 특정 애플리케이션 내 스트림으로부터 외부 목적지로 데이터를 기록합니다. 애플리케이션 코드가 출력 구성에 지정된 애플리케이션 내 스트림으로 기록하는지 확인합니다.

자세한 정보는 다음 주제를 참조하십시오:
+  [스트리밍 SQL 개념](streaming-sql-concepts.md)
+ [Amazon Kinesis Data Analytics SQL 참조](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/analytics-sql-reference.html)

# 애플리케이션 출력 구성
<a name="how-it-works-output"></a>



애플리케이션 코드에서 SQL 문 출력을 하나 이상의 인애플리케이션 스트림에 씁니다. 필요에 따라 애플리케이션에 출력 구성을 추가할 수 있습니다.는 인애플리케이션 스트림에 기록된 모든 내용을 Amazon Kinesis 데이터 스트림, Firehose 전송 스트림 또는 AWS Lambda 함수와 같은 외부 대상으로 유지할 수 있습니다.

애플리케이션 출력을 유지하는 데 사용할 수 있는 외부 대상의 수에는 제한이 있습니다. 자세한 설명은 [한도](limits.md) 섹션을 참조하십시오.

**참고**  
오류를 조사할 수 있도록 하나의 외부 대상을 사용하여 애플리케이션 내 오류 스트림 데이터를 유지하는 것이 좋습니다.



이들 출력 구성 각각에 대해 다음을 제공합니다:
+ **애플리케이션 내 스트림 명칭** – 외부 목적지에 유지하고자 하는 스트림.

  Kinesis Data Analytics는 출력 구성에 지정된 애플리케이션 내 스트림을 탐색합니다. (이 스트림 명칭은 대/소문자를 구분하며 정확히 일치해야 합니다.) 애플리케이션 코드가 이 애플리케이션 내 스트림을 생성하는지 확인하십시오.
+ **외부 대상** – Kinesis 데이터 스트림, Firehose 전송 스트림 또는 Lambda 함수에 데이터를 유지할 수 있습니다. 스트림 또는 함수의 Amazon 리소스 이름(ARN)을 제공합니다. 또한 Kinesis Data Analytics가 귀하를 대신하여 스트림 또는 기능을 가질 수 있도록 수 IAM 역할을 줄 수 있습니다 외부 목적지에 작성할 때 사용할 레코드 형식(JSON, CSV)을 Kinesis Data Analytics에 기술합니다.

Kinesis Data Analytics가 스트리밍 또는 Lambda 목적지에 작성할 수 없을 경우에는 계속하여 무한정 시도합니다. 이로 인해 백 프레셔(back pressure)가 발생하여 애플리케이션이 뒤쳐지게 됩니다. 이 문제가 해결되지 않을 경우 결국 애플리케이션이 신규 데이터 처리를 중단합니다. [Amazon Kinesis Data Analytics 지표](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aka-metricscollected.html)를 모니터링하고 장애에 대한 경보를 설정할 수 있습니다. 지표 및 경보에 대한 자세한 설명은 [Using Amazon CloudWatch 지표 사용](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html)과 [Creating Amazon CloudWatch 경보 생성](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html)을 참조하십시오.

 AWS Management Console을(를) 사용하여 애플리케이션 출력을 구성할 수 있습니다. 콘솔은 API 호출을 통해 구성을 저장합니다.

## 를 사용하여 출력 생성 AWS CLI
<a name="how-it-works-output-cli"></a>

이 섹션에서는 `CreateApplication` 또는 `AddApplicationOutput` 작업에 대한 요청 본문의 `Outputs` 섹션을 생성하는 방법을 설명합니다.

### Kinesis 스트림 출력 생성
<a name="how-it-works-output-cli-streams"></a>

다음 JSON 조각은 Amazon Kinesis 데이터 스트림 목적지를 생성하기 위한 `CreateApplication` 요청 본문의 `Outputs` 섹션을 보여줍니다.

```
"Outputs": [
   {
       "DestinationSchema": {
           "RecordFormatType": "string"
       },
       "KinesisStreamsOutput": {
           "ResourceARN": "string",
           "RoleARN": "string"
       },
       "Name": "string"
   }
 
]
```

### Firehose 전송 스트림 출력 생성
<a name="how-it-works-output-cli-firehose"></a>

다음 JSON 조각은 Amazon Data Firehose 전송 스트림 대상을 생성하기 위한 `CreateApplication` 요청 본문의 `Outputs` 섹션을 보여줍니다.

```
"Outputs": [
   {
       "DestinationSchema": {
           "RecordFormatType": "string"
       },
       "KinesisFirehoseOutput": {
           "ResourceARN": "string",
           "RoleARN": "string"
       },
       "Name": "string"
   }
]
```

### Lambda 함수 출력 생성
<a name="how-it-works-output-cli-lambda"></a>

다음 JSON 조각은 AWS Lambda 함수 대상을 생성하기 위한 `CreateApplication` 요청 본문의 `Outputs` 섹션을 보여줍니다.

```
"Outputs": [
   {
       "DestinationSchema": {
           "RecordFormatType": "string"
       },
       "LambdaOutput": {
           "ResourceARN": "string",
           "RoleARN": "string"
       },
       "Name": "string"
   }
]
```

# Lambda 함수를 출력으로 사용
<a name="how-it-works-output-lambda"></a>

 AWS Lambda 를 대상으로 사용하면 SQL 결과를 최종 대상으로 보내기 전에 사후 처리를 보다 쉽게 수행할 수 있습니다. 일반적인 사후 처리 작업에는 다음이 포함됩니다.
+ 단일 레코드에 여러 행 집계
+ 현재 결과와 과거 결과를 결합하여 늦게 도착하는 데이터 처리
+ 정보의 유형에 따라 서로 다른 대상으로 전송
+ 레코드 형식 변환(예: Protobuf로 변환)
+ 문자열 조작 또는 변환
+ 분석 처리 후 데이터 강화
+ 지리 공간 사용 사례에 대한 맞춤 처리
+ 데이터 암호화

Lambda 함수는 다음을 포함하여 다양한 AWS 서비스 및 기타 대상에 분석 정보를 제공할 수 있습니다.
+ [Amazon Simple Storage Service(Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/)
+ 맞춤 API
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/)
+ [Amazon Aurora](http://aurora.apache.org/)
+ [Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/)
+ [Amazon Simple Notification Service (Amazon SNS)](https://docs.aws.amazon.com/sns/latest/dg/)
+ [Amazon Simple Queue Service(Amazon SQS)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/)
+ [Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/)

Lambda 애플리케이션 생성에 대한 자세한 설명은 [AWS Lambda로 시작하기](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) 섹션을 참조하십시오.

**Topics**
+ [출력 권한으로서 Lambda](#how-it-works-output-lambda-perms)
+ [출력 지표로서의 Lambda](#how-it-works-output-lambda-metrics)
+ [출력 이벤트 입력 데이터 모델 및 레코드 응답 모델로서 Lambda](#how-it-works-output-lambda-model)
+ [Lambda 출력 호출 빈도](#how-it-works-output-lambda-frequency)
+ [출력으로 사용할 Lambda 함수 추가](#how-it-works-output-lambda-procedure)
+ [일반적인 Lambda 출력 실패](#how-it-works-output-lambda-troubleshooting)
+ [애플리케이션 목적지용 Lambda 함수 생성](how-it-works-output-lambda-functions.md)

## 출력 권한으로서 Lambda
<a name="how-it-works-output-lambda-perms"></a>

Lambda를 출력으로 사용하려면 애플리케이션의 Lambda 출력 IAM 역할에 다음과 같은 권한 정책이 필요합니다:

```
{
   "Sid": "UseLambdaFunction",
   "Effect": "Allow",
   "Action": [
       "lambda:InvokeFunction",
       "lambda:GetFunctionConfiguration"
   ],
   "Resource": "FunctionARN"
}
```

## 출력 지표로서의 Lambda
<a name="how-it-works-output-lambda-metrics"></a>

Amazon CloudWatch를 사용하여 전송된 바이트 수, 성공 및 실패 등을 모니터링 할 수 있습니다. Kinesis Data Analytics에서 Lambda를 출력으로 사용하여 방출되는 CloudWatch 지표에 대한 자세한 설명은 [Amazon Kinesis Analytics 지표](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aka-metricscollected.html)를 참조하십시오.

## 출력 이벤트 입력 데이터 모델 및 레코드 응답 모델로서 Lambda
<a name="how-it-works-output-lambda-model"></a>

Kinesis Data Analytics 출력 레코드를 전송하려면 Lambda 함수가 필수 이벤트 입력 데이터 및 레코드 응답 모델을 준수해야 합니다.

### 이벤트 입력 데이터 모델
<a name="how-it-works-output-lambda-model-request"></a>

Kinesis Data Analytics는 다음 요청 모델을 사용하여 애플리케이션의 출력 레코드를 출력 함수인 Lambda로 계속 전송합니다. 함수 내에서 목록을 반복하고 비즈니스 로직을 적용하여 출력 요구 사항(예: 최종 대상으로 전송하기 전에 데이터 변환)을 충족합니다.


| 필드 | 설명 | 
| --- | --- | 
| 필드 | 설명 | 
| --- | --- | 
| 필드 | 설명 | 
| --- | --- | 
| invocationId | Lambda 간접 호출 ID(임의의 GUID) | 
| applicationArn | Kinesis Data Analytics 애플리케이션 Amazon 리소스 이름(ARN). | 
| 레코드 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/kinesisanalytics/latest/dev/how-it-works-output-lambda.html)  | 
| recordId | 레코드 ID(임의 GUID) | 
| lambdaDeliveryRecordMetadata |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/kinesisanalytics/latest/dev/how-it-works-output-lambda.html)  | 
| 데이터 | Base64 인코딩된 출력 레코드 페이로드 | 
| retryHint | 전송 재시도 횟수 | 

**참고**  
`retryHint`는 전송이 실패할 때마다 증가하는 값입니다. 이 값은 영구적으로 유지되지 않으며 애플리케이션이 중단되면 재설정됩니다.

### 레코드 응답 모델
<a name="how-it-works-output-lambda-model-response"></a>

출력 함수인 Lambda로 전송된 각 레코드(레코드 ID 포함)는 `Ok` 또는 `DeliveryFailed`로 승인되어야 하며 다음 파라미터를 포함해야 합니다. 그렇지 않으면 Kinesis Data Analytics가 이를 전송 실패로 처리합니다.


| 필드 | 설명 | 
| --- | --- | 
| 레코드 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/kinesisanalytics/latest/dev/how-it-works-output-lambda.html)  | 
| recordId | 레코드 ID는 간접 호출 중에 Kinesis Data Analytics에서 Lambda로 전달됩니다. 원래 레코드의 ID와 승인된 레코드의 ID 간 불일치는 전송 실패로 처리됩니다. | 
| result | 레코드의 전송 상태입니다. 유효한 값은 다음과 같습니다.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/kinesisanalytics/latest/dev/how-it-works-output-lambda.html)  | 

## Lambda 출력 호출 빈도
<a name="how-it-works-output-lambda-frequency"></a>

Kinesis Data Analytics 애플리케이션은 출력 레코드를 버퍼링하고 AWS Lambda 목적지 함수를 빈번하게 간접 호출합니다.
+ 레코드가 데이터 분석 애플리케이션 내의 대상 인애플리케이션 스트림으로 텀블링 윈도우로 내보내지면 텀블링 윈도우 트리거당 AWS Lambda 대상 함수가 호출됩니다. 예를 들어 60초 텀블링 윈도우가 레코드를 목적지 애플리케이션 내 스트림으로 방출하는 데 사용되면 Lambda 함수가 60초에 한 번씩 간접 호출됩니다.
+ 레코드가 애플리케이션에서 연속 쿼리 또는 슬라이딩 윈도우로서 대상 애플리케이션 내 스트림으로 방출된 경우 약 1초에 한 번씩 Lambda 목적지 함수가 간접 호출됩니다.

**참고**  
[Lambda 함수 당 간접 호출 요청 페이로드 크기 한도](https://docs.aws.amazon.com/lambda/latest/dg/limits.html)가 적용됩니다. 이러한 제한을 초과하면 출력 레코드가 분할되어 여러 Lambda 함수 호출로 전송됩니다.

## 출력으로 사용할 Lambda 함수 추가
<a name="how-it-works-output-lambda-procedure"></a>

다음 절차는 Lambda 함수를 Kinesis Data Analytics 애플리케이션의 출력으로 추가하는 방법을 보여 줍니다.

1. 에 로그인 AWS Management Console 하고 [ https://console.aws.amazon.com/kinesisanalytics](https://console.aws.amazon.com/kinesisanalytics) Managed Service for Apache Flink 콘솔을 엽니다.

1. 목록에서 애플리케이션을 선택한 다음 [**Application details**]를 선택합니다.

1. [**Destination**] 섹션에서 [**Connect new destination**]을 선택합니다.

1. [**Destination**] 항목에서 [**AWS Lambda function**]을 선택합니다.

1. **레코드를 AWS Lambda에 전송** 섹션에서 기존 Lambda 함수 및 버전을 선택하거나, 또는 **새로 만들기**를 선택합니다.

1. Lambda 함수를 새로 생성하는 경우에는 다음을 수행합니다:

   1. 제공된 템플릿 중 하나를 선택합니다. 자세한 설명은 [애플리케이션 목적지용 Lambda 함수 생성](how-it-works-output-lambda-functions.md) 섹션을 참조하십시오.

   1. 새 브라우저 탭에서 **함수 생성** 페이지가 열립니다. **명칭** 상자에서 함수에 의미 있는 명칭(예: **myLambdaFunction**)을 지정합니다.

   1. 애플리케이션의 사후 처리 기능으로 템플릿을 업데이트합니다. Lambda 함수 생성에 대한 자세한 설명은 *AWS Lambda 개발자 가이드*의 [시작하기](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html)를 참조하십시오.

   1. Kinesis Data Analytics 콘솔의 **Lambda 함수** 목록에서, 방금 생성한 Lambda 함수를 선택합니다. Lambda 함수 버전의 경우 **\$1LATEST**를 선택합니다.

1. [**In-application stream**] 섹션에서 [**Choose an existing in-application stream**]을 선택합니다. [**In-application stream name**]에서 애플리케이션의 출력 스트림을 선택합니다. 선택한 출력 스트림의 결과는 Lambda 출력 함수로 전송됩니다.

1. 양식의 나머지 부분은 기본값으로 두고 [**Save and continue**]를 선택합니다.

이제 애플리케이션에서 애플리케이션 내 스트림의 레코드를 Lambda 함수로 전송합니다. Amazon CloudWatch 콘솔에서 기본 템플릿의 결과를 볼 수 있습니다. Lambda 함수에 전송되는 레코드 수를 보려면 `AWS/KinesisAnalytics/LambdaDelivery.OkRecords` 지표를 모니터링하십시오.

## 일반적인 Lambda 출력 실패
<a name="how-it-works-output-lambda-troubleshooting"></a>

다음은 Lambda 함수로 전송할 수 없는 일반적인 이유입니다.
+ Lambda 함수에 전송되는 배치 내의 일부 레코드(레코드 ID 포함)가 Kinesis Data Analytics 서비스에 반환 되지는 않습니다.
+ 응답에 레코드 ID 또는 상태 필드가 없습니다.
+ Lambda 함수 제한 시간이 Lambda 함수 내의 비즈니스 로직을 수행하는 데 충분하지 않습니다.
+ Lambda 함수 내의 비즈니스 로직은 모든 오류를 잡아내지 못하므로 처리되지 않은 예외로 인해 시간 초과 및 백 프레셔(back pressure)가 발생합니다. 이를 "독약" 메시지라고 하기도 합니다.

데이터 전송에 실패한 경우 Kinesis Data Analytics는 동일한 레코드 세트에 대해 Lambda 간접 호출을 성공할 때까지 계속 재시도합니다. 다음 CloudWatch 지표를 모니터링하여 실패의 원인을 알 수 있습니다: 
+ CloudWatch 출력 지표로서의 Kinesis Data Analytics 애플리케이션 Lambda: 다른 통계 중에서 성공 횟수와 실패 횟수를 나타냅니다. 자세한 설명은 [Amazon Kinesis Analytics 지표](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/aka-metricscollected.html)를 참조하십시오.
+ AWS Lambda 함수 CloudWatch 지표 및 로그.

# 애플리케이션 목적지용 Lambda 함수 생성
<a name="how-it-works-output-lambda-functions"></a>

Kinesis Data Analytics 애플리케이션은 AWS Lambda 함수를 출력으로 사용할 수 있습니다. Kinesis Data Analytics는 애플리케이션의 대상으로 사용할 Lambda 함수를 생성하기 위한 템플릿을 제공합니다. 이러한 템플릿은 애플리케이션에서 사후 처리 출력을 위한 시작점으로 사용합니다.

**Topics**
+ [Node.js에서 Lambda 함수 목적지 생성](#how-it-works-lambda-dest-nodejs)
+ [Python에서 Lambda 함수 목적지 생성](#how-it-works-lambda-dest-python)
+ [Java에서 Lambda 함수 목적지 생성](#how-it-works-lambda-dest-java)
+ [.NET에서 Lambda 함수 목적지 생성](#how-it-works-lambda-net)

## Node.js에서 Lambda 함수 목적지 생성
<a name="how-it-works-lambda-dest-nodejs"></a>

Node.js에서 Lambda 함수를 생성하는 다음 템플릿은 콘솔에서 사용할 수 있습니다:


| 출력 청사진으로서의 Lambda | 언어 및 버전 | 설명 | 
| --- | --- | --- | 
| kinesis-analytics-output | Node.js 12.x | Kinesis Data Analytics 애플리케이션의 출력 레코드를 맞춤 목적지로 전송합니다. | 

## Python에서 Lambda 함수 목적지 생성
<a name="how-it-works-lambda-dest-python"></a>

Python에서 목적지 Lambda 함수를 생성할 때 다음 템플릿은 콘솔에서 사용할 수 있습니다:


| 출력 청사진으로서의 Lambda | 언어 및 버전 | 설명 | 
| --- | --- | --- | 
| kinesis-analytics-output-sns | Python 2.7 | Kinesis Data Analytics 애플리케이션의 출력 기록을 Amazon SNS로 전송하십시오. | 
| kinesis-analytics-output-ddb | Python 2.7 | Kinesis Data Analytics 애플리케이션의 출력 기록을 Amazon DynamoDB로 전송하십시오. | 

## Java에서 Lambda 함수 목적지 생성
<a name="how-it-works-lambda-dest-java"></a>

Java에서 목적지 Lambda 함수를 생성하려면 [Java 이벤트](https://github.com/aws/aws-lambda-java-libs/tree/master/aws-lambda-java-events/src/main/java/com/amazonaws/services/lambda/runtime/events) 클래스를 사용합니다.

다음 코드는 Java를 사용한 목적지 Lambda 함수 예입니다:

```
public class LambdaFunctionHandler
        implements RequestHandler<KinesisAnalyticsOutputDeliveryEvent, KinesisAnalyticsOutputDeliveryResponse> {

    @Override
    public KinesisAnalyticsOutputDeliveryResponse handleRequest(KinesisAnalyticsOutputDeliveryEvent event,
            Context context) {
        context.getLogger().log("InvocatonId is : " + event.invocationId);
        context.getLogger().log("ApplicationArn is : " + event.applicationArn);

        List<KinesisAnalyticsOutputDeliveryResponse.Record> records = new ArrayList<KinesisAnalyticsOutputDeliveryResponse.Record>();
        KinesisAnalyticsOutputDeliveryResponse response = new KinesisAnalyticsOutputDeliveryResponse(records);

        event.records.stream().forEach(record -> {
            context.getLogger().log("recordId is : " + record.recordId);
            context.getLogger().log("record retryHint is :" + record.lambdaDeliveryRecordMetadata.retryHint);
            // Add logic here to transform and send the record to final destination of your choice.
            response.records.add(new Record(record.recordId, KinesisAnalyticsOutputDeliveryResponse.Result.Ok));
        });
        return response;
    }

}
```

## .NET에서 Lambda 함수 목적지 생성
<a name="how-it-works-lambda-net"></a>

.NET에서 목적지 Lambda 함수를 생성하려면 [.NET 이벤트](https://github.com/aws/aws-lambda-dotnet/tree/master/Libraries/src/Amazon.Lambda.KinesisAnalyticsEvents) 클래스를 사용합니다.

다음 코드는 C\$1을 사용한 목적지 Lambda 함수 예입니다:

```
public class Function
    {
        public KinesisAnalyticsOutputDeliveryResponse FunctionHandler(KinesisAnalyticsOutputDeliveryEvent evnt, ILambdaContext context)
        {
            context.Logger.LogLine($"InvocationId: {evnt.InvocationId}");
            context.Logger.LogLine($"ApplicationArn: {evnt.ApplicationArn}");

            var response = new KinesisAnalyticsOutputDeliveryResponse
            {
                Records = new List<KinesisAnalyticsOutputDeliveryResponse.Record>()
            };

            foreach (var record in evnt.Records)
            {
                context.Logger.LogLine($"\tRecordId: {record.RecordId}");
                context.Logger.LogLine($"\tRetryHint: {record.RecordMetadata.RetryHint}");
                context.Logger.LogLine($"\tData: {record.DecodeData()}");

                // Add logic here to send to the record to final destination of your choice.

                var deliveredRecord = new KinesisAnalyticsOutputDeliveryResponse.Record
                {
                    RecordId = record.RecordId,
                    Result = KinesisAnalyticsOutputDeliveryResponse.OK
                };
                response.Records.Add(deliveredRecord);
            }
            return response;
        }
    }
```

.NET에서 사전 처리 및 목적지 Lambda 함수 생성에 대한 자세한 설명은 [https://github.com/aws/aws-lambda-dotnet/tree/master/Libraries/src/Amazon.Lambda.KinesisAnalyticsEvents](https://github.com/aws/aws-lambda-dotnet/tree/master/Libraries/src/Amazon.Lambda.KinesisAnalyticsEvents)을 참조하십시오.

# 애플리케이션 출력을 외부 대상에 유지하기 위한 전송 모델
<a name="failover-checkpoint"></a>

Amazon Kinesis Data Analytics에서는 구성할 애플리케이션 출력에 대해 "최소 1회" 전송 모델을 적용합니다. 애플리케이션을 실행 중일 때 Kinesis Data Analytics에서는 내부 체크포인트를 사용합니다. 이러한 체크포인트는 출력 레코드가 데이터 손실 없이 대상으로 전송된 시점입니다. Kinesis Analytics에서는 필요에 따라 체크포인트를 사용하여 애플리케이션 출력이 구성된 대상으로 최소한 한번은 전달되도록 합니다.

정상적인 상황에서 애플리케이션은 들어오는 데이터를 지속적으로 처리합니다. Kinesis Data Analytics는 Kinesis 데이터 스트림 또는 Firehose 전송 스트림 같은 구성된 대상에 출력을 작성합니다. 하지만 애플리케이션은 경우에 따라 중단될 수 있습니다. 예:
+ 애플리케이션을 중단하고 나중에 재시작하도록 선택하는 경우.
+ Kinesis Data Analytics이 애플리케이션 출력을 구성된 목적지에 작성할 필요가 있는 IAM 역할을 삭제하는 경우. IAM 역할이 없다면 Kinesis Data Analytics는 귀하를 대신하여 외부 대상에 작성할 수 있는 권한이 없습니다.
+ 네트워크 중단 또는 기타 내부 서비스 결함으로 인해 애플리케이션의 실행이 일시적으로 중지됩니다.

애플리케이션이 다시 시작될 경우 Kinesis Data Analytics는 실패가 발생할 때 또는 그 이전 시점부터 출력을 계속 처리 및 기록합니다. 따라서 애플리케이션 출력이 구성된 대상으로 확실하게 전송됩니다.

동일한 애플리케이션 내 스트림에서 여러 대상을 구성했다고 가정해 보겠습니다. 애플리케이션이 실패에서 복구되면 Kinesis Data Analytics는 가장 느린 목적지로 전송된 마지막 레코드부터 구성된 목적지로 출력을 계속 유지합니다. 이렇게 할 경우 동일한 출력 레코드가 다른 목적지로 두 번 이상 전송될 수 있습니다. 이 경우 대상에서의 잠재적 중복을 외부적으로 처리해야 합니다.

# 오류 처리
<a name="error-handling"></a>

Amazon Kinesis Data Analytics는 API 또는 SQL 오류를 사용자에게 직접 반환합니다. API 작업에 대한 자세한 설명은 [작업](API_Operations.md) 섹션을 참조하십시오. SQL 오류 처리에 대한 자세한 설명은 [Amazon Kinesis Data Analytics SQL 참조](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/analytics-sql-reference.html)를 참고하십시오.

Amazon Kinesis Data Analytics는 `error_stream`이라고 하는 애플리케이션 내 오류 스트림을 사용하여 런타임 오류를 보고합니다.



## 애플리케이션 내 오류 스트림을 사용한 오류 보고
<a name="error-handling-errorstream"></a>

Amazon Kinesis Data Analytics는 `error_stream`이라고 하는 애플리케이션 내 오류 스트림에 런타임 오류를 보고합니다. 다음은 발생할 수 있는 오류의 예입니다:
+ 스트리밍 소스로부터 읽은 레코드가 입력 스키마에 부합하지 않습니다.
+ 애플리케이션 코드가 0으로 나누기를 지정했습니다.
+ 행이 순서에 벗어난 상태입니다(예: 레코드의 순서 이탈을 야기하는 사용자가 수정한 `ROWTIME` 값을 지닌 스트림 상에 레코드가 나타나는 경우).
+ 소스 스트림에 있는 데이터가 스키마에 지정된 데이터 유형으로 변환되지 않습니다(강제 변환 오류). 변환 가능한 데이터 유형에 관한 정보는 [JSON 데이터 유형을 SQL 데이터 유형으로 매핑하기](sch-mapping.md#sch-mapping-datatypes) 섹션을 참조하십시오.

SQL 코드에서 이러한 오류를 프로그래밍 방식으로 처리하거나 오류 스트림 상의 데이터를 외부 대상에 유지하는 것이 좋습니다. 이를 위해서는 애플리케이션에 출력 구성을 추가해야 합니다([애플리케이션 출력 구성](how-it-works-output.md) 참조). 애플리케이션 내 오류 스트림 작동 방식의 예는 [예: 애플리케이션 내 오류 스트림 탐색](app-explore-error-stream.md) 섹션을 참조하십시오.

**참고**  
시스템 계정을 사용하여 오류 스트림이 생성되었기 때문에 Kinesis Data Analytics 애플리케이션은 오류 스트림을 프로그래밍 방식으로 액세스하거나 수정할 수 없습니다. 오류 출력을 사용하여 애플리케이션에서 발생할 수 있는 에러가 무엇인지 판단해야 합니다. 그런 다음 애플리케이션의 SQL 코드를 작성하여 예상되는 오류 상태를 처리합니다.

### 오류 스트림 스키마
<a name="error-handling-errorstream-schema"></a>

오류 스트림의 스키마는 다음과 같습니다.


****  

|  |  |  | 
| --- |--- |--- |
| *필드* | *데이터 형식* | *참고* | 
| ERROR\$1TIME | TIMESTAMP | 오류 발생 시간 | 
| ERROR\$1LEVEL | VARCHAR(10) |  | 
| ERROR\$1NAME | VARCHAR(32) |  | 
| MESSAGE | VARCHAR(4096) |  | 
| DATA\$1ROWTIME | TIMESTAMP | 수신 레코드의 ROW TIME | 
| DATA\$1ROW | VARCHAR(49152) |  기존 행에 있는 16진수 인코딩 데이터. 표준 라이브러리를 사용하여 이 값을 16진수로 디코딩하거나 이 [ 16진수 - 문자열 변환기](http://string-functions.com/hex-string.aspx) 같은 웹 리소스를 사용할 수 있습니다. | 
| PUMP\$1NAME | VARCHAR(128) |  `CREATE PUMP`로 정의된 원본 펌프 | 

# 처리량 증가를 위해 애플리케이션 용량을 자동으로 확장 또는 축소
<a name="how-it-works-autoscaling"></a>

Amazon Kinesis Data Analytics는 대부분의 시나리오에서 소스 스트림의 데이터 처리량과 쿼리 복잡성을 수용할 수 있도록 애플리케이션을 탄력적으로 확장합니다. Kinesis Data Analytics는 용량을 Kinesis 처리 단위(KPU) 형식으로 제공합니다. 단일 KPU는 메모리(4GB)와 해당 컴퓨팅 및 네트워킹을 제공합니다.

귀하의 애플리케이션을 위한 KPU의 기본값 한도는 64입니다. 이 한도 증가 요청 지침은 **Amazon 서비스 한도**에서 [한도 상향 요청하기](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html)를 참조하십시오.

# 태그 지정 사용
<a name="how-tagging"></a>

이 섹션에서는 Kinesis Data Analytics 애플리케이션에 키-값 메타데이터를 추가하는 방법을 설명합니다. 이러한 태그는 다음과 같은 용도로 사용할 수 있습니다:
+ 개별 Kinesis Data Analytics 애플리케이션에 대한 청구 결정 자세한 내용을 알아보려면 *AWS 청구 및 비용 관리 가이드*의 [비용 할당 태그 사용](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html)을 참조하십시오.
+ 태그를 기반으로 애플리케이션 리소스에 대한 액세스 통제. 자세한 설명은 *사용자 가이드*의 [태그를 사용한 액세스 통제](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html)를 참조하십시오.
+ 사용자 정의 용도. 사용자 태그의 존재 유무를 기반으로 애플리케이션 기능을 정의할 수 있습니다.

태그 지정에 대한 다음 정보를 참조하십시오.
+ 애플리케이션 태그의 최대 수는 시스템 태그를 포함합니다. 사용자 정의 애플리케이션 태그의 최대 수는 50입니다.
+ 작업에 중복된 `Key` 값이 있는 태그 목록이 포함된 경우 서비스에서 `InvalidArgumentException`가 발생합니다.

**Topics**
+ [애플리케이션이 생성될 때 태그 추가](#how-tagging-create)
+ [기존 애플리케이션에 대한 태그 추가 또는 업데이트](#how-tagging-add)
+ [애플리케이션에 대한 태그 나열](#how-tagging-list)
+ [애플리케이션에서 태그 제거](#how-tagging-remove)

## 애플리케이션이 생성될 때 태그 추가
<a name="how-tagging-create"></a>

[CreateApplication](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/API_CreateApplication.html) 작업의 `tags` 파라미터를 사용하여 애플리케이션을 만들 때 태그를 추가합니다.

다음 예 요청은 `CreateApplication` 요청에 대한 `Tags` 노드를 보여줍니다.

```
"Tags": [ 
    { 
        "Key": "Key1",
        "Value": "Value1"
    },
    { 
        "Key": "Key2",
        "Value": "Value2"
    }
]
```

## 기존 애플리케이션에 대한 태그 추가 또는 업데이트
<a name="how-tagging-add"></a>

[TagResource](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/API_TagResource.html) 작업을 사용하여 애플리케이션에 태그를 추가합니다. [UpdateApplication](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/API_UpdateApplication.html) 작업을 사용해서는 애플리케이션에 태그를 추가할 수 없습니다.

기존 태그를 업데이트하려면, 기존 태그의 동일한 키로 태그를 추가합니다.

`TagResource` 작업을 위한 다음 예 요청은 새 태그를 추가하거나 기존 태그를 업데이트합니다.

```
{
   "ResourceARN": "string",
   "Tags": [ 
      { 
         "Key": "NewTagKey",
         "Value": "NewTagValue"
      },
      { 
         "Key": "ExistingKeyOfTagToUpdate",
         "Value": "NewValueForExistingTag"
      }
   ]
}
```

## 애플리케이션에 대한 태그 나열
<a name="how-tagging-list"></a>

기존 태그를 나열하려면 [ListTagsForResource](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/API_ListTagsForResource.html) 작업을 사용합니다.

`ListTagsForResource` 작업을 위한 다음 예 요청은 애플리케이션에 대한 태그를 나열합니다.

```
{
   "ResourceARN": "arn:aws:kinesisanalytics:us-west-2:012345678901:application/MyApplication"
}
```

## 애플리케이션에서 태그 제거
<a name="how-tagging-remove"></a>

애플리케이션에서 태그를 제거하려면 [UntagResource](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/API_UntagResource.html) 작업을 사용합니다.

`UntagResource` 작업을 위한 다음 요청 예는 애플리케이션에서 태그를 제거합니다.

```
{
   "ResourceARN": "arn:aws:kinesisanalytics:us-west-2:012345678901:application/MyApplication",
   "TagKeys": [ "KeyOfFirstTagToRemove", "KeyOfSecondTagToRemove" ]
}
```