AWS Lambda์ ๋ชจ๋ ๊ฒ: ์ด๋ณด์๋ฅผ ์ํ ์๋ฒฝํ ๊ฐ์ด๋ 2/2
- 2023๋ 12์ 20์ผ
- 4๋ถ ๋ถ๋
์ต์ข ์์ ์ผ: 2024๋ 2์ 19์ผ
AWS Lambda์ ๋ชจ๋ ๊ฒ: ์ด๋ณด์๋ฅผ ์ํ ์๋ฒฝํ ๊ฐ์ด๋ 2/2 - Console์์ ๋๋ค ํจ์ ์์ฑ, ํธ๋ฆฌ๊ฑฐ ์ค์ ๋ฐ ์๊ธ ๊ณ์ฐ

Written by Hyojung Yoon
์๋ ํ์ธ์! ์ค๋์ ์ง๋ ์๊ฐ์ ์ด์ด AWS Lambda์ ๋ํด์ ๋ ์์ธํ ์์๋ณผ ๊ฑด๋ฐ์, ํนํ ์ด๋ฒ ํํธ๋ AWS Console์ ํ์ฉํ์ฌ ์ง์ ๋๋ค ํจ์๋ฅผ ์์ฑํ๊ณ , ๋๋ค ํธ๋ฆฌ๊ฑฐ๋ฅผ ์ค์ ํ๋ ์ค์ต์ ํ ๊ฒ์ ๋๋ค.
๋ํ AWS Lambda์ ๋น์ฉ ์ ์ฑ ์ ์ดํดํ๊ณ ์ค์ ๋น์ฉ์ ๊ณ์ฐํ๋ ๋ฐฉ๋ฒ๋ ์์๋ณผ ๊ฒ์ ๋๋ค.
๊ทธ๋ผ ์ง๊ธ๋ถํฐ ์์ํ๊ฒ ์ต๋๋ค!!
AWS Lambda ์์ํ๊ธฐ
AWS Lambda์ ๊ฐ๊ฒฉ
AWS Lambda ์์ํ๊ธฐ
1. Console์์ ๋๋ค ํจ์ ์์ฑ

AWS ์ฝ์์ ์ฌ์ฉํด ์ฒซ ๋ฒ์งธ ํจ์๋ฅผ ์์ฑํ ์ ์์ต๋๋ค. AWS ์ฝ์์์ Lambda๋ฅผ ์ ํํฉ๋๋ค.
[ ํจ์ ์์ฑ ] ๋ฒํผ์ ๋๋ฌ ๋๋ค ํจ์๋ฅผ ๋ง๋ญ๋๋ค.

์๋จ์ 3 ๊ฐ์ง ์ต์ ์ค ํ๋๋ฅผ ์ ํํ๊ฒ ๋ฉ๋๋ค.
์๋ก ์์ฑ: ์ฒ์๋ถํฐ ํจ์๋ฅผ ๊ตฌํํ๋ค
๋ธ๋ฃจํ๋ฆฐํธ ์ฌ์ฉ: AWS์์ ์ ๊ณตํ๋ ๊ธฐ๋ฅ์ ํ ํ๋ฆฟ์ฒ๋ผ ์ฌ์ฉํ ์ ์๋ ๊ธฐ๋ฅ์ด๋ฉฐ, ์ํ ์ฝ๋ ํ์์ผ๋ก ์ปค์คํฐ๋ง์ด์งํ์ฌ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค
์ปจํ ์ด๋ ์ด๋ฏธ์ง: docker ์ปจํ ์ด๋ ์ฉ
์ต์ ์ ํ ํ ์ ํจ์์ ์ด๋ฆ์ ์ถ๊ฐํ๊ณ ์ํ๋ ๋ฐํ์ยน์ ์ ํํ๋ฉด ๋ฉ๋๋ค.
ยน๋ฐํ์(runtime)์ด๋? ๋๋ค๋ฅผ ์ด๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ก ์์ฑํ ์ง์ ๋ํ ์ต์ ์ผ๋ก Node.js, python, Go ๋ฑ ๋ค์ํ ๋ฐํ์ ์ธ์ด๋ฅผ ์ ๊ณตํฉ๋๋ค.

๊ถํ์ ๋๋ค์ ์ด๋ค ๊ถํ์ ๋ถ์ฌํ ์ง์ ๋ํ ์ต์ ์ ๋๋ค.
ํ๋จ์ [ ๊ธฐ๋ณธ ์คํ ์ญํ ๋ณ๊ฒฝ ] ์ ํด๋ฆญํด ๊ธฐ๋ณธ Lambda ๊ถํ์ ๊ฐ์ง ์ ์ญํ ์์ฑ์ ์ ํํด ์๋ก์ด ์ญํ ์ ๋ง๋ญ๋๋ค.
2. ๋๋ค ํจ์ ์ฝ๋ ์์ฑ
์์ฑ๋ ํจ์๋ฅผ ํ์ธํ์ธ์. ์ฌ๊ธฐ์๋ hjLambda๋ผ๋ ์ด๋ฆ์ผ๋ก ์์ฑ๋์์ต๋๋ค.
์คํฌ๋กค์ ๋ด๋ ค ํ๋จ์ ํจ์ ์ฝ๋ ํ๋ฉด์ผ๋ก ์ด๋ํฉ๋๋ค. ์๋์์ ์ฝ๋๋ฅผ ์ ํํ๊ฑฐ๋ ์์ ๋ง์ ํ ํ๋ฆฟ์ ๋ง๋ค ์ ์์ต๋๋ค.

๋๋ค ํจ์ ๊ตฌ์ฑ
myHandler = Lambda ํจ์์ ์ด๋ฆ
ํจ์๊ฐ ํธ์ถ๋๋ฉด Lambda๋ ํธ๋ค๋ฌ ๋ฉ์๋๋ฅผ ์คํํ๋๋ฐ, ์ด๋ ์ ๋ฌ๋๋ 3๊ฐ์ ์ธ์(parameter)์๋ event, context, callback์ด ์์ต๋๋ค.
event: ํธ์ถ์๋ก๋ถํฐ์ ์ ๋ณด๊ฐ ํฌํจ๋ event ๊ฐ์ฒด๋ก, Lambda๋ฅผ ํธ๋ฆฌ๊ฑฐ ํ ์ด๋ฒคํธ์ ๋ํ ๋ชจ๋ ์ ๋ณด๋ฅผ ํฌํจํฉ๋๋ค.
context: Lambda ํจ์ ๊ฐ์ ํธ์ถ๊ณผ ์คํ ํ๊ฒฝ, ๋ฐํ์์ ๋ํ ์ ๋ณด๋ฅผ ํฌํจํฉ๋๋ค.
callback: ๋น๋๊ธฐ ์๋ต์ ์ ์กํ๊ธฐ ์ํด ํ์ํ๋ฉฐ, Lambda ํจ์ ๋ด๋ถ์์ ๋ชจ๋ ์์ ์ ์ํํ ํ์๋ ๊ทธ์ ๋ํ ๊ฒฐ๊ณผ(๋๋ ์ค๋ฅ)์ ํจ๊ป callback ํจ์๋ฅผ ํธ์ถํ๊ณ ์ด๋ฅผ AWS๊ฐ HTTP ์์ฒญ์ ๋ํ ์๋ต์ผ๋ก ์ฒ๋ฆฌํฉ๋๋ค.
3. ๋๋ค ํจ์ ์คํํ๊ธฐ
๋๋ค ํจ์๋ฅผ ์คํํ๊ธฐ ์ ์ ํ ์คํธ๋ฅผ ๋จผ์ ์คํํ๋๋ก ํ๊ฒ ์ต๋๋ค.
ํ ์คํธ ๋๋กญ ๋ค์ด ๋ฉ๋ด์์ [ ํ ์คํธ ์ด๋ฒคํธ ๊ตฌ์ฑ ]์ ์ ํํ๋ฉด, ํ ์คํธ ์ด๋ฒคํธ ๊ตฌ์ฑ์ ์ํ ์ฝ๋ ํธ์ง๊ธฐ๊ฐ ๋ํ๋ฉ๋๋ค.

์ ์ด๋ฒคํธ ์์ฑ์ ์ ํํ ํ MyEvent ์ ๊ฐ์ ์ด๋ฒคํธ ์ด๋ฆ์ ์ ๋ ฅํฉ๋๋ค.
์ด๋ฒคํธ ๊ณต์ ์ค์ ์ ๊ธฐ๋ณธ ์ค์ ์ธ ๋น๊ณต๊ฐ๋ฅผ ์ ์งํฉ๋๋ค.
ํ ํ๋ฆฟ ๋ชฉ๋ก์์ hello-world๋ฅผ ์ ํํ ํ [ ์ ์ฅ ] ์ ํด๋ฆญํฉ๋๋ค.

[ Test ] ๋ฒํผ์ ํด๋ฆญํ๊ณ , ์ฝ์์์ ์ฑ๊ณต์ ์ผ๋ก ์คํ๋์๋์ง ๊ฒฐ๊ณผ๋ฅผ ํ์ธํฉ๋๋ค.

์คํ ๊ฒฐ๊ณผ ํญ์์ ์คํ์ด ์ฑ๊ณตํ๋์ง ํ์ธํฉ๋๋ค.
ํจ์ ๋ก๊ทธ ์น์ ์ Lambda ํจ์ ์คํ์ผ๋ก ์์ฑ๋ ๋ก๊ทธ์ ๋ก๊ทธ ์ถ๋ ฅ์ ๋ณด๊ณ ๋ ์ฃผ์ ์ ๋ณด๊ฐ ํ์๋ฉ๋๋ค.

ํ ์คํธ๊ฐ ์ ์์ ์ผ๋ก ์งํ ๋์๋ค๋ฉด [ Deploy ] ๋ฒํผ์ ๋๋ฌ ์คํ ๊ฐ๋ฅํ ์ํ๋ก ๋ณ๊ฒฝํด์ค๋๋ค.
4. ๋๋ค ํธ๋ฆฌ๊ฑฐ ์ค์
1) ๋๋ค ํธ๋ฆฌ๊ฑฐ + S3
AWS Lambda ํจ์๋ฅผ ์ฌ์ฉํ์ฌ Amazon S3 ๋ฒํท์์ ๋ค๋ฅธ ๋ฒํท์ผ๋ก ํ์ผ์ ๋ณต์ฌํ๋ ๋ก์ง์ ๊ตฌํํด ๋ณด๊ฒ ์ต๋๋ค.
1๋จ๊ณ: ์๋ณธ ๋ฐ ๋์ Amazon S3 ๋ฒํท์ ์์ฑํฉ๋๋ค.
Amazon S3 ์ฝ์์ ์ด๊ณ ๋ฒํท ์์ฑ์ ์ ํํฉ๋๋ค. ์๋ณธ ๋ฒํท๊ณผ ๋์ ๋ฒํท์ ์์ฑํฉ๋๋ค.

์ฌ๊ธฐ์๋ ์๋ณธ ๋ฒํท์ ์ด๋ฆ์ [ hjtestbucket ]์ผ๋ก ๋์ ๋ฒํท์ ์ด๋ฆ์ [ hjtestbucket02 ] ๋ก ์ค์ ํ์ต๋๋ค.
2๋จ๊ณ: Lambda ํจ์ ์์ฑ
Lambda ์ฝ์์์ ํจ์ ํ์ด์ง๋ฅผ ์ด๊ณ , ํจ์๋ฅผ ์์ฑํฉ๋๋ค.

๋ฐํ์ ๋๋กญ๋ค์ด ๋ชฉ๋ก์ ์ ํํ ๋ค์ Python 3.9๋ฅผ ์ ํํ ๋ค ์ ์ฌ์ง๊ณผ ๊ฐ์ ๋๋ค ํจ์๋ฅผ ์์ฑํฉ๋๋ค.

์ฝ๋ ํญ์ ์ ํํ๊ณ ๋ค์ JSON ์ฝ๋๋ฅผ ๋ถ์ฌ ๋ฃ์ต๋๋ค.
import boto3
import botocore
import json
import os
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
s3 = boto3.resource('s3')
def lambda_handler(event, context):
logger.info("New files uploaded to the source bucket.")
key = event['Records'][0]['s3']['object']['key']
source_bucket = event['Records'][0]['s3']['bucket']['name']
destination_bucket = "destination_bucket"
source = {'Bucket': source_bucket, 'Key': key}
try:
response = s3.meta.client.copy(source, destination_bucket, key)
logger.info("File copied to the destination bucket successfully!")
except botocore.exceptions.ClientError as error:
logger.error("There was an error copying the file to the destination bucket")
print('Error Message: {}'.format(error))
except botocore.exceptions.ParamValidationError as error:
logger.error("Missing required parameters while calling the API.")
print('Error Message: {}'.format(error))
์ฝ๋๋ฅผ ๋ถ์ฌ ๋ฃ์์ผ๋ฉด [ ๋ฐฐํฌ ]๋ฅผ ์ ํํฉ๋๋ค.

3๋จ๊ณ: Lambda ํจ์๋ฅผ ์ํ Amazon S3 ํธ๋ฆฌ๊ฑฐ ์์ฑ

Lambda ์ฝ์์์ ํจ์ ํ์ด์ง๋ฅผ ์ด๊ณ , ํจ์ ๊ฐ์์์ [ ํธ๋ฆฌ๊ฑฐ ์ถ๊ฐ ]๋ฅผ ์ ํํฉ๋๋ค.

ํธ๋ฆฌ๊ฑฐ ๊ตฌ์ฑ ๋๋กญ๋ค์ด ๋ชฉ๋ก์ ์ ํํ ๋ค์ S3๋ฅผ ์ ํํฉ๋๋ค.

๋ฒํท์ ์๋ณธ ๋ฒํท์ ์ด๋ฆ์ ์ ๋ ฅํ๊ณ , ์ด๋ฒคํธ ์ ํ์์๋ All object create events๋ฅผ ์ ํํฉ๋๋ค.
์ ๋ ฅ๊ณผ ์ถ๋ ฅ ๋ชจ๋์ ๋์ผํ S3 ๋ฒํท์ ์ฌ์ฉํ๋ ๊ฒ์ด ๊ถ์ฅ๋์ง ์์์ ์ธ์ ํฉ๋๋ค์ ๋์ํจ์ ์ ํํ ๋ค์ ์ถ๊ฐ๋ฅผ ์ ํํฉ๋๋ค.
4๋จ๊ณ: Lambda ํจ์์ ์คํ ์ญํ ์ ๋ํ AWS ID ๋ฐ ์ก์ธ์ค ๊ด๋ฆฌ(IAM) ๊ถํ ์ ๊ณต

๋ค์ ๋ฆฌ์์ค ๊ธฐ๋ฐ ์ ์ฑ ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋์ S3 ๋ฒํท์ ํ์ผ์ ๋ณต์ฌํ๋ ค๋ฉด Lambda ํจ์์ ์คํ ์ญํ ์ ๋ํ IAM ๊ถํ์ ์ถ๊ฐํด์ผ ํฉ๋๋ค.
Lambda ์ฝ์์์ ํจ์ ํ์ด์ง๋ฅผ ์ด๊ณ , ๊ตฌ์ฑ - ์คํ ์ญํ ์์ ์ญํ ์ด๋ฆ์ ํด๋ฆญํฉ๋๋ค.

IAM ์ฝ์์์ [ ๊ถํ ์ถ๊ฐ ]๋ฅผ ์ ํํ ๋ค์ [ ์ธ๋ผ์ธ ์ ์ฑ ์์ฑ ]์ ์ ํํฉ๋๋ค.

[ JSON ] ์ต์ ์ ์ ํํ ํ, ์๋ JSON ์ ์ฑ ๋ฌธ์๋ฅผ ๋ถ์ฌ๋ฃ์ต๋๋ค.
โป ์ฐธ๊ณ
destination-s3-bucket์ S3 ๋์ ๋ฒํท์ผ๋ก ๊ต์ฒดํ๊ณ source-s3-bucket์ S3 ์๋ณธ ๋ฒํท์ผ๋ก ๊ต์ฒดํฉ๋๋ค.
๋ฆฌ์์ค ARN ๋์ ์๋ /*๋ฅผ ํด๋น ํ๊ฒฝ์ ํ์ํ ์ ๋์ฌ ๊ฐ์ผ๋ก ๋ฐ๊พธ์ด ๊ถํ์ ์ ํํฉ๋๋ค.
์์ ์ ์ํํ๋ ๋ฐ ํ์ํ ๊ถํ์๋ง ์ต์ ๊ถํ์ ๋ถ์ฌํ๋ ๊ฒ์ด ๊ฐ์ฅ ์ข์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ์ต์ ๊ถํ ๋ถ์ฌ๋ฅผ ์ฐธ์กฐํ์ธ์.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "putObject",
"Effect": "Allow",
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::destination-s3-bucket/*"
]
},
{
"Sid": "getObject",
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::source-s3-bucket/*"
]
}
]
}
[ ์ ์ฑ ์์ฑ ]์ ์ ํํ์ฌ ์ ์ ์ฑ ์ ์ ์ฅํฉ๋๋ค.์ ์ ํํ์ฌ ์ ์ ์ฑ ์ ์ ์ฅํฉ๋๋ค.

5๋จ๊ณ: Lambda ํจ์๊ฐ ์ ๋๋ก ์คํ๋๊ณ ์๋์ง ํ์ธ
์ด์ ๋๋ค ํธ๋ฆฌ๊ฑฐ๊ฐ ์ ์๋๋๋์ง ํ์ธํ๊ธฐ ์ํด, ์๋ณธ S3 ๋ฒํท์ ํ์ผ์ ์ ๋ก๋ ํฉ๋๋ค.

[ ์ ๋ก๋ ]๋ฅผ ํด๋ฆญํ ํ, ์ ๋ก๋ ์ํ๋ฅผ ํ์ธํฉ๋๋ค.

๋์ S3 ๋ฒํท์ ๋ค์ด๊ฐ ํด๋น ํ์ผ์ด ๋ณต์ฌ๋์๋์ง ํ์ธํฉ๋๋ค.

๋์ผํ ํ์ผ์ด ์ ์ฅ๋์ด ์์ผ๋ฉด ํจ์๊ฐ ์ ๋๋ก ์๋ํ๊ณ ์๋ค๋ ๊ฒ์ ์ ์ ์๋ค.
AWS Lambda์ ๊ฐ๊ฒฉ
1. ๋๋ค์ ์๊ธ ์ ์ฑ

๋๋ค์ ๋น์ฉ์ ํฌ๊ฒ ์ธ ๊ฐ์ง ์์(์์ฒญ ์, ์คํ ์๊ฐ, ๋ฉ๋ชจ๋ฆฌ ํฌ๊ธฐ)์ ์ํด ๊ฒฐ์ ๋ฉ๋๋ค.
๋๋ค๋ ์ 1๋ฐฑ๋ง ํ์ ๋ฌด๋ฃ ์์ฒญ๊ณผ 400,000GB-์ด์ ๋ฌด๋ฃ ์ปดํจํ ์๊ฐ์ ์ ๊ณตํฉ๋๋ค. ์ด๋ฅผ ํตํด ์์ ํ๋ก์ ํธ๋ ํ ์คํธ ๋จ๊ณ์์๋ ๋ณ๋์ ๋น์ฉ ์์ด Lambda๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
๊ตฌ๋ถ | Free Tier ํด๋น ๊ฑด์ |
์์ฒญ ๊ฑด์ | ์๋ณ ๋ฌด๋ฃ ์์ฒญ 1๋ฐฑ๋ง ๊ฑด |
์ปดํจํ ์๊ฐ | ์๋ณ ๋ฌด๋ฃ 400,000GB-์ด |
๋ฉ๋ชจ๋ฆฌ ํฌ๊ธฐ | ์ฒซ 512MB(0.5G)๋ ์ถ๊ฐ ๋น์ฉ ์์ |
2. ๋๋ค ๊ฐ๊ฒฉ ๊ณ์ฐํ๊ธฐ
AWS ์๊ธ ๊ณ์ฐ๊ธฐ ์ฌ์ดํธ์์ ์ฝ๊ฒ ๋๋ค ๊ฐ๊ฒฉ์ ๊ณ์ฐํ ์ ์์ต๋๋ค.
ํ ๋ฌ์ 3,000,000ํ ์คํ, ๋งค 1์ด๊ฐ ์คํ, 512GM ๋ฉ๋ชจ๋ฆฌ (0.5 GB)์ผ ๊ฒฝ์ฐ AWS Lambda ์๊ธ์ ๊ณ์ฐํด๋ณด๊ฒ ์ต๋๋ค.

์คํฌ๋กค์ ๋ด๋ ค [ ๊ณ์ฐ ํ์ ] ๋ฅผ ํ์ธํ๋ฉด ์๊ธ ์ฐ์ ๋ฐฉ์์ ์ ์ ์์ต๋๋ค.

๋๋ค ์๊ธ ๊ณ์ฐ ํด์
์ ๊ณ์ฐ์ ๋ํ ํด์์ ๋๋ค.
์ด ์ฌ์ฉ๋(GB-์ด) = 3,000,000 x 1 x 0.5 = 1,500,000 GB-์ด
์ฌ๊ธฐ์ ๋ฌด๋ฃ ํฐ์ด 400,000GB-์ด๋ฅผ ์ ์ธํ๋ฉด
์ด ์ฌ์ฉ๋(GB-์ด) = 3,000,000 x 1 x 0.5 = 1,500,000 GB-์ด
AWS Lambda์ GB-์ด ๋น์ฉ์ $0.0000166667 per GB-์ด์ ๋๋ค.
์คํ ์๊ฐ ๋น์ฉ = 1,100,000 x 0,0000166667 = $18.33
์ฌ๊ธฐ์ ๋ฌด๋ฃ ํฐ์ด 1,000,000ํ๋ฅผ ์ ์ธํ๋ฉด
์ ๋ฃ ์ฌ์ฉ๋(์์ฒญ ๊ฑด์) = 3,000,000 - 1,000,000 = 2,000,000 ํ
์์ฒญ ๋น์ฉ์ ํ ๋ฌ์ 2,000,000ํ ์คํ์ด๊ธฐ ๋๋ฌธ์ $0.20 per 1M ์ ๋๋ค.
์์ฒญ ๋น์ฉ = 2,000,000/1,000,000 x 0.20 = $0.40
์์ ์คํ ๋ฆฌ์ง๋๊ฐ Lambda ํจ์์ 512MB(=0.5GB)์ ์คํ ๋ฆฌ์ง๋ฅผ ์ถ๊ฐ ๋น์ฉ ์์ด ์ฌ์ฉํ ์ ์์ต๋๋ค.
์ถ๊ฐ ์คํ ๋ฆฌ์ง ๋น์ฉ = 0.5GB - 0.5GB = 0.00
๋ฐ๋ผ์ ๋ฌด๋ฃ ํฐ์ด๋ฅผ ๊ณ ๋ คํ ์ด ๋น์ฉ์ ์ฝ $18.73์ ๋๋ค.
์ด ๋น์ฉ = $0.40(์์ฒญ ๋น์ฉ) + $18.33(์คํ ์๊ฐ ๋น์ฉ) = $18.73
์ด ๊ณ์ฐ์ ๊ธฐ๋ณธ ๋น์ฉ๋ง์ ๊ณ ๋ คํ ๊ฒ์ด๋ฏ๋ก, ์ถ๊ฐ์ ์ธ ๋น์ฉ์ด ๋ฐ์ํ ์ ์์ต๋๋ค. ๊ฐ๊ฒฉ์ ๋ณ๋๋ ์ ์์ผ๋, ์ต์ ์ ๋ณด๋ AWS ๊ณต์ ์น์ฌ์ดํธ์์ ํ์ธํ์๋ ๊ฒ์ด ์ข์ต๋๋ค.
๋ง์น๋ฉฐ
์ด๋ฒ AWS Lambda ๊ฐ์ด๋๋ฅผ ํตํด AWS ์ฝ์์์ Lambda ํจ์๋ฅผ ์์ฑํ๊ณ , ๋๋ค ํธ๋ฆฌ๊ฑฐ๋ฅผ ์ค์ ํ๋ ์ค์ต์ ๋ง์น์ จ์ต๋๋ค. ๋ํ ๋๋ค์ ๋น์ฉ ์ ์ฑ ๊ณผ ๊ณ์ฐ ๋ฐฉ๋ฒ๊น์ง ์์๋ณธ ์ด๋ฒ ์๋ฆฌ์ฆ๋ฅผ ํตํด ์ค์ ๋น์ฆ๋์ค ์๋๋ฆฌ์ค์ ์ ์ฉํ๋๋ฐ ํ์ํ ๊ธฐ๋ณธ์ ์ธ ๋จ๊ณ๋ฅผ ๋ชจ๋ ๊ฒฝํํ๋๋ฐ์, ์ด๋ฒ ๊ฒฝํ์ ๋ฐํ์ผ๋ก AWS Lambda๋ฅผ ํ์ฉํ ๋ค์ํ ํด๋ผ์ฐ๋ ์๋น์ค๋ฅผ ์ค๊ณ์ ๋์์ด ๋์์ผ๋ฉด ์ข๊ฒ ์ต๋๋ค.







