GitLab CI/CD

每次 push 之後,能不能有人幫忙檢查?從一份小網頁開始,理解 pipeline、job、runner 與 artifacts,再把檢查、Docker image 建置和網站發布接起來。

所以,Git 和 Docker 那兩篇留下的 CI/CD,今天終於輪到它了。

中間先跑去看了位元運算、PIO、執行緒和 DMA,繞得確實有一點遠。不過,坑還記得,也算是一種進度吧。

先接回原本的問題。我們已經能用 Git 保存修改,也知道怎麼用 Docker 準備程式的執行環境。但每次修改之後,還是得自己檢查、自己建置,確認沒問題,再把新版本交出去。

「這些指令明明每次都差不多,能不能在我 push 之後,就有人幫忙做?」

可以。這次就來看 GitLab CI/CD,先讓它替一份小網頁檢查內容、整理檔案,再把通過的結果拿去發布。前一篇提到的 Docker image,也會接回來。

不過,先不要急著貼一整頁 YAML。我覺得還是先知道,我們到底希望誰在什麼時候做什麼,後面的設定才比較看得懂。

一、為什麼需要 CI/CD?

假設我們正在修改 Docker 那篇的小網站。

原本的工作大概是:改網頁,確認內容,建立 image,再把準備好的版本交給其他人。

自己做一次,當然沒有太大問題。但做了十次、二十次之後,就可能開始出現一些變化。

例如今天只是改一句話,應該不用檢查吧。明天急著交出去,測試先跳過。後天同事換了一種建置方式,結果大家交出去的東西,又不太一樣。

嗯,流程還在,只是每次經過的站好像不太固定。

所以,我們希望把這些步驟寫下來,讓符合條件的修改,都走過同一套檢查與交付流程。

例如:

  1. 推送修改GitLab 收到新版本
  2. 執行檢查確認我們訂好的條件
  3. 準備產物整理要交付的檔案
  4. 發布版本讓使用者取得新內容

這樣每次修改,都會留下它執行過哪些工作、哪一步成功、哪一步失敗的紀錄。出問題時,也比較容易對回當時的 commit。GitLab:CI/CD 入門

不過,自動執行的前提,是我們已經告訴它要怎麼檢查。它不會看到一份網頁,就自己知道標題有沒有寫對,更不會順便幫忙判斷文章好不好看。

這部分,還是得自己來。

二、CI 和 CD,各自在說什麼?

先把這幾個字母拆開。

CI 是 Continuous Integration,也就是持續整合。

開發時,把修改頻繁地整合回共同的程式碼,並透過自動建置與測試,盡早知道這次修改能不能和其他部分一起工作。

例如兩個人分別修改函式和呼叫方式,Git 可能沒有合併衝突,編譯卻過不了。前面 Git 那篇已經說過,順利合併,不代表程式一定正確。CI 就能幫我們反覆執行那些用來確認的工作。

但如果半年才整合一次,最後才開一條 pipeline,雖然也能自動跑測試,原本累積半年的整合問題,還是得一次面對。

至於 CD,則常會看到兩個意思:

名稱中文先這樣理解
Continuous Delivery持續交付自動把通過檢查的修改準備成可發布的版本,正式發布可以由人決定
Continuous Deployment持續部署符合條件、通過檢查後,也自動部署到正式環境

所以,兩者的差別,可以先看最後發布到正式環境的那一步,是否還需要人來觸發。GitLab:手動與自動的部署安排

這篇會先把網站檔案準備好,再留一個手動發布的步驟。知道自己要發布哪一份,才按下去。

等這條路走得清楚了,再決定哪些條件下適合直接自動發布。

三、Pipeline、Job、Stage,還有 Runner?

剛把三個字母拆完,現在又多了四個名字,確實有一點熱鬧。

我們繼續用「檢查網頁,再發布」來看。

1. Job:一份要執行的工作

例如執行一支 Python 程式,檢查網頁內容,就是一個 job。

把網站檔案整理到指定資料夾,也可以是另一個 job。每個 job 都能設定要執行的指令,並留下自己的輸出紀錄。

job 的名字由我們自己取,例如 check_page、build_site。名字主要是方便辨認,真正做了什麼,還是要看裡面的指令。

2. Stage:把工作分成幾個階段

例如先檢查,再準備檔案,最後發布,可以分成 test、build、deploy 三個 stage。

在這篇使用的基本安排裡,前一個階段成功,才會繼續下一個階段。同一個 stage 裡的多個 job,則可以在 runner 資源允許時平行執行。

所以,stage 是用來分組與安排順序,job 才是裡面具體要做的事情。GitLab:Pipeline

3. Pipeline:這一次整套流程

GitLab 收到一次符合條件的修改,建立出這次的工作流程,就是一條 pipeline。

同一個專案可以留下很多條 pipeline,各自對應當時的版本和執行結果。修改了設定後再推送,建立的新 pipeline,也會使用那個版本裡的設定。

同一條 pipeline 內,test、build、deploy 階段依序進行,test 階段的兩個工作可以平行執行。
圖中多放一個檢查工作,示意同階段的分工;本文先用一個 check_page。

4. Runner:真的去執行工作的人

那誰來執行 python check_page.py?

這就要有 GitLab Runner。它是接收並執行 CI/CD 工作的程式,可以安裝在自己的機器,也可以使用平台提供的 runner。

Runner 會依設定準備環境、取得程式碼、執行指令,再把結果交回 GitLab。

它底下使用什麼方式執行工作,叫做 executor。例如 Docker executor 可以用容器執行;Shell executor 則直接在 runner 所在的環境執行 shell 指令。

這篇使用能執行 Linux 容器、支援 image 設定的 runner。不能換成 Shell executor,卻期待寫下一個 image 名稱後,它就自動替主機安裝 Python。GitLab Runner:Executors

先把關係記成:pipeline 安排這次有哪些 job,stage 把工作分組,runner 負責真的去執行。

四、先準備一份真的能檢查的網頁

這次用一個獨立的練習專案,不需要先修改自己的正式網站。

需要一個 GitLab 專案,以及能接收這個專案工作的 runner。如果使用 GitLab.com,可以先在專案的 Settings → CI/CD → Runners 查看可用的 runner;平台提供的執行資源,也要符合帳號與用量條件。

先建立兩個檔案:

ci-practice/
├── index.html
└── check_page.py

1. 網頁放什麼?

index.html 寫成:

<!doctype html>
<html lang="zh-Hant">
  <head>
    <meta charset="utf-8">
    <title>CI/CD 練習</title>
  </head>
  <body>
    <h1>Hello, GitLab</h1>
    <p>這份網頁會先經過檢查,再交出去。</p>
  </body>
</html>

和 Docker 那篇一樣,先只有靜態 HTML。這次要觀察的是流程,所以不順便加上資料庫和登入系統,不然還沒開始 CI,專案就先長大了。

2. 檢查要怎麼寫?

先訂兩個很小的要求:頁面要有標題,而且主要標題必須是 Hello, GitLab。

建立 check_page.py:

from html.parser import HTMLParser
from pathlib import Path


class PageParser(HTMLParser):
    def __init__(self):
        super().__init__()
        self.current = None
        self.parts = {"title": [], "h1": []}

    def handle_starttag(self, tag, attrs):
        if tag in self.parts:
            self.current = tag

    def handle_endtag(self, tag):
        if tag == self.current:
            self.current = None

    def handle_data(self, data):
        if self.current is not None:
            self.parts[self.current].append(data)


page = PageParser()
page.feed(Path("index.html").read_text(encoding="utf-8"))

title = "".join(page.parts["title"]).strip()
heading = "".join(page.parts["h1"]).strip()

if not title:
    raise SystemExit("缺少頁面標題")
if heading != "Hello, GitLab":
    raise SystemExit("主要標題應該是 Hello, GitLab")

print("網頁檢查通過")

這裡使用 Python 內建的 HTML parser,把 title 和 h1 裡的文字收集起來,再檢查剛才的條件,不需要另外安裝套件。

它只針對這份簡單頁面做檢查,沒有驗證整份 HTML 是否合法,也沒有打開瀏覽器檢查排版。

先在這個資料夾用 Python 3 執行:

python3 check_page.py

正常時應該看到:

網頁檢查通過

如果把 h1 改成別的文字,就會顯示錯誤,並以非零的退出碼結束。後面 GitLab 判斷這個 job 有沒有成功,就會用到這件事。

這也說明,CI 並沒有發明另一套測試。我們先寫出可以執行的檢查,再讓 runner 按照流程反覆執行。

五、把流程寫進 .gitlab-ci.yml

在專案最外層,再建立一個 .gitlab-ci.yml。檔名前面有一個點,副檔名使用這裡的 .yml。

先放最基本的兩個階段:

workflow:
  rules:
    - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH'

default:
  image: python:3.13-slim

stages:
  - test
  - build

check_page:
  stage: test
  script:
    - python check_page.py

build_site:
  stage: build
  script:
    - mkdir -p public
    - cp index.html public/index.html
  artifacts:
    paths:
      - public/
    expire_in: 1 week

YAML 使用縮排表示層次,這裡用空格,不要換成 Tab。先不用一次記住所有名稱,我們照著執行順序看。

1. Workflow:這一次要不要建立 Pipeline?

最上面的條件,表示這份練習只在分支收到 push 時建立 pipeline。

CI_PIPELINE_SOURCE 和 CI_COMMIT_BRANCH 是 GitLab 提供的變數。前者表示這次流程的來源,後者在分支 pipeline 裡表示分支名稱。

push 事件也可能來自推送 tag,所以多檢查 CI_COMMIT_BRANCH,把這次的範圍留在分支。

因此,這份設定沒有開啟排程、從畫面手動建立 pipeline,或專門的 merge request pipeline。後面按 job 的發布按鈕,則是在已經存在的 pipeline 裡啟動工作,和建立新 pipeline 不同。GitLab:Workflow

2. Image:工作要在哪個環境執行?

default.image 指定預設使用 python:3.13-slim。這是不是就接回 Docker 那篇了?

Runner 可以拿這份 image 準備工作容器,裡面已經有 Python,接著取得這個版本的專案檔案,執行我們寫的指令。

這裡的 image 是執行 CI 工作使用的環境。後面如果要替自己的網站建立 image,那又是這個工作產生的結果,兩份用途要分開看。

3. Stage 和 script:先檢查,再整理檔案

check_page 屬於 test 階段,script 裡寫它要執行的指令。

build_site 則在下一個 build 階段,把網頁放進 public/。這個靜態頁面不需要編譯,所以這次的建置工作,就只是準備好要交付的目錄。

如果之後換成 Astro 或其他框架,這一步才會改成安裝相依套件、執行對應的建置指令。stage 叫做 build,不會讓 GitLab 自己猜出要怎麼建置。

4. 檢查沒過,後面會怎樣?

在這份設定裡,Python 程式失敗並回傳非零退出碼,check_page 就會失敗,下一階段的 build_site 不會照常執行。GitLab:Script 與退出碼

所以,檢查程式不能只是印出「錯了」,最後卻正常結束。Runner 看的是指令結果,不會讀完那句中文,再替我們判斷應該擋下來。

也別為了讓畫面變綠,就加上 || true 把錯誤吃掉。這樣確實比較容易成功,只是原本想檢查的事情,也一起放過去了。

六、上一個 Job 產生的檔案,下一個就有了嗎?

回頭看 build_site 最下面的 artifacts。

它表示這個 job 要保存並上傳的產物。這裡指定的是 public/,所以工作完成後,GitLab 能留下這份網站檔案,讓我們下載,也能提供給後面的 job。

為什麼要特別上傳?不是都在同一條 pipeline 裡嗎?

因為不同 job 可能在不同容器、不同 runner,甚至不同機器上執行。前一個 job 在自己的目錄裡建立 public/,不代表下一個工作環境就會自動出現它。

build_site 產生 public 目錄,透過 artifacts 上傳至 GitLab,deploy_pages 再下載並使用這份檔案。
同一條 pipeline 裡的工作,仍然需要安排檔案怎麼交接。

artifacts.paths 的路徑以專案工作目錄為基準,expire_in 則設定保存期限。這裡寫一週,但實際是否保留更久,也會受到 GitLab 保留最新成功產物等設定影響。GitLab:Job artifacts

這次只把要交付的 public/ 留下來,不需要連整個工作目錄一起打包。

那 artifacts 和 cache,有什麼不同?

兩者都可能保存檔案,但目的不同。

artifacts 用來留下這次工作產生的結果,例如網站檔案、編譯好的程式或測試報告。後面的工作要使用這份結果,就安排下載。

cache 則主要用來加快後續工作,例如快取套件管理工具下載過的套件,減少重複下載。快取不保證每次都取得得到,沒有時應該仍然能重新準備。

所以,不能因為都能保存一個資料夾,就把「這個 commit 準備好的網站」隨便改成交給 cache。發布工作需要知道,自己拿到的是這次檢查過的哪一份結果。GitLab:Caching

這個練習沒有額外套件要下載,先不加 cache。

七、Push 一次,再故意讓它失敗

現在專案裡應該有這三個檔案:

ci-practice/
├── .gitlab-ci.yml
├── index.html
└── check_page.py

在已經連到 GitLab 遠端的 repo 裡,把它們提交並推送:

git add .gitlab-ci.yml index.html check_page.py
git commit -m "Add page checks and site build"
git push

如果還沒有建立 repo 或設定上游分支,可以先對照前面的 Git 筆記,把本機專案推到 GitLab。

接著到專案的 Build → Pipelines,查看這次 commit 的流程。點進 job,就能看到準備環境、執行指令,以及上傳 artifacts 的紀錄。GitLab:第一條 Pipeline

正常情況下,check_page 先成功,再輪到 build_site。完成後,可以在建置工作的 artifacts 裡找到 public/index.html。

讓主要標題寫錯一次

現在把 index.html 裡的主要標題改成:

<h1>Hello, GitLba</h1>

嗯,就只是把兩個字母交換了。這種修改,倒是很有機會真的發生。

再提交並 push,新的 pipeline 應該會在 check_page 失敗,紀錄裡出現:

主要標題應該是 Hello, GitLab

後面的建置就不會繼續。

把標題改回 Hello, GitLab,再提交與推送,才會建立使用修正版本的新 pipeline。對舊的失敗 job 按 Retry,通常仍然是在重試原本那個版本,不會自動改成讀取你剛剛修好的最新 commit。

所以,失敗時先確認自己正在看哪個 commit,再看是哪個指令失敗。不能在本機修完,就期待遠端已經失敗的那一條自己變好。

八、加上 CD:把網站發布到 GitLab Pages

前面已經能檢查與保存檔案,但網頁還沒有因此出現在網站上。

「那個 artifacts 裡不是已經有 HTML 了嗎?」

有,但保存一份檔案,和讓網站服務把它提供給瀏覽器,還是兩個步驟。

這次使用 GitLab Pages,讓 GitLab 託管這份靜態網頁。它不會替我們長期執行前一篇的 Python HTTP server,也不是拿來跑資料庫的地方。

下面使用 GitLab 17.10 以上的 pages.publish 寫法,並假設專案能使用 Pages。自行架設的 GitLab,也要先由管理端開啟對應服務。GitLab:從零建立 Pages 網站

1. 增加發布階段

把原本的 stages 換成:

stages:
  - test
  - build
  - deploy

接著在同一份 .gitlab-ci.yml 最外層,加入:

deploy_pages:
  stage: deploy
  dependencies:
    - build_site
  script:
    - test -s public/index.html
  pages:
    publish: public
  rules:
    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
      when: manual
      allow_failure: false

原本的 workflow、default 和兩個 job 保留。最後就是三個 job,分別放在三個階段。

dependencies 指定這次只下載 build_site 的 artifacts,讓發布工作拿到前面準備的 public/。這裡仍然沿著 stage 順序執行,不是下載完就跳過前面的檢查。

test -s 是 shell 指令,確認這份檔案存在而且不是空的。真正讓它成為 Pages 發布工作的,是下面的 pages.publish 設定。

在 GitLab 17.10 以上,這個發布目錄也會自動加入該 Pages job 的 artifacts 路徑。GitLab:Pages 設定

2. 為什麼只讓預設分支發布?

rules 決定這個 job 在什麼條件下加入 pipeline,以及要怎麼執行。

這裡比較目前分支和 CI_DEFAULT_BRANCH,也就是專案的預設分支。它常叫做 main,但專案也可能設定成其他名字。

這樣功能分支仍然可以跑前面的檢查和建置,卻不會每改一次,就把大家正在看的 Pages 網站換成那條分支的內容。沒有符合這條規則時,發布 job 就不加入這次流程。GitLab:Job rules

3. Manual:先停在發布之前

when: manual 表示要由人啟動這個 job;allow_failure: false 則明確把它設成會阻擋流程完成的手動工作。

所以預設分支通過檢查與建置後,pipeline 會停在等待手動發布的狀態。這時候不是測試又壞了,也不是 runner 忘記繼續。GitLab:手動工作

確認版本後,在這條 pipeline 啟動 deploy_pages。等 Pages 的發布流程完成,再到 Deploy → Pages 查看網站網址。實際網址以專案畫面提供的為準,不需要自己猜帳號和專案會怎麼組合。

如果等得太久,前面的 artifact 已經過期或被刪除,發布工作就可能無法取得檔案。這時要重新準備產物,不能只留下那個按鈕,就當成內容會一直存在。

這就是這次安排的持續交付:修改可以自動檢查並準備好,發布前再由人決定。

如果希望通過後直接發布呢?

把 deploy_pages 的規則改成:

  rules:
    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
      when: on_success

這是取代原本整段 rules,包含刪除手動工作裡的那行 allow_failure。其他部分保持相同。

在這個練習裡,預設分支通過前面的階段後,就會自動發布 Pages。發布這一端,也就不再等人按下按鈕。

但這不會讓原本那兩個內容檢查突然變完整。要把正式網站交給這條流程,仍然得先決定,需要哪些檢查才能支持這個發布決定。

九、接回 Docker:通過後,也能建立 Image 嗎?

可以。前面是把 HTML 交給 Pages;另一種需求,是把網站放進 image,再推送到 container registry,交給能執行容器的環境使用。

這時候,流程可以多一個 package 階段:

網頁通過檢查後整理成 public,再建成網站 image 並推送到 registry;下載 image 與啟動服務是後續的部署工作。
image 推進 registry,只完成了這一段交付;網站使用哪一版,還要安排部署。

不過,這裡很容易漏掉一件事:前面使用的 Python 工作容器,沒有因為它自己也是容器,就順便得到建置 image 的工具與權限。

甚至換成有 Docker CLI 的 image,也不代表已經有 Docker daemon 可以連線。CLI 是發送要求的工具,背後還要有人完成建置。

這次補充使用 rootless BuildKit,讀取 Dockerfile,建置並推送 image。它不需要另外連一個 Docker daemon,但 runner 仍要允許它需要的 user namespace 與掛載操作。GitLab:使用 BuildKit 建置 Image

這部分比前面的 HTML 檢查,多了 registry 與 runner 環境條件,所以把完整設定放在下面。第一次可以先讓 Pages 的流程走完,再回來加上。

把 public/ 建成 Image,推到這個專案的 Container Registry

前提是專案已開啟 Container Registry,而且 runner 能執行官方文件所述的 rootless BuildKit 工作。GitLab.com 的託管 Linux runner 與自己管理的 runner,底層權限設定可能不同;遇到權限錯誤,要先對照 runner 環境。

在專案最外層建立 Dockerfile:

FROM python:3.13-slim
WORKDIR /app
COPY public/ ./
EXPOSE 8000
CMD ["python", "-m", "http.server", "8000", "--bind", "0.0.0.0"]

這裡和 Docker 那篇的差別,是把 build_site 已經準備好的 public/ 放進去。它仍然是練習用的 Python HTTP server,正式服務要再選擇適合的伺服器。

把 stages 改成下面這一份,讓 package 在 build 之後、deploy 之前:

stages:
  - test
  - build
  - package
  - deploy

再在最外層加入這個 job:

package_image:
  stage: package
  image:
    name: moby/buildkit:rootless
    entrypoint: [""]
  dependencies:
    - build_site
  variables:
    BUILDKITD_FLAGS: --oci-worker-no-process-sandbox
  before_script:
    - mkdir -p ~/.docker
    - |
      printf '{"auths":{"%s":{"username":"%s","password":"%s"}}}' \
        "$CI_REGISTRY" "$CI_REGISTRY_USER" "$CI_REGISTRY_PASSWORD" \
        > ~/.docker/config.json
  script:
    - |
      buildctl-daemonless.sh build \
        --frontend dockerfile.v0 \
        --local context=. \
        --local dockerfile=. \
        --output "type=image,name=$CI_REGISTRY_IMAGE:$CI_COMMIT_SHA,push=true"
  rules:
    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'

這裡仍然保留原本的 check_page、build_site 和 deploy_pages。

package_image 使用自己的 image,覆寫預設的 Python 環境。entrypoint: [""] 則清掉原本的啟動入口,讓 runner 執行這裡的建置指令。

dependencies 取得 public/;--local context=. 指定建置內容來自目前專案目錄;--local dockerfile=. 則讓它在這裡找 Dockerfile。

最後的 push=true,才會把建置結果推到指定 registry。

登入資料使用 GitLab 提供的 CI_REGISTRY_USER 和 CI_REGISTRY_PASSWORD,在工作環境裡準備認證檔,不需要把自己的登入密碼寫進 repo。這份認證檔也不要加入 artifacts 或 cache。

輸出名稱由兩個變數組合:

變數在這裡的用途
CI_REGISTRY_IMAGE這個專案的 registry image 路徑
CI_COMMIT_SHA這次 commit 的完整識別碼,拿來當 image 標籤

用 commit 標籤,比只叫做 latest 更容易對回來源版本。不過標籤本身仍可能被覆寫;需要固定到同一份 image 內容時,可以記錄並使用它的 digest。GitLab:預先定義的變數/Docker:Image digest

這些 image 標籤也沒有固定建置工具與基礎 image 的全部內容。若要嚴格重現建置,還要進一步固定它們的版本或 digest。

因為前面用 stage 排順序,預設分支會等 package 成功,才走到手動的 Pages 發布。但 Pages 仍然發布 public/,不會使用這個網站 image;兩者是在示範同一份網頁的兩種交付方式。

所以,只想練習其中一種,也可以先保留對應的交付工作。建好並推送 image,不會自動讓另一台伺服器換成這一版。 真正的容器部署,還要再安排下載、啟動、健康檢查,以及失敗時怎麼處理。

十、沒有照預期執行,要從哪裡看?

設定寫完,當然也不保證第一次就會全綠。

不過,先分清楚停在哪裡,就比較不會一看到失敗,馬上開始重寫整份 YAML。

1. 連 Pipeline 都沒有出現

先確認 .gitlab-ci.yml 已經提交到正在看的那個分支,位置與檔名也正確。

接著看 workflow。這篇只允許分支 push,所以推 tag 或從畫面建立新 pipeline,本來就不符合條件。

如果是設定格式有問題,可以在 GitLab 的 Pipeline editor 使用 CI Lint 檢查語法與部分流程邏輯。它能幫忙發現設定錯誤,但不會真的替我們執行每一支測試程式。GitLab:驗證 CI/CD 設定

2. Job 一直 Pending

先看是不是有可用的 runner,以及它能不能接這個專案與分支的工作。

如果專案使用 runner tags,也要確認 job 要求的 tags 能被同一個 runner 滿足。只要有一台 runner 存在,不代表每個 job 都能交給它。

這裡還沒有開始執行 Python,所以一直改檢查程式,通常也不會讓等待中的工作突然找到 runner。

3. Job 已經開始,但失敗了

打開那個 job 的紀錄,先看是下載 image、取得程式碼、下載 artifacts,還是執行自己的 script 時失敗。

例如找不到 public/index.html,就回頭看前一個工作有沒有產生它、是否上傳成功,以及現在有沒有下載到正確的 artifact。若是 BuildKit 的權限錯誤,則要對照 runner 的執行方式。

不同階段的錯誤,得回到不同位置處理。GitLab:CI/CD 除錯

4. Pipeline 等待手動工作

先看自己是不是設定了 when: manual。

這篇預設分支的 Pages 發布,就是刻意停在這裡。檢查與建置成功後,確認 commit,再決定是否發布。

也要確認沒有打開更舊的 pipeline,手動把網站換回舊版本。實際專案還能另外安排部署順序與過期工作的限制,這次先從自己看清楚版本開始。

5. 全部成功,但網站還是不對

先問這條流程實際做到了哪一步。

只完成 build_site,是檔案準備好了;package_image 成功,是 image 已推進 registry;Pages 發布完成,才是這份靜態網站交給 Pages 提供服務。

而且,就算全部通過,也只代表我們安排的那些檢查通過。前面只檢查標題,內文寫錯、排版跑掉,都可能照樣放行。

綠色的勾勾看起來確實很安心,但它知道多少,還是取決於我們有讓它檢查多少。

十一、先知道這次改了什麼,再決定怎麼交出去

最開始只是想省下每次手動執行的幾條指令,結果一路拆下來,又多了不少名字。

但把這個練習放回原本的問題,就比較清楚了。

Git 記下這次修改;.gitlab-ci.yml 描述哪些條件下要做哪些工作;runner 準備環境並執行。檢查成功後,再把產物留下來,交給發布工作,或建成 image 推進 registry。

所以我覺得,這次比起先背下所有 YAML 關鍵字,更重要的是知道:這條流程對應哪個版本、每個工作確認了什麼,以及下一步拿到的是哪一份結果。

檢查失敗有沒有真的停下來?上一個 job 的檔案,下一個有沒有收到?畫面顯示成功,是檔案建好了,還是網站真的已經更新?

這些對上之後,那一排綠色才比較知道是在替什麼事情打勾。

至於 merge request pipeline、needs 怎麼調整工作依賴、不同環境的部署,以及失敗時的回復方式,就留到後面。今天先讓這份網頁順利走完一次,再慢慢把流程加完整。

前面 Git 和 Docker 留下的問題,終於接起來了。至於 Kubernetes,那個坑也還在。嗯,至少這次有先填一個。

參考資料

完

#學習筆記#GitLab#CI/CD#Pipeline#Docker#軟體工程

客官怎麼看

看完有話想說,留在這裡。罵我也可以,罵別人更好。

可用 GitHub 登入,或以筆名題字;Email 選填。地區章依網路位置辨識,臺灣可顯示縣市;編號用來區分留言。