🏢 Spotify 기술 스택 분석

매일 10억 개 이상의 스트림을 처리하며 개인화된 음악 경험을 제공하는 Spotify의 기술 스택을 심층 분석합니다.
"Music for everyone" - 기술로 만드는 글로벌 음악 플랫폼

---

📊 회사 개요

서비스 규모

• 월간 활성 사용자: 5.74억 명 (프리미엄 2.26억)
• 콘텐츠: 1억+ 트랙, 500만+ 팟캐스트
• 일일 스트림: 10억+ 재생
• 서비스 지역: 184개 시장
• 플레이리스트: 40억+ 사용자 생성

엔지니어링 조직

• 엔지니어: 2,000명+ (전체 직원 9,000+)
• Squad 모델: 자율적인 소규모 팀
• Chapter & Guild: 기술 공유 조직
• 오픈소스: 400+ 프로젝트

기술적 도전과제

1. 개인화: 5억 명을 위한 맞춤 추천
2. 저지연 스트리밍: 전 세계 실시간 음악 전송
3. 콘텐츠 관리: 1억+ 트랙 메타데이터
4. 크리에이터 도구: 아티스트 분석 플랫폼

---

🧩 기술 스택 상세

Backend 기술

마이크로서비스 아키텍처

// Spotify의 Apollo 프레임워크 기반 서비스
@Service
public class PlaylistService {
    private final UserService userService;
    private final TrackService trackService;
    private final RecommendationService recommendationService;

    @RequestMapping("/playlists/{id}")
    public CompletableFuture<Playlist> getPlaylist(
            @PathVariable String id,
            @RequestContext Context context) {

        return userService.getUser(context.userId())
            .thenCompose(user -> {
                // 병렬로 데이터 가져오기
                CompletableFuture<PlaylistMetadata> metadata =
                    getPlaylistMetadata(id);
                CompletableFuture<List<Track>> tracks =
                    trackService.getTracks(id);
                CompletableFuture<List<Recommendation>> recommendations =
                    recommendationService.getForPlaylist(id, user);

                return CompletableFuture.allOf(metadata, tracks, recommendations)
                    .thenApply(v -> buildPlaylist(
                        metadata.join(),
                        tracks.join(),
                        recommendations.join()
                    ));
            });
    }

    // Circuit breaker 패턴
    @HystrixCommand(
        fallbackMethod = "getDefaultRecommendations",
        commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000")
        }
    )
    private CompletableFuture<List<Track>> getPersonalizedTracks(String userId) {
        return mlService.getRecommendations(userId);
    }
}

Backend 기술 스택:

• 언어: Java (60%), Python (25%), Go (10%), C++ (5%)
• 프레임워크: Spring Boot, Apollo (자체), Flask
• API: GraphQL Federation, REST
• 메시징: Google Pub/Sub, Kafka (일부)
• 서비스 메시: Kubernetes + Istio

데이터 파이프라인

# Apache Beam 기반 데이터 처리
import apache_beam as beam
from apache_beam.options.pipeline_options import PipelineOptions

class SpotifyStreamingPipeline:
    def __init__(self):
        self.pipeline_options = PipelineOptions([
            '--runner=DataflowRunner',
            '--project=spotify-data',
            '--region=europe-west1',
            '--temp_location=gs://spotify-temp/dataflow',
            '--streaming'
        ])

    def build_pipeline(self):
        with beam.Pipeline(options=self.pipeline_options) as p:
            # 실시간 스트림 이벤트 수집
            events = (p
                | 'Read from Pub/Sub' >> beam.io.ReadFromPubSub(
                    topic='projects/spotify-data/topics/play-events'
                )
                | 'Parse JSON' >> beam.Map(json.loads)
            )

            # 사용자별 집계
            user_stats = (events
                | 'Extract User Data' >> beam.Map(
                    lambda x: (x['user_id'], {
                        'track_id': x['track_id'],
                        'duration': x['duration'],
                        'timestamp': x['timestamp']
                    })
                )
                | 'Window' >> beam.WindowInto(
                    beam.window.FixedWindows(60)  # 1분 윈도우
                )
                | 'Group by User' >> beam.GroupByKey()
                | 'Calculate Stats' >> beam.Map(self.calculate_user_stats)
            )

            # BigTable에 저장
            user_stats | 'Write to Bigtable' >> beam.io.WriteToBigTable(
                project_id='spotify-data',
                instance_id='user-analytics',
                table_id='streaming_stats'
            )

            # 추천 시스템 업데이트
            user_stats | 'Update ML Features' >> beam.Map(
                self.update_recommendation_features
            )

Frontend 기술

Web Player (React)

// Spotify Web Player 컴포넌트
import { useEffect, useState } from "react";
import { useSpotifySDK } from "@spotify/web-api-sdk";

interface PlayerProps {
  trackUri: string;
  onTrackEnd: () => void;
}

export function SpotifyPlayer({ trackUri, onTrackEnd }: PlayerProps) {
  const [player, setPlayer] = useState<Spotify.Player | null>(null);
  const [deviceId, setDeviceId] = useState<string>("");
  const sdk = useSpotifySDK();

  useEffect(() => {
    // Web Playback SDK 초기화
    const script = document.createElement("script");
    script.src = "https://sdk.scdn.co/spotify-player.js";
    script.async = true;
    document.body.appendChild(script);

    window.onSpotifyWebPlaybackSDKReady = () => {
      const player = new Spotify.Player({
        name: "Spotify Web Player",
        getOAuthToken: (cb) => {
          sdk.getAccessToken().then(cb);
        },
        volume: 0.5,
      });

      // 이벤트 리스너
      player.addListener("ready", ({ device_id }) => {
        console.log("Ready with Device ID", device_id);
        setDeviceId(device_id);
      });

      player.addListener("player_state_changed", (state) => {
        if (state.position === 0 && state.paused) {
          onTrackEnd();
        }

        // 재생 통계 전송
        sendPlaybackAnalytics({
          track_id: state.track_window.current_track.id,
          position: state.position,
          duration: state.duration,
          context: state.context,
        });
      });

      player.connect();
      setPlayer(player);
    };

    return () => {
      player?.disconnect();
    };
  }, []);

  const play = async () => {
    await sdk.player.play({
      device_id: deviceId,
      uris: [trackUri],
    });
  };

  return (
    <div className="player-container">
      <AudioVisualizer />
      <PlayerControls
        onPlay={play}
        onPause={() => player?.pause()}
        onNext={() => player?.nextTrack()}
      />
      <VolumeControl onChange={(volume) => player?.setVolume(volume)} />
    </div>
  );
}

Frontend 기술:

• Web: React, TypeScript, Redux
• Mobile: Native (Swift/Kotlin) + React Native (일부)
• Desktop: Electron + CEF (Chromium Embedded)
• TV/콘솔: C++ 커스텀 플레이어
• 빌드: Webpack, Bazel

Data & ML Infrastructure

추천 시스템

# Spotify의 추천 엔진 (간소화)
class CollaborativeFilteringModel:
    def __init__(self):
        self.user_embeddings = None
        self.item_embeddings = None
        self.model = self._build_model()

    def _build_model(self):
        # Two-tower 모델
        user_input = keras.Input(shape=(USER_FEATURES,))
        item_input = keras.Input(shape=(ITEM_FEATURES,))

        # User tower
        user_tower = keras.Sequential([
            keras.layers.Dense(256, activation='relu'),
            keras.layers.Dropout(0.2),
            keras.layers.Dense(128, activation='relu'),
            keras.layers.Dense(64)
        ])

        # Item tower
        item_tower = keras.Sequential([
            keras.layers.Dense(256, activation='relu'),
            keras.layers.Dropout(0.2),
            keras.layers.Dense(128, activation='relu'),
            keras.layers.Dense(64)
        ])

        user_embedding = user_tower(user_input)
        item_embedding = item_tower(item_input)

        # Dot product for similarity
        similarity = keras.layers.Dot(axes=1)([user_embedding, item_embedding])

        model = keras.Model(
            inputs=[user_input, item_input],
            outputs=similarity
        )

        return model

    def get_recommendations(self, user_id, context):
        # 사용자 특성 추출
        user_features = self.extract_user_features(user_id)

        # 컨텍스트 고려 (시간, 장소, 기기)
        context_features = self.extract_context_features(context)

        # 후보 생성
        candidates = self.retrieve_candidates(user_features)

        # 순위 매기기
        scores = self.model.predict([
            np.repeat(user_features, len(candidates)),
            candidates
        ])

        # 다양성 추가
        diversified = self.apply_diversity(candidates, scores)

        return diversified[:100]  # Top 100

Feature Store

// Spotify의 Feature Store (Feathr 기반)
object FeatureStore {
  case class UserFeatures(
    userId: String,
    totalListeningTime: Long,
    topGenres: Seq[String],
    topArtists: Seq[String],
    listeningPatterns: Map[Int, Float], // hour -> probability
    devicePreferences: Map[String, Float],
    lastUpdated: Timestamp
  )

  case class TrackFeatures(
    trackId: String,
    audioFeatures: AudioFeatures,
    popularity: Float,
    releaseDate: Date,
    genres: Seq[String],
    collaborativeSignal: Float,
    contentSignal: Float
  )

  case class AudioFeatures(
    danceability: Float,
    energy: Float,
    key: Int,
    loudness: Float,
    mode: Int,
    speechiness: Float,
    acousticness: Float,
    instrumentalness: Float,
    liveness: Float,
    valence: Float,
    tempo: Float,
    duration: Int
  )

  def getUserFeatures(userId: String): Future[UserFeatures] = {
    // BigTable에서 특성 조회
    bigtableClient.get(s"user_features:$userId").map { row =>
      UserFeatures(
        userId = userId,
        totalListeningTime = row.getLong("total_time"),
        topGenres = row.getList("genres"),
        topArtists = row.getList("artists"),
        listeningPatterns = row.getMap("patterns"),
        devicePreferences = row.getMap("devices"),
        lastUpdated = row.getTimestamp("updated")
      )
    }
  }
}

데이터 인프라:

• 데이터 레이크: Google Cloud Storage
• 실시간 처리: Google Pub/Sub + Dataflow
• 배치 처리: Apache Beam, Scio (Scala)
• 데이터베이스: Bigtable, Spanner, PostgreSQL
• 분석: BigQuery, Databricks
• ML 플랫폼: Kubeflow, TensorFlow Extended

Infrastructure & DevOps

Backstage 플랫폼

# Backstage 서비스 카탈로그
apiVersion: backstage.io/v1alpha1
kind: Component
metadata:
  name: playlist-service
  description: Manages user playlists and collaborative playlists
  tags:
    - java
    - backend
    - tier1
  annotations:
    github.com/project-slug: spotify/playlist-service
    backstage.io/techdocs-ref: dir:.
    spotify.com/squad-owner: playlist-experience
spec:
  type: service
  lifecycle: production
  owner: playlist-squad
  system: playlist-platform
  dependsOn:
    - resource:playlist-db
    - component:track-service
    - component:user-service
  providesApis:
    - playlist-api

Golden Path

# Spotify의 Golden Path CLI
$ spotify create service playlist-service --lang java --type rest

✓ Created service scaffold
✓ Set up GitHub repository
✓ Configured CI/CD pipelines
✓ Created Kubernetes manifests
✓ Registered in Backstage
✓ Set up monitoring dashboards
✓ Created runbooks

Your service is ready!
Local development: cd playlist-service && ./gradlew bootRun
Deploy to staging: git push origin main

인프라 기술:

• 클라우드: Google Cloud Platform (주력)
• 컨테이너: Kubernetes (자체 관리)
• CI/CD: Jenkins + Spinnaker
• 모니터링: Prometheus + Grafana
• 로깅: ELK Stack
• 개발자 포털: Backstage

---

💡 핵심 기술 인사이트

1. Squad 모델 & 자율성

// Squad의 자율적 서비스 운영
interface SquadOwnership {
  squad: string;
  mission: string;
  services: string[];
  kpis: {
    metric: string;
    target: number;
    current: number;
  }[];
  dependencies: {
    upstream: string[];
    downstream: string[];
  };
}

// 예시: Playlist Squad
const playlistSquad: SquadOwnership = {
  squad: "playlist-experience",
  mission: "Enable users to organize and discover music through playlists",
  services: [
    "playlist-service",
    "collaborative-playlist-service",
    "playlist-recommendation-service",
  ],
  kpis: [
    { metric: "playlist_creation_rate", target: 1000000, current: 1200000 },
    {
      metric: "collaborative_playlist_mau",
      target: 50000000,
      current: 62000000,
    },
    { metric: "p99_latency_ms", target: 200, current: 187 },
  ],
  dependencies: {
    upstream: ["user-service", "track-service", "ml-platform"],
    downstream: ["mobile-app", "web-player", "home-feed"],
  },
};

2. 음악 추천 알고리즘

# Spotify의 하이브리드 추천 시스템
class HybridRecommendationEngine:
    def __init__(self):
        self.collaborative_filter = CollaborativeFiltering()
        self.content_based = ContentBasedFiltering()
        self.nlp_engine = NLPEngine()
        self.contextual_bandit = ContextualBandit()

    def generate_discover_weekly(self, user_id):
        # 1. 협업 필터링 (유사 사용자 기반)
        collaborative_tracks = self.collaborative_filter.get_recommendations(
            user_id,
            method='matrix_factorization',
            n_tracks=1000
        )

        # 2. 콘텐츠 기반 필터링 (음악적 특성)
        user_taste_profile = self.get_user_taste_profile(user_id)
        content_tracks = self.content_based.find_similar_tracks(
            user_taste_profile,
            audio_features=['energy', 'valence', 'danceability'],
            n_tracks=1000
        )

        # 3. NLP 기반 추천 (가사, 리뷰 분석)
        nlp_tracks = self.nlp_engine.get_semantic_recommendations(
            user_id,
            sources=['lyrics', 'reviews', 'social_media'],
            n_tracks=500
        )

        # 4. 앙상블 & 다양성 최적화
        candidate_pool = self.merge_recommendations([
            (collaborative_tracks, 0.4),
            (content_tracks, 0.3),
            (nlp_tracks, 0.3)
        ])

        # 5. Contextual Bandit으로 최종 선택
        final_playlist = self.contextual_bandit.select_tracks(
            candidate_pool,
            context={
                'day_of_week': datetime.now().weekday(),
                'time_of_day': datetime.now().hour,
                'user_activity': self.get_recent_activity(user_id),
                'global_trends': self.get_trending_tracks()
            },
            n_tracks=30
        )

        return self.ensure_diversity(final_playlist)

3. 실시간 오디오 분석

// C++ 기반 오디오 특성 추출
class AudioAnalyzer {
private:
    std::unique_ptr<FFTProcessor> fft;
    std::unique_ptr<ChromaExtractor> chroma;
    std::unique_ptr<RhythmAnalyzer> rhythm;

public:
    AudioFeatures analyzeTrack(const AudioBuffer& buffer) {
        AudioFeatures features;

        // 스펙트럼 분석
        auto spectrum = fft->process(buffer);
        features.spectralCentroid = calculateSpectralCentroid(spectrum);
        features.spectralRolloff = calculateSpectralRolloff(spectrum, 0.85);

        // 크로마 벡터 (화성 분석)
        auto chromaVector = chroma->extract(buffer);
        features.key = estimateKey(chromaVector);
        features.mode = estimateMode(chromaVector);

        // 리듬 특성
        auto tempogram = rhythm->extractTempogram(buffer);
        features.tempo = estimateTempo(tempogram);
        features.timeSignature = estimateTimeSignature(tempogram);

        // 고급 특성
        features.danceability = calculateDanceability(features.tempo,
                                                     features.energy,
                                                     features.rhythm_strength);
        features.energy = calculateEnergy(spectrum);
        features.valence = estimateValence(chromaVector, features.tempo);

        // 음성/악기 분리
        auto separated = separateSources(buffer);
        features.instrumentalness = calculateInstrumentalness(separated);
        features.speechiness = calculateSpeechiness(separated);

        return features;
    }
};

4. Backstage 개발자 경험

# 개발자 생산성 도구
apiVersion: scaffolder.backstage.io/v1beta3
kind: Template
metadata:
  name: spotify-microservice
  title: Spotify Microservice
  description: Create a new microservice following Spotify standards
spec:
  owner: platform-team
  type: service

  parameters:
    - title: Service Details
      required:
        - name
        - description
        - squad
      properties:
        name:
          title: Name
          type: string
          pattern: "^[a-z0-9-]+$"
        description:
          title: Description
          type: string
        squad:
          title: Squad Owner
          type: string
          enum: ${squads}

    - title: Technical Choices
      properties:
        language:
          title: Programming Language
          type: string
          enum: ["java", "python", "go", "typescript"]
        database:
          title: Database
          type: string
          enum: ["bigtable", "spanner", "postgresql", "none"]
        messaging:
          title: Messaging
          type: string
          enum: ["pubsub", "kafka", "none"]

  steps:
    - id: fetch
      name: Fetch Skeleton
      action: fetch:template
      input:
        url: ./skeleton/${{ parameters.language }}

    - id: publish
      name: Publish to GitHub
      action: publish:github
      input:
        repoUrl: github.com?owner=spotify&repo=${{ parameters.name }}

    - id: register
      name: Register in Backstage
      action: catalog:register

    - id: setup-ci
      name: Setup CI/CD
      action: jenkins:create-job

---

📈 성과 & 지표

기술적 성과

• API 응답시간: P50 < 50ms, P99 < 200ms
• 가용성: 99.95% (연간 다운타임 < 4.5시간)
• 배포 빈도: 일일 2,000+ 배포
• 추천 정확도: 30% 향상 (2020년 대비)
• 스트리밍 품질: 320kbps (Premium)

비즈니스 영향

• 사용자 참여: 평균 일일 사용 2.5시간
• Discover Weekly: 40% 사용자가 매주 청취
• 개인화 효과: 추천 트랙 80%+ 긍정 반응
• 개발자 생산성: Golden Path로 50% 시간 단축

---

🎓 Spotify에서 배울 점

✅ 적용 가능한 패턴

1. Squad 모델: 자율적 팀 운영
2. Golden Path: 표준화된 개발 경로
3. Backstage: 개발자 포털 플랫폼
4. Feature Store: ML 특성 관리
5. 하이브리드 추천: 다양한 알고리즘 앙상블

❌ 주의사항

1. 복잡한 조직 구조: Squad 모델은 문화가 중요
2. 높은 자율성: 표준화와 균형 필요
3. 기술 다양성: 너무 많은 언어/프레임워크
4. 데이터 규모: 대규모 인프라 필요

📚 추천 리소스

• Spotify Engineering Blog
• Backstage.io
• Spotify Web API
• The Spotify Model

---

🔮 미래 전망

현재 집중 분야

1. AI DJ: 개인화된 라디오 경험
2. 팟캐스트 기술: 음성 콘텐츠 혁신
3. 라이브 오디오: 실시간 방송 플랫폼
4. 자동차 경험: 차량용 최적화
5. 창작자 도구: 아티스트 분석 플랫폼

기술 투자 영역

• 생성형 AI: 음악 생성, 리믹스
• 공간 오디오: 3D 사운드 경험
• 블록체인: 로열티 분배 투명성
• 엣지 컴퓨팅: 오프라인 최적화
• 그린 컴퓨팅: 탄소 중립 스트리밍

---

"우리는 세계 최고의 오디오 플랫폼이 되기 위해 기술의 한계를 계속 넓혀가고 있습니다."

• Spotify Engineering

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

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   Clients   │────►│   Backend   │────►│  ML Platform│
│(Mobile/Web) │     │  for FE(BFF)│     │ (Kubeflow)  │
└─────────────┘     └─────────────┘     └─────────────┘
       │                    │                    │
       │              ┌─────▼─────┐       ┌─────▼─────┐
       │              │  API Gateway│       │  Feature   │
       │              │   (Nginx)  │       │   Store    │
       │              └───────────┘       └───────────┘
       │                    │                    │
       └────────────────────┤                    │
                      ┌─────▼─────┐       ┌─────▼─────┐
                      │Microservices│      │ Data Lake │
                      │(100s of them)│      │   (GCS)   │
                      └───────────┘       └───────────┘

핵심 설계 원칙

1. Autonomous Teams: Squad 모델로 독립적 개발
2. Golden Path: 표준화된 개발 경로
3. Data-Driven: 모든 결정은 데이터 기반
4. Fail Fast: 빠른 실험과 학습
5. Platform Thinking: 내부 플랫폼 우선

기술 진화

• 2006-2008: Python 모놀리스
• 2009-2012: 마이크로서비스 전환
• 2013-2016: 자체 인프라 → 클라우드
• 2017-2020: ML 플랫폼 구축
• 2021-현재: Backstage, Golden Path

---