Docker Engine, ์ œ๋Œ€๋กœ ์ดํ•ดํ•˜๊ธฐ (1)

2022. 1. 16. 13:01ใ†BACKEND

๋ฐ˜์‘ํ˜•

๐Ÿ“Œ  Docker Series

> Docker Engine, ์ œ๋Œ€๋กœ ์ดํ•ดํ•˜๊ธฐ (1) - docker engine deep dive

Docker Engine, ์ œ๋Œ€๋กœ ์ดํ•ดํ•˜๊ธฐ (2) - namespace, cgroup

Docker Network, ์ œ๋Œ€๋กœ ์ดํ•ดํ•˜๊ธฐ (1) - libnetwork

Docker Network, ์ œ๋Œ€๋กœ ์ดํ•ดํ•˜๊ธฐ (2) - bridge, host, none drivers

Docker, ์ œ๋Œ€๋กœ ์‚ฌ์šฉํ•˜๊ธฐ - Commands



์•ˆ๋…•ํ•˜์„ธ์š”. ์˜ค๋Š˜์€ Docker Engine์— ๋Œ€ํ•ด ๊นŠ๊ฒŒ ๋‹ค๋ฃจ๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค.

 

์ด ํฌ์ŠคํŒ…์˜ ๋ชฉ์ ์€ dockerEngine์˜ ๋‚ด๋ถ€ ๊ตฌ์กฐ์™€ ๋™์ž‘์›๋ฆฌ ๋“ฑ์„ ์ตœ๋Œ€ํ•œ ์ž์„ธํžˆ ๋‹ค๋ฃจ๋Š”๋ฐ ์žˆ์Šต๋‹ˆ๋‹ค.

์ด ๊ธ€์„ ์ฝ๋Š” ๋…์ž๊ฐ€ Docker image, container ๋“ฑ ๊ธฐ๋ณธ์ ์ธ ๊ฐœ๋…์„ ์ดํ•ดํ•œ๋‹ค๋Š” ๊ฐ€์ •ํ•˜์— ์ž‘์„ฑํ•ฉ๋‹ˆ๋‹ค.

 

 

์ฐธ๊ณ  ์‚ฌํ•ญ์œผ๋กœ, ํฌ์ŠคํŒ…์€ " ๋Œ€์ฃผ์ œ(์ด๋ชจ์ง€+ํŒŒ๋ž€๊ธ€์ž) > โœ”๏ธ ์†Œ์ฃผ์ œ > # ๋ฌธ๋‹จ ํ‚ค์›Œ๋“œ " ๋กœ ๋ถ„๋ฆฌํ•ด์„œ ์ •๋ฆฌํ–ˆ์Šต๋‹ˆ๋‹ค.

 

ํ•ด๋‹น ํฌ์ŠคํŒ…์˜ ๋ชจ๋“  ๊ทธ๋ฆผ์€ ์ง์ ‘ ๊ทธ๋ฆฐ ๊ฒƒ์œผ๋กœ, ์‚ฌ์šฉ์‹œ ์ถœ์ฒ˜ ํ‘œ์‹œ ๋ถ€ํƒ๋“œ๋ฆฝ๋‹ˆ๋‹ค ๐Ÿ™๐Ÿป.

 

-----------------    INDEX     -----------------

 

[ 1๋ถ€ ]

History

Background

์ดˆ๊ธฐ Docker engine

docker daemon

LXC

Docker Engine

big picture

docker client

dockerd

containerd

runc

shim

 

[ 2๋ถ€ ]

Namespace

cgroups

 

[ Docker Network ]

(1) deep dive

----------------------------------------------

 

 

โ›ฑ  History

 

Docker๋Š” ์ปจํ…Œ์ด๋„ˆ ๊ธฐ์ˆ ์„ ์‚ฌ์šฉํ•˜์—ฌ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์— ํ•„์š”ํ•œ ํ™˜๊ฒฝ์„ ์‹ ์†ํ•˜๊ฒŒ ๊ตฌ์ถ•ํ•˜๊ณ  ํ…Œ์ŠคํŠธ ๋ฐ ๋ฐฐํฌ๋ฅผ ํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•ด์ฃผ๋Š” ํ”Œ๋žซํผ์ž…๋‹ˆ๋‹ค. Docker๋Š” ์™œ ์ƒ๊ฒผ์„๊นŒ์š”? ์•„์ฃผ ์งง๊ฒŒ ๊ทธ ํƒ„์ƒ ๊ณผ์ •์— ๋Œ€ํ•ด ์•Œ์•„๋ณผ๊ฒŒ์š”.

 

โœ”๏ธ  Background

# VMware

์•„-์ฃผ ์˜ˆ์ „์—๋Š” ํ•˜๋‚˜์˜ ์„œ๋ฒ„ ๋‹น ํ•˜๋‚˜์˜ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์ด ๋™์ž‘๋์Šต๋‹ˆ๋‹ค.

๋™์ผํ•œ ์„œ๋ฒ„์—์„œ ์—ฌ๋Ÿฌ ๊ฐœ์˜ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์„ ์šด์˜ ๋ฉด์—์„œ๋‚˜ ๋ณด์•ˆ๋ฉด์—์„œ๋‚˜ ์•ˆ์ „ํ•˜๊ฒŒ ์‹คํ–‰์‹œํ‚ค๋Š” ๊ธฐ์ˆ ์ด ์—†์—ˆ์ฃ .

 

๊ทธ๋ž˜์„œ ์ƒˆ๋กœ์šด ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์ด ํ•„์š”ํ•  ๋•Œ๋งˆ๋‹ค ์„œ๋ฒ„๋ฅผ ๊ตฌ๋งคํ•ด์•ผํ–ˆ๊ณ ,

๋ฌด์กฐ๊ฑด ์„ฑ๋Šฅ๊ณผ ๊ทœ๋ชจ๊ฐ€ ์ข‹์€ ๊ฒƒ์„ ๊ตฌ๋งคํ•˜๋Š๋ผ ๋‚ญ๋น„๊ฐ€ ์‹ฌํ–ˆ์Šต๋‹ˆ๋‹ค.

 

๊ทธ๋Ÿฌ๋‹ค๊ฐ€ '๊ฐ€์ƒ ๋จธ์‹  VM'์ด๋ผ๋Š” ๊ฐœ๋…์ด ์„ธ์ƒ์— ๋‚˜์˜ค๊ฒŒ ๋˜์—ˆ๊ณ ,

ํ•˜๋‚˜์˜ ์šด์˜์ฒด์ œ ์œ„์˜ ์—ฌ๋Ÿฌ OS๋ฅผ ์‹คํ–‰์‹œ์ผœ ๋‚ญ๋น„๋ฅผ ํฌ๊ฒŒ ์ค„๊ฒŒ ํ•ด์ฃผ์—ˆ์Šต๋‹ˆ๋‹ค.

 

ํ•˜์ง€๋งŒ, ๊ฐ€์ƒ๋จธ์‹ ๋„ ๊ฒฐํ•จ์„ ๊ฐ–๊ณ  ์žˆ๋Š”๋ฐ์š”.

ํ•˜๋‚˜์˜ VM ๋งˆ๋‹ค ๊ณ ์œ ํ•œ OS๊ฐ€ ํ•„์š”ํ•˜๊ธฐ ๋•Œ๋ฌธ์—,

๊ฐ๊ฐ CPU, RAM ๋ฐ ๊ธฐํƒ€ ๋ฆฌ์†Œ์Šค๋ฅผ ์†Œ๋น„ํ•˜๋ฉฐ ๋ณด๋‹ค ๋งŽ์€ ์‹œ๊ฐ„๊ณผ ์ž์›์„ ๋‚ญ๋น„ํ•˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

๋˜ํ•œ ํŠน์ • OS๋Š” ๋ผ์ด์„ผ์Šค๊ฐ€ ํ•„์š”ํ•œ ๊ฒฝ์šฐ๋„ ์žˆ์Šต๋‹ˆ๋‹ค. 

 

 

# Container

์œ„์˜ VM ๋ชจ๋ธ์˜ ๋‹จ์ ๋“ค๋กœ ์ธํ•ด ๊ตฌ๊ธ€๊ณผ ๊ฐ™์€ ๋Œ€ํ˜• ํšŒ์‚ฌ๋“ค์€ ์ปจํ…Œ์ด๋„ˆ ๊ธฐ์ˆ ์„ ์‚ฌ์šฉํ•ด์™”์Šต๋‹ˆ๋‹ค.

 

์ปจํ…Œ์ด๋„ˆ ๋ชจ๋ธ์—์„œ ์ปจํ…Œ์ด๋„ˆ๋Š” VM๊ณผ ์œ ์‚ฌํ•ฉ๋‹ˆ๋‹ค.

์ฃผ์š” ์ฐจ์ด์ ์€ ์ปจํ…Œ์ด๋„ˆ์— ์ž์ฒด์ ์ธ ํ•˜๋‚˜์˜ ์™„์ „ํ•œ OSfull-blown OS ๊ฐ€ ํ•„์š”ํ•˜์ง€ ์•Š๋‹ค๋Š” ์ ์ž…๋‹ˆ๋‹ค.

 

์‹ค์ œ๋กœ ์ปจํ…Œ์ด๋„ˆ ๋ชจ๋ธ์—์„œ๋Š” ๋‹จ์ผ ํ˜ธ์ŠคํŠธ์˜ ๋ชจ๋“  ์ปจํ…Œ์ด๋„ˆ๋Š” ํ˜ธ์ŠคํŠธ์˜ OS๋ฅผ ๊ณต์œ ํ•ฉ๋‹ˆ๋‹ค.

์ด ๊ฒƒ์€ CPU, RAM ๋ฐ ์Šคํ† ๋ฆฌ์ง€์™€ ๊ฐ™์€ ๋ง‰๋Œ€ํ•œ ์–‘์˜ ์‹œ์Šคํ…œ ๋ฆฌ์†Œ์Šค๊ฐ€ ํ™•๋ณด๋œ๋‹ค๋Š” ์˜๋ฏธ๋ฅผ ๊ฐ€์ง‘๋‹ˆ๋‹ค.

๋˜ํ•œ , ๋ผ์ด์„ผ์Šค ๋น„์šฉ์„ ์ ˆ๊ฐํ•  ์ˆ˜ ์žˆ๊ณ  OS ํŒจ์น˜ ๋ฐ ์œ ์ง€๋ณด์ˆ˜์˜ ์˜ค๋ฒ„ํ—ค๋“œ๋ฅผ ์ค„์—ฌ์ฃผ๋ฉฐ VM์˜ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

 

๊ฒฐ๊ณผ์ ์œผ๋กœ, VM์—์„œ ์ปจํ…Œ์ด๋„ˆ๋ฅผ ์‚ฌ์šฉํ•œ ํ›„ ์‹œ๊ฐ„์ด๋‚˜ ๋ฆฌ์†Œ์Šค ๋ฐ ๋„คํŠธ์›Œํฌ๋ฅผ ์ ˆ๊ฐํ•  ์ˆ˜ ์žˆ๋Š”๋ฐ์š”.

์ปจํ…Œ์ด๋„ˆ๋Š” ๋˜ํ•œ ์‹œ๋™๋„ ๋น ๋ฅด๊ณ  ๋งค์šฐ ํœด๋Œ€์„ฑ์ด ๋›ฐ์–ด๋‚ฉ๋‹ˆ๋‹คultra-portable.

์ปจํ…Œ์ด๋„ˆ ์›Œํฌ๋กœ๋“œ๋ฅผ ๋…ธํŠธ๋ถ์—์„œ ํด๋ผ์šฐ๋“œ๋กœ, ํ˜น์€ ๋ฒ ์–ด๋ฉ”ํƒˆ ์„œ๋ฒ„๋กœ ์‰ฝ๊ฒŒ ์ด๋™ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

 

 

 

 

 

โœ”๏ธ  ์ดˆ๊ธฐ Docker Engine

์ดˆ๊ธฐ Docker๋Š” ํ˜„์žฌ ๋ชจ๋ธ๊ณผ๋Š” ๋‹ค๋ฅด๊ฒŒ Docker Daemon, LXC ๋ผ๋Š” ๋‘ ๊ฐœ์˜ ์ฃผ์š” ๊ตฌ์„ฑ์„ ๊ฐ€์ง€๊ณ  ์žˆ์—ˆ์Šต๋‹ˆ๋‹ค.

 

 

์ดˆ๊ธฐ Docker Engine model

 

โœ”๏ธ  docker daemon

์ด ๋•Œ Dokcer Daemon์€ ํ˜„์žฌ์˜ Docker Daemon๊ณผ๋Š” ๋‹ฌ๋ž๋Š”๋ฐ์š”.

The Docker daemon๋Š” ๋ชจ๋†€๋ฆฌ ๋ฐ”์ด๋„ˆ๋ฆฌmonolithic binary์ด์—ˆ์Šต๋‹ˆ๋‹ค. (๋ชจ๋“ˆํ™”๊ฐ€ ๋˜์–ด์žˆ์ง€ ์•Š์Œ)

Docker Daemon์— Docker client, the Docker API, container runtime, image builds ๋“ฑ์„ ๋น„๋กฏํ•œ ๋งŽ์€ ์ฝ”๋“œ๋“ค์„ ๋‹ด๊ณ  ์žˆ์—ˆ์Šต๋‹ˆ๋‹ค.

 

 

โœ”๏ธ  LXC

 

LXC Architecture

 

 

LXC๋Š” ๋‹จ์ผ ์ปจํŠธ๋กค ํ˜ธ์ŠคํŠธ ์ƒ์—์„œ ์—ฌ๋Ÿฌ๊ฐœ์˜ ๊ณ ๋ฆฝ๋œ ๋ฆฌ๋ˆ…์Šค ์‹œ์Šคํ…œ(์ปจํ…Œ์ด๋„ˆ)๋“ค์„ ์‹คํ–‰ํ•˜๊ธฐ ์œ„ํ•œ ์šด์˜ ์‹œ์Šคํ…œ ๋ ˆ๋ฒจ ๊ฐ€์ƒํ™” ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค. daemon์—๊ฒŒ Linux kernel์— ์กด์žฌํ•˜๋Š” ์ปจํ…Œ์ด๋„ˆ์˜ ๊ธฐ๋ณธ building block์— ๋Œ€ํ•œ namespaces๋‚˜ cgroups(control groups)์™€ ๊ฐ™์€ ์ ‘๊ทผ์„ ์ œ๊ณตํ–ˆ์Šต๋‹ˆ๋‹ค.

 

namespace๋Š” ๊ฐ„๋‹จํžˆ ๋งํ•˜์ž๋ฉด,  ์šด์˜ ์‹œ์Šคํ…œ์„ ์ชผ๊ฐœ์„œ ๊ฐ๊ฐ ๊ณ ๋ฆฝ๋œ ์ƒํƒœ๋กœ ์šด์˜์ด ๋˜๋Š” ๊ฐœ๋…์„ ์˜๋ฏธํ•ด์š”. 

cgroups๋Š” ๊ฐ„๋‹จํžˆ ๋งํ•˜์ž๋ฉด,  namespaces์œผ๋กœ ๊ณ ๋ฆฝ๋œ ํ™˜๊ฒฝ์—์„œ ์‚ฌ์šฉํ•  ์ž์›์„ ์ œํ•œํ•˜๋Š” ์—ญํ•  ๋“ฑ์„ ํ•˜๋Š” ๊ฐœ๋…์ž…๋‹ˆ๋‹ค.

์ด ๋ถ€๋ถ„์€ Building Block์„ ์ดํ•ดํ•œ ํ›„ ๋‹ค์‹œ ๋ณด๋ฉด ์ดํ•ดํ•˜๋Š”๋ฐ ๋„์›€์ด ๋˜์‹ค๊ฑฐ์—์š”.

 

์–ด์จŒ๋“ , ๋ถ„๋ฆฌ๋œ ํ›„ ๊ณ ๋ฆฝ๋œ ๊ฐ๊ฐ์˜ ํ™˜๊ฒฝ๋“ค์ด ๋งŒ๋“ค์–ด์ง„๋‹ค๋Š” ๊ฒƒ์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ๋Š”๋ฐ์š”.

container์˜ ๊ฐœ๋…์„ ์•Œ๊ณ  ์žˆ๋‹ค๋ฉด, ๋ฐ”๋กœ ์ด ๊ธฐ์ˆ ์ด container ๊ธฐ์ˆ ์˜ ๊ทผ๊ฐ„์ด๋ผ๋Š” ๊ฒƒ์„ ์˜ˆ์ƒํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

 

 

 

# LXC์˜ ๋ฌธ์ œ์ 

LXC๋Š” ๋ฆฌ๋ˆ…์Šค์— ํŠนํ™”๋˜์–ด ์žˆ๋Š”๋ฐ, Docker๊ฐ€ Multi-Platform์„ ๋ชฉํ‘œ๋กœ ํ•˜๋Š”๋ฐ ํฐ ๋ฆฌ์Šคํฌ์˜€์Šต๋‹ˆ๋‹ค.

๋˜ํ•œ, ์‹œ์Šคํ…œ์„ ๊ตฌ์„ฑํ•˜๋Š” ํ•ต์‹ฌ์ ์ธ ์š”์†Œ๊ฐ€ ์™ธ๋ถ€ ์‹œ์Šคํ…œ์— ์˜์กดํ•œ๋‹ค๋Š” ๋ฌธ์ œ๋„ ์žˆ์—ˆ์Šต๋‹ˆ๋‹ค.

 

๋•Œ๋ฌธ์— Docker์‚ฌ๋Š” LXC๋ฅผ ๋Œ€์ฒดํ•˜๊ธฐ ์œ„ํ•ด libcontainer๋ผ๋Š” ๋…์ž์ ์ธ ํˆด์„ ๊ฐœ๋ฐœํ–ˆ์œผ๋ฉฐ,

go ์–ธ์–ด๋กœ ์ž‘์„ฑ๋˜์–ด platform-agnostic(๋ถˆํŠน์ • ํ”Œ๋žซํผ) ํˆด๋กœ ๋งŒ๋“ค์–ด์ฃผ์—ˆ์Šต๋‹ˆ๋‹ค.

 

๊ทธ๋ž˜์„œ Docker 0.9๋ถ€ํ„ฐ ๊ธฐ๋ณธ ์‹คํ–‰ ๋“œ๋ผ์ด๋ฒ„๋ฅผ LXC์—์„œ libcontainer๋กœ ๋Œ€์ฒดํ–ˆ์Šต๋‹ˆ๋‹ค.

 

 

# Libcontainer

Libcontainer๋Š” ํ˜„์žฌ์˜ Docker Engine์—์„œ ์‚ฌ์šฉํ•˜๊ณ  ์žˆ๋Š” ์ฃผ์š” ์ปดํฌ๋„ŒํŠธ์ž…๋‹ˆ๋‹ค.

Go ์–ธ์–ด๋กœ ๋งŒ๋“ค์–ด์ ธ์„œ Container๋ฅผ ์ƒ์„ฑ ์‹œ namespaces, cgroups, capabilities ๋ฅผ ์ œ๊ณตํ•˜๊ณ , filesystem์˜ ์ ‘๊ทผ์„ ์ œํ•œํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ปจํ…Œ์ด๋„ˆ๊ฐ€ ์ƒ์„ฑ๋œ ํ›„ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ๋„๋ก ์ปจํ…Œ์ด๋„ˆ์˜ ์ˆ˜๋ช… ์ฃผ๊ธฐ๋ฅผ ๊ด€๋ฆฌํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

 

 

docker architecture

 

 

์œ„ ๊ทธ๋ฆผ์„ ๋ณด๋ฉด ์•Œ ์ˆ˜ ์žˆ๋“ฏ์ด, Libcontainer๋Š”Docker์™€ ๋ถ„๋ฆฌ๋œ LXC์™€๋Š” ๋‹ค๋ฅด๊ฒŒ,

Docker ๋‚ด๋ถ€์—์„œ ์‹คํ–‰๋˜๊ณ  ์žˆ๋Š” ๊ฒƒ์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. 

 

Docker์—์„œ๋Š” ์ž์ฒด์ ์œผ๋กœ ์ œ์ž‘ํ•œ libcontainer์˜ CLI wrapper์ธ runc๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

 

 

์ž, ๊ทธ๋Ÿผ ์ด์ œ ๋ณธ๊ฒฉ์ ์œผ๋กœ ์ปจํ…Œ์ด๋„ˆ์˜ ๊ตฌ์กฐ๋ฅผ ์•Œ์•„๋ณผ๊ฒŒ์š”.

๋„์ปค ๋‚ด๋ถ€๋ฅผ ์•Œ์•„๊ฐ€๊ธฐ ์ „์— ๋„์ปค ์šฉ์–ด๋ฅผ ํ™•์‹คํžˆ ํ•˜๊ณ  ๋„˜์–ด๊ฐ€์•ผ ํ•  ๊ฒƒ ๊ฐ™์•„์š”.

๋„์ปค์˜ ๊ตฌ์กฐ๋ฅผ ์‚ดํ”ผ๋ฉฐ ์ž์ฃผ ์‚ฌ์šฉํ•  ๋‹จ์–ด๋“ค์„ ํ•œ๋ฒˆ์”ฉ ์งš๊ณ  ๊ฐ€๊ฒ ์Šต๋‹ˆ๋‹ค.

 

 

 

 

โš™๏ธ  Docker Engine

Docker๋Š” Client-Server ๋ชจ๋ธ์„ ๊ตฌํ˜„ํ•œ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์ž…๋‹ˆ๋‹ค.

Docker Engine์€ Docker Components์™€ ์„œ๋น„์Šค๋ฅผ ์ œ๊ณตํ•˜๋Š” ์ปจํ…Œ์ด๋„ˆ๋ฅผ ๊ตฌ์ถ•ํ•˜๊ณ  ์‹คํ–‰ํ•˜๋Š” ๊ธฐ๋ณธ ํ•ต์‹ฌ ์†Œํ”„ํŠธ์›จ์–ด์ž…๋‹ˆ๋‹ค.

 
Docker Engine์€ Docker Daemon, REST API, API๋ฅผ ํ†ตํ•ด ๋„์ปค ๋ฐ๋ชฌ๊ณผ ํ†ต์‹ ํ•˜๋Š” CLI๋กœ ๋ชจ๋“ˆ์‹์œผ๋กœ ๊ตฌ์„ฑ๋˜์–ด์žˆ์Šต๋‹ˆ๋‹ค.

๊ฐœ๋ฐœ์ž๋“ค์ด Docker๋ผ๊ณ  ํ•  ๋•Œ, ์ฃผ๋กœ Docker engine์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.

 

Docker Engine์€ ์ž๋™์ฐจ์˜ ์—”์ง„๊ณผ ๋น„๊ตํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

 

 

์ž๋™์ฐจ ์—”์ง„๊ณผ ๋„์ปค ์—”์ง„์€ ๋น„์œ ๋ฅผ ํ•˜์ž๋ฉด, ๋‘˜ ๋‹ค ๋ชจ๋“ˆ์‹์ด๊ณ  ๋งŽ์€ ์ „์šฉ ๋ถ€ํ’ˆ๋“ค์— ์˜ํ•ด ์—ฐ๊ฒฐ๋˜์–ด ์ œ์ž‘๋ฉ๋‹ˆ๋‹ค.

Car Engine — intake manifolds, throttle body, cylinders, spark plugs, exhaust manifolds etc.
Docker Engine — APIs, execution driver, runtimes, shims etc.

 

 

์•„๋ž˜์˜ ๊ทธ๋ฆผ์œผ๋กœ ๊ตฌ์กฐ๋ฅผ ์‰ฝ๊ฒŒ ํŒŒ์•…ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

 

Docker Engine

 

 

์ปจํ…Œ์ด๋„ˆ๋ฅผ ๋นŒ๋“œ, ์‹คํ–‰, ๋ฐฐํฌํ•˜๋Š” ๋“ฑ์˜ ๋ฌด๊ฑฐ์šด ์ž‘์—…์€ Docker Daemon์ด ํ•˜๋ฉฐ,

Docker Client๋Š” ์ด๋Ÿฌํ•œ ๋กœ์ปฌ ํ˜น์€ ์›๊ฒฉ์˜ Docker Daemon๊ณผ ํ†ต์‹ ํ•ฉ๋‹ˆ๋‹ค.

ํ†ต์‹ ์„ ํ•  ๋•Œ์—๋Š” UNIX socket(/var/run/docker.sock) ๋˜๋Š” ๋„คํŠธ์›Œํฌ ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ํ†ตํ•œ REST API๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

 

์ฃผ๋กœ ์‚ฌ๋žŒ๋“ค์ด "docker"๋ผ๋Š” ๋‹จ์–ด๋ฅผ ๋งํ•  ๋•Œ๋Š” ๋‹ค์–‘ํ•œ ์˜๋ฏธ๋ฅผ ๊ฐ€์งˆ ์ˆ˜ ์žˆ๋Š”๋ฐ์š”.

"docker"๋Š” Docker Engine ๋ฟ๋งŒ ์•„๋‹ˆ๋ผ Docker Client, ํ˜น์€ Docker Inc.(๋„์ปค ๊ฐœ๋ฐœ์‚ฌ)๋ฅผ ์˜๋ฏธํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

 

 

โœ”๏ธ  big picture

Docker Engine์ด ๋™์ž‘๋˜๋Š” ํฐ ๊ทธ๋ฆผ์„ ๋จผ์ € ๋ณผ๊ฒŒ์š”.

์•„๋ž˜์˜ ๊ธฐ๋Šฅ๋“ค์„ ๋จผ์ € ์ตํžŒ๋‹ค์Œ ์ฝ์–ด๋„ ์ข‹์Šต๋‹ˆ๋‹ค.

 

 

1) docker client

 

 

๊ฐ€์žฅ ๋จผ์ €, ์œ ์ €๊ฐ€ Docker CLI๋ฅผ ํ†ตํ•ด ์•„๋ž˜์™€ ๊ฐ™์€ ๋ช…๋ น์–ด๋ฅผ ์ž…๋ ฅํ•ฉ๋‹ˆ๋‹ค. 

 (e.g. $ docker container run --name ctr1 -it alpine:latest sh )

 

Docker CLI์— ์ž…๋ ฅํ•˜๋ฉด Docker client๋Š” ์ ์ ˆํ•œ API Payload๋กœ ๋ณ€ํ™˜ํ•ด์„œ

Docker Daemon(์ดํ•˜ dockerd)์—๊ฒŒ REST API๋กœ POST ์š”์ฒญ์„ ํ•ฉ๋‹ˆ๋‹ค.

(e.g. POST /containers/create HTTP/1.1 )

 

 

2) dockerd

 

 

API๋Š” Unix Socket์„ ํ†ตํ•ด dockerd์—๊ฒŒ ์ „๋‹ฌ๋ฉ๋‹ˆ๋‹ค.

Linux์—์„œ socket์€ /var/run/docker.sock ์ด๊ณ , Windows์—์„œ๋Š” \pipe\docker_engine ์ž…๋‹ˆ๋‹ค.

 

์ƒˆ ์ปจํ…Œ์ด๋„ˆ๋ฅผ ์‹œ์ž‘ํ•  ๋•Œ, dockerd๋Š” ๋กœ์ปฌ ์ด๋ฏธ์ง€๊ฐ€ ์žˆ๋Š”์ง€ ํ™•์ธํ•˜๊ณ 

์—†๋‹ค๋ฉด registry repository์—์„œ ํ•ด๋‹นํ•˜๋Š” ์ด๋ฆ„์˜ ์ด๋ฏธ์ง€๋ฅผ ๊ฐ€์ ธ์˜ต๋‹ˆ๋‹ค.

 

๋˜ํ•œ logging drivers์™€ volume์ด๋‚˜ volume drivers๋ฅผ ์„ค์ •ํ•˜๋Š” ๋“ฑ ์ปจํ…Œ์ด๋„ˆ์— ํ•„์š”ํ•œ ๋Œ€๋ถ€๋ถ„์˜ ์„ค์ •์„ ์ง€์ •ํ•ฉ๋‹ˆ๋‹ค.

 

dockerd๊ฐ€ '์ƒˆ๋กœ์šด container๋ฅผ ์ƒ์„ฑํ•˜๋ผ'๋Š” ๋ช…๋ น์„ ์ˆ˜์‹ ํ•˜๋ฉด, containerd๋ฅผ ํ˜ธ์ถœํ•ฉ๋‹ˆ๋‹ค.

์ด๋•Œ, dockerd๋Š” CRUD ์Šคํƒ€์ผ API๋ฅผ ํ†ตํ•ด gRPC๋กœ containerd์™€ ํ†ต์‹ ํ•ฉ๋‹ˆ๋‹ค.

(e.g. client.NewContainer(context, ...) )

 

 

3) containerd

 

 

containerd๋Š” ์‹ค์ œ๋กœ containers๋ฅผ ์ƒ์„ฑํ•˜์ง€ ๋ชปํ•˜๊ณ , runc๋ฅผ ํ†ตํ•ด ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค.

Docker ์ด๋ฏธ์ง€๋ฅผ ๊ฐ€์ ธ์™€์„œ ์ปจํ…Œ์ด๋„ˆ ๊ตฌ์„ฑ์„ ์ ์šฉํ•˜์—ฌ runc๊ฐ€ ์‹คํ–‰ํ•  ์ˆ˜ ์žˆ๋Š” OCI ๋ฒˆ๋“ค๋กœ ๋ณ€ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

 

 

4) runc

 

 

 

runc(๋‚ด๋ถ€์˜ libcontainer ์‚ฌ์šฉ)๋Š” OS ์ปค๋„์— ์ ‘์†ํ•ด์„œ 

์ปจํ…Œ์ด๋„ˆ๋ฅผ ๋งŒ๋“œ๋Š” ๋ฐ ํ•„์š”ํ•œ ๋ชจ๋“  ๊ตฌ์„ฑ ์š”์†Œ(๋„ค์ž„์ŠคํŽ˜์ด์Šค, cgroup ๋“ฑ)๋ฅผ ํ•˜๋‚˜๋กœ ๋ฌถ์Šต๋‹ˆ๋‹ค.

runc๋Š” ์ƒˆ๋กœ์šด container๋ฅผ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค.

 

 

5) shim

 

๊ทธ ๋‹ค์Œ ์ปจํ…Œ์ด๋„ˆ๋ฅผ ์‹œ์ž‘ํ•˜๊ธฐ ์œ„ํ•ด docker-containerd-shim๊ณผ ๊ฐ™์€ shim์„ ์‹คํ–‰ํ•ฉ๋‹ˆ๋‹ค.

 

์ปจํ…Œ์ด๋„ˆ ํ”„๋กœ์„ธ์Šค๋Š” runc์˜ ํ•˜์œ„ ํ”„๋กœ์„ธ์Šค๋กœ ์‹œ์ž‘๋˜๋Š”๋ฐ, ์ปจํ…Œ์ด๋„ˆ ํ”„๋กœ์„ธ์Šค๊ฐ€ ์‹คํ–‰ํ•˜์ž๋งˆ์ž runc๊ฐ€ ์ข…๋ฃŒexit๋ฉ๋‹ˆ๋‹ค.

์ด ๋•Œ, docker-containerd-shim์ด ์ƒˆ๋กœ์šด ์ƒ์œ„ ํ”„๋กœ์„ธ์Šค๊ฐ€ ๋˜์–ด ์ปจํ…Œ์ด๋„ˆ์˜ ์ƒ๋ช…์ฃผ๊ธฐ๋ฅผ ๊ด€๋ฆฌํ•ฉ๋‹ˆ๋‹ค. 

 

 

 

์ž, ์ด์ œ ์œ„์—์„œ ์–ธ๊ธ‰๋œ ๋ชจ๋“  ๊ธฐ์ˆ ์„ ์•Œ์•„๋ณด๋„๋ก ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

 

 

 

โœ”๏ธ  docker client

= docker

ํ”ํžˆ docker๋ผ๊ณ  ๋ถ€๋ฅด๋Š” ๊ฒƒ ์ค‘ ํ•˜๋‚˜๊ฐ€ ๋ฐ”๋กœ Docker Client์ž…๋‹ˆ๋‹ค.

๋‹จ์ˆœํžˆ Docker CLI๋ผ๊ณ  ์ดํ•ดํ•˜๋ฉด ํŽธํ• ํ…๋ฐ์š”.

 

Docker Client๋Š” ๊ฐœ๋ฐœ์ž๋“ค์ด Docker๋ฅผ ์‚ฌ์šฉํ•˜๋Š” Docker CLI๋‚˜ Docker Compose๋กœ, 

$ docker run ๊ณผ ๊ฐ™์€ ๋ช…๋ น์–ด๋ฅผ dockerd์—๊ฒŒ REST API ํ˜•ํƒœ๋กœ ์ „๋‹ฌํ•ฉ๋‹ˆ๋‹ค.

 

์ด ๊ธ€์„ ์“ฐ๋Š” ์‹œ์ ์—์„œ๋Š” Docker 1.41 ์ด ๊ฐ€์žฅ ์ตœ์‹ ์ด๋ฉฐ, ๋งํฌ๋ฅผ ํ™•์ธํ•˜์‹œ๋ฉด API ๋ช…์„ธ๋ฅผ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋˜ํ•œ, Docker Client๋Š” ๋‹ค์ˆ˜์˜ ๋ฐ๋ชฌ๊ณผ ํ†ต์‹ ํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

 

๊ธ€์„ ์ •๋ฆฌํ•˜๋ฉฐ ํ†ต์‹  ๊ณผ์ • ์ดํ•ด์— ์ฐธ๊ณ ํ•œ ํ†ต์‹  ํ…Œ์ŠคํŠธ ์˜์ƒ(Docker remote REST API)์„ ๋ณด๋ฉด ์ดํ•ด์— ๋„์›€์ด ๋  ๋“ฏํ•ฉ๋‹ˆ๋‹ค.

 

 

โœ”๏ธ  dockerd

= Docker Daemon (Server)

๋„์ปค ๋ฐ๋ชฌ(dockerd)์€ Docker API ์š”์ฒญ์„ ์ˆ˜์‹ ํ•˜๊ณ ,

๋„์ปค ๋ฐ๋ชฌ์€ ๋‹ค๋ฅธ ๋ฐ๋ชฌ๊ณผ ํ†ต์‹ ํ•˜์—ฌ ๋„์ปค ์„œ๋น„์Šค๋ฅผ ๊ด€๋ฆฌํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

 

dockerd์˜ ์—ญํ• ๋กœ๋Š” ์ด๋ฏธ์ง€ ๊ด€๋ฆฌ, ์ด๋ฏธ์ง€ ๋นŒ๋“œ, REST API, ์ธ์ฆ, ๋ณด์•ˆ, ์ฝ”์–ด ๋„คํŠธ์›Œํ‚น, ์˜ค์ผ€์ŠคํŠธ๋ ˆ์ด์…˜ ๋“ฑ์ด ์žˆ์Šต๋‹ˆ๋‹ค.

๊ณผ๊ฑฐ์˜ docker daemon๊ณผ๋Š” ๋‹ค๋ฅด๊ฒŒ ์ปจํ…Œ์ด๋„ˆ์˜ ์‹คํ–‰๊ณผ ์ปจํ…Œ์ด๋„ˆ ๋Ÿฐํƒ€์ž„ ์ฝ”๋“œ๊ฐ€ ๋ชจ๋“ˆํ™”๋กœ ๋ถ„๋ฆฌ๋˜์–ด ์œ„์˜ ๊ธฐ๋Šฅ๋“ค๋งŒ ๋‚จ์•˜์Šต๋‹ˆ๋‹ค.

 

 

 

 

โœ”๏ธ  containerd

containerd๋Š” Container์˜ ์ƒ๋ช…์ฃผ๊ธฐ๋ฅผ ๊ด€๋ฆฌํ•ฉ๋‹ˆ๋‹ค (= container lifecycle operations).

containerd๋Š” ์›๋ž˜ ์ž‘๊ณ , ๊ฐ€๋ฒผ์šด Container lifecycle operations์œผ๋กœ ์„ค๊ณ„๋˜์—ˆ๋Š”๋ฐ,

์‹œ๊ฐ„์ด ์ง€๋‚˜๋ฉด์„œ image pulls, volumes and networks์™€ ๊ฐ™์€ ๊ธฐ๋Šฅ๋“ค์ด ํ™•์žฅ๋˜์—ˆ์Šต๋‹ˆ๋‹ค.

 

๊ธฐ๋Šฅ๋“ค์ด ์ถ”๊ฐ€๋œ ์ด์œ  ์ค‘ ํ•˜๋‚˜๋Š” ๋‹ค๋ฅธ ํ”„๋กœ์ ํŠธ์—์„œ ๋” ์‰ฝ๊ฒŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋„๋ก ํ•˜๊ธฐ ์œ„ํ•ด์„œ์ธ๋ฐ์š”.

์˜ˆ๋ฅผ ๋“ค์–ด, Kubernetes๊ฐ™์€ ํ”„๋กœ์ ํŠธ์—์„œ๋Š” containerd๋ฅผ ํ†ตํ•ด ์ด๋ฏธ์ง€๋ฅผ pushํ•˜๊ณ  pullํ•˜๋Š” ๊ฒƒ๊ณผ ๊ฐ™์€ ์ถ”๊ฐ€์ ์ธ ์ž‘์—…์ด ์œ ์šฉํ•˜๋‹ค๋Š” ์ ์ด ์žˆ์Šต๋‹ˆ๋‹ค.

 

๋ชจ๋“  ์ถ”๊ฐ€์ ์ธ ๊ธฐ๋Šฅ๋“ค์€ ์˜ต์…˜์ด๊ธฐ ๋•Œ๋ฌธ์— ์›ํ•˜๋Š” ๊ฒƒ๋“ค์„ ์„ ํƒํ•˜์—ฌ ๋ฐ˜์˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

 

 

# High-Level Runtime

containerd๋Š” High-Level Runtime์ž…๋‹ˆ๋‹ค.

High-Level Runtime์€ ๋ณดํ†ต ์ด๋ฏธ์ง€ ๊ด€๋ฆฌ, gRPC/Web API์™€ ๊ฐ™์ด ์ปจํ…Œ์ด๋„ˆ๋ฅผ ๊ด€๋ฆฌํ•˜๋Š” ๊ฒƒ ์ด์ƒ์˜ ๋†’์€ ์ˆ˜์ค€์˜ ๊ธฐ๋Šฅ์„ ์ง€์›ํ•˜๋Š” ๋Ÿฐํƒ€์ž„์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค. "high-level container tools", "high-level container runtimes" ์œผ๋กœ ๋ถ€๋ฅด๊ฑฐ๋‚˜, ๊ฐ€๋”์€ ๊ทธ๋ƒฅ "container runtimes”์ด๋ผ๊ณ ๋„ ๋ถ€๋ฆ…๋‹ˆ๋‹ค.

๋Œ€์กฐ์ ์œผ๋กœ, Low-Level Runtime์—๋Š” ๋‹ค์Œ์œผ๋กœ ๋ณผ runc๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.

 

 

Docker Client๋กœ๋ถ€ํ„ฐ Container ๊ด€๋ จ ์š”์ฒญ์€ dockerd๋ฅผ ๊ฑฐ์ณ gRPC ํ†ต์‹ ์„ ํ†ตํ•ด containerd ๋กœ ์ „๋‹ฌ๋ฉ๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๋‚˜์„œ, containerd๋Š” ์ปจํ…Œ์ด๋„ˆ์˜ ๊ด€๋ฆฌ๋ฅผ ์œ„ํ•ด runc๋ฅผ ์‚ฌ์šฉํ•˜๋Š”๋ฐ์š”. ๊ทธ๋Ÿผ, runc๊ฐ€ ๋ฌด์—‡์ธ์ง€ ์•Œ์•„๋ณผ๊ฒŒ์š”.

 

 

โœ”๏ธ  runc

runc๋Š” *libcontainer์šฉ CLI Wrapper๋กœ, ๋…๋ฆฝ๋œ container runtime์ž…๋‹ˆ๋‹ค.

docker๊ฐ€ container ๊ด€๋ จ๋œ ๊ธฐ๋Šฅ๋“ค์„ ์‰ฝ๊ฒŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋„๋ก ํ•ด์ฃผ๋Š” ๊ฐ€๋ณ๊ณ  ์ด์‹๊ฐ€๋Šฅํ•œ ํˆด์ž…๋‹ˆ๋‹ค.

๋‹ค์‹œ ๋งํ•ด, container ๋™์ž‘ ํ™˜๊ฒฝ์ด ๊ฐ–์ถ”์–ด์ง„ ๊ฐ€๋ณ๊ณ  ์ด์‹ ๊ฐ€๋Šฅํ•œ ํˆด์ž…๋‹ˆ๋‹ค.

Docker์—์„œ runc๋Š” ๋ชฉ์ ์€ ๋‹จ ํ•˜๋‚˜์ธ๋ฐ์š”, ๋ฐ”๋กœ Container ์ƒ์„ฑ์ž…๋‹ˆ๋‹ค.

 

 

* libcontainer : Docker์‚ฌ๊ฐ€ multi-platform ์„œ๋น„์Šค๋ฅผ ๋งŒ๋“ค๊ธฐ ์œ„ํ•ด go ์–ธ์–ด๋กœ ์ž‘์„ฑ๋œ ํŒจํ‚ค์ง€. (History - LXC ์ฐธ๊ณ )

 

 

# OCI

runc๋Š” OCI container-runtime-spec์˜ ๊ตฌํ˜„์ฒด์ž…๋‹ˆ๋‹ค.

OCI(Open Container Initiative)๋Š” kernel์˜ container ๊ด€๋ จ ๊ธฐ์ˆ ์„ ๋‹ค๋ฃจ๋Š” interface๋ฅผ ํ‘œ์ค€ํ™”์‹œํ‚จ ๊ธฐ์ค€์ž…๋‹ˆ๋‹ค.

๊ทธ๋ž˜์„œ runc๊ฐ€ ๋™์ž‘ํ•˜๋Š” ๊ณ„์ธต์„ OCI Layer๋ผ๊ณ  ๋ถ€๋ฅด๊ธฐ๋„ ํ•ฉ๋‹ˆ๋‹ค.

 

 

# Low-Level Runtimes

Low-Level Runtimes๋Š” ๋ณดํ†ต ์ปจํ…Œ์ด๋„ˆ๋ฅผ ์šด์˜ํ•˜๋Š” ๊ฒƒ์— ์ดˆ์ ์„ ๋งž์ถ˜ ์‹ค์ œ ์ปจํ…Œ์ด๋„ˆ ๋Ÿฐํƒ€์ž„์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.

 

runc๋Š” ๋…๋ฆฝ๋œ ์ปจํ…Œ์ด๋„ˆ ๋Ÿฐํƒ€์ž„์ด๊ธฐ ๋•Œ๋ฌธ์— ๋ฐ”์ด๋„ˆ๋ฆฌ๋กœ ๋‹ค์šด๋ฐ›๊ณ  ๋นŒ๋“œํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

runc (OCI) container๋ฅผ ๋นŒ๋“œํ•˜๊ณ  ์‹คํ–‰์‹œํ‚ค๋Š”๋ฐ ๋ชจ๋“  ๊ฒƒ์„ ๊ฐ–์ถœ ์ˆ˜ ์žˆ๋‹ค๋Š” ์˜๋ฏธ์ž…๋‹ˆ๋‹ค.

 

ํ•˜์ง€๋งŒ ์ด๊ฒƒ์€ ๊ณจ๊ฒฉbare bones์ผ๋ฟ์ด๋ฉฐ ๋งค์šฐ ๋‚ฎ์€ ๋ ˆ๋ฒจlow-level์ž…๋‹ˆ๋‹ค.

์ฆ‰, ์™„์ „ํ•œ Docker ์—”์ง„์˜ ํŠน์„ฑfull-blown Docker engine์„ ๊ฐ€์งˆ ์ˆ˜๋Š” ์—†์Šต๋‹ˆ๋‹ค.

 

 

โœ”๏ธ  shim

์•ž์—์„œ containerd๊ฐ€ ์ƒˆ๋กœ์šด ์ปจํ…Œ์ด๋„ˆ๋ฅผ ๋งŒ๋“ค๊ธฐ ์œ„ํ•ด runc๋ฅผ ์‚ฌ์šฉํ•œ๋‹ค๊ณ  ํ–ˆ๋Š”๋ฐ์š”.

 

์ƒ์„ฑ๋˜๋Š” ๋ชจ๋“  container ๋‹น runc์˜ ์ƒˆ๋กœ์šด ์ธ์Šคํ„ด์Šค๋ฅผ fork ํ•ฉ๋‹ˆ๋‹ค.

๊ทธ๋Ÿฌ๋‚˜ ๊ฐ ์ปจํ…Œ์ด๋„ˆ๊ฐ€ ์ƒ์„ฑ๋˜๋ฉด, ์ƒ์œ„ runc ํ”„๋กœ์„ธ์Šค๊ฐ€ ์ข…๋ฃŒ๋ฉ๋‹ˆ๋‹ค.

์ˆ˜๋ฐฑ ๊ฐœ์˜ runc ์ธ์Šคํ„ด์Šค๋ฅผ ์‹คํ–‰ํ•˜์ง€ ์•Š๊ณ ๋„ ์ˆ˜๋ฐฑ ๊ฐœ์˜ container๋ฅผ ์‹คํ–‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

 

์ปจํ…Œ์ด๋„ˆ์˜ ํ• ๋‹น๋œ ๋ถ€๋ชจ runc ํ”„๋กœ์„ธ์Šค๊ฐ€ ์ข…๋ฃŒ๋˜๋ฉด, ์—ฐ๊ฒฐ๋œ containerd-shim ํ”„๋กœ์„ธ์Šค๊ฐ€ ์ปจํ…Œ์ด๋„ˆ์˜ ๋ถ€๋ชจํ”„๋กœ์„ธ์Šค๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.

์ด๋Š” containerd์—๊ฒŒ ์ปจํ…Œ์ด๋„ˆ์˜ file descriptor(e.g. stdin/out)์™€ ์ข…๋ฃŒ ์ƒํƒœ๋ฅผ ๊ด€๋ฆฌํ•˜๋Š” ๋ฐ ํ•„์š”ํ•œ ์ตœ์†Œํ•œ์˜ ์ฝ”๋“œ๋ฅผ ๋ฉ”๋ชจ๋ฆฌ์— ๋‚จ๊น๋‹ˆ๋‹ค.

 

* file descriptor

ํ”„๋กœ์„ธ์Šค์—์„œ ์—ด๋ฆฐ ํŒŒ์ผ์˜ ๋ชฉ๋ก์„ ๊ด€๋ฆฌํ•˜๋Š” ํŒŒ์ผ ํ…Œ์ด๋ธ”์˜ ์ธ๋ฑ์Šค์ž…๋‹ˆ๋‹ค. ํ”„๋กœ๊ทธ๋žจ์ด ํ”„๋กœ์„ธ์Šค๋กœ ๋ฉ”๋ชจ๋ฆฌ์—์„œ ์‹คํ–‰๋  ๋•Œ, ๊ธฐ๋ณธ์ ์œผ๋กœ ํ• ๋‹น๋˜๋Š” ํŒŒ์ผ๋””์Šคํฌ๋ฆฝํ„ฐ๋Š” ํ‘œ์ค€์ž…๋ ฅ(Standard Input), ํ‘œ์ค€ ์ถœ๋ ฅ(Standard Output), ํ‘œ์ค€์—๋Ÿฌ(Standard Error)์ด๋ฉฐ ์ด๋“ค์—๊ฒŒ ๊ฐ๊ฐ 0, 1, 2๋ผ๋Š” ์ •์ˆ˜(file table์˜ ์ธ๋ฑ์Šค)๊ฐ€ ํ• ๋‹น๋ฉ๋‹ˆ๋‹ค.

 

shim์ด ์ปจํ…Œ์ด๋„ˆ์˜ ์ƒ์œ„ ํ”„๋กœ์„ธ์„œ๋กœ์„œ ์ˆ˜ํ–‰ํ•˜๋Š” ์ฃผ์š” ์ฑ…์ž„์€ ์•„๋ž˜์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

 

๐Ÿ‘‰๐Ÿป daemon์ด ์žฌ์‹œ์ž‘๋  ๋•Œ, ํŒŒ์ดํ”„๊ฐ€ ๋‹ซํžˆ๋Š” ๋“ฑ์˜ ์ด์œ  ๋•Œ๋ฌธ์— container๊ฐ€ ์ข…๋ฃŒ๋˜์ง€ ์•Š๋„๋ก STDIN๊ณผ STDOUT ์ŠคํŠธ๋ฆผ์„ ์—ด๋ฆฐ ์ƒํƒœ๋กœ ์œ ์ง€ํ•ฉ๋‹ˆ๋‹ค.

๐Ÿ‘‰๐Ÿป daemon์—๊ฒŒ container์˜ ์ข…๋ฃŒ ์ƒํƒœ๋ฅผ ๋ณด๊ณ ํ•ฉ๋‹ˆ๋‹ค.

 

 

 

 

 

์ด๋ ‡๊ฒŒ Docker Engine์„ ๋‹ค๋ฃจ๋Š” ์ฒซ ๋ฒˆ์งธ ํฌ์ŠคํŒ…์„ ๋งˆ์น˜๊ฒ ์Šต๋‹ˆ๋‹ค.

ํ”ผ๋“œ๋ฐฑ ๋‚ด์šฉ์ด ์žˆ๋‹ค๋ฉด ๋Œ“๊ธ€๋กœ ๋‚จ๊ฒจ์ฃผ์‹œ๋ฉด ๊ฐ์‚ฌํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

 

๋‹ค์Œ ํฌ์ŠคํŒ…์€ namespace, cgroup ์„ ํ†ตํ•ด ์ปจํ…Œ์ด๋„ˆ ๊ฐ€์ƒํ™”๊ฐ€ ์‹คํ˜„๋  ์ˆ˜ ์žˆ์—ˆ๋˜ ๋‚ด์šฉ์„ ๋‹ค๋ฃจ๊ฒ ์Šต๋‹ˆ๋‹ค.

 

 

 

์ฐธ๊ณ  ์ž๋ฃŒ

- O'Reilly - "Docker Deep Dive, The Docker Engine"

- O'Reilly - "Docker: Up & Running, 2nd Edition"

- Docker Engine ๊ณต์‹ ๋ฌธ์„œ

 

๋ฐ˜์‘ํ˜•

Backend Software Engineer

Gyeongsun Park