",
transformationContext="datasource"
).getDynamicFrame()
val ruleset = """
Rules = [
(ColumnValues "age" >= 26) OR (ColumnLength "name" >= 4)
]
"""
val dq_results = EvaluateDataQuality.processRows(
frame=datasource,
ruleset=ruleset,
additionalOptions=JsonOptions("""
{
"compositeRuleEvaluation.method":"ROW"
}
"""
)
)
}
```
AWS Glue Data Catalog에서는 아래와 같이 사용자 인터페이스에서 이 옵션을 쉽게 구성할 수 있습니다.
![\[이 스크린샷은 행과 열 사이에서 규칙 평가 구성을 선택할 수 있는 복합 규칙 설정 창을 보여줍니다. 행을 선택하면 복합 규칙은 전체 행을 평가하는 단일 규칙으로 작동합니다. 열을 선택하면 복합 규칙은 전체 데이터 세트에서 개별 규칙을 평가하고 결과를 결합합니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/composite-rule-settings.png)
일단 설정되면 복합 규칙은 전체 행을 평가하는 단일 규칙으로 작동합니다. 다음 예제는 이 동작을 보여 줍니다.
```
# Row Level outcome
+------+------+------------------------------------------------------------+---------------------------+
|myCol1|myCol2|DataQualityRulesPass |DataQualityEvaluationResult|
+------+------+------------------------------------------------------------+---------------------------+
|2 |1 |[(ColumnValues "myCol1" > 1) OR (ColumnValues "myCol2" > 2)]|Passed |
|0 |3 |[(ColumnValues "myCol1" > 1) OR (ColumnValues "myCol2" > 2)]|Passed |
+------+------+------------------------------------------------------------+---------------------------+
```
일부 규칙은 임계값이나 비율에 따라 전체 결과가 달라지므로 이 기능에서 지원되지 않습니다. 이는 아래에 나열되어 있습니다.
비율에 따른 규칙:
+ 완전성
+ DatasetMatch
+ ReferentialIntegrity
+ Uniqueness
임계값에 따른 규칙:
다음 규칙에 with threshold가 포함된 경우 해당 규칙은 지원되지 않습니다. 그러나 `with threshold`를 포함하지 않는 규칙은 계속 지원됩니다.
+ ColumnDataType
+ ColumnValues
+ CustomSQL
### Expressions
규칙 유형이 부울 응답을 생성하지 않는 경우 부울 응답을 생성하려면 표현식을 파라미터로 제공해야 합니다. 예를 들어 다음 규칙은 열에 있는 모든 값의 중앙값(평균)을 표현식과 비교하여 true 또는 false 결과를 반환합니다.
```
Mean "colA" between 80 and 100
```
`IsUnique` 및 `IsComplete`와 같은 일부 규칙 유형은 이미 부울 응답을 반환합니다.
다음 표는 DQDL 규칙에서 사용할 수 있는 표현식을 나열합니다.
**지원되는 DQDL 표현식**
| 표현식 | 설명 | 예제 |
| --- | --- | --- |
| =x | 규칙 유형 응답이 x와 같은 경우 true로 확인됩니다. | Completeness "colA" = "1.0",
ColumnValues "colA" = "2022-06-30"
|
| \$1=x | 규칙 유형 응답이 x와 같지 않으면 x는 true로 확인됩니다. | ColumnValues "colA" != "a",
ColumnValues "colA" != "2022-06-30"
|
| > x | 규칙 유형 응답이 x보다 큰 경우 true로 확인됩니다. | ColumnValues "colA" > 10
|
| < x | 규칙 유형 응답이 x보다 작은 경우 true로 확인됩니다. | ColumnValues "colA" < 1000,
ColumnValues "colA" < "2022-06-30"
|
| >= x | 규칙 유형 응답이 x보다 크거나 같은 경우 true로 확인됩니다. | ColumnValues "colA" >= 10
|
| <= x | 규칙 유형 응답이 x보다 작거나 같은 경우 true로 확인됩니다. | ColumnValues "colA" <= 1000
|
| between x and y | 규칙 유형 응답이 지정된 범위(제외)에 속하는 경우 true로 확인됩니다. 이 표현식 유형은 숫자 및 날짜 유형에만 사용해야 합니다. | Mean "colA" between 8 and 100,
ColumnValues "colA" between "2022-05-31" and "2022-06-30"
|
| x 및 y 사이가 아님 | 규칙 유형 응답이 지정된 범위(포함)에 속하지 않으면 true로 확인됩니다. 이 표현식 유형은 숫자 및 날짜 유형에만 사용해야 합니다. | ColumnValues "colA" not between "2022-05-31" and "2022-06-30"
|
| in [a, b, c, ...] | 규칙 유형 응답이 지정된 세트 내에 있는 경우 true로 확인됩니다. | ColumnValues "colA" in [ 1, 2, 3 ],
ColumnValues "colA" in [ "a", "b", "c" ]
|
| not in [a, b, c, ...] | 규칙 유형 응답이 지정된 세트에 없으면 true로 확인됩니다. | ColumnValues "colA" not in [ 1, 2, 3 ],
ColumnValues "colA" not in [ "a", "b", "c" ]
|
| matches /ab\$1c/i | 규칙 유형 응답이 정규 표현식과 일치하는 경우 true로 확인됩니다. | ColumnValues "colA" matches "[a-zA-Z]*"
|
| /ab\$1c/i와 일치하지 않음 | 규칙 유형 응답이 정규식과 일치하지 않는 경우 true로 확인됩니다. | ColumnValues "colA" not matches "[a-zA-Z]*"
|
| now() | ColumnValues 규칙 유형에서만 작동하여 날짜 표현식을 생성합니다. | ColumnValues "load_date" > (now() - 3 days)
|
| matches/in […]/not matches/not in [...] with threshold | 규칙 조건과 일치하는 값의 백분율을 지정합니다. ColumnValues, ColumnDataType, CustomSQL 규칙 유형에만 적용됩니다. | ColumnValues "colA" in ["A", "B"] with threshold > 0.8,
ColumnValues "colA" matches "[a-zA-Z]*" with threshold between 0.2 and 0.9
ColumnDataType "colA" = "Timestamp" with threshold > 0.9
|
#### NULL, EMPTY, WHITESPACES\$1ONLY에 대한 키워드
문자열 열에 null, 비어 있음 또는 공백만 있는 문자열이 있는지 확인하려면 다음 키워드를 사용할 수 있습니다.
+ NULL/null - 이 키워드는 문자열 열의 `null` 값에 대해 true로 확인됩니다.
`ColumnValues "colA" != NULL with threshold > 0.5`는 데이터의 50% 이상에 null 값이 없는 경우 true를 반환합니다.
`(ColumnValues "colA" = NULL) or (ColumnLength "colA" > 5)`는 null 값이 있거나 길이가 5를 초과하는 모든 행에 대해 true를 반환합니다. **이 경우 "compositeRuleEvaluation.method" = "ROW" 옵션을 사용해야 한다는 점에 유의하세요.
+ EMPTY/empty - 이 키워드는 문자열 열의 빈 문자열("") 값에 대해 true로 확인됩니다. 일부 데이터 형식은 문자열 열의 null을 빈 문자열로 변환합니다. 이 키워드는 데이터에서 빈 문자열을 필터링하는 데 도움이 됩니다.
`(ColumnValues "colA" = EMPTY) or (ColumnValues "colA" in ["a", "b"])`는 행이 비어 있거나 "a" 또는 "b"인 경우 true를 반환합니다. **이 경우 "compositeRuleEvaluation.method" = "ROW" 옵션을 사용해야 한다는 점에 유의하세요.
+ WHITESPACES\$1ONLY/whitespaces\$1only - 이 키워드는 문자열 열에 공백(" ") 값만 있는 문자열에 대해 true로 확인됩니다.
`ColumnValues "colA" not in ["a", "b", WHITESPACES_ONLY]`는 ‘a’, ‘b’ 또는 공백만 있는 행이 아닌 경우 true를 반환합니다.
지원되는 규칙:
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
숫자 또는 날짜 기반 표현식에서 열에 null이 있는지 확인하려는 경우 다음 키워드를 사용할 수 있습니다.
+ NULL/null - 이 키워드는 문자열 열의 null 값에 대해 true로 확인됩니다.
`ColumnValues "colA" in [NULL, "2023-01-01"]`은 열의 날짜가 `2023-01-01`이거나 null인 경우 true를 반환합니다.
`(ColumnValues "colA" = NULL) or (ColumnValues "colA" between 1 and 9)`는 null 값이 있거나 1에서 9 사이의 값을 갖는 모든 행에 대해 true를 반환합니다. **이 경우 "compositeRuleEvaluation.method" = "ROW" 옵션을 사용해야 한다는 점에 유의하세요.
지원되는 규칙:
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
#### Where 절을 사용한 필터링
**참고**
여기에서 조항은 AWS Glue 4.0에서만 지원됩니다.
규칙을 작성할 때 데이터를 필터링할 수 있습니다. 이는 조건부 규칙을 적용하려는 경우에 유용합니다.
```
where " "
```
필터는 `where` 키워드와 따옴표(`("")`)로 묶인 유효한 SparkSQL 문을 사용하여 지정해야 합니다.
임계값이 있는 규칙에 where 절을 추가하려면 임계값 조건보다 먼저 where 절을 지정해야 합니다.
```
where "valid SparkSQL statement>" with threshold
```
이 구문을 사용하면 다음과 같은 규칙을 작성할 수 있습니다.
```
Completeness "colA" > 0.5 where "colB = 10"
ColumnValues "colB" in ["A", "B"] where "colC is not null" with threshold > 0.9
ColumnLength "colC" > 10 where "colD != Concat(colE, colF)"
```
제공된 SparkSQL 문이 유효한지 검증해보겠습니다. 유효하지 않은 경우 규칙 평가가 실패하고 다음 형식의 `IllegalArgumentException`이 실행됩니다.
```
Rule where "" has provided an invalid where clause :
```
**행 수준 오류 레코드 식별 기능이 켜져 있을 때의 Where 절 동작**
AWS Glue Data Quality를 사용하면 실패한 특정 레코드를 식별할 수 있습니다. 행 수준 결과를 지원하는 규칙에 where 절을 적용할 때는 where 절로 필터링된 행에 `Passed`라는 레이블을 지정합니다.
필터링된 행에 별도로 `SKIPPED`라는 레이블을 지정하려는 경우 ETL 작업에 대해 다음 `additionalOptions`를 설정할 수 있습니다.
```
object GlueApp {
val datasource = glueContext.getCatalogSource(
database="",
tableName="",
transformationContext="datasource"
).getDynamicFrame()
val ruleset = """
Rules = [
IsComplete "att2" where "att1 = 'a'"
]
"""
val dq_results = EvaluateDataQuality.processRows(
frame=datasource,
ruleset=ruleset,
additionalOptions=JsonOptions("""
{
"rowLevelConfiguration.filteredRowLabel":"SKIPPED"
}
"""
)
)
}
```
다음 규칙 및 데이터 프레임을 예시로 참조하세요.
```
IsComplete att2 where "att1 = 'a'"
```
| id | att1 | att2 | 행 수준 결과(기본값) | 행 수준 결과(Skipped 옵션) | 설명 |
| --- | --- | --- | --- | --- | --- |
| 1 | a | f | 통과 | 통과 | |
| 2 | b | d | 통과 | SKIPPED | att1이 "a"가 아니므로 행이 필터링됩니다. |
| 3 | a | null | FAILED | FAILED | |
| 4 | a | f | 통과 | 통과 | |
| 5 | b | null | 통과 | SKIPPED | att1이 "a"가 아니므로 행이 필터링됩니다. |
| 6 | a | f | 통과 | 통과 | |
### 상수
DQDL에서 상수 값을 정의하고 스크립트 전체에서 참조할 수 있습니다. 이는 허용 가능한 경계를 초과할 수 있는 큰 SQL 문으로 작업할 때처럼 쿼리 크기 제한과 관련된 문제를 방지하는 데 도움이 됩니다. 이러한 값을 상수에 할당하면 DQDL을 간소화하고 이러한 제한에 도달하지 않도록 할 수 있습니다.
다음 예제는 상수를 정의하고 사용하는 방법을 보여줍니다.
```
mySql = "select count(*) from primary"
Rules = [
CustomSql $mySql between 0 and 100
]
```
이 예제에서는 SQL 쿼리가 상수 `mySql`에 할당된 다음 이 상수가 `$` 접두사를 사용하여 규칙에서 참조됩니다.
### 레이블
레이블은 데이터 품질 결과를 구성하고 분석하는 효과적인 방법을 제공합니다. 특정 레이블로 결과를 쿼리하여 특정 범주 내의 실패한 규칙을 식별하고, 팀 또는 도메인별로 규칙 결과를 계산하고, 다양한 이해관계자를 위한 집중 보고서를 생성할 수 있습니다.
예를 들어 `"team=finance"` 레이블을 사용하여 재무 팀과 관련된 모든 규칙을 적용하고 재무 팀과 관련된 품질 지표를 보여주는 사용자 지정 보고서를 생성할 수 있습니다. 우선순위가 높은 규칙에 `"criticality=high"` 레이블을 지정하여 문제 해결 작업의 우선순위를 지정할 수 있습니다. 레이블은 DQDL의 일부로 작성할 수 있습니다. 규칙 결과, 행 수준 결과, API 응답의 일부로 레이블을 쿼리할 수 있어, 기존 모니터링 및 보고 워크플로와 쉽게 통합할 수 있습니다.
**참고**
레이블은 AWS Glue ETL에서만 사용할 수 있으며 AWS Glue Data Catalog 기반 Data Quality에서는 사용할 수 없습니다.
#### DQDL 레이블 구문
DQDL은 기본 레이블과 규칙별 레이블을 모두 지원합니다. 기본 레이블은 규칙 세트 수준에서 정의되며 해당 규칙 세트 내의 모든 규칙에 자동 적용됩니다. 개별 규칙에는 자체 레이블이 있을 수 있으며, 레이블이 키 값 페어로 구현되므로 동일한 키를 사용할 때 규칙별 레이블이 기본 레이블을 재정의할 수 있습니다.
다음 예제에서는 기본 레이블과 규칙별 레이블을 사용하는 방법을 보여줍니다.
```
DefaultLabels=["frequency"="monthly"]
Rules = [
// Auto includes the default label ["frequency"="monthly"]
ColumnValues "col" > 21,
// Add ["foo"="bar"] to default label. Labels for this rule would be ["frequency"="monthly", "foo"="bar"]
Rule 1 with threshold > 0.8 labels=["foo"="bar"],
// Override default label. Labels for this rule would be ["frequency"="daily", "foo"="bar"]
Rule 2 with threshold > 0.8 labels=["foo"="bar", "frequency"="daily"]
// Labels must be applied to the entire composite rule (parentheses required)
(Rule 1 AND Rule 2) labels=["foo"="bar]
]
```
##### 레이블 제약 조건
레이블의 제약 조건은
+ DQDL 규칙당 최대 10개의 레이블입니다.
+ 레이블은 키 값 페어 목록으로 지정됩니다.
+ 레이블 키와 레이블 값은 대소문자를 구분합니다.
+ 레이블 키의 최대 길이는 128자입니다. 레이블 키는 비어 있거나 null이면 안 됩니다.
+ 레이블 값의 최대 길이는 256자입니다. 레이블 값은 비어 있거나 null일 수 있습니다.
#### DQDL 레이블 검색
규칙 결과, 행 수준 결과, API 응답에서 DQDL 레이블을 검색할 수 있습니다.
##### 규칙 결과
DQDL 레이블은 규칙 결과에 항상 표시됩니다. DQDL 레이블을 활성화하기 위해 필요한 추가 구성은 없습니다.
##### 행 수준 결과
DQDL 레이블은 행 수준 결과에서 기본적으로 비활성화되지만 `EvaluateDataQuality`에서 `AdditionalOptions`를 사용하여 활성화할 수 있습니다.
다음 예제는 행 수준 결과에서 레이블을 활성화하는 방법을 보여줍니다.
```
val evaluateResult = EvaluateDataQuality.processRows(
frame=AmazonS3_node1754591511068,
ruleset=example_ruleset,
publishingOptions=JsonOptions("""{
"dataQualityEvaluationContext": "evaluateResult",
"enableDataQualityCloudWatchMetrics": "true",
"enableDataQualityResultsPublishing": "true"
}"""),
additionalOptions=JsonOptions("""{
"performanceTuning.caching":"CACHE_NOTHING",
"observations.scope":"ALL",
"rowLevelConfiguration.ruleWithLabels":"ENABLED"
}""")
)
```
활성화되면 행 수준 결과 데이터 프레임에 `DataQualityRulesPass`, `DataQualityRulesFail`, `DataQualityRulesSkip` 열의 각 규칙의 레이블이 포함됩니다.
##### API 응답
DQDL 레이블은 `RuleResults` 객체의 새 필드 `Labels` 아래에 있는 API 응답에 항상 표시됩니다.
다음 예제는 API 응답의 레이블을 보여줍니다.
```
{
"ResultId": "dqresult-example",
"ProfileId": "dqprofile-example",
"Score": 0.6666666666666666,
"RulesetName": "EvaluateDataQuality_node1754591514205",
"EvaluationContext": "EvaluateDataQuality_node1754591514205",
"StartedOn": "2025-08-22T19:36:10.448000+00:00",
"CompletedOn": "2025-08-22T19:36:16.368000+00:00",
"JobName": "anniezc-test-labels",
"JobRunId": "jr_068f6d7a45074d9105d14e4dee09db12c3b95664b45f6ee44fa29ed7e5619ba8",
"RuleResults": [
{
"Name": "Rule_0",
"Description": "IsComplete colA",
"EvaluationMessage": "Input data does not include column colA!",
"Result": "FAIL",
"EvaluatedMetrics": {},
"EvaluatedRule": "IsComplete colA",
"Labels": {
"frequency": "monthly"
}
},
{
"Name": "Rule_1",
"Description": "Rule 1 with threshold > 0.8",
"Result": "PASS",
"EvaluatedMetrics": {},
"EvaluatedRule": "Rule 1 with threshold > 0.8",
"Labels": {
"frequency": "monthly",
"foo": "bar"
}
},
{
"Name": "Rule_3",
"Description": "Rule 2 with threshold > 0.8",
"Result": "PASS",
"EvaluatedMetrics": {},
"EvaluatedRule": "Rule 2 with threshold > 0.8",
"Labels": {
"frequency": "daily",
"foo": "bar"
}
}
]
}
```
### 동적 규칙
**참고**
동적 규칙은 AWS Glue ETL에서만 지원되며 AWS Glue Data Catalog에서 지원되지 않습니다.
이제 동적 규칙을 작성하여 규칙에 의해 생성된 현재 지표를 기록 값과 비교할 수 있습니다. 이러한 기록 비교는 표현식에 `last()` 연산자를 사용하여 사용할 수 있습니다. 예를 들어 현재 실행 중인 행 수가 동일한 데이터 세트에 대한 가장 최근의 이전 행 수보다 많을 때 규칙 `RowCount > last()`가 성공합니다. `last()`는 고려할 기록 지표의 개수를 나타내는 선택적 자연수 인수를 취하고, `last(k)`는 마지막 `k` 지표를 참조하는 `k >= 1`을 취합니다.
+ 사용 가능한 데이터 포인트가 없는 경우 `last(k)`는 기본값 0.0을 반환합니다.
+ 사용할 수 있는 지표가 `k`개 미만인 경우 `last(k)`는 이전 지표를 모두 반환합니다.
유효한 표현식을 만들려면 `last(k)`를 사용합니다. 여기서 `k > 1`에는 여러 개의 기록 결과를 하나의 숫자로 줄이는 집계 함수가 필요합니다. 예를 들어 `RowCount > avg(last(5))`는 현재 데이터 세트의 행 수가 동일한 데이터 세트의 최근 5개 행 수의 평균보다 확실하게 큰지 확인합니다. `RowCount > last(5)`는 현재 데이터 세트 행 수를 목록과 유의미하게 비교할 수 없기 때문에 오류를 생성합니다.
지원되는 집계 함수:
+ `avg`
+ `median`
+ `max`
+ `min`
+ `sum`
+ `std`(표준 편차)
+ `abs`(절대값)
+ `index(last(k), i)`를 사용하면 최근 `k`개 중 가장 최근인 `i`번째 값을 선택할 수 있습니다. `i`는 0으로 인덱싱되므로 `index(last(3), 0)`은 가장 최근의 데이터 포인트를 반환하고, `index(last(3), 3)`은 데이터 포인트가 3개뿐이지만 4번째 가장 최근의 데이터 포인트를 인덱싱하려고 시도하기 때문에 오류가 발생합니다.
**샘플 표현식**
**ColumnCorrelation**
+ `ColumnCorrelation "colA" "colB" < avg(last(10))`
**DistinctValuesCount**
+ `DistinctValuesCount "colA" between min(last(10))-1 and max(last(10))+1`
숫자 조건 또는 임곗값이 있는 대부분의 규칙 유형은 동적 규칙을 지원합니다. 제공된 테이블인 [분석기 및 규칙](#dqdl-analyzers-table)을 참조하여 해당 규칙 유형에 동적 규칙이 지원되는지 확인하세요.
**동적 규칙에서 통계 제외**
때때로 동적 규칙 계산에서 데이터 통계를 제외해야 합니다. 과거 데이터 로드를 수행했지만 평균에 영향을 주지 않기를 원한다고 가정합니다. 이를 위해 AWS Glue ETL에서 작업을 열고 **데이터 품질** 탭을 선택한 다음, **통계**를 선택하고 제외하려는 통계를 선택합니다. 통계 테이블과 함께 추세 차트를 볼 수 있습니다. 제외하려는 값을 선택하고 **통계 제외**를 선택합니다. 이제 제외된 통계는 동적 규칙 계산에 포함되지 않습니다.
![\[스크린샷에서는 통계를 선택한 후 드롭다운 메뉴에서 통계를 제외하거나 포함하는 옵션을 보여줍니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/data-quality-excluding-statistics-from-dynamic-rules.png)
### 분석기
**참고**
분석기는 AWS Glue 데이터 카탈로그에서 지원되지 않습니다.
DQDL 규칙은 분석기**라는 함수를 사용하여 데이터에 대한 정보를 수집합니다. 이 정보는 규칙의 부울 표현식에 의해 사용되어 규칙의 성공 또는 실패 여부를 결정합니다. 예를 들어 RowCount 규칙 `RowCount > 5 `는 행 수 분석기를 사용하여 데이터 세트의 행 수를 검색하고, 그 수를 표현식 `> 5`와 비교하여 현재 데이터 세트에 5개 이상의 행이 존재하는지 확인합니다.
때로는 규칙을 작성하는 대신 분석기를 생성한 다음 이상을 탐지하는 데 사용할 수 있는 통계를 생성하는 것을 권장합니다. 이러한 경우에는 분석기를 생성할 수 있습니다. 분석기는 다음과 같은 점에서 규칙과 다릅니다.
| 기능 | 분석기 | 규칙 |
| --- | --- | --- |
| 규칙 세트의 일부 | 예 | 예 |
| 통계 생성 | 예 | 예 |
| 관찰 결과 생성 | 예 | 예 |
| 조건 평가 및 어설션 가능 | 아니요 | 예 |
| 실패 시 작업 중지, 작업 계속 처리 등의 작업을 구성할 수 있음 | 아니요 | 예 |
분석기는 규칙 없이 독립적으로 존재할 수 있으므로 신속하게 구성하고 데이터 품질 규칙을 점진적으로 구축할 수 있습니다.
일부 규칙 유형은 규칙 세트의 `Analyzers` 블록에 입력하여 분석기에 필요한 규칙을 실행하고 조건에 대한 검사를 적용하지 않고 정보를 수집할 수 있습니다. 일부 분석기는 규칙과 연결되지 않으며 `Analyzers` 블록에만 입력할 수 있습니다. 다음 테이블에는 각 항목이 규칙 또는 독립 실행형 분석기로 지원되는지 여부와 각 규칙 유형에 대한 추가 세부 정보가 나와 있습니다.
**분석기를 사용한 규칙 세트 예제**
다음 규칙 세트는 다음을 사용합니다.
+ 데이터 세트가 지난 세 번의 작업 실행에 대한 후행 평균보다 증가하고 있는지 확인하는 동적 규칙
+ 데이터 세트의 `Name` 열에 고유한 값의 수를 기록하는 `DistinctValuesCount` 분석기
+ 시간 경과에 따른 최소 및 최대 `Name` 크기를 추적하는 `ColumnLength` 분석기
분석기 메트릭 결과는 작업 실행의 Data Quality 탭에서 확인할 수 있습니다.
```
Rules = [
RowCount > avg(last(3))
]
Analyzers = [
DistinctValuesCount "Name",
ColumnLength "Name"
]
```
AWS Glue Data Quality는 다음 분석기를 지원합니다.
| 분석기 이름 | 기능 |
| --- | --- |
| RowCount | 데이터 세트의 행 수를 계산합니다. |
| Completeness | 열의 완전성 백분율을 계산합니다. |
| Uniqueness | 열의 고유성 비율을 계산합니다. |
| Mean | 숫자 열의 평균을 계산합니다. |
| Sum | 숫자 열의 합계를 계산합니다. |
| StandardDeviation | 숫자 열의 표준 편차를 계산합니다. |
| Entropy | 숫자 열의 엔트로피를 계산합니다. |
| DistinctValuesCount | 열의 고유 값 수를 계산합니다. |
| UniqueValueRatio | 열의 고유 값 비율을 계산합니다. |
| ColumnCount | 데이터 세트의 열 수를 계산합니다. |
| ColumnLength | 열의 길이를 계산합니다. |
| ColumnValues | 숫자 열의 최소값, 최대값을 계산합니다. 숫자가 아닌 열의 최소 열 길이 및 최대 열 길이를 계산합니다. |
| ColumnCorrelation | 지정된 열의 열 상관 관계를 계산합니다. |
| CustomSql | CustomSQL에서 반환된 통계를 계산합니다. |
| AllStatistics | 다음 통계를 계산합니다.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/dqdl.html) |
### 설명
‘\$1’ 문자를 사용하여 DQDL 문서에 설명을 추가할 수 있습니다. ‘\$1’ 문자 이후부터 줄 끝까지의 모든 내용은 DQDL에서 무시됩니다.
```
Rules = [
# More items should generally mean a higher price, so correlation should be positive
ColumnCorrelation "price" "num_items" > 0
]
```
# DQDL 규칙 유형 참조
이 섹션에서는 AWS Glue 데이터 품질에서 지원하는 각 규칙 유형에 대한 참조를 제공합니다.
**참고**
DQDL은 현재 중첩형 또는 목록형 열 데이터를 지원하지 않습니다.
아래 테이블의 괄호로 묶인 값은 규칙 인수에 제공된 정보로 대체됩니다.
규칙에는 일반적으로 표현식에 대한 추가 인수가 필요합니다.
| Ruletype | 설명 | 인수 | 보고된 지표 | 규칙으로 지원되나요? | 분석기로 지원되나요? | 행 수준 결과를 반환하나요? | 동적 규칙이 지원되나요? | 관찰 결과 생성 | Where 절 구문을 지원합니까? |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| AggregateMatch | 총 판매액과 같은 요약 지표를 비교하여 두 데이터 세트가 일치하는지 확인합니다. 금융 기관에서 모든 데이터가 소스 시스템에서 수집되었는지 비교할 때 유용합니다. | 하나 이상의 집계 | 첫 번째 및 두 번째 집계 열 이름이 일치하는 경우: `Column.[Column].AggregateMatch` 첫 번째 및 두 번째 집계 열 이름이 다른 경우: `Column.[Column1,Column2].AggregateMatch` | 예 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| AllStatistics | 데이터 세트의 제공된 열에 대한 여러 지표를 수집하는 독립 실행형 분석기 | 단일 열 이름 | 모든 유형의 열에 적용됩니다. `Dataset.*.RowCount` `Column.[Column].Completeness` `Column.[Column].Uniqueness` 문자열 값 열에 대한 추가 지표: `ColumnLength metrics` 숫자 값 열에 대한 추가 지표: `ColumnValues metrics` | 아니요 | 예 | 아니요 | 아니요 | 아니요 | 아니요 |
| ColumnCorrelation | 두 열의 상관 관계 수준을 확인합니다. | 정확히 두 개의 열 이름 | Multicolumn.[Column1,Column2].ColumnCorrelation | 예 | 예 | 아니요 | 예 | 아니요 | 예 |
| ColumnCount | 삭제된 열이 있는지 확인합니다. | 없음 | Dataset.\$1.ColumnCount | 예 | 예 | 아니요 | 예 | 예 | 아니요 |
| ColumnDataType | 열이 데이터 형식을 준수하는지 확인합니다. | 정확히 하나의 열 이름 | Column.[Column].ColumnDataType.Compliance | 예 | 아니요 | 아니요 | 예, 행 수준 임곗값 표현식에서 | 아니요 | 예 |
| ColumnExists | 데이터 세트에 열이 있는지 확인합니다. 이를 통해 고객은 특정 열을 사용할 수 있도록 셀프 서비스 데이터 플랫폼을 구축할 수 있습니다. | 정확히 하나의 열 이름 | N/A | 예 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| ColumnLength | 데이터 길이가 일관되는지 확인합니다. | 정확히 하나의 열 이름 | `Column.[Column].MaximumLength` `Column.[Column].MinimumLength` 행 수준 임곗값이 제공된 경우 추가 지표: `Column.[Column].ColumnValues.Compliance` | 예 | 예 | 예, 행 수준 임곗값이 제공된 경우 | 아니요 | 예. 최소 및 최대 길이를 분석하여 관찰 결과만 생성합니다. | 예 |
| ColumnNamesMatchPattern | 열 이름이 정의된 패턴과 일치하는지 확인합니다. 거버넌스 팀이 열 이름의 일관성을 적용하는 데 유용합니다. | 열 이름에 대한 정규식 | Dataset.\$1.ColumnNamesPatternMatchRatio | 예 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| ColumnValues | 데이터가 정의된 값에 따라 일관되는지 확인합니다. 이 규칙은 정규식을 지원합니다. | 정확히 하나의 열 이름 | `Column.[Column].Maximum` `Column.[Column].Minimum` 행 수준 임곗값이 제공된 경우 추가 지표: `Column.[Column].ColumnValues.Compliance` | 예 | 예 | 예, 행 수준 임곗값이 제공된 경우 | 아니요 | 예. 최솟값 및 최댓값을 분석하여 관찰 결과만 생성합니다. | 예 |
| 완전성 | 데이터에 공백 또는 NULL이 있는지 확인합니다. | 정확히 하나의 열 이름 | `Column.[Column].Completeness` | 예 | 예 | 예 | 예 | 예 | 예 |
| CustomSql | 고객은 거의 모든 유형의 데이터 품질 검사를 SQL로 구현할 수 있습니다. | SQL 문 (선택 사항) 행 수준 임곗값 | `Dataset.*.CustomSQL` 행 수준 임곗값이 제공된 경우 추가 지표: `Dataset.*.CustomSQL.Compliance` | 예 | 아니요 | 예, 행 수준 임곗값이 제공된 경우 | 예 | 아니요 | 아니요 |
| DataFreshness | 데이터가 최신인지 확인합니다. | 정확히 하나의 열 이름 | Column.[Column].DataFreshness.Compliance | 예 | 아니요 | 예 | 아니요 | 아니요 | 예 |
| DatasetMatch | 두 데이터 세트를 비교하여 두 데이터 세트가 동기화되었는지 확인합니다. | 참조 데이터 세트 이름 열 매핑 (선택 사항) 일치하는 항목이 있는지 확인하는 열 | Dataset.[ReferenceDatasetAlias].DatasetMatch | 예 | 아니요 | 예 | 예 | 아니요 | 아니요 |
| DistinctValuesCount | 중복된 값이 있는지 확인합니다. | 정확히 하나의 열 이름 | Column.[Column].DistinctValuesCount | 예 | 예 | 예 | 예 | 예 | 예 |
| DetectAnomalies | 다른 규칙 유형의 보고된 지표에서 이상이 있는지 확인합니다. | 규칙 유형 | 규칙 유형 인수로 보고된 지표 | 예 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| Entropy | 데이터의 엔트로피를 확인합니다. | 정확히 하나의 열 이름 | Column.[Column].Entropy | 예 | 예 | 아니요 | 예 | 아니요 | 예 |
| IsComplete | 데이터가 100% 완전한지 확인합니다. | 정확히 하나의 열 이름 | Column.[Column].Completeness | 예 | 아니요 | 예 | 아니요 | 아니요 | 예 |
| IsPrimaryKey | 열이 프라이머리 키(NULL이 아니고 고유함)인지 확인합니다. | 정확히 하나의 열 이름 | 단일 열의 경우: `Column.[Column].Uniqueness` 여러 열의 경우: `Multicolumn.[CommaDelimitedColumns].Uniqueness` | 예 | 아니요 | 예 | 아니요 | 아니요 | 예 |
| IsUnique | 데이터가 100% 고유한지 확인합니다. | 정확히 하나의 열 이름 | Column.[Column].Uniqueness | 예 | 아니요 | 예 | 아니요 | 아니요 | 예 |
| 평균 | 평균이 설정된 임곗값과 일치하는지 확인합니다. | 정확히 하나의 열 이름 | Column.[Column].Mean | 예 | 예 | 예 | 예 | 아니요 | 예 |
| ReferentialIntegrity | 두 데이터 세트에 참조 무결성이 있는지 확인합니다. | 데이터 세트에서 하나 이상의 열 이름 참조 데이터 세트에서 가져온 하나 이상의 열 이름 | Column.[ReferenceDatasetAlias].ReferentialIntegrity | 예 | 아니요 | 예 | 예 | 아니요 | 아니요 |
| RowCount | 레코드 수가 임곗값과 일치하는지 확인합니다. | 없음 | Dataset.\$1.RowCount | 예 | 예 | 아니요 | 예 | 예 | 예 |
| RowCountMatch | 두 데이터 세트 사이에서 레코드 수가 일치하는지 확인합니다. | 참조 데이터 세트 별칭 | Dataset.[ReferenceDatasetAlias].RowCountMatch | 예 | 아니요 | 아니요 | 예 | 아니요 | 아니요 |
| StandardDeviation | 표준 편차가 임곗값과 일치하는지 확인합니다. | 정확히 하나의 열 이름 | Column.[Column].StandardDeviation | 예 | 예 | 예 | 예 | 아니요 | 예 |
| SchemaMatch | 두 데이터 세트 사이에서 스키마가 일치하는지 확인합니다. | 참조 데이터 세트 별칭 | Dataset.[ReferenceDatasetAlias].SchemaMatch | 예 | 아니요 | 아니요 | 예 | 아니요 | 아니요 |
| Sum | 합계가 설정된 임곗값과 일치하는지 확인합니다. | 정확히 하나의 열 이름 | Column.[Column].Sum | 예 | 예 | 아니요 | 예 | 아니요 | 예 |
| Uniqueness | 데이터 세트의 고유성이 임곗값과 일치하는지 확인합니다. | 정확히 하나의 열 이름 | Column.[Column].Uniqueness | 예 | 예 | 예 | 예 | 아니요 | 예 |
| UniqueValueRatio | 고유 값 비율이 임곗값과 일치하는지 확인합니다. | 정확히 하나의 열 이름 | Column.[Column].UniqueValueRatio | 예 | 예 | 예 | 예 | 아니요 | 예 |
| FileFreshness | Amazon S3의 파일이 새 파일인지 확인합니다. | 파일 또는 폴더 경로와 임계치. | `Dataset.*.FileFreshness.Compliance` `Dataset.*.FileCount` | 예 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| FileMatch | 파일 내용이 체크섬 또는 다른 파일과 일치하는지 확인합니다. 이 규칙은 체크섬을 사용하여 두 파일이 동일한지 검증합니다. | 소스 파일 또는 폴더 경로와 대상 파일 또는 폴더 경로. | 통계가 생성되지 않습니다. | 예 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| FileSize | 파일 크기가 지정된 조건과 일치하는지 확인합니다. | 파일 또는 폴더 경로와 임계치. | `Dataset.*.FileSize.Compliance` `Dataset.*.FileCount` `Dataset.*.MaximumFileSize` `Dataset.*.MinimumFileSize` | 예 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| FileUniqueness | 체크섬을 사용하여 파일이 고유한지 확인합니다. | 파일 또는 폴더 경로와 임계치. | `Dataset.*.FileUniquenessRatio` `Dataset.*.FileCount` | 예 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
**Topics**
+ [AggregateMatch](dqdl-rule-types-AggregateMatch.md)
+ [ColumnCorrelation](dqdl-rule-types-ColumnCorrelation.md)
+ [ColumnCount](dqdl-rule-types-ColumnCount.md)
+ [ColumnDataType](dqdl-rule-types-ColumnDataType.md)
+ [ColumnExists](dqdl-rule-types-ColumnExists.md)
+ [ColumnLength](dqdl-rule-types-ColumnLength.md)
+ [ColumnNamesMatchPattern](dqdl-rule-types-ColumnNamesMatchPattern.md)
+ [ColumnValues](dqdl-rule-types-ColumnValues.md)
+ [완전성](dqdl-rule-types-Completeness.md)
+ [CustomSQL](dqdl-rule-types-CustomSql.md)
+ [DataFreshness](dqdl-rule-types-DataFreshness.md)
+ [DatasetMatch](dqdl-rule-types-DatasetMatch.md)
+ [DistinctValuesCount](dqdl-rule-types-DistinctValuesCount.md)
+ [Entropy](dqdl-rule-types-Entropy.md)
+ [IsComplete](dqdl-rule-types-IsComplete.md)
+ [IsPrimaryKey](dqdl-rule-types-IsPrimaryKey.md)
+ [IsUnique](dqdl-rule-types-IsUnique.md)
+ [Mean](dqdl-rule-types-Mean.md)
+ [ReferentialIntegrity](dqdl-rule-types-ReferentialIntegrity.md)
+ [RowCount](dqdl-rule-types-RowCount.md)
+ [RowCountMatch](dqdl-rule-types-RowCountMatch.md)
+ [StandardDeviation](dqdl-rule-types-StandardDeviation.md)
+ [Sum](dqdl-rule-types-Sum.md)
+ [SchemaMatch](dqdl-rule-types-SchemaMatch.md)
+ [Uniqueness](dqdl-rule-types-Uniqueness.md)
+ [UniqueValueRatio](dqdl-rule-types-UniqueValueRatio.md)
+ [DetectAnomalies](dqdl-rule-types-DetectAnomalies.md)
+ [FileFreshness](dqdl-rule-types-FileFreshness.md)
+ [FileMatch](dqdl-rule-types-FileMatch.md)
+ [FileUniqueness](dqdl-rule-types-FileUniqueness.md)
+ [FileSize](dqdl-rule-types-FileSize.md)
# AggregateMatch
지정된 표현식에서 두 열의 집계 비율을 확인합니다. 이 규칙 유형은 여러 데이터 세트에 적용됩니다. 두 열의 집계를 평가하고 첫 번째 열 집계 결과를 두 번째 열 집계 결과로 나누어 비율을 생성합니다. 제공된 표현식에서 비율을 확인하여 부울 응답을 생성합니다.
**구문**
**열 집계**
```
AggregateMatch (.)
```
+ **AGG\$1OPERATION** – 집계에 사용할 연산입니다. 현재 `sum` 및 `avg`가 지원됩니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **OPTIONAL\$1REFERENCE\$1ALIAS** – 기본 데이터 세트가 아닌 참조 데이터 세트에서 열을 가져온 경우 이 파라미터를 제공해야 합니다. AWS Glue 데이터 카탈로그에서 이 규칙을 사용하는 경우 참조 별칭은 '..' 형식을 따라야 합니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **COL\$1NAME** - 집계할 열의 이름입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
**예: 평균**
```
"avg(rating)"
```
**예: 합계**
```
"sum(amount)"
```
**예: 참조 데이터 세트의 열 평균**
```
"avg(reference.rating)"
```
**규칙**
```
AggregateMatch
```
+ **AGG\$1EXP\$11** - 첫 번째 열 집계입니다.
지원되는 열 유형: Byte, Decimal, Double, Float, Integer, Long, Short
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **AGG\$1EXP\$12** - 두 번째 열 집계입니다.
지원되는 열 유형: Byte, Decimal, Double, Float, Integer, Long, Short
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 합계를 사용한 일치 항목 집계**
다음 예제 규칙은 `amount` 열에서 값의 합계가 `total_amount` 열에서 값의 합계와 정확히 같은지 여부를 확인합니다.
```
AggregateMatch "sum(amount)" "sum(total_amount)" = 1.0
```
**예: 평균을 사용한 일치 항목 집계**
다음 예제 규칙은 `ratings` 열에서 값의 평균이 `reference` 데이터 세트 내 `ratings` 열에서 값의 평균 중 90% 이상인지를 확인합니다. 참조 데이터 세트는 ETL 또는 데이터 카탈로그 환경에서 추가 데이터 소스로 제공됩니다.
AWS Glue ETL에서 다음을 사용할 수 있습니다.
```
AggregateMatch "avg(ratings)" "avg(reference.ratings)" >= 0.9
```
AWS Glue 데이터 카탈로그에서 다음을 사용할 수 있습니다.
```
AggregateMatch "avg(ratings)" "avg(database_name.tablename.ratings)" >= 0.9
```
**Null 동작**
`AggregateMatch` 규칙은 집계 방법(합계/평균)의 계산에서 NULL 값이 있는 행을 무시합니다. 예:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
`units`열의 평균은 (0 \$1 20 \$1 40)/3 = 20이 됩니다. 101행과 103행은 이 계산에서 고려되지 않습니다.
# ColumnCorrelation
주어진 표현식을 기준으로 두 열 간의 **상관 관계를 확인합니다. AWS Glue 데이터 품질에서는 피어슨 상관 계수를 사용하여 두 열 간의 선형 상관 관계를 측정합니다. 결과는 관계의 강도와 방향을 측정하는 -1과 1 사이의 숫자입니다.
**구문**
```
ColumnCorrelation
```
+ **COL\$11\$1NAME** - 데이터 품질 규칙을 평가할 첫 번째 열의 이름입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **COL\$12\$1NAME** - 데이터 품질 규칙을 평가할 첫 번째 열의 이름입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 열 상관 관계**
다음 예제 규칙은 열 `height` 및 `weight` 간의 상관 계수가 강한 양의 상관 관계(0.8보다 큰 계수 값)를 갖는지 여부를 확인합니다.
```
ColumnCorrelation "height" "weight" > 0.8
```
```
ColumnCorrelation "weightinkgs" "Salary" > 0.8 where "weightinkgs > 40"
```
**샘플 동적 규칙**
+ `ColumnCorrelation "colA" "colB" between min(last(10)) and max(last(10))`
+ `ColumnCorrelation "colA" "colB" < avg(last(5)) + std(last(5))`
**Null 동작**
`ColumnCorrelation` 규칙은 상관 관계 계산에서 `NULL` 값이 있는 행을 무시합니다. 예:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
101행과 103행은 무시되고 `ColumnCorrelation`이 1.0이 됩니다.
# ColumnCount
지정된 표현식을 기준으로 기본 데이터 세트의 열 수를 확인합니다. 표현식에서 `>` 및 `<` 같은 연산자를 사용하여 열 수 또는 열 범위를 지정할 수 있습니다.
**구문**
```
ColumnCount
```
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 열 수 숫자 검사**
다음 예제 규칙은 열 수가 지정된 범위 내에 있는지 확인합니다.
```
ColumnCount between 10 and 20
```
**샘플 동적 규칙**
+ `ColumnCount >= avg(last(10))`
+ `ColumnCount between min(last(10))-1 and max(last(10))+1`
# ColumnDataType
지정된 열의 값을 Apache Spark에서 제공된 유형으로 캐스팅할 수 있는지 여부를 확인합니다. `with threshold` 식을 수락하여 열에 있는 값의 하위 세트를 확인합니다.
**구문**
```
ColumnDataType =
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
지원되는 열 유형: 문자열 유형
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPECTED\$1TYPE** - 열에 있는 값의 예상 유형입니다.
지원되는 값: Boolean, Date, Timestamp, Integer, Double, Float, Long
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPRESSION** - 예상 유형이어야 하는 값의 백분율을 지정하는 선택적 표현식입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
**예: 열 데이터 형식 정수 역할의 문자열**
다음 예제 규칙은 문자열 유형인 지정된 열의 값을 정수로 캐스팅할 수 있는지 여부를 확인합니다.
```
ColumnDataType "colA" = "INTEGER"
```
**예: 열 데이터 형식 정수 역할의 문자열에서 값의 하위 세트 확인**
다음 예제 규칙은 문자열 유형인 지정된 열의 값 중 90%를 정수로 캐스팅할 수 있는지 여부를 확인합니다.
```
ColumnDataType "colA" = "INTEGER" with threshold > 0.9
```
# ColumnExists
열이 존재하는지 확인합니다.
**구문**
```
ColumnExists
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 모든 열 유형
**예: 열이 존재함**
다음 예제 규칙은 `Middle_Name` 열이 존재하는지 여부를 확인합니다.
```
ColumnExists "Middle_Name"
```
# ColumnLength
열에 있는 각 행의 길이가 지정된 표현식을 준수하는지 확인합니다.
**구문**
```
ColumnLength
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 문자열
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 열 행 길이**
다음 예제 규칙은 `Postal_Code` 열의 각 행에 있는 값의 길이가 5자인지 여부를 확인합니다.
```
ColumnLength "Postal_Code" = 5
ColumnLength "weightinkgs" = 2 where "weightinkgs > 10"
```
**Null 동작**
`ColumnLength` 규칙은 `NULL`을 0 길이 문자열로 취급합니다. `NULL` 행의 경우:
```
ColumnLength "Postal_Code" > 4 # this will fail
```
```
ColumnLength "Postal_Code" < 6 # this will succeed
```
다음 예시 복합 규칙은 `NULL` 값을 명시적으로 실패하도록 하는 방법을 제공합니다.
```
(ColumnLength "Postal_Code" > 4) AND (ColumnValues "Postal_Code" != NULL)
```
# ColumnNamesMatchPattern
기본 데이터 세트의 모든 열 이름이 지정된 정규식과 일치하는지 확인합니다.
**구문**
```
ColumnNamesMatchPattern
```
+ **PATTERN** – 데이터 품질 규칙을 평가하는 데 사용할 패턴입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
**예: 열 이름 일치 패턴**
다음 예제 규칙은 모든 열이 접두사 'aws\$1'로 시작하는지 여부를 확인합니다.
```
ColumnNamesMatchPattern "aws_.*"
ColumnNamesMatchPattern "aws_.*" where "weightinkgs > 10"
```
# ColumnValues
열의 값에 대해 표현식을 실행합니다.
**구문**
```
ColumnValues
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 모든 열 유형
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 허용된 값**
다음 예제 규칙은 지정된 열의 각 값이 허용되는 값 세트(null, 비어 있음, 공백만 있는 문자열 포함)에 있는지 확인합니다.
```
ColumnValues "Country" in [ "US", "CA", "UK", NULL, EMPTY, WHITESPACES_ONLY ]
ColumnValues "gender" in ["F", "M"] where "weightinkgs < 10"
```
**예: 정규 표현식**
다음 예제 규칙은 열의 값을 정규 표현식과 비교하여 검사합니다.
```
ColumnValues "First_Name" matches "[a-zA-Z]*"
```
**예: 날짜 값**
다음 예제 규칙은 날짜 열의 값을 날짜 표현식과 비교하여 검사합니다.
```
ColumnValues "Load_Date" > (now() - 3 days)
```
**예: 숫자 값**
다음 예제 규칙은 열 값이 특정 숫자 제약 조건과 일치하는지 여부를 확인합니다.
```
ColumnValues "Customer_ID" between 1 and 2000
```
**Null 동작**
모든 `ColumnValues` 규칙(`!=` 및 `NOT IN` 제외)의 경우 `NULL` 행이 규칙에 실패합니다. null 값으로 인해 규칙이 실패하면 실패 이유가 다음과 같이 표시됩니다.
```
Value: NULL does not meet the constraint requirement!
```
다음 예제 복합 규칙은 `NULL` 값을 명시적으로 허용하는 방법을 제공합니다.
```
(ColumnValues "Age" > 21) OR (ColumnValues "Age" = NULL)
```
`!=` 및 `not in` 구문을 사용하는 부정 ColumnValues 규칙은 `NULL` 행에 대해 성공합니다. 예:
```
ColumnValues "Age" != 21
```
```
ColumnValues "Age" not in [21, 22, 23]
```
다음 예제는 `NULL` 값을 명시적으로 실패하도록 하는 방법을 제공합니다.
```
(ColumnValues "Age" != 21) AND (ColumnValues "Age" != NULL)
```
```
ColumnValues "Age" not in [21, 22, 23, NULL]
```
# 완전성
지정된 표현식을 기준으로 열에서 전체(null이 아닌) 값의 백분율을 검사합니다.
**구문**
```
Completeness
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 모든 열 유형
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: Null 값 백분율**
다음 예제 규칙은 열에 있는 값의 95% 이상이 완전한지를 확인합니다.
```
Completeness "First_Name" > 0.95
Completeness "First_Name" > 0.95 where "weightinkgs > 10"
```
**샘플 동적 규칙**
+ `Completeness "colA" between min(last(5)) - 1 and max(last(5)) + 1`
+ `Completeness "colA" <= avg(last(10))`
**Null 동작**
CSV 데이터 형식에 대한 참고 사항: CSV 열의 빈 행은 여러 동작을 표시할 수 있습니다.
+ 열의 유형이 `String`인 경우 빈 행은 빈 문자열로 인식되어 `Completeness` 규칙에 실패하지 않습니다.
+ 열이 `Int`와 같은 다른 데이터 유형인 경우 빈 행이 `NULL`로 인식되어 `Completeness` 규칙에 실패합니다.
# CustomSQL
이 규칙 유형은 다음과 같은 두 가지 사용 사례를 지원하도록 확장되었습니다.
+ 데이터 세트에 대해 사용자 지정 SQL 문을 실행하고 지정된 표현식을 기준으로 반환 값을 확인합니다.
+ 일부 조건과 비교하여 행 수준 결과를 얻는 SELECT 문에 열 이름을 지정하는 사용자 지정 SQL 문을 실행합니다.
**구문**
```
CustomSql
```
+ **SQL\$1STATEMENT** - 큰따옴표로 묶인 단일 숫자 값을 반환하는 SQL 문입니다.
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 전체 규칙 결과를 검색하기 위한 사용자 지정 SQL**
이 예제 규칙에서는 SQL 문을 사용하여 데이터 세트의 레코드 수를 검색합니다. 그런 다음 레코드 수가 10\$120 사이인지 확인합니다.
```
CustomSql "select count(*) from primary" between 10 and 20
```
**예: 행 수준 결과를 검색하기 위한 사용자 지정 SQL**
이 예제 규칙은 일부 조건과 비교하여 행 수준 결과를 얻는 SELECT 문에 열 이름을 지정하는 SQL 문을 사용합니다. 임곗값 조건 표현식에서는 전체 규칙이 실패하기 위해 실패해야 하는 레코드 수의 임곗값을 정의합니다. 규칙에는 조건과 키워드가 모두 포함되지 않을 수도 있습니다.
```
CustomSql "select Name from primary where Age > 18"
```
or
```
CustomSql "select Name from primary where Age > 18" with threshold > 3
```
**중요**
`primary` 별칭은 평가하려는 데이터 세트의 이름을 나타냅니다. 콘솔에서 시각적 ETL 작업을 수행할 때 `primary`에서는 항상 `EvaluateDataQuality.apply()` 변환에 전달 중인 `DynamicFrame`을 나타냅니다. AWS Glue 데이터 카탈로그를 사용하여 테이블에 대해 데이터 품질 작업을 실행하는 경우 `primary`는 테이블을 나타냅니다.
AWS Glue 데이터 카탈로그에 있는 경우 실제 테이블 이름을 사용할 수도 있습니다.
```
CustomSql "select count(*) from database.table" between 10 and 20
```
여러 테이블을 조인하여 서로 다른 데이터 요소를 비교할 수도 있습니다.
```
CustomSql "select count(*) from database.table inner join database.table2 on id1 = id2" between 10 and 20
```
AWS Glue ETL에서 CustomSQL은 데이터 품질 검사에 실패한 레코드를 식별할 수 있습니다. 이 작업을 수행하려면 데이터 품질을 평가하려는 기본 테이블의 일부인 레코드를 반환해야 합니다. 쿼리의 일부로 반환된 레코드는 성공으로 간주되고 반환되지 않은 레코드는 실패로 간주됩니다. 이는 CustomSQL 쿼리의 결과를 원래 데이터세트와 조인하는 방식으로 작동합니다. SQL 쿼리의 복잡성에 따라 성능에 영향을 미칠 수 있습니다.
방법:
+ 기본 테이블에서 열을 하나 이상 선택해야 합니다.
+ `select count(*) from primary`는 OVERALL CustomSQL DQ 규칙에 대한 유효한 쿼리이지만 행 수준 사용자 지정 SQL에는 유효하지 않습니다.
+ 이 규칙은 평가 중에 오류를 발생시킵니다. `The output from CustomSQL must contain at least one column that matches the input dataset for AWS Glue Data Quality to provide row level results. The SQL query is a valid query but the columns from the SQL result are not present in the Input Dataset. Ensure that matching columns are returned from the SQL.`
+ SQL 쿼리에서는 테이블에서 '프라이머리 키'를 선택하거나 복합 키를 구성하는 열 세트를 선택합니다. 이렇게 하지 않으면 중복된 행이 일치되어 결과가 일관되지 않고 성능이 저하될 수 있습니다.
+ 기본 테이블에서만 키를 선택하고 참조 테이블에서는 선택하지 않습니다.
다음 규칙에서는 age가 100 미만인 레코드는 성공으로, 그 이상인 레코드는 실패로 표시됩니다.
```
CustomSql "select id from primary where age < 100"
```
레코드 중 50%에서 age가 10을 초과하는 경우 이 CustomSQL 규칙은 통과되며 실패한 레코드도 식별합니다. 이 CustomSQL에서 반환된 레코드는 통과로 간주되고 반환되지 않은 레코드는 실패로 간주됩니다.
```
CustomSQL "select ID, CustomerID from primary where age > 10" with threshold > 0.5
```
참고: 데이터 세트에서 사용할 수 없는 레코드를 반환하면 CustomSQL 규칙이 실패합니다.
# DataFreshness
현재 시간과 날짜 열 값 간의 차이를 평가하여 열에 있는 데이터의 최신성을 검사합니다. 이 규칙 유형에 시간 기반 표현식을 지정하여 열 값이 최신 상태인지 확인할 수 있습니다.
**구문**
```
DataFreshness
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 날짜
+ **표현식** - 시간 또는 일 단위의 숫자 표현식입니다. 표현식에 시간 단위를 지정해야 합니다.
**예: 데이터 최신성**
다음 예제 규칙은 데이터 최신성을 확인합니다.
```
DataFreshness "Order_Date" <= 24 hours
DataFreshness "Order_Date" between 2 days and 5 days
```
**Null 동작**
`DataFreshness` 규칙은 `NULL` 값이 있는 행에 대해 실패합니다. null 값으로 인해 규칙이 실패하면 실패 이유가 다음과 같이 표시됩니다.
```
80.00 % of rows passed the threshold
```
여기서 실패한 행의 20%에는 `NULL`이 있는 행이 포함됩니다.
다음 예제 복합 규칙은 `NULL` 값을 명시적으로 허용하는 방법을 제공합니다.
```
(DataFreshness "Order_Date" <= 24 hours) OR (ColumnValues "Order_Date" = NULL)
```
**Amazon S3 객체의 데이터 최신성**
Amazon S3 파일 생성 시간을 기준으로 데이터의 최신성을 검증해야 하는 경우가 있습니다. 이렇게 하려면 다음 코드를 사용하여 타임스탬프를 가져와 데이터 프레임에 추가한 다음 데이터 최신성 검사를 적용할 수 있습니다.
```
df = glueContext.create_data_frame.from_catalog(database = "default", table_name = "mytable")
df = df.withColumn("file_ts", df["_metadata.file_modification_time"])
Rules = [
DataFreshness "file_ts" < 24 hours
]
```
# DatasetMatch
기본 데이터 세트의 데이터가 참조 데이터 세트의 데이터와 일치하는지 확인합니다. 제공된 키 열 매핑을 사용하여 두 데이터 세트를 조인합니다. 해당 열에서만 데이터의 관계(equality)를 확인하려는 경우 추가 열 매핑을 제공할 수 있습니다. **DataSetMatch**를 사용하려면 조인 키가 고유해야 하고 NULL이 아니어야 합니다(프라이머리 키여야 함). 이러한 조건을 충족하지 않으면 'Provided key map not suitable for given data frames' 오류 메시지가 표시됩니다. 고유한 조인 키를 사용할 수 없는 경우에는 **AggregateMatch**와 같은 다른 규칙 유형을 사용하여 요약 데이터와 일치시키는 것이 좋습니다.
**구문**
```
DatasetMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS** – 기본 데이터 세트의 데이터를 비교하는 참조 데이터 세트의 별칭입니다.
+ **KEY\$1COLUMN\$1MAPPINGS** – 데이터 세트의 키를 구성하는 쉼표로 구분된 열 이름 목록입니다. 두 데이터 세트의 열 이름이 동일하지 않은 경우 `->`로 구분해야 합니다.
+ **OPTIONAL\$1MATCH\$1COLUMN\$1MAPPINGS** - 특정 열의 데이터만 일치하는지 확인하려는 경우 이 파라미터를 제공할 수 있습니다. 키 열 매핑과 동일한 구문을 사용합니다. 이 파라미터를 제공하지 않으면 나머지 모든 열의 데이터를 일치시킵니다. 키가 아닌 나머지 열은 두 데이터 세트에서 이름이 같아야 합니다.
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: ID 열을 사용하여 설정된 데이터 세트 일치**
다음 예제 규칙은 두 데이터 세트를 조인하기 위해 'ID' 열을 사용하여 기본 데이터 세트 중 90%가 넘는 항목이 참조 데이터 세트와 일치하는지 확인합니다. 이 경우 모든 열을 비교합니다.
```
DatasetMatch "reference" "ID" >= 0.9
```
**예: 여러 키 열을 사용하는 설정된 데이터 세트 일치**
다음 예제에서는 기본 데이터 세트와 참조 데이터 세트의 키 열 이름이 다릅니다. `ID_1` 및 `ID_2`는 기본 데이터 세트에서 복합 키를 함께 형성합니다. `ID_ref1` 및 `ID_ref2`는 참조 데이터 세트에 복합 키를 함께 형성합니다. 이 시나리오에서는 특수 구문을 사용하여 열 이름을 제공할 수 있습니다.
```
DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" >= 0.9
```
**예: 여러 키 열을 사용하여 설정된 데이터 세트 일치 및 특정 열이 일치하는지 확인**
이 예는 이전 예를 기반으로 구축되었습니다. 금액이 포함된 열만 일치하는지 확인하려고 합니다. 이 열의 이름은 기본 데이터 세트에서 `Amount1`이고, 참조 데이터 세트에서 `Amount2`입니다. 정확한 일치시키려고 합니다.
```
DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" "Amount1->Amount2" >= 0.9
```
# DistinctValuesCount
지정된 표현식을 기준으로 열의 고유 값 수를 확인합니다.
**구문**
```
DistinctValuesCount
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 모든 열 유형
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 고유 열 값 개수**
다음 예제 규칙은 `State` 열에 3개 이상의 고유 값이 포함되어 있는지 확인합니다.
```
DistinctValuesCount "State" > 3
DistinctValuesCount "Customer_ID" < 6 where "Customer_ID < 10"
```
**샘플 동적 규칙**
+ `DistinctValuesCount "colA" between avg(last(10))-1 and avg(last(10))+1`
+ `DistinctValuesCount "colA" <= index(last(10),2) + std(last(5))`
# Entropy
열의 **엔트로피 값이 지정된 표현식과 일치하는지 확인합니다. 엔트로피는 메시지에 포함된 정보의 수준을 측정합니다. 열의 값에 대한 확률 분포를 고려할 때 엔트로피는 값을 식별하는 데 필요한 비트 수를 설명합니다.
**구문**
```
Entropy
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 모든 열 유형
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 열 엔트로피**
다음 예제 규칙은 `Feedback` 열의 엔트로피 값이 1보다 큰지 확인합니다.
```
Entropy "Star_Rating" > 1
Entropy "First_Name" > 1 where "Customer_ID < 10"
```
**샘플 동적 규칙**
+ `Entropy "colA" < max(last(10))`
+ `Entropy "colA" between min(last(10)) and max(last(10))`
# IsComplete
열의 모든 값이 완전한지(null이 아님) 확인합니다.
**구문**
```
IsComplete
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 모든 열 유형
**예: Null 값**
다음 예에서는 `email` 열의 모든 값이 null이 아닌지 확인합니다.
```
IsComplete "email"
IsComplete "Email" where "Customer_ID between 1 and 50"
IsComplete "Customer_ID" where "Customer_ID < 16 and Customer_ID != 12"
IsComplete "passenger_count" where "payment_type<>0"
```
**Null 동작**
CSV 데이터 형식에 대한 참고 사항: CSV 열의 빈 행은 여러 동작을 표시할 수 있습니다.
+ 열의 유형이 `String`인 경우 빈 행은 빈 문자열로 인식되어 `Completeness` 규칙에 실패하지 않습니다.
+ 열이 `Int`와 같은 다른 데이터 유형인 경우 빈 행이 `NULL`로 인식되어 `Completeness` 규칙에 실패합니다.
# IsPrimaryKey
열에 기본 키가 포함되어 있는지 확인합니다. 열의 모든 값이 고유하고 완전한 경우(null이 아닌 경우) 열에 기본 키가 포함됩니다. 여러 열이 있는 프라이머리 키를 확인할 수도 있습니다.
**구문**
```
IsPrimaryKey
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 모든 열 유형
**예: 기본 키**
다음 예제 규칙은 `Customer_ID` 열에 기본 키가 있는지 여부를 확인합니다.
```
IsPrimaryKey "Customer_ID"
IsPrimaryKey "Customer_ID" where "Customer_ID < 10"
```
**예: 여러 열이 있는 프라이머리 키입니다. 다음 예제는 유효합니다.**
```
IsPrimaryKey "colA" "colB"
IsPrimaryKey "colA" "colB" "colC"
IsPrimaryKey colA "colB" "colC"
```
# IsUnique
열의 모든 값이 고유한지 확인하고 부울 값을 반환합니다.
**구문**
```
IsUnique
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 모든 열 유형
**예시**
다음 예제 규칙은 `email` 열의 모든 값이 고유한지 확인합니다.
```
IsUnique "email"
IsUnique "Customer_ID" where "Customer_ID < 10"]
```
다음 예제 규칙은 여러 열을 확인합니다.
```
IsUnique "vendorid" "tpep_pickup_datetime"
```
# Mean
열에 있는 모든 값의 평균이 지정된 표현식과 일치하는지 확인합니다.
**구문**
```
Mean
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 평균값**
다음 예제 규칙은 열에 있는 모든 값의 평균이 임곗값을 초과하는지 여부를 확인합니다.
```
Mean "Star_Rating" > 3
Mean "Salary" < 6200 where "Customer_ID < 10"
```
**샘플 동적 규칙**
+ `Mean "colA" > avg(last(10)) + std(last(2))`
+ `Mean "colA" between min(last(5)) - 1 and max(last(5)) + 1`
**Null 동작**
`Mean` 규칙은 평균을 계산할 때 `NULL` 값이 있는 행을 무시합니다. 예:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
`units`열의 평균은 (0 \$1 20 \$1 40)/3 = 20이 됩니다. 101행과 103행은 이 계산에서 고려되지 않습니다.
# ReferentialIntegrity
기본 데이터 세트의 열 세트 값이 어느 범위까지 참조 데이터 세트의 열 세트 값에 대한 하위 세트인지를 확인합니다.
**구문**
```
ReferentialIntegrity
```
+ **PRIMARY\$1COLS** - 기본 데이터 세트의 쉼표로 구분된 열 이름 목록입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **REFERENCE\$1DATASET\$1COLS** - 이 파라미터는 마침표로 구분된 두 부분을 포함합니다. 첫 번째 부분은 참조 데이터 세트의 별칭입니다. 두 번째 부분은 참조 데이터 세트에서 괄호로 묶인 쉼표로 구분된 열 이름 목록입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: zip code 열의 참조 무결성 확인**
다음 예제 규칙은 기본 데이터 세트의 `zipcode` 열에 있는 값 중 90%가 넘는 항목이 `reference` 데이터 세트의 `zipcode` 열에 있는지 확인합니다.
```
ReferentialIntegrity "zipcode" "reference.zipcode" >= 0.9
```
**예: city 및 state 열의 참조 무결성 확인**
다음 예제에서는 city 및 state 정보가 포함된 열이 기본 데이터 세트과 참조 데이터 세트에 있습니다. 두 데이터 세트의 열 이름은 서로 다릅니다. 이 규칙은 기본 데이터 세트의 열 값 세트가 참조 데이터 세트의 열 값 세트와 정확히 같은지 확인합니다.
```
ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" = 1.0
```
**샘플 동적 규칙**
+ `ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" > avg(last(10))`
+ `ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" between min(last(10)) - 1 and max(last(10)) + 1`
# RowCount
지정된 표현식을 기준으로 데이터 세트의 행 수를 확인합니다. 표현식에서 `>` 및 `<` 같은 연산자를 사용하여 행 수 또는 행 범위를 지정할 수 있습니다.
**구문**
```
RowCount
```
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 행 수 수치 검사**
다음 예제 규칙은 행 수가 지정된 범위 내에 있는지 확인합니다.
```
RowCount between 10 and 100
RowCount between 1 and 50 where "Customer_ID < 10"
```
**샘플 동적 규칙**
```
RowCount > avg(last(10)) *0.8
```
# RowCountMatch
주어진 표현식과 비교하여 기본 데이터 세트의 행 수와 참조 데이터 세트의 행 수 비율을 확인합니다.
**구문**
```
RowCountMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS** - 행 수를 비교할 참조 데이터 세트의 별칭입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 참조 데이터 세트를 기준으로 행 수 확인**
다음 예제 규칙은 기본 데이터 세트의 행 수가 참조 데이터 세트 행 수의 90% 이상인지 확인합니다.
```
RowCountMatch "reference" >= 0.9
```
# StandardDeviation
지정된 표현식을 기준으로 열에 있는 모든 값의 표준 편차를 검사합니다.
**구문**
```
StandardDeviation
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 표준 편차**
다음 예제 규칙은 `colA` 열에 있는 값의 표준 편차가 지정된 값보다 작은지 여부를 확인합니다.
```
StandardDeviation "Star_Rating" < 1.5
StandardDeviation "Salary" < 3500 where "Customer_ID < 10"
```
**샘플 동적 규칙**
+ `StandardDeviation "colA" > avg(last(10) + 0.1`
+ `StandardDeviation "colA" between min(last(10)) - 1 and max(last(10)) + 1`
**Null 동작**
`StandardDeviation` 규칙은 표준 편차를 계산할 때 `NULL` 값이 있는 행을 무시합니다. 예:
```
+---+-----------+-----------+
|id |units1 |units2 |
+---+-----------+-----------+
|100|0 |0 |
|101|null |0 |
|102|20 |20 |
|103|null |0 |
|104|40 |40 |
+---+-----------+-----------+
```
`units1` 열의 표준 편차는 101열과 103열을 고려하지 않고 16.33으로 계산됩니다. `units2` 열의 표준 편차는 16이 됩니다.
# Sum
지정된 표현식을 기준으로 열에 있는 모든 값의 합계를 확인합니다.
**구문**
```
Sum
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 합계**
다음 예제 규칙은 열에 있는 모든 값의 합계가 지정된 임곗값을 초과하는지 여부를 확인합니다.
```
Sum "transaction_total" > 500000
Sum "Salary" < 55600 where "Customer_ID < 10"
```
**샘플 동적 규칙**
+ `Sum "ColA" > avg(last(10))`
+ `Sum "colA" between min(last(10)) - 1 and max(last(10)) + 1`
**Null 동작**
`Sum` 규칙은 합계를 계산할 때 `NULL` 값이 있는 행을 무시합니다. 예:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
`units` 열의 합계는 101열과 103열을 고려하지 않고 (0 \$1 20 \$1 40) = 60으로 계산됩니다.
# SchemaMatch
기본 데이터 세트의 스키마가 참조 데이터 세트의 스키마와 일치하는지 확인합니다. 스키마 검사는 열 단위로 수행됩니다. 이름이 동일하고 유형이 동일하면 두 열의 스키마가 일치합니다. 열 순서는 중요하지 않습니다.
**구문**
```
SchemaMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS** - 스키마를 비교할 때 사용할 참조 데이터 세트의 별칭입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: SchemaMatch**
다음 예제 규칙은 기본 데이터 세트의 스키마가 참조 데이터 세트의 스키마와 정확히 일치하는지 확인합니다.
```
SchemaMatch "reference" = 1.0
```
# Uniqueness
지정된 표현식을 기준으로 열에서 고유한 값의 백분율을 검사합니다. 고유한 값은 정확히 한 번 발생합니다.
**구문**
```
Uniqueness
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 모든 열 유형
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예제**
다음 예제 규칙은 열의 고유 값 백분율이 특정 숫자 기준과 일치하는지 여부를 확인합니다.
```
Uniqueness "email" = 1.0
Uniqueness "Customer_ID" != 1.0 where "Customer_ID < 10"
```
다음 예제 규칙은 여러 열을 확인합니다.
```
Uniqueness "vendorid" "tpep_pickup_datetime" = 1
```
**샘플 동적 규칙**
+ `Uniqueness "colA" between min(last(10)) and max(last(10))`
+ `Uniqueness "colA" >= avg(last(10))`
# UniqueValueRatio
지정된 표현식을 기준으로 열의 **고유 값 비율을 검사합니다. 고유 값 비율은 고유 값의 비율을 열에 있는 모든 고유 값의 수로 나눈 값입니다. 고유 값은 정확히 한 번 나타나는 반면 개별 값은 한 번 **이상 나타납니다.
예를 들어 `[a, a, b]` 세트에는 고유 값 1개(`b`)와 개별 값 2개(`a` 및 `b`)가 포함됩니다. 따라서 세트의 고유 값 비율은 ½ = 0.5입니다.
**구문**
```
UniqueValueRatio
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 모든 열 유형
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 고유 값 비율**
이 예에서는 열의 고유 값 비율을 값 범위와 비교하여 확인합니다.
```
UniqueValueRatio "test_score" between 0 and 0.5
UniqueValueRatio "Customer_ID" between 0 and 0.9 where "Customer_ID < 10"
```
**샘플 동적 규칙**
+ `UniqueValueRatio "colA" > avg(last(10))`
+ `UniqueValueRatio "colA" <= index(last(10),2) + std(last(5))`
# DetectAnomalies
지정된 데이터 품질 규칙의 이상을 탐지합니다. DetectAnomalies 규칙을 실행할 때마다 지정된 규칙에 대한 평가 값이 저장됩니다. 수집된 데이터가 충분하면 이상 탐지 알고리즘이 해당 규칙에 대한 모든 기록 데이터를 가져와서 이상 탐지를 실행합니다. 이상이 탐지되면 DetectAnomalies 규칙이 실패합니다. 어떤 이상이 탐지되었는지에 대한 자세한 정보는 관찰에서 확인할 수 있습니다.
**구문**
```
DetectAnomalies
```
`RULE_NAME` - 이상을 평가하고 탐지하려는 규칙의 이름입니다. 지원되는 규칙:
+ "RowCount"
+ "Completeness"
+ "Uniqueness"
+ "Mean"
+ "Sum"
+ "StandardDeviation"
+ "Entropy"
+ "DistinctValuesCount"
+ "UniqueValueRatio"
+ "ColumnLength"
+ "ColumnValues"
+ "ColumnCorrelation"
+ "CustomSQL"
+ "ColumnCount"
`RULE_PARAMETERS` - 일부 규칙을 실행하려면 추가 파라미터가 필요합니다. 필수 파라미터를 확인하려면 해당 규칙 설명서를 참조하세요.
**예: RowCount에 대한 이상 항목**
예를 들어 RowCount 이상을 탐지하려면 RowCount를 규칙 이름으로 입력합니다.
```
DetectAnomalies "RowCount"
```
**예: ColumnLength에 대한 이상 항목**
예를 들어 ColumnLength 이상을 탐지하려면 규칙 이름으로 ColumnLength와 열 이름을 입력합니다.
```
DetectAnomalies "ColumnLength" "id"
```
# FileFreshness
FileFreshness를 사용하면 사용자가 제공한 조건에 따라 데이터 파일을 새로 고칩니다. 파일의 마지막 수정 시간을 사용하여 데이터 파일 또는 전체 폴더가 최신 상태인지 확인합니다.
이 규칙은 두 가지 지표를 수집합니다.
+ 설정한 규칙에 따른 FileFreshness 규정 준수
+ 규칙에 따라 스캔된 파일 수
```
{"Dataset.*.FileFreshness.Compliance":1,"Dataset.*.FileCount":1}
```
이상 탐지에서는 이러한 지표를 고려하지 않습니다.
**파일 최신성 확인**
다음 규칙은 tickets.parquet가 지난 24시간 동안 생성되도록 보장합니다.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/tickets.parquet" > (now() - 24 hours)
```
**폴더 최신성 확인**
다음 규칙은 폴더의 모든 파일이 지난 24시간 이내에 생성되거나 수정된 경우 통과됩니다.
```
FileFreshness "s3://bucket/" >= (now() -1 days)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" >= (now() - 24 hours)
```
**임계치를 사용하여 폴더 또는 파일 최신성 확인**
다음 규칙은 지난 10일 동안 "tickets" 폴더에 있는 파일의 10%가 생성되거나 수정된 경우 통과됩니다.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" < (now() - 10 days) with threshold > 0.1
```
**특정 날짜의 파일 또는 폴더 확인**
특정 날짜의 파일 최신성을 확인할 수 있습니다.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "2020-01-01"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "2023-01-01" and "2024-01-01"
```
**시간 제한하여 파일 또는 폴더 확인**
FileFreshness를 사용하여 특정 시간에 따라 파일이 도착했는지 확인할 수 있습니다.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between now() and (now() - 45 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "9:30 AM" and "9:30 PM"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > (now() - 10 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > now()
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between (now() - 2 hours) and (now() + 15 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between (now() - 3 days) and (now() + 15 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "2001-02-07" and (now() + 15 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45""
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "2024-01-01"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "02:30" and "04:30"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "9:30 AM" and "22:15"
```
주요 고려 사항:
+ FileFreshness는 일, 시간 및 분 단위를 사용하여 파일을 평가할 수 있습니다.
+ 경우에 따라 오전/오후 및 24시간을 지원합니다.
+ 재정의가 지정되지 않는 한 시간은 UTC로 계산됩니다.
+ 날짜는 00:00 시간의 UTC로 계산됩니다.
시간 기반 FileFreshness는 다음과 같이 작동합니다.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45"
```
+ 먼저 시간 “21:45”를 UTC 형식의 오늘 날짜와 결합하여 날짜-시간 필드를 생성합니다.
+ 다음으로 날짜-시간이 지정한 시간대로 변환됩니다.
+ 마지막으로 규칙이 평가됩니다.
**선택적 파일 기반 규칙 태그:**
태그를 사용하면 규칙 동작을 제어할 수 있습니다.
**recentFiles**
이 태그는 가장 최근 파일을 먼저 유지하여 처리되는 파일 수를 제한합니다.
```
FileFreshness "s3://amzn-s3-demo-bucket/" between (now() - 100 minutes) and (now() + 10 minutes) with recentFiles = 1
```
**uriRegex**
**참고**
`uriRegex` 태그는 AWS Glue 5.0 이상에서 사용할 수 있습니다.
이 태그는 파일 경로에 정규식 패턴을 적용하여 파일을 필터링합니다. 경로가 패턴과 일치하는 파일만 처리됩니다. 부정적 예측을 사용하여 패턴과 일치하는 파일을 제외할 수도 있습니다.
```
# Match only files with a .csv extension
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with uriRegex = "\.csv$"
# Match Parquet files that contain "orders_" in the path
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with uriRegex = ".*orders_.*\.parquet"
# Exclude files ending in .tmp using a negative lookahead
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with uriRegex = "(?!.*\.tmp$).*"
```
**filterOrder**
**참고**
`filterOrder` 태그는 AWS Glue 5.0 이상에서 사용할 수 있습니다.
`recentFiles` 및 `uriRegex`와 같은 여러 필터 태그를 함께 사용하면 `filterOrder` 태그가 해당 태그의 적용 순서를 제어합니다. 기본 순서는 `recentFiles` 먼저, 그 다음에 `uriRegex`입니다.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with recentFiles = 1 with uriRegex = "inventory_" with filterOrder = ["uriRegex","recentFiles"]
```
위 예제에서 `uriRegex` 필터는 먼저 'inventory\$1'와 일치하는 파일만 선택하고 `recentFiles = 1`에서 필터링된 세트에서 최근 파일을 가져옵니다. `filterOrder`가 없으면 기본 동작은 하나의 최근 파일을 먼저 가져온 다음 정규식을 적용합니다. 이 경우 최근 파일이 패턴과 일치하지 않으면 일치하는 파일이 없을 수 있습니다.
**참고**
`filterOrder` 목록의 모든 값은 동일한 규칙에도 있는 다른 필터 태그(`recentFiles` 또는 `uriRegex`)를 참조해야 합니다. `timeZone` 또는 `failFast`와 같은 비필터 태그는 `filterOrder`에서 유효하지 않습니다.
**failFast**
`"true"`로 설정하면 규칙은 모든 파일을 평가하고 규정 준수 비율을 계산하는 대신 최신성 조건에 통과하지 못한 첫 번째 파일에서 즉시 실패를 반환합니다.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with failFast = "true"
```
**timeZone**
허용되는 시간대 재정의는 지원되는 시간대에 [Allowed Time Zones](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html)를 참조하세요.
```
FileFreshness "s3://path/" > "21:45" with timeZone = "America/New_York"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "America/Chicago"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "Europe/Paris"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "Asia/Shanghai"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "Australia/Darwin"
```
**데이터 프레임에서 직접 파일 이름 추론**
항상 파일 경로를 제공하지 않아도 됩니다. 예를 들어 AWS Glue Data Catalog에서 규칙을 작성할 때 카탈로그 테이블에서 사용 중인 폴더를 찾기 어려울 수 있습니다. AWS Glue Data Quality에서는 데이터 프레임을 채우는 데 사용되는 특정 폴더나 파일을 찾고 해당 항목이 최신 상태인지를 감지할 수 있습니다.
**참고**
이 기능은 파일이 DynamicFrame 또는 DataFrame으로 성공적으로 읽기된 경우에만 작동합니다.
```
FileFreshness > (now() - 24 hours)
```
이 규칙은 동적 프레임 또는 데이터 프레임을 채우는 데 사용되는 폴더 경로나 파일을 찾습니다. Amazon S3 경로 또는 Amazon S3 기반 AWS Glue Data Catalog 테이블에 대해 사용할 수 있습니다. 이때 몇 가지 고려 사항이 있습니다.
1. AWS Glue ETL에서 Amazon S3 또는 AWS Glue Data Catalog 변환 직후 **EvaluateDataQuality** 변환이 있어야 합니다.
![\[스크린샷에서는 Amazon S3 노드에 연결된 데이터 품질 평가 노드를 보여줍니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/data-quality-file-freshness.png)
1. 이 규칙은 AWS Glue 대화형 세션에서 작동하지 않습니다.
두 경우 모두에서 시도하거나 AWS Glue에서 파일을 찾을 수 없는 경우 AWS Glue에서 다음 오류가 발생합니다. `“Unable to parse file path from DataFrame”`
# FileMatch
FileMatch 규칙을 사용하면 파일을 다른 파일 또는 체크섬과 비교할 수 있습니다. 이는 다음과 같은 몇 가지 시나리오에서 유용할 수 있습니다.
1. 외부 소스에서 수신한 파일 검증: FileMatch를 사용하여 체크섬과 비교해 외부 소스에서 올바른 파일을 수신하도록 보장할 수 있습니다. 이 방식으로 수집 중인 데이터의 무결성을 검증할 수 있습니다.
1. 서로 다른 두 폴더의 데이터 비교: FileMatch를 사용하여 두 폴더 간의 파일을 비교할 수 있습니다.
이 규칙은 규칙에 따라 스캔한 파일 수라는 하나의 지표를 수집합니다.
```
{"Dataset.*.FileCount":1}
```
**체크섬으로 파일 검증:**
FileMatch는 파일과 설정된 체크섬을 수락하여 하나 이상의 체크섬이 파일과 일치하는지 확인합니다.
```
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-1"
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-256"
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"]
```
다음 표준 알고리즘이 지원됩니다.
+ MD5
+ SHA-1
+ SHA-256
알고리즘을 제공하지 않으면 기본값은 SHA-256입니다.
**체크섬 세트로 폴더의 모든 파일 검증:**
```
FileMatch "s3://amzn-s3-demo-bucket /" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch "s3://amzn-s3-demo-bucket /internal-folder/" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"]
```
**다른 폴더의 파일 비교**
```
# Compare all files across two buckets
FileMatch "s3://original_bucket/" "s3://archive_bucket/"
# Compare files within specific subfolders
FileMatch "s3://original_bucket/internal-folder/" "s3://original_bucket/other-folder/"
# Compare only .json files across two folders
FileMatch "s3://original_bucket/" "s3://archive_bucket/" with uriRegex = "\.json$"
# Compare only the 5 most recent .csv files
FileMatch "s3://original_bucket/" "s3://archive_bucket/" with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"]
```
FileMatch는 `original_bucket`에서 파일 콘텐츠를 확인하고 `archive_bucket`의 내용과 일치하는지 확인합니다. 정확히 일치하지 않으면 규칙은 실패합니다. 내부 폴더 또는 개별 파일의 콘텐츠를 확인할 수도 있습니다.
FileMatch는 개별 파일을 서로 비교하여 확인할 수도 있습니다.
```
FileMatch "s3://amzn-s3-demo-bucket /file_old.json" "s3://amzn-s3-demo-bucket /file_new.json"
```
**데이터 프레임에서 직접 파일 이름 추론**
항상 파일 경로를 제공하지 않아도 됩니다. 예를 들어 AWS Glue Data Catalog(Amazon S3 지원)에서 규칙을 작성하는 경우 카탈로그 테이블에서 사용 중인 폴더를 찾기 어려울 수 있습니다. AWS Glue Data Quality에서는 데이터 프레임을 채우는 데 사용되는 특정 폴더나 파일을 찾을 수 있습니다.
**참고**
이 기능은 파일이 DynamicFrame 또는 DataFrame으로 성공적으로 읽기된 경우에만 작동합니다.
```
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-1"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-256"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"]
```
제공된 체크섬이 계산된 체크섬과 다른 경우 FileMatch는 차이를 알립니다.
![\[스크린샷에서는 규칙의 DQ 상태가 실패인 규칙을 보여줍니다. FileMatch에서는 실패를 설명합니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/data-quality-file-match.png)
**선택적 파일 기반 규칙 태그:**
태그를 사용하면 규칙 동작을 제어할 수 있습니다.
**recentFiles**
이 태그는 가장 최근 파일을 먼저 유지하여 처리되는 파일 수를 제한합니다.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1
```
**uriRegex**
**참고**
`uriRegex` 태그는 AWS Glue 5.0 이상에서 사용할 수 있습니다.
이 태그는 파일 경로에 정규식 패턴을 적용하여 파일을 필터링합니다. 경로가 패턴과 일치하는 파일만 처리됩니다. 부정적 예측을 사용하여 패턴과 일치하는 파일을 제외할 수도 있습니다.
```
# Match only files with a .json extension
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with uriRegex = "\.json$"
# Exclude files ending in .tmp using a negative lookahead
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with uriRegex = "(?!.*\.tmp$).*"
```
**filterOrder**
**참고**
`filterOrder` 태그는 AWS Glue 5.0 이상에서 사용할 수 있습니다.
`recentFiles` 및 `uriRegex`와 같은 여러 필터 태그를 함께 사용하면 `filterOrder` 태그가 해당 태그의 적용 순서를 제어합니다. 기본 순서는 `recentFiles` 먼저, 그 다음에 `uriRegex`입니다.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1 with uriRegex = "\.json$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
이 태그는 파일의 이름이 중복되지 않게 합니다. 기본 동작은 false입니다.
```
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac04179sam4713e5ef8f319"] with matchFileName = "true"
```
이때 몇 가지 고려 사항이 있습니다.
1. AWS Glue ETL에서 Amazon S3 또는 AWS Glue Data Catalog 변환 직후 **EvaluateDataQuality** 변환이 있어야 합니다.
![\[스크린샷에서는 규칙의 DQ 상태가 실패인 규칙을 보여줍니다. FileMatch에서는 실패를 설명합니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/data-quality-file-match-transform.png)
1. 이 규칙은 AWS Glue 대화형 세션에서 작동하지 않습니다.
# FileUniqueness
파일 고유성을 사용하면 데이터 생산자로부터 수신한 데이터에 중복 파일이 없는지 확인할 수 있습니다.
다음 데이터 통계를 수집합니다.
1. 규칙에 따라 스캔된 파일 수
1. 파일의 고유성 비율
```
Dataset.*.FileUniquenessRatio: 1.00, Dataset.*.FileCount: 8.00
```
**폴더에서 중복 파일 찾기:**
```
FileUniqueness "s3://bucket/" > 0.5
FileUniqueness "s3://bucket/folder/" = 1
```
**데이터 프레임에서 직접 폴더 이름을 추론하여 중복 감지:**
항상 파일 경로를 제공하지 않아도 됩니다. 예를 들어 AWS Glue Data Catalog에서 규칙을 작성할 때 카탈로그 테이블에서 사용 중인 폴더를 찾기 어려울 수 있습니다. AWS Glue Data Quality에서는 데이터 프레임을 채우는 데 사용되는 특정 폴더나 파일을 찾을 수 있습니다.
**참고**
추론을 사용하는 경우 파일 기반 규칙은 DynamicFrame 또는 DataFrame으로 성공적으로 읽은 파일만 감지할 수 있습니다.
```
FileUniqueness > 0.5
```
**선택적 파일 기반 규칙 태그:**
태그를 사용하면 규칙 동작을 제어할 수 있습니다.
**recentFiles**
이 태그는 가장 최근 파일을 먼저 유지하여 처리되는 파일 수를 제한합니다.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with recentFiles = 1
```
**uriRegex**
**참고**
`uriRegex` 태그는 AWS Glue 5.0 이상에서 사용할 수 있습니다.
이 태그는 파일 경로에 정규식 패턴을 적용하여 파일을 필터링합니다. 경로가 패턴과 일치하는 파일만 처리됩니다. 부정적 예측을 사용하여 패턴과 일치하는 파일을 제외할 수도 있습니다.
```
# Match only files with a .csv extension
FileUniqueness "s3://bucket/" > 0.5 with uriRegex = "\.csv$"
# Exclude files ending in .tmp using a negative lookahead
FileUniqueness "s3://bucket/" > 0.5 with uriRegex = "(?!.*\.tmp$).*"
```
**filterOrder**
**참고**
`filterOrder` 태그는 AWS Glue 5.0 이상에서 사용할 수 있습니다.
`recentFiles` 및 `uriRegex`와 같은 여러 필터 태그를 함께 사용하면 `filterOrder` 태그가 해당 태그의 적용 순서를 제어합니다. 기본 순서는 `recentFiles` 먼저, 그 다음에 `uriRegex`입니다.
```
FileUniqueness "s3://bucket/" > 0.5 with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
이 태그는 파일의 이름이 중복되지 않게 합니다. 기본 동작은 false입니다.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with matchFileName = "true"
```
이때 몇 가지 고려 사항이 있습니다.
1. AWS Glue ETL에서 Amazon S3 또는 AWS Glue Data Catalog 변환 직후 **EvaluateDataQuality** 변환이 있어야 합니다.
1. 이 규칙은 AWS Glue 대화형 세션에서 작동하지 않습니다.
# FileSize
FileSize 규칙 유형을 사용하면 파일이 특정 파일 크기 기준을 충족하는지 확인할 수 있습니다. 다음 사용 사례에 유용합니다.
1. 생산자가 처리를 위해 빈 파일이나 상당히 작은 파일을 전송하지 않는지 확인합니다.
1. 대상 버킷에 성능 문제로 이어질 수 있는 더 작은 파일이 없는지 확인합니다.
FileSize는 다음 지표를 수집합니다.
1. 규정 준수: 설정한 규칙 임계치를 충족하는 파일의 비율(%) 반환
1. 파일 수: 규칙에 따라 스캔된 파일 수
1. 최소 파일 크기(바이트)
1. 최대 파일 크기(바이트)
```
Dataset.*.FileSize.Compliance: 1.00,
Dataset.*.FileCount: 8.00,
Dataset.*.MaximumFileSize: 327413121.00,
Dataset.*.MinimumFileSize: 204558920.00
```
이러한 지표에 대해서는 이상 탐지가 지원되지 않습니다.
**파일 크기 검증**
file.dat가 2MB를 초과하면 이 규칙이 통과됩니다.
```
FileSize "s3://amzn-s3-demo-bucket/file.dat" > 2 MB
```
지원되는 단위에는 B(바이트), MB(메가 바이트), GB(기가 바이트) 및 TB(테라 바이트)가 포함됩니다.
**폴더에서 파일 크기 검증**
```
FileSize "s3://bucket/" > 5 B
FileSize "s3://bucket/" < 2 GB
```
s3://amzn-s3-demo-bucket의 파일 중 70%가 2GB\$11TB인 경우 이 규칙을 통과합니다.
```
FileSize "s3://amzn-s3-demo-bucket/" between 2 GB and 1 TB with threshold > 0.7
```
**데이터 프레임에서 직접 파일 이름 추론**
항상 파일 경로를 제공하지 않아도 됩니다. 예를 들어 Data Catalog에서 규칙을 작성할 때 카탈로그 테이블에서 사용 중인 폴더를 찾기 어려울 수 있습니다. AWS Glue Data Quality에서는 데이터 프레임을 채우는 데 사용되는 특정 폴더나 파일을 찾을 수 있습니다.
**참고**
이 기능은 파일이 DynamicFrame 또는 DataFrame으로 성공적으로 읽기된 경우에만 작동합니다.
```
FileSize < 10 MB with threshold > 0.7
```
**선택적 파일 기반 규칙 태그:**
태그를 사용하면 규칙 동작을 제어할 수 있습니다.
**recentFiles**
이 태그는 가장 최근 파일을 먼저 유지하여 처리되는 파일 수를 제한합니다.
```
FileSize "s3://amzn-s3-demo-bucket/" > 5 B with recentFiles = 1
```
**uriRegex**
**참고**
`uriRegex` 태그는 AWS Glue 5.0 이상에서 사용할 수 있습니다.
이 태그는 파일 경로에 정규식 패턴을 적용하여 파일을 필터링합니다. 경로가 패턴과 일치하는 파일만 처리됩니다. 부정적 예측을 사용하여 패턴과 일치하는 파일을 제외할 수도 있습니다.
```
# Match only files with a .dat extension
FileSize "s3://bucket/" > 5 B with uriRegex = "\.dat$"
# Exclude files ending in .tmp using a negative lookahead
FileSize "s3://bucket/" > 5 B with uriRegex = "(?!.*\.tmp$).*"
```
**filterOrder**
**참고**
`filterOrder` 태그는 AWS Glue 5.0 이상에서 사용할 수 있습니다.
`recentFiles` 및 `uriRegex`와 같은 여러 필터 태그를 함께 사용하면 `filterOrder` 태그가 해당 태그의 적용 순서를 제어합니다. 기본 순서는 `recentFiles` 먼저, 그 다음에 `uriRegex`입니다.
```
FileSize "s3://bucket/" > 5 B with recentFiles = 5 with uriRegex = "\.dat$" with filterOrder = ["uriRegex","recentFiles"]
```
**failFast**
`"true"`로 설정하면 규칙은 모든 파일을 평가하고 규정 준수 비율을 계산하는 대신 크기 조건에 통과하지 못한 첫 번째 파일에서 즉시 실패를 반환합니다.
```
FileSize "s3://bucket/" > 2 MB with failFast = "true"
```
이때 몇 가지 고려 사항이 있습니다.
1. AWS Glue ETL에서는 Amazon S3 또는 Data Catalog 변환 직후 DataQuality 평가 변환이 있어야 합니다.
1. 이 규칙은 AWS Glue 대화형 세션에서 작동하지 않습니다.
# API를 사용하여 데이터 품질 측정 및 관리
이 주제에서는 API를 사용하여 데이터 품질을 측정하고 관리하는 방법에 대해 설명합니다.
**Contents**
+ [사전 조건](#using-apis-prerequisites)
+ [AWS Glue Data Quality 권장 사용](#using-apis-recommendations)
+ [AWS Glue Data Quality 규칙 세트 사용](#using-apis-rulesets)
+ [AWS Glue Data Quality 실행 사용](#using-apis-runs)
+ [AWS Glue Data Quality 결과 사용](#using-apis-results)
## 사전 조건
+ 최신 AWS Glue Data Quality API가 포함되도록 boto3 버전이 최신 버전인지 확인합니다.
+ 최신 CLI를 포함하도록 AWS CLI 버전이 최신인지 확인합니다.
AWS Glue 작업을 사용하여 이러한 API를 실행하는 경우 다음 옵션을 사용하여 boto3 라이브러리를 최신 버전으로 업데이트할 수 있습니다.
```
—additional-python-modules boto3==
```
## AWS Glue Data Quality 권장 사용
**AWS Glue Data Quality 권장 실행을 시작하려면:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def start_data_quality_rule_recommendation_run(self, database_name, table_name, role_arn):
"""
Starts a recommendation run that is used to generate rules when you don't know what rules to write. AWS Glue Data Quality
analyzes the data and comes up with recommendations for a potential ruleset. You can then triage the ruleset
and modify the generated ruleset to your liking.
:param database_name: The name of the AWS Glue database which contains the dataset.
:param table_name: The name of the AWS Glue table against which we want a recommendation
:param role_arn: The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM) role that grants permission to let AWS Glue access the resources it needs.
"""
try:
response = self.client.start_data_quality_rule_recommendation_run(
DataSource={
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name
}
},
Role=role_arn
)
except ClientError as err:
logger.error(
"Couldn't start data quality recommendation run %s. Here's why: %s: %s", name,
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response['RunId']
```
권장 실행의 경우 `pushDownPredicates` 또는 `catalogPartitionPredicates`를 사용하여 성능을 개선하고 카탈로그 소스의 특정 파티션에서만 권장을 실행할 수 있습니다.
```
client.start_data_quality_rule_recommendation_run(
DataSource={
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name,
'AdditionalOptions': {
'pushDownPredicate': "year=2022"
}
}
},
Role=role_arn,
NumberOfWorkers=2,
CreatedRulesetName=''
)
```
**AWS Glue Data Quality 권장 실행 결과를 얻으려면:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_data_quality_rule_recommendation_run(self, run_id):
"""
Gets the specified recommendation run that was used to generate rules.
:param run_id: The id of the data quality recommendation run
"""
try:
response = self.client.get_data_quality_rule_recommendation_run(RunId=run_id)
except ClientError as err:
logger.error(
"Couldn't get data quality recommendation run %. Here's why: %s: %s", run_id,
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
위의 응답 객체에서 실행에서 권장한 규칙 세트를 추출하여 이후 단계에서 사용할 수 있습니다.
```
print(response['RecommendedRuleset'])
Rules = [
RowCount between 2000 and 8000,
IsComplete "col1",
IsComplete "col2",
StandardDeviation "col3" between 58138330.8 and 64258155.09,
ColumnValues "col4" between 1000042965 and 1214474826,
IsComplete "col5"
]
```
**필터링 및 나열할 수 있는 모든 권장 실행 목록을 가져오려면:**
```
response = client.list_data_quality_rule_recommendation_runs(
Filter={
'DataSource': {
'GlueTable': {
'DatabaseName': '',
'TableName': ''
}
}
)
```
**기존 AWS Glue Data Quality 권장 작업을 취소하려면:**
```
response = client.cancel_data_quality_rule_recommendation_run(
RunId='dqrun-d4b6b01957fdd79e59866365bf9cb0e40fxxxxxxx'
)
```
## AWS Glue Data Quality 규칙 세트 사용
**AWS Glue Data Quality 규칙 세트를 생성하려면:**
```
response = client.create_data_quality_ruleset(
Name='',
Ruleset='Rules = [IsComplete "col1", IsPrimaryKey "col2", RowCount between 2000 and 8000]',
TargetTable={
'TableName': '',
'DatabaseName': ''
}
)
```
**데이터 품질 규칙 세트를 가져오려면:**
```
response = client.get_data_quality_ruleset(
Name=''
)
print(response)
```
이 API를 사용하여 규칙 세트를 추출할 수 있습니다.
```
print(response['Ruleset'])
```
**테이블의 모든 데이터 품질 규칙 세트를 나열하려면:**
```
response = client.list_data_quality_rulesets()
```
API 내의 필터 조건을 사용하여 특정 데이터베이스 또는 테이블에 연결된 모든 규칙 세트를 필터링할 수 있습니다.
```
response = client.list_data_quality_rulesets(
Filter={
'TargetTable': {
'TableName': '',
'DatabaseName': ''
}
},
)
```
**데이터 품질 규칙 세트를 업데이트하려면:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def update_data_quality_ruleset(self, ruleset_name, ruleset_string):
"""
Update an AWS Glue Data Quality Ruleset
:param ruleset_name: The name of the AWS Glue Data Quality ruleset to update
:param ruleset_string: The DQDL ruleset string to update the ruleset with
"""
try:
response = self.client.update_data_quality_ruleset(
Name=ruleset_name,
Ruleset=ruleset_string
)
except ClientError as err:
logger.error(
"Couldn't update the AWS Glue Data Quality ruleset. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
**데이터 품질 규칙 세트를 삭제하려면:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def delete_data_quality_ruleset(self, ruleset_name):
"""
Delete a AWS Glue Data Quality Ruleset
:param ruleset_name: The name of the AWS Glue Data Quality ruleset to delete
"""
try:
response = self.client.delete_data_quality_ruleset(
Name=ruleset_name
)
except ClientError as err:
logger.error(
"Couldn't delete the AWS Glue Data Quality ruleset. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
## AWS Glue Data Quality 실행 사용
**AWS Glue Data Quality 실행을 시작하려면:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def start_data_quality_ruleset_evaluation_run(self, database_name, table_name, role_name, ruleset_list):
"""
Start an AWS Glue Data Quality evaluation run
:param database_name: The name of the AWS Glue database which contains the dataset.
:param table_name: The name of the AWS Glue table against which we want to evaluate.
:param role_arn: The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM) role that grants permission to let AWS Glue access the resources it needs.
:param ruleset_list: The list of AWS Glue Data Quality ruleset names to evaluate.
"""
try:
response = client.start_data_quality_ruleset_evaluation_run(
DataSource={
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name
}
},
Role=role_name,
RulesetNames=ruleset_list
)
except ClientError as err:
logger.error(
"Couldn't start the AWS Glue Data Quality Run. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response['RunId']
```
`pushDownPredicate` 또는 `catalogPartitionPredicate` 파라미터를 전달하여 카탈로그 테이블 내의 특정 파티션 세트만 대상으로 데이터 품질 실행을 수행할 수 있습니다. 예:
```
response = client.start_data_quality_ruleset_evaluation_run(
DataSource={
'GlueTable': {
'DatabaseName': '',
'TableName': '',
'AdditionalOptions': {
'pushDownPredicate': 'year=2023'
}
}
},
Role='',
NumberOfWorkers=5,
Timeout=123,
AdditionalRunOptions={
'CloudWatchMetricsEnabled': False
},
RulesetNames=[
'',
]
)
```
또한 ROW 또는 COLUMN 수준에서 규칙 세트의 복합 규칙을 평가하는 방법도 구성할 수 있습니다. 복합 규칙의 작동 방식에 대한 자세한 내용은 설명서에서 [복합 규칙 작동 방식](dqdl.md#dqdl-syntax-composite-rules)을 참조하십시오.
요청에서 복합 규칙 평가 방법을 설정하는 방법을 보여주는 예:
```
response = client.start_data_quality_ruleset_evaluation_run(
DataSource={
'GlueTable': {
'DatabaseName': '',
'TableName': '',
'AdditionalOptions': {
'pushDownPredicate': 'year=2023'
}
}
},
Role='',
NumberOfWorkers=5,
Timeout=123,
AdditionalRunOptions={
'CompositeRuleEvaluationMethod':ROW
},
RulesetNames=[
'',
]
)
```
**AWS Glue Data Quality 실행에 대한 정보를 가져오려면:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_data_quality_ruleset_evaluation_run(self, run_id):
"""
Get details about an AWS Glue Data Quality Run
:param run_id: The AWS Glue Data Quality run ID to look up
"""
try:
response = self.client.get_data_quality_ruleset_evaluation_run(
RunId=run_id
)
except ClientError as err:
logger.error(
"Couldn't look up the AWS Glue Data Quality run ID. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
**AWS Glue Data Quality 실행 결과를 가져오려면:**
해당 AWS Glue Data Quality 실행에 대해 다음 방법을 사용하여 실행 평가 결과를 추출할 수 있습니다.
```
response = client.get_data_quality_ruleset_evaluation_run(
RunId='d4b6b01957fdd79e59866365bf9cb0e40fxxxxxxx'
)
resultID = response['ResultIds'][0]
response = client.get_data_quality_result(
ResultId=resultID
)
print(response['RuleResults'])
```
**AWS Glue Data Quality 실행을 모두 나열하려면:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def list_data_quality_ruleset_evaluation_runs(self, database_name, table_name):
"""
Lists all the AWS Glue Data Quality runs against a given table
:param database_name: The name of the database where the data quality runs
:param table_name: The name of the table against which the data quality runs were created
"""
try:
response = self.client.list_data_quality_ruleset_evaluation_runs(
Filter={
'DataSource': {
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name
}
}
}
)
except ClientError as err:
logger.error(
"Couldn't list the AWS Glue Quality runs. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
특정 시간 사이의 결과 또는 특정 테이블에 대해 실행된 결과만 표시하도록 filter 절을 수정할 수 있습니다.
**진행 중인 AWS Glue Data Quality 실행을 중지하려면:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def cancel_data_quality_ruleset_evaluation_run(self, result_id):
"""
Cancels a given AWS Glue Data Quality run
:param result_id: The result id of a AWS Glue Data Quality run to cancel
"""
try:
response = self.client.cancel_data_quality_ruleset_evaluation_run(
ResultId=result_id
)
except ClientError as err:
logger.error(
"Couldn't cancel the AWS Glue Data Quality run. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
## AWS Glue Data Quality 결과 사용
**AWS Glue Data Quality 실행 결과를 가져오려면:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_data_quality_result(self, result_id):
"""
Outputs the result of an AWS Glue Data Quality Result
:param result_id: The result id of an AWS Glue Data Quality run
"""
try:
response = self.client.get_data_quality_result(
ResultId=result_id
)
except ClientError as err:
logger.error(
"Couldn't get the AWS Glue Data Quality result. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
**특정 데이터 품질 결과에 대해 수집된 통계를 보려면:**
```
import boto3
from botocore.exceptions import ClientError
import logging
logger = logging.getLogger(__name__)
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_profile_for_data_quality_result(self, result_id):
"""
Outputs the statistic profile for a AWS Glue Data Quality Result
:param result_id: The result id of a AWS Glue Data Quality run
"""
try:
response = self.glue_client.get_data_quality_result(
ResultId=result_id
)
# the profile contains all statistics gathered for the result
profile_id = response['ProfileId']
profile = self.glue_client.list_data_quality_statistics(
ProfileId = profile_id
)
return profile
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality profile. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**여러 데이터 품질 실행에서 수집된 통계의 시계열을 보려면:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_statistics_for_data_quality_result(self, profile_id):
"""
Outputs an array of datapoints for each statistic in the input result.
:param result_id: The profile id of a AWS Glue Data Quality run
"""
try:
profile = self.glue_client.list_data_quality_statistics(
ProfileId = profile_id
)
statistics = [self.glue_client.list_data_quality_statistics(
StatisticId = s['StatisticId']
) for s in profile['Statistics']]
return statistics
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality statistics. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**특정 통계에 대한 이상 탐지 모델을 보려면:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_model_training_result_for_statistic(self, statistic_id, profile_id):
"""
Outputs the details (bounds) of anomaly detection training for the given statistic at the given profile.
:param statistic_id the model's statistic (the timeseries it is tracking)
:param profile_id the profile associated with the model (a point in the timeseries)
"""
try:
model = self.glue_client.get_data_quality_model_result(
ProfileId = profile_id, StatisticId = statistic_id
)
return model
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality model results. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**통계 모델의 이상 탐지 기준에서 데이터 포인트를 제외하려면:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def apply_exclusions_to_statistic(self, statistic_id, profile_ids):
"""
Annotate some points along a given statistic timeseries.
This example excludes the provided values; INCLUDE can also be used to undo this action.
:param statistic_id the statistic timeseries to annotate
:param profile_id the profiles we want to exclude (points in the timeseries)
"""
try:
response = self.glue_client.batch_put_data_quality_statistic_annotation(
InclusionAnnotations = [
{'ProfileId': prof_id,
'StatisticId': statistic_id,
'InclusionAnnotation': 'EXCLUDE'} for prof_id in profile_ids
]
)
return response['FailedInclusionAnnotations']
except ClientError as err:
logger.error(
"Couldn't store Data Quality annotations. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**특정 통계에 대한 이상 탐지 모델을 보려면:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_model_training_status_for_statistic(self, statistic_id, profile_id):
"""
Outputs the status of anomaly detection training for the given statistic at the given profile.
:param statistic_id the model's statistic (the timeseries it is tracking)
:param profile_id the profile associated with the model (a point in the timeseries)
"""
try:
model = self.glue_client.get_data_quality_model(
ProfileId = profile_id, StatisticId = statistic_id
)
return model
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality statistics. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**이상 탐지 기준에서 특정 데이터 품질 실행의 모든 결과를 제외하려면:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def apply_exclusions_to_profile(self, profile_id):
"""
Exclude datapoints produced by a run across statistic timeseries.
This example excludes the provided values; INCLUDE can also be used to undo this action.
:param profile_id the profiles we want to exclude (points in the timeseries)
"""
try:
response = self.glue_client.put_data_quality_profile_annotation(
ProfileId = profile_id,
InclusionAnnotation = "EXCLUDE"
)
return response
except ClientError as err:
logger.error(
"Couldn't store Data Quality annotations. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**특정 데이터 품질 실행의 결과를 가져와 결과를 표시하려면:**
AWS Glue Data Quality `runID`를 사용되면 아래와 같이 `resultID`을(를) 추출하여 실제 결과를 얻을 수 있습니다.
```
response = client.get_data_quality_ruleset_evaluation_run(
RunId='dqrun-abca77ee126abe1378c1da1ae0750d7dxxxx'
)
resultID = response['ResultIds'][0]
response = client.get_data_quality_result(
ResultId=resultID
)
print(resp['RuleResults'])
```
# 알림, 배포 및 예약 설정
이 주제에서는 AWS Glue Data Quality에 대한 알림, 배포 및 예약을 설정하는 방법을 설명합니다.
**Contents**
+ [Amazon EventBridge 통합에서 알림 설정](#data-quality-alerts-eventbridge)
+ [이벤트 패턴의 추가 구성 옵션](#data-quality-alerts-eventbridge-config-options)
+ [알림을 이메일 형식으로 지정](#data-quality-alerts-eventbridge-format-notifications)
+ [CloudWatch 통합에서 경보 및 알림 설정](#data-quality-alerts-cloudwatch)
+ [데이터 품질 결과를 쿼리하여 대시보드 구축](#data-quality-alerts-querying-results)
+ [AWS CloudFormation을 사용하여 데이터 품질 규칙 배포](#data-quality-deploy-cfn)
+ [데이터 품질 규칙 예약](#data-quality-scheduling-rules)
## Amazon EventBridge 통합에서 알림 설정
AWS Glue Data Quality는 데이터 품질 규칙 세트 평가 실행 완료 시 생성되는 EventBridge 이벤트의 게시를 지원합니다. 이를 통해 데이터 품질 규칙 실패 시 알림을 쉽게 설정할 수 있습니다.
다음은 데이터 카탈로그에서 데이터 품질 규칙 세트를 평가할 때 발생하는 샘플 이벤트입니다. 이 정보를 사용하여 Amazon EventBridge에서 사용할 수 있는 데이터를 검토할 수 있습니다. 추가 API 직접 호출을 통해 자세한 내용을 확인할 수 있습니다. 예를 들어 결과 ID로 `get_data_quality_result` API를 직접 호출하여 특정 실행의 세부 정보를 가져옵니다.
```
{
"version":"0",
"id":"abcdef00-1234-5678-9abc-def012345678",
"detail-type":"Data Quality Evaluation Results Available",
"source":"aws.glue-dataquality",
"account":"123456789012",
"time":"2017-09-07T18:57:21Z",
"region":"us-west-2",
"resources":[],
"detail":{
"context": {
"contextType": "GLUE_DATA_CATALOG",
"runId":"dqrun-12334567890",
"databaseName": "db-123",
"tableName": "table-123",
"catalogId": "123456789012"
},
"resultID": "dqresult-12334567890",
"rulesetNames": ["rulset1"],
"state":"SUCCEEDED",
"score": 1.00,
"rulesSucceeded": 100,
"rulesFailed": 0,
"rulesSkipped": 0
}
}
```
다음은 AWS Glue ETL 또는 AWS Glue Studio 노트북에서 데이터 품질 규칙 세트를 평가할 때 게시되는 샘플 이벤트입니다.
```
{
"version":"0",
"id":"abcdef00-1234-5678-9abc-def012345678",
"detail-type":"Data Quality Evaluation Results Available",
"source":"aws.glue-dataquality",
"account":"123456789012",
"time":"2017-09-07T18:57:21Z",
"region":"us-west-2",
"resources":[],
"detail":{
"context": {
"contextType": "GLUE_JOB",
"jobId": "jr-12334567890",
"jobName": "dq-eval-job-1234",
"evaluationContext": "",
}
"resultID": "dqresult-12334567890",
"rulesetNames": ["rulset1"],
"state":"SUCCEEDED",
"score": 1.00
"rulesSucceeded": 100,
"rulesFailed": 0,
"rulesSkipped": 0
}
}
```
Data Catalog와 ETL 작업 모두에서 데이터 품질 평가를 실행하는 경우, 기본적으로 선택되는 **Amazon CloudWatch에 지표 게시** 옵션을 선택한 상태로 유지해야 EventBridge에 게시할 수 있습니다.
**EventBridge 알림 설정**
![\[AWS CloudFormation에서 데이터 품질 속성\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/data-quality-properties-cfn.png)
생성된 이벤트를 수신하고 대상을 정의하려면 Amazon EventBridge 규칙을 구성해야 합니다. 규칙을 생성하려면:
1. Amazon EventBridge 콘솔을 엽니다.
1. 탐색 표시줄의 **버스** 섹션에서 **규칙**을 선택합니다.
1. [**Create Rule**]을 선택합니다.
1. **규칙 세부 정보 정의**에서:
1. 이름에 `myDQRule`을 입력합니다.
1. 설명을 입력합니다(선택 사항).
1. 이벤트 버스의 경우 이벤트 버스를 선택합니다. 이벤트 버스가 아직 없는 경우 기본값으로 둡니다.
1. 규칙 유형에서 **이벤트 패턴이 있는 규칙**을 선택하고 **다음**을 선택합니다.
1. **이벤트 패턴 작성**에서:
1. 이벤트 소스에서 **AWS 이벤트 또는 EventBridge 파트너 이벤트**를 선택합니다.
1. 샘플 이벤트 섹션은 건너뜁니다.
1. 생성 방법으로 **패턴 양식 사용**을 선택합니다.
1. 이벤트 패턴의 경우:
1. 이벤트 소스에 대한 **AWS 서비스**를 선택합니다.
1. AWS 서비스에 대한 **Glue Data Quality**를 선택합니다.
1. 이벤트 유형에 대해 **사용할 수 있는 데이터 품질 평가 결과**를 선택합니다.
1. 특정 상태에 대해 **실패**를 선택합니다. 그러면 다음과 비슷한 이벤트 패턴이 나타납니다.
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"state": ["FAILED"]
}
}
```
1. 더 많은 구성 옵션은 [이벤트 패턴의 추가 구성 옵션](#data-quality-alerts-eventbridge-config-options) 섹션을 참조하세요.
1. **대상 선택**에서:
1. **대상 유형**에 대해 **AWS 서비스**를 선택합니다.
1. **대상 선택** 드롭다운을 사용하여 연결하려는 AWS 서비스(SNS, Lambda, SQS 등)를 선택하고 **다음**을 선택합니다.
1. **태그 구성**에서 **새 태그 추가**를 클릭하여 선택적 태그를 추가하고 **다음**을 선택합니다.
1. 모든 선택 항목의 요약 페이지가 표시됩니다. 하단에서 **규칙 생성**을 선택합니다.
### 이벤트 패턴의 추가 구성 옵션
성공 또는 실패 시 이벤트 필터링 외에도 다양한 파라미터에서 이벤트를 추가로 필터링할 수 있습니다.
이렇게 하려면 이벤트 패턴 섹션으로 이동한 다음 **패턴 편집**을 선택하여 추가 파라미터를 지정합니다. 이벤트 패턴의 필드는 대소문자를 구분합니다. 다음은 이벤트 패턴 구성에 대한 예제입니다.
특정 규칙 세트를 평가하는 특정 테이블의 이벤트를 캡처하려면 다음 유형의 패턴을 사용합니다.
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"context": {
"contextType": ["GLUE_DATA_CATALOG"],
"databaseName": "db-123",
"tableName": "table-123",
},
"rulesetNames": ["ruleset1", "ruleset2"]
"state": ["FAILED"]
}
}
```
ETL 환경에서 특정 작업의 이벤트를 캡처하려면 다음 유형의 패턴을 사용합니다.
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"context": {
"contextType": ["GLUE_JOB"],
"jobName": ["dq_evaluation_job1", "dq_evaluation_job2"]
},
"state": ["FAILED"]
}
}
```
점수가 특정 임계값(예: 70%) 미만인 이벤트를 캡처하려면:
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"score": [{
"numeric": ["<=", 0.7]
}]
}
}
```
### 알림을 이메일 형식으로 지정
비즈니스 팀에 올바른 형식의 이메일 알림을 보내야 하는 경우가 있습니다. Amazon EventBridge와 AWS Lambda를 사용하면 됩니다.
![\[이메일 형식의 데이터 품질 알림\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/data_quality_sample_email.png)
다음 샘플 코드를 사용하여 데이터 품질 알림 형식을 지정하여 이메일을 생성할 수 있습니다.
```
import boto3
import json
from datetime import datetime
sns_client = boto3.client('sns')
glue_client = boto3.client('glue')
sns_topic_arn = 'arn:aws:sns:::'
def lambda_handler(event, context):
log_metadata = {}
message_text = ""
subject_text = ""
if event['detail']['context']['contextType'] == 'GLUE_DATA_CATALOG':
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['tableName'] = str(event['detail']['context']['tableName'])
log_metadata['databaseName'] = str(event['detail']['context']['databaseName'])
log_metadata['runId'] = str(event['detail']['context']['runId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_table_name: {}\n".format(log_metadata['tableName'])
message_text += "glue_database_name: {}\n".format(log_metadata['databaseName'])
message_text += "run_id: {}\n".format(log_metadata['runId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
else:
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['jobName'] = str(event['detail']['context']['jobName'])
log_metadata['jobId'] = str(event['detail']['context']['jobId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_job_name: {}\n".format(log_metadata['jobName'])
message_text += "job_id: {}\n".format(log_metadata['jobId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
resultID = str(event['detail']['resultId'])
response = glue_client.get_data_quality_result(ResultId=resultID)
RuleResults = response['RuleResults']
message_text += "\n\nruleset details evaluation steps results:\n\n"
subresult_info = []
for dic in RuleResults:
subresult = "Name: {}\t\tResult: {}\t\tDescription: \t{}".format(dic['Name'], dic['Result'], dic['Description'])
if 'EvaluationMessage' in dic:
subresult += "\t\tEvaluationMessage: {}".format(dic['EvaluationMessage'])
subresult_info.append({
'Name': dic['Name'],
'Result': dic['Result'],
'Description': dic['Description'],
'EvaluationMessage': dic.get('EvaluationMessage', '')
})
message_text += "\n" + subresult
log_metadata['resultrun'] = subresult_info
sns_client.publish(
TopicArn=sns_topic_arn,
Message=message_text,
Subject=subject_text
)
return {
'statusCode': 200,
'body': json.dumps('Message published to SNS topic')
}
```
## CloudWatch 통합에서 경보 및 알림 설정
Amazon EventBridge를 사용하여 데이터 품질 알림을 설정하는 것이 좋습니다. Amazon EventBridge는 고객에게 알림을 보낼 때 일회성 설정을 요구하기 때문입니다. 하지만 익숙하기 때문에 Amazon CloudWatch를 선호하는 고객도 있습니다. 이러한 고객을 위해 Amazon CloudWatch와의 통합을 제공합니다.
각 AWS Glue Data Quality 평가에서는 데이터 품질 실행당 `glue.data.quality.rules.passed`(통과한 규칙의 수를 나타냄) 및 `glue.data.quality.rules.failed`(실패한 규칙의 수를 나타냄)와 같은 지표 페어를 생성합니다. 이 생성된 지표를 사용하여 해당 데이터 품질 실행이 임계값 아래로 떨어질 경우 사용자에게 알리는 경보를 생성할 수 있습니다. Amazon SNS 알림을 통해 이메일을 보내는 경보 설정을 시작하려면 아래 단계를 수행합니다.
Amazon SNS 알림을 통해 이메일을 보내는 경보 설정을 시작하려면 아래 단계를 수행합니다.
1. Amazon CloudWatch 콘솔을 엽니다.
1. **지표** 아래에서 **모든 지표**를 선택합니다. Glue Data Quality라는 사용자 지정 네임스페이스 아래에 추가 네임스페이스가 표시됩니다.
**참고**
AWS Glue 데이터 품질 실행을 시작할 때 **Amazon CloudWatch에 지표 게시** 확인란이 활성화되어 있는지 확인합니다. 그렇지 않으면 특정 실행에 대한 지표가 Amazon CloudWatch에 게시되지 않습니다.
`Glue Data Quality` 네임스페이스 아래에서 테이블 및 규칙 세트별로 지표가 생성되었음을 알 수 있습니다. 이 주제의 목적에 따라 이 값이 1을 초과하는 경우 `glue.data.quality.rules.failed` 규칙 및 경보를 사용합니다(즉, 실패한 규칙 평가 수가 1보다 크면 알림을 제공하려고 함).
1. 경보를 생성하려면 **경보** 아래에서 **모든 경보**를 선택합니다.
1. **경보 생성**을 선택하세요.
1. **지표 선택**을 선택하세요.
1. 생성한 테이블에 해당하는 `glue.data.quality.rules.failed` 지표를 선택한 다음 **지표 선택**을 선택합니다.
1. **지표 및 조건 지정** 탭의 **지표** 섹션 아래에서:
1. **Statistic(통계)**에서 **Sum(합계)**를 선택합니다.
1. **기간**에서 **1분**을 선택합니다.
1. **조건** 섹션에서:
1. **임계값 유형(Threshold type)**에서 **정적(Static)**을 선택합니다.
1. **glue.data.quality.rules.failed 조건이 다음과 같을 때마다...**에서 **이상**을 선택합니다.
1. **기준...**에서 임계값으로 **1**을 입력합니다.
이렇게 선택하면 `glue.data.quality.rules.failed` 지표가 1 이상의 값을 생성하는 경우 경보가 트리거됩니다. 하지만 데이터가 없으면 허용 가능한 값으로 간주합니다.
1. **다음**을 선택합니다.
1. **작업 구성**에서:
1. **경보 상태 트리거**에서 **경보 내**를 선택합니다.
1. **다음 SNS 주제로 알림 보내기** 섹션에서 **새 주제를 생성하여 새 SNS 주제를 통해 알림 보내기**를 선택합니다.
1. **알림을 수신할 이메일 엔드포인트**에 이메일 주소를 입력합니다. 그리고 **주제 생성**을 클릭합니다.
1. **다음**을 선택합니다.
1. **경보 이름**에 `myFirstDQAlarm`을 입력한 후 **다음**을 선택합니다.
1. 모든 선택 항목의 요약 페이지가 표시됩니다. 하단에서 **경보 생성**을 선택합니다.
이제 Amazon CloudWatch 경보 대시보드에서 경보가 생성되는 것을 볼 수 있습니다.
## 데이터 품질 결과를 쿼리하여 대시보드 구축
대시보드를 구축하여 데이터 품질 결과를 표시할 수 있습니다. 이렇게 하는 방법은 두 가지입니다.
**다음 코드를 사용하여 Amazon S3에 데이터를 쓰도록 Amazon EventBridge 설정:**
```
import boto3
import json
from datetime import datetime
s3_client = boto3.client('s3')
glue_client = boto3.client('glue')
s3_bucket = 's3-bucket-name'
def write_logs(log_metadata):
try:
filename = datetime.now().strftime("%m%d%Y%H%M%S") + ".json"
key_opts = {
'year': datetime.now().year,
'month': "{:02d}".format(datetime.now().month),
'day': "{:02d}".format(datetime.now().day),
'filename': filename
}
s3key = "gluedataqualitylogs/year={year}/month={month}/day={day}/{filename}".format(**key_opts)
s3_client.put_object(Bucket=s3_bucket, Key=s3key, Body=json.dumps(log_metadata))
except Exception as e:
print(f'Error writing logs to S3: {e}')
def lambda_handler(event, context):
log_metadata = {}
message_text = ""
subject_text = ""
if event['detail']['context']['contextType'] == 'GLUE_DATA_CATALOG':
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['tableName'] = str(event['detail']['context']['tableName'])
log_metadata['databaseName'] = str(event['detail']['context']['databaseName'])
log_metadata['runId'] = str(event['detail']['context']['runId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_table_name: {}\n".format(log_metadata['tableName'])
message_text += "glue_database_name: {}\n".format(log_metadata['databaseName'])
message_text += "run_id: {}\n".format(log_metadata['runId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
else:
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['jobName'] = str(event['detail']['context']['jobName'])
log_metadata['jobId'] = str(event['detail']['context']['jobId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_job_name: {}\n".format(log_metadata['jobName'])
message_text += "job_id: {}\n".format(log_metadata['jobId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
resultID = str(event['detail']['resultId'])
response = glue_client.get_data_quality_result(ResultId=resultID)
RuleResults = response['RuleResults']
message_text += "\n\nruleset details evaluation steps results:\n\n"
subresult_info = []
for dic in RuleResults:
subresult = "Name: {}\t\tResult: {}\t\tDescription: \t{}".format(dic['Name'], dic['Result'], dic['Description'])
if 'EvaluationMessage' in dic:
subresult += "\t\tEvaluationMessage: {}".format(dic['EvaluationMessage'])
subresult_info.append({
'Name': dic['Name'],
'Result': dic['Result'],
'Description': dic['Description'],
'EvaluationMessage': dic.get('EvaluationMessage', '')
})
message_text += "\n" + subresult
log_metadata['resultrun'] = subresult_info
write_logs(log_metadata)
return {
'statusCode': 200,
'body': json.dumps('Message published to SNS topic')
}
```
Amazon S3에 데이터를 쓴 후 AWS Glue 크롤러를 사용하여 Athena에 등록하고 테이블을 쿼리할 수 있습니다.
**데이터 품질 평가 중에 Amazon S3 위치 구성:**
AWS Glue 데이터 카탈로그 또는 AWS Glue ETL에서 데이터 품질 작업을 실행할 때 Amazon S3 위치를 제공하여 데이터 품질 결과를 Amazon S3에 쓸 수 있습니다. 아래 구문을 통해 데이터 품질 결과를 읽기 위해 대상을 참조하여 테이블을 생성할 수 있습니다.
`CREATE EXTERNAL TABLE` 및 `MSCK REPAIR TABLE` 쿼리는 별도로 실행해야 합니다.
```
CREATE EXTERNAL TABLE (
catalogid string,
databasename string,
tablename string,
dqrunid string,
evaluationstartedon timestamp,
evaluationcompletedon timestamp,
rule string,
outcome string,
failurereason string,
evaluatedmetrics string)
PARTITIONED BY (
`year` string,
`month` string,
`day` string)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES (
'paths'='catalogId,databaseName,dqRunId,evaluatedMetrics,evaluationCompletedOn,evaluationStartedOn,failureReason,outcome,rule,tableName')
STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://glue-s3-dq-bucket-us-east-2-results/'
TBLPROPERTIES (
'classification'='json',
'compressionType'='none',
'typeOfData'='file');
```
```
MSCK REPAIR TABLE ;
```
위 테이블을 생성한 후에 Amazon Athena를 사용하여 분석 쿼리를 실행할 수 있습니다.
## AWS CloudFormation을 사용하여 데이터 품질 규칙 배포
AWS CloudFormation을 사용하여 데이터 품질 규칙을 생성할 수 있습니다. 자세한 내용은 [AWS Glue에 대한 AWS CloudFormation](https://docs.aws.amazon.com/glue/latest/dg/populate-with-cloudformation-templates.html)을 참조하세요.
## 데이터 품질 규칙 예약
다음 방법을 사용하여 데이터 품질 규칙을 예약할 수 있습니다.
+ 데이터 카탈로그에서 데이터 품질 규칙을 예약합니다. 코드를 사용하지 않는 사용자도 이 옵션을 사용하여 데이터 품질 검사를 쉽게 예약할 수 있습니다. AWS Glue Data Quality는 Amazon EventBridge에서 예약을 생성합니다. 데이터 품질 규칙을 예약하려면:
+ 규칙 세트로 이동한 다음 **실행**을 클릭합니다.
+ **실행 빈도**에서 원하는 예약을 선택하고 **작업 이름**을 제공합니다. 이 작업 이름은 EventBridge에서의 예약 이름입니다.
+ Amazon EventBridge 및 AWS Step Functions를 사용하여 데이터 품질 규칙에 대한 평가 및 권장 사항을 조정합니다.
# AWS Glue Data Quality의 저장 데이터 암호화
AWS Glue Data Quality는 기본적으로 암호화를 제공하여 민감한 고객 저장 데이터를 AWS 자체 암호화 키를 사용하여 보호합니다.
## AWS 소유 키
AWS Glue Data Quality는 이러한 키를 사용하여 고객의 데이터 품질 자산을 자동으로 암호화합니다. 사용자는 AWS 소유 키를 확인, 관리 또는 사용하거나 사용을 감사할 수 없습니다. 하지만 데이터를 암호화하는 키를 보호하기 위해 어떤 작업을 수행하거나 어떤 프로그램을 변경할 필요가 없습니다. 자세한 내용은 AWS KMS 개발자 가이드에서 [AWS 소유 키](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk)를 참조하세요.
기본적으로 저장 데이터를 암호화하면 민감한 데이터 보호와 관련된 운영 오버헤드와 복잡성을 줄이는 데 도움이 됩니다. 동시에 엄격한 암호화 규정 준수 및 규제 요구 사항을 충족하는 안전한 애플리케이션을 구축할 수 있습니다.
이 암호화 계층을 비활성화하거나 다른 암호화 유형을 선택할 수는 없지만 Data Quality 리소스를 생성할 때 고객 관리형 키를 선택하여 기존 AWS 소유 암호화 키에 두 번째 암호화 계층을 추가할 수 있습니다.
## 고객 관리형 키
**고객 관리형 키**: AWS Glue Data Quality는 사용자가 생성하고 소유하고 관리하는 대칭형 고객 관리형 키를 사용하도록 지원합니다. 따라서 기존 AWS 소유 암호화에 두 번째 암호화 계층이 추가됩니다. 이 암호화 계층을 완전히 제어할 수 있으므로 다음과 같은 작업을 수행할 수 있습니다.
+ 키 정책 수립 및 유지
+ IAM 정책 수립 및 유지
+ 키 정책 활성화 및 비활성화
+ 키 암호화 자료 교체
+ 태그 추가
+ 키 별칭 만들기
+ 삭제를 위한 스케줄 키
자세한 내용은 AWS KMS Developer Guide의 [Customer managed keys](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk)를 참조하십시오.
다음 표에는 AWS Glue Data Quality가 다양한 데이터 품질 자산을 암호화하는 방법이 요약되어 있습니다.
| 데이터 유형 | AWS 소유 키 암호화 | 고객 관리형 키 암호화 |
| --- | --- | --- |
| **데이터 품질 규칙 세트** 영구 DQ 규칙 세트에서 참조하는 DQDL 규칙 세트 문자열입니다. 이러한 영구 규칙 세트는 현재 AWS Glue Data Catalog 환경에서만 사용됩니다. | 활성화됨 | 활성화됨 |
| **데이터 품질 규칙/분석기 결과 ** 규칙 세트에 있는 각 규칙의 통과/실패 상태와 규칙과 분석기 모두에서 수집한 지표를 포함하는 결과 아티팩트입니다. | 활성화됨 | 활성화됨 |
| **관찰** 데이터에서 이상이 탐지되면 관찰 항목이 생성됩니다. 여기에는 예상 상한과 하한에 대한 정보와 이러한 한도를 기반으로 제안되는 규칙이 포함됩니다. 생성된 경우 Data Quality 결과와 함께 표시됩니다. | 활성화됨 | 활성화됨 |
| **통계** 지표 값(예: RowCount, Completeness), 열 이름, 기타 메타데이터 등 지정된 규칙 세트로 데이터를 평가한 후 수집된 지표에 대한 정보를 포함합니다. | 활성화됨 | 활성화됨 |
| **이상 탐지 통계 모델** 통계 모델에는 고객 데이터에 대한 이전 평가를 기반으로 생성된 특정 지표에 대한 상한과 하한의 시계열이 포함됩니다. | 활성화됨 | 활성화됨 |
**참고**
AWS Data Quality는 AWS 소유 키를 사용하여 저장된 데이터를 자동으로 암호화하여 개인 식별 데이터를 무료로 보호할 수 있습니다. 그러나 고객 관리형 키 사용에는 AWS KMS 비용이 부과됩니다. 요금에 대한 자세한 내용은 [AWS KMS 요금](https://aws.amazon.com/kms/pricing/) 부분을 참조하세요.
에 대한 자세한 설명은 AWS KMS 섹션을 참조하십시오..[AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)
## 고객 관리형 키 생성
AWS Management Console 또는 AWS KMS API를 사용하여 대칭형 고객 관리형 키를 만들 수 있습니다.
**대칭형 고객 관리형 키를 생성하려면**
+ 자세한 내용은 AWS Key Management Service 개발자 가이드의 [대칭 암호화 AWS KMS 키 생성](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk)의 단계를 따르세요.
### 키 정책
키 정책은 고객 관리형 키에 대한 액세스를 제어합니다. 모든 고객 관리형 키에는 키를 사용할 수 있는 사람과 키를 사용하는 방법을 결정하는 문장이 포함된 정확히 하나의 키 정책이 있어야 합니다. 고객 관리형 키를 만들 때 키 정책을 지정할 수 있습니다. 자세한 내용은 AWS Key Management Service 개발자 가이드에서 [AWS KMS 키의 키 정책](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html)을 참조하세요.
Data Quality 리소스에서 고객 관리형 키를 사용하려면 키 정책에서 다음 API 작업을 허용해야 합니다.
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) - `GenerateDataKeyWithoutPlaintext`를 사용하여 AWS KMS 키로 암호화된 사이퍼텍스트를 해독합니다.
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html) - Amazon Location에서 키의 유효성을 확인할 수 있도록 고객 관리형 키 세부 정보를 제공합니다.
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html) - AWS KMS 외부에서 사용할 고유한 대칭 데이터 키를 반환합니다. 이 작업은 지정한 대칭 암호화 KMS 키로 암호화된 데이터 키를 반환합니다. 키의 바이트 수는 무작위이며 호출자 또는 KMS 키와는 무관합니다. 고객이 실행해야 하는 KMS 호출을 줄이는 데 사용됩니다.
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html) - 사이퍼텍스트를 해독한 다음 AWS KMS 내에서 완전히 다시 암호화합니다. 이 작업을 사용하여 데이터가 암호화되는 KMS 키를 변경할 수 있습니다. 예를 들어 KMS 키를 [수동으로 교체](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html#rotate-keys-manually)하거나 암호문을 보호하는 KMS 키를 변경할 수 있습니다. 또한 사이퍼텍스트의 [암호화 컨텍스트](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context)를 변경하는 등 동일한 KMS 키로 암호문을 다시 암호화하는 데에도 사용할 수 있습니다.
다음은 Amazon Location에 추가할 수 있는 정책 설명 예시입니다.
```
"Statement" : [
{
"Sid" : "Allow access to principals authorized to use AWS Glue Data Quality",
"Effect" : "Allow",
"Principal" : {
"AWS": "arn:aws:iam:::role/ExampleRole"
},
"Action" : [
"kms:Decrypt",
"kms:DescribeKey",
"kms:GenerateDataKeyWithoutPlaintext",
"kms:ReEncrypt*"
],
"Resource" : "*",
"Condition" : {
"StringEquals" : {
"kms:ViaService" : "glue.amazonaws.com",
"kms:CallerAccount" : "111122223333"
}
},
{
"Sid": "Allow access for key administrators",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action" : [
"kms:*"
],
"Resource": "arn:aws:kms:region:111122223333:key/key_ID"
},
{
"Sid" : "Allow read-only access to key metadata to the account",
"Effect" : "Allow",
"Principal" : {
"AWS" : "arn:aws:iam::111122223333:root"
},
"Action" : [
"kms:Describe*",
"kms:Get*",
"kms:List*",
],
"Resource" : "*"
}
]
```
### AWS Glue Data Quality의 KMS 키 사용에 관한 참고 사항
AWS Glue Data Quality는 키 전환을 지원하지 않습니다. 즉, A 키로 데이터 품질 자산을 암호화하고 B 키로 전환하면, B 키를 사용하기 위해 A 키로 암호화된 데이터를 다시 암호화하지 않습니다. 어쨌든 B 키로 전환할 수는 있지만 이전에 A 키로 암호화된 데이터에 액세스하려면 A 키에 대한 액세스 권한을 유지해야 합니다.
정책의 권한 지정에 대한 자세한 내용은 AWS Key Management Service 개발자 가이드에서 [키 정책의 AWS 서비스에 대한 권한](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-services.html)을 참조하세요.
키 액세스 관련 문제 해결에 대한 내용은 AWS Key Management Service 개발자 가이드에서 [키 액세스 문제 해결](https://docs.aws.amazon.com/kms/latest/developerguide/policy-evaluation.html)을 참조하세요.
## 보안 구성 생성
AWS Glue의 [보안 구성 리소스](encryption-security-configuration.md)에는 암호화된 데이터를 쓸 때 필요한 속성이 포함되어 있습니다.
**데이터 품질 자산을 암호화하려면:**
1. **암호화 설정**의 **고급 설정**에서 **데이터 품질 암호화 활성화**를 선택합니다.
1. KMS 키를 선택하거나 **AWS KMS 키 생성**을 선택합니다.
![\[이 스크린샷은 보안 구성 추가 페이지를 보여줍니다. DataQuality 암호화 활성화 옵션이 선택되었습니다.\]](http://docs.aws.amazon.com/ko_kr/glue/latest/dg/images/data-quality-add-security-configuration.png)
## AWS Glue Data Quality 암호화 컨텍스트
[암호화 컨텍스트](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context)는 데이터에 대한 추가 컨텍스트 정보를 포함하는 선택적 키-값 페어 세트입니다.
AWS KMS는 암호화 컨텍스트를 [추가 인증 데이터](https://docs.aws.amazon.com/crypto/latest/userguide/cryptography-concepts.html#term-aad)로 사용하여 [인증된 암호화](https://docs.aws.amazon.com/crypto/latest/userguide/cryptography-concepts.html#term-aad)를 지원합니다. 데이터 암호화 요청에 암호화 컨텍스트를 포함하는 경우, AWS KMS는 암호화된 데이터에 암호화 컨텍스트를 바인딩합니다. 데이터 복호화를 위해, 이 요청에 동일한 암호화 컨텍스트를 포함합니다.
### AWS Glue Data Quality 암호화 컨텍스트 예
```
"encryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "beacon:ACTIVE"
}
```
### 모니터링을 위한 암호화 컨텍스트 사용
대칭형 고객 관리 키를 사용하여 트래커 또는 지오펜스 컬렉션을 암호화하는 경우 감사 기록 및 로그의 암호화 컨텍스트를 사용하여 고객 관리 키가 사용되는 방식을 식별할 수도 있습니다. 암호화 컨텍스트는 AWS CloudTrail 또는 Amazon CloudWatch Logs에서 생성되는 로그에도 나타납니다.
## AWS Glue Data Quality의 암호화 키 모니터링
AWS KMS 고객 관리형 키를 AWS Glue Data Quality 리소스에 사용하는 경우 AWS CloudTrail 또는 Amazon CloudWatch Logs를 사용하여 AWS Glue Data Quality가 AWS KMS에 보내는 요청을 추적할 수 있습니다.
다음은 AWS Glue Data Quality에서 고객 관리 키로 암호화된 데이터에 액세스하기 위해 직접적으로 호출한 KMS 운영을 모니터링하기 위한 `GenerateDataKeyWithoutPlainText` 및 `Decrypt`의 AWS CloudTrail 이벤트입니다.
**Decrypt**
```
{
"eventVersion": "1.09",
"userIdentity": {
"type": "AssumedRole",
"arn": "arn:aws:sts::111122223333:role/CustomerRole",
"accountId": "111122223333",
"invokedBy": "glue.amazonaws.com"
},
"eventTime": "2024-07-02T20:03:10Z",
"eventSource": "kms.amazonaws.com",
"eventName": "Decrypt",
"awsRegion": "us-east-1",
"sourceIPAddress": "glue.amazonaws.com",
"userAgent": "glue.amazonaws.com",
"requestParameters": {
"keyId": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"encryptionAlgorithm": "SYMMETRIC_DEFAULT",
"encryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:ACTIVE",
"version": "branch:version:ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE"
}
},
"responseElements": null,
"requestID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"eventID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"readOnly": true,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
}
],
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "111122223333",
"eventCategory": "Management"
}
```
**GenerateDataKeyWithoutPlaintext**
```
{
"eventVersion": "1.09",
"userIdentity": {
"type": "AssumedRole",
"arn": "arn:aws:sts::111122223333:role/CustomerRole",
"accountId": "111122223333",
"invokedBy": "glue.amazonaws.com"
},
"eventTime": "2024-07-02T20:03:10Z",
"eventSource": "kms.amazonaws.com",
"eventName": "GenerateDataKeyWithoutPlaintext",
"awsRegion": "us-east-1",
"sourceIPAddress": "glue.amazonaws.com",
"userAgent": "glue.amazonaws.com",
"requestParameters": {
"keyId": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"encryptionAlgorithm": "SYMMETRIC_DEFAULT",
"encryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:version:ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE"
}
},
"responseElements": null,
"requestID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"eventID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"readOnly": true,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
}
],
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "111122223333",
"eventCategory": "Management"
}
```
**ReEncyrpt**
```
{
"eventVersion": "1.09",
"userIdentity": {
"type": "AssumedRole",
"arn": "arn:aws:sts::111122223333:role/CustomerRole",
"accountId": "111122223333",
"invokedBy": "glue.amazonaws.com"
},
"eventTime": "2024-07-17T21:34:41Z",
"eventSource": "kms.amazonaws.com",
"eventName": "ReEncrypt",
"awsRegion": "us-east-1",
"sourceIPAddress": "glue.amazonaws.com",
"userAgent": "glue.amazonaws.com",
"requestParameters": {
"destinationEncryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:ACTIVE"
"version": "branch:version:12345678-SAMPLE"
},
"destinationKeyId": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"sourceAAD": "1234567890-SAMPLE+Z+lqoYOHj7VtWxJLrvh+biUFbliYDAQkobM=",
"sourceKeyId": "arn:aws:kms:ap-southeast-2:585824196334:key/17ca05ca-a8c1-40d7-b7fd-30abb569a53a",
"destinationEncryptionAlgorithm": "SYMMETRIC_DEFAULT",
"sourceEncryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:version:ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE"
},
"destinationAAD": "1234567890-SAMPLE",
"sourceEncryptionAlgorithm": "SYMMETRIC_DEFAULT"
},
"responseElements": null,
"requestID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"eventID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"readOnly": true,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
},
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
}
],
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "111122223333",
"eventCategory": "Management"
}
```
## 자세히 알아보기
다음 리소스에서 키에 대한 추가 정보를 확인할 수 있습니다.
+ [AWS Key Management Service 기본 개념](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html)에 대한 자세한 내용은 AWS Key Management Service 개발자 가이드를 참조하세요.
+ [AWS Key Management Service의 보안 모범 사례](https://docs.aws.amazon.com/kms/latest/developerguide/best-practices.html)에 대한 자세한 내용은 AWS Key Management Service 개발자 가이드를 참조하세요.
# AWS Glue Data Quality 오류 해결
AWS Glue Data Quality에서 오류가 발생하면 다음 해결 방법을 사용하여 문제의 원인을 찾아 수정할 수 있습니다.
**Contents**
+ [오류: 누락된 AWS Glue Data Quality 모듈](#data-quality-trouble-error-1)
+ [오류: AWS Lake Formation 권한 부족](#data-quality-trouble-error-2)
+ [오류: 규칙 세트의 이름이 고유하지 않음](#data-quality-trouble-error-3)
+ [오류: 특수 문자가 있는 테이블](#data-quality-trouble-error-4)
+ [오류: 큰 규칙 세트로 인한 오버플로 오류](#data-quality-trouble-error-5)
+ [오류: 전체 규칙 상태에서 실패임](#data-quality-trouble-error-6)
+ [AnalysisException: 기본 데이터베이스의 존재를 확인할 수 없음](#data-quality-trouble-error-7)
+ [오류 메시지: Provided key map not suitable for given data frames](#data-quality-trouble-error-8)
+ [사용자 클래스에서 예외: java.lang.RuntimeException: 데이터를 가져오지 못했습니다. 자세한 내용은 CloudWatch의 로그를 확인하세요.](#data-quality-trouble-error-9)
+ [시작 오류: 버킷에 대해 S3에서 다운로드하는 중 오류 발생](#data-quality-trouble-error-10)
+ [InvalidInputException(상태: 400): 데이터 품질 규칙을 구문 분석할 수 없음](#data-quality-trouble-error-11)
+ [오류: Eventbridge에서 사용자가 설정한 일정에 따라 Glue DQ 작업을 트리거하지 않습니다.](#data-quality-trouble-error-12)
+ [CustomSQL 오류](#data-quality-trouble-error-13)
+ [동적 규칙](#data-quality-trouble-error-14)
+ [사용자 클래스의 예외: org.apache.spark.sql.AnalysisException: org.apache.hadoop.hive.ql.metadata.HiveException](#data-quality-trouble-error-15)
+ [UNCLASSIFIED\$1ERROR; IllegalArgumentException: Parsing Error: No rules or analyzers provided., no viable alternative at input](#data-quality-trouble-error-16)
## 오류: 누락된 AWS Glue Data Quality 모듈
**오류 메시지**: No module named 'awsgluedq'.
**해결 방법**: 이 오류는 지원되지 않는 버전에서 AWS Glue Data Quality을 실행할 때 발생합니다. AWS Glue Data Quality는 Glue 버전 3.0 이상에서만 지원됩니다.
## 오류: AWS Lake Formation 권한 부족
**오류 메시지**: Exception in User Class: `com.amazonaws.services.glue.model.AccessDeniedException`: Insufficient Lake Formation permission(s) on impact\$1sdg\$1involvement (Service: AWS Glue; Status Code: 400; Error Code: AccessDeniedException; Request ID: 465ae693-b7ba-4df0-a4e4-6b17xxxxxxxx; Proxy: null).
**해결 방법**: AWS Lake Formation에 충분한 권한을 제공해야 합니다.
## 오류: 규칙 세트의 이름이 고유하지 않음
**오류 메시지**: Exception in User Class: ...services.glue.model.AlreadyExistsException: Another ruleset with the same name already exists.
**해결 방법**: 규칙 세트는 글로벌 항목이며 고유해야 합니다.
## 오류: 특수 문자가 있는 테이블
**오류 메시지**: Exception in User Class: org.apache.spark.sql.AnalysisException: cannot resolve ''C'' given input columns: [primary.data\$1end\$1time, primary.data\$1start\$1time, primary.end\$1time, primary.last\$1updated, primary.message, primary.process\$1date, primary.rowhash, primary.run\$1by, primary.run\$1id, primary.start\$1time, primary.status]; line 1 pos 44;.
**해결 방법**: 현재 '.' 같은 특수 문자가 있는 테이블에서는 AWS Glue Data Quality를 실행할 수 없다는 제한 사항이 있습니다.
## 오류: 큰 규칙 세트로 인한 오버플로 오류
**오류 메시지**: Exception in User Class: java.lang.StackOverflowError.
**해결 방법**: 규칙 개수가 2,000개가 넘는 큰 규칙 세트가 있는 경우 이 문제가 발생할 수 있습니다. 규칙을 여러 규칙 세트로 구분합니다.
## 오류: 전체 규칙 상태에서 실패임
**오류 조건**: 내 규칙 세트는 성공했지만 전체 규칙 상태는 실패입니다.
**해결 방법**: 이 오류는 게시하는 동안 Amazon CloudWatch에 지표를 게시하는 옵션을 선택했기 때문에 발생했을 수 있습니다. 데이터 세트가 VPC에 있는 경우 VPC는 AWS Glue에서 Amazon CloudWatch에 지표를 게시하는 것을 허용하지 않을 수 있습니다. 이 경우 VPC에서 Amazon CloudWatch에 액세스할 수 있도록 엔드포인트를 설정해야 합니다.
## AnalysisException: 기본 데이터베이스의 존재를 확인할 수 없음
**오류 조건**: AnalysisException: 기본 데이터베이스의 존재를 확인할 수 없음: com.amazonaws.services.glue.model.AccessDeniedException: 기본에서 Lake Formation 권한 부족(서비스: AWS Glue, 상태 코드: 400, 오류 코드: AccessDeniedException, 요청 ID: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX, 프록시: null)
**해결 방법**: AWS Glue 작업의 카탈로그 통합에서 AWS Glue는 항상 기본 데이터베이스의 존재 여부와 AWS Glue `GetDatabase API`의 사용 여부를 확인하려고 합니다. `DESCRIBE` Lake Formation 권한이 부여되지 않거나 `GetDatabase IAM` 권한이 부여되면 기본 데이터베이스의 존재를 확인할 때 작업에 실패합니다.
이 문제를 해결하려면:
1. Lake Formation에서 기본 데이터베이스에 대한 `DESCRIBE` 권한을 추가합니다.
1. Lake Formation에서 데이터베이스 생성자로 AWS Glue 작업에 연결된 IAM 역할을 구성합니다. 그러면 자동으로 기본 데이터베이스가 생성되고 역할에 필요한 Lake Formation 권한이 부여됩니다.
1. `--enable-data-catalog` 옵션을 비활성화합니다. (이는 AWS Glue Studio에서 **Hive 메타스토어로 Data Catalog 사용**으로 표시됩니다.)
작업에 Spark SQL Data Catalog 통합이 필요하지 않은 경우 이를 비활성화할 수 있습니다.
## 오류 메시지: Provided key map not suitable for given data frames
**오류 조건**: 제공된 키 맵이 해당 데이터 프레임에 적합하지 않습니다.
**해결 방법**: **DataSetMatch** 규칙 유형을 사용하고 있으며 조인 키가 중복되었습니다. 조인 키는 고유해야 하며 NULL이 아니어야 합니다. 고유한 조인 키를 사용할 수 없는 경우에는 **AggregateMatch**와 같은 다른 규칙 유형을 사용하여 요약 데이터와 일치시키는 것이 좋습니다.
## 사용자 클래스에서 예외: java.lang.RuntimeException: 데이터를 가져오지 못했습니다. 자세한 내용은 CloudWatch의 로그를 확인하세요.
**오류 조건**: 사용자 클래스에서 예외: java.lang.RuntimeException: 데이터를 가져오지 못했습니다. 자세한 내용은 CloudWatch의 로그를 확인하세요.
**해결 방법**: 이 문제는 Amazon S3 기반 테이블에서 Amazon RDS 또는 Amazon Redshift와 비교되는 DQ 규칙을 생성할 때 발생합니다. 이 경우에는 AWS Glue에서 연결을 로드할 수 없습니다. 대신 Amazon Redshift 또는 Amazon RDS 데이터 세트에 DQ 규칙을 설정하세요. 이는 알려진 버그입니다.
## 시작 오류: 버킷에 대해 S3에서 다운로드하는 중 오류 발생
**오류 조건**: 시작 오류: 버킷에 대해 S3에서 다운로드하는 중 오류 발생: `aws-glue-ml-data-quality-assets-us-east-1, key: jars/aws-glue-ml-data-quality-etl.jar.Access Denied (Service: Amazon S3; Status Code: 403; Please refer logs for details) `.
**해결 방법**: AWS Glue Data Quality에 전달된 역할의 권한에서 이전 Amazon S3 위치에서의 읽기를 허용해야 합니다. 이 IAM 정책은 다음 역할에 연결되어야 합니다.
```
{
"Sid": "allowS3",
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::aws-glue-ml-data-quality-assets-/*"
}
```
자세한 권한은 [데이터 품질 권한 부여](https://docs.aws.amazon.com/glue/latest/dg/data-quality-authorization.html)를 참조하세요. 이 라이브러리는 데이터 세트의 데이터 품질을 평가하는 데 필요합니다.
## InvalidInputException(상태: 400): 데이터 품질 규칙을 구문 분석할 수 없음
**오류 조건**: InvalidInputException(상태: 400): 데이터 품질 규칙을 구문 분석할 수 없습니다.
**해결 방법**: 이 오류에는 여러 가지 가능성이 있습니다. 한 가지 가능성으로, 규칙에 작은따옴표가 포함되었을 수 있습니다. 큰따옴표로 묶여 있는지 확인합니다. 예제:
```
Rules = [
ColumnValues "tipo_vinculo" in ["CODO", "DOCO", "COCO", "DODO"] AND "categoria" = 'ES"
AND "cod_bandera" = 'CEP'
```
이를 다음과 같이 변경합니다.
```
Rules = [
(ColumnValues "tipovinculo" in [ "CODO", "DOCO", "COCO", "DODO"]) AND (ColumnValues "categoria" = "ES")
AND (ColumnValues "codbandera" = "CEP")
]
```
## 오류: Eventbridge에서 사용자가 설정한 일정에 따라 Glue DQ 작업을 트리거하지 않습니다.
**오류 조건**: Eventbridge에서 사용자가 설정한 일정에 따라 AWS Glue Data Quality 작업을 트리거하지 않습니다.
**해결 방법**: 작업을 트리거하는 역할에 적절한 권한이 없을 수 있습니다. 작업을 시작하는 데 사용하는 역할에 [평가 실행 예약에 필요한 IAM 설정](https://docs.aws.amazon.com/glue/latest/dg/data-quality-authorization.html#data-quality-iam-setup-evaluation-runs)에서 언급한 권한이 있는지 확인합니다.
## CustomSQL 오류
**오류 조건**:` The output from CustomSQL must contain at least one column that matches the input dataset for AWS Glue Data Quality to provide row level results. The SQL query is a valid query but no columns from the SQL result are present in the Input Dataset. Ensure that matching columns are returned from the SQL`.
**해결 방법**: SQL 쿼리가 유효한 경우 기본 테이블에서 열만 선택했는지 확인합니다. 기본 테이블의 열에서 sum, count 등의 집계 함수를 선택하면 이 오류가 발생할 수 있습니다.
**오류 조건**:` There was a problem when executing your SQL statement: cannot resolve "Col"`.
**해결 방법**: 이 열은 기본 테이블에 없습니다.
**오류 조건**:` The columns that are returned from the SQL statement should only belong to the primary table. "In this case, some columns ( Col ) belong to reference table"`.
**해결 방법**: SQL 쿼리에서 기본 테이블을 다른 참조 테이블과 조인할 때 기본 테이블에 대해 행 수준 결과를 생성하려면 select 문에 기본 테이블의 열 이름만 있는지 확인합니다.
## 동적 규칙
**오류 조건**`: Dynamic rules require job context, and cannot be evaluated in interactive session or data preview.`.
**원인:** 해당 오류 메시지는 규칙 세트에 동적 DQ 규칙이 있는 경우 데이터 미리 보기 결과 또는 다른 대화형 세션에 나타날 수 있습니다. 동적 규칙은 특정 작업 이름 및 평가 컨텍스트와 관련된 기록 지표를 참조하므로 대화형 세션에서는 평가할 수 없습니다.
**해결 방법**: AWS Glue 작업을 실행하면 이전 지표가 생성되며 이후 동일한 작업에 대한 작업 실행 시 참조할 수 있습니다.
**오류 조건**:
+ ` [RuleType] rule only supports simple atomic operands in thresholds.`.
+ `Function last not yet implemented for [RuleType] rule.`
**해결 방법**: 동적 규칙은 일반적으로 숫자 표현식의 모든 DQDL 규칙 유형에 대해 지원됩니다([데이터 품질 정의 언어(DQDL) 참조](dqdl.md) 참조). 그러나 여러 지표를 생성하는 일부 규칙인 ColumnValues 및 ColumnLength는 아직 지원되지 않습니다.
**오류 조건**:` Binary expression operands must resolve to a single number.`.
**원인**: 동적 규칙은 `RowCount > avg(last(5)) * 0.9`와 같은 이진 표현식을 지원합니다. 여기서 이진 표현식은 `avg(last(5)) * 0.9`입니다. 이 규칙은 피연산자 `avg(last(5))` 및 `0.9`가 모두 단일 숫자로 해석되므로 유효합니다. `RowCount > last(5) * 0.9`는 잘못된 예입니다. `last(5)`는 현재 행 수와 유의미하게 비교할 수 없는 목록을 생성하기 때문입니다.
**해결 방법**: 집계 함수를 사용하여 목록 값 피연산자를 단일 숫자로 줄입니다.
**오류 조건**:
+ `Rule threshold results in list, and a single value is expected. Use aggregation functions to produce a single value. Valid example: sum(last(10)), avg(last(10)).`
+ `Rule threshold results in empty list, and a single value is expected.`
**원인**: 동적 규칙을 사용하여 데이터 세트의 일부 기능을 기록 값과 비교할 수 있습니다. 마지막 함수를 사용하는 경우 양의 정수 인수가 제공되면 여러 기록 값을 검색할 수 있습니다. 예를 들어 `last(5)`는 규칙에 대한 작업 실행에서 관찰된 가장 최근의 값 5개를 검색합니다.
**해결 방법**: 현재 작업 실행에서 관찰된 값과 유의미한 비교를 수행하려면 집계 함수를 사용하여 이러한 값을 단일 숫자로 줄여야 합니다.
유효한 예:
+ `RowCount >= avg(last(5))`
+ `RowCount > last(1)`
+ `RowCount < last()`
잘못된 예: `RowCount > last(5)`.
**오류 조건**:
+ `Function index used in threshold requires positive integer argument.`
+ `Index argument must be an integer. Valid syntax example: RowCount > index(last(10, 2)), which means RowCount must be greater than third most recent execution from last 10 job runs.`
**해결 방법**: 동적 규칙을 작성할 때 `index` 집계 함수를 사용하여 목록에서 하나의 기록 값을 선택할 수 있습니다. 예를 들어 `RowCount > index(last(5)`, 1)은 현재 작업에서 관찰된 행 수가 해당 작업에서 관찰된 두 번째로 최근 행 수보다 확실하게 큰지 여부를 확인합니다. `index`는 0으로 인덱싱됩니다.
**오류 조건**:` IllegalArgumentException: Parsing Error: Rule Type: DetectAnomalies is not valid`.
**해결 방법**: 이상 탐지는 AWS Glue 4.0에서만 사용할 수 있습니다.
**오류 조건**:` IllegalArgumentException: Parsing Error: Unexpected condition for rule of type ... no viable alternative at input ...`.
참고: `...`은 동적입니다. 예시: `IllegalArgumentException: Parsing Error: Unexpected condition for rule of type RowCount with number return type, line 4:19 no viable alternative at input '>last'`.
**해결 방법**: 이상 탐지는 AWS Glue 4.0에서만 사용할 수 있습니다.
## 사용자 클래스의 예외: org.apache.spark.sql.AnalysisException: org.apache.hadoop.hive.ql.metadata.HiveException
**오류 조건**`: Exception in User Class: org.apache.spark.sql.AnalysisException: org.apache.hadoop.hive.ql.metadata.HiveException: Unable to fetch table mailpiece_submitted. StorageDescriptor#InputFormat cannot be null for table: mailpiece_submitted (Service: null; Status Code: 0; Error Code: null; Request ID: null; Proxy: null)`
**원인:** AWS Glue 데이터 카탈로그에서 Apache Iceberg를 사용 중이고 AWS Glue 데이터 카탈로그의 입력 형식 속성이 비어 있습니다.
**해결 방법**: 이 문제는 DQ 규칙에서 CustomSQL 레이블 유형을 사용할 때 발생합니다. 이 문제를 해결하는 한 가지 방법은 ‘기본’을 사용하거나 카탈로그 이름 `glue_catalog.`를 `. in Custom ruletype`으로 추가하는 것입니다.
## UNCLASSIFIED\$1ERROR; IllegalArgumentException: Parsing Error: No rules or analyzers provided., no viable alternative at input
**오류 조건**`: UNCLASSIFIED_ERROR; IllegalArgumentException: Parsing Error: No rules or analyzers provided., no viable alternative at input`
**해결 방법**: DQDL이 구문 분석할 수 없습니다. 이러한 현상이 발생하는 몇 가지 경우가 있습니다. 복합 규칙을 사용하는 경우 괄호가 올바른지 확인하세요.
```
(RowCount >= avg(last(10)) * 0.6) and (RowCount <= avg(last(10)) * 1.4) instead of
RowCount >= avg(last(10)) * 0.6 and RowCount <= avg(last(10)) * 1.4
```