test0823d

Young-Kyoo Kim·2025년 8월 22일

좋아요. MinIO S3 스토리지를 **다양한 크기의 객체(object)**로 채우는 방법을 단계별로 정리해 드릴게요. 목적은 POC/성능 테스트, 용량 채우기, Small/Large Object 테스트 등 다양한 상황에서 활용할 수 있습니다.

1️⃣ 기본 방법: mc (MinIO Client) 사용

MinIO 공식 클라이언트 mc는 S3 API 기반으로 객체를 PUT/GET/DELETE할 수 있습니다.

설치

# Linux
wget https://dl.min.io/client/mc/release/linux-amd64/mc
chmod +x mc
sudo mv mc /usr/local/bin/

MinIO 서버 alias 등록

mc alias set myminio http://<MINIO_HOST>:9000 <ACCESS_KEY> <SECRET_KEY>

1.1 랜덤 데이터 파일 생성

# 1MB 파일 생성
dd if=/dev/urandom of=file_1MB bs=1M count=1

# 100MB 파일 생성
dd if=/dev/urandom of=file_100MB bs=1M count=100

1.2 객체 업로드

# 버킷 생성
mc mb myminio/testbucket

# 업로드
mc cp file_1MB myminio/testbucket/
mc cp file_100MB myminio/testbucket/

장점: 간단하고 S3 API 호환.
단점: 대량/병렬 업로드는 느릴 수 있음.

2️⃣ 고속/대량 테스트: MinIO Warp

warp는 MinIO가 제공하는 고성능 벤치마크 도구로, 다양한 object 크기, 멀티파트, 병렬 업로드 테스트 가능.

설치

wget https://dl.min.io/client/mc/release/linux-amd64/warp
chmod +x warp
sudo mv warp /usr/local/bin/

예제: 다양한 Object Size 업로드

# 1KB ~ 100MB 객체 1000개, 16 parallel, PUT
warp put --access-key <ACCESS_KEY> --secret-key <SECRET_KEY> \
  --host http://<MINIO_HOST>:9000 --bucket testbucket \
  --object-size 1KB,10KB,100KB,1MB,10MB,100MB --count 1000 --parallel 16

특징:

  • object-size를 콤마로 여러 값 지정 가능
  • --count: 총 업로드 수
  • --parallel: 동시에 몇 개 업로드할지

3️⃣ 스크립트 자동화 방법 (Bash + mc)

작은 파일 ~ 큰 파일을 섞어서 여러 개 업로드하는 예시:

#!/bin/bash

BUCKET="testbucket"
mc mb -p myminio/$BUCKET 2>/dev/null

SIZES=("1K" "10K" "100K" "1M" "10M" "100M")
COUNT=10  # 각 사이즈별 파일 수

for SIZE in "${SIZES[@]}"; do
  for i in $(seq 1 $COUNT); do
    FILENAME="${SIZE}_${i}.dat"
    # /dev/urandom으로 랜덤 데이터 생성
    dd if=/dev/urandom of=$FILENAME bs=$SIZE count=1 status=none
    mc cp $FILENAME myminio/$BUCKET/
    rm -f $FILENAME
  done
done

장점: 원하는 사이즈별 개수를 조절 가능, 버킷 여러 개에 분산 가능.

4️⃣ 파이썬 boto3 활용

MinIO는 S3 호환 API이므로 boto3로도 객체 생성 가능.

import boto3
import os
import random

s3 = boto3.client(
    's3',
    endpoint_url='http://<MINIO_HOST>:9000',
    aws_access_key_id='<ACCESS_KEY>',
    aws_secret_access_key='<SECRET_KEY>'
)

bucket_name = 'testbucket'
s3.create_bucket(Bucket=bucket_name)

sizes = [1024, 10*1024, 100*1024, 1024*1024]  # 1KB,10KB,100KB,1MB
for size in sizes:
    obj_name = f'obj_{size}.bin'
    data = os.urandom(size)
    s3.put_object(Bucket=bucket_name, Key=obj_name, Body=data)

장점: 테스트용 랜덤 데이터, 스크립트로 정밀 제어 가능, 멀티스레드로 병렬화 가능.

5️⃣ 추천 전략

목적방법특징
단순 소규모 POCmc + dd간단, 스크립트화 쉬움
대량/병렬/벤치마크warp성능 최대치 테스트 가능, 멀티 크기 지원
정밀 스크립트/자동화bash + mc / python boto3크기, 개수, 이름 등 정밀 제어, CI/CD 연동 가능

MinIO S3 스토리지에 다양한 크기의 객체 채우기 방법

MinIO는 AWS S3 호환 객체 스토리지로, MinIO Client (mc)를 사용해 쉽게 객체를 업로드할 수 있습니다. 아래는 MinIO 버킷을 생성하고, 로컬에서 다양한 크기의 파일을 생성한 후 업로드하는 단계별 가이드입니다. 이 방법은 Linux 환경을 가정하며, MinIO 서버가 이미 실행 중이고 mc 클라이언트가 설치되어 있다고 전제합니다. (mc 설치: https://min.io/docs/minio/linux/reference/minio-mc.html 참조)

1. 준비 단계

  • MinIO 서버 실행: MinIO 서버를 로컬이나 서버에서 실행하세요. 예: minio server /data --console-address ":9001"
  • mc alias 설정: MinIO 엔드포인트를 등록하세요. 예:
    mc alias set myminio http://localhost:9000 YOUR_ACCESS_KEY YOUR_SECRET_KEY
    여기서 http://localhost:9000은 MinIO 엔드포인트, 키는 MinIO 콘솔에서 확인.

2. 버킷 생성

mc mb 명령어를 사용해 버킷을 생성합니다. 버킷은 객체를 저장할 컨테이너입니다.

mc mb myminio/mybucket
  • 옵션: --with-versioning을 추가하면 버전 관리 활성화 (예: mc mb --with-versioning myminio/mybucket).
  • 이미 존재하면 --ignore-existing 옵션 사용.

3. 다양한 크기의 파일 생성

로컬에서 dd 명령어를 사용해 랜덤 데이터 파일을 생성합니다. /dev/urandom을 입력으로 사용하면 무작위 바이트로 채워집니다. bs (block size)와 count를 조합해 원하는 크기를 만듭니다. (예: bs=1K count=1 → 1KB 파일)

아래 스크립트 예시를 사용해 여러 크기의 파일을 한 번에 생성하세요. 파일은 현재 디렉토리에 저장됩니다.

#!/bin/bash

# 1KB 파일
dd if=/dev/urandom of=file_1KB bs=1K count=1

# 10KB 파일
dd if=/dev/urandom of=file_10KB bs=1K count=10

# 1MB 파일
dd if=/dev/urandom of=file_1MB bs=1M count=1

# 10MB 파일
dd if=/dev/urandom of=file_10MB bs=1M count=10

# 100MB 파일
dd if=/dev/urandom of=file_100MB bs=1M count=100

# 1GB 파일 (주의: 시간 소요, 큰 파일은 count 줄여 테스트)
dd if=/dev/urandom of=file_1GB bs=1M count=1024

echo "파일 생성 완료. ls -lh로 크기 확인하세요."
  • 실행: 스크립트를 저장 후 bash script.sh 실행.
  • 팁: 큰 파일(1GB 이상)은 생성 시간이 오래 걸리니, /dev/zero로 zeros 채우면更快: dd if=/dev/zero of=file_1GB bs=1M count=1024 (하지만 랜덤 데이터가 필요하면 urandom 사용).
  • 파일 크기 확인: ls -lh 또는 du -h file_*

4. 객체 업로드

mc cp 명령어를 사용해 파일을 MinIO 버킷으로 업로드합니다. 여러 파일을 한 번에 업로드할 수 있습니다.

  • 단일 파일 업로드:

    mc cp file_1KB myminio/mybucket/file_1KB

  • 여러 파일 업로드 (와일드카드 사용):

    mc cp file_* myminio/mybucket/

    이는 file_1KB, file_10KB 등 모든 매칭 파일을 업로드합니다.

  • 디렉토리 전체 업로드 (재귀적으로):
    파일들을 test_files/ 디렉토리에 모아두었다면:

    mc cp --recursive test_files/ myminio/mybucket/

  • 큰 파일 처리 옵션:

    • --disable-multipart: 작은 파일에 멀티파트 업로드 비활성화 (단순화).
    • --limit-upload 1G: 업로드 속도 제한 (큰 파일 네트워크 관리, 단위: KiB/s, MiB/s, GiB/s).
    • 예: 큰 파일 업로드 mc cp --limit-upload 500M file_1GB myminio/mybucket/file_1GB

업로드 후 확인: mc ls myminio/mybucket/로 객체 목록 보기.

추가 팁

  • AWS CLI 대안: mc 대신 AWS CLI 사용 가능 (S3 호환). alias 대신 aws --endpoint-url http://localhost:9000 s3 mb s3://mybucket 후 aws --endpoint-url http://localhost:9000 s3 cp file_* s3://mybucket/
  • 자동화: 스크립트로 파일 생성 + 업로드 결합. 예: 루프에서 크기 배열(1K, 10K, ...)로 dd와 mc cp 호출.
  • 테스트 주의: 큰 객체는 스토리지/네트워크 부하 발생. MinIO 콘솔(http://localhost:9001)로 업로드 확인.
  • 문제 해결: 업로드 실패 시 mc --debug로 로그 확인. 큰 파일은 멀티파트 자동 지원됨.

이 방법으로 MinIO 스토리지를 다양한 크기(1KB~1GB+) 객체로 채울 수 있습니다. 실제 워크로드에 맞게 조정하세요.

다양한 크기의 객체(Object Size)를 MinIO S3 스토리지에 채우는 방법

MinIO(S3 호환) 스토리지에 여러 크기의 객체를 대량으로 업로드하려면, 파일 생성·벤치마킹 도구·스크립트를 조합해 자동화할 수 있습니다. 아래에 대표적인 방법 4가지를 제시합니다.

1. Linux 기본 도구(dd/fallocate) + mc CLI

1.1. 파일 생성

  • 1 KiB: 
    dd if=/dev/zero of=obj_1KiB bs=1K count=1
  • 1 MiB: 
    dd if=/dev/zero of=obj_1MiB bs=1M count=1
  • 100 MiB: 
    fallocate -l 100M obj_100MiB

1.2. 버킷에 업로드

# MinIO 서버 및 자격증명 설정
export MINIO_SERVER="https://minio.local:9000"
export MINIO_ACCESS_KEY="YOURACCESSKEY"
export MINIO_SECRET_KEY="YOURSECRETKEY"

# 버킷 생성
mc mb local/mybucket

# 반복 업로드 예시 (10개씩)
for size in 1KiB 1MiB 100MiB; do
  for i in $(seq 1 10); do
    mc cp obj_${size} local/mybucket/${size}_${i}
  done
done

2. MinIO 전용 벤치마크 도구 Warp

MinIO에서 제공하는 warp 도구는 다양한 크기의 객체 업로드를 자동화하고 성능도 측정할 수 있습니다.

# 설치 (Go 환경 필요)
go install github.com/minio/warp@latest

# 1 MiB 객체 1,000개 업로드
warp put --host $MINIO_SERVER \
    --access-key $MINIO_ACCESS_KEY --secret-key $MINIO_SECRET_KEY \
    --bucket mybucket --prefix 1MiB/ --obj.size 1MiB \
    --objects 1000 --concurrent 64

# 혼합 워크로드: 1 KiB, 1 MiB, 10 MiB 객체 각각 500개씩
warp mixed --host $MINIO_SERVER \
    --access-key $MINIO_ACCESS_KEY --secret-key $MINIO_SECRET_KEY \
    --bucket mybucket --prefix mixed/ \
    --obj.size 1KiB-10MiB --objects 1500 --concurrent 128

3. Python 스크립트(boto3)

Python의 boto3 라이브러리를 활용해 다양한 사이즈의 객체를 동적으로 생성·업로드할 수 있습니다.

import boto3
import io
import os

# 환경 변수에서 자격증명 로드
s3 = boto3.resource(
    's3',
    endpoint_url=os.getenv('MINIO_SERVER'),
    aws_access_key_id=os.getenv('MINIO_ACCESS_KEY'),
    aws_secret_access_key=os.getenv('MINIO_SECRET_KEY'),
    config=boto3.session.Config(signature_version='s3v4'),
)

bucket = s3.Bucket('mybucket')
sizes = [1024, 1024*1024, 10*1024*1024]  # 1KiB, 1MiB, 10MiB

for size in sizes:
    for i in range(100):
        data = io.BytesIO(b'\0' * size)
        key = f"{size//1024}KiB/object_{i}"
        bucket.put_object(Key=key, Body=data)

4. s3cmd 또는 aws-cli

s3cmd

# 객체 생성
fallocate -l 5M obj_5MiB

# 업로드
for i in {1..50}; do
  s3cmd put obj_5MiB s3://mybucket/5MiB_${i}
done

AWS CLI

# AWS CLI 프로파일에 MinIO 설정 (config/credentials)
aws s3api create-bucket --bucket mybucket --endpoint-url $MINIO_SERVER

# 반복 업로드 (100 MiB 객체 20개)
fallocate -l 100M obj_100MiB
for i in $(seq 1 20); do
  aws s3 cp obj_100MiB s3://mybucket/100MiB_${i} --endpoint-url $MINIO_SERVER
done

📌 요약

  • 단일 파일 생성: dd, fallocate
  • 대량/혼합 워크로드: warp 벤치마크 도구
  • 프로그래밍 자동화: Python(boto3), Go(warp)
  • 범용 도구: mc, s3cmd, aws-cli

이 방법들을 조합하여 원하는 객체 크기와 개수로 MinIO 버킷을 채울 수 있습니다.

네, MinIO S3 스토리지에 다양한 크기의 객체를 채우는 가장 효율적인 방법은 셸 스크립트를 사용하는 것입니다. 스크립트를 이용하면 원하는 크기와 개수만큼 랜덤 데이터를 가진 파일을 자동으로 생성하고 업로드할 수 있습니다.

아래에 바로 사용 가능한 셸 스크립트와 그 사용법을 단계별로 안내해 드립니다.

## 셸 스크립트를 이용한 자동화 방법

이 스크립트는 지정된 크기(예: 1KB, 10MB, 128MB 등)의 파일을 지정된 개수만큼 생성하여 MinIO 버킷에 자동으로 업로드합니다.

1단계: MinIO 클라이언트(mc) 준비

먼저 터미널에서 mc 명령어를 사용할 수 있도록 설정해야 합니다.

# 'myminio'라는 별칭으로 MinIO 서버를 설정합니다. (정보는 실제 환경에 맞게 수정)
mc alias set myminio https://your-minio-server:9000 YOUR_ACCESS_KEY YOUR_SECRET_KEY

2단계: 스크립트 작성

아래 내용을 populate_minio.sh 라는 이름의 파일로 저장하세요.

#!/bin/bash

# --- ⚙️ 설정 (이 부분을 사용자에 맞게 수정하세요) ---
MC_ALIAS="myminio"                   # 1단계에서 설정한 MinIO 별칭
BUCKET_NAME="test-data"              # 데이터를 채울 버킷 이름
TEMP_DIR="/tmp/minio_gen_files"      # 파일 생성에 사용할 임시 폴더

# 생성할 파일 크기 목록 (K, M, G 등 단위 사용 가능)
SIZES=("1K" "256K" "1M" "32M" "128M")

# 각 크기별로 생성할 파일 개수
COUNT_PER_SIZE=10
# --- 설정 끝 ---


# --- 스크립트 실행 로직 ---
echo "🚀 MinIO 객체 생성을 시작합니다..."

# 1. 임시 폴더 생성
mkdir -p "$TEMP_DIR"
echo "임시 폴더 생성 완료: $TEMP_DIR"

# 2. 버킷 존재 여부 확인 및 생성
if ! mc ls "$MC_ALIAS/$BUCKET_NAME" &> /dev/null; then
  echo "버킷 '$BUCKET_NAME'이(가) 없습니다. 새로 생성합니다."
  mc mb "$MC_ALIAS/$BUCKET_NAME"
else
  echo "버킷 '$BUCKET_NAME'을(를) 사용합니다."
fi

# 3. 파일 생성 및 업로드 루프
for size in "${SIZES[@]}"; do
  echo "--- [크기: ${size}B] 파일 $COUNT_PER_SIZE 개 생성 및 업로드 시작 ---"
  for i in $(seq 1 $COUNT_PER_SIZE); do
    file_name="object_${size}_${i}.dat"
    file_path="$TEMP_DIR/$file_name"

    # 랜덤 데이터로 파일 생성 (head 명령어 사용)
    echo "  -> 생성 중: $file_name"
    head -c ${size}B < /dev/urandom > "$file_path"

    # MinIO에 파일 업로드
    echo "  -> 업로드 중: $file_name"
    mc cp "$file_path" "$MC_ALIAS/$BUCKET_NAME/"
  done
done

# 4. 임시 폴더 삭제
echo "🧹 임시 파일을 정리합니다..."
rm -rf "$TEMP_DIR"

echo "✅ 모든 작업이 완료되었습니다!"

3단계: 스크립트 실행

  1. 작성한 스크립트 파일에 실행 권한을 부여합니다.

    chmod +x populate_minio.sh

  2. 스크립트를 실행합니다.

    ./populate_minio.sh

이제 스크립트가 설정된 크기와 개수에 따라 자동으로 파일을 만들고 MinIO 버킷에 업로드하는 것을 볼 수 있습니다.

## 간단한 일회성 테스트 방법

스크립트 없이 특정 크기의 파일 하나만 빠르게 테스트하고 싶다면, 터미널에서 다음 명령어를 한 줄씩 실행하면 됩니다.

# 1. 10MB 크기의 랜덤 데이터 파일 생성
head -c 10M < /dev/urandom > random_10M.dat

# 2. MinIO 버킷에 업로드 ('myminio'와 'test-data'는 실제 환경에 맞게 수정)
mc cp random_10M.dat myminio/test-data/

# 3. 로컬에 생성된 파일 삭제
rm random_10M.dat

=======

좋아요. 말씀하신 환경을 기준으로, 70~80대 노드, 20 NVMe/노드, 25Gb/s x2 bonded 조건에서 MinIO Warp를 이용해 10KB~100MB 객체를 병렬로 수백만 개 업로드할 수 있는 배치 스크립트 예제를 만들어 드릴게요.

1️⃣ 전제 조건

  • MinIO 클러스터 주소: http://<MINIO_HOST>:9000
  • Access/Secret Key: <ACCESS_KEY> / <SECRET_KEY>
  • Warp 설치: /usr/local/bin/warp
  • 테스트 목적: 다양한 크기 객체 업로드 (10KB, 100KB, 1MB, 10MB, 100MB)
  • 병렬: 노드 수 × CPU 코어 활용 (멀티노드 병렬 가능)

2️⃣ 배치 스크립트 (Bash)

#!/bin/bash
# ===========================================
# MinIO Warp 대규모 객체 업로드 배치
# 노드 70~80대 환경, 10KB~100MB
# ===========================================

# MinIO 연결 정보
MINIO_HOST="http://<MINIO_HOST>:9000"
ACCESS_KEY="<ACCESS_KEY>"
SECRET_KEY="<SECRET_KEY>"
BUCKET="warp_test_bucket"

# 객체 크기 리스트
OBJECT_SIZES=("10KB" "100KB" "1MB" "10MB" "100MB")

# 각 크기당 업로드 수 (조정 가능)
COUNT=50000   # 예: 5만개
PARALLEL=32   # 각 노드에서 병렬 업로드

# Warp 설치 확인
command -v warp >/dev/null 2>&1 || { echo "warp 설치 필요"; exit 1; }

# 1. 버킷 생성 (이미 존재하면 무시)
warp mb --access-key $ACCESS_KEY --secret-key $SECRET_KEY --host $MINIO_HOST $BUCKET

# 2. 각 객체 크기별 업로드
for SIZE in "${OBJECT_SIZES[@]}"; do
    echo "=== Uploading objects of size $SIZE ==="
    warp put \
        --access-key $ACCESS_KEY \
        --secret-key $SECRET_KEY \
        --host $MINIO_HOST \
        --bucket $BUCKET \
        --object-size $SIZE \
        --count $COUNT \
        --parallel $PARALLEL
done

echo "=== Warp upload completed ==="

3️⃣ 멀티노드/멀티 프로세스 확장

  • 각 노드에서 위 스크립트를 실행하도록 Ansible, pdsh, tmux, GNU parallel 등을 활용 가능
  • 예: 70노드 × 32병렬 → 총 2240 병렬로 업로드

4️⃣ 주의 사항 & 최적화 팁

  1. Object Size Mix

    • 작은 파일(10KB100KB)은 수십만백만 단위
    • 큰 파일(10MB100MB)은 수만수십만 단위로 조정

  2. Warp 파라미터

    • --multipart-size를 지정하면 큰 파일 업로드 시 효율 ↑ (예: 10MB)
    • --concurrency와 --parallel 조합으로 CPU+네트워크 활용 최적화

  3. 스토리지 I/O 확인

    • 20 NVMe 디스크/노드 → Linux I/O scheduler, fio 벤치 확인 후 최적화
    • 필요시 noop 또는 mq-deadline scheduler 추천

  4. 모니터링

    • Prometheus + MinIO metrics 사용
    • 업로드 진행률, 에러율 확인

좋아요. 그러면 70~80대 노드 환경에서 MinIO Warp를 이용해 다양한 크기 객체를 분산 업로드하고, 로그와 결과를 수집/통계화하는 실전용 배치 스크립트 예제를 만들어 드릴게요.

1️⃣ 전제 조건

  • 노드 목록: nodes.txt (한 줄에 IP 또는 호스트명)
  • MinIO 클러스터 주소: http://<MINIO_HOST>:9000
  • Access/Secret Key: <ACCESS_KEY> / <SECRET_KEY>
  • Warp 설치: /usr/local/bin/warp
  • 업로드 객체 크기: 10KB, 100KB, 1MB, 10MB, 100MB
  • 각 객체별 업로드 수: 소형 50만, 중형 10만, 대형 1~5만 (조정 가능)
  • 병렬 수: CPU 코어 기준 (예: 32)

2️⃣ 디렉토리 구조

warp_distributed/
├─ nodes.txt
├─ warp_upload.sh
├─ logs/
└─ results/

3️⃣ nodes.txt 예시

node01
node02
node03
...
node80

4️⃣ warp_upload.sh (분산+로그+통계)

#!/bin/bash
# ===========================================
# Distributed Warp Upload for MinIO (POC)
# ===========================================

MINIO_HOST="http://<MINIO_HOST>:9000"
ACCESS_KEY="<ACCESS_KEY>"
SECRET_KEY="<SECRET_KEY>"
BUCKET="warp_test_bucket"

OBJECT_SIZES=("10KB" "100KB" "1MB" "10MB" "100MB")
UPLOAD_COUNTS=(500000 200000 100000 50000 10000)  # 객체 크기별 업로드 수
PARALLEL=32  # 병렬 처리 수

LOG_DIR="./logs"
RESULT_DIR="./results"
mkdir -p $LOG_DIR $RESULT_DIR

NODES_FILE="nodes.txt"
NODES=$(cat $NODES_FILE)

# 1. 버킷 생성
warp mb --access-key $ACCESS_KEY --secret-key $SECRET_KEY --host $MINIO_HOST $BUCKET

# 2. 멀티노드 분산 업로드
for SIZE_IDX in "${!OBJECT_SIZES[@]}"; do
    SIZE=${OBJECT_SIZES[$SIZE_IDX]}
    COUNT=${UPLOAD_COUNTS[$SIZE_IDX]}
    echo "=== Uploading objects of size $SIZE, count $COUNT ==="

    for NODE in $NODES; do
        LOG_FILE="$LOG_DIR/${NODE}_${SIZE}.log"
        RESULT_FILE="$RESULT_DIR/${NODE}_${SIZE}.result"

        echo "Dispatching to $NODE ..."

        ssh $NODE "nohup warp put \
            --access-key $ACCESS_KEY \
            --secret-key $SECRET_KEY \
            --host $MINIO_HOST \
            --bucket $BUCKET \
            --object-size $SIZE \
            --count $COUNT \
            --parallel $PARALLEL \
            --json > $RESULT_FILE 2>&1 &" &

    done
    wait
done

echo "=== All distributed uploads dispatched ==="

5️⃣ 특징

  1. 멀티노드 병렬 처리

    • 각 노드에서 warp put 병렬 실행
    • SSH를 통한 원격 실행 + nohup으로 백그라운드 처리

  2. 로그/결과 관리

    • 각 노드/각 객체 크기별 로그와 JSON 결과 저장
    • 나중에 통계 분석 가능 (jq, python pandas 등 활용)

  3. 대규모 POC 적합

    • 70~80대 노드, NVMe/CPU 리소스 활용 최적화
    • 객체 크기별, 노드별 성능 비교 가능

6️⃣ 추가 추천 사항

  • --multipart-size 옵션으로 10MB 이상 객체 분할 업로드 최적화
  • Prometheus + MinIO metrics로 업로드 속도, IOPS, 네트워크 사용량 모니터링
  • 업로드 후 warp stat 또는 mc admin info로 데이터 무결성 확인

원하시면 제가 이 스크립트에 자동 통계 분석 기능까지 포함해서,

  • 노드별 업로드 성공/실패 개수
  • 초당 처리량(OPS)
  • 총 전송량(TB 단위)

까지 자동으로 CSV나 요약 보고서로 만들어주는 버전으로 업그레이드해 드릴 수도 있어요.

그 버전까지 만들어 드릴까?

===
좋아요. 그러면 기존 분산 Warp 업로드 스크립트에 자동 통계 분석 기능을 추가해서, 각 노드별 성공/실패 건수, 초당 처리량(OPS), 총 전송량(TB)을 계산하고 CSV와 요약 보고서까지 만들어주는 완전판으로 만들어 드릴게요.

1️⃣ 디렉토리 구조 (업데이트)

warp_distributed/
├─ nodes.txt
├─ warp_upload_with_stats.sh
├─ logs/
├─ results/
└─ summary/
  • logs/ : 개별 노드/객체 업로드 로그
  • results/ : warp JSON 결과 파일
  • summary/ : 최종 CSV 및 요약 보고서

2️⃣ warp_upload_with_stats.sh

#!/bin/bash
# ===========================================
# Distributed Warp Upload + Stats for MinIO
# ===========================================

MINIO_HOST="http://<MINIO_HOST>:9000"
ACCESS_KEY="<ACCESS_KEY>"
SECRET_KEY="<SECRET_KEY>"
BUCKET="warp_test_bucket"

OBJECT_SIZES=("10KB" "100KB" "1MB" "10MB" "100MB")
UPLOAD_COUNTS=(500000 200000 100000 50000 10000)
PARALLEL=32

LOG_DIR="./logs"
RESULT_DIR="./results"
SUMMARY_DIR="./summary"
mkdir -p $LOG_DIR $RESULT_DIR $SUMMARY_DIR

NODES_FILE="nodes.txt"
NODES=$(cat $NODES_FILE)

CSV_FILE="$SUMMARY_DIR/warp_summary.csv"
REPORT_FILE="$SUMMARY_DIR/warp_report.txt"

# 1. CSV 헤더 생성
echo "node,object_size,count,success_count,failure_count,ops,total_bytes_tb" > $CSV_FILE

# 2. 버킷 생성
warp mb --access-key $ACCESS_KEY --secret-key $SECRET_KEY --host $MINIO_HOST $BUCKET

# 3. 멀티노드 분산 업로드
for SIZE_IDX in "${!OBJECT_SIZES[@]}"; do
    SIZE=${OBJECT_SIZES[$SIZE_IDX]}
    COUNT=${UPLOAD_COUNTS[$SIZE_IDX]}
    echo "=== Uploading objects of size $SIZE, count $COUNT ==="

    for NODE in $NODES; do
        LOG_FILE="$LOG_DIR/${NODE}_${SIZE}.log"
        RESULT_FILE="$RESULT_DIR/${NODE}_${SIZE}.json"

        echo "Dispatching to $NODE ..."

        ssh $NODE "nohup warp put \
            --access-key $ACCESS_KEY \
            --secret-key $SECRET_KEY \
            --host $MINIO_HOST \
            --bucket $BUCKET \
            --object-size $SIZE \
            --count $COUNT \
            --parallel $PARALLEL \
            --json > $RESULT_FILE 2>&1 &" &
    done
    wait
done

echo "=== All distributed uploads dispatched ==="
echo "=== Waiting for completion on all nodes ==="
# 간단한 wait 체크
sleep 60  # 필요시 더 긴 wait or node별 check 추가

# 4. 자동 통계 수집
echo "=== Collecting statistics ==="
for SIZE_IDX in "${!OBJECT_SIZES[@]}"; do
    SIZE=${OBJECT_SIZES[$SIZE_IDX]}
    for NODE in $NODES; do
        RESULT_FILE="$RESULT_DIR/${NODE}_${SIZE}.json"
        if [[ -f $RESULT_FILE ]]; then
            SUCCESS=$(jq '[.[] | select(.status=="success")] | length' $RESULT_FILE)
            FAIL=$(jq '[.[] | select(.status=="fail")] | length' $RESULT_FILE)
            TOTAL_BYTES=$(jq '[.[] | select(.status=="success") | .size] | add' $RESULT_FILE)
            TOTAL_SEC=$(jq '[.[] | select(.status=="success") | .duration_sec] | add' $RESULT_FILE)
            OPS=0
            if (( $(echo "$TOTAL_SEC > 0" | bc -l) )); then
                OPS=$(echo "scale=2; $SUCCESS / $TOTAL_SEC" | bc)
            fi
            TOTAL_TB=$(echo "scale=4; $TOTAL_BYTES/1024/1024/1024/1024" | bc)
            echo "$NODE,$SIZE,$COUNT,$SUCCESS,$FAIL,$OPS,$TOTAL_TB" >> $CSV_FILE
        fi
    done
done

# 5. 요약 보고서 생성
echo "=== Generating summary report ==="
echo "Warp Upload Summary Report" > $REPORT_FILE
echo "Date: $(date)" >> $REPORT_FILE
echo "Nodes: $(wc -l < $NODES_FILE)" >> $REPORT_FILE
echo "----------------------------------------" >> $REPORT_FILE
column -s, -t < $CSV_FILE >> $REPORT_FILE

echo "=== Completed. CSV: $CSV_FILE, Report: $REPORT_FILE ==="

3️⃣ 특징

  1. 자동 통계 분석 포함

    • 노드별 success_count, failure_count
    • 초당 처리량(OPS) 계산
    • 전송량(TB 단위) 계산

  2. 결과 저장

    • CSV: 데이터 분석/시각화용
    • TXT 보고서: 간단하게 보고용

  3. JSON 기반

    • Warp --json 옵션으로 결과 수집
    • jq로 노드/객체 단위 집계

  4. 확장성

    • 노드 수/객체 크기 자유롭게 조정 가능
    • 필요시 wait/check 로직으로 완료 여부 정밀 체크 가능

원하면 제가 이 스크립트를 완전 자동화 배치용으로 바꾸어서,

  • 업로드 완료 체크
  • 실패 시 재시도
  • 노드별 병렬 개수 조정

까지 포함한 운영용 POC 배포 스크립트로 만들어 드릴 수도 있어요.

profile
Young-Kyoo Kim
engineer
이전 포스트

test0823c2

다음 포스트

code0823

0개의 댓글