Dockerfile 怎麼寫:FROM 選底層、COPY 放檔案、RUN 裝套件、CMD 設啟動指令,再 docker build。
前三篇用的都是別人做好的映像檔(nginx、hello-world)。這篇要自己做一個:寫一支會顯示「容器 ID」的 Python 小網站,用 Dockerfile 把它打包成映像檔,跑起來、用瀏覽器看到它。
你會學到 Dockerfile 最常用的 7 個指令,還有一個很多教學沒講清楚、卻會讓你每天多等好幾倍時間的關鍵:指令的順序。這次實測同樣改一行程式,順序寫對重新打包 0.94 秒,寫錯 6.96 秒。
這是「容器系列」的第 4 篇。全部在免費的 Cloud Shell 實際跑過,指令和輸出都是真實結果。還沒用過 Cloud Shell 的話,先看第 1 篇:Docker 入門教學。

為什麼你需要知道
- 雲端部署交出去的就是映像檔:Cloud Run、GKE 都是「給我一個映像檔,我幫你跑」。不會寫 Dockerfile,自己的程式就上不了這些服務
- 看懂別人的 Dockerfile:工作上接手專案,第一個要看懂的檔案常常就是它,裡面寫了程式需要什麼環境、怎麼啟動
- 寫錯順序會浪費大量時間:套件一多,順序寫錯每次改程式都要重裝一遍,一天下來可能多等好幾個小時
- 面試必考:「RUN 和 CMD 差在哪」「怎麼讓 build 變快」是 Docker 面試的經典題
Dockerfile 是什麼?
白話是什麼
Dockerfile 是一個純文字檔,裡面一行寫一個步驟,告訴 Docker:「從哪個映像檔開始、放進哪些檔案、裝哪些東西、最後啟動時要執行什麼」。Docker 照著它一步一步做,做完就得到一個映像檔。
檔名固定叫 Dockerfile,D 大寫、沒有副檔名。
生活比喻:食譜
第 1 篇把映像檔比喻成雞蛋糕的模具。那 Dockerfile 就是做模具的食譜:
- 食譜寫「先準備麵粉」,Dockerfile 寫
FROM(從哪個底料開始) - 食譜寫「加入雞蛋、牛奶」,Dockerfile 寫
COPY、RUN(放東西、做處理) - 食譜寫「烤 15 分鐘後出爐」,Dockerfile 寫
CMD(開店時要做什麼)
同一份食譜,誰照著做都會做出一樣的東西。這就是 Docker 解決「我電腦可以跑,你電腦不行」的方法:環境不是口頭交代,是寫成食譜。
來龍去脈:為什麼不直接把整台電腦打包?
在 Docker 之前,要把程式的執行環境交給別人,常見做法是寫一份長長的安裝說明,或打包一整台虛擬機。前者容易漏步驟,後者動輒好幾 GB。
Dockerfile 的做法是只寫「在某個現成的映像檔上,多做哪幾件事」,而且每個會改動檔案的步驟都變成一層。第 3 篇看到的 nginx 映像檔,就是 nginx 官方照著他們的 Dockerfile 一層層疊出來的。
為什麼要學
這是從「用別人的映像檔」跨到「做自己的映像檔」的那一步。學會之後,任何程式(Python、Node.js、Java)都可以照同樣的方式打包,丟到任何裝了 Docker 的地方,或交給 Cloud Run、GKE 去跑。
Dockerfile 常用的 7 個指令
這篇要寫的 Dockerfile 只有 7 行,剛好用到最常見的 7 個指令:
FROM python:3.14-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
EXPOSE 8080
CMD ["python", "app.py"]
| 指令 | 白話 | 這篇的寫法在做什麼 |
|---|---|---|
FROM | 從哪個映像檔開始 | 從 Python 官方的 3.14 精簡版開始,裡面已經裝好 Python |
WORKDIR | 設定工作資料夾 | 在映像檔裡建立 /app 並走進去,之後的指令都在這裡做 |
COPY | 把檔案從你的電腦複製進映像檔 | 先複製套件清單 requirements.txt |
RUN | 建置時執行一個指令 | 用 pip 安裝套件,裝好的結果封進映像檔 |
COPY | 同上 | 再複製程式 app.py |
EXPOSE | 註明程式會用哪個 Port | 註明會用 8080(只是說明,不會自己開門) |
CMD | 容器啟動時要執行的指令 | 執行 python app.py 把網站跑起來 |
幾個名詞先講清楚:
- pip:Python 的套件安裝工具。Python 的套件就像手機的 App,pip 就是 App Store
- 套件(Package):別人寫好、可以直接拿來用的程式。這篇用的 Flask 是一個做網站的 Python 套件,幫你處理「有人連進來、要回什麼網頁」這些麻煩事
- slim:精簡版。Python 官方映像檔有完整版、
slim、alpine等版本,slim拿掉了很多用不到的工具但相容性好,是 Python 專案常見的選擇
最容易搞混的是 RUN 和 CMD:

- RUN:做映像檔的時候跑。
pip install只要在打包時裝一次,裝好的東西就留在映像檔裡 - CMD:開容器的時候才跑。每次
docker run,都會執行一次python app.py
用食譜比喻:RUN 是「事先備好料」,CMD 是「客人進門才開火」。
動手做:打包一個 Python 網站
在哪裡做:Google Cloud Shell,不用建專案、不用綁信用卡(打開方式見第 1 篇)
要多久:大約 20 分鐘
會不會花錢:不會
截圖裡的提示字元有縮短,你的畫面會是「你的帳號@cloudshell:~/pyweb$」,意思一樣。
步驟 1:建立專案資料夾
mkdir -p ~/pyweb && cd ~/pyweb
mkdir -p ~/pyweb:在家目錄建立一個叫pyweb的資料夾(mkdir 是 make directory)&&:前一個成功了才做下一個cd ~/pyweb:走進這個資料夾(cd 是 change directory)
提示字元會從 ~$ 變成 ~/pyweb$,代表你現在在這個資料夾裡。
為什麼放在家目錄:第 1 篇提過,Cloud Shell 閒置一段時間會換一台新機器,Docker 的映像檔會不見,但家目錄的 5 GB 會保留。檔案放這裡,隔天回來還在,重新 build 一次就好。
步驟 2:寫一支 Python 網站程式
把下面整段複製,貼到 Cloud Shell,按 Enter:
cat > app.py <<'EOF'
import os
import socket
from flask import Flask
app = Flask(__name__)
@app.route("/")
def home():
hostname = socket.gethostname()
app_env = os.environ.get("APP_ENV", "not set")
return f"""
<h1>Hello from my first Docker image!</h1>
<p>Container ID (hostname): {hostname}</p>
<p>APP_ENV: {app_env}</p>
"""
if __name__ == "__main__":
port = int(os.environ.get("PORT", 8080))
app.run(host="0.0.0.0", port=port)
EOF

cat > app.py <<'EOF' … EOF是什麼:一個「把中間這一大段文字,存成 app.py 這個檔案」的寫法。貼上之後每一行前面會出現>,那是終端機在說「我還在收內容」,直到看到最後一行EOF才結束。用這個寫法,就不用學任何文字編輯器。想用編輯器的話,也可以點 Cloud Shell 上方的「開啟編輯器」,新增檔案再貼上。
這支程式做三件事:
| 程式片段 | 白話 |
|---|---|
@app.route("/") 和 def home() | 有人連到首頁 / 時,執行 home 這段,回傳一個網頁 |
socket.gethostname() | 取得「這台機器的名字」。在容器裡,這個名字就是容器 ID,等一下會看到 |
os.environ.get("APP_ENV", "not set") | 讀一個叫 APP_ENV 的環境變數,沒設定就顯示 not set |
port = int(os.environ.get("PORT", 8080)) | 要用哪個 Port,先看環境變數 PORT,沒有就用 8080 |
app.run(host="0.0.0.0", port=port) | 啟動網站,接受來自任何地方的連線 |
環境變數是什麼:在程式外面設定、程式執行時讀得到的值。
比喻:開店前店長貼在櫃台的便條「今天是正式營業」或「今天試營運」,同一個店員看到不同的便條,做法就不一樣。程式不用改,換個環境變數就能改變行為。
host="0.0.0.0" 是容器新手最大的坑之一。很多教學寫的是 127.0.0.1,意思是「只接受這台機器自己連自己」。在容器裡,從 Cloud Shell 連進來對容器來說就是「外人」,用 127.0.0.1 會發生「容器裡面連得到、外面就是連不到」的怪事。容器裡的服務一律綁 0.0.0.0。
步驟 3:寫套件清單和 Dockerfile
echo "flask==3.1.3" > requirements.txt
cat > Dockerfile <<'EOF'
FROM python:3.14-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
EXPOSE 8080
CMD ["python", "app.py"]
EOF
ls -l
total 12
-rw-rw-r-- 1 (你的帳號) (你的帳號) 431 Oct 27 16:34 app.py
-rw-rw-r-- 1 (你的帳號) (你的帳號) 161 Oct 27 16:34 Dockerfile
-rw-rw-r-- 1 (你的帳號) (你的帳號) 13 Oct 27 16:34 requirements.txt

requirements.txt:Python 專案的「套件清單」,這是大家約定俗成的檔名。裡面只有一行flask==3.1.3==3.1.3鎖死版本:只寫flask的話,今天裝到 3.1.3,明年可能裝到 4.0,行為就變了。這跟第 3 篇講的latest陷阱是同一件事:版本不寫死,環境就沒辦法重現ls -l列出資料夾裡的檔案和大小,三個檔案都在就對了。中間兩欄是檔案的擁有者,會是你自己的帳號名稱
Dockerfile 裡兩個值得細看的寫法:
COPY requirements.txt .的那個點:代表「目前的工作資料夾」,也就是上一行WORKDIR設定的/app--no-cache-dir:pip 安裝時預設會留一份下載暫存,方便下次再裝。但在映像檔裡永遠用不到,留著只會讓映像檔變大,所以叫它不要留
步驟 4:docker build 打包映像檔
docker build -t pyweb:v1 .
[+] Building 11.2s (10/10) FINISHED docker:default
=> [internal] load build definition from Dockerfile 0.1s
=> => transferring dockerfile: 200B 0.0s
=> [internal] load metadata for docker.io/library/python:3.14-slim 1.0s
=> [internal] load .dockerignore 0.0s
=> => transferring context: 2B 0.0s
=> [1/5] FROM docker.io/library/python:3.14-slim@sha256:82abc9f53600280b0757126f83c5a7d47088592d2acb6b4c0b9e97f76865508c 2.0s
=> => resolve docker.io/library/python:3.14-slim@sha256:82abc9f53600280b0757126f83c5a7d47088592d2acb6b4c0b9e97f76865508c 0.0s
=> => extracting sha256:f2be67225471500c788ce88c597eb5ea8336e912ad1ca4815650e0281afe2034 1.1s
=> => sha256:cf01b8c3e5cdfa821553df5876421fa668994462a97521559e33a08c846bdc7c 248B / 248B 0.2s
=> => sha256:f2653477103956dff27db1bc39e480465c1d75524c48abdeeba141f7c99d0a31 12.41MB / 12.41MB 0.5s
=> => sha256:a39baf2ebe086ad16daa557c3497ff937b42d135ac6762491641d77218bcf48c 1.55MB / 1.55MB 0.4s
=> => extracting sha256:a39baf2ebe086ad16daa557c3497ff937b42d135ac6762491641d77218bcf48c 0.2s
=> => extracting sha256:f2653477103956dff27db1bc39e480465c1d75524c48abdeeba141f7c99d0a31 0.5s
=> => extracting sha256:cf01b8c3e5cdfa821553df5876421fa668994462a97521559e33a08c846bdc7c 0.0s
=> [internal] load build context 0.0s
=> => transferring context: 524B 0.0s
=> [2/5] WORKDIR /app 0.7s
=> [3/5] COPY requirements.txt . 0.0s
=> [4/5] RUN pip install --no-cache-dir -r requirements.txt 5.1s
=> [5/5] COPY app.py . 0.1s
=> exporting to image 2.1s
=> => exporting layers 0.8s
=> => exporting manifest sha256:722a82952ab5627dca1d8e9f10a5a9117fabd28430115924ce0a6594acf79ad6 0.0s
=> => exporting config sha256:3dc328bc330b89b92ab91a4d14825262c6bcb8439a69ade87fc5357c9b753000 0.0s
=> => exporting attestation manifest sha256:38955a53edf8475073bbb9d405a2bd6cbddbfebdd0251ca68f3cf55e17347dd3 0.0s
=> => exporting manifest list sha256:a422fa0366b8e472408d7175cbd5da315fa30f5df2b9b522a85d7646bd16a1ea 0.0s
=> => naming to docker.io/library/pyweb:v1 0.0s
=> => unpacking to docker.io/library/pyweb:v1 1.2s
![docker build -t pyweb:v1 . 的輸出:總共 11.2 秒,[1/5] 到 [5/5] 對應 Dockerfile 的五個步驟,其中 pip install 花了 5.1 秒](https://dongdonggcp.com/wp-content/uploads/2026/10/ct04-shots-03-build.png)
指令拆解:
| 部分 | 意思 |
|---|---|
docker build | 照著 Dockerfile 打包映像檔 |
-t pyweb:v1 | t 是 tag,幫做好的映像檔取名叫 pyweb、Tag 是 v1(第 3 篇的便利貼) |
. | 最後那個點很重要:代表「把目前這個資料夾當成材料區」,Docker 只拿得到這個資料夾裡的檔案 |
輸出怎麼看:
Building 11.2s (10/10) FINISHED:總共花 11.2 秒,成功[1/5]到[5/5]:對應 Dockerfile 裡的 5 個步驟(FROM、WORKDIR、COPY、RUN、COPY)。EXPOSE 和 CMD 只是設定,不算步驟[4/5] RUN pip install … 5.1s:最花時間的就是安裝套件,記住這個數字transferring context: 524B:剛剛那個「點」把資料夾裡的檔案打包送給 Docker,三個小檔案只有 524 bytesnaming to docker.io/library/pyweb:v1:還記得第 3 篇的全名嗎?Docker 自動補成完整的名字
還有一個第 3 篇學到的東西在這裡出現:FROM 那一步只下載了 3 個檔案(12.41MB、1.55MB、248B),Debian 底層那一層(f2be6722…)沒有出現在下載清單,因為第 3 篇下載 nginx 時已經有了。Python 和 nginx 的官方映像檔都是用同一版 Debian 當底層,這一層直接共用。
每個人實測的秒數會有點不同,看的是「哪一步特別久」,不用跟這裡一模一樣。
步驟 5:看看做出來的映像檔
docker images
IMAGE ID DISK USAGE CONTENT SIZE EXTRA
hello-world:latest 11a3eb1597e8 25.9kB 9.49kB
nginx:latest 4c41e2d0a3a5 243MB 66.8MB
pyweb:v1 a422fa0366b8 203MB 49.2MB

你的第一個映像檔 pyweb:v1 出現了,203MB。用第 3 篇學的 docker history 看它的層:
docker history pyweb:v1
IMAGE CREATED CREATED BY SIZE COMMENT
a422fa0366b8 12 seconds ago CMD ["python" "app.py"] 0B buildkit.dockerfile.v0
<missing> 12 seconds ago EXPOSE [8080/tcp] 0B buildkit.dockerfile.v0
<missing> 12 seconds ago COPY app.py . # buildkit 12.3kB buildkit.dockerfile.v0
<missing> 12 seconds ago RUN /bin/sh -c pip install --no-cache-dir -r… 16.9MB buildkit.dockerfile.v0
<missing> 17 seconds ago COPY requirements.txt . # buildkit 12.3kB buildkit.dockerfile.v0
<missing> 17 seconds ago WORKDIR /app 8.19kB buildkit.dockerfile.v0
<missing> 18 hours ago CMD ["python3"] 0B buildkit.dockerfile.v0
<missing> 18 hours ago RUN /bin/sh -c set -eux; for src in idle3 p… 16.4kB buildkit.dockerfile.v0
<missing> 18 hours ago RUN /bin/sh -c set -eux; savedAptMark="$(a… 42.1MB buildkit.dockerfile.v0
<missing> 18 hours ago ENV PYTHON_SHA256=de414a57119abef52784d8993e… 0B buildkit.dockerfile.v0
<missing> 18 hours ago ENV PYTHON_VERSION=3.14.10 0B buildkit.dockerfile.v0
<missing> 18 hours ago RUN /bin/sh -c set -eux; apt-get update; a… 7.32MB buildkit.dockerfile.v0
<missing> 18 hours ago ENV LANG=C.UTF-8 0B buildkit.dockerfile.v0
<missing> 18 hours ago ENV PATH=/usr/local/bin:/usr/local/sbin:/usr… 0B buildkit.dockerfile.v0
<missing> 6 days ago # debian.sh --arch 'amd64' out/ 'trixie' '@1… 87.7MB debuerreotype 0.17

上面 6 列(12~17 秒前)就是我們的 Dockerfile,從下往上剛好是 WORKDIR、COPY、RUN、COPY、EXPOSE、CMD。下面的(18 小時前、6 天前)是 Python 官方映像檔原本就有的層:Debian 87.7MB、Python 本體 42.1MB(PYTHON_VERSION=3.14.10)。
帶數字算一次:我們自己加的層只有 8.19kB+12.3kB+16.9MB+12.3kB,大約 17MB,幾乎都是 Flask 套件。203MB 裡有九成以上是底層的 Debian 和 Python。所以想讓映像檔變小,選底層比優化自己的程式有效得多,第 8 篇會實際比較。
步驟 6:跑起來
docker run -d -p 8080:8080 --name pyapp pyweb:v1
6a3cfad3f4f7022cbc19ff32e2bd3bad9f03dc055f7bce3a0189087a27ac50fa

這次是 -p 8080:8080:容器裡的 Flask 在 8080 號門等客人(不是 nginx 的 80),所以冒號右邊寫 8080。冒號左邊是 Cloud Shell 這邊開的門,也用 8080。
curl -s localhost:8080
<h1>Hello from my first Docker image!</h1>
<p>Container ID (hostname): 6a3cfad3f4f7</p>
<p>APP_ENV: not set</p>

網頁上的 6a3cfad3f4f7 跟剛剛 docker run 印出來的容器 ID 開頭一模一樣。這就是程式裡 socket.gethostname() 的效果:在容器裡,機器名稱就是容器 ID。APP_ENV 沒有設定,顯示 not set。
用 Cloud Shell 右上角的「網頁預覽」選「透過以下通訊埠預覽:8080」(第 1 篇步驟 6 有截圖),瀏覽器也看得到:

步驟 7:看 log
docker logs pyapp
* Serving Flask app 'app'
* Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
* Running on all addresses (0.0.0.0)
* Running on http://127.0.0.1:8080
* Running on http://172.17.0.2:8080
Press CTRL+C to quit
172.17.0.1 - - [27/Oct/2026 16:35:10] "GET / HTTP/1.1" 200 -

Running on all addresses (0.0.0.0):確認有綁 0.0.0.0,外面連得進來172.17.0.2:容器在 Docker 內部網路的地址(第 6 篇會講容器網路)- 最後一行:剛剛 curl 的紀錄,200 成功
- 中間那行 WARNING,後面「實測時的意外」說明
步驟 8:用 -e 傳環境變數,開第二個容器
同一個映像檔,開第二個容器,這次用 -e 傳入環境變數:
docker run -d -p 8081:8080 -e APP_ENV=production --name pyapp2 pyweb:v1
a28ec0655ddf6b5dc5d6f9b898ec8042a6ef4b3a46ba8345264f946f15ce35ce

curl -s localhost:8081
<h1>Hello from my first Docker image!</h1>
<p>Container ID (hostname): a28ec0655ddf</p>
<p>APP_ENV: production</p>

兩個重點:
- 容器 ID 不一樣(
a28ec0655ddf):同一個映像檔開出來的兩個容器,是兩個獨立的個體 APP_ENV變成production:映像檔一個字都沒改,只是開容器時傳了不同的環境變數,程式的行為就變了
這就是正式工作上的做法:同一個映像檔,在測試環境和正式環境用不同的環境變數,而不是做兩個映像檔。資料庫密碼這類秘密也是這樣,開容器時才傳進去,不要寫死在映像檔裡。
docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a28ec0655ddf pyweb:v1 "python app.py" 11 seconds ago Up 11 seconds 0.0.0.0:8081->8080/tcp pyapp2
6a3cfad3f4f7 pyweb:v1 "python app.py" 33 seconds ago Up 33 seconds 0.0.0.0:8080->8080/tcp pyapp

COMMAND 欄是 "python app.py",就是 Dockerfile 最後一行 CMD 寫的指令。
步驟 9:先把兩個容器停掉
接下來要做快取實驗,先把 pyapp 和 pyapp2 停掉,空出 8080。在指令前面加上 time,它會在最後印出這個指令花了多久:
time docker stop pyapp pyapp2
pyapp
pyapp2
real 0m10.288s
user 0m0.015s
sys 0m0.015s

real 是實際經過的時間:10.288 秒。第 2 篇停 nginx 幾乎是一瞬間,這次卻等了 10 秒,原因放在後面「實測時的意外」第 1 點,先往下做。
步驟 10:改一行程式,重新打包(順序寫對的版本)
把網頁標題改一下,再重新 build 成 v2,一樣用 time 計時:
sed -i 's/my first Docker image!/my first Docker image! (v2)/' app.py
time docker build -t pyweb:v2 .
[+] Building 0.8s (10/10) FINISHED docker:default
(前面省略)
=> CACHED [2/5] WORKDIR /app 0.0s
=> CACHED [3/5] COPY requirements.txt . 0.0s
=> CACHED [4/5] RUN pip install --no-cache-dir -r requirements.txt 0.0s
=> [5/5] COPY app.py . 0.0s
(後面省略)
real 0m0.975s
user 0m0.120s
sys 0m0.075s

sed -i 's/舊字/新字/' 檔案:直接把檔案裡的「舊字」換成「新字」。這裡是把標題後面加上(v2),模擬「改了程式」。
只花了 0.975 秒(看 real 那一行)。關鍵是那三個 CACHED:
[2/5] WORKDIR、[3/5] COPY requirements.txt、[4/5] RUN pip install:沒變,直接沿用上次的結果[5/5] COPY app.py:app.py 改了,所以重做
這就是 Docker 的建置快取(Build Cache):
白話:每一步做完的結果都會留下來,下次 build 時,如果這一步和它的材料都沒變,就直接拿上次的結果。
比喻:備料備好放冰箱,明天菜單沒變就直接拿出來用,不用重切一次。
規則:官方文件寫得很清楚,只要某一層變了,它後面的所有層都要重做,就算它們本身沒變也一樣。
步驟 11:順序寫錯會怎樣
很多人的直覺寫法是「先把全部檔案複製進去,再安裝套件」:
cat > Dockerfile.bad <<'EOF'
FROM python:3.14-slim
WORKDIR /app
COPY . .
RUN pip install --no-cache-dir -r requirements.txt
EXPOSE 8080
CMD ["python", "app.py"]
EOF
docker build -f Dockerfile.bad -t pyweb:bad .
[+] Building 6.8s (9/9) FINISHED docker:default
(前面省略)
=> CACHED [2/4] WORKDIR /app 0.0s
=> [3/4] COPY . . 0.0s
=> [4/4] RUN pip install --no-cache-dir -r requirements.txt 5.0s
(後面省略)

COPY . .:把資料夾裡所有檔案都複製進去(第一個點是你的資料夾,第二個點是映像檔裡的/app)-f Dockerfile.bad:指定用哪一個 Dockerfile,不寫就預設用叫Dockerfile的那個
現在一樣改一行程式,再 build 一次:
sed -i 's/(v2)/(v3)/' app.py
time docker build -f Dockerfile.bad -t pyweb:bad .
[+] Building 6.8s (9/9) FINISHED docker:default
(前面省略)
=> CACHED [2/4] WORKDIR /app 0.0s
=> [3/4] COPY . . 0.1s
=> [4/4] RUN pip install --no-cache-dir -r requirements.txt 5.0s
(後面省略)
real 0m6.961s
user 0m0.144s
sys 0m0.083s

pip install 又重跑了 5.0 秒,總共 6.961 秒。明明套件清單一個字都沒改!
原因就是快取規則:app.py 變了 → COPY . . 這層變了 → 它後面的 RUN pip install 也必須重做。
拿同樣的修改,用順序正確的 Dockerfile 再 build 一次做對照:
time docker build -t pyweb:v3 .
[+] Building 0.8s (10/10) FINISHED docker:default
(前面省略)
=> CACHED [2/5] WORKDIR /app 0.0s
=> CACHED [3/5] COPY requirements.txt . 0.0s
=> CACHED [4/5] RUN pip install --no-cache-dir -r requirements.txt 0.0s
=> [5/5] COPY app.py . 0.1s
(後面省略)
real 0m0.943s
user 0m0.114s
sys 0m0.066s


帶數字算一次:
- 順序對:0.943 秒;順序錯:6.961 秒,差了 7.4 倍
- 這次只有 1 個套件,pip 只要 5 秒。真實專案的套件清單常常有幾十個,安裝一次要好幾分鐘。假設一次要 3 分鐘、一天改 30 次程式,順序寫錯一天就多等 90 分鐘
- 套件越多、改程式越頻繁,這個數字越大
黃金法則:很少改的放前面,常常改的放後面。套件清單可能一個月才改一次,放前面;程式碼一天改幾十次,放最後。不管用什麼程式語言,Dockerfile 都照這個原則寫。
COPY . .還有另一個問題:它會把資料夾裡所有東西都複製進去,包括不該進映像檔的檔案(例如放密碼的設定檔)。解法是寫一個.dockerignore檔案列出要排除的東西,第 8 篇會示範。
步驟 12:忘了最後那個點
docker build -t pyweb:v4
ERROR: docker: 'docker buildx build' requires 1 argument
Usage: docker buildx build [OPTIONS] PATH | URL | -
Run 'docker buildx build --help' for more information

新手最常見的錯誤。錯誤訊息說「需要 1 個參數」,那個參數就是 PATH,也就是那個點(要用哪個資料夾當材料區)。補上 . 就好。
注意錯誤訊息寫的是 docker buildx build,不是 docker build。為什麼?後面「實測時的意外」說明。
步驟 13:跑最新版確認
docker run -d -p 8080:8080 --name pyapp3 pyweb:v3
curl -s localhost:8080
df79755a72aa8fd1d8ccf7e83450cac29076366c641eb4b54c7746160057b759
<h1>Hello from my first Docker image! (v3)</h1>
<p>Container ID (hostname): df79755a72aa</p>
<p>APP_ENV: not set</p>

標題變成 (v3) 了。改程式 → docker build → docker run,這就是用 Docker 開發的日常循環。
實測時的意外
1. docker stop 要等滿 10 秒
步驟 9 停 pyapp 和 pyapp2 花了 10.288 秒。第 2 篇停 nginx 幾乎是一瞬間,為什麼 Python 這麼慢?看一下狀態(這時候 pyapp3 是步驟 13 開的,還在跑):
docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
df79755a72aa pyweb:v3 "python app.py" 26 seconds ago Up 25 seconds 0.0.0.0:8080->8080/tcp pyapp3
a28ec0655ddf pyweb:v1 "python app.py" About a minute ago Exited (137) About a minute ago pyapp2
6a3cfad3f4f7 pyweb:v1 "python app.py" 2 minutes ago Exited (137) About a minute ago pyapp

結束代碼是 137,不是 0。137 = 128 + 9,9 是「強制結束」的訊號(SIGKILL)。意思是:程式根本沒有理會「請準備結束」的通知,Docker 等滿 10 秒後只好強制砍掉。
原因是一條 Linux 的特殊規則。Docker 官方文件說明:容器裡的主程式(編號 PID 1)會被特別對待,沒有特別寫程式處理的話,它會忽略 SIGTERM 這類結束訊號。nginx 有寫處理,所以停得很快;我們的 Python 小程式沒寫,所以只能被硬砍。
最簡單的解法是開容器時加 --init,讓 Docker 放一個小管家當 PID 1,由它把訊號轉給你的程式:
docker run -d --init --name pyinit pyweb:v3
sleep 2
time docker stop pyinit
50e78869fde55d14780ac9fe8fbb4b5a4319aa1bd78c20b16012b9e1a07e43a1
pyinit
real 0m0.187s
user 0m0.012s
sys 0m0.015s

0.187 秒,快了 55 倍。官方文件寫明,--init 用的小管家是一個叫 tini 的程式,負責轉發訊號和清理結束的子程序。
為什麼要在意?被硬砍的程式沒機會收尾,手上的請求會直接斷掉、資料可能沒寫完。正式環境常見的做法是在程式裡處理結束訊號,或用 --init;Kubernetes 和 Cloud Run 在關掉容器時也是先送 SIGTERM,所以這件事到了雲端一樣重要。
2. Flask 自己警告「不要用在正式環境」
docker logs 裡有一行:
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
意思是:app.run() 啟動的是 Flask 內建的開發用伺服器,方便寫程式時測試,但效能和穩定度不適合正式環境,正式環境要改用 Gunicorn 這類專門的伺服器程式。
這篇的目標是學會寫 Dockerfile,用開發用伺服器沒問題。要部署到 Cloud Run 時,會再換成正式的寫法。
3. docker build 其實是 docker buildx build
步驟 12 忘了點的時候,錯誤訊息寫的是 docker buildx build。這不是打錯:Docker 官方文件說明,BuildKit 現在是 Docker Engine 預設的建置工具,docker build 實際上是交給 buildx(BuildKit 的指令介面)去做。
這也是為什麼這次的 build 輸出長這樣([+] Building 11.2s、=> [1/5]、每步都有秒數)。網路上的舊教學常常是 Step 1/7 : FROM … 那種格式,那是舊版建置工具(legacy builder)的輸出,指令一樣,只是畫面不同。
4. Python 映像檔直接用了 nginx 留下的 Debian 層
這是第 3 篇觀念的現場印證:build 的時候 Debian 底層(f2be6722…)沒有重新下載,只下載了 Python 自己的 3 個檔案,加起來不到 14MB。官方映像檔大多用同一套 Debian 當底層,本機上的映像檔越多,下載新映像檔時能共用的就越多。
用完記得刪
docker rm -f pyapp pyapp2 pyapp3 pyinit
docker rmi pyweb:v1 pyweb:v2 pyweb:v3 pyweb:bad
ls ~/pyweb
pyapp
pyapp2
pyapp3
pyinit
Untagged: pyweb:v1
Deleted: sha256:a422fa0366b8e472408d7175cbd5da315fa30f5df2b9b522a85d7646bd16a1ea
Untagged: pyweb:v2
Deleted: sha256:1db3c069e88724a4a5e740b730901b713707262f8701670897ba86ea79c384d5
Untagged: pyweb:v3
Deleted: sha256:2b115daa83ebda0e818740108a0dbbe4d7782a3d7e709fed5c35dcdc25eb4f34
Untagged: pyweb:bad
Deleted: sha256:4f39e54f9211886bdfe6b53d6ed10a7c4ff59ae8836f1a8e593721b56bf0a522
app.py Dockerfile Dockerfile.bad requirements.txt

容器和映像檔都刪了,但 ~/pyweb 資料夾裡的檔案還在。之後要用,進資料夾 docker build -t pyweb:v1 . 就能重新做出一模一樣的映像檔,這正是寫 Dockerfile 的意義:映像檔可以隨時刪、隨時重做,食譜留著就好。
這篇都在 Cloud Shell 裡,不會產生任何費用。
到了 GCP 上叫什麼
| 這篇做的事 | 到了 Google Cloud |
|---|---|
在 Cloud Shell 用 docker build 打包 | 交給 Cloud Build 在雲端打包,不用自己的機器,第 21 篇教 |
| 映像檔存在本機 | 推到 Artifact Registry 存起來,第 19 篇教 |
docker run -p 8080:8080 | 交給 Cloud Run 跑。Cloud Run 會用 PORT 環境變數告訴容器要聽哪個 Port,預設 8080,這就是程式裡寫 os.environ.get("PORT", 8080) 的原因 |
用 -e 傳環境變數 | Cloud Run 部署時也可以設定環境變數,密碼類的改用 Secret Manager |
最省事的是 Cloud Run 的「從原始碼部署」:官方文件寫明,資料夾裡有 Dockerfile,就照著你的 Dockerfile 打包;沒有的話,才由 Google 自動判斷語言幫你打包。所以這篇寫的 Dockerfile,第 20 篇可以直接拿去部署。
面試/證照會怎麼問
面試常見題
| 題目 | 回答重點 |
|---|---|
| RUN 和 CMD 差在哪? | RUN 在 build 時執行,結果存進映像檔;CMD 在容器啟動時執行,是容器的主程式 |
| CMD 和 ENTRYPOINT 差在哪? | CMD 是預設指令,docker run 後面加指令就會蓋掉它;ENTRYPOINT 讓容器像一個固定的執行檔,後面加的東西會變成它的參數。兩個可以搭配用 |
| COPY 和 ADD 差在哪? | 功能相近;ADD 多了從網址下載、自動解壓縮 tar 檔。一般複製檔案用 COPY |
| EXPOSE 會開放 Port 嗎? | 不會,只是說明文件性質;真的要對外要靠 docker run -p |
| 怎麼讓 docker build 變快? | 利用建置快取:很少變的步驟放前面(裝套件),常變的放後面(複製程式碼);用 .dockerignore 排除不需要的檔案 |
為什麼 CMD 建議寫成 ["python", "app.py"] 這種中括號格式? | 中括號是 exec 格式,程式直接當主程序,才收得到 docker stop 的結束訊號;不加中括號的 shell 格式會多包一層 shell,訊號可能傳不到程式 |
| 容器裡的網站為什麼要綁 0.0.0.0? | 綁 127.0.0.1 只接受容器自己連自己,從外面連不進來 |
看到這些字,就想到這個
| 題目出現的字 | 想到 |
|---|---|
| 「建置時執行」「安裝套件」 | RUN |
| 「容器啟動時執行」「預設指令」 | CMD |
| 「build 很慢」「每次都重裝套件」 | 指令順序與建置快取,先 COPY 套件清單 |
| 「不要把某些檔案打包進去」 | .dockerignore |
| 「同一個映像檔、不同環境」 | 環境變數(-e) |
| 「docker stop 很慢」「Exited (137)」 | PID 1 沒處理 SIGTERM,用 exec 格式、處理訊號或 --init |
Google Cloud 證照(ACE、PCA)不會考 Dockerfile 怎麼寫,但會考「原始碼怎麼變成 Cloud Run 上的服務」:看到「從原始碼部署、不想自己管建置」就想到 Cloud Build 和 gcloud run deploy --source。
常見問答
Dockerfile 要放在哪裡?檔名有規定嗎?
通常放在專案資料夾的最上層,檔名就叫 Dockerfile,D 大寫、沒有副檔名。docker build 預設會在你指定的資料夾(最後那個點)裡找這個檔名。要用別的檔名,加上 -f 檔名 指定,例如 docker build -f Dockerfile.bad。
docker build 最後那個點是什麼意思?
點代表「目前所在的資料夾」,Docker 會把這個資料夾裡的檔案打包送去建置,Dockerfile 裡的 COPY 只拿得到這個資料夾裡的東西。忘了寫點,會出現 docker buildx build requires 1 argument 的錯誤。
RUN 和 CMD 差在哪?
RUN 在 docker build 打包映像檔時執行一次,例如安裝套件,結果會存進映像檔。CMD 是容器啟動時才執行的指令,每次 docker run 都會跑一次,通常是啟動你的程式。
為什麼改了程式碼,docker build 還是很慢?
通常是 Dockerfile 的順序問題。如果先 COPY . . 把全部檔案複製進去再安裝套件,只要程式碼一改,複製那層就變了,後面的安裝套件也要跟著重做。改成先複製套件清單、安裝套件,最後才複製程式碼,實測同樣改一行程式從 6.96 秒降到 0.94 秒。
EXPOSE 不寫可以嗎?
可以。EXPOSE 只是說明這個映像檔的程式會用哪個 Port,不會真的開放。真正讓外面連得進來的是 docker run 的 -p。寫上 EXPOSE 是好習慣,讓別人一看就知道要對應哪個 Port。
為什麼我的容器 docker stop 要等 10 秒?
容器的主程式(PID 1)預設會忽略 SIGTERM 結束訊號,除非程式有寫處理。Docker 等不到它結束,10 秒後只好強制砍掉,結束代碼會是 137。解法是在程式裡處理 SIGTERM,或開容器時加上 –init,實測從 10.288 秒降到 0.187 秒。
Python 的映像檔要選 slim 還是 alpine?
Python 專案多半選 slim。alpine 更小,但它用的底層函式庫跟一般 Linux 不同,有些需要編譯的 Python 套件會裝不起來或要裝很久。slim 是精簡過的 Debian,相容性好、大小也還可以,這篇實測 pyweb 做出來是 203MB。
重點整理
- Dockerfile 是做映像檔的食譜:
FROM選底層、WORKDIR設資料夾、COPY放檔案、RUN建置時執行、EXPOSE註明 Port、CMD啟動時執行 docker build -t 名稱:Tag .,最後的點是材料區,不能忘- 順序決定速度:很少改的放前面、常改的放後面,實測同樣改一行程式 0.94 秒 vs 6.96 秒
- 同一個映像檔用
-e傳不同環境變數,就能用在不同環境;容器裡的服務要綁0.0.0.0 - PID 1 預設不理 SIGTERM,沒處理的話
docker stop要等 10 秒(Exited 137),加--init實測只要 0.19 秒
延伸閱讀
本系列
- 第 1 篇:Docker 入門教學:不用安裝,用 Cloud Shell 跑出第一個容器
- 第 2 篇:Docker 常用指令一次看懂:run、ps、logs、exec、stop、rm
- 上一篇:第 3 篇:Docker 映像檔和容器差在哪?Image、Layer、Tag 白話解釋
- 下一篇:第 5 篇:Docker 資料會消失?Volume 和 Bind Mount 怎麼選
站上相關文章
- 容器 (Container) 技術是什麼?從零開始看懂 Docker 與容器化應用
- Cloud Run 簡介與手把手教學
- Vertex AI 自訂訓練:容器、分散式訓練、GPU 與 TPU
- 轉職 IT 新手必學知識完整指南:從零基礎到雲端技術入門
會寫 Dockerfile,你的程式就能帶著自己的環境走到任何地方。如果你想有系統地從容器一路學到在 Google Cloud 上部署服務,可以看看東東的 GCP 課程,或加 LINE 聊聊你現在的狀況,一起找出最適合你的學習順序。