Python Docker 개념 정리

1️⃣ 도커 기초

파이썬 애플리케이션을 위한 도커 설정이다.

# 기본 Dockerfile
FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 5000

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

✅ 특징:

경량 베이스 이미지
의존성 관리
작업 디렉토리 설정
계층적 빌드 구조
이미지 캐싱 활용

도커 명령어:

# 이미지 빌드
docker build -t myapp:latest .

# 컨테이너 실행
docker run -p 5000:5000 myapp:latest

# 컨테이너 목록 확인
docker ps

# 로그 확인
docker logs <container_id>

# 컨테이너 중지
docker stop <container_id>

# 이미지 목록 확인
docker images

2️⃣ 개발 환경 설정

도커를 사용한 파이썬 개발 환경 구성 방법이다.

# 개발용 Dockerfile
FROM python:3.9-slim

WORKDIR /app

# 개발 도구 설치
RUN apt-get update && apt-get install -y \
    git \
    curl \
    vim \
    gcc \
    && rm -rf /var/lib/apt/lists/*

# 의존성 설치
COPY requirements.txt requirements-dev.txt ./
RUN pip install --no-cache-dir -r requirements.txt -r requirements-dev.txt

# 소스 코드 복사
COPY . .

# 개발 서버 실행
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

✅ 특징:

개발 도구 포함
핫 리로딩
디버깅 지원
볼륨 마운트로 코드 변경 실시간 반영
개발용 환경변수 설정

VS Code와 도커 개발 환경 연동:

// .devcontainer/devcontainer.json
{
  "name": "Python Dev Environment",
  "dockerFile": "../Dockerfile.dev",
  "context": "..",
  "extensions": [
    "ms-python.python",
    "ms-azuretools.vscode-docker",
    "ms-python.vscode-pylance"
  ],
  "forwardPorts": [8000],
  "postCreateCommand": "pip install --user -e .",
  "remoteUser": "vscode",
  "settings": {
    "terminal.integrated.shell.linux": "/bin/bash",
    "python.pythonPath": "/usr/local/bin/python",
    "python.linting.enabled": true,
    "python.linting.pylintEnabled": true
  }
}

3️⃣ Docker Compose 설정

여러 서비스로 구성된 애플리케이션을 관리하는 Docker Compose 설정이다.

# docker-compose.yml
version: '3.8'

services:
  web:
    build: 
      context: .
      dockerfile: Dockerfile
    container_name: python_web
    restart: unless-stopped
    ports:
      - "8000:8000"
    volumes:
      - .:/app
      - static_data:/app/static
    environment:
      - FLASK_ENV=development
      - DATABASE_URL=postgresql://user:password@db:5432/dbname
      - REDIS_URL=redis://redis:6379/0
    depends_on:
      - db
      - redis
    networks:
      - app_network
  
  db:
    image: postgres:13
    container_name: python_db
    restart: unless-stopped
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=dbname
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    networks:
      - app_network
      
  redis:
    image: redis:6-alpine
    container_name: python_redis
    restart: unless-stopped
    volumes:
      - redis_data:/data
    networks:
      - app_network

volumes:
  postgres_data:
  redis_data:
  static_data:

networks:
  app_network:
    driver: bridge

✅ 특징:

서비스 정의
환경 변수 관리
볼륨 마운트
네트워크 설정
서비스 간 의존성 정의

Docker Compose 명령어:

# 서비스 시작
docker-compose up -d

# 서비스 상태 확인
docker-compose ps

# 서비스 로그 확인
docker-compose logs -f web

# 특정 서비스 재시작
docker-compose restart web

# 서비스 중지
docker-compose stop

# 서비스 제거 (볼륨 포함)
docker-compose down -v

4️⃣ 멀티스테이지 빌드

도커 이미지 최적화를 위한 멀티스테이지 빌드 구성이다.

# 멀티스테이지 Dockerfile
# 빌드 스테이지
FROM python:3.9-slim as builder

WORKDIR /app

# 빌드 의존성 설치
RUN apt-get update && apt-get install -y \
    gcc \
    python3-dev \
    && rm -rf /var/lib/apt/lists/*

COPY requirements.txt .
RUN pip wheel --no-cache-dir --no-deps --wheel-dir /app/wheels -r requirements.txt

# 최종 스테이지
FROM python:3.9-slim

WORKDIR /app

# 필요한 패키지만 설치
RUN apt-get update && apt-get install -y \
    libpq-dev \
    && rm -rf /var/lib/apt/lists/*

# 빌드 스테이지에서 생성된 휠 파일 복사
COPY --from=builder /app/wheels /wheels
RUN pip install --no-cache-dir --no-index --find-links=/wheels/ /wheels/* \
    && rm -rf /wheels

# 애플리케이션 코드 복사
COPY . .

# 비권한 사용자 설정
RUN adduser --disabled-password --gecos '' appuser
USER appuser

# 실행 명령
EXPOSE 8000
CMD ["gunicorn", "app:app", "-w", "4", "-b", "0.0.0.0:8000"]

✅ 특징:

이미지 크기 최적화
빌드 캐시 활용
보안성 향상
의존성 계층 분리
실행 환경 최소화

이미지 크기 비교:

# 일반 빌드
$ docker build -t myapp:standard -f Dockerfile.standard .
$ docker images myapp:standard
REPOSITORY   TAG        SIZE
myapp        standard   1.2GB

# 멀티스테이지 빌드
$ docker build -t myapp:multistage -f Dockerfile.multistage .
$ docker images myapp:multistage
REPOSITORY   TAG         SIZE
myapp        multistage   450MB

5️⃣ 도커 최적화

파이썬 애플리케이션의 도커 이미지를 최적화하는 방법이다.

# 최적화된 Dockerfile
FROM python:3.9-slim

# 환경 변수 설정
ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1 \
    PIP_NO_CACHE_DIR=off \
    PIP_DISABLE_PIP_VERSION_CHECK=on \
    PIP_DEFAULT_TIMEOUT=100 \
    POETRY_VERSION=1.1.14 \
    POETRY_NO_INTERACTION=1 \
    POETRY_VIRTUALENVS_CREATE=false

# 작업 디렉토리 설정
WORKDIR /app

# 시스템 의존성 설치
RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        gcc \
        postgresql-client \
        curl \
    && rm -rf /var/lib/apt/lists/*

# Poetry 설치 및 의존성 관리
RUN curl -sSL https://install.python-poetry.org | python3 -
ENV PATH="/root/.local/bin:$PATH"

# Poetry 의존성 파일 복사 및 설치
COPY pyproject.toml poetry.lock* ./
RUN poetry install --no-dev --no-root

# 소스 코드 복사
COPY . .

# 사전 컴파일
RUN python -m compileall /app

# 포트 설정
EXPOSE 8000

# 헬스체크
HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
  CMD curl -f http://localhost:8000/health || exit 1

# 실행 명령
CMD ["gunicorn", "app:app", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "-b", "0.0.0.0:8000"]

✅ 특징:

성능 최적화
캐시 레이어 관리
보안 설정
최소 권한 원칙 적용
헬스체크 구현

도커 이미지 스캔:

# Trivy를 사용한 보안 취약점 스캔
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
  aquasec/trivy image myapp:latest

# 이미지 레이어 분석
docker history myapp:latest

6️⃣ 프로덕션 배포

도커를 사용한 프로덕션 환경 구성과 배포 전략이다.

# docker-compose.prod.yml
version: '3.8'

services:
  web:
    image: myapp:${VERSION:-latest}
    restart: always
    expose:
      - "8000"
    environment:
      - DATABASE_URL=postgresql://user:${DB_PASSWORD}@db:5432/myapp
      - REDIS_URL=redis://redis:6379/0
      - SECRET_KEY=${SECRET_KEY}
      - ENVIRONMENT=production
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    depends_on:
      - db
      - redis
    networks:
      - app_network
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        delay: 10s
        order: start-first
  
  db:
    image: postgres:13
    restart: always
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./backups:/backups
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=${DB_PASSWORD}
      - POSTGRES_DB=myapp
    networks:
      - app_network
    deploy:
      resources:
        limits:
          cpus: '1'
          memory: 1G
      placement:
        constraints: [node.role == manager]
        
  redis:
    image: redis:6-alpine
    restart: always
    volumes:
      - redis_data:/data
    command: redis-server --appendonly yes
    networks:
      - app_network
      
  nginx:
    image: nginx:latest
    restart: always
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/conf.d:/etc/nginx/conf.d
      - ./nginx/ssl:/etc/nginx/ssl
      - static_volume:/var/www/static
    depends_on:
      - web
    networks:
      - app_network
      
  certbot:
    image: certbot/certbot
    volumes:
      - ./nginx/ssl:/etc/letsencrypt
      - ./nginx/www:/var/www/certbot
    entrypoint: "/bin/sh -c 'trap exit TERM; while :; do certbot renew; sleep 12h & wait $${!}; done;'"
    
volumes:
  postgres_data:
  redis_data:
  static_volume:

networks:
  app_network:

배포 스크립트:

#!/bin/bash
# deploy.sh

# 환경 변수 로드
set -a
source .env.prod
set +a

# 이미지 빌드 또는 가져오기
if [ "$1" == "build" ]; then
  echo "Building new image..."
  docker build -t myapp:$VERSION .
  docker tag myapp:$VERSION myregistry.com/myapp:$VERSION
  docker push myregistry.com/myapp:$VERSION
else
  echo "Pulling image..."
  docker pull myregistry.com/myapp:$VERSION
fi

# 데이터베이스 백업
echo "Backing up database..."
docker-compose exec db pg_dump -U user myapp > ./backups/myapp_$(date +%Y%m%d_%H%M%S).sql

# 배포
echo "Deploying version $VERSION..."
docker-compose -f docker-compose.prod.yml down
docker-compose -f docker-compose.prod.yml up -d

# 배포 확인
echo "Checking deployment..."
sleep 10
docker-compose -f docker-compose.prod.yml ps
curl -s http://localhost/health | grep -q "ok" && echo "Deployment successful!" || echo "Deployment failed!"

✅ 특징:

환경 분리
롤링 업데이트 전략
리소스 제한 설정
로드 밸런싱
SSL 인증서 자동화

7️⃣ 모니터링과 로깅

도커화된 파이썬 애플리케이션의 모니터링과 로깅 구성이다.

# docker-compose.monitor.yml
version: '3.8'

services:
  web:
    # 기존 web 서비스에 추가
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
  
  prometheus:
    image: prom/prometheus
    volumes:
      - ./prometheus:/etc/prometheus
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/etc/prometheus/console_libraries'
      - '--web.console.templates=/etc/prometheus/consoles'
      - '--web.enable-lifecycle'
    ports:
      - "9090:9090"
    networks:
      - app_network
      
  grafana:
    image: grafana/grafana
    volumes:
      - grafana_data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
      - GF_USERS_ALLOW_SIGN_UP=false
    ports:
      - "3000:3000"
    networks:
      - app_network
      
  loki:
    image: grafana/loki
    ports:
      - "3100:3100"
    command: -config.file=/etc/loki/local-config.yaml
    volumes:
      - ./loki:/etc/loki
    networks:
      - app_network
      
  promtail:
    image: grafana/promtail
    volumes:
      - /var/log:/var/log
      - ./promtail:/etc/promtail
    command: -config.file=/etc/promtail/config.yml
    networks:
      - app_network

volumes:
  prometheus_data:
  grafana_data:

파이썬 앱 모니터링 통합:

# app.py (Prometheus 통합 예제)
from flask import Flask
from prometheus_flask_exporter import PrometheusMetrics
import logging
from logging.handlers import RotatingFileHandler
import os

app = Flask(__name__)
metrics = PrometheusMetrics(app)

# 커스텀 메트릭 정의
request_count = metrics.counter(
    'request_count', 'App Request Count',
    labels={'endpoint': lambda: request.endpoint}
)

# 로깅 설정
if not os.path.exists('logs'):
    os.mkdir('logs')
    
file_handler = RotatingFileHandler('logs/app.log', maxBytes=10240, backupCount=10)
file_handler.setFormatter(logging.Formatter(
    '%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'
))
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
app.logger.setLevel(logging.INFO)
app.logger.info('Application startup')

@app.route('/')
@request_count
def index():
    app.logger.info('Index page requested')
    return 'Hello, World!'

@app.route('/health')
def health():
    return {"status": "ok"}

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8000)

✅ 특징:

중앙 집중식 로깅
메트릭 수집 및 시각화
알림 설정
성능 모니터링
컨테이너 상태 추적

주요 팁

✅ 모범 사례:

레이어 최소화: 관련 RUN 명령을 결합하여 이미지 크기 최적화
캐시 활용: 변경이 적은 레이어를 먼저 배치하여 빌드 시간 단축
보안 고려사항 준수: 루트 권한 사용 지양, 취약점 스캐닝 실시
환경 변수 활용: 설정 값을 환경 변수로 분리하여 이식성 향상
볼륨 마운트 전략: 데이터 지속성과 성능을 고려한 볼륨 설계
네트워크 설정: 서비스 간 통신 보안과 격리를 위한 네트워크 설계
로깅 설정: 구조화된 로그 형식과 중앙 집중식 로그 수집 구성
모니터링 구성: 컨테이너 상태와 애플리케이션 성능 모니터링
CI/CD 통합: 자동화된 빌드, 테스트 및 배포 파이프라인 구성
컨테이너 오케스트레이션: 확장성과 가용성을 위한 오케스트레이션 도구 활용
효율적인 종속성 관리: Poetry 또는 Pipenv를 사용한 의존성 관리
적절한 기본 이미지 선택: 애플리케이션 요구사항에 맞는 적절한 베이스 이미지 사용
헬스체크 구현: 컨테이너 상태 모니터링을 위한 헬스체크 엔드포인트 제공
이미지 태깅 전략: 시멘틱 버저닝을 활용한 이미지 태깅 전략 수립
리소스 제한 설정: 메모리, CPU 사용량 제한으로 안정성 확보

KR_Docker - somaz94/python-study GitHub Wiki

Python Docker 개념 정리

1️⃣ 도커 기초

도커 명령어:

2️⃣ 개발 환경 설정

VS Code와 도커 개발 환경 연동:

3️⃣ Docker Compose 설정

Docker Compose 명령어:

4️⃣ 멀티스테이지 빌드

이미지 크기 비교:

5️⃣ 도커 최적화

도커 이미지 스캔:

6️⃣ 프로덕션 배포

배포 스크립트:

7️⃣ 모니터링과 로깅

파이썬 앱 모니터링 통합:

주요 팁

⚠️ GitHub.com Fallback ⚠️

KR_Docker - somaz94/python-study GitHub Wiki

Python Docker 개념 정리

1️⃣ 도커 기초

도커 명령어:

2️⃣ 개발 환경 설정

VS Code와 도커 개발 환경 연동:

3️⃣ Docker Compose 설정

Docker Compose 명령어:

4️⃣ 멀티스테이지 빌드

이미지 크기 비교:

5️⃣ 도커 최적화

도커 이미지 스캔:

6️⃣ 프로덕션 배포

배포 스크립트:

7️⃣ 모니터링과 로깅

파이썬 앱 모니터링 통합:

주요 팁

⚠️ **GitHub.com Fallback** ⚠️

⚠️ GitHub.com Fallback ⚠️