100년 뒤 개발자 한승규입니다.

• 컨테이너의 중지와 재시작

docker ps

docker ps를 입력하면 현재 실행 중인 도커 컨테이너들을 확인할 수 있다.

만약 현재 실행 중인 컨테이너 외에도 중지된 컨테이너까지 확인하기 위해서는 다음 명령어를 사용하면 된다.

docker ps -a

이러면 현재 종료되어 있는 컨테이너도 확인할 수 있다.

이 종료되어 있는 컨테이너를 다시 재시작할 수도 있다.

docker run은 이미지를 기반으로 새 컨테이너를 만들지만, 변경사항이 없어서 컨테이너를 재실행하고 싶다면 docker ps -a로 컨테이너를 검색한 후

docker start {container ID || container name}

이렇게 종료된 컨테이너를 재실행한 것을 볼 수 있다.

• Attached, Detached

방금 해보았던 docker start로 컨테이너를 실행하면, 외부에서 docker ps로 상태만 확인할 수 있었고 내부에서 작업은 하지 않았었다.

분명히 실행 중인데도 말이다.

이 전의 docker run으로 컨테이너를 실행하면, 해당 터미널에서 컨테이너가 실행되고 다른 터미널에서 상태를 확인할 수 있었다.

이제 여기서 자유롭게 attached, detached를 설정하여 작업해 보도록 하자.

우선 docker start는 detached 모드가 디폴트이며, docker run은 attached 모드가 디폴트이다.

docker run을 확인해보자.

이렇게 콘솔에 컨테이너의 결과가 출력되는 것을 볼 수 있다.

이 컨테이너를 콘솔과 연결되지 않는 detached 모드로 실행하기 위해서는, -d 옵션을 넣어주면 된다.

이렇게 -d 옵션을 넣어주면, 이전과는 다르게 바로 컨테이너가 실행되었다고 나오고 터미널과는 분리되는 것을 볼 수 있다.

분리된 컨테이너와 터미널을 다시 연결하고 싶다면, attach 명령어를 사용하면 된다.

docker attach {container ID || container name}

이렇게 다시 연결되어 결과가 출력되는 것을 볼 수 있다.

터미널과 연결시키지 않고 로그만 가져오고 싶다면, logs 명령어를 사용하면 된다.

이렇게 바로 출력의 결과만 가져오는 것을 볼 수 있다.

• 인터렉티브 모드로 작업하기

웹서버뿐만 아니라 짠 코드를 직접 실행시킬 수도 있다.

작성한 파이썬 코드를 실행해보도록 하겠다.

Dockerfile은 다음과 같이 작성했다.

FROM python

WORKDIR /python

COPY . /python

CMD ["python", "rng.py"]

해당 Dockerfile을 바탕으로 이미지를 생성하고, 컨테이너를 실행한다.

그리고는 run -it를 사용하여, 인터렉티브하게 컨테이너를 실행한다.

docker run -it {image ID || image name}

이러면 해당 컨테이너와 상호작용하며 실행할 수 있다.

run이 아닌 start의 상황에서는 -ai 옵션을 사용하여 인터렉티브하게 재실행한다.

• 이미지와 컨테이너 삭제하기

그 동안 생성했던 많은 이미지와 컨테이너들을 삭제해보도록 하자.

컨테이너를 제거할 때는 rm 명령어를 사용한다.

docker rm {container ID || container name}

당연히 실행 중인 컨테이너는 삭제할 수 없고, 현재 종료된 컨테이너만 제거가 가능하다.

이번에는 이미지를 삭제해보자.

이미지를 삭제할 때는 rmi 명령어를 사용한다.

docker rmi {image ID || image name}

이렇게 이미지가 삭제되는 것을 볼 수 있다.

여기서도 이미지는 해당 이미지를 사용하여 실행 중인 컨테이너가 존재하지 않을 때만 삭제가 가능하다.

해당 명령어를 사용하면, 삭제 가능한 모든 이미를 삭제한다.

docker image prune

만약 컨테이너를 종료 후 해당 컨테이너를 자동으로 제거하고 싶다면, run을 하면서 --rm 옵션을 넣어주면 된다.

docker run --rm {image ID || image name}

이렇게 종료하자마자 자동으로 삭제되는 것을 볼 수 있다.

• 컨테이너에서의 파일 복사

실행 중인 컨테이너로 또는 실행 중인 컨테이너 밖으로 파일 또는 폴더를 복사할 수 있다.

해당 과정에서는 cp 명령어를 사용한다.

docker cp {복사하려는 파일 혹은 폴더} {container name}:{복사하려는 경로}

당연히 반대로 컨테이너에서 가져올 수도 있다.

cp 명령어를 사용하여 경로의 순서를 바꾸면 된다.

docker cp {container name}:{복사하려는 경로} {복사하려는 파일 혹은 폴더}

• 컨테이너와 이미지에 이름 혹은 태그 지정하기

지금까지는 자동으로 도커에서 생성된 이름만을 사용했다.

당연히 이런 이름들도 우리가 직접 지정할 수 있다.

직접 지정하는 방법을 알아보도록 하자.

--name 옵션에 이름을 지정해주면 된다.

docker run --name {container name} {image ID || image name}

myapp이라는 이름이 지정된 것을 볼 수 있다.

이번에는 이미지에 이름을 지정해보자.

이미지의 이름을 태그라고 하며 2개로 구분할 수 있다.

이미지의 리포지토리 : 이미지의 태그 이렇게 구성이 되어 있는 데, 이렇게 만든 이유는 여러개의 특정화된 이미지 그룹을 만들 수 있기 때문이다.

이미지를 가져올 때도 태그를 지정할 수 있으며, 보통은 특정 버전의 이미지를 가져올 때 사용한다.

이미지의 이름을 생성할 때는 -t 옵션을 사용한다.

docker build -t {이미지의 이름}:{이미지의 태그} .

https://www.acmicpc.net/problem/2468

물의 높이를 올려가며 해당 높이에 대하여 그래프의 탐색을 진행했다.

한 번 틀렸었는데, 높이가 0일 때도 고려를 해야 한다.

import sys

N = int(sys.stdin.readline())

land = list()

for _ in range(N):
    land.append(list(map(int, sys.stdin.readline().split())))

max_result = 0

for height in range(101):
    result = 0

    visited = [[False for _ in range(N)] for _ in range(N)]

    for i in range(N):
        for t in range(N):
            if visited[i][t] is False and land[i][t] > height:
                visited[i][t] = True
                need_visit = [[i, t]]

                result += 1

                while need_visit:
                    cur_i, cur_t = need_visit.pop()

                    for next_i, next_t in [[cur_i + 1, cur_t], [cur_i - 1, cur_t], [cur_i, cur_t + 1], [cur_i, cur_t - 1]]:
                        if 0 <= next_i < N and 0 <= next_t < N and not visited[next_i][next_t] and land[next_i][next_t] > height:
                            need_visit.append([next_i, next_t])
                            visited[next_i][next_t] = True

    max_result = max(max_result, result)

print(max_result)

https://www.acmicpc.net/problem/1012

해당 문제도 평범한 그래프 문제이다.

visited 배열로 방문을 기록할 수 있도록 하였다.

import sys

for _ in range(int(sys.stdin.readline().strip())):

    M, N, K = map(int, sys.stdin.readline().split())

    land = [[0 for _ in range(M)] for _ in range(N)]

    for _ in range(K):
        m, n = map(int, sys.stdin.readline().split())
        land[n][m] = 1

    result = 0

    visited = [[False for _ in range(M)] for _ in range(N)]

    for n in range(N):
        for m in range(M):
            if visited[n][m] or land[n][m] == 0:
                continue

            result += 1

            need_visit = [[n, m]]
            visited[n][m] = False

            while need_visit:

                cur_n, cur_m = need_visit.pop()

                for next_n, next_m in [[cur_n, cur_m + 1], [cur_n, cur_m - 1], [cur_n + 1, cur_m], [cur_n - 1, cur_m]]:
                    if 0 <= next_n < N and 0 <= next_m < M:
                        if land[next_n][next_m] == 1 and visited[next_n][next_m] is False:
                            need_visit.append([next_n, next_m])
                            visited[next_n][next_m] = True
    print(result)

https://www.acmicpc.net/problem/4963

전형적인 그래프 탐색 문제이다.

BFS로 풀든, DFS로 풀든 상관 없을 것이라고 생각한다.

visited 배열을 만들어 방문했던 기록을 남기고, 만약 방문했던 곳이라면 해당 지역은 건너뛸 수 있도록 했다.

그리고 항상 그래프를 탐색할 때에는 구역 내에 있는 지 확인을 먼저 하고 진행할 수 있도록 했다.

만약 땅이 맞다면, 방문을 한다는 의미로 visited를 True로 바꾸고 다음에 방문을 진행할 need_visit 배열에 추가하도록 했다.

import sys

dx = [0, 1, 1, 1, 0, -1, -1, -1]
dy = [-1, 0, 1, -1, 1, 0, -1, 1]

while True:

    w, h = map(int, sys.stdin.readline().split())

    if w == 0 and h == 0:
        break

    land = list()
    visited = [[False for _ in range(w)] for _ in range(h)]

    result = 0

    for _ in range(h):
        land.append(list(map(int, sys.stdin.readline().split())))

    for height in range(h):
        for width in range(w):

            if visited[height][width] is True:
                continue

            if land[height][width] == 0:
                visited[height][width] = True
                continue

            result += 1

            need_visit = [[height, width]]
            visited[height][width] = True

            while need_visit:
                cur_height, cur_width = need_visit.pop(0)

                for i in range(8):
                    target_height, target_width = cur_height + dy[i], cur_width + dx[i]
                    if 0 <= target_height < h and 0 <= target_width < w and land[target_height][target_width] == 1 and not visited[target_height][target_width]:
                        need_visit.append([target_height, target_width])
                        visited[target_height][target_width] = True

    print(result)

https://www.acmicpc.net/problem/2178

당연히 고민하지 않고 BFS로 풀었다.

지나온 길을 기록하기 위해 N x M 크기의 visited 배열을 사용했다.

import sys

N, M = map(int, sys.stdin.readline().split())

miro = [list(map(int, sys.stdin.readline().strip())) for _ in range(N)]
visited = [[float('inf') for _ in range(M)] for _ in range(N)]

bfs = [[0, 0, 0]]

result = -1

dx = [1, 0, -1, 0]
dy = [0, 1, 0, -1]

while bfs:
    count, x, y = bfs.pop(0)

    if x == N - 1 and y == M - 1:
        result = count
        break

    for i in range(4):
        if 0 <= x + dx[i] < N and 0 <= y + dy[i] < M and miro[x + dx[i]][y + dy[i]] == 1 and visited[x + dx[i]][y + dy[i]] > count + 1:
            bfs.append([count + 1, x + dx[i], y + dy[i]])
            visited[x + dx[i]][y + dy[i]] = count + 1


print(result + 1)

https://www.acmicpc.net/problem/1260

단순한 그래프 문제이다.

입력받은 edge를 배열에 저장하고 해당 배열을 DFS, BFS에 맞게 탐색하면서 풀었다.

DFS, BFS에서의 다른 점은 BFS는 바로바로 다음 방문 배열에 넣은 반면, DFS는 해당 노드에서 인접한 노드를 모두 구해 배열로 만든 후 다음 방문 배열 앞으로 넣어주었다.

import sys

N, M, V = map(int, sys.stdin.readline().split())

graph = [[False for _ in range(N+1)] for _ in range(N+1)]

for i in range(M):
    V1, V2 = map(int, sys.stdin.readline().split())
    graph[V1-1][V2-1] = True
    graph[V2-1][V1-1] = True

DFS, BFS = [False for i in range(N)], [False for i in range(N)]
to_visit = [V-1]

while to_visit:
    cur_node = to_visit.pop(0)
    if DFS[cur_node]:
        continue
    save_to_visit = []
    for i in range(N):
        if graph[cur_node][i] and not DFS[i]:
            save_to_visit.append(i)

    to_visit = save_to_visit + to_visit

    print(cur_node + 1, end=' ')
    DFS[cur_node] = True

print()

to_visit = [V-1]

while to_visit:
    cur_node = to_visit.pop(0)
    if BFS[cur_node]:
        continue

    for i in range(N):
        if graph[cur_node][i] and not BFS[i]:
            to_visit.append(i)

    print(cur_node + 1, end=' ')
    BFS[cur_node] = True

• 이미지와 컨테이너는 무엇인가?

저번에 다루어 봤듯이 컨테이너는 애플리케이션, 애플리케이션을 실행하는 전체 환경 등등 무엇이든 포함하는 작은 패키지이다.

컨테이너에는 소프트웨어 실행 유닛이 존재하며, 우리는 그 유닛을 실행하는 것이다.

이미지는 템플릿, 컨테이너의 블루프린트이다.

이미지는 실제로 코드와 코드를 실행하는데 필요한 도구를 포함한다.

하나의 이미지는 하나의 컨테이너만 실행하는 것이 아니라

이미지를 기반으로 여러 컨테이너를 만들 수 있다.

이미지는 모든 설정과 코드가 포함된 공유 가능한 패키지이며, 컨테이너는 그런 이미지의 구체적인 실행 인스턴스이다.

• 외부에서 이미지를 가져와 사용하기

이미지는 우리가 직접 만드는 것이 아닌, 가져와서 사용하는 방법도 존재한다.

일반적이어서 미리 구축이 되어 있는 공식 이미지들이 많이 있으며, 해당 이미지를 가져오는 것도 좋은 방법이다.

보통은 DockerHub에서 많이 찾아볼 수 있다.

https://hub.docker.com/

docker run node 명령어를 실행해 보았는 데, 아래처럼 나오는 것을 볼 수 있다.

우선 local에서 node image를 찾고, 없기 때문에 원격으로 이미지를 가져오는 것을 볼 수 있다.

• 이미지를 이용하여 빌드하기

커스텀 이미지를 만들기 위해서는 Dockerfile을 만들고 작성해야 한다.

우선 다음과 같이 작성한다.

FROM node

WORKDIR /app

COPY . /app

RUN npm install

EXPOSE 80

CMD ["node", "server.js"]

FROM은 다른 베이스 이미지 위에 현재 이미지를 생성한다는 의미이다.

물론 처음부터 만들 수는 있지만, 언제나 코드에 필요한 도구 같은 레이어가 필요하기에 보통은 추가한다.

WORKDIR은 도커 내부에서 해당 컨테이너를 작업할 경로를 명시한다.

/app 폴더 밑에서 작업한다는 의미이다.

COPY는 Dockerfile과 같은 디렉토리디렉터리 내에서 작업 디렉터리로 복사해 가져갈 파일들을 적어놓는 것이며, . 을 사용하면 현재 디렉터리에서 Dockerfile을 제외한 모든 파일을 복사한다는 의미이며, 도커 내부의 /app 폴더로 복사해 간다는 것이다.

WORKDIR에 의해 도커 내부의 경로는 상대주소를 가질 수 있지만, 보통 명확하게 하기 위해 절대경로로 하는 것을 추천한다.

RUN은 이미지에서 실행할 명령을 작성하는 것이다. 여기서에선 npm install을 사용해 필요한 종속성들을 설치해 주었다.

EXPOSE는 노출하고 싶은 포트의 주소를 명시한다.

없어도 되지만 그래도 명시하도록 하자.

CMD는 이미지가 빌드 될 때 실행되는 명령이 아닌, 컨테이너를 실행할 때 사용하는 명령어를 적어두면 된다.

이제 해당 이미지를 바탕으로 빌드해보자.

docker build .

해당 명령어를 사용하면 현재 디렉토리에 있는 Dockerfile을 사용해 이미지를 빌드한다.

Dockerfile에 있는 명령어들이 실행 된 것을 볼 수 있다.

해당 이미지를 바탕으로 컨테이너를 실행해본다.

docker run -p 80:80 {이미지 ID}

이렇게 접속이 되는 것을 볼 수 있다.

도커의 실행 상태를 보고 싶다면

docker ps 명령어를 사용하여 현재 실행 중인 컨테이너들을 볼 수 있다.

• 이미지의 변경사항

이미지는 단순히 읽기를 위해서 작성한 코드이다.

무슨 말인지를 직접 보여주도록 하겠다.

이렇게 html 중간의 내용을 변경하였다.

이렇게 변경을 하고 도커의 컨테이너를 재실행해도

이렇게 이전 그대로 나오게 된다.

이는 이전에 COPY 한 내용을 바탕으로 실행이 되기 때문에 해당 COPY에서는 변경사항이 적용되지 않아 생기는 문제이다.

그렇기 위해 이미지로 빌드를 다시 해서 COPY를 다시 해야 해당 변경사항이 적용 될 것이다.

이미지를 다시 빌드하고 컨테이너를 실행해보니

이렇게 제대로 적용이 된 것을 볼 수 있다.

• 이미지의 레이어

Docker에서 이미지를 만들 때

이렇게 CACHED라고 나오는 경우를 볼 수 있을 것이다.

도커는 명령어를 다시 실행했을 때의 결과가 동일하다고 판단되면, Cache를 사용한다.

모든 명령의 결과를 캐시하고, 그 캐시를 사용하는 것이다.

이것을 레이어 기반 구조라고 한다.

Dockerfile의 모든 명령어는 레이어를 나타낸다.

이렇게 이미지 레이어를 기반으로 컨테이너가 실행되게 된다.

해당 레이어에서 아무것도 변경되지 않으면, 캐시를 사용하지만

만약 코드가 변경이 된다면 캐시의 일부만 사용하고 해당 변경내용을 다시 실행하게 된다.

이렇게 만약 코드가 변경이 되었다면, 해당 파일을 다시 COPY하며 캐시를 사용하지 않는 것을 볼 수 있다.

그리고 그 아래의 레이어들도 모두 재실행되는 것을 볼 수 있다.

https://www.acmicpc.net/problem/1202

당연히 heap을 사용해야 한다는 것은 알고 있었지만, 어떻게 사용할 지에 대해서 고민을 많이 했었다.

보석과 가방을 같은 heap에 넣는다는 생각을 하는 게 좀 힘들었던 것 같다.

무게를 기준으로 최소 heap에 보석과 가방을 넣어준다.

가방 같은 경우는 같은 무게에서 가장 뒤로 갈 수 있도록 가치에는 무한을 넣어준다.

하나씩 꺼낼 때 쓸 heap도 만들어준다.

보석과 가방을 넣은 heap에서 하나씩 꺼내어서 반복문을 실행해준다.

만약 꺼낸 것이 보석이라면 최대 heap에 가치를 넣어준다.

만약 꺼낸 것이 가방이라면 최대 heap에서 하나의 보석을 넣을 수 있는 것이므로 가장 큰 값을 가져와 결과값에 더해준다.

그렇게해서 구한 결과값을 출력해주면 된다.

import sys
import heapq

N, K = map(int, sys.stdin.readline().split())

jewelry = list()

for _ in range(N):
    heapq.heappush(jewelry, list(map(int, sys.stdin.readline().split())))

for _ in range(K):
    heapq.heappush(jewelry, [int(sys.stdin.readline().strip()), float('inf')])

result = 0
cur_jewelry = list()

while jewelry:

    weight, value = heapq.heappop(jewelry)

    if value == float('inf'):
        if cur_jewelry:
            result += heapq.heappop(cur_jewelry)
    else:
        heapq.heappush(cur_jewelry, value * -1)


print(result * -1)