리눅스 커널의 네임스페이스 메커니즘 심층 분석

네임스페이스란 무엇인가?

네임스페이스는 리눅스 커널이 제공하는 강력한 격리 메커니즘으로, 단일 호스트 상에서 여러 격리된 환경을 생성할 수 있게 합니다. 각 환경은 독립적인 시스템 자원 뷰를 가지며, 이는 도커와 쿠버네티스 같은 컨테이너 기술의 핵심 기반입니다.

네임스페이스를 통해 독립적인 시스템처럼 보이는 환경을 생성할 수 있으며, 실제로는 동일한 커널을 공유합니다. 이러한 격리 메커니즘은 컨테이너가 안전하고 격리된 환경에서 실행되면서도 자원을 효율적으로 활용할 수 있게 해줍니다.

네임스페이스의 종류

리눅스 커널은 여러 종류의 네임스페이스를 지원하며, 각각 다른 시스템 자원을 격리합니다:

• PID 네임스페이스: 프로세스 ID를 격리하여 각 네임스페이스 내에서 독립적인 PID 공간을 제공
• 네트워크 네임스페이스: 네트워크 장치, IP 주소, 포트 등 네트워크 자원을 격리
• 마운트 네임스페이스: 파일 시스템 마운트 지점을 격리
• UTS 네임스페이스: 호스트명과 도메인명을 격리
• IPC 네임스페이스: 프로세스 간 통신 자원을 격리
• 사용자 네임스페이스: 사용자와 그룹 ID를 격리
• Cgroup 네임스페이스: cgroups 뷰를 격리

네임스페이스의 작동 원리

1. 네임스페이스의 생성 및 관리

네임스페이스의 생성과 관리는 주로 다음 시스템 호출을 통해 이루어집니다:

• clone(): 새 프로세스를 생성할 때 특정 네임스페이스 유형을 지정
• unshare(): 기존 프로세스에서 새 네임스페이스 생성
• setns(): 프로세스를 기존 네임스페이스에 추가
• ioctl(): 네임스페이스 정보 가져오기

2. 네임스페이스의 계층 구조

네임스페이스는 계층 구조를 형성하며, 하위 네임스페이스는 상위 네임스페이스의 특정 속성을 상속하지만 독립적인 설정을 가질 수 있습니다:

• 새 네임스페이스를 생성할 때 현재 자원 상태를 상위 네임스페이스로부터 상속
• 하위 네임스페이스에서의 변경은 상위 네임스페이스에 영향을 미치지 않음
• 상위 네임스페이스는 하위 네임스페이스의 자원을 볼 수 있지만, 그 반대는 불가능

3. 네임스페이스 식별자

각 네임스페이스는 고유한 식별자를 가지며, 이는 `/proc/[pid]/ns/` 디렉토리의 파일을 통해 접근할 수 있습니다:

# 프로세스 1의 네임스페이스 확인
ls -la /proc/1/ns/

이 파일들은 네임스페이스를 식별하거나 프로세스를 기존 네임스페이스에 추가하는 데 사용할 수 있습니다.

주요 네임스페이스 유형 상세 분석

1. PID 네임스페이스

PID 네임스페이스는 프로세스 ID를 격리하여 각 네임스페이스 내에서 독립적인 PID 공간을 제공합니다. 새 PID 네임스페이스에서 첫 번째 프로세스는 PID가 1로 설정되며, 마치 새로운 시스템에서 시작되는 것처럼 동작합니다.

**사용 예시**:

# 새 PID 네임스페이스에서 bash 실행
unshare --pid --fork bash

# 새 네임스페이스에서 프로세스 확인
ps aux

**코드 예시**:

#include 
#include 
#include 
#include 
#include 

#define STACK_SIZE (1024 * 1024)

static char child_stack[STACK_SIZE];

static int process_runner(void *args) {
    printf("하위 프로세스 PID: %d\n", getpid());
    system("ps aux");
    return 0;
}

int main() {
    printf("상위 프로세스 PID: %d\n", getpid());
    
    int pid = clone(process_runner, child_stack + STACK_SIZE, CLONE_NEWPID | SIGCHLD, NULL);
    if (pid < 0) {
        perror("프로세스 생성 실패");
        return 1;
    }
    
    waitpid(pid, NULL, 0);
    return 0;
}

2. 네트워크 네임스페이스

네트워크 네임스페이스는 네트워크 장치, IP 주소, 포트 등 네트워크 자원을 격리합니다. 각 네트워크 네임스페이스는 네트워크 인터페이스, 라우팅 테이블, 방화벽 규칙 등을 포함하는 독립적인 네트워크 스택을 가집니다.

**사용 예시**:

# 새 네트워크 네임스페이스 생성
ip netns add test_net

# 새 네트워크 네임스페이스에서 명령 실행
ip netns exec test_net ip addr

# 네트워크 네임스페이스 삭제
ip netns delete test_net

**코드 예시**:

#include 
#include 
#include 
#include 
#include 

#define STACK_SIZE (1024 * 1024)

static char child_stack[STACK_SIZE];

static int network_handler(void *args) {
    printf("하위 네트워크 네임스페이스\n");
    system("ip addr");
    return 0;
}

int main() {
    printf("상위 네트워크 네임스페이스\n");
    system("ip addr");
    
    int pid = clone(network_handler, child_stack + STACK_SIZE, CLONE_NEWNET | SIGCHLD, NULL);
    if (pid < 0) {
        perror("프로세스 생성 실패");
        return 1;
    }
    
    waitpid(pid, NULL, 0);
    return 0;
}

3. 마운트 네임스페이스

마운트 네임스페이스는 파일 시스템 마운트 지점을 격리하여 각 네임스페이스가 독립적인 마운트 트리를 가질 수 있게 합니다.

**사용 예시**:

# 새 마운트 네임스페이스에서 bash 실행
unshare --mount --fork bash

# 새 네임스페이스에서 파일 시스템 마운트
mount -t tmpfs tmpfs /mnt

# 마운트 지점 확인
mount

**코드 예시**:

#include 
#include 
#include 
#include 
#include 
#include 

#define STACK_SIZE (1024 * 1024)

static char child_stack[STACK_SIZE];

static int mount_handler(void *args) {
    printf("하위 마운트 네임스페이스\n");
    
    // 새 네임스페이스에서 tmpfs 마운트
    if (mount("tmpfs", "/mnt", "tmpfs", 0, NULL) < 0) {
        perror("마운트 실패");
        return 1;
    }
    
    system("mount");
    return 0;
}

int main() {
    printf("상위 마운트 네임스페이스\n");
    system("mount | grep /mnt");
    
    int pid = clone(mount_handler, child_stack + STACK_SIZE, CLONE_NEWNS | SIGCHLD, NULL);
    if (pid < 0) {
        perror("프로세스 생성 실패");
        return 1;
    }
    
    waitpid(pid, NULL, 0);
    
    printf("\n하위 프로세스 종료 후 상위 마운트 네임스페이스\n");
    system("mount | grep /mnt");
    return 0;
}

4. UTS 네임스페이스

UTS 네임스페이스는 호스트명과 도메인명을 격리하여 각 네임스페이스가 독립적인 호스트명을 가질 수 있게 합니다.

**사용 예시**:

# 새 UTS 네임스페이스에서 bash 실행
unshare --uts --fork bash

# 새 네임스페이스에서 호스트명 변경
hostname test_container

hostname

**코드 예시**:

#include 
#include 
#include 
#include 
#include 
#include 

#define STACK_SIZE (1024 * 1024)

static char child_stack[STACK_SIZE];

static int uts_handler(void *args) {
    struct utsname system_info;
    
    // 호스트명 변경
    if (sethostname("test-container", 13) < 0) {
        perror("호스트명 변경 실패");
        return 1;
    }
    
    // 호스트명 가져와서 출력
    if (uname(&system_info) < 0) {
        perror("시스템 정보 가져오기 실패");
        return 1;
    }
    
    printf("하위 UTS 네임스페이스 호스트명: %s\n", system_info.nodename);
    return 0;
}

int main() {
    struct utsname system_info;
    
    // 호스트명 가져와서 출력
    if (uname(&system_info) < 0) {
        perror("시스템 정보 가져오기 실패");
        return 1;
    }
    
    printf("상위 UTS 네임스페이스 호스트명: %s\n", system_info.nodename);
    
    int pid = clone(uts_handler, child_stack + STACK_SIZE, CLONE_NEWUTS | SIGCHLD, NULL);
    if (pid < 0) {
        perror("프로세스 생성 실패");
        return 1;
    }
    
    waitpid(pid, NULL, 0);
    
    // 다시 호스트명 가져와서 출력
    if (uname(&system_info) < 0) {
        perror("시스템 정보 가져오기 실패");
        return 1;
    }
    
    printf("하위 프로세스 종료 후 상위 UTS 네임스페이스 호스트명: %s\n", system_info.nodename);
    return 0;
}

5. IPC 네임스페이스

IPC 네임스페이스는 메시지 큐, 공유 메모리, 세마포어 등 프로세스 간 통신 자원을 격리합니다.

**사용 예시**:

# 새 IPC 네임스페이스에서 bash 실행
unshare --ipc --fork bash

# 새 네임스페이스에서 IPC 자원 확인
ipcs

**코드 예시**:

#include 
#include 
#include 
#include 
#include 

#define STACK_SIZE (1024 * 1024)

static char child_stack[STACK_SIZE];

static int ipc_handler(void *args) {
    printf("하위 IPC 네임스페이스\n");
    system("ipcs");
    return 0;
}

int main() {
    printf("상위 IPC 네임스페이스\n");
    system("ipcs");
    
    int pid = clone(ipc_handler, child_stack + STACK_SIZE, CLONE_NEWIPC | SIGCHLD, NULL);
    if (pid < 0) {
        perror("프로세스 생성 실패");
        return 1;
    }
    
    waitpid(pid, NULL, 0);
    return 0;
}

6. 사용자 네임스페이스

사용자 네임스페이스는 사용자와 그룹 ID를 격리하여 네임스페이스 내에서 호스트 시스템과 다른 사용자와 그룹 ID를 사용할 수 있게 합니다. 이는 중요한 보안 메커니즘으로, 비특권 사용자가 네임스페이스 내에서 루트 권한을 가질 수 있게 해줍니다.

**사용 예시**:

# 새 사용자 네임스페이스에서 bash 실행
unshare --user --fork bash

# 새 네임스페이스에서 사용자 ID 확인
id

**코드 예시**:

#include 
#include 
#include 
#include 
#include 
#include 

#define STACK_SIZE (1024 * 1024)

static char child_stack[STACK_SIZE];

static int user_handler(void *args) {
    printf("하위 사용자 네임스페이스\n");
    printf("현재 UID: %d, GID: %d\n", getuid(), getgid());
    
    // 사용자 네임스페이스에서 uid를 0(root)로 설정
    if (setuid(0) < 0) {
        perror("사용자 ID 설정 실패");
        return 1;
    }
    
    printf("setuid(0) 후 UID: %d, GID: %d\n", getuid(), getgid());
    return 0;
}

int main() {
    printf("상위 사용자 네임스페이스\n");
    printf("현재 UID: %d, GID: %d\n", getuid(), getgid());
    
    int pid = clone(user_handler, child_stack + STACK_SIZE, CLONE_NEWUSER | SIGCHLD, NULL);
    if (pid < 0) {
        perror("프로세스 생성 실패");
        return 1;
    }
    
    waitpid(pid, NULL, 0);
    return 0;
}

7. Cgroup 네임스페이스

Cgroup 네임스페이스는 cgroups 뷰를 격리하여 각 네임스페이스가 자신의 cgroups 계층 구조만 볼 수 있게 합니다.

**사용 예시**:

# 새 cgroup 네임스페이스에서 bash 실행
unshare --cgroup --fork bash

# 새 네임스페이스에서 cgroups 확인
ls -la /sys/fs/cgroup/

**코드 예시**:

#include 
#include 
#include 
#include 
#include 

#define STACK_SIZE (1024 * 1024)

static char child_stack[STACK_SIZE];

static int cgroup_handler(void *args) {
    printf("하위 cgroup 네임스페이스\n");
    system("ls -la /sys/fs/cgroup/");
    return 0;
}

int main() {
    printf("상위 cgroup 네임스페이스\n");
    system("ls -la /sys/fs/cgroup/");
    
    int pid = clone(cgroup_handler, child_stack + STACK_SIZE, CLONE_NEWCGROUP | SIGCHLD, NULL);
    if (pid < 0) {
        perror("프로세스 생성 실패");
        return 1;
    }
    
    waitpid(pid, NULL, 0);
    return 0;
}

네임스페이스의 실제 적용

1. 컨테이너 기술

네임스페이스는 컨테이너 기술의 핵심 기반 중 하나로, cgroups와 함께 컨테이너의 기초를 형성합니다:

• 도커: 네임스페이스를 사용하여 격리된 컨테이너 환경 생성
• 쿠버네티스: 도커 등 컨테이너 런타임을 기반으로 리소스 격리를 위해 네임스페이스 사용
• LXC/LXD: 네임스페이스와 cgroups를 사용하여 경량 컨테이너 생성

2. 보안 격리

네임스페이스는 보안 격리 환경 생성에 사용할 수 있습니다:

• 샌드박스: 신뢰할 수 없는 코드를 실행하기 위한 격리된 샌드박스 환경 생성
• 다중 테넌트 환경
: 단일 서버에서 여러 사용자를 위한 격리된 환경 제공
• 테스트 환경: 프로덕션 환경에 영향을 주지 않는 격리된 테스트 환경 생성

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define STACK_SIZE (1024 * 1024)

static char child_stack[STACK_SIZE];

static int container_process(void *args) {
    printf("컨테이너 시작\n");
    
    // proc 파일 시스템 마운트
    if (mount("proc", "/proc", "proc", 0, NULL) < 0) {
        perror("proc 마운트 실패");
        return 1;
    }
    
    // 명령 실행
    execl("/bin/bash", "bash", NULL);
    
    return 0;
}

int main() {
    printf("컨테이너 생성 중\n");
    
    // 새 네임스페이스 생성
    int pid = clone(container_process, child_stack + STACK_SIZE, 
                   CLONE_NEWPID | CLONE_NEWNET | CLONE_NEWNS | 
                   CLONE_NEWUTS | CLONE_NEWIPC | SIGCHLD, NULL);
    
    if (pid < 0) {
        perror("프로세스 생성 실패");
        return 1;
    }
    
    printf("컨테이너 PID: %d\n", pid);
    
    // 하위 프로세스 종료 대기
    waitpid(pid, NULL, 0);
    
    printf("컨테이너 종료\n");
    return 0;
}

#include 
#include 
#include 
#include 
#include 
#include 

#define STACK_SIZE (1024 * 1024)

static char child_stack[STACK_SIZE];

static int network_isolation(void *args) {
    printf("네트워크 네임스페이스 생성 완료\n");
    
    // 네트워크 구성
    system("ip link set lo up");
    system("ip addr add 192.168.1.1/24 dev lo");
    system("ip addr");
    
    // 명령 실행
    execl("/bin/bash", "bash", NULL);
    
    return 0;
}

int main() {
    printf("네트워크 네임스페이스 생성 중\n");
    
    // 새 네트워크 네임스페이스 생성
    int pid = clone(network_isolation, child_stack + STACK_SIZE, 
                   CLONE_NEWNET | SIGCHLD, NULL);
    
    if (pid < 0) {
        perror("프로세스 생성 실패");
        return 1;
    }
    
    printf("네트워크 네임스페이스 PID: %d\n", pid);
    
    // 하위 프로세스 종료 대기
    waitpid(pid, NULL, 0);
    
    printf("네트워크 네임스페이스 종료\n");
    return 0;
}