# PySpark의 AWS Glue ETL 스크립트 프로그래밍 GitHub 웹 사이트의 [AWS Glue 샘플 리포지토리](https://github.com/awslabs/aws-glue-samples)에서 AWS Glue용 Python 코드 예제 및 유틸리티를 찾을 수 있습니다. ## AWS Glue와 함께 Python 사용 AWS Glue는 추출, 변환, 로드 작업 스크립트에 대해 PySpark Python의 확장을 지원합니다. 이 섹션에서는 AWS Glue API와 함께 Python의 ETL 스크립트를 사용하는 방법을 설명합니다. + [AWS Glue과 함께 Python을 사용하기 위한 설정](aws-glue-programming-python-setup.md) + [Python에서 AWS Glue API 호출](aws-glue-programming-python-calling.md) + [AWS Glue와 함께 Python 라이브러리 사용](aws-glue-programming-python-libraries.md) + [AWS Glue Python 코드 샘플](aws-glue-programming-python-samples.md) ## AWS Glue PySpark 확장 AWS Glue는 다음 확장 기능을 PySpark Python 언어에 생성합니다. + [`getResolvedOptions`를 사용한 파라미터 액세스](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md) + [PySpark 확장 유형](aws-glue-api-crawler-pyspark-extensions-types.md) + [DynamicFrame 클래스](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md) + [DynamicFrameCollection 클래스](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-collection.md) + [DynamicFrameWriter 클래스](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-writer.md) + [DynamicFrameReader 클래스](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md) + [GlueContext 클래스](aws-glue-api-crawler-pyspark-extensions-glue-context.md) ## AWS Glue PySpark 변환 AWS Glue는 PySpark ETL 작업에 다음 변환 클래스를 사용하기 위해 생성됩니다. + [GlueTransform 베이스 클래스](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md) + [ApplyMapping 클래스](aws-glue-api-crawler-pyspark-transforms-ApplyMapping.md) + [DropFields 클래스](aws-glue-api-crawler-pyspark-transforms-DropFields.md) + [DropNullField 클래스](aws-glue-api-crawler-pyspark-transforms-DropNullFields.md) + [ErrorsAsDynamicFrame 클래스](aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame.md) + [FillMissingValues 클래스](aws-glue-api-crawler-pyspark-transforms-fillmissingvalues.md) + [Filter 클래스](aws-glue-api-crawler-pyspark-transforms-filter.md) + [FindIncrementalMatches 클래스](aws-glue-api-crawler-pyspark-transforms-findincrementalmatches.md) + [FindMatches 클래스](aws-glue-api-crawler-pyspark-transforms-findmatches.md) + [FlatMap 클래스](aws-glue-api-crawler-pyspark-transforms-flat-map.md) + [Join 클래스](aws-glue-api-crawler-pyspark-transforms-join.md) + [Map 클래스](aws-glue-api-crawler-pyspark-transforms-map.md) + [MapToCollection 클래스](aws-glue-api-crawler-pyspark-transforms-MapToCollection.md) + [mergeDynamicFrame](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-merge) + [Relationalize 클래스](aws-glue-api-crawler-pyspark-transforms-Relationalize.md) + [RenameField 클래스](aws-glue-api-crawler-pyspark-transforms-RenameField.md) + [ResolveChoice 클래스](aws-glue-api-crawler-pyspark-transforms-ResolveChoice.md) + [SelectFields 클래스](aws-glue-api-crawler-pyspark-transforms-SelectFields.md) + [SelectFromCollection 클래스](aws-glue-api-crawler-pyspark-transforms-SelectFromCollection.md) + [Spigot 클래스](aws-glue-api-crawler-pyspark-transforms-spigot.md) + [SplitFields 클래스](aws-glue-api-crawler-pyspark-transforms-SplitFields.md) + [SplitRows 클래스](aws-glue-api-crawler-pyspark-transforms-SplitRows.md) + [Unbox 클래스](aws-glue-api-crawler-pyspark-transforms-Unbox.md) + [UnnestFrame 클래스](aws-glue-api-crawler-pyspark-transforms-UnnestFrame.md) # AWS Glue과 함께 Python을 사용하기 위한 설정 Python을 사용하여 Spark 작업에 대한 ETL 스크립트를 개발합니다. ETL 작업에 대해 지원되는 Python 버전은 작업의 AWS Glue 버전에 따라 다릅니다. AWS Glue 버전에 대한 자세한 내용은 [Glue version job property](add-job.md#glue-version-table) 섹션을 참조하세요. **AWS Glue와 함께 Python을 사용하기 위해 시스템을 설정합니다.** 다음 관계에 따라 Python을 설치하고 AWS Glue API를 호출할 수 있도록 합니다. 1. Python을 아직 설치하지 않았다면 [Python.org 다운로드 페이지](https://www.python.org/downloads/)에서 다운로드하여 설치합니다. 1. AWS Command Line Interface(AWS CLI)를 [AWS CLI 설명서](https://docs.aws.amazon.com/cli/latest/userguide/installing.html)에 기록하여 설치합니다. AWS CLI는 Python을 사용하는 데 직접적으로 필요하지 않습니다. 하지만 Python을 설치하고 구성하는 것은 계정 자격으로 AWS를 설치하고 계정 자격이 효용성이 있는지 확인하는 편리한 방법입니다. 1. AWS SDK for Python(Boto 3)이 [Boto3 빠른 시작](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html)에 기록되어 있어 설치할 수 있습니다. AWS Glue에서는 Boto 3 리소스 API를 사용할 수 없습니다. 현재, Boto 3 사용자 API만 사용할 수 있습니다. Boto 3에 대한 자세한 내용은 [AWS SDK for Python(Boto3) 시작하기](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)를 참조하세요. AWS Glue용 Python 코드 예제와 유틸리티는 GitHub 웹 사이트의 [AWS Glue 샘플 리포지토리](https://github.com/awslabs/aws-glue-samples)에서 찾을 수 있습니다. # Python에서 AWS Glue API 호출 AWS Glue에서는 Boto 3 리소스 API를 사용할 수 없습니다. 현재, Boto 3 사용자 API만 사용할 수 있습니다. ## Python에 있는 AWS Glue API 이름 Java 언어로 된 AWS Glue API 이름과 기타 프로그래밍 언어는 보통 카멜케이스(CamelCased)된 단어(단어들 사이의 간격이 없는 단어)입니다. 하지만 Python이 호출하면 일반 이름이 Python식으로 단어들이 밑줄 문자로 분리된 소문자로 바뀝니다. [AWS Glue API](aws-glue-api.md) 참조 문서에서는 이 Python식 이름이 일반 카멜케이스(CamelCased)된 이름 다음에 괄호 안에 기록됩니다. 그러나 비록 AWS Glue API 이름 자체가 소문자로 변환되었지만 이 파라미터 이름은 대문자로 남겨집니다. 이런 점을 기억해야 하는 이유는 파마리터가 다음 설명처럼 AWS Glue API를 호출할 때 이름에 따라 통과하기 때문입니다. ## AWS Glue에서 Python 파라미터 전달 및 액세스 Python은 AWS Glue API를 호출할 경우, 파라미터를 이름에 따라 정확하게 통과하는 것이 최선의 방법입니다. 예: ``` job = glue.create_job(Name='sample', Role='Glue_DefaultRole', Command={'Name': 'glueetl', 'ScriptLocation': 's3://my_script_bucket/scripts/my_etl_script.py'}) ``` Python이 [작업 구조](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-Job) 또는 [JobRun 구조](aws-glue-api-jobs-runs.md#aws-glue-api-jobs-runs-JobRun)의 ETL 스크립트 논제로 지정한 이름/값의 딕셔너리를 생성한다는 점을 이해하면 도움이 됩니다. Boto 3은 JSON 형식으로 REST API 호출을 거쳐 AWS Glue를 통과합니다. 이런 과정은 스크립트에서 논제로 액세스할 경우 논제의 순서에 의존하지 않습니다. 예를 들어, Python Lambda 관리 함수에서 `JobRun`을 시작하고자 하고 몇 가지 파라미터를 지정하고자 한다고 가정합니다. 코드는 다음과 같을 것입니다. ``` from datetime import datetime, timedelta client = boto3.client('glue') def lambda_handler(event, context): last_hour_date_time = datetime.now() - timedelta(hours = 1) day_partition_value = last_hour_date_time.strftime("%Y-%m-%d") hour_partition_value = last_hour_date_time.strftime("%-H") response = client.start_job_run( JobName = 'my_test_Job', Arguments = { '--day_partition_key': 'partition_0', '--hour_partition_key': 'partition_1', '--day_partition_value': day_partition_value, '--hour_partition_value': hour_partition_value } ) ``` 안전하게 ETL에서 이 파라미터로 액세스하기 위해서는 AWS Glue의 `getResolvedOptions` 함수를 사용하여 이름에 따라 지정하고 딕셔너리 결과로부터 파라미터로 액세스합니다. ``` import sys from awsglue.utils import getResolvedOptions args = getResolvedOptions(sys.argv, ['JOB_NAME', 'day_partition_key', 'hour_partition_key', 'day_partition_value', 'hour_partition_value']) print "The day partition key is: ", args['day_partition_key'] print "and the day partition value is: ", args['day_partition_value'] ``` 중첩된 JSON 문자열인 인수를 전달하려는 경우 파라미터 값이 AWS Glue ETL 작업에 전달될 때 해당 값을 유지하려면 작업 실행을 시작하기 전에 파라미터 문자열을 인코딩한 다음, 작업 스크립트를 참조하기 전에 파라미터 문자열을 디코딩해야 합니다. 예를 들어 다음 인수 문자열을 고려하세요. ``` glue_client.start_job_run(JobName = "gluejobname", Arguments={ "--my_curly_braces_string": '{"a": {"b": {"c": [{"d": {"e": 42}}]}}}' }) ``` 이 파라미터를 올바르게 전달하려면 인수를 Base64로 인코딩한 문자열로 인코딩해야 합니다. ``` import base64 ... sample_string='{"a": {"b": {"c": [{"d": {"e": 42}}]}}}' sample_string_bytes = sample_string.encode("ascii") base64_bytes = base64.b64encode(sample_string_bytes) base64_string = base64_bytes.decode("ascii") ... glue_client.start_job_run(JobName = "gluejobname", Arguments={ "--my_curly_braces_string": base64_bytes}) ... sample_string_bytes = base64.b64decode(base64_bytes) sample_string = sample_string_bytes.decode("ascii") print(f"Decoded string: {sample_string}") ... ``` ## 예: 작업 생성 및 실행 다음 예제는 Python을 사용하여 AWS Glue API를 호출하여 ETL 작업을 실행할 수 있는 방법을 보여줍니다. **예: 작업을 생성하고 실행하기 위해서** 1. AWS Glue 클라이언트의 인스턴스를 만듭니다. ``` import boto3 glue = boto3.client(service_name='glue', region_name='us-east-1', endpoint_url='https://glue.us-east-1.amazonaws.com') ``` 1. 작업 만들기 다음 코드에서 보여지듯이 `glueetl`를 ETL 명령어로 사용해야 합니다. ``` myJob = glue.create_job(Name='sample', Role='Glue_DefaultRole', Command={'Name': 'glueetl', 'ScriptLocation': 's3://my_script_bucket/scripts/my_etl_script.py'}) ``` 1. 이전 단계에서 만든 작업을 새롭게 시작합니다. ``` myNewJobRun = glue.start_job_run(JobName=myJob['Name']) ``` 1. 작업 상태 얻기. ``` status = glue.get_job_run(JobName=myJob['Name'], RunId=myNewJobRun['JobRunId']) ``` 1. 작업 실행의 현재 상태를 프린트합니다. ``` print(status['JobRun']['JobRunState']) ``` # AWS Glue와 함께 Python 라이브러리 사용 AWS Glue ETL과 함께 사용할 추가 Python 모듈 및 라이브러리를 설치할 수 있습니다. AWS Glue 2.0 이상에서 AWS Glue는 Python 패키지 설치 프로그램(pip3)을 사용하여 AWS Glue ETL에서 사용할 추가 모듈을 설치합니다. AWS Glue에서 여러 옵션을 사용하여 추가 Python 모듈을 AWS Glue 작업 환경으로 가져올 수 있습니다. `--additional-python-modules` 파라미터를 사용하여 번들링된 Python 휠이 포함된 ZIP 파일(‘휠 Zip’이라고도 함, AWS Glue 5.0 이상에서 사용 가능), 개별 Python 휠 파일, 요구 사항 파일(requirements.txt, AWS Glue 5.0 이상에서 사용 가능) 또는 쉼표로 구분된 Python 모듈 목록을 사용하여 새 모듈을 가져올 수 있습니다. 또한 AWS Glue 환경에서 제공된 Python 모듈의 버전을 변경하는 데 사용할 수도 있습니다(자세한 내용은 [AWS Glue에서 이미 제공되는 Python 모듈](#glue-modules-provided) 참조). **Topics** + [pip를 사용하여 AWS Glue 2.0 이상에 추가 Python 모듈 설치](#addl-python-modules-support) + [PySpark 네이티브 기능으로 Python 파일 포함](#extra-py-files-support) + [시각적 변환을 사용하는 프로그래밍 스크립트](#aws-glue-programming-with-cvt) + [라이브러리 압축하여 포함](#aws-glue-programming-python-libraries-zipping) + [AWS Glue Studio 노트북에서 Python 라이브러리 로드](#aws-glue-programming-python-libraries-notebooks) + [AWS Glue 0.9/1.0의 개발 엔드포인트에서 Python 라이브러리 로딩](#aws-glue-programming-python-libraries-dev-endpoint) + [Job 혹은 JobRun에서 Python 라이브러리 사용](#aws-glue-programming-python-libraries-job) + [Python 종속성 사전 분석](#aws-glue-programming-analyzing-python-dependencies) + [AWS Glue에서 이미 제공되는 Python 모듈](#glue-modules-provided) + [부록 A: 휠 ZIP 아티팩트 생성](#glue-python-library-zip-of-wheels-appendix) + [부록 B: AWS Glue 환경 세부 정보](#glue-python-libraries-environment-details) ## pip를 사용하여 AWS Glue 2.0 이상에 추가 Python 모듈 설치 AWS Glue는 Python 패키지 설치 프로그램(pip3)을 사용하여 AWS Glue ETL에서 사용할 추가 모듈을 설치합니다. `--additional-python-modules` 파라미터를 쉼표로 구분된 Python 모듈 목록과 함께 사용하여 새 모듈을 추가하거나 기존 모듈의 버전을 변경할 수 있습니다. 빌드된 휠 아티팩트는 휠 ZIP 또는 독립 실행형 휠 아티팩트를 통해 파일을 Amazon S3에 업로드한 다음 모듈 목록에 Amazon S3 객체 경로를 포함하여 설치할 수 있습니다. 작업 파라미터 설정에 대한 자세한 내용은 [AWS Glue 작업에서 작업 파라미터 사용](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html)을 참조하세요. `--python-modules-installer-option` 파라미터를 사용하여 pip3에 추가 옵션을 전달할 수 있습니다. 예를 들어 pip가 `--additional-python-modules`에 지정된 패키지에 대해 사전 빌드된 아티팩트만 설치하도록 강제로 `--only-binary`를 전달할 수 있습니다. 더 많은 예제를 보려면 [Building Python modules from a wheel for Spark ETL workloads using AWS Glue 2.0](https://aws.amazon.com/blogs/big-data/building-python-modules-from-a-wheel-for-spark-etl-workloads-using-aws-glue-2-0/)을 참조하세요. ### Python 종속성 관리 모범 사례 프로덕션 워크로드의 경우 AWS Glue는 모든 Python 종속성을 단일 ZIP 아티팩트에 휠 파일로 패키징하는 것이 좋습니다. 이 접근 방식은 다음과 같은 이점을 제공합니다. + **결정론적 실행**: 설치될 패키지 버전을 정확하게 제어 + **신뢰성**: 작업 실행 중 외부 패키지 리포지토리에 대한 종속성 없음 + **성능**: 여러 네트워크 호출 대신 단일 다운로드 작업 + **오프라인 설치**: 인터넷 액세스 없이 프라이빗 VPC 환경에서 작동 #### 중요 고려 사항 [AWS 공동 책임 모델](https://aws.amazon.com/compliance/shared-responsibility-model/)에 따라 추가 Python 모듈, 라이브러리 및 해당 종속성을 관리하는 것은 사용자의 책임입니다. 여기에는 다음이 포함됩니다. + **보안 업데이트**: 보안 취약성을 해결하기 위해 패키지를 정기적으로 업데이트 + **버전 호환성**: 패키지가 AWS Glue 버전과 호환되는지 확인 + **테스트**: Glue 환경에서 패키징된 종속성이 올바르게 작동하는지 검증 최소한의 종속성만 있는 경우, 개별 휠 파일을 사용하는 것이 좋습니다. ### (권장) 휠 ZIP을 사용하여 AWS Glue 5.0 이상에 추가 Python 라이브러리 설치 AWS Glue 5.0 이상은 보다 안정적이고 결정론적인 종속성 관리를 위해 여러 휠 파일을 번들 Python 휠이 포함된 단일 ZIP 아티팩트로 패키징하는 것을 지원합니다. 이 접근 방식을 사용하려면 `.gluewheels.zip` 접미사를 사용하여 모든 휠 종속성과 전이적 종속성이 포함된 ZIP 파일을 생성하여 Amazon S3에 업로드한 다음 `--additional-python-modules` 파라미터를 사용하여 참조합니다. `--python-modules-installer-option` 작업 파라미터에 `--no-index`를 추가해야 합니다. 이 구성을 사용하면 휠 ZIP 파일이 기본적으로 pip의 로컬 인덱스 역할을 하여 런타임 시의 종속성을 해결합니다. 이렇게 하면 작업 실행 중에 PyPI와 같은 외부 패키지 리포지토리에 대한 종속성이 제거되므로 프로덕션 워크로드의 안정성과 일관성이 향상됩니다. 예제: ``` --additional-python-modules s3://amzn-s3-demo-bucket/path/to/zip-of-wheels-1.0.0.gluewheels.zip --python-modules-installer-option --no-index ``` 휠 ZIP 파일을 만드는 방법에 대한 지침은 [부록 A: 휠 ZIP 아티팩트 생성](#glue-python-library-zip-of-wheels-appendix) 섹션을 참조하세요. ### Wheel을 사용하여 추가 Python 라이브러리 설치 AWS Glue는 Amazon S3에 저장된 wheel(.whl) 파일을 사용하여 사용자 지정 Python 패키지 설치를 지원합니다. AWS Glue 작업에 wheel 파일을 포함하려면 `--additional-python-modules` 작업 파라미터에 S3에 저장된 휠 파일 목록(쉼표로 구분)을 제공합니다. 예제: ``` --additional-python-modules s3://amzn-s3-demo-bucket/path/to/package-1.0.0-py3-none-any.whl,s3://your-bucket/path/to/another-package-2.1.0-cp311-cp311-linux_x86_64.whl ``` 이 접근 방식은 사용자 지정 배포판 또는 올바른 운영 체제에 대해 사전 컴파일된 기본 종속성이 있는 패키지가 필요한 경우에도 지원됩니다. 더 많은 예제를 보려면 [Building Python modules from a wheel for Spark ETL workloads using AWS Glue 2.0](https://aws.amazon.com/blogs/big-data/building-python-modules-from-a-wheel-for-spark-etl-workloads-using-aws-glue-2-0/)을 참조하세요. ### requirements.txt를 사용하여 AWS Glue 5.0 이상에 추가 Python 라이브러리 설치 AWS Glue 5.0 이상에서는 Python 라이브러리 종속성을 관리하기 위한 표준 `requirements.txt`를 제공할 수 있습니다. 이렇게 하려면 다음 두 가지 작업 파라미터를 제공합니다. + 키: `--python-modules-installer-option` 값: `-r` + 키: `--additional-python-modules` 값: `s3://path_to_requirements.txt` AWS Glue 5.0 노드는 처음에 `requirements.txt`에 지정된 python 라이브러리를 로드합니다. 다음은 샘플 requirements.txt입니다. ``` awswrangler==3.9.1 elasticsearch==8.15.1 PyAthena==3.9.0 PyMySQL==1.1.1 PyYAML==6.0.2 pyodbc==5.2.0 pyorc==0.9.0 redshift-connector==2.1.3 scipy==1.14.1 scikit-learn==1.5.2 SQLAlchemy==2.0.36 ``` **중요** 특히 프로덕션 워크로드에서는 이 옵션을 주의해서 사용해야 합니다. 런타임 시 PyPI에서 종속성을 가져오면 아티팩트 pip가 어떻게 해결되는지 확신할 수 없으므로 매우 위험합니다. 고정되지 않은 라이브러리 버전을 사용하면 최신 버전의 Python 모듈을 가져와 최신 변경 사항이 적용되거나 호환되지 않는 Python 모듈을 가져올 수 있으므로 특히 위험합니다. 이로 인해 AWS Glue 작업 환경에서 Python 설치 실패로 인해 작업이 실패할 수 있습니다. 라이브러리 버전을 고정하면 안정성이 향상되지만 pip 해결은 여전히 완전히 결정론적이지 않으므로 유사한 문제가 발생할 수 있습니다. 모범 사례로 AWS Glue는 휠 ZIP 또는 개별 휠 파일과 같은 동결된 아티팩트를 사용할 것을 권장합니다(자세한 내용은 [(권장) 휠 ZIP을 사용하여 AWS Glue 5.0 이상에 추가 Python 라이브러리 설치](#glue-python-library-installing-zip-of-wheels) 참조). **중요** 전이적 종속성의 버전을 고정하지 않는 경우, 기본 종속성이 호환되지 않는 전이적 종속성 버전을 가져올 수 있습니다. 모범 사례로 AWS Glue 작업의 일관성을 위해 모든 라이브러리 버전을 고정하는 것이 좋습니다. 또한 AWS Glue는 종속성을 휠 ZIP 파일로 패키징하여 프로덕션 워크로드의 일관성과 신뢰성을 극대화할 것을 권장합니다. ### 쉼표로 구분된 목록으로 직접 구성하는 추가 Python 라이브러리 설치 새 Python 모듈을 업데이트하거나 추가하기 위해 AWS Glue를 사용하면 쉼표로 구분된 Python 모듈 목록을 값으로 사용하여 `--additional-python-modules` 파라미터를 전달할 수 있습니다. 예를 들어, scikit-learn 모듈을 업데이트/추가하려면 다음 키/값을 사용합니다. `"--additional-python-modules", "scikit-learn==0.21.3"`. 두 가지 옵션으로 Python 모듈을 직접 구성할 수 있습니다. + **고정된 Python 모듈** `"--additional-python-modules", "scikit-learn==0.21.3,ephem==4.1.6"` + **고정되지 않은 Python 모듈: (프로덕션 워크로드에는 권장되지 않음)** `"--additional-python-modules", "scikit-learn>==0.20.0,ephem>=4.0.0"` 또는 `"--additional-python-modules", "scikit-learn,ephem"` **중요** 특히 프로덕션 워크로드에서는 이 옵션을 주의해서 사용해야 합니다. 런타임 시 PyPI에서 종속성을 가져오면 아티팩트 pip가 어떻게 해결되는지 확신할 수 없으므로 매우 위험합니다. 고정되지 않은 라이브러리 버전을 사용하면 최신 버전의 Python 모듈을 가져와 최신 변경 사항이 적용되거나 호환되지 않는 Python 모듈을 가져올 수 있으므로 특히 위험합니다. 이로 인해 AWS Glue 작업 환경에서 Python 설치 실패로 인해 작업이 실패할 수 있습니다. 라이브러리 버전을 고정하면 안정성이 향상되지만 pip 해결은 여전히 완전히 결정론적이지 않으므로 유사한 문제가 발생할 수 있습니다. 모범 사례로 AWS Glue는 휠 ZIP 또는 개별 휠 파일과 같은 동결된 아티팩트를 사용할 것을 권장합니다(자세한 내용은 [(권장) 휠 ZIP을 사용하여 AWS Glue 5.0 이상에 추가 Python 라이브러리 설치](#glue-python-library-installing-zip-of-wheels) 참조). **중요** 전이적 종속성의 버전을 고정하지 않는 경우, 기본 종속성이 호환되지 않는 전이적 종속성 버전을 가져올 수 있습니다. 모범 사례로 AWS Glue 작업의 일관성을 위해 모든 라이브러리 버전을 고정하는 것이 좋습니다. 또한 AWS Glue는 종속성을 휠 ZIP 파일로 패키징하여 프로덕션 워크로드의 일관성과 신뢰성을 극대화할 것을 권장합니다. ## PySpark 네이티브 기능으로 Python 파일 포함 AWS Glue는 PySpark를 사용하여 AWS Glue ETL 작업에 Python 파일을 포함합니다. 사용 가능한 경우 종속성을 관리하기 위해 `--additional-python-modules`를 사용하고 싶을 것입니다. `--extra-py-files` 작업 파라미터를 사용하여 Python 파일을 포함할 수 있습니다. 종속성은 Amazon S3에서 호스팅되어야 하며, 인수 값은 공백 없이 쉼표로 구분된 Amazon S3 경로 목록이어야 합니다. 이 기능은 Spark에서 사용하는 Python 종속성 관리처럼 작동합니다. Spark의 Python 종속성 관리에 대한 자세한 내용을 알아보려면 Apache Spark 설명서의[Using PySpark Native Features](https://spark.apache.org/docs/latest/api/python/tutorial/python_packaging.html#using-pyspark-native-features)(PySpark 기본 기능 사용) 페이지를 참조하세요. `--extra-py-files`는 추가 코드가 패키징되지 않은 경우 또는 종속성 관리를 위해 기존 도구 체인으로 Spark 프로그램을 마이그레이션하는 경우에 유용합니다. 종속성 도구를 유지 관리하려면 제출하기 전에 종속성을 번들로 묶어야 합니다. ## 시각적 변환을 사용하는 프로그래밍 스크립트 AWS Glue Studio 시각적 인터페이스를 사용하여 AWS Glue 작업을 생성하면 관리형 데이터 변환 노드와 사용자 지정 시각적 변환을 사용하여 데이터를 변환할 수 있습니다. 관리형 데이터 변환 노드에 대한 자세한 내용은 [AWS Glue 관리형 변환으로 데이터 변환](edit-jobs-transforms.md) 섹션을 참조하세요. 사용자 지정 시각적 변환에 대한 자세한 내용은 [사용자 지정 시각적 변환으로 데이터 변환](custom-visual-transform.md) 섹션을 참조하세요. 시각적 변환을 사용하는 스크립트는 작업 **언어**가 Python 사용으로 설정된 경우에만 생성할 수 있습니다. 시각적 변환을 사용하여 AWS Glue 작업을 생성할 때 AWS Glue Studio는 작업 구성의 `--extra-py-files` 파라미터를 사용하여 런타임 환경에 이러한 변환을 포함합니다. 작업 파라미터에 대한 자세한 내용을 알아보려면 [AWS Glue 작업에서 작업 파라미터 사용](aws-glue-programming-etl-glue-arguments.md) 섹션을 참조하세요. 생성된 스크립트 또는 런타임 환경을 변경할 때 스크립트가 성공적으로 실행되도록 하려면 이 작업 구성을 유지해야 합니다. ## 라이브러리 압축하여 포함 라이브러리가 하나의 `.py` 파일로 포함되지 않는 한 `.zip` 아카이브로 패킹되어야 합니다. 패키지 디렉터리는 아가이브의 루트에 있어야 하고 패키지용 `__init__.py` 파일을 포함해야 합니다. 그러면 Python은 정상적인 방법으로 패키지를 가져올 수 있습니다. 라이브러리가 하나의 `.py` 파일에 하나의 Python 모듈만 구성할 수 있으면 모듈을 `.zip`에 넣을 필요가 없습니다. ## AWS Glue Studio 노트북에서 Python 라이브러리 로드 AWS Glue Studio 노트북에서 Python 라이브러리를 지정하려면 [추가 Python 모듈 설치](https://docs.aws.amazon.com/glue/latest/dg/manage-notebook-sessions.html#specify-default-modules)를 참조하세요. ## AWS Glue 0.9/1.0의 개발 엔드포인트에서 Python 라이브러리 로딩 다른 ETL 스크립트를 설치하기 위해 다른 라이브러리를 사용할 경우, 각 세트에 따라 개별 개발 엔드포인트를 설치하거나 개발 엔드포인트가 스크립트를 스위치할 때마다 로딩되는 라이브러리 `.zip` 파일(들)을 덮어쓰기할 수 있습니다. 콘솔을 사용하여 개발 엔드포인트를 생성할 때 개발 엔드포인트를 위한 하나 이상의 .zip 파일을 지정할 수 있습니다. 이름과 IAM 역할을 할당한 후 [**스크립트 라이브러리 및 작업 파라미터(선택 사항)(Script Libraries and job parameters (optional))**]를 선택하고 [**Python 라이브러리 경로(Python library path)**] 상자에 라이브러리 `.zip` 파일에 대한 전체 Amazon S3 경로를 입력합니다. 예: ``` s3://bucket/prefix/site-packages.zip ``` 원한다면, 다음과 같이 빈 칸없이 쉼표로만 나뉜 파일까지의 전체 경로를 지정할 수 있습니다. ``` s3://bucket/prefix/lib_A.zip,s3://bucket_B/prefix/lib_X.zip ``` 이런 `.zip` 파일을 나중에 업데이트하면 콘솔을 사용하여 개발 엔드포인트로 이러 파일을 다시 가져올 수 있습니다. 해당 개발자 엔드포인트로 이동하여 옆에 있는 확인란을 선택한 다음 [**작업(Action)**] 메뉴에서 [**ETL 라이브러리 업데이트(Update ETL libraries)**]를 선택합니다. 비슷한 방식으로 AWS Glue API를 사용하여 라이브러리 파일을 지정할 수 있습니다. [CreateDevEndpoint 작업(Python: create\$1dev\$1endpoint)](aws-glue-api-dev-endpoint.md#aws-glue-api-dev-endpoint-CreateDevEndpoint)를 호출하여 개발 엔드포인트를 생성하고자 할 때 다음과 같은 호출에 따라 `ExtraPythonLibsS3Path` 파라미터의 라이브러리까지 하나 이상의 전체 경로를 지정할 수 있습니다. ``` dep = glue.create_dev_endpoint( EndpointName="testDevEndpoint", RoleArn="arn:aws:iam::123456789012", SecurityGroupIds="sg-7f5ad1ff", SubnetId="subnet-c12fdba4", PublicKey="ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCtp04H/y...", NumberOfNodes=3, ExtraPythonLibsS3Path="s3://bucket/prefix/lib_A.zip,s3://bucket_B/prefix/lib_X.zip") ``` 개발 엔드포인트를 업데이트할 때 [DevEndpointCustomLibraries](aws-glue-api-dev-endpoint.md#aws-glue-api-dev-endpoint-DevEndpointCustomLibraries) 객체를 사용하고 [UpdateDevEndpoint(update\$1dev\$1endpoint)](aws-glue-api-dev-endpoint.md#aws-glue-api-dev-endpoint-UpdateDevEndpoint)를 호출할 때 `UpdateEtlLibraries ` 파라미터를 `True`로 설정하여 로드하는 라이브러리를 업데이트할 수도 있습니다. ## Job 혹은 JobRun에서 Python 라이브러리 사용 콘솔에서 새로운 작업을 생성하고자 할 경우, [**스크립트 라이브러리 및 작업 파라미터(선택 사항)(Script Libraries and job parameters (optional))**]를 선택하고 개발 엔드포인트를 생성할 때와 동일한 방식으로 전체 Amazon S3 라이브러리 경로를 입력하여 라이브러리 .zip 파일을 하나 이상 지정할 수 있습니다. ``` s3://bucket/prefix/lib_A.zip,s3://bucket_B/prefix/lib_X.zip ``` [CreateJob(create\$1job)](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-CreateJob)를 호출한다면 다음과 같은 `--extra-py-files` 기본 파라미터를 사용하여 기본 라이브러리까지 하나 이상의 전체 경로를 지정할 수 있습니다. ``` job = glue.create_job(Name='sampleJob', Role='Glue_DefaultRole', Command={'Name': 'glueetl', 'ScriptLocation': 's3://my_script_bucket/scripts/my_etl_script.py'}, DefaultArguments={'--extra-py-files': 's3://bucket/prefix/lib_A.zip,s3://bucket_B/prefix/lib_X.zip'}) ``` 그런 다음 JobRun을 시작할 경우, 다른 것으로 기본 라이브러리 설정을 재정의할 수 있습니다. ``` runId = glue.start_job_run(JobName='sampleJob', Arguments={'--extra-py-files': 's3://bucket/prefix/lib_B.zip'}) ``` ## Python 종속성 사전 분석 AWS Glue에 배포하기 전에 잠재적 종속성 문제를 사전에 식별하기 위해 종속성 분석 도구를 사용하여 대상 AWS Glue 환경에 맞춰 Python 패키지를 검증할 수 있습니다. AWS에서는 AWS Glue 환경에 특별히 설계된 오픈 소스 Python 종속성 분석기 도구를 제공합니다. 이 도구는 AWS Glue 샘플 리포지토리에서 사용할 수 있고 배포 전에 로컬에서 종속성을 검증하는 데 사용할 수 있습니다. 이 분석을 통해 종속성에서 일관적인 프로덕션 배포를 위해 모든 라이브러리 버전을 고정시키는 권장 관행을 따를 수 있습니다. 자세한 내용은 도구의 [README](https://github.com/aws-samples/aws-glue-samples/tree/master/utilities/glue_python_dependency_analyzer)를 참조하세요. ### AWS Glue Dependency Analyzer 사용 AWS Glue Python Dependency Analyzer는 대상 AWS Glue 환경과 일치하는 플랫폼별 제약 조건으로 pip 설치를 시뮬레이션하여 고정되지 않은 종속성과 버전 충돌을 식별하는 데 도움이 됩니다. ``` # Analyze a single Glue job python glue_dependency_analyzer.py -j my-glue-job # Analyze multiple jobs with specific AWS configuration python glue_dependency_analyzer.py -j job1 -j job2 --aws-profile production --aws-region us-west-2 ``` 도구는 다음과 같은 경우에 플래그를 지정합니다. + 작업 실행 간에 다른 버전이 설치될 수 있는 고정되지 않은 종속성 + 패키지 간 버전 충돌 + 대상 AWS Glue 환경에 종속성을 사용할 수 없음 ## Amazon Q Developer를 사용하여 Python 종속성으로 인한 작업 실패 분석 및 수정 Amazon Q Developer는 AWS애플리케이션을 이해하고, 구축하고, 확장하고, 운영하는 데 도움을 줄 수 있는 생성형 인공 지능(AI) 기반 대화형 어시스턴트입니다. Amazon Q 시작 안내서의 지침에 따라 다운로드할 수 있습니다. Amazon Q Developer를 사용하여 Python 종속성으로 인한 작업 실패를 분석 및 수정할 수 있습니다. 작업 자리표시자를 Glue 작업 이름으로 바꾸어 다음 프롬프트를 사용하는 것이 좋습니다. ``` I have an AWS Glue job named that has failed due to Python module installation conflicts. Please assist in diagnosing and resolving this issue using the following systematic approach. Proceed once sufficient information is available. Objective: Implement a fix that addresses the root cause module while minimizing disruption to the existing working environment. Step 1: Root Cause Analysis • Retrieve the most recent failed job run ID for the specified Glue job • Extract error logs from CloudWatch Logs using the job run ID as a log stream prefix • Analyze the logs to identify: • The recently added or modified Python module that triggered the dependency conflict • The specific dependency chain causing the installation failure • Version compatibility conflicts between required and existing modules Step 2: Baseline Configuration Identification • Locate the last successful job run ID prior to the dependency failure • Document the Python module versions that were functioning correctly in that baseline run • Establish the compatible version constraints for conflicting dependencies Step 3: Targeted Resolution Implementation • Apply pinning by updating the job's additional_python_modules parameter • Pin only the root cause module and its directly conflicting dependencies to compatible versions, and do not remove python modules unless necessary • Preserve flexibility for non-conflicting modules by avoiding unnecessary version constraints • Deploy the configuration changes with minimal changes to the existing configuration and execute a validation test run. Do not change the Glue versions. Implementation Example: Scenario: Recently added pandas==2.0.0 to additional_python_modules Error: numpy version conflict (pandas 2.0.0 requires numpy>=1.21, but existing job code requires numpy<1.20) Resolution: Update additional_python_modules to "pandas==1.5.3,numpy==1.19.5" Rationale: Use pandas 1.5.3 (compatible with numpy 1.19.5) and pin numpy to last known working version Expected Outcome: Restore job functionality with minimal configuration changes while maintaining system stability. ``` 프롬프트를 통해 Q에 다음을 지시합니다. 1. 최근에 실패한 작업 실행 ID 가져오기 1. 관련 로그 및 세부 정보 찾기 1. 성공적인 작업 실행을 찾아 변경된 Python 패키지 감지 1. 구성 수정 및 다른 테스트 실행 트리거 ## AWS Glue에서 이미 제공되는 Python 모듈 이러한 제공된 모듈의 버전을 변경하려면 새 버전에 `--additional-python-modules` 작업 파라미터를 제공합니다. ------ #### [ AWS Glue version 5.1 ] AWS Glue 버전 5.1은 기본적으로 다음과 같은 Python 모듈을 포함합니다. + aiobotocore==2.25.1 + aiohappyeyeballs==2.6.1 + aiohttp==3.13.2 + aioitertools==0.12.0 + aiosignal==1.4.0 + appdirs==1.4.4 + attrs==25.4.0 + boto3==1.40.61 + botocore==1.40.61 + certifi==2025.10.5 + charset-normalizer==3.4.4 + choreographer==1.2.0 + contourpy==1.3.3 + cycler==0.12.1 + distlib==0.4.0 + filelock==3.20.0 + fonttools==4.60.1 + frozenlist==1.8.0 + fsspec==2025.10.0 + idna==3.11 + iniconfig==2.3.0 + jmespath==1.0.1 + kaleido==1.2.0 + kiwisolver==1.4.9 + logistro==2.0.1 + matplotlib==3.10.7 + multidict==6.7.0 + narwhals==2.10.2 + numpy==2.3.4 + orjson==3.11.4 + packaging==25.0 + pandas==2.3.3 + pillow==12.0.0 + pip==24.0 + platformdirs==4.5.0 + plotly==6.4.0 + pluggy==1.6.0 + propcache==0.4.1 + pyarrow==22.0.0 + Pygments==2.19.2 + pyparsing==3.2.5 + pytest-timeout==2.4.0 + pytest==8.4.2 + python-dateutil==2.9.0.post0 + pytz==2025.2 + requests==2.32.5 + s3fs==2025.10.0 + s3transfer==0.14.0 + seaborn==0.13.2 + setuptools==79.0.1 + simplejson==3.20.2 + six==1.17.0 + tenacity==9.1.2 + typing\$1extensions==4.15.0 + tzdata==2025.2 + urllib3==2.5.0 + uv==0.9.7 + virtualenv==20.35.4 + wrapt==1.17.3 + yarl==1.22.0 ------ #### [ AWS Glue version 5.0 ] AWS Glue 버전 5.0은 기본적으로 다음과 같은 Python 모듈을 포함합니다. + aiobotocore==2.13.1 + aiohappyeyeballs==2.3.5 + aiohttp==3.10.1 + aioitertools==0.11.0 + aiosignal==1.3.1 + appdirs==1.4.4 + attrs==24.2.0 + boto3==1.34.131 + botocore==1.34.131 + certifi==2024.7.4 + charset-normalizer==3.3.2 + contourpy==1.2.1 + cycler==0.12.1 + fonttools==4.53.1 + frozenlist==1.4.1 + fsspec==2024.6.1 + idna==2.10 + jmespath==0.10.0 + kaleido==0.2.1 + kiwisolver==1.4.5 + matplotlib==3.9.0 + multidict==6.0.5 + numpy==1.26.4 + packaging==24.1 + pandas==2.2.2 + pillow==10.4.0 + pip==23.0.1 + plotly==5.23.0 + pyarrow==17.0.0 + pyparsing==3.1.2 + python-dateutil==2.9.0.post0 + pytz==2024.1 + requests==2.32.2 + s3fs==2024.6.1 + s3transfer==0.10.2 + seaborn==0.13.2 + setuptools==59.6.0 + six==1.16.0 + tenacity==9.0.0 + tzdata==2024.1 + urllib3==1.25.10 + virtualenv==20.4.0 + wrapt==1.16.0 + yarl==1.9.4 ------ #### [ AWS Glue version 4.0 ] AWS Glue 버전 4.0은 기본적으로 다음과 같은 Python 모듈을 포함합니다. + aiobotocore==2.4.1 + aiohttp==3.8.3 + aioitertools==0.11.0 + aiosignal==1.3.1 + async-timeout==4.0.2 + asynctest==0.13.0 + attrs==22.2.0 + avro-python3==1.10.2 + boto3==1.24.70 + botocore==1.27.59 + certifi==2021.5.30 + chardet==3.0.4 + charset-normalizer==2.1.1 + click==8.1.3 + cycler==0.10.0 + Cython==0.29.32 + fsspec==2021.8.1 + idna==2.10 + importlib-metadata==5.0.0 + jmespath==0.10.0 + joblib==1.0.1 + kaleido==0.2.1 + kiwisolver==1.4.4 + matplotlib==3.4.3 + mpmath==1.2.1 + multidict==6.0.4 + nltk==3.7 + numpy==1.23.5 + packaging==23.0 + pandas==1.5.1 + patsy==0.5.1 + Pillow==9.4.0 + pip==23.0.1 + plotly==5.16.0 + pmdarima==2.0.1 + ptvsd==4.3.2 + pyarrow==10.0.0 + pydevd==2.5.0 + pyhocon==0.3.58 + PyMySQL==1.0.2 + pyparsing==2.4.7 + python-dateutil==2.8.2 + pytz==2021.1 + PyYAML==6.0.1 + regex==2022.10.31 + requests==2.23.0 + s3fs==2022.11.0 + s3transfer==0.6.0 + scikit-learn==1.1.3 + scipy==1.9.3 + setuptools==49.1.3 + six==1.16.0 + statsmodels==0.13.5 + subprocess32==3.5.4 + sympy==1.8 + tbats==1.1.0 + threadpoolctl==3.1.0 + tqdm==4.64.1 + typing\$1extensions==4.4.0 + urllib3==1.25.11 + wheel==0.37.0 + wrapt==1.14.1 + yarl==1.8.2 + zipp==3.10.0 ------ #### [ AWS Glue version 3.0 ] AWS Glue 버전 3.0은 기본적으로 다음과 같은 Python 모듈을 포함합니다. + aiobotocore==1.4.2 + aiohttp==3.8.3 + aioitertools==0.11.0 + aiosignal==1.3.1 + async-timeout==4.0.2 + asynctest==0.13.0 + attrs==22.2.0 + avro-python3==1.10.2 + boto3==1.18.50 + botocore==1.21.50 + certifi==2021.5.30 + chardet==3.0.4 + charset-normalizer==2.1.1 + click==8.1.3 + cycler==0.10.0 + Cython==0.29.4 + docutils==0.17.1 + enum34==1.1.10 + frozenlist==1.3.3 + fsspec==2021.8.1 + idna==2.10 + importlib-metadata==6.0.0 + jmespath==0.10.0 + joblib==1.0.1 + kiwisolver==1.3.2 + matplotlib==3.4.3 + mpmath==1.2.1 + multidict==6.0.4 + nltk==3.6.3 + numpy==1.19.5 + packaging==23.0 + pandas==1.3.2 + patsy==0.5.1 + Pillow==9.4.0 + pip==23.0 + pmdarima==1.8.2 + ptvsd==4.3.2 + pyarrow==5.0.0 + pydevd==2.5.0 + pyhocon==0.3.58 + PyMySQL==1.0.2 + pyparsing==2.4.7 + python-dateutil==2.8.2 + pytz==2021.1 + PyYAML==5.4.1 + regex==2022.10.31 + requests==2.23.0 + s3fs==2021.8.1 + s3transfer==0.5.0 + scikit-learn==0.24.2 + scipy==1.7.1 + six==1.16.0 + Spark==1.0 + statsmodels==0.12.2 + subprocess32==3.5.4 + sympy==1.8 + tbats==1.1.0 + threadpoolctl==3.1.0 + tqdm==4.64.1 + typing\$1extensions==4.4.0 + urllib3==1.25.11 + wheel==0.37.0 + wrapt==1.14.1 + yarl==1.8.2 + zipp==3.12.0 ------ #### [ AWS Glue version 2.0 ] AWS Glue 버전 2.0은 기본적으로 다음과 같은 Python 모듈을 포함합니다. + avro-python3==1.10.0 + awscli==1.27.60 + boto3==1.12.4 + botocore==1.15.4 + certifi==2019.11.28 + chardet==3.0.4 + click==8.1.3 + colorama==0.4.4 + cycler==0.10.0 + Cython==0.29.15 + docutils==0.15.2 + enum34==1.1.9 + fsspec==0.6.2 + idna==2.9 + importlib-metadata==6.0.0 + jmespath==0.9.4 + joblib==0.14.1 + kiwisolver==1.1.0 + matplotlib==3.1.3 + mpmath==1.1.0 + nltk==3.5 + numpy==1.18.1 + pandas==1.0.1 + patsy==0.5.1 + pmdarima==1.5.3 + ptvsd==4.3.2 + pyarrow==0.16.0 + pyasn1==0.4.8 + pydevd==1.9.0 + pyhocon==0.3.54 + PyMySQL==0.9.3 + pyparsing==2.4.6 + python-dateutil==2.8.1 + pytz==2019.3 + PyYAML==5.3.1 + regex==2022.10.31 + requests==2.23.0 + rsa==4.7.2 + s3fs==0.4.0 + s3transfer==0.3.3 + scikit-learn==0.22.1 + scipy==1.4.1 + setuptools==45.2.0 + six==1.14.0 + Spark==1.0 + statsmodels==0.11.1 + subprocess32==3.5.4 + sympy==1.5.1 + tbats==1.0.9 + tqdm==4.64.1 + typing-extensions==4.4.0 + urllib3==1.25.8 + wheel==0.35.1 + zipp==3.12.0 ------ ## 부록 A: 휠 ZIP 아티팩트 생성 휠 ZIP 아티팩트를 생성하는 방법을 예제로 보여줍니다. 표시된 예제에서는 패키지 `cryptography` 및 `scipy`를 휠 ZIP 아티팩트에 다운로드하고 휠 ZIP을 Amazon S3 위치에 복사합니다. 1. 명령을 실행하여 Glue의 환경과 유사한 Amazon Linux 환경에서 휠 ZIP을 생성해야 합니다. [부록 B: AWS Glue 환경 세부 정보](#glue-python-libraries-environment-details)을(를) 참조하세요. Glue 5.1은 Python 버전 3.11과 함께 AL2023을 사용합니다. 이 환경을 구축할 Dockerfile을 생성합니다. ``` FROM --platform=linux/amd64 public.ecr.aws/amazonlinux/amazonlinux:2023-minimal # Install Python 3.11, pip, and zip utility RUN dnf install -y python3.11 pip zip && \ dnf clean all WORKDIR /build ``` 1. requirements.txt 파일 생성 ``` cryptography scipy ``` 1. Docker 컨테이너 빌드 및 가동 ``` # Build docker image docker build --platform linux/amd64 -t glue-wheel-builder . # Spin up container docker run --platform linux/amd64 -v $(pwd)/requirements.txt:/input/requirements.txt:ro -v $(pwd):/output -it glue-wheel-builder bash ``` 1. 도커 이미지에서 다음 명령 실행 ``` # Create a directory for the wheels mkdir wheels # Copy requirements.txt into wheels directory cp /input/requirements.txt wheels/ # Download the wheels with the correct platform and Python version pip3 download \ -r wheels/requirements.txt \ --dest wheels/ \ --platform manylinux2014_x86_64 \ --python-version 311 \ --only-binary=:all: # Package the wheels into a zip archive with the .gluewheels.zip suffix zip -r mylibraries-1.0.0.gluewheels.zip wheels/ # Copy zip to output cp mylibraries-1.0.0.gluewheels.zip /output/ # Exit the container exit ``` 1. 휠 ZIP을 Amazon S3 위치에 업로드 ``` aws s3 cp mylibraries-1.0.0.gluewheels.zip s3://amzn-s3-demo-bucket/example-prefix/ ``` 1. 선택적 정리 ``` rm mylibraries-1.0.0.gluewheels.zip rm Dockerfile rm requirements.txt ``` 1. 다음 작업 인수를 사용하여 Glue 작업을 실행합니다. ``` --additional-python-modules s3://amzn-s3-demo-bucket/example-prefix/mylibraries-1.0.0.gluewheels.zip --python-modules-installer-option --no-index ``` ## 부록 B: AWS Glue 환경 세부 정보 **Glue 버전 호환성 및 설치 방법** | AWS Glue 버전 | Python 버전 | 기본 이미지 | glibc 버전 | 호환되는 플랫폼 태그 | | --- | --- | --- | --- | --- | | 5.1 | 3.11 | [Amazon Linux 2023(AL2023)](https://aws.amazon.com/linux/amazon-linux-2023/) | 2.34 | manylinux\$12\$134\$1x86\$164 manylinux\$12\$128\$1x86\$164 manylinux2014\$1x86\$164 | | 5.0 | 3.11 | [Amazon Linux 2023(AL2023)](https://aws.amazon.com/linux/amazon-linux-2023/) | 2.34 | manylinux\$12\$134\$1x86\$164 manylinux\$12\$128\$1x86\$164 manylinux2014\$1x86\$164 | | 4.0 | 3.10 | [Amazon Linux 2(AL2)](https://aws.amazon.com/amazon-linux-2/) | 2.26 | manylinux2014\$1x86\$164 | | 3.0 | 3.7 | [Amazon Linux 2(AL2)](https://aws.amazon.com/amazon-linux-2/) | 2.26 | manylinux2014\$1x86\$164 | | 2.0 | 3.7 | [Amazon Linux AMI(AL1)](https://aws.amazon.com/amazon-linux-ami/) | 2.17 | manylinux2014\$1x86\$164 | [AWS 공동 책임 모델](https://aws.amazon.com/compliance/shared-responsibility-model/)에 따라 AWS Glue ETL 작업에 사용하는 추가 Python 모듈, 라이브러리 및 해당 종속성을 관리해야 합니다. 여기에는 업데이트 및 보안 패치 적용이 포함됩니다. AWS Glue에서는 작업 환경의 네이티브 코드 컴파일을 지원하지 않습니다. 하지만 AWS Glue 작업은 Amazon 관리형 Linux 환경 내에서 실행됩니다. Python wheel 파일을 통해 컴파일된 형식으로 네이티브 종속성을 제공할 수 있습니다. AWS Glue 버전 호환성 세부 정보는 위에 있는 표를 참조하세요. **중요** 호환되지 않는 종속성을 사용하는 경우, 특히 대상 환경의 아키텍처 및 시스템 라이브러리와 일치해야 하는 네이티브 확장이 있는 라이브러리에서 런타임 문제가 발생할 수 있습니다. 각 AWS Glue 버전은 라이브러리 및 시스템 구성이 사전 설치된 특정 Python 버전에서 실행됩니다. # AWS Glue Python 코드 샘플 + [코드 예: 데이터 조인 및 관계화](aws-glue-programming-python-samples-legislators.md) + [코드 예: ResolveChoice, Lambda, 및 ApplyMapping을 사용한 데이터 준비](aws-glue-programming-python-samples-medicaid.md) # 코드 예: 데이터 조인 및 관계화 이 예제에서는 [http://everypolitician.org/](http://everypolitician.org/)에서 Amazon Simple Storage Service(Amazon S3)(`s3://awsglue-datasets/examples/us-legislators/all`)의 `sample-dataset` 버킷으로 다운로드한 데이터 집합을 사용합니다. 데이터 세트에는 미국 입법 기관과 미 상원 및 하원에서 확보한 의석에 대한 JSON 형식의 데이터가 포함되어 있으며, 이 자습서의 용도에 맞게 퍼블릭 Amazon S3 버킷에서 사용할 수 있도록 데이터 세트가 약간 수정되었습니다. 이 예제의 소스 코드는 GitHub 웹 사이트의 [AWS Glue 샘플 리포지토리](https://github.com/awslabs/aws-glue-samples)에 있는 `join_and_relationalize.py` 파일에서 찾을 수 있습니다. 이 데이터를 사용하여 이 자습서에서는 다음을 수행하는 방법을 보여줍니다. + AWS Glue 크롤러를 사용하여 퍼블릭 Amazon S3 버킷에 저장된 객체를 분류하고 AWS Glue Data Catalog에 객체의 스키마를 저장합니다. + 크롤의 결과인 테이블 메타데이터 및 스키마를 검토합니다. + Data Catalog의 메타데이터를 사용하여 Python 추출, 변환, 로드(ETL) 스크립트를 작성하고 다음을 실행합니다. + 하나의 데이터 테이블로 다른 원본 파일의 데이터를 모읍니다 (즉, 데이터를 비정규화합니다). + 제정자 유형에 따라 모아진 테이블을 개별 테이블로 필터링합니다. + 다음 분석을 위해 결과 데이터를 Apache Parquet 파일을 작성합니다. AWS에서 실행하는 중에 Python 또는 PySpark 스크립트를 디버깅하는 기본적인 방법은 [AWS Glue Studio에서 노트북](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html)을 사용하는 것입니다. ## 1단계: Amazon S3 버킷에서 데이터 크롤 1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)에서 AWS Glue 콘솔을 엽니다. 1. [크롤러 구성](define-crawler.md)의 단계에 따라 AWS Glue Data Catalog에서 `legislators`라는 데이터베이스로 `s3://awsglue-datasets/examples/us-legislators/all` 데이터 집합을 크롤링할 수 있는 새 크롤러를 만듭니다. 이 예제 데이터는 이 퍼블릭 Amazon S3 버킷에 이미 존재합니다. 1. 새로운 크롤러를 실행한 다음 `legislators` 데이터베이스를 확인합니다. 크롤러는 다음 메타데이터 테이블을 생성합니다. + `persons_json` + `memberships_json` + `organizations_json` + `events_json` + `areas_json` + `countries_r_json` 제정자와 제정자 기록을 포함한 테이블 반정규화된 컬렉션입니다. ## 2단계: 개발 엔드포인트 노트북에 표준 문안 스크립트 추가 다음 표준 문안 스크립트를 개발 엔드포인트 노트북에 복사하고 필요한 AWS Glue 라이브러리로 들여와 단일 `GlueContext`를 설정합니다. ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job glueContext = GlueContext(SparkContext.getOrCreate()) ``` ## 3단계: Data Catalog의 데이터에서 스키마 검토 다음으로 AWS Glue Data Catalog에서 검사 DynamicFrame을 쉽게 생성하고 데이터의 스키마를 검사할 수 있습니다. 예를 들어, `persons_json` 테이블의 스키마를 보고 노트북에 다음을 추가합니다. ``` persons = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="persons_json") print "Count: ", persons.count() persons.printSchema() ``` 프린트 호출에 따른 출력값입니다. ``` Count: 1961 root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- note: string | | |-- name: string | | |-- lang: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string ``` 테이블에 있는 각자는 미국 의회 기관의 멤버입니다. `memberships_json` 테이블의 스키마를 보고 다음을 입력합니다. ``` memberships = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="memberships_json") print "Count: ", memberships.count() memberships.printSchema() ``` 출력값은 다음과 같습니다. ``` Count: 10439 root |-- area_id: string |-- on_behalf_of_id: string |-- organization_id: string |-- role: string |-- person_id: string |-- legislative_period_id: string |-- start_date: string |-- end_date: string ``` `organizations`는 정당이고 미국의 상원과 하원인 의회 양원입니다. `organizations_json` 테이블의 스키마를 보고 다음을 입력합니다. ``` orgs = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="organizations_json") print "Count: ", orgs.count() orgs.printSchema() ``` 출력값은 다음과 같습니다. ``` Count: 13 root |-- classification: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- id: string |-- name: string |-- seats: int |-- type: string ``` ## 4단계: 데이터 필터링 원하는 필드만 남기고 `id`를 `org_id`로 이름을 바꿉니다. 데이터셋은 전체를 볼 수 있을만큼 작습니다. `toDF()`는 `DynamicFrame`를 Apache Spark `DataFrame`로 변환하기 때문에 Apache Spark SQL에 이미 존재한 변환을 적용할 수 있습니다. ``` orgs = orgs.drop_fields(['other_names', 'identifiers']).rename_field( 'id', 'org_id').rename_field( 'name', 'org_name') orgs.toDF().show() ``` 다음은 출력값을 보여줍니다. ``` +--------------+--------------------+--------------------+--------------------+-----+-----------+--------------------+ |classification| org_id| org_name| links|seats| type| image| +--------------+--------------------+--------------------+--------------------+-----+-----------+--------------------+ | party| party/al| AL| null| null| null| null| | party| party/democrat| Democrat|[[website,http://...| null| null|https://upload.wi...| | party|party/democrat-li...| Democrat-Liberal|[[website,http://...| null| null| null| | legislature|d56acebe-8fdc-47b...|House of Represen...| null| 435|lower house| null| | party| party/independent| Independent| null| null| null| null| | party|party/new_progres...| New Progressive|[[website,http://...| null| null|https://upload.wi...| | party|party/popular_dem...| Popular Democrat|[[website,http://...| null| null| null| | party| party/republican| Republican|[[website,http://...| null| null|https://upload.wi...| | party|party/republican-...|Republican-Conser...|[[website,http://...| null| null| null| | party| party/democrat| Democrat|[[website,http://...| null| null|https://upload.wi...| | party| party/independent| Independent| null| null| null| null| | party| party/republican| Republican|[[website,http://...| null| null|https://upload.wi...| | legislature|8fa6c3d2-71dc-478...| Senate| null| 100|upper house| null| +--------------+--------------------+--------------------+--------------------+-----+-----------+--------------------+ ``` `memberships`에 나타나는 `organizations`를 보려면 다음을 입력합니다. ``` memberships.select_fields(['organization_id']).toDF().distinct().show() ``` 다음은 출력값을 보여줍니다. ``` +--------------------+ | organization_id| +--------------------+ |d56acebe-8fdc-47b...| |8fa6c3d2-71dc-478...| +--------------------+ ``` ## 5단계: 데이터 조인 이제 AWS Glue를 사용하여 이런 관계형 테이블을 조인하고 제정자 `memberships`의 전체 기록 테이블과 제정자에 대응하는 `organizations`을 생성합니다. 1. 우선, `persons`와 `memberships`를 `id`와 `person_id`로 조인합니다. 1. 다음으로 `org_id` 및 `organization_id`에서 `orgs`와 결과를 조인합니다. 1. 그 후, 중복 필드, `person_id` 및 `org_id`을 드롭합니다. 이 모든 작업을 하나 줄의 (확장된) 코드로 실행할 수 있습니다. ``` l_history = Join.apply(orgs, Join.apply(persons, memberships, 'id', 'person_id'), 'org_id', 'organization_id').drop_fields(['person_id', 'org_id']) print "Count: ", l_history.count() l_history.printSchema() ``` 출력값은 다음과 같습니다. ``` Count: 10439 root |-- role: string |-- seats: int |-- org_name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- type: string |-- sort_name: string |-- area_id: string |-- images: array | |-- element: struct | | |-- url: string |-- on_behalf_of_id: string |-- other_names: array | |-- element: struct | | |-- note: string | | |-- name: string | | |-- lang: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- name: string |-- birth_date: string |-- organization_id: string |-- gender: string |-- classification: string |-- death_date: string |-- legislative_period_id: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- image: string |-- given_name: string |-- family_name: string |-- id: string |-- start_date: string |-- end_date: string ``` 이제, 분석을 위한 최종 테이블이 있습니다. AWS Glue, Amazon Athena 또는 Amazon Redshift Spectrum에서 SQL을 실행할 수 있는 압축되고 효율적인 분석 형식(즉, Parquet)으로 작성할 수 있습니다. 다음 호출은 여러 파일의 테이블을 작성하여 나중에 분석을 할 때 빠른 병렬 판독을 지원합니다. ``` glueContext.write_dynamic_frame.from_options(frame = l_history, connection_type = "s3", connection_options = {"path": "s3://glue-sample-target/output-dir/legislator_history"}, format = "parquet") ``` 하나의 파일에 기록 데이터 모두를 넣으면 데이터 프레임으로 변환하고 다시 분할하며 작성할 수 있습니다. ``` s_history = l_history.toDF().repartition(1) s_history.write.parquet('s3://glue-sample-target/output-dir/legislator_single') ``` 상원과 하원으로 나누고자 한다면 ``` l_history.toDF().write.parquet('s3://glue-sample-target/output-dir/legislator_part', partitionBy=['org_name']) ``` ## 6단계: 관계형 데이터베이스를 위한 데이터 변환 AWS Glue를 사용하면 반정형 데이터가 포함된, Amazon Redshift와 같은 관계형 데이터베이스에도 데이터를 쉽게 쓸 수 있습니다. 프레임의 객체가 아무리 복잡하더라도 `DynamicFrames`를 평면화하는 변환 `relationalize`를 제공합니다. 이 예제에 `l_history` `DynamicFrame`를 사용하여 루트 테이블의 이름(`hist_root`)과 임시 작업 경로를 `relationalize`로 넘깁니다. 이렇게 하면 `DynamicFrameCollection`가 반환됩니다. 컬렉션의 `DynamicFrames`의 이름을 열거할 수 있습니다. ``` dfc = l_history.relationalize("hist_root", "s3://glue-sample-target/temp-dir/") dfc.keys() ``` 다음은 이 `keys` 호출의 출력입니다. ``` [u'hist_root', u'hist_root_contact_details', u'hist_root_links', u'hist_root_other_names', u'hist_root_images', u'hist_root_identifiers'] ``` `Relationalize`는 `DynamicFrame`의 각 객체의 기록을 포함한 루트 테이블과 배열의 보조 테이블을 포함한 6 개의 새로운 테이블로 기록 테이블을 나눕니다. 관계형 데이터베이스에서 처리한 배열은 보통 차선책일 수 있습니다. 특히 배열이 커지면 그렇습니다. 배열을 다른 테이블로 나누면 쿼리 과정이 빨라집니다. 이제, `contact_details`를 보고 나누는 과정에 대해 알아봅니다. ``` l_history.select_fields('contact_details').printSchema() dfc.select('hist_root_contact_details').toDF().where("id = 10 or id = 75").orderBy(['id','index']).show() ``` 다음은 이 `show` 호출의 출력입니다. ``` root |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 10| 0| fax| | | 10| 1| | 202-225-1314| | 10| 2| phone| | | 10| 3| | 202-225-3772| | 10| 4| twitter| | | 10| 5| | MikeRossUpdates| | 75| 0| fax| | | 75| 1| | 202-225-7856| | 75| 2| phone| | | 75| 3| | 202-225-2711| | 75| 4| twitter| | | 75| 5| | SenCapito| +---+-----+------------------------+-------------------------+ ``` `contact_details` 필드는 기존 `DynamicFrame`의 구조 배열이었습니다. 이 배열에 있는 각 요소가 `index`에 따라 보조 테이블의 별도 행입니다. 여기서 `id`는 `contact_details` 키가 있는 `hist_root` 테이블의 외래 키입니다. ``` dfc.select('hist_root').toDF().where( "contact_details = 10 or contact_details = 75").select( ['id', 'given_name', 'family_name', 'contact_details']).show() ``` 출력값은 다음과 같습니다. ``` +--------------------+----------+-----------+---------------+ | id|given_name|family_name|contact_details| +--------------------+----------+-----------+---------------+ |f4fc30ee-7b42-432...| Mike| Ross| 10| |e3c60f34-7d1b-4c0...| Shelley| Capito| 75| +--------------------+----------+-----------+---------------+ ``` 이 명령어에는 `toDF()`와 `where` 순으로 선택하여 보고자 하는 열을 필터링합니다. 따라서 보조 테이블과 함께 `hist_root`을 조인하여 다음과 같은 작업을 수행할 수 있습니다. + 배열 지원 없이 데이터베이스로 데이터를 로드합니다. + SQL을 사용하여 배열에서 개별 항목을 쿼리합니다. AWS Glue 연결을 사용하여 Amazon Redshift 자격 증명을 안전하게 저장하고 액세스합니다. 자체 연결을 만드는 방법에 대한 자세한 내용은 [데이터에 연결](glue-connections.md)을 참조하십시오. 이제 `DynamicFrames`를 차례로 순환하여 데이터를 연결에 쓸 준비가 되었습니다. ``` for df_name in dfc.keys(): m_df = dfc.select(df_name) print "Writing to table: ", df_name glueContext.write_dynamic_frame.from_jdbc_conf(frame = m_df, connection settings here) ``` 연결 설정은 관계형 데이터베이스 유형에 따라 달라집니다. + Amazon Redshift에 쓰는 방법에 대한 지침은 [Redshift 연결](aws-glue-programming-etl-connect-redshift-home.md) 섹션을 참조하세요. + 다른 데이터베이스의 경우 [AWS Glue for Spark에서 ETL에 대한 연결 유형 및 옵션](aws-glue-programming-etl-connect.md) 섹션을 참조하세요. ## 결론 전체적으로 AWS Glue는 유연성이 뛰어납니다. 보통 며칠을 걸려 작성해야 가능한 이 작업을 단 몇 줄의 코드로 얻을 수 있습니다. GitHub의 [AWS Glue 샘플](https://github.com/awslabs/aws-glue-samples)에 있는 Python 파일 `join_and_relationalize.py`에서 전체 소스-대상 ETL 스크립트를 찾을 수 있습니다. # 코드 예: ResolveChoice, Lambda, 및 ApplyMapping을 사용한 데이터 준비 이 예에서 사용된 데이터 집합은 두 [Data.CMS.gov](https://data.cms.gov) 데이터 집합("상위 100개 진단 관련 그룹에 대한 입원 환자 예상 지불 시스템 제공자 요약 - FY2011" 및 "FY2011 입원 환자 비용 데이터")에서 다운로드한 Medicare Provider 지불 데이터로 구성됩니다. 데이터 다운로드 후 데이터 집합을 수정하여 파일 끝에 몇 가지 잘못된 기록을 소개합니다. 이 수정된 파일은 `s3://awsglue-datasets/examples/medicare/Medicare_Hospital_Provider.csv`의 퍼블릭 Amazon S3 버킷에 있습니다. 이 예제에 대한 소스 코드는 [AWS Glue 예제](https://github.com/awslabs/aws-glue-samples) GitHub 리포지토리의 `data_cleaning_and_lambda.py` 파일에서 찾을 수 있습니다. AWS에서 실행하는 중에 Python 또는 PySpark 스크립트를 디버깅하는 기본적인 방법은 [AWS Glue Studio에서 노트북](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html)을 사용하는 것입니다. ## 1단계: Amazon S3 버킷에서 데이터 크롤 1. AWS Management Console에 로그인하여 [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)에서 AWS Glue 콘솔을 엽니다. 1. [크롤러 구성](define-crawler.md)의 절차를 밟고 `s3://awsglue-datasets/examples/medicare/Medicare_Hospital_Provider.csv` 파일을 크롤할 수 있는 새로운 크롤러를 생성하며 그 결과 생성된 메타데이터를 AWS Glue Data Catalog의 `payments`라는 데이터베이스에 둡니다. 1. 새로운 크롤러를 실행한 다음 `payments` 데이터베이스를 확인합니다. 파일의 시작 부분을 읽어 형식과 구분 기호를 확인한 후 크롤러가 데이터베이스에 `medicare`라는 이름의 메타데이터 테이블을 생성했을 것입니다. 새로운 `medicare`의 스키마는 다음과 같습니다. ``` Column name Data type ================================================== drg definition string provider id bigint provider name string provider street address string provider city string provider state string provider zip code bigint hospital referral region description string total discharges bigint average covered charges string average total payments string average medicare payments string ``` ## 2단계: 개발 엔드포인트 노트북에 표준 문안 스크립트 추가 다음 표준 문안 스크립트를 개발 엔드포인트 노트북에 복사하고 필요한 AWS Glue 라이브러리로 들여와 단일 `GlueContext`를 설정합니다. ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job glueContext = GlueContext(SparkContext.getOrCreate()) ``` ## 3단계: 다른 스키마 파싱과 비교 그 다음, Apache Spark `DataFrame`이 인지한 스키마가 AWS Glue 크롤러가 기록한 것과 동일한지 알아봅니다. 이 코드를 실행합니다. ``` medicare = spark.read.format( "com.databricks.spark.csv").option( "header", "true").option( "inferSchema", "true").load( 's3://awsglue-datasets/examples/medicare/Medicare_Hospital_Provider.csv') medicare.printSchema() ``` `printSchema` 호출에 따른 출력값입니다. ``` root |-- DRG Definition: string (nullable = true) |-- Provider Id: string (nullable = true) |-- Provider Name: string (nullable = true) |-- Provider Street Address: string (nullable = true) |-- Provider City: string (nullable = true) |-- Provider State: string (nullable = true) |-- Provider Zip Code: integer (nullable = true) |-- Hospital Referral Region Description: string (nullable = true) |-- Total Discharges : integer (nullable = true) |-- Average Covered Charges : string (nullable = true) |-- Average Total Payments : string (nullable = true) |-- Average Medicare Payments: string (nullable = true) ``` 다음, AWS Glue `DynamicFrame`가 생성한 스키마를 알아봅니다. ``` medicare_dynamicframe = glueContext.create_dynamic_frame.from_catalog( database = "payments", table_name = "medicare") medicare_dynamicframe.printSchema() ``` `printSchema`의 출력값은 다음과 같습니다. ``` root |-- drg definition: string |-- provider id: choice | |-- long | |-- string |-- provider name: string |-- provider street address: string |-- provider city: string |-- provider state: string |-- provider zip code: long |-- hospital referral region description: string |-- total discharges: long |-- average covered charges: string |-- average total payments: string |-- average medicare payments: string ``` `DynamicFrame`는 `provider id`가 `long` 혹은 `string` 유형일 수 있는 스키마를 생성합니다. `DataFrame` 스키마는 `Provider Id`를 `string` 유형으로 목록에 기록하고 Data Catalog는 `provider id`를 `bigint` 유형으로 목록에 기록합니다. 무엇이 정답입니까? 파일의 끝에는 이 열에 있는 `string` 값과 함께 (160,000 기록 중) 두 기록이 있습니다. 이 두 기록은 문제를 보여주기 위한 잘못된 기록입니다. 이런 문제를 설명하기 위해서 AWS Glue `DynamicFrame`는 *선택* 유형의 개념을 도입합니다. 이 경우, `DynamicFrame`는 이 열에 나타나는 `long` 및 `string` 모두를 보여줍니다. AWS Glue 크롤러는 `string` 값을 누락했는데 그 이유는 데이터 2MB 접두사만 고려했기 때문입니다. Apache Spark `DataFrame`는 전체 데이터 세트를 고려했지만 `string`이라는 열에 가장 일반적인 유형을 지정하도록 강요되었습니다. 사실, Spark는 익숙하지 않은 복잡한 유형이나 변수가 있으면 가장 일반적인 케이스를 적용합니다. `provider id` 열을 쿼리하려면 먼저 선택 유형을 선택합니다. `DynamicFrame`의 `resolveChoice` 변환 방법을 사용하여 `cast:long` 옵션으로 `string` 값을 `long` 값으로 변환할 수 있습니다. ``` medicare_res = medicare_dynamicframe.resolveChoice(specs = [('provider id','cast:long')]) medicare_res.printSchema() ``` 이제 `printSchema` 출력값은 다음과 같습니다. ``` root |-- drg definition: string |-- provider id: long |-- provider name: string |-- provider street address: string |-- provider city: string |-- provider state: string |-- provider zip code: long |-- hospital referral region description: string |-- total discharges: long |-- average covered charges: string |-- average total payments: string |-- average medicare payments: string ``` 값이 보낼 수 없는 `string`이면 AWS Glue는 `null`을 삽입합니다. 다른 방법으로 선택 유형을 `struct`으로 변환하는 것인데 두 유형의 값은 유지됩니다. 다음, 이례적인 열을 알아봅니다. ``` medicare_res.toDF().where("'provider id' is NULL").show() ``` 다음을 알아봅니다. ``` +--------------------+-----------+---------------+-----------------------+-------------+--------------+-----------------+------------------------------------+----------------+-----------------------+----------------------+-------------------------+ | drg definition|provider id| provider name|provider street address|provider city|provider state|provider zip code|hospital referral region description|total discharges|average covered charges|average total payments|average medicare payments| +--------------------+-----------+---------------+-----------------------+-------------+--------------+-----------------+------------------------------------+----------------+-----------------------+----------------------+-------------------------+ |948 - SIGNS & SYM...| null| INC| 1050 DIVISION ST| MAUSTON| WI| 53948| WI - Madison| 12| $11961.41| $4619.00| $3775.33| |948 - SIGNS & SYM...| null| INC- ST JOSEPH| 5000 W CHAMBERS ST| MILWAUKEE| WI| 53210| WI - Milwaukee| 14| $10514.28| $5562.50| $4522.78| +--------------------+-----------+---------------+-----------------------+-------------+--------------+-----------------+------------------------------------+----------------+-----------------------+----------------------+-------------------------+ ``` 이제, 오류 기록을 다음과 같이 제거합니다. ``` medicare_dataframe = medicare_res.toDF() medicare_dataframe = medicare_dataframe.where("'provider id' is NOT NULL") ``` ## 4단계: 데이터 매핑 및 Apache Spark Lambda 함수 사용 AWS Glue는 사용자 정의 함수인 Lambda 함수를 직접 지원하지 않습니다. 하지만 항상 `DynamicFrame`와 Apache Spark `DataFrame` 간에 변환하여 `DynamicFrames`의 특별한 기능 외에도 Spark 기능도 활용할 수 있습니다. 그런 다음 결제 정보를 숫자로 변환하여 Amazon Redshift 또는 Amazon Athena와 같은 분석 엔진이 빠르게 수 처리를 할 수 있게 만듭니다. ``` from pyspark.sql.functions import udf from pyspark.sql.types import StringType chop_f = udf(lambda x: x[1:], StringType()) medicare_dataframe = medicare_dataframe.withColumn( "ACC", chop_f( medicare_dataframe["average covered charges"])).withColumn( "ATP", chop_f( medicare_dataframe["average total payments"])).withColumn( "AMP", chop_f( medicare_dataframe["average medicare payments"])) medicare_dataframe.select(['ACC', 'ATP', 'AMP']).show() ``` `show` 호출의 출력값은 다음과 같습니다. ``` +--------+-------+-------+ | ACC| ATP| AMP| +--------+-------+-------+ |32963.07|5777.24|4763.73| |15131.85|5787.57|4976.71| |37560.37|5434.95|4453.79| |13998.28|5417.56|4129.16| |31633.27|5658.33|4851.44| |16920.79|6653.80|5374.14| |11977.13|5834.74|4761.41| |35841.09|8031.12|5858.50| |28523.39|6113.38|5228.40| |75233.38|5541.05|4386.94| |67327.92|5461.57|4493.57| |39607.28|5356.28|4408.20| |22862.23|5374.65|4186.02| |31110.85|5366.23|4376.23| |25411.33|5282.93|4383.73| | 9234.51|5676.55|4509.11| |15895.85|5930.11|3972.85| |19721.16|6192.54|5179.38| |10710.88|4968.00|3898.88| |51343.75|5996.00|4962.45| +--------+-------+-------+ only showing top 20 rows ``` 이것은 아직도 모두 데이터에서 문자열입니다. 강력한 `apply_mapping` 변환 방법을 사용하여 데이터를 드롭, 이름 바꾸기, 중첩할 수 있어 다른 데이터 프로그램 언어 및 시스템이 쉽게 접근할 수 있도록 합니다. ``` from awsglue.dynamicframe import DynamicFrame medicare_tmp_dyf = DynamicFrame.fromDF(medicare_dataframe, glueContext, "nested") medicare_nest_dyf = medicare_tmp_dyf.apply_mapping([('drg definition', 'string', 'drg', 'string'), ('provider id', 'long', 'provider.id', 'long'), ('provider name', 'string', 'provider.name', 'string'), ('provider city', 'string', 'provider.city', 'string'), ('provider state', 'string', 'provider.state', 'string'), ('provider zip code', 'long', 'provider.zip', 'long'), ('hospital referral region description', 'string','rr', 'string'), ('ACC', 'string', 'charges.covered', 'double'), ('ATP', 'string', 'charges.total_pay', 'double'), ('AMP', 'string', 'charges.medicare_pay', 'double')]) medicare_nest_dyf.printSchema() ``` `printSchema` 출력값은 다음과 같습니다. ``` root |-- drg: string |-- provider: struct | |-- id: long | |-- name: string | |-- city: string | |-- state: string | |-- zip: long |-- rr: string |-- charges: struct | |-- covered: double | |-- total_pay: double | |-- medicare_pay: double ``` 데이터를 Spark `DataFrame`으로 되돌리면 현재는 어떻게 생겼는지 볼 수 있습니다. ``` medicare_nest_dyf.toDF().show() ``` 출력값은 다음과 같습니다. ``` +--------------------+--------------------+---------------+--------------------+ | drg| provider| rr| charges| +--------------------+--------------------+---------------+--------------------+ |039 - EXTRACRANIA...|[10001,SOUTHEAST ...| AL - Dothan|[32963.07,5777.24...| |039 - EXTRACRANIA...|[10005,MARSHALL M...|AL - Birmingham|[15131.85,5787.57...| |039 - EXTRACRANIA...|[10006,ELIZA COFF...|AL - Birmingham|[37560.37,5434.95...| |039 - EXTRACRANIA...|[10011,ST VINCENT...|AL - Birmingham|[13998.28,5417.56...| |039 - EXTRACRANIA...|[10016,SHELBY BAP...|AL - Birmingham|[31633.27,5658.33...| |039 - EXTRACRANIA...|[10023,BAPTIST ME...|AL - Montgomery|[16920.79,6653.8,...| |039 - EXTRACRANIA...|[10029,EAST ALABA...|AL - Birmingham|[11977.13,5834.74...| |039 - EXTRACRANIA...|[10033,UNIVERSITY...|AL - Birmingham|[35841.09,8031.12...| |039 - EXTRACRANIA...|[10039,HUNTSVILLE...|AL - Huntsville|[28523.39,6113.38...| |039 - EXTRACRANIA...|[10040,GADSDEN RE...|AL - Birmingham|[75233.38,5541.05...| |039 - EXTRACRANIA...|[10046,RIVERVIEW ...|AL - Birmingham|[67327.92,5461.57...| |039 - EXTRACRANIA...|[10055,FLOWERS HO...| AL - Dothan|[39607.28,5356.28...| |039 - EXTRACRANIA...|[10056,ST VINCENT...|AL - Birmingham|[22862.23,5374.65...| |039 - EXTRACRANIA...|[10078,NORTHEAST ...|AL - Birmingham|[31110.85,5366.23...| |039 - EXTRACRANIA...|[10083,SOUTH BALD...| AL - Mobile|[25411.33,5282.93...| |039 - EXTRACRANIA...|[10085,DECATUR GE...|AL - Huntsville|[9234.51,5676.55,...| |039 - EXTRACRANIA...|[10090,PROVIDENCE...| AL - Mobile|[15895.85,5930.11...| |039 - EXTRACRANIA...|[10092,D C H REGI...|AL - Tuscaloosa|[19721.16,6192.54...| |039 - EXTRACRANIA...|[10100,THOMAS HOS...| AL - Mobile|[10710.88,4968.0,...| |039 - EXTRACRANIA...|[10103,BAPTIST ME...|AL - Birmingham|[51343.75,5996.0,...| +--------------------+--------------------+---------------+--------------------+ only showing top 20 rows ``` ## 5단계: 데이터를 Apache Parquet에 쓰기 AWS Glue는 Apache Parquet과 같은 형식으로 데이터를 쉽게 작성할 수 있어 관계형 데이터베이스가 효과적으로 소비될 수 있습니다. ``` glueContext.write_dynamic_frame.from_options( frame = medicare_nest_dyf, connection_type = "s3", connection_options = {"path": "s3://glue-sample-target/output-dir/medicare_parquet"}, format = "parquet") ``` # AWS Glue PySpark 확장 참조 AWS Glue는 다음 확장 기능을 PySpark Python 언어에 생성합니다. + [`getResolvedOptions`를 사용한 파라미터 액세스](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md) + [PySpark 확장 유형](aws-glue-api-crawler-pyspark-extensions-types.md) + [DynamicFrame 클래스](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md) + [DynamicFrameCollection 클래스](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-collection.md) + [DynamicFrameWriter 클래스](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-writer.md) + [DynamicFrameReader 클래스](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md) + [GlueContext 클래스](aws-glue-api-crawler-pyspark-extensions-glue-context.md) # `getResolvedOptions`를 사용한 파라미터 액세스 AWS Glue `getResolvedOptions(args, options)` 유틸리티 함수는 작업이 실행되면 스크립트로 통과된 인수로 액세스할 수 있도록 도와줍니다. 이 함수를 사용하려면 먼저 `sys` 모듈과 함께 AWS Glue `utils` 모듈에서 가져옵니다. ``` import sys from awsglue.utils import getResolvedOptions ``` **`getResolvedOptions(args, options)`** + `args` - `sys.argv`에 포함된 인수 목록입니다. + `options` - 가져오고자 하는 인수 이름의 Python 배열입니다. **Example JobRun으로 통과된 인수 가져오기** JobRun을 Lambda 함수 내 스크립트에 생성했다고 가정합니다. ``` response = client.start_job_run( JobName = 'my_test_Job', Arguments = { '--day_partition_key': 'partition_0', '--hour_partition_key': 'partition_1', '--day_partition_value': day_partition_value, '--hour_partition_value': hour_partition_value } ) ``` 통과된 인수를 가져오기 위해서는 다음과 같이 `getResolvedOptions` 함수를 사용합니다. ``` import sys from awsglue.utils import getResolvedOptions args = getResolvedOptions(sys.argv, ['JOB_NAME', 'day_partition_key', 'hour_partition_key', 'day_partition_value', 'hour_partition_value']) print "The day-partition key is: ", args['day_partition_key'] print "and the day-partition value is: ", args['day_partition_value'] ``` 각 인수는 두 개의 하이픈으로 시작된 다음 하이픈 없이 스크립트에서 참조되는 것으로 정의됩니다. 인수는 하이픈이 아닌 밑줄만 사용합니다. 인수가 해석되려면 이 규칙을 따라야 합니다. # PySpark 확장 유형 AWS Glue PySpark 확장에 사용된 유형. ## 데이터 유형 다른 AWS Glue 유형의 베이스 클래스. **`__init__(properties={})`** + `properties` - 데이터 유형의 속성(선택 사항)입니다.   **`typeName(cls)`** AWS Glue 유형 클래스(즉, 끝에서 "Type"이 제거된 클래스)의 유형을 반환합니다. + `cls` – `DataType`에서 파생된 AWS Glue 클래스 인스턴스입니다.   `jsonValue( )` 클래스 속성의 데이터 유형을 포함하는 JSON 객체를 반환합니다. ``` { "dataType": typeName, "properties": properties } ``` ## AtomicType 및 단순 파생물 [데이터 유형](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-datatype) 클래스에서 상속되고 확장되며 모든 AWS Glue 원자 데이터 유형의 베이스 클래스로서 역할을 합니다. **`fromJsonValue(cls, json_value)`** JSON 객체의 값으로 클래스 인스턴스를 초기화합니다. + `cls` – 초기화할 AWS Glue 유형 클래스 인스턴스입니다. + `json_value` – JSON 객체에서 키-값 페어를 로드합니다.   다음 유형은 [AtomicType](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-atomictype) 클래스의 단순 파생물입니다. + `BinaryType` – 이진 데이터입니다. + `BooleanType` – 부울 값입니다. + `ByteType` - 바이트 값입니다. + `DateType` - 날짜/시간 값입니다. + `DoubleType` – 부동 소수점 값입니다. + `IntegerType` – 정수 값입니다. + `LongType` - 정수(long) 값입니다. + `NullType` – null 값입니다. + `ShortType` - 정수(short) 값입니다. + `StringType` - 텍스트 문자열입니다. + `TimestampType` – 타임스탬프 값(일반적으로 1/1/1970에서 초 단위)입니다. + `UnknownType` - 식별되지 않은 유형의 값입니다. ## DecimalType(AtomicType) [AtomicType](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-atomictype) 클래스에서 상속받고 확장하여 십진수(이진수 기반 2 숫자와 반대 개념인 십진수로 표현된 수)를 나타냅니다. **`__init__(precision=10, scale=2, properties={})`** + `precision` – 십진수의 단위 수입니다(선택; 기본값이 10). + `scale` – 십진수 오른쪽의 단위 수입니다(선택; 기본값이 2). + `properties` – 십진수 유형의 속성(선택 사항). ## EnumType(AtomicType) [AtomicType](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-atomictype) 클래스에서 상속받고 확장되어 유효한 옵션을 열거합니다. **`__init__(options)`** + `options` – 열거된 옵션 목록입니다. ## 컬렉션 형식 + [ArrayType(DataType)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-arraytype) + [ChoiceType(DataType)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-choicetype) + [MapType(DataType)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-maptype) + [필드(객체)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-field) + [StructType(DataType)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-structtype) + [EntityType(DataType)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-entitytype) ## ArrayType(DataType) **`__init__(elementType=UnknownType(), properties={})`** + `elementType` – 배열의 요소 유형(선택; 기본값은 UnknownType입니다). + `properties` - 배열의 속성입니다(선택 사항). ## ChoiceType(DataType) **`__init__(choices=[], properties={})`** + `choices` - 가능한 선택 항목의 목록입니다(선택 사항). + `properties` - 이러한 선택 항목의 속성입니다(선택 사항).   **`add(new_choice)`** 가능한 선택 목록에 새로운 선택을 추가합니다. + `new_choice` – 가능한 선택 항목 목록에 추가할 선택 항목입니다.   **`merge(new_choices)`** 기존 선택 목록과 새로운 선택 목록을 병합합니다. + `new_choices` – 기존 선택 항목과 병합할 새 선택 항목 목록입니다. ## MapType(DataType) **`__init__(valueType=UnknownType, properties={})`** + `valueType` – 맵 값의 유형(선택; 기본값은 UnknownType입니다). + `properties` - 맵의 속성입니다(선택 사항). ## 필드(객체) [데이터 유형](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-datatype)에서 상속받은 객체에서 필드 객체를 생성합니다. **`__init__(name, dataType, properties={})`** + `name` – 필드에 지정된 이름입니다. + `dataType` - 필드를 생성할 객체입니다. + `properties` - 필드의 속성입니다(선택 사항). ## StructType(DataType) 데이터 구조를 정의합니다 (`struct`). **`__init__(fields=[], properties={})`** + `fields` – 구조에 포함할 `Field` 유형의 필드는 목록입니다(선택 사항). + `properties` - 구조의 속성입니다(선택 사항).   **`add(field)`** + `field` – 구조에 추가할 `Field` 유형의 객체입니다.   **`hasField(field)`** 이 구조가 동일 이름의 필드를 가지고 있다면 `True`를 반환하고 그렇지 않으면 `False`를 반환합니다. + `field` - 필드 이름 혹은 이름이 사용된 `Field` 유형의 객체입니다.   **`getField(field)`** + `field` - 필드 이름 혹은 이름이 사용된 `Field` 유형의 객체입니다. 구조가 동일 이름의 필드를 가지고 있다면 이것은 반환됩니다. ## EntityType(DataType) `__init__(entity, base_type, properties)` 이 클래스는 아직 구현되지 않았습니다. ## 기타 유형 + [DataSource(객체)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-data-source) + [DataSink(객체)](#aws-glue-api-crawler-pyspark-extensions-types-awsglue-data-sink) ## DataSource(객체) **`__init__(j_source, sql_ctx, name)`** + `j_source` - 데이터 원본입니다. + `sql_ctx` - SQL 컨텍스트입니다. + `name` – 데이터 원본 이름입니다.   **`setFormat(format, **options)`** + `format` – 데이터 원본을 설정하기 위한 포맷입니다. + `options` – 데이터 원본을 설정하기 위한 옵션 모음입니다. 형식 옵션에 대한 자세한 내용은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md) 섹션을 참조하세요.   `getFrame()` 데이터 원본을 위한 `DynamicFrame`을 반환합니다. ## DataSink(객체) **`__init__(j_sink, sql_ctx)`** + `j_sink` - 생성할 싱크입니다. + `sql_ctx` – 데이터 싱크를 위한 SQL 컨텍스트입니다.   **`setFormat(format, **options)`** + `format` - 데이터 싱크에 대해 설정할 포맷입니다. + `options` – 데이터 싱크를 설정하기 위한 옵션 모음입니다. 형식 옵션에 대한 자세한 내용은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md) 섹션을 참조하세요.   **`setAccumulableSize(size)`** + `size` – 바이트 단위로 설정할 늘어날 수 있는 사이즈입니다.   **`writeFrame(dynamic_frame, info="")`** + `dynamic_frame` - 작성할 `DynamicFrame`입니다. + `info` - `DynamicFrame`에 대한 정보입니다(선택 사항).   **`write(dynamic_frame_or_dfc, info="")`** `DynamicFrame` 혹은 `DynamicFrameCollection` 작성. + `dynamic_frame_or_dfc` – 작성할 `DynamicFrame` 객체 또는 `DynamicFrameCollection` 객체입니다. + `info`- 작성할 `DynamicFrame` 또는 `DynamicFrames`에 대한 정보입니다(선택 사항). # DynamicFrame 클래스 Apache Spark의 주요 추상화 중 하나는 SparkSQL `DataFrame`이며, R 및 Pandas에서 찾아볼 수 있는 `DataFrame` 구문과 유사합니다. `DataFrame`은 테이블과 비슷한 기능적 스타일(맵/줄임/필터 등) 작업과 SQL 작업(선택, 계획, 집계)을 지원합니다. `DataFrames` 는 광범위하게 사용되는 유용한 것이지만 추출, 변환, 로드(ETL) 작업 시 제한이 있습니다. 무엇보다도 데이터가 로딩되기 전에 스키마를 명시해야 합니다. 첫 번째는 스키마를 추론하고 두 번째는 데이터를 로드하도록 두 개를 데이터에 통과시켜 SparkSQL이 이를 해결합니다. 하지만 이러한 추론은 제한적이며 복잡한 데이터의 현실을 해결해주지 않습니다. 예를 들어, 동일한 필드는 다른 기록에서 다른 유형을 가져야 합니다. 아파치 스파크는 간혹 실행을 포기하고 기존 필드 텍스트를 사용하여 `string`으로써 유형을 보고합니다. 이는 올바르지 않을 수 있고 스키마 차이를 해결할 수 있는 좀 더 확실한 관리법을 알고 싶을 겁니다. 라지 데이터세트의 경우, 추가로 소스 데이터를 통과하는 것이 매우 비쌀 수 있습니다. 이러한 상황을 해결하려면 AWS Glue는 `DynamicFrame`을 도입합니다. `DynamicFrame`는 애초에 스키마가 필요없이 각 기록이 자기 설명적인 것을 제외하고는 `DataFrame`와 비슷합니다. 대신에 AWS Glue는 필요하면 스키마 온더플라이를 계산하고 선택 (혹은 재결합) 유형을 사용하여 스키마 불일치를 확실하게 암호화합니다. 이런 불일치를 해결하여 데이터세트와 고정 스키마가 필요한 데이터 스토어를 호환하게 만들 수 있습니다. 비슷하게, `DynamicRecord`는 `DynamicFrame`내 논리적 기록입니다. 자기 설명적이고 고정 스키마를 준수하지 않은 데이터에 사용될 수 있다는 점을 제외하면 스파크 `DataFrame`의 열과 같습니다. PySpark에서 AWS Glue를 사용하는 경우 일반적으로 독립된 `DynamicRecords`를 조작하지 않습니다. 대신, 해당 `DynamicFrame`을 통해 데이터 세트를 함께 변환합니다. 모든 스키마 불일치를 해결한 후 `DynamicFrames`로 그리고 `DataFrames`에서 변환할 수 있습니다. ## - 생성 - + [\$1\$1init\$1\$1](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-__init__) + [fromDF](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-fromDF) + [toDF](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-toDF) ## \$1\$1init\$1\$1 **`__init__(jdf, glue_ctx, name)`** + `jdf` - Java Virtual Machine(JVM)의 데이터 프레임 참조입니다. + `glue_ctx` – [GlueContext 클래스](aws-glue-api-crawler-pyspark-extensions-glue-context.md) 객체입니다. + `name` - 기본값이 빈 선택적 이름 문자열입니다. ## fromDF **`fromDF(dataframe, glue_ctx, name)`** `DataFrame` 필드를 `DynamicRecord` 필드로 변환하여 `DataFrame`를 `DynamicFrame`로 변환합니다. 새로운 `DynamicFrame`을 반환합니다. `DynamicRecord`는 `DynamicFrame`내 논리적 기록입니다. 자기 설명적이고 고정 스키마를 준수하지 않은 데이터에 사용될 수 있다는 점을 제외하면 스파크 `DataFrame`의 열과 비슷합니다. 이 함수는 `DataFrame`에서 이름이 중복된 열이 이미 해결된 것으로 예상합니다. + `dataframe` - Apache Spark SQL `DataFrame`으로 변환합니다(필수). + `glue_ctx` - 이 변환의 맥락을 명시하는 [GlueContext 클래스](aws-glue-api-crawler-pyspark-extensions-glue-context.md) 객체입니다(필수). + `name` – 결과 `DynamicFrame`의 이름(AWS Glue 3.0부터 선택 사항). ## toDF **`toDF(options)`** `DynamicRecords`를 `DataFrame` 필드로 변환하여 `DynamicFrame`을 Apache Spark `DataFrame`으로 변환합니다. 새로운 `DataFrame`을 반환합니다. `DynamicRecord`는 `DynamicFrame`내 논리적 기록입니다. 자기 설명적이고 고정 스키마를 준수하지 않은 데이터에 사용될 수 있다는 점을 제외하면 스파크 `DataFrame`의 열과 비슷합니다. + `options` - 변환 도중 선택 유형을 확인하는 방법을 지정하는 `ResolveOption` 객체 목록입니다. 이 파라미터는 CSV 구문 분석과 같은 형식 옵션이 아닌 스키마 불일치를 처리하는 데 사용됩니다. CSV 구문 분석 및 기타 형식 옵션의 경우 `toDF` 메서드가 아닌 DynamicFrame을 생성할 때 `from_options` 메서드에 이를 지정합니다. 다음은 CSV 형식 옵션을 처리하는 올바른 방법의 예제입니다. ``` from awsglue.context import GlueContext from awsglue.dynamicframe import DynamicFrame from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) # Correct: Specify format options in from_options csv_dyf = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://my-bucket/path/to/csv/"]}, format="csv", format_options={ "withHeader": True, "separator": ",", "inferSchema": True } ) # Convert to DataFrame (no format options needed here) csv_df = csv_dyf.toDF() ``` `toDF`의 `options` 파라미터는 특히 선택 유형을 확인하는 데 사용됩니다. `Project`와 `Cast` 작업 유형을 선택한 경우 대상 유형을 지정합니다. 예는 다음과 같습니다. ``` >>>toDF([ResolveOption("a.b.c", "KeepAsStruct")]) >>>toDF([ResolveOption("a.b.c", "Project", DoubleType())]) ``` ## - 정보 - + [count](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-count) + [schema](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-schema) + [printSchema](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-printSchema) + [show](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-show) + [repartition](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-repartition) + [coalesce](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-coalesce) ## count `count( )` - 기본 `DataFrame`의 행 수를 반환합니다. ## schema `schema( )` – 이 `DynamicFrame`의 스키마를 반환하거나, 가능하지 않는 경우 기본 `DataFrame`의 스키마를 반환합니다. 이 스키마를 구성하는 `DynamicFrame` 유형에 대한 자세한 내용은 [PySpark 확장 유형](aws-glue-api-crawler-pyspark-extensions-types.md) 섹션을 참조하세요. ## printSchema `printSchema( )` - 기본 `DataFrame`의 스키마를 인쇄합니다. ## show `show(num_rows)` - 기본 `DataFrame`으로부터 지정된 수의 행을 인쇄합니다. ## repartition `repartition(numPartitions)` – `numPartitions` 파티션이 있는 새 `DynamicFrame`을 반환합니다. ## coalesce `coalesce(numPartitions)` – `numPartitions` 파티션이 있는 새 `DynamicFrame`을 반환합니다. ## - 변형 - + [apply\$1mapping](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-apply_mapping) + [drop\$1fields](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-drop_fields) + [필터](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-filter) + [join](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-join) + [map](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-map) + [mergeDynamicFrame](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-merge) + [relationalize](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-relationalize) + [rename\$1field](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-rename_field) + [resolveChoice](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-resolveChoice) + [select\$1fields](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-select_fields) + [spigot](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-spigot) + [split\$1fields](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-split_fields) + [split\$1rows](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-split_rows) + [unbox](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-unbox) + [결합](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-union) + [unnest](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-unnest) + [unnest\$1ddb\$1json](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-unnest_ddb_json) + [write](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-write) ## apply\$1mapping **`apply_mapping(mappings, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** `DynamicFrame`으로 매핑을 선언하고 지정한 필드에 해당 매핑이 적용된 새로운 `DynamicFrame`을 반환합니다. 지정되지 않은 필드는 새 `DynamicFrame` 필드에서 생략됩니다. + `mappings` - 매핑 튜플 목록(필수). 각각 (소스 열, 소스 유형, 대상 열, 대상 유형)으로 구성된 매핑 튜플 목록입니다. 소스 열 이름에 점('`.`')이 있는 경우 백틱('````')으로 묶어야 합니다. 예를 들어 `this.old.name`(문자열)을 `thisNewName`에 매핑하려면 다음 튜플을 사용합니다. ``` ("`this.old.name`", "string", "thisNewName", "string") ``` + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 이 변환에 따른 오류 보고 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생되는 변환 중에 발생하는 오류 수(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. + `totalThreshold` - 프로세스에서 오류가 발생해야 하는 이 변환을 포함하여 최대 발생한 오류 수입니다(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. ### 예: apply\$1maping을 사용하여 필드 이름을 바꾸고 필드 유형을 변경합니다. 다음 코드 예제에서는 `apply_mapping` 메서드를 사용하여 선택한 필드의 이름을 바꾸고 필드 유형을 변경하는 방법을 보여 줍니다. **참고** 이 예제에서 사용되는 데이터 세트에 액세스하려면 [코드 예: 데이터 조인 및 관계화](aws-glue-programming-python-samples-legislators.md) 항목을 참조하고 [1단계: Amazon S3 버킷에서 데이터 크롤](aws-glue-programming-python-samples-legislators.md#aws-glue-programming-python-samples-legislators-crawling)의 지침을 따르세요. ``` # Example: Use apply_mapping to reshape source data into # the desired column names and types as a new DynamicFrame from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Create a DynamicFrame and view its schema persons = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="persons_json" ) print("Schema for the persons DynamicFrame:") persons.printSchema() # Select and rename fields, change field type print("Schema for the persons_mapped DynamicFrame, created with apply_mapping:") persons_mapped = persons.apply_mapping( [ ("family_name", "String", "last_name", "String"), ("name", "String", "first_name", "String"), ("birth_date", "String", "date_of_birth", "Date"), ] ) persons_mapped.printSchema() ``` #### 출력 ``` Schema for the persons DynamicFrame: root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string Schema for the persons_mapped DynamicFrame, created with apply_mapping: root |-- last_name: string |-- first_name: string |-- date_of_birth: date ``` ## drop\$1fields **`drop_fields(paths, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** [FlatMap 클래스](aws-glue-api-crawler-pyspark-transforms-flat-map.md) 변환을 불러들여 `DynamicFrame`에서 필드를 제거합니다. 특정 필드가 드롭된 새로운 `DynamicFrame`을 반환합니다. + `paths` – 문자열 목록입니다. 각각에는 드롭할 필드 노드에 대한 전체 경로가 포함되어 있습니다. 점 표기를 사용하여 중첩된 필드를 지정할 수 있습니다. 예를 들어 `first` 필드가 트리에서 `name` 필드의 자식 필드인 경우 해당 경로에 `"name.first"`를 지정합니다. 필드 노드 이름에 `.` 리터럴이 있는 경우 이름을 백틱(```)으로 묶어야 합니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 이 변환에 따른 오류 보고 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생되는 변환 중에 발생하는 오류 수(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. + `totalThreshold` - 프로세스에서 오류가 발생해야 하는 이 변환을 포함하여 최대 발생한 오류 수입니다(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. ### 예: drop\$1fields를 사용하여 `DynamicFrame`에서 필드를 제거합니다. 이 코드 예제에서는 `drop_fields` 메서드를 사용하여 `DynamicFrame`에서 선택한 최상위 및 중첩 필드를 제거합니다. **예제 데이터 세트** 이 예제에서는 코드의 `EXAMPLE-FRIENDS-DATA` 테이블로 표시되는 다음 데이터 세트를 사용합니다. ``` {"name": "Sally", "age": 23, "location": {"state": "WY", "county": "Fremont"}, "friends": []} {"name": "Varun", "age": 34, "location": {"state": "NE", "county": "Douglas"}, "friends": [{"name": "Arjun", "age": 3}]} {"name": "George", "age": 52, "location": {"state": "NY"}, "friends": [{"name": "Fred"}, {"name": "Amy", "age": 15}]} {"name": "Haruki", "age": 21, "location": {"state": "AK", "county": "Denali"}} {"name": "Sheila", "age": 63, "friends": [{"name": "Nancy", "age": 22}]} ``` **예제 코드** ``` # Example: Use drop_fields to remove top-level and nested fields from a DynamicFrame. # Replace MY-EXAMPLE-DATABASE with your Glue Data Catalog database name. # Replace EXAMPLE-FRIENDS-DATA with your table name. from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Create a DynamicFrame from Glue Data Catalog glue_source_database = "MY-EXAMPLE-DATABASE" glue_source_table = "EXAMPLE-FRIENDS-DATA" friends = glueContext.create_dynamic_frame.from_catalog( database=glue_source_database, table_name=glue_source_table ) print("Schema for friends DynamicFrame before calling drop_fields:") friends.printSchema() # Remove location.county, remove friends.age, remove age friends = friends.drop_fields(paths=["age", "location.county", "friends.age"]) print("Schema for friends DynamicFrame after removing age, county, and friend age:") friends.printSchema() ``` #### 출력 ``` Schema for friends DynamicFrame before calling drop_fields: root |-- name: string |-- age: int |-- location: struct | |-- state: string | |-- county: string |-- friends: array | |-- element: struct | | |-- name: string | | |-- age: int Schema for friends DynamicFrame after removing age, county, and friend age: root |-- name: string |-- location: struct | |-- state: string |-- friends: array | |-- element: struct | | |-- name: string ``` ## 필터 **`filter(f, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 지정된 술어 함수 `f`를 만족하는 `DynamicFrame`이 입력된 `DynamicRecords`에 모두 포함된 새로운 `DynamicFrame`을 반환합니다. + `f` - `DynamicFrame`에 적용하는 조건자 함수입니다. 함수는 `DynamicRecord`를 논리로 받아들이며, `DynamicRecord`가 필터 요구 사항과 맞으면 True을 반환하고 아니면 False를 반환합니다(필수). `DynamicRecord`는 `DynamicFrame`내 논리적 기록입니다. 자기 설명적이고 고정 스키마를 준수하지 않은 데이터에 사용될 수 있다는 점을 제외하면 스파크 `DataFrame`의 열과 비슷합니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 이 변환에 따른 오류 보고 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생되는 변환 중에 발생하는 오류 수(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. + `totalThreshold` - 프로세스에서 오류가 발생해야 하는 이 변환을 포함하여 최대 발생한 오류 수입니다(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. ### 예: 필터를 사용하여 필터링된 필드 선택 가져오기 이 예에서는 `filter` 메서드를 사용하여 다른 사람의 `DynamicFrame` 필드에 대한 필터링된 선택을 포함하는 새 `DynamicFrame` 항목을 만듭니다. `map` 메서드와 같이 `filter`는 함수를 인수로 취하여 원본 `DynamicFrame`의 각 레코드에 적용됩니다. 이 함수는 레코드를 입력으로 받아 부울 값을 반환합니다. 반환 값이 true이면 레코드가 결과 `DynamicFrame`에 포함됩니다. 거짓이면 레코드가 제외됩니다. **참고** 이 예제에서 사용되는 데이터 세트에 액세스하려면 [코드 예: ResolveChoice, Lambda, 및 ApplyMapping을 사용한 데이터 준비](aws-glue-programming-python-samples-medicaid.md) 항목을 참조하고 [1단계: Amazon S3 버킷에서 데이터 크롤](aws-glue-programming-python-samples-medicaid.md#aws-glue-programming-python-samples-medicaid-crawling)의 지침을 따르세요. ``` # Example: Use filter to create a new DynamicFrame # with a filtered selection of records from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Create DynamicFrame from Glue Data Catalog medicare = glueContext.create_dynamic_frame.from_options( "s3", { "paths": [ "s3://awsglue-datasets/examples/medicare/Medicare_Hospital_Provider.csv" ] }, "csv", {"withHeader": True}, ) # Create filtered DynamicFrame with custom lambda # to filter records by Provider State and Provider City sac_or_mon = medicare.filter( f=lambda x: x["Provider State"] in ["CA", "AL"] and x["Provider City"] in ["SACRAMENTO", "MONTGOMERY"] ) # Compare record counts print("Unfiltered record count: ", medicare.count()) print("Filtered record count: ", sac_or_mon.count()) ``` #### 출력 ``` Unfiltered record count: 163065 Filtered record count: 564 ``` ## join **`join(paths1, paths2, frame2, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 다른 `DynamicFrame`로 균등 연결을 실행하고 결과인 `DynamicFrame`을 반환합니다. + `paths1` - 조인할 이 프레임의 키 목록입니다. + `paths2` - 조인할 다른 프레임의 키 목록입니다. + `frame2` - 조인할 다른 `DynamicFrame`입니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 이 변환에 따른 오류 보고 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생되는 변환 중에 발생하는 오류 수(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. + `totalThreshold` - 프로세스에서 오류가 발생해야 하는 이 변환을 포함하여 최대 발생한 오류 수입니다(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. ### 예: 조인을 사용하여 `DynamicFrames` 결합 이 예제에서는 `join` 메서드를 사용하여 3개의 `DynamicFrames`에서 조인을 수행합니다. AWS Glue는 사용자가 제공한 필드 키를 기반으로 조인을 수행합니다. 결과 `DynamicFrame`에는 지정된 키가 일치하는 두 원본 프레임의 행이 포함됩니다. `join` 변환은 모든 필드를 그대로 유지한다는 점에 유의하세요. 즉, 일치하도록 지정하는 필드가 중복되고 동일한 키가 포함된 경우에도 결과 DynamicFrame에 나타납니다. 이 예에서는 `drop_fields`를 사용하여 조인 후 이러한 중복 키를 제거합니다. **참고** 이 예제에서 사용되는 데이터 세트에 액세스하려면 [코드 예: 데이터 조인 및 관계화](aws-glue-programming-python-samples-legislators.md) 항목을 참조하고 [1단계: Amazon S3 버킷에서 데이터 크롤](aws-glue-programming-python-samples-legislators.md#aws-glue-programming-python-samples-legislators-crawling)의 지침을 따르세요. ``` # Example: Use join to combine data from three DynamicFrames from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Load DynamicFrames from Glue Data Catalog persons = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="persons_json" ) memberships = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="memberships_json" ) orgs = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="organizations_json" ) print("Schema for the persons DynamicFrame:") persons.printSchema() print("Schema for the memberships DynamicFrame:") memberships.printSchema() print("Schema for the orgs DynamicFrame:") orgs.printSchema() # Join persons and memberships by ID persons_memberships = persons.join( paths1=["id"], paths2=["person_id"], frame2=memberships ) # Rename and drop fields from orgs # to prevent field name collisions with persons_memberships orgs = ( orgs.drop_fields(["other_names", "identifiers"]) .rename_field("id", "org_id") .rename_field("name", "org_name") ) # Create final join of all three DynamicFrames legislators_combined = orgs.join( paths1=["org_id"], paths2=["organization_id"], frame2=persons_memberships ).drop_fields(["person_id", "org_id"]) # Inspect the schema for the joined data print("Schema for the new legislators_combined DynamicFrame:") legislators_combined.printSchema() ``` #### 출력 ``` Schema for the persons DynamicFrame: root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string Schema for the memberships DynamicFrame: root |-- area_id: string |-- on_behalf_of_id: string |-- organization_id: string |-- role: string |-- person_id: string |-- legislative_period_id: string |-- start_date: string |-- end_date: string Schema for the orgs DynamicFrame: root |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- id: string |-- classification: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- image: string |-- seats: int |-- type: string Schema for the new legislators_combined DynamicFrame: root |-- role: string |-- seats: int |-- org_name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- type: string |-- sort_name: string |-- area_id: string |-- images: array | |-- element: struct | | |-- url: string |-- on_behalf_of_id: string |-- other_names: array | |-- element: struct | | |-- note: string | | |-- name: string | | |-- lang: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- name: string |-- birth_date: string |-- organization_id: string |-- gender: string |-- classification: string |-- legislative_period_id: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- image: string |-- given_name: string |-- start_date: string |-- family_name: string |-- id: string |-- death_date: string |-- end_date: string ``` ## map **`map(f, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 특정 매핑 함수를 기존 `DynamicFrame`의 모든 기록에 적용한 결과인 새로운 `DynamicFrame`을 반환합니다. + `f` - `DynamicFrame`의 모든 레코드에 적용하는 매핑 함수입니다. 함수는 `DynamicRecord`를 인수로 받아들이고 새로운 `DynamicRecord`를 반환합니다(필수). `DynamicRecord`는 `DynamicFrame`내 논리적 기록입니다. 자기 설명적이고 고정 스키마를 준수하지 않은 데이터에 사용될 수 있다는 점을 제외하면 Apache Spark `DataFrame`의 열과 비슷합니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 변환에 따른 오류 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다(선택 사항). 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다(선택 사항). 기본값은 0입니다. ### 예: map을 사용하여 `DynamicFrame`의 모든 레코드에 함수를 적용합니다. 이 예제에서는 `map` 메서드를 사용하여 `DynamicFrame`의 모든 레코드에 기능을 적용하는 방법을 보여 줍니다. 특히 이 예에서는 여러 주소 필드를 단일 `struct` 유형으로 병합하기 위해 각 레코드에 `MergeAddress`라는 함수를 적용합니다. **참고** 이 예제에서 사용되는 데이터 세트에 액세스하려면 [코드 예: ResolveChoice, Lambda, 및 ApplyMapping을 사용한 데이터 준비](aws-glue-programming-python-samples-medicaid.md) 항목을 참조하고 [1단계: Amazon S3 버킷에서 데이터 크롤](aws-glue-programming-python-samples-medicaid.md#aws-glue-programming-python-samples-medicaid-crawling)의 지침을 따르세요. ``` # Example: Use map to combine fields in all records # of a DynamicFrame from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Create a DynamicFrame and view its schema medicare = glueContext.create_dynamic_frame.from_options( "s3", {"paths": ["s3://awsglue-datasets/examples/medicare/Medicare_Hospital_Provider.csv"]}, "csv", {"withHeader": True}) print("Schema for medicare DynamicFrame:") medicare.printSchema() # Define a function to supply to the map transform # that merges address fields into a single field def MergeAddress(rec): rec["Address"] = {} rec["Address"]["Street"] = rec["Provider Street Address"] rec["Address"]["City"] = rec["Provider City"] rec["Address"]["State"] = rec["Provider State"] rec["Address"]["Zip.Code"] = rec["Provider Zip Code"] rec["Address"]["Array"] = [rec["Provider Street Address"], rec["Provider City"], rec["Provider State"], rec["Provider Zip Code"]] del rec["Provider Street Address"] del rec["Provider City"] del rec["Provider State"] del rec["Provider Zip Code"] return rec # Use map to apply MergeAddress to every record mapped_medicare = medicare.map(f = MergeAddress) print("Schema for mapped_medicare DynamicFrame:") mapped_medicare.printSchema() ``` #### 출력 ``` Schema for medicare DynamicFrame: root |-- DRG Definition: string |-- Provider Id: string |-- Provider Name: string |-- Provider Street Address: string |-- Provider City: string |-- Provider State: string |-- Provider Zip Code: string |-- Hospital Referral Region Description: string |-- Total Discharges: string |-- Average Covered Charges: string |-- Average Total Payments: string |-- Average Medicare Payments: string Schema for mapped_medicare DynamicFrame: root |-- Average Total Payments: string |-- Average Covered Charges: string |-- DRG Definition: string |-- Average Medicare Payments: string |-- Hospital Referral Region Description: string |-- Address: struct | |-- Zip.Code: string | |-- City: string | |-- Array: array | | |-- element: string | |-- State: string | |-- Street: string |-- Provider Id: string |-- Total Discharges: string |-- Provider Name: string ``` ## mergeDynamicFrame **`mergeDynamicFrame(stage_dynamic_frame, primary_keys, transformation_ctx = "", options = {}, info = "", stageThreshold = 0, totalThreshold = 0)`** 레코드를 식별하기 위해, 지정된 기본 키를 기반으로 이 `DynamicFrame`을 스테이징 `DynamicFrame`과 병합합니다. 중복 레코드(기본 키가 동일한 레코드)는 중복 제거되지 않습니다. 스테이징 프레임에 일치하는 레코드가 없으면 모든 레코드(중복 레코드 포함)가 소스에서 유지됩니다. 스테이징 프레임에 일치하는 레코드가 있으면 스테이징 프레임의 레코드가 AWS Glue의 소스에 있는 레코드를 덮어씁니다. + `stage_dynamic_frame` - 병합할 스테이징 `DynamicFrame`입니다. + `primary_keys` - 소스 및 스테이징 동적 프레임의 레코드와 일치시킬 기본 키 필드 목록입니다. + `transformation_ctx` - 현재 변환에 대한 메타데이터를 검색하는 데 사용되는 고유한 문자열입니다(선택 사항). + `options` - 이 변환에 대한 추가 정보를 제공하는 JSON 이름-값 페어 문자열입니다. 이 인수는 현재 사용되지 않습니다. + `info` - `String`입니다. 이 변환에 따른 오류와 관련된 문자열입니다. + `stageThreshold` - `Long`입니다. 오류가 발생되는 지정된 변환의 오류 수입니다. + `totalThreshold` - `Long`입니다. 오류가 발생되는 이 변환의 총 오류 수입니다. 이 메소드는 이 `DynamicFrame`을 스테이징 `DynamicFrame`과 병합하여 얻은 새 `DynamicFrame`을 반환합니다. 다음과 같은 경우 반환된 `DynamicFrame`에 레코드 A가 포함되어 있습니다. + `A`가 소스 프레임과 스테이징 프레임 모두에 있는 경우에는 스테이징 프레임의 `A`가 반환됩니다. + `A`가 소스 테이블에 있고 `A.primaryKeys`가 `stagingDynamicFrame`에 없는 경우에는 `A`는 스테이징 테이블에서 업데이트되지 않습니다. 소스 프레임과 스테이징 프레임이 동일한 스키마를 가질 필요는 없습니다. ### 예: MergeDynamicFrame을 사용하여 기본 키를 기반으로 두 개 `DynamicFrames`를 병합합니다 다음 코드 예제는 기본 키 `id`를 기반으로 `mergeDynamicFrame` 메서드를 사용하여 `DynamicFrame`를 “스테이징” `DynamicFrame`과 병합하는 방법을 보여줍니다. **예제 데이터 세트** 이 예제에서는 `split_rows_collection`로 호출된 `DynamicFrameCollection`에서 두 개의 `DynamicFrames`을 사용합니다. 다음은 `split_rows_collection`에서의 키 목록입니다. ``` dict_keys(['high', 'low']) ``` **예제 코드** ``` # Example: Use mergeDynamicFrame to merge DynamicFrames # based on a set of specified primary keys from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.transforms import SelectFromCollection # Inspect the original DynamicFrames frame_low = SelectFromCollection.apply(dfc=split_rows_collection, key="low") print("Inspect the DynamicFrame that contains rows where ID < 10") frame_low.toDF().show() frame_high = SelectFromCollection.apply(dfc=split_rows_collection, key="high") print("Inspect the DynamicFrame that contains rows where ID > 10") frame_high.toDF().show() # Merge the DynamicFrames based on the "id" primary key merged_high_low = frame_high.mergeDynamicFrame( stage_dynamic_frame=frame_low, primary_keys=["id"] ) # View the results where the ID is 1 or 20 print("Inspect the merged DynamicFrame that contains the combined rows") merged_high_low.toDF().where("id = 1 or id= 20").orderBy("id").show() ``` #### 출력 ``` Inspect the DynamicFrame that contains rows where ID < 10 +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 1| 0| fax| 202-225-3307| | 1| 1| phone| 202-225-5731| | 2| 0| fax| 202-225-3307| | 2| 1| phone| 202-225-5731| | 3| 0| fax| 202-225-3307| | 3| 1| phone| 202-225-5731| | 4| 0| fax| 202-225-3307| | 4| 1| phone| 202-225-5731| | 5| 0| fax| 202-225-3307| | 5| 1| phone| 202-225-5731| | 6| 0| fax| 202-225-3307| | 6| 1| phone| 202-225-5731| | 7| 0| fax| 202-225-3307| | 7| 1| phone| 202-225-5731| | 8| 0| fax| 202-225-3307| | 8| 1| phone| 202-225-5731| | 9| 0| fax| 202-225-3307| | 9| 1| phone| 202-225-5731| | 10| 0| fax| 202-225-6328| | 10| 1| phone| 202-225-4576| +---+-----+------------------------+-------------------------+ only showing top 20 rows Inspect the DynamicFrame that contains rows where ID > 10 +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 11| 0| fax| 202-225-6328| | 11| 1| phone| 202-225-4576| | 11| 2| twitter| RepTrentFranks| | 12| 0| fax| 202-225-6328| | 12| 1| phone| 202-225-4576| | 12| 2| twitter| RepTrentFranks| | 13| 0| fax| 202-225-6328| | 13| 1| phone| 202-225-4576| | 13| 2| twitter| RepTrentFranks| | 14| 0| fax| 202-225-6328| | 14| 1| phone| 202-225-4576| | 14| 2| twitter| RepTrentFranks| | 15| 0| fax| 202-225-6328| | 15| 1| phone| 202-225-4576| | 15| 2| twitter| RepTrentFranks| | 16| 0| fax| 202-225-6328| | 16| 1| phone| 202-225-4576| | 16| 2| twitter| RepTrentFranks| | 17| 0| fax| 202-225-6328| | 17| 1| phone| 202-225-4576| +---+-----+------------------------+-------------------------+ only showing top 20 rows Inspect the merged DynamicFrame that contains the combined rows +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 1| 0| fax| 202-225-3307| | 1| 1| phone| 202-225-5731| | 20| 0| fax| 202-225-5604| | 20| 1| phone| 202-225-6536| | 20| 2| twitter| USRepLong| +---+-----+------------------------+-------------------------+ ``` ## relationalize **`relationalize(root_table_name, staging_path, options, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** `DynamicFrame`을 관계형 데이터베이스에 맞는 형식으로 변환합니다. `DynamicFrame`을 관계형으로 만들면 DynamoDB와 같은 NoSQL 환경에서 MySQL과 같은 관계형 데이터베이스로 데이터를 이동하려는 경우에 특히 유용합니다. 변환은 중첩된 열의 중첩을 해제하고 배열 열을 회전하여 프레임 목록을 생성합니다. 회전 배열 열은 중첩되지 않는 상태에서 생성된 조인 키를 사용하여 루트 테이블에 연결될 수 있습니다. + `root_table_name` - 루트 테이블의 스키마 이름입니다. + `staging_path` - 메소드가 CSV 포맷으로 회전 테이블의 파티션을 저장하는 경로입니다(선택 사항). 회전 테이블은 이 경로부터 다시 읽습니다. + `options` - 선택적 파라미터의 딕셔너리입니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 이 변환에 따른 오류 보고 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생되는 변환 중에 발생하는 오류 수(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. + `totalThreshold` - 프로세스에서 오류가 발생해야 하는 이 변환을 포함하여 최대 발생한 오류 수입니다(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. ### 예: 관계형 만들기를 사용하여 `DynamicFrame` 내 중첩된 스키마를 플랫하게 만들기 이 코드 예제는 `relationalize` 메서드를 사용하여 중첩된 스키마를 관계형 데이터베이스에 맞는 형식으로 평면화합니다. **예제 데이터 세트** 이 예제에서는 다음 스키마와 함께 `legislators_combined`를 호출한 `DynamicFrame`을 사용합니다. `legislators_combined`은 `links`, `images`, 및 `contact_details`와 같은 여러 개의 중첩 필드를 가지고, `relationalize` 변환에 의해 평면화됩니다. ``` root |-- role: string |-- seats: int |-- org_name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- type: string |-- sort_name: string |-- area_id: string |-- images: array | |-- element: struct | | |-- url: string |-- on_behalf_of_id: string |-- other_names: array | |-- element: struct | | |-- note: string | | |-- name: string | | |-- lang: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- name: string |-- birth_date: string |-- organization_id: string |-- gender: string |-- classification: string |-- legislative_period_id: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- image: string |-- given_name: string |-- start_date: string |-- family_name: string |-- id: string |-- death_date: string |-- end_date: string ``` **예제 코드** ``` # Example: Use relationalize to flatten # a nested schema into a format that fits # into a relational database. # Replace DOC-EXAMPLE-S3-BUCKET/tmpDir with your own location. from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Apply relationalize and inspect new tables legislators_relationalized = legislators_combined.relationalize( "l_root", "s3://DOC-EXAMPLE-BUCKET/tmpDir" ) legislators_relationalized.keys() # Compare the schema of the contact_details # nested field to the new relationalized table that # represents it legislators_combined.select_fields("contact_details").printSchema() legislators_relationalized.select("l_root_contact_details").toDF().where( "id = 10 or id = 75" ).orderBy(["id", "index"]).show() ``` #### 출력 다음 출력을 통해 `contact_details`을 호출한 중첩 필드의 스키마를 `relationalize` 변환이 만든 테이블과 비교할 수 있습니다. 테이블 레코드는 `id`라는 외래 키와 배열의 위치를 나타내는 `index` 열을 사용하여 기본 테이블로 다시 연결됩니다. ``` dict_keys(['l_root', 'l_root_images', 'l_root_links', 'l_root_other_names', 'l_root_contact_details', 'l_root_identifiers']) root |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 10| 0| fax| 202-225-4160| | 10| 1| phone| 202-225-3436| | 75| 0| fax| 202-225-6791| | 75| 1| phone| 202-225-2861| | 75| 2| twitter| RepSamFarr| +---+-----+------------------------+-------------------------+ ``` ## rename\$1field **`rename_field(oldName, newName, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** `DynamicFrame`에서 필드 이름을 바꾸고 바꾼 필드로 새로운 `DynamicFrame`을 반환합니다. + `oldName` - 바꾸고자 하는 노드의 전체 경로입니다. 기존 이름에 점이 있으면 그 주위로 억음 부호(```)를 하지 않는 한 `RenameField`는 실행되지 않습니다. 예를 들어 `this.old.name`를 `thisNewName`으로 바꾸려면 다음과 같이 rename\$1field를 불러올 수 있습니다. ``` newDyF = oldDyF.rename_field("`this.old.name`", "thisNewName") ``` + `newName` - 전체 경로로써 새로운 이름입니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 이 변환에 따른 오류 보고 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생되는 변환 중에 발생하는 오류 수(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. + `totalThreshold` - 프로세스에서 오류가 발생해야 하는 이 변환을 포함하여 최대 발생한 오류 수입니다(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. ### 예: rename\$1field를 사용하여 `DynamicFrame`의 필드 이름을 변경합니다 이 코드 예제는 `rename_field` 메서드를 사용하여 `DynamicFrame`의 필드 이름을 변경합니다. 참고로 이 예제에서는 메서드 체인을 사용하여 여러 필드의 이름을 동시에 바꾸고 있습니다. **참고** 이 예제에서 사용되는 데이터 세트에 액세스하려면 [코드 예: 데이터 조인 및 관계화](aws-glue-programming-python-samples-legislators.md) 항목을 참조하고 [1단계: Amazon S3 버킷에서 데이터 크롤](aws-glue-programming-python-samples-legislators.md#aws-glue-programming-python-samples-legislators-crawling)의 지침을 따르세요. **예제 코드** ``` # Example: Use rename_field to rename fields # in a DynamicFrame from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Inspect the original orgs schema orgs = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="organizations_json" ) print("Original orgs schema: ") orgs.printSchema() # Rename fields and view the new schema orgs = orgs.rename_field("id", "org_id").rename_field("name", "org_name") print("New orgs schema with renamed fields: ") orgs.printSchema() ``` #### 출력 ``` Original orgs schema: root |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- id: string |-- classification: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- image: string |-- seats: int |-- type: string New orgs schema with renamed fields: root |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- classification: string |-- org_id: string |-- org_name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- image: string |-- seats: int |-- type: string ``` ## resolveChoice **`resolveChoice(specs = None, choice = "" , database = None , table_name = None , transformation_ctx="", info="", stageThreshold=0, totalThreshold=0, catalog_id = None)`** 이 `DynamicFrame`로 선택 유형을 해결하고 새로운 `DynamicFrame`을 반환합니다. + `specs` - 해결할 특정 모호성 목록이며, 각각은 `(field_path, action)`의 튜플 형식입니다. `resolveChoice`를 사용하는 방법은 두 가지입니다. 첫 번째는 `specs` 인수를 사용하여 특정 필드의 시퀀스와 이를 확인하는 방법을 지정하는 것입니다. `resolveChoice`의 다른 모드는 `choice` 인수를 사용하여 모든 `ChoiceTypes`에 대해 단 하나의 해결책을 지정합니다. `specs`의 값은 `(field_path, action)` 페어로 구성된 튜플로 지정됩니다. `field_path` 가치는 특정 모호한 요소를 확인하고 `action` 가치는 관련 해결 방안을 제안합니다. 가능한 작업은 다음과 같습니다. + `cast:type` - 모든 값을 지정된 유형으로 캐스트하는 시도를 합니다. 예를 들면 `cast:int`입니다. + `make_cols` - 각 고유 유형을 `columnName_type`이라는 이름을 가진 열로 변환합니다. 데이터를 평면화하여 잠재적 모호성을 해결합니다. 예를 들어, `columnA`가 `int` 혹은 `string`이면 해결 방안은 `DynamicFrame`에서 `columnA_int`와 `columnA_string`으로 된 두 열을 생산하는 것입니다. + `make_struct` – 데이터를 나타내도록 `struct`를 사용하여 잠재적 모호성을 해결합니다. 예를 들어, 열에서 데이터가 `int` 혹은 `string`이면 `make_struct` 작업은 결과적인 `DynamicFrame`의 구조 열을 생성합니다. 각 구조에는 `int` 및 `string`가 모두 포함됩니다. + `project:type` - 모든 데이터를 가능한 데이터 유형 중 하나로 투영하여 잠재적인 모호성을 해결합니다. 예를 들어, 열에서 데이터가 `int` 혹은 `string`이면 `project:string` 작업을 사용하면 모든 `int` 가치가 문자열로 변환된 결과인 `DynamicFrame`의 열을 생성합니다. 만약 `field_path`가 배열을 확인하면, 빈 대괄호를 배열 이름 다음에 만들어 모호성을 피합니다. 예를 들어, 다음과 같은 구조화된 데이터와 작업한다고 가정합시다. ``` "myList": [ { "price": 100.00 }, { "price": "$100.00" } ] ``` `field_path`를 `"myList[].price"`로 설정하고, `action`을 `"cast:double"`로 설정하여 가격의 문자열 버전보다 숫자 버전을 선택할 수 있습니다. **참고** `specs` 및 `choice` 파라미터 중 하나만 사용할 수 있습니다. `specs` 파라미터가 `None`이 아니면 `choice` 파라미터는 빈 문자열이어야 합니다. 반대로 `choice` 파라미터가 빈 문자열이 아니면, `specs` 파라미터는 `None`이어야 합니다. + `choice`- 모든 `ChoiceTypes`에 대해 단일 해상도를 지정합니다. 실행 시간 전에 `ChoiceTypes`의 완전한 목록을 모르는 경우에 사용할 수 있습니다. 이 인수는 `specs`에 대해 앞에서 나열한 작업 외에 다음 작업을 지원합니다. + `match_catalog` – 각 `ChoiceType`을 지정된 Data Catalog 테이블의 해당 유형에 캐스팅해봅니다. + `database` - `match_catalog` 작업에 사용할 Data Catalog 데이터베이스입니다. + `table_name` - `match_catalog` 작업에 사용할 Data Catalog 테이블입니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 이 변환에 따른 오류 보고 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생되는 변환 중에 발생하는 오류 수(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. + `totalThreshold` - 오류가 발생되는 변환을 포함하여 최대 발생하는 오류 수입니다(선택). 기본 값은 0이고 이는 프로세스에서 오류가 발생되지 않음을 나타냅니다. + `catalog_id` - 액세스 중인 Data Catalog의 카탈로그 ID(Data Catalog의 계정 ID)입니다. `None`(기본값)으로 설정하면 호출 계정의 카탈로그 ID를 사용합니다. ### 예: resolveChoice를 사용하여 여러 유형이 포함된 열을 처리합니다 이 코드 예제는 `resolveChoice` 메서드를 사용하여 여러 유형의 값이 포함된 `DynamicFrame` 열을 처리하는 방법을 지정합니다. 이 예제는 유형이 다른 열을 처리하는 두 가지 일반적인 방법을 보여줍니다. + 열을 단일 데이터 유형으로 보내버립니다. + 모든 유형을 별도의 열에 보관합니다. **예제 데이터 세트** **참고** 이 예제에서 사용되는 데이터 세트에 액세스하려면 [코드 예: ResolveChoice, Lambda, 및 ApplyMapping을 사용한 데이터 준비](aws-glue-programming-python-samples-medicaid.md) 항목을 참조하고 [1단계: Amazon S3 버킷에서 데이터 크롤](aws-glue-programming-python-samples-medicaid.md#aws-glue-programming-python-samples-medicaid-crawling)의 지침을 따르세요. 이 예제에서는 다음 스키마와 함께 `medicare`를 호출한 `DynamicFrame`을 사용합니다. ``` root |-- drg definition: string |-- provider id: choice | |-- long | |-- string |-- provider name: string |-- provider street address: string |-- provider city: string |-- provider state: string |-- provider zip code: long |-- hospital referral region description: string |-- total discharges: long |-- average covered charges: string |-- average total payments: string |-- average medicare payments: string ``` **예제 코드** ``` # Example: Use resolveChoice to handle # a column that contains multiple types from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Load the input data and inspect the "provider id" column medicare = glueContext.create_dynamic_frame.from_catalog( database="payments", table_name="medicare_hospital_provider_csv" ) print("Inspect the provider id column:") medicare.toDF().select("provider id").show() # Cast provider id to type long medicare_resolved_long = medicare.resolveChoice(specs=[("provider id", "cast:long")]) print("Schema after casting provider id to type long:") medicare_resolved_long.printSchema() medicare_resolved_long.toDF().select("provider id").show() # Create separate columns # for each provider id type medicare_resolved_cols = medicare.resolveChoice(choice="make_cols") print("Schema after creating separate columns for each type:") medicare_resolved_cols.printSchema() medicare_resolved_cols.toDF().select("provider id_long", "provider id_string").show() ``` #### 출력 ``` Inspect the 'provider id' column: +-----------+ |provider id| +-----------+ | [10001,]| | [10005,]| | [10006,]| | [10011,]| | [10016,]| | [10023,]| | [10029,]| | [10033,]| | [10039,]| | [10040,]| | [10046,]| | [10055,]| | [10056,]| | [10078,]| | [10083,]| | [10085,]| | [10090,]| | [10092,]| | [10100,]| | [10103,]| +-----------+ only showing top 20 rows Schema after casting 'provider id' to type long: root |-- drg definition: string |-- provider id: long |-- provider name: string |-- provider street address: string |-- provider city: string |-- provider state: string |-- provider zip code: long |-- hospital referral region description: string |-- total discharges: long |-- average covered charges: string |-- average total payments: string |-- average medicare payments: string +-----------+ |provider id| +-----------+ | 10001| | 10005| | 10006| | 10011| | 10016| | 10023| | 10029| | 10033| | 10039| | 10040| | 10046| | 10055| | 10056| | 10078| | 10083| | 10085| | 10090| | 10092| | 10100| | 10103| +-----------+ only showing top 20 rows Schema after creating separate columns for each type: root |-- drg definition: string |-- provider id_string: string |-- provider id_long: long |-- provider name: string |-- provider street address: string |-- provider city: string |-- provider state: string |-- provider zip code: long |-- hospital referral region description: string |-- total discharges: long |-- average covered charges: string |-- average total payments: string |-- average medicare payments: string +----------------+------------------+ |provider id_long|provider id_string| +----------------+------------------+ | 10001| null| | 10005| null| | 10006| null| | 10011| null| | 10016| null| | 10023| null| | 10029| null| | 10033| null| | 10039| null| | 10040| null| | 10046| null| | 10055| null| | 10056| null| | 10078| null| | 10083| null| | 10085| null| | 10090| null| | 10092| null| | 10100| null| | 10103| null| +----------------+------------------+ only showing top 20 rows ``` ## select\$1fields **`select_fields(paths, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 선택된 필드를 포함한 새로운 `DynamicFrame`을 반환합니다. + `paths` – 문자열 목록입니다. 각 문자열은 선택하려는 최상위 노드에 대한 경로입니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 이 변환에 따른 오류 보고 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생되는 변환 중에 발생하는 오류 수(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. + `totalThreshold` - 프로세스에서 오류가 발생해야 하는 이 변환을 포함하여 최대 발생한 오류 수입니다(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. ### 예: select\$1fields를 사용하여 선택한 필드로 새 `DynamicFrame` 생성 다음 코드 예제에서는 `select_fields` 메서드를 사용하여 기존 `DynamicFrame`에서 선택한 필드 목록으로 새 `DynamicFrame`을 만드는 방법을 보여줍니다. **참고** 이 예제에서 사용되는 데이터 세트에 액세스하려면 [코드 예: 데이터 조인 및 관계화](aws-glue-programming-python-samples-legislators.md) 항목을 참조하고 [1단계: Amazon S3 버킷에서 데이터 크롤](aws-glue-programming-python-samples-legislators.md#aws-glue-programming-python-samples-legislators-crawling)의 지침을 따르세요. ``` # Example: Use select_fields to select specific fields from a DynamicFrame from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Create a DynamicFrame and view its schema persons = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="persons_json" ) print("Schema for the persons DynamicFrame:") persons.printSchema() # Create a new DynamicFrame with chosen fields names = persons.select_fields(paths=["family_name", "given_name"]) print("Schema for the names DynamicFrame, created with select_fields:") names.printSchema() names.toDF().show() ``` #### 출력 ``` Schema for the persons DynamicFrame: root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string Schema for the names DynamicFrame: root |-- family_name: string |-- given_name: string +-----------+----------+ |family_name|given_name| +-----------+----------+ | Collins| Michael| | Huizenga| Bill| | Clawson| Curtis| | Solomon| Gerald| | Rigell| Edward| | Crapo| Michael| | Hutto| Earl| | Ertel| Allen| | Minish| Joseph| | Andrews| Robert| | Walden| Greg| | Kazen| Abraham| | Turner| Michael| | Kolbe| James| | Lowenthal| Alan| | Capuano| Michael| | Schrader| Kurt| | Nadler| Jerrold| | Graves| Tom| | McMillan| John| +-----------+----------+ only showing top 20 rows ``` ## simplify\$1ddb\$1json **`simplify_ddb_json(): DynamicFrame`** `DynamicFrame`의 중첩된 열 중 특히 DynamoDB JSON 구조에 있는 열을 단순화하고 단순화된 새로운 `DynamicFrame`을 반환합니다. 목록 유형에 여러 유형 또는 맵 유형이 있는 경우 목록의 요소는 단순화되지 않습니다. 이 변환은 일반적인 `unnest` 변환과 다르게 작동하는 특정 유형의 변환이며 데이터가 이미 DynamoDB JSON 구조에 있어야 한다는 점에 유의하세요. 자세한 내용은 [DynamoDB JSON](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html#DataExport.Output.Data)을 참조하세요. 예를 들어, DynamoDB JSON 구조를 사용하여 내보내기를 읽는 스키마는 다음과 같을 수 있습니다. ``` root |-- Item: struct | |-- parentMap: struct | | |-- M: struct | | | |-- childMap: struct | | | | |-- M: struct | | | | | |-- appName: struct | | | | | | |-- S: string | | | | | |-- packageName: struct | | | | | | |-- S: string | | | | | |-- updatedAt: struct | | | | | | |-- N: string | |-- strings: struct | | |-- SS: array | | | |-- element: string | |-- numbers: struct | | |-- NS: array | | | |-- element: string | |-- binaries: struct | | |-- BS: array | | | |-- element: string | |-- isDDBJson: struct | | |-- BOOL: boolean | |-- nullValue: struct | | |-- NULL: boolean ``` `simplify_ddb_json()` 변환은 이 구조를 다음과 같이 변환합니다. ``` root |-- parentMap: struct | |-- childMap: struct | | |-- appName: string | | |-- packageName: string | | |-- updatedAt: string |-- strings: array | |-- element: string |-- numbers: array | |-- element: string |-- binaries: array | |-- element: string |-- isDDBJson: boolean |-- nullValue: null ``` ### 예제: simplify\$1ddb\$1json을 사용하여 DynamoDB JSON 단순화 호출 이 코드 예제에서는 `simplify_ddb_json` 메서드를 사용하여 AWS Glue DynamoDB 내보내기 커넥터를 사용하고, DynamoDB JSON 단순화를 호출하고, 파티션 수를 인쇄합니다. **예제 코드** ``` from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext() glueContext = GlueContext(sc) dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type = "dynamodb", connection_options = { 'dynamodb.export': 'ddb', 'dynamodb.tableArn': '', 'dynamodb.s3.bucket': '', 'dynamodb.s3.prefix': '', 'dynamodb.s3.bucketOwner': '' } ) simplified = dynamicFrame.simplify_ddb_json() print(simplified.getNumPartitions()) ``` ## spigot **`spigot(path, options={})`** 작업에 의해 수행된 변환을 확인하는 데 도움이 되도록 샘플 레코드를 지정된 대상에 기록합니다. + `path` - 작성할 기본 대상 주소 경로입니다(필수). + `options` - 옵션을 지정하는 키-값 페어입니다(선택 사항). `"topk"` 옵션은 첫 번째 `k` 기록이 작성되어야 한다는 것을 명시합니다. `"prob"` 옵션은 특정 레코드를 선택할 가능성(십진수)을 지정합니다. 작성할 레코드를 선택할 때 사용할 수 있습니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). ### 예: spigot을 사용하여 `DynamicFrame`에서 Amazon S3에 샘플 필드를 작성합니다 이 코드 예제는 `select_fields` 변환을 적용한 후 `spigot` 메서드를 사용하여 Amazon S3 버킷에 샘플 레코드를 작성합니다. **예제 데이터 세트** **참고** 이 예제에서 사용되는 데이터 세트에 액세스하려면 [코드 예: 데이터 조인 및 관계화](aws-glue-programming-python-samples-legislators.md) 항목을 참조하고 [1단계: Amazon S3 버킷에서 데이터 크롤](aws-glue-programming-python-samples-legislators.md#aws-glue-programming-python-samples-legislators-crawling)의 지침을 따르세요. 이 예제에서는 다음 스키마와 함께 `persons`를 호출한 `DynamicFrame`을 사용합니다. ``` root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string ``` **예제 코드** ``` # Example: Use spigot to write sample records # to a destination during a transformation # from pyspark.context import SparkContext. # Replace DOC-EXAMPLE-BUCKET with your own location. from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Load table data into a DynamicFrame persons = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="persons_json" ) # Perform the select_fields on the DynamicFrame persons = persons.select_fields(paths=["family_name", "given_name", "birth_date"]) # Use spigot to write a sample of the transformed data # (the first 10 records) spigot_output = persons.spigot( path="s3://DOC-EXAMPLE-BUCKET", options={"topk": 10} ) # Example: Use spigot to write sample records # to a destination during a transformation # from pyspark.context import SparkContext. # Replace DOC-EXAMPLE-BUCKET with your own location. from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Load table data into a DynamicFrame persons = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="persons_json" ) # Perform the select_fields on the DynamicFrame persons = persons.select_fields(paths=["family_name", "given_name", "birth_date"]) # Use spigot to write a sample of the transformed data # (the first 10 records) spigot_output = persons.spigot( path="s3://DOC-EXAMPLE-BUCKET", options={"topk": 10} ) ``` #### 출력 다음은 `spigot`이 Amazon S3에 작성한 데이터 예제입니다. 예제 코드가 `options={"topk": 10}`를 지정하였으므로 샘플 데이터에는 처음 10개의 레코드가 포함됩니다. ``` {"family_name":"Collins","given_name":"Michael","birth_date":"1944-10-15"} {"family_name":"Huizenga","given_name":"Bill","birth_date":"1969-01-31"} {"family_name":"Clawson","given_name":"Curtis","birth_date":"1959-09-28"} {"family_name":"Solomon","given_name":"Gerald","birth_date":"1930-08-14"} {"family_name":"Rigell","given_name":"Edward","birth_date":"1960-05-28"} {"family_name":"Crapo","given_name":"Michael","birth_date":"1951-05-20"} {"family_name":"Hutto","given_name":"Earl","birth_date":"1926-05-12"} {"family_name":"Ertel","given_name":"Allen","birth_date":"1937-11-07"} {"family_name":"Minish","given_name":"Joseph","birth_date":"1916-09-01"} {"family_name":"Andrews","given_name":"Robert","birth_date":"1957-08-04"} ``` ## split\$1fields **`split_fields(paths, name1, name2, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 두 개의 `DynamicFrames`이 포함된 새 `DynamicFrameCollection`을 반환합니다. 첫 번째 `DynamicFrame`은 분할된 모든 노드를 포함하고 두 번째는 남겨진 노드를 포함합니다. + `paths` - 문자열 목록이며, 각 문자열 목록은 새로운 `DynamicFrame`으로 스플릿하려는 노드의 전체 경로입니다. + `name1` - 스플릿된 `DynamicFrame`의 이름 문자열입니다. + `name2` - 스플릿된 특정 노드 이후에 남겨진 `DynamicFrame`을 위한 이름 문자열입니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 이 변환에 따른 오류 보고 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생되는 변환 중에 발생하는 오류 수(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. + `totalThreshold` - 프로세스에서 오류가 발생해야 하는 이 변환을 포함하여 최대 발생한 오류 수입니다(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. ### 예제: split\$1fields를 사용하여 선택한 필드를 별도의 `DynamicFrame`로 분할합니다 이 코드 예제는 `split_fields` 메서드를 사용하여 지정된 필드 목록을 별도의 `DynamicFrame`으로 분할합니다. **예제 데이터 세트** 이 예제에서는 `legislators_relationalized`라는 컬렉션의 `l_root_contact_details`를 호출한 `DynamicFrame`을 사용합니다. `l_root_contact_details`에는 다음 스키마와 엔트리가 포함됩니다. ``` root |-- id: long |-- index: int |-- contact_details.val.type: string |-- contact_details.val.value: string +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 1| 0| phone| 202-225-5265| | 1| 1| twitter| kathyhochul| | 2| 0| phone| 202-225-3252| | 2| 1| twitter| repjackyrosen| | 3| 0| fax| 202-225-1314| | 3| 1| phone| 202-225-3772| ... ``` **예제 코드** ``` # Example: Use split_fields to split selected # fields into a separate DynamicFrame from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Load the input DynamicFrame and inspect its schema frame_to_split = legislators_relationalized.select("l_root_contact_details") print("Inspect the input DynamicFrame schema:") frame_to_split.printSchema() # Split id and index fields into a separate DynamicFrame split_fields_collection = frame_to_split.split_fields(["id", "index"], "left", "right") # Inspect the resulting DynamicFrames print("Inspect the schemas of the DynamicFrames created with split_fields:") split_fields_collection.select("left").printSchema() split_fields_collection.select("right").printSchema() ``` #### 출력 ``` Inspect the input DynamicFrame's schema: root |-- id: long |-- index: int |-- contact_details.val.type: string |-- contact_details.val.value: string Inspect the schemas of the DynamicFrames created with split_fields: root |-- id: long |-- index: int root |-- contact_details.val.type: string |-- contact_details.val.value: string ``` ## split\$1rows **`split_rows(comparison_dict, name1, name2, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** 새로운 `DynamicFrame`으로 `DynamicFrame`의 하나 이상의 열을 스플릿합니다. 이 메서드는 2개의 `DynamicFrames`가 포함된 새 `DynamicFrameCollection`을 반환합니다. 첫 번째 `DynamicFrame`은 스플릿된 모든 행을 포함하고 두 번째는 남겨진 열을 포함합니다. + `comparison_dict` - 열까지 경로의 키와 열 값이 비교된 값의 매핑 비교기를 위한 다른 딕셔너리인 값의 딕셔너리입니다. 예를 들어, `{"age": {">": 10, "<": 20}}`는 나이 열에서 가치가 10 초과 20 미만인 모든 열을 스플릿합니다. + `name1` - 스플릿된 `DynamicFrame`의 이름 문자열입니다. + `name2` - 스플릿된 특정 노드 이후에 남겨진 `DynamicFrame`을 위한 이름 문자열입니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 이 변환에 따른 오류 보고 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생되는 변환 중에 발생하는 오류 수(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. + `totalThreshold` - 프로세스에서 오류가 발생해야 하는 이 변환을 포함하여 최대 발생한 오류 수입니다(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. ### 예제: split\$1rows를 사용하여 `DynamicFrame` 행을 분할합니다 이 코드 예제는 `split_rows` 메서드를 사용하여 `id` 필드 값을 기준으로 `DynamicFrame`에서 행을 분할합니다. **예제 데이터 세트** 이 예제에서는 `legislators_relationalized`라는 컬렉션에서 선택한 `l_root_contact_details`를 호출한 `DynamicFrame`을 사용합니다. `l_root_contact_details`에는 다음 스키마와 엔트리가 포함됩니다. ``` root |-- id: long |-- index: int |-- contact_details.val.type: string |-- contact_details.val.value: string +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 1| 0| phone| 202-225-5265| | 1| 1| twitter| kathyhochul| | 2| 0| phone| 202-225-3252| | 2| 1| twitter| repjackyrosen| | 3| 0| fax| 202-225-1314| | 3| 1| phone| 202-225-3772| | 3| 2| twitter| MikeRossUpdates| | 4| 0| fax| 202-225-1314| | 4| 1| phone| 202-225-3772| | 4| 2| twitter| MikeRossUpdates| | 5| 0| fax| 202-225-1314| | 5| 1| phone| 202-225-3772| | 5| 2| twitter| MikeRossUpdates| | 6| 0| fax| 202-225-1314| | 6| 1| phone| 202-225-3772| | 6| 2| twitter| MikeRossUpdates| | 7| 0| fax| 202-225-1314| | 7| 1| phone| 202-225-3772| | 7| 2| twitter| MikeRossUpdates| | 8| 0| fax| 202-225-1314| +---+-----+------------------------+-------------------------+ ``` **예제 코드** ``` # Example: Use split_rows to split up # rows in a DynamicFrame based on value from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Retrieve the DynamicFrame to split frame_to_split = legislators_relationalized.select("l_root_contact_details") # Split up rows by ID split_rows_collection = frame_to_split.split_rows({"id": {">": 10}}, "high", "low") # Inspect the resulting DynamicFrames print("Inspect the DynamicFrame that contains IDs < 10") split_rows_collection.select("low").toDF().show() print("Inspect the DynamicFrame that contains IDs > 10") split_rows_collection.select("high").toDF().show() ``` #### 출력 ``` Inspect the DynamicFrame that contains IDs < 10 +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 1| 0| phone| 202-225-5265| | 1| 1| twitter| kathyhochul| | 2| 0| phone| 202-225-3252| | 2| 1| twitter| repjackyrosen| | 3| 0| fax| 202-225-1314| | 3| 1| phone| 202-225-3772| | 3| 2| twitter| MikeRossUpdates| | 4| 0| fax| 202-225-1314| | 4| 1| phone| 202-225-3772| | 4| 2| twitter| MikeRossUpdates| | 5| 0| fax| 202-225-1314| | 5| 1| phone| 202-225-3772| | 5| 2| twitter| MikeRossUpdates| | 6| 0| fax| 202-225-1314| | 6| 1| phone| 202-225-3772| | 6| 2| twitter| MikeRossUpdates| | 7| 0| fax| 202-225-1314| | 7| 1| phone| 202-225-3772| | 7| 2| twitter| MikeRossUpdates| | 8| 0| fax| 202-225-1314| +---+-----+------------------------+-------------------------+ only showing top 20 rows Inspect the DynamicFrame that contains IDs > 10 +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 11| 0| phone| 202-225-5476| | 11| 1| twitter| RepDavidYoung| | 12| 0| phone| 202-225-4035| | 12| 1| twitter| RepStephMurphy| | 13| 0| fax| 202-226-0774| | 13| 1| phone| 202-225-6335| | 14| 0| fax| 202-226-0774| | 14| 1| phone| 202-225-6335| | 15| 0| fax| 202-226-0774| | 15| 1| phone| 202-225-6335| | 16| 0| fax| 202-226-0774| | 16| 1| phone| 202-225-6335| | 17| 0| fax| 202-226-0774| | 17| 1| phone| 202-225-6335| | 18| 0| fax| 202-226-0774| | 18| 1| phone| 202-225-6335| | 19| 0| fax| 202-226-0774| | 19| 1| phone| 202-225-6335| | 20| 0| fax| 202-226-0774| | 20| 1| phone| 202-225-6335| +---+-----+------------------------+-------------------------+ only showing top 20 rows ``` ## unbox **`unbox(path, format, transformation_ctx="", info="", stageThreshold=0, totalThreshold=0, **options)`** `DynamicFrame`의 문자열 필드를 열고(포맷 재지정) 개봉된 `DynamicRecords`를 포함한 새로운 `DynamicFrame`를 반환합니다. `DynamicRecord`는 `DynamicFrame`내 논리적 기록입니다. 자기 설명적이고 고정 스키마를 준수하지 않은 데이터에 사용될 수 있다는 점을 제외하면 Apache Spark `DataFrame`의 열과 비슷합니다. + `path` - 열고자 하는 문자열 노드의 전체 경로입니다. + `format` - 포맷 사양입니다(선택 사항). 여러 포맷을 지원하는 Amazon S3 또는 AWS Glue 연결에 사용할 수 있습니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하세요. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 이 변환에 따른 오류 보고 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생되는 변환 중에 발생하는 오류 수(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. + `totalThreshold` - 프로세스에서 오류가 발생해야 하는 이 변환을 포함하여 최대 발생한 오류 수입니다(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. + `options` - 다음 중 한 개 이상을 수행할 수 있습니다. + `separator` - 구분자 문자를 포함한 문자열입니다. + `escaper` - 에스케이프 문자를 포함한 문자열입니다. + `skipFirst` - 첫 번째 인스턴스를 넘어갈지 여부를 나타내는 부울 값입니다. + `withSchema` - 노드 스키마의 JSON 표현을 포함하는 문자열입니다. 스키마의 JSON 표현 형식은 `StructType.json()`의 출력에 의해 정의됩니다. + `withHeader` - 헤더가 포함되었는지 여부를 나타내는 부울 값입니다. ### 예제: 개봉하기를 사용하여 문자열 필드를 구조에 개봉하기 이 코드 예제는 `unbox` 메서드를 사용하여 `DynamicFrame`의 문자열 필드를 유형 구조 필드로 *개봉하거나* 포맷을 다시 지정합니다. **예제 데이터 세트** 이 예제에서는 다음과 같은 스키마 및 항목과 함께 `mapped_with_string`를 호출한 `DynamicFrame`을 사용합니다. `AddressString`로 이름이 지정된 필드를 확인하십시오. 이 필드는 예제에서 구조로 개봉되는 필드입니다. ``` root |-- Average Total Payments: string |-- AddressString: string |-- Average Covered Charges: string |-- DRG Definition: string |-- Average Medicare Payments: string |-- Hospital Referral Region Description: string |-- Address: struct | |-- Zip.Code: string | |-- City: string | |-- Array: array | | |-- element: string | |-- State: string | |-- Street: string |-- Provider Id: string |-- Total Discharges: string |-- Provider Name: string +----------------------+--------------------+-----------------------+--------------------+-------------------------+------------------------------------+--------------------+-----------+----------------+--------------------+ |Average Total Payments| AddressString|Average Covered Charges| DRG Definition|Average Medicare Payments|Hospital Referral Region Description| Address|Provider Id|Total Discharges| Provider Name| +----------------------+--------------------+-----------------------+--------------------+-------------------------+------------------------------------+--------------------+-----------+----------------+--------------------+ | $5777.24|{"Street": "1108 ...| $32963.07|039 - EXTRACRANIA...| $4763.73| AL - Dothan|[36301, DOTHAN, [...| 10001| 91|SOUTHEAST ALABAMA...| | $5787.57|{"Street": "2505 ...| $15131.85|039 - EXTRACRANIA...| $4976.71| AL - Birmingham|[35957, BOAZ, [25...| 10005| 14|MARSHALL MEDICAL ...| | $5434.95|{"Street": "205 M...| $37560.37|039 - EXTRACRANIA...| $4453.79| AL - Birmingham|[35631, FLORENCE,...| 10006| 24|ELIZA COFFEE MEMO...| | $5417.56|{"Street": "50 ME...| $13998.28|039 - EXTRACRANIA...| $4129.16| AL - Birmingham|[35235, BIRMINGHA...| 10011| 25| ST VINCENT'S EAST| ... ``` **예제 코드** ``` # Example: Use unbox to unbox a string field # into a struct in a DynamicFrame from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) unboxed = mapped_with_string.unbox("AddressString", "json") unboxed.printSchema() unboxed.toDF().show() ``` #### 출력 ``` root |-- Average Total Payments: string |-- AddressString: struct | |-- Street: string | |-- City: string | |-- State: string | |-- Zip.Code: string | |-- Array: array | | |-- element: string |-- Average Covered Charges: string |-- DRG Definition: string |-- Average Medicare Payments: string |-- Hospital Referral Region Description: string |-- Address: struct | |-- Zip.Code: string | |-- City: string | |-- Array: array | | |-- element: string | |-- State: string | |-- Street: string |-- Provider Id: string |-- Total Discharges: string |-- Provider Name: string +----------------------+--------------------+-----------------------+--------------------+-------------------------+------------------------------------+--------------------+-----------+----------------+--------------------+ |Average Total Payments| AddressString|Average Covered Charges| DRG Definition|Average Medicare Payments|Hospital Referral Region Description| Address|Provider Id|Total Discharges| Provider Name| +----------------------+--------------------+-----------------------+--------------------+-------------------------+------------------------------------+--------------------+-----------+----------------+--------------------+ | $5777.24|[1108 ROSS CLARK ...| $32963.07|039 - EXTRACRANIA...| $4763.73| AL - Dothan|[36301, DOTHAN, [...| 10001| 91|SOUTHEAST ALABAMA...| | $5787.57|[2505 U S HIGHWAY...| $15131.85|039 - EXTRACRANIA...| $4976.71| AL - Birmingham|[35957, BOAZ, [25...| 10005| 14|MARSHALL MEDICAL ...| | $5434.95|[205 MARENGO STRE...| $37560.37|039 - EXTRACRANIA...| $4453.79| AL - Birmingham|[35631, FLORENCE,...| 10006| 24|ELIZA COFFEE MEMO...| | $5417.56|[50 MEDICAL PARK ...| $13998.28|039 - EXTRACRANIA...| $4129.16| AL - Birmingham|[35235, BIRMINGHA...| 10011| 25| ST VINCENT'S EAST| | $5658.33|[1000 FIRST STREE...| $31633.27|039 - EXTRACRANIA...| $4851.44| AL - Birmingham|[35007, ALABASTER...| 10016| 18|SHELBY BAPTIST ME...| | $6653.80|[2105 EAST SOUTH ...| $16920.79|039 - EXTRACRANIA...| $5374.14| AL - Montgomery|[36116, MONTGOMER...| 10023| 67|BAPTIST MEDICAL C...| | $5834.74|[2000 PEPPERELL P...| $11977.13|039 - EXTRACRANIA...| $4761.41| AL - Birmingham|[36801, OPELIKA, ...| 10029| 51|EAST ALABAMA MEDI...| | $8031.12|[619 SOUTH 19TH S...| $35841.09|039 - EXTRACRANIA...| $5858.50| AL - Birmingham|[35233, BIRMINGHA...| 10033| 32|UNIVERSITY OF ALA...| | $6113.38|[101 SIVLEY RD, H...| $28523.39|039 - EXTRACRANIA...| $5228.40| AL - Huntsville|[35801, HUNTSVILL...| 10039| 135| HUNTSVILLE HOSPITAL| | $5541.05|[1007 GOODYEAR AV...| $75233.38|039 - EXTRACRANIA...| $4386.94| AL - Birmingham|[35903, GADSDEN, ...| 10040| 34|GADSDEN REGIONAL ...| | $5461.57|[600 SOUTH THIRD ...| $67327.92|039 - EXTRACRANIA...| $4493.57| AL - Birmingham|[35901, GADSDEN, ...| 10046| 14|RIVERVIEW REGIONA...| | $5356.28|[4370 WEST MAIN S...| $39607.28|039 - EXTRACRANIA...| $4408.20| AL - Dothan|[36305, DOTHAN, [...| 10055| 45| FLOWERS HOSPITAL| | $5374.65|[810 ST VINCENT'S...| $22862.23|039 - EXTRACRANIA...| $4186.02| AL - Birmingham|[35205, BIRMINGHA...| 10056| 43|ST VINCENT'S BIRM...| | $5366.23|[400 EAST 10TH ST...| $31110.85|039 - EXTRACRANIA...| $4376.23| AL - Birmingham|[36207, ANNISTON,...| 10078| 21|NORTHEAST ALABAMA...| | $5282.93|[1613 NORTH MCKEN...| $25411.33|039 - EXTRACRANIA...| $4383.73| AL - Mobile|[36535, FOLEY, [1...| 10083| 15|SOUTH BALDWIN REG...| | $5676.55|[1201 7TH STREET ...| $9234.51|039 - EXTRACRANIA...| $4509.11| AL - Huntsville|[35609, DECATUR, ...| 10085| 27|DECATUR GENERAL H...| | $5930.11|[6801 AIRPORT BOU...| $15895.85|039 - EXTRACRANIA...| $3972.85| AL - Mobile|[36608, MOBILE, [...| 10090| 27| PROVIDENCE HOSPITAL| | $6192.54|[809 UNIVERSITY B...| $19721.16|039 - EXTRACRANIA...| $5179.38| AL - Tuscaloosa|[35401, TUSCALOOS...| 10092| 31|D C H REGIONAL ME...| | $4968.00|[750 MORPHY AVENU...| $10710.88|039 - EXTRACRANIA...| $3898.88| AL - Mobile|[36532, FAIRHOPE,...| 10100| 18| THOMAS HOSPITAL| | $5996.00|[701 PRINCETON AV...| $51343.75|039 - EXTRACRANIA...| $4962.45| AL - Birmingham|[35211, BIRMINGHA...| 10103| 33|BAPTIST MEDICAL C...| +----------------------+--------------------+-----------------------+--------------------+-------------------------+------------------------------------+--------------------+-----------+----------------+--------------------+ only showing top 20 rows ``` ## 결합 **`union(frame1, frame2, transformation_ctx = "", info = "", stageThreshold = 0, totalThreshold = 0)`** 두 개의 DynamicFrame을 결합합니다. 두 입력 DynamicFrames의 모든 레코드를 포함하는 DynamicFrame을 반환합니다. 이 변환은 두 DataFrame을 동일한 데이터와 결합하여 다른 결과를 반환할 수 있습니다. Spark DataFrame 통합 동작이 필요한 경우 `toDF`을(를) 사용하는 것을 고려해 보세요. + `frame1`— 결합할 첫 번째 DynamicFrame. + `frame2`— 결합할 두 번째 DynamicFrame. + `transformation_ctx` – (선택 사항) 통계/상태 정보를 확인하는 데 사용되는 고유 문자열 + `info` - (선택 사항) 변환에 따른 오류 관련 문자열 + `stageThreshold`— (선택 사항) 처리 오류가 발생할 때까지 변환에서 발생한 최대 오류 수 + `totalThreshold`— (선택 사항) 처리 오류가 발생할 때까지의 총 최대 오류 수. ## unnest **`unnest(transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** `DynamicFrame`에서 중첩된 객체를 중첩시키지 않고 상위 객체로 만들어서 새로운 중첩되지 않은 `DynamicFrame`을 반환합니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 이 변환에 따른 오류 보고 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생되는 변환 중에 발생하는 오류 수(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. + `totalThreshold` - 프로세스에서 오류가 발생해야 하는 이 변환을 포함하여 최대 발생한 오류 수입니다(선택 사항). 기본값은 0이며, 이는 프로세스에 오류가 발생하지 않아야 함을 나타냅니다. ### 예제: 중첩 해제를 사용하여 중첩된 필드를 최상위 필드로 전환합니다 이 코드 예제는 `unnest` 메서드를 사용하여 `DynamicFrame`의 모든 중첩된 필드를 최상위 필드로 병합합니다. **예제 데이터 세트** 이 예제에서는 다음 스키마와 함께 `mapped_medicare`를 호출하는 `DynamicFrame`을 사용합니다. `Address` 필드는 중첩된 데이터를 포함하는 유일한 필드라는 점에 유의하십시오. ``` root |-- Average Total Payments: string |-- Average Covered Charges: string |-- DRG Definition: string |-- Average Medicare Payments: string |-- Hospital Referral Region Description: string |-- Address: struct | |-- Zip.Code: string | |-- City: string | |-- Array: array | | |-- element: string | |-- State: string | |-- Street: string |-- Provider Id: string |-- Total Discharges: string |-- Provider Name: string ``` **예제 코드** ``` # Example: Use unnest to unnest nested # objects in a DynamicFrame from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Unnest all nested fields unnested = mapped_medicare.unnest() unnested.printSchema() ``` #### 출력 ``` root |-- Average Total Payments: string |-- Average Covered Charges: string |-- DRG Definition: string |-- Average Medicare Payments: string |-- Hospital Referral Region Description: string |-- Address.Zip.Code: string |-- Address.City: string |-- Address.Array: array | |-- element: string |-- Address.State: string |-- Address.Street: string |-- Provider Id: string |-- Total Discharges: string |-- Provider Name: string ``` ## unnest\$1ddb\$1json DynamoDB JSON 구조의 `DynamicFrame`에 있는 중첩된 열을 한정해서 중첩 해제하고, 중첩되지 않은 새 `DynamicFrame`을 반환합니다. 구조체 유형 배열인 열은 중첩 해제되지 않습니다. 이 변환은 일반적인 `unnest` 변환과는 다르게 작동하는 특정 유형의 중첩 해제 변환이며, 데이터가 이미 DynamoDB JSON 구조에 있어야 합니다. 자세한 내용은 [DynamoDB JSON](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html#DataExport.Output.Data)을 참조하세요. **`unnest_ddb_json(transformation_ctx="", info="", stageThreshold=0, totalThreshold=0)`** + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 이 변환에 따른 오류 보고 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생되는 변환 중에 발생하는 오류 수 (선택: 오류가 발생되지 않은 변환을 나타내는 기본값은 0입니다). + `totalThreshold` - 오류가 발생되는 변환을 포함하여 최대 발생하는 오류 수 (선택: 오류가 발생되지 않은 변환을 나타내는 기본값은 0입니다). 예를 들어, DynamoDB JSON 구조를 사용하여 내보내기를 읽는 스키마는 다음과 같을 수 있습니다. ``` root |-- Item: struct | |-- ColA: struct | | |-- S: string | |-- ColB: struct | | |-- S: string | |-- ColC: struct | | |-- N: string | |-- ColD: struct | | |-- L: array | | | |-- element: null ``` `unnest_ddb_json()` 변환은 이 구조를 다음과 같이 변환합니다. ``` root |-- ColA: string |-- ColB: string |-- ColC: string |-- ColD: array | |-- element: null ``` 아래 코드 예제에서는 AWS Glue DynamoDB 내보내기 커넥터를 사용하고, DynamoDB JSON unnest를 호출하고, 파티션 수를 인쇄하는 방법을 보여줍니다. ``` import sys from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job from awsglue.utils import getResolvedOptions args = getResolvedOptions(sys.argv, ["JOB_NAME"]) glue_context= GlueContext(SparkContext.getOrCreate()) job = Job(glue_context) job.init(args["JOB_NAME"], args) dynamicFrame = glue_context.create_dynamic_frame.from_options( connection_type="dynamodb", connection_options={ "dynamodb.export": "ddb", "dynamodb.tableArn": "", "dynamodb.s3.bucket": "", "dynamodb.s3.prefix": "", "dynamodb.s3.bucketOwner": "", } ) unnested = dynamicFrame.unnest_ddb_json() print(unnested.getNumPartitions()) job.commit() ``` ## write **`write(connection_type, connection_options, format, format_options, accumulator_size)`** 이 `DynamicFrame`의 [GlueContext 클래스](aws-glue-api-crawler-pyspark-extensions-glue-context.md)에서 지정된 연결 유형의 [DataSink(객체)](aws-glue-api-crawler-pyspark-extensions-types.md#aws-glue-api-crawler-pyspark-extensions-types-awsglue-data-sink)를 얻어 `DynamicFrame` 내용을 포맷하고 작성하는 데 사용합니다. 명시된 대로 포맷되고 작성된 새로운 `DynamicFrame`을 반환합니다. + `connection_type` - 사용할 연결 유형입니다. 유효한 값에는 `s3`, `mysql`, `postgresql`, `redshift`, `sqlserver` 및 `oracle`가 있습니다. + `connection_options` - 사용할 연결 옵션입니다(선택 사항). `s3`의 `connection_type`의 경우, Amazon S3 경로가 정의됩니다. ``` connection_options = {"path": "s3://aws-glue-target/temp"} ``` JDBC 연결의 경우, 몇 까지 속성이 정의되어야 합니다. 단, 데이터베이스 이름이 URL의 일부여야 합니다. 연결 옵션에 선택적으로 포함될 수 있습니다. **주의** 스크립트에 암호를 저장하는 것은 권장되지 않습니다. AWS Secrets Manager 또는 AWS Glue 데이터 카탈로그에서 데이터를 검색할 때 `boto3` 사용을 고려합니다. ``` connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path"} ``` + `format` - 포맷 사양입니다(선택 사항). 여러 포맷을 지원하는 Amazon Simple Storage Service(Amazon S3) 또는 AWS Glue 연결에 사용됩니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하십시오. + `format_options` - 지정된 포맷에 대한 포맷 옵션입니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하십시오. + `accumulator_size` - (선택 사항) 사용할 누적 가능한 크기(바이트)입니다. ## - 오류 - + [assertErrorThreshold](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-assertErrorThreshold) + [errorsAsDynamicFrame](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-errorsAsDynamicFrame) + [errorsCount](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-errorsCount) + [stageErrorsCount](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-stageErrorsCount) ## assertErrorThreshold `assertErrorThreshold( )` - 이 `DynamicFrame`을 생성한 변환의 오류에 대한 어설션입니다. 기본 `DataFrame`으로부터 `Exception`을 반환합니다. ## errorsAsDynamicFrame `errorsAsDynamicFrame( )` - 내부에 중첩된 오류 기록을 보유한 `DynamicFrame`을 반환합니다. ### 예: errorsAsDynamicFrame을 사용하여 오류 레코드 보기 다음 코드 예제에서는 `errorsAsDynamicFrame` 메서드를 사용하여 `DynamicFrame`에 대한 오류 레코드를 보는 방법을 보여 줍니다. **예제 데이터 세트** 이 예제에서는 Amazon S3에 JSON으로 업로드할 수 있는 다음 데이터 세트를 사용합니다. 두 번째 레코드의 형식이 잘못되었습니다. 잘못된 형식의 데이터는 일반적으로 SparkSQL을 사용할 때 파일 구문 분석을 중단합니다. 그러나 `DynamicFrame`은 잘못된 형식 문제를 인식하고 잘못된 형식 행을 개별적으로 처리할 수 있는 오류 레코드로 바꿉니다. ``` {"id": 1, "name": "george", "surname": "washington", "height": 178} {"id": 2, "name": "benjamin", "surname": "franklin", {"id": 3, "name": "alexander", "surname": "hamilton", "height": 171} {"id": 4, "name": "john", "surname": "jay", "height": 190} ``` **예제 코드** ``` # Example: Use errorsAsDynamicFrame to view error records. # Replace s3://DOC-EXAMPLE-S3-BUCKET/error_data.json with your location. from pyspark.context import SparkContext from awsglue.context import GlueContext # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Create errors DynamicFrame, view schema errors = glueContext.create_dynamic_frame.from_options( "s3", {"paths": ["s3://DOC-EXAMPLE-S3-BUCKET/error_data.json"]}, "json" ) print("Schema of errors DynamicFrame:") errors.printSchema() # Show that errors only contains valid entries from the dataset print("errors contains only valid records from the input dataset (2 of 4 records)") errors.toDF().show() # View errors print("Errors count:", str(errors.errorsCount())) print("Errors:") errors.errorsAsDynamicFrame().toDF().show() # View error fields and error data error_record = errors.errorsAsDynamicFrame().toDF().head() error_fields = error_record["error"] print("Error fields: ") print(error_fields.asDict().keys()) print("\nError record data:") for key in error_fields.asDict().keys(): print("\n", key, ": ", str(error_fields[key])) ``` #### 출력 ``` Schema of errors DynamicFrame: root |-- id: int |-- name: string |-- surname: string |-- height: int errors contains only valid records from the input dataset (2 of 4 records) +---+------+----------+------+ | id| name| surname|height| +---+------+----------+------+ | 1|george|washington| 178| | 4| john| jay| 190| +---+------+----------+------+ Errors count: 1 Errors: +--------------------+ | error| +--------------------+ |[[ File "/tmp/20...| +--------------------+ Error fields: dict_keys(['callsite', 'msg', 'stackTrace', 'input', 'bytesread', 'source', 'dynamicRecord']) Error record data: callsite : Row(site=' File "/tmp/2060612586885849088", line 549, in \n sys.exit(main())\n File "/tmp/2060612586885849088", line 523, in main\n response = handler(content)\n File "/tmp/2060612586885849088", line 197, in execute_request\n result = node.execute()\n File "/tmp/2060612586885849088", line 103, in execute\n exec(code, global_dict)\n File "", line 10, in \n File "/opt/amazon/lib/python3.6/site-packages/awsglue/dynamicframe.py", line 625, in from_options\n format_options, transformation_ctx, push_down_predicate, **kwargs)\n File "/opt/amazon/lib/python3.6/site-packages/awsglue/context.py", line 233, in create_dynamic_frame_from_options\n source.setFormat(format, **format_options)\n', info='') msg : error in jackson reader stackTrace : com.fasterxml.jackson.core.JsonParseException: Unexpected character ('{' (code 123)): was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name at [Source: com.amazonaws.services.glue.readers.BufferedStream@73492578; line: 3, column: 2] at com.fasterxml.jackson.core.JsonParser._constructError(JsonParser.java:1581) at com.fasterxml.jackson.core.base.ParserMinimalBase._reportError(ParserMinimalBase.java:533) at com.fasterxml.jackson.core.base.ParserMinimalBase._reportUnexpectedChar(ParserMinimalBase.java:462) at com.fasterxml.jackson.core.json.UTF8StreamJsonParser._handleOddName(UTF8StreamJsonParser.java:2012) at com.fasterxml.jackson.core.json.UTF8StreamJsonParser._parseName(UTF8StreamJsonParser.java:1650) at com.fasterxml.jackson.core.json.UTF8StreamJsonParser.nextToken(UTF8StreamJsonParser.java:740) at com.amazonaws.services.glue.readers.JacksonReader$$anonfun$hasNextGoodToken$1.apply(JacksonReader.scala:57) at com.amazonaws.services.glue.readers.JacksonReader$$anonfun$hasNextGoodToken$1.apply(JacksonReader.scala:57) at scala.collection.Iterator$$anon$9.next(Iterator.scala:162) at scala.collection.Iterator$$anon$16.hasNext(Iterator.scala:599) at scala.collection.Iterator$$anon$16.hasNext(Iterator.scala:598) at scala.collection.Iterator$class.foreach(Iterator.scala:891) at scala.collection.AbstractIterator.foreach(Iterator.scala:1334) at com.amazonaws.services.glue.readers.JacksonReader$$anonfun$1.apply(JacksonReader.scala:120) at com.amazonaws.services.glue.readers.JacksonReader$$anonfun$1.apply(JacksonReader.scala:116) at com.amazonaws.services.glue.DynamicRecordBuilder.handleErr(DynamicRecordBuilder.scala:209) at com.amazonaws.services.glue.DynamicRecordBuilder.handleErrorWithException(DynamicRecordBuilder.scala:202) at com.amazonaws.services.glue.readers.JacksonReader.nextFailSafe(JacksonReader.scala:116) at com.amazonaws.services.glue.readers.JacksonReader.next(JacksonReader.scala:109) at com.amazonaws.services.glue.readers.JSONReader.next(JSONReader.scala:247) at com.amazonaws.services.glue.hadoop.TapeHadoopRecordReaderSplittable.nextKeyValue(TapeHadoopRecordReaderSplittable.scala:103) at org.apache.spark.rdd.NewHadoopRDD$$anon$1.hasNext(NewHadoopRDD.scala:230) at org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37) at scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:409) at scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:409) at scala.collection.Iterator$$anon$13.hasNext(Iterator.scala:462) at scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:409) at scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:409) at scala.collection.Iterator$$anon$13.hasNext(Iterator.scala:462) at scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:409) at scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:409) at org.apache.spark.sql.execution.SparkPlan$$anonfun$2.apply(SparkPlan.scala:255) at org.apache.spark.sql.execution.SparkPlan$$anonfun$2.apply(SparkPlan.scala:247) at org.apache.spark.rdd.RDD$$anonfun$mapPartitionsInternal$1$$anonfun$apply$24.apply(RDD.scala:836) at org.apache.spark.rdd.RDD$$anonfun$mapPartitionsInternal$1$$anonfun$apply$24.apply(RDD.scala:836) at org.apache.spark.rdd.MapPartitionsRDD.compute(MapPartitionsRDD.scala:52) at org.apache.spark.rdd.RDD.computeOrReadCheckpoint(RDD.scala:324) at org.apache.spark.rdd.RDD.iterator(RDD.scala:288) at org.apache.spark.rdd.MapPartitionsRDD.compute(MapPartitionsRDD.scala:52) at org.apache.spark.rdd.RDD.computeOrReadCheckpoint(RDD.scala:324) at org.apache.spark.rdd.RDD.iterator(RDD.scala:288) at org.apache.spark.scheduler.ResultTask.runTask(ResultTask.scala:90) at org.apache.spark.scheduler.Task.run(Task.scala:121) at org.apache.spark.executor.Executor$TaskRunner$$anonfun$10.apply(Executor.scala:408) at org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1360) at org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:414) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) at java.lang.Thread.run(Thread.java:750) input : bytesread : 252 source : dynamicRecord : Row(id=2, name='benjamin', surname='franklin') ``` ## 포괄적 DynamicFrame 예제 다음 예제에서는 기본 Glue 카탈로그 시나리오 외에 DynamicFrames를 생성하고 작업하는 다양한 방법을 보여줍니다. ### SQL SELECT 쿼리를 사용하여 PostgreSQL에서 로드 이 예제에서는 사용자 지정 SQL SELECT 쿼리를 사용하여 PostgreSQL 데이터베이스에서 데이터를 로드하는 방법을 보여줍니다. ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) # Load specific data from PostgreSQL with custom query postgres_dyf = glueContext.create_dynamic_frame.from_options( connection_type="postgresql", connection_options={ "url": "jdbc:postgresql://your-postgres-host:5432/your-database", "user": "your-username", "password": "your-password", "dbtable": "(SELECT customer_id, customer_name, email FROM customers WHERE active = true) AS filtered_customers" } ) ``` ### 전체 테이블 스캔을 방지하도록 특정 열 로드 이 예제는 대규모 데이터베이스 테이블에서 특정 열만 로드하는 방법을 보여줍니다. ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) # Load only specific columns from a large table selected_columns_dyf = glueContext.create_dynamic_frame.from_options( connection_type="mysql", connection_options={ "url": "jdbc:mysql://your-mysql-host:3306/your-database", "user": "your-username", "password": "your-password", "dbtable": "(SELECT order_id, customer_id FROM large_orders_table) AS selected_data" } ) # Alternative approach using column selection in query efficient_load_dyf = glueContext.create_dynamic_frame.from_options( connection_type="postgresql", connection_options={ "url": "jdbc:postgresql://your-postgres-host:5432/your-database", "user": "your-username", "password": "your-password", "query": "SELECT product_id, product_name FROM products WHERE category = 'electronics'" } ) ``` ### JDBC 연결을 통한 행 수준 필터링 이 예제에서는 행 수준 필터링을 사용하여 데이터베이스 테이블에서 특정 행만 로드하는 방법을 보여줍니다. ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) # Load filtered rows using WHERE clause filtered_rows_dyf = glueContext.create_dynamic_frame.from_options( connection_type="postgresql", connection_options={ "url": "jdbc:postgresql://your-postgres-host:5432/your-database", "user": "your-username", "password": "your-password", "dbtable": "(SELECT * FROM transactions WHERE transaction_date >= '2024-01-01' AND amount > 100) AS recent_large_transactions" } ) # Using partitionColumn for parallel loading with filtering partitioned_load_dyf = glueContext.create_dynamic_frame.from_options( connection_type="mysql", connection_options={ "url": "jdbc:mysql://your-mysql-host:3306/your-database", "user": "your-username", "password": "your-password", "dbtable": "sales_data", "partitionColumn": "sale_date", "lowerBound": "2024-01-01", "upperBound": "2024-12-31", "numPartitions": "10" } ) ``` ### 메모리 내 Python 데이터에서 DynamicFrame 생성 이 예제에서는 Python 목록, 튜플 또는 사전에서 DynamicFrame을 생성하는 방법을 보여줍니다. ``` from awsglue.context import GlueContext from awsglue.dynamicframe import DynamicFrame from pyspark.context import SparkContext from pyspark.sql import Row sc = SparkContext() glueContext = GlueContext(sc) # Method 1: From list of tuples data_tuples = [ ("John", "Doe", 30, "Engineer"), ("Jane", "Smith", 25, "Designer"), ("Bob", "Johnson", 35, "Manager") ] # Convert to RDD of Rows rdd = sc.parallelize([Row(first_name=row[0], last_name=row[1], age=row[2], job=row[3]) for row in data_tuples]) df = glueContext.spark_session.createDataFrame(rdd) dyf_from_tuples = DynamicFrame.fromDF(df, glueContext, "employees_from_tuples") # Method 2: From list of dictionaries data_dicts = [ {"product_id": 1, "product_name": "Laptop", "price": 999.99, "category": "Electronics"}, {"product_id": 2, "product_name": "Book", "price": 19.99, "category": "Education"}, {"product_id": 3, "product_name": "Chair", "price": 149.99, "category": "Furniture"} ] df_from_dicts = glueContext.spark_session.createDataFrame(data_dicts) dyf_from_dicts = DynamicFrame.fromDF(df_from_dicts, glueContext, "products_from_dicts") # Method 3: From nested data structures nested_data = [ { "customer_id": 1, "customer_info": { "name": "Alice Brown", "email": "alice@example.com" }, "orders": [ {"order_id": 101, "amount": 250.00}, {"order_id": 102, "amount": 175.50} ] } ] df_nested = glueContext.spark_session.createDataFrame(nested_data) dyf_nested = DynamicFrame.fromDF(df_nested, glueContext, "customers_with_orders") ``` ### 대규모 데이터 세트 성능 최적화 대규모 데이터 세트 사용 시에 고려할 성능 최적화 기법: ``` # Use partitioning for parallel reads large_table_dyf = glueContext.create_dynamic_frame.from_options( connection_type="postgresql", connection_options={ "url": "jdbc:postgresql://your-postgres-host:5432/your-database", "user": "your-username", "password": "your-password", "dbtable": "large_table", "partitionColumn": "id", "lowerBound": "1", "upperBound": "1000000", "numPartitions": "20" } ) # Use pushdown predicates to filter at source filtered_dyf = glueContext.create_dynamic_frame.from_options( connection_type="mysql", connection_options={ "url": "jdbc:mysql://your-mysql-host:3306/your-database", "user": "your-username", "password": "your-password", "dbtable": "transactions" }, push_down_predicate="transaction_date >= '2024-01-01'" ) ``` ## errorsCount `errorsCount( )` - `DynamicFrame`의 전체 오류 수를 반환합니다. ## stageErrorsCount `stageErrorsCount` - 이 `DynamicFrame`을 생성하는 과정에서 발생한 오류 수를 반환합니다. # DynamicFrameCollection 클래스 `DynamicFrameCollection`는 키가 `DynamicFrames`의 이름이고 값이 `DynamicFrame` 객체인 [DynamicFrame 클래스](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md) 객체의 목록입니다. ## \$1\$1init\$1\$1 **`__init__(dynamic_frames, glue_ctx)`** + `dynamic_frames` – [DynamicFrame 클래스](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md) 객체의 딕셔너리입니다. + `glue_ctx` – [GlueContext 클래스](aws-glue-api-crawler-pyspark-extensions-glue-context.md) 객체입니다. ## 키 `keys( )` - 이 컬렉션에 키 목록을 반환합니다. 일반적으로 `DynamicFrame` 값과 대응하는 이름을 포함합니다. ## 값 `values(key)` - 이 컬렉션에 `DynamicFrame` 값의 목록을 반환합니다. ## Select **`select(key)`** 지정된 키(일반적으로 `DynamicFrame`의 이름)에 해당되는 `DynamicFrame`를 반환합니다. + `key` - `DynamicFrameCollection`의 키이고 보통 `DynamicFrame`의 이름을 나타냅니다. ## 맵 **`map(callable, transformation_ctx="")`** 입장 함수를 사용하여 이 컬렉션의 `DynamicFrames` 기반 새로운 `DynamicFrameCollection`를 생성하고 반환합니다. + `callable` - `DynamicFrame`과 지정 변환 내용을 파라미터로 여기고 `DynamicFrame`을 반환하는 함수입니다. + `transformation_ctx` - 호출 기능에 사용되는 변환 내용입니다(선택 사항). ## flatmap **`flatmap(f, transformation_ctx="")`** 입장 함수를 사용하여 이 컬렉션의 `DynamicFrames` 기반 새로운 `DynamicFrameCollection`를 생성하고 반환합니다. + `f` – `DynamicFrame`을 파라미터로 여기고 `DynamicFrame` 혹은 `DynamicFrameCollection`을 반환하는 함수입니다. + `transformation_ctx` - 함수에 사용되는 변환 내용입니다(선택 사항). # DynamicFrameWriter 클래스 ## 메서드 + [\$1\$1init\$1\$1](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-writer-__init__) + [from\$1options](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-writer-from_options) + [from\$1catalog](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-writer-from_catalog) + [from\$1jdbc\$1conf](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-writer-from_jdbc_conf) ## \$1\$1init\$1\$1 **`__init__(glue_context)`** + `glue_context` – 사용할 [GlueContext 클래스](aws-glue-api-crawler-pyspark-extensions-glue-context.md)입니다. ## from\$1options **`from_options(frame, connection_type, connection_options={}, format=None, format_options={}, transformation_ctx="")`** 지정한 연결 및 포맷을 사용하여 `DynamicFrame`를 작성합니다. + `frame` - 작성할 `DynamicFrame`입니다. + `connection_type` - 연결 유형입니다. 유효한 값에는 `s3`, `mysql`, `postgresql`, `redshift`, `sqlserver` 및 `oracle`가 있습니다. + `connection_options` - 경로 및 데이터베이스 테이블과 같은 연결 옵션입니다(선택 사항). `s3`의 `connection_type`의 경우, Amazon S3 경로가 정의됩니다. ``` connection_options = {"path": "s3://aws-glue-target/temp"} ``` JDBC 연결의 경우, 몇 까지 속성이 정의되어야 합니다. 단, 데이터베이스 이름이 URL의 일부여야 합니다. 연결 옵션에 선택적으로 포함될 수 있습니다. **주의** 스크립트에 암호를 저장하는 것은 권장되지 않습니다. AWS Secrets Manager 또는 AWS Glue 데이터 카탈로그에서 데이터를 검색할 때 `boto3` 사용을 고려합니다. ``` connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path"} ``` `dbtable` 속성은 JDBC 테이블의 이름입니다. 데이터베이스 내의 스키마를 지원하는 JDBC 데이터 스토어의 경우 `schema.table-name`에 대해 지정합니다. 스키마가 제공되지 않으면 기본 "퍼블릭" 스키마가 사용됩니다. 자세한 내용은 [AWS Glue for Spark에서 ETL에 대한 연결 유형 및 옵션](aws-glue-programming-etl-connect.md) 섹션을 참조하세요. + `format` - 포맷 사양입니다(선택 사항). 여러 포맷을 지원하는 Amazon Simple Storage Service(Amazon S3) 또는 AWS Glue 연결에 사용됩니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하십시오. + `format_options` - 지정된 포맷에 대한 포맷 옵션입니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하십시오. + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). ## from\$1catalog **`from_catalog(frame, name_space, table_name, redshift_tmp_dir="", transformation_ctx="")`** 지정한 카탈로그 데이터베이스 및 테이블 이름을 사용하여 `DynamicFrame`를 작성합니다. + `frame` - 작성할 `DynamicFrame`입니다. + `name_space` - 사용할 데이터베이스입니다. + `table_name` – 사용할 `table_name`입니다. + `redshift_tmp_dir` – 사용할 Amazon Redshift 임시 디렉터리입니다(선택 사항). + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). + `additional_options` - AWS Glue에 제공되는 추가 옵션입니다. Lake Formation 관리형 테이블에 쓰려면 다음과 같은 추가 옵션을 사용할 수 있습니다. + `transactionId` - (문자열) 관리형 테이블에 쓰기를 수행할 트랜잭션 ID입니다. 이 트랜잭션은 이미 커밋되거나 중단되었을 수 없습니다. 그렇지 않으면 쓰기에 실패합니다. + `callDeleteObjectsOnCancel ` - (부울, 선택 사항) `true`(기본값)로 설정된 경우 AWS Glue는 객체가 Amazon S3에 기록된 후 `DeleteObjectsOnCancel` API를 자동으로 호출합니다. 자세한 내용은 *AWS Lake Formation 개발자 가이드*의 [DeleteObjectsOnCancel](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-transactions-api.html#aws-lake-formation-api-transactions-api-DeleteObjectsOnCancel)을 참조하세요. **Example 예: Lake Formation의 관리형 테이블에 쓰기** ``` txId = glueContext.start_transaction(read_only=False) glueContext.write_dynamic_frame.from_catalog( frame=dyf, database = db, table_name = tbl, transformation_ctx = "datasource0", additional_options={"transactionId":txId}) ... glueContext.commit_transaction(txId) ``` ## from\$1jdbc\$1conf **`from_jdbc_conf(frame, catalog_connection, connection_options={}, redshift_tmp_dir = "", transformation_ctx="")`** 지정한 JDBC 연결 정보를 사용하여 `DynamicFrame`를 작성합니다. + `frame` - 작성할 `DynamicFrame`입니다. + `catalog_connection` - 사용할 카탈로그 연결입니다. + `connection_options` - 경로 및 데이터베이스 테이블과 같은 연결 옵션입니다(선택 사항). + `redshift_tmp_dir` – 사용할 Amazon Redshift 임시 디렉터리입니다(선택 사항). + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). ## write\$1dynamic\$1frame의 예 이 예에서는 `connection_options`의 POSIX 경로 인수와 함께 S3의 `connection_type`을 사용하여 로컬 스토리지에 쓰기를 허용하는 출력을 로컬로 씁니다. ``` glueContext.write_dynamic_frame.from_options(\ frame = dyf_splitFields,\ connection_options = {'path': '/home/glue/GlueLocalOutput/'},\ connection_type = 's3',\ format = 'json') ``` # DynamicFrameReader 클래스 ## - 메서드 - + [\$1\$1init\$1\$1](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-__init__) + [from\$1rdd](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_rdd) + [from\$1options](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_options) + [from\$1catalog](#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_catalog) ## \$1\$1init\$1\$1 **`__init__(glue_context)`** + `glue_context` – 사용할 [GlueContext 클래스](aws-glue-api-crawler-pyspark-extensions-glue-context.md)입니다. ## from\$1rdd **`from_rdd(data, name, schema=None, sampleRatio=None)`** 탄력적 분산형 데이터셋(RDD)로부터 `DynamicFrame`을 판독합니다. + `data` - 읽어야 할 데이터 집합입니다. + `name` - 읽어야 할 이름입니다. + `schema` - 판독할 스키마입니다(선택 사항). + `sampleRatio` - 사용할 예제 비율입니다(선택 사항). ## from\$1options **`from_options(connection_type, connection_options={}, format=None, format_options={}, transformation_ctx="")`** 지정한 연결 및 포맷을 사용하여 `DynamicFrame`를 판독합니다. + `connection_type` - 연결 유형입니다. 유효한 값에는 `s3`, `mysql`, `postgresql`, `redshift`, `sqlserver`, `oracle`, `dynamodb`, `snowflake`가 있습니다. + `connection_options` - 경로 및 데이터베이스 테이블과 같은 연결 옵션입니다(선택 사항). 자세한 내용은 [Spark를 위한 AWS Glue의 ETL 연결 유형 및 옵션](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-connect.html)을 참조하세요. `s3`의 `connection_type`의 경우, Amazon S3 경로가 배열에 정의됩니다. ``` connection_options = {"paths": [ "s3://amzn-s3-demo-bucket/object_a", "s3://amzn-s3-demo-bucket/object_b"]} ``` JDBC 연결의 경우, 몇 까지 속성이 정의되어야 합니다. 단, 데이터베이스 이름이 URL의 일부여야 합니다. 연결 옵션에 선택적으로 포함될 수 있습니다. **주의** 스크립트에 암호를 저장하는 것은 권장되지 않습니다. AWS Secrets Manager 또는 AWS Glue 데이터 카탈로그에서 데이터를 검색할 때 `boto3` 사용을 고려합니다. ``` connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path"} ``` 병렬 읽기를 수행하는 JDBC 연결의 경우 해시 필드 옵션을 설정할 수 있습니다. 예: ``` connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path" , "hashfield": "month"} ``` 자세한 내용은 [JDBC 테이블을 병렬로 읽기](run-jdbc-parallel-read-job.md) 섹션을 참조하세요. + `format` - 포맷 사양입니다(선택 사항). 여러 포맷을 지원하는 Amazon Simple Storage Service(Amazon S3) 또는 AWS Glue 연결에 사용됩니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하십시오. + `format_options` - 지정된 포맷에 대한 포맷 옵션입니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하십시오. + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). + `push_down_predicate` - 데이터 집합 내 모든 파일을 나열하거나 읽지 않아도 파티션에 필터링할 수 있습니다. 자세한 내용은 [푸시다운 조건자를 사용하여 사전 필터링](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-pushdowns)을 참조하세요. ## from\$1catalog **`from_catalog(database, table_name, redshift_tmp_dir="", transformation_ctx="", push_down_predicate="", additional_options={})`** 지정한 카탈로그 네임스페이스 및 테이블 이름을 사용하여 `DynamicFrame`를 판독합니다. + `database` - 읽어야 할 데이터베이스입니다. + `table_name` - 읽어올 테이블의 이름입니다. + `redshift_tmp_dir` – 사용할 Amazon Redshift 임시 디렉터리(Redshift에서 데이터를 읽지 않는 경우 선택 사항)입니다. + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). + `push_down_predicate` - 데이터 집합 내 모든 파일을 나열하거나 읽지 않아도 파티션에 필터링할 수 있습니다. 자세한 내용은 [푸시다운 조건자를 사용하여 예비 필터링](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns) 섹션을 참조하세요. + `additional_options` - AWS Glue에 제공되는 추가 옵션입니다. + 병렬 읽기를 수행하는 JDBC 연결을 사용하기 위해 `hashfield`, `hashexpression` 또는 `hashpartitions` 옵션을 설정할 수 있습니다. 예: ``` additional_options = {"hashfield": "month"} ``` 자세한 내용은 [JDBC 테이블을 병렬로 읽기](run-jdbc-parallel-read-job.md) 섹션을 참조하세요. + 인덱스 열을 기준으로 필터링할 카탈로그 표현식을 전달하려면 `catalogPartitionPredicate` 옵션을 볼 수 있습니다. `catalogPartitionPredicate` - 카탈로그 표현식을 전달하여 인덱스 열을 기준으로 필터링할 수 있습니다. 이렇게 하면 필터링이 서버 측으로 푸시됩니다. 자세한 내용은 [AWS Glue 파티션 인덱스](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html)를 참조하세요. `push_down_predicate`와 `catalogPartitionPredicate`는 다른 구문을 사용합니다. 전자는 Spark SQL 표준 구문을 사용하고 후자는 JSQL 구문 분석기를 사용합니다. 자세한 내용은 [AWS Glue에서 ETL 출력의 파티션 관리](aws-glue-programming-etl-partitions.md) 섹션을 참조하세요. # GlueContext 클래스 Apache Spark [SparkContext](https://spark.apache.org/docs/latest/api/java/org/apache/spark/SparkContext.html) 객체를 포함하여 Apache Spark 플랫폼과 상호작용하기 위한 원리를 제공합니다. ## \$1\$1init\$1\$1 **`__init__(sparkContext)`** + `sparkContext` - 사용할 아파치 스파크 내용입니다. ## 생성 중 + [\$1\$1init\$1\$1](#aws-glue-api-crawler-pyspark-extensions-glue-context-__init__) + [getSource](#aws-glue-api-crawler-pyspark-extensions-glue-context-get-source) + [create\$1dynamic\$1frame\$1from\$1rdd](#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_rdd) + [create\$1dynamic\$1frame\$1from\$1catalog](#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog) + [create\$1dynamic\$1frame\$1from\$1options](#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options) + [create\$1sample\$1dynamic\$1frame\$1from\$1catalog](#aws-glue-api-crawler-pyspark-extensions-glue-context-create-sample-dynamic-frame-from-catalog) + [create\$1sample\$1dynamic\$1frame\$1from\$1options](#aws-glue-api-crawler-pyspark-extensions-glue-context-create-sample-dynamic-frame-from-options) + [add\$1ingestion\$1time\$1columns](#aws-glue-api-crawler-pyspark-extensions-glue-context-add-ingestion-time-columns) + [create\$1data\$1frame\$1from\$1catalog](#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-catalog) + [create\$1data\$1frame\$1from\$1options](#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options) + [forEachBatch](#aws-glue-api-crawler-pyspark-extensions-glue-context-forEachBatch) ## getSource **`getSource(connection_type, transformation_ctx = "", **options)`** 외부 소스에서 `DataSource`를 읽을 때 사용되는 `DynamicFrames` 객체를 생성합니다. + `connection_type` - Amazon Simple Storage Service(Amazon S3), Amazon Redshift 및 JDBC와 같이 사용할 연결 유형입니다. 유효한 값에는 `s3`, `mysql`, `postgresql`, `redshift`, `sqlserver`, `oracle` 및 `dynamodb`가 있습니다. + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). + `options` - 선택적 이름-값 페어의 모음입니다. 자세한 내용은 [AWS Glue for Spark에서 ETL에 대한 연결 유형 및 옵션](aws-glue-programming-etl-connect.md) 섹션을 참조하세요. 다음은 `getSource`를 사용한 예입니다. ``` >>> data_source = context.getSource("file", paths=["/in/path"]) >>> data_source.setFormat("json") >>> myFrame = data_source.getFrame() ``` ## create\$1dynamic\$1frame\$1from\$1rdd **`create_dynamic_frame_from_rdd(data, name, schema=None, sample_ratio=None, transformation_ctx="")`** Apache Spark Resilient Distributed Dataset(RDD)로부터 생성된 `DynamicFrame`을 반환합니다. + `data` - 사용할 데이터 원본입니다. + `name` - 사용할 데이터 이름입니다. + `schema` - 사용할 스키마입니다(선택 사항). + `sample_ratio` - 사용할 예제 비율입니다(선택 사항). + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). ## create\$1dynamic\$1frame\$1from\$1catalog **`create_dynamic_frame_from_catalog(database, table_name, redshift_tmp_dir, transformation_ctx = "", push_down_predicate= "", additional_options = {}, catalog_id = None)`** 데이터 카탈로그 데이터베이스 및 테이블 이름을 사용하여 생성된 `DynamicFrame`을 반환합니다. 이 메서드를 사용하는 경우 지정된 AWS Glue 데이터 카탈로그 테이블의 테이블 속성을 통해 `format_options`를 제공하고, `additional_options` 인수를 통해 기타 옵션을 제공합니다. + `Database` - 읽어야 할 데이터베이스입니다. + `table_name` - 읽어올 테이블의 이름입니다. + `redshift_tmp_dir` – 사용할 Amazon Redshift 임시 디렉터리입니다(선택 사항). + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). + `push_down_predicate` - 데이터 집합 내 모든 파일을 나열하거나 읽지 않아도 파티션에 필터링할 수 있습니다. 지원되는 소스 및 제한 사항은 [AWS Glue ETL의 푸시다운으로 읽기 최적화](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-pushdown.html)를 참조하세요. 자세한 내용은 [푸시다운 조건자를 사용하여 예비 필터링](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns) 섹션을 참조하세요. + `additional_options` - 선택적 이름-값 페어의 모음입니다. 가능한 옵션에는 [AWS Glue for Spark에서 ETL에 대한 연결 유형 및 옵션](aws-glue-programming-etl-connect.md)에 나열된 옵션이 포함됩니다(`endpointUrl`, `streamName`, `bootstrap.servers`, `security.protocol`, `topicName`, `classification` 및 `delimiter` 제외). 지원되는 또 다른 옵션은 `catalogPartitionPredicate`입니다. `catalogPartitionPredicate` - 카탈로그 표현식을 전달하여 인덱스 열을 기준으로 필터링할 수 있습니다. 이렇게 하면 필터링이 서버 측으로 푸시됩니다. 자세한 내용은 [AWS Glue 파티션 인덱스](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html)를 참조하세요. `push_down_predicate`와 `catalogPartitionPredicate`는 다른 구문을 사용합니다. 전자는 Spark SQL 표준 구문을 사용하고 후자는 JSQL 구문 분석기를 사용합니다. + `catalog_id` - 액세스 중인 데이터 카탈로그의 카탈로그 ID(계정 ID)입니다. None인 경우 호출자의 기본 계정 ID가 사용됩니다. ## create\$1dynamic\$1frame\$1from\$1options **`create_dynamic_frame_from_options(connection_type, connection_options={}, format=None, format_options={}, transformation_ctx = "")`** 지정된 연결 및 포맷으로 생성된 `DynamicFrame`을 반환합니다. + `connection_type` - Amazon S3, Amazon Redshift 및 JDBC 등의 연결 유형입니다. 유효한 값에는 `s3`, `mysql`, `postgresql`, `redshift`, `sqlserver`, `oracle` 및 `dynamodb`가 있습니다. + `connection_options` - 경로 및 데이터베이스 테이블과 같은 연결 옵션(선택 사항). `s3`의 `connection_type`인 경우, Amazon S3 경로 목록이 정의됩니다. ``` connection_options = {"paths": ["s3://aws-glue-target/temp"]} ``` JDBC 연결의 경우, 몇 까지 속성이 정의되어야 합니다. 단, 데이터베이스 이름이 URL의 일부여야 합니다. 연결 옵션에 선택적으로 포함될 수 있습니다. **주의** 스크립트에 암호를 저장하는 것은 권장되지 않습니다. AWS Secrets Manager 또는 AWS Glue 데이터 카탈로그에서 데이터를 검색할 때 `boto3` 사용을 고려합니다. ``` connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path"} ``` `dbtable` 속성은 JDBC 테이블의 이름입니다. 데이터베이스 내의 스키마를 지원하는 JDBC 데이터 스토어의 경우 `schema.table-name`에 대해 지정합니다. 스키마가 제공되지 않으면 기본 "퍼블릭" 스키마가 사용됩니다. 자세한 내용은 [AWS Glue for Spark에서 ETL에 대한 연결 유형 및 옵션](aws-glue-programming-etl-connect.md) 섹션을 참조하세요. + `format` - 형식 사양. 여러 포맷을 지원하는 Amazon S3 또는 AWS Glue 연결에 사용됩니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하십시오. + `format_options` - 지정된 포맷에 대한 포맷 옵션입니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하십시오. + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). + `push_down_predicate` - 데이터 집합 내 모든 파일을 나열하거나 읽지 않아도 파티션에 필터링할 수 있습니다. 지원되는 소스 및 제한 사항은 [AWS Glue ETL의 푸시다운으로 읽기 최적화](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-pushdown.html)를 참조하세요. 자세한 내용은 [푸시다운 조건자를 사용하여 사전 필터링](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-pushdowns)을 참조하세요. ## create\$1sample\$1dynamic\$1frame\$1from\$1catalog **`create_sample_dynamic_frame_from_catalog(database, table_name, num, redshift_tmp_dir, transformation_ctx = "", push_down_predicate= "", additional_options = {}, sample_options = {}, catalog_id = None)`** 데이터 카탈로그 데이터베이스와 테이블 이름을 사용하여 생성된 샘플 `DynamicFrame`을 반환합니다. `DynamicFrame`에는 데이터 소스의 첫 번째 `num` 레코드만 포함됩니다. + `database` - 읽어야 할 데이터베이스입니다. + `table_name` - 읽어올 테이블의 이름입니다. + `num` - 반환된 샘플 동적 프레임의 최대 레코드 수입니다. + `redshift_tmp_dir` – 사용할 Amazon Redshift 임시 디렉터리입니다(선택 사항). + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). + `push_down_predicate` - 데이터 집합 내 모든 파일을 나열하거나 읽지 않아도 파티션에 필터링할 수 있습니다. 자세한 내용은 [푸시다운 조건자를 사용하여 예비 필터링](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns) 섹션을 참조하세요. + `additional_options` - 선택적 이름-값 페어의 모음입니다. 가능한 옵션에는 [AWS Glue for Spark에서 ETL에 대한 연결 유형 및 옵션](aws-glue-programming-etl-connect.md)에 나열된 옵션이 포함됩니다(`endpointUrl`, `streamName`, `bootstrap.servers`, `security.protocol`, `topicName`, `classification` 및 `delimiter` 제외). + `sample_options` - 샘플링 동작을 제어하는 파라미터(선택 사항)입니다. Amazon S3 소스에 현재 사용 가능한 파라미터: + `maxSamplePartitions` - 샘플링에서 읽을 최대 파티션 수입니다. 기본값은 10입니다. + `maxSampleFilesPerPartition` - 샘플링이 한 파티션에서 읽을 최대 파일 수입니다. 기본값은 10입니다. 이러한 파라미터는 파일 나열에 소요되는 시간을 줄이는 데 도움이 됩니다. 예를 들어 데이터 세트에 1,000개의 파티션이 있고 각 파티션에 10개의 파일이 있다고 가정합니다. `maxSamplePartitions` = 10 및 `maxSampleFilesPerPartition` = 10으로 설정하면 10,000개의 파일을 모두 나열하는 대신 샘플링은 각각에 처음 10개의 파일이 있는 처음 10개의 파티션만 나열하고 읽습니다(10\$110 = 총 100개의 파일). + `catalog_id` - 액세스 중인 데이터 카탈로그의 카탈로그 ID(데이터 카탈로그의 계정 ID)입니다. 기본적으로 `None`으로 설정됩니다. `None`인 경우 서비스에 있는 호출 계정의 카탈로그 ID가 기본 설정됩니다. ## create\$1sample\$1dynamic\$1frame\$1from\$1options **`create_sample_dynamic_frame_from_options(connection_type, connection_options={}, num, sample_options={}, format=None, format_options={}, transformation_ctx = "")`** 지정된 연결과 형식으로 생성된 샘플 `DynamicFrame`을 반환합니다. `DynamicFrame`에는 데이터 소스의 첫 번째 `num` 레코드만 포함됩니다. + `connection_type` - Amazon S3, Amazon Redshift 및 JDBC 등의 연결 유형입니다. 유효한 값에는 `s3`, `mysql`, `postgresql`, `redshift`, `sqlserver`, `oracle` 및 `dynamodb`가 있습니다. + `connection_options` - 경로 및 데이터베이스 테이블과 같은 연결 옵션(선택 사항). 자세한 내용은 [AWS Glue for Spark에서 ETL에 대한 연결 유형 및 옵션](aws-glue-programming-etl-connect.md) 섹션을 참조하세요. + `num` - 반환된 샘플 동적 프레임의 최대 레코드 수입니다. + `sample_options` - 샘플링 동작을 제어하는 파라미터(선택 사항)입니다. Amazon S3 소스에 현재 사용 가능한 파라미터: + `maxSamplePartitions` - 샘플링에서 읽을 최대 파티션 수입니다. 기본값은 10입니다. + `maxSampleFilesPerPartition` - 샘플링이 한 파티션에서 읽을 최대 파일 수입니다. 기본값은 10입니다. 이러한 파라미터는 파일 나열에 소요되는 시간을 줄이는 데 도움이 됩니다. 예를 들어 데이터 세트에 1,000개의 파티션이 있고 각 파티션에 10개의 파일이 있다고 가정합니다. `maxSamplePartitions` = 10 및 `maxSampleFilesPerPartition` = 10으로 설정하면 10,000개의 파일을 모두 나열하는 대신 샘플링은 각각에 처음 10개의 파일이 있는 처음 10개의 파티션만 나열하고 읽습니다(10\$110 = 총 100개의 파일). + `format` - 형식 사양. 여러 포맷을 지원하는 Amazon S3 또는 AWS Glue 연결에 사용됩니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하십시오. + `format_options` - 지정된 포맷에 대한 포맷 옵션입니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하십시오. + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). + `push_down_predicate` - 데이터 집합 내 모든 파일을 나열하거나 읽지 않아도 파티션에 필터링할 수 있습니다. 자세한 내용은 [푸시다운 조건자를 사용하여 예비 필터링](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns) 섹션을 참조하세요. ## add\$1ingestion\$1time\$1columns **`add_ingestion_time_columns(dataFrame, timeGranularity = "")`** 입력 `DataFrame`에 `ingest_year`, `ingest_month`, `ingest_day`, `ingest_hour`, `ingest_minute`와 같은 수집 시간 열을 추가합니다. 이 함수는 Amazon S3을 대상으로 하는 데이터 카탈로그 테이블을 지정할 때 AWS Glue가 생성하는 스크립트에서 자동으로 생성됩니다. 이 함수는 출력 테이블의 수집 시간 열로 파티션을 자동으로 업데이트합니다. 이를 통해 입력 데이터에 명시적인 수집 시간 열을 요구하지 않고도 출력 데이터를 수집 시간에 자동으로 분할할 수 있습니다. + `dataFrame` - 수집 시간 열을 추가할 `dataFrame`입니다. + `timeGranularity` - 시간 열의 세분성입니다. 유효 값은 "`day`", "`hour`" 및 "`minute`"입니다. 예를 들어 "`hour`"가 함수에 전달되면 원래 `dataFrame`에 "`ingest_year`", "`ingest_month`", "`ingest_day`" 및 "`ingest_hour`" 시간 열이 추가됩니다. 시간 세분성 열을 추가한 후 데이터 프레임을 반환합니다. 예제: ``` dynamic_frame = DynamicFrame.fromDF(glueContext.add_ingestion_time_columns(dataFrame, "hour")) ``` ## create\$1data\$1frame\$1from\$1catalog **`create_data_frame_from_catalog(database, table_name, transformation_ctx = "", additional_options = {})`** 데이터 카탈로그 테이블의 정보를 사용하여 생성된 `DataFrame`을 반환합니다. + `database` - 읽을 데이터 카탈로그 데이터베이스입니다. + `table_name` - 읽을 데이터 카탈로그 테이블의 이름입니다. + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). + `additional_options` - 선택적 이름-값 페어의 모음입니다. 가능한 옵션에는 스트리밍 소스에 대해 [AWS Glue for Spark에서 ETL에 대한 연결 유형 및 옵션](aws-glue-programming-etl-connect.md)에 나열된 옵션(예: `startingPosition`, `maxFetchTimeInMs`, `startingOffsets`)이 있습니다. + `useSparkDataSource` - true로 설정하면 AWS Glue는 네이티브 Spark 데이터 소스 API를 사용하여 테이블을 읽도록 강제 적용합니다. Spark 데이터 소스 API는 AVRO, 바이너리, CSV, JSON, ORC, Parquet 및 텍스트 형식을 지원합니다. 데이터 카탈로그 테이블에서는 `classification` 속성을 사용하여 형식을 지정합니다. Spark 데이터 소스 API에 대한 자세한 내용은 공식 [Apache Spark 설명서](https://spark.apache.org/docs/latest/sql-data-sources-load-save-functions.html)를 참조하세요. `create_data_frame_from_catalog`를 `useSparkDataSource`와 함께 사용하면 다음과 같은 이점이 있습니다. + `DataFrame`을 직접 반환하고 `create_dynamic_frame.from_catalog().toDF()`에 대한 대안을 제공합니다. + 기본 형식에 대한 AWS Lake Formation 테이블 수준 권한 제어를 지원합니다. + AWS Lake Formation 테이블 수준 권한 제어 없이 데이터 레이크 형식 읽기를 지원합니다. 자세한 내용은 [AWS Glue ETL 작업에서 데이터 레이크 프레임워크 사용](aws-glue-programming-etl-datalake-native-frameworks.md) 섹션을 참조하세요. `useSparkDataSource`를 활성화하면 필요에 따라 `additional_options`에서 [Spark 데이터 소스 옵션](https://spark.apache.org/docs/latest/sql-data-sources.html)을 추가할 수도 있습니다. AWS Glue는 이러한 옵션을 Spark 리더에 직접 전달합니다. + `useCatalogSchema` - true로 설정하면 AWS Glue는 결과 `DataFrame`에 데이터 카탈로그 스키마를 적용합니다. 그렇지 않으면 리더는 데이터에서 스키마를 추론합니다. 또한 `useCatalogSchema`를 활성화할 경우 `useSparkDataSource`를 true로 설정해야 합니다. **제한 사항 ** `useSparkDataSource` 옵션을 사용할 경우 다음과 같은 제한 사항을 고려하세요. + `useSparkDataSource`를 사용하면 AWS Glue에서는 원래 Spark 세션과 다른 별도의 Spark 세션에 새 `DataFrame`을 만듭니다. + Spark DataFrame 파티션 필터링은 다음 AWS Glue 기능에서 작동하지 않습니다. + [작업 북마크](monitor-continuations.md) + [Amazon S3 스토리지 클래스 제외](aws-glue-programming-etl-storage-classes.md#aws-glue-programming-etl-storage-classes-dynamic-frame) + [카탈로그 파티션 조건자](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-cat-predicates) 이러한 기능에 파티션 필터링을 사용하려면 AWS Glue 푸시다운 조건자를 사용할 수 있습니다. 자세한 내용은 [푸시다운 조건자를 사용하여 예비 필터링](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns) 섹션을 참조하세요. 분할되지 않은 열에 대한 필터링에는 영향을 주지 않습니다. 다음 예제 스크립트는 `excludeStorageClasses` 옵션을 사용하여 파티션 필터링을 수행하는 잘못된 방법을 보여줍니다. ``` // Incorrect partition filtering using Spark filter with excludeStorageClasses read_df = glueContext.create_data_frame.from_catalog( database=database_name, table_name=table_name, additional_options = { "useSparkDataSource": True, "excludeStorageClasses" : ["GLACIER", "DEEP_ARCHIVE"] } ) // Suppose year and month are partition keys. // Filtering on year and month won't work, the filtered_df will still // contain data with other year/month values. filtered_df = read_df.filter("year == '2017 and month == '04' and 'state == 'CA'") ``` 다음 예제 스크립트는 `excludeStorageClasses` 옵션을 사용하여 파티션 필터링을 수행하기 위해 푸시다운 조건자를 사용하는 올바른 방법을 보여줍니다. ``` // Correct partition filtering using the AWS Glue pushdown predicate // with excludeStorageClasses read_df = glueContext.create_data_frame.from_catalog( database=database_name, table_name=table_name, // Use AWS Glue pushdown predicate to perform partition filtering push_down_predicate = "(year=='2017' and month=='04')" additional_options = { "useSparkDataSource": True, "excludeStorageClasses" : ["GLACIER", "DEEP_ARCHIVE"] } ) // Use Spark filter only on non-partitioned columns filtered_df = read_df.filter("state == 'CA'") ``` **예: Spark 데이터 소스 리더를 사용하여 CSV 테이블 생성** ``` // Read a CSV table with '\t' as separator read_df = glueContext.create_data_frame.from_catalog( database=, table_name=, additional_options = {"useSparkDataSource": True, "sep": '\t'} ) ``` ## create\$1data\$1frame\$1from\$1options **`create_data_frame_from_options(connection_type, connection_options={}, format=None, format_options={}, transformation_ctx = "")`** 이 API는 이제 더 이상 사용되지 않습니다. 대신에 `getSource()` API를 사용하십시오. 지정된 연결 및 포맷으로 생성된 `DataFrame`을 반환합니다. 이 함수는 AWS Glue 스트리밍 소스에만 사용합니다. + `connection_type` - 스트리밍 연결 유형입니다. 유효한 값에는 `kinesis` 및 `kafka`(이)가 있습니다. + `connection_options` - Kinesis 및 Kafka에 대해 서로 다른 연결 옵션입니다. [AWS Glue for Spark에서 ETL에 대한 연결 유형 및 옵션](aws-glue-programming-etl-connect.md)에서 각 스트리밍 데이터 원본에 대한 모든 연결 옵션 목록을 찾을 수 있습니다. 스트리밍 연결 옵션에는 다음과 같은 차이점이 있습니다. + Kinesis 스트리밍 소스에는 `streamARN`, `startingPosition`, `inferSchema` 및 `classification`이 필요합니다. + Kafka 스트리밍 소스에는 `connectionName`, `topicName`, `startingOffsets`, `inferSchema` 및 `classification`이 필요합니다. + `format` - 형식 사양. 여러 포맷을 지원하는 Amazon S3 또는 AWS Glue 연결에 사용됩니다. 지원되는 포맷에 관한 내용은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)섹션을 참조하세요. + `format_options` - 지정된 포맷에 대한 포맷 옵션입니다. 지원되는 포맷 옵션에 대한 자세한 내용은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md) 섹션을 참조하세요. + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). Amazon Kinesis 스트리밍 소스의 예: ``` kinesis_options = { "streamARN": "arn:aws:kinesis:us-east-2:777788889999:stream/fromOptionsStream", "startingPosition": "TRIM_HORIZON", "inferSchema": "true", "classification": "json" } data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kinesis", connection_options=kinesis_options) ``` Kafka 스트리밍 소스의 예: ``` kafka_options = { "connectionName": "ConfluentKafka", "topicName": "kafka-auth-topic", "startingOffsets": "earliest", "inferSchema": "true", "classification": "json" } data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kafka", connection_options=kafka_options) ``` ## forEachBatch **`forEachBatch(frame, batch_function, options)`** 스트리밍 소스에서 읽는 모든 마이크로 배치에 전달된 `batch_function`을 적용합니다. + `frame` - 현재 마이크로 배치를 포함하는 DataFrame입니다. + `batch_function` - 모든 마이크로 배치에 적용될 함수입니다. + `options` - 마이크로 배치를 처리하는 방법에 대한 정보가 들어 있는 키-값 페어 컬렉션입니다. 다음 옵션이 필요합니다. + `windowSize` - 각 배치를 처리하는 데 소요되는 시간입니다. + `checkpointLocation` - 스트리밍 ETL 작업에 대해 체크포인트가 저장되는 위치입니다. + `batchMaxRetries` – 실패한 경우 배치를 다시 시도할 수 있는 최대 횟수입니다. 기본값은 3입니다. 이 옵션은 Glue 버전 2.0 이상에서만 구성할 수 있습니다. **예시:** ``` glueContext.forEachBatch( frame = data_frame_datasource0, batch_function = processBatch, options = { "windowSize": "100 seconds", "checkpointLocation": "s3://kafka-auth-dataplane/confluent-test/output/checkpoint/" } ) def processBatch(data_frame, batchId): if (data_frame.count() > 0): datasource0 = DynamicFrame.fromDF( glueContext.add_ingestion_time_columns(data_frame, "hour"), glueContext, "from_data_frame" ) additionalOptions_datasink1 = {"enableUpdateCatalog": True} additionalOptions_datasink1["partitionKeys"] = ["ingest_yr", "ingest_mo", "ingest_day"] datasink1 = glueContext.write_dynamic_frame.from_catalog( frame = datasource0, database = "tempdb", table_name = "kafka-auth-table-output", transformation_ctx = "datasink1", additional_options = additionalOptions_datasink1 ) ``` ## Amazon S3의 데이터 집합 작업 + [purge\$1table](#aws-glue-api-crawler-pyspark-extensions-glue-context-purge_table) + [purge\$1s3\$1path](#aws-glue-api-crawler-pyspark-extensions-glue-context-purge_s3_path) + [transition\$1table](#aws-glue-api-crawler-pyspark-extensions-glue-context-transition_table) + [transition\$1s3\$1path](#aws-glue-api-crawler-pyspark-extensions-glue-context-transition_s3_path) ## purge\$1table **`purge_table(catalog_id=None, database="", table_name="", options={}, transformation_ctx="")`** 지정된 카탈로그의 데이터베이스 및 테이블에 대한 파일을 Amazon S3에서 삭제합니다. 파티션의 모든 파일을 삭제하면 해당 파티션도 카탈로그에서 삭제됩니다. Lake Formation에 등록된 테이블에 대해서는 purge\$1table 작업을 지원하지 않습니다. 삭제된 객체를 복구하려면 Amazon S3 버킷에서 [객체 버전 관리](https://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectVersioning.html)를 설정할 수 있습니다. 객체 버전 관리가 활성화되어 있지 않은 버킷에서 객체를 삭제하는 경우에는 객체를 복구할 수 없습니다. 버전 관리가 사용되는 버킷에서 삭제된 객체를 복구하는 방법에 대한 자세한 내용은 AWS Support 지식 센터에서 [삭제된 Amazon S3 객체를 검색하려면 어떻게 해야 합니까?](https://aws.amazon.com/premiumsupport/knowledge-center/s3-undelete-configuration/)를 참조하세요. + `catalog_id` - 액세스 중인 데이터 카탈로그의 카탈로그 ID(데이터 카탈로그의 계정 ID)입니다. 기본적으로 `None`으로 설정됩니다. `None`인 경우 서비스에 있는 호출 계정의 카탈로그 ID가 기본 설정됩니다. + `database` - 사용할 데이터베이스입니다. + `table_name` - 사용할 테이블의 이름입니다. + `options` - 삭제할 파일 필터링 및 매니페스트 파일 생성을 위한 옵션입니다. + `retentionPeriod` - 파일을 보존할 기간(시간)을 지정합니다. 보존 기간 내의 파일은 유지됩니다. 기본적으로 168시간(7일)으로 설정됩니다. + `partitionPredicate` - 이 조건자를 충족하는 파티션이 삭제됩니다. 이러한 파티션에서 보존 기간 내에 있는 파일은 삭제되지 않습니다. 기본적으로 `""`(비움)로 설정합니다. + `excludeStorageClasses` – `excludeStorageClasses` 집합에 스토리지 클래스가 있는 파일은 삭제되지 않습니다. 기본값은 `Set()`(빈 집합)입니다. + `manifestFilePath` - 매니페스트 파일 생성을 위한 선택적 경로입니다. 성공적으로 제거된 모든 파일은 `Success.csv`에 기록되고 실패한 파일은 `Failed.csv`에 기록됩니다. + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). 매니페스트 파일 경로에 사용됩니다. **Example** ``` glueContext.purge_table("database", "table", {"partitionPredicate": "(month=='march')", "retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/"}) ``` ## purge\$1s3\$1path **`purge_s3_path(s3_path, options={}, transformation_ctx="")`** 지정된 Amazon S3 경로에서 파일을 재귀적으로 삭제합니다. 삭제된 객체를 복구하려면 Amazon S3 버킷에서 [객체 버전 관리](https://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectVersioning.html)를 설정할 수 있습니다. 객체 버전 관리가 설정되어 있지 않은 버킷에서 객체를 삭제하는 경우에는 객체를 복구할 수 없습니다. 버전 관리를 사용하여 버킷에서 삭제된 객체를 복구하는 방법에 대한 자세한 내용은 지원 지식 센터에서 [삭제된 Amazon S3 객체를 검색하려면 어떻게 해야 합니까?](https://aws.amazon.com/premiumsupport/knowledge-center/s3-undelete-configuration/)를 참조하세요. + `s3_path` - `s3:////` 포맷으로 삭제할 파일에 대한 Amazon S3의 경로입니다. + `options` - 삭제할 파일 필터링 및 매니페스트 파일 생성을 위한 옵션입니다. + `retentionPeriod` - 파일을 보존할 기간(시간)을 지정합니다. 보존 기간 내의 파일은 유지됩니다. 기본적으로 168시간(7일)으로 설정됩니다. + `excludeStorageClasses` – `excludeStorageClasses` 집합에 스토리지 클래스가 있는 파일은 삭제되지 않습니다. 기본값은 `Set()`(빈 집합)입니다. + `manifestFilePath` - 매니페스트 파일 생성을 위한 선택적 경로입니다. 성공적으로 제거된 모든 파일은 `Success.csv`에 기록되고 실패한 파일은 `Failed.csv`에 기록됩니다. + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). 매니페스트 파일 경로에 사용됩니다. **Example** ``` glueContext.purge_s3_path("s3://bucket/path/", {"retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/"}) ``` ## transition\$1table **`transition_table(database, table_name, transition_to, options={}, transformation_ctx="", catalog_id=None)`** 지정된 카탈로그의 데이터베이스 및 테이블에 대해 Amazon S3에 저장된 파일의 스토리지 클래스를 전환합니다. 두 스토리지 클래스 간에 전환할 수 있습니다. `GLACIER` 및 `DEEP_ARCHIVE` 스토리지 클래스의 경우 이러한 클래스로 전환할 수 있습니다. 하지만 `S3 RESTORE`를 사용하여 `GLACIER` 및 `DEEP_ARCHIVE` 스토리지 클래스에서 전환할 수 있습니다. Amazon S3에서 파일 또는 파티션을 읽는 AWS Glue ETL 작업을 실행하는 경우 일부 Amazon S3 스토리지 클래스 유형을 제외할 수 있습니다. 자세한 내용은 [Amazon S3 스토리지 클래스 제외](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-storage-classes.html)를 참조하세요. + `database` - 사용할 데이터베이스입니다. + `table_name` - 사용할 테이블의 이름입니다. + `transition_to` - 전환할 [Amazon S3 스토리지 클래스](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/s3/model/StorageClass.html)입니다. + `options` - 삭제할 파일 필터링 및 매니페스트 파일 생성을 위한 옵션입니다. + `retentionPeriod` - 파일을 보존할 기간(시간)을 지정합니다. 보존 기간 내의 파일은 유지됩니다. 기본적으로 168시간(7일)으로 설정됩니다. + `partitionPredicate` - 이 조건자를 충족하는 파티션이 전환됩니다. 이러한 파티션에서 보존 기간 내에 있는 파일은 전환되지 않습니다. 기본적으로 `""`(비움)로 설정합니다. + `excludeStorageClasses` – `excludeStorageClasses` 집합에 스토리지 클래스가 있는 파일은 전환되지 않습니다. 기본값은 `Set()`(빈 집합)입니다. + `manifestFilePath` - 매니페스트 파일 생성을 위한 선택적 경로입니다. 성공적으로 전환된 모든 파일은 `Success.csv`에 기록되고 실패한 파일은 `Failed.csv`에 기록됩니다. + `accountId` - 전환 변환을 실행할 Amazon Web Services 계정 ID입니다. 이 변환에 대해 필수입니다. + `roleArn` - 전환/변환을 실행할 AWS 역할입니다. 이 변환에 대해 필수입니다. + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). 매니페스트 파일 경로에 사용됩니다. + `catalog_id` - 액세스 중인 데이터 카탈로그의 카탈로그 ID(데이터 카탈로그의 계정 ID)입니다. 기본적으로 `None`으로 설정됩니다. `None`인 경우 서비스에 있는 호출 계정의 카탈로그 ID가 기본 설정됩니다. **Example** ``` glueContext.transition_table("database", "table", "STANDARD_IA", {"retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/", "accountId": "12345678901", "roleArn": "arn:aws:iam::123456789012:user/example-username"}) ``` ## transition\$1s3\$1path **`transition_s3_path(s3_path, transition_to, options={}, transformation_ctx="")`** 지정된 Amazon S3 경로에 있는 파일의 스토리지 클래스를 재귀적으로 전환합니다. 두 스토리지 클래스 간에 전환할 수 있습니다. `GLACIER` 및 `DEEP_ARCHIVE` 스토리지 클래스의 경우 이러한 클래스로 전환할 수 있습니다. 하지만 `S3 RESTORE`를 사용하여 `GLACIER` 및 `DEEP_ARCHIVE` 스토리지 클래스에서 전환할 수 있습니다. Amazon S3에서 파일 또는 파티션을 읽는 AWS Glue ETL 작업을 실행하는 경우 일부 Amazon S3 스토리지 클래스 유형을 제외할 수 있습니다. 자세한 내용은 [Amazon S3 스토리지 클래스 제외](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-storage-classes.html)를 참조하세요. + `s3_path` - `s3:////` 포맷으로 전환할 파일에 대한 Amazon S3의 경로입니다. + `transition_to` - 전환할 [Amazon S3 스토리지 클래스](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/s3/model/StorageClass.html)입니다. + `options` - 삭제할 파일 필터링 및 매니페스트 파일 생성을 위한 옵션입니다. + `retentionPeriod` - 파일을 보존할 기간(시간)을 지정합니다. 보존 기간 내의 파일은 유지됩니다. 기본적으로 168시간(7일)으로 설정됩니다. + `partitionPredicate` - 이 조건자를 충족하는 파티션이 전환됩니다. 이러한 파티션에서 보존 기간 내에 있는 파일은 전환되지 않습니다. 기본적으로 `""`(비움)로 설정합니다. + `excludeStorageClasses` – `excludeStorageClasses` 집합에 스토리지 클래스가 있는 파일은 전환되지 않습니다. 기본값은 `Set()`(빈 집합)입니다. + `manifestFilePath` - 매니페스트 파일 생성을 위한 선택적 경로입니다. 성공적으로 전환된 모든 파일은 `Success.csv`에 기록되고 실패한 파일은 `Failed.csv`에 기록됩니다. + `accountId` - 전환 변환을 실행할 Amazon Web Services 계정 ID입니다. 이 변환에 대해 필수입니다. + `roleArn` - 전환/변환을 실행할 AWS 역할입니다. 이 변환에 대해 필수입니다. + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). 매니페스트 파일 경로에 사용됩니다. **Example** ``` glueContext.transition_s3_path("s3://bucket/prefix/", "STANDARD_IA", {"retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/", "accountId": "12345678901", "roleArn": "arn:aws:iam::123456789012:user/example-username"}) ``` ## 추출 + [extract\$1jdbc\$1conf](#aws-glue-api-crawler-pyspark-extensions-glue-context-extract_jdbc_conf) ## extract\$1jdbc\$1conf **`extract_jdbc_conf(connection_name, catalog_id = None)`** 데이터 카탈로그에 있는 AWS Glue 연결 개체의 구성 속성이 있는 `dict`와 키를 반환합니다. + `user` – 데이터베이스 사용자 이름입니다. + `password` – 데이터베이스 암호입니다. + `vendor` – 공급업체를 지정합니다 (`mysql`, `postgresql`, `oracle`, `sqlserver` 등.). + `enforceSSL` – 보안 연결이 필요한지 여부를 나타내는 부울 문자열입니다. + `customJDBCCert` – 표시된 Amazon S3 경로의 특정 클라이언트 인증서를 사용합니다. + `skipCustomJDBCCertValidation` – CA에서 `customJDBCCert`의 유효성을 검사해야 하는지 여부를 나타내는 부울 문자열입니다. + `customJDBCCertString` – 드라이버 유형에 맞는 사용자 지정 인증서에 대한 추가 정보입니다. + `url` – (더 이상 사용되지 않음) 프로토콜, 서버 및 포트만 있는 JDBC URL입니다. + `fullUrl` - 연결이 생성될 때 입력한 JDBC URL입니다(AWS Glue 버전 3.0 이상에서 사용 가능). JDBC 구성 검색의 예: ``` jdbc_conf = glueContext.extract_jdbc_conf(connection_name="your_glue_connection_name") print(jdbc_conf) >>> {'enforceSSL': 'false', 'skipCustomJDBCCertValidation': 'false', 'url': 'jdbc:mysql://myserver:3306', 'fullUrl': 'jdbc:mysql://myserver:3306/mydb', 'customJDBCCertString': '', 'user': 'admin', 'customJDBCCert': '', 'password': '1234', 'vendor': 'mysql'} ``` ## 트랜잭션 + [start\$1transaction](#aws-glue-api-pyspark-extensions-glue-context-start-transaction) + [commit\$1transaction](#aws-glue-api-pyspark-extensions-glue-context-commit-transaction) + [cancel\$1transaction](#aws-glue-api-pyspark-extensions-glue-cancel-transaction) ## start\$1transaction **`start_transaction(read_only)`** 새 트랜잭션을 시작합니다. 내부적으로 Lake Formation [startTransaction](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-aws-lake-formation-api-transactions.html#aws-lake-formation-api-aws-lake-formation-api-transactions-StartTransaction) API를 호출합니다. + `read_only` - (부울) 이 트랜잭션이 읽기 전용인지 또는 읽기/쓰기인지를 나타냅니다. 읽기 전용 트랜잭션 ID를 사용하여 수행된 쓰기는 거부됩니다. 읽기 전용 트랜잭션은 커밋할 필요가 없습니다. 트랜잭션 ID를 반환합니다. ## commit\$1transaction **`commit_transaction(transaction_id, wait_for_commit = True)`** 지정된 트랜잭션을 커밋하려는 시도입니다. 트랜잭션이 커밋을 완료하기 전에 `commit_transaction`이 반환될 수 있습니다. 내부적으로 Lake Formation [commitTransaction](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-aws-lake-formation-api-transactions.html#aws-lake-formation-api-aws-lake-formation-api-transactions-CommitTransaction) API를 호출합니다. + `transaction_id ` - (문자열) 커밋할 트랜잭션입니다. + `wait_for_commit` - (부울) `commit_transaction`이 즉시 반환되는지 여부를 결정합니다. 기본값은 true입니다. false인 경우 `commit_transaction`은 폴링한 후 트랜잭션이 커밋될 때까지 기다립니다. 대기 시간은 최대 재시도 횟수가 6회인 지수 백오프를 사용하여 1분으로 제한됩니다. 커밋이 수행되었는지 여부를 나타내는 부울을 반환합니다. ## cancel\$1transaction **`cancel_transaction(transaction_id)`** 지정된 트랜잭션을 취소하려는 시도입니다. 트랜잭션이 이전에 커밋된 경우 `TransactionCommittedException` 예외를 반환합니다. 내부적으로 Lake Formation [CancelTransaction](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-aws-lake-formation-api-transactions.html#aws-lake-formation-api-aws-lake-formation-api-transactions-CancelTransaction) API를 호출합니다. + `transaction_id` - (문자열) 취소할 트랜잭션입니다. ## 작성 + [getSink](#aws-glue-api-crawler-pyspark-extensions-glue-context-get-sink) + [write\$1dynamic\$1frame\$1from\$1options](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options) + [write\$1from\$1options](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_from_options) + [write\$1dynamic\$1frame\$1from\$1catalog](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_catalog) + [write\$1data\$1frame\$1from\$1catalog](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_data_frame_from_catalog) + [write\$1dynamic\$1frame\$1from\$1jdbc\$1conf](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_jdbc_conf) + [write\$1from\$1jdbc\$1conf](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_from_jdbc_conf) ## getSink **`getSink(connection_type, format = None, transformation_ctx = "", **options)`** 외부 소스로 `DataSink`를 읽을 때 사용되는 `DynamicFrames` 객체를 얻습니다. 먼저 SparkSQL `format`를 확인하여 예상 싱크를 얻도록 합니다. + `connection_type` - Amazon S3, Amazon Redshift 및 JDBC와 같이 사용할 연결 유형입니다. 유효한 값에는 `s3`, `mysql`, `postgresql`, `redshift`, `sqlserver`, `oracle`, `kinesis`, `kafka`가 있습니다. + `format` - 사용할 SparkSQL 포맷입니다(선택 사항). + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). + `options` - 연결 옵션을 지정하는 데 사용되는 이름-값 페어의 컬렉션입니다. 몇 가지 가능한 값은 다음과 같습니다. + `user` 및 `password`: 권한 부여용 + `url`: 데이터 스토어에 대한 엔드포인트 + `dbtable`: 대상 테이블의 이름 + `bulkSize`: 삽입 작업의 병렬 처리 수준 지정할 수 있는 옵션은 연결 유형에 따라 다릅니다. 추가 값과 예제는 [AWS Glue for Spark에서 ETL에 대한 연결 유형 및 옵션](aws-glue-programming-etl-connect.md) 섹션을 참조하세요. 예제: ``` >>> data_sink = context.getSink("s3") >>> data_sink.setFormat("json"), >>> data_sink.writeFrame(myFrame) ``` ## write\$1dynamic\$1frame\$1from\$1options **`write_dynamic_frame_from_options(frame, connection_type, connection_options={}, format=None, format_options={}, transformation_ctx = "")`** 지정한 연결 및 포맷을 사용하여 `DynamicFrame`를 작성하고 반환합니다. + `frame` - 작성할 `DynamicFrame`입니다. + `connection_type` - Amazon S3, Amazon Redshift 및 JDBC 등의 연결 유형입니다. 유효한 값에는 `s3`, `mysql`, `postgresql`, `redshift`, `sqlserver`, `oracle`, `kinesis`, `kafka`가 있습니다. + `connection_options` - 경로 및 데이터베이스 테이블과 같은 연결 옵션입니다(선택 사항). `s3`의 `connection_type`의 경우, Amazon S3 경로가 정의됩니다. ``` connection_options = {"path": "s3://aws-glue-target/temp"} ``` JDBC 연결의 경우, 몇 까지 속성이 정의되어야 합니다. 단, 데이터베이스 이름이 URL의 일부여야 합니다. 연결 옵션에 선택적으로 포함될 수 있습니다. **주의** 스크립트에 암호를 저장하는 것은 권장되지 않습니다. AWS Secrets Manager 또는 AWS Glue 데이터 카탈로그에서 데이터를 검색할 때 `boto3` 사용을 고려합니다. ``` connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path"} ``` `dbtable` 속성은 JDBC 테이블의 이름입니다. 데이터베이스 내의 스키마를 지원하는 JDBC 데이터 스토어의 경우 `schema.table-name`에 대해 지정합니다. 스키마가 제공되지 않으면 기본 "퍼블릭" 스키마가 사용됩니다. 자세한 내용은 [AWS Glue for Spark에서 ETL에 대한 연결 유형 및 옵션](aws-glue-programming-etl-connect.md) 섹션을 참조하세요. + `format` - 형식 사양. 여러 포맷을 지원하는 Amazon S3 또는 AWS Glue 연결에 사용됩니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하십시오. + `format_options` - 지정된 포맷에 대한 포맷 옵션입니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하십시오. + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). ## write\$1from\$1options **`write_from_options(frame_or_dfc, connection_type, connection_options={}, format={}, format_options={}, transformation_ctx = "")`** 지정한 연결 및 포맷 정보로 생성된 `DynamicFrame` 또는 `DynamicFrameCollection`을 작성하고 반환합니다. + `frame_or_dfc` – 작성할 `DynamicFrame` 또는 `DynamicFrameCollection`입니다. + `connection_type` - Amazon S3, Amazon Redshift 및 JDBC 등의 연결 유형입니다. 유효한 값에는 `s3`, `mysql`, `postgresql`, `redshift`, `sqlserver` 및 `oracle`가 있습니다. + `connection_options` - 경로 및 데이터베이스 테이블과 같은 연결 옵션입니다(선택 사항). `s3`의 `connection_type`의 경우, Amazon S3 경로가 정의됩니다. ``` connection_options = {"path": "s3://aws-glue-target/temp"} ``` JDBC 연결의 경우, 몇 까지 속성이 정의되어야 합니다. 단, 데이터베이스 이름이 URL의 일부여야 합니다. 연결 옵션에 선택적으로 포함될 수 있습니다. **주의** 스크립트에 암호를 저장하는 것은 권장되지 않습니다. AWS Secrets Manager 또는 AWS Glue 데이터 카탈로그에서 데이터를 검색할 때 `boto3` 사용을 고려합니다. ``` connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path"} ``` `dbtable` 속성은 JDBC 테이블의 이름입니다. 데이터베이스 내의 스키마를 지원하는 JDBC 데이터 스토어의 경우 `schema.table-name`에 대해 지정합니다. 스키마가 제공되지 않으면 기본 "퍼블릭" 스키마가 사용됩니다. 자세한 내용은 [AWS Glue for Spark에서 ETL에 대한 연결 유형 및 옵션](aws-glue-programming-etl-connect.md) 섹션을 참조하세요. + `format` - 형식 사양. 여러 포맷을 지원하는 Amazon S3 또는 AWS Glue 연결에 사용됩니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하십시오. + `format_options` - 지정된 포맷에 대한 포맷 옵션입니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하십시오. + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). ## write\$1dynamic\$1frame\$1from\$1catalog **`write_dynamic_frame_from_catalog(frame, database, table_name, redshift_tmp_dir, transformation_ctx = "", additional_options = {}, catalog_id = None)`** 데이터 카탈로그 데이터베이스 및 테이블의 정보를 사용하여 `DynamicFrame`을 작성하고 반환합니다. + `frame` - 작성할 `DynamicFrame`입니다. + `Database` - 테이블이 들어 있는 데이터 카탈로그 데이터베이스입니다. + `table_name` - 대상과 연결된 데이터 카탈로그 테이블의 이름입니다. + `redshift_tmp_dir` – 사용할 Amazon Redshift 임시 디렉터리입니다(선택 사항). + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). + `additional_options` - 선택적 이름-값 페어의 모음입니다. + `catalog_id` - 액세스 중인 데이터 카탈로그의 카탈로그 ID(계정 ID)입니다. None인 경우 호출자의 기본 계정 ID가 사용됩니다. ## write\$1data\$1frame\$1from\$1catalog **`write_data_frame_from_catalog(frame, database, table_name, redshift_tmp_dir, transformation_ctx = "", additional_options = {}, catalog_id = None)`** 데이터 카탈로그 데이터베이스 및 테이블의 정보를 사용하여 `DataFrame`을 작성하고 반환합니다. 이 메서드는 데이터 레이크 형식(Hudi, Iceberg, Delta Lake) 쓰기를 지원합니다. 자세한 내용은 [AWS Glue ETL 작업에서 데이터 레이크 프레임워크 사용](aws-glue-programming-etl-datalake-native-frameworks.md) 섹션을 참조하세요. + `frame` - 작성할 `DataFrame`입니다. + `Database` - 테이블이 들어 있는 데이터 카탈로그 데이터베이스입니다. + `table_name` - 대상과 연결된 데이터 카탈로그 테이블의 이름입니다. + `redshift_tmp_dir` – 사용할 Amazon Redshift 임시 디렉터리입니다(선택 사항). + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). + `additional_options` - 선택적 이름-값 페어의 모음입니다. + `useSparkDataSink` - true로 설정하면 AWS Glue가 네이티브 Spark 데이터 싱크 API를 사용하여 테이블에 쓰도록 강제 적용합니다. 이 옵션을 활성화하면 필요에 따라 [Spark 데이터 소스 옵션](https://spark.apache.org/docs/latest/sql-data-sources.html)을 `additional_options`에 추가할 수 있습니다. AWS Glue는 이러한 옵션을 Spark 라이터에 직접 전달합니다. + `catalog_id` - 액세스 중인 데이터 카탈로그의 카탈로그 ID(계정 ID)입니다. 값을 지정하지 않으면 발신자의 기본 계정 ID가 사용됩니다. **제한 사항 ** `useSparkDataSink` 옵션을 사용할 경우 다음과 같은 제한 사항을 고려하세요. + `useSparkDataSink` 옵션을 사용하는 경우 [`enableUpdateCatalog`](update-from-job.md) 옵션이 지원되지 않습니다. **예: Spark 데이터 소스 라이터를 사용하여 Hudi 테이블에 쓰기** ``` hudi_options = { 'useSparkDataSink': True, 'hoodie.table.name': , 'hoodie.datasource.write.storage.type': 'COPY_ON_WRITE', 'hoodie.datasource.write.recordkey.field': 'product_id', 'hoodie.datasource.write.table.name': , 'hoodie.datasource.write.operation': 'upsert', 'hoodie.datasource.write.precombine.field': 'updated_at', 'hoodie.datasource.write.hive_style_partitioning': 'true', 'hoodie.upsert.shuffle.parallelism': 2, 'hoodie.insert.shuffle.parallelism': 2, 'hoodie.datasource.hive_sync.enable': 'true', 'hoodie.datasource.hive_sync.database': , 'hoodie.datasource.hive_sync.table': , 'hoodie.datasource.hive_sync.use_jdbc': 'false', 'hoodie.datasource.hive_sync.mode': 'hms'} glueContext.write_data_frame.from_catalog( frame = , database = , table_name = , additional_options = hudi_options ) ``` ## write\$1dynamic\$1frame\$1from\$1jdbc\$1conf **`write_dynamic_frame_from_jdbc_conf(frame, catalog_connection, connection_options={}, redshift_tmp_dir = "", transformation_ctx = "", catalog_id = None)`** 지정한 JDBC 연결 정보를 사용하여 `DynamicFrame`를 작성하고 반환합니다. + `frame` - 작성할 `DynamicFrame`입니다. + `catalog_connection` - 사용할 카탈로그 연결입니다. + `connection_options` - 경로 및 데이터베이스 테이블과 같은 연결 옵션입니다(선택 사항). 자세한 내용은 [AWS Glue for Spark에서 ETL에 대한 연결 유형 및 옵션](aws-glue-programming-etl-connect.md) 섹션을 참조하세요. + `redshift_tmp_dir` – 사용할 Amazon Redshift 임시 디렉터리입니다(선택 사항). + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). + `catalog_id` - 액세스 중인 데이터 카탈로그의 카탈로그 ID(계정 ID)입니다. None인 경우 호출자의 기본 계정 ID가 사용됩니다. ## write\$1from\$1jdbc\$1conf **`write_from_jdbc_conf(frame_or_dfc, catalog_connection, connection_options={}, redshift_tmp_dir = "", transformation_ctx = "", catalog_id = None)`** 지정한 JDBC 연결 정보를 사용하여 `DynamicFrame` 또는 `DynamicFrameCollection`을 작성하고 반환합니다. + `frame_or_dfc` – 작성할 `DynamicFrame` 또는 `DynamicFrameCollection`입니다. + `catalog_connection` - 사용할 카탈로그 연결입니다. + `connection_options` - 경로 및 데이터베이스 테이블과 같은 연결 옵션입니다(선택 사항). 자세한 내용은 [AWS Glue for Spark에서 ETL에 대한 연결 유형 및 옵션](aws-glue-programming-etl-connect.md) 섹션을 참조하세요. + `redshift_tmp_dir` – 사용할 Amazon Redshift 임시 디렉터리입니다(선택 사항). + `transformation_ctx` - 사용할 변환 내용입니다(선택 사항). + `catalog_id` - 액세스 중인 데이터 카탈로그의 카탈로그 ID(계정 ID)입니다. None인 경우 호출자의 기본 계정 ID가 사용됩니다. # AWS Glue PySpark 변환 참조 AWS Glue는 PySpark ETL 작동에서 사용할 수 있는 다음과 같은 내장형 변환을 제공합니다. 데이터가 *DynamicFrame*이라는 데이터 구조 내의 변환에서 변환으로 전달됩니다. 이는 Apache Spark SQL `DataFrame`을 확장한 것입니다. `DynamicFrame`은 데이터를 포함하고 데이터 스키마를 참조하여 데이터를 진행합니다. 이러한 변환의 대부분은 `DynamicFrame` 클래스의 메서드로도 존재합니다. 자세한 내용은 [DynamicFrame 변환](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-_transforms)을 참조하세요. + [GlueTransform 베이스 클래스](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md) + [ApplyMapping 클래스](aws-glue-api-crawler-pyspark-transforms-ApplyMapping.md) + [DropFields 클래스](aws-glue-api-crawler-pyspark-transforms-DropFields.md) + [DropNullField 클래스](aws-glue-api-crawler-pyspark-transforms-DropNullFields.md) + [ErrorsAsDynamicFrame 클래스](aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame.md) + [EvaluateDataQuality 클래스](aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality.md) + [FillMissingValues 클래스](aws-glue-api-crawler-pyspark-transforms-fillmissingvalues.md) + [Filter 클래스](aws-glue-api-crawler-pyspark-transforms-filter.md) + [FindIncrementalMatches 클래스](aws-glue-api-crawler-pyspark-transforms-findincrementalmatches.md) + [FindMatches 클래스](aws-glue-api-crawler-pyspark-transforms-findmatches.md) + [FlatMap 클래스](aws-glue-api-crawler-pyspark-transforms-flat-map.md) + [Join 클래스](aws-glue-api-crawler-pyspark-transforms-join.md) + [Map 클래스](aws-glue-api-crawler-pyspark-transforms-map.md) + [MapToCollection 클래스](aws-glue-api-crawler-pyspark-transforms-MapToCollection.md) + [mergeDynamicFrame](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-merge) + [Relationalize 클래스](aws-glue-api-crawler-pyspark-transforms-Relationalize.md) + [RenameField 클래스](aws-glue-api-crawler-pyspark-transforms-RenameField.md) + [ResolveChoice 클래스](aws-glue-api-crawler-pyspark-transforms-ResolveChoice.md) + [SelectFields 클래스](aws-glue-api-crawler-pyspark-transforms-SelectFields.md) + [SelectFromCollection 클래스](aws-glue-api-crawler-pyspark-transforms-SelectFromCollection.md) + [Simplify\$1ddb\$1json 클래스](aws-glue-api-crawler-pyspark-transforms-simplify-ddb-json.md) + [Spigot 클래스](aws-glue-api-crawler-pyspark-transforms-spigot.md) + [SplitFields 클래스](aws-glue-api-crawler-pyspark-transforms-SplitFields.md) + [SplitRows 클래스](aws-glue-api-crawler-pyspark-transforms-SplitRows.md) + [Unbox 클래스](aws-glue-api-crawler-pyspark-transforms-Unbox.md) + [UnnestFrame 클래스](aws-glue-api-crawler-pyspark-transforms-UnnestFrame.md) # GlueTransform 베이스 클래스 이 베이스 클래스에서 모든 `awsglue.transforms` 클래스가 물려받습니다. 이 클래스는 `__call__` 방법을 정의합니다. 이것들은 다음 섹션에 있는 `GlueTransform` 클래스 방법을 재정의하거나 기본값으로 클래스 이름을 사용하여 호출됩니다. ## 메서드 + [apply(cls, \$1args, \$1\$1kwargs)](#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply) + [name(cls)](#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name) + [describeArgs(cls)](#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs) + [describeReturn(cls)](#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn) + [describeTransform(cls)](#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform) + [describeErrors(cls)](#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors) + [describe(cls)](#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe) ## apply(cls, \$1args, \$1\$1kwargs) 변환 클래스를 호출하여 변환을 적용하고 결과를 반환합니다. + `cls` – `self` 클래스 객체입니다. ## name(cls) 파생된 변환 클래스의 이름을 반환합니다. + `cls` – `self` 클래스 객체입니다. ## describeArgs(cls) + `cls` – `self` 클래스 객체입니다. 명명된 논제와 관련된 딕셔너리 목록을 다음과 같은 포맷으로 반환합니다. ``` [ { "name": "(name of argument)", "type": "(type of argument)", "description": "(description of argument)", "optional": "(Boolean, True if the argument is optional)", "defaultValue": "(Default value string, or None)(String; the default value, or None)" }, ... ] ``` 파생된 변환이 실행되지 않고 호출되지 않으면 `NotImplementedError` 예외가 발생합니다. ## describeReturn(cls) + `cls` – `self` 클래스 객체입니다. 반환 유형에 대한 정보와 함께 다음 포맷으로 딕셔너리를 반환합니다. ``` { "type": "(return type)", "description": "(description of output)" } ``` 파생된 변환이 실행되지 않고 호출되지 않으면 `NotImplementedError` 예외가 발생합니다. ## describeTransform(cls) 변환을 나타내는 문자열을 반환합니다. + `cls` – `self` 클래스 객체입니다. 파생된 변환이 실행되지 않고 호출되지 않으면 `NotImplementedError` 예외가 발생합니다. ## describeErrors(cls) + `cls` – `self` 클래스 객체입니다. 변환에 따른 예외를 나타내는 딕셔너리 목록을 다음과 같은 포맷으로 반환합니다. ``` [ { "type": "(type of error)", "description": "(description of error)" }, ... ] ``` ## describe(cls) + `cls` – `self` 클래스 객체입니다. 다음의 형식으로 객체를 반환합니다. ``` { "transform" : { "name" : cls.name( ), "args" : cls.describeArgs( ), "returns" : cls.describeReturn( ), "raises" : cls.describeErrors( ), "location" : "internal" } } ``` # ApplyMapping 클래스 `DynamicFrame`에서 매핑을 적용합니다. ## 예제 `DynamicFrame`에 매핑을 적용하기 위해서는 [`DynamicFrame.apply_mapping()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-apply_mapping) 메서드를 사용하는 것을 권장합니다. 코드에 대한 예제는 [예: apply\$1maping을 사용하여 필드 이름을 바꾸고 필드 유형을 변경합니다.](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-apply_mapping-example) 단원을 참조하세요. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-describeErrors) + [설명](#aws-glue-api-crawler-pyspark-transforms-ApplyMapping-describe) ## \$1\$1call\$1\$1(frame, mappings, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) 지정 `DynamicFrame`에 서술식 매핑을 적용합니다. + `frame` – `DynamicFrame`은 매핑을 적용할 대상(필수). + `mappings` - 매핑 튜플 목록(필수). 각각 (소스 열, 소스 유형, 대상 열, 대상 유형)으로 구성된 매핑 튜플 목록입니다. 소스 열에 점(“`.`”)이 있는 경우 주위에 백틱(“````”)을 넣어야 합니다. 예를 들어 `this.old.name`(문자열)을 `thisNewName`에 매핑하려면 다음 튜플을 사용합니다. ``` ("`this.old.name`", "string", "thisNewName", "string") ``` + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 변환에 따른 오류 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다(선택 사항). 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다(선택 사항). 기본값은 0입니다. “매핑” 튜플에 지정된 `DynamicFrame`의 필드만 반환합니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # DropFields 클래스 `DynamicFrame` 내에서 필드를 드롭합니다. ## 예제 `DynamicFrame.drop_fields()`에서 필드를 드롭하기 위해 [`DynamicFrame`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-drop_fields) 방법을 사용하는 것이 좋습니다. 코드에 대한 예제는 [예: drop\$1fields를 사용하여 `DynamicFrame`에서 필드를 제거합니다.](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-drop_fields-example) 단원을 참조하세요. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-DropFields-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-DropFields-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-DropFields-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-DropFields-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-DropFields-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-DropFields-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-DropFields-describeErrors) + [설명](#aws-glue-api-crawler-pyspark-transforms-DropFields-describe) ## \$1\$1call\$1\$1(frame, paths, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) `DynamicFrame` 내에서 노드를 드롭합니다. + `frame` – `DynamicFrame`은 노드를 드롭합니다(필수). + `paths` - 드롭할 노드의 전체 경로 목록입니다(필수). + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 변환에 따른 오류 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다(선택 사항). 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다(선택 사항). 기본값은 0입니다. 지정된 필드없이 새로운 `DynamicFrame`을 반환합니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # DropNullField 클래스 `DynamicFrame` 에서 `NullType` 인 유형의 모든 널 필드를 드롭합니다. `DynamicFrame` 데이터 세트의 모든 기록에서 누락된 혹은 null 값인 필드입니다. ## 예제 이 예제에서는 `NullType` 유형의 필드가 삭제된 새 `DynamicFrame`을 만드는 데 `DropNullFields`를 사용합니다. `DropNullFields`를 보여 주기 위해 이미 로드된 `persons` 데이터 세트에 null 유형의 `empty_column`라는 이름의 새 열을 추가합니다. **참고** 이 예제에서 사용되는 데이터 세트에 액세스하려면 [코드 예: 데이터 조인 및 관계화](aws-glue-programming-python-samples-legislators.md) 항목을 참조하고 [1단계: Amazon S3 버킷에서 데이터 크롤](aws-glue-programming-python-samples-legislators.md#aws-glue-programming-python-samples-legislators-crawling)의 지침을 따르세요. ``` # Example: Use DropNullFields to create a new DynamicFrame without NullType fields from pyspark.context import SparkContext from awsglue.context import GlueContext from pyspark.sql.functions import lit from pyspark.sql.types import NullType from awsglue.dynamicframe import DynamicFrame from awsglue.transforms import DropNullFields # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Create DynamicFrame persons = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="persons_json" ) print("Schema for the persons DynamicFrame:") persons.printSchema() # Add new column "empty_column" with NullType persons_with_nulls = persons.toDF().withColumn("empty_column", lit(None).cast(NullType())) persons_with_nulls_dyf = DynamicFrame.fromDF(persons_with_nulls, glueContext, "persons_with_nulls") print("Schema for the persons_with_nulls_dyf DynamicFrame:") persons_with_nulls_dyf.printSchema() # Remove the NullType field persons_no_nulls = DropNullFields.apply(persons_with_nulls_dyf) print("Schema for the persons_no_nulls DynamicFrame:") persons_no_nulls.printSchema() ``` ### 출력 ``` Schema for the persons DynamicFrame: root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string Schema for the persons_with_nulls_dyf DynamicFrame: root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string |-- empty_column: null null_fields ['empty_column'] Schema for the persons_no_nulls DynamicFrame: root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string ``` ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-describeErrors) + [설명](#aws-glue-api-crawler-pyspark-transforms-DropNullFields-describe) ## \$1\$1call\$1\$1(frame, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) `DynamicFrame` 에서 `NullType` 인 유형의 모든 널 필드를 드롭합니다. `DynamicFrame` 데이터 세트의 모든 기록에서 누락된 혹은 null 값인 필드입니다. + `frame` – `DynamicFrame`은 null 필드를 드롭합니다(필수). + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 변환에 따른 오류 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다(선택 사항). 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다(선택 사항). 기본값은 0입니다. 널값이 없는 새로운 `DynamicFrame`을 반환합니다. ## apply(cls, \$1args, \$1\$1kwargs) + `cls` – cls ## name(cls) + `cls` – cls ## describeArgs(cls) + `cls` – cls ## describeReturn(cls) + `cls` – cls ## describeTransform(cls) + `cls` – cls ## describeErrors(cls) + `cls` – cls ## describe(cls) + `cls` – cls # ErrorsAsDynamicFrame 클래스 소스 `DynamicFrame`이 생성되는 동안 발생한 오류에 대한 중첩 레코드가 포함된 `DynamicFrame`을 반환합니다. ## 예시 오류 레코드를 조회하고 보는 데는 [`DynamicFrame.errorsAsDynamicFrame()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-errorsAsDynamicFrame) 메서드를 권장합니다. 코드에 대한 예제는 [예: errorsAsDynamicFrame을 사용하여 오류 레코드 보기](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-errorsAsDynamicFrame-example) 단원을 참조하세요. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-describeErrors) + [설명](#aws-glue-api-crawler-pyspark-transforms-ErrorsAsDynamicFrame-describe) ## \$1\$1call\$1\$1(frame) `DynamicFrame` 소스 생성과 관련된 중첩된 오류 기록을 포함하는 `DynamicFrame`을 반환합니다. + `frame` – 소스 `DynamicFrame`입니다(필수). ## apply(cls, \$1args, \$1\$1kwargs) + `cls` – cls ## name(cls) + `cls` – cls ## describeArgs(cls) + `cls` – cls ## describeReturn(cls) + `cls` – cls ## describeTransform(cls) + `cls` – cls ## describeErrors(cls) + `cls` – cls ## describe(cls) + `cls` – cls # EvaluateDataQuality 클래스 `DynamicFrame`을 기준으로 데이터 품질 규칙 세트를 평가하고 새 `DynamicFrame`을 평가 결과와 함께 반환합니다. ## 예제 다음 예제 코드는 `DynamicFrame`의 데이터 품질을 평가한 다음 데이터 품질 결과를 확인하는 방법을 보여줍니다. ``` from awsglue.transforms import * from pyspark.context import SparkContext from awsglue.context import GlueContext from awsgluedq.transforms import EvaluateDataQuality #Create Glue context sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Define DynamicFrame legislatorsAreas = glueContext.create_dynamic_frame.from_catalog( database="legislators", table_name="areas_json") # Create data quality ruleset ruleset = """Rules = [ColumnExists "id", IsComplete "id"]""" # Evaluate data quality dqResults = EvaluateDataQuality.apply( frame=legislatorsAreas, ruleset=ruleset, publishing_options={ "dataQualityEvaluationContext": "legislatorsAreas", "enableDataQualityCloudWatchMetrics": True, "enableDataQualityResultsPublishing": True, "resultsS3Prefix": "amzn-s3-demo-bucket1", }, ) # Inspect data quality results dqResults.printSchema() dqResults.toDF().show() ``` ### 출력 ``` root |-- Rule: string |-- Outcome: string |-- FailureReason: string |-- EvaluatedMetrics: map | |-- keyType: string | |-- valueType: double +-----------------------+-------+-------------+---------------------------------------+ |Rule |Outcome|FailureReason|EvaluatedMetrics | +-----------------------+-------+-------------+---------------------------------------+ |ColumnExists "id" |Passed |null |{} | |IsComplete "id" |Passed |null |{Column.first_name.Completeness -> 1.0}| +-----------------------+-------+-------------+---------------------------------------+ ``` ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-EvaluateDataQuality-describe) ## \$1\$1call\$1\$1(frame, ruleset, publishing\$1options = \$1\$1) + `frame` - 데이터 품질을 평가하려는 `DynamicFrame`입니다. + `ruleset` - 문자열 형식의 DQDL(데이터 품질 정의 언어) 규칙 세트입니다. DQDL에 대한 자세한 내용은 [데이터 품질 정의 언어(DQDL) 참조](dqdl.md) 안내서를 참조하세요. + `publishing_options` - 평가 결과 및 지표를 게시하기 위해 다음 옵션을 지정하는 사전입니다. + `dataQualityEvaluationContext` - AWS Glue가 Amazon CloudWatch 지표와 데이터 품질 결과를 게시할 네임스페이스를 지정하는 문자열입니다. 집계된 지표는 CloudWatch에 표시되고 전체 결과는 AWS Glue Studio 인터페이스에 표시됩니다. + 필수 여부: 아니요 + 기본값: `default_context` + `enableDataQualityCloudWatchMetrics` - 데이터 품질 평가 결과를 CloudWatch에 게시할지 여부를 지정합니다. `dataQualityEvaluationContext` 옵션을 사용하여 지표의 네임스페이스를 지정합니다. + 필수 여부: 아니요 + 기본값: False + `enableDataQualityResultsPublishing` - AWS Glue Studio 인터페이스의 **Data Quality**(데이터 품질) 탭에 데이터 품질 결과를 표시할지 여부를 지정합니다. + 필수 여부: 아니요 + 기본값: True + `resultsS3Prefix` - AWS Glue가 데이터 품질 평가 결과를 기록할 수 있는 Amazon S3 위치를 지정합니다. + 필수 여부: 아니요 + 기본값: ""(빈 문자열) ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # FillMissingValues 클래스 `FillMissingValues` 클래스는 지정된 `DynamicFrame`에서 null 값과 빈 문자열을 찾고 선형 회귀 및 랜덤 포레스트와 같은 기계 학습 방법을 사용하여 누락된 값을 예측합니다. ETL 작업은 입력 데이터 집합의 값을 사용하여 기계 학습 모델을 훈련합니다. 이 모델은 누락 된 값이 무엇인지 예측합니다. **작은 정보** 증분 데이터 집합을 사용하는 경우 각 증분 집합은 기계 학습 모델의 훈련 데이터로 사용되므로 결과가 정확하지 않을 수 있습니다. 가져오려면 ``` from awsglueml.transforms import FillMissingValues ``` ## 메서드 + [Apply](#aws-glue-api-crawler-pyspark-transforms-fillmissingvalues-apply) ## apply(frame, missing\$1values\$1column, output\$1column ="", transformation\$1ctx ="", info ="", stageThreshold = 0, totalThreshold = 0) 지정된 열에 동적 프레임의 누락된 값을 채우고 새 열에 추정 값과 함께 새 프레임을 반환합니다. 누락된 값이 없는 행의 경우 지정된 열의 값이 새 열에 복제됩니다. + `frame` – 누락된 값을 채울 `DynamicFrame`입니다 필수 사항입니다. + `missing_values_column` - 누락된 값(`null` 값 및 빈 문자열)이 포함된 열입니다. 필수 사항입니다. + `output_column` - 값이 누락된 모든 행에 대한 예상 값을 포함할 새 열의 이름입니다. 선택 사항이며 기본값은 `"_filled"`가 접미사로 사용된 `missing_values_column`의 이름입니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 변환에 따른 오류 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다(선택 사항, 기본값은 0). + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다(선택 사항, 기본값은 0). 누락된 값이 있는 행에 대한 추정 값과 다른 행에 대한 현재 값이 포함된 하나의 추가 열이 있는 새 `DynamicFrame`을 반환합니다. # Filter 클래스 지정된 술어 함수를 충족하는 `DynamicFrame` 입력의 레코드를 포함하는 새 `DynamicFrame` 항목을 빌드합니다. ## 예제 `DynamicFrame`에서 레코드를 필터링하기 위해 [`DynamicFrame.filter()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-filter) 방법을 사용하는 것이 좋습니다. 코드에 대한 예제는 [예: 필터를 사용하여 필터링된 필드 선택 가져오기](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-filter-example) 단원을 참조하세요. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-filter-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-filter-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-filter-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-filter-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-filter-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-filter-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-filter-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-filter-describe) ## \$1\$1call\$1\$1(frame, f, transformation\$1ctx="", info="", stageThreshold=0, totalThreshold=0)) 지정된 조건자 함수를 만족하는 입력 `DynamicFrame`에서 기록을 선택하여 만든 새로운 `DynamicFrame`을 반환합니다. + `frame` – 소스 `DynamicFrame`으로 지정된 필터 함수를 적용합니다(필수). + `f` - `DynamicFrame`의 각 `DynamicRecord`를 적용하는 조건자 함수입니다. 함수는 `DynamicRecord`를 인수로 받아들이고 `DynamicRecord`가 필터 요구 사항과 맞으면 True을 반환하고 아니면 False를 반환합니다 (필수). `DynamicRecord`는 `DynamicFrame`내 논리적 기록입니다. 자기 설명적이고 고정 스키마를 준수하지 않은 데이터에 사용될 수 있다는 점을 제외하면 스파크 `DataFrame`의 열과 비슷합니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 변환에 따른 오류 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다(선택 사항). 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다(선택 사항). 기본값은 0입니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # FindIncrementalMatches 클래스 기존 및 증분 `DynamicFrame`에서 일치하는 레코드를 식별하고 일치하는 레코드의 각 그룹에 할당된 고유 식별자로 새 `DynamicFrame`을 생성합니다. 가져오려면 ``` from awsglueml.transforms import FindIncrementalMatches ``` ## 메서드 + [Apply](#aws-glue-api-crawler-pyspark-transforms-findincrementalmatches-apply) ## apply(existingFrame, incrementalFrame, transformId, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0, enforcedMatches = none, computeMatchConfidenceScores = 0) 입력 `DynamicFrame`에서 일치하는 레코드를 식별하고 일치하는 레코드의 각 그룹에 할당된 고유 식별자를 사용하여 새 `DynamicFrame`을 생성합니다. + `existingFrame` - FindIncrementalMatches 변환을 적용하기 위한 기존 및 사전 일치 `DynamicFrame`입니다. 필수 사항입니다. + `incrementalFrame`- `existingFrame`과 일치하도록 FindIncrementalMatches 변환을 적용하는 증분 `DynamicFrame`입니다. 필수 사항입니다. + `transformId` - `DynamicFrames`의 레코드에 적용할 FindIncrementalMatches 변환과 연결된 고유 ID입니다. 필수 사항입니다. + `transformation_ctx` – 고유 문자열을 통해 통계/상태 정보를 확인합니다. 선택 사항. + `info` - 변환에 따른 오류 관련 문자열입니다. 선택 사항. + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다. 선택 사항. 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다. 선택 사항. 기본값은 0입니다. + `enforcedMatches` - 일치를 적용하는 데 사용되는 `DynamicFrame`입니다. 선택 사항. 기본값은 없습니다. + `computeMatchConfidenceScores` - 각 일치 레코드 그룹의 신뢰도 점수를 컴퓨팅할지 여부를 나타내는 부울 값입니다. 선택 사항. 기본값은 false입니다. 일치하는 레코드의 각 그룹에 고유 식별자가 할당된 새 `DynamicFrame`을 반환합니다. # FindMatches 클래스 입력 `DynamicFrame`에서 일치하는 레코드를 식별하고 일치하는 레코드의 각 그룹에 할당된 고유 식별자를 사용하여 새 `DynamicFrame`을 생성합니다. 가져오려면 ``` from awsglueml.transforms import FindMatches ``` ## 메서드 + [Apply](#aws-glue-api-crawler-pyspark-transforms-findmatches-apply) ## apply(frame, transformId, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0, enforcedMatches = none, computeMatchConfidenceScores = 0) 입력 `DynamicFrame`에서 일치하는 레코드를 식별하고 일치하는 레코드의 각 그룹에 할당된 고유 식별자를 사용하여 새 `DynamicFrame`을 생성합니다. + `frame` – FindMatches 변환을 적용할 `DynamicFrame`입니다. 필수 사항입니다. + `transformId` – `DynamicFrame`의 레코드에 적용할 FindMatches 변환과 연결된 고유 ID입니다. 필수 사항입니다. + `transformation_ctx` – 고유 문자열을 통해 통계/상태 정보를 확인합니다. 선택 사항. + `info` - 변환에 따른 오류 관련 문자열입니다. 선택 사항. + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다. 선택 사항. 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다. 선택 사항. 기본값은 0입니다. + `enforcedMatches` - 일치를 적용하는 데 사용되는 `DynamicFrame`입니다. 선택 사항. 기본값은 없습니다. + `computeMatchConfidenceScores` - 각 일치 레코드 그룹의 신뢰도 점수를 컴퓨팅할지 여부를 나타내는 부울 값입니다. 선택 사항. 기본값은 false입니다. 일치하는 레코드의 각 그룹에 고유 식별자가 할당된 새 `DynamicFrame`을 반환합니다. # FlatMap 클래스 컬렉션에서 각 `DynamicFrame`에 변환을 적용합니다. 결과는 하나의 `DynamicFrame`으로 병합되지 않고 컬렉션으로 유지됩니다. ## FlatMap 예제 다음 스니펫 예제에서는 `FlatMap`에 적용할 때 동적 프레임 컬렉션에서 `ResolveChoice` 변환을 사용하는 방법을 보여줍니다. 입력에 사용되는 데이터는 JSON에서 Amazon S3 주소 `s3://bucket/path-for-data/sample.json` 자리 표시자에 있으며, 다음 데이터를 포함합니다. ### 예시 JSON 데이터 ``` [{ "firstname": "Arnav", "lastname": "Desai", "address": { "street": "6 Anyroad Avenue", "city": "London", "state": "England", "country": "UK" }, "phone": 17235550101, "affiliations": [ "General Anonymous Example Products", "Example Independent Research", "Government Department of Examples" ] }, { "firstname": "Mary", "lastname": "Major", "address": { "street": "7821 Spot Place", "city": "Centerville", "state": "OK", "country": "US" }, "phone": 19185550023, "affiliations": [ "Example Dot Com", "Example Independent Research", "Example.io" ] }, { "firstname": "Paulo", "lastname": "Santos", "address": { "street": "123 Maple Street", "city": "London", "state": "Ontario", "country": "CA" }, "phone": 12175550181, "affiliations": [ "General Anonymous Example Products", "Example Dot Com" ] }] ``` **Example ResolveChoice를 DynamicFrameCollection에 적용하고 출력을 표시합니다.** ``` #Read DynamicFrame datasource = glueContext.create_dynamic_frame_from_options("s3", connection_options = {"paths":["s3://bucket/path/to/file/mysamplejson.json"]}, format="json") datasource.printSchema() datasource.show() ## Split to create a DynamicFrameCollection split_frame=datasource.split_fields(["firstname","lastname","address"],"personal_info","business_info") split_frame.keys() print("---") ## Use FlatMap to run ResolveChoice kwargs = {"choice": "cast:string"} flat = FlatMap.apply(split_frame, ResolveChoice, frame_name="frame", transformation_ctx='tcx', **kwargs) flat.keys() ##Select one of the DynamicFrames personal_info = flat.select("personal_info") personal_info.printSchema() personal_info.show() print("---") business_info = flat.select("business_info") business_info.printSchema() business_info.show() ``` `FlatMap.apply` 직접 호출 시 `frame_name` 파라미터는 **반드시** `"frame"`이어야 합니다. 현재 다른 값은 허용되지 않습니다. ### 출력 예시 ``` root |-- firstname: string |-- lastname: string |-- address: struct | |-- street: string | |-- city: string | |-- state: string | |-- country: string |-- phone: long |-- affiliations: array | |-- element: string --- { "firstname": "Mary", "lastname": "Major", "address": { "street": "7821 Spot Place", "city": "Centerville", "state": "OK", "country": "US" }, "phone": 19185550023, "affiliations": [ "Example Dot Com", "Example Independent Research", "Example.io" ] } { "firstname": "Paulo", "lastname": "Santos", "address": { "street": "123 Maple Street", "city": "London", "state": "Ontario", "country": "CA" }, "phone": 12175550181, "affiliations": [ "General Anonymous Example Products", "Example Dot Com" ] } --- root |-- firstname: string |-- lastname: string |-- address: struct | |-- street: string | |-- city: string | |-- state: string | |-- country: string { "firstname": "Mary", "lastname": "Major", "address": { "street": "7821 Spot Place", "city": "Centerville", "state": "OK", "country": "US" } } { "firstname": "Paulo", "lastname": "Santos", "address": { "street": "123 Maple Street", "city": "London", "state": "Ontario", "country": "CA" } } --- root |-- phone: long |-- affiliations: array | |-- element: string { "phone": 19185550023, "affiliations": [ "Example Dot Com", "Example Independent Research", "Example.io" ] } { "phone": 12175550181, "affiliations": [ "General Anonymous Example Products", "Example Dot Com" ] } ``` ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-flat-map-__call__) + [Apply](#aws-glue-api-crawler-pyspark-transforms-flat-map-apply) + [명칭](#aws-glue-api-crawler-pyspark-transforms-flat-map-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-flat-map-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-flat-map-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-flat-map-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-flat-map-describeErrors) + [설명](#aws-glue-api-crawler-pyspark-transforms-flat-map-describe) ## \$1\$1call\$1\$1(dfc, BaseTransform, frame\$1name, transformation\$1ctx = "", \$1\$1base\$1kwargs) 컬렉션의 각 `DynamicFrame`에 변환을 적용하고 결과를 플랫합니다. + `dfc` – 플랫맵할 `DynamicFrameCollection`입니다(필수). + `BaseTransform` – `GlueTransform`로부터 얻어진 변환을 사용하여 컬렉션의 각 멤버에게 적용합니다(필수). + `frame_name` - 컬렉션의 요소를 전달하기 위한 인수 이름입니다(필수). + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `base_kwargs` - 기본 변환으로 전달을 위한 인수입니다(필수). `DynamicFrameCollection` 원본의 변환을 각 `DynamicFrame`에 적용하여 생성한 새로운 `DynamicFrameCollection`을 반환합니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # Join 클래스 두 개의 `DynamicFrames`에 동일한 조인을 실행합니다. ## 예제 `DynamicFrames`에 조인하려면 [`DynamicFrame.join()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-join) 메서드를 사용하는 것이 좋습니다. 코드에 대한 예제는 [예: 조인을 사용하여 `DynamicFrames` 결합](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-join-example) 단원을 참조하세요. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-join-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-join-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-join-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-join-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-join-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-join-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-join-describeErrors) + [설명](#aws-glue-api-crawler-pyspark-transforms-join-describe) ## \$1\$1call\$1\$1(frame1, frame2, keys1, keys2, transformation\$1ctx = "") 두 개의 `DynamicFrames`에 동일한 조인을 실행합니다. + `frame1` - 조인할 첫 번째 `DynamicFrame`입니다(필수). + `frame2` - 조인할 두 번째 `DynamicFrame`입니다(필수). + `keys1` - 첫 번째 프레임을 조인할 키입니다(필수). + `keys2` - 두 번째 프레임을 조인할 키입니다(필수). + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). 두 `DynamicFrames`를 조인하여 생성된 새 `DynamicFrame` 항목을 반환합니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # Map 클래스 입력 `DynamicFrame`의 모든 기록에 함수를 적용하여 새로운 `DynamicFrame`을 설계합니다. ## 예제 `DynamicFrame`의 모든 레코드에 함수를 적용하는 [`DynamicFrame.map()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-map) 메서드를 사용하는 것이 좋습니다. 코드에 대한 예제는 [예: map을 사용하여 `DynamicFrame`의 모든 레코드에 함수를 적용합니다.](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-map-example) 단원을 참조하세요. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-map-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-map-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-map-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-map-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-map-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-map-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-map-describeErrors) + [설명](#aws-glue-api-crawler-pyspark-transforms-map-describe) ## \$1\$1call\$1\$1(frame, f, transformation\$1ctx="", info="", stageThreshold=0, totalThreshold=0) 기존 `DynamicFrame`의 모든 `DynamicRecords`에 지정된 함수를 적용한 결과로써 새로운 `DynamicFrame`을 반환합니다. + `frame` - 원본 `DynamicFrame`은 매핑 함수를 적용합니다(필수). + `f` - `DynamicFrame`에 모든 `DynamicRecords`를 적용하려는 함수입니다. 함수는 매핑 결과에 따라 `DynamicRecord`를 논증으로 받아들이고 새로운 `DynamicRecord`를 반환합니다(필수). `DynamicRecord`는 `DynamicFrame`내 논리적 기록입니다. 자기 설명적이고 고정 스키마를 준수하지 않은 데이터에 사용될 수 있다는 점을 제외하면 Apache Spark `DataFrame`의 열과 비슷합니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 변환에 따른 오류 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다(선택 사항). 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다(선택 사항). 기본값은 0입니다. 기존 `DynamicFrame`의 모든 `DynamicRecords`에 지정된 함수를 적용한 결과로써 새로운 `DynamicFrame`을 반환합니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # MapToCollection 클래스 지정된 `DynamicFrameCollection`의 각 `DynamicFrame`에 변환을 적용합니다. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-__call__) + [Apply](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-apply) + [명칭](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-describeErrors) + [설명](#aws-glue-api-crawler-pyspark-transforms-MapToCollection-describe) ## \$1\$1call\$1\$1(dfc, BaseTransform, frame\$1name, transformation\$1ctx = "", \$1\$1base\$1kwargs) 지정된 `DynamicFrameCollection`의 각 `DynamicFrame`에 변환 함수를 적용합니다. + `dfc` - 원본 `DynamicFrameCollection`은 변환 함수를 적용합니다(필수). + `callable` - 호출 가능한 변환 함수는 각 컬렉션의 수에 적용됩니다(필수). + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). `DynamicFrameCollection` 원본의 변환을 각 `DynamicFrame`에 적용하여 생성한 새로운 `DynamicFrameCollection`을 반환합니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # Relationalize 클래스 중첩된 스키마를 `DynamicFrame`에 평면화하고 평면화된 프레임에서 배열의 열을 회전합니다. ## 예제 `DynamicFrame`을 관계형으로 만들려면 [`DynamicFrame.relationalize()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-relationalize) 메서드를 사용하는 것이 좋습니다. 코드에 대한 예제는 [예: 관계형 만들기를 사용하여 `DynamicFrame` 내 중첩된 스키마를 플랫하게 만들기](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-relationalize-example) 단원을 참조하세요. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-Relationalize-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-Relationalize-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-Relationalize-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-Relationalize-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-Relationalize-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-Relationalize-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-Relationalize-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-Relationalize-describe) ## \$1\$1call\$1\$1(frame, staging\$1path=None, name='roottable', options=None, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) `DynamicFrame`를 관계화하고 중첩되지 않은 열과 회전되는 배열 열이 생성한 프레임 목록을 생산합니다. 회전된 배열 열은 중첩되지 않는 상태에서 생성된 조인 키를 사용하여 루트 테이블에 연결될 수 있습니다. + `frame` - 관계화할 `DynamicFrame`입니다(필수). + `staging_path` - 메소드가 CSV 포맷으로 회전 테이블의 파티션을 저장하는 경로입니다(선택 사항). 회전 테이블은 이 경로부터 다시 읽습니다. + `name` - 루트 테이블의 이름입니다(선택 사항). + `options` - 선택적 파라미터의 딕셔너리입니다. 현재 사용되지 않습니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 변환에 따른 오류 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다(선택 사항). 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다(선택 사항). 기본값은 0입니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # RenameField 클래스 `DynamicFrame` 내에서 노드 이름을 바꿉니다. ## 예제 `DynamicFrame`에서 필드 이름을 다시 지정하기 위해 [`DynamicFrame.rename_field()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-rename_field) 메소드를 사용하는 것이 좋습니다. 코드에 대한 예제는 [예: rename\$1field를 사용하여 `DynamicFrame`의 필드 이름을 변경합니다](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-rename_field-example) 단원을 참조하세요. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-RenameField-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-RenameField-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-RenameField-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-RenameField-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-RenameField-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-RenameField-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-RenameField-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-RenameField-describe) ## \$1\$1call\$1\$1(frame, old\$1name, new\$1name, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) `DynamicFrame` 내에서 노드 이름을 바꿉니다. + `frame` – `DynamicFrame`은 노드 이름을 바꿉니다(필수). + `old_name` - 이름을 바꿀 노드의 전체 경로입니다(필수). 기존 이름에 점이 있으면 그 주위로 억음 부호(````)를 하지 않는 한 RenameField는 실행되지 않습니다. 예를 들어, `this.old.name`를 `thisNewName`로 바꾸려면 다음과 같이 RenameField를 불러올 수 있습니다. ``` newDyF = RenameField(oldDyF, "`this.old.name`", "thisNewName") ``` + `new_name` - 전체 경로를 포함한 새로운 이름입니다(필수). + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 변환에 따른 오류 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다(선택 사항). 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다(선택 사항). 기본값은 0입니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # ResolveChoice 클래스 선택 유형을 `DynamicFrame` 내에서 해결합니다. ## 예제 [`DynamicFrame.resolveChoice()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-resolveChoice) 메서드를 사용하여 `DynamicFrame`에 여러 유형이 포함된 필드를 처리하는 것이 좋습니다. 코드에 대한 예제는 [예: resolveChoice를 사용하여 여러 유형이 포함된 열을 처리합니다](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-resolveChoice-example) 단원을 참조하세요. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-ResolveChoice-describe) ## \$1\$1call\$1\$1(frame, specs = none, choice = "", transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) 모호한 유형을 `DynamicFrame` 내에서 해결하기 위한 정보를 제공합니다. 결과 `DynamicFrame`를 반환합니다. + `frame` – `DynamicFrame`은 선택 유형을 해결합니다(필수). + `specs` - 해결할 특정 모호성 목록이며, 각각은 `(path, action)`의 튜플 형식입니다. `path` 가치는 특정 모호한 요소를 확인하고 `action` 가치는 관련 해결 방안을 제안합니다. `spec` 및 `choice` 파라미터 중 하나만 사용할 수 있습니다. `spec` 파라미터가 `None`이 아니면 `choice` 파라미터는 빈 문자열이어야 합니다. 반대로 `choice` 파라미터가 빈 문자열이 아니면, `spec` 파라미터는 `None`이어야 합니다. 어떠한 파라미터도 제공되지 않을 경우, AWS Glue는 스키마를 구문분석하고 모호함을 해결하기 위해 사용합니다. `specs` 튜플의 `action` 부분에서 다음 해결 전략 중 하나를 지정할 수 있습니다. + `cast` - 보내버릴 유형을 명시할 수 있도록 도와줍니다. (예를 들어, `cast:int`). + `make_cols` - 데이터를 평면화하여 잠재적 모호성을 해결합니다. 예를 들어, `columnA`가 `int` 혹은 `string`이면 해결 방안은 `DynamicFrame`에서 `columnA_int`와 `columnA_string`으로 된 두 열을 생산하는 것입니다. + `make_struct` - 데이터를 나타내도록 구조를 사용하여 잠재적 모호성을 해결합니다. 예를 들어, 열에서 데이터가 `int` 혹은 `string`이면 `make_struct` 작업은 각 `DynamicFrame`와 `int`을 포함하는 결과인 `string`의 구조 열을 생성합니다. + `project` - 결과 `DynamicFrame`에 지정된 유형의 값만 유지하여 잠재적 모호성을 해결합니다. 예를 들어 `ChoiceType` 열에서 데이터가 `int` 혹은 `string`이면 `project:string` 작업은 `string` 유형이 아닌 결과 `DynamicFrame`의 값을 삭제합니다. 만약 `path`가 배열을 확인하면, 빈 대괄호를 배열 이름 다음에 만들어 모호성을 피합니다. 예를 들어, 다음과 같은 구조화된 데이터와 작업한다고 가정합시다. ``` "myList": [ { "price": 100.00 }, { "price": "$100.00" } ] ``` `path`를 `"myList[].price"`로 설정하고, `action`을 `"cast:double"`로 설정하여 가격의 문자열 버전보다 숫자 버전을 선택할 수 있습니다. + `choice` - `specs` 파라미터가 `None`인 경우의 기본 해결 작업입니다. `specs` 파라미터가 `None`이 아니면 이것은 어떠한 것에도 설정되지 않고 빈 문자열이어야 합니다. 이 인수는 앞에서 설명된 `specs` 작업 외에 다음 작업을 지원합니다. + `MATCH_CATALOG` – 각 `ChoiceType`을 지정된 Data Catalog 테이블의 해당 유형에 캐스팅해봅니다. + `database` — `MATCH_CATALOG` 선택 항목과 함께 사용할 AWS Glue 데이터 카탈로그 데이터베이스입니다(`MATCH_CATALOG`에 대해 필수). + `table_name`— `MATCH_CATALOG` 작업에 사용할 AWS Glue 데이터 카탈로그 테이블 이름 입니다(`MATCH_CATALOG`에 대해 필수). + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 변환에 따른 오류 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다(선택 사항). 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다(선택 사항). 기본값은 0입니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # SelectFields 클래스 `SelectFields` 클래스는 기존 `DynamicFrame`에서 새 `DynamicFrame` 항목을 만들고 지정한 필드만 유지합니다. `SelectFields`는 SQL `SELECT` 문과 유사한 기능을 제공합니다. ## 예제 `DynamicFrame`에서 필드를 선택하기 위해 [`DynamicFrame.select_fields()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-select_fields) 방법을 사용하는 것이 좋습니다. 코드에 대한 예제는 [예: select\$1fields를 사용하여 선택한 필드로 새 `DynamicFrame` 생성](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-select_fields-example) 단원을 참조하세요. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-SelectFields-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-SelectFields-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-SelectFields-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-SelectFields-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-SelectFields-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-SelectFields-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-SelectFields-describeErrors) + [설명](#aws-glue-api-crawler-pyspark-transforms-SelectFields-describe) ## \$1\$1call\$1\$1(frame, paths, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) `DynamicFrame`의 필드(노드)를 얻습니다. + `frame` – `DynamicFrame`에서 필드를 선택합니다(필수). + `paths` - 선택할 필드의 전체 경로 목록입니다(필수). + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 변환에 따른 오류 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다(선택 사항). 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다(선택 사항). 기본값은 0입니다. 특정 필드만 포함한 새로운 `DynamicFrame`을 반환합니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # SelectFromCollection 클래스 `DynamicFrameCollection`에서 `DynamicFrame` 하나를 선택합니다. ## 예시 이 예제에서는 `SelectFromCollection`을 사용하여 `DynamicFrameCollection`에서 `DynamicFrame`를 선택합니다. **예제 데이터 세트** 예제에서는 `split_rows_collection`을 호출한 `DynamicFrameCollection`에서 두 개의 `DynamicFrames`을 선택합니다. 다음은 `split_rows_collection`에서의 키 목록입니다. ``` dict_keys(['high', 'low']) ``` **예제 코드** ``` # Example: Use SelectFromCollection to select # DynamicFrames from a DynamicFrameCollection from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.transforms import SelectFromCollection # Create GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) # Select frames and inspect entries frame_low = SelectFromCollection.apply(dfc=split_rows_collection, key="low") frame_low.toDF().show() frame_high = SelectFromCollection.apply(dfc=split_rows_collection, key="high") frame_high.toDF().show() ``` ### 출력 ``` +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 1| 0| fax| 202-225-3307| | 1| 1| phone| 202-225-5731| | 2| 0| fax| 202-225-3307| | 2| 1| phone| 202-225-5731| | 3| 0| fax| 202-225-3307| | 3| 1| phone| 202-225-5731| | 4| 0| fax| 202-225-3307| | 4| 1| phone| 202-225-5731| | 5| 0| fax| 202-225-3307| | 5| 1| phone| 202-225-5731| | 6| 0| fax| 202-225-3307| | 6| 1| phone| 202-225-5731| | 7| 0| fax| 202-225-3307| | 7| 1| phone| 202-225-5731| | 8| 0| fax| 202-225-3307| | 8| 1| phone| 202-225-5731| | 9| 0| fax| 202-225-3307| | 9| 1| phone| 202-225-5731| | 10| 0| fax| 202-225-6328| | 10| 1| phone| 202-225-4576| +---+-----+------------------------+-------------------------+ only showing top 20 rows +---+-----+------------------------+-------------------------+ | id|index|contact_details.val.type|contact_details.val.value| +---+-----+------------------------+-------------------------+ | 11| 0| fax| 202-225-6328| | 11| 1| phone| 202-225-4576| | 11| 2| twitter| RepTrentFranks| | 12| 0| fax| 202-225-6328| | 12| 1| phone| 202-225-4576| | 12| 2| twitter| RepTrentFranks| | 13| 0| fax| 202-225-6328| | 13| 1| phone| 202-225-4576| | 13| 2| twitter| RepTrentFranks| | 14| 0| fax| 202-225-6328| | 14| 1| phone| 202-225-4576| | 14| 2| twitter| RepTrentFranks| | 15| 0| fax| 202-225-6328| | 15| 1| phone| 202-225-4576| | 15| 2| twitter| RepTrentFranks| | 16| 0| fax| 202-225-6328| | 16| 1| phone| 202-225-4576| | 16| 2| twitter| RepTrentFranks| | 17| 0| fax| 202-225-6328| | 17| 1| phone| 202-225-4576| +---+-----+------------------------+-------------------------+ only showing top 20 rows ``` ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-apply) + [name](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-SelectFromCollection-describe) ## \$1\$1call\$1\$1(dfc, key, transformation\$1ctx = "") `DynamicFrameCollection`에서 `DynamicFrame` 하나를 가져옵니다. + `dfc` – `DynamicFrame`을 선택해야 하는 `DynamicFrameCollection`입니다(필수). + `key` - 선택할 `DynamicFrame`의 키입니다(필수). + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # Simplify\$1ddb\$1json 클래스 `DynamicFrame`의 중첩된 열 중 특히 DynamoDB JSON 구조에 있는 열을 단순화하고 단순화된 새로운 `DynamicFrame`을 반환합니다. ## 예시 특히 DynamoDB JSON 구조에 있는 `DynamicFrame`의 중첩 열을 단순화하려면 `DynamicFrame.simplify_ddb_json()` 메서드를 사용하는 것이 좋습니다. 코드에 대한 예제는 [예제: simplify\$1ddb\$1json을 사용하여 DynamoDB JSON 단순화 호출](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-simplify-ddb-json-example) 단원을 참조하세요. # Spigot 클래스 AWS Glue 작업에 의해 수행된 변환을 확인하는 데 도움이 되도록 샘플 레코드를 지정된 대상에 기록합니다. ## 예제 [`DynamicFrame.spigot()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-spigot) 메서드를 사용하여 `DynamicFrame`에서 지정한 대상에 레코드의 하위 집합을 쓰는 것이 좋습니다. 코드에 대한 예제는 [예: spigot을 사용하여 `DynamicFrame`에서 Amazon S3에 샘플 필드를 작성합니다](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-spigot-example) 단원을 참조하세요. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-spigot-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-spigot-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-spigot-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-spigot-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-spigot-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-spigot-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-spigot-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-spigot-describe) ## \$1\$1call\$1\$1(frame, path, options, transformation\$1ctx = "") 변환 중에 특정 대상 주소에 샘플 기록을 씁니다. + `frame` - spigot으로 `DynamicFrame`입니다(필수). + `path` - 작성할 기본 대상 주소 경로입니다(필수). + `options` - 옵션을 지정하는 JSON 키-값 페어입니다(선택 사항). `"topk"` 옵션은 첫 번째 *k* 레코드가 작성되어야 한다는 것을 명시합니다. `"prob"` 옵션은 특정 레코드를 선택할 확률(10진수)을 명시합니다. 작성할 레코드를 선택할 때 사용합니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # SplitFields 클래스 지정된 필드로 `DynamicFrame`을 두 개의 새로운 것으로 쪼갭니다. ## 예제 `DynamicFrame`에서 레코드를 분할하기 위해 [`DynamicFrame.split_fields()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-split_fields) 메소드를 사용하는 것이 좋습니다. 코드에 대한 예제는 [예제: split\$1fields를 사용하여 선택한 필드를 별도의 `DynamicFrame`로 분할합니다](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-split_fields-example) 단원을 참조하세요. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-SplitFields-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-SplitFields-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-SplitFields-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-SplitFields-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-SplitFields-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-SplitFields-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-SplitFields-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-SplitFields-describe) ## \$1\$1call\$1\$1(frame, paths, name1 = none, name2 = none, transformation\$1ctx = "", info = "", stageThreshold = 0, totalThreshold = 0) `DynamicFrame`의 하나 이상의 필드를 새로운 `DynamicFrame`으로 분할하고 남겨진 필드를 포함하는 새로운 다른 `DynamicFrame`을 생성합니다. + `frame` – 소스 `DynamicFrame`으로 새로운 두 개로 스플릿합니다(필수). + `paths` - 스플릿할 필드의 전체 경로 목록입니다(필수). + `name1` - 스플릿될 필드를 포함할 `DynamicFrame`에 지정되는 이름입니다. 이름이 제공되지 않으면 소스 프레임의 이름은 "1"이 붙여져 사용됩니다. + `name2` - 지정된 필드가 스플릿된 후 남겨진 필드를 포함하는 `DynamicFrame`에 지정되는 이름입니다. 이름이 제공되지 않으면 소스 프레임의 이름은 "2"이 붙여져 사용됩니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 변환에 따른 오류 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다(선택 사항). 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다(선택 사항). 기본값은 0입니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # SplitRows 클래스 두 개의 `DynamicFrames`가 포함된 `DynamicFrameCollection`를 만듭니다. `DynamicFrame`은 분할 예정으로 지정된 행만 포함하고 다른 하나는 남겨진 모든 행을 포함합니다. ## 예제 `DynamicFrame`의 행을 분할하려면 [`DynamicFrame.split_rows()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-split_rows) 메서드를 사용하는 것이 좋습니다. 코드에 대한 예제는 [예제: split\$1rows를 사용하여 `DynamicFrame` 행을 분할합니다](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-split_rows-example) 단원을 참조하세요. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-SplitRows-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-SplitRows-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-SplitRows-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-SplitRows-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-SplitRows-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-SplitRows-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-SplitRows-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-SplitRows-describe) ## \$1\$1call\$1\$1(frame, comparison\$1dict, name1="frame1", name2="frame2", transformation\$1ctx = "", info = none, stageThreshold = 0, totalThreshold = 0) 새로운 `DynamicFrame`으로 `DynamicFrame`의 하나 이상의 열을 스플릿합니다. + `frame` – 소스 `DynamicFrame`으로 새로운 두 개로 스플릿합니다(필수). + `comparison_dict` - 열까지 전체 경로의 키와 열 값이 비교된 값의 매핑 비교기를 위한 다른 딕셔너리인 값의 딕셔너리입니다. 예를 들어, `{"age": {">": 10, "<": 20}}`는 "수명"이 범위를 벗어난 행에서 "수명" 값이 10과 20 사이인 행을 제외하고 스플릿합니다. + `name1` - 스플릿될 행을 포함할 `DynamicFrame`에 지정되는 이름입니다. + `name2` - 지정된 행이 스플릿된 후 남겨진 `DynamicFrame`에 지정되는 이름입니다. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 변환에 따른 오류 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다(선택 사항). 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다(선택 사항). 기본값은 0입니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # Unbox 클래스 `DynamicFrame`의 문자열 필드를 개봉합니다(다시 포맷합니다). ## 예제 `DynamicFrame`에서 필드를 레코드를 개봉하기 위해 [`DynamicFrame.unbox()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-unbox) 메소드를 사용하는 것이 좋습니다. 코드에 대한 예제는 [예제: 개봉하기를 사용하여 문자열 필드를 구조에 개봉하기](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-unbox-example) 단원을 참조하세요. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-Unbox-__call__) + [applyapply](#aws-glue-api-crawler-pyspark-transforms-Unbox-apply) + [이름이름](#aws-glue-api-crawler-pyspark-transforms-Unbox-name) + [describeArgsdescribeArgs](#aws-glue-api-crawler-pyspark-transforms-Unbox-describeArgs) + [describeReturndescribeReturn](#aws-glue-api-crawler-pyspark-transforms-Unbox-describeReturn) + [describeTransformdescribeTransform](#aws-glue-api-crawler-pyspark-transforms-Unbox-describeTransform) + [describeErrorsdescribeErrors](#aws-glue-api-crawler-pyspark-transforms-Unbox-describeErrors) + [describedescribe](#aws-glue-api-crawler-pyspark-transforms-Unbox-describe) ## \$1\$1call\$1\$1(frame, path, format, transformation\$1ctx = "", info="", stageThreshold=0, totalThreshold=0, \$1\$1options) `DynamicFrame`의 문자열 필드를 개봉합니다. + `frame` – `DynamicFrame`에서 필드를 개봉합니다(필수). + `path` - 개봉할 `StringNode`로의 전체 경로입니다(필수). + `format` - 포맷 사양입니다(선택 사항). 여러 포맷을 지원하는 Amazon S3 또는 AWS Glue 연결에 사용됩니다. 지원되는 포맷은 [AWS Glue for Spark에서 입력 및 출력의 데이터 형식 옵션](aws-glue-programming-etl-format.md)를 참조하세요. + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 변환에 따른 오류 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다(선택 사항). 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다(선택 사항). 기본값은 0입니다. + `separator` - 구분자 토큰입니다(선택 사항). + `escaper` - 이스케이프 토큰입니다(선택 사항). + `skipFirst` – 첫 번째 데이터 행을 건너뛰어야 한다면 `True`이고 건너뛰지 않아야 한다면 `False`입니다(선택 사항). + withSchema`` – 개봉할 데이터 스키마를 포함하는 문자열입니다(선택 사항). 이것은 `StructType.json`을 사용하여 생성되어야 합니다. + `withHeader` – 헤더를 포함해 데이터가 개봉되면 `True`이고 그렇지 않으면 `False`입니다(선택 사항). ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # UnnestFrame 클래스 `DynamicFrame`을 내보내고 중첩된 객체를 최상위 요소로 평면화하여 배열 객체의 조인 키를 생성합니다. ## 예제 [`DynamicFrame.unnest()`](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-unnest) 메소드를 사용하여 `DynamicFrame`에서 중첩된 구조를 평면화하는 것이 좋습니다. 코드에 대한 예제는 [예제: 중첩 해제를 사용하여 중첩된 필드를 최상위 필드로 전환합니다](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#pyspark-unnest-example) 단원을 참조하세요. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-UnnestFrame-describe) ## \$1\$1call\$1\$1(frame, transformation\$1ctx = "", info="", stageThreshold=0, totalThreshold=0) `DynamicFrame`을 내보내고 중첩된 객체를 최상위 요소로 평면화하여 배열 객체의 조인 키를 생성합니다. + `frame` - 중첩하지 않을 `DynamicFrame`입니다(필수). + `transformation_ctx` - 고유 문자열을 통해 상태 정보를 확인합니다(선택 사항). + `info` - 변환에 따른 오류 관련 문자열입니다(선택 사항). + `stageThreshold` - 오류가 발생하기 전까지 변환에 따라 생길 수 있는 최대 오류 수입니다(선택 사항). 기본값은 0입니다. + `totalThreshold` - 오류가 진행되기 전까지 생길 수 있는 최대 전체 오류 수입니다(선택 사항). 기본값은 0입니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # FlagDuplicatesInColumn 클래스 `FlagDuplicatesInColumn` 변환은 각 행에 지정된 값이 있는 새 열을 반환합니다. 이 열은 행의 소스 열 값이 소스 열의 이전 행 값과 일치하는지 여부를 나타냅니다. 일치 항목이 발견되면 중복으로 플래그가 지정됩니다. 초기 발생은 이전 행과 일치하지 않으므로 플래그가 지정되지 않습니다. ## 예제 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) datasource1 = spark.read.json("s3://${BUCKET}/json/zips/raw/data") try: df_output = column.FlagDuplicatesInColumn.apply( data_frame=datasource1, spark_context=sc, source_column="city", target_column="flag_col", true_string="True", false_string="False" ) except: print("Unexpected Error happened ") raise ``` ## 출력 `FlagDuplicatesInColumn` 변환은 `df\$1output` DataFrame에 새 열 `flag\$1col`을 추가합니다. 이 열에는 해당 행의 `city` 열에 중복 값이 있는지 여부를 나타내는 문자열 값이 포함됩니다. 행에 중복된 `city` 값이 있는 경우 `flag\$1col`에는 `true\$1string` 값 'True'가 포함됩니다. 행에 고유한 `city` 값이 있는 경우 `flag\$1col`에는 `false\$1string` 값 'False'가 포함됩니다. 결과 `df\$1output` DataFrame에는 원래 `datasource1` DataFrame의 모든 열과 중복 `city` 값을 나타내는 추가 `flag\$1col` 열이 포함됩니다. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-FlagDuplicatesInColumn-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicatesInColumn-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicatesInColumn-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicatesInColumn-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicatesInColumn-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicatesInColumn-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicatesInColumn-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicatesInColumn-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1column, target\$1column, true\$1string=DEFAULT\$1TRUE\$1STRING, false\$1string=DEFAULT\$1FALSE\$1STRING) `FlagDuplicatesInColumn` 변환은 각 행에 지정된 값이 있는 새 열을 반환합니다. 이 열은 행의 소스 열 값이 소스 열의 이전 행 값과 일치하는지 여부를 나타냅니다. 일치 항목이 발견되면 중복으로 플래그가 지정됩니다. 초기 발생은 이전 행과 일치하지 않으므로 플래그가 지정되지 않습니다. + `source_column` - 소스 열의 이름. + `target_column` - 대상 열의 이름. + `true_string` - 소스 열 값이 해당 열의 이전 값을 복제할 때 대상 열에 삽입할 문자열. + `false_string` - 소스 열 값이 해당 열의 이전 값과 다를 때 대상 열에 삽입할 문자열. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # FormatPhoneNumber 클래스 `FormatPhoneNumber` 변환은 전화번호 문자열을 형식이 지정된 값으로 변환하는 열을 반환합니다. ## 예제 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ ("408-341-5669",), ("4083415669",) ], ["phone"], ) try: df_output = column_formatting.FormatPhoneNumber.apply( data_frame=input_df, spark_context=sc, source_column="phone", default_region="US" ) df_output.show() except: print("Unexpected Error happened ") raise ``` ## 출력 출력은 다음과 같습니다. ``` ``` +---------------+ | phone| +---------------+ |(408) 341-5669| |(408) 341-5669| +---------------+ ``` ``` `FormatPhoneNumber` 변환은 `source\$1column`을 `"phone"`으로, `default\$1region`을 `"US"`로 가져옵니다. 변환은 초기 형식에 관계없이 두 전화번호의 형식을 표준 미국 형식 `(408) 341-5669`로 지정합니다. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-FormatPhoneNumber-__call__) + [applyapply](#aws-glue-api-crawler-pyspark-transforms-FormatPhoneNumber-apply) + [이름이름](#aws-glue-api-crawler-pyspark-transforms-FormatPhoneNumber-name) + [describeArgsdescribeArgs](#aws-glue-api-crawler-pyspark-transforms-FormatPhoneNumber-describeArgs) + [describeReturndescribeReturn](#aws-glue-api-crawler-pyspark-transforms-FormatPhoneNumber-describeReturn) + [describeTransformdescribeTransform](#aws-glue-api-crawler-pyspark-transforms-FormatPhoneNumber-describeTransform) + [describeErrorsdescribeErrors](#aws-glue-api-crawler-pyspark-transforms-FormatPhoneNumber-describeErrors) + [describedescribe](#aws-glue-api-crawler-pyspark-transforms-FormatPhoneNumber-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1column, phone\$1number\$1format=None, default\$1region=None, default\$1region\$1column=None) `FormatPhoneNumber` 변환은 전화번호 문자열을 형식이 지정된 값으로 변환하는 열을 반환합니다. + `source_column` – 기존 열의 이름입니다. + `phone_number_format` - 전화번호를 변환할 형식. 형식을 지정하지 않은 경우 기본값은 국제적으로 인정되는 표준 전화번호 형식(`E.164`)입니다. 유효한 값은 다음과 같습니다. + E164(E 뒤의 마침표 생략) + `default_region` - 번호 자체에 국가 코드가 없는 경우 전화번호의 리전을 지정하는 두 개 또는 세 개의 대문자로 구성된 유효한 리전 코드. 최대 `defaultRegion` 또는 `defaultRegionColumn` 중 하나를 제공할 수 있습니다. + `default_region_column` - 고급 데이터 유형 `Country`의 열 이름. 지정된 열의 리전 코드는 번호 자체에 국가 코드가 없는 경우 전화번호의 국가 코드를 결정하는 데 사용됩니다. 최대 `defaultRegion` 또는 `defaultRegionColumn` 중 하나를 제공할 수 있습니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # FormatCase 클래스 `FormatCase` 변환은 열의 각 문자열을 지정된 케이스 유형으로 변경합니다. ## 예제 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) datasource1 = spark.read.json("s3://${BUCKET}/json/zips/raw/data") try: df_output = data_cleaning.FormatCase.apply( data_frame=datasource1, spark_context=sc, source_column="city", case_type="LOWER" ) except: print("Unexpected Error happened ") raise ``` ## 출력 `FormatCase` 변환은 `case\$1type="LOWER"` 파라미터를 기반으로 `city` 열의 값을 소문자로 변환합니다. 결과 `df\$1output` DataFrame에는 원래 `datasource1` DataFrame의 모든 열이 포함되지만 `city` 열 값은 소문자로 표시됩니다. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-FormatCase-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-FormatCase-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-FormatCase-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-FormatCase-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-FormatCase-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-FormatCase-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-FormatCase-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-FormatCase-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1column, case\$1type) `FormatCase` 변환은 열의 각 문자열을 지정된 케이스 유형으로 변경합니다. + `source_column` – 기존 열의 이름입니다. + `case_type` – 지원되는 케이스 유형은 `CAPITAL`, `LOWER`, `UPPER`, `SENTENCE`입니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # FillWithMode 클래스 `FillWithMode` 변환은 지정한 전화번호 형식에 따라 열의 형식을 지정합니다. 일부 값이 동일한 타이 브레이커 로직을 지정할 수도 있습니다. 예를 들어 다음과 같은 입력 값을 고려합니다. `1 2 2 3 3 4` modeType이 `MINIMUM`이면 `FillWithMode`에서 모드 값으로 2를 반환합니다. modeType이 `MAXIMUM`이면 모드는 3입니다. `AVERAGE`의 경우 모드는 2.5입니다. ## 예제 ``` from awsglue.context import * from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ (105.111, 13.12), (1055.123, 13.12), (None, 13.12), (13.12, 13.12), (None, 13.12), ], ["source_column_1", "source_column_2"], ) try: df_output = data_quality.FillWithMode.apply( data_frame=input_df, spark_context=sc, source_column="source_column_1", mode_type="MAXIMUM" ) df_output.show() except: print("Unexpected Error happened ") raise ``` ## 출력 지정된 코드의 출력은 다음과 같습니다. ``` ``` +---------------+---------------+ |source_column_1|source_column_2| +---------------+---------------+ | 105.111| 13.12| | 1055.123| 13.12| | 1055.123| 13.12| | 13.12| 13.12| | 1055.123| 13.12| +---------------+---------------+ ``` ``` `awsglue.data\$1quality` 모듈의 `FillWithMode` 변환은 `input\$1df` DataFrame에 적용됩니다. `source_column_1` 열의 `null` 값을 해당 열의 null이 아닌 값 중 최댓값(`mode\$1type="MAXIMUM"`)으로 바꿉니다. 이 경우 `source_column_1` 열의 최댓값은 `1055.123`입니다. 따라서 `source_column_1`의 `null` 값은 출력 DataFrame `df\$1output`에서 `1055.123`으로 바뀝니다. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-FillWithMode-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-FillWithMode-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-FillWithMode-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-FillWithMode-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-FillWithMode-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-FillWithMode-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-FillWithMode-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-FillWithMode-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1column, mode\$1type) `FillWithMode` 변환은 열의 문자열 케이스 형식을 지정합니다. + `source_column` – 기존 열의 이름입니다. + `mode_type` - 데이터의 타이 값을 확인하는 방법. 이 값은 `MINIMUM`, `NONE`, `AVERAGE` 또는 `MAXIMUM` 중 하나여야 합니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # FlagDuplicateRows 클래스 `FlagDuplicateRows` 변환은 각 행에 지정된 값이 있는 새 열을 반환합니다. 이 열은 해당 행이 데이터세트의 이전 행과 정확히 일치하는지 여부를 나타냅니다. 일치 항목이 발견되면 중복으로 플래그가 지정됩니다. 초기 발생은 이전 행과 일치하지 않으므로 플래그가 지정되지 않습니다. ## 예제 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ (105.111, 13.12), (13.12, 13.12), (None, 13.12), (13.12, 13.12), (None, 13.12), ], ["source_column_1", "source_column_2"], ) try: df_output = data_quality.FlagDuplicateRows.apply( data_frame=input_df, spark_context=sc, target_column="flag_row", true_string="True", false_string="False", target_index=1 ) except: print("Unexpected Error happened ") raise ``` ## 출력 출력은 `source_column_1` 열을 기반으로 행의 중복 여부를 나타내는 추가 열 `flag_row`를 포함하는 PySpark DataFrame입니다. 결과 `df\$1output` DataFrame에는 다음 행이 포함됩니다. ``` ``` +---------------+---------------+--------+ |source_column_1|source_column_2|flag_row| +---------------+---------------+--------+ | 105.111| 13.12| False| | 13.12| 13.12| True| | null| 13.12| True| | 13.12| 13.12| True| | null| 13.12| True| +---------------+---------------+--------+ ``` ``` `flag_row` 열은 행이 중복인지 여부를 나타냅니다. `true\$1string`은 'True'로 설정되고 `false\$1string`은 'False'로 설정됩니다. `target\$1index`는 1로 설정됩니다. 즉, 출력 DataFrame의 두 번째 위치(인덱스 1)에 `flag_row` 열이 삽입됩니다. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-FlagDuplicateRows-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicateRows-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicateRows-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicateRows-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicateRows-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicateRows-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicateRows-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-FlagDuplicateRows-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, target\$1column, true\$1string=DEFAULT\$1TRUE\$1STRING, false\$1string=DEFAULT\$1FALSE\$1STRING, target\$1index=None) `FlagDuplicateRows` 변환은 각 행에 지정된 값이 있는 새 열을 반환합니다. 이 열은 해당 행이 데이터세트의 이전 행과 정확히 일치하는지 여부를 나타냅니다. 일치 항목이 발견되면 중복으로 플래그가 지정됩니다. 초기 발생은 이전 행과 일치하지 않으므로 플래그가 지정되지 않습니다. + `true_string` - 행이 이전 행과 일치하는 경우 삽입할 값. + `false_string` - 행이 고유할 경우 삽입할 값. + `target_column` - 데이터세트에 삽입된 새 열의 이름. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # RemoveDuplicates 클래스 `RemoveDuplicates` 변환은 선택한 소스 열에서 중복 값이 발생하는 경우 전체 행을 삭제합니다. ## 예제 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ (105.111, 13.12), (13.12, 13.12), (None, 13.12), (13.12, 13.12), (None, 13.12), ], ["source_column_1", "source_column_2"], ) try: df_output = data_quality.RemoveDuplicates.apply( data_frame=input_df, spark_context=sc, source_column="source_column_1" ) except: print("Unexpected Error happened ") raise ``` ## 출력 출력은 `source_column_1` 열에 따라 중복이 제거된 PySpark DataFrame입니다. 결과 `df\$1output` DataFrame에는 다음 행이 포함됩니다. ``` ``` +---------------+---------------+ |source_column_1|source_column_2| +---------------+---------------+ | 105.111| 13.12| | 13.12| 13.12| | null| 13.12| +---------------+---------------+ ``` ``` `source_column_1` 열에 따라 중복이 제거되므로 `source_column_1` 값이 `13.12` 및 `null`인 행은 출력 DataFrame에 한 번만 표시됩니다. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-RemoveDuplicates-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-RemoveDuplicates-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-RemoveDuplicates-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-RemoveDuplicates-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-RemoveDuplicates-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-RemoveDuplicates-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-RemoveDuplicates-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-RemoveDuplicates-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1column) `RemoveDuplicates` 변환은 선택한 소스 열에서 중복 값이 발생하는 경우 전체 행을 삭제합니다. + `source_column` – 기존 열의 이름입니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # MonthName 클래스 `MonthName` 변환은 날짜를 나타내는 문자열에서 월의 이름이 포함된 새 열을 생성합니다. ## 예제 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) spark.conf.set("spark.sql.legacy.timeParserPolicy", "LEGACY") input_df = spark.createDataFrame( [ ("20-2018-12",), ("2018-20-12",), ("20182012",), ("12202018",), ("20122018",), ("20-12-2018",), ("12/20/2018",), ("02/02/02",), ("02 02 2009",), ("02/02/2009",), ("August/02/2009",), ("02/june/2009",), ("02/2020/june",), ("2013-02-21 06:35:45.658505",), ("August 02 2009",), ("2013/02/21",), (None,), ], ["column_1"], ) try: df_output = datetime_functions.MonthName.apply( data_frame=input_df, spark_context=sc, source_column="column_1", target_column="target_column" ) df_output.show() except: print("Unexpected Error happened ") raise ``` ## 출력 출력은 다음과 같습니다. ``` ``` +------------+------------+ | column_1|target_column| +------------+------------+ |20-2018-12 | December | |2018-20-12 | null | | 20182012| null | | 12202018| null | | 20122018| null | |20-12-2018 | December | |12/20/2018 | December | | 02/02/02 | February | |02 02 2009 | February | |02/02/2009 | February | |August/02/2009| August | |02/june/2009| null | |02/2020/june| null | |2013-02-21 06:35:45.658505| February | |August 02 2009| August | | 2013/02/21| February | | null | null | +------------+------------+ ``` ``` `MonthName` 변환은 `source\$1column`을 `"column\$11"`로, `target\$1column`을 `"target\$1column"`으로 가져옵니다. `"column\$11"` 열의 날짜/시간 문자열에서 월 이름을 추출하여 `"target\$1column"` 열에 배치하려고 합니다. 날짜/시간 문자열이 인식할 수 없는 형식이거나 구문 분석할 수 없는 경우 `"target\$1column"` 값이 `null`로 설정됩니다. 변환은 '20-12-2018', '12/20/2018', '02/02/2009', '2013-02-21 06:35:45.658505', 'August 02 2009'와 같은 다양한 날짜/시간 형식에서 월 이름을 성공적으로 추출합니다. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-MonthName-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-MonthName-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-MonthName-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-MonthName-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-MonthName-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-MonthName-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-MonthName-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-MonthName-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, target\$1column, source\$1column=None, value=None) `MonthName` 변환은 날짜를 나타내는 문자열에서 월의 이름이 포함된 새 열을 생성합니다. + `source_column` – 기존 열의 이름입니다. + `value` - 평가할 문자열. + `target_column` - 새로 생성된 열의 이름. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # IsEven 클래스 `IsEven` 변환은 소스 열 또는 값이 짝수인지 여부를 나타내는 부울 값을 새 열에서 반환합니다. 소스 열 또는 값이 소수인 경우 결과는 false입니다. ## 예제 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [(5,), (0,), (-1,), (2,), (None,)], ["source_column"], ) try: df_output = math_functions.IsEven.apply( data_frame=input_df, spark_context=sc, source_column="source_column", target_column="target_column", value=None, true_string="Even", false_string="Not even", ) df_output.show() except: print("Unexpected Error happened ") raise ``` ## 출력 출력은 다음과 같습니다. ``` ``` +------------+------------+ |source_column|target_column| +------------+------------+ | 5| Not even| | 0| Even| | -1| Not even| | 2| Even| | null| null| +------------+------------+ ``` ``` `IsEven` 변환은 `source\$1column`을 'source\$1column'으로, `target\$1column`을 'target\$1column'으로 가져옵니다. `"source\$1column"`의 값이 짝수인지 확인합니다. 값이 짝수인 경우 `"target\$1column"` 값을 `true\$1string` 'Even'으로 설정합니다. 값이 홀수인 경우 `"target\$1column"`값을 `false\$1string` 'Not even'으로 설정합니다. `"source\$1column"` 값이 `null`인 경우 `"target\$1column"` 값은 `null`로 설정됩니다. 변환은 짝수(0 및 2)를 올바르게 식별하고 "target\$1column"` 값을 'Even'으로 설정합니다. 홀수(5 및 -1)의 경우 "target\$1column"` 값을 'Not even'으로 설정합니다. `''source\$1column''` 값이 `null`인 경우 `''target\$1column''` 값은 `null`로 설정됩니다. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-IsEven-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-IsEven-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-IsEven-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-IsEven-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-IsEven-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-IsEven-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-IsEven-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-IsEven-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, target\$1column, source\$1column=None, true\$1string=DEFAULT\$1TRUE\$1STRING, false\$1string=DEFAULT\$1FALSE\$1STRING, value=None) `IsEven` 변환은 소스 열 또는 값이 짝수인지 여부를 나타내는 부울 값을 새 열에서 반환합니다. 소스 열 또는 값이 소수인 경우 결과는 false입니다. + `source_column` – 기존 열의 이름입니다. + `target_column` - 생성할 새 열의 이름. + `true_string` - 값이 짝수인지 여부를 나타내는 문자열. + `false_string` - 값이 짝수가 아닌지 여부를 나타내는 문자열. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # CryptographicHash 클래스 `CryptographicHash` 변환은 열에서 값을 해시하는 데 알고리즘을 적용합니다. ## 예제 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * secret = "${SECRET}" sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ (1, "1234560000"), (2, "1234560001"), (3, "1234560002"), (4, "1234560003"), (5, "1234560004"), (6, "1234560005"), (7, "1234560006"), (8, "1234560007"), (9, "1234560008"), (10, "1234560009"), ], ["id", "phone"], ) try: df_output = pii.CryptographicHash.apply( data_frame=input_df, spark_context=sc, source_columns=["id", "phone"], secret_id=secret, algorithm="HMAC_SHA256", output_format="BASE64", ) df_output.show() except: print("Unexpected Error happened ") raise ``` ## 출력 출력은 다음과 같습니다. ``` ``` +---+------------+-------------------+-------------------+ | id| phone | id_hashed | phone_hashed | +---+------------+-------------------+-------------------+ | 1| 1234560000 | QUI1zXTJiXmfIb... | juDBAmiRnnO3g... | | 2| 1234560001 | ZAUWiZ3dVTzCo... | vC8lgUqBVDMNQ... | | 3| 1234560002 | ZP4VvZWkqYifu... | Kl3QAkgswYpzB... | | 4| 1234560003 | 3u8vO3wQ8EQfj... | CPBzK1P8PZZkV... | | 5| 1234560004 | eWkQJk4zAOIzx... | aLf7+mHcXqbLs... | | 6| 1234560005 | xtI9fZCJZCvsa... | dy2DFgdYWmr0p... | | 7| 1234560006 | iW9hew7jnHuOf... | wwfGMCOEv6oOv... | | 8| 1234560007 | H9V1pqvgkFhfS... | g9WKhagIXy9ht... | | 9| 1234560008 | xDhEuHaxAUbU5... | b3uQLKPY+Q5vU... | | 10| 1234560009 | GRN6nFXkxk349... | VJdsKt8VbxBbt... | +---+------------+-------------------+-------------------+ ``` ``` 변환은 지정된 알고리즘과 시크릿 키를 사용하여 `id` 및 `phone` 열 값의 암호화 해시를 계산하고 Base64 형식으로 해시를 인코딩합니다. 결과 `df\$1output` DataFrame에는 원래 `input\$1df` DataFrame의 모든 열과 계산된 해시가 포함된 추가 `id\$1hashed` 및 `phone\$1hashed` 열이 있습니다. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-CryptographicHash-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-CryptographicHash-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-CryptographicHash-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-CryptographicHash-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-CryptographicHash-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-CryptographicHash-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-CryptographicHash-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-CryptographicHash-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1columns, secret\$1id, algorithm=None, secret\$1version=None, create\$1secret\$1if\$1missing=False, output\$1format=None, entity\$1type\$1filter=None) `CryptographicHash` 변환은 열에서 값을 해시하는 데 알고리즘을 적용합니다. + `source_columns` - 기존 열의 배열. + `secret_id` – Secrets Manager 시크릿 키의 ARN. 소스 열을 해시하기 위해 해시 기반 메시지 인증 코드(HMAC) 접두사 알고리즘에 사용되는 키. + `secret_version` – 선택 사항입니다. 기본적으로 최신 시크릴 버전으로 설정됩니다. + `entity_type_filter` - 엔터티 유형의 선택적 배열. 자유 텍스트 열에서 탐지된 PII만 암호화하는 데 사용할 수 있습니다. + `create_secret_if_missing` - 선택적 부울. true인 경우 호출자를 대신하여 시크릿을 생성하려고 시도합니다. + `algorithm` – 데이터를 해시하는 데 사용되는 알고리즘. 유효한 열거형 값: MD5, SHA1, SHA256, SHA512, HMAC\$1MD5, HMAC\$1SHA1, HMAC\$1SHA256, HMAC\$1SHA512. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # Decrypt 클래스 `Decrypt` 변환은 AWS Glue 내부에서 복호화를 수행합니다. AWS 암호화 SDK를 사용하여 AWS Glue 외부에서 데이터를 복호화할 수도 있습니다. 제공된 KMS 키 ARN이 열을 암호화하는 데 사용된 것과 일치하지 않으면 복호화 작업이 실패합니다. ## 예제 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * kms = "${KMS}" sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ (1, "1234560000"), (2, "1234560001"), (3, "1234560002"), (4, "1234560003"), (5, "1234560004"), (6, "1234560005"), (7, "1234560006"), (8, "1234560007"), (9, "1234560008"), (10, "1234560009"), ], ["id", "phone"], ) try: df_encrypt = pii.Encrypt.apply( data_frame=input_df, spark_context=sc, source_columns=["phone"], kms_key_arn=kms ) df_decrypt = pii.Decrypt.apply( data_frame=df_encrypt, spark_context=sc, source_columns=["phone"], kms_key_arn=kms ) df_decrypt.show() except: print("Unexpected Error happened ") raise ``` ## 출력 출력은 원본 `id` 열과 복호화된 `phone` 열이 있는 PySpark DataFrame입니다. ``` ``` +---+------------+ | id| phone| +---+------------+ | 1| 1234560000| | 2| 1234560001| | 3| 1234560002| | 4| 1234560003| | 5| 1234560004| | 6| 1234560005| | 7| 1234560006| | 8| 1234560007| | 9| 1234560008| | 10| 1234560009| +---+------------+ ``` ``` `Encrypt` 변환은 `source\$1columns`를 `["phone"]`으로, `kms\$1key\$1arn`을 `\$1\$1KMS\$1` 환경 변수의 값으로 가져옵니다. 변환은 지정된 KMS 키를 사용하여 `phone` 열의 값을 암호화합니다. 그런 다음, 암호화된 DataFrame `df\$1encrypt`가 `awsglue.pii` 모듈에서 `Decrypt` 변환으로 전달됩니다. 이때 `source\$1columns`를 `["phone"]`으로, `kms\$1key\$1arn`을 `\$1\$1KMS\$1` 환경 변수의 값으로 가져옵니다. 변환은 동일한 KMS 키를 사용하여 `phone` 열의 암호화된 값을 복호화합니다. 결과 `df\$1decrypt` DataFrame에는 원본 `id` 열과 복호화된 `phone` 열이 포함되어 있습니다. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-Decrypt-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-Decrypt-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-Decrypt-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-Decrypt-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-Decrypt-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-Decrypt-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-Decrypt-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-Decrypt-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1columns, kms\$1key\$1arn) `Decrypt` 변환은 AWS Glue 내부에서 복호화를 수행합니다. AWS 암호화 SDK를 사용하여 AWS Glue 외부에서 데이터를 복호화할 수도 있습니다. 제공된 KMS 키 ARN이 열을 암호화하는 데 사용된 것과 일치하지 않으면 복호화 작업이 실패합니다. + `source_columns` - 기존 열의 배열. + `kms_key_arn` - 소스 열을 복호화하는 데 사용할 AWS Key Management Service 키의 키 ARN. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # Encrypt 클래스 `Encrypt` 변환은 AWS Key Management Service 키를 사용하여 소스 열을 암호화합니다. `Encrypt` 변환은 셀당 최대 128MiB를 암호화할 수 있습니다. 복호화할 때 형식을 보존하려고 시도합니다. 데이터 유형을 보존하려면 데이터 유형 메타데이터를 1KB 미만으로 직렬화해야 합니다. 그렇지 않으면 `preserve_data_type` 파라미터를 false로 설정해야 합니다. 데이터 유형 메타데이터는 암호화 컨텍스트에서 일반 텍스트로 저장됩니다. ## 예제 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * kms = "${KMS}" sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ (1, "1234560000"), (2, "1234560001"), (3, "1234560002"), (4, "1234560003"), (5, "1234560004"), (6, "1234560005"), (7, "1234560006"), (8, "1234560007"), (9, "1234560008"), (10, "1234560009"), ], ["id", "phone"], ) try: df_encrypt = pii.Encrypt.apply( data_frame=input_df, spark_context=sc, source_columns=["phone"], kms_key_arn=kms ) except: print("Unexpected Error happened ") raise ``` ## 출력 출력은 원래 `id` 열과 `phone` 열의 암호화된 값이 포함된 추가 열이 있는 PySpark DataFrame입니다. ``` ``` +---+------------+-------------------------+ | id| phone | phone_encrypted | +---+------------+-------------------------+ | 1| 1234560000| EncryptedData1234...abc | | 2| 1234560001| EncryptedData5678...def | | 3| 1234560002| EncryptedData9012...ghi | | 4| 1234560003| EncryptedData3456...jkl | | 5| 1234560004| EncryptedData7890...mno | | 6| 1234560005| EncryptedData1234...pqr | | 7| 1234560006| EncryptedData5678...stu | | 8| 1234560007| EncryptedData9012...vwx | | 9| 1234560008| EncryptedData3456...yz0 | | 10| 1234560009| EncryptedData7890...123 | +---+------------+-------------------------+ ``` ``` `Encrypt` 변환은 `source\$1columns`를 `["phone"]`으로, `kms\$1key\$1arn`을 `\$1\$1KMS\$1` 환경 변수의 값으로 가져옵니다. 변환은 지정된 KMS 키를 사용하여 `phone` 열의 값을 암호화합니다. 결과 `df\$1encrypt` DataFrame에는 원래 `id` 열, 원래 `phone` 열, `phone\$1encrypted` 열의 암호화된 값이 포함된 `phone\$1encrypted`라는 추가 열이 포함되어 있습니다. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-Encrypt-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-Encrypt-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-Encrypt-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-Encrypt-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-Encrypt-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-Encrypt-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-Encrypt-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-Encrypt-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, source\$1columns, kms\$1key\$1arn, entity\$1type\$1filter=None, preserve\$1data\$1type=None) `Encrypt` 변환은 AWS Key Management Service 키를 사용하여 소스 열을 암호화합니다. + `source_columns` - 기존 열의 배열. + `kms_key_arn` - 소스 열을 암호화하는 데 사용할 AWS Key Management Service 키의 키 ARN. + `entity_type_filter` - 엔터티 유형의 선택적 배열. 자유 텍스트 열에서 탐지된 PII만 암호화하는 데 사용할 수 있습니다. + `preserve_data_type` - 선택적 부울. 기본값은 true입니다. false인 경우 데이터 유형이 저장되지 않습니다. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # IntToIp 클래스 `IntToIp` 변환은 소스 열의 정수 값 또는 기타 값을 대상 열의 대응하는 IPv4 값으로 변환한 다음, 새 열에서 결과를 반환합니다. ## 예제 ``` from pyspark.context import SparkContext from pyspark.sql import SparkSession from awsgluedi.transforms import * sc = SparkContext() spark = SparkSession(sc) input_df = spark.createDataFrame( [ (3221225473,), (0,), (1,), (100,), (168430090,), (4294967295,), (4294967294,), (4294967296,), (-1,), (None,), ], ["source_column_int"], ) try: df_output = web_functions.IntToIp.apply( data_frame=input_df, spark_context=sc, source_column="source_column_int", target_column="target_column", value=None ) df_output.show() except: print("Unexpected Error happened ") raise ``` ## 출력 출력은 다음과 같습니다. ``` ``` +---------------+---------------+ |source_column_int|target_column| +---------------+---------------+ | 3221225473| 192.0.0.1 | | 0| 0.0.0.0 | | 1| 0.0.0.1 | | 100| 0.0.0.100| | 168430090 | 10.0.0.10 | | 4294967295| 255.255.255.255| | 4294967294| 255.255.255.254| | 4294967296| null | | -1| null | | null| null | +---------------+---------------+ ``` ``` `IntToIp.apply` 변환은 `source\$1column`을 `"source\$1column\$1int"`로, `target\$1column`을 `"target\$1column"`으로 변환하고 `source\$1column\$1int` 열의 정수 값을 대응하는 IPv4 주소 표현으로 변환한 다음, `target\$1column` 열에 결과를 저장합니다. IPv4 주소 범위(0\$14294967295) 내 유효한 정수 값의 경우 변환은 해당 값을 IPv4 주소 표현(예: 192.0.0.1, 0.0.0.0, 10.0.0.10, 255.255.255.255)으로 변환합니다. 유효한 범위를 벗어난 정수 값(예: 4294967296, -1)의 경우 `target\$1column` 값이 `null`로 설정됩니다. `source\$1column\$1int` 열에 `null` 값이 있는 경우 `target\$1column` 값도 `null`로 설정됩니다. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-IntToIp-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-IntToIp-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-IntToIp-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-IntToIp-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-IntToIp-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-IntToIp-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-IntToIp-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-IntToIp-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, target\$1column, source\$1column=None, value=None) `IntToIp` 변환은 소스 열의 정수 값 또는 기타 값을 대상 열의 대응하는 IPv4 값으로 변환한 다음, 새 열에서 결과를 반환합니다. + `sourceColumn` – 기존 열의 이름입니다. + `value` - 평가할 문자열. + `targetColumn` - 생성할 새 열의 이름. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. # IpToInt 클래스 `IpToInt` 변환은 소스 열의 Internet Protocol 버전 4(IPv4) 값 또는 기타 값을 대상 열의 대응하는 정수 값으로 변환한 다음, 새 열에서 결과를 반환합니다. ## 예제 AWS Glue 4.0 이상의 경우 `key: --enable-glue-di-transforms, value: true`를 사용하여 작업 인수를 생성하거나 업데이트하세요. ``` from pyspark.context import SparkContext from awsgluedi.transforms import * sc = SparkContext() input_df = spark.createDataFrame( [ ("192.0.0.1",), ("10.10.10.10",), ("1.2.3.4",), ("1.2.3.6",), ("http://12.13.14.15",), ("https://16.17.18.19",), ("1.2.3.4",), (None,), ("abc",), ("abc.abc.abc.abc",), ("321.123.123.123",), ("244.4.4.4",), ("255.255.255.255",), ], ["source_column_ip"], ) df_output = web_functions.IpToInt.apply( data_frame=input_df, spark_context=sc, source_column="source_column_ip", target_column="target_column", value=None ) df_output.show() ``` ## 출력 출력은 다음과 같습니다. ``` ``` +----------------+---------------+ |source_column_ip| target_column| +----------------+---------------+ | 192.0.0.1| 3221225473| | 10.10.10.10| 168427722| | 1.2.3.4| 16909060| | 1.2.3.6| 16909062| |http://12.13.14.15| null| |https://16.17.18.19| null| | 1.2.3.4| 16909060| | null| null| | abc| null| |abc.abc.abc.abc| null| | 321.123.123.123| null| | 244.4.4.4| 4102444804| | 255.255.255.255| 4294967295| +----------------+---------------+ ``` ``` `IpToInt` 변환은 `source\$1column`을 `"source\$1column\$1ip"`로, `target\$1column`을 `"target\$1column"`으로 변환하고 `source\$1column\$1ip` 열의 유효한 IPv4 주소 문자열을 대응하는 32비트 정수 표현으로 변환한 다음, `target\$1column` 열에 결과를 저장합니다. 유효한 IPv4 주소 문자열(예: '192.0.0.1', '10.10.10.10', '1.2.3.4')의 경우 변환은 해당 값을 정수 표현(예: 3221225473, 168427722, 16909060)으로 변환합니다. 유효한 IPv4 주소가 아닌 문자열(예: URL , 'abc'와 같은 IP 외 문자열, 'abc.abc.abc.abc'와 같은 유효하지 않은 IP 형식)의 경우 `target\$1column` 값은 `null`로 설정됩니다. `source\$1column\$1ip` 열에 `null` 값이 있는 경우 `target\$1column` 값도 `null`로 설정됩니다. ## 메서드 + [\$1\$1call\$1\$1](#aws-glue-api-pyspark-transforms-IpToInt-__call__) + [apply](#aws-glue-api-crawler-pyspark-transforms-IpToInt-apply) + [이름](#aws-glue-api-crawler-pyspark-transforms-IpToInt-name) + [describeArgs](#aws-glue-api-crawler-pyspark-transforms-IpToInt-describeArgs) + [describeReturn](#aws-glue-api-crawler-pyspark-transforms-IpToInt-describeReturn) + [describeTransform](#aws-glue-api-crawler-pyspark-transforms-IpToInt-describeTransform) + [describeErrors](#aws-glue-api-crawler-pyspark-transforms-IpToInt-describeErrors) + [describe](#aws-glue-api-crawler-pyspark-transforms-IpToInt-describe) ## \$1\$1call\$1\$1(spark\$1context, data\$1frame, target\$1column, source\$1column=None, value=None) `IpToInt` 변환은 소스 열의 Internet Protocol 버전 4(IPv4) 값 또는 기타 값을 대상 열의 대응하는 정수 값으로 변환한 다음, 새 열에서 결과를 반환합니다. + `sourceColumn` – 기존 열의 이름입니다. + `value` - 평가할 문자열. + `targetColumn` - 생성할 새 열의 이름. ## apply(cls, \$1args, \$1\$1kwargs) `GlueTransform` [apply](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-apply)에서 상속됩니다. ## name(cls) `GlueTransform` [name](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-name)에서 상속됩니다. ## describeArgs(cls) `GlueTransform` [describeArgs](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeArgs)에서 상속됩니다. ## describeReturn(cls) `GlueTransform` [describeReturn](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeReturn)에서 상속됩니다. ## describeTransform(cls) `GlueTransform` [describeTransform](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeTransform)에서 상속됩니다. ## describeErrors(cls) `GlueTransform` [describeErrors](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describeErrors)에서 상속됩니다. ## describe(cls) `GlueTransform` [describe](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md#aws-glue-api-crawler-pyspark-transforms-GlueTransform-describe)에서 상속됩니다. ## 데이터 통합 변환 AWS Glue 4.0 이상의 경우 `key: --enable-glue-di-transforms, value: true`를 사용하여 작업 인수를 생성하거나 업데이트하세요. 작업 스크립트 예제: ``` from pyspark.context import SparkContext from awsgluedi.transforms import * sc = SparkContext() input_df = spark.createDataFrame( [(5,), (0,), (-1,), (2,), (None,)], ["source_column"], ) try: df_output = math_functions.IsEven.apply( data_frame=input_df, spark_context=sc, source_column="source_column", target_column="target_column", value=None, true_string="Even", false_string="Not even", ) df_output.show() except: print("Unexpected Error happened ") raise ``` 노트북을 사용한 세션 예제 ``` %idle_timeout 2880 %glue_version 4.0 %worker_type G.1X %number_of_workers 5 %region eu-west-1 ``` ``` %%configure { "--enable-glue-di-transforms": "true" } ``` ``` from pyspark.context import SparkContext from awsgluedi.transforms import * sc = SparkContext() input_df = spark.createDataFrame( [(5,), (0,), (-1,), (2,), (None,)], ["source_column"], ) try: df_output = math_functions.IsEven.apply( data_frame=input_df, spark_context=sc, source_column="source_column", target_column="target_column", value=None, true_string="Even", false_string="Not even", ) df_output.show() except: print("Unexpected Error happened ") raise ``` AWS CLI를 사용한 세션 예제 ``` aws glue create-session --default-arguments "--enable-glue-di-transforms=true" ``` DI 변환: + [FlagDuplicatesInColumn 클래스](aws-glue-api-pyspark-transforms-FlagDuplicatesInColumn.md) + [FormatPhoneNumber 클래스](aws-glue-api-pyspark-transforms-FormatPhoneNumber.md) + [FormatCase 클래스](aws-glue-api-pyspark-transforms-FormatCase.md) + [FillWithMode 클래스](aws-glue-api-pyspark-transforms-FillWithMode.md) + [FlagDuplicateRows 클래스](aws-glue-api-pyspark-transforms-FlagDuplicateRows.md) + [RemoveDuplicates 클래스](aws-glue-api-pyspark-transforms-RemoveDuplicates.md) + [MonthName 클래스](aws-glue-api-pyspark-transforms-MonthName.md) + [IsEven 클래스](aws-glue-api-pyspark-transforms-IsEven.md) + [CryptographicHash 클래스](aws-glue-api-pyspark-transforms-CryptographicHash.md) + [Decrypt 클래스](aws-glue-api-pyspark-transforms-Decrypt.md) + [Encrypt 클래스](aws-glue-api-pyspark-transforms-Encrypt.md) + [IntToIp 클래스](aws-glue-api-pyspark-transforms-IntToIp.md) + [IpToInt 클래스](aws-glue-api-pyspark-transforms-IpToInt.md) ### Maven: Spark 애플리케이션과 플러그인 번들링 Spark 애플리케이션을 로컬에서 개발하는 동안 Maven `pom.xml`에 플러그인 종속성을 추가하여 Spark 애플리케이션 및 Spark 배포(버전 3.3)와 변환 종속성을 번들링할 수 있습니다. ``` ... aws-glue-etl-artifacts https://aws-glue-etl-artifacts.s3.amazonaws.com/release/ ... com.amazonaws AWSGlueTransforms 4.0.0 ``` 또는 다음과 같이 AWS Glue Maven 아티팩트에서 바이너리를 직접 다운로드하여 Spark 애플리케이션에 포함할 수도 있습니다. ``` #!/bin/bash sudo wget -v https://aws-glue-etl-artifacts.s3.amazonaws.com/release/com/amazonaws/AWSGlueTransforms/4.0.0/AWSGlueTransforms-4.0.0.jar -P /usr/lib/spark/jars/ ```