ggoggo

[Docker Compose] Docker Compose 작성법

chchae01 — Sun, 3 Dec 2023 18:03:58 +0900

예시를 통해 알아보자!

다음은 bitnami/kafka 이미지를 사용해 kraft 모드의 Kafka을 세팅하는 docker-compose.yml 파일이다.

version: "3"
services:
  kafka:
    image: bitnami/kafka
    container_name: kafka
    ports:
      - 9092:9092
    environment:
      - KAFKA_ENABLE_KRAFT=yes
      - KAFKA_CFG_PROCESS_ROLES=broker,controller
      - KAFKA_CFG_CONTROLLER_LISTENER_NAMES=CONTROLLER
      - KAFKA_CFG_LISTENERS=PLAINTEXT://:9092,CONTROLLER://:2181
      - KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP=CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT
      - KAFKA_CFG_ADVERTISED_LISTENERS=PLAINTEXT://127.0.0.1:9092
      - KAFKA_BROKER_ID=1
      - KAFKA_CFG_CONTROLLER_QUORUM_VOTERS=1@127.0.0.1:2181
      - ALLOW_PLAINTEXT_LISTENER=yes
      - KAFKA_CFG_NODE_ID=1
      - KAFKA_KRAFT_CLUSTER_ID=MkU3OEVBNTcwNTJENDM2Qk
    volumes:
      - ./kafka:/bitnami/kafka

docker-compose 파일 작성 방법

주항목 -> 이름 추가 -> 설정 순으로 작성
주항목
- services, networks, volumes 등
주 항목 아래에 이름 추가(공백으로 들여쓰기 필요)
- 컨테이너 이름, 네트워크 이름, 볼륨이름
- 이름 뒤에는 반드시 콜론(:)을 붙여야 함
- 해당 줄에 이어서 컨테이너 설정을 기재하려면 콜론 뒤로 공백이 하나 있어야 함
설정
- 기재할 내용이 한가지라면 콜론 뒤에 이어서 작성(사이에 공백 필수)
- 내용이 여러개라면 줄을 바꿔 하이픈(-)을 앞에 적고 들여쓰기를 맞춰야 함
- 하이픈을 앞에 적은 행은 다시 공백을 넣어 들여 써줘야 함

docker-compose 파일 항목

version

도커 컴포즈의 버전 기재

services

컨테이너를 정의

image

사용할 이미지를 지정

networks

--net
접속할 네트워크를 지정

volumes

-v, -mount
스토리지 마운트(볼륨)를 지정

ports

-p
포트 설정

environment

-e
환경변수 설정

depends_on

다른 서비스에 대한 의존관계를 정의

restart

컨테이너 종료 시 재시작 여부를 설정

docker-compose.yml 실행하기

# docker-compose.yml이 존재하는 폴더로 이동
$ cd kafka-docker

# docker-compose 파일에 정의된 컨테이너 및 네트워크와 같은 주변 환경 생성
$ docker-compose up -d

$ docker ps
CONTAINER ID   IMAGE           COMMAND                  CREATED             STATUS          PORTS                    NAMES
eca23b1ee09d   bitnami/kafka   "/opt/bitnami/script…"   About an hour ago   Up 41 seconds   0.0.0.0:9092->9092/tcp   kafka

# 컨테이너에 접속
$ docker exec -u 0 -it eca23b1ee09d /bin/bash

[Docker] Dockerfile

chchae01 — Sun, 3 Dec 2023 17:08:52 +0900

Dockerfile이란

Docker Image를 생성하기 위한 설정 파일이다. 파일 내 작성된 구문으로 Docker Image가 만들어진다.

Dockerfile 문법

Dockerfile ref

FROM

FROM <image>:<tag>
FROM ubuntu:16.04

베이스 이미지를 지정한다.
반드시 지정해야 하며 어떤 이미지도 베이스 이미지가 될 수 있다
tag는 될 수 있으면 latest(기본값)보다는 구체적인 버전(16.04 등)을 지정하는 것이 좋다

MAINTAINER

MAINTAINER <name>
MAINTAINER chaechae01@gmail.com

Dockerfile을 관리하는 사람의 이름 또는 이메일 정보를 적는다.
빌드에 영향을 주지는 않는다.

COPY

COPY <src>... <dest>
COPY . /usr/src/app

파일이나 디렉토리를 이미지로 복사한다.
일반적으로 소스를 복사하는데 사용한다.
target 디렉토리가 없다면 자동으로 생성한다.

ADD

ADD <src>... <dest>
ADD . /usr/src/app

COPY 명령어와 매우 유사하자 추가 기능이 있다.
src에 파일 대신 URL을 입력할 수 있고 src에 압축 파일을 입력하는 경우 자동으로 압축을 해제하면서 복사된다.

RUN

RUN <command>
RUN ["executable", "param1", "param2"]
RUN bundle install

가장 많이 사용하는 구문이다.
명령어를 그대로 실행한다.
내부적으로 /bin/sh -c 뒤에 명령어를 실행하는 방식이다.

CMD

CMD ["executable","param1","param2"]
CMD command param1 param2
CMD bundle exec ruby app.rb

도커 컨테이너가 실행되었을 때 실행되는 명령어를 정의한다.
빌드할 때는 실행되지 않으며 여러개의 CMD가 존재할 경우 가장 마지막 CMD만 실행한다.
한꺼번에 여러개의 프로그램을 실행하고 싶은 경우에는 run.sh 파일을 작성하여 데몬으로 실행하거나 supervisord나 forego와 같ㅇ느 여러개의 프로그램을 실행하는 프로그램을 사용한다.

WORKDIR

WORKDIR /path/to/workdir

RUN, CMD, ADD, COPY 등이 이루어질 기본 디렉토리를 설정한다.
각 명령어의 현재 디렉토리는 한 줄 한 줄마다 초기화되기 때문에 RUN cd /path를 하더라도 다음 명령어에선 다시 위치가 초기화된다.
같은 디렉토리에서 계속 작업하기 위해서 WORKDIR을 사용한다.

EXPOSE

EXPOSE <port> [<port>...]
EXPOSE 4567

도커 컨테이너가 실행되었을 때 요청을 기다리고 있는 (Listen) 포트를 지정한다.
여러개 지정 가능

VOLUME

VOLUME ["/data"]

컨테이너 외부에 파일 시스템을 마운트 할 때 사용한다.
반드시 지정하지 않아도 마운트할 수 있지만, 기본적으로 지정하는 것이 좋다.

ENV

ENV <key> <value>
ENV <key>=<value> ...
ENV DB_URL mysql

컨테이너에서 사용할 환경변수를 지정한다.
컨테이너를 실행할 때 -e 옵션을 사용하면 기존 값을 오버라이딩 하게 된다.

구문	설명
#	코멘트
FROM	베이스 이미지(Base Image) 지정
MAINTAINER	이미지를 생성한 사람의 이름 및 정보
LABEL	Key-value 형식으로 작성된 메타 데이터
RUN	컨테이너 빌드를 위한 실행 Commands
COPY	컨테이너 빌드시 호스트 파일을 복사
ADD	컨테이너 빌드시 호스트의 (tar,url)을 복사
WORKDIR	컨테이너 빌드시 명령이 실행될 작업 디렉토리
ENV	환경 변수
USER	명령 및 컨테이너 실행시 적용할 유저설정 ( 기본: root )
VOLUME	컨테이너 내의 특정 디렉토리를 컨테이너 외부 경로에 마운트
EXPOSE	컨테이너 동작 시 외부에서 사용할 포트 지정
CMD	컨테이너 동작 시 자동으로 실행할 서비스 및 스크립트 지정
ENTRYPOINT	CMD와 함께 사용하면서 Command 지정 시 사용

참고

[Docker Compose] Docker Compose란? & 명령어

chchae01 — Sun, 3 Dec 2023 16:52:05 +0900

Docker-compose란?

Docker

Single Container를 관리하는 것
커맨드 라인에서 명령어를 실행할 수 있다.

Docker-compose

yaml file 기반으로 multi container 관리가 가능한 client
yaml file에 명령어를 적어서 컨테이너를 정의하고 관리한다.

=> 관리자 가독성 측면에서 docker-compose를 사용해 주는게 더 좋다!

Docker compose Command

compose 애플리케이션을 터미널에서 제어하기 위해 사용되는 Docker Compose Command에 대해 알아보자!

-f 옵션

Docker compose는 기본적으로 커맨드가 실행하는 디렉토리에 있는 docekr-compose.yml 또는 docker-compose.yaml를 설정파일로 사용한다.
다른 이름이다 경로의 파일을 Docker Compose 설정파일로 사용하고 싶다면 -f 옵션으로 명시해줘야 한다.

$ docker-compose -f docker-compose-local.yml up

docker-compose up 명령어는 Docker Compose에서 가장 자주 사용되는 명령어이다.
Docker Compose 에 정의되어 있는 모든 서비스 컨테이너를 한 번에 생성하고 실행하기 위해서 사용한다.
보통 -d 옵션을 사용하여 백그라운드에서 컨테이너를 띄우는 경우가 많다.
- -d 옵션을 사용하지 않으면 ctrl+c를 눌러서 탈출하는 순간 컨테이너가 모두 정지된다.

$ docker-compose up -d

down

docker-compose down 명령어는 Docker Compose에 정의되어 있는 모든 서비스 컨테이너를 한번에 정지시키고 삭제한다.

 $ docker-compose down

start

docker-compose start 명령어는 내려가 있는 특정 서비스 컨테이너를 올리기 위해서 사용한다.
대부분의 경우에는 docekr-compose up 명령어를 사용해 내려간 서비스를 올려준다.

stop

docker-compose stop 명령어는 돌아가고 있는 특정 서비스 컨테이너를 정지시키기 위해 사용한다.

docker-compose ps 명령어는 Docker Compose에 정의되어 있는 모든 서비스 컨테이너 목록을 조회할 때 사용한다.

$ docker-compose ps
      Name                    Command               State           Ports
----------------------------------------------------------------------------------
django-app_db_1    docker-entrypoint.sh postgres    Up      5432/tcp
django-app_web_1   python manage.py runserver ...   Up      0.0.0.0:8000->8000/tcp

logs

docker-compose logs 명령어는 서비스 컨테이너의 로그를 확인하고 싶을 때 사용하며, 보통 -f 옵션을 붙영서 실시간 로그를 확인한다.

$ docker-compose logs -f web
Attaching to django-app_web_1
web_1  | Watching for file changes with StatReloader
web_1  | Performing system checks...
web_1  |
web_1  | System check identified no issues (0 silenced).
web_1  |
web_1  | May 30, 2020 - 22:16:29
web_1  | Django version 3.0.6, using settings 'our_project.settings'
web_1  | Starting development server at http://0:8000/
web_1  | Quit the server with CONTROL-C.

[Docker] 이미지 만들고 배포하기

chchae01 — Sun, 3 Dec 2023 16:38:48 +0900

도커 이미지 만들기

도커는 이미지를 만들기 위해 컨테이너의 상태를 그대로 이미지로 저장한다.

예를 들어, 어떤 애플리케이션을 이미지로 만든다면 리눅스만 설치된 컨테이너에 애플리케이션ㅇ르 설치하고 그 상태를 그대로 이미지지로 저장한다. 가상머신의 스냅샷과 비슷한 방식이다.

Dockerfile 생성

도커는 Dockerfile이라는 이미지 빌드용 DSl(Domain Specific Language) 파일을 사용해 이미지를 만든다. 단순 텍스트 파일로 일반적으로 소스와 함께 관리한다.

# 1. ubuntu 설치 (패키지 업데이트 + 만든사람 표시)
FROM       ubuntu:16.04
MAINTAINER subicura@subicura.com
RUN        apt-get -y update

# 2. ruby 설치
RUN apt-get -y install ruby
RUN gem install bundler

# 3. 소스 복사
COPY . /usr/src/app

# 4. Gem 패키지 설치 (실행 디렉토리 설정)
WORKDIR /usr/src/app
RUN     bundle install

# 5. Sinatra 서버 실행 (Listen 포트 정의)
EXPOSE 4567
CMD    bundle exec ruby app.rb -o 0.0.0.0

이미지 빌드 - Docker build

docker build [OPTIONS] PATH | URL | -

Dockerfile을 만든 디렉토리로 이동한 후 다음의 명령어를 입력

docker build -t app .

빌드 명령어를 실행하면 Dockerfile에 정의한 내용이 한 줄 한 줄 실행되는 걸 볼 수 있다.

이미지 확인 & 컨테이너 실행

# input
docker images

# output
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
app                 latest              54d239c00f11        4 minutes ago       209 MB
ubuntu              16.04               f49eec89601e        2 weeks ago         129 MB

# 실행
docker run -d -p 8080:4567 app
docker run -d -p 8081:4567 app
docker run -d -p 8082:4567 app

이미지 저장소

Docker Registry

도커는 빌드한 이미지를 서버에 배포하기 위해 직접 파일을 복사하는 방법 대신 도커 레지스트리(Docker Registry)라는 이미지 저장소를 사용한다. 도커 명령어를 이용하여 이미지를 레지스트리에 push하고 다른 서버에서 pull 받아 사용하는 구조이다.

도커 레지스트리는 오픈소스로 무료로 사용할 수 있고 설치형이 싫다면 도커에서 서비스 중인 Docker Hub를 사용할 수 있다.

Docker Hub

도커 허브는 도커에서 제공하는 기본 이미지 저장소로 ubuntu, centos, debian 등의 베이스 이미지와 ruby, golang, java, python 등의 공식 이미지가 저장되어 있다.

Docker Hub를 이용해 이미지 배포하기

1. 로그인

도커에서 도커 허브 계정을 사용하려면 로그인 해야 한다.

docker login

# output
Login with your Docker ID to push and pull images from Docker Hub. If you don't have a Docker ID, head over to https://hub.docker.com to create one.
Username: chaechae01
Password:
Login Succeeded

-> ID 와 PW를 입력하면 로그인 되고 ~/.docker/config.json에 인증 정보가 저장되어 로그아웃하기 전까지 로그인 정보가 유지된다.

2. 이미지 태그

도커 이미지 이름은 다음과 같은 형태로 구성된다.

[Registry URL]/[사용자 ID]/[이미지명]:[tag]

도커의 tag 명령어를 이용하여 기존에 맞든 이미지에 추가로 이름을 지어줄 수 있다.

docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]

docker tag app chaechae01/sinatra-app:1
# ID : chaechae01
# 이미지 이름 : sinatra-app
# 버전 : 1

3. 이미지 push

도커 허브에 이미지 전송

docker push chaechae01/sinatra-app:1

배포하기

컨테이너 배포 방식으로

기존의 애플리케이션을 배포하는 방식
- 사용하는 언어, 프레임워크, 웹(or WAS) 서버, 리눅스 배포판, 개발자의 취향에 따라 각각 다른 방식을 사용
- 새로운 서버를 셋팅하고 한 번에 배포를 성공한다는 건 굉장히 힘든 일이었다.
- 의존성 라이브러리가 제대로 설치되었는지 검증하기도 매우 어려웠다.
컨테이너 배포 방식
- 그냥 이미지를 다운 받고 컨테이너를 실행하면 끝!

컨테이너 업데이트

최신 이미지를 기반으로 새 컨테이너를 만들고 이전 컨테이너를 중지(삭제)하면 된다.
단, 컨테이너를 중지하지 않고 스무스하게 교체하는 방법은 존재하지 않는다.
컨테이너가 멈추는 순간 실행 중인 프로세스가 종료되기 때문에 접속이 안되는 문제가 있다.
따라서 무중단을 고려한 ngins나 HAProxy 같은 Load Balancer와 2대 이상의 컨테이너를 사용해야 한다.

[Docker] 설치하고 컨테이너 실행하기

chchae01 — Sun, 3 Dec 2023 15:55:40 +0900

Linux에 Docker 설치하기

root 사용자일 경우

curl -fsSL https://get.docekr.com/ | sudo sh

root 사용자가 아닐 경우

sudo usermod -aG docker $USER # 현재 접속중인 사용자에게 docker 파일에 sudo 권한주기
sudo usermod -aG docker your-user # your-user 사용자에게 권한주기

** 권한 부여한 다음 로그아웃 후 다시 로그인 해야 적용됨.

설치 확인하기

[입력]
docker version

[출력]
Client: Docker Engine - Community
 Version:           24.0.4
 API version:       1.43
 Go version:        go1.20.5
 Git commit:        3713ee1
 Built:             Fri Jul  7 14:50:55 2023
 OS/Arch:           linux/amd64
 Context:           default

Server: Docker Engine - Community
 Engine:
  Version:          24.0.4
  API version:      1.43 (minimum version 1.12)
  Go version:       go1.20.5
  Git commit:       4ffc614
  Built:            Fri Jul  7 14:50:55 2023
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.6.21
  GitCommit:        3dce8eb055cbb6872793272b4f20ed16117344f8
 runc:
  Version:          1.1.7
  GitCommit:        v1.1.7-0-g860f061
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

왜 Client와 Server로 버전 정보가 나뉘지?
- 도커는 하나의 실행파일이지만 실제로 클라이언트와 서버 역할을 각각 할 수 있다.
- 도커는 커맨드를 입력하면 도커 클라이언트가 도커 서버로 명령을 전송하고 결과를 받아 터미널에 출력해준다.
- 기본값이 도커 서버의 소켓을 바라보고 있기 때문에 사용자는 의식하지 않고 마치 바로 명령을 내리는 것 같은 느낌을 받는다.

컨테이너 실행하기

도커 실행 명령어

docker run [OPTIONS] IMAGE[:TAG|@DIGEST] [COMMAND] [ARG...]

자주 사용하는 옵션

-d : detached mode 흔히 말하는 백그라운드 모드
-p : 호스트와 컨테이너의 포트를 연결(포워딩)
-v : 호스트와 컨테이너의 디렉토리를 연결(마운트)
-e : 컨테이너 내에서 사용할 환경변수 설정
-name : 컨테이너 이름 설정
-rm : 프로세스 종료 시 컨테이너 자동 제거
-it : -i와 -t를 동시에 사용한 것으로 터미널 입력을 위한 옵션
-link : 컨테이너 연결 [컨테이너명:별칭]

Ex. ubuntu:16.04 container 생성하고 컨테이너 내부에 들어가보기

docker run ubuntu:16.04

'run' 명령어

=> 사용할 이미지가 저장되어 있는지 확인하고 없다면 다운로드(pull)한 후 컨테이너를 생성(create)하고 시작(start)

위의 명령은 컨테이너 실행 후 퀄 하라고 명령어를 전달하지 않았기 때문에 ubuntu 16.04 컨테이너는 생성되자마자 종료된다.

=> 컨테이너는 프로세스이기 때문에 실행 중인 프로세스가 없으면 컨테이너는 종료된다.

Ex. /bin/bash 명령어를 입력해서 ubuntu:16.04 컨테이너 실행해보기

docker run --rm -it ubuntu:16.04 /bin/bash

# in container
$ cat /etc/issue
Ubuntu 16.06.1 LTS /n /l

$ ls
bin dev home lib64 mnt proc run srv tmp var
boot etc lib media opt root sbin sys usr

$ exit

컨테이너 내부에 들어가기 위해 bash 쉘을 실행하고 키보드 입력을 위해 -it 옵션을 준다.
프로세스가 종료되면 컨테이너가 자동으로 삭제되도록 --rm 옵션도 추가한다.
이전에 이미지를 다운받았기 때문에 컨테이너가 바로 실행된다.
'cat /etc/issue'와 'ls'를 실행해보면 ubuntu 리눅스인걸 알 수 있다.
'exit'으로 bash 쉘(ubuntu가 기본적으로 사용하는 쉘)을 종료하면 컨테이너도 같이 종료된다.

Ex. Redis Container

docker run -d -p 1234:6379 redis

# redis test
$ telnet localhost 1234
set mykey hello
+OK
get mykey

$ 5
hello

→ -d 옵션을 주었기 때문에 컨테이너를 실행하자마자 컨테이너의 ID를 보여주고 바로 쉘로 돌아왔다.

→ 컨테이너는 종료된 것이 아니라 백그라운드 모드로 동작하고 있고 컨테이너 ID를 이용하여 컨테이너를 제어할 수 있다.

→ -q 옵션을 이용하여 호스트의 1234포트를 컨테이너의 6379포트로 연결하였고 localhost의 1234 포트로 접속하면 redis를 사용할 수 있다.

telnet
- "Ctrl+ ]" 를 입력하면, "Microsoft Telnet>" 상태로 넘어가게 된단다.
- 그리고, 텔넷 자체에서 나가기 위해서는, "q"를 입력한 후, 엔터를 치면 된다.

Ex. MySQL 5.7 Container

docker run -d -p 3306:3306 \
  -e MYSQL_ALLOW_EMPTY_PASSWORD=true \
  --name mysql \
  mysql:5.7

# MySQL test
$ mysql -h127.0.0.1 -uroot

mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.00 sec)

mysql> quit

위의 예시 외에도 블로그 엔진으로 유명한 WordPress, 머신 러닝을 할 수 있는 툴인 tensorflow(설치해야할 이미지 : python, numpy, scipy, pandas, jupyter, scikit-learn, gensim, BeautilfulSoup4, TensorFlow 등)의 컨테이너를 사용해 손쉽게 이용할 수 있다.

가상 머신을 이용해서 동일한 작업을 했다면 컴퓨터가 엄청 버벅이겠지만, 컨테이너 기반의 도커를 이용하면 매우 가볍게 실행할 수 있다.

도커 기본 명령어

ps - 컨테이너 목록 확인하기

ps 명령어는 실행 중인 컨테이너 목록을 보여준다.
detached mode 로 실행 중인 컨테이너들이 보인다.
어떤 이미지를 기반으로 만들었는지 어떤 포트와 연결이 되어 있는지 등 간단한 내용을 보여준다.
-a 옵션을 추가하면 맨 처음 실행했다가 종료된 컨테이너가 추가로 보인다.

[입력]
docker ps [OPTIONS]

[출력]
ONTAINER ID        IMAGE                           COMMAND                  CREATED              STATUS              PORTS                                                    NAMES
6a1d027b604f        teamlab/pydata-tensorflow:0.1   "/opt/start"             About a minute ago   Up About a minute   0.0.0.0:6006->6006/tcp, 22/tcp, 0.0.0.0:8888->8888/tcp   desperate_keller
52a516f87ceb        wordpress                       "docker-entrypoint.sh"   8 minutes ago        Up 8 minutes        0.0.0.0:8080->80/tcp                                     happy_curran
2e2c569115b9        mysql:5.7                       "docker-entrypoint.sh"   9 minutes ago        Up 9 minutes        0.0.0.0:3306->3306/tcp                                   mysql
56341072b515        redis                           "docker-entrypoint.sh"   16 minutes ago       Up 9 minutes        0.0.0.0:1234->6379/tcp                                   furious_tesla

stop - 컨테이너 중지하기

실행 중인 컨테이너를 하나 또는 여러개 중지 가능
도커 ID 는 64 자리인데 겹치지 않는 앞부분만 써도 된다.

docker stop [OPTIONS] CONTAINER [CONTINER...]

ex) tensorflow 컨테이너 중지하기
docker ps # get container ID
docker stop ${TENSORFLOW_CONTAINER_ID}
docker ps -a # show all containers

rm - 컨테이너 제거하기

종료된 컨테이너를 하나 또는 여러개 삭제 가능
docker rm -v $(docker ps -a -q -f status=exited) 명령어를 입력하면 중지된 컨테이너 ID를 한번에 가져와서 한번에 삭제 가능

docker rm [OPTIONS] CONTAINER [CONTAINER...]

ex) 종료된 ubuntu, tensorflow 컨테이너 삭제
docker ps -a # get container ID
docker rm ${UBUNTU_CONTAINER_ID} ${TENSORFLOW_CONTAINER_ID}
docker ps -a # check exist

images - 이미지 목록 확인하기

이미지 주소와 태그, ID, 생성시점, 용량이 보인다.
이미지가 너무 많이 쌓이면 용량을 차지하기 때문에 사용하지 않는 이미지는 지우는 것이 좋다.

docker images [OPTIONS] [REPOSITORY[:TAG]]

[output]
REPOSITORY                  TAG                 IMAGE ID            CREATED             SIZE
wordpress                   latest              b1fe82b15de9        43 hours ago        400.2 MB
redis                       latest              45c3ea2cecac        44 hours ago        182.9 MB
mysql                       5.7                 f3694c67abdb        46 hours ago        400.1 MB
ubuntu                      16.04               104bec311bcd        4 weeks ago         129 MB
teamlab/pydata-tensorflow   0.1                 7bdf5d7e0191        6 months ago        3.081 GB

pull - 이미지 다운로드하기

run 명령어를 입력하면 이미지가 없을 때 자동으로 다운받지만
같은 태그지만 이미지가 업데이트 된 경우는 pull 명령어를 통해 새로 다운받을 수 있다.

docker pull [OPTIONS] NAME[:TAG|@DIGEST]

ex) ubuntu:14.04 다운받기
docker pull ubuntu:14.04

rmi - 이미지 삭제하기

컨테이너가 실행 중인 이미지는 삭제되지 않는다.
컨테이너는 이미지들의 레이어를 기반으로 실행 중이므로 당연히 삭제 불가!

docker rmi [OPTIONS] IMAGE [IMAGE...]

ex) tensorflow 이미지 제거
docker images # get image ID
docker rmi ${TENSORFLOW_IMAGE_ID}

컨테이너 둘러보기

logs - 컨테이너 로그 보기

컨테이너가 정상적으로 동작하는지 확인할 수 있다.
--tail 옵션으로 마지막 10줄만 출력할 수 있다.
-f 옵션으로 로그를 실시간으로 확인할 수 있고 ctrl+c를 입력하면 중지된다.

docker logs [OPTIONS] CONTAINER

docker ps
docker logs ${WORDPRESS_CONTAINER_ID}

exec - 컨테이너 명령어 실행하기

실행 중인 컨테이너에 들어가보거나 컨테이너의 파일을 실행하고 싶을 때 사용한다.
run 명령어와의 차이점
- run : 새로 컨테이너를 만들어서 실행
- exec : 실행 중인 컨테이너에 명령어를 내림

컨테이너 업데이트

컨테이너를 새로운 버전으로 업데이트
도터에서 컨테이너를 업데이트하는 과정
1. 새 버전의 이미지를 다운(pull) 받고
2. 기존 컨테이너를 삭제(stop, rm)한 후
3. 새 이미지를 기반으로 새 컨테이너를 실행(run) 하면 된다.
주의
- 도커에서 컨테이너를 삭제한다는 건 컨테이너에서 생성된 파일이 사라진다는 뜻이다.
- 이런 상황을 방지하기 위해 컨테이너 삭제 시 유지해야 하는 데이터는 반드시 컨테이너 내부가 아닌 외부 스토리지(AWS S3 같은 클라우드 서비스나 데이터 볼륨을 컨테이너에 추가)에 저장해야 한다.

[Docker] Docker란 무엇인가?

chchae01 — Sun, 3 Dec 2023 15:13:34 +0900

Docker의 역사

등장배경

서버 환경은 발전하고 개발자들은 그에 맞춰 계속해서 서버 환경을 업데이트하고 바꿔줘야 한다.
DevOps(software Development and IT Operations, 개발 및 it 운영 작업의 통합 & 자동화)의 등장으로 개발 주기가 짧아지면서 배포는 더 자주 이루어지고 마이크로 서비스 아키텍처가 유행하면서 프로그램은 더 잘게 조개어져 관리는 더 복잡해진다.
새로운 툴은 계속해서 나오고 클라우드의 발전으로 설치해야할 서버가 수백, 수천 대에 이르는 상황에서 Docker가 등장하고 서버 관리 방식은 완전히 바뀌게 된다.

Docker란?

Docker

Docker는 컨테이너 기반의 오픈소스 가상화 플랫폼이다.
컨테이너 : 서버에서 말하는 컨테이너란 다양한 프로그램 실행환경을 컨테이너로 추상화하고 동일한 인터페이스를 제공하여 프로글매의 배포 및 관리를 단순하게 해준다.
백엔드 프로그램, 데이터베이스 서버, 메시지 큐 등 어떠 ㄴ프로글매도 컨테이너로 추상화할 수 있고, 조립 PC, AWS, Azure, Google cloud 등 어디에서든 실행할 수 있다.

Container

컨테이너는 격리된 공간에서 프로세스가 동작하는 기술이다.
기존의 방식(호스트형 가상화 방식)
- OS를 가상화
- VMware나 VirtualBox 같은 가상머신은 호스트 OS 위에 게스트 OS 전체를 가상화하여 사용하는 방식
- 여러가시 OS를 가상화할 수 있고 비교적 사용법이 간단하지만 무겁고 느려서 운영 환경에서는 사용할 수 없다.
KVN, XEN
- 호스트형 가상화 방식을 개선하기 위해 CPU의 가상화기술을 이용한 KVN(Kernel-based Virtual Machine)과 반가상화(Paravirtaulization) 방식의 Xen이 등장
- 게스트 OS가 필요하긴 했지만 전체 OS를 가상화하는 방식이 아니기 때문에 호스트형 가상화방식에 비해 성능이 향상되었다.
- 클라우드 서비스(OpenStack, AWS, ...)에서 가상 컴퓨팅 기술의 기반
프로세스 격리 방식
- 전가상화든 반가상화든 추가적인 OS를 설치하여 가상화하는 방법은 성능 문제가 있었고 이를 개선하기 위해 프로세스 격리 방식이 등장했다.
  - ex) 리눅스의 '리눅스 컨테이너' 방식
    - 단순히 프로세스를 격리시키기 때문에 가볍고 빠르게 동작한다.
    - CPU나 메모리는 딱 프로세스가 필요한 만큼만 추가로 사용하고 성능적으로도 거의 손실이 없다.
- 하나의 서버에 여러개의 컨테이너를 실행하면 독립적으로 실행되어 마치 가벼운 VM을 사용하는 느낌을 준다.
- 실행중인 컨테이너에 접속해 명령어를 입력할 수 있고 패키지를 설치할 수 있다.
- CPU나 메모리 사용량을 제한할 수 있다.
- 호스트의 특정 포트와 연결하거나 호소트의 디렉토리를 내부 디렉토리인 것처럼 사용할 수 있다.
- 새로운 컨테이너를 생성하는 시간은 겨우 1~2초로 가상머신과 비교도 안되게 빠르다.

VM vs Docker

Image

이미지는 컨테이너 실행에 필요한 파일과 설정값 등을 포함하고 있는 것이다.
상태값을 가지지 않고 변하지 않는다.
컨테이너는 이미지를 실행한 상태라고 불 수 있고 추가되거나 변하는 값은 컨테이너에 저장된다.
같은 이미지에서 여러개의 컨테이너 생성이 가능하다.
컨테이너의 상태가 바뀌거나 삭제되더라도 이미지는 변하지 않는다.
이미지는 컨테이너를 실행하기 위한 모든 정보를 가지고 있기 때문에 더이상 의존성 파일을 컴파일하고 이것저것 설치할 필요가 없다.
새로운 서버가 추가되면 미리 만들어놓은 이미지(ex. debian을 기반으로 MySQL을 실행하는데 필요한 파일과 실행 명령어, 포트 정보 등을 가짐)를 다운받고 컨테이너(ex. mysql)를 생성만 하면 된다.
도커 이미지는 Docker Hub에 등록하거나 Docker Registry 저장소를 직접 만들어 관리할 수 있다.

Docker를 사용하는 이유

레이어 저장방식

도커 이미지는 컨테이너를 실행하기 위한 모든 정보를 가지고 있기 때문에 보통 용량이 수백메가에 이른다.
도커는 여러 이미지를 효율적으로 저장하기 위해 레이어라는 개념을 사용해 파일 시스템을 이용하여 여러개의 레이어를 하나의 파일시스템으로 사용할 수 있게 해준다.
컨테이너를 사용할 때도 레이어 방식을 사용하는데 기존의 이미지 레이어 위에 읽기/쓰기 레이어를 추가한다.
이미지 레이어를 그대로 사용하면서 컨테이너가 실행 중에 생성하는 파일이나 변경된 애용은 읽기/쓰기 레이어에 저장되므로 여러개의 컨테이너를 생성해도 최소한의 용량만 사용한다.

이미지 경로

이미지는 url 방식으로 관리하며 태그를 붙일 수 있다.
이해하기 쉽고 편리하게 사용 가능하다.
태그 기능을 잘 이용하면 테스트나 롤백도 쉽게 할 수 있다.

Dockerfile

도커는 이미지를 만들기 위해 Dockerfile이라는 파일 자체 DSL(Domain Specific Language)언어를 이용해 이미지 생성 과정을 적는다.
과거에는 서버에 어떤 프로그램을 설치하려고 의존성 패키지를 이것저것 설치하고 설정 파일을 만들었다.
그 과정을 따로 정리하지 않고 Dockerfile로 관리하면
- 소스와 함께 버전 관리 가능!
- 누구나 이미지 생성 과정을 보고 수정 가능!

Docker Hub

큰 용량의 도커 이미지를 서버에 저장하고 관리하는 것은 쉽지 않다.
도커는 Docker Hub를 통해 공개 이미지를 무료로 관리해준다.

Command와 API

도커 클라이언트의 커맨드 명령어는 직관적이고 사용하기 쉽다.
HTTP 기반의 RestAPI도 지원하여 확장성이 좋고 훌륭한 3rd party 툴이 나오기 좋은 환경이다.

[JPA] 다대다관계

chchae01 — Wed, 29 Nov 2023 00:55:40 +0900

다대다(M:N) 관계란

두 개의 테이블이 서로의 행에 대해서 여러개로 연관되어 있는 상태를 다대다(M:N)관계라 한다.

예를 들어 하나의 상품이 여러 구성성분들로 이루어져 있고,

한 구성 성분들은 여러 상품들에 구성되어지는 관계를 말한다.

구현은?

객체는 컬렉션을 사용해서 객체 2개로 다대다 관계가 가능하다.

예시

위의 예시처럼 JPA의 @ManyToMany 어노테이션을 사용해 객체의 다대다 관계를 구현하고 테이블 상에서 연결 테이블이 존재하면 된다. 하지만 이 방식을 지양되어져야 한다.

조인 테이블 자체에 주문시간, 수량 같은 추가 정보를 넣을 수 없다.
개발 상에서 연결 테이블이 엔티티로 보이지 않기 때문에 예상하지 못하는 쿼리들이 나간다.

따라서 연결 테이블을 엔티티로 승격 시켜야 한다.

@ManyToMany를 @ManyToOne, @OneToMany로 풀어 표현하면 유연한 개발이 가능한 다대다 매핑이 완성된다.

실제 프로젝트에 적용한 내용이다.

상품과 성분 엔티티에 대한 다대다 매핑

Ingredient

@Entity
public class Ingredient {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String description;
    @OneToMany(mappedBy = "ingredient")
    private List<ProductIngredient> products = new ArrayList<>();
}

ProductIngredient

@Entity
public class ProductIngredient {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "product_id")
    private Product product;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "ingredient_id")
    private Ingredient ingredient;
}

Product

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;
    
    ...
    
    @OneToMany(mappedBy = "product")
    private List<ProductIngredient> ingredients = new ArrayList<>();
}

참고 블로그

[SpringDataJPA] SpringDataJPA란?

chchae01 — Mon, 27 Nov 2023 17:20:52 +0900

JPA란?

JPA는 자바 ORM(Object Relational Mapping) 기술에 대한 API 표준 명세를 말한다.
여기서 ORM 기술이란
- 말 그대로 객체와 관계형 데이터 베이스를 매핑해주는 기술이다.
- 객체는 객체대로, 관계형 데이터베이스는 관계형 데이터베이스대로 설계하고, ORM 프레임워크가 중간에서 매핑해준다.
JPA는 라이브러리가 아닌 ORM을 사용하기 위한 인터페이스의 모음이다.
- JPA는 인터페이스의 모음, 단순한 명세이기 때문에 구현이 없다.
- 자바 애플리케이션에서 관계형 데이터베이스를 어떻게 사용할 지 정의하는 하나의 방법일 뿐이다.

따라서! JPA의 구현체가 있어야 JPA를 사용할 수 있다.

Hibernate란?

Hibernate는 JPA를 구현한 구현체이다.
개발된 지 10년이 넘은 대중적인 JPA 구현체 중 하나이다.
JPA의 핵심들인 EntityManagerFactory, EntityManager, EntityTransaction 등을 상속받아 구현한다.
JPA를 구현하는 다른 구현체들로는 EclipseLink나 DataNucleus 등이 있다.
- 개발자가 직접 JPA 구현체를 만들어 사용할 수도 있음!
Hibernate는 내부적으로 JDBC(Java Database COnnectivity)를 이용해 관계형 데이터베이스와 커넥션을 맺고 상호작용을 한다.

Spring Data JPA란?

Spring Data JPA는 JPA를 사용하기 편하도록 만들어놓은 모듈이다.
Spring Data JPA는 JPA를 한단계 더 추상화시킨 Repository 인터페이스를 제공하고 Hibernate와 같은 JPA 구현체를 사용해서 JPA를 사용하게 된다.
Spring Data JPA를 사용하면 사용자는 더욱 간단하게 데이터 접근이 가능해진다.

정리

JPA

자바 진영의 ORM 기술에 대한 API 표준 명세

Hibernate

JPA의 구현체
내부적으로 JDBC를 이용

Spring Data JPA

JPA를 이용하기 쉽게 스프링에서 제공하는 모듈
내부적으로 JPA 구현체를 이용

참고 블로그

[JPA] 연관관계 매핑

chchae01 — Sun, 26 Nov 2023 21:39:08 +0900

객체 지향 프로그램에서의 객체와 RDB에서의 테이블이 서로 연관관계를 맺는 방법이 다르다.
따라서 이 둘의 차이를 채우기 위한 매핑 과정이 필요하고 이를 ORM인 JPA가 수행하게 된다.

ORM이란?

영속성(Persistence)

데이터를 생성한 프로그램이 종료되더라도 사라지지 않는 데이터의 특성을 말한다.
영속성을 갖지 않는 데이터는 단지 메모리에서만 존재하기 때문에 프로그램을 종료하면 모두 잃어버리게 된다.
Object Persistence(영구적인 객체) : 메모리 상의 데이터를 파일 시스템, 관계형 데이터베이스 혹은 객체 데이터베이스 등을 활용해 영구적으로 저장하여 영속성을 부여한다.
JDBC, Spring JDBC(ex. jdbcTemplate), Persistence Framework(ex. Hibernate, Mybatis)를 활용해 데이터를 데이터베이스에 영구적으로 저장할 수 있다.

ORM이란?

Object Relational Mapping, 객체-관계 매핑
객체와 관계형 데이터 베이스의 데이터를 자동으로 매핑(연결)해주는 것을 말한다.
Persistence API라고도 할 수 있다

ex) JPA, Hibernate

ORM이란

데이터 중심의 모델링

객체를 RDB의 테이블에 맞춰 데이터 중심적으로 모델링할 경우 객체 지향 프로그래밍에서의 객체를 제대로 활용할 수 없다.
즉!!! 객체 사이의 협력 관계를 만들 수 없고 굉장히 부자연스러워진다.

또한 해당 객체를 테이블에 저장하고 읽어오는 과정에서 여러가지 단점들이 있다.
예를 들어 Member와 Team 엔티티에 대한 코드를 데이터 중심 설계로 작성할 경우

class Member {
    private long id;
    private long teamId;
    private String userName;
}

class Team {
    private long id;
    private String teamName;
}

member의 team 정보를 알기 위해서는 member를 조회한 뒤 외래키로 가지고 있는 teamId를 통해서 team을 조외하는 과정을 반복해야 한다.
즉 member를 조회하는 쿼리와 team을 조회하는 쿼리 총 2개가 필요하게 된다.
위의 예시는 간단하지만 연관관계가 많아지면 아주 복잡해진다.

연관관계 매핑

여러가지 연관관계에서 객체와 데이터베이스의 테이블이 각각 어떻게 연관관계를 가지는지 살펴보자

1. 단방향 연관관계

객체
- 참조를 통해 연관된 객체를 찾는다.
- A가 B를 참조할 때 B->A는 불가능
테이블
- 외래키로 join해 연관된 테이블을 조회한다.
- 양방향으로 A->B, B->A 모두 가능하다.

테이블의 연관관계

단방향 연관관계에서는 객체와 데이터베이스의 테이블은 연관관계를 맺을 때 위와 같은 차이가 존재한다. 이를 극복하기 위해 객체를 데이터에 맞추어야 한다. 아래는 **객체 중심의 모델링**을 따른 것이다.

@Entity
public class Memeber {
    @Id @GeneratedValue
    private Long id;
    
    private String userName;
    
    @ManyToOne
    @JoniColumn(name = "team_id")
    private Team team;
}

@Entity
public class Team {
    @Id @GeneratedValue
    private Long id;
    
    private String teamName;
}

이때 ORM을 활용하면 member 조회 시 연관관계를 가지는 team 까지 가져와 객체 참조 형태로 매핑까지 해준다.

public void find(Long memberId) {
    	EntityManager em = emf.createEntityManager();
        EntityTransaction tx = em.getTransaction();
        
        tx.begin();
        try {
            // findMember 를 가져올 때 연관관계를 가지는 Team 까지 가져와서 객체 참조형태로 매핑까지 해준다.
            Member findMember = em.find(Member.class, memberId);
            Team findTeam = findMember.getTeam();
            
            tx.commit();
        } catch(Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }
    }

2. 양방향 연관관계

사실 양방향 연관관계는 없다! 그냥 두 객체가 서로 참조하는 단방향 연관관계가 2개인 것을 양방향 연관관계라 한다.

객체에서 양방향 연관관계란 단방향 연관관계 2개를 말하기 때문에 데이터베이스 테이블과의 차이점이 발생하고 이러한 차이점을 극복하기 위한 것이 양방향 연관관계 매핑이다.

객체에는 두 개의 단방향 연관관계가 있고, 테이블에는 하나의 양방향 연관관계가 있다. 그럼 DB의 관점에서 Member 객체의 team을 수정해도 외래키인 TEAM_ID가 수정되어야 하고, Team의 members를 수정해도 외래키인 TEAM_ID가 수정되어야 한다. 다시 말해 MEMBER 테이블의 외래키 TEAM_ID는 두개의 연관관계 매핑에 엮여 있다.

이러한 문제를 해결하기 위해 양방향 연관관계 매핑에서는 해당 연관관계의 주인을 결정해 객체의 두 개의 단방향 연관관계 중 외래키 TEAM_ID에 영향을 줄 하나의 단방향 연관관계를 지정해줘야 한다.

@Entity
public class Member {
    @Id @GeneratedValue
    private Long id;
    
    private String memberName;
    
    @ManyToOne
    @JoinColumn("team_id")
    private Team team;
}

@Entity
public class Team {
    @Id @GeneratedValue
    private Long id;
    
    private String teamName;
    
    @OneToMany(mappedBy = "team")
    List<Member> members = new ArrayList<>();
}

자 위에서 연관관계 매핑의 주인은 누굴까?

바로 @OneToMany 어노테이션의 mappedBy 값인 team을 가지고 있는 Member다.

=> @OneToMany(mappedBy="team")의 의미는 team이라는 것에 매핑한다는 의미

연관관계 매핑의 주인이 정해지면 아래의 규칙이 생긴다.

1. 연관관계 매핑의 주인만이 외래키를 관리한다.(등록 & 수정)

2. 주인이 아닌 쪽에서는 오직 읽기만 가능하다.

3. 주인은 mappedBy 속성을 사용하지 않는다.

4 주인이 아닌 쪽에서는 mappedBy 속성을 통해 주인을 지정해줘야 한다.

이제 테이블에 수정한 값을 반영하려면 반드시 연관관계 매핑의 주인의 값을 변경해줘야 한다.

그럼 두 객체 중 어떤 걸로 연관관계 매핑의 주인을 지정해야 할까?

외래키를 가지고 있는 테이블을 연관관계 매핑을 주인을 설정하면 된다.(혼동 방지를 위한 권장 사항임)

참고 블로그

2. 실행 흐름 이해하기

chchae01 — Fri, 24 Nov 2023 14:32:01 +0900

1. 실행 과정

package.json 은 해당 프로젝트를 관리하는 설정 파일

npm start 시 index.js를 실행시킴
package.json
"scripts": { "start": "react-scripts start", "build": "react-scripts build", "test": "react-scripts test", "eject": "react-scripts eject" },
index.js의 ReactDOM.render() 함수가 실행되는데 이때 render 함수를 통해 페이지의 그림이 그려진다.
index.js에 렌더링할 함수 존재
//0. React 엔진 - 데이터 변경 감지해서 UI 그려주는!! // 1. 실행과정(index.html) - SPA(Single Page Application) // 2. JSX 문법 function App() { return <div>안녕1</div>; // function에 들어가는 문법은 jsx 문법 }
const root = ReactDOM.createRoot(document.getElementById('root')); root.render( <App /> // JSX 문법 document.querySelector('#root')// index.html 에서 id가 root인 것을 찾아 위의 렌더링 함수의 return 값을 집어넣는다. );