🏢 Stripe 기술 스택 분석

개발자를 위한 결제 인프라를 구축하며 금융의 미래를 만드는 Stripe의 기술 스택을 심층 분석합니다.
"Increase the GDP of the internet" - 인터넷 경제의 기반을 만드는 기술

📊 회사 개요

서비스 규모

• 연간 결제 처리량: $817B+ (2023)
• 비즈니스 고객: 수백만 개
• 서비스 국가: 45+ 개국
• API 요청: 연간 5,000억+ 건
• 가용성: 99.999% (Five nines)

엔지니어링 조직

• 엔지니어: 2,500명+ (전체 직원 8,000+)
• 문화: "Move fast with stable infrastructure"
• 원격 우선: 전 세계 분산 팀
• 기술 철학: API 우선, 개발자 경험 중심

기술적 도전과제

1. 금융 규제 준수: 각국 규제 대응
2. 보안: 민감한 금융 데이터 보호
3. 신뢰성: 다운타임 제로 목표
4. 확장성: 폭발적 성장 대응

🏗️ 아키텍처 Overview

시스템 다이어그램

┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ API │────►│ Gateway │────►│ Payment │ │ Clients │ │ (Kong) │ │ Engine │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │ │ ┌─────▼─────┐ ┌─────▼─────┐ │ │Rate Limiter│ │Risk Engine │ │ │ (Redis) │ │ (ML) │ │ └───────────┘ └───────────┘ │ │ │ └────────────────────┤ │ ┌─────▼─────┐ ┌─────▼─────┐ │ Ledger DB │ │ Analytics │ │(PostgreSQL)│ │ (Presto) │ └───────────┘ └───────────┘ 

핵심 설계 원칙

1. API-First: 모든 기능은 API로
2. Idempotency: 멱등성 보장
3. Eventual Consistency: 최종 일관성
4. Defense in Depth: 다층 보안
5. Observability: 완전한 가시성

기술 진화

• 2010-2012: Ruby 모놀리스
• 2013-2015: 서비스 분리 시작
• 2016-2018: Go 도입, 마이크로서비스
• 2019-2021: 글로벌 확장, ML 플랫폼
• 2022-현재: 임베디드 금융, 암호화폐

🧩 기술 스택 상세

Backend 기술

결제 처리 엔진

# Stripe의 Ruby 기반 결제 처리 module Stripe class PaymentProcessor include Retriable include Idempotent def process_payment(payment_intent) # 멱등성 키 확인 idempotency_key = payment_intent.idempotency_key if result = IdempotencyStore.get(idempotency_key) return result end # 트랜잭션 시작 transaction do # 1. 유효성 검증 validate_payment_intent(payment_intent) # 2. 위험 평가 risk_score = RiskEngine.evaluate(payment_intent) if risk_score.high_risk? return handle_high_risk_payment(payment_intent, risk_score) end # 3. 결제 수단 확인 payment_method = PaymentMethod.find(payment_intent.payment_method_id) verify_payment_method(payment_method) # 4. 잔액 확인 및 보류 amount = payment_intent.amount currency = payment_intent.currency hold = create_balance_hold( payment_method: payment_method, amount: amount, currency: currency ) # 5. 네트워크 요청 (카드사, 은행 등) network_response = process_with_network( payment_method: payment_method, amount: amount, metadata: payment_intent.metadata ) # 6. 결과 처리 case network_response.status when :approved complete_payment(payment_intent, hold, network_response) when :declined release_hold(hold) handle_decline(payment_intent, network_response) when :requires_action handle_3ds_authentication(payment_intent, network_response) else raise UnexpectedNetworkResponse, network_response end end rescue => e # 에러 처리 및 복구 handle_payment_error(payment_intent, e) ensure # 멱등성 결과 저장 IdempotencyStore.set(idempotency_key, result, expires_in: 24.hours) end private def complete_payment(payment_intent, hold, network_response) # 원장에 기록 ledger_entry = Ledger.record( type: :payment, debit_account: payment_intent.customer_account, credit_account: payment_intent.merchant_account, amount: payment_intent.amount, currency: payment_intent.currency, reference: network_response.authorization_code ) # 보류 해제 및 실제 이체 transfer = Transfer.create!( from_hold: hold, to_account: payment_intent.merchant_account, ledger_entry: ledger_entry ) # 이벤트 발행 Events.publish( 'payment.succeeded', payment_intent: payment_intent, transfer: transfer, timestamp: Time.now ) # Webhook 트리거 WebhookDispatcher.dispatch_async( event_type: 'payment_intent.succeeded', account: payment_intent.merchant_account, data: payment_intent.to_webhook_payload ) payment_intent.update!(status: :succeeded) end end end 

Go 기반 고성능 서비스

// Stripe의 Go 기반 리스크 엔진 package risk import ( "context" "time" "github.com/stripe/stripe-go/v72" "github.com/stripe/veneur/trace" ) type RiskEngine struct { mlModels map[string]MLModel ruleEngine *RuleEngine dataStore DataStore cache Cache } type RiskAssessment struct { Score float64 Reasons []string Action RiskAction RequiredActions []string } func (re *RiskEngine) Evaluate(ctx context.Context, payment *Payment) (*RiskAssessment, error) { span := trace.StartSpan("risk.evaluate") defer span.End() // 동시에 여러 신호 수집 signals := make(chan Signal, 10) errors := make(chan error, 10) go re.collectDeviceSignals(ctx, payment, signals, errors) go re.collectBehaviorSignals(ctx, payment, signals, errors) go re.collectNetworkSignals(ctx, payment, signals, errors) go re.collectHistoricalSignals(ctx, payment, signals, errors) // 타임아웃 설정 timeout := time.After(100 * time.Millisecond) collectedSignals := []Signal{} for i := 0; i < 4; i++ { select { case signal := <-signals: collectedSignals = append(collectedSignals, signal) case err := <-errors: // 에러는 로그하지만 계속 진행 span.LogFields(trace.Error(err)) case <-timeout: // 타임아웃 시 수집된 것만으로 진행 break } } // ML 모델 예측 mlScore := re.runMLModels(ctx, payment, collectedSignals) // 규칙 엔진 실행 ruleResults := re.ruleEngine.Evaluate(payment, collectedSignals) // 최종 점수 계산 assessment := re.calculateFinalAssessment(mlScore, ruleResults) // 결과 저장 (비동기) go re.storeAssessment(ctx, payment.ID, assessment) return assessment, nil } func (re *RiskEngine) runMLModels(ctx context.Context, payment *Payment, signals []Signal) float64 { features := re.extractFeatures(payment, signals) // 앙상블 모델 실행 predictions := make([]float64, 0, len(re.mlModels)) for name, model := range re.mlModels { pred, err := model.Predict(features) if err != nil { continue } predictions = append(predictions, pred) } // 가중 평균 return re.weightedAverage(predictions) } // 실시간 사기 탐지 규칙 func (re *RiskEngine) detectVelocityAbuse(customerID string) bool { // 슬라이딩 윈도우로 속도 제한 체크 key := fmt.Sprintf("velocity:%s", customerID) windows := []struct { duration time.Duration limit int }{ {time.Minute, 5}, // 분당 5건 {time.Hour, 20}, // 시간당 20건 {24 * time.Hour, 100}, // 일당 100건 } for _, window := range windows { count, err := re.cache.IncrementWindow(key, window.duration) if err != nil { return true // 에러 시 안전하게 차단 } if count > window.limit { return true } } return false } 

원장 시스템 (Double-Entry Bookkeeping)

// Stripe의 Java 기반 원장 시스템 @Service @Transactional public class LedgerService { private final LedgerRepository ledgerRepository; private final AccountRepository accountRepository; private final AuditLogger auditLogger; public LedgerEntry recordTransaction(TransactionRequest request) { // 원자적 트랜잭션 보장 return transactionTemplate.execute(status -> { // 1. 계정 잠금 (데드락 방지를 위해 ID 순서대로) List<Account> accounts = lockAccountsInOrder( request.getDebitAccountId(), request.getCreditAccountId() ); Account debitAccount = accounts.get(0); Account creditAccount = accounts.get(1); // 2. 잔액 검증 if (!debitAccount.hasSufficientBalance(request.getAmount())) { throw new InsufficientFundsException( debitAccount.getId(), request.getAmount() ); } // 3. 원장 항목 생성 (불변) LedgerEntry entry = LedgerEntry.builder() .id(UUID.randomUUID()) .transactionId(request.getTransactionId()) .debitAccountId(debitAccount.getId()) .creditAccountId(creditAccount.getId()) .amount(request.getAmount()) .currency(request.getCurrency()) .description(request.getDescription()) .metadata(request.getMetadata()) .timestamp(Instant.now()) .build(); // 4. 잔액 업데이트 debitAccount.debit(request.getAmount()); creditAccount.credit(request.getAmount()); // 5. 영속화 ledgerRepository.save(entry); accountRepository.saveAll(Arrays.asList(debitAccount, creditAccount)); // 6. 감사 로그 auditLogger.log(AuditEvent.builder() .type(AuditEventType.LEDGER_ENTRY_CREATED) .entityId(entry.getId()) .entityType("LedgerEntry") .userId(request.getInitiatorId()) .changes(entry.toMap()) .timestamp(Instant.now()) .build() ); // 7. 이벤트 발행 publishLedgerEvent(entry); return entry; }); } // 일일 정산 및 검증 @Scheduled(cron = "0 0 2 * * *") // 매일 오전 2시 public void runDailyReconciliation() { LocalDate yesterday = LocalDate.now().minusDays(1); // 모든 계정의 데빗/크레딧 합계 계산 BigDecimal totalDebits = ledgerRepository .sumDebitsForDate(yesterday); BigDecimal totalCredits = ledgerRepository .sumCreditsForDate(yesterday); // 복식부기 원칙: 데빗 = 크레딧 if (!totalDebits.equals(totalCredits)) { alertOps( "Ledger imbalance detected", Map.of( "date", yesterday, "debits", totalDebits, "credits", totalCredits, "difference", totalDebits.subtract(totalCredits) ) ); } // 각 계정별 잔액 검증 reconcileAccountBalances(yesterday); } } 

Frontend 기술

React 기반 대시보드

// Stripe Dashboard 컴포넌트 import React, { useEffect, useState } from "react"; import { useStripe } from "@stripe/react-stripe-js"; import { LineChart, BarChart } from "recharts"; interface DashboardProps { accountId: string; } export const StripeDashboard: React.FC<DashboardProps> = ({ accountId }) => { const stripe = useStripe(); const [metrics, setMetrics] = useState<DashboardMetrics>(); const [timeRange, setTimeRange] = useState<TimeRange>("7d"); useEffect(() => { loadDashboardData(); }, [accountId, timeRange]); const loadDashboardData = async () => { // 병렬로 여러 메트릭 로드 const [revenue, transactions, customers, disputes, payouts] = await Promise.all([ fetchRevenueMetrics(timeRange), fetchTransactionMetrics(timeRange), fetchCustomerMetrics(timeRange), fetchDisputeMetrics(timeRange), fetchPayoutSchedule(), ]); setMetrics({ revenue, transactions, customers, disputes, payouts, }); }; return ( <div className="stripe-dashboard"> <Header> <h1>Dashboard</h1> <TimeRangeSelector value={timeRange} onChange={setTimeRange} /> </Header> <MetricsGrid> <MetricCard title="Gross Volume" value={formatCurrency(metrics?.revenue.total)} change={metrics?.revenue.changePercent} sparkline={metrics?.revenue.daily} /> <MetricCard title="Successful Payments" value={metrics?.transactions.successful.toLocaleString()} subtitle={`${metrics?.transactions.successRate}% success rate`} /> <MetricCard title="New Customers" value={metrics?.customers.new.toLocaleString()} change={metrics?.customers.changePercent} /> <MetricCard title="Disputes" value={metrics?.disputes.active} subtitle={`${formatCurrency(metrics?.disputes.amount)} at risk`} variant={metrics?.disputes.active > 0 ? "warning" : "default"} /> </MetricsGrid> <ChartsSection> <RevenueChart data={metrics?.revenue.hourly} /> <PaymentMethodBreakdown data={metrics?.transactions.byMethod} /> <GeographicDistribution data={metrics?.revenue.byCountry} /> </ChartsSection> <PayoutSchedule payouts={metrics?.payouts} /> <RecentActivity /> </div> ); }; // 실시간 활동 피드 const RecentActivity: React.FC = () => { const [activities, setActivities] = useState<Activity[]>([]); useEffect(() => { // WebSocket 연결로 실시간 업데이트 const ws = new WebSocket("wss://dashboard.stripe.com/activity"); ws.onmessage = (event) => { const activity = JSON.parse(event.data); setActivities((prev) => [activity, ...prev].slice(0, 50)); }; return () => ws.close(); }, []); return ( <ActivityFeed> {activities.map((activity) => ( <ActivityItem key={activity.id}> <ActivityIcon type={activity.type} /> <ActivityContent> <ActivityDescription>{activity.description}</ActivityDescription> <ActivityTime> {formatRelativeTime(activity.timestamp)} </ActivityTime> </ActivityContent> <ActivityAmount> {activity.amount && formatCurrency(activity.amount)} </ActivityAmount> </ActivityItem> ))} </ActivityFeed> ); }; // Stripe Elements 통합 export const CheckoutForm: React.FC = () => { const stripe = useStripe(); const elements = useElements(); const [error, setError] = useState<string>(); const [processing, setProcessing] = useState(false); const handleSubmit = async (event: FormEvent) => { event.preventDefault(); if (!stripe || !elements) return; setProcessing(true); // 결제 수단 생성 const { error: methodError, paymentMethod } = await stripe.createPaymentMethod({ type: "card", card: elements.getElement(CardElement)!, billing_details: { name: formData.name, email: formData.email, address: formData.address, }, }); if (methodError) { setError(methodError.message); setProcessing(false); return; } // 서버로 결제 요청 const response = await fetch("/api/create-payment-intent", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ payment_method_id: paymentMethod.id, amount: calculateTotal(), currency: "usd", }), }); const result = await response.json(); if (result.requires_action) { // 3D Secure 인증 필요 const { error: confirmError } = await stripe.confirmCardPayment( result.payment_intent_client_secret ); if (confirmError) { setError(confirmError.message); } } setProcessing(false); }; return ( <form onSubmit={handleSubmit}> <CardElement options={{ style: stripeElementStyles, hidePostalCode: true, }} /> {error && <ErrorMessage>{error}</ErrorMessage>} <Button type="submit" disabled={!stripe || processing}> {processing ? <Spinner /> : `Pay ${formatCurrency(total)}`} </Button> </form> ); }; 

인프라 및 신뢰성

분산 시스템 패턴

# Stripe의 분산 시스템 관리 import asyncio from typing import List, Optional import consul import aioredis class DistributedLock: """분산 잠금 구현""" def __init__(self, redis_client: aioredis.Redis): self.redis = redis_client async def acquire( self, key: str, ttl: int = 30, retry_times: int = 10, retry_delay: float = 0.1 ) -> Optional[str]: """ Redlock 알고리즘 구현 """ token = str(uuid.uuid4()) for _ in range(retry_times): # SET NX EX 원자적 실행 acquired = await self.redis.set( key, token, expire=ttl, exist=False ) if acquired: return token await asyncio.sleep(retry_delay) return None async def release(self, key: str, token: str) -> bool: """ Lua 스크립트로 안전한 해제 """ lua_script = """ if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end """ result = await self.redis.eval(lua_script, [key], [token]) return bool(result) class CircuitBreaker: """서킷 브레이커 패턴""" def __init__( self, failure_threshold: int = 5, recovery_timeout: int = 60, expected_exception: type = Exception ): self.failure_threshold = failure_threshold self.recovery_timeout = recovery_timeout self.expected_exception = expected_exception self.failure_count = 0 self.last_failure_time = None self.state = 'closed' # closed, open, half-open async def call(self, func, *args, **kwargs): if self.state == 'open': if self._should_attempt_reset(): self.state = 'half-open' else: raise CircuitOpenError("Circuit breaker is open") try: result = await func(*args, **kwargs) self._on_success() return result except self.expected_exception as e: self._on_failure() raise def _on_success(self): self.failure_count = 0 self.state = 'closed' def _on_failure(self): self.failure_count += 1 self.last_failure_time = time.time() if self.failure_count >= self.failure_threshold: self.state = 'open' class RateLimiter: """토큰 버킷 기반 rate limiter""" def __init__(self, rate: int, burst: int): self.rate = rate # tokens per second self.burst = burst # max tokens self.tokens = burst self.last_update = time.time() self.lock = asyncio.Lock() async def acquire(self, tokens: int = 1) -> bool: async with self.lock: now = time.time() elapsed = now - self.last_update self.last_update = now # 토큰 리필 self.tokens = min( self.burst, self.tokens + elapsed * self.rate ) if self.tokens >= tokens: self.tokens -= tokens return True return False 

보안 및 컴플라이언스

PCI 컴플라이언스

// Rust로 구현된 카드 번호 토큰화 use aes_gcm::{Aes256Gcm, Key, Nonce}; use ring::rand::{SecureRandom, SystemRandom}; pub struct CardTokenizer { encryption_key: Key<Aes256Gcm>, token_vault: TokenVault, hsm_client: HsmClient, } impl CardTokenizer { pub fn tokenize_card(&self, card_number: &str) -> Result<String, TokenizationError> { // 1. 카드 번호 검증 if !self.validate_card_number(card_number) { return Err(TokenizationError::InvalidCardNumber); } // 2. 형식 정규화 let normalized = card_number.chars() .filter(|c| c.is_digit(10)) .collect::<String>(); // 3. 토큰 생성 let token = self.generate_token(&normalized); // 4. HSM에서 암호화 let encrypted = self.hsm_client.encrypt( normalized.as_bytes(), &self.encryption_key )?; // 5. 토큰 볼트에 저장 self.token_vault.store( &token, &encrypted, TokenMetadata { created_at: Utc::now(), last_four: &normalized[normalized.len()-4..], card_brand: detect_card_brand(&normalized), expiry_date: None, // 저장하지 않음 } )?; // 6. 감사 로그 audit_log!("card_tokenized", { "token": &token, "brand": detect_card_brand(&normalized), "timestamp": Utc::now(), }); Ok(token) } fn validate_card_number(&self, number: &str) -> bool { // Luhn 알고리즘 let digits: Vec<u8> = number.chars() .filter_map(|c| c.to_digit(10).map(|d| d as u8)) .collect(); if digits.len() < 13 || digits.len() > 19 { return false; } let checksum: u8 = digits.iter() .rev() .enumerate() .map(|(i, &d)| { if i % 2 == 1 { let doubled = d * 2; if doubled > 9 { doubled - 9 } else { doubled } } else { d } }) .sum(); checksum % 10 == 0 } fn generate_token(&self, seed: &str) -> String { // 형식 보존 암호화 (Format Preserving Encryption) let mut token = String::with_capacity(16); token.push_str("tok_"); // 안전한 난수 생성 let rng = SystemRandom::new(); let mut bytes = [0u8; 12]; rng.fill(&mut bytes).unwrap(); // Base62 인코딩 token.push_str(&base62::encode(&bytes)); token } } 

기술 스택 요약:

• Backend: Ruby, Go, Java, Rust
• Frontend: React, TypeScript
• 데이터베이스: PostgreSQL, MongoDB, Redis
• 메시지 큐: Kafka, NSQ
• 인프라: AWS, 자체 데이터센터
• 모니터링: Veneur, Datadog
• 보안: HSM, Vault

💡 핵심 기술 인사이트

1. API 설계의 교과서

• RESTful하면서도 실용적
• 뛰어난 개발자 경험
• 포괄적인 문서화

2. 금융 시스템의 신뢰성

• 복식부기 원장
• 완벽한 감사 추적
• 멱등성 보장

3. 글로벌 규모의 보안

• PCI DSS Level 1
• 엔드투엔드 암호화
• 실시간 사기 탐지

📈 성과 & 지표

기술적 성과

• 가용성: 99.999% (연간 5분 다운타임)
• API 응답시간: P50 < 100ms
• 처리 용량: 초당 65,000+ 요청
• 글로벌 지연시간: < 150ms
• 보안 사고: 0 (설립 이후)

비즈니스 영향

• 결제 처리량: 연간 $817B+
• 개발자 만족도: 96%
• 통합 시간: 평균 10줄 코드
• 수익 증가: 고객사 평균 6.7%

🎓 Stripe에서 배울 점

✅ 적용 가능한 패턴

1. API 우선 설계: 모든 기능을 API로
2. 멱등성: 분산 시스템 필수
3. 점진적 마이그레이션: 모놀리스→마이크로서비스
4. 개발자 경험: 문서와 도구의 중요성
5. 감사 추적: 모든 변경사항 기록

❌ 주의사항

1. 규제 복잡성: 각국 금융 법규
2. 보안 요구사항: 극도로 높은 기준
3. 레거시 시스템: 금융권 통합 어려움
4. 다운타임 불가: 24/7 운영 부담

📚 추천 리소스

• Stripe Engineering Blog
• Stripe API Documentation
• Incremental Migration
• API Design Guide

🔮 미래 전망

현재 집중 분야

1. Stripe Treasury: 은행 서비스 API
2. Stripe Capital: 대출 서비스
3. Stripe Climate: 탄소 제거 투자
4. Crypto: 암호화폐 결제
5. Embedded Finance: 금융 인프라화

기술 투자 영역

• 기계학습: 더 정교한 사기 탐지
• 블록체인: 국경 간 결제
• 실시간 결제: 즉시 정산
• 개발자 도구: 더 나은 DX
• 글로벌 확장: 더 많은 국가

"우리는 인터넷의 결제 인프라를 구축하여, 모든 비즈니스가 글로벌하게 성장할 수 있도록 돕고 있습니다."

• Stripe Engineering

마지막 업데이트: 2025-01-28