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가지
| 유형 | 특징 | 실무 위치 |
|---|---|---|
| Standalone | Spark 내장. Master + Worker 데몬 | 소규모, 테스트, Spark 전용 클러스터 |
| YARN | Hadoop 생태계 표준 | 온프레미스 기업 환경의 사실상 표준 |
| Kubernetes | 컨테이너 기반. Spark 3.1+ GA | 클라우드/컨테이너 전환 조직 |
| Mesos | Spark 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의 실제 역할
- RM에게 Executor 컨테이너 요청/반납
- 할당받은 컨테이너에 Executor 기동 지시
- Executor 장애 감지 → 대체 컨테이너 재요청
- 앱 종료 시 RM에 최종 상태 보고
배포 모드에 따라 AM의 내용물이 달라짐
| 모드 | AM 컨테이너 안에 들어있는 것 |
|---|---|
| Cluster Mode | AM + Driver (같은 JVM 프로세스) |
| Client Mode | AM만 (ExecutorLauncher라는 축소판). Driver는 클러스터 밖 |
Kubernetes에는 AM이 없음
K8s 모드에서는 Driver Pod가 직접 K8s API Server에 Executor Pod 생성을 요청함. AM이라는 프록시가 존재하지 않음.
YARN : Driver → AM → RM → NM → ExecutorK8s : Driver Pod → API Server → Executor PodAM은 YARN 고유 개념임을 명확히 구분할 것.
3. Application Driver — 애플리케이션의 두뇌
정의: SparkSession/SparkContext를 소유하고, 사용자 코드를 실행하며, 전체 작업을 지휘하는 단일 프로세스.
Driver 내부 컴포넌트
| 컴포넌트 | 역할 |
|---|---|
| SparkSession / SparkContext | 진입점. 클러스터 연결 핸들 |
| Catalyst Optimizer | Logical → Physical Plan 변환 |
| DAGScheduler | Job을 Stage로 분할. Shuffle 경계 판단 |
| TaskScheduler | Stage 내 Task를 Executor에 배치. locality 고려 |
| SchedulerBackend | Cluster Manager와 통신 (YARN/K8s별 구현체) |
| BlockManagerMaster | 클러스터 전체의 캐시/셔플 블록 위치 카탈로그 |
| Spark UI (4040) | 실행 상태 웹 서버 |
Driver가 하는 일(순서대로)
- 사용자 코드 실행 → DAG 구성
- Action 만나면 → 실행 계획 생성 및 최적화
- Job → Stage → Task 분할
- Executor에 Task 직렬화하여 전송
- Task 상태·결과 수집, 실패 시 재시도
collect()결과를 Driver 메모리에 모음- 종료 시 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
--num-executors 10--executor-cores 5--executor-memory 20gFat 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
| Static | Dynamic | |
|---|---|---|
| 설정 | --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 (최후 수단)