# AWS Glue Spark 작업 모니터링
**Topics**
+ [AWS Glue Studio에서 사용할 수 있는 Spark 지표](#console-jobs-details-metrics-spark)
+ [Apache Spark 웹 UI를 사용하여 작업 모니터링](monitor-spark-ui.md)
+ [AWS Glue 작업 실행 인사이트를 사용한 모니터링](monitor-job-insights.md)
+ [Amazon CloudWatch를 사용한 모니터링](monitor-cloudwatch.md)
+ [작업 모니터링 및 디버깅](monitor-profile-glue-job-cloudwatch-metrics.md)
## AWS Glue Studio에서 사용할 수 있는 Spark 지표
[**지표(Metrics)**] 탭에는 작업이 실행되고 프로파일링이 활성화될 때 수집되는 지표가 표시됩니다. 다음 그래프가 Spark 작업에 표시됩니다.
+ ETL 데이터 이동
+ 메모리 프로필: 드라이버 및 실행기
다음 그래프를 표시하려면 **View additional metrics(추가 측정치 보기)**를 선택합니다.
+ ETL 데이터 이동
+ 메모리 프로필: 드라이버 및 실행기
+ 실행기 간의 데이터 셔플
+ CPU 부하: 드라이버 및 실행기
+ 작업 실행: 활성 실행기, 완료된 단계 및 최대 필요 실행기
지표를 수집하도록 작업이 구성된 경우 이러한 그래프에 대한 데이터가 CloudWatch 지표로 푸시됩니다. 지표를 설정하고 그래프를 해석하는 방법에 대한 자세한 내용은 [작업 모니터링 및 디버깅](monitor-profile-glue-job-cloudwatch-metrics.md) 섹션을 참조하세요.
**Example ETL 데이터 이동 그래프**
ETL 데이터 이동 그래프는 다음 측정치를 표시합니다.
+ 모든 실행기가 Amazon S3에서 읽은 바이트 수 - [`glue.ALL.s3.filesystem.read_bytes`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes)
+ 모든 실행기가 Amazon S3에 쓴 바이트 수 - [`glue.ALL.s3.filesystem.write_bytes`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes)
![\[AWS Glue 콘솔의 [지표(Metrics)] 탭의 ETL 데이터 이동 그래프.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/job_detailed_etl.png)
**Example 메모리 프로필 그래프**
메모리 프로필 그래프는 다음 측정치를 표시합니다.
+ 드라이버에 의해 이 드라이버용 JVM 힙에 사용되는 메모리 부분(규모: 0\$11), *executorId*에 의해 식별되는 실행기, 또는 모든 실행기 -
+ [`glue.driver.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.jvm.heap.usage)
+ [`glue.executorId.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.usage)
+ [`glue.ALL.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage)
![\[AWS Glue 콘솔의 [지표(Metrics)] 탭의 메모리 프로파일 그래프.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/job_detailed_mem.png)
**Example 실행기 간의 데이터 셔플 그래프**
실행기 간의 데이터 셔플 그래프는 다음 측정치를 표시합니다.
+ 서로 간에 데이터를 셔플링하기 위해 모든 실행기가 읽은 바이트 수 - [`glue.driver.aggregate.shuffleLocalBytesRead`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleLocalBytesRead)
+ 서로 간에 데이터를 셔플링하기 위해 모든 실행기가 쓴 바이트 수 - [`glue.driver.aggregate.shuffleBytesWritten`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleBytesWritten)
![\[AWS Glue 콘솔의 [지표(Metrics)] 탭의 실행기 간의 데이터 셔플 그래프.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/job_detailed_data.png)
**Example CPU 부하 그래프**
CPU 부하 그래프는 다음 측정치를 표시합니다.
+ 드라이버, *executorId*로 식별되는 실행기 또는 모든 실행기가 사용한 CPU 시스템 로드 부분(규모: 0\$11).
+ [`glue.driver.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.system.cpuSystemLoad)
+ [`glue.executorId.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.system.cpuSystemLoad)
+ [`glue.ALL.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.system.cpuSystemLoad)
![\[AWS Glue 콘솔의 [지표(Metrics)] 탭의 CPU 로드 그래프.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/job_detailed_cpu.png)
**Example 작업 실행 그래프**
작업 실행 그래프는 다음 측정치를 표시합니다.
+ 능동적으로 실행 중인 실행기 수 - [`glue.driver.ExecutorAllocationManager.executors.numberAllExecutors`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors)
+ 완료된 단계 수 - [`glue.aggregate.numCompletedStages`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.numCompletedStages)
+ 최대 필요 실행기 수 - [`glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors)
![\[AWS Glue 콘솔의 [지표(Metrics)] 탭의 작업 실행 그래프.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/job_detailed_exec.png)
# Apache Spark 웹 UI를 사용하여 작업 모니터링
Apache Spark 웹 UI를 사용하여 AWS Glue 작업 시스템에서 실행 중인 AWS Glue ETL 작업과 AWS Glue 개발 엔드포인트에서 실행 중인 Spark 애플리케이션을 모니터링하고 디버그할 수 있습니다. Spark UI를 사용하면 각 작업에 대해 다음을 확인할 수 있습니다.
+ 각 Spark 단계의 이벤트 타임라인
+ 작업의 방향성 비순환 그래프(DAG)
+ SparkSQL 쿼리에 대한 물리적, 논리적 계획
+ 각 작업에 대한 기본 Spark 환경 변수
Spark 웹 UI 사용에 대한 자세한 내용은 Spark 설명서의 [웹 UI](https://spark.apache.org/docs/3.3.0/web-ui.html)를 참조하십시오. Spark UI 결과를 해석하여 작업 성능을 개선하는 방법에 대한 지침은 AWS 권장 가이드의 [Apache Spark 용 AWS Glue 작업 성능 조정 모범 사례](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/introduction.html)를 참조하세요.
AWS Glue 콘솔에서 Spark UI를 확인할 수 있습니다. 이 기능은 AWS Glue 작업이 AWS Glue 3.0 이상 버전에서 실행되고 새로운 작업의 기본값인 레거시 형식이 아닌 표준 형식으로 생성된 로그가 있는 경우 사용할 수 있습니다. 로그 파일이 0.5GB를 초과하는 경우 AWS Glue 4.0 이상 버전에서 작업 실행에 대한 로그 롤링 지원을 활성화하여 로그 아카이브, 분석 및 문제 해결을 간소화할 수 있습니다.
AWS Glue 콘솔 또는 AWS Command Line Interface(AWS CLI)를 사용하여 Spark UI를 활성화할 수 있습니다. Spark UI를 사용하면 AWS Glue 개발 엔드포인트의 AWS Glue ETL 작업과 Spark 애플리케이션은 Amazon Simple Storage Service(Amazon S3)에서 지정한 위치에 Spark 이벤트 로그를 백업할 수 있습니다. 작업이 작동 중일 때와 완료된 후 모두 실시간으로 Amazon S3에서 Spark UI를 통해 백업된 이벤트 로그를 사용할 수 있습니다. 로그가 Amazon S3에 남아 있는 동안 AWS Glue 콘솔의 Spark UI에서 해당 로그를 볼 수 있습니다.
## 권한
AWS Glue 콘솔에서 Spark UI를 사용하려면 `UseGlueStudio`를 사용하거나 모든 개별 서비스 API를 추가할 수 있습니다. Spark UI를 완전히 사용하려면 모든 API가 필요하지만, 사용자는 세분화된 액세스를 위해 IAM 권한에 해당 서비스 API를 추가하여 SparkUI 기능에 액세스할 수 있습니다.
`RequestLogParsing`은 로그 구문 분석을 수행하므로 가장 중요합니다. 나머지 API는 각각의 구문 분석된 데이터를 읽는 데 사용됩니다. 예를 들어 `GetStages`는 Spark 작업의 모든 단계에 대한 데이터에 액세스할 수 있습니다.
`UseGlueStudio`에 매핑된 Spark UI 서비스 API 목록은 아래 샘플 정책에 나와 있습니다. 아래 정책은 Spark UI 기능만 사용할 수 있는 액세스 권한을 제공합니다. Amazon S3 및 IAM과 같은 권한을 더 추가하려면 [AWS Glue Studio에 대한 사용자 지정 IAM 정책 만들기](https://docs.aws.amazon.com/glue/latest/dg/getting-started-min-privs.html#getting-started-all-gs-privs.html)를 참조하세요.
`UseGlueStudio`에 매핑된 Spark UI 서비스 API 목록은 아래 샘플 정책에 나와 있습니다. Spark UI 서비스 API를 사용할 때는 다음 네임스페이스를 사용하세요. `glue:`
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowGlueStudioSparkUI",
"Effect": "Allow",
"Action": [
"glue:RequestLogParsing",
"glue:GetLogParsingStatus",
"glue:GetEnvironment",
"glue:GetJobs",
"glue:GetJob",
"glue:GetStage",
"glue:GetStages",
"glue:GetStageFiles",
"glue:BatchGetStageFiles",
"glue:GetStageAttempt",
"glue:GetStageAttemptTaskList",
"glue:GetStageAttemptTaskSummary",
"glue:GetExecutors",
"glue:GetExecutorsThreads",
"glue:GetStorage",
"glue:GetStorageUnit",
"glue:GetQueries",
"glue:GetQuery"
],
"Resource": [
"*"
]
}
]
}
```
------
## 제한 사항
+ AWS Glue 콘솔의 Spark UI는 레거시 로그 형식이므로 2023년 11월 20일 이전에 발생한 작업 실행에는 사용할 수 없습니다.
+ AWS Glue 콘솔의 Spark UI는 스트리밍 작업에서 기본적으로 생성되는 로그와 같이 AWS Glue 4.0에 대한 로그 롤링을 지원합니다. 생성된 모든 롤링된 로그 이벤트 파일의 최대 합계는 2GB입니다. 롤링된 로그를 지원하지 않는 AWS Glue 작업의 경우 SparkUI에 대해 지원되는 최대 로그 이벤트 파일 크기는 0.5GB입니다.
+ VPC에서만 액세스할 수 있는 Amazon S3 버킷에 저장된 Spark 이벤트 로그에 대해서는 서버리스 Spark UI를 사용할 수 없습니다.
## 예: Apache Spark 웹 UI
이 예제에서는 Spark UI를 사용하여 작업 성과를 이해하는 방법을 보여줍니다. 스크린샷은 자체 관리형 Spark 기록 서버에서 제공하는 Spark 웹 UI를 보여줍니다. AWS Glue 콘솔의 Spark UI에서도 비슷한 화면을 볼 수 있습니다. Spark 웹 UI 사용에 대한 자세한 내용은 Spark 설명서의 [웹 UI](https://spark.apache.org/docs/3.3.0/web-ui.html)를 참조하십시오.
다음은 Spark 애플리케이션에서 두 데이터 소스의 데이터를 읽고 조인 변환을 수행하여 Parquet 형식으로 Amazon S3에 쓰는 예제입니다.
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from pyspark.sql.functions import count, when, expr, col, sum, isnull
from pyspark.sql.functions import countDistinct
from awsglue.dynamicframe import DynamicFrame
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'])
df_persons = spark.read.json("s3://awsglue-datasets/examples/us-legislators/all/persons.json")
df_memberships = spark.read.json("s3://awsglue-datasets/examples/us-legislators/all/memberships.json")
df_joined = df_persons.join(df_memberships, df_persons.id == df_memberships.person_id, 'fullouter')
df_joined.write.parquet("s3://aws-glue-demo-sparkui/output/")
job.commit()
```
다음 DAG 시각화는 이 Spark 작업의 여러 단계를 보여줍니다.
![\[작업 0의 완료된 2단계를 보여주는 Spark UI의 스크린샷.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/spark-ui1.png)
작업에 대한 다음 이벤트 타임라인은 다양한 Spark 실행기의 시작, 실행 및 종료를 보여줍니다.
![\[다양 Spark 실행기의 완료, 실패 및 활성 단계를 보여주는 Spark UI의 스크린샷.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/spark-ui2.png)
다음 화면은 SparkSQL 쿼리 계획의 세부 정보를 보여줍니다.
+ 구문 분석된 논리적 계획
+ 분석된 논리적 계획
+ 최적화된 논리적 계획
+ 실행할 물리적 계획
![\[SparkSQL 쿼리 계획 : 구문 분석, 분석 및 최적화된 논리적 계획과 실행할 물리적 계획.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/spark-ui3.png)
**Topics**
+ [권한](#monitor-spark-ui-limitations-permissions)
+ [제한 사항](#monitor-spark-ui-limitations)
+ [예: Apache Spark 웹 UI](#monitor-spark-ui-limitations-example)
+ [AWS Glue 작업을 위한 Apache Spark 웹 UI 사용 설정](monitor-spark-ui-jobs.md)
+ [Spark 기록 서버 시작](monitor-spark-ui-history.md)
# AWS Glue 작업을 위한 Apache Spark 웹 UI 사용 설정
Apache Spark 웹 UI를 사용하여 AWS Glue 작업 시스템에서 실행 중인 AWS Glue ETL 작업을 모니터링하고 디버그할 수 있습니다. AWS Glue 콘솔 또는 AWS Command Line Interface(AWS CLI)를 사용하여 Spark UI를 구성할 수 있습니다.
30초마다 AWS Glue가 Spark 이벤트 로그를 지정한 Amazon S3 경로로 백업합니다.
**Topics**
+ [Spark UI 구성(콘솔)](#monitor-spark-ui-jobs-console)
+ [Spark UI 구성(AWS CLI)](#monitor-spark-ui-jobs-cli)
+ [노트북을 사용하여 세션에 대한 Spark UI 구성](#monitor-spark-ui-sessions)
+ [롤링 로그 활성화](#monitor-spark-ui-rolling-logs)
## Spark UI 구성(콘솔)
AWS Management Console을 사용하여 Spark UI를 구성하려면 다음 단계를 따르세요. AWS Glue 작업을 생성할 때 Spark UI는 기본으로 활성화됩니다.
**작업을 생성하거나 편집할 때 Spark UI를 켜려면**
1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)에서 AWS Glue 콘솔을 엽니다.
1. 탐색 창에서, **작업**을 선택합니다.
1. **작업 추가**를 선택하거나 기존 작업을 선택합니다.
1. **작업 세부 정보**에서 **고급 속성**을 엽니다.
1. **Spark UI** 탭에서 **Amazon S3에 Spark UI 로그 쓰기**를 선택합니다.
1. 작업의 Spark 이벤트 로그를 저장할 Amazon S3 경로를 지정합니다. 작업에서 보안 구성을 사용하는 경우 암호화는 Spark UI 로그 파일에도 적용됩니다. 자세한 내용은 [AWS Glue에서 작성한 데이터 암호화](encryption-security-configuration.md) 섹션을 참조하세요.
1. **Spark UI 로깅 및 모니터링** 구성에서:
+ AWS Glue 콘솔에서 볼 로그를 생성하는 경우 **표준**을 선택합니다.
+ Spark 기록 서버에서 볼 로그를 생성하는 경우 **레거시**를 선택합니다.
+ 둘 다 생성하도록 선택할 수도 있습니다.
## Spark UI 구성(AWS CLI)
AWS CLI를 사용하여 AWS Glue 콘솔에서 Spark UI로 볼 로그를 생성하려면 다음 작업 파라미터를 AWS Glue 작업에 전달합니다. 자세한 내용은 [AWS Glue 작업에서 작업 파라미터 사용](aws-glue-programming-etl-glue-arguments.md) 섹션을 참조하세요.
```
'--enable-spark-ui': 'true',
'--spark-event-logs-path': 's3://s3-event-log-path'
```
기존 위치에 로그를 배포하려면 `--enable-spark-ui-legacy-path` 파라미터를 `"true"`로 설정합니다. 두 가지 형식으로 로그를 생성하지 않으려면 `--enable-spark-ui` 매개변수를 제거하십시오.
## 노트북을 사용하여 세션에 대한 Spark UI 구성
**주의**
AWS Glue 대화형 세션은 현재 콘솔의 Spark UI를 지원하지 않습니다. Spark 기록 서버를 구성합니다.
AWS Glue 노트북을 사용하는 경우 세션을 시작하기 전에 SparkUI 구성을 설정합니다. 이렇게 하려면 `%%configure` 셀 매직을 사용합니다.
```
%%configure { “--enable-spark-ui”: “true”, “--spark-event-logs-path”: “s3://path” }
```
## 롤링 로그 활성화
AWS Glue 작업에 SparkUI 및 로그 이벤트 파일 롤링을 활성화하면 다음과 같은 몇 가지 이점이 있습니다.
+ 로그 이벤트 파일 롤링 - 로그 이벤트 파일 롤링이 활성화된 상태에서 AWS Glue는 작업 실행의 각 단계에 대해 별도의 로그 파일을 생성하므로 특정 단계 또는 변환과 관련된 문제를 쉽게 식별하고 해결할 수 있습니다.
+ 더 나은 로그 관리 - 로그 이벤트 파일을 롤링하면 로그 파일을 더 효율적으로 관리하는 데 도움이 됩니다. 잠재적으로 큰 단일 로그 파일을 보유하는 대신, 작업 실행 단계에 따라 더 작고 관리 가능한 파일로 로그가 분할됩니다. 이렇게 하면 로그 아카이빙, 분석 및 문제 해결을 간소화할 수 있습니다.
+ 내결함성 개선 - AWS Glue 작업이 실패하거나 중단되는 경우 로그 이벤트 파일 롤링은 마지막 성공 단계에 대한 중요한 정보를 제공할 수 있으므로 처음부터 시작하는 대신 해당 시점부터 작업을 더 쉽게 재개할 수 있습니다.
+ 비용 최적화 - 로그 이벤트 파일 롤링을 활성화하면 로그 파일과 관련된 스토리지 비용을 절감할 수 있습니다. 잠재적으로 큰 단일 로그 파일을 저장하는 대신 더 작고 관리 가능한 로그 파일을 저장합니다. 특히 장기 실행 또는 복잡한 작업의 경우 더 비용 효율적일 수 있습니다.
새 환경에서 사용자는 다음을 통해 로그 롤링을 명시적으로 활성화할 수 있습니다.
```
'—conf': 'spark.eventLog.rolling.enabled=true'
```
or
```
'—conf': 'spark.eventLog.rolling.enabled=true —conf
spark.eventLog.rolling.maxFileSize=128m'
```
로그 롤링이 활성화된 경우 `spark.eventLog.rolling.maxFileSize`에서는 롤오버하기 전 이벤트 로그 파일의 최대 크기를 지정합니다. 지정하지 않으면 이 선택적 파라미터의 기본값은 128MB입니다. 최소 10MB입니다.
생성된 모든 롤링된 로그 이벤트 파일의 최대 합계는 2GB입니다. 로그 롤링을 지원하지 않는 AWS Glue 작업의 경우 SparkUI에 대해 지원되는 최대 로그 이벤트 파일 크기는 0.5GB입니다.
추가 구성을 전달하여 스트리밍 작업에 대한 롤링 로그를 끌 수 있습니다. 로그 파일이 매우 크면 유지 관리 비용이 많이 들 수 있습니다.
롤링 로그를 끄려면 다음 구성을 제공하십시오.
```
'--spark-ui-event-logs-path': 'true',
'--conf': 'spark.eventLog.rolling.enabled=false'
```
# Spark 기록 서버 시작
Spark 기록 서버를 사용하여 자체 인프라에서 Spark 로그를 시각화할 수 있습니다. AWS Glue 콘솔에서는 AWS Glue 4.0 이상 버전의 AWS Glue 작업 실행에 대한 동일한 시각화를 레거시 형식이 아닌 표준 형식으로 생성된 로그와 함께 볼 수 있습니다. 자세한 내용은 [Apache Spark 웹 UI를 사용하여 작업 모니터링](monitor-spark-ui.md) 섹션을 참조하세요.
EC2 인스턴스에서 서버를 호스팅하는 AWS CloudFormation 템플릿을 사용하여 Spark 기록 서버를 시작하거나 Docker를 사용하여 로컬로 시작할 수 있습니다.
**Topics**
+ [AWS CloudFormation을 사용하여 Spark 기록 서버 시작 및 Spark UI 보기](#monitor-spark-ui-history-cfn)
+ [Docker를 사용하여 Spark 기록 서버 시작 및 Spark UI 보기](#monitor-spark-ui-history-local)
## AWS CloudFormation을 사용하여 Spark 기록 서버 시작 및 Spark UI 보기
AWS CloudFormation 템플릿을 사용하여 Apache Spark 기록 서버를 시작하고 Spark 웹 UI를 볼 수 있습니다. 이 템플릿은 요구 사항에 맞게 수정해야 하는 샘플입니다.
**CloudFormation을 사용하여 Spark History Server를 시작하고 Spark UI를 보려면**
1. 다음 표에서 **스택 시작** 버튼 중 하나를 선택하십시오. 그러면 CloudFormation 콘솔에서 스택이 시작됩니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitor-spark-ui-history.html)
1. **Specify template(템플릿 지정)** 페이지에서 **다음**을 선택합니다.
1. **스택 세부 정보 지정** 페이지에서 **스택 이름**을 입력합니다. **파라미터(Parameters)** 아래에 추가 정보를 입력합니다.
1.
**Spark UI 구성**
다음 정보를 제공합니다.
+ [**IP 주소 범위(IP address range)**] - Spark UI를 보는 데 사용할 수 있는 IP 주소 범위입니다. 특정 IP 주소 범위의 액세스를 제한하려면 사용자 지정 값을 사용해야 합니다.
+ [**기록 서버 포트(History server port)**] - Spark UI의 포트입니다. 기본값을 사용할 수 있습니다.
+ [**이벤트 로그 디렉터리(Event log directory)**] - AWS Glue 작업 또는 개발 엔드포인트에서 Spark 이벤트 로그가 저장되는 위치를 선택합니다. 이벤트 로그 경로 체계에 **s3a://**를 사용해야 합니다.
+ [**Spark 패키지 위치(Spark package location)**] - 기본값을 사용할 수 있습니다.
+ [**키 스토어 경로(Keystore path)**] - HTTPS의 SSL/TLS 키 스토어 경로입니다. 사용자 지정 키 스토어 파일을 사용하려면 여기에서 S3 경로 `s3://path_to_your_keystore_file`을 지정하면 됩니다. 이 파라미터를 비워두면 자체 서명된 인증서 기반 키 스토어가 생성되어 사용됩니다.
+ **키 스토어 암호(Keystore password)** - HTTPS에 대한 SSL/TLS 키 스토어 암호를 입력합니다.
1.
**EC2 인스턴스 구성**
다음 정보를 제공합니다.
+ [**인스턴스 유형(Instance type)**] - Spark 기록 서버를 호스팅하는 Amazon EC2 인스턴스 유형입니다. 이 템플릿은 계정에서 Amazon EC2 인스턴스를 시작하므로 계정에 별도로 Amazon EC2 비용이 청구됩니다.
+ [**최신 AMI ID(Latest AMI ID)**] - Spark 기록 서버 인스턴스에 대한 Amazon Linux 2의 AMI ID입니다. 기본값을 사용할 수 있습니다.
+ [**VPC ID**] - Spark 기록 서버 인스턴스의 Virtual Private Cloud(VPC) ID입니다. 계정에 제공된 모든 VPC를 사용할 수 있습니다. [기본 네트워크 ACL](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html#default-network-acl)과 함께 기본 VPC를 사용하지 않는 것이 좋습니다. 자세한 내용은 *Amazon VPC 사용 설명서*의 [기본 VPC 및 서브넷](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html)과 [VPC 생성](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#Create-VPC)을 참조하세요.
+ [**서브넷 ID(Subnet ID)**] - Spark 기록 서버 인스턴스의 ID입니다. VPC의 모든 서브넷을 사용할 수 있습니다. 클라이언트에서 서브넷으로 네트워크에 도달할 수 있어야 합니다. 인터넷을 통해 액세스하려면 라우팅 테이블에 인터넷 게이트웨이가 있는 퍼블릭 서브넷을 사용해야 합니다.
1. **다음**을 선택합니다.
1. **스택 옵션 구성(Configure stack options)** 페이지에서 현재 사용자 자격 증명을 사용하여 CloudFormation이 스택의 리소스를 생성, 수정 또는 삭제하는 방식을 확인하려면 **다음(Next)**을 선택합니다. **권한** 섹션에서 현재 사용자 권한 대신 사용할 역할을 지정하고 **다음**을 선택할 수도 있습니다.
1. **검토** 페이지에서 설정을 확인합니다.
**CloudFormation에서 IAM 리소스를 생성할 수 있음을 승인합니다**를 선택하고 **스택 생성**을 선택합니다.
1. 스택이 생성되기를 기다립니다.
1. **출력** 탭을 클릭합니다.
1. 퍼블릭 서브넷을 사용하는 경우 **SparkUiPublicUrl**의 URL을 복사하십시오.
1. 프라이빗 서브넷을 사용하는 경우 **SparkUiPrivateUrl**의 URL을 복사하십시오.
1. 웹 브라우저를 열고 URL에 붙여 넣습니다. 지정된 포트에서 HTTPS를 사용하여 서버에 액세스할 수 있습니다. 브라우저가 서버 인증을 인식하지 못할 수 있어 서버 보호를 재정의하여 실행해야 합니다.
## Docker를 사용하여 Spark 기록 서버 시작 및 Spark UI 보기
로컬 액세스를 선호하는 경우(Apache Spark 기록 서버에 EC2 인스턴스가 없는 경우) Docker를 사용하여 Apache Spark 기록 서버를 시작하고 Spark UI를 로컬로 볼 수도 있습니다. 이 Dockerfile은 요구 사항에 맞게 수정해야 하는 샘플입니다.
**사전 조건**
노트북에 도커를 설치하는 방법에 대한 자세한 내용은 [Docker Engine community](https://docs.docker.com/install/)를 참조하십시오.
**Docker를 사용하여 로컬로 Spark History Server를 시작하고 Spark UI를 보려면**
1. GitHub에서 파일을 다운로드하십시오.
[ AWS Glue 코드 샘플](https://github.com/aws-samples/aws-glue-samples/tree/master/utilities/Spark_UI/)에서 Dockerfile과 `pom.xml`을 다운로드합니다.
1. AWS에 액세스하는 데 사용자 자격 증명을 사용할지 또는 페더레이션 사용자 자격 증명을 사용할지 결정합니다.
+ 현재 사용자 자격 증명을 사용하여 AWS에 액세스하려면 `docker run` 명령의 ` AWS_ACCESS_KEY_ID`와 `AWS_SECRET_ACCESS_KEY`에 사용할 값을 가져옵니다. 자세한 내용은 * IAM 사용 설명서*의 [IAM 사용자의 액세스 키 관리](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)를 참조하세요.
+ SAML 2.0 페더레이션 사용자를 사용하여 AWS에 액세스하려면 ` AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` 및 ` AWS_SESSION_TOKEN`의 값을 가져옵니다. 자세한 내용은 [임시 보안 자격 증명 요청](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)을 참조하세요.
1. `docker run` 명령에서 사용할 이벤트 로그 디렉터리의 위치를 결정합니다.
1. 이름 ` glue/sparkui` 및 태그 `latest`를 사용하여 로컬 디렉터리의 파일을 통해 Docker 이미지를 구축합니다.
```
$ docker build -t glue/sparkui:latest .
```
1. Docker 컨테이너를 생성하고 시작합니다.
다음 명령에서는 이전 2단계와 3단계에서 얻은 값을 사용합니다.
1. 사용자 자격 증명을 사용하여 Docker 컨테이너를 생성하려면 다음과 비슷한 명령을 사용합니다.
```
docker run -itd -e SPARK_HISTORY_OPTS="$SPARK_HISTORY_OPTS -Dspark.history.fs.logDirectory=s3a://path_to_eventlog
-Dspark.hadoop.fs.s3a.access.key=AWS_ACCESS_KEY_ID -Dspark.hadoop.fs.s3a.secret.key=AWS_SECRET_ACCESS_KEY"
-p 18080:18080 glue/sparkui:latest "/opt/spark/bin/spark-class org.apache.spark.deploy.history.HistoryServer"
```
1. 임시 자격 증명을 사용하여 Docker 컨테이너를 생성하려면 ` org.apache.hadoop.fs.s3a.TemporaryAWSCredentialsProvider`를 공급자로 사용하고 2단계에서 얻은 자격 증명 값을 제공합니다. 자세한 내용은 *Hadoop: Amazon Web Services와 통합* 설명서의 [TemporaryAWSCredentialsProvider로 세션 자격 증명 사용](https://hadoop.apache.org/docs/stable/hadoop-aws/tools/hadoop-aws/index.html#Using_Session_Credentials_with_TemporaryAWSCredentialsProvider)을 참조하세요.
```
docker run -itd -e SPARK_HISTORY_OPTS="$SPARK_HISTORY_OPTS -Dspark.history.fs.logDirectory=s3a://path_to_eventlog
-Dspark.hadoop.fs.s3a.access.key=AWS_ACCESS_KEY_ID -Dspark.hadoop.fs.s3a.secret.key=AWS_SECRET_ACCESS_KEY
-Dspark.hadoop.fs.s3a.session.token=AWS_SESSION_TOKEN
-Dspark.hadoop.fs.s3a.aws.credentials.provider=org.apache.hadoop.fs.s3a.TemporaryAWSCredentialsProvider"
-p 18080:18080 glue/sparkui:latest "/opt/spark/bin/spark-class org.apache.spark.deploy.history.HistoryServer"
```
**참고**
이러한 구성 파라미터는 [ Hadoop-AWS 모듈](https://hadoop.apache.org/docs/stable/hadoop-aws/tools/hadoop-aws/index.html)에서 나옵니다. 사용 사례를 바탕으로 특정 구성을 추가해야 할 수 있습니다. 예를 들어, 격리된 리전에 있는 사용자는 ` spark.hadoop.fs.s3a.endpoint`를 구성해야 합니다.
1. 브라우저에서 `http://localhost:18080`을 열어 로컬로 Spark UI를 봅니다.
# AWS Glue 작업 실행 인사이트를 사용한 모니터링
AWS Glue 작업 실행 인사이트는 작업 디버깅 및 AWS Glue 작업의 최적화를 간소화해 주는 AWS Glue의 기능입니다. AWS Glue는 AWS Glue 작업을 모니터링할 수 있도록 [Spark UI](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui.html)와 [CloudWatch 로그 및 지표](https://docs.aws.amazon.com/glue/latest/dg/monitor-cloudwatch.html)를 제공합니다. 이 기능을 사용하면 AWS Glue 작업의 실행에 대해 다음과 같은 정보를 확인할 수 있습니다.
+ 실패가 발생한 AWS Glue 작업 스크립트의 행 번호
+ 작업 실패가 발생하기 직전에 Spark 쿼리 계획에서 마지막으로 실행된 Spark 작업
+ 실패와 관련된 Spark 예외 이벤트의 시간순으로 된 로그 스트림
+ 근본 원인 분석 및 문제 해결을 위한 권장 작업(예: 스크립트 튜닝)
+ 일반적인 Spark 이벤트(Spark 작업과 관련된 로그 메시지)와 근본 원인 해결을 위한 권장 작업
이러한 인사이트는 AWS Glue 작업의 CloudWatch 로그에 추가된 2가지 로그 스트림을 사용하여 확인할 수 있습니다.
## 요구 사항
AWS Glue 작업 실행 인사이트 기능은 AWS Glue 버전 2.0 이상에서 사용할 수 있습니다. 기존 작업의 [마이그레이션 가이드](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-30.html)에 따라 이전 버전의 AWS Glue에서 업그레이드할 수 있습니다.
## AWS Glue ETL 작업에 대해 작업 실행 인사이트 활성화
작업 실행 인사이트는 AWS Glue Studio 또는 CLI를 통해 활성화할 수 있습니다.
### AWS Glue Studio
AWS Glue Studio를 통해 작업을 생성할 때는 **Job Details**(작업 세부 정보) 탭에서 작업 실행 인사이트를 활성화 또는 비활성화할 수 있습니다. **작업 인사이트 생성** 상자가 선택되어 있는지 확인합니다.
![\[AWS Glue Studio에서 작업 실행 인사이트 활성화.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-job-run-insights-1.png)
### 명령줄
CLI를 통해 작업을 생성할 때는 새로 추가된 단일 [작업 파라미터](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html) `--enable-job-insights = true`를 사용하여 작업 실행을 시작할 수 있습니다.
기본적으로 작업 실행 인사이트 로그 스트림은 [AWS Glue 연속 로깅](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging.html)에서 사용되는 것과 동일한 기본 로그 그룹인 `/aws-glue/jobs/logs-v2/` 아래에 생성됩니다. 연속 로깅에 사용된 것과 동일한 인수 세트를 사용하여 사용자 지정 로그 그룹 이름, 로그 필터 및 로그 그룹 구성을 설정할 수 있습니다. 자세한 내용은 [Enabling Continuous Logging for AWS Glue Jobs](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging-enable.html)(작업에 대해 연속 로깅 활성화)를 참조하세요.
## CloudWatch에서 작업 실행 인사이트 로그 스트림에 액세스
작업 실행 인사이트 기능이 활성화된 상태에서 작업 실행이 실패할 경우 2가지 로그 스트림이 생성될 수 있습니다. 작업이 성공적으로 완료되면 2가지 스트림 모두 생성되지 않습니다.
1. *예외 분석 로그 스트림*: `-job-insights-rca-driver`. 이 스트림은 다음과 같은 정보를 제공합니다.
+ 실패의 원인이 된 AWS Glue 작업 스크립트의 행 번호.
+ Spark 쿼리 계획(DAG)에서 마지막으로 실행된 Spark 작업.
+ Spark 드라이버 및 실행기의 예외와 관련 있는 시간순 이벤트. 필요한 경우 전체 오류 메시지, 실패한 Spark 작업과 해당 실행기 ID(특정 실행기의 로그 스트림을 살펴보는 데 사용)와 같은 세부 정보를 볼 수 있습니다.
1. *규칙 기반 인사이트 스트림*:
+ 근본 원인 분석 및 오류 수정을 위한 권장 사항(예: 특정 작업 파라미터를 사용하여 성능 최적화).
+ 근본 원인 분석의 기반이 되는 관련 있는 Spark 이벤트 및 권장 작업.
**참고**
첫 번째 스트림은 실패한 작업 실행의 예외 Spark 이벤트가 있는 경우에만 생성되고, 두 번째 스트림은 실패한 작업 실행에 대한 인사이트가 있는 경우에만 생성됩니다. 예를 들어, 작업이 성공적으로 완료되었다면 2가지 스트림 모두 생성되지 않고, 작업이 실패했으나 실패 시나리오와 일치하는 서비스 정의 규칙이 없는 경우에는 첫 번째 스트림만 생성됩니다.
작업이 AWS Glue Studio에서 생성되었다면 Job Run Details(작업 실행 세부 정보) 탭 아래의 Job run insights(작업 실행 인사이트)에 위 스트림의 링크가 각각 ‘Concise and consolidated error logs’(간결하고 통합된 오류 로그) 및 ‘Error analysis and guidance’(오류 분석 및 가이드)로 표시됩니다.
![\[로그 스트림 링크가 표시된 Job Run Details(작업 실행 세부 정보) 페이지.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-job-run-insights-2.png)
## AWS Glue 작업 실행 인사이트의 예
이 섹션에서는 작업 실행 인사이트 기능을 사용하여 실패한 작업의 문제를 해결하는 방법을 예를 통해 살펴봅니다. 이 예제에서는 사용자가 AWS Glue 작업에서 데이터에 대한 기계 학습 모델을 분석 및 빌드하는 데 필요한 모듈(tensorflow)을 가져오지 않았습니다.
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from pyspark.sql.types import *
from pyspark.sql.functions import udf,col
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
data_set_1 = [1, 2, 3, 4]
data_set_2 = [5, 6, 7, 8]
scoresDf = spark.createDataFrame(data_set_1, IntegerType())
def data_multiplier_func(factor, data_vector):
import tensorflow as tf
with tf.compat.v1.Session() as sess:
x1 = tf.constant(factor)
x2 = tf.constant(data_vector)
result = tf.multiply(x1, x2)
return sess.run(result).tolist()
data_multiplier_udf = udf(lambda x:data_multiplier_func(x, data_set_2), ArrayType(IntegerType(),False))
factoredDf = scoresDf.withColumn("final_value", data_multiplier_udf(col("value")))
print(factoredDf.collect())
```
작업 실행 인사이트 기능이 없다면 작업이 실패해도 Spark에 의해 발생된 다음과 같은 메시지만 볼 수 있습니다.
`An error occurred while calling o111.collectToPython. Traceback (most recent call last):`
이 메시지는 명확하지 않으므로 디버깅에 큰 도움이 되지 않습니다. 작업 실행 인사이트 기능은 다음과 같은 2가지 CloudWatch 로그 스트림을 통해 추가 인사이트를 제공합니다.
1. `job-insights-rca-driver` 로그 스트림:
+ *예외 이벤트*: 이 로그 스트림에서 Spark 드라이버 및 여러 분산 작업자로부터 수집된, 실패와 관련 있는 Spark 예외 이벤트를 볼 수 있습니다. 이러한 이벤트를 검토하면 여러 AWS Glue 작업자에 분산된 Spark 작업, 실행기 및 단계에서 결함 있는 코드가 실행되는 과정에서 예외가 전파된 상황을 시간순으로 살펴볼 수 있습니다.
+ *행 번호*: 이 로그 스트림에서 누락된 Python 모듈 가져오기를 호출하여 실패의 원인이 된 것이 21번 행이고 스크립트에서 마지막으로 실행된 Spark 작업 `collect()`의 호출은 24번 행인 것을 알 수 있습니다.
![\[job-insights-rca-driver 로그 스트림.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-job-run-insights-3.png)
1. `job-insights-rule-driver` 로그 스트림:
+ *근본 원인 분석 및 권장 사항*: 스크립트에서 결함이 되는 행 번호와 마지막으로 실행된 행 번호 외에도 이 로그 스트림에서는 근본 원인 분석과 권장 사항(AWS Glue 작업에서 추가 Python 모듈을 사용하려면 AWS Glue 문서에 따라 필요한 작업 파라미터를 설정할 것)을 볼 수 있습니다.
+ *기본 이벤트*: 이 로그 스트림에서는 근본 원인을 유추할 수 있도록, 서비스 정의 규칙을 사용하여 평가된 Spark 예외 이벤트를 볼 수 있으며 권장 사항을 제공합니다.
![\[job-insights-rule-driver 로그 스트림.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-job-run-insights-4.png)
# Amazon CloudWatch를 사용한 모니터링
AWS Glue에서 원시 데이터를 수집하여 읽기 가능하며 실시간에 가까운 지표로 처리하는 Amazon CloudWatch를 통해 AWS Glue를 모니터링할 수 있습니다. 이러한 통계는 2주간 기록되므로 기록 정보에 액세스하여 웹 애플리케이션 또는 서비스가 어떻게 실행되고 있는지 전체적으로 더 잘 파악할 수 있습니다. 기본적으로 AWS Glue 지표 데이터는 CloudWatch에 자동으로 전송됩니다. 자세한 내용은 [AWS Glue 지표](monitoring-awsglue-with-cloudwatch-metrics.md#awsglue-metrics) 및 *Amazon CloudWatch User Guide*의 [What Is Amazon CloudWatch?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/WhatIsCloudWatch.html)를 참조하세요.
**연속 로깅**
AWS Glue에서도 AWS Glue 작업에 대한 실시간 지속 로깅을 지원합니다. 작업에 대한 지속 로깅이 활성화되어 있으면 AWS Glue 콘솔 또는 CloudWatch 콘솔 대시보드에서 실시간 로그를 볼 수 있습니다. 자세한 내용은 [AWS Glue 작업의 로깅](monitor-continuous-logging.md) 섹션을 참조하세요.
**관찰성 메트릭**
**작업 관찰성 지표**가 활성화되면 작업이 실행될 때 추가 Amazon CloudWatch 지표가 생성됩니다. AWS Glue 관찰성 메트릭을 사용하면 AWS Glue 내부에서 일어나는 일에 대한 통찰력을 얻어 문제의 분류 및 분석을 개선할 수 있습니다.
**Topics**
+ [Amazon CloudWatch 지표를 사용하여 AWS Glue 모니터링](monitoring-awsglue-with-cloudwatch-metrics.md)
+ [AWS Glue 작업 프로파일에서 Amazon CloudWatch 경보 설정](monitor-profile-glue-job-cloudwatch-alarms.md)
+ [AWS Glue 작업의 로깅](monitor-continuous-logging.md)
+ [AWS Glue 관찰성 메트릭을 사용한 모니터링](monitor-observability.md)
# Amazon CloudWatch 지표를 사용하여 AWS Glue 모니터링
AWS Glue 작업 프로파일러를 사용하여 AWS Glue 작업을 프로파일링하고 모니터링할 수 있습니다. AWS Glue 작업에서 원시 데이터를 수집한 후 Amazon CloudWatch에 저장된 판독이 가능한 지표로 실시간에 가깝게 처리합니다. 이러한 통계는 CloudWatch에서 보관 및 집계되므로 기록 정보에 액세스하여 애플리케이션이 어떻게 실행되고 있는지 전체적으로 더 잘 파악할 수 있습니다.
**참고**
작업 지표를 활성화하고 CloudWatch 사용자 지정 지표를 생성하면 추가 요금이 발생할 수 있습니다. 자세한 내용은 [Amazon CloudWatch 요금](https://aws.amazon.com/cloudwatch/pricing/)을 참조하세요.
## AWS Glue 지표 개요
AWS Glue는 사용자와 상호 작용할 때 지표를 CloudWatch로 전송합니다. AWS Glue 콘솔(기본 방법), CloudWatch 콘솔 대시보드 또는 AWS Command Line Interface(AWS CLI)를 사용하여 이러한 지표를 볼 수 있습니다.
**AWS Glue 콘솔 대시보드를 사용하여 지표를 보려면**
작업에 대한 요약이나 세부 그래프, 또는 작업 실행에 대한 세부 그래프를 볼 수 있습니다.
1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)에서 AWS Glue 콘솔을 엽니다.
1. 탐색 창에서 **작업 실행 모니터링**을 선택합니다.
1. **작업 실행**에서 현재 실행 중인 **작업**을 중지하거나, 작업을 보거나, 작업 북마크를 되돌립니다.
1. 작업을 선택한 다음 **실행 세부 정보 보기**를 선택하여 작업 실행에 대한 추가 정보를 확인합니다.
**CloudWatch 콘솔 대시보드를 사용하여 지표를 보려면**
지표는 먼저 서비스 네임스페이스별로 그룹화된 다음 각 네임스페이스 내에서 다양한 차원 조합별로 그룹화됩니다.
1. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)에서 CloudWatch 콘솔을 엽니다.
1. 탐색 창에서 **지표**를 선택합니다.
1. **Glue** 네임스페이스를 선택합니다.
**AWS CLI을(를) 사용하여 지표를 보려면**
+ 명령 프롬프트에서 다음 명령을 사용합니다.
```
1. aws cloudwatch list-metrics --namespace Glue
```
AWS Glue는 30초마다 CloudWatch에 지표를 보고하며, CloudWatch 지표 대시보드는 1분마다 이러한 지표를 표시하도록 구성되어 있습니다. AWS Glue 지표는 이전에 보고한 값의 델타 값을 나타냅니다. 적절한 경우 지표 대시보드는 30초 값을 집계(합)하여 마지막 1분 전체에 대한 값을 얻습니다.
### Spark 작업에 대한 AWS Glue 지표 동작
AWS Glue 지표는 스크립트에서 `GlueContext`를 초기화할 때 활성화되며 일반적으로 Apache Spark 작업이 끝날 때만 업데이트됩니다. 이러한 지표는 지금까지 완료된 모든 Spark 작업의 집계 값을 나타냅니다.
그러나 AWS Glue가 CloudWatch로 전달하는 Spark 지표는 일반적으로 보고되는 시점의 현재 상태를 나타내는 절대 값입니다. AWS Glue는 이 지표를 30초마다 CloudWatch로 보고하며, 일반적으로 지표 대시보드에는 마지막 1분 동안 받은 데이터 포인트의 평균이 표시됩니다.
AWS Glue 지표 이름은 모두 다음 접두사 유형 중 하나로 시작합니다.
+ `glue.driver.` – 이 접두사로 시작하는 이름의 지표는 Spark 드라이버의 모든 실행기에서 집계된 AWS Glue 지표 또는 Spark 드라이버에 해당하는 Spark 지표를 나타냅니다.
+ `glue.`*executorId*`.` – *executorId*는 특정 Spark 실행기의 번호입니다. 이는 로그에 나열된 실행기에 해당됩니다.
+ `glue.ALL.` – 이름이 이 접두사로 시작하는 지표는 모든 Spark 실행기의 값을 집계합니다.
## AWS Glue 지표
AWS Glue는 30초 간격으로 다음 지표를 프로파일링하여 CloudWatch로 전송하며, AWS Glue 지표 대시보드는 1분마다 이들 지표를 보고합니다.
| 지표 | 설명 |
| --- | --- |
| `glue.driver.aggregate.bytesRead` | 모든 실행기에서 실행되는 모든 완료된 Spark 태스크가 모든 데이터 원본에서 읽은 바이트 수. 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(개수). 유효 통계: SUM. 이 지표는 마지막으로 보고된 값의 델타 값입니다. 그러므로 AWS Glue 지표 대시보드에서 SUM 통계가 집계에 사용됩니다. 단위: 바이트 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 이 지표는 `glue.ALL.s3.filesystem.read_bytes` 지표와 동일한 방식으로 사용할 수 있으며(차이는 이 지표가 Spark 작업 종료 시 업데이트된다는 것) 비 S3 데이터 원본도 캡처합니다. |
| `glue.driver.aggregate.elapsedTime` | 밀리초 단위의 ETL 경과 시간(작업 부트스트랩 시간은 포함하지 않음). 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(개수). 유효 통계: SUM. 이 지표는 마지막으로 보고된 값의 델타 값입니다. 그러므로 AWS Glue 지표 대시보드에서 SUM 통계가 집계에 사용됩니다. 단위: 밀리초 작업 실행이 평균적으로 얼마나 오래 실행되는지 측정하는 데 사용할 수 있습니다. 이 데이터는 다음과 같이 사용할 수 있습니다. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.aggregate.numCompletedStages` | 작업에서 완료된 단계 수. 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(개수). 유효 통계: SUM. 이 지표는 마지막으로 보고된 값의 델타 값입니다. 그러므로 AWS Glue 지표 대시보드에서 SUM 통계가 집계에 사용됩니다. 단위: 수 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 이 데이터는 다음과 같이 사용할 수 있습니다. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.aggregate.numCompletedTasks` | 작업에서 상관관계가 있는 태스크 수. 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(개수). 유효 통계: SUM. 이 지표는 마지막으로 보고된 값의 델타 값입니다. 그러므로 AWS Glue 지표 대시보드에서 SUM 통계가 집계에 사용됩니다. 단위: 수 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.aggregate.numFailedTasks` | 실패한 태스크 수. 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(개수). 유효 통계: SUM. 이 지표는 마지막으로 보고된 값의 델타 값입니다. 그러므로 AWS Glue 지표 대시보드에서 SUM 통계가 집계에 사용됩니다. 단위: 수 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 이 데이터를 사용하여 데이터, 클러스터 또는 스크립트 이상을 암시하는 실패 증가에 대해 경보를 설정할 수 있습니다. |
| `glue.driver.aggregate.numKilledTasks` | 중지된 태스크 수. 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(개수). 유효 통계: SUM. 이 지표는 마지막으로 보고된 값의 델타 값입니다. 그러므로 AWS Glue 지표 대시보드에서 SUM 통계가 집계에 사용됩니다. 단위: 수 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 이 데이터는 다음과 같이 사용할 수 있습니다. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.aggregate.recordsRead` | 모든 실행기에서 실행되는 모든 완료된 Spark 작업이 모든 데이터 원본에서 읽은 레코드 수. 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(개수). 유효 통계: SUM. 이 지표는 마지막으로 보고된 값의 델타 값입니다. 그러므로 AWS Glue 지표 대시보드에서 SUM 통계가 집계에 사용됩니다. 단위: 수 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 이 지표는 `glue.ALL.s3.filesystem.read_bytes` 지표와 동일한 방식으로 사용할 수 있으며, 차이는 이 지표가 Spark 작업 종료 시 업데이트된다는 것입니다. |
| `glue.driver.aggregate.shuffleBytesWritten` | 이전 보고 이후 데이터 셔플을 위해 모든 실행기가 기록한 바이트 수(AWS Glue 지표 대시보드가 이 목적으로 이전 1분 동안 기록된 바이트 수로 집계). 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(개수). 유효 통계: SUM. 이 지표는 마지막으로 보고된 값의 델타 값입니다. 그러므로 AWS Glue 지표 대시보드에서 SUM 통계가 집계에 사용됩니다. 단위: 바이트 다음을 모니터링하는 데 사용: 작업(대규모 joins, groupBy, repartition, coalesce) 내 데이터 셔플. 이 데이터는 다음과 같이 사용할 수 있습니다. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.aggregate.shuffleLocalBytesRead` | 이전 보고 이후 데이터 셔플을 위해 모든 실행기가 읽은 바이트 수(AWS Glue 지표 대시보드가 이 목적으로 이전 1분 동안 읽은 바이트 수로 집계). 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(개수). 유효 통계: SUM. 이 지표는 마지막으로 보고된 값의 델타 값입니다. 그러므로 AWS Glue 지표 대시보드에서 SUM 통계가 집계에 사용됩니다. 단위: 바이트 다음을 모니터링하는 데 사용: 작업(대규모 joins, groupBy, repartition, coalesce) 내 데이터 셔플. 이 데이터는 다음과 같이 사용할 수 있습니다. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.BlockManager.disk.diskSpaceUsed_MB` | 모든 실행기에서 사용된 디스크 공간의 메가바이트 수. 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(게이지). 유효 통계: Average. 이 Spark 지표는 절대값으로 보고됩니다. 단위: 메가바이트 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 이 데이터는 다음과 같이 사용할 수 있습니다. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.ExecutorAllocationManager.executors.numberAllExecutors` | 능동적으로 실행 중인 실행기 수. 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(게이지). 유효 통계: Average. 이 Spark 지표는 절대값으로 보고됩니다. 단위: 수 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 이 데이터는 다음과 같이 사용할 수 있습니다. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors` | 현재 로드를 충족하는 데 필요한 최대 작업 (능동 실행 및 보류) 실행기 수. 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(게이지). 유효한 통계: Maximum. 이 Spark 지표는 절대값으로 보고됩니다. 단위: 수 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 이 데이터는 다음과 같이 사용할 수 있습니다. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.jvm.heap.usage` `glue.`*executorId*`.jvm.heap.usage` `glue.ALL.jvm.heap.usage` | 드라이버, executorId로 식별되는 실행기 또는 모든 실행기에 대해 이 드라이버용 JVM 힙이 사용하는 메모리 부분(규모: 0-1). 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(게이지). 유효 통계: Average. 이 Spark 지표는 절대값으로 보고됩니다. 단위: 퍼센트 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 이 데이터는 다음과 같이 사용할 수 있습니다. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.jvm.heap.used` `glue.`*executorId*`.jvm.heap.used` `glue.ALL.jvm.heap.used` | 드라이버, *executorId*로 식별되는 실행기 또는 모든 실행기에 대해 JVM 힙이 사용하는 메모리 바이트 수. 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(게이지). 유효 통계: Average. 이 Spark 지표는 절대값으로 보고됩니다. 단위: 바이트 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 이 데이터는 다음과 같이 사용할 수 있습니다. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.s3.filesystem.read_bytes` `glue.`*executorId*`.s3.filesystem.read_bytes` `glue.ALL.s3.filesystem.read_bytes` | 이전 보고 이후 드라이버, *executorId*로 식별되는 실행기 또는 모든 실행기가 Amazon S3에서 읽은 바이트 수(AWS Glue 지표 대시보드가 이 목적으로 이전 1분 동안 읽은 바이트 수로 집계). 유효 차원: `JobName`, `JobRunId`, `Type`(게이지). 유효 통계: SUM. 이 지표는 마지막으로 보고된 값의 델타 값입니다. 그러므로 AWS Glue 지표 대시보드에서 SUM 통계가 집계에 사용됩니다. AWS Glue 지표 대시보드에서 곡선 아래 영역은 두 작업 실행이 읽은 바이트 수를 시각적으로 비교하는 데 사용할 수 있습니다. 단위: 바이트 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 결과 데이터는 다음 용도로 사용할 수 있습니다. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.s3.filesystem.write_bytes` `glue.`*executorId*`.s3.filesystem.write_bytes` `glue.ALL.s3.filesystem.write_bytes` | 이전 보고 이후 드라이버, *executorId*로 식별되는 실행기 또는 모든 실행기가 Amazon S3에 쓴 바이트 수(AWS Glue 지표 대시보드가 이 목적으로 이전 1분 동안 기록된 바이트 수로 집계). 유효 차원: `JobName`, `JobRunId`, `Type`(게이지). 유효 통계: SUM. 이 지표는 마지막으로 보고된 값의 델타 값입니다. 그러므로 AWS Glue 지표 대시보드에서 SUM 통계가 집계에 사용됩니다. AWS Glue 지표 대시보드에서 곡선 아래 영역은 두 작업 실행이 기록한 바이트 수를 시각적으로 비교하는 데 사용할 수 있습니다. 단위: 바이트 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 이 데이터는 다음과 같이 사용할 수 있습니다. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.streaming.numRecords` | 마이크로 배치로 수신된 레코드 수입니다. 이 지표는 AWS Glue 버전 2.0 이상의 AWS Glue 스트리밍 작업에만 사용할 수 있습니다. 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(개수). 유효 통계: Sum, Maximum, Minimum, Average, Percentile 단위: 수 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.streaming.batchProcessingTimeInMs` | 배치를 처리하는 데 걸리는 시간(밀리초)입니다. 이 지표는 AWS Glue 버전 2.0 이상의 AWS Glue 스트리밍 작업에만 사용할 수 있습니다. 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(개수). 유효 통계: Sum, Maximum, Minimum, Average, Percentile 단위: 수 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.system.cpuSystemLoad` `glue.`*executorId*`.system.cpuSystemLoad` `glue.ALL.system.cpuSystemLoad` | 드라이버, *executorId*로 식별되는 실행기 또는 모든 실행기가 사용한 CPU 시스템 부하 부분(규모: 0-1). 유효 차원: `JobName`(AWS Glue 작업 이름), `JobRunId`(JobRun ID. 또는 `ALL`), `Type`(게이지). 유효 통계: Average. 이 지표는 절대값으로 보고됩니다. 단위: 퍼센트 다음을 모니터링하는 데 사용: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 이 데이터는 다음과 같이 사용할 수 있습니다. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
## AWS Glue 지표의 차원
AWS Glue 지표는 AWS Glue 네임스페이스를 사용하며 다음 차원의 지표를 제공합니다.
| 차원 | 설명 |
| --- | --- |
| `JobName` | 이 차원은 특정 AWS Glue 작업 내 모든 작업 실행의 지표를 필터링합니다. |
| `JobRunId` | 이 차원은 JobRun ID에 의해 실행되는 특정 AWS Glue 작업 또는 `ALL`의 지표를 필터링합니다. |
| `Type` | 이 차원은 `count`(집계 값) 또는 `gauge`(특정 시점 값) 기준 지표를 필터링합니다. |
자세한 내용은 [Amazon CloudWatch 사용 설명서](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)를 참조하세요.
# AWS Glue 작업 프로파일에서 Amazon CloudWatch 경보 설정
AWS Glue 지표는 Amazon CloudWatch에서도 사용할 수 있습니다. 예약된 작업의 AWS Glue 측정치에 대해 경보를 설정할 수 있습니다.
경보 설정을 위한 몇 가지 일반적인 시나리오는 다음과 같습니다.
+ 메모리 부족(OOM) 발생 작업: 메모리 사용량이 AWS Glue 작업에 대한 드라이버 또는 실행기에 대해 정상 평균을 초과할 때 경보를 설정합니다.
+ 스트래글링 실행기: AWS Glue 작업에서 실행기 수가 오랜 시간 동안 특정 임곗값보다 낮을 때 경보를 설정합니다.
+ 데이터 백로그 또는 재처리: CloudWatch 수학 표현식을 사용하여 워크플로 내 개별 작업의 지표를 비교합니다. 결과 표현식 값(작업이 쓴 바이트 수와 다음 작업이 읽은 바이트 수의 비율 등)에 대해 경보를 트리거할 수 있습니다.
경보 설정에 대한 자세한 지침은 *[Amazon CloudWatch Events User Guide](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/)*의 [Create or Edit a CloudWatch Alarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ConsoleAlarms.html)을 참조하세요.
CloudWatch를 사용한 모니터링 및 디버깅 시나리오는 [작업 모니터링 및 디버깅](monitor-profile-glue-job-cloudwatch-metrics.md) 섹션을 참조하세요.
# AWS Glue 작업의 로깅
AWS Glue 5.0에서는 모든 작업에 실시간 로깅 기능이 제공됩니다. 또한 사용자 지정 구성 옵션을 지정하여 로깅 동작을 조정할 수 있습니다. 이러한 옵션으로는 Amazon CloudWatch 로그 그룹 이름, Amazon CloudWatch 로그 스트림 접두사(AWS Glue 작업 실행 ID 및 드라이버/실행기 ID 앞에 있음), 로그 메시지의 로그 변환 패턴 설정이 있습니다. 이러한 구성을 사용하면 만료 정책이 서로 다른 사용자 지정 Amazon CloudWatch 로그 그룹의 로그를 집계할 수 있습니다. 여기에 더해 사용자 지정 로그 스트림 접두사와 변환 패턴을 사용하여 로그를 보다 효과적으로 분석할 수 있습니다. 이러한 수준의 사용자 지정을 통해 특정 요구 사항에 따라 로그 관리 및 분석을 최적화할 수 있습니다.
## AWS Glue 5.0의 로깅 동작
기본적으로 시스템 로그, Spark 대몬 로그 및 사용자 AWS Glue Logger 로그는 Amazon CloudWatch의 `/aws-glue/jobs/error` 로그 그룹에 기록됩니다. 반면 사용자 stdout(표준 출력) 및 stderr(표준 오류) 로그는 기본적으로 `/aws-glue/jobs/output` 로그 그룹에 기록됩니다.
## 사용자 지정 로깅
다음 작업 인수를 사용하여 기본 로그 그룹 및 로그 스트림 접두사를 사용자 지정할 수 있습니다.
+ `--custom-logGroup-prefix`: `/aws-glue/jobs/error` 및 `/aws-glue/jobs/output` 로그 그룹에 대한 사용자 지정 접두사를 지정할 수 있습니다. 사용자 지정 접두사를 입력하는 경우 로그 그룹 이름의 형식은 다음과 같습니다.
+ `/aws-glue/jobs/error`은 `/error`이 됩니다.
+ `/aws-glue/jobs/output `은 `/output`이 됩니다.
+ `--custom-logStream-prefix`: 로그 그룹 내에 있는 로그 스트림 이름의 사용자 지정 접두사를 지정할 수 있습니다. 사용자 지정 접두사를 입력하는 경우 로그 스트림 이름의 형식은 다음과 같습니다.
+ `jobrunid-driver`은 `-driver`이 됩니다.
+ `jobrunid-executorNum`은 `-executorNum`이 됩니다.
사용자 지정 접두사의 검증 규칙 및 제한 사항:
+ 전체 로그 스트림 이름은 1\$1512자여야 합니다.
+ 사용자 지정 접두사 자체는 400자로 제한됩니다.
+ 사용자 지정 접두사는 정규식 패턴 `[^:\$1]\$1`(허용되는 특수 문자는 '\$1', '-' 및 '/')과 일치해야 합니다.
## 사용자 지정 스크립트 로거를 사용하여 애플리케이션별 메시지 로깅
AWS Glue 로거를 사용하면 드라이버 로그 스트림에 실시간으로 전송되는 모든 애플리케이션별 메시지를 스크립트에서 로깅할 수 있습니다.
다음 예제에서는 Python 스크립트를 보여줍니다.
```
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
logger = glueContext.get_logger()
logger.info("info message")
logger.warn("warn message")
logger.error("error message")
```
다음 예제에서는 Scala 스크립트를 보여줍니다.
```
import com.amazonaws.services.glue.log.GlueLogger
object GlueApp {
def main(sysArgs: Array[String]) {
val logger = new GlueLogger
logger.info("info message")
logger.warn("warn message")
logger.error("error message")
}
}
```
## 작업 진행률을 보여주는 진행률 표시줄 사용 설정
AWS Glue는 AWS Glue 작업 실행 상태를 확인하기 위해 `JOB_RUN_ID-progress-bar` 로그 스트림 아래에 실시간 진행률 표시줄을 제공합니다. 현재 `glueContext`를 초기화하는 작업만 지원합니다. `glueContext`를 초기화하지 않고 기본 Spark 작업을 실행하는 경우에는 AWS Glue 진행률 표시줄이 나타나지 않습니다.
이 진행률 표시줄에서는 5초마다 다음 진행률 업데이트를 표시합니다.
```
Stage Number (Stage Name): > (numCompletedTasks + numActiveTasks) / totalNumOfTasksInThisStage]
```
## Amazon CloudWatch 로깅을 사용한 보안 구성
Amazon CloudWatch 로그에 대한 보안 구성이 활성화되면 AWS Glue는 보안 구성 이름을 포함하는 특정 명명 패턴이 있는 로그 그룹을 생성합니다.
### 보안 구성을 사용한 로그 그룹 이름 지정
기본 및 사용자 정의 로그 그룹은 다음과 같습니다.
+ **기본 오류 로그 그룹:** `/aws-glue/jobs/Security-Configuration-Name-role/glue-job-role/error`
+ **기본 출력 로그 그룹:** `/aws-glue/jobs/Security-Configuration-Name-role/glue-job-role/output`
+ **사용자 지정 오류 로그 그룹(AWS Glue 5.0):** `custom-log-group-prefix/Security-Configuration-Name-role/glue-job-role/error`
+ **사용자 지정 출력 로그 그룹(AWS Glue 5.0):** `custom-log-group-prefix/Security-Configuration-Name-role/glue-job-role/output`
### 필수 IAM 권한
Amazon CloudWatch Logs로 보안 구성을 사용하는 경우 IAM 역할 권한에 `logs:AssociateKmsKey` 권한을 추가해야 합니다. 해당 권한이 포함되지 않으면 연속 로깅이 사용 중지됩니다.
또한 Amazon CloudWatch Logs에 대한 암호화를 구성하려면 Amazon Amazon CloudWatch Logs 사용 설명서의 [AWS Key Management Service를 사용하여 Amazon CloudWatch 로그에서 로그 데이터 암호화](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html)를 참조하세요.
### 추가 정보
보안 구성 생성에 대한 자세한 내용은 [AWS Glue 콘솔에서 보안 구성 관리](https://docs.aws.amazon.com/glue/latest/dg/console-security-configurations.html)를 참조하세요.
**Topics**
+ [AWS Glue 5.0의 로깅 동작](#monitor-logging-behavior-glue-50)
+ [사용자 지정 로깅](#monitor-logging-custom)
+ [사용자 지정 스크립트 로거를 사용하여 애플리케이션별 메시지 로깅](#monitor-logging-script)
+ [작업 진행률을 보여주는 진행률 표시줄 사용 설정](#monitor-logging-progress)
+ [Amazon CloudWatch 로깅을 사용한 보안 구성](#monitor-security-config-logging)
+ [AWS Glue 4.0 이하 작업에 대한 지속 로깅 활성화](monitor-continuous-logging-enable.md)
+ [AWS Glue 작업 로그 보기](monitor-continuous-logging-view.md)
# AWS Glue 4.0 이하 작업에 대한 지속 로깅 활성화
**참고**
AWS Glue 4.0 이하 버전에서는 지속 로깅이 사용 가능한 기능이었습니다. 하지만 AWS Glue 5.0이 도입됨에 따라 모든 작업에는 실시간 로깅 기능이 제공됩니다. AWS Glue 5.0의 로깅 기능 및 구성 옵션에 대한 자세한 내용은 [AWS Glue 작업의 로깅](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging.html)을 참조하세요.
AWS Glue 콘솔을 사용하거나 AWS Command Line Interface(AWS CLI)를 통해 지속 로깅을 활성화할 수 있습니다.
새 작업을 만들거나 기존 작업을 편집할 때 또는 AWS CLI를 통해 연속 로깅을 사용 설정할 수 있습니다.
Amazon CloudWatch 로그 그룹 이름, AWS Glue 작업 실행 ID 드라이버/실행기 ID 앞의 CloudWatch 로그 스트림 접두사 및 로그 메시지에 대한 로그 변환 패턴 등의 사용자 정의 구성 옵션을 지정할 수도 있습니다. 이러한 구성을 사용하면 만료 정책이 서로 다른 사용자 지정 CloudWatch 로그 그룹에 집계 로그를 설정하고 사용자 지정 로그 스트림 접두사 및 변환 패턴을 사용하여 더 자세히 분석할 수 있습니다.
**Topics**
+ [AWS Management Console 사용](#monitor-continuous-logging-enable-console)
+ [사용자 지정 스크립트 로거를 사용하여 애플리케이션별 메시지 로깅](#monitor-continuous-logging-script)
+ [작업 진행률을 보여주는 진행률 표시줄 사용 설정](#monitor-continuous-logging-progress)
+ [지속 로깅을 사용한 보안 구성](#monitor-logging-encrypt-log-data)
## AWS Management Console 사용
AWS Glue 작업을 생성하거나 편집할 때 콘솔에서 지속 로깅을 활성화하려면 다음 절차를 수행합니다.
**지속 로깅으로 새 AWS Glue 작업을 생성하려면**
1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)에서 AWS Glue 콘솔을 엽니다.
1. 탐색 창에서 **ETL 작업**을 선택합니다.
1. **시각적 ETL**을 선택합니다.
1. **작업 세부 정보** 탭에서 **고급 속성** 섹션을 확장합니다.
1. **연속 로깅**에서 **CloudWatch에서 로그 활성화**를 선택합니다.
**기존 AWS Glue 작업에 대한 지속 로깅을 활성화하려면**
1. [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)에서 AWS Glue 콘솔을 엽니다.
1. 탐색 창에서, **작업**을 선택합니다.
1. **작업** 목록에서 기존 작업을 선택합니다.
1. **작업**, **작업 편집**을 선택합니다.
1. **작업 세부 정보** 탭에서 **고급 속성** 섹션을 확장합니다.
1. **연속 로깅**에서 **CloudWatch에서 로그 활성화**를 선택합니다.
### AWS CLI 사용
지속 로깅을 활성화하려면 작업 파라미터를 AWS Glue 작업에 전달합니다. 다른 AWS Glue 작업 파라미터와 유사한 다음 특수 작업 파라미터를 전달합니다. 자세한 내용은 [AWS Glue 작업에서 작업 파라미터 사용](aws-glue-programming-etl-glue-arguments.md) 섹션을 참조하세요.
```
'--enable-continuous-cloudwatch-log': 'true'
```
사용자 정의 Amazon CloudWatch 로그 그룹 이름을 지정할 수 있습니다. 지정하지 않으면 기본 로그 그룹 이름은 `/aws-glue/jobs/logs-v2`입니다.
```
'--continuous-log-logGroup': 'custom_log_group_name'
```
사용자 정의 Amazon CloudWatch 로그 스트림 접두사를 지정할 수 있습니다. 지정하지 않으면 기본 로그 스트림 접두사는 작업 실행 ID입니다.
```
'--continuous-log-logStreamPrefix': 'custom_log_stream_prefix'
```
사용자 지정 지속적 로깅 변환 규칙을 지정할 수 있습니다. 지정하지 않으면 기본 변환 패턴은 `%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n`입니다. 변환 패턴은 드라이버 로그 및 실행기 로그에만 적용되며 AWS Glue 진행률 표시줄에는 영향을 주지 않습니다.
```
'--continuous-log-conversionPattern': 'custom_log_conversion_pattern'
```
## 사용자 지정 스크립트 로거를 사용하여 애플리케이션별 메시지 로깅
AWS Glue 로거를 사용하면 드라이버 로그 스트림에 실시간으로 전송되는 모든 애플리케이션별 메시지를 스크립트에서 로깅할 수 있습니다.
다음 예제에서는 Python 스크립트를 보여줍니다.
```
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
logger = glueContext.get_logger()
logger.info("info message")
logger.warn("warn message")
logger.error("error message")
```
다음 예제에서는 Scala 스크립트를 보여줍니다.
```
import com.amazonaws.services.glue.log.GlueLogger
object GlueApp {
def main(sysArgs: Array[String]) {
val logger = new GlueLogger
logger.info("info message")
logger.warn("warn message")
logger.error("error message")
}
}
```
## 작업 진행률을 보여주는 진행률 표시줄 사용 설정
AWS Glue는 AWS Glue 작업 실행 상태를 확인하기 위해 `JOB_RUN_ID-progress-bar` 로그 스트림 아래에 실시간 진행률 표시줄을 제공합니다. 현재 `glueContext`를 초기화하는 작업만 지원합니다. `glueContext`를 초기화하지 않고 기본 Spark 작업을 실행하는 경우에는 AWS Glue 진행률 표시줄이 나타나지 않습니다.
이 진행률 표시줄에서는 5초마다 다음 진행률 업데이트를 표시합니다.
```
Stage Number (Stage Name): > (numCompletedTasks + numActiveTasks) / totalNumOfTasksInThisStage]
```
## 지속 로깅을 사용한 보안 구성
CloudWatch 로그에 보안 구성이 사용되는 경우 AWS Glue는 연속 로그에 대해 다음과 같은 이름의 로그 그룹을 생성합니다.
```
-
```
기본 및 사용자 정의 로그 그룹은 다음과 같습니다.
+ 기본 연속 로그 그룹은 `/aws-glue/jobs/error-`입니다.
+ 사용자 정의 연속 로그 그룹은 `-`입니다.
CloudWatch Logs로 보안 구성을 사용하는 경우 IAM 역할 권한에 `logs:AssociateKmsKey`를 추가해야 합니다. 해당 권한이 포함되지 않으면 연속 로깅이 사용 중지됩니다. 또한 CloudWatch Logs에 대한 암호화를 구성하려면 *Amazon CloudWatch Logs User Guide*의 [Encrypt Log Data in CloudWatch Logs Using AWS Key Management Service](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html)를 참조하세요.
보안 구성 생성에 대한 자세한 내용은 [AWS Glue 콘솔에서 보안 구성 관리](console-security-configurations.md) 섹션을 참조하세요.
**참고**
로깅을 활성화하고 추가 CloudWatch 로그 이벤트가 생성되면 추가 요금이 발생할 수 있습니다. 자세한 내용은 [Amazon CloudWatch 요금](https://aws.amazon.com/cloudwatch/pricing/)을 참조하세요.
# AWS Glue 작업 로그 보기
AWS Glue 콘솔 또는 Amazon CloudWatch 콘솔을 사용하여 실시간 로그를 볼 수 있습니다.
**AWS Glue 콘솔 대시보드를 사용하여 실시간 로그를 보려면**
1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)에서 AWS Glue 콘솔을 엽니다.
1. 탐색 창에서, **작업**을 선택합니다.
1. 기존 작업을 추가하거나 시작합니다. **작업**, **작업 실행**을 선택합니다.
작업 실행을 시작할 때 실행 중인 작업에 대한 정보가 포함된 페이지로 이동합니다.
+ **로그** 탭에 이전에 집계된 애플리케이션 로그가 표시됩니다.
+ **로그** 탭에는 `glueContext`가 초기화된 작업이 실행 중일 때 실시간 진행률 표시줄이 표시됩니다.
+ **로그** 탭에는 실시간 Apache Spark 드라이버 로그를 캡처하는 **드라이버 로그** 및 작업이 실행 중일 때 AWS Glue 애플리케이션 로거를 사용하여 로깅한 스크립트의 애플리케이션 로그도 포함됩니다.
1. 이전 작업의 경우 [**로그(Logs)**]를 선택하여 [**작업 기록(Job History)**] 보기에서 실시간 로그를 볼 수도 있습니다. 이러한 작업을 수행하면 해당 작업 실행에 대한 모든 Spark 드라이버, 실행기 및 진행률 표시줄 로그 스트림을 표시하는 CloudWatch 콘솔로 이동합니다.
**CloudWatch 콘솔 대시보드를 사용하여 실시간 로그를 보려면**
1. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)에서 CloudWatch 콘솔을 엽니다.
1. 탐색 창에서 **로그**를 선택합니다.
1. **/aws-glue/jobs/error/** 로그 그룹을 선택합니다.
1. **필터** 상자에 작업 실행 ID를 붙여넣습니다.
드라이버 로그, 실행기 로그 및 진행률 표시줄을 볼 수 있습니다(**Standard filter(표준 필터)**를 사용하는 경우).
# AWS Glue 관찰성 메트릭을 사용한 모니터링
**참고**
AWS Glue 관찰성 지표는 AWS Glue 4.0 이상 버전에서 사용할 수 있습니다.
AWS Glue 관찰성 메트릭을 사용하면 Apache Spark의 AWS Glue 내부에서 일어나는 일에 대한 통찰력을 얻어 문제의 분류 및 분석을 개선할 수 있습니다. 관찰성 지표는 Amazon CloudWatch 대시보드를 통해 시각화되며 오류의 근본 원인 분석을 수행하고 성능 병목 현상을 진단하는 데 사용할 수 있습니다. 대규모 문제 디버깅에 소요되는 시간을 줄여 문제를 더 빠르고 효과적으로 해결하는 데 집중할 수 있습니다.
AWS Glue 관찰성은 다음 네 그룹으로 분류된 Amazon CloudWatch 메트릭을 제공합니다.
+ **신뢰성(예: 오류 클래스)** - 주어진 시간 범위에서 해결해야 할 가장 일반적인 장애 원인을 쉽게 식별할 수 있습니다.
+ **성능(예: Skewness)** - 성능 병목 지점을 식별하고 조정 기법을 적용합니다. 예를 들어 작업 왜곡으로 인해 성능이 저하되는 경우 Spark Adaptive Query Execution을 활성화하고 스큐 조인 임곗값을 미세 조정하는 것이 좋습니다.
+ **처리량(예: 소스/싱크당 처리량)** - 데이터 읽기 및 쓰기 추세를 모니터링합니다. 또한 이상 현상에 대한 Amazon CloudWatch 경보를 구성할 수 있습니다.
+ **리소스 사용률(예: 작업자, 메모리 및 디스크 사용률)** - 용량 사용률이 낮은 작업을 효율적으로 찾을 수 있습니다. 이러한 작업에 대해 AWS Glue Auto Scaling을 활성화할 수 있습니다.
## AWS Glue 관찰성 메트릭 시작하기
**참고**
새로운 지표는 AWS Glue Studio 콘솔에서 기본적으로 활성화됩니다.
**AWS Glue Studio에서 관찰성 지표를 구성하려면 다음을 수행합니다.**
1. AWS Glue 콘솔에 로그인하고 콘솔 메뉴에서 **ETL 작업**을 선택합니다.
1. 내 작업 섹션에서 작업 이름을 클릭하여 **작업**을 선택합니다.
1. [**작업 세부 정보(Job details)**] 탭을 선택합니다.
1. 하단으로 스크롤하여 **고급 속성**을 선택한 다음 **작업 관찰성 지표**를 선택합니다.
![\[스크린샷은 작업 세부 정보 탭 고급 속성 탭을 보여줍니다. 작업 관찰성 메트릭 옵션이 강조 표시됩니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/job-details-observability-metrics.png)
**AWS CLI를 사용하여 AWS Glue 관찰성 지표를 활성화하려면 다음을 수행합니다.**
+ 입력 `--default-arguments` JSON 파일의 다음 키-값을 맵에 추가합니다.
```
--enable-observability-metrics, true
```
## AWS Glue 관찰성 사용
AWS Glue 관찰성 지표는 Amazon CloudWatch를 통해 제공되므로 Amazon CloudWatch 콘솔, AWS CLI, SDK 또는 API를 사용하여 관찰성 지표 데이터 포인트를 쿼리할 수 있습니다. AWS Glue 관찰성 지표를 사용하는 사용 사례의 예는 [Using Glue Observability for monitoring resource utilization to reduce cost](https://aws.amazon.com/blogs/big-data/enhance-monitoring-and-debugging-for-aws-glue-jobs-using-new-job-observability-metrics/)를 참조하세요.
### Amazon CloudWatch 콘솔에서 AWS Glue 관찰성 사용
**Amazon CloudWatch 콘솔에서 메트릭을 쿼리하고 시각화는 방법:**
1. Amazon CloudWatch 콘솔을 열고 **모든 지표**를 선택합니다.
1. 사용자 지정 네임스페이스에서 **AWS Glue**를 선택합니다.
1. **작업 관찰성 지표, 소스별 관찰 가능성 지표 또는 싱크당 관찰 가능성 지표**를 선택합니다.
1. 특정 지표 이름, 작업 이름, 작업 실행 ID를 검색하고 선택합니다.
1. **그래프로 표시된 지표** 탭에서 원하는 통계, 기간 및 기타 옵션을 구성합니다.
![\[스크린샷은 Amazon CloudWatch 콘솔 및 지표 그래프를 보여줍니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/cloudwatch-console-metrics.png)
**AWS CLI를 사용하여 관찰성 지표를 쿼리하려면 다음을 수행합니다.**
1. 지표 정의 JSON 파일을 생성하고 `your-Glue-job-name` 및 `your-Glue-job-run-id`를 변경합니다.
```
$ cat multiplequeries.json
[
{
"Id": "avgWorkerUtil_0",
"MetricStat": {
"Metric": {
"Namespace": "Glue",
"MetricName": "glue.driver.workerUtilization",
"Dimensions": [
{
"Name": "JobName",
"Value": ""
},
{
"Name": "JobRunId",
"Value": ""
},
{
"Name": "Type",
"Value": "gauge"
},
{
"Name": "ObservabilityGroup",
"Value": "resource_utilization"
}
]
},
"Period": 1800,
"Stat": "Minimum",
"Unit": "None"
}
},
{
"Id": "avgWorkerUtil_1",
"MetricStat": {
"Metric": {
"Namespace": "Glue",
"MetricName": "glue.driver.workerUtilization",
"Dimensions": [
{
"Name": "JobName",
"Value": ""
},
{
"Name": "JobRunId",
"Value": ""
},
{
"Name": "Type",
"Value": "gauge"
},
{
"Name": "ObservabilityGroup",
"Value": "resource_utilization"
}
]
},
"Period": 1800,
"Stat": "Minimum",
"Unit": "None"
}
}
]
```
1. `get-metric-data` 명령을 실행합니다.
```
$ aws cloudwatch get-metric-data --metric-data-queries file: //multiplequeries.json \
--start-time '2023-10-28T18: 20' \
--end-time '2023-10-28T19: 10' \
--region us-east-1
{
"MetricDataResults": [
{
"Id": "avgWorkerUtil_0",
"Label": "",
"Timestamps": [
"2023-10-28T18:20:00+00:00"
],
"Values": [
0.06718750000000001
],
"StatusCode": "Complete"
},
{
"Id": "avgWorkerUtil_1",
"Label": "",
"Timestamps": [
"2023-10-28T18:50:00+00:00"
],
"Values": [
0.5959183673469387
],
"StatusCode": "Complete"
}
],
"Messages": []
}
```
## 관찰성 메트릭
AWS Glue 관찰성은 다음 지표의 프로필을 작성하고 30초마다 Amazon CloudWatch로 전송하며, 이러한 지표 중 일부는 AWS Glue Studio 작업 실행 모니터링 페이지에서 확인할 수 있습니다.
| 지표 | 설명 | 카테고리 |
| --- | --- | --- |
| glue.driver.skewness.stage | 지표 범주: job\$1performance Spark 스테이지 실행 왜도: 이 지표는 특정 스테이지의 최대 태스크 지속 시간이 이 스테이지의 태스크 지속 시간 중앙값과 비교하여 얼마나 긴지 나타내는 지표입니다. 이 지표는 입력 데이터 왜도 또는 변환(예: 왜곡된 조인)으로 인해 발생할 수 있는 실행 왜도를 캡처합니다. 이 지표의 값은 [0, 무한] 범위에 속합니다. 여기서 0은 스테이지의 모든 작업 중 최대 작업 실행 시간과 중간 작업 실행 시간의 비율이 특정 스테이지 왜도 인자보다 작다는 것을 의미합니다. 기본 스테이지 왜도 인자는 `5`이며 spark conf: spark.metrics.conf.driver.source.glue.jobPerformance.skewnessFactor를 통해 덮어쓸 수 있습니다. 스테이지 왜도 값이 1이면 비율이 단계 왜도 인자의 두 배임을 의미합니다. 스테이지 왜도 값은 현재 왜도를 반영하여 30초마다 업데이트됩니다. 스테이지가 끝날 때의 값은 최종 스테이지 왜도를 반영합니다. 이 스테이지 수준 지표는 작업 수준 지표 `glue.driver.skewness.job`을 계산하는 데 사용됩니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(Job\$1Performance) 유효 통계: 평균, 최대, 최소, 백분위수 단위: 수 | job\$1performance |
| glue.driver.skewness.job | 지표 범주: job\$1performance 작업 왜도는 모든 스테이지의 최대 가중치 왜도입니다. 스테이지 왜도(glue.driver.skewness.stage)에는 스테이지 지속 시간이 가중치로 적용됩니다. 이는 매우 왜곡된 스테이지가 실제로 다른 스테이지에 비해 매우 짧은 시간 동안 실행되는 경우를 피하기 위한 것입니다. 따라서 왜도는 전체 작업 성능에 있어 중요하지 않으며 왜도를 해결하려고 노력할 필요가 없습니다. 이 지표는 각 단계가 완료될 때마다 업데이트되므로 마지막 값은 실제 전체 작업 왜도를 반영합니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(Job\$1Performance) 유효 통계: 평균, 최대, 최소, 백분위수 단위: 수 | job\$1performance |
| glue.succeed.ALL | 지표 범주: 오류 실패 범주의 그림을 완성하기 위한 총 작업 실행 성공 횟수 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(개수), ObservabilityGroup(오류) 유효 통계: SUM 단위: 수 | 오류 |
| glue.error.ALL | 지표 범주: 오류 실패 범주의 그림을 완성하기 위한 총 작업 실행 오류 횟수 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(개수), ObservabilityGroup(오류) 유효 통계: SUM 단위: 수 | 오류 |
| glue.error.[error category] | 지표 범주: 오류 이것은 실제로 작업 실행이 실패할 때만 업데이트되는 지표 세트입니다. 오류 분류는 분류 및 디버깅에 도움이 됩니다. 작업 실행이 실패하면 실패의 원인이 되는 오류가 분류되고 해당 오류 범주 지표가 1로 설정됩니다. 이를 통해 시간 경과에 따른 오류 분석은 물론 모든 작업에 대한 오류 분석을 수행하여 가장 일반적인 오류 범주를 식별하고 문제 해결을 시작할 수 있습니다. AWS Glue에는 OUT\$1OF\$1MEMORY(드라이버 및 실행기), PERMISSION, SYNTAX 및 THROTTLING 오류 범주를 포함한 28개의 오류 범주가 있습니다. 오류 범주는 COMPILATION, LAUNCH, TIMEOUT 오류 범주도 포함합니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(개수), ObservabilityGroup(오류) 유효 통계: SUM 단위: 수 | 오류 |
| glue.driver.workerUtilization | 지표 범주: resource\$1utilization 할당된 작업자 중 실제로 사용된 작업자의 비율입니다. 상황이 좋지 않다면 Auto Scaling이 도움이 될 수 있습니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) 유효 통계: 평균, 최대, 최소, 백분위수 단위: 퍼센트 | resource\$1utilization |
| glue.driver.memory.heap.[available \$1 used] | 지표 범주: resource\$1utilization 작업 실행 중 드라이버의 사용 가능/사용된 힙 메모리입니다. 이는 특히 시간 경과에 따른 메모리 사용량 추세를 파악하는 데 도움이 되며 메모리 관련 오류를 디버깅할 뿐만 아니라 잠재적인 오류를 방지하는 데도 도움이 될 수 있습니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 바이트 | resource\$1utilization |
| glue.driver.memory.heap.used.percentage | 지표 범주: resource\$1utilization 작업 실행 중 드라이버가 사용한 힙 메모리(%)입니다. 이는 특히 시간 경과에 따른 메모리 사용량 추세를 파악하는 데 도움이 되며 메모리 관련 오류를 디버깅할 뿐만 아니라 잠재적인 오류를 방지하는 데도 도움이 될 수 있습니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 퍼센트 | resource\$1utilization |
| glue.driver.memory.non-heap.[available \$1 used] | 지표 범주: resource\$1utilization 작업 실행 중 드라이버가 사용 가능한 또는 사용한 힙이 아닌 메모리입니다. 이는 특히 시간 경과에 따른 메모리 사용량 추세를 파악하는 데 도움이 되며 메모리 관련 오류를 디버깅할 뿐만 아니라 잠재적인 오류를 방지하는 데도 도움이 될 수 있습니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 바이트 | resource\$1utilization |
| glue.driver.memory.non-heap.used.percentage | 지표 범주: resource\$1utilization 작업 실행 중 드라이버가 사용한 힙이 아닌 메모리(%)입니다. 이는 특히 시간 경과에 따른 메모리 사용량 추세를 파악하는 데 도움이 되며 메모리 관련 오류를 디버깅할 뿐만 아니라 잠재적인 오류를 방지하는 데도 도움이 될 수 있습니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 퍼센트 | resource\$1utilization |
| glue.driver.memory.total.[available \$1 used] | 지표 범주: resource\$1utilization 작업 실행 중 드라이버가 사용 가능한 또는 사용한 총 메모리입니다. 이는 특히 시간 경과에 따른 메모리 사용량 추세를 파악하는 데 도움이 되며 메모리 관련 오류를 디버깅할 뿐만 아니라 잠재적인 오류를 방지하는 데도 도움이 될 수 있습니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 바이트 | resource\$1utilization |
| glue.driver.memory.total.used.percentage | 지표 범주: resource\$1utilization 작업 실행 중 드라이버가 사용한 총 메모리(%)입니다. 이는 특히 시간 경과에 따른 메모리 사용량 추세를 파악하는 데 도움이 되며 메모리 관련 오류를 디버깅할 뿐만 아니라 잠재적인 오류를 방지하는 데도 도움이 될 수 있습니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 퍼센트 | resource\$1utilization |
| glue.ALL.memory.heap.[available \$1 used] | 지표 범주: resource\$1utilization 실행기의 사용 가능한/사용된 힙 메모리입니다. ALL은 모든 실행기를 의미합니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 바이트 | resource\$1utilization |
| glue.ALL.memory.heap.used.percentage | 지표 범주: resource\$1utilization 실행기가 사용한 힙 메모리(%)입니다. ALL은 모든 실행기를 의미합니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 퍼센트 | resource\$1utilization |
| glue.ALL.memory.non-heap.[available \$1 used] | 지표 범주: resource\$1utilization 실행기의 사용 가능한/사용된 힙이 아닌 메모리입니다. ALL은 모든 실행기를 의미합니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 바이트 | resource\$1utilization |
| glue.ALL.memory.non-heap.used.percentage | 지표 범주: resource\$1utilization 실행기가 사용한 힙이 아닌 메모리(%)입니다. ALL은 모든 실행기를 의미합니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 퍼센트 | resource\$1utilization |
| glue.ALL.memory.total.[available \$1 used] | 지표 범주: resource\$1utilization 실행기의 사용 가능한/사용된 총 메모리입니다. ALL은 모든 실행기를 의미합니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 바이트 | resource\$1utilization |
| glue.ALL.memory.total.used.percentage | 지표 범주: resource\$1utilization 실행기의 총 메모리 사용률(%)입니다. ALL은 모든 실행기를 의미합니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 퍼센트 | resource\$1utilization |
| glue.driver.disk.[available\$1GB \$1 used\$1GB] | 지표 범주: resource\$1utilization 작업 실행 중 드라이버의 사용 가능한/사용된 디스크 공간입니다. 이는 특히 시간 경과에 따른 디스크 사용량 추세를 파악하는 데 도움이 되며 디스크 공간 부족 관련 오류를 디버깅할 뿐만 아니라 잠재적인 오류를 방지하는 데도 도움이 될 수 있습니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 기가바이트 | resource\$1utilization |
| glue.driver.disk.used.percentage] | 지표 범주: resource\$1utilization 작업 실행 중 드라이버의 사용 가능한/사용된 디스크 공간입니다. 이는 특히 시간 경과에 따른 디스크 사용량 추세를 파악하는 데 도움이 되며 디스크 공간 부족 관련 오류를 디버깅할 뿐만 아니라 잠재적인 오류를 방지하는 데도 도움이 될 수 있습니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 퍼센트 | resource\$1utilization |
| glue.ALL.disk.[available\$1GB \$1 used\$1GB] | 지표 범주: resource\$1utilization 실행기의 사용 가능한/사용된 디스크 공간입니다. ALL은 모든 실행기를 의미합니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 기가바이트 | resource\$1utilization |
| glue.ALL.disk.used.percentage | 지표 범주: resource\$1utilization 실행기의 사용 가능한/사용된/사용된(%) 디스크 공간입니다. ALL은 모든 실행기를 의미합니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization) Valid Statistics: Average 단위: 퍼센트 | resource\$1utilization |
| glue.driver.bytesRead | 지표 범주: 처리량 이 작업 실행에서 입력 소스당 및 모든 소스에 대해 읽은 바이트 수입니다. 이를 통해 데이터양과 시간 경과에 따른 변화를 파악할 수 있으므로 데이터 왜도와 같은 문제를 해결하는 데 도움이 됩니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization), Source(소스 데이터 위치) Valid Statistics: Average 단위: 바이트 | 처리량 |
| glue.driver.[recordsRead \$1 filesRead] | 지표 범주: 처리량 이 작업 실행에서 입력 소스당 및 모든 소스에 대해 읽은 레코드/파일 수입니다. 이를 통해 데이터양과 시간 경과에 따른 변화를 파악할 수 있으므로 데이터 왜도와 같은 문제를 해결하는 데 도움이 됩니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization), Source(소스 데이터 위치) Valid Statistics: Average 단위: 수 | 처리량 |
| glue.driver.partitionsRead | 지표 범주: 처리량 이 작업 실행에서 Amazon S3 입력 소스당 및 모든 소스에 대해 읽은 파티션 수입니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization), Source(소스 데이터 위치) Valid Statistics: Average 단위: 수 | 처리량 |
| glue.driver.bytesWrittten | 지표 범주: 처리량 이 작업 실행에서 출력 싱크당 및 모든 싱크에 대해 작성된 바이트 수입니다. 이를 통해 데이터양과 시간이 지남에 따라 어떻게 변화하는지 파악할 수 있으므로 처리 왜도와 같은 문제를 해결하는 데 도움이 됩니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization), Sink(싱크 데이터 위치) Valid Statistics: Average 단위: 바이트 | 처리량 |
| glue.driver.[recordsWritten \$1 filesWritten] | 지표 범주: 처리량 이 작업 실행에서 출력 싱크당 및 모든 싱크에 대해 작성된 레코드/파일 수입니다. 이를 통해 데이터양과 시간이 지남에 따라 어떻게 변화하는지 파악할 수 있으므로 처리 왜도와 같은 문제를 해결하는 데 도움이 됩니다. 유효 차원: JobName(AWS Glue 작업 이름), JobRunId(JobRun ID 또는 ALL), Type(게이지), ObservabilityGroup(resource\$1utilization), Sink(싱크 데이터 위치) Valid Statistics: Average 단위: 수 | 처리량 |
## 오류 범주
| 오류 범주 | 설명 |
| --- | --- |
| COMPILATION\$1ERROR | Scala 코드를 컴파일하는 동안 오류가 발생합니다. |
| CONNECTION\$1ERROR | 서비스/원격 호스트/데이터베이스 서비스 등에 연결하는 동안 오류가 발생합니다. |
| DISK\$1NO\$1SPACE\$1ERROR | 드라이버/실행기의 디스크에 공간이 남아 있지 않은 경우 오류가 발생합니다. |
| OUT\$1OF\$1MEMORY\$1ERROR | 드라이버/실행기의 메모리에 공간이 남아 있지 않은 경우 오류가 발생합니다. |
| IMPORT\$1ERROR | 종속성을 가져올 때 오류가 발생합니다. |
| INVALID\$1ARGUMENT\$1ERROR | 입력 인수가 유효하지 않거나 잘못된 경우 오류가 발생합니다. |
| PERMISSION\$1ERROR | 서비스, 데이터 등에 대한 권한이 없는 경우 오류가 발생합니다. |
| RESOURCE\$1NOT\$1FOUND\$1ERROR | 데이터, 위치 등이 종료되지 않을 경우 오류가 발생합니다. |
| QUERY\$1ERROR | Spark SQL 쿼리 실행으로 인해 오류가 발생합니다. |
| SYNTAX\$1ERROR | 스크립트에 구문 오류가 있는 경우 오류가 발생합니다. |
| THROTTLING\$1ERROR | 서비스 동시성 한도에 도달하거나 서비스 할당량 한도를 초과하는 경우 오류가 발생합니다. |
| DATA\$1LAKE\$1FRAMEWORK\$1ERROR | Hudi, Iceberg 등과 같은 AWS Glue 기본 지원 데이터 레이크 프레임워크에서 오류가 발생합니다. |
| UNSUPPORTED\$1OPERATION\$1ERROR | 지원되지 않는 작업을 수행하는 경우 오류가 발생합니다. |
| RESOURCES\$1ALREADY\$1EXISTS\$1ERROR | 생성하거나 추가하려는 리소스가 이미 존재하는 경우 오류가 발생합니다. |
| GLUE\$1INTERNAL\$1SERVICE\$1ERROR | AWS Glue 내부 서비스 문제가 있는 경우 오류가 발생합니다. |
| GLUE\$1OPERATION\$1TIMEOUT\$1ERROR | AWS Glue 작업 시간이 초과되는 경우 오류가 발생합니다. |
| GLUE\$1VALIDATION\$1ERROR | AWS Glue 작업에 필요한 값을 검증할 수 없는 경우 오류가 발생합니다. |
| GLUE\$1JOB\$1BOOKMARK\$1VERSION\$1MISMATCH\$1ERROR | 동일한 소스 버킷에서 동일한 작업이 실행되고 동일한/다른 대상에 동시에 작성되는 경우 오류가 발생합니다(동시성 > 1). |
| LAUNCH\$1ERROR | AWS Glue 작업 시작 단계에서 오류가 발생합니다. |
| DYNAMODB\$1ERROR | Amazon DynamoDB 서비스에서 일반 오류가 발생합니다. |
| GLUE\$1ERROR | AWS Glue 서비스에서 일반 오류가 발생합니다. |
| LAKEFORMATION\$1ERROR | AWS Lake Formation 서비스에서 일반 오류가 발생합니다. |
| REDSHIFT\$1ERROR | Amazon Redshift 서비스에서 일반 오류가 발생합니다. |
| S3\$1ERROR | Amazon S3 서비스에서 일반 오류가 발생합니다. |
| SYSTEM\$1EXIT\$1ERROR | 일반 시스템 종료 오류입니다. |
| TIMEOUT\$1ERROR | 작업 시간 초과로 인해 작업이 실패하면 일반 오류가 발생합니다. |
| UNCLASSIFIED\$1SPARK\$1ERROR | Spark에서 일반 오류가 발생합니다. |
| UNCLASSIFIED\$1ERROR | 기본 오류 범주입니다. |
## 제한 사항
**참고**
`glueContext`를 초기화해야만 지표를 게시할 수 있습니다.
소스 차원에서 값은 소스 유형에 따라 Amazon S3 경로 또는 테이블 이름입니다. 또한 소스가 JDBC이고 쿼리 옵션이 사용되는 경우 쿼리 문자열은 소스 차원에 설정됩니다. 값이 500자보다 길면 500자 이내로 잘립니다. 다음은 값의 제한 사항입니다.
+ ASCII가 아닌 문자는 제거됩니다.
+ 소스 이름에 ASCII 문자가 포함되어 있지 않으면 <비 ASCII 입력>으로 변환됩니다.
### 처리량 지표의 제한 사항 및 고려 사항
+ DataFrame 및 DataFrame 기반 DynamicFrame(예: JDBC, Amazon S3의 Parquet에서 읽기)은 지원되지만 RDD 기반 DynamicFrame(예: Amazon S3에서 csv, json 읽기 등)은 지원되지 않습니다. 기술적으로는 Spark UI에 표시되는 모든 읽기 및 쓰기가 지원됩니다.
+ 데이터 소스가 카탈로그 테이블이고 형식이 JSON, CSV, 텍스트 또는 Iceberg인 경우 `recordsRead` 지표가 내보내집니다.
+ `glue.driver.throughput.recordsWritten`, `glue.driver.throughput.bytesWritten`, `glue.driver.throughput.filesWritten` 지표는 JDBC 및 Iceberg 테이블에서 사용할 수 없습니다.
+ 지표가 지연될 수 있습니다. 작업이 약 1분 안에 완료되면 Amazon CloudWatch 지표에 처리량 지표가 표시되지 않을 수 있습니다.
# 작업 모니터링 및 디버깅
AWS Glue 작업에 대한 지표를 수집하고 AWS Glue 및 Amazon CloudWatch 콘솔에서 이러한 지표를 시각화하여 문제를 식별하고 수정할 수 있습니다. AWS Glue 작업을 프로파일링하려면 다음 단계를 수행해야 합니다.
1. 지표를 활성화하려면 다음을 수행합니다.
1. 작업 정의에서 **작업 측정치** 옵션을 활성화합니다. AWS Glue 콘솔에서 또는 작업의 파라미터로서 프로파일링을 활성화할 수 있습니다. 자세한 정보는 [Spark 작업에 대한 작업 속성 정의](add-job.md#create-job) 또는 [AWS Glue 작업에서 작업 파라미터 사용](aws-glue-programming-etl-glue-arguments.md) 섹션을 참조하세요.
1. 작업 정의에서 **AWS Glue 관찰성 지표** 옵션을 활성화합니다. AWS Glue 콘솔에서 또는 작업의 파라미터로서 관찰성을 활성화할 수 있습니다. 자세한 내용은 [AWS Glue 관찰성 메트릭을 사용한 모니터링](monitor-observability.md)을 참조하세요.
1. 작업 스크립트에서 `GlueContext`를 초기화하는지 확인합니다. 예를 들면 다음 스크립트 조각은 `GlueContext`를 초가화하고 프로파일링된 코드가 스크립트에 있는 위치를 표시합니다. 이 일반적인 형식은 이어지는 디버깅 시나리오에서 사용됩니다.
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
import time
## @params: [JOB_NAME]
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
...
...
code-to-profile
...
...
job.commit()
```
1. 작업을 실행합니다.
1. 지표를 시각화하려면 다음을 수행합니다.
1. AWS Glue 콘솔에서 작업 지표를 시각화하고 드라이버 또는 실행기의 이상 지표를 식별합니다.
1. 작업 실행 모니터링 페이지, 작업 실행 세부 정보 페이지 또는 Amazon CloudWatch에서 관찰성 지표를 확인합니다. 자세한 내용은 [AWS Glue 관찰성 메트릭을 사용한 모니터링](monitor-observability.md) 섹션을 참조하세요.
1. 식별된 측정치를 사용하여 근본 원인의 범위를 좁힙니다.
1. 원한다면 식별된 드라이버나 작업 실행기의 로그 스트림을 사용하여 근본 원인을 확인할 수 있습니다.
**AWS Glue 관찰성 지표의 사용 사례**
+ [OOM 예외 사항 및 작업 이상 현상 디버깅](monitor-profile-debug-oom-abnormalities.md)
+ [까다로운 단계와 스트래글러 작업 디버깅](monitor-profile-debug-straggler.md)
+ [여러 작업의 진행 상황 모니터링](monitor-debug-multiple.md)
+ [DPU 용량 계획 모니터링](monitor-debug-capacity.md)
+ [리소스 사용률 모니터링을 위해 AWS Glue 관찰성을 사용하여 비용 절감](https://aws.amazon.com/blogs/big-data/enhance-monitoring-and-debugging-for-aws-glue-jobs-using-new-job-observability-metrics)
# OOM 예외 사항 및 작업 이상 현상 디버깅
AWS Glue에서 메모리 부족(OOM) 예외 사항 및 작업 이상 현상을 디버깅할 수 있습니다. 다음 단원에서는 Apache Spark 드라이버 또는 Spark 실행기의 메모리 부족 예외 사항을 디버깅하는 시나리오를 설명합니다.
+ [드라이버 OOM 예외 사항 디버깅](#monitor-profile-debug-oom-driver)
+ [실행기 OOM 예외 사항 디버깅](#monitor-profile-debug-oom-executor)
## 드라이버 OOM 예외 사항 디버깅
이 시나리오에서는 Spark 작업이 Amazon Simple Storage Service(Amazon S3)에서 여러 작은 파일을 읽습니다. 파일을 Apache Parquet 포맷으로 변환한 다음 Amazon S3에 씁니다. Spark 드라이버에서 메모리 부족이 발생합니다. 입력 Amazon S3 데이터의 파일 수는 서로 다른 Amazon S3 파티션에 걸쳐 100만개가 넘습니다.
프로파일링된 코드는 다음과 같습니다.
```
data = spark.read.format("json").option("inferSchema", False).load("s3://input_path")
data.write.format("parquet").save(output_path)
```
### AWS Glue 콘솔에서 프로파일링된 지표 시각화
다음 그래프는 드라이버와 실행기에 대한 메모리 사용률(%)을 표시합니다. 이 사용률은 지난 1분 안에 보고된 값에 대한 평균으로 계산된 데이터 하나로 표시됩니다. [드라이버 메모리](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.jvm.heap.usage)가 50% 사용률의 안전 임계값을 넘는 작업의 메모리 프로필을 볼 수 있습니다. 반면에, 모든 실행기의 [평균 메모리 사용률](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage)은 여전히 4%보다 낮습니다. 이로써 이 Spark 작업에서 드라이버 실행에 이상이 있음을 명확히 알 수 있습니다.
![\[드라이버 및 실행기의 메모리 사용률(%).\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-oom-memoryprofile.png)
작업 실행이 곧 실패하고 AWS Glue 콘솔의 [**기록(History)**] 탭에 [종료 코드 1로 명령 실패(Command Failed with Exit Code 1)] 오류가 나타납니다. 이 오류 문자열은 시스템 전체 오류(이 경우 메모리 부족)로 인해 작업이 실패했음을 의미합니다.
![\[AWS Glue 콘솔에 표시된 오류 메시지입니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-oom-errorstring.png)
콘솔의 [**기록(History)**] 탭에서 [**오류 로그(Error logs)**] 링크를 선택하여 CloudWatch Logs에서 드라이버 OOM에 대한 결과를 확인합니다. 작업의 오류 로그에서 "**Error**"를 검색하여 작업 실패의 원인이 된 OOM 예외 사항이 정말 발생했는지 확인합니다.
```
# java.lang.OutOfMemoryError: Java heap space
# -XX:OnOutOfMemoryError="kill -9 %p"
# Executing /bin/sh -c "kill -9 12039"...
```
작업에 대해 **기록** 탭에서 **로그**를 선택합니다. 작업의 시작 부분에서 다음과 같은 CloudWatch Logs의 드라이버 실행 추적 정보를 찾아볼 수 있습니다. Spark 드라이버에서 모든 디렉터리의 모든 파일을 나열하려고 했으며, `InMemoryFileIndex`를 생성하고 파일마다 작업 하나를 실행합니다. 이로 인해 Spark 드라이버는 모든 작업을 추적하기 위해 메모리에서 매우 많은 상태를 유지해야 합니다. 따라서 메모리 내 인덱스에 대해 다량의 파일을 포함하는 전체 목록을 캐시하므로 드라이버 OOM이 발생하게 됩니다.
### 그룹화를 사용하여 여러 파일의 처리 수정
AWS Glue의 *그룹화* 기능을 사용하여 여러 파일의 처리를 수정할 수 있습니다. 그룹화는 동적 프레임을 사용할 때와 입력 데이터 세트에 파일 수가 많을 때(50,000개 초과) 자동으로 활성화됩니다. 그룹화를 통해 여러 파일을 그룹 하나로 합칠 수 있으므로 작업 하나로 단일 파일 대신에 전체 그룹을 처리할 수 있습니다. 결과적으로 Spark 드라이버는 메모리 안에 훨씬 더 적은 상태를 저장하여 몇 개 작업만 추적합니다. 데이터 세트에 대한 그룹화 수동 활성화에 대한 자세한 내용은 [입력 파일을 더 큰 그룹에서 읽기](grouping-input-files.md) 단원을 참조하십시오.
AWS Glue 작업의 메모리 프로파일을 확인하려면 그룹화가 활성화된 상태에서 다음과 같은 코드를 프로파일링합니다.
```
df = glueContext.create_dynamic_frame_from_options("s3", {'paths': ["s3://input_path"], "recurse":True, 'groupFiles': 'inPartition'}, format="json")
datasink = glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet", transformation_ctx = "datasink")
```
AWS Glue 작업 프로필에서 메모리 프로필 및 ETL 데이터 이동을 모니터링할 수 있습니다.
이 드라이버는 AWS Glue 작업의 전체 기간 동안 메모리 사용량의 50%인 임계값 미만으로 실행됩니다. 실행기가 Amazon S3에서 데이터를 스트리밍하고 처리한 후 Amazon S3에 씁니다. 결과적으로 모든 시점에서 5%보다 적은 양의 메모리가 사용됩니다.
![\[문제를 나타냈던 메모리 프로필이 수정되었습니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-oom-memoryprofile-fixed.png)
아래 데이터 이동 프로파일은 작업이 진행됨에 따라 모든 실행기가 마지막 1분 동안 [읽고](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) [쓴](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes) 총 Amazon S3 바이트 수를 보여줍니다. 둘 다 모든 실행기에서 데이터가 스트리밍될 때 유사한 패턴을 따릅니다. 이 작업은 세 시간 내에 100만 개에 이르는 모든 파일에 대한 처리를 완료합니다.
![\[문제를 나타냈던 데이터 이동 프로필이 수정되었습니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-oom-etlmovement.png)
## 실행기 OOM 예외 사항 디버깅
이 시나리오에서는 Apache Spark 실행기에서 발생할 수 있는 OOM 예외 사항을 디버깅하는 방법을 알아볼 수 있습니다. 다음 코드는 Spark MySQL 리더를 사용하여 약 3400만개 행으로 이루어진 대형 테이블을 Spark 데이터 프레임으로 읽어 들입니다. 그런 다음 Parquet 포맷으로 Amazon S3에 씁니다. 연결 속성을 제공하고 기본 Spark 구성을 사용하여 테이블을 읽을 수 있습니다.
```
val connectionProperties = new Properties()
connectionProperties.put("user", user)
connectionProperties.put("password", password)
connectionProperties.put("Driver", "com.mysql.jdbc.Driver")
val sparkSession = glueContext.sparkSession
val dfSpark = sparkSession.read.jdbc(url, tableName, connectionProperties)
dfSpark.write.format("parquet").save(output_path)
```
### AWS Glue 콘솔에서 프로파일링된 지표 시각화
메모리 사용량 그래프의 경사가 양수이고 50%를 넘는 경우 다음 지표를 내보내기 전에 작업이 실패하면 메모리 부족이 실패 원인이 될 수 있습니다. 다음 그래프는 1분 실행 기간 내에 모든 실행기의 [평균 메모리 사용률](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage)이 50%를 급격하게 초과함을 보여줍니다. 이 사용률은 최대 92%에 도달하며 해당 실행기를 실행 중인 컨테이너가 Apache Hadoop YARN에 의해 중지됩니다.
![\[모든 실행기의 평균 메모리 사용률.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-oom-2-memoryprofile.png)
다음 그래프에서처럼, 작업이 실패할 때까지 항상 [단일 실행기](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors)가 실행 중입니다. 이는 새 실행기가 시작되어 중지된 실행기를 대체하기 때문입니다. JDBC 데이터 원본 읽기는 기본적으로 병렬화되지 않습니다. 그 이유는 한 열에서 테이블을 분할하고 여러 연결을 열어야 하기 때문입니다. 따라서 실행기 하나만 전체 테이블에서 순차적으로 읽혀집니다.
![\[이 작업 실행은 작업이 실패할 때까지 단일 실행기가 실행 중임을 보여줍니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-oom-2-execution.png)
다음 그래프에서처럼, Spark는 작업 실패 전에 새 작업 시작을 4회 시도합니다. 세 개 실행기의 [메모리 프로필](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.used)을 볼 수 있습니다. 각 실행기가 모든 메모리를 신속히 소비합니다. 네 번째 실행기에서 메모리 부족이 발생하여 작업이 실패합니다. 따라서 이 작업의 측정치가 즉시 보고되지 않습니다.
![\[실행기의 메모리 프로필.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-oom-2-exec-memprofile.png)
다음 이미지와 같이, OOM 예외로 인해 작업이 실패했던 AWS Glue 콘솔에서 오류 문자열을 확인할 수 있습니다.
![\[AWS Glue 콘솔에 표시된 오류 메시지입니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-oom-2-errorstring.png)
**작업 출력 로그:** 실행기 OOM 예외 사항의 결과를 추가로 확인하려면 CloudWatch Logs를 살펴봅니다. **Error**를 검색하면 지표 대시보드처럼 거의 동일한 기간 내에 네 개 실행기가 중지됨을 확인할 수 있습니다. 이들 실행기는 메모리 제한을 초과할 때 YARN에 의해 모두 종료됩니다.
실행기 1
```
18/06/13 16:54:29 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:54:29 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:54:29 ERROR YarnClusterScheduler: Lost executor 1 on ip-10-1-2-175.ec2.internal: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:54:29 WARN TaskSetManager: Lost task 0.0 in stage 0.0 (TID 0, ip-10-1-2-175.ec2.internal, executor 1): ExecutorLostFailure (executor 1 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
```
실행기 2
```
18/06/13 16:55:35 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:55:35 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:55:35 ERROR YarnClusterScheduler: Lost executor 2 on ip-10-1-2-16.ec2.internal: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:55:35 WARN TaskSetManager: Lost task 0.1 in stage 0.0 (TID 1, ip-10-1-2-16.ec2.internal, executor 2): ExecutorLostFailure (executor 2 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
```
실행기 3
```
18/06/13 16:56:37 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:56:37 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:56:37 ERROR YarnClusterScheduler: Lost executor 3 on ip-10-1-2-189.ec2.internal: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:56:37 WARN TaskSetManager: Lost task 0.2 in stage 0.0 (TID 2, ip-10-1-2-189.ec2.internal, executor 3): ExecutorLostFailure (executor 3 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
```
실행기 4
```
18/06/13 16:57:18 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:57:18 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:57:18 ERROR YarnClusterScheduler: Lost executor 4 on ip-10-1-2-96.ec2.internal: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:57:18 WARN TaskSetManager: Lost task 0.3 in stage 0.0 (TID 3, ip-10-1-2-96.ec2.internal, executor 4): ExecutorLostFailure (executor 4 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
```
### AWS Glue 동적 프레임을 사용하여 가져오기 크기 설정 수정
Spark JDBC 가져오기 크기에 대한 기본 구성이 0이므로 JDBC 테이블을 읽는 동안 실행기에서 메모리 부족이 발생했습니다. 이는 Spark가 한 번에 한 개씩 행을 스트리밍하더라도 Spark 실행기의 JDBC 드라이버가 데이터베이스의 3400만개 행을 함께 가져와서 캐시하려고 함을 의미합니다. Spark에서 가져오기 크기 파라미터를 0 이외의 기본값으로 설정하여 이 시나리오를 방지할 수 있습니다.
또한 AWS Glue 동적 프레임을 대신 사용하여 이 문제를 해결할 수도 있습니다. 기본적으로 동적 프레임에서는 가져오기 크기로 1,000개 행이 사용되는데, 일반적으로 충분한 값입니다. 결과적으로 실행기에 사용되는 메모리의 양이 총 메모리의 7%를 초과하지 않습니다. AWS Glue 작업은 단일 실행기만으로 2분 안에 완료됩니다. AWS Glue 동적 프레임을 사용하는 것이 권장되는 접근 방식이지만, Apache Spark `fetchsize` 속성을 사용하여 가져오기 크기를 설정할 수도 있습니다. [Spark SQL, DataFrames 및 데이터 세트 가이드](https://spark.apache.org/docs/2.2.0/sql-programming-guide.html#jdbc-to-other-databases)를 참조하십시오.
```
val (url, database, tableName) = {
("jdbc_url", "db_name", "table_name")
}
val source = glueContext.getSource(format, sourceJson)
val df = source.getDynamicFrame
glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet", transformation_ctx = "datasink")
```
**정상 프로파일링된 측정치:** [실행기 메모리](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage)(AWS Glue 동적 프레임 사용)가 다음 이미지와 같이 안전 임곗값을 절대로 초과하지 않습니다. 데이터베이스에서 행을 읽고 어느 시점에든 JDBC 드라이버에 1,000개 행만 캐시합니다. 메모리 부족 예외는 발생하지 않습니다.
![\[안전 임곗값보다 낮은 실행기 메모리를 보여주는 AWS Glue 콘솔입니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-oom-2-memoryprofile-fixed.png)
# 까다로운 단계와 스트래글러 작업 디버깅
AWS Glue 작업 프로파일링을 사용하여 추출, 변환 및 로드(ETL) 작업에서 까다로운 단계와 스트래글러 작업을 식별할 수 있습니다. 스트래글러 작업은 AWS Glue 작업의 단계에서 나머지 작업보다 더 오래 걸립니다. 따라서 해당 단계를 완료하는 데 더 오래 걸리므로 작업의 총 실행 시간도 지연됩니다.
## 작은 입력 파일을 큰 출력 파일로 병합
스트래글러 작업은 여러 작업들 간에 작업량이 균일하지 않게 배포되거나, 데이터 스큐로 인해 한 작업에서 더 많은 데이터를 처리하는 경우에 발생할 수 있습니다.
다음 코드(Apache Spark의 일반 패턴)를 프로파일링하여 다량의 작은 파일을 큰 출력 파일로 병합할 수 있습니다. 예를 들면, 입력 데이터 세트는 JSON Gzip 압축 파일 32GB입니다. 출력 데이터 세트는 거의 190GB에 이르는 압축되지 않은 JSON 파일입니다.
프로파일링된 코드는 다음과 같습니다.
```
datasource0 = spark.read.format("json").load("s3://input_path")
df = datasource0.coalesce(1)
df.write.format("json").save(output_path)
```
### AWS Glue 콘솔에서 프로파일링된 지표 시각화
작업을 프로파일링하여 네 가지 지표 세트를 살펴볼 수 있습니다.
+ ETL 데이터 이동
+ 실행기 간의 데이터 셔플
+ 작업 실행
+ 메모리 프로필
**ETL 데이터 이동**: **ETL 데이터 이동** 프로필에서는 처음 6분 안에 완료되는 첫 번째 단계에서 모든 실행기가 바이트를 매우 빠르게 [읽습니다](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes). 하지만 총 작업 실행 시간은 거의 1시간으로, 이 시간 중 대부분을 데이터 [쓰기](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes)가 차지합니다.
![\[ETL 데이터 이동 프로필을 보여주는 그래프.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-straggler-1.png)
**실행기 간 데이터 셔플:** 셔플링 중에 [읽고](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleLocalBytesRead) [쓴](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleBytesWritten) 바이트 수도 [**작업 실행(Job Execution)**] 및 [**데이터 셔플(Data Shuffle)**] 지표에서 알 수 있듯이 2단계가 끝나기 전 스파이크를 나타냅니다. 모든 실행기의 데이터 셔플 후에는 실행기 번호 3에서만 읽기 및 쓰기가 진행됩니다.
![\[실행기 간의 데이터 셔플 측정치.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-straggler-2.png)
**작업 실행:** 아래 그래프와 같이, 다른 모든 실행기는 유휴 상태이며 최종적으로 10:09에 중지됩니다. 이 시점에는 총 실행기 수가 1로 감소됩니다. 이는 실행기 번호 3이 실행 시간이 가장 오래 걸리고 작업 실행 시간의 대부분을 차지하는 스트래글러 작업으로 이루어짐을 보여줍니다.
![\[활성 실행기의 실행 측정치.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-straggler-3.png)
**메모리 프로필:** 처음 두 단계 이후에는 [실행기 번호 3](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.used)에서 메모리를 적극적으로 소비하며 데이터를 처리합니다. 나머지 실행기는 단순 유휴 상태이거나 처음 두 단계가 완료되고 나서 잠시 후에 중지되었습니다.
![\[처음 두 단계 이후의 메모리 프로필 측정치.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-straggler-4.png)
### 그룹화를 사용하여 스트래글링 실행기 수정
AWS Glue의 *그룹화* 기능을 사용하면 실행기가 뒤처지는 것을 방지할 수 있습니다. 그룹화를 사용하면 데이터를 모든 실행기에 균일하게 분포하고 클러스터의 모든 사용 가능한 실행기를 사용하여 파일을 더 큰 파일로 병합할 수 있습니다. 자세한 내용은 [입력 파일을 더 큰 그룹에서 읽기](grouping-input-files.md) 섹션을 참조하세요.
AWS Glue 작업의 ETL 데이터 이동을 확인하려면 그룹화가 활성화된 상태에서 다음과 같은 코드를 프로파일링합니다.
```
df = glueContext.create_dynamic_frame_from_options("s3", {'paths': ["s3://input_path"], "recurse":True, 'groupFiles': 'inPartition'}, format="json")
datasink = glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "json", transformation_ctx = "datasink4")
```
**ETL 데이터 이동:** 이제 작업 실행 시간 전체에 걸쳐 데이터 쓰기와 데이터 읽기를 병렬로 스트리밍합니다. 따라서 작업이 8분(이전보다 훨씬 빠름) 내에 완료됩니다.
![\[문제를 나타냈던 ETL 데이터 이동이 수정되었습니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-straggler-5.png)
**실행기 간의 데이터 셔플:** 입력 파일이 그룹화 기능을 사용하여 읽는 동안 병합되므로 데이터를 읽은 후에 비용이 많이 들던 데이터 셔플이 발생하지 않습니다.
![\[문제를 나타냈던 데이터 셔플 측정치가 수정되었습니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-straggler-6.png)
**작업 실행:** 작업 실행 측정치는 데이터 실행 및 처리 중인 총 활성 실행기 수가 상당히 일관되게 유지됨을 보여줍니다. 작업에 단일 스트래글러가 없습니다. 모든 실행기가 활성 상태이며 작업이 완료될 때까지 활성 상태로 유지됩니다. 실행기 간에 중간 데이터 셔플이 없으므로 작업에 단일 단계만 존재합니다.
![\[작업에 스트래글러가 없음을 보여주는 작업 실행 위젯의 측정치.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-straggler-7.png)
**메모리 프로파일:** 이 지표는 모든 실행기의 [활성 메모리 소비](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.used)를 표시하여 모든 실행기에서 활동이 존재함을 재확인합니다. 데이터가 동시에 스트리밍되고 작성되므로, 모든 실행기의 총 메모리 공간이 모든 실행기의 안전 임계값보다 훨씬 낮고 거의 균일합니다.
![\[모든 실행기에서 활성 메모리 소비를 보여주는 메모리 프로필 측정치.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-straggler-8.png)
# 여러 작업의 진행 상황 모니터링
여러 AWS Glue 작업을 함께 프로파일링하고 작업 간에 데이터 흐름을 모니터링할 수 있습니다. 이 모니터링은 일반적인 워크플로우 패턴으로, 개별 작업 진행 상황, 데이터 처리 백로그, 데이터 재처리 및 작업 북마크를 모니터링해야 합니다,
**Topics**
+ [프로파일링된 코드](#monitor-debug-multiple-profile)
+ [AWS Glue 콘솔에서 프로파일링된 지표 시각화](#monitor-debug-multiple-visualize)
+ [파일 처리 수정](#monitor-debug-multiple-fix)
## 프로파일링된 코드
이 워크플로우에는 두 가지 작업, 즉 입력 작업과 출력 작업이 있습니다. 입력 작업은 정기 트리거를 사용하여 30분마다 실행하도록 예약되어 있습니다. 출력 작업은 입력 작업의 각각의 성공적인 실행 이후에 실행하도록 예약되어 있습니다. 이러한 예약된 작업은 작업 트리거를 사용하여 제어됩니다.
![\[입력 및 출력 작업 예약을 제어하는 작업 트리거를 보여주는 콘솔 스크린샷.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-multiple-1.png)
**입력 작업**: 이 작업은 Amazon Simple Storage Service(Amazon S3) 위치에서 데이터를 읽고 `ApplyMapping`을 사용하여 변환한 다음, 스테이징 Amazon S3 위치에 씁니다. 다음 코드는 입력 작업용으로 프로파일링된 코드입니다.
```
datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": ["s3://input_path"], "useS3ListImplementation":True,"recurse":True}, format="json")
applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [map_spec])
datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": staging_path, "compression": "gzip"}, format = "json")
```
**출력 작업**: 이 작업은 Amazon S3의 스테이징 위치에서 입력 작업의 출력을 읽고. 다시 변환한 다음, 대상에 씁니다.
```
datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [staging_path], "useS3ListImplementation":True,"recurse":True}, format="json")
applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [map_spec])
datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": output_path}, format = "json")
```
## AWS Glue 콘솔에서 프로파일링된 지표 시각화
다음 대시보드는 출력 작업에 대한 동일한 타임라인에서 입력 작업의 Amazon S3 바이트 쓰기 지표를 Amazon S3 바이트 읽기 지표에 중첩합니다. 이 타임라인은 입력 작업과 출력 작업의 서로 다른 작업 실행을 보여줍니다. 입력 작업(빨간색으로 표시됨)이 30분마다 시작됩니다. 출력 작업(갈색으로 표시됨)은 입력 작업 완료 시 시작되며, 최대 동시성은 1입니다.
![\[읽고 쓴 데이터를 표시하는 그래프.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-multiple-4.png)
이 예에서는, [작업 북마크](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html)가 활성화되지 않습니다. 변환 컨텍스트를 사용하여 스크립트 코드에서 작업 북마크를 활성화하지 않습니다.
**작업 기록**: 입력 및 출력 작업은 오후 12:00부터 시작되는 **기록** 탭에서처럼 여러 번 실행되었습니다.
AWS Glue 콘솔의 입력 작업은 다음과 같습니다.
![\[입력 작업의 기록 탭을 표시하는 콘솔 스크린샷.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-multiple-2.png)
다음 이미지는 출력 작업을 보여줍니다.
![\[출력 작업의 기록 탭을 표시하는 콘솔 스크린샷.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-multiple-3.png)
**첫 번째 작업 실행**: 아래 읽고 쓴 데이터 바이트 그래프에서처럼, 12:00 \$1 12:30의 입력 및 출력 작업의 첫 번째 작업 실행은 거의 동일한 곡선하 면적을 보입니다. 이 면적은 입력 작업에서 쓴 Amazon S3 바이트와 출력 작업에서 읽은 Amazon S3 바이트를 나타냅니다. 또한 이 데이터는 작성된 Amazon S3 바이트의 비율(30분 동안의 합계 - 입력 작업의 경우 작업 트리거 빈도)로 확인됩니다. 오후 12:00에 시작된 입력 작업 비율의 데이터 지점도 1입니다.
다음 그래프는 모든 작업 실행에 대한 데이터 흐름 비율을 보여줍니다.
![\[데이터 흐름 비율을 보여주는 그래프: 쓴 바이트와 읽은 바이트\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-multiple-5.png)
**두 번째 작업 실행**: 두 번째 작업 실행에서 입력 작업에서 쓴 바이트 수와 출력 작업에서 읽은 바이트 수 사이에는 명확한 차이가 있습니다. (출력 작업에 대한 두 작업 실행의 곡선하 면적을 비교하거나, 입력 작업과 출력 작업의 두 번째 실행 시 면적을 비교합니다.) 읽은 바이트 수와 쓴 바이트 수의 비율은 12:30 \$1 13:00의 두 번째 기간인 30분 동안 입력 작업에 의해 작성된 데이터의 약 2.5배를 출력 작업에서 읽었음을 보여줍니다. 이는 작업 북마크가 활성화되지 않았기 때문에 출력 작업이 입력 작업의 첫 번째 작업 실행에서 나오는 출력을 재처리하기 때문입니다. 비율이 1보다 크면 출력 작업에 의해 데이터의 추가 백로그가 처리되었음을 의미합니다.
**세 번째 작업 실행**: 입력 작업은 작성된 바이트 수 면에서 일관성이 거의 유지됩니다(빨간색 곡선하 면적 참조). 하지만, 입력 작업의 세 번째 작업 실행 시간이 예상보다 더 길어졌습니다(빨간색 곡선의 긴 후미부 참조). 결과적으로 출력 작업의 세 번째 작업 실행이 늦게 시작되었습니다. 세 번째 작업은 13:00 \$1 13:30의 나머지 30분 동안 스테이징 위치에 누적된 데이터 부분만 처리했습니다. 바이트 흐름의 비율은 입력 작업의 세 번째 작업 실행에 의해 작성된 데이터의 0.83만 처리되었음을 보여줍니다(13:00의 비율 참조).
**입력 작업과 출력 작업의 중첩**: 입력 작업의 네 번째 작업 실행이 출력 작업의 세 번째 작업 실행이 완료되기 전에 일정에 따라 13:30에 시작되었습니다. 두 작업 실행 사이에 약간의 중첩 부분이 있습니다. 하지만, 출력 작업의 세 번째 작업 실행은 약 13:17에 시작되었을 때 Amazon S3의 스테이징 위치에 나열되어 있는 파일만 캡처합니다. 캡처 데이터는 입력 작업의 첫 번째 작업 실행에서 얻은 모든 데이터 출력으로 구성됩니다. 13:30에서 실제 비율은 약 2.75입니다. 출력 작업의 세 번째 작업 실행에서는 13:30\$114:00의 입력 작업 중 네 번째 작업 실행에서 작성된 데이터의 약 2.75x를 처리했습니다.
이러한 이미지에 표시된 바와 같이, 출력 작업은 입력 작업에 대한 모든 이전 작업 실행의 스테이징 위치부터 데이터를 처리하고 있습니다. 결과적으로, 출력 작업에 대한 네 번째 작업 실행이 가장 길며 입력 작업의 전체 다섯 번째 작업 실행과 겹칩니다.
## 파일 처리 수정
출력 작업에서 출력 작업의 이전 작업 실행에 의해 처리되지 않은 파일만 처리하도록 해야 합니다. 이렇게 하려면 다음과 같이 출력 작업에서 작업 북마크를 활성화하고 변환 컨텍스트를 설정합니다.
```
datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [staging_path], "useS3ListImplementation":True,"recurse":True}, format="json", transformation_ctx = "bookmark_ctx")
```
작업 북마크를 활성화한 상태에서는 출력 작업이 입력 작업에 대한 모든 이전 작업 실행의 스테이징 위치에 있는 데이터를 재처리하지 않습니다. 읽고 쓴 데이터를 보여주는 다음 이미지에서는 갈색 곡선하 면적이 상당히 일관되며 빨간 곡선과 비슷합니다.
![\[읽은 데이터와 쓴 데이터를 빨간색 선과 갈색 선으로 표시하는 그래프.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-multiple-6.png)
추가 데이터 처리가 없으므로 바이트 흐름의 비율도 거의 1에 가깝게 유지됩니다.
![\[데이터 흐름 비율을 보여주는 그래프: 쓴 바이트와 읽은 바이트\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-multiple-7.png)
다음 입력 작업 실행이 시작되기 전에 출력 작업에 대한 작업 실행이 시작되고 스테이징 위치에 있는 파일을 캡처하여 더 많은 데이터를 스테이징 위치에 넣습니다. 이 작업이 계속되는 동안은 이전 입력 작업 실행에서 캡처한 파일만 처리되며 비율이 계속 1에 가깝게 유지됩니다.
![\[데이터 흐름 비율을 보여주는 그래프: 쓴 바이트와 읽은 바이트\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-multiple-7.png)
입력 작업이 예상보다 길어지며, 그 결과로서 출력 작업이 두 입력 작업 실행의 스테이징 위치에 있는 파일을 캡처한다고 가정해 보겠습니다. 그러면 해당 출력 작업 실행에 대해 비율이 1보다 높습니다. 하지만, 출력 작업의 다음 작업 실행에서는 출력 작업의 이전 작업 실행에 의해 이미 처리된 파일이 하나도 처리되지 않습니다.
# DPU 용량 계획 모니터링
AWS Glue의 작업 측정치를 사용하여 AWS Glue 작업을 확장하는 데 사용할 수 있는 데이터 처리 단위(DPU) 수를 추정할 수 있습니다.
**참고**
이 페이지는 AWS Glue 버전 0.9 및 1.0에만 적용됩니다. 최신 버전의 AWS Glue에는 용량 계획 시 추가 고려 사항을 적용하는 비용 절감 기능이 포함되어 있습니다.
**Topics**
+ [프로파일링된 코드](#monitor-debug-capacity-profile)
+ [AWS Glue 콘솔에서 프로파일링된 지표 시각화](#monitor-debug-capacity-visualize)
+ [최적 DPU 용량 결정](#monitor-debug-capacity-fix)
## 프로파일링된 코드
다음 스크립트는 428개의 gzip 압축된 JSON 파일을 포함하는 Amazon Simple Storage Service(Amazon S3) 파티션을 읽습니다. 이 스크립트는 필드 이름에 변경할 매핑을 적용하고 변환한 후 다시 Amazon S3에 Apache Parquet 포맷으로 씁니다. 기본값에 따라 10개 DPU를 프로비저닝하고 이 작업을 실행할 수 있습니다.
```
datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [input_path], "useS3ListImplementation":True,"recurse":True}, format="json")
applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [(map_spec])
datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet")
```
## AWS Glue 콘솔에서 프로파일링된 지표 시각화
**작업 실행 1:** 이 작업 실행에서는 클러스터에서 부족 프로비저닝된 DPU가 있는지 알아보는 방법을 보여줍니다. AWS Glue의 작업 실행 기능은 [능동적으로 실행 중인 총 실행기 수](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors), [완료된 단계 수](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.numCompletedStages), 그리고 [최대 필요 실행기 수](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors)를 표시합니다.
최대 필요 실행기 수는 총 실행 중인 작업 수와 보류 작업 수를 합한 다음 실행기당 작업 수로 나누어서 계산합니다. 이 결과는 현재 부하를 충족하는 데 필요한 총 실행기 수를 나타내는 측정치입니다.
이와는 대조적으로, 능동적으로 실행 중인 실행기 수는 활성 Apache Spark 작업을 실행 중인 실행기 수를 측정합니다. 작업이 진행됨에 따라 최대 필요 실행기가 변경될 수 있으며 일반적으로 보류 작업 대기열이 축소되면서 작업 완료에 가까워질수록 줄어듭니다.
다음 그래프의 가로 빨간색 선은 최대 할당 실행기 수를 표시하며, 이는 작업에 할당하는 DPU 수에 따라 달라집니다. 이 경우, 작업 실행에 대해 10개 DPU를 할당합니다. 하나의 DPU는 관리용으로 예약되어 있습니다. 9개 DPU가 각각 실행기 두 개를 실행하며 실행기 하나가 Spark 드라이버용으로 예약되어 있습니다. Spark 드라이버는 기본 애플리케이션에서 실행됩니다. 그러므로 최대 할당 실행기 수는 2\$19 - 1 = 17개입니다.
![\[활성 실행기 및 최대 필요 실행기를 표시하는 작업 측정치.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-capacity-1.png)
그래프가 표시될 때, 최대 필요 실행기 수는 작업 시작 시 107로 시작하지만, 활성 실행기 수는 17개로 유지됩니다. 이 개수는 DPU 수가 10개인 최대 할당 실행기 수와 동일합니다. 최대 필요 실행기 수와 최대 할당 실행기 수 간의 비율(Spark 드라이버에 대해 두 수치에 모두 1을 더함)은 부족 프로비저닝 계수를 제공합니다. 즉, 108/18 = 6x. 최대 병렬화로 실행하고 더 빨리 완료하도록 작업을 확장하기 위해 6(언더프로비저닝 비율)\$19(현재 DPU 용량 - 1) \$1 DPU 1개 = DPU 55개를 프로비저닝할 수 있습니다.
AWS Glue 콘솔은 자세한 작업 지표를 원래 할당된 최대 실행기 수를 나타내는 정적 행으로 표시합니다. 이 콘솔은 지표에 대한 작업 정의에서 할당된 최대 실행기를 계산합니다. 반면 자세한 작업 실행 지표의 경우 이 콘솔은 작업 실행 구성에서 할당된 최대 실행기, 특히 작업 실행에 대해 할당된 DPU를 계산합니다. 개별 작업 실행에 대한 지표를 보려면 작업 실행을 선택하고 **View run metrics(실행 지표 보기)**를 선택합니다.
![\[ETL 데이터 이동을 표시하는 작업 측정치\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-capacity-2.png)
[읽고](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) [쓴](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes) Amazon S3 바이트를 살펴보면 작업이 Amazon S3에서 데이터를 스트리밍하고 병렬로 쓰는 데 6분을 모두 소비함을 알 수 있습니다. 할당된 DPU의 모든 코어가 Amazon S3에(서) 읽고 쓰고 있습니다. 최대 필요 실행기 수(107)는 입력 Amazon S3 경로의 파일 수(428)와도 일치합니다. 각 실행기는 Spark 작업 네 개를 시작하여 네 개 입력 파일(JSON gzip 압축됨)을 처리할 수 있습니다.
## 최적 DPU 용량 결정
이전 작업 실행 결과에 따라, 총 할당된 DPU 수를 55로 늘리고 작업이 어떻게 수행되는지 알아볼 수 있습니다. 작업이 이전 소요 시간의 절반에 해당하는 3분 이내에 완료됩니다. 단기 실행 작업이므로 이 경우에는 작업 확장이 선형적이지 않습니다. 장기 지속 작업이나 다량의 작업을 포함하는 작업(최대 필요 실행기 수가 많음)은 선형에 가까운 DPU 확장 성능 가속화가 도움이 됩니다.
![\[총 할당 DPU 수 증가를 보여주는 그래프\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-capacity-3.png)
위 이미지에서 볼 수 있듯이 활성 실행기의 총 수는 할당된 최대값인 107개에 도달합니다. 마찬가지로, 최대 필요 실행기는 최대 할당 실행기 수보다 절대 높지 않습니다. 최대 필요 실행기 수는 능동적으로 실행 중인 작업 수와 보류 중인 작업 수에서 계산되므로 활성 실행기 수보다 작을 수도 있습니다. 이는 짧은 시간 동안 부분적으로 또는 전체적으로 유휴 상태이거나 아직 폐기되지 않은 실행기가 있을 수 있기 때문입니다.
![\[총 활성 실행기 수가 최대 할당 개수에 도달함을 보여주는 그래프\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-capacity-4.png)
이 작업 실행은 6x 이상의 실행기를 사용하여 Amazon S3에서 데이터를 동시에 읽고 씁니다. 결과적으로 이 작업은 읽기 및 쓰기에 모두 더 많은 Amazon S3 대역폭을 사용하여 더 빨리 완료합니다.
### 과다 프로비저닝된 DPU 식별
다음에는, DPU가 100개(99 \$1 2 = 198개 실행기)인 작업을 확장하는 것이 성능을 향상하는 데 도움이 되는지 여부를 결정할 수 있습니다. 다음 그래프와 같이, 작업을 완료하는 데 여전히 3분이 걸립니다. 마찬가지로, 이 작업은 실행기를 107 개 이상(55개 DPU 구성)으로 확장하지 않으며, 남은 91개 실행기가 과다 프로비저닝되고 전혀 사용되지 않습니다. 이는 최대 필요 실행기 수에서 분명히 알 수 있듯이 DPU 수를 늘리는 것이 항상 성능을 향상시키지는 않을 수도 있음을 보여줍니다.
![\[DPU 수를 늘리는 것이 작업 성능을 항상 향상시키지는 않음을 보여주는 그래프.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/monitor-debug-capacity-5.png)
### 시간차 비교
다음 표에 나와 있는 세 가지 작업 실행은 10개 DPU, 55개 DPU 및 100개 DPU에 대한 작업 실행 시간을 요약한 것입니다. 첫 번째 작업 실행을 모니터링함으로써 설정한 추정치를 사용하여 작업 실행 시간을 개선할 DPU 용량을 찾아낼 수 있습니다.
| 작업 ID | DPU 수 | 실행 시간 |
| --- | --- | --- |
| jr\$1c894524c8ef5048a4d9... | 10 | 6분 |
| jr\$11a466cf2575e7ffe6856... | 55 | 3분 |
| jr\$134fa1ed4c6aa9ff0a814... | 100 | 3분 |