카테고리 Archives: Python

AWS SES – SMTP 계정 의 키 변경

AWS SES (Simple Email Service) 는 직접 구축이 어려운 이메일 서비스를 제공한다.

sendmail 으로 SMTP 구성을 사용할 수 있지만 보통 스팸 방지를 위한 여러 솔루션에 의해서 차단이 되기 때문에

직접 sendmail 서비스를 구성하고 서비스 하기 위해서는 광범위한 공부가 필요 하다.

1. sendmail – smtp 구축

2. KISARBL 등록 (이것은 한국의 포털 쪽으로 메일 서비스 원활히 발송하기 위해 필요 하다.)

3. ReverseDNS 등록 (이건 해외 포털 서비스 쪽과 관련이 있다. Internet Service Provider 에서 등록이 가능하다. – KT, SK, U+ 등등..)

4. DKIM, DMARC 설정 (해외 포탈 gmail, yahoo 등등)

아울어서 주기적인 IP 신뢰도 관리를 위해 서버내에서 발송되는 메일을 추적, 통제 해야 한다.

AWS SES 는 월 62,000건 까지는 무료로 발송이 되며 이후 초과 되는 1000개의 메일당 약 100~150원 정도의 비용이 발생 한다.

물론 수신자의 스팸 신고가 많거나(1%) 허위 메일 주소로 발송(5%)되면 메일 발송 서비스가 차단 된다.

메일 발송을 위한 SMTP 계정은 생성을 하게 되면 auth 계정이 할당 되게 되며 사전에 등록된 메일 주소로만 발송을 할 수 있다.

문제는 ID / PW 형식 이기 때문에 유출 되었거나.. 혹은 패스워드 생성일이 오래 되면 보안상 바꾸어 주어야 한다.

AWS – IAM 에서 일반적으로 생성하는 액세스 키는 20글자 시크릿 키는 40 글자 를 차지 한다.

AWS – SES 에서는 SMTP 계정을 만들때 패스워드 길이가 44 글자를 가진다.

즉 SES 메뉴에서 “Create My SMTP Credentials” 생성한 계정을 사용할 수 있다.

그래서 찾아 보니 아래와 같은 메뉴얼을 찾을 수 있었다.

https://aws.amazon.com/ko/premiumsupport/knowledge-center/ses-rotate-smtp-access-keys/

근데 이해는 잘 되지 않는…

종합해보면 기본으로 제공 되는 파이선코드 를 이용하여 컨버팅 해서 써야 한다는 말이다.

시스템 엔지니어링을 하는 입장에서는 생성된 값을 테스트 하고 넘겨 줘야 하는 부분도 있고 python3 전용인 부분도 조금 마음에 안들어서

패스워드 생성 후 SMTP 테스트를 진행 하도록 하였다. ‘ㅅ’a

#!/usr/bin/env python

# -*- coding: utf-8 -*-

import sys

import hmac

import hashlib

import base64

import argparse

import smtplib

import email.utils

from email.header import Header

from email.mime.text import MIMEText

from email.mime.multipart import MIMEMultipart

def smtp_test(frommail, tomail, acckey, seckey, region):

SENDERNAME = 'PySender'

SENDER = frommail

RECIPIENT = tomail

USERNAME_SMTP = acckey

PASSWORD_SMTP = seckey

HOST = "email-smtp." + region + ".amazonaws.com"

PORT = 587

print("SMTP: email-smtp." + region + ".amazonaws.com:"+str(PORT))

print("AUTH: ID="+acckey+" PW="+seckey)

print("From: "+SENDER+" To: "+RECIPIENT)

SUBJECT = 'AWS SES 메일 테스트'

BODY_TEXT = """Amazon SES SMTP Email 테스트

현재 이메일은 Amazone SES 를 통해 발송 되었으며 Python 언어의 smtplib 라이브러리를 사용합니다."""

BODY_HTML = """<html>

<h1>Amazon SES SMTP Email 테스트</h1>

<p>현재 이메일은 Amazone SES 를 통해 발송 되었으며

<a href='https://www.python.org/'>Python</a> 언어의

<a href='https://docs.python.org/3/library/smtplib.html'>smtplib</a> 라이브러리를 사용합니다.

</p>

</body></html>"""

msg = MIMEMultipart('alternative')

msg['Subject'] = Header(SUBJECT, 'utf-8')

msg['From'] = email.utils.formataddr((SENDERNAME, SENDER))

msg['To'] = RECIPIENT

msg.attach(MIMEText(BODY_TEXT, 'plain', 'utf-8'))

msg.attach(MIMEText(BODY_HTML, 'html', 'utf-8'))

try:

server = smtplib.SMTP(HOST, PORT)

server.ehlo()

server.starttls()

server.ehlo()

server.login(USERNAME_SMTP, PASSWORD_SMTP)

server.sendmail(SENDER, RECIPIENT, msg.as_string())

server.close()

res = "Email sent!"

except Exception as e:

res = "Error: " + e

return res

def sign(key, msg):

return hmac.new(key, msg.encode('utf-8'), hashlib.sha256).digest()

def calculate_key(secret_access_key, region):

SMTP_REGIONS = ['us-east-1', 'us-east-2', 'us-west-2', 'us-gov-west-1', 'sa-east-1',

'ap-northeast-1', 'ap-northeast-2', 'ap-southeast-1', 'ap-southeast-2', 'ap-south-1',

'ca-central-1', 'eu-central-1', 'eu-west-1', 'eu-west-2']

if region not in SMTP_REGIONS:

raise ValueError("The "+region+" Region doesn't have an SMTP endpoint.")

signature = sign(("AWS4" + secret_access_key).encode('utf-8'), "11111111")

signature = sign(signature, region)

signature = sign(signature, "ses")

signature = sign(signature, "aws4_request")

signature = sign(signature, "SendRawEmail")

signature_and_version = bytes([0x04]) + signature

if sys.version_info[0] == 2:

signature_and_version = '\x04'.encode('utf-8') + signature

smtp_password = base64.b64encode(signature_and_version)

return smtp_password.decode('utf-8')

def main():

parser = argparse.ArgumentParser(description='AWS IAM Secret Access Key to SMTP password.')

parser.add_argument('AccessKEY', help='AWS IAM - Access Key ID')

parser.add_argument('SecretKEY', help='AWS IAM - Secret Access Key')

parser.add_argument('REGION', help='AWS SES - Region - us-west-2, ap-south-1, etc...')

args = parser.parse_args()

seskey = calculate_key(args.SecretKEY, args.REGION)

print('make SMTP Password complet.')

print('testing send e-mail? (Y/n) ')

read = str(sys.stdin.readline())

if read in ('Y\n', 'y\n'):

print(smtp_test("FROM@메일주소.com", "TO@메일주소.com", args.AccessKEY, seskey, args.REGION))

else:

print("AWS-SES ID: " + args.AccessKEY)

print("AWS-SES PW: " + seskey)

if __name__ == '__main__':

main()

exit(0)

사용 방법은 다음과 같다.

~]# ./aws-iam-secret_2_aws-ses-smtp-password.py [IAM엑세스키] [IAM시크릿키] [SES리전]

~]# ./aws-iam-secret_2_aws-ses-smtp-password.py AKIAUYPWLXWWGIYWWM4Q 3GYODowMLpLHyQxGRluCrpm0v5jatueqctIcwcGz ap-northeast-2

make SMTP Password complet.

testing send e-mail? (Y/n)

AWS-SES ID: AKIAUYPWLXWWGIYWWM4Q

AWS-SES PW: BL9kb7yvHjw+579VGgM9I0tGYaduQO/iRITu4hzqizpm

IAM 아무렇게나 생성된 계정에서는 작동하지 않고, 계정에 ses:SendRawEmail 권한이 부여 되어 있어야 작동 한다. (SES 에서 생성한 계정은 이미 부여가 되어 있을 것임.)

ps. 위에 예시된 엑세스키/시크릿키/SMTP비밀번호는 이 글을 포스팅 한 이후 모두 삭제 했으니까 굳이 테스트 해보지 않으셔도 된다. ‘ㅅ’a

python – apache pyarrow 를 이용한 parquet 생성 및 테스트

apache 재단에서 진행 되는 프로젝트 이다. python, java, R 등등 많은 언어를 지원 한다.

CSV (Comma-Separated Values)의 가로열 방식의 데이터 기록이 아닌 세로열 기록 방식으로 기존 가로열 방식에서 불가능한 영역을 처리가 가능하도록 한다.

보이는가 선조의 지혜가 -3-)b

이미지 출처: 훈민정음 나무위키

차이점을 그림으로 표현하자면 아래와 같다.

문서를 모두 읽는다 에서는 큰 차이가 발생하지 않지만 구조적으로 모든 행이 색인(index) 처리가 된 것처럼 파일을 읽을 수 있다.

sql 문으로 가정으로 “(SELECT * FROM 테이블 WHERE 재질 = ‘철’)” 을 찾게 될 경우 index 가 둘다 없다는 가정하에서

CSV 는 9개의 칸을 읽어야 하지만 (재질->무게->산화->나무->가벼워->탄다->철->무거워->안탄다->return)

parquet 의 경우 5개의 칸만 읽으면 된다. (재질->나무->철->무거워->안탄다->return)

PS. 물론 색인(index) 는 이런 구조가 아닌 hash 처리에 따른 협차법 으로 찾아서 빨리 찾을 수 있어 차이가 있다.

압축을 하더라도 컬럼별 압축이 되기 때문에 필요한 내용만 읽어서 압축해제 하여 데이터를 리턴 한다.

적당한 TSV (Tab-Separated Values)데이터를 준비 한다.

python 을 이용하여 TSV 파일을 읽고 python 의 pyarrow를 이용하여 parquet 파일을 생성 하고 읽는 테스트를 한다. (pyarrow, pandas 는 pip install pyarrow pandas 으로 설치할 수 있다.)

#!/usr/bin/env python

# -*- coding: utf-8 -*-

import os

import time

import pandas as pd

import pyarrow as pa

import pyarrow.parquet as pq

from pyarrow import csv

def tsv2parquet(filename, skiphead, column_length, toformat):

if toformat in ('none', 'snappy', 'gzip', 'lzo', 'brotil', 'lz4', 'zstd'):

if skiphead == 0:

skiphead = None

table_columns = [str(i) for i in range(0, column_length)]

r_opt = csv.ReadOptions(skip_rows=skiphead, column_names=table_columns, use_threads=False)

p_opt = csv.ParseOptions(delimiter='\t')

pyarrow_table = csv.read_csv(fname, read_options=r_opt, parse_options=p_opt)

outname = os.path.splitext(fname)[0]+'.'+toformat+'.parquet'

pq.write_table(pyarrow_table, outname, compression=toformat)

else:

print('didn\'t support format: '+ toformat)

exit(1)

return outname

print('pyarrow version:', pa.__version__) # print pyarrow Version

fname = "sample/shjang_Genome_20191011.txt" # Target file (TSV)

sh = 4 # file header line.

cc = 10 # column count

out_format = 'gzip' # pyarrow 0.16 support: 'none', 'snappy', 'gzip', 'lz4', 'zstd'

print('File size: ' + str(os.path.getsize(fname)))

ts = time.time()

outfile = tsv2parquet(fname, sh, cc, out_format) # make parquet file.

print('make parquet(' + out_format + ') file: ' + str(round(time.time() - ts, 2)) + ' sec')

ts = time.time()

dataframe = pd.read_parquet(outfile, engine='pyarrow')

print('parquet -> pandas -> dataframe: ' + str(round(time.time() - ts, 2)) + ' sec')

ts = time.time()

dataframe = pq.read_table(outfile).to_pandas()

print('parquet -> pyarrow -> dataframe: ' + str(round(time.time() - ts, 2)) + ' sec')

exit(0)

TSV -> parquet 압축률(높을수록 좋음) 및 처리 시간(낮을수록 좋음)

	def	ext	MB	compress ratio	processing time python 2.7	processing time python 3.6
txt		.txt	58.8 MB
gzip		.txt.gz	16.3 MB	72%	3.24 sec
pyarrow	write_table, compression='none'	.parquet	40.1 MB	32%	0.74 sec	0.93 sec
	write_table, compression='snappy'		24.8 MB	58%	1.31 sec	0.95 sec
	write_table, compression='lz4'		24.7 MB	58%	0.79 sec	0.94 sec
	write_table, compression='zstd'		19.3 MB	67%	1.00 sec	0.98 sec
	write_table, compression='gzip'		18.8 MB	68%	5.07 sec	1.18 sec

읽기/쓰기 테스트 모두 AWS – EC2(m5.large-centos7) – gp2(100GB) 에서 진행 하였다.

parquet 을 생성한 이유는 파일을 읽을때 모든 컬럼인 index가 걸려있는것과 같이 빠르게 읽기 위함이니 읽기 테스트도 해본다.

#!/usr/bin/env python

# -*- coding: utf-8 -*-

import os

import time

import pandas as pd

import pyarrow as pa

import pyarrow.parquet as pq

from pyarrow import csv

def tsv2table2dataframe(filename, skiphead, column_length):

table_columns = [str(i) for i in range(0, column_length)]

r_opt = csv.ReadOptions(skip_rows=skiphead, column_names=table_columns, use_threads=False)

p_opt = csv.ParseOptions(delimiter='\t')

pyarrow_table = csv.read_csv(fname, read_options=r_opt, parse_options=p_opt)

t1 = str(round(time.time() - ts, 2))

ts2 = time.time()

pyarrow_df = pyarrow_table.to_pandas()

t2 = str(round(time.time() - ts2, 2))

return pyarrow_df, t1, t2

print('pyarrow version:', pa.__version__) # print pyarrow Version

fname = "sample/shjang_Genome_20191011.txt" # Target file (TSV)

sh = 4 # file header line.

cc = 10 # column count

out_format = 'gzip' # pyarrow 0.16 support: 'none', 'snappy', 'gzip', 'lz4', 'zstd'

print('File size: ' + str(os.path.getsize(fname)))

ts = time.time()

dataframe = pd.read_csv(fname, skiprows=sh, sep='\t', quotechar='"', header=None, index_col=None, error_bad_lines=False)

print('text TSV file read with pandas to dataframe: ' + str(round(time.time() - ts, 2)) + ' sec')

ts = time.time()

dataframe = pd.read_csv(fname+'.gz', compression='gzip', skiprows=sh, sep='\t', quotechar='"', header=None, index_col=None, error_bad_lines=False)

print('gzip TSV file read with pandas to dataframe: ' + str(round(time.time() - ts, 2)) + ' sec')

ts = time.time()

dataframe, t1, t2 = tsv2table2dataframe(fname, sh, cc)

print('text TSV read(' + t1 + ' sec) with pyarrow to dataframe(' + t2 + ' sec): ' + str(round(time.time() - ts, 2)) + ' sec')

ts = time.time()

dataframe, t1, t2 = tsv2table2dataframe(fname+'.gz', sh, cc)

print('gzip TSV read(' + t1 + ' sec) with pyarrow to dataframe(' + t2 + ' sec): ' + str(round(time.time() - ts, 2)) + ' sec')

exit(0)

TSV, parquet 파일 읽기 테스트 (pandas, pyarrow)

	def	ext	MB	processing time python 2.7	processing time python 3.6
pandas	read_csv	.txt	58.8 MB	1.39 sec	1.56 sec
	read_csv, compression='gzip'	.txt.gz	16.3 MB	1.68 sec	2.06 sec
	read_parquet	.parquet (none)	40.1 MB	0.72 sec	0.93 sec
		.parquet (snappy)	24.8 MB	1.03 sec	0.95 sec
		.parquet (lz4)	24.7 MB	0.73 sec	0.94 sec
		.parquet (zstd)	19.3 MB	0.76 sec	0.95 sec
		.parquet (gzip)	18.8 MB	0.96 sec	1.18 sec
pyarrow	read_csv, to_pandas	.txt	58.8 MB	1.01 sec	1.30 sec
	read_csv, to_pandas	.txt.gz	16.3 MB	1.41 sec	1.37 sec
	read_table, to_pandas	.parquet (none)	40.1 MB	0.69 sec	0.90 sec
		.parquet (snappy)	24.8 MB	0.99 sec	0.89 sec
		.parquet (lz4)	24.7 MB	0.69 sec	0.92 sec
		.parquet (zstd)	19.3 MB	0.75 sec	0.95 sec
		.parquet (gzip)	18.8 MB	0.95 sec	1.22sec

이 문서 처음에 언급 했다 시피 대용량 파일을 처리 하기 위함. 즉 “빅데이터”(HIVE, Presto, Spark, AWS-athena)환경을 위한 포멧이다.

모두 테스트 해보면 좋겠지만 아직 실력이 부족해서 AWS athena 만 테스트를 진행 한다.

구조적으로 S3 버킷에 parquet 파일을 넣어 두고 athena 에서 테이블을(S3 디렉토리 연결) 생성 하여 SQL 문으로 검색을 하는데 사용 한다.

TSV, parquet 파일 읽기 테스트 (AWS – athena)

	ROW FORMAT SERDE	ext	Searched MB	processing time (select target 2)	processing time (select target 50)
athena	org.apache.hadoop.hive. serde2.lazy. LazySimpleSerDe	.txt	58.8 MB	1.17 ~ 3.35 sec	1.86 ~ 2.68 sec
	org.apache.hadoop.hive. serde2.lazy. LazySimpleSerDe	.txt.gz	16.3 MB	1.37 ~ 1.49 sec	1.44 ~ 2.69 sec
	org.apache.hadoop.hive. ql.io.parquet.serde. ParquetHiveSerDe	.txt.parquet	10.48 MB	1.11 ~ 1.49 sec	1.00 ~ 1.38 sec
		.snappy.parquet	4.71 MB	0.90 ~ 2.36 sec	0.90 ~ 1.00 sec
	지원 불가	.lz4.parquet	지원 불가
	지원 불가	.zstd.parquet	지원 불가
	org.apache.hadoop.hive. ql.io.parquet.serde. ParquetHiveSerDe	.gzip.parquet	2.76 MB	0.89 ~ 1.17 sec	0.90 ~ 1.85 sec

읽는 속도가 향상되었고 스캔 크기가 적게 나온다. (parquet 의 강점을 보여주는 테스트-스캔비용의 절감이 가능.)

athena 테이블 생성에 사용된 DDL 쿼리문 (TSV, parquet)

CREATE EXTERNAL TABLE IF NOT EXISTS [데이터베이스명].[테이블명] (

`rsid` string,

`chr` string,

`pos` int,

`gt` string

)

ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe'

STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat'

OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'

LOCATION 's3://[S3-URL]/[TSV폴더]';

CREATE EXTERNAL TABLE IF NOT EXISTS [데이터베이스명].[테이블명] (

`rsid` string,

`chr` string,

`pos` int,

`gt` string

)

ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'

WITH SERDEPROPERTIES ('serialization.format' = '1', 'parquet.column.index.access'='true')

LOCATION 's3://[S3-URL]/[parquet폴더]'

TBLPROPERTIES ('has_encrypted_data'='true');

PS. 이건 저도 어려 웠어요…..

Machine Learning 공부 – PlaidML

말로만 듣지 말고 해보자 라는 개념으로 시작했다.

Anaconda3 64비트를 설치 하고 파이선의 venv를 생성 한뒤에 tensorflow 설치 및 keras 설치를 진행 한다.

C:\somewhere> set CONDA_FORCE_32BIT=

C:\somewhere> conda create -n py38_64_ml_test

C:\somewhere> activate py38_64_ml_test

C:\somewhere> pip install numpy pandas matplotlib sklearn tensorflow==2.3.0 keras==2.4.3

이후 메뉴얼의 트레이닝을 했을때 CPU 연산을 하는것으로 확인이 되었고

연습용 PC 으로 AMD 르누아르 계열을 쓰고 있기 때문에 GPU 연산을 위해 PlaidML 을 설치 진행 하였다.

C:\somewhere> activate py38_64_ml_test

C:\somewhere> pip install plaidml

C:\somewhere> plaidml-setup

setup시 대화형인데 동의, 그래픽카드선택, 저장 에 순서 의다.

사용방법 – keras를 이용하는 코드에서 아래와 같이 선언만 하면 된다.

1 2	import plaidml.keras plaidml.keras.install_backend()

테스트1 – plaidbench

C:\somewhere> activate py38_64_ml_test

C:\somewhere> pip install plaidml-keras plaidbench

C:\somewhere> plaidbench keras mobilenet

테스트2 – python 코드 VGG19

#!/usr/bin/env python

import numpy as np

import time

import plaidml.keras

plaidml.keras.install_backend()

import keras

import keras.applications as kapp

from keras.datasets import cifar10

(x_train, y_train_cats), (x_test, y_test_cats) = cifar10.load_data()

batch_size = 8

x_train = x_train[:batch_size]

x_train = np.repeat(np.repeat(x_train, 7, axis=1), 7, axis=2)

model = kapp.VGG19()

model.compile(optimizer='sgd', loss='categorical_crossentropy',

metrics=['accuracy'])

print("Running initial batch (compiling tile program)")

y = model.predict(x=x_train, batch_size=batch_size)

# Now start the clock and run 10 batches

print("Timing inference...")

start = time.time()

for i in range(10):

y = model.predict(x=x_train, batch_size=batch_size)

print("Ran in {} seconds".format(time.time() - start))

잘 돌기는 도는데 이게 지금 GPU 연산을 하는가? 라는 의문이 있었다.

위와 같이 작업 관리자의 GPU 그래프가 너무나도 잠잠했기 때문에..

트레이닝을 시켰을때 GPU의 메모리 사용량이 늘은 것을 확인 했으나 GPU 코어 측정 부분이 가만히 있고 덩달아 시스템의 cpu / mem 사용량이 늘어 났다.

자세히 디버깅을 하면서 실행 해보니 AI 트레이닝 이전에 CPU/MEM 사용량이 먼저 증가 하였다 ‘ㅅ’a

구동 시나리오상 python도 같이 돌기 때문에 python 이 학습 및 테스트 데이터를 dataframe 에 넣을때 cpu 및 memory 사용량이 늘어나는것 같다.

윈도우 작업 관리자의 GPU 부분은 3D / Copy / Video Encoding, Decoding 등등만 보여주기 때문에 트레이닝시 GPU 로드 그래프 확인이 안되는것으로 추정 된다.

그래서 찾은 방법은 GPU-Z 를 설치해서 모니터링 하는 것이다.

잘된다 🙂

다른 방법으로는 트레이닝 시간을 측정해 볼수 있겠다.

CPU연산을 했을때에는 5 columns, 110,281 rows 를 LSTM 연산을 했을때 약 35분 11초(2111초)가 소요 되는 트레이닝이 GPU 연산을 했을때 5분 46초(346초)로 단축이 되었다.

PS. PlaidML 은 intel 이 만들었고 keras backend 를 연결하여 intel, AMD gpu를 쓸수 있게 해주는 패키지 이다 ‘ㅅ’a

Nvidia 가 만든 CUDA를 이용하는 구글의 tensorflow 를 쉽게 쓰게 도와주는 keras…

이와 별개로 AMD가 구축하는 ROCm 이 있다 ‘ㅅ’a (이거는 나중에 스스로 공부할때 사용할 키워드를 주절주절 써놓은것…)

AWS 상에서의 API Gateway – Lambda – python – pymysql – rds(mariadb) 구현

aws 에서는 API Gateway 를 제공 한다.

이는 serverless 기반의 API 생성 및 운영을 손쉽게 할 수 있는 서비스 이다. (근데 손쉽지 않더라..)

물론 굉장히 난해 하고 어렵지만 처음 한걸음은 항상 어려 웠다 ‘ㅅ’a (이 산을 넘으면 devops 가 되는 첫걸음이 된다.)

위 이미지 생성은 클라우드크래프트 (https://cloudcraft.co/) 에서 진행 하였다. (AWS 아키텍쳐를 짜는데 매우 유용함.)

즉 restful API 를 AWS 상에서 API gateway 와 Lambda 서비스를 이용하여 구축 하여 운영하는 것이다.

이미 이와 같은 많은 글을 참고 하였으나 대부분 아마존에서 제공 하는 nodojs 를 활용하는 방법만 존재 하더라…

1. Lambda 에서 함수를 생성 한다.

2. 함수가 생성 되면 기본 설정에서 함수의 제한 등을 확인할 수 있다.

핸들러의 의미는 함수가 실행되었을때 lambda_function.py 한의 def lambda_handler() 를 실행한다는 의미가 된다.

(물론 편집도 된다. DB 접근 시간이 있기 때문에 제한시간을 10~15초로 늘린다.)

3. 스크롤을 올려 보면 AWS Cloud 9 IDE 의 간소화 버전을 이용하여 수정을 할 수 있다.

4. Test 버튼을 눌러 테스트 셋을 생성 한다. (이미지는 없음)

테스트를 위한 좀더 많은 json 은 https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/sample-apps/nodejs-apig/event.json 에서 확인할 수 있다.

{

"httpMethod": "GET",

"queryStringParameters": { "nick-name": "Enteroa", "Locate": "인천" }

}

{

"httpMethod": "POST",

"body": "{\"nick-name\":\"Enteroa\",\"Locate\":\"인천\"}"

}

다시 TEST 버튼를 눌러보면 실행 API Gateway 에 연결 되었을때 실행 후 결과 값이 확인 된다.

함수 생성이 완료 되었지만 Hello World 를 보려고 이것을 하는게 아니기 때문에 API의 근본 목적인 데이터베이스 접속을 할 차례이다 ‘ㅅ’a

배포용 코드 작성은 AWS cloud 9 IDE 를 통해 작성을 할 예정이다. (일반적인 linux 나 windows 환경에서도 가능하다.)

물론 Cloud 9 을 통해 lambda 배포가 가능하지만 단순 소스 작성을 위해서만 이용할 예정 이다 ‘ㅅ’a (이걸 하려면 또 Cloud Fomation 을 해야 하기 때문에…)

Lambda 에서는 일부 json, logging 등을 별다른 설정 없이 import 할 수 있지만 pymysql 과 같은 서버에 별도 설치가 필요한 부분은 같이 업로드가 되어야 한다.

때문에 아래와 같이 pymysql 설치를 한다.

~]$ mkdir -p pydbcon

~]$ cd pydbcon

~]$ pip install -t ./ pymysql

~]$ touch dbinfo.py lambda_function.py

db 정보를 저장할 dbinfo.py 파일과 AWS lambda 핸들러에서 지정된 lambda_function.py 파일을 같이 생성 한다.

db_host = "mydb.ap-northeast-2.rds.amazonaws.com"

db_username = "enteroa"

db_password = "pa55w@RD"

db_name = "enteroa"

db_port = 3306

import json

import logging

import pymysql

import dbinfo

log = logging.getLogger()

log.setLevel(logging.INFO)

db = pymysql.connect(

host = rds_config.db_host,

port = rds_config.db_port,

db = rds_config.db_name,

user = rds_config.db_username,

password = rds_config.db_password,

ssl = {'ca':rds_config.db_ssl_ca},

charset = "utf8" )

def lambda_handler(event, context):

with db.cursor(pymysql.cursors.DictCursor) as cursor:

if event['httpMethod'] == 'GET':

bodydata = json.loads(json.dumps(event['queryStringParameters']))

response = {

'statusCode': 200,

'headers': {

'content-type': 'application/json; charset=utf-8'

'body': json.dumps(bodydata),

'isBase64Encoded': False

}

return response

if event['httpMethod'] == 'POST':

req_body_dict = json.loads(event['body'])

cursor.execute('SELECT VERSION()')

list1 = cursor.fetchall()

for a in list1:

req_body_dict['MariaDB-Version'] = a['VERSION()']

bodydata = req_body_dict

response ={

'statusCode': 200,

'headers': {

'content-type': 'application/json; charset=utf-8'

'body': json.dumps(bodydata),

'isBase64Encoded': False

}

return response

db.close()

위와 같이 작성을 하고 zip 파일로 압축을 한다.

~]$ ls

PyMySQL-0.10.0.dist-info lambda_function.py pymysql dbinfo.py

~]$ zip -r lambda001.zip ./*

adding: lambda_function.py (deflated 62%)

adding: dbinfo.py (deflated 25%)

adding: pymysql/ (stored 0%)

adding: PyMySQL-0.10.0.dist-info/ (stored 0%)

압출한 파일을 AWS 웹콘솔 에서 업로드 한다.

zip 파일이 압축 해제가 되며 lambda001 아래에 파일 및 폴더가 위치 할 수 있는데 아래와 같이 드래그 앤 드롭으로 맞추어 준다.

아니면 기본설정-핸들러를 lambda_function.lambda001.lambda_handler 으로 바꾸어도 될꺼 같기도 하다 ‘ㅅ’a

데이터베이스의 경우 보안 때문에 IP를 막고 일부만 열어서 서비스 하는것이 일반적이기 때문에 실행하는 람다를 VPC 내에서 실행 되게 해야 한다.

그래서 생성한 lambda 함수가 자신의 VPC 에서 네트워크 인터페이스를 사용할 수 있는 권한을 주어야 한다.

화면 최상단의 권한 으로 이동하고 실행 역할(IAM role) 을 눌러 해당 정책에 정책 추가를 진행해야 한다.

아래의 권한으로 정책을 새롭게 생성해서 연결 해도 되고 인라인 정책 추가를 해도 된다.

추후 생성되는 Lambda 함수는 권한 부분에서 기존 역할로 이미 VPC 권한이 부여된 역할을 선택 해주면 좀더 편하게 사용할 수 있겠다.

{

"Version": "2012-10-17",

"Statement": [

{

"Sid": "VisualEditor0",

"Effect": "Allow",

"Action": [

"ec2:CreateNetworkInterface",

"ec2:DescribeInstances",

"ec2:DescribeNetworkInterfaces",

"ec2:DeleteNetworkInterface",

"ec2:AttachNetworkInterface"

"Resource": "*"

}

]

}

lambda 실행될 VPC 에 대한 정보를 설정해 주어야 한다.

사용자 지정 VPC 지정과 VPC 지정 subnet 지정(2개 이상) 과 EC2보안그룹을 지정 하면 된다.

그리고 RDS 서버의 보안그룹에서 위에서 lambda 가 사용할 것으로 지정된 두개의 서브넷(172.31.0.0/20, 172.31.16.0/20)을 허용한다.

테스트를 달려 본다.

앗싸 가오리!

너무 길어져서 API 게이트웨이는 나중에 추가 할 예정이다 =_=a

팔로우 할때 주의 할점은 API 게이트 웨이의 리소스 > 메소드 에서 “통합 요청”의 유형이 LAMBDA 가 아닌 LAMBDA_PROXY 으로 해야 하는 python 코드 이다.

python 에서 mysql 접속 하기

서버사이드 프로그램을 짜더라도 DB에 접근 하여 데이터를 가져다가 작동을 하게 하는 경우가 많다.

python의 경우 프로그래밍 언어 이고 사용자 층도 두껍고 오래 되었기 때문에 대부분 드라이버가 제공이 된다.

그래서 필요한 내용을 설치하여 import 하여 사용 하면 된다 🙂

하지만 db 정보가 소스에 삽입되어 있는 것은 좋지 못하기 때문에 YAML 형식의 문서로 config 파일을 생성하고

그 config 파일을 python 에서 읽어서 DB 접속을 해야 한다. (json 은 시인성이 좋지만 주석을 첨부 할 수 없고/xml은 시인성이 너무 떨어진다.)

---

MYSQLDB:

DBHOST: 127.0.0.1

DBPORT: 3306

DBNAME: databasename

DBUSER: sqlusename

DBPASS: userpassword

CHARSET: utf8

DBCA: /some/where/ca.pem ### mysql-ssl 접속을 위한 Root CA

DBKEY: /some/where/ccc.key ### mysql-ssl 접속을 위한 Keyfile

DBCERT: /some/where/ccc.cert ### mysql-ssl 접속을 위한 Certificate

#!/usr/bin/env python

#-*- coding: utf-8 -*-

import yaml

import pymysql

def mysqldbcon():

readyaml = yaml.safe_load_all(file('/opt/test/config.yaml', 'r')) ### 경로를 모두 지정하는것이 좋다.

for a in readyaml:

for b, c in a.items():

if b == 'MYSQLDB':

conn = pymysql.connect(

host = c['DBHOST'], port = c['DBPORT'],

db = c['DBNAME'], user = c['DBUSER'], password = c['DBPASS'],

#ssl = { 'ssl': { 'ca': c['DBCA'], 'key': c['DBKEY'], 'cert': c['DBCERT'] } }, ### ssl 접속을 쓰는 것을 추천하지만...

charset = c['CHARSET']

)

return conn

def main():

db = mysqldbcon()

with db.cursor(pymysql.cursors.DictCursor) as cur:

sqlquery = 'SELECT VERSION()'

cur.execute(sqlquery)

rows = cur.fetchall()

for a in rows:

print a['VERSION()']

db.close()

if __name__ == "__main__":

main()

exit(0)

~]# ./test.py

10.3.14-MariaDB-log

여담으로 python은 기본적으로 CentOS linux 에 대부분 설치되어 있으나 import 하는 pymysql 과 yaml은 설치 되어 있지 않기 때문에 아래와 같이 pip를 설치 하고 pip으로 설치 한다..

~]# yum install python2-pip

...

~]# pip install pymysql pyyaml

...

YAML의 경우 python 혼자만 쓰는 설정파일일 경우 info.py 를 만들고 import 하는게 편하지만 다른 언어의 프로그램 이나 로직과 겸용해야 할때 필요하겠지..