Serverless Architecture
Serverless Architecture(서버리스 아키텍처) 는 개발자가 서버 인프라를 직접 관리하지 않고, 클라우드 서비스 제공자가 컴퓨팅 리소스의 프로비저닝, 확장, 운영을 자동으로 처리하는 현대적 아키텍처 스타일이다. 대표적으로 Function as a Service(FaaS, 함수형 서비스) 와 Backend as a Service(BaaS, 백엔드 서비스) 가 있으며, 이벤트 기반 트리거, 자동 확장, 사용량 기반 과금, 빠른 배포와 높은 확장성을 특징으로 한다. 이로 인해 개발자는 비즈니스 로직 구현에 집중할 수 있다.
핵심 개념
Serverless Architecture(서버리스 아키텍처) 는 서버 인프라 관리 없이, 클라우드 서비스 제공자가 모든 인프라 운영을 책임지고, 개발자는 코드 (주로 함수 단위) 만 작성하여 배포하는 아키텍처 스타일이다.
기본 개념
서버리스 컴퓨팅 (Serverless Computing)
- 클라우드 제공업체가 서버 인프라를 완전히 관리하는 실행 모델
- 개발자는 서버 프로비저닝, 확장, 유지보수에서 해방됨
- " 서버가 없다 " 는 의미가 아니라 " 서버 관리가 없다 " 는 의미
- 종류:
- Function as a Service (FaaS): 이벤트 trigger 로 코드를 실행, 클라우드 제공
- Backend as a Service (BaaS): 인증, DB, 메시징 등 관리형 서비스 활용
이벤트 기반 아키텍처 (Event-Driven Architecture)
- 특정 이벤트나 트리거에 의해 함수가 실행되는 방식
- HTTP 요청, 데이터베이스 변경, 파일 업로드 등이 이벤트 소스가 됨
- 비동기적이고 반응형 시스템 구조
무상태성 (Statelessness)
- 함수 간 상태 정보를 공유하지 않는 설계 원칙
- 각 함수 실행은 독립적이며 이전 실행과 무관
- 외부 저장소를 통해 상태 관리 필요
심화 개념
자동 확장성 (Auto Scaling)
- 요청량에 따라 자동으로 리소스를 확장하거나 축소
- 제로 스케일링 (Zero Scaling) 지원으로 비용 최적화
- 트래픽 급증 시 즉시 대응 가능
사용량 기반 과금 (Pay-per-Use)
- 실제 코드 실행 시간에 대해서만 과금
- 유휴 시간에 대한 비용 부담 없음
- 예측 불가능한 워크로드에 대한 비용 효율성
실무 구현 연관성
아키텍처 설계 측면
- 마이크로서비스 아키텍처와의 자연스러운 결합
- API 우선 설계 (API-First Design) 접근법 활용
- 이벤트 소싱 (Event Sourcing) 패턴 적용
개발 프로세스 측면
- CI/CD 파이프라인과의 긴밀한 통합
- Infrastructure as Code (IaC) 활용 필수
- 모니터링 및 관찰성 (Observability) 강화 필요
운영 관리 측면
- DevOps 문화와의 시너지 효과
- 분산 시스템 관리 복잡성 증가
- 보안 모델의 변화 (제로 트러스트 보안)
배경
서버리스 아키텍처의 등장 배경은 전통적인 서버 관리의 복잡성과 비효율성에서 시작된다. 2014 년 아마존이 AWS Lambda 를 출시하면서 Function as a Service (FaaS) 의 개념이 본격적으로 도입되었다. 이전에는 개발팀이 하드웨어 프로비저닝, 운영체제 관리, 보안 업데이트, 백업 등 인프라 관련 업무에 상당한 시간과 자원을 투입해야 했다.
목적 및 필요성
주요 목적
- 인프라 관리 복잡성 제거를 통한 개발 생산성 향상
- 비용 효율성 증대를 통한 운영비 절감
- 자동 확장성을 통한 안정적인 서비스 제공
- 빠른 출시 시간 (Time-to-Market) 단축
필요성
- 급변하는 비즈니스 요구사항에 대한 민첩한 대응
- 예측 불가능한 트래픽 패턴에 대한 효과적인 대응
- 개발 리소스의 핵심 업무 집중 필요성
- 스타트업과 중소기업의 인프라 비용 부담 해결
주요 기능 및 역할
- 이벤트 처리 (Event Processing)
- HTTP 요청, 데이터베이스 트리거, 파일 업로드 등 다양한 이벤트 처리
- 실시간 데이터 스트림 처리
- 스케줄링된 작업 실행
- API 엔드포인트 제공
- RESTful API 및 GraphQL API 구현
- 마이크로서비스 간 통신 지원
- 써드파티 서비스 통합
- 데이터 처리 및 변환
- 실시간 데이터 분석 및 변환
- 이미지/비디오 처리
- 로그 분석 및 집계
특징
- 동적 확장성 (Dynamic Scalability):
서버리스 함수는 요청량에 따라 자동으로 확장되며, 트래픽이 없을 때는 제로 스케일링을 통해 리소스를 완전히 해제한다. - 이벤트 기반 실행 (Event-Driven Execution):
함수는 특정 이벤트가 발생했을 때만 실행되며, 이벤트가 없으면 비활성 상태를 유지한다. - 단기 실행 (Short-Lived Execution):
대부분의 서버리스 플랫폼은 함수 실행 시간에 제한을 두어 (예: AWS Lambda 15 분) 단기 실행에 최적화되어 있다. - 관리형 인프라 (Managed Infrastructure):
모든 인프라 관리는 클라우드 제공업체가 담당하며, 개발자는 코드 작성에만 집중할 수 있다.
핵심 원칙
- 단일 책임 원칙 (Single Responsibility Principle):
각 함수는 하나의 명확한 기능만을 수행해야 하며, 복잡한 로직은 여러 함수로 분리한다. - 무상태 설계 (Stateless Design):
함수 간에는 상태를 공유하지 않으며, 필요한 상태는 외부 저장소를 통해 관리한다. - 멱등성 (Idempotency):
동일한 입력에 대해 여러 번 실행해도 같은 결과를 보장해야 한다. - 장애 복원력 (Fault Tolerance):
개별 함수의 장애가 전체 시스템에 영향을 주지 않도록 설계한다.
주요 원리
이벤트 기반 처리 원리
graph TD A[이벤트 발생] --> B[이벤트 라우팅] B --> C[함수 트리거] C --> D[리소스 할당] D --> E[함수 실행] E --> F[결과 반환] F --> G[리소스 해제]
이벤트가 발생하면 클라우드 플랫폼이 해당 이벤트를 적절한 함수로 라우팅하고, 필요한 컴퓨팅 리소스를 동적으로 할당하여 함수를 실행한 후 결과를 반환하고 리소스를 해제한다.
자동 확장 원리
graph LR A[트래픽 증가] --> B[새 인스턴스 생성] B --> C[로드 분산] C --> D[병렬 처리] D --> E[트래픽 감소] E --> F[인스턴스 해제]
트래픽이 증가하면 플랫폼이 자동으로 새로운 함수 인스턴스를 생성하여 로드를 분산시키고, 트래픽이 감소하면 불필요한 인스턴스를 해제한다.
작동 원리 및 방식
함수 라이프사이클
sequenceDiagram participant C as Client participant G as API Gateway participant P as Platform participant F as Function participant S as Storage C->>G: HTTP Request G->>P: Route Request P->>P: Cold/Warm Start Check alt Cold Start P->>P: Initialize Runtime P->>F: Load Function Code end P->>F: Execute Function F->>S: Access External Data S->>F: Return Data F->>P: Return Result P->>G: Response G->>C: HTTP Response
클라이언트 요청이 API Gateway 를 통해 들어오면, 플랫폼은 함수가 이미 실행 중인지 (Warm Start) 또는 새로 시작해야 하는지 (Cold Start) 를 확인한다. Cold Start 의 경우 런타임 환경을 초기화하고 함수 코드를 로드한 후 실행한다.
구조 및 아키텍처
서버리스 아키텍처는 여러 핵심 구성 요소들이 유기적으로 결합된 형태이다. 각 요소는 자동 확장, 무상태, 종량 과금이라는 Serverless 핵심 원칙과 연관되며, 이벤트 기반 호출 흐름을 지원한다.
graph TB subgraph "Client Layer" A[Web Client] B[Mobile Client] C[IoT Device] end subgraph "API Layer" D[API Gateway] E[Load Balancer] end subgraph "Function Layer (FaaS)" F[Authentication Function] G[Business Logic Function] H[Data Processing Function] end subgraph "Backend Services (BaaS)" I[Database] J[Object Storage] K[Message Queue] L[Third-party APIs] end subgraph "Event Sources" M[HTTP Events] N[Database Events] O[File Events] P[Schedule Events] end A --> D B --> D C --> D D --> F D --> G D --> H F --> I G --> I G --> J H --> K H --> L M --> F N --> G O --> H P --> H
구성요소
구분 | 구성요소 | 기능 | 역할 | 특징 |
---|---|---|---|---|
필수 | API Gateway | 클라이언트 요청을 함수로 라우팅 | 인증, 권한 부여, 요청/응답 변환 및 트래픽 제어 | HTTP 엔드포인트 제공, REST/GraphQL 지원 |
Function Runtime | 함수 코드 실행 환경 제공 | 코드 실행, 메모리/수명 주기 관리, 로깅 지원 | Node.js, Python, Go 등 다양한 언어 지원 | |
Event Sources | 함수 실행을 유발하는 이벤트 제공 | HTTP 요청, DB 변경, 파일 업로드 등 이벤트 트리거 역할 | 동기/비동기 이벤트 처리 모두 지원 | |
Storage Services | 데이터 저장소 제공 | 함수 실행 중 생성된 데이터의 저장 및 공유 | DB, 객체 스토리지 (S3 등), 서버리스 파일시스템 포함 | |
선택 | Message Queues | 비동기 메시지 처리 및 버퍼링 | 서비스 간 느슨한 결합, 트래픽 완충, 장애 전파 방지 | 확장성, 내결함성 강화 (예: SQS, Pub/Sub) |
Monitoring & Logging | 시스템 성능/오류 모니터링 및 추적 | 애플리케이션 상태 가시성 제공 | 로그 집계, 메트릭 수집, 분산 트레이싱 (X-Ray 등) | |
Security Services | 인증, 인가, 데이터 보호 기능 제공 | 제로 트러스트 기반 보안 정책 적용 및 관리 | IAM, API Key, 암호화, VPC 격리 등 포함 | |
CI/CD Pipeline | 코드 자동 배포 및 테스트 | 개발 - 운영 간 파이프라인 자동화, 생산성 향상 | IaC 연동, Git 기반 워크플로우 적용 가능 |
구현 기법
구현 기법 | 정의 | 주요 구성 요소 | 주요 목적 | 실전 예시 (요약) |
---|---|---|---|---|
Function as a Service (FaaS) | 개별 함수 단위로 배포되고, 트리거에 따라 실행되는 서버리스 실행 모델 | - 함수 코드 - 트리거 - 런타임 환경 - IAM 역할 | 함수 단위 서비스 분리 및 확장성 확보 | AWS Lambda + API Gateway (REST 처리) |
Backend as a Service (BaaS) | 인증, DB, 스토리지 등 백엔드 기능을 API 로 제공하는 관리형 백엔드 서비스 | - 인증 - 데이터베이스 - 스토리지 - 푸시 알림 | 백엔드 인프라 부담 감소, 빠른 개발 가능 | Firebase Auth + Firestore (사용자 인증 및 저장) |
이벤트 기반 아키텍처 | 이벤트에 반응하여 함수나 서비스가 실행되는 비동기적 분산 시스템 패턴 | - 이벤트 프로듀서 - 이벤트 라우터 - 이벤트 컨슈머 | 느슨한 결합 및 고확장성 확보 | S3 업로드 트리거 → Lambda 이미지 처리 |
Serverless 마이크로서비스 | 각 기능을 독립 함수로 분리하여 API 를 통해 통신하는 마이크로서비스 아키텍처 | - 독립 서비스 - API Gateway - 분산 데이터 스토어 | 독립 배포, 기능별 확장, 장애 격리 | Lambda 함수 기반 주문/재고/결제 서비스 분리 구성 |
추가 구현 기법 및 고급 패턴
구현 기법 | 설명 | 실전 적용 고려사항 |
---|---|---|
1. Step Functions / Orchestration | 서버리스 함수들을 정의된 순서대로 흐름 제어 (직렬/병렬/조건 분기 등) | AWS Step Functions, Azure Durable Functions 등 |
2. EventBridge 기반 이벤트 브로커 | 다수의 서비스 간 Pub/Sub 메시징 구조. 느슨한 결합 + 이벤트 라우팅 | 필터링, 리트라이, DLQ 구성이 필수 |
3. API Gateway 기반 Aggregation | 여러 Lambda 함수로 분산된 로직을 하나의 API 로 통합 | API Composition 패턴 + Mapping Template 활용 |
4. GraphQL + Serverless Resolver | 단일 GraphQL Endpoint 에서 리졸버 별 Lambda 연결 | AWS AppSync 또는 Apollo Server + Lambda |
5. Function Chaining with Queues | 함수 실행 결과를 다음 함수에 연결하는 구성. 비동기 파이프라인 구현 | SQS/SNS → Lambda 체인 또는 S3 → EventBridge 활용 |
6. Serverless Cron Jobs | 정기 실행 기반 작업 구성. 배치나 리포트 처리 등에 적합 | CloudWatch Events / EventBridge Schedule 사용 |
7. Serverless Data Pipeline | 데이터 수집 → 변환 → 저장 흐름을 Lambda + Kinesis + Glue 등으로 구성 | 처리 순서 보장, 장애 복구 처리 고려 필요 |
장점
카테고리 | 항목 | 설명 |
---|---|---|
1. 운영 효율성 | 서버 관리 불필요 | 인프라 유지보수, 패치, 확장 등의 작업이 불필요하여 운영 부담을 대폭 감소시킴 |
자동 확장성 | 요청 수 또는 트래픽에 따라 자동으로 함수 인스턴스를 확장/축소 (제로 스케일링 포함) | |
무상태 구조 (Stateless) | 각 함수 실행이 독립적으로 수행되어 수평 확장 및 장애 격리에 유리함 | |
운영 복잡성 감소 | 보안 업데이트, 장애 대응, 백업 등 대부분의 운영 책임을 클라우드 제공자가 담당 | |
내결함성 | 개별 함수 실패가 전체 시스템에 영향을 주지 않으며, 고립성과 자동 복구가 가능함 | |
2. 비용 최적화 | 사용량 기반 과금 | 실제 실행된 시간과 호출 횟수만큼만 과금되며, 유휴 상태일 경우 비용이 발생하지 않음 (Pay-per-execution) |
예측 불가능한 워크로드 대응 | 트래픽 변동이 큰 서비스에 유리하며, 스팟 인스턴스 대비 더 정밀한 비용 제어 가능 | |
3. 개발 생산성 | 빠른 배포/릴리즈 속도 | 인프라 설정 없이 바로 코드 배포 가능하며, CI/CD 파이프라인과 쉽게 통합됨 |
빠른 프로토타이핑 및 MVP 출시 | 아이디어 구현에서 서비스 배포까지의 사이클이 짧아 스타트업이나 실험적 서비스에 적합함 | |
비즈니스 로직 집중 가능 | 서버나 인프라 관련 작업 없이 오직 애플리케이션 기능 구현에만 집중할 수 있어 개발 효율 극대화 | |
다양한 언어 지원 | Python, JavaScript, Go, Java, C# 등 주요 언어를 지원하여 개발자의 기술 선택 폭이 넓음 | |
4. 아키텍처 유연성 | 이벤트 기반 구조 지원 | HTTP 요청, 메시지 큐, 스토리지 변경 등 다양한 이벤트 소스로 유연한 아키텍처 설계가 가능 |
마이크로서비스와 결합 용이 | 단일 책임 함수 구조와 잘 맞으며, 도메인 분리와 확장 가능한 분산 시스템 설계에 적합함 |
단점과 문제점 그리고 해결방안
단점
카테고리 | 항목 | 설명 | 해결책 또는 우회 전략 |
---|---|---|---|
성능/지연 | 콜드 스타트 지연 | 비활성 상태의 함수가 새로 인스턴스될 때 초기화 지연 발생 | Provisioned Concurrency, 함수 워밍업, 경량화 런타임 사용 |
실행 제한 | 시간 및 메모리 제약 | 플랫폼별로 함수 실행 시간 (예: 15 분) 및 메모리 제한 존재 | 작업 분할 (예: AWS Step Functions), 외부 워커 사용 |
플랫폼 종속성 | 벤더 락인 | 특정 클라우드 서비스 (API, 구성 방식 등) 에 종속 | 멀티클라우드 전략, OpenFaaS, Serverless Framework, 추상화 계층 도입 |
운영 복잡도 | 디버깅 및 로깅 어려움 | 분산 함수 호출 간의 흐름 추적이 어려움 | OpenTelemetry, CloudWatch, DataDog 등 통합 트레이싱 도구 도입 |
상태 관리 | 무상태로 인한 제약 | 서버리스 함수는 기본적으로 상태를 저장하지 않기 때문에 외부 저장소 필요 | Redis, DynamoDB, 외부 세션 저장소, 상태 저장 마이크로서비스 도입 |
네트워크 구조 | 네트워크 지연 | 다수 함수 간 호출 또는 외부 서비스 접근 시 네트워크 오버헤드 발생 | 함수 클러스터링, 데이터/함수 지역성 최적화, 캐싱 전략 |
테스트/개발 환경 | 로컬 환경 한계 | 실제 환경과 로컬 테스트 환경의 차이로 인해 사전 검증 어려움 | localstack , sam-cli , serverless-offline 등을 활용한 환경 구성 |
문제점
카테고리 | 항목 | 원인 | 영향 | 탐지 및 진단 도구 | 예방 방법 | 해결 방법 및 기법 |
---|---|---|---|---|---|---|
성능 | 메모리 누수 | GC 미작동, 파일 핸들/DB 연결 미종료, 정적 객체 과다 유지 등 | 성능 저하, 비용 증가, 장애 가능성 | 메모리 프로파일러, CloudWatch, NewRelic | 정적 분석 도구, 연결 해제 코드 삽입, 정기 점검 | 리소스 풀링, 연결 해제 보장 코드, context manager 사용 |
보안 | 과도한 권한 부여 | IAM 정책 부재, 최소 권한 원칙 미준수 | 민감 정보 노출, 무단 접근 가능 | AWS IAM Access Analyzer, CloudTrail 등 | 최소 권한 정책, 정책 자동화 도구 사용 | 역할 기반 접근 제어, 암호화 및 키 관리 강화 |
비용 | 함수 호출 폭증 | 무한 루프, 트리거 오류, DDoS, 무제한 반복 호출 등 | 비용 폭증, 서비스 중단 | 비용 알림, Cloud Cost Explorer | 리소스 제한 설정, 실행 횟수 제한, 코드 품질 점검 | 레이트 리미팅, 서킷 브레이커, 쿼터 설정 |
데이터 정합성 | 상태 불일치 및 경쟁 조건 | 다중 함수 간 상태 공유 미흡, 트랜잭션 부재, 멱등성 미보장 | 데이터 정합성 오류, 비즈니스 로직 오작동 | 로깅, 이벤트 로그 분석, 정합성 검증 로직 | 이벤트 소싱, SAGA/보상 트랜잭션 패턴 적용 | 멱등 처리, 락 기반 보장, 큐 기반 순차 처리 |
가용성 | API 호출 실패 | 외부 시스템 실패, 의존 함수 장애, 리소스 초과 | 시스템 일부 기능 불가 | 상태 코드 로깅, Retry/Error log 분석 | 재시도 로직, 대체 경로 (fallback), 장애 격리 | 리트라이 + 지수 백오프, Dead Letter Queue |
배포 리스크 | 함수 버전 간 충돌 | 트리거 및 이벤트 구조 변경, 의존 버전 불일치 | 호출 실패 또는 예외 발생 | Canary 배포, 모니터링 + 롤백 조건 설정 | 버전 고정, 트리거 테스트 자동화, A/B 테스트 적용 | 점진적 배포, 블루그린 배포 전략 적용 |
도전 과제
카테고리 | 도전 과제 | 원인 | 영향 | 대응 전략 |
---|---|---|---|---|
성능 최적화 | 콜드 스타트 지연 | 초기 함수 로딩 지연, VPC 연결, 대용량 라이브러리 | 사용자 응답 지연, SLA 위반 가능성 | Provisioned Concurrency, 함수 워밍업, 런타임 최적화 |
네트워크 오버헤드 | 클라우드 간 통신, 외부 API 호출 시 지연 | 처리 시간 증가, 비용 상승 | CDN, 지역 분산 배포, Edge 서버리스 (예: Cloudflare Workers) | |
관찰성 및 운영 | 관측성 부족 | 짧은 함수 실행 시간, 이벤트 기반 호출로 트랜잭션 흐름 추적 어려움 | 장애 원인 진단 어려움, 운영 효율 저하 | OpenTelemetry, X-Ray, 통합 로깅 및 메트릭 수집 |
보안 및 규정 준수 | 새로운 보안 위협 대응 필요 (예: Denial of Wallet) | 비용 기반 공격, 멀티 테넌시 환경의 경계 불명확성 | 비용 손실, 인증/인가 취약점 | 제로 트러스트 모델, IAM 최소 권한, 요청 제한 정책 |
컴플라이언스 및 감사 대응 | 분산 환경에서의 감사 추적 어려움 | 법적/보안 규제 위반 위험 | 암호화, 감사 로그 중앙화, 정책 기반 접근 제어 | |
플랫폼 전략 | 벤더 종속성 (Vendor Lock-in) | 특정 CSP 의 독자적 서비스에 의존 | 이식성 제한, 장기 비용 증가 | 멀티 클라우드 CDK, OpenFaaS 등 추상화 도구 도입 |
복잡한 트랜잭션/워크플로우 처리 | 함수 간 상태 공유 불가, 복잡한 호출 체계 | 상태 비일관성, 복잡한 예외 처리 | 상태 머신 (Step Functions), 이벤트 소싱 기반 설계 | |
통합 및 마이그레이션 | 레거시 시스템 통합 | 이질적인 시스템 아키텍처, 데이터 이전 어려움 | 통합 장애, 운영 이중화 비용 | API Gateway + 래퍼 패턴, 점진적 마이그레이션 전략 |
지능형 제어 | 예측 기반 자동화 부족 (콜드 스타트 등) | 트래픽 패턴 변동성, 통계 기반 스케일링의 한계 | 오버프로비저닝 또는 언더프로비저닝 | 트랜스포머 기반 예측 모델 도입, ML 기반 워밍업 제어 |
분류 기준별 유형
분류 기준 | 유형 | 설명 |
---|---|---|
실행 모델 | FaaS (Function as a Service) | 함수 단위로 실행되는 서버리스 모델 (예: AWS Lambda, Azure Functions) |
BaaS (Backend as a Service) | 인증, DB, 스토리지 등 백엔드 기능을 API 기반으로 제공 (예: Firebase) | |
트리거 방식 | 동기식 호출 (Synchronous) | HTTP 요청과 같이 즉시 응답이 필요한 처리 방식 |
비동기식 호출 (Asynchronous) | 이벤트, 큐, 스토리지 트리거 등 지연 응답이 허용되는 처리 방식 | |
구성 단위 | 단일 함수 기반 | 독립적인 단일 함수로 구성되는 서버리스 구조 |
마이크로서비스 함수 조합 | 여러 함수로 구성된 서버리스 마이크로서비스 패턴 (컴포지션 기반 설계) | |
실행 환경 | 퍼블릭 클라우드 기반 | AWS, Azure, GCP 등의 CSP 환경에서 실행 |
프라이빗/온프레미스 환경 | 자체 인프라 기반의 서버리스 플랫폼 (예: OpenFaaS, Knative) | |
엣지 서버리스 (Edge Serverless) | 사용자 가까운 엣지에서 실행되는 분산 함수 (예: Cloudflare Workers, Deno Deploy) | |
배포 방식 | 배치 기반 배포 | 수동 배포 또는 간단한 스크립트를 통한 일괄 배포 |
CI/CD 자동화 기반 | GitOps, 파이프라인 기반의 지속적 배포 (예: GitHub Actions + SAM) | |
언어 런타임 | 인터프리터 기반 | Python, JavaScript, Ruby 등 빠른 시작과 유연성 중심 |
컴파일 기반 | Java, Go,.NET 등 고성능 및 정적 타입 기반 환경 |
실무 사용 예시
카테고리 | 사용 사례 | 목적 | 주요 구성 요소 | 기대 효과 |
---|---|---|---|---|
데이터 처리 | 이미지 리사이징 자동화 | 이미지 업로드 시 실시간 트랜스폼 | S3 + Lambda + CloudFront | 처리 자동화, 서버 운영 비용 절감, 확장성 확보 |
실시간 ETL 파이프라인 | 데이터 정제 및 적재 | Kinesis + Lambda + DynamoDB | 실시간 처리, 스케일 대응, ETL 자동화 | |
IoT 센서 데이터 처리 | 고빈도 센서 데이터의 집계 및 저장 | IoT Core + Lambda + Timestream | 대규모 이벤트 처리, 유지 비용 최소화 | |
이벤트 기반 | 실시간 알림 시스템 | 사용자/시스템 이벤트 발생 시 알림 전송 | SNS/SQS + Lambda + Firebase/Slack/Webhook | 빠른 이벤트 반응, 사용자 경험 향상 |
웹훅 이벤트 처리 (예: Stripe, GitHub) | 외부 시스템 이벤트 수신 후 내부 처리 연동 | API Gateway + Lambda + 외부 서비스 (Webhook) | 자동 트리거, 워크플로우 통합 | |
AI / ML | 머신러닝 모델 인퍼런스 | 예측, 분류 등 AI 서비스 실행 | S3 + Lambda + SageMaker Endpoint or TensorFlow.js | 비용 절감, 온디맨드 AI 실행 |
상품 추천 / 이미지 분류 | 사용자 맞춤형 추천 또는 자동 라벨링 | Lambda + Pretrained Model + DynamoDB | 빠른 응답 시간, 서버 관리 최소화 | |
챗봇/자동화 | 챗봇 백엔드 | 사용자 질의 처리, 응답 자동화 | API Gateway + Lambda + NLP API (e.g., Lex, GPT) | 무중단 서비스, 손쉬운 유지보수 |
모바일 백엔드 | 모바일 앱 API 서버 | 경량 API 백엔드, 서버 없는 아키텍처 구현 | API Gateway + Lambda + RDS/DynamoDB | 신속한 개발, 자동 확장, 비용 최적화 |
전자상거래 | 쇼핑몰 백엔드 처리 (상품, 채팅, 세션) | 고빈도 트래픽 대응, 빠른 CRUD | Lambda + DynamoDB | 빠른 응답 속도, 트래픽 급증 대응 용이 |
활용 사례
사례 1: 넷플릭스의 동영상 인코딩 시스템
넷플릭스는 서버리스 아키텍처를 활용하여 대용량 동영상 콘텐츠의 인코딩과 배포 시스템을 구축했다.
시스템 구성:
graph TB A[콘텐츠 업로드] --> B[S3 저장소] B --> C[Lambda 트리거] C --> D[동영상 분할] D --> E[병렬 인코딩] E --> F[품질별 변환] F --> G[CDN 배포] G --> H[사용자 스트리밍]
워크플로우:
- 콘텐츠 제작팀이 원본 동영상을 S3 에 업로드
- S3 이벤트가 Lambda 함수를 트리거
- Lambda 함수가 동영상을 5 분 단위로 분할
- 각 세그먼트를 60 개의 병렬 스트림으로 인코딩
- 다양한 해상도와 품질로 변환
- CloudFront CDN 을 통해 전 세계 배포
서버리스 아키텍처의 역할:
- 자동 확장: 업로드 volume 에 따라 자동으로 처리 능력 조절
- 비용 최적화: 실제 인코딩 시간에 대해서만 과금
- 병렬 처리: 동시에 수백 개의 인코딩 작업 실행
- 내결함성: 개별 세그먼트 처리 실패가 전체에 미치는 영향 최소화
서버리스 적용 전후 차이점:
- 적용 전 (전통적 서버 기반):
- 24/7 실행되는 인코딩 서버 클러스터 필요
- 피크 시간 대비 과도한 리소스 프로비저닝
- 서버 관리, 패치, 모니터링 등 운영 부담
- 장애 시 전체 시스템 영향
- 적용 후 (서버리스 기반):
- 필요 시에만 리소스 사용
- 자동 확장으로 처리량 최적화
- 인프라 관리 부담 제거
- 개별 함수 장애가 전체에 미치는 영향 최소화
사례 2: 이미지 처리 파이프라인
시스템 구성: S3(스토리지), Lambda(함수), DynamoDB(메타데이터 저장)
Workflow: 이미지 업로드 → S3 이벤트 → Lambda 실행 → 이미지 변환/저장 → DynamoDB 기록
다이어그램:
sequenceDiagram participant User participant S3 participant Lambda participant DynamoDB User->>S3: 이미지 업로드 S3->>Lambda: 이벤트 트리거 Lambda->>S3: 이미지 처리/저장 Lambda->>DynamoDB: 메타데이터 기록
실무에서 효과적으로 적용하기 위한 고려사항 및 주의할 점
카테고리 | 고려사항 | 설명 | 권장사항 |
---|---|---|---|
아키텍처 설계 | 함수 크기 최적화 | 큰 함수는 콜드 스타트 지연, 배포 및 유지보수 복잡도 증가 | 단일 책임 원칙 (SRP), 함수 분리, 경량 라이브러리 사용 |
상태 관리 분리 | 서버리스 함수는 기본적으로 무상태 (stateless) 환경 | 외부 DB/스토리지 활용 (S3, RDS 등) | |
함수 호출 구조 | 과도한 함수 간 호출은 “Lambda Pinball” 안티패턴을 유발 | Step Functions 등 오케스트레이터 활용 | |
성능 관리 | 콜드 스타트 대응 | 초기 요청 시 함수 초기화 지연 (특히 VPC 연결, 대용량 라이브러리 사용 시) | Provisioned Concurrency, Lambda Layer |
메모리 할당 최적화 | 메모리는 CPU 성능과 비용에 직접 영향 | 벤치마크 기반 최적 메모리 설정 (128MB~3GB 조정) | |
보안 관리 | IAM 권한 최소화 | 과도한 권한 설정은 보안 취약점 초래 가능 | Least Privilege 원칙, 함수 단위 정책 설정 |
외부 호출 제어 | 트리거 오용, 인가되지 않은 API 접근 등 보안 리스크 존재 | API Gateway + WAF 설정, 네트워크 격리 (VPC/Subnet) | |
모니터링 및 운영 | 로그 및 트레이싱 통합 | 서버리스 환경은 분산되어 있어 디버깅 및 모니터링 어려움 | CloudWatch, X-Ray, OpenTelemetry 연동 |
실행 흐름 가시성 확보 | 이벤트 기반 비동기 호출로 인해 호출 경로 추적 어려움 | 트랜잭션 ID 기반 로깅, 구조화된 로그 설계 | |
비용 관리 | 호출 및 리소스 비용 관리 | 짧은 실행이라도 고빈도 호출 또는 외부 API 사용으로 비용 급증 가능 | 비용 알림 설정, 호출 패턴 분석, 리소스 프로파일링 |
개발 프로세스 | 로컬 개발 및 테스트 환경 구성 | 클라우드에서만 실행 가능한 특성 때문에 개발자 생산성 저하 가능 | SAM CLI, LocalStack, Serverless Framework 활용 |
플랫폼 전략 | 벤더 종속성 관리 | 특정 CSP 의 서비스에 지나치게 의존하면 이식성 저하 | 추상화 계층 도입, 멀티 클라우드 CDK/Infra 도구 사용 |
최적화하기 위한 고려사항 및 주의할 점
카테고리 | 최적화 요소 | 설명 | 권장 전략 |
---|---|---|---|
1. 성능 최적화 | 콜드 스타트 최소화 | 함수가 초기화되는 시점의 지연 최소화 | 프로비저닝된 동시성 설정, 워밍업 트리거 사용, 공통 패키지 Layer 분리 |
함수 실행 속도 향상 | 실행 로직의 지연 최소화 | 경량화된 코드 구성, 단일 책임 함수, 효율적인 알고리즘, 비동기/배치 처리 적용 | |
초기화 외부화 | DB/SDK 초기화를 핸들러 외부로 분리하여 반복 초기화 방지 | 핸들러 외부에 클라이언트 생성 (boto3 , pg , etc.) | |
2. 코드 최적화 | 패키지 경량화 | 배포 크기 축소를 통한 로딩 시간 단축 | 공통 라이브러리를 Layer 로 분리, 최소 의존성만 포함한 배포 패키지 구성 |
언어 및 런타임 선택 | 실행 속도와 Cold Start 성능에 영향을 주는 실행 환경 | Node.js, Go, Python 등 최적 언어 선택, 런타임 버전 최신 유지 | |
3. 리소스 최적화 | 메모리/타임아웃 설정 튜닝 | 과도하거나 부족한 설정은 비용 또는 오류 발생 요인이 됨 | CloudWatch 기반 리소스 프로파일링, 점진적 조정 |
사용량 기반 자원 관리 | 리소스를 효율적으로 사용하지 않으면 비용만 증가 | 리소스 자동 할당 기반의 Autoscaling, 예약/스케줄링 처리 | |
4. 네트워크 최적화 | 외부 호출 최소화 | 외부 API 또는 DB 호출 지연이 전체 성능 저하를 유발 | 캐싱 계층 도입, 연결 풀링, 비동기 큐 또는 배치 처리 활용 |
5. 운영 자동화 | 배포 자동화 | 환경 불일치, 수동 오류 방지 | IaC 도구 (Terraform, CDK) 기반 정의 + CI/CD 파이프라인 연동 |
테스트 자동화 | 서버리스 특성상 로컬 환경과의 차이 존재 → 신뢰도 있는 테스트 필요 | 로컬 테스트 프레임워크 활용 (SAM , LocalStack , pytest , jest 등) | |
성능 분석 및 벤치마크 | 최적화 지표 기반 개선 | CloudWatch, X-Ray, vHive, REAP, LibProf 등을 통한 지표 분석 및 cold/warm 비교 | |
6. 비용 최적화 | 종량 과금 모델 이해 | GB- 초 + 호출 횟수 기반 과금 구조 | 짧은 실행 + 적정 메모리 조합 설계, 호출 횟수 최소화, 불필요한 트리거 제거 |
FinOps 전략 적용 | 사용량 시각화 및 예산 예측 | 비용 대시보드 구성, 경고 임계값 설정, 리소스 태깅 기반 비용 분석 |
주제와 관련하여 주목할 내용
카테고리 | 주제 | 항목 | 설명 |
---|---|---|---|
1. 아키텍처 | 서버리스 구조 | FaaS, BaaS | 서버 인프라 관리 없이 함수 단위 또는 관리형 백엔드로 구성된 클라우드 네이티브 구조 |
이벤트 기반 설계 | Event-driven Architecture | 트리거 기반 구조로 유연한 분산 시스템 구성 가능 | |
이벤트 스토밍 설계 기법 | Domain Event Modeling | 도메인 중심의 이벤트 흐름 기반 설계 방식, 마이크로서비스와의 결합에 적합 | |
함수 체인 방지 패턴 | Orchestrator 활용, 함수 분리 전략 | 과도한 함수 호출 연결 (Pinball) 방지로 성능 및 유지보수성 확보 | |
2. 운영/성능 최적화 | 자동 확장 | 이벤트 기반 오토스케일링 | 요청 수에 따라 자동으로 함수 인스턴스가 확장/축소되어 자원 낭비를 방지함 |
콜드 스타트 최적화 | 패키지 크기, 런타임, warm-up 전략 | 초기화 지연 (Cold Start) 을 줄이기 위한 구조적/코드적 최적화 방법 | |
엣지 서버리스 | Edge Functions (Cloudflare Workers 등) | 사용자 위치와 가까운 Edge 환경에서 실행하여 레이턴시 감소 | |
3. 관찰성 및 운영 도구 | 분산 추적 및 모니터링 | X-Ray, OpenTelemetry, Jaeger | 다중 함수 호출 흐름을 시각화하고 문제 지점을 추적할 수 있는 관찰성 (Observability) 도구 적용 |
FinOps 운영 전략 | 비용 시각화, 예산 경고, 활용량 기반 분석 | 종량 과금 환경에서 비용을 효과적으로 추적 및 예측하여 예산 초과 방지 | |
4. 보안 | 최소 권한 및 IAM 관리 | RBAC, IAM 정책 분리 | 최소 권한 원칙에 따라 자원별 접근 권한을 분리하여 보안 사고 방지 |
입력 검증 및 Webhook 보안 | 시그니처 검증, 입력 스키마 검증 | 외부 트리거 진입점에서의 취약점 방지 및 공격면 최소화 | |
제로 트러스트 모델 | 클라우드 함수 단위 인증/권한 확인 | 모든 요청에 대해 인증/검증을 수행하는 세밀한 서버리스 보안 모델 적용 | |
5. 멀티 클라우드/이식성 | 벤더 락인 완화 | 추상화 레이어, 멀티 클라우드 프레임워크 사용 | 특정 클라우드에 종속되지 않도록 설계하여 이식성과 유연성 확보 |
6. AI/신기술 융합 | 서버리스 AI 통합 | GenAI + Lambda 등 결합 | LLM 이나 AI 모델을 서버리스 구조로 통합하여 지능형 애플리케이션 구성 |
반드시 학습해야할 내용
카테고리 | 주제 | 항목 | 설명 |
---|---|---|---|
1. 클라우드 기초 이해 | 클라우드 플랫폼 이해 | AWS / Azure / GCP | 각 클라우드의 서버리스 서비스 (FaaS, BaaS 등) 구조 및 비교 |
2. 서버리스 핵심 개념 | 서버리스 아키텍처의 구성 요소 | FaaS, BaaS | 함수 단위 실행 / 인증, DB, 메시징 등 관리형 백엔드 서비스 활용법 |
자동 확장 원리 | 오토스케일링 | 트래픽 변화에 따라 자동으로 리소스를 확장/축소하는 구조 및 원리 | |
콜드 스타트 대응 | Cold Start / Provisioned Concurrency | 초기 실행 지연 최소화 전략: 사전 프로비저닝, 워밍업 트릭 등 | |
3. 프로그래밍 언어/런타임 | 서버리스 친화 언어 | Python / JavaScript | 서버리스 실행에 널리 사용되는 언어 숙련도 확보 |
4. 이벤트 트리거 구성 | 트리거/이벤트 유형 | HTTP / 메시지 큐 / 스토리지 이벤트 | 다양한 이벤트 소스를 통한 Lambda 등 함수 실행 트리거 설계 |
5. 아키텍처 설계 및 패턴 | 마이크로서비스와의 결합 | 분산 시스템, 마이크로서비스 통합 | 서버리스 기반으로 MSA 구성 시 고려사항 및 통신 전략 |
이벤트 기반 아키텍처 | Event Sourcing / CQRS | 상태 변경을 이벤트로 캡처 + 읽기/쓰기 모델 분리 | |
서버리스 안티패턴 | Lambda‑Pinball, Grain-of-Sand | 과도한 분할 또는 연결 복잡성 증가로 인한 설계 실패 사례 | |
6. 배포 및 운영 자동화 | IaC 및 CD 도구 활용 | Serverless Framework / AWS CDK / Terraform | 선언형 인프라 및 지속적 배포 구현 방식 |
멀티 클라우드 대응 | Serverless Framework / Knative | 벤더 종속성 감소 및 포팅 전략 강화 | |
7. 모니터링 및 관찰성 | 로깅/분산 추적 | AWS X-Ray / OpenTelemetry | 함수 호출 흐름, 오류 발생 지점, 병목 등을 시각화 및 추적 |
8. 보안 및 정책 관리 | 권한 관리 | IAM / 최소 권한 원칙 | 자원 접근 제어를 위한 역할 기반 권한 및 보안 정책 설계 |
입력 보안 및 웹훅 보호 | Webhook 서명 검증 / 입력 검증 | 외부 호출에 대한 유효성 검증 및 공격면 축소 전략 | |
서버리스 특화 보안 위협 | Denial-of-Wallet / 코드 취약점 | 과금 유발 공격, 패키지 종속성 등 서버리스 환경 고유 보안 리스크 대응 | |
9. 비용 및 최적화 | 종량 과금 모델 이해 | GB- 초, 요청 수 기반 청구 | 처리 시간과 메모리 크기 기반 과금 구조 이해 및 예산 계획 |
최적화 전략 | 함수 패키지 크기, 의존성 관리 | 콜드 스타트와 비용을 줄이기 위한 성능/크기 최적화 | |
10. 상태/세션 처리 | 상태 저장 문제 | Stateless 원칙, 외부 상태 관리 | 함수 상태는 외부 저장소로 위임하며, DB 또는 캐시를 통한 세션 유지 |
용어 정리
카테고리 | 용어 | 설명 |
---|---|---|
컴퓨팅 모델 | FaaS (Function as a Service) | 이벤트 기반 함수 단위 실행 모델. 서버리스 아키텍처의 핵심 구성 요소 |
BaaS (Backend as a Service) | 인증, DB, 스토리지, 메시징 등 백엔드 기능을 API 형태로 제공하는 서비스 | |
실행 동작 및 성능 | Cold Start | 함수가 비활성 상태에서 처음 호출될 때 초기화로 인해 발생하는 지연 |
Warm Start | 이미 초기화된 인스턴스에서 빠르게 함수가 실행되는 상태 | |
Provisioned Concurrency | 항상 일정 수의 함수 인스턴스를 미리 준비하여 콜드 스타트 지연을 제거 | |
아키텍처 패턴 | Stateless | 함수는 상태를 저장하지 않으며, 요청 간 상태는 외부 저장소에 보관 |
Lambda-Pinball | 함수 간 과도한 호출로 인한 체인 복잡성과 지연이 발생하는 서버리스 아키텍처 안티패턴 | |
Event Sourcing | 상태 변경을 이벤트 시퀀스로 저장하여 시스템 상태를 재구성하는 이벤트 중심 아키텍처 패턴 | |
CQRS | Command 와 Query 를 분리하여 성능, 확장성, 복잡도 관리를 향상시키는 아키텍처 패턴 | |
Saga Pattern | 분산 트랜잭션을 여러 로컬 트랜잭션으로 나누어 보상 작업을 포함해 처리하는 장기 트랜잭션 관리 패턴 | |
트리거 및 연동 | Event Source | 함수 실행을 유발하는 외부 이벤트 소스 (예: HTTP 요청, 메시지 큐, 스토리지 변경 등) |
인프라 관리 도구 | Infrastructure as Code (IaC) | 인프라 자원을 코드로 선언 및 자동화하여 운영 일관성과 버전 관리를 가능하게 하는 방식 |
모니터링 및 운영 | Distributed Tracing | 여러 마이크로서비스 간의 요청 흐름을 추적하여 병목 지점 및 성능 병해 분석에 활용 |
Observability | 메트릭, 로그, 트레이스를 통해 시스템의 상태를 외부에서 명확하게 이해할 수 있는 능력 | |
안정성 패턴 | Circuit Breaker | 연쇄 장애를 막기 위해 일정 실패 조건 시 요청 차단 후 복구를 시도하는 패턴 |
보안 원칙 | IAM (Identity and Access Management) | 클라우드 자원에 대한 인증, 권한 제어, 역할 기반 접근 제어를 담당하는 핵심 서비스 |
Zero Trust | 네트워크 내부/외부를 불문하고 모든 요청에 대해 지속적으로 검증을 수행하는 보안 아키텍처 모델 | |
Least Privilege Principle | 사용자나 서비스에 최소한의 권한만 부여하여 보안을 강화하는 정책 |
참고 및 출처
- AWS Lambda 공식 문서
- Azure Functions 개요
- Google Cloud Functions 문서
- Martin Fowler의 Serverless 아키텍처 분석
- 서버리스 아키텍처 2024년 트렌드 분석
- Datadog 서버리스 모니터링 가이드
- GeeksforGeeks: Serverless Computing의 미래 전망