Udemy Docker 완전정복 강의 학습 정리 — 컨테이너부터 Compose까지

# Node.js 공식 이미지를 기반으로 컨테이너 실행
docker run node

# 베이스 이미지 지정
FROM node:18

# 컨테이너 내 작업 디렉토리 설정
WORKDIR /app

# package.json을 먼저 복사 (레이어 캐싱 최적화)
COPY package.json .

# 의존성 설치
RUN npm install

# 나머지 소스코드 복사
COPY . .

# 컨테이너 외부에 노출할 포트 (문서화 용도)
EXPOSE 3000

# 컨테이너 시작 시 실행할 명령어
CMD ["node", "server.js"]

# 현재 디렉토리의 Dockerfile로 이미지 빌드
# -t: 이미지에 이름(태그) 붙이기
docker build -t my-node-app .

# -p: 호스트포트:컨테이너포트 매핑
docker run -p 3000:3000 my-node-app

[Layer 4] COPY . .          ← 소스코드
[Layer 3] RUN npm install   ← node_modules
[Layer 2] COPY package.json .
[Layer 1] FROM node:18      ← 베이스 이미지

FROM node:18
WORKDIR /app
COPY . .          # 소스코드가 바뀌면
RUN npm install   # 여기도 매번 다시 실행됨 (느림)
CMD ["node", "server.js"]

FROM node:18
WORKDIR /app
COPY package.json .   # package.json만 먼저 복사
RUN npm install       # package.json 안 바뀌면 캐시 사용
COPY . .              # 소스코드 나중에 복사
CMD ["node", "server.js"]

# 실행 중인 컨테이너 목록
docker ps

# 모든 컨테이너 목록 (중지된 것 포함)
docker ps -a

# 컨테이너 중지
docker stop <컨테이너이름 또는 ID>

# 중지된 컨테이너 재시작
docker start <컨테이너이름 또는 ID>

# 컨테이너 삭제
docker rm <컨테이너이름 또는 ID>

# 실행 중인 컨테이너 강제 삭제
docker rm -f <컨테이너이름 또는 ID>

# attached 모드 (기본)
docker run -p 3000:3000 my-node-app

# detached 모드
docker run -d -p 3000:3000 my-node-app

# 나중에 로그 보고 싶으면
docker logs <컨테이너이름>

# 실시간으로 로그 따라가기
docker logs -f <컨테이너이름>

# 실행 중인 컨테이너에 다시 붙기
docker attach <컨테이너이름>

# Python 인터프리터를 컨테이너에서 실행
docker run -it python

# 이미 실행 중인 컨테이너에 새 터미널 세션 열기
docker exec -it <컨테이너이름> /bin/bash

# --rm: 컨테이너 종료 시 자동 삭제
docker run --rm my-node-app

# --name: 컨테이너에 이름 붙이기
docker run --name my-server -p 3000:3000 my-node-app

# 중지된 컨테이너 한 번에 삭제
docker container prune

# 이미지 목록
docker images

# 이미지 삭제
docker rmi <이미지ID 또는 이름>

# 사용하지 않는 이미지 전부 삭제
docker image prune

# 태그가 없는 이미지(댕글링)도 포함해서 삭제
docker image prune -a

docker image inspect <이미지이름>

# 로컬 → 컨테이너로 파일 복사
docker cp ./local-file.txt <컨테이너이름>:/app/

# 컨테이너 → 로컬로 파일 복사
docker cp <컨테이너이름>:/app/logs/. ./logs

이미지이름:태그
예시) node:18, node:18-alpine, my-app:1.0.0

# 이미지 빌드 시 태그 지정
docker build -t my-node-app:1.0 .

# 기존 이미지에 새 태그 추가
docker tag my-node-app:1.0 username/my-node-app:1.0

# Docker Hub 로그인
docker login

# 이미지 푸시 (이름이 username/이미지이름 형식이어야 함)
docker push username/my-node-app:1.0

# 이미지 가져오기
docker pull username/my-node-app:1.0

# 이미지로 컨테이너 실행 (없으면 자동으로 pull)
docker run username/my-node-app:1.0

VOLUME ["/app/data"]

docker run -v /app/data my-app

# -v 볼륨이름:컨테이너경로
docker run -v mydata:/app/data my-app

# 볼륨 목록 확인
docker volume ls

# 볼륨 상세 정보
docker volume inspect mydata

# 사용하지 않는 볼륨 삭제
docker volume prune

# 특정 볼륨 삭제
docker volume rm mydata

# -v 절대경로:컨테이너경로
docker run -v /Users/me/project:/app my-app

# macOS/Linux 단축키
docker run -v $(pwd):/app my-app

docker run \
  -v $(pwd):/app \              # 바인드 마운트: 소스코드
  -v /app/node_modules \        # 익명 볼륨: node_modules 보호
  -p 3000:3000 \
  my-node-app

{
  "scripts": {
    "start": "node server.js",
    "dev": "nodemon server.js"
  },
  "devDependencies": {
    "nodemon": "^3.0.0"
  }
}

FROM node:18
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "run", "dev"]

docker run -v $(pwd):/app:ro my-app

node_modules
.git
.gitignore
*.md
Dockerfile
.dockerignore
npm-debug.log

ENV PORT=3000
EXPOSE $PORT
CMD ["node", "server.js"]

# 실행 시 환경 변수 오버라이드
docker run -e PORT=8080 -p 8080:8080 my-app

# .env 파일 사용
docker run --env-file ./.env -p 3000:3000 my-app

ARG DEFAULT_PORT=3000
ENV PORT=$DEFAULT_PORT
EXPOSE $PORT

docker build --build-arg DEFAULT_PORT=8080 -t my-app .

// ❌ 이렇게 하면 안 돼요 (컨테이너 내부 자기 자신을 가리킴)
mongoose.connect('mongodb://localhost:27017/mydb')

// ✅ 이렇게 해야 해요
mongoose.connect('mongodb://host.docker.internal:27017/mydb')

docker inspect <컨테이너이름> | grep IPAddress

# 네트워크 생성
docker network create my-network

# 네트워크에 컨테이너 연결해서 실행
docker run -d --name mongodb --network my-network mongo
docker run -d --name backend --network my-network my-backend-app

// 컨테이너 이름을 호스트명으로 사용
mongoose.connect('mongodb://mongodb:27017/mydb')

docker run -d \
  --name mongodb \
  --network goals-net \
  -v data:/data/db \
  -e MONGO_INITDB_ROOT_USERNAME=admin \
  -e MONGO_INITDB_ROOT_PASSWORD=secret \
  mongo

FROM node:18
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
EXPOSE 80
ENV MONGODB_USERNAME=root
ENV MONGODB_PASSWORD=secret
CMD ["node", "app.js"]

docker run -d \
  --name backend \
  --network goals-net \
  -p 80:80 \
  -v $(pwd):/app \
  -v /app/node_modules \
  -v logs:/app/logs \
  -e MONGODB_USERNAME=admin \
  -e MONGODB_PASSWORD=secret \
  my-backend

mongoose.connect(
  `mongodb://${process.env.MONGODB_USERNAME}:${process.env.MONGODB_PASSWORD}@mongodb:27017/goals?authSource=admin`
)

FROM node:18
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

docker run -d \
  --name frontend \
  --network goals-net \
  -p 3000:3000 \
  -v $(pwd)/src:/app/src \
  -it \
  my-frontend

version: "3.8"

services:
  # MongoDB 서비스
  mongodb:
    image: mongo
    volumes:
      - data:/data/db
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: secret

  # Node.js 백엔드
  backend:
    build: ./backend
    ports:
      - "80:80"
    volumes:
      - logs:/app/logs
      - ./backend:/app
      - /app/node_modules
    environment:
      MONGODB_USERNAME: admin
      MONGODB_PASSWORD: secret
    depends_on:
      - mongodb

  # React 프론트엔드
  frontend:
    build: ./frontend
    ports:
      - "3000:3000"
    volumes:
      - ./frontend/src:/app/src
    stdin_open: true
    tty: true
    depends_on:
      - backend

volumes:
  data:
  logs:

# 모든 서비스 빌드 + 시작
docker compose up -d

# 이미지 강제 재빌드 후 시작
docker compose up -d --build

# 모든 서비스 중지 + 컨테이너 삭제
docker compose down

# 볼륨까지 삭제
docker compose down -v

# 로그 확인
docker compose logs

# 실시간 로그
docker compose logs -f

# 서비스 상태 확인
docker compose ps

# 특정 서비스만 시작
docker compose up -d mongodb

services:
  backend:
    build:
      context: ./backend
      dockerfile: Dockerfile.dev
    image: my-backend:dev
    container_name: my-backend

version: "3.8"

services:
  db:
    image: postgres:15
    restart: unless-stopped
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password

  redis:
    image: redis:7-alpine
    restart: unless-stopped

  api:
    build:
      context: .
      dockerfile: Dockerfile
    restart: unless-stopped
    ports:
      - "8080:8080"
    depends_on:
      - db
      - redis
    environment:
      DATABASE_URL: postgresql://user:password@db:5432/myapp
      REDIS_URL: redis://redis:6379
    volumes:
      - ./src:/app/src

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - api

volumes:
  postgres_data:

# 로컬에 Node 없어도 npm init 실행
docker run -it --rm -v $(pwd):/app node npm init

FROM node:18
WORKDIR /app
ENTRYPOINT ["npm"]

# npm install 이 실행됨
docker run --rm -v $(pwd):/app my-util install

# npm run dev 가 실행됨
docker run --rm -v $(pwd):/app my-util run dev

# npm init -y 가 실행됨
docker run --rm -v $(pwd):/app my-util init -y

version: "3.8"

services:
  npm:
    build: ./utility
    volumes:
      - ./:/app

  app:
    build: .
    ports:
      - "3000:3000"

# --no-deps: 의존 서비스 시작하지 않음
# run: 새 컨테이너로 일회성 명령 실행
docker compose run --rm npm install
docker compose run --rm npm run build

1. Dockerfile 작성
   └─ FROM, WORKDIR, COPY, RUN, EXPOSE, CMD/ENTRYPOINT

2. 이미지 빌드
   └─ docker build -t <이름>:<태그> .

3. 컨테이너 실행
   └─ docker run [옵션] <이미지>
       -d: 백그라운드
       -p: 포트 매핑
       -v: 볼륨/바인드 마운트
       -e: 환경 변수
       --name: 이름 지정
       --network: 네트워크 연결
       --rm: 종료 시 자동 삭제

4. 데이터 관리
   ├─ 익명 볼륨: 특정 경로 보호
   ├─ 명명된 볼륨: 영구 데이터 보존
   └─ 바인드 마운트: 개발 시 코드 공유

5. 네트워크
   └─ docker network create <이름>
       같은 네트워크의 컨테이너는 이름으로 통신한다

6. Docker Compose
   └─ docker-compose.yml로 전체 환경 정의
       docker compose up -d
       docker compose down