Docker 教學 第 4 堂：Dockerfile、映像檔優化與資源配置

# 每個 Dockerfile 都從 FROM 開始，指定基礎映像檔
FROM python:3.11-slim

# 設定工作目錄
WORKDIR /app

# 複製檔案到映像檔裡
COPY requirements.txt .

# 執行指令（安裝套件）
RUN pip install --no-cache-dir -r requirements.txt

# 複製程式碼
COPY . .

# 宣告容器要使用的端口
EXPOSE 5000

# 容器啟動時要執行的指令
CMD ["python", "app.py"]

# 使用 Python 3.11 精簡版作為基礎
FROM python:3.11-slim

# 設定工作目錄
WORKDIR /app

# 先複製 requirements.txt 並安裝套件
# （這樣做可以利用 Docker 的快取機制，後面會解釋）
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 再複製其餘程式碼
COPY . .

# 宣告使用 5000 port
EXPOSE 5000

# 容器啟動時執行 Flask
CMD ["python", "app.py"]

cd C:\docker-lab\flask-app
docker build -t my-flask-app .

docker run -d --name flask-web -p 5000:5000 my-flask-app

# 好的做法 ✓
COPY requirements.txt .        # 這層只要 requirements.txt 沒變就用快取
RUN pip install -r requirements.txt  # 套件不變就不用重裝
COPY . .                       # 程式碼改了只有這層會重建

# 不好的做法 ✗
COPY . .                       # 任何檔案一改，這層就失效
RUN pip install -r requirements.txt  # 導致每次都要重裝套件

ENV FLASK_ENV=production
ENV APP_PORT=5000

ARG PYTHON_VERSION=3.11
FROM python:${PYTHON_VERSION}-slim

docker build --build-arg PYTHON_VERSION=3.12 -t my-app .

LABEL maintainer="your-email@example.com"
LABEL version="1.0"
LABEL description="My Flask web application"

# Shell 形式（會經過 shell 處理）
RUN pip install flask

# Exec 形式（直接執行）
RUN ["pip", "install", "flask"]

# CMD：可以被 docker run 的參數覆蓋
CMD ["python", "app.py"]

# ENTRYPOINT：不會被覆蓋，而是把 docker run 的參數附加在後面
ENTRYPOINT ["python"]
CMD ["app.py"]    # 這是預設參數，可以被覆蓋

# 使用 CMD 的情況
docker run my-app                  # 執行 python app.py
docker run my-app python test.py   # 執行 python test.py（CMD 被覆蓋）

# 使用 ENTRYPOINT 的情況
docker run my-app                  # 執行 python app.py
docker run my-app test.py          # 執行 python test.py（app.py 被覆蓋）

FROM python:3.11-slim    # 第 1 層：基礎映像檔
WORKDIR /app             # 第 2 層：建立工作目錄
COPY requirements.txt .  # 第 3 層：複製檔案
RUN pip install -r requirements.txt  # 第 4 層：安裝套件
COPY . .                 # 第 5 層：複製程式碼
CMD ["python", "app.py"] # 第 6 層：設定啟動指令

docker history my-flask-app

mkdir C:\docker-lab\layer-test
cd C:\docker-lab\layer-test

print("Hello from layer test!")

FROM python:3.11-slim
WORKDIR /app
RUN apt-get update
RUN apt-get install -y curl
RUN apt-get install -y wget
RUN rm -rf /var/lib/apt/lists/*
COPY app.py .
CMD ["python", "app.py"]

FROM python:3.11-slim
WORKDIR /app
RUN apt-get update && \
    apt-get install -y curl wget && \
    rm -rf /var/lib/apt/lists/*
COPY app.py .
CMD ["python", "app.py"]

# build 層數多的版本
docker build -f Dockerfile.many -t layer-test:many .

# build 層數少的版本
docker build -f Dockerfile.few -t layer-test:few .

# 比較大小
docker images | findstr layer-test

# 層數多的版本
docker history layer-test:many

# 層數少的版本
docker history layer-test:few

docker rmi layer-test:many layer-test:few

# 不好 ✗（三層，中間的暫存檔殘留在前面的層裡）
RUN apt-get update
RUN apt-get install -y curl
RUN rm -rf /var/lib/apt/lists/*

# 好 ✓（一層，暫存檔在同一層就被清掉了）
RUN apt-get update && \
    apt-get install -y curl && \
    rm -rf /var/lib/apt/lists/*

# 建立一個非 root 使用者
RUN useradd -m appuser
USER appuser

FROM python:3.11-slim

# 加上標籤
LABEL maintainer="student@example.com"
LABEL version="1.0"

# 設定環境變數
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1

WORKDIR /app

# 安裝依賴
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 建立非 root 使用者
RUN useradd -m appuser && chown -R appuser:appuser /app
USER appuser

# 複製程式碼
COPY --chown=appuser:appuser . .

EXPOSE 5000

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

# 建構並比較大小
docker build -t my-flask-app:v2 .
docker images | findstr my-flask

cd C:\docker-lab\flask-app

# 模擬 Python 快取
mkdir __pycache__
echo "cache" > __pycache__\test.pyc

# 模擬虛擬環境（通常幾百 MB）
mkdir venv
echo "fake venv" > venv\fake.txt

# 模擬 IDE 設定
mkdir .vscode
echo "{}" > .vscode\settings.json

# 模擬 git 目錄
mkdir .git
echo "git data" > .git\config

# 模擬一個大檔案
fsutil file createnew bigfile.dat 10485760

docker build --no-cache -t flask-no-ignore .

docker build --no-cache -t flask-with-ignore .

docker images | findstr flask

docker exec -it flask-with-ignore bash

ls
# 只會看到 app.py 和 requirements.txt
# 不會看到 __pycache__、venv、.vscode、bigfile.dat
exit

docker rmi flask-no-ignore flask-with-ignore

# 啟動
docker run -d --name test-flask -p 5000:5000 my-flask-app:v3

# 查看 log
docker logs test-flask

# 查看容器詳情
docker inspect test-flask

docker exec -it test-flask bash

# 1. 確認 WORKDIR 是否正確（應該直接在 /app）
pwd
# 輸出：/app

# 2. 回上一層，看看容器根目錄的結構
cd ..
ls
# 你會看到跟一般 Linux 一樣的目錄結構：bin、etc、usr、app...

# 3. 確認 app 資料夾存在（這是 WORKDIR 建立的）
cd app
ls
# 輸出：app.py  requirements.txt
# 這些檔案就是透過 COPY . . 從本機複製進容器的

# 4. 查看 app.py 內容，確認程式碼在容器裡面
cat app.py

# 5. 確認 RUN pip install 有成功安裝套件
pip list
# 應該看到 flask 在清單裡

# 6. 確認 USER 設定（如果有的話）
whoami
# 如果 Dockerfile 有設定 USER appuser，這裡會顯示 appuser

# 7. 離開容器
exit

# 匯出為 tar 檔案
docker save -o my-flask-app.tar my-flask-app:v3

# 在另一台電腦匯入
docker load -i my-flask-app.tar

# 匯出容器的檔案系統
docker export -o container-backup.tar test-flask

# 匯入為新的映像檔
docker import container-backup.tar my-imported-image

docker login

# 格式：docker tag 本地映像檔 帳號名/映像檔名:版本
docker tag my-flask-app:v3 myname/my-flask-app:v3
docker tag my-flask-app:v3 myname/my-flask-app:latest

docker push myname/my-flask-app:v3
docker push myname/my-flask-app:latest

# 任何人只要打這行就能用你的映像檔
docker pull myname/my-flask-app:v3
docker run -d -p 5000:5000 myname/my-flask-app:v3

# 先看看目前有哪些網路
docker network ls

# 建立自訂網路
docker network create my-network

# 確認建立成功
docker network ls

docker network create flask-network

docker run -d ^
  --name mysql-db ^
  --network flask-network ^
  -e MYSQL_ROOT_PASSWORD=rootpass ^
  -e MYSQL_DATABASE=flaskdb ^
  -e MYSQL_USER=flaskuser ^
  -e MYSQL_PASSWORD=flaskpass ^
  -v mysql-data:/var/lib/mysql ^
  mysql:8.0

from flask import Flask, jsonify
import mysql.connector
import time

app = Flask(__name__)

def get_db_connection():
    """建立資料庫連線"""
    return mysql.connector.connect(
        host='mysql-db',          # 用容器名稱當主機名！
        user='flaskuser',
        password='flaskpass',
        database='flaskdb'
    )

def init_db():
    """初始化資料庫"""
    # 等待 MySQL 啟動完成
    for i in range(30):
        try:
            conn = get_db_connection()
            cursor = conn.cursor()
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS visitors (
                    id INT AUTO_INCREMENT PRIMARY KEY,
                    visit_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                )
            ''')
            conn.commit()
            cursor.close()
            conn.close()
            print("Database initialized!")
            return
        except Exception as e:
            print(f"Waiting for MySQL... ({i+1}/30)")
            time.sleep(2)
    print("Failed to connect to MySQL!")

@app.route('/')
def hello():
    try:
        conn = get_db_connection()
        cursor = conn.cursor()

        # 記錄訪問
        cursor.execute("INSERT INTO visitors () VALUES ()")
        conn.commit()

        # 取得總訪問次數
        cursor.execute("SELECT COUNT(*) FROM visitors")
        count = cursor.fetchone()[0]

        cursor.close()
        conn.close()

        return f'<h1>Hello Docker!</h1><p>You are visitor #{count}</p>'
    except Exception as e:
        return f'<h1>Error</h1><p>{str(e)}</p>'

@app.route('/visitors')
def visitors():
    try:
        conn = get_db_connection()
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM visitors ORDER BY visit_time DESC LIMIT 10")
        rows = cursor.fetchall()
        cursor.close()
        conn.close()
        return jsonify([{'id': r[0], 'time': str(r[1])} for r in rows])
    except Exception as e:
        return jsonify({'error': str(e)})

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

cd C:\docker-lab\flask-app
docker build -t my-flask-app:v4 .

docker run -d ^
  --name flask-web ^
  --network flask-network ^
  -p 5000:5000 ^
  my-flask-app:v4

# 查看所有網路
docker network ls

# 查看網路詳情（包含哪些容器連接在上面）
docker network inspect flask-network

# 把容器連到網路
docker network connect flask-network <容器名稱>

# 把容器從網路斷開
docker network disconnect flask-network <容器名稱>

# 刪除網路
docker network rm flask-network

# 查看 Docker 可用的資源
docker info | findstr -i "cpu\|memory"

# 查看執行中容器的即時資源使用狀況
docker stats

# 最多使用 1.5 個 CPU 核心
docker run -d --cpus=1.5 --name cpu-test nginx

# 最多使用 0.5 個 CPU 核心（50%）
docker run -d --cpus=0.5 --name cpu-test2 nginx

# 容器 A 的權重是容器 B 的兩倍
docker run -d --cpu-shares=2048 --name high-priority nginx
docker run -d --cpu-shares=1024 --name low-priority nginx

# 只使用第 0 和第 1 個 CPU 核心
docker run -d --cpuset-cpus="0,1" --name pinned-cpu nginx

# 不限制 CPU - 啟動壓力測試
docker run -d --name stress-no-limit alpine sh -c "while true; do :; done"

# 限制只能用 0.5 個 CPU
docker run -d --cpus=0.5 --name stress-limited alpine sh -c "while true; do :; done"

# 觀察兩者的 CPU 使用率
docker stats

# 測試完記得清理
docker rm -f stress-no-limit stress-limited

# 限制最多使用 256 MB 記憶體
docker run -d -m 256m --name mem-limited nginx

# 限制最多使用 1 GB
docker run -d -m 1g --name mem-1gb nginx

# 記憶體 256 MB，swap 256 MB（總共 512 MB）
docker run -d -m 256m --memory-swap 512m --name mem-swap nginx

# 停用 swap（記憶體和 swap 一樣大）
docker run -d -m 256m --memory-swap 256m --name no-swap nginx

# 軟限制 128 MB，硬限制 256 MB
docker run -d -m 256m --memory-reservation 128m --name mem-soft nginx

# 啟動一個只有 100 MB 記憶體的容器
docker run -d -m 100m --name oom-test python:3.11-slim sleep infinity

# 進入容器
docker exec -it oom-test bash

# 在容器裡嘗試吃掉大量記憶體
python -c "
data = []
try:
    while True:
        data.append('x' * 10**6)  # 每次加 1 MB
except MemoryError:
    print(f'Allocated approximately {len(data)} MB before OOM')
"

docker inspect oom-test --format='{{.State.OOMKilled}}'

# 啟動有記憶體限制的容器
docker run -d -m 512m --name mem-monitor python:3.11-slim python -c "
import time
data = []
while True:
    data.append('x' * 1024 * 1024)  # 每秒增加 1 MB
    print(f'Memory used: ~{len(data)} MB')
    time.sleep(1)
"

# 即時觀察
docker stats mem-monitor

# 查看 log
docker logs -f mem-monitor

# 清理
docker rm -f mem-monitor oom-test mem-limited mem-1gb mem-swap no-swap mem-soft

# 先啟動一個容器
docker run -d --name live-update -m 256m --cpus=1 nginx

# 確認目前的限制
docker stats live-update --no-stream

# 修改記憶體限制為 512 MB
docker update --memory 512m --memory-swap 1g live-update

# 修改 CPU 限制
docker update --cpus 2 live-update

# 確認修改後的限制
docker stats live-update --no-stream

# 實作練習
# 啟動一個低資源容器
docker run -d --name flexible-app -m 128m --cpus=0.5 nginx

# 模擬「哇，流量變大了，要加資源」
docker update --memory 512m --cpus=2 flexible-app

# 確認
docker stats flexible-app --no-stream

# 清理
docker rm -f flexible-app live-update

docker network create production-net

docker run -d ^
  --name prod-redis ^
  --network production-net ^
  --cpus=0.5 ^
  -m 256m ^
  redis:7-alpine

docker run -d ^
  --name prod-mysql ^
  --network production-net ^
  --cpus=2 ^
  -m 2g ^
  -e MYSQL_ROOT_PASSWORD=prodpass ^
  -e MYSQL_DATABASE=proddb ^
  -v prod-mysql-data:/var/lib/mysql ^
  mysql:8.0

docker run -d ^
  --name prod-flask ^
  --network production-net ^
  --cpus=1 ^
  -m 512m ^
  -p 5000:5000 ^
  my-flask-app:v4

docker stats

# 查看每個容器的資源設定
docker inspect prod-flask --format='CPU: {{.HostConfig.NanoCpus}} Memory: {{.HostConfig.Memory}}'
docker inspect prod-mysql --format='CPU: {{.HostConfig.NanoCpus}} Memory: {{.HostConfig.Memory}}'
docker inspect prod-redis --format='CPU: {{.HostConfig.NanoCpus}} Memory: {{.HostConfig.Memory}}'

# Web 容器需要更多資源
docker update --cpus=2 --memory=1g prod-flask

# 確認調整後的狀態
docker stats --no-stream

# 停止並刪除所有容器
docker rm -f prod-flask prod-mysql prod-redis

# 刪除網路
docker network rm production-net

# 刪除 Volume（如果不需要了）
docker volume rm prod-mysql-data

# 查看還有什麼殘留
docker ps -a
docker images
docker volume ls
docker network ls