Docker 是什麼:在 PC 與 AWS 上怎麼用

耀達 Lite 雲端進銷存.說明文件.2026-11-17 整理(網路資料也是這一天查的)

一句話:Docker 把程式和它需要的執行環境包成一包(映像檔),這一包放到哪台機器都跑得起來,機器上只要裝 Docker,不用再裝 .NET 執行環境。

這頁分三部分:Docker 本身、在 PC 上怎麼佈置(場景 ①)、在 AWS 上怎麼佈置(場景 ②、③)。

還沒定的:「程式要用什麼形式交到三個場景」還在談。Claude 推薦「容器為準」,Jesse 還沒選;這頁是讓 Jesse 先把 Docker 弄懂,再回來決定。 雲端放哪一家也還沒談,這頁拿 AWS 當例子,只是因為 Jesse 問的是 AWS、而且有 EC2 的經驗。

前兩頁:模組化單體是什麼(整體形狀:一支後端程式+一個資料庫+前端,三個場景各長怎樣)、多家公司的資料怎麼隔開。

全頁的指令與設定檔都是照官方文件寫的,出處列在第 26 節。這些指令沒有在這台機器上實際跑過(這次的規矩是不在這台機器上安裝 Docker、不建立 AWS 資源)。 映像檔名稱 liteerp、資料庫名稱、帳號、連接埠號碼等都是示意,名字還沒定。 標了 推論 一般經驗 沒查到來源 的句子,是沒有官方文件可以直接佐證的。
第一部分:Docker 本身

1. 從熟的做法說起:EC2 上放執行檔

Jesse 現在在 EC2 上架一個 .NET 的伺服器,大概是這幾步:

  1. 開一台 EC2。
  2. 在機器上裝對的那一版 .NET 執行環境(程式是 .NET 8 寫的,就要裝 8,不能只有 6)。
  3. 把編譯好的執行檔與網頁檔放上去。
  4. 設環境變數(資料庫連線字串這類)。
  5. 設成服務,開機自動跑、掛掉自動重開。
  6. 要第二台機器(或機器壞了換一台):上面 2~5 步再做一次。

會出問題的地方,都在「每台機器自己裝、自己設」:

以前 一台 EC2 環境變數、服務設定(自己設) 執行檔+網頁檔(自己放) .NET 執行環境(自己裝) 作業系統 橘色三層:每台機器做一次
圖 1a 以前:每台機器自己裝、自己設
容器 一台 EC2 設定:啟動容器時才給 容器(照映像檔跑起來) 執行檔+網頁檔 .NET 執行環境 Docker(機器上唯一要裝的) 作業系統 綠色那包:包一次,每台都一樣
圖 1b 容器:程式和執行環境包成一包
要做的事以前(EC2 上放執行檔)容器
.NET 執行環境每台機器自己裝,版本要對包在映像檔裡,機器上不用裝
程式檔複製到機器上的某個資料夾包在映像檔裡
環境變數在機器上設啟動容器時給(第 6 節)
設成服務、掛掉重開在機器上設定服務啟動容器時加一個重開的選項(第 9 節)
機器上要裝什麼.NET 執行環境+程式需要的其他東西只有 Docker
換一台機器上面全部重做裝 Docker,拿同一包來跑
換版本停服務、覆蓋檔案、再開拿新的一包、停舊的、起新的(第 3 節)

Docker 官方文件的說法:「Containers are lightweight and contain everything needed to run the application, so you don't need to rely on what's installed on the host.」(容器很輕,裡面有程式執行需要的一切,所以不必依賴主機上裝了什麼。)

2. 映像檔與容器

先看例子

想成 Windows 的安裝檔:setup.exe 是一個檔案,放著不會動;你拿它裝了一份程式、跑起來,那才是「正在跑的東西」。同一個安裝檔可以在三台電腦各裝一份。

映像檔 liteerp:1.4 唯讀,不會被改 照它 跑起來 容器 1(正在跑) 容器 2(正在跑) 容器 3(正在跑)
圖 2 一個映像檔,跑成三個容器。場景 ③「程式開很多份」就是這樣開出來的。

再給名詞(Docker 官方文件)

跟虛擬機有什麼不同

Docker 官方文件的說法:

虛擬機 程式 A 自己的作業系統 (含核心) 程式 B 自己的作業系統 (含核心) 虛擬機軟體 主機的作業系統與硬體 每台虛擬機各帶一整套作業系統
圖 3a 虛擬機
容器 程式 A +它需要的檔案 程式 B +它需要的檔案 Docker 主機的作業系統(核心共用)與硬體 容器之間共用同一個核心
圖 3b 容器

對我們的意思:容器比虛擬機輕,一台機器可以跑好幾個;但它不是一台獨立的機器,沒有自己的核心。這句是推論

3. 映像檔倉庫與版本標籤

映像檔包好之後,要放在一個各台機器都拿得到的地方,機器才能去拿。這個地方叫映像檔倉庫(registry)。Docker 官方:「An image registry is a centralized location for storing and sharing your container images.」(映像檔倉庫是集中存放、分享容器映像檔的地方。)AWS 上的映像檔倉庫叫 ECR(第 16 節)。

每一版用標籤(tag)分開:liteerp:1.3、liteerp:1.4。冒號前面是映像檔的名字,後面是標籤。Docker 官方:「Docker tags allow you to label and version your images.」(標籤讓你替映像檔標記版本。)

完整的名字還會帶倉庫的位址。.NET 文件寫的格式:

REGISTRY[:PORT]/REPOSITORY[:TAG]
倉庫位址        /映像檔名字 :標籤

例:123456789012.dkr.ecr.us-east-1.amazonaws.com/liteerp:1.4   (帳號與機房是示意)

換版本的流程(例子:線上 1.3 換成 1.4)

① 包:dotnet publish 在開發的電腦上,包出 liteerp:1.4 ② 推 映像檔倉庫 1.2 1.3 1.4 ③ 拿 跑程式的機器 1.3:停掉 1.4:起來 ④ 退版:叫機器改跑 1.3(1.3 還在倉庫裡) 退版和上版是同一個動作,只是換一個標籤
圖 4 每一版都是獨立的一包。1.4 推上去之後,1.3 不會被蓋掉。
  1. 包出新的映像檔,標版本號 1.4。1.3 的映像檔還在,每一版都是獨立的一包。
  2. 推到映像檔倉庫(各台機器都拿得到的地方)。
  3. 叫機器換成新版。
    • 場景 ① 本機 PC:下一個指令(拿新版、停舊的、起新的),中斷幾秒(第 13 節)。
    • 雲端只開 1 份:自己在一台機器上換(路線 A,第 17 節)會中斷幾秒,這幾秒的請求會失敗,再按一次就好。交給 ECS 換(路線 B,第 18 節)照預設不中斷,它會先起新的、確認正常,才停舊的。
    • 開很多份:用滾動更新(rolling update),一次只換幾份,先起新的、確認正常、再停舊的,不中斷。
  4. 退版:叫機器改跑 1.3,映像檔還在倉庫裡。退版和上版是同一個動作。

換版時要小心的三件事

4. 容器用完就丟,資料放外面

容器的檔案系統是跟著容器走的:容器刪掉,它裡面寫的檔案也跟著不見。我們程式的容器沒關係,每出一版就整個換掉,本來就不該在裡面存東西。

但 PostgreSQL 不一樣,它的資料檔一定要留著。做法是:資料檔不放在容器裡,放在主機硬碟上的一塊地方,掛給容器用。容器刪掉重建,那一塊還在,新的容器掛上去,資料都在。

這塊地方 Docker 叫 volume(可以想成「Docker 幫你管的一個資料夾,掛給容器用」)。Docker 官方:

PostgreSQL 容器 舊的:刪掉 PostgreSQL 容器 新的:重新建立 都掛在 同一個地方 volume:pgdata 資料檔在這裡,不在容器裡 主機硬碟上 Docker 管的一塊地方
圖 5 容器可以丟,volume 留著。名字 pgdata 是示意。

另一種做法叫 bind mount:直接把主機上一個你指定的資料夾掛給容器。差別是 volume 由 Docker 管(你不用管它在硬碟哪裡),bind mount 是你自己指定路徑。Docker 官方說,主機上的程式也要直接存取那些檔案時,用 bind mount;只給容器用,volume 比較省事。這頁的範例都用 volume。

PostgreSQL 的資料要掛在哪個路徑,跟版本有關(PostgreSQL 官方映像檔的說明頁): 這頁的範例一律寫 postgres:18,並掛在 /var/lib/postgresql。PostgreSQL 用哪一個主版本還沒定,定了要照那一版的路徑。

5. 容器之間、容器與外面怎麼連

外面連進容器:連接埠對應

容器有自己的網路。程式在容器裡聽 8080,主機的瀏覽器直接打 localhost:8080 是連不到的,要先把主機的某個連接埠接到容器的某個連接埠,這叫連接埠對應(publish a port)。

-p 8080:8080
   主機:容器      主機的 8080 → 容器裡的 8080

左邊是主機的連接埠,右邊是容器的。兩邊可以不一樣,例如 -p 80:8080 是「主機的 80 → 容器裡的 8080」。

為什麼範例裡容器那一邊都是 8080:.NET 8 起,微軟的 ASP.NET Core 映像檔預設聽 8080。原文「The default ASP.NET Core port configured in .NET container images has been updated from port 80 to 8080.」(.NET 容器映像檔裡設定的 ASP.NET Core 預設連接埠,從 80 改成 8080。)

容器連容器:用名字找

程式的容器要連 PostgreSQL 的容器。用 Compose(第 7 節)叫起來的一組容器,會在同一個網路上,彼此用服務名稱就找得到。Docker 官方:「Each container for a service joins the default network and is both reachable by other containers on that network, and discoverable by its service name.」(每個服務的容器都會加入預設網路,同網路的其他容器連得到它,也能用它的服務名稱找到它。)

所以 PostgreSQL 的服務叫 db,程式的連線字串寫主機名稱 db、連接埠 5432 就好,不用知道它的 IP。

容器之間用的是容器那一邊的連接埠。Docker 官方:「Networked service-to-service communication uses the CONTAINER_PORT. The host port is only used when accessing the service from outside the network.」(服務之間走網路連線,用的是容器的連接埠;主機的連接埠只在從網路外面連進來時才用。)所以 PostgreSQL 根本不必對應到主機的連接埠,只讓程式的容器連得到就好。

不用 Compose、自己一個一個 docker run 的時候(路線 A,第 17 節),要先自己建一個網路,把兩個容器都接上去,才能用名字互找。Docker 官方說預設的網路「They cannot refer to each other by name.」(容器之間不能用名字互找。)

6. 設定怎麼給

同一個映像檔要跑在三個場景,差別只在設定(資料庫在哪、密碼是什麼)。所以設定不寫死在映像檔裡,啟動容器時才用環境變數給:

場景同一個映像檔不同的設定(示意)
① 本機 PCliteerp:1.4資料庫在 db(同一台的 PostgreSQL 容器)
② 雲端幾十人liteerp:1.4資料庫在同一台的 PostgreSQL 容器,或 RDS 的位址
③ 雲端幾萬人liteerp:1.4資料庫在 RDS 的位址

.NET 怎麼從環境變數讀到連線字串:ASP.NET Core 的設定可以從環境變數來,階層用兩個底線 __ 隔開。微軟文件:「A double underscore (__) is supported by all platforms and is automatically converted into a colon (:) when the configuration is read by the app.」(兩個底線在所有平台都能用,程式讀設定時會自動換成冒號。)所以環境變數 ConnectionStrings__Default 就等於 appsettings.json 裡的 ConnectionStrings:Default(Default 這個名字是示意)。

機密不要寫進映像檔,也不要進版控

7. 一份清單叫起一組容器:Compose

場景 ① 要兩個容器:程式、PostgreSQL。每次都打兩串很長的指令,還要記得先建網路、掛 volume、給環境變數,很容易漏。Compose 就是把這些寫成一份清單(一個 YAML 檔),一個指令全部叫起來。

Docker 官方:「Docker Compose is a tool for defining and running multi-container applications.」(Compose 是定義與執行多容器應用程式的工具。)以及「Compose simplifies the control of your entire application stack, making it easy to manage services, networks, and volumes in a single YAML configuration file.」(Compose 讓你在一個 YAML 設定檔裡管理服務、網路與 volume。)

完整的範例在第 12 節。Compose 主要用在一台機器上(場景 ①);雲端開很多份,是交給 ECS 這類服務去排(第 18 節)。後半句是推論

8. 我們的程式怎麼變成映像檔

.NET SDK 本身就會包映像檔,不用寫 Dockerfile,也不用另外裝套件(.NET SDK 8.0.200 起內建)。微軟文件:「The .NET SDK creates container images without Docker. Docker or Podman are only needed if you want to run the image locally.」(.NET SDK 不靠 Docker 就能包出容器映像檔;只有要在本機跑這個映像檔時,才需要 Docker 或 Podman。)

指令(照微軟文件;名字與版本號是示意):

dotnet publish -c Release --os linux --arch x64 /t:PublishContainer -p ContainerRepository=liteerp -p ContainerImageTag=1.4
這一段在做什麼
-c Release用 Release 設定編譯。
--os linux做成 Linux 的映像檔(雲端與 Docker Desktop 跑的都是 Linux 容器)。
--arch x64做成 x64 處理器用的。要跑在 ARM 的機器(例如第 21 節的 t4g)就改成 arm64,見下面的說明。
/t:PublishContainer告訴 SDK:這次發佈的成品是容器映像檔。
-p ContainerRepository=liteerp映像檔的名字。沒給的話,預設是專案的組件名稱(AssemblyName)。
-p ContainerImageTag=1.4標籤。一定要給:微軟文件寫「Starting with .NET 8, when a tag isn't provided the default is latest.」(.NET 8 起,沒給標籤時預設是 latest。)全部都叫 latest,就分不出 1.3 和 1.4。

名字與標籤也可以寫在 .csproj 裡,指令就不用每次打(照微軟文件的寫法):

<PropertyGroup>
  <ContainerRepository>liteerp</ContainerRepository>
  <ContainerImageTag>1.4</ContainerImageTag>
</PropertyGroup>

包出來的映像檔放哪裡

處理器架構:x64 與 ARM

映像檔是照某一種處理器包的。x64 包的不能跑在 ARM 的機器上,反過來也一樣。Jesse 的 PC 是 x64;第 21 節費用表裡的 EC2 t4g.small 是 ARM,Fargate 那幾列是照 x86 算的。

所以前面說的「三個場景同一個映像檔」,精確地說是「同一個名字與標籤」;如果機器的處理器不一樣,要包成多架構,或分開包。.NET 跑在 ARM 上我們沒有實際試過。

映像檔裡有什麼、沒有什麼

有沒有
  • 後端程式(C#,編譯好的)
  • 前端網頁檔(TypeScript 編譯出來的檔案,由後端送出去)
  • .NET 執行環境(微軟的基底映像檔帶進來的;ASP.NET Core 專案預設用 mcr.microsoft.com/dotnet/aspnet)
  • 一個精簡的 Linux 檔案系統
  • 資料庫(PostgreSQL 是另一個容器,或雲端代管)
  • 設定(連線字串等,啟動時給)
  • 機密(密碼)
  • 使用者的資料

另外,微軟的 .NET 8 以上映像檔預設用一個不是 root 的使用者(叫 app)跑程式,這是微軟文件寫的預設。

Dockerfile 是什麼(看別人教學時認得就好)

傳統做法是寫一個叫 Dockerfile 的檔案,一行一行寫「從哪個基底映像檔開始、複製哪些檔案、跑什麼指令、啟動時執行什麼」,再用 docker build 包出映像檔。網路上大部分的教學都是這樣寫。AWS 的 ECS 入門教學也是用 Dockerfile 做一個網頁伺服器的例子。

.NET SDK 的做法省掉這個檔。微軟文件說唯一做不到的是 Dockerfile 裡的 RUN(在包的過程中執行指令,例如安裝作業系統套件);真的需要時,可以改用 Dockerfile,或自己做一個基底映像檔。

9. 常用指令小抄

指令照 Docker 官方的指令參考。<名字> 換成容器或映像檔的名字。

指令白話
docker ps現在有哪些容器在跑。加 -a 連停掉的也列出來。
docker logs <容器>看這個容器的紀錄(程式印到主控台的東西)。加 -f 一直跟著看新的,--tail 100 只看最後 100 行。
docker exec -it <容器> sh進到正在跑的容器裡,開一個命令列,像 SSH 連進一台機器。打 exit 離開。
docker stop <容器>停掉容器(容器還在,可以再啟動)。
docker rm <容器>刪掉容器(要先停,或加 -f 強制刪正在跑的)。有名字的 volume 不會跟著刪,資料還在。
docker images這台機器上有哪些映像檔、各是什麼標籤。
docker pull <映像檔:標籤>從倉庫拿一個映像檔下來。
docker rmi <映像檔:標籤>刪掉這台機器上的一個映像檔(倉庫裡的不受影響)。
docker volume ls有哪些 volume。
docker run -d --name <容器> -p 主機:容器 -e 變數=值 --restart unless-stopped <映像檔:標籤>照映像檔起一個容器:-d 在背景跑、--name 取名字、-p 連接埠對應、-e 環境變數、--restart unless-stopped 掛掉自動重開(除非是你自己停的)。這一項就是「設成服務」的替代。

用 Compose 的時候,在 compose.yaml 那個資料夾下 docker compose 開頭的指令,對象是服務名稱(app、db),不是容器名稱:

指令白話
docker compose up -d照清單把全部叫起來(在背景跑)。已經在跑的,設定或映像檔有變才會重建。
docker compose ps這一組容器的狀態與連接埠。
docker compose logs -f app跟著看 app 的紀錄。
docker compose exec db sh進到 db 的容器裡(Compose 預設就是互動模式,不用加 -it)。
docker compose stop全部停掉,容器留著。
docker compose down停掉並刪掉容器與網路;volume 預設不刪,資料還在。
docker compose pull把清單裡的映像檔從倉庫拿下來,但不啟動。
第二部分:在 PC 上佈置(場景 ①)

10. 要裝什麼

Docker Desktop

在 Windows 上跑 Docker,官方的做法是裝 Docker Desktop。它會在 Windows 裡帶一個 Linux 環境(預設用 WSL 2),Linux 容器跑在那裡面。安裝步驟照官方頁:下載安裝檔、執行、在設定頁選要不要用 WSL 2(預設是 WSL 2),裝完要自己打開 Docker Desktop(它不會自己啟動)、同意訂閱條款。

Jesse 的 Windows 10 Pro(版本 10.0.19045)符不符合

官方需求(WSL 2 與 Hyper-V 兩種後端都寫同一行):

build 19045 就是 Windows 10 的 22H2,版本與版別(Pro)都對得上需求那一行。

但同一頁還有一句:

微軟的生命週期頁寫:「Windows 10 will reach end of support on October 14, 2025.」Windows 10 Home 與 Pro 的 22H2 結束日期是 2025-10-14(美國太平洋時間;表上寫 2025-10-15 06:59:59),今天(2026-11-17)已經過了。

判斷:需求清單上照字面符合;但照「只支援還在服務期限內的版本」那一句,Windows 10 Pro 22H2 已經不在微軟的服務期限內,Docker 官方可能不再支援這台。兩句放在一起怎麼解讀,官方頁沒有說清楚(例如有買微軟延伸安全性更新的機器算不算)。實際上裝不裝得起來、跑不跑得順,要裝了才知道,這次沒有裝。

其他需求(WSL 2 後端),官方頁列的:WSL 2.1.5 以上;Windows 的 Server 服務(LanmanServer)要啟用、啟動類型設為自動;打開 Windows 的 WSL 2 功能;64 位元處理器且支援 SLAT;8 GB 記憶體;BIOS/UEFI 打開硬體虛擬化。

順手在這台機器上唯讀查了幾項(沒有改任何設定):Windows 10 專業版 10.0.19045;記憶體約 32 GB;LanmanServer 正在執行、啟動類型自動;Windows 回報「已有 hypervisor 在執行」。處理器的虛擬化與 SLAT 兩項讀到的是 False,但 hypervisor 已經在跑的機器,Windows 常常把這兩項回報成 False,不代表真的沒有。後半句是一般經驗 WSL 的版本沒有查。這台是不是就是 Jesse 說的那台 PC,Claude 是照版本號推測的。

授權

Docker Desktop 對小公司免費的條件是「fewer than 250 employees AND less than $10 million in annual revenue」(員工少於 250 人,而且年營收少於 1,000 萬美元);個人使用、教育、非商業的開源專案也免費。超過就要付費訂閱。

另一個選擇:Podman

微軟的 .NET 文件把 Podman 列為另一個可以在本機跑映像檔的工具:「An open-source daemonless alternative to Docker.」(開源、不需要常駐背景服務的 Docker 替代品。).NET SDK 包映像檔也支援把成品放進 Podman。這頁的指令都照 Docker 寫,Podman 的指令這次沒查。

開發時不用每改一行就包容器

平常寫程式照舊:在開發工具或命令列直接跑、直接除錯,不經過容器。只有「交出去測」的那一版才包成映像檔、標版本號,放到測試那台 PC 上跑。

11. 整體長怎樣

Jesse(這台 PC) localhost:8080 辦公室同事 PC 的 IP:8080 PC 的連接埠 8080 這台 PC(Windows+Docker Desktop) 程式容器(服務名稱 app) liteerp:1.4.後端+前端網頁檔.聽 8080 db:5432 PostgreSQL 容器(服務名稱 db) postgres:18.聽 5432.不對 PC 外開放 volume:pgdata PostgreSQL 的資料檔在這裡
圖 6 場景 ①。我們自己包的只有上面那個程式容器;PostgreSQL 用官方現成的映像檔。名字都是示意。

為什麼程式和資料庫不放在同一個容器

12. Compose 檔範例,逐行解釋

同一個資料夾放兩個檔:compose.yaml(清單)與 .env(版本號與密碼)。兩個檔都是示意,名字還沒定。PostgreSQL 那一段的環境變數、資料路徑、健康檢查,照 PostgreSQL 官方映像檔的說明頁與 Docker 官方的啟動順序範例寫。

compose.yaml

services:
  app:
    image: liteerp:${LITEERP_TAG:?請在.env設定LITEERP_TAG}
    ports:
      - "8080:8080"
    environment:
      ConnectionStrings__Default: "Host=db;Port=5432;Database=liteerp;Username=liteerp;Password=${DB_PASSWORD}"
    depends_on:
      db:
        condition: service_healthy
        restart: true
    restart: unless-stopped

  db:
    image: postgres:18
    environment:
      POSTGRES_USER: liteerp
      POSTGRES_PASSWORD: ${DB_PASSWORD:?請在.env設定DB_PASSWORD}
      POSTGRES_DB: liteerp
    volumes:
      - pgdata:/var/lib/postgresql
    shm_size: 128mb
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
      interval: 10s
      retries: 5
      start_period: 30s
      timeout: 10s
    restart: unless-stopped

volumes:
  pgdata:

.env(不要 commit 進版控)

LITEERP_TAG=1.4
DB_PASSWORD=換成一組夠長的密碼

逐行解釋

這一行在做什麼
services:底下列出要跑的服務,每個服務會變成一個容器。
app:第一個服務,名字叫 app:我們的程式。
image: liteerp:${LITEERP_TAG:?…}用哪個映像檔。標籤從 .env 的 LITEERP_TAG 拿;:? 的意思是「沒設就直接報錯、不要啟動」(官方:「value of VAR if set and non-empty, otherwise exit with error」)。這樣換版本只要改 .env 一個數字。映像檔是從倉庫拿的話,這裡要寫完整名字(帶倉庫位址)。
ports: - "8080:8080"PC 的 8080 → 容器的 8080(第 5 節)。官方建議這種寫法加引號,當成字串。
environment:給這個容器的環境變數。
ConnectionStrings__Default: "…"資料庫連線字串,程式讀到的是 ConnectionStrings:Default(第 6 節)。主機寫 db(另一個服務的名字)、連接埠寫容器那邊的 5432。密碼從 .env 帶進來。字串的寫法依之後選的資料庫驅動程式而定,這裡是示意。
depends_on: db: condition: service_healthy等 db 的健康檢查通過了,才啟動 app。官方說「On startup, Compose does not wait until a container is "ready", only until it's running.」(Compose 啟動時只等容器跑起來,不等它準備好。)PostgreSQL 第一次啟動要先建資料庫,這段時間不收連線,不等的話程式一啟動就連不上。
restart: true(在 depends_on 底下)db 被 Compose 重啟或更新時,app 也跟著重啟,重新連線。照官方範例。
restart: unless-stopped容器掛掉自動重開,除非是你自己停的。等於以前「設成服務、掛掉自動重開」。
db:第二個服務,名字叫 db:PostgreSQL。程式就是用這個名字連它。
image: postgres:18PostgreSQL 官方映像檔,主版本 18。不要只寫 postgres(等於 latest),哪天主版本變了,資料路徑跟著變(第 4 節),資料檔也不一定能直接用。後半句是推論
POSTGRES_USER建立一個有超級使用者權限的帳號(沒給的話預設是 postgres),並建一個同名的資料庫。
POSTGRES_PASSWORD那個帳號的密碼。官方說這個變數一定要給、不能是空的。
POSTGRES_DB預設資料庫的名字(沒給的話跟帳號同名)。
volumes: - pgdata:/var/lib/postgresql把 volume pgdata 掛到容器裡的 /var/lib/postgresql,資料檔就寫在 volume 裡。18 以上掛這裡;17 以下要掛 /var/lib/postgresql/data。
shm_size: 128mb給容器的共用記憶體大小。官方說容器預設只有 64MB,用完會出錯;這一行照官方的 Compose 範例。
healthcheck:怎麼判斷 PostgreSQL 準備好了:每 10 秒跑一次 pg_isready(PostgreSQL 自帶的檢查工具),最多重試 5 次;啟動後前 30 秒的失敗不算;每次最多等 10 秒。照官方範例原樣。$$ 是兩個錢字號,讓 Compose 不要自己代換,留給容器裡的命令列去展開。這一句是推論
volumes: pgdata:(最下面)宣告有一個叫 pgdata 的 volume,第一次啟動時 Docker 會自己建。
容易踩的地方:POSTGRES_USER、POSTGRES_PASSWORD、POSTGRES_DB 只在第一次、資料目錄還是空的時候有用。官方原文:「the Docker specific variables will only have an effect if you start the container with a data directory that is empty; any pre-existing database will be left untouched on container startup.」所以資料建好之後,再改 .env 的 DB_PASSWORD,資料庫的密碼不會跟著變,程式反而會連不上。要改密碼得進資料庫裡改。

PostgreSQL 沒有對應到 PC 的連接埠,所以 PC 上的資料庫工具連不到它。要連的話,在 db 底下加 ports: - "127.0.0.1:5432:5432",只開給這台 PC 自己(官方的 ports 寫法支援在前面加 IP)。

13. 日常操作

以下指令都在放 compose.yaml 的那個資料夾下(Compose 會在這個資料夾找 compose.yaml 和 .env)。

第一次啟動

docker compose up -d      # 照清單把 app 和 db 叫起來,在背景跑
docker compose ps         # 看兩個服務的狀態,db 會先變成 healthy,app 才起來

瀏覽器打 http://localhost:8080。第一次啟動時 PostgreSQL 要先建資料庫,會比較久。

看紀錄

docker compose logs -f app          # 跟著看程式的紀錄,Ctrl+C 離開(容器不會停)
docker compose logs --tail 100 db   # 只看資料庫最後 100 行

停掉

docker compose stop       # 停掉,容器留著,下次 up -d 很快
docker compose down       # 停掉並刪掉容器與網路;volume 預設不刪,資料還在

換新版(1.3 → 1.4)

  1. 拿到新的映像檔。在這台 PC 上 dotnet publish 包的,已經在本機了;從倉庫來的,改完下一步後先跑 docker compose pull app;收到壓縮檔的,用 docker load -i liteerp.tar.gz。
  2. 把 .env 的 LITEERP_TAG=1.3 改成 1.4。
  3. docker compose up -d
    Compose 發現 app 的映像檔變了,就停掉舊的、用新的重建;db 沒變,不動。官方:「docker compose up picks up the changes by stopping and recreating the containers (preserving mounted volumes).」(會停掉並重建容器,掛著的 volume 保留。)中間程式中斷幾秒。

資料表的升級要在新程式開始服務之前跑完(第 3 節),用什麼工具、怎麼接在這個流程裡,還沒談。

退版(1.4 → 1.3)

把 .env 改回 LITEERP_TAG=1.3,再 docker compose up -d。跟上版是同一個動作。要注意的是資料表:1.4 已經把資料表升級了的話,1.3 的程式要能看得懂新的資料表(第 3 節「這一版只加東西」那一條)。

把資料清掉重來

docker compose down -v    # -v:連清單裡宣告的 volume(pgdata)一起刪,資料就沒了
docker compose up -d      # 重新啟動,PostgreSQL 會建一個全新的空資料庫

這一步回不去,先備份。

備份資料庫

用 PostgreSQL 自己的匯出工具 pg_dump。官方:它在資料庫有人在用的時候也能匯出一致的內容,而且不會擋住其他人讀寫。

# 1. 在 db 容器裡匯出成一個檔(-Fc:PostgreSQL 自己的壓縮格式,之後用 pg_restore 還原)
docker compose exec db pg_dump -U liteerp -Fc -f /tmp/liteerp.dump liteerp

# 2. 把那個檔從容器複製到 PC 的這個資料夾
docker compose cp db:/tmp/liteerp.dump ./liteerp-2026-11-17.dump

還原(示意):

docker compose stop app                                   # 還原時先停程式,不讓人寫入
docker compose cp ./liteerp-2026-11-17.dump db:/tmp/liteerp.dump
docker compose exec db pg_restore -U liteerp -d liteerp --clean /tmp/liteerp.dump
docker compose start app

--clean:還原前先把要還原的東西刪掉,用在覆蓋現有的資料庫(PostgreSQL 官方的說明)。還原前先停程式 一般經驗。

PostgreSQL 官方對 pg_dump 有一句提醒:「Note, however, that except in simple cases, pg_dump is generally not the right choice for taking regular backups of production databases.」(除了簡單的情況,pg_dump 通常不適合拿來做正式環境資料庫的定期備份。)場景 ① 是內部測試,用它沒問題 推論;正式環境的備份另外談(第 19 節的 RDS 會自己備份)。

14. 辦公室其他人怎麼連進來測

這一節是一般經驗,沒有逐項查官方文件

第三部分:在 AWS 上佈置(場景 ②、③)
再說一次:雲端放哪一家還沒談,這部分拿 AWS 當例子。AWS 跑容器還有其他服務(例如 App Runner、Lightsail,還有 EKS),這頁不談。這部分的區域一律用 us-east-1(美國東岸維吉尼亞)、帳號一律用 123456789012 當示意。

15. 先對照名詞

Jesse 熟的 EC2 世界容器的世界白話
一台 EC2路線 A:照舊是一台 EC2,上面跑容器
路線 B:Fargate 上的「工作」(task)
路線 B 沒有你看得到的機器,只有一份一份正在跑的容器。
AMI(開機碟的映像)容器映像檔AMI 是整台機器的開機碟;容器映像檔只包程式和它的執行環境。推論
放執行檔的地方ECR(Elastic Container Registry)AWS 的映像檔倉庫,各台機器從這裡拿映像檔。
「設成服務」:開機自動跑、掛掉重開ECS 的服務(service)「這個工作定義要一直開 N 份,掛了就補一份」。
啟動時的設定:要跑什麼、環境變數、連接埠ECS 的工作定義(task definition)一份 JSON:哪個映像檔、多少 CPU 與記憶體、環境變數、連接埠。每改一次多一個版本號。
一群機器ECS 的叢集(cluster)一個分組的名字。用 Fargate 時,裡面沒有你要管的機器。
選機型、開機器Fargate只告訴 AWS 要跑什麼容器、要多少 CPU 與記憶體,機器它自己找。
Security Group照舊用 Security GroupEC2、Fargate 的工作、負載平衡器、RDS 都用它決定誰能連進來。
自己在機器上處理 HTTPSALB(Application Load Balancer,負載平衡器)擋在最前面,HTTPS 憑證掛在這裡,再把請求分給後面的幾份程式。
自己在 EC2 上裝資料庫RDS(Relational Database Service)AWS 代管的資料庫:備份、更新、備援由 AWS 做。
給 EC2 的 IAM 角色照舊;路線 B 另有「工作執行角色」讓機器(或 Fargate)有權限去 ECR 拿映像檔、寫紀錄。
登入機器看 log 檔CloudWatch Logs路線 B 連不進機器,容器的紀錄送到這裡看。

16. 把映像檔推到 ECR

兩條路線的第一步一樣。下面的指令在開發的那台 PC 上跑,要先裝好 AWS CLI 並設定好帳號(AWS 的入門頁列為前置條件)。指令照 AWS 官方文件。

  1. 建一個倉庫(只要做一次)。官方說推之前倉庫一定要已經存在。
    aws ecr create-repository --repository-name liteerp --region us-east-1
    輸出裡的 repositoryUri 就是之後要用的位址,長這樣:123456789012.dkr.ecr.us-east-1.amazonaws.com/liteerp。
  2. 讓 Docker 登入 ECR。
    aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 123456789012.dkr.ecr.us-east-1.amazonaws.com
    前半段向 AWS 拿一組臨時密碼,用 | 交給後半段的 docker login;帳號固定寫 AWS。官方說這組權杖「valid for 12 hours」(12 小時內有效),過了要重新登入。AWS 也提供 PowerShell 的寫法:(Get-ECRLoginCommand).Password | docker login --username AWS --password-stdin 123456789012.dkr.ecr.us-east-1.amazonaws.com(要裝 AWS Tools for PowerShell)。
  3. 找到本機的映像檔。
    docker images
  4. 替映像檔加上 ECR 的完整名字。
    docker tag liteerp:1.4 123456789012.dkr.ecr.us-east-1.amazonaws.com/liteerp:1.4
    這不是複製一份,是替同一個映像檔多取一個名字。標籤不寫的話,官方說預設當成 latest。
  5. 推上去。
    docker push 123456789012.dkr.ecr.us-east-1.amazonaws.com/liteerp:1.4

另一條路:登入之後,直接讓 .NET SDK 推,不經過本機的 Docker:

dotnet publish -c Release --os linux --arch x64 /t:PublishContainer -p ContainerRepository=liteerp -p ContainerImageTag=1.4 -p ContainerRegistry=123456789012.dkr.ecr.us-east-1.amazonaws.com

微軟文件把 Amazon ECR 列在支援的倉庫裡,登入用 docker login 那一套。這條路沒有實際試過。

17. 路線 A:EC2 上裝 Docker

最接近 Jesse 現在的做法:還是一台自己的 EC2,只是上面不放執行檔,改跑容器。

Jesse 現在路線 A
開 EC2開 EC2(Linux),並給它讀 ECR 的權限
裝 .NET 執行環境裝 Docker(機器上只裝這個)
放執行檔從 ECR 拿映像檔
設環境變數、設成服務docker run 時給環境變數、加 --restart
使用者(瀏覽器) Cloudflare 或 ALB(HTTPS) 一台 EC2(Amazon Linux 2023) 機器上只裝了 Docker 程式容器 app 主機 80 → 容器 8080 db:5432 PostgreSQL 容器 db(選用) 資料在 volume pgdata 作業系統更新、磁碟、Docker 都要自己顧 ECR 1.3 1.4 IAM 角色 允許機器拿 或連到 RDS RDS(選用)
圖 7 路線 A。資料庫二選一:同一台再跑一個 PostgreSQL 容器,或用 RDS。

步驟

  1. 建 ECR、推映像檔(第 16 節)。
  2. 開一台 EC2,作業系統選 Amazon Linux 2023(AWS 裝 Docker 的官方說明就是用這個)。Security Group 開放 HTTP 80(或 HTTPS)進來,SSH 照舊。t4g 這類 ARM 機型要搭配 ARM 的映像檔(第 8 節)。
  3. 給機器讀 ECR 的權限。建一個 IAM 角色,掛上 AWS 管理的政策 AmazonEC2ContainerRegistryReadOnly(唯讀,含用 Docker 拿映像檔)或 AmazonEC2ContainerRegistryPullOnly(只能拿),開機時指定,或之後掛到這台機器上。AWS 說 IAM 角色讓機器上的程式拿到臨時的權限,不用把存取金鑰放在機器上。
  4. 裝 Docker(AWS 官方寫法,SSH 連進機器後):
    sudo yum update -y                  # 更新機器上已裝的套件
    sudo yum install docker             # 裝 Docker
    sudo service docker start           # 啟動 Docker
    sudo usermod -a -G docker ec2-user  # 讓 ec2-user 不用 sudo 就能下 docker 指令
    # 登出再登入(關掉 SSH 重連),群組才生效
    docker info                         # 確認不用 sudo 也能用
    官方提醒:有時要重開機才會生效,看到「Cannot connect to the Docker daemon. Is the docker daemon running on this host?」就重開一次。
    官方這段沒寫「開機自動啟動 Docker」。Linux 上一般用 sudo systemctl enable docker 一般經驗,沒查官方;沒設的話,機器重開機後 Docker 沒起來,容器的 --restart 也不會生效。
  5. 在機器上登入 ECR:跟第 16 節第 2 步同一行 aws ecr get-login-password …。這需要機器上有 AWS CLI;Amazon Linux 2023 有沒有預先裝好,這次沒查。權杖 12 小時過期,所以下面的更新腳本每次都先登入一次。AWS 另外提供一個 Docker 的登入輔助程式(Amazon ECR Docker Credential Helper),裝了就不用自己登入,這次沒細看。
  6. (資料庫放同一台時)建網路、起 PostgreSQL 容器。不用 Compose 時,兩個容器要接在自己建的網路上才能用名字互找(第 5 節)。
    docker network create -d bridge liteerp-net
    
    docker run -d --name db --network liteerp-net --restart unless-stopped \
      --env-file /home/ec2-user/db.env \
      -v pgdata:/var/lib/postgresql --shm-size=128mb \
      postgres:18
    db.env(只放在這台機器上,權限設成只有自己能讀):
    POSTGRES_USER=liteerp
    POSTGRES_PASSWORD=換成一組夠長的密碼
    POSTGRES_DB=liteerp
  7. 起程式的容器,指定版本、連接埠、資料庫連線字串:
    docker run -d --name app --network liteerp-net --restart unless-stopped \
      -p 80:8080 \
      --env-file /home/ec2-user/app.env \
      123456789012.dkr.ecr.us-east-1.amazonaws.com/liteerp:1.4
    app.env(連線字串的寫法是示意):
    ConnectionStrings__Default=Host=db;Port=5432;Database=liteerp;Username=liteerp;Password=同一組密碼

逐項解釋 docker run

這一段在做什麼
-d在背景跑,不佔住 SSH 的視窗。
--name app容器取名 app,之後 docker logs app、docker stop app 都用這個名字。
--network liteerp-net接到自己建的網路,app 才能用 db 這個名字找到資料庫。
--restart unless-stopped掛掉自動重開,除非是你自己停的。取代以前「設成服務」。
-p 80:8080機器的 80 → 容器的 8080。資料庫的容器沒有 -p,外面連不到它。
--env-file …從檔案讀環境變數,每行 名稱=值,# 開頭的行是註解。密碼不寫在指令裡,指令紀錄裡就不會留下密碼。後半句是一般經驗
-v pgdata:/var/lib/postgresql把 volume pgdata 掛給 PostgreSQL(第 4 節)。沒有這個 volume 時 Docker 會自己建。
--shm-size=128mb共用記憶體,跟第 12 節的 shm_size 同一件事。PostgreSQL 說明頁舉的例子是 256MB,這裡跟 Compose 範例一樣用 128mb。
最後一段要跑的映像檔:ECR 上的 liteerp:1.4。

更新與退版:寫成一個腳本

update.sh(示意,沒有實際跑過):

#!/bin/bash
set -e                                  # 任何一行失敗就停下來
TAG=$1                                  # 用法:./update.sh 1.4
REGISTRY=123456789012.dkr.ecr.us-east-1.amazonaws.com

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin $REGISTRY
docker pull $REGISTRY/liteerp:$TAG      # 先拿新版,拿不到就不會往下停掉舊的
docker stop app
docker rm app
docker run -d --name app --network liteerp-net --restart unless-stopped \
  -p 80:8080 --env-file /home/ec2-user/app.env \
  $REGISTRY/liteerp:$TAG

機器還是自己的:要自己顧什麼

18. 路線 B:ECS+Fargate

不用管機器。ECS(Elastic Container Service)負責「照指示把容器跑起來、維持份數、換版」;Fargate 負責提供跑容器的機器,你看不到那台機器。AWS 文件對 Fargate 的說法:「Fargate is a serverless, pay-as-you-go compute engine. With Fargate you don't need to manage servers, handle capacity planning, or isolate container workloads for security.」(Fargate 是不用管伺服器、用多少付多少的運算服務;不用管伺服器、不用規劃容量,也不用為了安全自己把各個容器隔開。)

三個名詞

使用者(瀏覽器) ALB+憑證(HTTPS) ECS 叢集 工作 1 liteerp:5 工作 2 liteerp:5 服務:一直開 2 份 掛了自動補,換版滾動更新 跑在 Fargate 上 看不到、也連不進機器 工作定義 liteerp:5 映像檔 CPU、記憶體 環境變數 ECR 1.4 1.5 RDS 代管的 PostgreSQL
圖 8 路線 B。工作定義的「:5」是第 5 版的意思(每改一次加 1),跟映像檔的版本號是兩回事。

步驟

  1. 建 ECR、推映像檔(第 16 節)。
  2. 建叢集:ECS 主控台 → Clusters → Create cluster → 取一個名字(例如 liteerp)→ Create。
  3. 工作執行角色:讓 Fargate 有權限去 ECR 拿映像檔、把紀錄送到 CloudWatch Logs、讀機密。AWS 提供管理好的政策 AmazonECSTaskExecutionRolePolicy,角色名稱慣例是 ecsTaskExecutionRole;主控台會試著自動建。
  4. 寫工作定義(下面的示意),在主控台用「Create new revision with JSON」貼上,或用指令登記:
    aws ecs register-task-definition --cli-input-json file://liteerp-task.json
    同一個名字(family)第一次登記是第 1 版,之後每登記一次版本號加 1。
  5. 建服務:在叢集裡 Services → Create,選工作定義、取服務名稱、啟動類型選 FARGATE、份數(Desired tasks)、網路與 Security Group;要接負載平衡器也在這裡設。
  6. ALB+憑證+網域(第 20 節)。
  7. 資料庫用 RDS(第 19 節)。

liteerp-task.json(示意;欄位照 AWS 的工作定義參數說明,名字與版本號都還沒定):

{
  "family": "liteerp",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "runtimePlatform": {
    "operatingSystemFamily": "LINUX",
    "cpuArchitecture": "X86_64"
  },
  "cpu": "1024",
  "memory": "2048",
  "executionRoleArn": "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
  "containerDefinitions": [
    {
      "name": "app",
      "image": "123456789012.dkr.ecr.us-east-1.amazonaws.com/liteerp:1.4",
      "essential": true,
      "portMappings": [
        { "containerPort": 8080, "protocol": "tcp" }
      ],
      "environment": [
        { "name": "ASPNETCORE_HTTP_PORTS", "value": "8080" }
      ],
      "secrets": [
        {
          "name": "ConnectionStrings__Default",
          "valueFrom": "arn:aws:ssm:us-east-1:123456789012:parameter/liteerp/connection-string"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/liteerp",
          "awslogs-region": "us-east-1",
          "awslogs-stream-prefix": "app"
        }
      }
    }
  ]
}
欄位白話
family這份工作定義的名字。每登記一次多一個版本號,寫成 liteerp:5 這樣。
networkMode: awsvpc網路模式。AWS 說用 Fargate 一定要 awsvpc:每份工作有自己的網路介面。
requiresCompatibilities讓 AWS 檢查這份定義能不能跑在 Fargate 上。
runtimePlatform作業系統與處理器架構。X86_64 對應 --arch x64 包的映像檔;要用 ARM 就寫 ARM64。
cpu、memory這份工作要多少 CPU 與記憶體。"1024" 是 1 核心、"2048" 是 2 GB;Fargate 只接受固定的組合,例如 0.5 核心(512)配 1~4 GB、1 核心配 2~8 GB。
executionRoleArn第 3 步的工作執行角色。
containerDefinitions這份工作裡的容器,我們只有一個。
name、image容器的名字;用 ECR 上的哪個映像檔與標籤。
essential: true這個容器停了,整份工作就算停了。
portMappings容器聽哪個連接埠。awsvpc 模式只寫 containerPort。
environment不機密的環境變數。這裡示意寫 ASPNETCORE_HTTP_PORTS(微軟建議明確指定程式聽哪個連接埠;8080 本來就是預設值)。
secrets機密的環境變數:值不寫在這裡,寫「去哪裡拿」(AWS Systems Manager Parameter Store 或 Secrets Manager 的位址)。工作啟動時由 AWS 拿出來放進環境變數。工作執行角色要另外給讀這些機密的權限(例如 ssm:GetParameters)。
logConfiguration容器的紀錄送到 CloudWatch Logs 的哪個群組。群組要先建好,或加 awslogs-create-group 讓它自己建(要有對應權限)。

更新與退版

  1. 推 1.5 的映像檔到 ECR。
  2. 把工作定義的 image 改成 …/liteerp:1.5,再登記一次,得到下一版(例如 liteerp:6)。
  3. 叫服務改用新版:
    aws ecs update-service --cluster liteerp --service liteerp-app --task-definition liteerp:6
    (AWS 指令參考裡的例子是 aws ecs update-service --cluster test --service my-http-service --task-definition amazon-ecs-sample;不寫版本號時用最新的一版。)
  4. 服務自己做滾動更新。AWS 的說明:「Amazon ECS spawns a task with the new version of the task definition and then stops an old task after the new version is running.」(先起一份新版的工作,新版跑起來之後才停掉一份舊的。)
  5. 退版:同一行指令,把 liteerp:6 改回 liteerp:5。另外 ECS 有「部署斷路器」(deployment circuit breaker),新版起不來時可以自動退回上一版。

一次換幾份,由兩個數字控制:minimumHealthyPercent(換的過程中至少要有幾成是健康的)和 maximumPercent(最多可以同時開到幾成)。AWS 的例子:最少 50%、要開 4 份時,可以先停 2 份舊的再起 2 份新的;最多 200%、要開 4 份時,可以先起 4 份新的再停 4 份舊的。

只開 1 份時會不會中斷:照預設值不會。AWS 的 API 參考寫:「The default maximumPercent value for a service using the REPLICA service scheduler is 200%.」以及「The default value for a replica service for minimumHealthyPercent is 100%.」只開 1 份時,這兩個數字的意思是「至少要有 1 份健康的、最多可以同時開到 2 份」,所以 ECS 會先起一份新的,等它健康了才停舊的。有接負載平衡器時,「健康」要等負載平衡器的健康檢查通過:「the service scheduler will wait for the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total.」
之前跟 Jesse 講「雲端只開 1 份也會中斷幾秒」,那是路線 A 的情況;路線 B 那樣講是錯的,這裡更正。開 2 份的好處不是「更新不中斷」,而是其中一份壞了,還有另一份在服務。最後一句是推論

不用顧什麼、失去什麼

19. 資料庫放哪裡

AWS 對 RDS 的說法:「Amazon RDS manages backups, software patching, automatic failure detection, and recovery.」(RDS 負責備份、軟體更新、自動偵測故障與復原。)也可以加唯讀複本分擔讀取。AWS 自己的對照表(摘錄):

誰負責在 EC2 上自己跑RDS
資料庫備份自己AWS
資料庫軟體更新自己AWS
高可用性(壞了切到備援)自己AWS
作業系統更新自己AWS
查詢調校自己自己
EC2 上自己跑 PostgreSQL 容器RDS
費用(第 21 節)跟程式同一台,幾乎不多花db.t4g.small 約 23 美元起一個月
備份與救援自己排 pg_dump 或其他方式、自己存、自己演練還原打開自動備份,可以還原
PostgreSQL 升級自己處理(主版本升級還要處理資料檔)AWS 處理大部分
機器壞了資料在那台的 volume 上,要靠自己的備份有備援的設定可以切過去(要另外開,價錢另計)
適合場景 ② 想省錢、能接受自己顧備份場景 ② 想少操心;場景 ③ 幾乎一定用代管

場景 ② 用哪一種還沒決定。

20. HTTPS 與網域

這一節只講概念。

做法一:ALB 掛憑證

在 ALB 上開一個 HTTPS 的入口(listener),掛一張憑證。AWS 的說明:「The load balancer uses a server certificate to terminate the front-end connection and then decrypt requests from clients before sending them to the targets.」(負載平衡器用伺服器憑證處理前端的加密連線,解密後再送給後面的目標。)憑證可以從 AWS Certificate Manager(ACM)選。網域的 DNS 指到 ALB。程式的容器本身只聽 HTTP 8080,不用管憑證。

路線 B 一定會用到 ALB:程式開好幾份時要有人分流,換版時一份一份換掉也要有人知道該把請求送給誰,而且憑證要有地方掛。這些理由是推論 嚴格說 AWS 文件寫的是服務「可以」接負載平衡器(不是必須),入門教學就是直接用工作的公開 IP 連;但那種 IP 會跟著工作換掉,不適合正式使用。後半句是推論

做法二:Cloudflare 擋在前面

Jesse 已經在用 Cloudflare 放原型。網域交給 Cloudflare 管,DNS 紀錄設成「Proxied」(橘色雲朵)。Cloudflare 的說明:「When a record is Proxied, Cloudflare sits between your visitors and your server — optimizing, caching, and protecting traffic along the way.」(設成 Proxied 時,Cloudflare 站在訪客和你的伺服器中間,沿路最佳化、快取、保護流量。)訪客看到的憑證是 Cloudflare 的。路線 A 只有一台 EC2 時,這條比加 ALB 便宜(不用 ALB 那每月約 16 美元)。

Cloudflare 到 EC2 這一段要不要再加密、怎麼設,這次沒查。

21. 費用

美國東岸維吉尼亞的牌價,一個月以 730 小時算。下面全部的但書都要一起看。

項目單價一個月
EC2 t4g.small(2 核心、2 GB,ARM 處理器)每小時 0.0168 美元約 12 美元
EC2 的硬碟 30 GB(gp3)每 GB 每月 0.08 美元約 2.4 美元
Fargate 0.5 核心+1 GB,開 1 份(Linux/x86)每核心每秒 0.000011244、每 GB 每秒 0.000001235 美元(換算每核心每小時約 0.0405、每 GB 每小時約 0.0044)約 18 美元
Fargate 1 核心+2 GB,開 1 份同上約 36 美元
負載平衡器 ALB每小時 0.0225 美元,另加每 LCU 每小時 0.008 美元約 16 美元起
RDS PostgreSQL db.t4g.small(2 核心、2 GB)每小時 0.032 美元,硬碟另計約 23 美元起
映像檔倉庫 ECR每 GB 每月 0.10 美元;同一個機房裡拿映像檔不收費不到 1 美元

場景 ②(幾十人)兜起來

組合一個月約
路線 A,資料庫也在同一台 EC215 美元
路線 A,資料庫用 RDS40 美元
路線 B,Fargate 1 份+ALB+RDS60 美元
路線 B,Fargate 2 份(一份壞了還有一份)+ALB+RDS78 美元

場景 ③(幾萬人)

給不出可靠數字:要開幾份、資料庫要多大,要量過才知道。只能說程式那邊每多開一份 1 核心+2 GB,約 36 美元一個月;資料庫會是最貴的一塊,這次沒查到大型機種的價格。

但書

22. 兩條路線比較表

路線 A:EC2 上裝 Docker路線 B:ECS+Fargate
誰管機器自己(作業系統、Docker、磁碟)AWS(看不到機器)
更新方式連進機器跑腳本:拿新版、停舊的、起新的登記新版工作定義,update-service,服務自己滾動更新
會不會中斷只有一台、一份:中斷幾秒照預設不中斷,只開 1 份也是(第 18 節)
退版同一個腳本,給舊的標籤同一行指令,給舊的工作定義版本
最低費用(場景 ②,第 21 節)約 15 美元(資料庫同一台)/約 40 美元(RDS)約 60 美元(1 份)/約 78 美元(2 份)
HTTPSCloudflare 擋在前面,或加 ALBALB(第 20 節)
適合哪個場景場景 ②場景 ②、③
Jesse 要多學什麼Docker 指令、ECR、給 EC2 的 IAM 角色上面那些,再加工作定義、服務、工作執行角色、ALB、CloudWatch Logs、機密的存放

23. 從場景 ② 走到場景 ③

同一個映像檔(處理器架構一樣的前提下,第 8 節),差別在怎麼開、開幾份。對照 模組化單體那頁第 7 節的三個場景,與第 8 節「人變多時先卡在哪裡」。

收尾

24. 還沒決定的

25. 沒把握、沒查到的地方

26. 來源

網路資料都是 2026-11-17 查的。

Docker

PostgreSQL

.NET

Microsoft

AWS

費用(第 21 節)

Cloudflare