게임 데이터 분석을 위한 Data Lake 구축과 Machine Learning 을 활용한 분석 Hands on Lab (안효빈 솔루션즈 아키텍트, AWS) :: Gaming on AWS 2018

게임 데이터 분석을 위한 Data Lake 구축과
Machine Learning 을 활용한 분석
Hyobin An

Gaming on AWS
게임 데이터 분석을 위한 Data Lake 구축과 Machine Learning 을 활용한 분석
Copyright 2018, Amazon Web Services, All Rights Reserved Page 2
This work may not be reproduced or redistributed, in whole or in part, without prior written
permission from Amazon Web Services, Inc. Commercial copying, lending, or selling is prohibited.
Correction or feedback for this lab guide, please send email to : anhyobin@amazon.com
All trademarks are the property of their owners.
Special thanks to SAs Pil Ho Kim, Junghee Kang, and Sungsoo Khim who gave me lots of advice on making this lab.

Gaming on AWS
Table of Contents
실습 소개............................................................................................................................................................. 4
실습 아키텍처...................................................................................................................................................... 4
실습 흐름............................................................................................................................................................. 4
데이터 설명.......................................................................................................................................................... 5
리전 선택............................................................................................................................................................. 6
EC2 키 페어 생성................................................................................................................................................. 6
S3 버킷 생성........................................................................................................................................................ 6
CLOUDFORMATION 스택 생성 및 확인 ............................................................................................................... 7
KINESIS DATA FIREHOSE 생성......................................................................................................................... 10
DYNAMODB 설정.............................................................................................................................................. 12
EC2 인스턴스 설정 및 KINESIS AGENT 를 통한 데이터 수집.............................................................................. 14
GLUE DATA CATALOG 생성.............................................................................................................................. 20
GLUE ETL JOB 실행.......................................................................................................................................... 24
ATHENA 를 활용한 분석 작업............................................................................................................................. 28
SAGEMAKER 를 통한 MACHINE LEARNING 모델 학습 및 이상 행동 탐지 ......................................................... 31
결론................................................................................................................................................................... 41
실습 리소스 삭제................................................................................................................................................ 42

Gaming on AWS
실습 소개
이번 실습에서는 AWS 상에서 임의로 생성한 게임 데이터를 분석해봅니다. 이를 통해 AWS 상에서
데이터를 실시간으로 수집하고, 가공한 뒤 실제로 분석을 간편하게 수행해볼 수 있습니다. 더 나아가
수집한 데이터를 학습하고 이를 이용해 이상 행동 패턴을 판단해보게 됩니다.
실습 아키텍처
실습 흐름
DynamoDB 의 User Profile 데이터와 EC2 의 Play Log 데이터를 각각의 Kinesis Data Firehose 를
이용하여 실시간으로 S3 에 수집합니다. 이후 Glue Crawler 를 활용하여 Data Catalog 를 만들고 실제
분석을 위한 가공은 Glue Job 을 활용한 ETL 작업을 하게 됩니다.
이렇게 가공한 데이터는 이후 Athena 를 활용하여 쿼리를 통한 분석 해보고, 또한 SageMaker 를
이용하여 Machine Learning 을 통해 보다 정교한 분석 및 예측을 수행합니다.

Gaming on AWS
데이터 설명
실습에서 크게 두 가지 종류의 데이터를 수집합니다. 본격적인 실습에 앞서 우선 오늘 분석에 사용하는
데이터에 관해 살펴보는 것이 필요합니다.
1. User Profile 은 DynamoDB 에 저장되어 있으며 특정 유저의 레벨과 직업에 대한 정보를
포함합니다.
pidx uclass ulevel utimestamp
8672 healer 9 2018-10-12 05:53:59.318075
13233 warrior 11 2018-10-12 05:48:44.748598
2. Play Log 는 유저의 현재 좌표, 다음 좌표, 액션 등에 관한 정보를 포함합니다.
posnewx posnewy posnewz pidx createdate
542 824 0 8672 2018-10-12 05:53:59.318075
668 245 0 13233 2018-10-12 05:48:44.748598
posoldx posoldy posoldz action idx
541 828 0 0 30725885
666 240 0 0 30721726
여기에는 전체 20043 명의 유저의 약 4 천만건의 플레이 기록을 포함하고 있습니다. 유저들이 실제
게임을 플레이한 가상의 공간은 다음의 형태입니다. 빨간색 구역은 정상 유저는 갈 수 없는
영역입니다.
0 2000
1000
1000
400

Gaming on AWS
리전 선택
실습은 us-east-1 (N.Virginia) 리전을 사용합니다. 실습을 시작하기에 앞서 해당 리전을 선택합니다.
EC2 키 페어 생성
이후 생성할 EC2 에 SSH 접속을 하기 위해서는 키가 필요합니다. 이미 us-east-1 리전에 사용 중인
키가 있다면 이번 스텝을 건너 뜁니다.
1. AWS Management Console 에서 EC2 서비스로 이동합니다.
2. 좌측 메뉴에서 [Key Pairs] 메뉴를 클릭한 뒤 [Create Key Pair] 를 클릭합니다.
3. [Key pair name] 을 입력한 뒤 [Create] 버튼을 클릭하여 완료합니다.
4. .pem 파일 다운로드가 잘 되었는지 확인합니다.
S3 버킷 생성
이후 실습을 진행하며 필요한 모든 데이터를 저장할 S3 버킷이 필요합니다. 실습에서는 원본 데이터를
저장할 raw 버킷과 가공한 뒤 실제 분석에 사용할 데이터를 저장할 analytic 버킷을 구분하여
생성하겠습니다.
1. AWS Management Console 에서 S3 서비스로 이동합니다.
2. [+ Create bucket] 버튼을 클릭하여 버킷을 생성합니다.
3. [Bucket name] 에 gaming-raw 와 같이 고유한 이름의 버킷을 입력하고 [Create] 버튼을
클릭합니다.
4. 두 번째 버킷은 gaming-analytics 와 같은 이름으로 생성해줍니다. 구분이 가능하도록 버킷
이름을 지정해줍니다.

Gaming on AWS
CloudFormation 스택 생성 및 확인
실습에 사용되는 EC2, DynamoDB, Lambda 및 IAM role 등을 CloudFormation 스택을 통해
생성합니다. 단순히 리소스를 프로비저닝 하는 것 외에도 CloudFormation 스택 생성 후 Lambda 함수
Invoke 를 통해 DynamoDB 를 초기화 하는 로직을 수행하게 됩니다.
1. AWS Management Console 에서 CloudFormation 서비스로 이동합니다.
2. [Create new stack] 버튼을 클릭합니다. [Specify an Amazon S3 template URL] 옵션을 선택하고
다음 URL 을 입력합니다. https://s3.amazonaws.com/anhyobin-gaming/cloudformation.yaml
[Next] 를 선택합니다.
3. [Stack name] 에 적절한 이름과 [KeyName] 부분에 앞서 생성한 EC2 키 페어를 선택합니다.
[Next] 를 선택하여 진행합니다.
4. 옵션 화면에서도 [Next] 를 선택한 뒤 검토 화면에서 [I acknowledge that AWS CloudFormation
might create IAM resources with custom names.] 옵션을 체크한 뒤 [Create] 를 클릭하여 스택
생성을 시작합니다.
5. 스택 생성에는 약 10 분이 소요됩니다.

Gaming on AWS
6. 스택이 생성되는 동안 생성하는 CloudFormation 스택에 관한 아래의 설명을 읽어보시기 바랍니다.
이 실습에서 사용하는 CloudFormation 템플릿은 생성 중간에 템플릿 내에서 생성한 DDBInitialize
라는 Lambda 함수를 자동으로 Invoke 합니다. 이는 CloudFormation 에서 제공하는 사용자 지정
리소스를 통해 가능합니다.
https://docs.aws.amazon.com/ko_kr/AWSCloudFormation/latest/UserGuide/template-custom-
resources.html
DDBInitLambdaInvoke:
Type: Custom::DDBInitLambdaInvoke
Properties:
ServiceToken: !GetAtt DDBInitLambda.Arn
CloudFormation 은 기본적으로 템플릿에 정의된 리소스를 병렬로 동시에 생성하지만 중간에
DependsOn 속성을 이용해 로직을 제어하는 것도 가능합니다.
DDBInitLambda:
Type: AWS::Lambda::Function
DependsOn: DDBTable
유의할 점은 사용자 지정 리소스 생성 완료(Lambda 함수 실행) 응답을 CloudFormation 보내주어야
합니다. 따라서 이번 실습에서 사용하는 DDBInitialize 함수는 다음 내용을 포함합니다.
def send_response(event, context, response_status, response_data):
response_body = json.dumps({
"Status": response_status,
"Reason": "See the details in CloudWatch Log Stream: " + context.log_stream_name,
"PhysicalResourceId": context.log_stream_name,
"StackId": event['StackId'],
"RequestId": event['RequestId'],
"LogicalResourceId": event['LogicalResourceId'],
"Data": response_data
})
headers = {
"Content-Type": "",
"Content-Length": str(len(response_body))
}
response = requests.put(event["ResponseURL"], headers = headers, data = response_body)
사용자 지정 리소스는 CloudFormation 의 Create, Update, Delete 상황 모두에서 수행되기 때문에 이
부분 처리를 원한다면 마찬가지로 Lambda 함수에 다음과 같은 로직을 작성해주어야 합니다.
if event['RequestType'] == 'Delete':
print 'Send response to CFN.'
send_response(event, context, "SUCCESS", {"Message": "CFN deleted!"})

Gaming on AWS
7. 다음과 같이 [Resources] 탭에서 아래의 리소스 생성이 완료된 것을 확인합니다. [Outputs] 탭에서
생성된 EC2 인스턴스의 접속 정보를 확인할 수 있습니다.
8. DynamoDB 는 스택이 생성한 Lambda 함수가 정상 수행 되어 데이터가 입력되었는지
확인해보겠습니다. AWS Management Console 에서 DynamoDB 서비스로 이동합니다.
9. 좌측의 [Tables] 메뉴를 선택하면 UserProfile 테이블이 생성된 것을 확인할 수 있습니다. 이를
선택한 뒤 우측 메뉴에서 [Items] 를 클릭하여 테이블 내의 데이터가 정상적으로 쓰여진 것을
확인합니다.

Gaming on AWS
Kinesis Data Firehose 생성
DynamoDB 와 EC2 인스턴스에서 생성되는 데이터는 Kinesis Data Firehose 를 통해서 수집합니다.
Kinesis Data Firehose 는 스트림 데이터를 지정한 타겟으로 전송하기 위한 완전 관리형 서비스입니다.
이번 단계에서는 아키텍처 상에서 아래 표시된 부분을 구성합니다.
1. AWS Management Console 에서 Kinesis 서비스로 이동합니다.
2. [Get started] 를 선택한 뒤 Deliver streaming data with Kinesis Firehose delivery streams 의
[Create delivery stream] 버튼을 선택합니다.
3. [Delivery stream name] 에 stream-playlog 를 입력합니다. Source 는 [Direct PUT or other
sources] 를 선택합니다. [Next] 를 클릭합니다.
4. Kinesis Data Firehose 는 Lambda 를 이용한 데이터 전처리를 지원합니다. 이번 실습에서 이
기능을 이용하지는 않습니다. [Next] 를 클릭하여 진행합니다.
5. Destination 은 [Amazon S3] 를 선택하고 아래 [S3 bucket] 은 앞서 생성한 버킷 중 raw 데이터를
저장할 버킷을 선택합니다. [Prefix] 에는 데이터 구분을 위해 playlog/ 를 입력합니다. 아래와 같이
설정하였다면 [Next] 를 클릭합니다.
6. [Buffer size] 는 1MB, [Buffer interval] 은 60seconds 를 입력합니다.

Gaming on AWS
7. 아래 IAM role 의 [Create new or choose] 버튼을 클릭합니다. IAM 페이지가 열리고 자동으로
IAM 역할이 구성됩니다. [Allow] 버튼을 클릭합니다. Kinesis Data Firehose 생성 페이지로
돌아오면 [Next] 를 선택하고 설정한 내용(Destination, S3 buffer conditions 등) 을 확인한 뒤
[Create delivery stream] 을 클릭하여 Kinesis Data Firehose 생성을 완료합니다.
8. 잠시 후 Status 가 Active 로 변경되면 Kinesis Data Firehose 생성이 완료된 것입니다.
9. 이번 실습에는 총 두개의 Kinesis Data Firehose 가 필요합니다. 위에서 생성한 것과 동일한
방법으로 두번 째 Kinesis Data Firehose 를 생성합니다.
10. [Delivery stream name] 은 stream-userprofile 로 설정하여 줍니다.
11. Destination 은 [Amazon S3] 를 선택하고 아래 [S3 bucket] 은 앞서 생성한 버킷 중 raw 데이터를
저장할 버킷을 선택합니다. [Prefix] 에는 데이터 구분을 위해 userlog/ 로 설정합니다.
12. 앞서와 동일하게 [Buffer size] 는 1MB, [Buffer interval] 은 60seconds 로 설정한 뒤 생성을
완료합니다.
13. 다음과 같이 두개의 Kinesis Data Firehose 를 생성했다면 다음 단계로 진행합니다.

Gaming on AWS
DynamoDB 설정
DynamoDB 에는 User Profile 데이터가 있습니다. 그리고 이번 단계를 통해 각각의 유저별로 레벨업
히스토리를 S3 에 저장하도록 구성해봅니다. 여기에는 앞서 생성한 Kinesis 와 이미 생성되어 있는
Lambda 함수를 활용하게 됩니다. 아키텍처 상에서는 다음 부분에 해당합니다.
1. AWS Management Console 에서 DynamoDB 서비스로 이동합니다.
2. 좌측의 [Tables] 메뉴를 선택하고 CloudFormation 을 통해 생성된 UserProfile 테이블을
선택합니다.
3. [Overview] 탭에 [Manage Stream] 버튼을 클릭합니다. 이를 통해 DynamoDB 테이블에 저장된
항목이 변경되는 내용을 캡처할 수 있습니다.
4. [New and old images] 옵션을 선택한 뒤 [Enable] 버튼을 클릭합니다. 다음과 같이 Stream
기능이 활성화되는 것을 확인할 수 있습니다.
5. AWS Management Console 에서 Lambda 서비스로 이동합니다. 생성된 Lambda 함수에
DynamoDB Stream 을 이벤트 트리거로 추가하여 변경사항이 발생할 경우 해당 데이터를 Kinesis
로 수집하게 됩니다.
6. 미리 생성된 StreamUserLog 함수를 선택한 뒤 좌측에서 [DynamoDB] 를 선택합니다.

Gaming on AWS
7. [DynamoDB table] 은 UserProfile, [Batch size] 는 100, [Starting position] 에는 [Trim horizon]
을 선택합니다. 아래 [Enable trigger] 옵션이 체크된 것을 확인한 뒤 아래 [Add] 버튼을
클릭합니다.
8. 우측 상단의 [Save] 버튼을 클릭하여 변경사항을 저장합니다. 아래 스크린 캡처와 같이 적용된
것을 확인합니다.
Lambda 함수를 간단히 살펴보면 아래와 같이 캡처한 변경 사항을 앞서 생성한 Kinesis Data Firehose
인 stream-userprofile 로 수집하는 것을 알 수 있습니다. Lambda 에서 직접 S3 로 데이터를 저장할
수도 있지만 중간에 Kinesis 가 버퍼 역할을 하게 되어 과도한 S3 PUT 요청을 방지합니다.
response = client.put_record(
DeliveryStreamName = 'stream-userprofile',
Record = {
'Data' : data
}
)

Gaming on AWS
EC2 인스턴스 설정 및 Kinesis Agent 를 통한 데이터 수집
실습에서는 EC2 인스턴스를 이용해 PlayLog 를 발생시키고 DynamoDB 에 저장된 UserProfile 정보를
지속적으로 업데이트(유저 레벨 업 상황) 합니다.
발생하는 PlayLog 는 EC2 에 설치된 Kinesis Agent 를 통해서 앞서 생성한 Kinesis Data Firehose 로
수집되게 됩니다. 업데이트 되는 UserProfile 의 경우는 이전 단계에서 설정한 DyanamoDB Streams
등을 통해 수집이 이루어 집니다. 결과적으로 발생하는 모든 데이터는 Kinesis Data Firehose 에 설정한
Target 인 S3 버킷으로 수집됩니다. 이와 같이 원본 데이터를 S3 에 수집하여 이를 Data Lake 로
구성하고 이후 분석작업에 쉽게 활용하게 됩니다. 이번 단계는 아키텍처 상에서 다음 부분에
해당합니다.
1. AWS Management Console 에서 EC2 서비스로 이동합니다.
2. 좌측의 [Instances] 메뉴를 선택하고 CloudFormation 을 통해 생성된 PlayLogGenerator
인스턴스를 선택합니다.
3. 해당 인스턴스의 [Description] 탭을 살펴보면 실습에 필요한 권한이 EC2GeneratorRole 이라는
IAM role 과 연결되어 있습니다. 때문에 인스턴스에 Access Key, Secret Key 등을 입력하거나
실행하는 코드에서 이를 API 등으로 호출할 필요가 없습니다. 이는 EC2 인스턴스에서 실행되는
애플리케이션에 권한을 부여하는 모범 사례입니다.

Gaming on AWS
4. 해당 인스턴스의 Public IP 를 확인한 뒤 SSH 클라이언트 (ex. Mac OS – Terminal, Windows OS –
PuTTY) 를 이용하여 원격 접속 합니다.
EC2 인스턴스에 원격 접속하는 방법은 상단의 [Connect] 버튼을 클릭하면 설명이 나와있습니다.
https://docs.aws.amazon.com/ko_kr/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html
5. 우선 다음과 같이 실습에 필요한 파일이 존재하는지 확인합니다.
[ec2-user@ip-172-31-84-120 ~]$ ls
playlog_gen.py StreamLog UserList
[ec2-user@ip-172-31-84-120 ~]$ ls -l /tmp/archived_playlog/2018/10/09/01/
total 6493876
-rw-rw-r-- 1 ec2-user ec2-user 169079641 Oct 17 08:32 run-1538992116187-
part-r-00000
-rw-rw-r-- 1 ec2-user ec2-user 169128956 Oct 17 08:32 run-1538992116187-
part-r-00001
...
...
...
6. 4000 만건의 데이터를 오늘 실습에서 모두 발생시키기에는 무리가 있기 때문에 다음의 AWS CLI
명령어를 이용해 /tmp/archived_playlog/ 경로의 아카이빙 되어 있는 로그데이터를 앞서 생성한
S3 버킷에 업로드 합니다. 아래의 명렁어를 실행합니다. 명령어 상의 s3://gaming-raw/playlog
에서 gaming-raw 부분은 raw 데이터를 수집하기 위해 생성한 버킷명을 입력합니다.
[ec2-user@ip-172-31-84-120 ~]$ aws s3 cp /tmp/archived_playlog/ s3://gaming-
raw/playlog/ --recursive
upload: ../../tmp/archived_playlog/2018/10/09/01/run-1538992116187-part-r-
00000 to s3://gaming-raw/playlog/2018/10/09/01/run-1538992116187-part-r-
00000
...
...
...
7. AWS Management Console 에서 S3 서비스로 이동합니다.
8. raw 데이터를 수집한 버킷으로 이동하면 다음과 같이 40 개의 데이터가 복사된 것을 확인할 수
있습니다. 버킷 아래에 YYYY/MM/DD/HH 로 구분한 것은 데이터 파티셔닝을 위한 것입니다. 이후
Kinesis 로 수집하는 데이터와 동일한 파티션을 이용하기 위해 꼭 다음과 같은 구조로
저장되었는지 확인해야 합니다.

Gaming on AWS
9. 다시 EC2 인스턴스로 돌아와서 다음 명령어를 통해 Kinesis Agent 설정을 확인합니다.
[ec2-user@ip-172-31-84-120 ~]$ sudo service aws-kinesis-agent status
aws-kinesis-agent is stopped
[ec2-user@ip-172-31-84-120 ~]$ cat /etc/aws-kinesis/agent.json
{
"cloudwatch.emitMetrics": true,
"firehose.endpoint": "firehose.us-east-1.amazonaws.com",
"flows": [
{
"filePattern": "/tmp/playlog/*.json",
"deliveryStream": "stream-playlog"
}
]
}
agent.json 을 보게 되면 "filePattern": "/tmp/playlog/*.json" 에 해당하는 모든 로그에 대해서 앞서
생성한 Kinesis Data Firehose 인 "deliveryStream": "stream-playlog" 로 수집하게 설정되어 있는
것을 확인할 수 있습니다.
10. 다음의 명령어로 Kinesis Agent 를 실행합니다.
[ec2-user@ip-172-31-84-120 ~]$ sudo service aws-kinesis-agent start
aws-kinesis-agent startup [ OK ]
11. 다음 명령어를 이용하여 로드 생성을 시작합니다. 백엔드에서 작업을 수행하기 위해 & 를 꼭
포함해줍니다.
[ec2-user@ip-172-31-84-120 ~]$ python playlog_gen.py &
[1] 2296

Gaming on AWS
12. 스크립트가 multiprocessing 을 이용하여 플레이 로그를 생성하고 DynamoDB 의 유저 레벨을
지속적으로 업데이트 하게 됩니다.
[ec2-user@ip-172-31-84-120 ~]$ ps -ef | grep python
ec2-user 2296 2138 1 06:44 pts/0 00:00:00 python playlog_gen.py
ec2-user 2303 2138 0 06:44 pts/0 00:00:00 grep --color=auto python
proc1 = Process(target = playlog)
proc2 = Process(target = dynamodb)
def playlog():
filename = '/tmp/playlog/' + str(flag) + '_playlog.json'
with open(filename, 'a') as logFile:
json.dump(raw_data, logFile)
# Kinesis Agent parsed from each file based on n
logFile.write('n')
os.chmod(filename, 0o777)
def dynamodb():
if(ulevel < 100):
response = table.update_item(
Key = {'pidx': selectUser},
UpdateExpression = "SET ulevel = :ul, utimestamp = :ut",
ExpressionAttributeValues = {
':ul' : ulevel + 1,
':ut' : currentTime
},
ReturnValues = "UPDATED_NEW"
)
13. /tmp/playlog/ 경로에 로그가 생성되는 것을 확인할 수 있습니다.
[ec2-user@ip-172-31-84-120 ~]$ ls -l /tmp/playlog
total 456
-rwxrwxrwx 1 ec2-user ec2-user 183067 Oct 21 06:44 0_playlog.json

Gaming on AWS
14. /var/log/aws-kinesis-agent/aws-kinesis-agent.log 를 통해 Kinesis Agent 의 로그를 확인할 수
있습니다. 이를 통해 Kinesis Agent 가 파싱한 뒤 지정한 Kinesis Data Firehose 로 수집하고 있는
데이터의 정보를 확인할 수 있습니다. 아래의 명령어를 실행하여 로그를 확인해봅니다.
[ec2-user@ip-172-31-84-120 ~]$ tail -f /var/log/aws-kinesis-agent/aws-
kinesis-agent.log
2018-10-21 06:47:14.324+0000 ip-172-31-84-120 (Agent.MetricsEmitter RUNNING)
com.amazon.kinesis.streaming.agent.Agent [INFO] Agent: Progress: 6223
records parsed (1142565 bytes), and 6000 records sent successfully to
destinations. Uptime: 210022ms
...
...
...
15. AWS Management Console 에서 S3 서비스로 이동합니다. Kinesis Data Firehose 가 지정한 타깃
버킷으로 데이터를 저장하고 있는지 확인합니다.
16. raw 데이터를 수집한 버킷을 선택하면 다음과 같이 playlog 외에 userlog 폴더가 생긴 것을
확인할 수 있습니다. 여기에는 DynamoDB 에 업데이트 된 유저 정보가 저장되어 있습니다.
17. playlog 폴더에 들어가서 확인해보면 아래와 같이 데이터가 YYYY/MM/DD/HH 구조로 파티셔닝
되어 실시간으로 수집되고 있는 것을 확인할 수 있습니다.

Gaming on AWS
18. userlog 폴더에도 playlog 와 동일한 형태로 파티셔닝 되어 데이터가 실시간으로 수집되고 있는
19. AWS Management Console 에서 DynamoDB 서비스로 이동하여 UserProfile 테이블을
확인해보면 [Items] 탭에 다음과 같이 유저 정보가 업데이트 되는 것을 확인할 수 있습니다.
20. 데이터 수집 단계를 완료했습니다.

Gaming on AWS
Glue Data Catalog 생성
이전 과정을 통해 서버에서 발생한 로그와 DynamoDB 에 업데이트 되는 유저 정보를 실시간으로 S3
에 수집했습니다. 이제는 본격적으로 데이터 분석을 위한 작업을 시작하겠습니다.
첫 번째로 하게 되는 작업은 Glue Data Catalog 를 만드는 작업입니다. Glue Data Catalog 는 Apache
Hive Metastore 와 호환되는 중앙 메타데이터 리포지토리입니다. 여기에는 해당 데이터 세트에 대한
테이블 정의와 저장 위치가 포함되어 있으며, 이를 채우는데 Glue Crawler 를 활용하게 됩니다. Glue
Crawler 는 데이터 스토어에 연결된 뒤 데이터 스키마 등을 추출하고 이러한 메타데이터로 Glue Data
Catalog 를 채우는 역할을 합니다. 이번 단계는 아키텍처 상에는 다음 부분에 해당합니다.
1. AWS Management Console 에서 Glue 서비스로 이동합니다.
2. 좌측의 [Crawlers] 메뉴를 선택한 뒤 [Add crawler] 버튼을 클릭합니다.
3. [Crawler name] 에는 gamelog-raw 와 같이 원하는 이름을 입력하고 [Next] 버튼을 클릭합니다.
4. [Choose a data store] 에는 [S3] 를 선택하고 [Crawl data in] 은 [Specified path in my
account] 옵션을 선택합니다. 아래 [Include path] 에는 우측의 폴더 버튼을 클릭한 뒤 앞서 raw
데이터를 수집한 버킷을 선택합니다. [Next] 를 클릭하여 진행합니다.

Gaming on AWS
5. [Add another data store] 는 [No] 를 선택하고 [Next] 를 클릭합니다. IAM role 의 경우
CloudFormation 을 통해 생성된 IAM role 을 선택합니다. [Choose an existing IAM role] 옵션을
선택하고 [IAM role] 은 [GlueETLRole] 을 선택합니다. [Next] 를 선택합니다.
6. [Frequency] 는 [Hourly] 옵션을 선택합니다. S3 에 데이터가 YYYY/MM/DD/HH 구조로 파티셔닝
되어 저장되고 있기 때문에 이 정보를 최신으로 유지하기 위함입니다.
7. 메타데이터를 저장한 database 가 필요합니다. [Add database] 버튼을 클릭한 뒤 [Database
name] 에는 gamelogdb 를 입력한 뒤 [Create] 버튼을 클릭합니다. [Next] 를 클릭하고 내용을
리뷰한 뒤 [Finish] 버튼을 클릭하여 완료합니다.
8. 생성한 Glue Crawler 는 매시간 스케줄을 통해 실행되지만, 우선 실습을 위한 최초 데이터가
필요합니다. 생성된 Crawler 를 선택한 뒤 [Run crawler] 버튼을 클릭합니다.
9. Crawler 가 완료되면 아래와 같이 두개의 Table 추가되는 것을 확인할 수 있습니다.

Gaming on AWS
10. 생성된 Data Catalog 를 확인해보겠습니다. 좌측의 [Tables] 메뉴를 선택해보면 두개의 테이블이
추가되었습니다. 각각을 클릭하면 해당 테이블 정보를 조회할 수 있습니다. 여기에는 앞서 데이터
스토어에 선택한 버킷 내의 두 가지 데이터의 테이블 정보 등이 담겨 있고, 파티션을 자동인식 하는
11. 추가로 DynamoDB 의 테이블 정보 역시도 Glue Data Catalog 를 통해 관리할 수 있습니다. 이전과
유사한 방법으로 Glue Crawler 생성을 시작합니다.
12. [Crawler name] 에는 userprofile 과 같은 이름을 입력해주고 [Choose a data store] 는
[DynamoDB] 를 선택합니다. [Table name] 에는 UserProfile 을 선택하고 [IAM role] 은
[GlueETLRole] 을 선택합니다. DynamoDB 테이블의 경우 스키마 변경이 없기 때문에 [Frequency]
는 [Run on demand] 를 선택하여 생성합니다.

Gaming on AWS
13. DynamoDB 의 데이터도 동일한 Data Catalog 데이터 베이스에 저장하도 무방합니다. 이전에
생성한 [gamelogdb] 를 선택하여 Glue Crawler 생성을 완료합니다.
14. Crawler 생성을 완료한 뒤에는 [Run crawler] 버튼을 클릭하여 실행합니다.
15. Crawler 실행이 완료되면 한개의 테이블이 추가되고 좌측의 [Tables] 메뉴로 이동하면 다음과 같이
총 세개의 테이블을 확인할 수 있습니다.

Gaming on AWS
Glue ETL Job 실행
이번 단계에서는 앞서 생성한 Glue Data Catalog 를 이용하여 ETL 작업을 수행하겠습니다. 실습에서는
Athena 와 SageMaker 를 이용해 실제 데이터 분석 작업을 하게 되는데 각각에서 사용할 데이터가
다릅니다. Athena 를 이용해서는 실습에서 발생한 전체 데이터 세트에 쿼리를 이용하여 분석할 것이고
SageMaker 에서는 머신러닝 모델 학습에 필요한 데이터 세트를 별도로 만들어야 합니다. 이러한 ETL
작업은 Glue Job 을 통해 수행할 수 있습니다.
Glue 에서는 Python 과 Scala 두 가지 언어를 이용하여 작성한 ETL 스크립트를 수행할 수 있습니다.
또한 스크립트를 자동으로 생성하고 테스트하고 실행하는 것이 가능합니다. 아키텍처 상에서는 다음
부분입니다.
1. AWS Management Console 에서 Glue 서비스로 이동합니다.
2. 좌측의 ETL 아래의 [Jobs] 버튼을 클릭하고 [Add job] 버튼을 선택하여 Glue Job 생성을
시작합니다.
3. [Name] 에는 gamelog-etl 를 입력하고 [IAM role] 은 [GlueETLRole] 을 선택합니다. [This job
runs] 옵션은 [A new script to be authored by you] 옵션을 선택하여 직접 ETL 을 위한 Python
스크립트를 작성합니다. 하단의 [Advanced properties] 메뉴를 펼친 뒤 [Job metrics] 를 [Enable]
해줍니다. 이를 통해 ETL Job 이 수행될 때 CloudWatch 를 통해 모니터링 할 수 있습니다. [Next]
를 클릭합니다.
4. RDS, Redshift 등에 저장된 데이터를 이용할 때 Connections 를 활용하게 됩니다. 이번 실습의
데이터는 S3 와 DynamoDB 에 저장되어 있는 데이터만 활용하기 때문에 추가가 필요하지
않습니다. [Next] 를 클릭하고 [Save job and edit script] 버튼을 클릭하여 Job 을 생성합니다.

Gaming on AWS
5. 스크립트 작성 페이지에서 모든 내용은 삭제한 뒤, 아래의 링크에서 Python 스크립트를 복사하여
붙여넣습니다. 단, s3Bucket = "s3://<Analytics 버킷명>" 부분에 이전에 생성한 analytics 버킷
이름으로 변경하고 상단의 [Save] 버튼을 클릭한 뒤 [Run job] 버튼을 클릭하여 실행합니다.
https://s3.amazonaws.com/anhyobin-gaming/gamelog-etl-job.py
import sys
import datetime
from awsglue.transforms import *
from awsglue.dynamicframe import DynamicFrame
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
s3Bucket = "s3://<Analytics 버킷명>"
s3Folder ="/gamelog/"
# Set source data with playlog in S3, userprofile in DynamoDB
datasource0 = glueContext.create_dynamic_frame.from_catalog(database = "gamelogdb",
table_name = "playlog")
table_name = "userprofile")
df1 = datasource0.toDF()
df1.createOrReplaceTempView("playlogView")
df2 = datasource1.toDF()
df2.createOrReplaceTempView("userprofileView")
# Query to join playlog and userprofile
sql_select_athena = 'SELECT playlogView.partition_0, playlogView.partition_1,
playlogView.partition_2, playlogView.partition_3, playlogView.posnewz, playlogView.posnewy,
playlogView.posnewx, playlogView.posoldz, playlogView.posoldy, playlogView.posoldx,
playlogView.action, playlogView.idx, playlogView.pidx, playlogView.createdate,
userprofileView.pidx, userprofileView.uclass, userprofileView.ulevel FROM playlogView,
userprofileView WHERE playlogView.pidx = userprofileView.pidx ORDER BY
playlogView.createdate'

Gaming on AWS
sql_select_ml = 'SELECT playlogView.posnewx, playlogView.posnewy FROM (SELECT * FROM
playlogView ORDER BY playlogView.pidx, playlogView.createdate)'
exec_sql_athena = spark.sql(sql_select_athena)
exec_sql_dyf_athena = DynamicFrame.fromDF(exec_sql_athena, glueContext,
"exec_sql_dyf_athena")
exec_sql_ml = spark.sql(sql_select_ml)
exec_sql_dyf_ml = DynamicFrame.fromDF(exec_sql_ml, glueContext, "exec_sql_dyf_ml")
# Set target as S3 into two types, json and csv
datasink1 = glueContext.write_dynamic_frame.from_options(frame = exec_sql_dyf_athena,
connection_type = "s3", connection_options = {"path": s3Bucket + s3Folder + "gamelog_athena",
"partitionKeys" : ["partition_0", "partition_1", "partition_2", "partition_3"]}, format =
"json", transformation_ctx = "datasink1")
datasink2 = glueContext.write_dynamic_frame.from_options(frame = exec_sql_dyf_ml,
connection_type = "s3", connection_options = {"path": s3Bucket + s3Folder +
"gamelog_sagemaker"}, format = "csv", transformation_ctx = "datasink2")
job.commit()
ETL 스크립트를 잠시 살펴보게 되면 datasource0, datasource1 두 가지의 데이터 소스를 활용하는데
이는 모두 Glue Data Catalog 의 데이터인 것을 확인할 수 있습니다.
table_name = "playlog")
table_name = "userprofile")
Athena 에서는 이후 모든 데이터 세트를 활용할 것이기 때문에 sql_select_athena 에서와 같은
쿼리문을 통해 데이터 변환 작업을 하게 됩니다. S3 와 DynamoDB 두 군데에 나뉘어 저장된 playlog
와 user profile 을 하나로 조인하는 변환 작업을 수행합니다.
WHERE playlogView.pidx = userprofileView.pidx
SageMaker 에서는 모델 학습을 위한 x, y 좌표의 2 차원 데이터가 필요합니다. 단 pidx 로 정렬하여 각
사용자별로 행동 패턴을 나타내주어야 합니다. 이를 고려한 sql_select_ml 은 다음과 같습니다.
SELECT playlogView.posnewx, playlogView.posnewy FROM (SELECT * FROM playlogView ORDER BY
playlogView.pidx, playlogView.createdate)
Athena 용 데이터는 json 형태로 SageMaker 용 데이터는 csv 형태로 저장합니다. 그 외에도 Parquet,
ORC 등 열 기반 데이터 타입도 지원합니다. 포맷은 단순히 format = "" 을 통해 설정합니다.
datasink2 = glueContext.write_dynamic_frame.from_options(format = "csv" ...)

Gaming on AWS
6. [Run job] 버튼을 클릭하여 실행하면 아래 Oct 21, 2018, 7:24:42 PM Pending execution 와
같은 로그가 나타나고 실제 작업이 시작되기 까지 약간의 시간이 필요합니다. Glue 는 Serverless
환경으로 Job 을 실행하게 되면 해당 ETL 스크립트를 수행할 리소스가 내부적으로 우선
프로비저닝 된 뒤에 해당 스크립트가 실행됩니다. 때문에 조금의 딜레이가 존재합니다.
7. Job 실행이 완료되면 아래에서 file: s3://gaming-analytics/gamelog/gamelog_sagemaker/run-
1540118641016-part-r-00135 End of LogType:stdout 와 유사한 로그를 확인할 수 있습니다.
8. AWS Management Console 에서 S3 서비스를 선택합니다.
9. ETL 스크립트에 지정한 Analytics 버킷으로 이동해 ETL 작업이 성공적으로 실행되어 변환한
데이터가 저장되었는지 확인합니다. 버킷 내에 gamelog 폴더 아래에 gamelog_athena,
gamelog_sagemaker 두 개의 폴더가 생성되었고, 다음과 같이 변환된 데이터가 저장한 것을
확인할 수 있습니다.
10. 분석을 위한 데이터를 수집한 뒤 분석을 위해 변환하는 작업까지 완료하였습니다. 하지만 끝이
아닙니다. 마지막으로 새롭게 추가된 데이터를 Data Catalog 에 추가해주는 작업이 필요합니다.
11. AWS Management Console 에서 Glue 서비스를 선택합니다.
12. 좌측에서 [Crawlers] 메뉴를 선택한 뒤 이제는 많이 익숙해진 방법으로 Glue Crawler 를
생성합니다. [Crawler name] 은 gamelog-analytics 와 같이 입력하여 생성해줍니다. [Choose a
data store] 에는 [S3] 를 선택하고 [Include path] 는 새롭게 analytics 데이터를 수집한 버킷을
선택합니다. [Frequency] 는 [Run on demand], [Database] 는 이전과 동일하게 [gamelogdb] 를
선택하여 생성합니다. 생성 후에는 [Run crawler] 버튼을 클릭하여 실행해줍니다.
13. 실행이 완료되면 두개의 테이블이 추가되고 좌측의 [Tables] 에서 확인해보면 총 다섯개의
테이블이 존재하는 것을 확인할 수 있습니다.
14. 이런 방식으로 데이터 유형이나 용량에 관계없이 손쉽게 Data Lake 를 구축하는 것이 가능합니다.

Gaming on AWS
Athena 를 활용한 분석 작업
이전 과정을 통해 분석에 필요한 데이터를 가공하고 저장하는 단계까지 진행했습니다. 이렇게 Data
Lake 를 구축한 뒤에는 원하는 분석 서비스를 이용하여 빠르게 분석을 시작할 수 있습니다. Athena 뿐
아니라 Redshift, EMR 등 원하는 형태의 분석 서비스 모두에서 Glue Data Catalog 와 S3 의 데이터를
이용한 데이터 분석이 가능합니다.
이번 실습에는 Athena 를 이용해 S3 에 저장된 데이터를 표준 SQL 을 이용하여 분석해봅니다. Athena
는 Glue Data Catalog 와 즉시 통합이 되기 때문에 별도의 스키마 정의 없이 바로 대화식 쿼리를 통한
데이터 분석이 가능합니다. 이번 단계는 아키텍처 상 다음 부분에 해당합니다.
1. AWS Management Console 에서 Athena 서비스로 이동합니다.
2. [Get Started] 버튼을 클릭합니다. 튜토리얼이 나타난다면 닫아줍니다.
3. 좌측 [Database] 아래에서 이전에 생성한 Glue Data Catalog 에 저장된 [gamelogdb] 를
선택합니다. DynamoDB 테이블을 제외한 S3 에 저장된 네개의 테이블이 나타납니다.

Gaming on AWS
4. 각각의 테이블로 확인할 수 있는 데이터는 아래와 같습니다.
gamelog_athena playlog 와 userlog 를 조인한 모든 정보가 포함된 데이터 세트
gamelog_sagemaker Machine learning 모델 학습용 x, y 좌표만 포함된 데이터 세트
playlog EC2 인스턴스에서 생성된 유저들의 플레이 기록만 포함된 데이터 세트
userlog DynamoDB 에 저장된 유저 프로필의 히스토리가 포함된 데이터 세트
5. 이제 아래의 SQL 쿼리를 통해 데이터를 분석해봅니다. Athena 에서는 Presto 함수를 함께 사용할
수 있습니다. 아래의 예제 SQL 쿼리문을 수행해봅니다.
우선 데이터를 Glue 가 ETL 작업을 통해 조인한 gamelog_athena 의 데이터를 조회해보겠습니다.
SELECT * FROM gamelog_athena WHERE CAST(partition_2 AS BIGINT) = 9 limit 100;
mage, warrior, healer 중 어느 직업을 가장 많이 선택했는지 확인해봅니다.
SELECT COUNT(DISTINCT pidx) AS users, uclass FROM gamelog_athena GROUP BY uclass;
userlog 테이블의 데이터를 통해 최고 레벨 유저의 정보를 확인할 수 있습니다.
SELECT * FROM userlog WHERE ulevel IN (SELECT MAX(ulevel) FROM userlog);
특정 이벤트 지역에서 플레이한 유저수를 살펴봅니다.
SELECT COUNT(DISTINCT pidx) AS hotzone FROM gamelog_athena WHERE posnewx BETWEEN 300 AND 500
AND posnewy BETWEEN 400 AND 700;

Gaming on AWS
6. [QUIZ] 이제 쿼리를 이용하여 이상 행동을 보이는 유저를 찾아봅니다. 힌트는 유저들이 게임을
진행한 지도에 있습니다. posnewx, posnewy 와 같은 좌표 정보를 이용한다면 원하는 사용자들을
찾아낼 수 있습니다.
0 2000
1000
1000
400

Gaming on AWS
SageMaker 를 통한 Machine Learning 모델 학습 및 이상 행동 탐지
이번 단계에서는 SageMaker 의 빌트인 알고리즘인 Random Cut Forest(RCF) 를 이용하여 데이터
세트의 이상치를 탐지합니다. 실습을 통해 수집한 데이터에 이상 탐지를 위한 RCF 알고리즘을 적용해
보겠습니다. 이전까지의 과정을 통해 이미 학습을 위한 데이터 세트를 수집하고 준비까지 마친
상황입니다.
SageMaker 는 개발자 및 데이터 분석가가 Machine Learning 모델을 쉽고 빠르게 구축하고 교육 및
배포까지 할 수 있도록 지원하는 완전 관리형 플랫폼입니다.
RCF 알고리즘은 데이터 세트에 포함되어 있는 이상치들을 탐지하는 비지도 학습 알고리즘입니다.
SageMaker 에서 지원하는 RCF 알고리즘의 경우 각각의 데이터에 대해 이상치 스코어(anomaly
score)를 부여합니다. 이상치 스코어가 낮을 경우 해당 데이터는 정상일 가능성이 높은 반면, 높은
스코어를 보일 경우는 비정상일 가능성이 높다는 것을 나타냅니다. 이번 단계는 아키텍처 상에는 가장
마지막 단계인 다음에 해당합니다.
RCF 알고리즘에 관한 보다 자세한 정보는 다음의 AWS 한국 블로그의 내용을 참고하시기 바랍니다.
이상 탐지를 위한 Amazon SageMaker 의 Random Cut Forest 빌트인 알고리즘 (남궁 영환, AI 전문
솔루션즈 아키텍트) : https://aws.amazon.com/ko/blogs/korea/use-the-built-in-amazon-sagemaker-
random-cut-forest-algorithm-for-anomaly-detection/

Gaming on AWS
1. AWS Management Console 에서 SageMaker 서비스로 이동합니다.
2. 좌측의 [Notebook instances] 메뉴로 이동한 뒤 [Create notebook instance] 버튼을 클릭합니다.
3. [Notebook instance name] 에는 gamelog-ml-notebook, [Notebook instance type] 은
[ml.m4.2xlarge] 를 선택합니다. [IAM role] 은 [Create a new role] 을 선택합니다. IAM role 생성
화면에서 [S3 buckets you specify] 의 [Specific S3 buckets] 에는 gamelog_sagemaker 가
저장된 analytics 버킷을 입력하거나 [Any S3 bucket] 을 선택합니다.
4. 다음과 같이 설정했다면 [Create notebook instance] 버튼을 클릭하여 노트북 인스턴스를
생성합니다.
5. 잠시 후면 생성한 노트북 인스턴스가 InService 상태로 변경됩니다. [Open] 버튼을 클릭하여
Jupyter 노트북에 접속합니다.

Gaming on AWS
6. 이미 작성된 노트북을 임포트하여 실습을 진행할 수 있지만 스텝별로 살펴보기 위해 직접 코드를
입력하고 실행하도록 하겠습니다. 우측의 [New] 버튼을 클릭하고 [conda_python3] 를
선택합니다.
7. 상단의 [Untitles] 를 클릭한 뒤 GameLog-RCF 등을 입력한 뒤 [Rename] 버튼을 클릭합니다.
아래 링크에서 다음 스텝부터 사용되는 소스 코드를 확인할 수 있습니다. 링크에서 코드를 복사 & 붙여넣기 하시기 바랍니다.
8. SageMaker 전체 소스코드 : http://anhyobin-gaming.s3-website-us-east-1.amazonaws.com/
9. 첫번째 셀에서는 gamelog_sagemaker 의 데이터를 읽는 작업을 수행합니다. 코드 페이지에서
아래에 해당하는 부분을 복사하여 붙여넣기 합니다. 단, bucket = '<Analytics 버킷>' 부분에
데이터가 저장된 버킷명을 입력합니다. [▶Run] 버튼을 클릭합니다.
import boto3
import pandas
s3 = boto3.client('s3')
bucket = '<Analytics 버킷명>'
prefix = 'gamelog/gamelog_sagemaker/'
response = s3.list_objects_v2(Bucket = bucket, Prefix = prefix)
objs = []
for obj in response['Contents']:
objs.append(obj['Key'])
game_data = pandas.concat([pandas.read_csv('s3://' + bucket + '/' + obj, delimiter = ',') for
obj in objs])

Gaming on AWS
10. 두번째 셀에서는 전체 데이터 세트를 그래프로 그려보겠습니다. 실습을 시작할 때 S3 로 업로드한
데이터와 Kinesis Data Firehose 로 수집한 데이터를 합한 약 4 천만건의 데이터 전체를 이용하므로
시간이 조금 소요됩니다. 코드 페이지에서 아래에 해당하는 부분을 복사하여 붙여넣은 뒤 [▶Run]
버튼을 클릭합니다. <matplotlib.axes._subplots.AxesSubplot at 0x7f23bb72c358> 와 같은
아웃풋만 나타나고 그래프가 그려지지 않았다면 다음으로 진행하거나 재실행 해줍니다.
import matplotlib
# Set graph parameters for 40 million data set
matplotlib.rcParams['agg.path.chunksize'] = 100000
matplotlib.rcParams['figure.figsize'] = [20, 10]
matplotlib.rcParams['figure.dpi'] = 100
game_data.plot.scatter(
x = 'posnewx',
y = 'posnewy'
)
그래프를 살펴보면 이상 행동이라 의심되는 데이터 포인트를 찾을 수 있습니다. x 좌표 1000 에서
1200 까지와 y 좌표 0 에서 400 까지의 구간입니다. 이미 우리는 Athena 를 통해 해당 부분에 움직임이
있는 유저는 찾아낸 바 있습니다.

Gaming on AWS
11. 다음 셀에서는 이제 모델 학습을 위해 데이터를 RecordIO prodobuf 포맷으로 인코딩 하겠습니다.
SageMaker 의 다른 알고리즘과 마찬가지로 모델 학습은 해당 포맷에서 가장 좋은 성능을
보여줍니다. 이 단계에서는 단순히 CSV 포맷의 원본 데이터를 변환하고 결과를 S3 버킷에
저장합니다. 코드 페이지에서 아래에 해당하는 코드를 붙여넣은 뒤 bucket = '<Analytics 버킷>'
을 자신의 버킷으로 수정한 뒤 [▶Run] 을 클릭하여 실행합니다.
def convert_and_upload_training_data(
ndarray, bucket, prefix, filename='gamelog.pbr'):
import boto3
import os
from sagemaker.amazon.common import numpy_to_record_serializer
# Convert Numpy array to Protobuf RecordIO format
serializer = numpy_to_record_serializer()
buffer = serializer(ndarray)
# Upload to S3
s3_object = os.path.join(prefix, 'train', filename)
boto3.Session().resource('s3').Bucket(bucket).Object(s3_object).upload_fileobj(buffer)
s3_path = 's3://{}/{}'.format(bucket, s3_object)
return s3_path
bucket = '<Analytics 버킷명>'
prefix = 'sagemaker/randomcutforest'
s3_train_data = convert_and_upload_training_data(
game_data.as_matrix().reshape(-1,2),
bucket,
prefix)
실습에 사용하는 데이터는 x, y 좌표가 포함된 2 차원 데이터 입니다. 따라서 다음과 같이 2 차원으로
재정의 작업을 해주게 됩니다.
game_data.as_matrix().reshape(-1,2),

Gaming on AWS
12. 변환한 데이터 세트를 대상으로 SageMaker 의 RCF 모델을 학습합니다. 코드 페이지에서 아래에
해당하는 부분을 복사하여 붙여넣은 뒤 [▶Run] 을 클릭하여 실행합니다.
import boto3
import sagemaker
containers = {
'us-west-2': '174872318107.dkr.ecr.us-west-2.amazonaws.com/randomcutforest:latest',
'us-east-1': '382416733822.dkr.ecr.us-east-1.amazonaws.com/randomcutforest:latest',
'eu-west-1': '438346466558.dkr.ecr.eu-west-1.amazonaws.com/randomcutforest:latest'}
region_name = boto3.Session().region_name
container = containers[region_name]
session = sagemaker.Session()
# Set training job parameter
rcf = sagemaker.estimator.Estimator(
container,
sagemaker.get_execution_role(),
output_path='s3://{}/{}/output'.format(bucket, prefix),
train_instance_count=1,
train_instance_type='ml.c5.xlarge',
sagemaker_session=session)
# Set RCF Hyperparameter
rcf.set_hyperparameters(
num_samples_per_tree=1000,
num_trees=200,
feature_dim=2)
s3_train_input = sagemaker.session.s3_input(
s3_train_data,
distribution='ShardedByS3Key',
content_type='application/x-recordio-protobuf')
rcf.fit({'train': s3_train_input})
위의 코드에서 지정한 파라미터를 잠시 살펴보겠습니다. 우선 RCF 알고리즘을 위한 도커 컨테이너를
다음과 같이 지정했습니다.
containers = {
'us-west-2': '174872318107.dkr.ecr.us-west-2.amazonaws.com/randomcutforest:latest',
'eu-west-1': '438346466558.dkr.ecr.eu-west-1.amazonaws.com/randomcutforest:latest'}

Gaming on AWS
알고리즘을 실행시킬 인스턴스 타입과 숫자는 아래와 같이 지정했습니다. 더욱 빠르게 모델 학습을
원한다면 이 부분의 값을 변경하면 됩니다.
# Set training job parameter
rcf = sagemaker.estimator.Estimator(
container,
sagemaker.get_execution_role(),
output_path='s3://{}/{}/output'.format(bucket, prefix),
train_instance_count=1,
train_instance_type='ml.c5.xlarge',
sagemaker_session=session)
RCF 알고리즘에 필요한 하이퍼 파라미터를 지정한 부분이 보입니다. 이를 통해 200 개의 트리에 각
1000 개의 서브 샘플을 할당하고 학습하게 됩니다. 각각 파라미터에 대한 설명은 다음 링크에서
확인할 수 있습니다.
https://docs.aws.amazon.com/ko_kr/sagemaker/latest/dg/rcf_hyperparameters.html
rcf.set_hyperparameters(
num_samples_per_tree=1000,
num_trees=200,
feature_dim=2)
붙여넣은 코드의 실행이 완료되면 다음과 같이 학습 완료에 대한 아웃풋을 확인할 수 있습니다. 모델
학습이 완료 된 것입니다.

Gaming on AWS
13. 이제 실제로 이상 행동에 대한 스코어를 통해 예측하는 과정만 남았습니다. 그에 앞서 앞 단계에서
학습이 완료된 모델을 이용하는 추론용 엔드포인트를 생성합니다. 코드 페이지에서 아래에
해당하는 부분을 복사하여 붙여넣은 뒤 [▶Run] 을 클릭하여 실행합니다.
from sagemaker.predictor import csv_serializer, json_deserializer
rcf_inference = rcf.deploy(
initial_instance_count=2,
instance_type='ml.c5.2xlarge',
)
rcf_inference.content_type = 'text/csv'
rcf_inference.serializer = csv_serializer
rcf_inference.deserializer = json_deserializer
추론용 엔드포인트의 인스턴스 타입과 수를 지정할 수 있습니다. 이번 실습에는 ml.c5.2xlarge 두 대를
이용하겠습니다.
rcf_inference = rcf.deploy(
initial_instance_count=2,
instance_type='ml.c5.2xlarge',
)
실제 운영환경에서 더욱 큰 데이터세트에 대해 추론 작업을 진행한다면 더욱 큰 인스턴스를
할당해주거나 SageMaker Batch Transform 을 활용할 수 있습니다.
https://docs.aws.amazon.com/ko_kr/sagemaker/latest/dg/how-it-works-batch.html
다음과 같은 아웃풋을 통해 추론용 엔드포인트가 생성된 것을 확인합니다.

Gaming on AWS
14. 실제 데이터 세트를 추론 작업을 수행하겠습니다. 전체 데이터 세트를 추론하면 좋겠지만 이번
실습에는 ml.c5.2xlarge 인스턴스 두대만을 추론용으로 사용하는 제약이 있습니다. 때문에 임의로
추출한 약 18 만건의 데이터를 기반으로 추론작업을 수행하겠습니다. 혹은 analytics 버킷의
gamelog_sagemaker 폴더 내의 데이터를 활용해도 무방합니다. 우선 추론용 데이터 세트를 살펴
보겠습니다. 코드 페이지에서 아래에 해당하는 부분을 복사하여 붙여넣은 뒤 [▶Run] 을 클릭하여
실행합니다.
import pandas
import urllib.request
predict_file = 'predict.csv'
predict_source = 'https://s3.amazonaws.com/anhyobin-gaming/predict.csv'
urllib.request.urlretrieve(predict_source, predict_file)
predict_data = pandas.read_csv(predict_file, delimiter = ',')
predict_data.plot.scatter(
x = 'posnewx',
y = 'posnewy'
)
아웃풋으로 그래프가 나타납니다. 우리가 이미 알고 있는 이상 사용자들의 행동이 포함된 것을 알 수
있습니다.

Gaming on AWS
15. 마지막으로 실제 추론을 수행합니다. 이번 실습에서는 평균값에서 1.5 표준편차 범위를 넘는 모든
이상치 스코어에 대해서 이상치로 간주하겠습니다. 코드 페이지에서 아래에 해당하는 부분을
복사하여 붙여넣은 뒤 [▶Run] 을 클릭하여 실행합니다.
results = rcf_inference.predict(predict_data.as_matrix().reshape(-1,2))
scores = [datum['score'] for datum in results['scores']]
predict_data['score'] = pandas.Series(scores, index=predict_data.index)
score_mean = predict_data.score.mean()
score_std = predict_data.score.std()
score_cutoff = score_mean + 1.5 * score_std
anomalies = predict_data[predict_data['score'] > score_cutoff]
anomalies.plot.scatter(
x = 'posnewx',
y = 'posnewy'
)
평균값에서 1.5 표준편차 범위를 넘는 스코어는 다음와 같이 작성하였습니다.
score_cutoff = score_mean + 1.5 * score_std
anomalies = predict_data[predict_data['score'] > score_cutoff]
아웃풋으로 해당 모델을 기반으로 이상 행동을 보인 움직인 패턴이 나타나게 됩니다. 데이터가 실제
데이터가 아닌 이번 실습을 위해 랜덤하게 생성한 데이터이기 때문에 100% 정확하지는 않습니다.
하지만 Machine Learning 을 적용하고 원하는 결과를 어느 정도는 얻을 수 있었습니다.

Gaming on AWS
결론
‘게임 데이터 분석을 위한 Data Lake 구축과 Machine Learning 을 활용한 분석’ 실습을 통해 AWS
상에서 발생하는 데이터를 빠르게 수집하고 저장했습니다. 실제 데이터 분석을 위해서는 데이터를
준비하는 작업에 많은 시간과 비용이 필요하지만, Glue 를 활용하여 Data Catalog 를 만들고 ETL
작업을 통해 빠르게 데이터를 가공해 실제 분석 작업을 시작할 수 있었습니다.
이렇게 S3 에 데이터를 효율적으로 저장한다면 이후에 실습에서와 같이 Athena 와 같은 서비스를
이용해 손쉬운 분석이 가능해집니다.
마지막으로 SageMaker 를 통해 Machine Learning 을 위한 모델을 구축하고 학습한 후 실제
프로덕션까지 배포하는 자칫 어려울 수 있는 작업을 복잡하지 않게 수행할 수 있었습니다. SageMaker
는 가장 일반적으로 사용하는 알고리즘이 이미 사전에 설치되어 있기 때문에 이번 실습에서 Random
Cut Forest 알고리즘을 사용한 것과 유사하게 다양한 알고리즘을 적용해볼 수 있습니다.
긴 실습 끝까지 진행해 주셔서 깊이 감사드립니다.

Gaming on AWS
실습 리소스 삭제
1. S3 버킷 삭제
a. 버킷 선택 후 [Delete bucket] 버튼 클릭
2. Glue 삭제
a. [Crawlers] 에 생성한 세개의 Glue Crawler 각각 선택 후 [Actions] 메뉴 아래 [Delete
crawler] 클릭
b. Databases 에 생성한 [gamelogdb] 선택 후 [Actions] 메뉴 아래 [Delete database] 클릭
c. ETL 아래 [Jobs] 메뉴 선택한 뒤 [gamelog-etl] 선택 후 [Actions] 메뉴 아래 [Delete] 클릭
3. SageMaker 삭제
a. 좌측 [Notebook instances] 메뉴로 이동한 뒤 [gamelog-ml-notebook] 인스턴스 선택 후
우측 [Stop] 버튼 클릭. 인스턴스가 완전히 중지된 후 [Actions] 메뉴 아래 [Delete] 클릭
b. 좌측 Inference 아래 [Models] 메뉴로 이동한 뒤 [randomcutforest-2018-10-22-07-28-
35-425] 와 같은 형태로 생성된 모델 선택 후 [Actions] 메뉴 아래 [Delete] 클릭
c. [Endpoints] 메뉴로 이동한 뒤 [randomcutforest-2018-10-22-07-02-34-941] 와 같은
형태의 엔드포인트 선택 후 [Actions] 메뉴 아래 [Delete] 클릭
4. Kinesis Data Firehose 삭제
a. 좌측 [Data Firehose] 메뉴로 이동한 뒤 두개의 Kinesis Data Firehose 각각 선택 후
[Delete] 버튼 클릭
5. CloudFormation 스택 삭제
a. 생성한 스택 선택 후 [Actions] 아래의 [Delete Stack] 클릭

게임 데이터 분석을 위한 Data Lake 구축과 Machine Learning 을 활용한 분석 Hands on Lab (안효빈 솔루션즈 아키텍트, AWS) :: Gaming on AWS 2018

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a 게임 데이터 분석을 위한 Data Lake 구축과 Machine Learning 을 활용한 분석 Hands on Lab (안효빈 솔루션즈 아키텍트, AWS) :: Gaming on AWS 2018

Semelhante a 게임 데이터 분석을 위한 Data Lake 구축과 Machine Learning 을 활용한 분석 Hands on Lab (안효빈 솔루션즈 아키텍트, AWS) :: Gaming on AWS 2018 (20)

Mais de Amazon Web Services Korea

Mais de Amazon Web Services Korea (20)

게임 데이터 분석을 위한 Data Lake 구축과 Machine Learning 을 활용한 분석 Hands on Lab (안효빈 솔루션즈 아키텍트, AWS) :: Gaming on AWS 2018