기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.
# 수집 중 로그 변환
로그 변환 및 보강을 사용하면 CloudWatch Logs로 수집할 때 일관되고 컨텍스트가 풍부한 형식으로 모든 로그를 정규화할 수 있습니다. AWS WAF 및 Amazon Route 53과 같은 일반적인 AWS 서비스에 대해 사전 구성된 템플릿을 사용하여 로그에 구조를 추가하거나 [Grok](CloudWatch-Logs-Transformation-Configurable.md#CloudWatch-Logs-Transformation-Grok)과 같은 네이티브 파서를 사용하여 사용자 지정 변환기를 빌드할 수 있습니다. 기존 속성의 이름을 바꾸고 계정 ID 및 리전과 같은 추가 메타데이터를 로그에 추가할 수도 있습니다.
로그 변환은 애플리케이션 전반의 로그 쿼리를 간소화 및 단축하고 로그에 대한 알림 생성을 간소화하는 데 도움이 됩니다. 이 기능은 VPC 흐름 로그, Route 53 및 같은 주요 AWS 로그 소스에 대한 out-of-the-box 제공 변환 템플릿을 사용하여 일반적인 로그 유형에 대한 변환을 제공합니다 Amazon RDS for PostgreSQL. 사전 구성된 변환 템플릿을 사용하거나 필요에 맞게 사용자 지정 트랜스포머를 생성할 수 있습니다.
로그 변환을 사용하면 형식과 속성 이름이 매우 다양한 소스에서 내보낸 로그를 관리할 수 있습니다.
트랜스포머를 생성하면 수집된 로그 이벤트가 변환되고 표준 형식으로 저장됩니다. 이러한 변환된 로그를 활용하여 다음 기능을 통해 분석 경험을 가속화할 수 있습니다.
+ [필드 인덱스](CloudWatchLogs-Field-Indexing.md)
+ [CloudWatch Logs Insights 검색된 필드](CWL_AnalyzeLogData-discoverable-fields.md)
+ [지표 필터](MonitoringLogData.md)를 사용한 경보의 유연성
+ [구독 필터](Subscriptions.md)를 통한 전달
+ [Contributor Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ContributorInsights.html)를 사용하여 로그 이벤트에서 지표 데이터를 생성하면 Contributor Insights 규칙이 변환 전 또는 후에 로그 이벤트를 평가하도록 선택할 수 있습니다.
변환은 로그 수집 중에만 발생합니다. 이미 수집된 로그 이벤트는 변환할 수 없습니다. 변환은 되돌릴 수 없습니다. 원본 로그와 변환된 로그는 모두 동일한 보존 정책을 사용하여 CloudWatch Logs에 저장됩니다. 로그 변환 및 보강 기능은 기존 표준 로그 클래스 수집 가격에 포함됩니다. 로그 스토리지 비용은 원래 로그 볼륨을 초과할 수 있는 변환 후 로그 크기를 기준으로 합니다.
**중요**
로그 이벤트가 변환된 후에는 CloudWatch Logs Insights 쿼리를 사용하여 변환된 로그 버전을 확인해야 합니다. [GetLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetLogEvents.html) 및 [ FilterLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_FilterLogEvents.html) 작업은 변환되기 전에 로그 이벤트의 원래 버전만 반환합니다.
**중요**
PutLogEvents에서 최대 1MB를 허용하는 단일 로그 이벤트에도 불구하고 로그 변환은 크기가 512kb 미만인 로그 이벤트만 처리할 수 있습니다. 512kb보다 큰 모든 로그 이벤트는 변환에 실패하고 오류를 내보냅니다. PutLogEvents의 총 크기는 여전히 512kb를 초과할 수 있습니다.
다른 형식으로 변환하는 것 외에도 계정 ID, 리전 및 키워드와 같은 추가 컨텍스트로 로그를 보강할 수도 있습니다. 로그 그룹 이름과 정적 키워드에서 추출됩니다.
로그 변환은 형식과 속성 이름이 매우 다양한 소스에서 생성된 로그를 제공하는 데 도움이 됩니다.
로그 변환 및 보강은 표준 로그 클래스의 로그 그룹에 대해서만 지원됩니다.
개별 로그 그룹에 대한 트랜스포머를 생성할 수 있으며 계정의 모든 또는 많은 로그 그룹에 적용되는 계정 수준 트랜스포머를 생성할 수도 있습니다. 로그 그룹에 로그 그룹 수준 트랜스포머가 있는 경우 해당 트랜스포머는 해당 로그 그룹에 적용되는 모든 계정 수준 트랜스포머를 재정의합니다.
**Topics**
+ [로그 트랜스포머 생성 및 관리](CloudWatch-Logs-Transformation-Create.md)
+ [구성 가능한 구문 분석기 유형 프로세서](CloudWatch-Logs-Transformation-Configurable.md)
+ [AWS 벤딩 로그용 기본 제공 프로세서](CloudWatch-Logs-Transformation-BuiltIn.md)
+ [문자열 변형 프로세서](CloudWatch-Logs-Transformation-StringMutate.md)
+ [JSON 변형 프로세서](CloudWatch-Logs-Transformation-JSONMutate.md)
+ [데이터타입 컨버터 프로세서](CloudWatch-Logs-Transformation-Datatype.md)
+ [변환 지표 및 오류](Transformation-Errors-Metrics.md)
# 로그 트랜스포머 생성 및 관리
로그 트랜스포머에는 논리적 파이프라인에 함께 있는 하나 이상의 *프로세서*가 포함됩니다. 각 프로세서는 트랜스포머 구성에 나열된 순서대로 차례로 로그 이벤트에 적용됩니다.
일부 프로세서는 *구문 분석기* 유형입니다. 각 트랜스포머에는 구문 분석기가 하나 이상 있어야 하며, 트랜스포머의 첫 번째 프로세서는 구문 분석기여야 합니다.
일부 구문 분석기는 특정 유형의 AWS 판매 로그에 대해 구성된 기본 제공 구문 분석기입니다.
다른 프로세서 유형은 문자열 변형기, JSON 변형기 및 데이터 프로세서입니다.
개별 로그 그룹에 대한 트랜스포머를 생성할 수 있으며 계정의 모든 또는 많은 로그 그룹에 적용되는 계정 수준 트랜스포머를 생성할 수도 있습니다. 로그 그룹에 로그 그룹 수준 트랜스포머가 있는 경우 해당 트랜스포머는 해당 로그 그룹에 적용되는 모든 계정 수준 트랜스포머를 재정의합니다. 계정의 한 리전에 최대 20개의 계정 수준 트랜스포머를 보유할 수 있습니다.
트랜스포머를 생성할 때 이러한 지침을 따라야 합니다.
+ AWS 판매된 로그 유형에 대해 미리 구성된 구문 분석기를 포함하는 경우 변환기에 나열된 첫 번째 프로세서여야 합니다. 트랜스포머에는 이러한 프로세서를 하나만 포함할 수 있습니다.
+ 트랜스포머에는 `grok` 프로세서를 하나만 포함할 수 있습니다.
+ 트랜스포머에 구문 분석기 유형 프로세서가 하나 이상 있어야 합니다. 최대 5개의 구문 분석기 유형 프로세서를 포함할 수 있습니다. 이 5개 제한에는 기본 제공 구문 분석기와 구성 가능한 구문 분석기가 모두 포함됩니다.
+ 트랜스포머에는 최대 20개의 프로세서가 있을 수 있습니다.
+ 트랜스포머에는 **addKeys** 프로세서를 하나만 포함할 수 있습니다.
+ 트랜스포머에는 **copyValue** 프로세서를 하나만 포함할 수 있습니다.
+ 각 트랜스포머는 로그 이벤트에서 최대 200개의 필드를 추출할 수 있습니다.
+ 각 로그 이벤트는 512KB 미만이어야 **합니다**. 로그 이벤트의 총 크기는 여전히 512KB를 초과할 수 있습니다.
**Topics**
+ [계정 수준 트랜스포머 정책 생성](CloudWatchLogs-Transformer-CreateAccountLevel.md)
+ [계정 수준 트랜스포머 정책 편집 또는 삭제](CloudWatchLogs-Transformer-EditAccountLevel.md)
+ [처음부터 로그 그룹 수준 로그 트랜스포머 생성](CloudWatch-Logs-Transformation-CreateNew.md)
+ [기존 트랜스포머를 복사하여 로그 그룹 수준 트랜스포머 생성](CloudWatch-Logs-Transformation-Copy.md)
+ [로그 그룹 수준 트랜스포머 편집](CloudWatch-Logs-Transformation-Edit.md)
+ [로그 그룹 수준 트랜스포머 삭제](CloudWatch-Logs-Transformation-Delete.md)
# 계정 수준 트랜스포머 정책 생성
이 섹션의 단계를 사용하여 계정의 모든 로그 그룹 또는 동일한 문자열(접두사)로 시작하는 로그 그룹 이름이 있는 여러 로그 그룹에 적용되는 트랜스포머 정책을 생성합니다. 한 리전에 최대 20개의 계정 수준 트랜스포머 정책을 보유할 수 있습니다.
동일한 접두사를 사용하거나 하나의 접두사가 다른 접두사에 포함된 두 개의 트랜스포머 정책을 동일한 리전에 생성할 수 없습니다. 예를 들어, 문자열 접두사 `/aws/lambda`에 대해 하나의 트랜스포머 정책을 생성하는 경우 접두사 `/aws`로 다른 트랜스포머 정책을 생성할 수 없습니다. 하지만 `/aws/lambda`용 트랜스포머 하나와 `/aws/waf`용 트랜스포머 하나가 있을 수 있습니다.
**계정 수준 트랜스포머 정책을 생성하려면**
1. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)에서 CloudWatch 콘솔을 엽니다.
1. 왼쪽 탐색 창에서 **설정**을 선택한 다음, **로그** 탭을 선택합니다.
1. **계정의 트랜스포머 정책** 섹션에서 **트랜스포머 정책 생성**을 선택합니다.
1. **트랜스포머 정책 이름**에 새 정책의 이름을 입력합니다.
1. **로그 그룹 선택**에서 다음 중 하나를 수행합니다.
+ 트랜스포머 정책을 계정의 모든 표준 클래스 로그 그룹에 적용하려면 **모든 표준 로그 그룹**을 선택합니다.
+ **접두사 매칭별 로그 그룹**을 선택하여 이름이 모두 동일한 문자열로 시작하는 로그 그룹의 하위 집합에 정책을 적용합니다. 그런 다음 **선택 기준**에 이러한 로그 그룹의 접두사를 입력합니다.
1. **구문 분석기 선택** 영역에서 **구문 분석기**를 사용하여 트랜스포머에 포함할 구문 분석기를 선택합니다.
AWS 벤딩된 로그 유형에 대해 사전 구성된 구문 분석기인 경우 해당 로그에 대한 구성을 지정할 필요가 없습니다.
다른 구문 분석기인 경우 구성을 지정해야 합니다. 자세한 내용은 [구성 가능한 구문 분석기 유형 프로세서](CloudWatch-Logs-Transformation-Configurable.md)에서 해당 프로세서에 대한 정보를 참조하세요.
1. 다른 프로세서를 추가하려면 **프로세서 선택**을 선택합니다. 그런 다음 프로세서 상자에서 원하는 **프로세서**를 선택하고 구성 파라미터를 입력합니다.
프로세서는 트랜스포머에 추가하는 순서대로 로그 이벤트에서 작동합니다.
1. (선택 사항) 프로세서를 추가하려면 **\$1 프로세서**를 선택하고 이전 단계를 반복합니다.
1. (선택 사항) 샘플 로그 이벤트에서 지금까지 빌드한 트랜스포머를 언제든지 테스트할 수 있습니다. 이렇게 하려면 **트랜스포머 미리 보기** 섹션에서 다음 중 하나를 수행합니다.
+ **로그 그룹 선택**에서 최대 5개의 로그 그룹을 선택한 다음, **최신 로그 이벤트 로드**를 선택합니다. 그런 다음 **트랜스포머 테스트**를 선택합니다.
+ 로그 이벤트를 **샘플 로그 이벤트**에 직접 복사한 다음, **트랜스포머 테스트**를 선택합니다.
그러면 로그의 변환된 버전이 나타납니다.
1. 프로세서 추가를 마치고 샘플 로그의 테스트에 만족하면 **저장**을 선택합니다.
1. 모두 마쳤으면 **생성**을 선택합니다.
# 계정 수준 트랜스포머 정책 편집 또는 삭제
이 섹션의 단계를 사용하여 계정 수준 트랜스포머 정책을 편집하거나 삭제합니다.
**계정 수준 트랜스포머 정책을 편집하거나 삭제하려면**
1. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)에서 CloudWatch 콘솔을 엽니다.
1. 왼쪽 탐색 창에서 **설정**을 선택한 다음, **로그** 탭을 선택합니다.
1. **트랜스포머 계정 정책** 섹션에서 **관리**를 선택합니다.
1. 관리하려는 트랜스포머 정책 옆에 있는 버튼을 선택한 다음 **편집** 또는 **삭제**를 선택합니다.
정책을 편집하는 경우 옵션을 보려면 [구성 가능한 구문 분석기 유형 프로세서](CloudWatch-Logs-Transformation-Configurable.md)의 5\$111단계를 참조하세요.
# 처음부터 로그 그룹 수준 로그 트랜스포머 생성
다음 단계에 따라 로그 그룹 수준 트랜스포머를 처음부터 생성합니다.
**콘솔을 사용하여 로그 그룹에 대한 로그 트랜스포머를 생성하려면**
1. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)에서 CloudWatch 콘솔을 엽니다.
1. 탐색 창에서 **로그**, **로그 그룹**을 선택합니다.
1. 트랜스포머를 생성하려는 로그 그룹을 선택합니다.
1. **트랜스포머** 탭을 선택합니다. 탭 목록을 보려면 오른쪽으로 스크롤해야 할 수 있습니다.
1. **트랜스포머 생성**을 선택합니다.
1. **구문 분석기 선택** 상자에서 트랜스포머에 포함할 구문 분석기를 선택합니다.
AWS 벤딩된 로그 유형에 대해 사전 구성된 구문 분석기인 경우 해당 로그에 대한 구성을 지정할 필요가 없습니다.
다른 구문 분석기인 경우 구성을 지정해야 합니다. 자세한 내용은 [구성 가능한 구문 분석기 유형 프로세서](CloudWatch-Logs-Transformation-Configurable.md)에서 해당 프로세서에 대한 정보를 참조하세요.
1. 다른 프로세서를 추가하려면 **\$1 프로세서 추가**를 선택합니다. 그런 다음 **프로세서 선택** 상자에서 원하는 프로세서를 선택하고 구성 파라미터를 입력합니다.
프로세서는 트랜스포머에 추가하는 순서대로 로그 이벤트에서 작동합니다.
1. (선택 사항) 샘플 로그 이벤트에서 지금까지 빌드한 트랜스포머를 언제든지 테스트할 수 있습니다. 그렇게 하려면 다음을 수행합니다.
1. **변환 미리 보기** 섹션에서 **샘플 로그 로드**를 선택하여 이 트랜스포머가 사용되는 로그 그룹에서 샘플 로그 이벤트를 로드하거나 로그 이벤트를 텍스트 상자에 붙여넣습니다.
**트랜스포머 테스트**를 선택합니다. 로그의 변환된 버전이 나타납니다.
1. 프로세서 추가를 마치고 샘플 로그의 테스트에 만족하면 **저장**을 선택합니다.
**AWS CLI 를 사용하여 처음부터 로그 변환기를 생성하려면**
+ `aws logs put-transformer` 명령을 사용합니다. `parseJSON`을 첫 번째 프로세서로 사용할 때는 `@message`를 소스 필드로 사용하여 전체 로그 이벤트를 구문 분석해야 합니다. 초기 JSON 구문 분석 후 후속 프로세서에서 특정 필드를 조작할 수 있습니다. 다음은 `parseJSON` 및 `addKeys` 프로세서를 포함하는 트랜스포머를 생성하는 예제입니다.
```
aws logs put-transformer \
--transformer-config '[{"parseJSON":{"source":"@message"}},{"addKeys":{"entries":[{"key":"metadata.transformed_in","value":"CloudWatchLogs"},{"key":"feature","value":"Transformation"}]}},{"trimString":{"withKeys":["status"]}}]' \
--log-group-identifier my-log-group-name
```
# 기존 트랜스포머를 복사하여 로그 그룹 수준 트랜스포머 생성
콘솔을 사용하여 기존 트랜스포머의 JSON 구성을 복사할 수 있습니다. 그런 다음 해당 코드를 사용하여를 사용하여 동일한 변환기를 생성 AWS CLI하거나 먼저 구성을 수정할 수 있습니다.
**기존 로그 트랜스포머를 복사하여 로그 트랜스포머를 생성하려면**
1. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)에서 CloudWatch 콘솔을 엽니다.
1. 탐색 창에서 **로그**, **로그 그룹**을 선택합니다.
1. 복사하려는 트랜스포머가 있는 로그 그룹을 선택합니다.
1. **변환** 탭을 선택합니다. 탭 목록을 보려면 오른쪽으로 스크롤해야 할 수 있습니다.
1. **트랜스포머 관리**를 선택합니다.
1. **트랜스포머 복사**를 선택합니다. 그러면 트랜스포머 JSON이 클립보드에 복사됩니다.
1. 파일을 생성하고 트랜스포머 구성에 붙여 넣습니다. 이 예제에서는 `CopiedTransformer.json` 파일을 직접 호출합니다
1. AWS CLI 를 사용하여 해당 구성으로 새 변환기를 생성합니다.
```
aws logs put-transformer --log-group-identifier my-log-group-name \
--transformer-config file://CopiedTransformer.json
```
# 로그 그룹 수준 트랜스포머 편집
다음 단계에 따라 기존 로그 트랜스포머를 편집합니다.
**로그 트랜스포머를 편집하려면**
1. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)에서 CloudWatch 콘솔을 엽니다.
1. 탐색 창에서 **로그**, **로그 그룹**을 선택합니다.
1. 편집하려는 트랜스포머가 있는 로그 그룹을 선택합니다.
1. **변환** 탭을 선택합니다. 탭 목록을 보려면 오른쪽으로 스크롤해야 할 수 있습니다.
1. **트랜스포머 관리**를 선택합니다.
1. **구문 분석기** 및 **프로세서** 섹션에서 변경합니다.
1. 다른 프로세서를 추가하려면 **\$1 프로세서 추가**를 선택합니다. 그런 다음 프로세서 상자에서 원하는 **프로세서**를 선택하고 구성 파라미터를 입력합니다.
프로세서는 트랜스포머에 추가하는 순서대로 로그 이벤트에서 작동합니다.
1. (선택 사항) 샘플 로그 이벤트에서 지금까지 빌드한 트랜스포머를 언제든지 테스트할 수 있습니다. 그렇게 하려면 다음을 수행합니다.
1. **변환 미리 보기** 섹션에서 **샘플 로그 로드**를 선택하여 이 트랜스포머가 사용되는 로그 그룹에서 샘플 로그 이벤트를 로드하거나 로그 이벤트를 텍스트 상자에 붙여넣습니다.
**변환 테스트**를 선택합니다. 로그의 변환된 버전이 나타납니다.
1. 프로세서 추가를 마치고 샘플 로그의 테스트에 만족하면 **저장**을 선택합니다.
# 로그 그룹 수준 트랜스포머 삭제
다음 단계에 따라 로그 트랜스포머를 삭제합니다.
**로그 트랜스포머를 삭제하려면**
1. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)에서 CloudWatch 콘솔을 엽니다.
1. 탐색 창에서 **로그**, **로그 그룹**을 선택합니다.
1. 편집하려는 트랜스포머가 있는 로그 그룹을 선택합니다.
1. **변환** 탭을 선택합니다. 탭 목록을 보려면 오른쪽으로 스크롤해야 할 수 있습니다.
1. **삭제**를 선택합니다.
1. 확인 상자에서 **정책 삭제**를 선택합니다.
# 구성 가능한 구문 분석기 유형 프로세서
이 섹션에는 로그 이벤트 변환기에서 사용할 수 있는 구성 가능한 데이터 구문 분석기 프로세서에 대한 정보가 포함되어 있습니다.
**Contents**
+ [parseJSON](#CloudWatch-Logs-Transformation-parseJSON)
+ [grok](#CloudWatch-Logs-Transformation-Grok)
+ [Grok 예제](#Grok-Examples)
+ [예제 1: grok를 사용하여 비정형 로그에서 필드 추출](#Grok-Example1)
+ [예제 2: parseJSON과 함께 grok를 사용하여 JSON 로그 이벤트에서 필드 추출](#Grok-Example3)
+ [예제 3: FIELD\$1NAME에 점 주석이 있는 Grok 패턴](#Grok-Example4)
+ [지원되는 grok 패턴](#Grok-Patterns)
+ [일반적인 로그 형식 예제](#Common-Log-Examples)
+ [Apache 로그 예제](#Apache-Log-Example)
+ [NGINX 로그 예제](#NGINX-Log-Example)
+ [Syslog 프로토콜(RFC 5424) 로그 예제](#syslog5424-Log-Example)
+ [csv](#CloudWatch-Logs-Transformation-csv)
+ [parseKeyValue](#CloudWatch-Logs-Transformation-parseKeyValue)
## parseJSON
**parseJSON** 프로세서는 JSON 로그 이벤트를 구문 분석하며, 추출된 JSON 키-값 쌍을 대상 아래에 삽입합니다. 대상을 지정하지 않으면 프로세서가 루트 노드 아래에 키-값 쌍을 배치합니다. `parseJSON`을 첫 번째 프로세서로 사용할 때는 `@message`를 소스 필드로 사용하여 전체 로그 이벤트를 구문 분석해야 합니다. 초기 JSON 구문 분석 후 후속 프로세서에서 특정 필드를 조작할 수 있습니다.
원래 `@message` 내용은 변경되지 않으며 새 키가 메시지에 추가됩니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| source | 구문 분석할 로그 이벤트의 필드 경로. 점 표기법을 사용하여 하위 필드에 액세스합니다. 예: store.book | 아니요 | `@message` | 최대 길이: 128 최대 중첩 키 깊이: 3 |
| 대상 | 구문 분석된 JSON의 대상 필드 | 아니요 | `Parent JSON node` | 최대 길이: 128 최대 중첩 키 깊이: 3 |
**예제**
수집된 로그 이벤트가 다음과 같다고 가정해 보겠습니다.
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
이 **parseJSON** 프로세서가 있는 경우:
```
[
{
"parseJSON": {
"destination": "new_key"
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"new_key": {
"outer_key": {
"inner_key": "inner_value"
}
}
}
```
## grok
grok 프로세서를 사용하여 패턴 매칭을 사용하여 비정형 데이터를 구문 분석하고 구조화합니다. 이 프로세서는 로그 메시지에서 필드를 추출할 수도 있습니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 | 참고 사항 |
| --- | --- | --- | --- | --- | --- |
| source | Grok 매칭을 적용할 필드의 경로 | 아니요 | `@message` | 최대 길이: 128 최대 중첩 키 깊이: 3 |
| match | 로그 이벤트와 매칭할 grok 패턴 | 예 | | 최대 길이: 512 최대 grok 패턴: 20 일부 grok 패턴 유형에는 개별 사용량 제한이 있습니다. \$1URI, URIPARAM, URIPATHPARAM, SPACE, DATA, GREEDYDATA, GREEDYDATA\$1MULTILINE\$1 패턴의 조합은 최대 5회까지 사용할 수 있습니다. Grok 패턴은 유형 변환을 지원하지 않습니다. 일반적인 로그 형식 패턴(APACHE\$1ACCESS\$1LOG, NGINX\$1ACCESS\$1LOG, SYSLOG5424)의 경우 일반적인 로그 패턴 뒤에는 DATA, GREEDYDATA 또는 GREEDYDATA\$1MULTILINE 패턴만 포함될 수 있습니다. | [지원되는 모든 Grok 패턴 보기](#Grok-Patterns) |
**Grok 패턴의 구조**
지원되는 grok 패턴 구조는 다음과 같습니다.
```
%{PATTERN_NAME:FIELD_NAME}
```
+ **PATTERN\$1NAME**: 특정 유형의 데이터와 일치시키기 위해 미리 정의된 정규식을 나타냅니다. 사전 정의된 [grok 패턴](#Grok-Patterns)만 지원됩니다. 사용자 지정 패턴 생성은 허용되지 않습니다.
+ **FIELD\$1NAME**: 추출된 값에 이름을 할당합니다. `FIELD_NAME`은 선택 사항이지만 이 값을 지정하지 않으면 추출된 데이터가 변환된 로그 이벤트에서 삭제됩니다. `FIELD_NAME`은 점 표기법(예: 'parent.child')을 사용하는 경우 JSON 경로로 간주됩니다.
+ **유형 변환**: 명시적 유형 변환은 지원되지 않습니다. [TypeConverter 프로세서](CloudWatch-Logs-Transformation-Datatype.md#CloudWatch-Logs-Transformation-typeConverter)를 사용하여 grok에서 추출한 값의 데이터타입을 변환합니다.
보다 복잡한 매칭 표현식을 생성하려면 여러 grok 패턴을 결합하면 됩니다. 로그 이벤트를 매칭하도록 최대 20개의 grok 패턴을 결합할 수 있습니다. 예를 들어, 이 `%{NUMBER:timestamp} [%{NUMBER:db} %{IP:client_ip}:%{NUMBER:client_port}] %{GREEDYDATA:data}` 패턴 조합을 사용하여 다음과 같은 Redis 슬로우 로그 항목에서 필드를 추출할 수 있습니다.
`1629860738.123456 [0 127.0.0.1:6379] "SET" "key1" "value1"`
### Grok 예제
#### 예제 1: grok를 사용하여 비정형 로그에서 필드 추출
샘플 로그:
```
293750 server-01.internal-network.local OK "[Thread-000] token generated"
```
사용된 트랜스포머:
```
[
{
"grok": {
"match": "%{NUMBER:version} %{HOSTNAME:hostname} %{NOTSPACE:status} %{QUOTEDSTRING:logMsg}"
}
}
]
```
출력:
```
{
"version": "293750",
"hostname": "server-01.internal-network.local",
"status": "OK",
"logMsg": "[Thread-000] token generated"
}
```
샘플 로그:
```
23/Nov/2024:10:25:15 -0900 172.16.0.1 200
```
사용된 트랜스포머:
```
[
{
"grok": {
"match": "%{HTTPDATE:timestamp} %{IPORHOST:clientip} %{NUMBER:response_status}"
}
}
]
```
출력:
```
{
"timestamp": "23/Nov/2024:10:25:15 -0900",
"clientip": "172.16.0.1",
"response_status": "200"
}
```
#### 예제 2: parseJSON과 함께 grok를 사용하여 JSON 로그 이벤트에서 필드 추출
샘플 로그:
```
{
"timestamp": "2024-11-23T16:03:12Z",
"level": "ERROR",
"logMsg": "GET /page.html HTTP/1.1"
}
```
사용된 트랜스포머:
```
[
{
"parseJSON": {}
},
{
"grok": {
"source": "logMsg",
"match": "%{WORD:http_method} %{NOTSPACE:request} HTTP/%{NUMBER:http_version}"
}
}
]
```
출력:
```
{
"timestamp": "2024-11-23T16:03:12Z",
"level": "ERROR",
"logMsg": "GET /page.html HTTP/1.1",
"http_method": "GET",
"request": "/page.html",
"http_version": "1.1"
}
```
#### 예제 3: FIELD\$1NAME에 점 주석이 있는 Grok 패턴
샘플 로그:
```
192.168.1.1 GET /index.html?param=value 200 1234
```
사용된 트랜스포머:
```
[
{
"grok": {
"match": "%{IP:client.ip} %{WORD:method} %{URIPATHPARAM:request.uri} %{NUMBER:response.status} %{NUMBER:response.bytes}"
}
}
]
```
출력:
```
{
"client": {
"ip": "192.168.1.1"
},
"method": "GET",
"request": {
"uri": "/index.html?param=value"
},
"response": {
"status": "200",
"bytes": "1234"
}
}
```
### 지원되는 grok 패턴
다음 표에는 `grok` 프로세서에서 지원하는 패턴이 나열되어 있습니다.
**일반 grok 패턴**
| Grok 패턴 | 설명 | 최대 패턴 제한 | 예제 |
| --- | --- | --- | --- |
| 사용자 이름 또는 사용자 | 소문자(a\$1z), 대문자(A\$1Z), 숫자(0\$19), 점(.), 밑줄(\$1) 또는 하이픈(-)을 포함할 수 있는 하나 이상의 문자와 일치합니다. | 20 | 입력: `user123.name-TEST` 패턴: `%{USERNAME:name}` 출력: `{"name": "user123.name-TEST"}` |
| INT | 선택 사항인 더하기 또는 빼기 기호 뒤에 하나 이상의 숫자가 오는 것과 일치합니다. | 20 | 입력: `-456` 패턴: `%{INT:num}` 출력: `{"num": "-456"}` |
| BASE10NUM | 부호 및 소수점 옵션이 있는 정수 또는 부동 소수점 숫자와 일치합니다. | 20 | 입력: `-0.67` 패턴: `%{BASE10NUM:num}` 출력: `{"num": "-0.67"}` |
| BASE16NUM | 10진수 및 16진수와 선택적 기호(\$1 또는 -) 및 선택적 0x 접두사와 일치합니다. | 20 | 입력: `+0xA1B2` 패턴: `%{BASE16NUM:num}` 출력: `{"num": "+0xA1B2"}` |
| POSINT | 하나 이상의 숫자(1\$19 다음에 0\$19)로 구성된 앞에 0이 없는 정수와 일치합니다. | 20 | 입력: `123` 패턴: `%{POSINT:num}` 출력: `{"num": "123"}` |
| NONNEGINT | 0과 앞에 0이 있는 숫자를 포함하여 모든 정수(0\$19의 숫자로 구성)와 일치합니다. | 20 | 입력: `007` 패턴: `%{NONNEGINT:num}` 출력: `{"num": "007"}` |
| WORD | 문자, 숫자 및 밑줄을 포함하여 하나 이상의 단어 문자(\$1w)로 구성된 전체 단어와 일치합니다.. | 20 | 입력: `user_123` 패턴: `%{WORD:user}` 출력: `{"user": "user_123"}` |
| NOTSPACE | 공백이 없는 하나 이상의 문자와 일치합니다. | 5 | 입력: `hello_world123` 패턴: `%{NOTSPACE:msg}` 출력: `{"msg": "hello_world123"}` |
| SPACE | 0개 이상의 공백 문자와 일치합니다. | 5 | 입력: `" "` 패턴: `%{SPACE:extra}` 출력: `{"extra": " "}` |
| DATA | 모든 문자(줄 바꿈 제외)와 0회 이상 최소 일치합니다. | 5 | 입력: `abc def ghi` 패턴: `%{DATA:x} %{DATA:y}` 출력: `{"x": "abc", "y": "def ghi"}` |
| GREEDYDATA | 모든 문자(줄 바꿈 제외)와 0회 이상 최대 일치합니다. | 5 | 입력: `abc def ghi` 패턴: `%{GREEDYDATA:x} %{GREEDYDATA:y}` 출력: `{"x": "abc def", "y": "ghi"}` |
| GREEDYDATA\$1MULTILINE | 모든 문자(줄 바꿈 포함)와 0회 이상 최대 일치합니다. | 1 | 입력: `abc` `def` `ghi` 패턴: `%{GREEDYDATA_MULTILINE:data}` 출력: `{"data": "abc\ndef\nghi"}` |
| QUOTEDSTRING | 이스케이프 처리된 문자가 포함된 따옴표(작은따옴표 또는 큰따옴표)로 묶인 문자열과 일치합니다. | 20 | 입력: `"Hello, world!"` 패턴: `%{QUOTEDSTRING:msg}` 출력: `{"msg": "Hello, world!"}` |
| UUID | 표준 UUID 형식과 일치합니다. 즉, 8개의 16진수 문자 뒤에 4개의 16진수 문자로 구성된 3개의 그룹이 오고 12개의 16진수 문자로 끝나며, 모두 하이픈으로 구분됩니다. | 20 | 입력: `550e8400-e29b-41d4-a716-446655440000` 패턴: `%{UUID:id}` 출력: `{"id": "550e8400-e29b-41d4-a716-446655440000"}` |
| urn | URN(Uniform Resource Name) 구문과 일치합니다. | 20 | 입력: `urn:isbn:0451450523` 패턴: `%{URN:urn}` 출력: `{"urn": "urn:isbn:0451450523"}` |
**AWS grok 패턴**
| 패턴 | 설명 | 최대 패턴 제한 | 예제 |
| --- | --- | --- | --- |
| ARN | 파티션(`aws`, 또는 `aws-us-gov`), 서비스`aws-cn`, 리전, 계정 ID 및 슬래시로 구분된 최대 5개의 계층적 리소스 식별자를 캡처하여 AWS Amazon 리소스 이름(ARNs)과 일치합니다. 콜론 간에 누락된 정보가 있는 ARN을 매칭하지 않습니다. | 5 | 입력: `arn:aws:iam:us-east-1:123456789012:user/johndoe` 패턴: `%{ARN:arn}` 출력: `{"arn": "arn:aws:iam:us-east-1:123456789012:user/johndoe"}` |
**네트워킹 grok 패턴**
| Grok 패턴 | 설명 | 최대 패턴 제한 | 예제 |
| --- | --- | --- | --- |
| CISCOMAC | 4-4-4 16진수 형식의 MAC 주소와 일치합니다. | 20 | 입력: `0123.4567.89AB` 패턴: `%{CISCOMAC:MacAddress}` 출력: `{"MacAddress": "0123.4567.89AB"}` |
| WINDOWSMAC | 하이픈이 포함된 16진수 형식의 MAC 주소와 일치합니다. | 20 | 입력: `01-23-45-67-89-AB` 패턴: `%{WINDOWSMAC:MacAddress}` 출력: `{"MacAddress": "01-23-45-67-89-AB"}` |
| COMMONMAC | 콜론이 포함된 16진수 형식의 MAC 주소와 일치합니다. | 20 | 입력: `01:23:45:67:89:AB` 패턴: `%{COMMONMAC:MacAddress}` 출력: `{"MacAddress": "01:23:45:67:89:AB"}` |
| MAC | CISCOMAC, WINDOWSMAC 또는 COMMONMAC grok 패턴 중 하나와 일치합니다. | 20 | 입력: `01:23:45:67:89:AB` 패턴: `%{MAC:m1}` 출력: `{"m1":"01:23:45:67:89:AB"}` |
| IPV6 | 압축된 양식 및 IPv4 매핑된 IPv6 주소를 포함한 IPv6 주소와 일치합니다. | 5 | 입력: `2001:db8:3333:4444:5555:6666:7777:8888` 패턴: `%{IPV6:ip}` 출력: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}` |
| IPV4 | IPv4 주소와 일치합니다. | 20 | 입력: `192.168.0.1` 패턴: `%{IPV4:ip}` 출력: `{"ip": "192.168.0.1"}` |
| IP | %\$1IPv6\$1에서 지원하는 IPv6 주소 또는 %\$1IPv4\$1에서 지원하는 IPv4 주소 중 하나와 일치합니다. | 5 | 입력: `192.168.0.1` 패턴: `%{IP:ip}` 출력: `{"ip": "192.168.0.1"}` |
| HOSTNAME 또는 HOST | 하위 도메인을 포함한 도메인 이름과 일치합니다. | 5 | 입력: `server-01.internal-network.local` 패턴: `%{HOST:host}` 출력: `{"host": "server-01.internal-network.local"}` |
| IPORHOST | 호스트 이름 또는 IP 주소와 일치합니다. | 5 | 입력: `2001:db8:3333:4444:5555:6666:7777:8888` 패턴: `%{IPORHOST:ip}` 출력: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}` |
| HOSTPORT | %\$1IPORHOST\$1 패턴에서 지원하는 IP 주소 또는 호스트 이름과 일치하고, 그 뒤에 콜론과 포트 번호가 오며, 출력에서 포트를 'PORT'로 캡처합니다. | 5 | 입력: `192.168.1.1:8080` 패턴: `%{HOSTPORT:ip}` 출력: `{"ip":"192.168.1.1:8080","PORT":"8080"}` |
| URIHOST | %\$1IPORHOST\$1 패턴에서 지원하는 IP 주소 또는 호스트 이름과 일치하고, 선택적으로 그 뒤에 콜론과 포트 번호가 오고, 포트가 있는 경우 'port'로 캡처합니다. | 5 | 입력: `example.com:443 10.0.0.1` 패턴: `%{URIHOST:host} %{URIHOST:ip}` 출력: `{"host":"example.com:443","port":"443","ip":"10.0.0.1"}` |
**경로 grok 패턴**
| Grok 패턴 | 설명 | 최대 패턴 제한 | 예제 |
| --- | --- | --- | --- |
| UNIXPATH | 쿼리 파라미터를 포함할 수 있는 URL 경로와 일치합니다. | 20 | 입력: `/search?q=regex` 패턴: `%{UNIXPATH:path}` 출력: `{"path":"/search?q=regex"}` |
| WINPATH | Windows 파일 경로와 일치합니다. | 5 | 입력: `C:\Users\John\Documents\file.txt` 패턴: `%{WINPATH:path}` 출력: `{"path": "C:\\Users\\John\\Documents\\file.txt"}` |
| PATH | URL 또는 Windows 파일 경로와 일치합니다. | 5 | 입력: `/search?q=regex` 패턴: `%{PATH:path}` 출력: `{"path":"/search?q=regex"}` |
| TTY | 터미널 및 가상 터미널의 Unix 디바이스 경로와 일치합니다. | 20 | 입력: `/dev/tty1` 패턴: `%{TTY:path}` 출력: `{"path":"/dev/tty1"}` |
| URIPROTO | 문자와 일치하며, 선택적으로 그 뒤에 더하기(\$1) 문자와 추가 문자 또는 더하기(\$1) 문자가 옵니다. | 20 | 입력: `web+transformer` 패턴: `%{URIPROTO:protocol}` 출력: `{"protocol":"web+transformer"}` |
| URIPATH | URI의 경로 구성 요소와 일치합니다. | 20 | 입력: `/category/sub-category/product_name` 패턴: `%{URIPATH:path}` 출력: `{"path":"/category/sub-category/product_name"}` |
| URIPARAM | URL 쿼리 파라미터와 일치합니다. | 5 | 입력: `?param1=value1¶m2=value2` 패턴: `%{URIPARAM:url}` 출력: `{"url":"?param1=value1¶m2=value2"}` |
| URIPATHPARAM | URI 경로와 일치하며, 선택적으로 그 뒤에 쿼리 파라미터가 옵니다. | 5 | 입력: `/category/sub-category/product?id=12345&color=red` 패턴: `%{URIPATHPARAM:path}` 출력: `{"path":"/category/sub-category/product?id=12345&color=red"}` |
| URI | 전체 URI와 일치합니다. | 5 | 입력: `https://user:password@example.com/path/to/resource?param1=value1¶m2=value2` 패턴: `%{URI:uri}` 출력: `{"path":"https://user:password@example.com/path/to/resource?param1=value1¶m2=value2"}` |
**날짜/시간 Grok 패턴**
| Grok 패턴 | 설명 | 최대 패턴 제한 | 예제 |
| --- | --- | --- | --- |
| MONTH | 전체 또는 축약된 영어 월 이름과 전체 단어로 일치합니다. | 20 | 입력: `Jan` 패턴: `%{MONTH:month}` 출력: `{"month":"Jan"}` 입력: `January` 패턴: `%{MONTH:month}` 출력: `{"month":"January"}` |
| MONTHNUM | 1에서 12까지의 월 수와 일치하며, 한 자릿수 월의 경우 선택적으로 앞에 0이 표시됩니다. | 20 | 입력: `5` 패턴: `%{MONTHNUM:month}` 출력: `{"month":"5"}` 입력: `05` 패턴: `%{MONTHNUM:month}` 출력: `{"month":"05"}` |
| MONTHNUM2 | 01에서 12까지의 두 자리 숫자와 일치합니다. | 20 | 입력: `05` 패턴: `%{MONTHNUM2:month}` 출력: `{"month":"05"}` |
| MONTHDAY | 1에서 31까지의 일과 일치하며, 선택적으로 앞에 0이 표시됩니다. | 20 | 입력: `31` 패턴: `%{MONTHDAY:monthDay}` 출력: `{"monthDay":"31"}` |
| YEAR | 2자리 또는 4자리 연도와 일치합니다. | 20 | 입력: `2024` 패턴: `%{YEAR:year}` 출력: `{"year":"2024"}` 입력: `24` 패턴: `%{YEAR:year}` 출력: `{"year":"24"}` |
| DAY | 전체 또는 축약된 요일 이름과 일치합니다. | 20 | 입력: `Tuesday` 패턴: `%{DAY:day}` 출력: `{"day":"Tuesday"}` |
| 시간 | 24시간 형식의 시간(0\$123)과 일치하며, 선택적으로 앞에 영(0)이 표시됩니다. | 20 | 입력: `22` 패턴: `%{HOUR:hour}` 출력: `{"hour":"22"}` |
| 분 | 분(00\$159)과 일치합니다. | 20 | 입력: `59` 패턴: `%{MINUTE:min}` 출력: `{"min":"59"}` |
| SECOND | 초((0)0\$160)를 나타내는 숫자와 일치하며, 선택적으로 그 뒤에 소수점 또는 콜론과 소수 분을 나타내는 하나 이상의 숫자가 옵니다. | 20 | 입력: `3` 패턴: `%{SECOND:second}` 출력: `{"second":"3"}` 입력: `30.5` 패턴: `%{SECOND:minSec}` 출력: `{"minSec":"30.5"}` 입력: `30:5` 패턴: `%{SECOND:minSec}` 출력: `{"minSec":"30:5"}` |
| TIME | 시간, 분 및 초가 (H)H:mm:(s)s 형식인 시간 형식과 일치합니다. 초에는 윤초(0)0\$160이 포함됩니다. | 20 | 입력: `09:45:32` 패턴: `%{TIME:time}` 출력: `{"time":"09:45:32"}` |
| DATE\$1US | (M)M/(d)d/(yy)yy 또는 (M)M-(d)d-(yy)yy 형식의 날짜와 일치합니다. | 20 | 입력: `11/23/2024` 패턴: `%{DATE_US:date}` 출력: `{"date":"11/23/2024"}` 입력: `1-01-24` 패턴: `%{DATE_US:date}` 출력: `{"date":"1-01-24"}` |
| DATE\$1EU | (d)d/(M)M/(yy)yy, (d)d-(M)M-(yy)yy 또는 (d)d.(M)M.(yy)yy 형식의 날짜와 일치합니다. | 20 | 입력: `23/11/2024` 패턴: `%{DATE_EU:date}` 출력: `{"date":"23/11/2024"}` 입력: `1.01.24` 패턴: `%{DATE_EU:date}` 출력: `{"date":"1.01.24"}` |
| ISO8601\$1TIMEZONE | UTC 오프셋 'Z' 또는 선택적 콜론이 포함된 시간대 오프셋과 [\$1-](H)H(:)mm 형식으로 일치합니다. | 20 | 입력: `+05:30` 패턴: `%{ISO8601_TIMEZONE:tz}` 출력: `{"tz":"+05:30"}` 입력: `-530` 패턴: `%{ISO8601_TIMEZONE:tz}` 출력: `{"tz":"-530"}` 입력: `Z` 패턴: `%{ISO8601_TIMEZONE:tz}` 출력: `{"tz":"Z"}` |
| ISO8601\$1SECOND | 초((0)0\$160)를 나타내는 숫자와 일치하며, 선택적으로 그 뒤에 소수점 또는 콜론과 소수 초를 나타내는 하나 이상의 숫자가 옵니다. | 20 | 입력: `60` 패턴: `%{ISO8601_SECOND:second}` 출력: `{"second":"60"}` |
| TIMESTAMP\$1ISO8601 | 선택적 초 및 시간대가 포함된 ISO8601 날짜/시간 형식 (yy)yy-(M)M-(d)dT(H)H:mm:((s)s)(Z\$1[\$1-](H)H:mm)과 일치합니다. | 20 | 입력: `2023-05-15T14:30:00+05:30` 패턴: `%{TIMESTAMP_ISO8601:timestamp}` 출력: `{"timestamp":"2023-05-15T14:30:00+05:30"}` 입력: `23-5-1T1:25+5:30` 패턴: `%{TIMESTAMP_ISO8601:timestamp}` 출력: `{"timestamp":"23-5-1T1:25+5:30"}` 입력: `23-5-1T1:25Z` 패턴: `%{TIMESTAMP_ISO8601:timestamp}` 출력: `{"timestamp":"23-5-1T1:25Z"}` |
| DATE | %\$1DATE\$1US\$1를 사용하는 미국 형식 또는 %\$1DATE\$1EU\$1를 사용하는 EU 형식의 날짜와 일치합니다. | 20 | 입력: `11/29/2024` 패턴: `%{DATE:date}` 출력: `{"date":"11/29/2024"}` 입력: `29.11.2024` 패턴: `%{DATE:date}` 출력: `{"date":"29.11.2024"}` |
| DATESTAMP | 공백 또는 하이픈으로 구분된 %\$1DATE\$1 뒤에 %\$1TIME\$1이 오는 패턴과 일치합니다. | 20 | 입력: `29-11-2024 14:30:00` 패턴: `%{DATESTAMP:dateTime}` 출력: `{"dateTime":"29-11-2024 14:30:00"}` |
| TZ | 공통 시간대 약어(PST, PDT, MST, MDT, CST CDT, EST, EDT, UTC)와 일치합니다. | 20 | 입력: `PDT` 패턴: `%{TZ:tz}` 출력: `{"tz":"PDT"}` |
| DATESTAMP\$1RFC822 | Day MonthName (D)D (YY)YY (H)H:mm:(s)s Timezone 형식의 날짜/시간과 일치합니다. | 20 | 입력: `Monday Jan 5 23 1:30:00 CDT` 패턴: `%{DATESTAMP_RFC822:dateTime}` 출력: `{"dateTime":"Monday Jan 5 23 1:30:00 CDT"}` 입력: `Mon January 15 2023 14:30:00 PST` 패턴: `%{DATESTAMP_RFC822:dateTime}` 출력: `{"dateTime":"Mon January 15 2023 14:30:00 PST"}` |
| DATESTAMP\$1RFC2822 | Day, (d)d MonthName (yy)yy (H)H:mm:(s)s Z\$1[\$1-](H)H:mm 형식의 RFC2822 날짜/시간과 일치합니다. | 20 | 입력: `Mon, 15 May 2023 14:30:00 +0530` 패턴: `%{DATESTAMP_RFC2822:dateTime}` 출력: `{"dateTime":"Mon, 15 May 2023 14:30:00 +0530"}` 입력: `Monday, 15 Jan 23 14:30:00 Z` 패턴: `%{DATESTAMP_RFC2822:dateTime}` 출력: `{"dateTime":"Monday, 15 Jan 23 14:30:00 Z"}` |
| DATESTAMP\$1OTHER | Day MonthName (d)d (H)H:mm:(s)s Timezone (yy)yy 형식의 날짜/시간과 일치합니다. | 20 | 입력: `Mon May 15 14:30:00 PST 2023` 패턴: `%{DATESTAMP_OTHER:dateTime}` 출력: `{"dateTime":"Mon May 15 14:30:00 PST 2023"}` |
| DATESTAMP\$1EVENTLOG | 구분자가 없는 압축 날짜/시간((yy)yyMM(d)d(H)Hmm(s)s)과 일치합니다. | 20 | 입력: `20230515143000` 패턴: `%{DATESTAMP_EVENTLOG:dateTime}` 출력: `{"dateTime":"20230515143000"}` |
**로그 grok 패턴**
| Grok 패턴 | 설명 | 최대 패턴 제한 | 예제 |
| --- | --- | --- | --- |
| LOGLEVEL | Alert/ALERT, Trace/TRACE, Debug/DEBUG, Notice/NOTICE, Info/INFO, Warn/Warning/WARN/WARNING, Err/Error/ERR/ERROR, Crit/Critical/CRIT/CRITICAL, Fatal/FATAL, Severe/SEVERE, Emerg/Emergency/EMERG/EMERGENCY를 포함하여 다양한 대문자 및 약어의 표준 로그 수준과 일치합니다. | 20 | 입력: `INFO` 패턴: `%{LOGLEVEL:logLevel}` 출력: `{"logLevel":"INFO"}` |
| HTTPDATE | 로그 파일에 자주 사용되는 날짜/시간 형식과 일치합니다. 형식: (d)d/MonthName/(yy)yy:(H)H:mm:(s)s Timezone MonthName: 전체 또는 축약된 영어 월 이름과 일치합니다(예: 'Jan' 또는 'January'). Timezone: %\$1INT\$1 grok 패턴과 일치합니다. | 20 | 입력: `23/Nov/2024:14:30:00 +0640` 패턴: `%{HTTPDATE:date}` 출력: `{"date":"23/Nov/2024:14:30:00 +0640"}` |
| SYSLOGTIMESTAMP | MonthName (d)d (H)H:mm:(s)s 날짜 형식과 일치합니다. MonthName: 전체 또는 축약된 영어 월 이름과 일치합니다(예: 'Jan' 또는 'January'). | 20 | 입력: `Nov 29 14:30:00` 패턴: `%{SYSLOGTIMESTAMP:dateTime}` 출력: `{"dateTime":"Nov 29 14:30:00"}` |
| PROG | 문자, 숫자, 점, 밑줄, 슬래시, 백분율 기호 및 하이픈 문자로 구성된 문자열로 구성된 프로그램 이름과 일치합니다. | 20 | 입력: `user.profile/settings-page` 패턴: `%{PROG:program}` 출력: `{"program":"user.profile/settings-page"}` |
| SYSLOGPROG | PROG grok 패턴과 일치하며, 선택적으로 그 뒤에 대괄호로 묶인 프로세스 ID가 옵니다. | 20 | 입력: `user.profile/settings-page[1234]` 패턴: `%{SYSLOGPROG:programWithId}` 출력: `{"programWithId":"user.profile/settings-page[1234]","program":"user.profile/settings-page","pid":"1234"}` |
| SYSLOGHOST | %\$1HOST\$1 또는 %\$1IP\$1 패턴과 일치합니다. | 5 | 입력: `2001:db8:3333:4444:5555:6666:7777:8888` 패턴: `%{SYSLOGHOST:ip}` 출력: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}` |
| SYSLOGFACILITY | 십진수 형식의 syslog 우선 순위와 일치합니다. 값은 각진 대괄호(<>)로 묶어야 합니다. | 20 | 입력: `<13.6>` 패턴: `%{SYSLOGFACILITY:syslog}` 출력: `{"syslog":"<13.6>","facility":"13","priority":"6"}` |
**일반적인 로그 grok 패턴**
사전 정의된 사용자 지정 grok 패턴을 사용하여 Apache, NGINX 및 Syslog Protocol(RFC 5424) 로그 형식을 매칭할 수 있습니다. 이러한 특정 패턴을 사용하는 경우 매칭 구성의 첫 번째 패턴이어야 하며, 다른 패턴보다 우선할 수 없습니다. 또한 정확히 하나의 **데이터**로만 추적할 수 있습니다. **GREEDYDATA** 또는 **GREEDYDATA\$1MULTILINE** 패턴.
| Grok 패턴 | 설명 | 최대 패턴 제한 |
| --- | --- | --- |
| APACHE\$1ACCESS\$1LOG | Apache 액세스 로그와 일치합니다. | 1 |
| NGINX\$1ACCESS\$1LOG | NGINX 액세스 로그와 일치합니다. | 1 |
| SYSLOG5424 | Syslog 프로토콜(RFC 5424) 로그와 일치합니다. | 1 |
다음은 이러한 일반적인 로그 형식 패턴을 사용하기 위한 유효한 예제와 잘못된 예제입니다.
```
"%{NGINX_ACCESS_LOG} %{DATA}" // Valid
"%{SYSLOG5424}%{DATA:logMsg}" // Valid
"%{APACHE_ACCESS_LOG} %{GREEDYDATA:logMsg}" // Valid
"%{APACHE_ACCESS_LOG} %{SYSLOG5424}" // Invalid (multiple common log patterns used)
"%{NGINX_ACCESS_LOG} %{NUMBER:num}" // Invalid (Only GREEDYDATA and DATA patterns are supported with common log patterns)
"%{GREEDYDATA:logMsg} %{SYSLOG5424}" // Invalid (GREEDYDATA and DATA patterns are supported only after common log patterns)
```
#### 일반적인 로그 형식 예제
##### Apache 로그 예제
샘플 로그:
```
127.0.0.1 - - [03/Aug/2023:12:34:56 +0000] "GET /page.html HTTP/1.1" 200 1234
```
트랜스포머:
```
[
{
"grok": {
"match": "%{APACHE_ACCESS_LOG}"
}
}
]
```
출력:
```
{
"request": "/page.html",
"http_method": "GET",
"status_code": 200,
"http_version": "1.1",
"response_size": 1234,
"remote_host": "127.0.0.1",
"timestamp": "2023-08-03T12:34:56Z"
}
```
##### NGINX 로그 예제
샘플 로그:
```
192.168.1.100 - Foo [03/Aug/2023:12:34:56 +0000] "GET /account/login.html HTTP/1.1" 200 42 "https://www.amazon.com/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36"
```
트랜스포머:
```
[
{
"grok": {
"match": "%{NGINX_ACCESS_LOG}"
}
}
]
```
출력:
```
{
"request": "/account/login.html",
"referrer": "https://www.amazon.com/",
"agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36",
"http_method": "GET",
"status_code": 200,
"auth_user": "Foo",
"http_version": "1.1",
"response_size": 42,
"remote_host": "192.168.1.100",
"timestamp": "2023-08-03T12:34:56Z"
}
```
##### Syslog 프로토콜(RFC 5424) 로그 예제
샘플 로그:
```
<165>1 2003-10-11T22:14:15.003Z mymachine.example.com evntslog - ID47 [exampleSDID@32473 iut="3" eventSource= "Application" eventID="1011"][examplePriority@32473 class="high"]
```
트랜스포머:
```
[
{
"grok": {
"match": "%{SYSLOG5424}"
}
}
]
```
출력:
```
{
"pri": 165,
"version": 1,
"timestamp": "2003-10-11T22:14:15.003Z",
"hostname": "mymachine.example.com",
"app": "evntslog",
"msg_id": "ID47",
"structured_data": "exampleSDID@32473 iut=\"3\" eventSource= \"Application\" eventID=\"1011\"",
"message": "[examplePriority@32473 class=\"high\"]"
}
```
## csv
**csv** 프로세서는 로그 이벤트의 쉼표로 구분된 값(CSV)을 열로 구문 분석합니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| source | 구문 분석할 로그 이벤트의 필드 경로 | 아니요 | `@message` | 최대 길이: 128 최대 중첩 키 깊이: 3 |
| delimiter | 원래 쉼표로 구분된 값 로그 이벤트에서 각 열을 구분하는 데 사용되는 문자 | 아니요 | `,` | 최대 길이: 값이 `\t` 또는 `\s`이 아닌 경우 1 |
| quoteCharacter | 단일 데이터 열에 대한 텍스트 한정자로 사용되는 문자 | 아니요 | `"` | 최대 길이: 1 |
| columns | 변환된 로그 이벤트의 열에 사용할 이름의 목록. | 아니요 | `[column_1, column_2 ...]` | 최대 CSV 열: 100 최대 길이: 128 최대 중첩 키 깊이: 3 |
| 대상 | 변환된 키 값 페어를 넣을 상위 필드입니다. | 아니요 | `Root node` | 최대 길이: 128 최대 중첩 키 깊이: 3 |
`delimiter`을 `\t`로 설정하면 탭 문자에서 각 열이 구분되며, `\t`은 단일 공백 문자에서 각 열을 구분합니다.
**예제**
수집된 로그 이벤트의 일부가 다음과 같다고 가정해 보겠습니다.
```
'Akua Mansa':28:'New York: USA'
```
**csv** 프로세서만 사용한다고 가정해 보겠습니다.
```
[
{
"csv": {
"delimiter": ":",
"quoteCharacter": "'"
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"column_1": "Akua Mansa",
"column_2": "28",
"column_3": "New York: USA"
}
```
**예제 2**
수집된 로그 이벤트가 다음과 같다고 가정해 보겠습니다.
```
{
"timestamp": "2024-11-23T16:03:12Z",
"type": "user_data",
"logMsg": "'Akua Mansa':28:'New York: USA'"
}
```
이벤트를 JSON으로 구문 분석하고 열 이름과 대상을 지정하여 **csv** 프로세서로 JSON 필드를 구문 분석한다고 가정해 보겠습니다.
```
[
{
"parseJSON": {}
},
{
"csv": {
"source": "logMsg",
"delimiter": ":",
"quoteCharacter": "'",
"columns":["name","age","location"],
"destination": "msg"
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"timestamp": "2024-11-23T16:03:12Z",
"logMsg": "'Akua Mansa':28:'New York: USA'",
"type": "user_data",
"msg": {
"name": "Akua Mansa",
"age": "28",
"location": "New York: USA"
}
}
```
## parseKeyValue
**parseKeyValue** 프로세서를 사용하여 지정된 필드를 키-값 쌍으로 구문 분석합니다. 다음 옵션을 사용하여 필드 정보를 구문 분석하도록 프로세서를 사용자 지정할 수 있습니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| source | 구문 분석할 로그 이벤트의 필드 경로 | 아니요 | `@message` | 최대 길이: 128 최대 중첩 키 깊이: 3 |
| 대상 | 추출된 키-값 쌍을 넣을 대상 필드 | 아니요 | | 최대 길이: 128 |
| fieldDelimiter | 원래 로그 이벤트의 키-값 쌍 간에 사용되는 필드 구분 문자 문자열. | 아니요 | `&` | 최대 길이: 128 |
| keyValueDelimiter | 변환된 로그 이벤트의 각 쌍에서 키와 값 사이에 사용할 구분 문자 문자열 | 아니요 | `=` | 최대 길이: 128 |
| nonMatchValue | 키-값 쌍이 성공적으로 분할되지 않은 경우 결과의 값 필드에 삽입할 값. | 아니요 | | 최대 길이: 128 |
| keyPrefix | 변환된 모든 키에 접두사를 추가하려면 여기에 지정합니다. | 아니요 | | 최대 길이: 128 |
| overwriteIfExists | 대상 키가 이미 있는 경우 값을 덮어쓸지 여부 | 아니요 | `false` | |
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
key1:value1!key2:value2!key3:value3!key4
```
다음 프로세서 구성을 사용한다고 가정해 보겠습니다.
```
[
{
"parseKeyValue": {
"destination": "new_key",
"fieldDelimiter": "!",
"keyValueDelimiter": ":",
"nonMatchValue": "defaultValue",
"keyPrefix": "parsed_"
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"new_key": {
"parsed_key1": "value1",
"parsed_key2": "value2",
"parsed_key3": "value3",
"parsed_key4": "defaultValue"
}
}
```
# AWS 벤딩 로그용 기본 제공 프로세서
이 섹션에는 로그를 제공하는 AWS 서비스와 함께 사용할 수 있는 내장 프로세서에 대한 정보가 포함되어 있습니다.
**Contents**
+ [parseWAF](#CloudWatch-Logs-Transformation-parseWAF)
+ [parsePostgres](#CloudWatch-Logs-Transformation-parsePostGres)
+ [parseCloudfront](#CloudWatch-Logs-Transformation-parseCloudFront)
+ [parseRoute53](#CloudWatch-Logs-Transformation-parseRoute53)
+ [parseVPC](#CloudWatch-Logs-Transformation-parseVPC)
+ [parseToOCSF](CloudWatch-Logs-Transformation-parseToOCSF.md)
## parseWAF
이 프로세서를 사용하여 AWS WAF 벤딩된 로그를 구문 분석합니다. 각 헤더 이름에서의 콘텐츠를 가져`httpRequest.headers`와서 해당 값과 함께 JSON 키를 생성합니다. 또한 `labels`에 대해서도 동일한 작업을 수행합니다. 이러한 변환을 통해 AWS WAF 로그를 훨씬 쉽게 쿼리할 수 있습니다. AWS WAF 로그 형식에 대한 자세한 내용은 [ 웹 ACL 트래픽에 대한 로그 예제](https://docs.aws.amazon.com/waf/latest/developerguide/logging-examples.html)를 참조하세요.
이 프로세서는 `@message`만 입력으로 허용합니다.
**중요**
이 프로세서를 사용하는 경우 트랜스포머의 첫 번째 프로세서여야 합니다.
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
{
"timestamp": 1576280412771,
"formatVersion": 1,
"webaclId": "arn:aws:wafv2:ap-southeast-2:111122223333:regional/webacl/STMTest/1EXAMPLE-2ARN-3ARN-4ARN-123456EXAMPLE",
"terminatingRuleId": "STMTest_SQLi_XSS",
"terminatingRuleType": "REGULAR",
"action": "BLOCK",
"terminatingRuleMatchDetails": [
{
"conditionType": "SQL_INJECTION",
"sensitivityLevel": "HIGH",
"location": "HEADER",
"matchedData": ["10", "AND", "1"]
}
],
"httpSourceName": "-",
"httpSourceId": "-",
"ruleGroupList": [],
"rateBasedRuleList": [],
"nonTerminatingMatchingRules": [],
"httpRequest": {
"clientIp": "1.1.1.1",
"country": "AU",
"headers": [
{ "name": "Host", "value": "localhost:1989" },
{ "name": "User-Agent", "value": "curl/7.61.1" },
{ "name": "Accept", "value": "*/*" },
{ "name": "x-stm-test", "value": "10 AND 1=1" }
],
"uri": "/myUri",
"args": "",
"httpVersion": "HTTP/1.1",
"httpMethod": "GET",
"requestId": "rid"
},
"labels": [{ "name": "value" }]
}
```
프로세서 구성은 다음과 같습니다.
```
[
{
"parseWAF": {}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"httpRequest": {
"headers": {
"Host": "localhost:1989",
"User-Agent": "curl/7.61.1",
"Accept": "*/*",
"x-stm-test": "10 AND 1=1"
},
"clientIp": "1.1.1.1",
"country": "AU",
"uri": "/myUri",
"args": "",
"httpVersion": "HTTP/1.1",
"httpMethod": "GET",
"requestId": "rid"
},
"labels": { "name": "value" },
"timestamp": 1576280412771,
"formatVersion": 1,
"webaclId": "arn:aws:wafv2:ap-southeast-2:111122223333:regional/webacl/STMTest/1EXAMPLE-2ARN-3ARN-4ARN-123456EXAMPLE",
"terminatingRuleId": "STMTest_SQLi_XSS",
"terminatingRuleType": "REGULAR",
"action": "BLOCK",
"terminatingRuleMatchDetails": [
{
"conditionType": "SQL_INJECTION",
"sensitivityLevel": "HIGH",
"location": "HEADER",
"matchedData": ["10", "AND", "1"]
}
],
"httpSourceName": "-",
"httpSourceId": "-",
"ruleGroupList": [],
"rateBasedRuleList": [],
"nonTerminatingMatchingRules": []
}
```
## parsePostgres
이 프로세서를 사용하여 Amazon RDS for PostgreSQL 벤딩된 로그를 구문 분석하고, 필드를 추출하고, JSON 형식으로 변환합니다. RDS for PostgreSQL 로그 형식에 대한 자세한 내용은 [RDS for PostgreSQL 데이터베이스 로그 파일](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_LogAccess.Concepts.PostgreSQL.html#USER_LogAccess.Concepts.PostgreSQL.Log_Format.log-line-prefix)을 참조하세요.
이 프로세서는 `@message`만 입력으로 허용합니다.
**중요**
이 프로세서를 사용하는 경우 트랜스포머의 첫 번째 프로세서여야 합니다.
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
2019-03-10 03:54:59 UTC:10.0.0.123(52834):postgres@logtestdb:[20175]:ERROR: column "wrong_column_name" does not exist at character 8
```
프로세서 구성은 다음과 같습니다.
```
[
{
"parsePostgres": {}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"logTime": "2019-03-10 03:54:59 UTC",
"srcIp": "10.0.0.123(52834)",
"userName": "postgres",
"dbName": "logtestdb",
"processId": "20175",
"logLevel": "ERROR"
}
```
## parseCloudfront
이 프로세서를 사용하여 Amazon CloudFront 벤딩된 로그를 구문 분석하고, 필드를 추출하고, JSON 형식으로 변환합니다. 인코딩된 필드 값은 디코딩됩니다. 정수 및 2배인 값은 이와 같이 처리됩니다. Amazon CloudFront 로그 형식에 대한 자세한 내용은 [ 표준 로그 구성 및 사용(액세스 로그)](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html)을 참조하세요.
이 프로세서는 `@message`만 입력으로 허용합니다.
**중요**
이 프로세서를 사용하는 경우 트랜스포머의 첫 번째 프로세서여야 합니다.
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
2019-12-04 21:02:31 LAX1 392 192.0.2.24 GET d111111abcdef8.cloudfront.net /index.html 200 - Mozilla/5.0%20(Windows%20NT%2010.0;%20Win64;%20x64)%20AppleWebKit/537.36%20(KHTML,%20like%20Gecko)%20Chrome/78.0.3904.108%20Safari/537.36 - - Hit SOX4xwn4XV6Q4rgb7XiVGOHms_BGlTAC4KyHmureZmBNrjGdRLiNIQ== d111111abcdef8.cloudfront.net https 23 0.001 - TLSv1.2 ECDHE-RSA-AES128-GCM-SHA256 Hit HTTP/2.0 - - 11040 0.001 Hit text/html 78 - -
```
프로세서 구성은 다음과 같습니다.
```
[
{
"parseCloudfront": {}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"date": "2019-12-04",
"time": "21:02:31",
"x-edge-location": "LAX1",
"sc-bytes": 392,
"c-ip": "192.0.2.24",
"cs-method": "GET",
"cs(Host)": "d111111abcdef8.cloudfront.net",
"cs-uri-stem": "/index.html",
"sc-status": 200,
"cs(Referer)": "-",
"cs(User-Agent)": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36",
"cs-uri-query": "-",
"cs(Cookie)": "-",
"x-edge-result-type": "Hit",
"x-edge-request-id": "SOX4xwn4XV6Q4rgb7XiVGOHms_BGlTAC4KyHmureZmBNrjGdRLiNIQ==",
"x-host-header": "d111111abcdef8.cloudfront.net",
"cs-protocol": "https",
"cs-bytes": 23,
"time-taken": 0.001,
"x-forwarded-for": "-",
"ssl-protocol": "TLSv1.2",
"ssl-cipher": "ECDHE-RSA-AES128-GCM-SHA256",
"x-edge-response-result-type": "Hit",
"cs-protocol-version": "HTTP/2.0",
"fle-status": "-",
"fle-encrypted-fields": "-",
"c-port": 11040,
"time-to-first-byte": 0.001,
"x-edge-detailed-result-type": "Hit",
"sc-content-type": "text/html",
"sc-content-len": 78,
"sc-range-start": "-",
"sc-range-end": "-"
}
```
## parseRoute53
이 프로세서를 사용하여 Amazon Route 53 Public Data Plane 벤딩된 로그를 구문 분석하고, 필드를 추출하고, JSON 형식으로 변환합니다. 인코딩된 필드 값은 디코딩됩니다. 이 프로세서는 Amazon Route 53 Resolver 로그를 지원하지 않습니다.
이 프로세서는 `@message`만 입력으로 허용합니다.
**중요**
이 프로세서를 사용하는 경우 트랜스포머의 첫 번째 프로세서여야 합니다.
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
1.0 2017-12-13T08:15:50.235Z Z123412341234 example.com AAAA NOERROR TCP IAD12 192.0.2.0 198.51.100.0/24
```
프로세서 구성은 다음과 같습니다.
```
[
{
"parseRoute53": {}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"version": 1.0,
"queryTimestamp": "2017-12-13T08:15:50.235Z",
"hostZoneId": "Z123412341234",
"queryName": "example.com",
"queryType": "AAAA",
"responseCode": "NOERROR",
"protocol": "TCP",
"edgeLocation": "IAD12",
"resolverIp": "192.0.2.0",
"ednsClientSubnet": "198.51.100.0/24"
}
```
## parseVPC
이 프로세서를 사용하여 Amazon VPC 판매 로그를 구문 분석하고, 필드를 추출하고, JSON 형식으로 변환합니다. 인코딩된 필드 값은 디코딩됩니다.
이 프로세서는 `@message`만 입력으로 허용합니다.
**중요**
이 프로세서를 사용하는 경우 트랜스포머의 첫 번째 프로세서여야 합니다.
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
2 123456789010 eni-abc123de 192.0.2.0 192.0.2.24 20641 22 6 20 4249 1418530010 1418530070 ACCEPT OK
```
프로세서 구성은 다음과 같습니다.
```
[
{
"parseVPC": {}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"version": 2,
"accountId": "123456789010",
"interfaceId": "eni-abc123de",
"srcAddr": "192.0.2.0",
"dstAddr": "192.0.2.24",
"srcPort": 20641,
"dstPort": 22,
"protocol": 6,
"packets": 20,
"bytes": 4249,
"start": 1418530010,
"end": 1418530070,
"action": "ACCEPT",
"logStatus": "OK"
}
```
# parseToOCSF
`parseToOCSF` 프로세서는 로그를 OCSF(Open Cybersecurity Schema Framework) 이벤트로 변환합니다. OCSF는 보안 데이터에 대한 공통 스키마를 제공하는 개방형 표준으로, 다양한 보안 도구 및 플랫폼에서 보다 나은 상호 운용성과 분석을 지원합니다.
이 프로세서는 다양한 AWS 서비스의 로그 형식을 다운스트림 분석을 위한 일관된 스키마로 표준화해야 하는 보안 분석 워크플로에 특히 유용합니다.
**파라미터**
`eventSource`(필수)
변환할 로그 이벤트를 생성하는 AWS 서비스 또는 프로세스를 지정합니다. 유효값은 다음과 같습니다.
+ `CloudTrail` - CloudTrail 로그
+ `Route53Resolver` - Route 53 Resolver 로그
+ `VPCFlow` - Amazon VPC Flow Logs
+ `EKSAudit` - Amazon EKS 감사 로그
+ `AWSWAF` - AWS WAF 로그
`ocsfVersion`(필수)
변환된 로그 이벤트에 사용할 OCSF 스키마 버전을 지정합니다. 현재 지원되는 버전: `V1.1, V1.5`
`mappingVersion` (선택 사항)
OCSF 변환 매핑 버전을 지정합니다. 로그를 OCSF 형식으로 변환할 때 적용되는 변환 로직을 제어합니다. 지정하지 않으면는 정책 생성 시 사용 가능한 최신 버전을 사용합니다. 새 매핑 버전이 릴리스되면 기존 정책이 자동으로 업그레이드되지 않습니다. 현재 최신 버전: `v1.5.0`.
**참고:**이 `ocsfVersion`인 경우 지원되지 않습니다`V1.1`.
`source` (선택 사항)
구문 분석하려는 로그 이벤트의 필드 경로. 생략하면 전체 로그 메시지가 구문 분석됩니다.
**예제**
다음 예제에서는 `parseToOCSF`를 사용하여 VPC 흐름 로그를 OCSF 형식으로 변환하는 방법을 보여줍니다.
```
{
"parseToOCSF": {
"eventSource": "VPCFlow",
"ocsfVersion": "V1.1"
}
}
```
다음 예제에서는 일관된 변환 동작을 위해 특정 매핑 버전을 지정하는 방법을 보여줍니다.
```
{
"parseToOCSF": {
"eventSource": "CloudTrail",
"ocsfVersion": "V1.5",
"mappingVersion": "v1.5.0"
}
}
```
# 문자열 변형 프로세서
이 섹션에는 로그 이벤트 변환기와 함께 사용할 수 있는 문자열 변형 프로세서에 대한 정보가 포함되어 있습니다.
**Contents**
+ [lowerCaseString](#CloudWatch-Logs-Transformation-lowerCaseString)
+ [upperCaseString](#CloudWatch-Logs-Transformation-upperCaseString)
+ [splitString](#CloudWatch-Logs-Transformation-splitString)
+ [substituteString](#CloudWatch-Logs-Transformation-substituteString)
+ [trimString](#CloudWatch-Logs-Transformation-trimString)
## lowerCaseString
`lowerCaseString` 프로세서는 문자열을 소문자 버전으로 변환합니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| withKeys | 소문자로 변환할 키의 목록 | 예 | | 최대 항목: 10 |
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
{
"outer_key": {
"inner_key": "INNER_VALUE"
}
}
```
트랜스포머 구성은 `lowerCaseString`를 `parseJSON`과 사용하는 경우 다음과 같습니다.
```
[
{
"parseJSON": {}
},
{
"lowerCaseString": {
"withKeys":["outer_key.inner_key"]
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
## upperCaseString
`upperCaseString` 프로세서는 문자열을 대문자 버전으로 변환합니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| withKeys | 대문자로 변환할 키의 목록 | 예 | | 최대 항목: 10 |
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
트랜스포머 구성은 `upperCaseString`를 `parseJSON`과 사용하는 경우 다음과 같습니다.
```
[
{
"parseJSON": {}
},
{
"upperCaseString": {
"withKeys":["outer_key.inner_key"]
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"outer_key": {
"inner_key": "INNER_VALUE"
}
}
```
## splitString
`splitString` 프로세서는 구분 문자를 사용하여 필드를 배열로 분할하는 문자열 변형 프로세서의 한 유형입니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| 항목 | 항목의 배열. 배열의 각 항목에는 source 및 delimiter 필드가 포함되어야 합니다. | 예 | | 최대 항목: 10 |
| source | 분할할 필드 값의 키 | 예 | | 최대 길이: 128 |
| delimiter | 필드 값을 분할할 구분 문자 문자열 | 예 | | 최대 길이: 128 |
**예제 1**
다음 예제 로그 이벤트를 살펴봅니다.
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
트랜스포머 구성은 `splitString`를 `parseJSON`과 사용하는 경우 다음과 같습니다.
```
[
{
"parseJSON": {}
},
{
"splitString": {
"entries": [
{
"source": "outer_key.inner_key",
"delimiter": "_"
}
]
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"outer_key": {
"inner_key": [
"inner",
"value"
]
}
}
```
**예제 2**
문자열을 분할할 구분 문자는 여러 문자일 수 있습니다.
다음 예제 로그 이벤트를 살펴봅니다.
```
{
"outer_key": {
"inner_key": "item1, item2, item3"
}
}
```
트랜스포머 구성은 다음과 같습니다.
```
[
{
"parseJSON": {}
},
{
"splitString": {
"entries": [
{
"source": "outer_key.inner_key",
"delimiter": ", "
}
]
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"outer_key": {
"inner_key": [
"item1",
"item2",
"item3"
]
}
}
```
## substituteString
`substituteString` 프로세서는 키 값을 정규식과 비교하여 일치하는 모든 항목을 대체 문자열로 대체하는 문자열 변형 프로세서의 한 유형입니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| 항목 | 항목의 배열. 배열의 각 항목에는 source, from 및 to 필드가 포함되어야 합니다. | 예 | | 최대 항목: 10 |
| source | 수정할 필드의 키 | 예 | | 최대 길이: 128 최대 중첩 키 깊이: 3 |
| from | 대체될 정규식 문자열입니다. 큰따옴표를 사용할 때는 \$1\$1를 사용하고 작은따옴표를 사용하거나 AWS Management Console에서 구성하는 경우에는 \$1를 사용하여 [ 및 ]와 같은 특수 정규식 문자를 이스케이프 처리해야 합니다. 자세한 내용은 Oracle 웹사이트의 [Class Pattern](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html)을 참조하세요. `(...)`에서 패턴을 래핑하여 번호가 지정된 캡처 그룹을 생성하고 `to` 필드에서 참조할 수 있는 이름이 `(?P...)`인 캡처 그룹을 생성할 수 있습니다. | 예 | | 최대 길이: 128 |
| to | 캡처 그룹에 대한 from 역참조의 각 매칭으로 대체될 문자열을 사용할 수 있습니다. \$11와 같은 번호가 매겨진 그룹에는 \$1n 형식을 사용하고, \$1\$1my\$1group\$1와 같은 명명된 그룹에는 \$1\$1group\$1name\$1을 사용합니다.> | 예 | | 최대 길이: 128 최대 역참조의 수: 10 최대 중복된 역참조의 수: 2 |
**예제 1**
다음 예제 로그 이벤트를 살펴봅니다.
```
{
"outer_key": {
"inner_key1": "[]",
"inner_key2": "123-345-567",
"inner_key3": "A cat takes a catnap."
}
}
```
트랜스포머 구성은 `substituteString`를 `parseJSON`과 사용하는 경우 다음과 같습니다.
```
[
{
"parseJSON": {}
},
{
"substituteString": {
"entries": [
{
"source": "outer_key.inner_key1",
"from": "\\[\\]",
"to": "value1"
},
{
"source": "outer_key.inner_key2",
"from": "[0-9]{3}-[0-9]{3}-[0-9]{3}",
"to": "xxx-xxx-xxx"
},
{
"source": "outer_key.inner_key3",
"from": "cat",
"to": "dog"
}
]
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"outer_key": {
"inner_key1": "value1",
"inner_key2": "xxx-xxx-xxx",
"inner_key3": "A dog takes a dognap."
}
}
```
**예제 2**
다음 예제 로그 이벤트를 살펴봅니다.
```
{
"outer_key": {
"inner_key1": "Tom, Dick, and Harry",
"inner_key2": "arn:aws:sts::123456789012:assumed-role/MyImportantRole/MySession"
}
}
```
트랜스포머 구성은 `substituteString`를 `parseJSON`과 사용하는 경우 다음과 같습니다.
```
[
{
"parseJSON": {}
},
{
"substituteString": {
"entries": [
{
"source": "outer_key.inner_key1",
"from": "(\w+), (\w+), and (\w+)",
"to": "$1 and $3"
},
{
"source": "outer_key.inner_key2",
"from": "^arn:aws:sts::(?P\\d{12}):assumed-role/(?P[\\w+=,.@-]+)/(?P[\\w+=,.@-]+)$",
"to": "${account_id}:${role_name}:${role_session_name}"
}
]
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"outer_key": {
"inner_key1": "Tom and Harry",
"inner_key2": "123456789012:MyImportantRole:MySession"
}
}
```
## trimString
`trimString` 프로세서는 키의 시작과 끝에서 공백을 제거합니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| withKeys | 정리할 키의 목록 | 예 | | 최대 항목: 10 |
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
{
"outer_key": {
"inner_key": " inner_value "
}
}
```
트랜스포머 구성은 `trimString`를 `parseJSON`과 사용하는 경우 다음과 같습니다.
```
[
{
"parseJSON": {}
},
{
"trimString": {
"withKeys":["outer_key.inner_key"]
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
# JSON 변형 프로세서
이 섹션에는 로그 이벤트 변환기와 함께 사용할 수 있는 JSON 변형 프로세서에 대한 정보가 포함되어 있습니다.
**Contents**
+ [addKeys](#CloudWatch-Logs-Transformation-addKeys)
+ [deleteKeys](#CloudWatch-Logs-Transformation-deleteKeys)
+ [moveKeys](#CloudWatch-Logs-Transformation-moveKeys)
+ [renameKeys](#CloudWatch-Logs-Transformation-renameKeys)
+ [copyValue](#CloudWatch-Logs-Transformation-copyValue)
+ [listToMap](#CloudWatch-Logs-Transformation-listToMap)
## addKeys
`addKeys` 프로세서를 사용하여 로그 이벤트에 새 키-값 쌍을 추가합니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| 항목 | 항목의 배열. 배열의 각 항목에는 key, value 및 overwriteIfExists 필드가 포함될 수 있습니다. | 예 | | 최대 항목: 5 |
| 키 | 추가할 새 항목의 키 | 예 | | 최대 길이: 128 최대 중첩 키 깊이: 3 |
| 값 | 추가할 새 항목의 값 | 예 | | 최대 길이: 256 |
| overwriteIfExists | 이 값을 true로 설정하면 이벤트에 key가 이미 있는 경우 기존 값을 덮어씁니다. 기본값은 false입니다. | 아니요 | false | 제한 없음 |
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
트랜스포머 구성은 `addKeys`를 `parseJSON`과 사용하는 경우 다음과 같습니다.
```
[
{
"parseJSON": {}
},
{
"addKeys": {
"entries": [
{
"key": "outer_key.new_key",
"value": "new_value"
}
]
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"outer_key": {
"inner_key": "inner_value",
"new_key": "new_value"
}
}
```
## deleteKeys
`deleteKeys` 프로세서를 사용하여 로그 이벤트에서 필드를 삭제합니다. 이러한 필드에는 키-값 쌍이 포함될 수 있습니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| withKeys | 삭제할 키의 목록. | 예 | 제한 없음 | 최대 항목: 5 |
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
트랜스포머 구성은 `deleteKeys`를 `parseJSON`과 사용하는 경우 다음과 같습니다.
```
[
{
"parseJSON": {}
},
{
"deleteKeys": {
"withKeys":["outer_key.inner_key"]
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"outer_key": {}
}
```
## moveKeys
`moveKeys` 프로세서를 사용하여 한 필드에서 다른 필드로 키를 이동합니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| 항목 | 항목의 배열. 배열의 각 항목에는 source, target 및 overwriteIfExists 필드가 포함될 수 있습니다. | 예 | | 최대 항목: 5 |
| source | 이동할 키 | 예 | | 최대 길이: 128 최대 중첩 키 깊이: 3 |
| 대상 | 이동할 키 | 예 | | 최대 길이: 128 최대 중첩 키 깊이: 3 |
| overwriteIfExists | 이 값을 true로 설정하면 이벤트에 key가 이미 있는 경우 기존 값을 덮어씁니다. 기본값은 false입니다. | 아니요 | false | 제한 없음 |
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
{
"outer_key1": {
"inner_key1": "inner_value1"
},
"outer_key2": {
"inner_key2": "inner_value2"
}
}
```
트랜스포머 구성은 `moveKeys`를 `parseJSON`과 사용하는 경우 다음과 같습니다.
```
[
{
"parseJSON": {}
},
{
"moveKeys": {
"entries": [
{
"source": "outer_key1.inner_key1",
"target": "outer_key2"
}
]
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"outer_key1": {},
"outer_key2": {
"inner_key2": "inner_value2",
"inner_key1": "inner_value1"
}
}
```
## renameKeys
`renameKeys` 프로세서를 사용하여 로그 이벤트에서 키의 이름을 바꿉니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| 항목 | 항목의 배열. 배열의 각 항목에는 key, target 및 overwriteIfExists 필드가 포함될 수 있습니다. | 예 | 제한 없음 | 최대 항목: 5 |
| 키 | 이름을 바꿀 키 | 예 | 제한 없음 | 최대 길이: 128 |
| 대상 | 새 키 이름 | 예 | 제한 없음 | 최대 길이: 128 최대 중첩 키 깊이: 3 |
| overwriteIfExists | 이 값을 true로 설정하면 이벤트에 key가 이미 있는 경우 기존 값을 덮어씁니다. 기본값은 false입니다. | 아니요 | false | 제한 없음 |
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
트랜스포머 구성은 `renameKeys`를 `parseJSON`과 사용하는 경우 다음과 같습니다.
```
[
{
"parseJSON": {}
},
{
"renameKeys": {
"entries": [
{
"key": "outer_key",
"target": "new_key"
}
]
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"new_key": {
"inner_key": "inner_value"
}
}
```
## copyValue
`copyValue` 프로세서를 사용하여 로그 이벤트 내에서 값을 복사합니다. 또한 이 프로세서를 사용하여 `@logGroupName`, `@logGroupStream`, `@accountId`, `@regionName` 등 메타데이터 키 값을 로그 이벤트에 복사하여 로그 이벤트에 메타데이터를 추가할 수 있습니다. 다음 예제에 설명되어 있습니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| 항목 | 항목의 배열. 배열의 각 항목에는 source, target 및 overwriteIfExists 필드가 포함될 수 있습니다. | 예 | | 최대 항목: 5 |
| source | 복사할 키 | 예 | | 최대 길이: 128 최대 중첩 키 깊이: 3 |
| 대상 | 값을 복사할 키 | 예 | 제한 없음 | 최대 길이: 128 최대 중첩 키 깊이: 3 |
| overwriteIfExists | 이 값을 true로 설정하면 이벤트에 key가 이미 있는 경우 기존 값을 덮어씁니다. 기본값은 false입니다. | 아니요 | false | 제한 없음 |
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
트랜스포머 구성은 `copyValue`를 `parseJSON`과 사용하는 경우 다음과 같습니다.
```
[
{
"parseJSON": {}
},
{
"copyValue": {
"entries": [
{
"key": "outer_key.new_key",
"target": "new_key"
},
{
"source": "@logGroupName",
"target": "log_group_name"
},
{
"source": "@logGroupStream",
"target": "log_group_stream"
},
{
"source": "@accountId",
"target": "account_id"
},
{
"source": "@regionName",
"target": "region_name"
}
]
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"outer_key": {
"inner_key": "inner_value"
},
"new_key": "inner_value",
"log_group_name": "myLogGroupName",
"log_group_stream": "myLogStreamName",
"account_id": "012345678912",
"region_name": "us-east-1"
}
```
## listToMap
`listToMap` 프로세서는 키 필드가 포함된 객체 목록을 가져와 대상 키 맵으로 변환합니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| source | 맵으로 변환될 객체 목록이 있는 ProcessingEvent의 키 | 예 | | 최대 길이: 128 최대 중첩 키 깊이: 3 |
| 키 | 생성된 맵에서 키로 추출할 필드의 키 | 예 | | 최대 길이: 128 |
| valueKey | 이렇게 지정하면 이 파라미터에서 지정하는 값이 source 객체에서 추출되어 생성된 맵의 값에 추가됩니다. 그렇지 않으면 소스 목록의 원본 객체가 생성된 맵의 값에 추가됩니다. | 아니요 | | 최대 길이: 128 |
| 대상 | 생성된 맵을 보관할 필드의 키. | 아니요 | 루트 노드 | 최대 길이: 128 최대 중첩 키 깊이: 3 |
| 평면화 | 목록을 단일 항목으로 평탄화할지 아니면 생성된 맵의 값을 목록으로 만들지 나타내는 부울 값입니다. 기본적으로 매칭 키의 값은 배열로 표시됩니다. `flatten`을 `true`로 설정하여 배열을 `flattenedElement`의 값을 기반으로 하는 단일 값으로 변환합니다. | 아니요 | false | |
| flattenedElement | flatten을 true로 설정한 경우 flattenedElement를 사용하여 유지할 요소 first 또는 last를 지정합니다. | `flatten`이 `true`로 설정된 경우 필요합니다. | | 값은 first 또는 last만 될 수 있습니다. |
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
{
"outer_key": [
{
"inner_key": "a",
"inner_value": "val-a"
},
{
"inner_key": "b",
"inner_value": "val-b1"
},
{
"inner_key": "b",
"inner_value": "val-b2"
},
{
"inner_key": "c",
"inner_value": "val-c"
}
]
}
```
**사용 사례 1의 트랜스포머:** `flatten`은 `false`입니다
```
[
{
"parseJSON": {}
},
{
"listToMap": {
"source": "outer_key"
"key": "inner_key",
"valueKey": "inner_value",
"flatten": false
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"outer_key": [
{
"inner_key": "a",
"inner_value": "val-a"
},
{
"inner_key": "b",
"inner_value": "val-b1"
},
{
"inner_key": "b",
"inner_value": "val-b2"
},
{
"inner_key": "c",
"inner_value": "val-c"
}
],
"a": [
"val-a"
],
"b": [
"val-b1",
"val-b2"
],
"c": [
"val-c"
]
}
```
**사용 사례 2의 트랜스포머:** `flatten`은 `true`이고, `flattenedElement`는 `first`입니다
```
[
{
"parseJSON": {}
},
{
"listToMap": {
"source": "outer_key"
"key": "inner_key",
"valueKey": "inner_value",
"flatten": true,
"flattenedElement": "first"
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"outer_key": [
{
"inner_key": "a",
"inner_value": "val-a"
},
{
"inner_key": "b",
"inner_value": "val-b1"
},
{
"inner_key": "b",
"inner_value": "val-b2"
},
{
"inner_key": "c",
"inner_value": "val-c"
}
],
"a": "val-a",
"b": "val-b1",
"c": "val-c"
}
```
**사용 사례 3의 트랜스포머:** `flatten`은 `true`이고, `flattenedElement`는 `last`입니다
```
[
{
"parseJSON": {}
},
{
"listToMap": {
"source": "outer_key"
"key": "inner_key",
"valueKey": "inner_value",
"flatten": true,
"flattenedElement": "last"
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"outer_key": [
{
"inner_key": "a",
"inner_value": "val-a"
},
{
"inner_key": "b",
"inner_value": "val-b1"
},
{
"inner_key": "b",
"inner_value": "val-b2"
},
{
"inner_key": "c",
"inner_value": "val-c"
}
],
"a": "val-a",
"b": "val-b2",
"c": "val-c"
}
```
# 데이터타입 컨버터 프로세서
이 섹션에는 로그 이벤트 변환기와 함께 사용할 수 있는 데이터 유형 변환기 프로세서에 대한 정보가 포함되어 있습니다.
**Contents**
+ [typeConverter](#CloudWatch-Logs-Transformation-typeConverter)
+ [datetimeConverter](#CloudWatch-Logs-Transformation-datetimeConverter)
## typeConverter
`typeConverter` 프로세서를 사용하여 지정된 키와 연결된 값 유형을 지정된 유형으로 변환합니다. 지정된 필드의 유형을 변경하는 캐스팅 프로세서입니다. 값은 `integer`, `double` `string` 및 `boolean` 데이터타입 중 하나로 변환할 수 있습니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| 항목 | 항목의 배열. 배열의 각 항목에는 key 및 type 필드가 포함되어야 합니다. | 예 | | 최대 항목: 10 |
| 키 | 다른 유형으로 변환할 값이 있는 키 | 예 | | 최대 길이: 128 최대 중첩 키 깊이: 3 |
| type | 변환할 유형. 유효값은 integer, double, string 및 boolean입니다. | 예 | | |
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
{
"name": "value",
"status": "200"
}
```
트랜스포머 구성은 `typeConverter`를 `parseJSON`과 사용하는 경우 다음과 같습니다.
```
[
{
"parseJSON": {}
},
{
"typeConverter": {
"entries": [
{
"key": "status",
"type": "integer"
}
]
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"name": "value",
"status": 200
}
```
## datetimeConverter
`datetimeConverter` 프로세서를 사용하여 날짜/시간 문자열을 지정한 형식으로 변환합니다.
| 필드 | 설명 | 필수 | 기본값 | 제한 사항 |
| --- | --- | --- | --- | --- |
| source | 날짜 변환을 적용할 키. | 예 | | 최대 항목: 10 |
| matchPatterns | source 필드를 매칭할 패턴의 목록 | 예 | | 최대 항목: 5 |
| 대상 | 결과를 저장할 JSON 필드. | 예 | | 최대 길이: 128 최대 중첩 키 깊이: 3 |
| targetFormat | 대상 필드의 변환된 데이터에 사용할 날짜/시간 형식. | 아니요 | ` yyyy-MM-dd'T'HH:mm:ss.SSS'Z` | 최대 길이: 64 |
| sourceTimezone | 소스 필드의 시간대. 가능한 값의 목록은 [Java 지원되는 영역 ID 및 오프셋](https://howtodoinjava.com/java/date-time/supported-zone-ids-offsets/#3-java-supported-zone-ids-and-offsets)을 참조하세요. | 아니요 | UTC | 최소 길이: 1 |
| targetTimezone | 대상 필드의 시간대. 가능한 값의 목록은 [Java 지원되는 영역 ID 및 오프셋](https://howtodoinjava.com/java/date-time/supported-zone-ids-offsets/#3-java-supported-zone-ids-and-offsets)을 참조하세요. | 아니요 | UTC | 최소 길이: 1 |
| locale | 소스 필드의 로케일. 가능한 값의 목록은 [예제가 포함된 Java의 Locale getAvailableLocales() Method](https://www.geeksforgeeks.org/locale-getavailablelocales-method-in-java-with-examples/)를 참조하세요. | 예 | | 최소 길이: 1 |
**예제**
다음 예제 로그 이벤트를 살펴봅니다.
```
{"german_datetime": "Samstag 05. Dezember 1998 11:00:00"}
```
트랜스포머 구성은 `dateTimeConverter`를 `parseJSON`과 사용하는 경우 다음과 같습니다.
```
[
{
"parseJSON": {}
},
{
"dateTimeConverter": {
"source": "german_datetime",
"target": "target_1",
"locale": "de",
"matchPatterns": ["EEEE dd. MMMM yyyy HH:mm:ss"],
"sourceTimezone": "Europe/Berlin",
"targetTimezone": "America/New_York",
"targetFormat": "yyyy-MM-dd'T'HH:mm:ss z"
}
}
]
```
변환된 로그 이벤트는 다음과 같습니다.
```
{
"german_datetime": "Samstag 05. Dezember 1998 11:00:00",
"target_1": "1998-12-05T17:00:00 MEZ"
}
```
# 변환 지표 및 오류
CloudWatch Logs는 CloudWatch에 변환 지표를 게시합니다. 이러한 지표에는 `TransformedLogEvents`, `TransformedBytes` 및 `TransformationErrors`이 있습니다. 자세한 내용은 [로그 트랜스포머 지표 및 차원](CloudWatch-Logs-Monitoring-CloudWatch-Metrics.md#CloudWatchLogs-Transformer-Metrics) 단원을 참조하십시오.
CloudWatch Logs가 로그 이벤트를 변환하려고 하거나 변환하지 못할 때마다 해당 로그 이벤트에 `@transformationError` 시스템 필드가 추가됩니다. CloudWatch Logs Insights 쿼리를 실행하면 변환에 실패한 모든 로그 이벤트에이 필드가 표시됩니다. `filter ispresent(@transformationError)`와 같은 쿼리로 이 필드를 쿼리하여 실패한 모든 변환 이벤트를 찾을 수 있습니다.