Split View: WEKA 고성능 스토리지 완전 가이드 2025: AI/HPC를 위한 병렬 파일시스템

일반적인 AI 훈련 파이프라인:

[스토리지] --읽기--> [CPU: 전처리] --전송--> [GPU: 훈련]
    ^                    ^                    ^
    |                    |                    |
  병목 1:              병목 2:              실제 연산:
  I/O 대기            데이터 변환           GPU 활용
  (30-50% 시간)       (10-20% 시간)        (30-60% 시간)

NFS (Network File System) 한계:
- 단일 서버 병목 (scale-up만 가능)
- 메타데이터 성능 제한
- 소규모 파일 I/O 비효율
- 수백 클라이언트 이상 스케일링 어려움

SAN/블록 스토리지 한계:
- 공유 파일시스템이 아님 (단일 마운트)
- 관리 복잡성
- 비용 높음

일반 분산 스토리지 한계:
- 레이턴시가 높음 (Ceph: 1-5ms)
- AI 워크로드 최적화 부족
- GPU Direct Storage 미지원

일반 NFS:
Client -> [NFS Server] -> [Disk]
                          (단일 경로)

병렬 파일시스템:
Client -> [Node 1] -> [Disk 1]  (동시 접근)
       -> [Node 2] -> [Disk 2]  (동시 접근)
       -> [Node 3] -> [Disk 3]  (동시 접근)
       -> [Node N] -> [Disk N]  (동시 접근)

  처리량 = 노드 수 x 노드당 처리량

+------------------------------------------------------------+
|                    WEKA Cluster                              |
|                                                              |
|  +------------------+  +------------------+                  |
|  | Backend Server 1 |  | Backend Server 2 |  ...            |
|  | +----+ +----+    |  | +----+ +----+    |                 |
|  | |NVMe| |NVMe|    |  | |NVMe| |NVMe|    |                 |
|  | +----+ +----+    |  | +----+ +----+    |                 |
|  | DPDK Networking   |  | DPDK Networking   |                |
|  +------------------+  +------------------+                  |
|                                                              |
|  Distributed Metadata (모든 노드에 분산)                       |
|  Erasure Coding Engine (N+2 or N+4)                          |
|  Inline Dedup + Compression                                  |
|                                                              |
|  +------------------+  +------------------+                  |
|  | Frontend Client 1|  | Frontend Client 2|  ...            |
|  | (Compute Node)   |  | (Compute Node)   |                 |
|  | GPU GPU GPU GPU   |  | GPU GPU GPU GPU   |                |
|  +------------------+  +------------------+                  |
+------------------------------------------------------------+

복제 방식 (3중 복제):
  Data -> Copy1, Copy2, Copy3
  오버헤드: 200% (1TB 데이터 = 3TB 소비)

이레이저 코딩 (N+2):
  Data -> Stripe1, Stripe2, ..., StripeN, Parity1, Parity2
  오버헤드: ~29% (N=7일 때, 7+2=9, 2/7=28.6%)
  최대 2개 노드 동시 장애 허용

이레이저 코딩 (N+4):
  오버헤드: ~57% (N=7일 때, 7+4=11, 4/7=57.1%)
  최대 4개 노드 동시 장애 허용

전통적 스토리지 I/O 경로:
Application -> VFS -> Filesystem -> Block Layer -> Device Driver -> NVMe
  (수많은 커널 컨텍스트 스위칭, 인터럽트, 복사)

WEKA I/O 경로 (DPDK):
Application -> WEKA Client (userspace) -> DPDK -> NVMe
  (커널 바이패스, 폴링 모드, 제로 카피)

+------------------------------------------------------------+
|  Hot Tier (NVMe)        Warm Tier         Cold Tier         |
|  +-----------------+  +-----------+  +------------------+   |
|  | Active Training |  | Recent    |  | S3 / Azure Blob  |   |
|  | Data            |  | Experiments|  | / GCS            |   |
|  | (Fast Access)   |  | (SSD)     |  | (Archived)       |   |
|  +-----------------+  +-----------+  +------------------+   |
|         ^                  ^                   ^            |
|         |                  |                   |            |
|    자동 티어링 정책: 접근 시간, 크기, 나이 기반                |
+------------------------------------------------------------+

# 백엔드 서버 상태 확인
weka cluster host
weka status

# 노드 상세 정보
weka cluster host -v

# WEKA 클라이언트 마운트
mount -t wekafs backend-host/fs-name /mnt/weka

# 또는 POSIX 마운트
weka local mount fs-name /mnt/weka

# 마운트 상태 확인
weka local status

# WEKA CLI 기본 명령어
weka status                        # 클러스터 상태
weka cluster host                  # 호스트 목록
weka fs                            # 파일시스템 목록
weka fs group                      # 파일시스템 그룹
weka alerts                        # 알림 확인

# 파일시스템 생성
weka fs create myfs default 10TiB

# 파일시스템 크기 조정
weka fs update myfs --total-capacity 20TiB

# 스냅샷
weka fs snapshot create myfs snap-before-training
weka fs snapshot list myfs
weka fs snapshot restore myfs snap-before-training

# 조직 생성
weka org create research-team

# 파일시스템 그룹 (용도별 분류)
weka fs group create ai-training --org research-team
weka fs group create inference --org research-team

# 할당량(Quota) 설정
weka fs quota set myfs --hard-limit 50TiB --path /projects/team-a

기존 I/O 경로:
Storage -> CPU Memory (bounce buffer) -> GPU Memory
           ^^^^^^^^^^^^^^^^^^^^^^^^^
           CPU 개입 필요, 추가 메모리 복사

GDS I/O 경로:
Storage -> GPU Memory (direct DMA)
           ^^^^^^^^^^^^^^^^^^^^^^^^
           CPU 바이패스, 제로 카피

// GDS를 사용한 파일 읽기 예시 (CUDA C)
#include <cufile.h>

// GPU 메모리 할당
void* gpu_buffer;
cudaMalloc(&gpu_buffer, file_size);

// cuFile 핸들 열기
CUfileDescr_t cf_desc;
CUfileHandle_t cf_handle;
cf_desc.type = CU_FILE_HANDLE_TYPE_OPAQUE_FD;

int fd = open("/mnt/weka/training_data.bin", O_RDONLY | O_DIRECT);
cf_desc.handle.fd = fd;

cuFileHandleRegister(&cf_handle, &cf_desc);

// GPU 버퍼 등록
cuFileBufRegister(gpu_buffer, file_size, 0);

// 스토리지에서 GPU로 직접 읽기
cuFileRead(cf_handle, gpu_buffer, file_size, 0, 0);
// CPU를 거치지 않고 스토리지에서 GPU 메모리로 직접 DMA 전송

# 1. NVIDIA 드라이버 및 CUDA 설치 확인
nvidia-smi
nvcc --version

# 2. GDS 패키지 설치
# NVIDIA GDS와 WEKA 클라이언트가 모두 필요

# 3. WEKA 마운트 시 GDS 활성화
mount -t wekafs -o gds backend-host/fs-name /mnt/weka

# 4. GDS 상태 확인
/usr/local/cuda/gds/tools/gds_stats

# 5. 성능 테스트
/usr/local/cuda/gds/tools/cufile_sample_001

import torch
from torch.utils.data import DataLoader, Dataset

class WEKAImageDataset(Dataset):
    def __init__(self, root_dir="/mnt/weka/imagenet"):
        self.root_dir = root_dir
        self.file_list = self._build_file_list()

    def _build_file_list(self):
        # WEKA의 빠른 메타데이터 처리로
        # 수백만 파일 목록을 수초 내에 구축
        import os
        files = []
        for root, dirs, fnames in os.walk(self.root_dir):
            for fname in fnames:
                if fname.endswith(('.jpg', '.jpeg', '.png')):
                    files.append(os.path.join(root, fname))
        return files

    def __len__(self):
        return len(self.file_list)

    def __getitem__(self, idx):
        img_path = self.file_list[idx]
        # WEKA의 낮은 레이턴시로 빠른 파일 접근
        image = read_image(img_path)
        return image

# 최적화된 DataLoader 설정
dataloader = DataLoader(
    WEKAImageDataset(),
    batch_size=256,
    num_workers=16,        # WEKA가 높은 동시성 지원
    pin_memory=True,       # GPU 전송 최적화
    prefetch_factor=4,     # 미리 읽기
    persistent_workers=True # 워커 재활용
)

from nvidia.dali import pipeline_def
import nvidia.dali.fn as fn
import nvidia.dali.types as types

@pipeline_def(batch_size=256, num_threads=12, device_id=0)
def training_pipeline():
    # WEKA에서 직접 읽기 (GDS 활용 가능)
    jpegs, labels = fn.readers.file(
        file_root="/mnt/weka/imagenet/train",
        random_shuffle=True,
        name="Reader"
    )
    # GPU에서 디코딩 (CPU 바이패스)
    images = fn.decoders.image_random_crop(
        jpegs, device="mixed",
        output_type=types.RGB
    )
    images = fn.resize(images, device="gpu", size=224)
    images = fn.crop_mirror_normalize(
        images, device="gpu",
        dtype=types.FLOAT,
        mean=[0.485 * 255, 0.456 * 255, 0.406 * 255],
        std=[0.229 * 255, 0.224 * 255, 0.225 * 255]
    )
    return images, labels

import torch

# 체크포인트 저장 (WEKA의 높은 쓰기 처리량 활용)
def save_checkpoint(model, optimizer, epoch, path="/mnt/weka/checkpoints"):
    checkpoint = {
        'epoch': epoch,
        'model_state_dict': model.state_dict(),
        'optimizer_state_dict': optimizer.state_dict(),
    }
    # LLM 모델의 경우 체크포인트 크기: 수 GB ~ 수십 GB
    torch.save(checkpoint, f"{path}/checkpoint_epoch_{epoch}.pt")

# 체크포인트 복원
def load_checkpoint(path, model, optimizer):
    checkpoint = torch.load(path)
    model.load_state_dict(checkpoint['model_state_dict'])
    optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
    return checkpoint['epoch']

ImageNet 데이터셋 예시:
- 총 파일 수: 약 1,400만 개
- 평균 파일 크기: ~100KB
- 에포크당 전체 데이터 읽기 필요

파일 시스템별 ImageNet 에포크 시간 (8x A100):
- NFS:    45분 (I/O 바운드)
- Lustre: 15분 (메타데이터 병목)
- WEKA:   3분  (GPU 바운드)

분산 훈련 아키텍처 (NCCL + WEKA):

+----------+  +----------+  +----------+  +----------+
| Node 1   |  | Node 2   |  | Node 3   |  | Node 4   |
| 8x H100  |  | 8x H100  |  | 8x H100  |  | 8x H100  |
+-----+----+  +-----+----+  +-----+----+  +-----+----+
      |              |              |              |
      +-------+------+------+------+------+-------+
              |      NCCL All-Reduce       |
              +----------------------------+
              |
      +-------+-------+
      |  WEKA Cluster  |
      | (공유 데이터)    |
      +----------------+

각 노드가 WEKA에서 독립적으로 데이터를 읽음
NCCL이 그래디언트 동기화 담당
WEKA가 32개 노드까지 선형 스케일링 제공

추론 워크로드 특성:
- 모델 로딩: 큰 파일 1회 읽기 (수 GB ~ 수십 GB)
- 추론 입력: 작은 파일 반복 읽기 (이미지, 텍스트)
- 레이턴시 민감: 실시간 응답 필요 (수 ms)

WEKA가 추론에 적합한 이유:
- 모델 파일의 빠른 로딩 (NVMe 캐싱)
- 낮은 첫 바이트 레이턴시 (200us 미만)
- 여러 추론 서버의 동시 모델 접근
- 모델 버전 관리 (스냅샷 활용)

+------------------------------------------------------------+
|              WEKA Tiered Storage                             |
|                                                              |
|  Tier 1: Hot (NVMe)                                         |
|  +------------------------------------------------------+   |
|  | 활성 훈련 데이터, 현재 실험 데이터셋                        |   |
|  | 레이턴시: 0.1ms 미만                                     |   |
|  | 처리량: 100+ GB/s                                       |   |
|  +------------------------------------------------------+   |
|                      |                                       |
|           자동 티어링 (접근 패턴 기반)                          |
|                      |                                       |
|  Tier 2: Warm (SSD, optional)                                |
|  +------------------------------------------------------+   |
|  | 최근 실험 데이터, 자주 접근하는 아카이브                      |   |
|  | 레이턴시: 0.5ms 미만                                     |   |
|  +------------------------------------------------------+   |
|                      |                                       |
|           Snap-to-Object 티어링                               |
|                      |                                       |
|  Tier 3: Cold (Object Storage)                               |
|  +------------------------------------------------------+   |
|  | S3 / Azure Blob / GCS                                   |   |
|  | 아카이브된 데이터셋, 오래된 체크포인트                        |   |
|  | 레이턴시: 수십 ms                                        |   |
|  | 비용: NVMe 대비 1/10 ~ 1/50                             |   |
|  +------------------------------------------------------+   |
+------------------------------------------------------------+

# 티어링 정책 설정
weka fs tier s3 add myfs \
  --obs-name my-s3-bucket \
  --obs-type s3 \
  --hostname s3.amazonaws.com \
  --port 443 \
  --bucket weka-tier-data \
  --access-key-id AKIAIOSFODNN7EXAMPLE \
  --secret-key wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

# 티어링 정책: 7일 미접근 데이터를 S3로 이동
weka fs tier s3 update myfs --tiering-cue 7d

# 수동 티어링 (특정 경로)
weka fs tier fetch myfs /datasets/imagenet  # S3에서 NVMe로 복원
weka fs tier release myfs /datasets/old_experiment  # NVMe에서 S3로 이동

전체 데이터: 5PB
- Hot (NVMe): 500TB (활성 훈련) = 약 7.5만 달러/월
- Cold (S3):  4.5PB (아카이브)  = 약 10.3만 달러/월
- 합계: 약 17.8만 달러/월

전부 NVMe에 보관 시: 약 75만 달러/월
절감률: 약 76%

AWS 배포 아키텍처:

+------------------------------------------------------------+
|  VPC                                                        |
|  +------------------+  +------------------+                  |
|  | WEKA Backend     |  | WEKA Backend     |  ...            |
|  | i3en.24xlarge    |  | i3en.24xlarge    |                  |
|  | (8x 7.5TB NVMe) |  | (8x 7.5TB NVMe) |                  |
|  | 100 Gbps ENA     |  | 100 Gbps ENA     |                  |
|  +------------------+  +------------------+                  |
|                                                              |
|  +------------------+  +------------------+                  |
|  | Compute Client   |  | Compute Client   |  ...            |
|  | p5.48xlarge      |  | p5.48xlarge      |                  |
|  | (8x H100 GPU)    |  | (8x H100 GPU)    |                  |
|  | 3200 Gbps EFA    |  | 3200 Gbps EFA    |                  |
|  +------------------+  +------------------+                  |
|                                                              |
|  S3 Bucket (Cold Tier)                                       |
+------------------------------------------------------------+

# AWS CloudFormation으로 WEKA 배포
aws cloudformation create-stack \
  --stack-name weka-cluster \
  --template-url https://weka-deploy-templates.s3.amazonaws.com/weka-latest.yaml \
  --parameters \
    ParameterKey=ClusterSize,ParameterValue=6 \
    ParameterKey=InstanceType,ParameterValue=i3en.24xlarge \
    ParameterKey=VpcId,ParameterValue=vpc-xxxxx

온프레미스 + 클라우드 하이브리드:

[온프레미스 WEKA 클러스터]
  - 상시 운영 워크로드
  - 민감한 데이터
  - NVMe Hot Tier
         |
    S3 티어링 (자동)
         |
[AWS S3]
         |
    클라우드 버스트 (필요 시)
         |
[AWS WEKA 클러스터 (임시)]
  - 대규모 훈련 작업
  - 온디맨드 GPU (p5 인스턴스)
  - 작업 완료 후 클러스터 해제

# 1. 온프레미스에서 데이터셋을 S3로 티어링
weka fs tier release myfs /datasets/large-training-set

# 2. AWS에서 임시 WEKA 클러스터 생성
# (CloudFormation/Terraform)

# 3. S3 데이터를 AWS WEKA로 페치
weka fs tier fetch myfs /datasets/large-training-set

# 4. 훈련 실행
# (분산 훈련 작업)

# 5. 결과를 S3로 저장
weka fs tier release myfs /results/experiment-42

# 6. AWS 클러스터 해제 (비용 절감)

백엔드 서버 (최소 6대 권장):
  CPU: 최소 19코어 (WEKA 전용 16코어 + OS 3코어)
  RAM: 최소 72GB (WEKA 전용 31GB + OS)
  NVMe: 최소 1개 (권장 4-8개, 각 1TB+)
  네트워크: 25GbE 이상 (권장 100GbE)

프론트엔드 클라이언트:
  CPU: 최소 2코어 (WEKA 클라이언트용)
  RAM: 최소 4GB (WEKA 클라이언트용)
  네트워크: 25GbE 이상

네트워크 요구사항:
  - 전용 DPDK NIC (Mellanox ConnectX-5/6 권장)
  - Jumbo Frame (MTU 9000)
  - 로스리스 네트워크 (RoCE v2 또는 InfiniBand)

# DPDK NIC 설정 확인
dpdk-devbind.py --status

# Mellanox NIC 설정
mlnx_tune -p THROUGHPUT

# MTU 설정
ip link set dev enp3s0f0 mtu 9000

# 1. WEKA 패키지 다운로드 및 설치
curl -o weka.tar https://get.weka.io/dist/v4.3/weka-4.3.tar
tar xf weka.tar
cd weka-4.3
./install.sh

# 2. 클러스터 생성
weka cluster create backend1 backend2 backend3 backend4 backend5 backend6

# 3. 드라이브 추가
weka cluster drive add --host backend1 /dev/nvme0n1 /dev/nvme1n1

# 4. 클러스터 시작
weka cluster start

# 5. 파일시스템 생성
weka fs create training-data default 100TiB

# 6. 클라이언트 마운트
mount -t wekafs backend1/training-data /mnt/weka

# 순차 읽기 테스트
fio --name=seq-read \
  --directory=/mnt/weka/fio-test \
  --rw=read \
  --bs=1M \
  --numjobs=16 \
  --iodepth=32 \
  --size=10G \
  --direct=1

# 랜덤 읽기 IOPS 테스트
fio --name=rand-read \
  --directory=/mnt/weka/fio-test \
  --rw=randread \
  --bs=4K \
  --numjobs=32 \
  --iodepth=64 \
  --size=1G \
  --direct=1

# 혼합 워크로드 (70% 읽기 / 30% 쓰기)
fio --name=mixed \
  --directory=/mnt/weka/fio-test \
  --rw=randrw \
  --rwmixread=70 \
  --bs=64K \
  --numjobs=16 \
  --iodepth=32 \
  --size=5G \
  --direct=1

# MLPerf Storage 벤치마크 실행
git clone https://github.com/mlcommons/storage_benchmark.git
cd storage_benchmark

# 구성 파일 설정
cat benchmark_config.yaml

# benchmark_config.yaml
benchmark:
  model: resnet50
  accelerator: h100
  num_accelerators: 8
  dataset_path: /mnt/weka/mlperf/imagenet
  results_dir: /mnt/weka/mlperf/results

주요 대시보드 항목:
- 클러스터 건강 상태 (녹색/황색/적색)
- 용량 사용률 및 추세
- 처리량/IOPS 실시간 그래프
- 노드별 성능 분포
- 티어링 상태 (NVMe vs S3 사용량)
- 알림 히스토리

# 알림 확인
weka alerts
weka alerts --severity critical

# 클러스터 상태
weka status
weka cluster host -v

# 성능 통계
weka stats --category ops
weka stats --category throughput
weka stats --category latency

# 용량 정보
weka fs --name training-data -v

# 현재 용량 사용량
weka fs --name training-data
# Total: 100 TiB, Used: 67 TiB, Available: 33 TiB

# 일별 증가량 추적
weka events --category capacity --start-time "7 days ago"

# 예상 고갈 시점 계산 (수동)
# 일평균 증가: 500GB
# 남은 용량: 33TB
# 예상 고갈: 약 66일

# 롤링 업그레이드 (무중단)
# 1. 새 버전 다운로드
weka cluster update download --url https://get.weka.io/dist/v4.4/weka-4.4.tar

# 2. 업그레이드 시작 (노드별 순차 진행)
weka cluster update start

# 3. 진행 상태 확인
weka cluster update status

# 4. 완료 확인
weka status

GPT-4 규모 훈련 예시:
- 훈련 데이터: 약 13TB (토큰화된 텍스트)
- 체크포인트: 각 약 2TB (수천 개)
- GPU 클러스터: 10,000+ H100
- 스토리지 요구: 200+ GB/s 읽기 처리량

WEKA 구성:
- 12노드 x 8 NVMe = 약 600TB Hot Tier
- S3에 체크포인트 자동 아카이브
- GDS로 GPU 활용률 95% 이상 유지

자율주행 데이터 규모:
- 차량당 일일 데이터: 약 20TB (카메라, LiDAR, 레이더)
- 전체 데이터셋: 수 PB ~ 수십 PB
- 훈련 주기: 지속적 (새 데이터 수집 + 재훈련)

WEKA의 역할:
- 수집된 센서 데이터의 고속 수집
- 라벨링/전처리 파이프라인 지원
- 모델 훈련 데이터 제공
- 시뮬레이션 결과 저장

유전체학 워크로드:
- WGS (Whole Genome Sequencing): 샘플당 약 100GB
- 대규모 코호트: 수만 샘플 = 수 PB
- 분석 파이프라인: 소규모 파일 수백만 개 생성

약물 발견:
- 분자 시뮬레이션: 높은 I/O 처리량 필요
- AI 기반 약물 스크리닝: GPU 집약적
- 데이터 공유: 여러 연구팀 동시 접근

리스크 모델링:
- 대규모 몬테카를로 시뮬레이션
- 밀리초 단위 레이턴시 요구
- 장내/장외 거래 데이터 분석

WEKA 장점:
- 초저 레이턴시 (0.1ms 미만)
- 결정적 성능 (지터 최소)
- 규제 요건에 맞는 데이터 보존

VFX 렌더링:
- 프레임당 수 GB의 텍스처/에셋
- 수백 대의 렌더 노드 동시 접근
- 높은 순차 읽기 처리량 필요

8K/16K 비디오 편집:
- 실시간 스트리밍: 프레임 드롭 없이 재생
- 다수의 편집자 동시 접근
- 대용량 프로젝트 파일 관리