Processing Types

Processing Types

데이터 처리 방식은 시스템의 요구 사항에 따라 배치 (Batch), 스트림 (Stream), 하이브리드 (Hybrid) 로 구분된다. Batch Processing 은 데이터의 대량 집계와 정확성에 적합하고, Stream Processing 은 실시간 응답성과 낮은 지연 시간에 유리하다. Hybrid Processing 은 Lambda Architecture 처럼 두 방식을 조합해 실시간성과 정확성을 모두 확보하려는 전략이다. 각각은 처리량, 지연 시간, 아키텍처 복잡도 등에서 상호 보완적이며, 시스템 목적에 따라 선택 또는 병행된다.

핵심 개념

• Batch는 대용량 데이터를 정확하게 처리하고, 일정 간격으로 분석과 보고서를 생성하는 데 적합하다.
• Stream은 지연 없이 이벤트를 실시간 처리하고, 즉시 반응해야 하는 시스템에 사용된다.
• Hybrid는 두 방식의 강점을 조합하여, 실시간성과 정합성이 모두 중요한 복잡한 비즈니스 도메인에서 사용된다.
  예: 이상 탐지, 실시간 사용자 분석, 추천 시스템 등.

실무 기술 스택 매핑

실무 적용 사례 및 고려 사항

하위 처리 기준 비교

아키텍처 연계 요약

Batch Processing vs. Stream Processing vs. Hybrid Processing 비교

각 처리 방식은 데이터의 시간적 특성과 비즈니스 요구사항에 따라 선택된다. 배치 처리는 정확성과 효율성을, 스트림 처리는 실시간성과 반응성을, 하이브리드 처리는 두 방식의 균형을 추구한다.

강점

약점

구조 및 아키텍처

아래 다이어그램은 각 처리 방식의 데이터 흐름과 구조를 시각적으로 보여준다.

flowchart TD
    subgraph Batch Processing
        A1[데이터 수집]
        A2[일괄 처리]
        A3[결과 저장 및 제공]
        A1 --> A2 --> A3
    end

    subgraph Hybrid Processing
        B1[데이터 수집]
        B2[배치 처리]
        B3[스트림 처리]
        B4[결과 통합 및 제공]
        B1 --> B2
        B1 --> B3
        B2 --> B4
        B3 --> B4
    end

    subgraph Stream Processing
        C1[데이터 수집]
        C2[실시간 처리]
        C3[결과 저장 및 제공]
        C1 --> C2 --> C3
    end

• 배치 처리: 데이터를 모아 일괄 처리, 결과 저장.
• 하이브리드 처리: 데이터가 동시에 배치와 스트림 경로로 전달, 결과를 통합.
• 스트림 처리: 데이터가 발생 즉시 실시간 처리.

구성 요소

작동 원리 및 데이터 흐름

• Batch: 느리지만 강력한 집계/분석용 처리 방식, 대규모 로그 분석이나 ETL 에 적합
• Stream: 실시간 반응이 필요한 모니터링, 알림 시스템 등에 필수적이며, 상태 기반 처리가 핵심
• Hybrid: 실시간성과 정확성을 동시에 만족하고자 할 때, 아키텍처 복잡도가 높은 대신 유연한 처리 가능

Batch Processing

sequenceDiagram
    participant Source
    participant Collector
    participant BatchEngine
    participant Storage
    participant BI

    Source->>Collector: Raw Data 수집 (Log, DB, File)
    Collector->>BatchEngine: 주기적 전달
    BatchEngine->>Storage: 결과 저장
    BI->>Storage: 쿼리

배치 처리 작동 원리:

1. 데이터 축적: 일정 기간 동안 데이터 수집 및 저장
2. 배치 생성: 처리 단위로 데이터 그룹화
3. 병렬 처리: 다수 노드에서 동시 처리
4. 결과 통합: 개별 결과를 최종 결과로 병합
5. 결과 저장: 처리된 데이터를 목적지에 저장

Stream Processing

sequenceDiagram
    participant EventSource
    participant StreamProcessor
    participant Storage
    participant Dashboard

    EventSource->>StreamProcessor: 실시간 이벤트 전송
    StreamProcessor->>Storage: 처리 결과 저장
    Dashboard->>Storage: 실시간 데이터 조회

스트림 처리 작동 원리:

1. 연속 수집: 실시간으로 데이터 스트림 수신
2. 윈도우 처리: 시간 또는 크기 기반 윈도우 적용
3. 상태 관리: 과거 이벤트 정보 유지 및 활용
4. 즉시 처리: 수신과 동시에 처리 로직 적용
5. 실시간 출력: 처리 결과 즉시 전달

Hybrid Processing

sequenceDiagram
    participant Source
    participant BatchLayer
    participant SpeedLayer
    participant Serving
    participant Client

    Source->>BatchLayer: 주기적 배치 데이터 전달
    Source->>SpeedLayer: 실시간 데이터 전달
    BatchLayer-->>Serving: 정확한 결과
    SpeedLayer-->>Serving: 실시간 결과
    Client->>Serving: 통합 결과 요청
    Serving-->>Client: 응답

구현 기법 비교

실무적 고려 요소 포함

Batch Processing

Spark Batch (PySpark)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

from pyspark.sql import SparkSession

# Spark 세션 생성
spark = SparkSession.builder.appName("BatchExample").getOrCreate()

# CSV 데이터 로드
df = spark.read.csv("data.csv", header=True, inferSchema=True)

# 그룹 집계
result = df.groupBy("category").sum("amount")

# 결과 저장
result.write.csv("output/result.csv")

Stream Processing

Kafka 소비 + 상태 관리 (Python + Kafka-python + Redis)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from kafka import KafkaConsumer
import redis
import json

# Kafka 소비자 설정
consumer = KafkaConsumer(
    'sensor-data',
    bootstrap_servers='localhost:9092',
    value_deserializer=lambda m: json.loads(m.decode('utf-8'))
)

# Redis로 상태 저장
r = redis.StrictRedis(host='localhost', port=6379, db=0)

for message in consumer:
    data = message.value
    sensor_id = data["sensor_id"]
    value = float(data["value"])

    # Redis에 누적값 저장
    prev = float(r.get(sensor_id) or 0)
    r.set(sensor_id, prev + value)

    print(f"Sensor {sensor_id} Total: {prev + value}")

Node.js 스트림 처리 (중첩 슬라이딩 윈도우)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

const { Transform } = require('stream');

let buffer = [];

const slidingWindow = new Transform({
  objectMode: true,
  transform(chunk, encoding, callback) {
    buffer.push(chunk);

    if (buffer.length > 5) buffer.shift();

    const average = buffer.reduce((acc, val) => acc + Number(val), 0) / buffer.length;
    console.log("Moving Average:", average.toFixed(2));
    callback(null, chunk);
  }
});

// 예시 스트림
require('fs')
  .createReadStream('data.txt')
  .pipe(require('split')()) // 한 줄씩
  .pipe(slidingWindow);

Hybrid Processing

Lambda Architecture 구성 예 (Batch + Stream)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Batch Layer: Spark로 집계
from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("BatchAggregation").getOrCreate()
batch_df = spark.read.json("historical_data.json")
agg = batch_df.groupBy("user_id").count()
agg.write.parquet("batch_output/")

# Stream Layer: 실시간 Kafka 스트림 처리
from kafka import KafkaConsumer
for msg in KafkaConsumer('realtime-data', bootstrap_servers='localhost:9092'):
    # Kafka 메시지 실시간 처리
    print("Streaming msg:", msg.value)

Replay-Based (Kafka 기반 재처리)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from kafka import KafkaConsumer

consumer = KafkaConsumer(
    'events',
    bootstrap_servers='localhost:9092',
    auto_offset_reset='earliest',  # 과거부터 다시 읽기
    enable_auto_commit=False
)

for message in consumer:
    event = message.value.decode("utf-8")
    print(f"Reprocessing Event: {event}")

실무 사용 예시

• 배치 처리는 정밀한 분석, 정기 보고, 대규모 데이터에 유리
• 스트림 처리는 실시간 반응성과 지연 최소화가 핵심인 도메인에 최적
• 하이브리드 처리는 실시간성과 정확성을 동시에 요구하는 복합 시나리오에 적합

도전 과제 및 해결 방안

실무에서 효과적으로 적용하기 위한 고려사항 및 주의할 점

최적화 고려사항 및 주의점

주제별 주목할 내용

반드시 학습해야할 내용

용어 정리

참고 및 출처

• Batch Processing vs. Stream Processing: A Comprehensive Guide – Rivery
• Batch Processing vs Stream Processing: Key Differences for 2025 – Atlan
• Difference between Batch Processing and Stream Processing – GeeksforGeeks
• Batch vs Stream Processing: When to Use Each and Why It Matters – DataCamp
• Batch vs Stream Processing: Differences and Use Cases – Snowflake
• What is Stream Processing? – Confluent
• Batch vs. Stream vs. Real‑Time Data Processing – Databricks
• Apache Flink Documentation – Apache Flink
• Apache Kafka Official Site – Apache Kafka
• Spark Structured Streaming Guide – Apache Spark
• Top Trends for Data Streaming with Apache Kafka and Flink in 2025 – Kai Waehner
• Lambda Architecture – Wikipedia
• Kappa Architecture Overview – Hazelcast
• Batch vs. Stream Processing – Towards Data Science