AWS 비용 폭탄 막는 백엔드 개발자의 5가지 실천법

안녕하세요! 오늘은 AWS 비용을 효과적으로 절감하는 방법에 대해 알아보겠습니다. 특히 백엔드 개발자 관점에서 실천할 수 있는 5가지 핵심 전략을 소개합니다.

1. EC2 인스턴스 최적화

1.1 인스턴스 타입 선택

# AWS SDK를 사용한 인스턴스 권장사항 조회
import boto3

def get_instance_recommendations():
    ec2 = boto3.client('ec2')
    response = ec2.get_instance_recommendations(
        InstanceArns=['arn:aws:ec2:region:account-id:instance/instance-id']
    )
    return response['InstanceRecommendations']

1.2 Auto Scaling 설정

{
    "AutoScalingGroupName": "your-asg",
    "MinSize": 2,
    "MaxSize": 5,
    "DesiredCapacity": 2,
    "TargetTrackingConfigurations": [
        {
            "PredefinedMetricSpecification": {
                "PredefinedMetricType": "ASGAverageCPUUtilization"
            },
            "TargetValue": 70.0
        }
    ]
}

1.3 스팟 인스턴스 활용

# 스팟 인스턴스 요청
import boto3

def request_spot_instances():
    ec2 = boto3.client('ec2')
    response = ec2.request_spot_instances(
        SpotPrice='0.03',
        InstanceCount=1,
        Type='one-time',
        LaunchSpecification={
            'ImageId': 'ami-12345678',
            'InstanceType': 't3.micro',
            'KeyName': 'your-key-pair'
        }
    )
    return response['SpotInstanceRequests']

2. RDS 데이터베이스 최적화

2.1 인스턴스 크기 조정

# RDS 인스턴스 크기 조정
import boto3

def resize_rds_instance():
    rds = boto3.client('rds')
    response = rds.modify_db_instance(
        DBInstanceIdentifier='your-db',
        DBInstanceClass='db.t3.small',
        ApplyImmediately=True
    )
    return response['DBInstance']

2.2 읽기 전용 복제본 활용

# 읽기 전용 복제본 생성
def create_read_replica():
    rds = boto3.client('rds')
    response = rds.create_db_instance_read_replica(
        DBInstanceIdentifier='your-db-replica',
        SourceDBInstanceIdentifier='your-db',
        DBInstanceClass='db.t3.small'
    )
    return response['DBInstance']

2.3 쿼리 최적화

# Django ORM 쿼리 최적화 예시
from django.db.models import Prefetch

def optimized_query():
    # N+1 문제 해결
    orders = Order.objects.select_related('user').prefetch_related(
        Prefetch('items', queryset=OrderItem.objects.select_related('product'))
    )

    # 필요한 필드만 선택
    users = User.objects.only('id', 'email', 'username')

    return orders, users

3. S3 스토리지 최적화

3.1 수명 주기 관리

{
    "Rules": [
        {
            "ID": "Move to IA",
            "Status": "Enabled",
            "Transitions": [
                {
                    "Days": 30,
                    "StorageClass": "STANDARD_IA"
                }
            ]
        },
        {
            "ID": "Delete old versions",
            "Status": "Enabled",
            "NoncurrentVersionExpiration": {
                "NoncurrentDays": 90
            }
        }
    ]
}

3.2 압축 및 캐싱

# Django에서 S3 파일 압축
from django.core.files.storage import default_storage
import gzip

def compress_and_upload(file_path):
    with open(file_path, 'rb') as f_in:
        with gzip.open(f'{file_path}.gz', 'wb') as f_out:
            f_out.writelines(f_in)

    with open(f'{file_path}.gz', 'rb') as f:
        default_storage.save(f'{file_path}.gz', f)

4. Lambda 함수 최적화

4.1 메모리 설정 최적화

# Lambda 함수 메모리 사용량 모니터링
import boto3
import json

def monitor_lambda_memory():
    cloudwatch = boto3.client('cloudwatch')
    response = cloudwatch.get_metric_statistics(
        Namespace='AWS/Lambda',
        MetricName='MemoryUtilization',
        Dimensions=[
            {
                'Name': 'FunctionName',
                'Value': 'your-function'
            }
        ],
        StartTime=datetime.now() - timedelta(days=1),
        EndTime=datetime.now(),
        Period=3600,
        Statistics=['Average']
    )
    return response['Datapoints']

4.2 콜드 스타트 최소화

# Lambda 핸들러 최적화
import json
import boto3

# 전역 변수로 클라이언트 초기화
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('your-table')

def lambda_handler(event, context):
    # 핸들러 로직
    return {
        'statusCode': 200,
        'body': json.dumps('Success')
    }

5. 모니터링 및 알림 설정

5.1 CloudWatch 대시보드

# CloudWatch 대시보드 생성
import boto3

def create_cloudwatch_dashboard():
    cloudwatch = boto3.client('cloudwatch')
    dashboard_body = {
        "widgets": [
            {
                "type": "metric",
                "properties": {
                    "metrics": [
                        ["AWS/EC2", "CPUUtilization", "InstanceId", "i-1234567890abcdef0"]
                    ],
                    "period": 300,
                    "stat": "Average",
                    "region": "ap-northeast-2",
                    "title": "EC2 CPU Utilization"
                }
            }
        ]
    }

    response = cloudwatch.put_dashboard(
        DashboardName='CostOptimization',
        DashboardBody=json.dumps(dashboard_body)
    )
    return response

5.2 비용 알림 설정

# 비용 알림 생성
import boto3

def create_cost_alert():
    cloudwatch = boto3.client('cloudwatch')
    response = cloudwatch.put_metric_alarm(
        AlarmName='MonthlyCostAlert',
        MetricName='EstimatedCharges',
        Namespace='AWS/Billing',
        Statistic='Maximum',
        Period=21600,
        EvaluationPeriods=1,
        Threshold=100.0,
        ComparisonOperator='GreaterThanThreshold',
        AlarmActions=['arn:aws:sns:region:account-id:your-topic']
    )
    return response

추가 팁

1. 리소스 태깅: 모든 리소스에 태그를 추가하여 비용 추적
2. 예약 인스턴스: 장기 사용 예상 시 예약 인스턴스 활용
3. 리소스 정리: 사용하지 않는 리소스 정기적으로 삭제
4. 멀티 리전 전략: 비용 효율적인 리전 선택
5. 서버리스 아키텍처: 가능한 경우 서버리스 서비스 활용

결론

AWS 비용을 효과적으로 관리하는 것은 지속 가능한 서비스 운영에 매우 중요합니다. 이 글에서 소개한 5가지 실천법을 통해 비용을 최적화하고, 더 효율적인 백엔드 서비스를 구축할 수 있습니다. 추가적인 질문이나 궁금한 점이 있으시면 댓글로 남겨주세요!