3829 words
19 minutes
[Spark] 클러스터 구성요소
2025-10-30
2026-11-06

1. Cluster 구성요소들#

Spark 애플리케이션 하나가 뜨면 클러스터에 생기는 프로세스들:

┌─────────────────────────────────────────────────────┐
│ Cluster │
│ │
│ ┌──────────────────┐ │
│ │ Resource Manager │ "자원의 소유자" │
│ │ (YARN RM / K8s │ 어느 노드에 얼마나 줄지 결정 │
│ │ API Server) │ │
│ └────────┬─────────┘ │
│ │ 1. 자원 요청 / 할당 │
│ ▼ │
│ ┌──────────────────┐ │
│ │ Application │ "이 앱 전용 자원 협상 프록시" │
│ │ Master (AM) │ 앱 1개당 1개 │
│ └────────┬─────────┘ │
│ │ 2. Executor 컨테이너 요청 │
│ ▼ │
│ ┌──────────────────┐ 3. Task 전송 │
│ │ Driver │ ─────────────┐ │
│ │ (SparkContext) │ │ │
│ │ "두뇌 / 지휘자" │ ◀────────────┤ 4. 결과,상태 │
│ └──────────────────┘ │ │
│ ▼ │
│ ┌──────────┐ ┌──────────┐ ┌────────┐ │
│ │ Executor │ │ Executor │ │Executor│ │
│ │ "일꾼" │ │ │ │ │ │
│ └──────────┘ └──────────┘ └────────┘ │
└─────────────────────────────────────────────────────┘

2. Cluster Manager / Resource Manager#

정의: 클러스터 전체의 물리 자원(CPU, 메모리)을 관리하고, 여러 애플리케이션에 배분하는 계층. 핵심: Spark는 자원 관리를 직접 하지 않음. 외부에 위임함.

보통 보는 선택지 4가지#

유형특징실무 위치
StandaloneSpark 내장. Master + Worker 데몬소규모, 테스트, Spark 전용 클러스터
YARNHadoop 생태계 표준온프레미스 기업 환경의 사실상 표준
Kubernetes컨테이너 기반. Spark 3.1+ GA클라우드/컨테이너 전환 조직
MesosSpark 3.2부터 deprecated사실상 사용 안 함

YARN의 경우#

  • ResourceManager (RM) — 클러스터 마스터. 전역 자원 스케줄링. 노드별 가용 자원 추적
  • NodeManager (NM) — 각 워커 노드의 데몬. 컨테이너 실제 기동/감시/종료
  • Container — 자원 할당의 단위. <메모리 N GB, vCore M개> 형태의 자원 임대권

동작:

Client → RM: "앱 하나 띄우겠음"
RM → 임의 NM: "AM 컨테이너 띄워"
AM → RM: "Executor용 컨테이너 10개 필요"
RM → AM: "노드3, 노드7, 노드9에 할당함"
AM → 해당 NM들: "Executor 프로세스 기동"

헷갈리는 지점#

“Resource Manager가 Task를 스케줄링하지 않음”

Resource Manager는 자원(컨테이너)만 배분함. 어떤 Task를 어느 Executor에 보낼지는 Driver가 결정. 두 층위의 스케줄링이 완전히 분리되어 있음.

  • 자원 스케줄링 = Resource Manager 담당 (앱 간 공정성, 큐, 우선순위)
  • 작업 스케줄링 = Driver 담당 (Task → Executor 배치, data locality)

2-2. Application Master (AM)#

정의: YARN에서 애플리케이션 1개당 1개 생성되는, 해당 앱 전용의 자원 협상 프로세스.

YARN 이전 Hadoop 1.x에서는 JobTracker 하나가 자원 관리 + 작업 스케줄링을 모두 처리 → 단일 병목 + SPOF.

YARN은 이를 분리:

  • 전역 자원 관리 → ResourceManager (앱 개수와 무관하게 가벼움)
  • 앱별 실행 관리 → Application Master (앱마다 따로 생성, 부하 분산)

AM의 실제 역할#

  1. RM에게 Executor 컨테이너 요청/반납
  2. 할당받은 컨테이너에 Executor 기동 지시
  3. Executor 장애 감지 → 대체 컨테이너 재요청
  4. 앱 종료 시 RM에 최종 상태 보고

배포 모드에 따라 AM의 내용물이 달라짐#

모드AM 컨테이너 안에 들어있는 것
Cluster ModeAM + Driver (같은 JVM 프로세스)
Client ModeAM만 (ExecutorLauncher라는 축소판). Driver는 클러스터 밖

Kubernetes에는 AM이 없음#

K8s 모드에서는 Driver Pod가 직접 K8s API Server에 Executor Pod 생성을 요청함. AM이라는 프록시가 존재하지 않음.

YARN : Driver → AM → RM → NM → Executor
K8s : Driver Pod → API Server → Executor Pod

AM은 YARN 고유 개념임을 명확히 구분할 것.


3. Application Driver — 애플리케이션의 두뇌#

정의: SparkSession/SparkContext를 소유하고, 사용자 코드를 실행하며, 전체 작업을 지휘하는 단일 프로세스.

Driver 내부 컴포넌트#

컴포넌트역할
SparkSession / SparkContext진입점. 클러스터 연결 핸들
Catalyst OptimizerLogical → Physical Plan 변환
DAGSchedulerJob을 Stage로 분할. Shuffle 경계 판단
TaskSchedulerStage 내 Task를 Executor에 배치. locality 고려
SchedulerBackendCluster Manager와 통신 (YARN/K8s별 구현체)
BlockManagerMaster클러스터 전체의 캐시/셔플 블록 위치 카탈로그
Spark UI (4040)실행 상태 웹 서버

Driver가 하는 일(순서대로)#

  1. 사용자 코드 실행 → DAG 구성
  2. Action 만나면 → 실행 계획 생성 및 최적화
  3. Job → Stage → Task 분할
  4. Executor에 Task 직렬화하여 전송
  5. Task 상태·결과 수집, 실패 시 재시도
  6. collect() 결과를 Driver 메모리에 모음
  7. 종료 시 Executor 정리

Driver의 리스크#

SPOF (Single Point of Failure)

Driver가 죽으면 애플리케이션 전체가 죽음. Executor는 몇 개 죽어도 재시도로 복구되지만 Driver는 대체 불가.

Driver OOM

data = df.collect() # 전체 데이터가 Driver 힙으로
big = df.toPandas() # 동일
df.write.parquet(path) # Executor가 직접 씀
df.limit(1000).collect() # 크기 제한

spark.driver.maxResultSize (기본 1g)로 방어 가능하나, 애초에 collect를 안 하는 설계가 정답.

네트워크 병목

모든 Task 상태 보고, heartbeat, 스케줄링 결정이 Driver로 집중. Task 수가 수십만 개면 Driver 자체가 병목. → 과도한 파티션 분할 주의.


2-4. PySpark Driver — Python과 JVM의 이중 구조#

Spark는 Scala/JVM으로 구현되어 있음. Python은 Wrapper

Driver 측 구조#

┌────────────────── Driver 노드 ──────────────────┐
│ │
│ ┌───────────────┐ ┌──────────────────┐ │
│ │ Python 프로세스│◀─Py4J─▶│ JVM 프로세스 │ │
│ │ (내 스크립트) │ 소켓 │ (진짜 Driver) │ │
│ │ │ │ SparkContext │ │
│ │ pyspark API │ │ DAGScheduler │ │
│ │ = 얇은 래퍼 │ │ TaskScheduler │ │
│ └───────────────┘ └──────────────────┘ │
└─────────────────────────────────────────────────┘
  • Py4J = Python ↔ JVM 브리지. 로컬 소켓으로 JVM 객체를 원격 조작
  • spark.read.parquet(...) 호출 시 → Py4J로 JVM의 동일 메서드 호출 → JVM이 실제 작업
  • Python 객체는 JVM 객체의 **프록시(참조)**일 뿐

Executor 구조#

DataFrame API만 쓰면 Executor에 Python이 개입하지 않음. 그러나 Python UDF를 쓰는 순간:

┌───────────── Executor ─────────────┐
│ │
│ JVM (Task 실행) │
│ │ │
│ │ ① 데이터 직렬화(pickle) │
│ ▼ │
│ ┌──────────────────┐ │
│ │ Python Worker │ ② UDF 실행 │
│ │ (pyspark.daemon) │ │
│ └──────────────────┘ │
│ │ │
│ │ ③ 결과 역직렬화 │
│ ▼ │
│ JVM (다음 연산) │
└────────────────────────────────────┘

성능:

방식비용
내장 함수 (F.col, F.when)JVM 내부 처리. serialization 없음
Python UDF행 단위 pickle serialization+ 프로세스 간 통신
Pandas UDF (Arrow)배치 단위 Arrow 전송. 10~100배 개선
# 행마다 JVM <-> Python 왕복
@udf("double")
def slow(x): return x * 1.5
# 개선 — Arrow 배치
@pandas_udf("double")
def better(s: pd.Series) -> pd.Series: return s * 1.5
df.withColumn("v", F.col("x") * 1.5)

Python Worker 메모리는 JVM 힙 밖에서 잡힘 → spark.executor.memoryOverhead를 사용


5. Executors#

정의: 워커 노드에서 실행되는 JVM 프로세스. 애플리케이션 시작 시 뜨고 종료 시까지 유지됨.

Executor의 두 가지 역할#

1. Task 실행

Executor (spark.executor.cores = 4)
├── Task 스레드 1 ← Partition A
├── Task 스레드 2 ← Partition B
├── Task 스레드 3 ← Partition C
└── Task 스레드 4 ← Partition D
  • Executor 1개 = JVM 1개, 그 안에서 코어 수만큼 Task를 스레드로 병렬 실행
  • 전체 병렬도 = Executor 수 × Executor당 코어 수
  • Task는 스레드이므로 같은 Executor 내 Task들은 힙 메모리를 공유 → 한 Task의 폭주가 이웃 Task를 죽일 수 있음

2. 데이터 저장 (BlockManager)

  • cache() / persist() 된 파티션 보관
  • Shuffle write 결과를 로컬 디스크에 보관, 다른 Executor의 요청에 제공
  • Broadcast 변수 보관

이렇기 때문에 Executor를 죽이면 그 안의 캐시와 셔플 파일도 사라짐 → 재계산 발생. Dynamic Allocation에서 External Shuffle Service가 필요

Executor Sizing#

Terminal window
--num-executors 10
--executor-cores 5
--executor-memory 20g

Fat vs Thin 트레이드오프:

Fat (코어 20, 메모리 80g)Thin (코어 1, 메모리 4g)
장점브로드캐스트 1부만 복제, 셔플 상대 수 적음장애 영향 범위 작음
단점HDFS I/O 스레드 경합, GC 정지 시간 김, 장애 시 손실 큼브로드캐스트 중복, 셔플 연결 폭증, 오버헤드 비율 높음

Executor당 코어 4~5개가 일반적인 스위트스팟. HDFS 클라이언트가 코어 5개 초과 시 I/O 처리량이 떨어진다는 경험적 관찰에서 유래.

메모리 산정시 검토:

--executor-memory 20g 로 요청했는데
YARN 컨테이너는 20g + max(384m, 20g × 0.1) = 22g 를 잡음

이 초과분이 Overhead Memory. 컨테이너 상한 계산 시 반드시 포함

Static vs Dynamic Allocation#

StaticDynamic
설정--num-executors N 고정spark.dynamicAllocation.enabled=true
동작시작 시 확보, 끝까지 유지대기 Task 많으면 추가 요청, 유휴 시 반납
전제없음External Shuffle Service 또는 Shuffle Tracking 필요
적합예측 가능한 배치부하 변동 큰 워크로드, 멀티테넌트 클러스터

Dynamic Allocation에서 셔플 서비스가 필요한 이유: Executor를 반납해도 Executor안의 셔플 파일은 다른 Stage가 읽어야 함. NodeManager에 붙는 External Shuffle Service가 파일을 대신 보관 및 제공해야 안전하게 반납 가능.


헷갈리기 쉬운 지점들#

오해정정
Driver = Application Master별개 개념. cluster mode에서 같은 JVM에 있을 뿐
Resource Manager가 Task를 배분자원(컨테이너)만 배분. Task 배분은 Driver
Executor 1개 = Task 1개Executor 1개 안에서 코어 수만큼 Task 병렬 실행
K8s에도 AM이 있다없음. Driver Pod가 API Server와 직접 통신
PySpark는 Python으로 분산 처리Python은 얇은 래퍼. 실제 분산 실행은 JVM
Executor 많을수록 좋다코어 5개 초과·과다 Executor는 오히려 성능 저하

Concept

  • Cluster Manager / Resource Manager : 클러스터 물리 자원을 관리하고 애플리케이션에 배분하는 외부 계층. Spark는 자원 관리를 여기에 위임
  • Standalone : Spark 내장 클러스터 매니저. Master/Worker 데몬 구조. 소규모·전용 클러스터용
  • YARN : Hadoop 생태계의 자원 관리자. 온프레미스 기업 환경의 사실상 표준
  • ResourceManager (YARN) : 클러스터 전역 자원 스케줄러. 노드별 가용 자원 추적 및 컨테이너 할당 결정
  • NodeManager (YARN) : 각 워커 노드의 데몬. 컨테이너 기동·감시·종료 담당
  • Container : 자원 할당의 단위. <메모리, vCore> 조합의 임대권
  • Application Master (AM) : YARN에서 애플리케이션 1개당 1개 생성되는 자원 협상 전용 프로세스. Executor 컨테이너 요청·반납·장애 복구 담당
  • ExecutorLauncher : Client Mode에서 AM이 취하는 축소 형태. Driver 없이 Executor 기동만 수행
  • Application Driver : SparkSession을 소유하고 실행 계획 수립·Task 스케줄링·결과 수집을 담당하는 단일 지휘 프로세스
  • SparkContext / SparkSession : Spark 애플리케이션 진입점. 클러스터 연결 핸들이자 Driver 컴포넌트의 소유자
  • DAGScheduler : Job을 Shuffle 경계 기준으로 Stage 단위로 분할하는 Driver 내부 컴포넌트
  • TaskScheduler : Stage 내 Task를 개별 Executor에 배치하는 컴포넌트. Data Locality 고려
  • SchedulerBackend : Cluster Manager와 통신하는 추상 계층. YARN/K8s/Standalone별 구현체 존재
  • BlockManagerMaster : 클러스터 전체 캐시·셔플 블록의 위치를 관리하는 Driver 측 카탈로그
  • SPOF (Single Point of Failure) : Driver의 구조적 특성. Driver 종료 시 애플리케이션 전체 종료
  • Driver OOM : collect(), toPandas() 등으로 전체 데이터를 Driver 힙에 모을 때 발생하는 메모리 부족
  • spark.driver.maxResultSize : Driver로 반환되는 결과 크기 상한. 기본 1g. 초과 시 Job 실패로 방어
  • PySpark Driver : Python 프로세스 + Py4J + JVM Driver의 이중 구조. Python은 JVM 객체의 프록시 역할
  • Py4J : Python과 JVM 간 로컬 소켓 브리지. Python에서 JVM 객체를 원격 조작하게 해주는 라이브러리
  • Python Worker (pyspark.daemon) : Executor에서 Python UDF를 실행하는 별도 프로세스. JVM 힙 외부 메모리 사용
  • Pandas UDF / Arrow : 행 단위 pickle 대신 Apache Arrow 배치 전송으로 직렬화 비용을 크게 낮춘 UDF 방식
  • Executor : 워커 노드의 JVM 프로세스. Task 실행과 데이터(캐시·셔플 블록) 보관을 동시에 담당
  • spark.executor.cores : Executor 내 Task 병렬 실행 스레드 수. 전체 병렬도 = Executor 수 × 코어 수
  • BlockManager : Executor 내 저장소 관리자. 캐시 파티션·셔플 블록·브로드캐스트 변수 보관
  • Fat / Thin Executor : 코어·메모리를 크게 잡는 방식과 작게 잡는 방식. 통상 코어 4~5개가 스위트스팟
  • Static Allocation : Executor 수를 시작 시 고정하는 방식. 예측 가능한 배치에 적합
  • Dynamic Allocation : 부하에 따라 Executor를 자동 증감하는 방식. External Shuffle Service가 전제 조건
  • External Shuffle Service : NodeManager에 상주하며 셔플 파일을 대신 제공하는 서비스. Executor 안전 반납을 가능하게 함

  • YARN Scheduler (Capacity / Fair) : 큐 기반 자원 배분 정책. 멀티테넌트 온프레미스 클러스터에서 Spark 앱이 자원을 못 받고 대기하는 원인 대부분이 여기에 있음
  • Data Locality 5단계 : PROCESS_LOCAL / NODE_LOCAL / NO_PREF / RACK_LOCAL / ANY. spark.locality.wait가 스케줄링 지연에 미치는 영향
  • Executor Heartbeat & Blacklisting : spark.executor.heartbeatInterval, spark.excludeOnFailure.*. 특정 노드 장애가 반복될 때 해당 Executor를 배제하는 메커니즘
  • Spark on Kubernetes 아키텍처 : Driver Pod / Executor Pod, Pod Template, Volcano·YuniKorn 스케줄러 연동. YARN 대체 전환 시 필수
  • Speculative Execution : spark.speculation. 느린 Task를 다른 Executor에서 중복 실행해 straggler 완화
  • Spark History Server : 종료된 애플리케이션의 이벤트 로그를 재구성해 사후 분석. 온프레미스 운영에서 사실상 필수
  • Cluster Manager별 자원 격리 방식 : YARN Container(cgroup) vs K8s Pod(cgroup + namespace). CPU/메모리 제한이 실제로 어떻게 강제되는지

PySpark에서 df.withColumn("y", F.col("x") * 2)와 동일 로직의 Python UDF는 결과가 같지만 성능 차이가 큼. Driver/Executor 구조 관점에서 이유를 설명하고, 중간 대안과 그 원리를 제시한다면

내장 함수 (F.col("x") * 2)

  • Python 측에서는 Py4J로 표현식 트리(Expression)만 JVM에 전달. 데이터는 넘어가지 않음
  • Executor에서 Catalyst가 이 표현식을 JVM 바이트코드로 코드 생성(Whole-Stage Codegen)
  • 데이터는 JVM 힙 안에서만 이동 → 직렬화·프로세스 간 통신 0회

Python UDF

  • Executor의 JVM이 각 행을 pickle 직렬화 → 소켓으로 Python Worker 프로세스에 전송
  • Python Worker가 함수 실행 → 결과를 다시 직렬화해 JVM으로 반환
  • 비용: ① 행 단위 직렬화/역직렬화 ② 프로세스 간 컨텍스트 스위칭 ③ Catalyst가 UDF 내부를 볼 수 없어 최적화 대상에서 제외(블랙박스) ④ Python Worker 메모리가 힙 밖 Overhead 영역을 소비

중간 대안 — Pandas UDF (Vectorized UDF)

@pandas_udf("long")
def double(s: pd.Series) -> pd.Series:
return s * 2
  • Apache Arrow 컬럼형 포맷으로 배치 단위 전송
  • Arrow는 zero-copy 지향 포맷이라 역직렬화 비용도 낮음
  • 통상 일반 Python UDF 대비 10~100배 개선

우선순위: 내장 함수 → Pandas UDF → Python UDF (최후 수단)

[Spark] 클러스터 구성요소
https://yjinheon.netlify.app/posts/02de/03-spark/spark-02-cluster-component/
Author
Datamind
Published at
2025-10-30
License
CC BY-NC-SA 4.0