NAS and Object Storage

문제 - 로컬 디스크는 서버 한 대 안에서만 쓸 수 있음

[서버 A]
  디스크 → LVM → 파일시스템 → mount /data
  → /data 는 서버 A만 사용 가능
  • 서버 B가 서버 A의 /data를 볼 방법이 없음
  • 서버 A가 고장 나면 그 안의 데이터도 같이 못 씀

그래서 저장소를 서버 밖으로 빼서 네트워크로 제공함 네트워크로 무엇을 넘겨주느냐에 따라 세 가지로 나뉨

방식넘겨주는 것요청 단위장부(파일시스템)를 가진 쪽
SAN (Storage Area Network)디스크 (빈 칸)"몇 번 칸"받는 서버
NAS (Network Attached Storage)파일시스템 (폴더, 파일)"어느 파일의 어디"NAS
오브젝트 스토리지키 → 덩어리 창고"어느 키 덩어리 전체"스토리지 내부 관리 층
네트워크로 제공하는 것
├── SAN             → 디스크(빈 칸)
├── NAS             → 파일시스템(폴더/파일)
└── Object Storage  → "키 → 덩어리" 창고

1. NAS (Network Attached Storage)

파일시스템(장부)을 NAS가 직접 관리하면서, 네트워크로 들어오는 파일 단위 요청(열기, 읽기, 쓰기, 목록)을 대신 처리해 주는 저장장치 여러 서버가 같은 폴더를 mount해서 동시에 사용 가능

NAS 내부 구조

NAS 안을 열어 보면 디스크 → 파일시스템 구조가 그대로 있음

[NAS 10.0.0.50]
  디스크 여러 장
    → RAID / LVM 으로 묶고 나눔
    → 파일시스템 생성
    → /export/share 폴더
    → NFS 서버가 이 폴더를 네트워크로 공유
                │
                │  NFS (Network File System)
                │
     ┌──────────┼──────────┐
     │          │          │
[Server A] [Server B] [Server C]

# 세 서버 모두 같은 명령
mount 10.0.0.50:/export/share /mnt/nas
  • RAID (Redundant Array of Independent Disks) : 디스크 여러 장을 묶어 한 장이 고장 나도 데이터를 지키는 기술

"파일시스템을 공유한다"의 의미

SAN - 디스크(빈 칸)를 넘겨주는 경우

[저장장치]
  LV 하나를 네트워크로 넘겨줌 (빈 칸 덩어리 그대로)
        │
        ↓
[Server A]
  새 디스크 /dev/sdx 가 생김
  → mkfs.xfs /dev/sdx         장부를 서버 A가 직접 생성
  → mount /dev/sdx /data
  • 저장장치는 "1500번 칸 읽어줘 / 써줘" 같은 칸 단위 요청만 처리
  • 장부(파일시스템)는 받는 서버가 만들고 관리
  • 대표 기술 : iSCSI (Internet Small Computer Systems Interface)

NAS - 파일시스템을 공유하는 경우

[NAS]  장부를 NAS가 직접 생성·관리
  disk → LVM → mkfs → /export/share
        ↑
        │  파일 단위 요청: "logs/a.log 끝에 hi 추가해줘"
        │
[Server A]  mkfs 하지 않음
  mount -t nfs NAS:/export/share /mnt/nas
  • 서버 A는 칸 번호를 모름. 파일 이름과 폴더로만 요청
  • NAS가 자기 장부를 보고 "a.log는 300번 칸" 이라고 판단해서 대신 처리
SAN (블록)NAS (NFS)
요청 예READ 블록 1500, WRITE 블록 1500LOOKUP logs/a.log, READ a.log 0~100바이트, WRITE, CREATE, READDIR
요청 단위칸 번호파일 이름과 폴더
장부 위치받는 서버NAS
받는 서버가 하는 일mkfs + mountmount만

여러 서버가 같이 쓸 수 있는 이유

SAN에 서버 두 대가 같은 디스크를 붙이면

서버 A: 자기 메모리에 장부 사본 → "300번 칸 비었네, a.log 저장"
서버 B: 자기 메모리에 장부 사본 → "300번 칸 비었네, b.log 저장"
→ 같은 칸을 서로 덮어씀 → 파일시스템이 깨짐

NAS는

[Server A] ─┐  "a.log 저장해줘"
            ├─→ [NAS] 장부 하나로 순서대로 처리 → 충돌 없음
[Server B] ─┘  "b.log 저장해줘"

장부가 NAS 한 곳에만 있기 때문에 여러 서버가 같은 폴더를 공유할 수 있음

동작 방식

① NAS 쪽 - 이 폴더를 어떤 서버들에게 공개할지 설정

# NAS 서버의 /etc/exports
/export/share   10.0.0.0/24(rw)
└ 공유할 폴더      └ 이 IP 대역 서버들에게 읽기/쓰기(rw) 허용

② 사용하는 서버 - 주소로 mount

mount -t nfs 10.0.0.50:/export/share /mnt/nas
         │   │         │             └ 내 서버의 폴더
         │   │         └ NAS의 공유 폴더
         │   └ NAS IP
         └ 종류 (type)
  • 로컬 디스크는 장치 파일(/dev/...)을 연결하고, NAS는 IP:경로를 연결함
  • mount 이후에는 ls, cat, vi를 로컬 폴더처럼 그대로 사용

③ 실제 통신

[Server A]
  $ cat /mnt/nas/logs/a.log
  NFS 클라이언트가 파일 요청으로 변환
        │
        │  TCP 2049
        │  LOOKUP logs/a.log
        │  READ a.log 0~4KB
        ↓
[NAS 10.0.0.50]
  장부에서 a.log 찾기
  디스크에서 읽기
        │
        │  TCP 2049
        │  data
        ↓
[Server A]
  화면에 내용 출력

저장이 실제로 내려가는 경로

서버 A: echo "hi" >> /mnt/nas/logs/a.log
  → /mnt/nas 는 NFS mount
  → 네트워크로 NAS에 "a.log 끝에 hi 추가해줘" 요청
  → NAS 파일시스템 장부: "a.log = 칸 300, 301"
  → NAS LVM/RAID: "그 칸 = 디스크 3번의 ○○칸"
  → NAS 디스크에 기록
서버 B: cat /mnt/nas/logs/a.log → "hi" 보임

로컬 디스크의 저장 경로에 네트워크 한 단계만 끼어든 것

NAS의 성질

성질이유
진짜 폴더 트리파일시스템을 그대로 공유하기 때문
부분 수정, 이어 쓰기 가능장부로 칸 위치를 알아서 그 칸만 고치면 됨
여러 서버가 동시에 mount장부가 NAS 한 곳에 있기 때문
주소 = NAS IP:공유경로파일시스템 방식 그대로
포트 = TCP 2049NFS 표준 포트
인증 = 서버 IP 허용 + 리눅스 권한(rwx)/etc/exports로 접속 서버 IP 대역을 지정
확장 = 스케일 업장비에 디스크를 더 꽂거나 더 큰 장비로 교체

NAS의 약점

  • 장비 한 대가 중심이라 그 장비가 멈추면 mount한 모든 서버가 같이 멈춤 → SPOF (Single Point Of Failure)
  • 장비 한 대 크기에 한계가 있어서 무한정 키우기 어려움
  • 여러 서버가 같은 파일을 동시에 고치면 충돌에 주의해야 함

NAS와 NFS

  • NAS = 역할 또는 장비 이름
  • NFS = 그 장비와 대화하는 프로토콜 (윈도우는 SMB(Server Message Block) 사용)
  • 평범한 리눅스 서버에 NFS 서버 프로그램을 켜고 폴더를 공유하면, 그 서버가 NAS 역할을 함

2. 오브젝트 스토리지 (Object Storage)

이름표(키)를 붙인 데이터 덩어리를 HTTP(HyperText Transfer Protocol)로 통째로 맡기고 찾는 저장소 밖으로 파일시스템을 보여주지 않음

구성 요소

Bucket (버킷) = 오브젝트들을 담는 논리적 그릇
  └─ Object (오브젝트) = 맡긴 데이터 하나
       ├─ Key       : 이름표 "2026/11/12/db.dump"
       ├─ Data      : 내용물 (몇 KB ~ 몇 TB 바이트 덩어리)
       └─ Metadata  : 꼬리표 (크기, 종류, 만든 시각, 사용자 태그)
  • 키는 무언가를 담는 그릇이 아니라 오브젝트의 이름표
  • 오브젝트 하나의 주소 = 버킷 + 키 → s3://backup/2026/11/12/db.dump

논리 층과 물리 층

[논리 층] 사용자 눈에 보이는 것, 이름과 규칙만 있음

   bucket: backup      bucket: logs        bucket: models
     ├─ obj A            ├─ obj X            ├─ obj M
     └─ obj B            └─ obj Y            └─ ...

──────────────────────────────────────────────────────────────

[물리 층] 실제 장비, 디스크가 달린 서버(노드)들

   Node 1      Node 2      Node 3      Node 4       Node 5
   [A] [X]     [A] [M]     [B] [Y]     [A] [X] [M]  [B] [Y] [M]
  • 노드(서버) = 실제 물리 장치. 각 노드 안에는 디스크 → 파일시스템 구조가 있음
  • 버킷 = 노드들 위에 걸쳐 있는 논리적 분류. 물리 장치가 아님
  • 같은 버킷 안의 오브젝트들도 각자 다른 노드에 있음
  • 노드 하나 안에는 여러 버킷의 오브젝트가 섞여 있음
  • 복제·분산은 오브젝트(또는 그 조각) 단위로 일어남
  • 내부 관리 층이 "키 → 어느 노드에 있나"를 관리함. 사용자는 노드를 몰라도 됨

버킷이 갖는 것 - 이름과 규칙

버킷 설정예
이름backup, logs, models
접근 권한"이 Access Key는 logs에만 쓸 수 있음"
용량 제한(쿼터)logs 버킷은 최대 10TB
보관 규칙 (lifecycle)logs는 90일 지나면 자동 삭제
버전 관리 (versioning)덮어써도 이전 버전 보관

성격이 다른 데이터를 버킷으로 나누면 권한과 보관 기간을 버킷마다 다르게 적용할 수 있음

동작 방식 - mount가 아니라 HTTP 요청

필요한 정보는 세 가지

endpoint   : http://10.0.0.80          ← 스토리지 주소
bucket/key : backup / 2026/11/db.dump  ← 무엇을
auth       : Access Key / Secret Key   ← 누가 (인증)

요청 방법

PUT    /bucket/key              → 통째로 업로드
GET    /bucket/key              → 통째로 다운로드
DELETE /bucket/key              → 삭제
HEAD   /bucket/key              → 메타데이터만 조회
LIST   /bucket?prefix=2026/11/  → "2026/11/" 로 시작하는 키 목록

실제로 오가는 요청 - 웹 요청과 같은 모양

[Program on Server A]
  PUT /backup/2026/11/db.dump HTTP/1.1
  Host: 10.0.0.80
  Authorization: AWS4-HMAC-SHA256 Credential=<AccessKey>/... Signature=...
  Content-Length: 1073741824
  <db.dump 1GB 전체 내용>
        │
        │  TCP 80 / 443
        ↓
[Object Storage 10.0.0.80]
  키 확인 → 서명 검증
  노드 2, 5, 7에 나눠 저장
        │
        │  HTTP/1.1 200 OK
        ↓
[Program on Server A]
  업로드 완료
  • 주소 = endpoint + /버킷/키 → 결국 URL(Uniform Resource Locator) 하나
  • 포트 = HTTP 80, HTTPS(HTTP Secure) 443 (제품에 따라 9000 등)
  • 인증 = Secret Key로 요청에 서명(Signature)을 만들어 붙임. Secret Key 자체는 네트워크로 보내지 않음
  • mount 없이 요청할 때마다 이 정보를 보냄
  • 요청은 직접 쓰지 않고 도구나 SDK(Software Development Kit)가 대신 만들어 줌
aws s3 cp db.dump s3://backup/2026/11/db.dump --endpoint-url http://10.0.0.80   # 업로드
aws s3 ls s3://backup/2026/11/ --endpoint-url http://10.0.0.80                  # 목록

--endpoint-url을 지정하지 않으면 도구가 기본값인 AWS(Amazon Web Services) S3로 요청함

엔드포인트 (Endpoint)

서비스에 요청을 보낼 입구 주소

http://10.0.0.80:9000
└┬─┘   └───┬───┘ └┬─┘
 │         │      └ Port   : 포트, 그 서버의 몇 번 문으로? (생략 시 http=80, https=443)
 │         └ Host          : 호스트, 어느 서버? (IP 또는 도메인)
 └ Scheme                  : 프로토콜, 어떤 방식으로? (http / https)
  • 비유 : 콜센터 대표번호. 상담원이 몇 명이든 대표번호 하나로 연결됨
  • 뒤에 노드가 몇 대든 사용자는 엔드포인트 하나만 알면 됨
  • 엔드포인트 + /버킷/키 = 실제 요청 URL
endpoint                  /bucket/key                 request URL
http://10.0.0.80:9000  +  /backup/2026/11/db.dump  =  http://10.0.0.80:9000/backup/2026/11/db.dump

IP 대신 도메인으로 적어도 엔드포인트

http://storage.example.com:9000
   ↓ ① DNS(Domain Name System)에 질의 : "storage.example.com 의 IP는?" → 10.0.0.80
   ↓ ② 10.0.0.80 의 9000번 포트로 실제 연결
도메인을 쓰는 이유설명
IP가 바뀌어도 설정 유지DNS만 수정하면 됨
HTTPS 인증서인증서는 보통 도메인 이름으로 발급
분산도메인 하나 뒤에 여러 IP나 로드밸런서를 둘 수 있음

주의 : 요청을 보내는 서버에서 그 도메인이 IP로 풀려야 함

getent hosts storage.example.com   # 아무것도 안 나오면 DNS 미등록 → 접속 불가

오브젝트 스토리지의 성질

성질설명
폴더 없음 (평평한 구조)키의 /는 이름의 일부. 같은 앞부분(prefix)끼리 묶어 폴더처럼 보여줄 뿐
부분 수정 불가한 글자를 고쳐도 전체를 다시 올려 덮어씀. 이어 쓰기(append)도 안 됨
메타데이터오브젝트마다 꼬리표를 달아 관리
인증 = Access Key + Secret KeyIP가 아니라 키로 권한 부여
확장 = 스케일 아웃노드를 옆에 더 붙임 → PB(Petabyte)급까지 확장
튼튼함여러 노드에 복제·분산해서 일부 고장에도 데이터 유지

S3 호환

  • S3 (Simple Storage Service) = AWS의 오브젝트 스토리지 서비스 이름
  • S3의 API(Application Programming Interface) 규칙(PUT/GET 등)이 업계 표준이 됨
  • 다른 제품도 "S3와 같은 규칙으로 대화한다"는 의미로 S3 호환이라고 함
  • 프로그램은 endpoint와 키만 바꾸면 어떤 S3 호환 스토리지든 같은 방식으로 사용

오브젝트를 수정하려면

(1) GET  /bucket/report.csv  → 1GB 통째로 다운로드
(2) edit (local)             → 내 서버에서 끝에 3줄 추가
(3) PUT  /bucket/report.csv  → 같은 키로 1GB 통째로 다시 업로드
(4) replace (storage)        → 같은 키의 기존 오브젝트를 새 것으로 교체

3줄을 고치려고 1GB를 내려받고 다시 올림 → 자주 고치는 데이터에는 부적합

복사본은 스토리지가 알아서 처리

[교체 전]
  report.csv (옛 버전) → 노드 2, 5, 7 에 복사본

PUT 으로 새 버전 도착
  → 관리 층이 새 버전을 노드들에 새로 저장
  → 저장 완료 후 "report.csv = 새 버전" 으로 장부 교체
  → 사용자에게 200 OK 응답

[교체 후]
  report.csv (새 버전) → 노드들에 새 복사본
  옛 버전 복사본 → 스토리지가 뒤에서 정리 (versioning을 켜면 보관)
  • 사용자는 "같은 키로 PUT 했다"가 전부. 복사본을 직접 건드리지 않음
  • 200 OK 이후에는 누가 GET 하든 새 버전을 받음. 교체는 통째로 한 번에 일어남

동시에 고치면 마지막에 올린 것만 남음

서버 A: GET (원본) → 1줄 추가 → PUT
서버 B: GET (원본) → 2줄 추가 → PUT   ← 나중에 올림
결과: B의 버전만 남음. A가 추가한 1줄은 사라짐

기본적으로 파일 잠금(lock) 기능이 없음

그래서 실무에서는 수정하지 않고 새 조각을 계속 추가함

❌ app.log 하나를 계속 받아서 이어 쓰고 다시 올리기

✅ 일정 시간마다 모인 만큼 새 오브젝트로 올리기
   logs/2026/11/13/10-00.gz
   logs/2026/11/13/10-05.gz
   logs/2026/11/13/10-10.gz   ← 이미 올린 건 절대 고치지 않음
[쓰는 중]
  로컬 디스크나 NAS에서 이어 쓰기 (자주 고침)
        │
        │  일정량이 모이면
        ↓
[다 쓴 조각]
  오브젝트 스토리지에 새 오브젝트로 PUT (이후 읽기만)

3. 물리 장비인가, 클라우드인가

둘 다 세 가지 형태가 모두 있음

형태NAS오브젝트 스토리지
전용 물리 장비NAS 전용 장비오브젝트 스토리지 전용 장비
일반 서버 + 소프트웨어리눅스 서버 + NFS 서버 프로그램서버 여러 대 + MinIO, Ceph 같은 소프트웨어
클라우드 서비스AWS EFS(Elastic File System), Azure FilesAWS S3, Azure Blob, Google Cloud Storage
  • 폐쇄망에서는 클라우드를 쓸 수 없으므로 전용 장비나 서버 형태로 데이터센터 안에 둠
  • 물리 장비를 열어 보면 결국 디스크 → 파일시스템 구조가 바닥에 있음
NAS 1대
  디스크 여러 장 → RAID / LVM → 파일시스템 → 공유 폴더 → NFS로 공개

오브젝트 스토리지 (노드 여러 대)
  노드마다: 디스크 → 파일시스템
  그 위에: 오브젝트 관리 층 (키 → 노드 위치) → HTTP로 공개

4. 비교

NAS오브젝트 스토리지
단위파일 (부분 읽기/쓰기 가능)오브젝트 통째
구조진짜 폴더 트리버킷 + 키 (폴더 없음)
연결 방식mount 한 번 → 계속 연결요청마다 HTTP
주소NAS IP:/공유경로endpoint/버킷/키
프로토콜 / 포트NFS, TCP 2049HTTP(S), TCP 80 / 443
인증서버 IP 허용 + rwx 권한Access Key / Secret Key 서명
수정부분 수정, 이어 쓰기 가능통째로 교체만 가능
확장스케일 업 (장비를 키움)스케일 아웃 (노드를 옆에 추가)
서버에서 보이는 모습그냥 폴더 /mnt/nas폴더 없음, 도구나 프로그램으로 요청
비유공용 캐비닛 (사서가 장부 관리)택배 물류창고 (송장 번호로 상자째)
Local  : [Server] ─ FS ─ Disk                                   내 서버 안에 장부
NAS    : [Server] ──NFS──→ [NAS: FS ─ Disk]                    장부를 NAS가 관리
Object : [Server] ──HTTP──→ [Object Layer ─ (FS ─ Disk) x N]   밖에는 파일시스템을 안 보여줌

FS = 파일시스템, Object Layer = 키 → 노드 위치를 관리하는 오브젝트 관리 층

일반적인 쓰임새

데이터저장소이유
여러 서버가 같이 쓰는 작업 폴더NASmount해서 바로 고치며 씀
계속 이어 쓰는 로그 파일 (쓰는 중)NAS 또는 로컬이어 쓰기가 필요
백업 파일오브젝트한 번 쓰고 오래 보관, 대용량
다 모인 로그 묶음, 모니터링 지표 장기 보관오브젝트완성본을 싸게 오래 보관
이미지, 동영상오브젝트통째로 올리고 통째로 받음
AI 모델 파일오브젝트크고, 버전별 완성본

5. LV와 버킷의 범위 차이

LV는 같은 서버 안의 여러 디스크에 걸칠 수 있음

LVM은 VG(Volume Group)를 4MB짜리 작은 조각으로 나눠 관리함 → PE (Physical Extent) LV(Logical Volume)를 만든다는 것은 이 조각들을 필요한 만큼 골라 이어 붙인 조각 목록(지도)을 만드는 것

[서버 A]
  ├─ sdb (50GB)  ┐
  └─ sdc (50GB)  ┘→ PV → VG vg_data (100GB)

경우 ① 한 디스크에만 놓임
  lv_sw (30GB) = sdb의 조각들만 사용

경우 ② 두 디스크에 걸침 (sdb에 20GB만 남았을 때)
  lv_sw (30GB) = sdb 조각 20GB어치 + sdc 조각 10GB어치
  • OS 입장에서는 30GB 디스크 한 장(/dev/dm-N)으로 보임
  • device-mapper가 "LV의 이 칸 = sdb 몇 번 칸 / 저 칸 = sdc 몇 번 칸"을 번역함
  • 서버 경계는 넘지 않음

확인 - lvs -o +devices

[root@node01 ~]# lvs -o +devices
  LV   VG  Attr       LSize   ... Devices
  home rlm -wi-ao---- 852.76g     /dev/sda2(1983)
  root rlm -wi-ao----  70.00g     /dev/sda2(220290)
  swap rlm -wi-a-----  <7.75g     /dev/sda2(0)
  • /dev/sda2(1983) = sda2의 1983번 조각(PE)부터 이 LV가 시작
  • 디스크 여러 장에 걸친 LV라면 /dev/sdb(0),/dev/sdc(0) 처럼 쉼표로 여러 개가 나옴
LV시작 조각크기조각 수 (크기 ÷ 4MB)끝 조각
swap07.75G약 1,983개1,982
home1,983852.76G약 218,307개220,289
root220,29070.00G17,920개238,209
/dev/sda2
┌──────────┬────────────────────────────────────────┬──────────┐
│  swap    │                 home                   │   root   │
│ 0~1,982  │           1,983 ~ 220,289              │ 220,290~ │
└──────────┴────────────────────────────────────────┴──────────┘
                                                      끝까지 꽉 참 → VFree 0
  • Attr의 a = active(켜짐), o = open(사용 중). swap은 o가 없음 → 쿠버네티스 노드라 swap이 꺼져 있음

범위 비교

무엇에 걸치나범위
LVM의 LV한 서버 안의 여러 디스크서버 1대 안
오브젝트 스토리지의 버킷여러 서버(노드)서버 여러 대

결론

NAS    : [Server] ─mount─ TCP 2049 ───→ [NAS: FS → Disk]                 "파일 a.log의 여기"
Object : [Server] ─ TCP 80/443 ───────→ [Object Layer → Nodes → Disk]   "PUT /bucket/key + 서명 + 통째"
  • NAS는 파일시스템을 NAS가 직접 관리하면서 파일 단위 요청을 대신 처리해 주는 저장소. 장부가 한 곳에 있으므로 여러 서버가 같은 폴더를 mount해서 부분 수정과 이어 쓰기까지 함께 할 수 있음
  • 오브젝트 스토리지는 키를 붙인 데이터 덩어리를 HTTP로 통째로 주고받는 저장소. 버킷은 논리적 그릇이고, 오브젝트는 여러 노드에 복제되어 저장되며, 수정은 통째 교체로만 가능함

결국 작업 중인 데이터는 NAS, 완성된 데이터는 오브젝트 스토리지 → 작업대는 NAS, 창고는 오브젝트 스토리지

On this page