Antony 筆記：技術原理與實務經驗 – 維運與自動化

動手實作 OpenTelemetry

Tue, 16 Dec 2025 19:45:08 +0800

0. Preface

本篇文章是翻譯 Getting Started with OpenTelemetry (LFS148) 的第四章節，想看原文可參考以下網址：

https://training.linuxfoundation.org/training/getting-started-with-opentelemetry-lfs148/#

為什麼需要 OpenTelemetry

Tue, 16 Dec 2025 19:44:46 +0800

0. Preface

本篇文章是翻譯 Getting Started with OpenTelemetry (LFS148) 的第二章節，想看原文可參考以下網址：

https://training.linuxfoundation.org/training/getting-started-with-opentelemetry-lfs148/#

1. 學習目標完成本章後，您將能夠：

定義與工作負載 (Workload) 及資源分析相關的通用術語
說明為何可觀測性 (Observability) 在分散式系統中至關重要
探討可觀測性的三大支柱——日誌 (Logs)、指標 (Metrics) 與 追蹤 (Traces)
探討現代——且常是多語言混合 (Polyglot)——分散式應用程式所面臨的挑戰
描述 OpenTelemetry 的特性
說明 OpenTelemetry 如何試圖解決傳統可觀測性解決方案的不足之處

2. 當前可觀察性的狀態

根據維基百科的定義，「可觀測性 (Observability) 是衡量我們能多有效地透過系統的外部輸出，來推斷其內部狀態的一項指標」(2024)。換句話說，可觀測性指的是您透過檢視系統（例如應用程式或服務）所產生的資訊，來理解其內部運作狀況的容易程度。

分散式系統 (Distributed System) 是由一組獨立的電腦或節點 (nodes) 所組成的網路，它們協同運作以執行任務，表現得就像是一個單一系統。這類系統廣泛應用於雲端運算 (Cloud Computing) 等領域，其中應用程式的不同部分會在不同的伺服器上運行，藉此共享資源並達成工作負載平衡 (balance the workload)。由於分散式系統的複雜性，要在任何時間點掌握每個元件 (component) 內部的運作情形，往往是一項艱鉅的挑戰。這正是可觀測性變得至關重要的原因。

為了讓分散式系統具備可觀測性，我們必須以一種能讓我們推導其行為的方式來建立狀態模型。這個模型由三個要素組成：

首先是 工作負載 (Workload)。這是系統為了達成目標所執行的操作。例如，當使用者發送一個請求時，分散式系統通常會將其拆解為由不同服務處理的較小任務。這通常也被稱為 交易 (Transactions)。

第二是構成分散式系統結構的 軟體抽象層 (Software Abstractions)。這包含了諸如 負載平衡器 (Load Balancers)、服務 (Services)、Pods、容器 (Containers) 等元件。

最後是提供 運算資源 (Computational Resources)（如 RAM、CPU、磁碟空間、網路）以執行工作的 實體機器 (Physical Machines)。

根據我們的背景不同，在調查分散式系統的效能或進行故障排除時，我們往往會有特定的 切入視角 (bias)。應用程式開發人員通常專注於與工作負載相關的層面，而 維運團隊 (Operations Teams) 則傾向於關注實體資源。

為了真正理解一個系統，我們必須結合來自多個角度的洞察，並釐清它們彼此之間的關聯。然而，在我們能進行分析之前，必須先捕捉系統行為的各個面向。這通常是透過結合 日誌 (Logs)、指標 (Metrics) 和 追蹤 (Traces) 來完成的。

2.1. Logs

日誌（Logs）是一種僅能追加（append-only）的資料結構，用來記錄系統中發生的事件。 一筆日誌紀錄包含標示事件發生時間的時間戳記（timestamp），以及描述事件細節的訊息。然而，要制定一個標準化的日誌格式並非易事。其中一個原因是，不同類型的軟體通常傳達不同的資訊內容。HTTP 網頁伺服器的日誌，肯定與核心（kernel）的日誌截然不同。但即使是相似的軟體，人們對於「好的日誌」應具備的樣貌也常有不同看法。

除了內容之外，日誌格式也會隨著其使用對象（consumers）而有所不同。最初，純文字格式是為了迎合人類的可讀性而設計。然而，隨著軟體系統變得日益複雜，日誌的量級很快就變得難以管理。為了應對這個問題，我們開始將事件編碼為鍵值對（key/value pairs），使其具備機器可讀性（machine-readable），這通常被稱為結構化日誌（structured logging）。

此外，貨櫃化（containerized）應用程式的分散式與短暫特性（ephemeral nature），意味著登入個別機器去翻找日誌的做法不再可行。因此，人們開始構建日誌代理程式（logging agents）和通訊協定，將日誌轉發到專用的服務中。這些日誌系統實現了高效的儲存，並具備在集中位置搜尋與過濾日誌的能力。

2.2. Metrics

服務在執行時捕獲的測量值。

日誌（Logs）非常擅長提供關於個別事件的詳細資訊。然而，有時我們需要掌握系統當前狀態的宏觀概覽（high-level view）。這正是指標（Metrics）派上用場的地方。

指標是透過對一組事件應用統計運算後，所推導出的單一數值。換句話說，指標代表的是一種聚合數據。這非常有價值，因為它們精簡的呈現方式，讓我們能夠將系統隨時間變化的情形繪製成圖表。

因應這些需求，業界開發了用來萃取指標的儀器（instruments）、用來表示與傳輸資料的格式與通訊協定、專門用來儲存資料的時序資料庫（time-series databases），以及讓終端使用者能存取這些資料的前端介面。

2.3. Traces

隨著分散式系統的規模擴大，傳統日誌系統在對複雜問題進行除錯（debug）時，顯然經常感到力有未逮。原因在於，我們往往必須理解系統中一連串事件的脈絡。

在單機環境下，堆疊追蹤（stack traces）讓我們能將例外狀況（exception）追溯回特定的程式碼行數。然而在分散式環境中，我們無法享有這種便利。取而代之的是，我們必須進行大量的過濾，才能定位出我們關注的日誌事件。為了理解整體脈絡（context），我們必須識別其他相關聯的事件，例如觸發該日誌紀錄的特定請求或交易，以及該請求在系統中處理時所涉及的服務或微服務之順序。這通常會導致大量的人工操作（例如比對時間戳記），或者需要對應用程式具備深厚的領域知識。為了正視這個問題，Google 開發了 Dapper，並普及了分散式追蹤（distributed tracing）的概念。

從本質上來說，分散式追蹤就是「強化版」的日誌記錄（logging on steroids）。其核心概念在於為日誌添加交易脈絡（transactional context）。這使得我們能夠推斷因果關係，並還原請求在系統中的完整路徑（journey）。

3. 可觀測性的三大支柱

遙測（Telemetry） 是指從遠端或分散式系統自動收集並傳輸資料的過程，目的是為了監控、測量及追蹤這些系統的效能或狀態。遙測資料提供了關於應用程式各個部分運作情形的即時洞察（real-time insights）。這些數據成為可觀測性工具的基礎，協助開發人員和系統管理員觀察、除錯（troubleshoot）並最佳化系統，而無需手動檢查每一個元件。

從表面上看，Log（日誌）、Metric（指標）和 Trace（追蹤）在其生命週期和組成元件上有許多相似之處。一切都始於 Instrumentation（儀器化/埋點），負責捕捉並發送資料。這些資料必須具備由格式定義的特定結構。接著，我們需要一種機制來收集並轉發這些遙測數據。通常會有某種 Agent（代理程式） 來進一步擴充（enrich）、處理和批次打包資料，然後將其攝入（ingest）後端系統。這個過程通常涉及一個資料庫，以有效地儲存、索引和搜尋大量的資料。最後，會有前端分析介面讓終端使用者能存取這些數據。

然而，在實務上，我們針對每種類型的遙測開發專用系統是有充分理由的：每一種遙測訊號（signal）都帶來了獨特的技術挑戰。這些挑戰主要源於資料本質的不同。

資料模型、交換格式和傳輸協定的設計，高度取決於你處理的是非結構化或半結構化的文字資訊（Logs）、時間序列中緊湊的數值（Metrics），還是描述事件間因果關係的圖狀結構（Traces）。即使是針對單一種訊號，業界在這些議題上也尚未達成共識。

此外，我們如何運用並從遙測中獲取洞察的方式也大相徑庭。一個系統可能需要執行全文檢索、檢查單一事件、分析歷史趨勢、視覺化請求流程、診斷效能瓶頸等等。這些需求具體體現在儲存、存取模式、查詢功能等方面的設計與最佳化上。

當面對這些技術挑戰時，垂直整合（vertical integration） 成為了一種務實的解決方案。在實務中，可觀測性廠商往往將問題範圍縮小到單一訊號，並提供生成資料的 Instrumentation 以及分析遙測的工具，形成一個單一且完全整合的解決方案。

The Three Pillars of Observability: Metrics, Traces and Logs

正因為針對 Logs（日誌）、Metrics（指標）和 Traces（追蹤）擁有各自專用的系統，我們才普遍將它們稱為可觀測性的「三大支柱」。

「支柱」這個概念提供了一個極佳的思考框架（mental framework），因為它強調了以下重點：

遙測資料（telemetry）區分為不同的類別。
每一根支柱都具備其獨特的優勢，且能獨當一面。
這些支柱具有互補性，必須結合在一起，才能構成實現可觀測性的穩固基石。

3.1. 現行可觀測性作法的問題

面對市面上充斥著大量的開源與商用可觀測性解決方案，你可能會（很合理地）問自己：

如果針對 Logs、Metrics 和 Traces 的產生、收集、儲存與分析，都已經有許多成熟的解決方案了，那我為什麼要在意（OpenTelemetry）？
目前的可觀測性現狀到底有什麼問題？
喔，好極了……這該不會又是一次試圖制定標準的嘗試吧？

這些都是合理的問題。為了回答這些問題，我們必須點出在建構與使用那些「基於支柱（pillar-based）」的可觀測性系統時，所衍生出的一些缺點。

3.2. 孤島式的遙測資料難以運用

首先，遙測資料的品質本身存在不足。為了說明這一點，讓我們想像一下我們要調查某個問題的根本原因（root cause）。

問題的第一個徵兆，通常是來自警報，或是指標儀表板（metrics dashboard）上的異常。為了確認該事件值得調查，我們必須先形成初步的假設。目前我們手上唯一的資訊是，在特定時間點發生了某些事情。因此，第一步通常是使用指標系統，去尋找其他在時間上具備關聯性（temporally correlated）且呈現異常行為的指標。

在對問題做出有根據的推測後，我們會希望深入挖掘（drill down）並調查問題的根本原因。為了獲取額外資訊，我們通常會切換到日誌系統（logging system）。在這裡，我們撰寫查詢語法並進行大量的過濾，試圖找出與那些可疑指標相關的日誌事件。

發現感興趣的日誌事件後，我們通常想了解該操作發生當下更廣泛的脈絡（context）。遺憾的是，傳統日誌系統缺乏重建特定交易中事件鏈的機制。傳統日誌系統往往無法捕捉操作的完整脈絡，導致難以將跨越不同服務或元件的事件關聯起來。它們經常缺乏保留關鍵 Metadata（如 Trace ID 或 Span ID）的能力，而這些對於連結相關事件至關重要。這種限制導致了系統行為視角的破碎化，單一操作的「故事」散落在多個日誌中，缺乏清晰的敘事。此外，缺乏標準化的查詢語言或介面，更加深了有效搜尋與分析日誌的難度，因為維運人員必須仰賴客製化腳本或手動過濾，才能發掘出模式與異常。

如果我們將視角從「構建」可觀測性解決方案的人，切換到「使用」它的人，就會發現一種本質上的脫節。真實世界的問題並不是由 Log、Metrics 或 Tracing 構成的。相反地，我們必須在不同類型的遙測數據之間來回切換，以建立心智模型（mental model）並推斷系統的行為。由於可觀測性工具往往是彼此不相連的資料孤島（silos），要釐清資訊片段之間的關聯，會給維運人員帶來巨大的認知負擔（cognitive load）。

3.3. 缺乏 Instrumentation (儀器化) 標準導致資料品質低落

另一個讓根本原因分析（root-cause analysis）變得困難的因素是，遙測資料往往深受「缺乏一致性」所苦。

這導致在不同服務或元件之間關聯（correlating） 事件變得相當困難，因為缺乏標準化的方式來識別相關聯的事件，例如透過 Trace ID 或 Span ID 來串接。

此外，目前也沒有直接了當的方法，能將多個針對特定解決方案（solution-specific）的日誌函式庫，整合到一個連貫的系統中。這最終導致我們對系統行為的觀察變得破碎且脫節。

3.4. 開源軟體缺乏內建 Instrumentation (儀器化)

讓我們從開源軟體開發者的角度來看待這件事。現今，大多數的應用程式都是建構在開源函式庫、框架和獨立元件之上。由於大量的運作都發生在應用程式開發者所撰寫的商業邏輯之外，因此從這些開源元件收集遙測數據（telemetry）至關重要。最了解軟體運作時哪些資訊至關重要的，莫過於開發者與維護者本身。然而，目前缺乏一種透過原生儀器化（native instrumentation） 來傳遞這些資訊的良好方式。

其中一個選項是選用特定可觀測性解決方案的儀器化工具。然而，這會為專案增加額外的相依性（dependencies），並強迫使用者將其整合到自己的系統中。雖然同時運行多套日誌與指標系統雖然不切實際（impractical），但在技術上尚屬可行；然而，分散式追蹤（Tracing）卻是完全不可能的，因為它需要所有人達成共識，採用統一的標準，才能讓 Trace Context 的傳遞（propagation） 順利運作。

電腦科學界解決問題的一個常見策略，就是增加一層間接層（indirection）。與其嵌入特定廠商的儀器化程式碼，開源開發者通常會提供可觀測性的 Hooks。這讓使用者能撰寫轉接器（adapters），將開源元件連接到自己的可觀測性系統。

雖然這種方法提供了較大的彈性，但也伴隨著不少問題。例如，每當軟體推出新版本時，使用者都必須留意並更新他們的轉接器。此外，這種間接層也增加了系統開銷（overhead），因為我們必須在不同的遙測格式之間進行轉換。

3.5. 結合遙測生成與特定方案將導致供應商綁定 (Vendor Lock-in)

讓我們試著戴上終端使用者的帽子（站在使用者的立場）來看待這件事。一旦決定採用某個解決方案，應用程式的程式碼庫（codebase）中就會遍佈著許多針對該特定解決方案的函式庫呼叫（library calls）。

若日後想要轉換到另一個可觀測性工具，我們將被迫把現有所有的儀器化程式碼（instrumentation）連根拔除並替換，同時還得遷移我們的分析工具。這種「重新儀器化（re-instrumentation）」所需的巨大前期成本，使得遷移變得困難重重，而這正是供應商綁定（Vendor Lock-in） 的一種形式。

3.6. 陷入苦戰的可觀測性廠商 / 高聳的進入門檻

這個方程式的最後一個環節，是可觀測性廠商本身。乍看之下，廠商似乎是唯一從現狀中獲利的一方。在過去，高品質的儀器化（instrumentation）是與競爭對手做出市場區隔（differentiation）的絕佳方式。此外，由於為大量既有軟體開發整合介面（integrations）非常昂貴，可觀測性市場具有相對較高的進入門檻（barrier to entry）。

由於客戶對昂貴的「重新儀器化（re-instrumentation）」望之卻步，既有的老牌廠商面臨較少的競爭與創新壓力。然而，他們也正經歷著巨大的痛點。過去十年間，軟體開發的速度呈現指數級成長。現今 異質化（heterogeneous） 的軟體生態，使得要維護針對每一個函式庫、框架和元件的儀器化支援，變得根本不可能。

一旦廠商開始難以提供（特定的）儀器化支援，客戶就會開始拒絕採用他們的產品。結果導致各家解決方案都在競爭誰能打造出最好的「N 對 N 格式轉換器」，而不是將這些資源投入到開發更棒的分析工具上。另一個缺點是，轉換那些由外部來源產生的資料，往往會導致遙測資料品質的劣化（degradation）。一旦資料定義不再明確，分析起來就變得更加困難。

4. 什麼是 OpenTelemetry

OpenTelemetry (OTel) 是一個開源專案，旨在提供標準化的工具和 API，用於生成、收集和匯出追蹤 (Traces)、指標 (Metrics) 和 日誌 (Logs) 等遙測數據。其目的是讓開發人員能深入掌握應用程式的可觀測性，進而協助監控、故障排除以及最佳化軟體系統。

OpenTelemetry 的主要目標包括：

統一的遙測 (Unified telemetry)： 將追蹤、日誌和指標結合至單一框架中，實現所有數據的關聯分析，並建立遙測數據的開放標準。
供應商中立 (Vendor-neutrality)： 可整合不同的後端系統來處理數據（不被特定單一廠商綁定）。
跨平台 (Cross-platform)： 支援多種程式語言（如 Java、Python、Go 等）與平台，使其能靈活適用於各種開發環境。

4.1. OpenTelemetry 不是什麼？

通常透過定義某個事物「不是什麼」，會更有助於理解它的本質。

OpenTelemetry 是：

不是一套多合一 (All-in-One) 的監控或可觀測性工具 OpenTelemetry 不會取代像 Datadog、New Relic 或 Prometheus 這類功能完整的監控或可觀測性平台。相反地，它協助收集並標準化遙測數據（追蹤、指標、日誌），讓您可以將數據發送到這些工具進行視覺化和分析。
不是數據儲存或儀表板 (Dashboarding) 解決方案 OpenTelemetry 本身不負責儲存或視覺化數據。它專注於收集和匯出遙測數據到負責儲存與呈現的外部系統，例如 Grafana、Jaeger 或 Prometheus。
不是預先設定好的監控工具 OpenTelemetry 是一套用於收集和匯出數據的工具組 (Toolkit)，但它需要進行設定並與其他系統整合。它不會自動提供開箱即用 (out-of-the-box) 的監控或告警功能。
不是效能最佳化工具 (Performance Optimizer) 雖然 OpenTelemetry 協助您收集詳細的效能數據，但它不會自動將應用程式效能最佳化。它是一種診斷工具，協助您收集數據洞察，以作為手動調校 (Manual tuning) 的依據。

總結來說： 本質上，OpenTelemetry 是一個針對遙測數據的「整合與標準化工具」，而非監控、日誌記錄或效能管理的多合一解決方案。它透過標準化數據收集流程，來與其他工具相輔相成 (Complements)。

4.2. 為什麼 OpenTelemetry 備受看好？

截至本文撰寫時（2024 年 5 月），OpenTelemetry 是 CNCF（雲端原生運算基金會）中成長速度第二快的專案。OpenTelemetry 之所以獲得如此高度的關注，是因為它有望為我們產生遙測數據的方式帶來根本性的轉變 (Fundamental shift)。

我們必須記住，「可觀測性 (Observability)」還是一個相當年輕的領域。在過去，快速的創新步調以及（廠商間的）利益衝突 (Conflicts of interest)，阻礙了我們為遙測數據制定出一套廣泛採用的標準。然而，憑藉著 OpenTelemetry 目前的時機點與發展動能 (Momentum)，看來確實有極大的機會能推動遙測數據通用面向的標準化。

4.3. OpenTelemetry 的優勢

一次儀器化，隨處可用 (Instrument once, use everywhere) OpenTelemetry 的一個關鍵承諾是，您只需對程式碼進行一次 儀器化 (Instrument)，之後便不再需要重複進行，並能在任何地方使用該儀器化結果。OpenTelemetry 體認到，若要成功，它必須成為許多軟體專案的核心依賴 (Dependency)。因此，它遵循嚴格的流程以提供長期的穩定性保證。一旦某個訊號 (Signal) 被宣告為穩定版本 (Stable)，其承諾是客戶端將永遠不會遇到破壞性的 API 變更 (Breaking API change)。
將遙測數據的「生成」與「分析」分離 OpenTelemetry 的另一個核心概念是，將產生遙測數據的機制，與分析數據的系統分開。這種開放且不依賴特定供應商 (Vendor-agnostic) 的儀器化方式，標誌著可觀測性產業的根本變革。供應商不再需要投入大量資源開發專有的儀器化工具並維持其更新，而是必須透過功能豐富且易用性極佳的分析平台來做出市場區隔。OpenTelemetry 促進了競爭，因為使用者不再被開發期間選擇的可觀測性解決方案綁死 (Lock-in)。切換到 OpenTelemetry 後，您可以更換平台，而無需重新對整個系統進行儀器化。
讓軟體預設即具備可觀測性 (Make software observable by default) 藉由 OpenTelemetry，開源開發者可以在專案中加入原生的儀器化功能，而無需引入會造成使用者負擔的廠商特定程式碼。其概念是讓「可觀測性」在開發階段就成為一等公民 (First-class citizen)。透過軟體出廠時即內建儀器化功能，我們不再需要於事後 (After the fact) 透過複雜的機制來擷取和整合數據。
改善我們使用遙測數據的方式最後（但絕對同樣重要），OpenTelemetry 試圖改變我們思考和使用遙測數據的方式。OpenTelemetry 摒棄了將日誌、指標和追蹤視為三個獨立孤島 (Silos) 的做法，而是採用將遙測訊號相互連結的典範。隨著上下文 (Context) 在訊號之間建立起接觸點，遙測數據的整體價值與易用性將大幅提升。例如，想像一下能夠直接從儀表板上顯著的統計數據，跳轉到相關聯的日誌中。互相關聯的遙測數據有助於降低維運複雜系統的人員的認知負荷 (Cognitive load)。能夠利用這些連結數據，將標誌著新一代可觀測性工具的誕生。

5. 本章總結

在本章中，我們涵蓋了 工作負載與資源分析（Workload and resource analysis） 的核心概念，為您在監控與優化現代應用程式時所需的術語打下基礎。我們強調了 可觀測性（Observability） 的重要性，以及它在了解分散式系統健康狀況與效能方面所扮演的關鍵角色。

您現在已經了解可觀測性的三大支柱——日誌（Logs）、指標（Metrics）與追蹤（Traces）——以及它們如何各自發揮獨特作用，以提供系統行為的完整視野。本章也點出了現代化、多語言開發（Polyglot）及分散式應用程式所帶來的挑戰，例如日益增加的複雜度，以及難以跨多種服務來關聯 遙測資料（Telemetry data） 的問題。

我們探討了 OpenTelemetry 是什麼——它是一個 供應商中立（Vendor-neutral） 的開源工具，用於收集與標準化遙測資料——並釐清了它「不是」什麼。我們特別強調 OpenTelemetry 並非一個一站式的可觀測性平台，而是一個強大的整合與資料收集工具。

最後，我們檢視了 OpenTelemetry 如何透過提供一種統一的方式，以高度適應性且跨平台的手法來收集追蹤、指標與日誌，從而解決傳統可觀測性解決方案的局限性。

6. 小試身手

問題 1

下列哪一項敘述最能貼切地描述可觀測性的三大支柱——指標 (Metrics)、日誌 (Logs) 與 追蹤 (Traces)——如何各自協助我們理解系統的行為？

A. 指標 (Metrics) 提供個別錯誤的詳細解釋，日誌 (Logs) 總結整體效能，而追蹤 (Traces) 則記錄每個請求完成所需的時間。

B. 追蹤 (Traces) 記錄即時 CPU 使用率，日誌 (Logs) 顯示效能趨勢，而指標 (Metrics) 則記錄請求在系統中的完整歷程。

C. 指標 (Metrics) 與追蹤 (Traces) 用於記錄使用者行為，而日誌 (Logs) 則監控伺服器效能與錯誤。

D. 日誌 (Logs) 捕捉用於故障排除的歷史資料，指標 (Metrics) 追蹤隨時間變化的系統效能，而追蹤 (Traces) 則跟隨請求在分散式系統中的路徑，以精準定位延遲或故障發生的位置。

here is why:

Logs (日誌)：紀錄發生了什麼事 (What happened? - 歷史事件)
Metrics (指標)：紀錄系統狀態與趨勢 (Is it healthy? - 數值與趨勢)
Traces (追蹤)：紀錄請求的路徑與因果關係 (Where is the latency? - 分散式路徑)

問題 2

OpenTelemetry 是什麼？

A. OpenTelemetry 是一個針對分散式系統的完整監控與告警平台。

B. OpenTelemetry 是一個針對遙測資料（日誌、指標與追蹤）的資料收集工具，並可與可觀測性平台進行整合。

C. OpenTelemetry 是一個特定供應商專用的工具，用於在微服務環境中收集指標。

D. OpenTelemetry 會自動最佳化（Optimize）分散式應用程式的效能。

here is why:

OpenTelemetry 專注於產生與收集資料（Telemetry），它本身不負責儲存資料後的分析與告警（那是 Backend 平台的工作，所以 A 錯）。
它是供應商中立 (Vendor-neutral) 的，所以 C 錯。
它是用來觀察系統的，而非主動去修改或優化系統效能，所以 D 錯。

問題 3

OpenTelemetry 是一個預先設定好（Pre-configured）的監控工具，用於收集與匯出資料。

正確還是錯誤？

A. 正確 (True)

B. 錯誤 (False)

here is why:

OpenTelemetry 是一套用於收集與匯出資料的工具組，但它需要經過設定並與其他系統進行整合。它並不自動提供開箱即用（out-of-the-box）的監控或告警功能。

問題 4

情境

貴公司的 Web 應用程式正面臨回應速度變慢的問題，但該系統是由多個微服務 (Microservices) 所建構。每個服務都會產生自己的日誌 (Logs)、指標 (Metrics) 和追蹤 (Traces)，但這些資料皆各自獨立儲存，缺乏跨所有服務的統一視圖 (Unified view)。

問題

在嘗試找出並修復此問題時，您最可能面臨的主要挑戰是什麼？

A. 來自每個服務的資料會發生衝突，導致無法採信任何日誌或指標。

B. 當偵測到效能問題時，每個服務會停止產生日誌，導致無法進行故障排除。

C. 難以將跨服務的資訊進行關聯 (Correlate)，這使得難以追蹤請求的流向，或無法精準定位 (Pinpoint)問題發生的位置。

D. 您將無法同時存取所有服務的日誌，導致在識別根本原因 (Root cause) 時產生延遲。

here is why:

A: 資料通常不會衝突，只是分散而已。
B: 系統通常不會因為效能差就停止寫 Log（反而可能寫更多錯誤 Log）。
C: 遙測資料孤島化 (Siloed telemetry) 意指日誌、指標與追蹤是針對個別服務分開儲存的，這使得難以看清請求在系統中流動的完整全貌。這種缺乏整合的情況，會導致在識別效能問題或錯誤時，增加複雜度並造成延誤。
D: 「無法同時存取」通常是指權限或工具介面問題，但在這個情境下，真正的痛點不是「讀不到」，而是讀到了卻「看不出彼此的關係」。

OpenTelemetry 框架概述

Tue, 16 Dec 2025 19:41:46 +0800

0. Preface

本篇文章是翻譯 Getting Started with OpenTelemetry (LFS148) 的第三章節，想看原文可參考以下網址：

https://training.linuxfoundation.org/training/getting-started-with-opentelemetry-lfs148/#

1. 學習目標在本章結束後，您應該能夠：

解釋 OpenTelemetry 訊號規範 (Signal Specification) 的目的，以及它如何確保跨語言和跨平台的一致性。
描述 OTel SDK 和 API 規範，以及語意約定 (Semantic Conventions)。
探討供應商中立 (Vendor-Agnostic) 的儀表化 (Instrumentation) 概念，重點在於 OpenTelemetry 如何提供針對特定語言的儀表化功能，包含不同的儀表化層級。
解釋 OpenTelemetry Collector 作為遙測數據處理器 (Telemetry Processor) 的角色，以及它如何協助處理與匯出遙測數據。
探討 OTLP (OpenTelemetry Protocol)，說明其作為傳輸遙測數據之傳輸協定 (Wire Protocol) 的重要性，以及其在標準化不同元件間通訊的角色。

2. Signal Specification 訊號規範 (Language-Agnostic / 跨語言通用)

從宏觀角度來看，OpenTelemetry 是由各種 訊號 (Signals) 所組成的，主要包含 Tracing (追蹤)、Metrics (指標) 和 Logging (日誌)。每一個訊號都是作為獨立的元件進行開發（但仍有方法可以將彼此的資料流串接起來）。

這些訊號都被定義在 OpenTelemetry 的「跨語言規範 (Language-Agnostic Specification)」中，這也是整個專案的核心所在。雖然終端使用者 (End-user) 可能不會直接接觸到這份規範，但它對於確保 OpenTelemetry 生態系中的一致性 (Consistency) 與互通性 (Interoperability) 扮演著至關重要的角色。

OpenTelemetry Specification (Language Agnostic)

這份規範主要由三個部分組成。首先是術語定義，旨在建立共同的詞彙與認知，以避免混淆。其次，它詳述了每個訊號的技術設計細節。這包含：

API 規範 (請參閱 Tracing API, Metrics API 和 OpenTelemetry Logging)
- 定義實作 (Implementations) 必須遵守的（概念性）介面。
- 確保各個實作之間彼此相容。
- 包含可用於產生、處理及匯出遙測數據 (Telemetry data) 的方法。
SDK 規範 (請參閱 Tracing SDK, Metrics SDK, Logs SDK)
- 作為開發人員的指引。
- 定義特定語言的 API 實作必須滿足哪些需求才能符合標準 (Compliant)。
- 包含關於遙測數據的設定 (Configuration)、處理和匯出的相關概念。

除了訊號架構之外，該規範也涵蓋了與遙測數據相關的面向。例如，OpenTelemetry 定義了 語意約定 (Semantic Conventions)。透過推動通用遙測 Metadata 在命名與解釋上的一致性，OpenTelemetry 旨在減少對來自不同來源的數據進行「正規化 (Normalize)」的需求。

最後，規範中還包含了 OpenTelemetry Protocol (OTLP)，我們將在本章稍後進行探討。

3. 供應商中立、針對特定語言的儀表化 (Instrumentation)

Generate and Emit Telemetry via the OTel API and SDK Packages

為了從應用程式中產生並發送遙測數據 (Telemetry)，我們使用遵循 OpenTelemetry 規範的「特定語言實作 (Language-specific implementations)」。OpenTelemetry 支援多種熱門的程式語言，且各語言的支援成熟度 (Maturity) 亦有所不同。一個訊號 (Signal) 的實作包含兩個部分：

API
- 定義規範中列出的介面 (Interfaces) 與常數。
- 供應用程式與函式庫開發者使用，以進行供應商中立 (Vendor-agnostic) 的儀表化。
- 預設指向一個「無操作 (no-op)」的實作（即呼叫後不會執行任何動作）。
SDK
- 實作了 OpenTelemetry API 的提供者 (Provider)。
- 包含產生、處理並發送遙測數據的實際邏輯。
- OpenTelemetry 隨附了官方提供者作為「參考實作 (Reference Implementation)」（通常直接稱為 SDK）。
- 您也可以自行撰寫 SDK。

一般來說，我們使用 OpenTelemetry API 將儀表化功能加入原始碼中。實際上，這可以透過多種方式達成，例如：

零程式碼 (Zero-code) 或自動儀表化 (Automatic Instrumentation)（若可用，且為了避免修改程式碼）。
儀表化函式庫 (Instrumentation Libraries) 提供簡化版 OpenTelemetry 整合的函式庫（可能需要或不需要修改程式碼）。
手動或基於程式碼的儀表化 (Manual Instrumentation)（為了精細的控制，並深度嵌入程式碼中）。

目前我們先跳過細節，專注於為何 OpenTelemetry 決定將 API 與 SDK 分離。在啟動時，應用程式會為每種類型的訊號註冊一個提供者 (Provider)。之後，對 API 的呼叫會被轉送 (Forwarded) 給相應的提供者。如果我們沒有明確註冊，OpenTelemetry 將使用一個備援 (Fallback) 提供者，將 API 呼叫轉換為無操作 (no-ops)。

將 API 與 SDK 分離的主要原因，是為了讓開源函式庫更容易嵌入原生儀表化 (Native Instrumentation) 功能。OpenTelemetry 的 API 被設計為輕量級且可安全依賴 (Safe to depend on)。相對地，由 SDK 提供的訊號實作則明顯複雜許多，且很可能包含對其他軟體的依賴 (Dependencies)。若強制使用者接受這些依賴，可能會導致與其特定的軟體環境 (Software stack) 發生衝突。

透過在初始設定期間註冊提供者，允許使用者藉由選擇不同的實作來解決依賴衝突。此外，這讓我們能發布內建可觀測性 (Observability) 的軟體，而不會將儀表化的執行成本 (Runtime cost) 強加給不需要的使用者。

4. 遙測數據處理器（獨立元件）Telemetry Processor (Standalone Component)

到目前為止，我們已經看到 OpenTelemetry 為應用程式與函式庫開發者提供了供應商中立 (Vendor-agnostic) 的儀表化工具。光是這一點就是一個重大的里程碑，但 OpenTelemetry 框架所涵蓋的範圍不僅止於此。

在產生並發送遙測數據 (Telemetry) 後，維運人員 (Operators) 負責管理這些數據，並將其攝取 (Ingest) 到各自的後端系統中。這包含了以下任務：

從各種來源收集數據。
解析數據並進行轉換，以供下游處理。
使用額外的 Metadata 進行豐富化 (Enrichment)。
過濾掉不相關的數據，以減少雜訊並降低儲存需求。
進行正規化 (Normalization) 並套用轉換。
進行緩衝 (Buffering) 以提升韌性 (Resilience) 與效能。
進行路由 (Routing)，將部分遙測數據引導至不同的目的地。
轉送至後端系統。

為了建構並設定這類遙測數據管線 (Pipelines)，維運團隊通常會部署額外的基礎設施。一個常見的例子是 fluentbit 遙測代理程式 (Agent)。同樣地，OpenTelemetry 提供了一個具備這些能力的獨立元件：OpenTelemetry Collector。

5. 傳輸協定 (Wire Protocol)

為了完善標準化、數據產生及管理的整套方案，OpenTelemetry 也定義了如何在生產者 (Producers)、代理程式 (Agents) 和後端 (Backends) 之間傳輸遙測數據。

OpenTelemetry Protocol (OTLP) 是一個開源且供應商中立 (Vendor-neutral) 的傳輸格式 (Wire format)，它定義了：

數據如何在記憶體中被編碼。
用於在網路上傳輸該數據的協定。

因此，OTLP 被廣泛應用於整個可觀測性堆疊 (Observability stack) 中。以 OTLP 格式發送遙測數據，意味著已儀表化 (Instrumented) 的應用程式與第三方服務，能與無數的可觀測性解決方案相容。

雖然 Collector 支援接收來自各種格式的遙測數據，也能匯出成各種格式（例如：Prometheus Metrics, Zipkin traces 等），但通常會優先選擇 OTLP，因為 Collector 內部正是使用 OTLP 來表示與處理遙測數據。藉此，我們避免了格式轉換的成本，並提升了一致性。這是因為該原生格式與框架提出的理念緊密契合（例如屬性遵循語意約定、跨訊號關聯等）。

同樣地，大多數可觀測性後端都開箱即用 (Right out of the box) 地支援 OTLP。鑑於 OpenTelemetry 的快速普及，整合 OTLP 能讓你自動觸及廣大的潛在使用者群體。此外，一個開源且供應商中立的遙測協定，意味著可觀測性工具開發者的工作量更少。以前，你必須開發無數的轉接器 (Adapters)，才能攝取 (Ingest) 以各種專有格式 (Proprietary formats) 傳來的數據。換句話說，OTLP 大力推動了可觀測性生態系中工具與服務間的互通性 (Interoperability)。

OTLP 提供了三種用於傳輸遙測數據的傳輸機制：HTTP/1.1、HTTP/2 和 gRPC。使用 OTLP 時，傳輸機制的選擇取決於應用程式需求，需考量效能、可靠性與安全性等因素。

OTLP 數據通常使用 Protocol Buffers (Protobuf) 二進位格式進行編碼，該格式精簡且網路傳輸效率高，並支援模式演進 (Schema Evolution)，允許在不破壞相容性的情況下修改未來的資料模型。數據也可以編碼為 JSON 格式，這提供了人類可讀 (Human-readable) 的格式，但缺點是網路流量較高且檔案較大。

6. 章節總結

在本章中，我們探討了 OpenTelemetry 框架的關鍵元件，涵蓋了它如何提供一種統一的方法來收集與傳輸遙測數據 (Telemetry data)。

我們首先探討了 訊號規範 (Signal Specification)，它是跨語言通用 (Language-agnostic) 的，確保了在不同平台與語言之間，定義和收集遙測數據（Log、Metric、Trace）的一致性。

接著，我們討論了 供應商中立的儀表化 (Vendor-Agnostic Instrumentation)，強調 OpenTelemetry 如何在特定程式語言中實現遙測數據的收集，同時保持獨立性，不被任何特定供應商的可觀測性工具組所綁定。

隨後，我們檢視了 OpenTelemetry Collector 作為遙測數據處理器 (Telemetry Processor) 的角色，詳細說明它如何處理、轉換並匯出遙測數據至各種後端 (Backends)，讓管理可觀測性數據管線 (Pipelines) 更具彈性。

此外，我們介紹了 OTLP (OpenTelemetry Protocol)，它標準化了整個系統中的遙測數據傳輸，確保不同元件之間能有可靠的通訊。

最後，我們提及了 OTel SDK 與 API 規範的重要性，它們定義了開發者如何與 OpenTelemetry 互動；以及 語意約定 (Semantic Conventions)，它為遙測數據提供一致的標籤 (Labeling) 與結構，提升了所收集資訊的清晰度與實用性。

7. 小試身手

問題 1

OpenTelemetry 訊號規範 (Signal Specification) 的目的是什麼？

A. 指定使用 OpenTelemetry 的供應商需求 (Vendor requirements)

B. 定義針對特定語言 (Language-specific) 的 Tracing (追蹤) 協定

C. 提供一種一致且跨語言通用 (Language-agnostic) 的遙測數據收集方法

D. 建立自定義訊號以監控網路流量

here is why:

跨語言通用 (Language-Agnostic)：本文中明確提到「Signals are defined inside OpenTelemetry’s language-agnostic specification（訊號定義在 OpenTelemetry 的跨語言規範中）」。這表示規範本身不綁定特定語言，而是作為一個通用的標準，讓各種程式語言（如 Java, Python, Go）的實作去遵循。
一致性 (Consistency)：本文中提到該規範的角色是「ensuring consistency and interoperability（確保一致性與互通性）」。這正是選項 c 中提到的重點。

為什麼其他選項不正確？

A. 指定使用 OpenTelemetry 的供應商需求：OpenTelemetry 的核心原則是「供應商中立 (Vendor-Agnostic)」，目的是不被特定廠商綁定，而不是為了制定廠商的需求。
B. 定義針對特定語言的 Tracing 協定：規範本身是跨語言通用 (Language-Agnostic) 的，而不是針對特定語言 (Language-specific)。「特定語言」的部分是在 SDK 實作層面，而非核心規範層面。
D. 建立自定義訊號以監控網路流量：雖然 OpenTelemetry 可以用於監控，但訊號規範的主要目的在於定義標準的三大訊號（Tracing, Metrics, Logging），而非專注於建立「監控網路流量的自定義訊號」。

問題 2

OpenTelemetry 中的供應商中立儀表化 (Vendor-Agnostic Instrumentation) 如何讓開發者受益？

A. 它確保所有儀表化都在應用程式層級 (Application level) 處理 B. 它支援跨不同程式語言的自動 (Automatic) 與手動 (Manual) 儀表化 C. 它將儀表化僅限於高階效能指標 D. 它提供針對各家雲端供應商 (Cloud Provider) 的預建儀表化功能

here is why:

根據前文「Vendor-Agnostic, Language-Specific Instrumentation」章節的內容：

支援多種模式：文中明確提到儀表化可以透過「零程式碼或自動儀表化 (zero-code or automatic instrumentation)」以及「手動或基於程式碼的儀表化 (manual or code-based instrumentation)」來達成。
跨語言支援：文中提到 OTel 支援「廣泛的熱門程式語言 (wide-range of popular programming languages)」。
供應商中立：選項 D 提到「針對特定雲端供應商」，這與 Vendor-Agnostic（不被廠商綁定）的核心精神相違背。OTel 的目的是讓你的程式碼不依賴特定廠商的 SDK。

問題 3

OpenTelemetry 中的語意約定 (Semantic Conventions) 是什麼？

A. 用於透過網際網路傳輸遙測數據的預定義格式 B. 僅用於 OpenTelemetry 日誌中的自定義命名慣例 C. 一種透過機器學習演算法處理追蹤 (Traces) 的方法 D. 一套用於一致地組織與標記 (Labeling) 遙測數據的規則

根據前文「Signal Specification」章節的內容：

定義與目的：文中提到 OpenTelemetry 定義語意約定是為了推動「通用遙測 Metadata 在命名與解釋上的一致性 (consistency in the naming and interpretation of common telemetry metadata)」。
減少正規化需求：透過這些規則，目的是減少對來自不同來源的數據進行正規化的需求，讓數據結構標準化。

為什麼其他選項不正確？

A. 傳輸格式：這是 OTLP (OpenTelemetry Protocol) 的功能，屬於傳輸協定 (Wire Protocol) 的範疇。
B. 僅用於日誌：語意約定適用於所有訊號（Tracing, Metrics 和 Logging），並非僅限於日誌。
C. 機器學習：這與語意約定的定義完全無關。

Installing the Red Hat build of OpenTelemetry by using the CLI

Thu, 18 Sep 2025 12:23:02 +0800

可以從命令列安裝 Red Hat 版的 OpenTelemetry。

1. 本篇文章 Openshift 環境資訊

Openshift version: 4.18.22

1. 先決條件

具備 cluster-admin 角色的叢集管理員，且已啟用 OpenShift CLI（oc）的工作階段。

2. 開始安裝 Red Hat 版 OpenTelemetry Operator：

執行下列指令，為 Red Hat 版 OpenTelemetry Operator 建立專案：

oc apply -f - << EOF
apiVersion: project.openshift.io/v1
kind: Project
metadata:
labels:
kubernetes.io/metadata.name: openshift-opentelemetry-operator
openshift.io/cluster-monitoring: "true"
name: openshift-opentelemetry-operator
EOF

執行下列指令，建立 OperatorGroup：

oc apply -f - << EOF
apiVersion: operators.coreos.com/v1
kind: OperatorGroup
metadata:
name: openshift-opentelemetry-operator
namespace: openshift-opentelemetry-operator
spec:
upgradeStrategy: Default
EOF

執行下列指令，建立 Subscription：

oc apply -f - << EOF
apiVersion: operators.coreos.com/v1alpha1
kind: Subscription
metadata:
name: opentelemetry-product
namespace: openshift-opentelemetry-operator
spec:
channel: stable
installPlanApproval: Automatic
name: opentelemetry-product
source: cs-redhat-operator-index
sourceNamespace: openshift-marketplace
EOF

執行下列指令，檢查該 Operator 的狀態：

oc get csv -n openshift-opentelemetry-operator

執行結果 :

NAME DISPLAY VERSION REPLACES PHASE
opentelemetry-operator.v0.127.0-2 Red Hat build of OpenTelemetry 0.127.0-2 opentelemetry-operator.v0.127.0-1 Succeeded

3. 建立的 OpenTelemetry Collector instance，建立一個您選擇的允許專案（permitted project）：

若要建立不含 metadata 的專案，請執行下列指令：
```
oc new-project opentelemetry
```
若要建立包含 metadata 的專案，請執行下列指令：
```
oc apply -f - << EOF
apiVersion: project.openshift.io/v1
kind: Project
metadata:
name: opentelemetry
EOF
```
備註

可以在同一個叢集上的不同專案中，建立多個 OpenTelemetry Collector instance 。

建立與切換工作目錄

mkdir -p "${HOME}"/wulin/openTelemetr;
cd "${HOME}"/wulin/openTelemetr

自訂 OpenTelemetryCollector 自訂資源 (CR)

nano openTelemetryCollector.yaml

檔案內容如下:

apiVersion: opentelemetry.io/v1beta1
kind: OpenTelemetryCollector
metadata:
name: otel
namespace: opentelemetry
spec:
mode: deployment
config:
receivers:
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
http:
endpoint: 0.0.0.0:4318
processors:
batch:
send_batch_size: 10000
timeout: 10s
memory_limiter:
check_interval: 1s
limit_percentage: 50
spike_limit_percentage: 30
exporters:
debug: {}
service:
pipelines:
traces:
receivers: [otlp]
processors: [memory_limiter,batch]
exporters: [debug]

為 OpenTelemetryCollector 部署所選擇的project。不允許使用 openshift- 前綴開頭的 project 名稱。

請執行以下指令以建立自訂後的 CR：

oc -n opentelemetry apply -f openTelemetryCollector.yaml

請執行以下指令，以驗證 OpenTelemetry Collector Pod 的 status.phase 為 Running，且其條件的 type 為 Ready：

oc -n opentelemetry get pod \
-l app.kubernetes.io/managed-by=opentelemetry-operator,app.kubernetes.io/instance=opentelemetry.otel \
-o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.phase}{"\t"}{.status.conditions[?(@.type=="Ready")].status}{"\n"}{end}'

執行結果 :

otel-collector-75bfc8d889-4klkq Running True

請執行以下指令以取得 OpenTelemetry Collector 服務：

oc -n opentelemetry get service \
-l app.kubernetes.io/managed-by=opentelemetry-operator,app.kubernetes.io/instance=opentelemetry.otel

執行結果 :

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
otel-collector ClusterIP 10.98.50.143 <none> 14250/TCP,14268/TCP,6831/UDP,6832/UDP,9411/TCP 3m51s
otel-collector-headless ClusterIP None <none> 14250/TCP,14268/TCP,6831/UDP,6832/UDP,9411/TCP 3m51s
otel-collector-monitoring ClusterIP 10.98.180.38 <none> 8888/TCP 3m51s

自動建立所需的 RBAC 資源

某些收集器 (Collector) 元件需要設定 RBAC 資源。

將下列權限新增至 opentelemetry-operator-controller-manage 服務帳戶，如此一來 Red Hat build of OpenTelemetry Operator 就能自動建立它們：

oc apply -f - << EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: generate-processors-rbac
rules:
- apiGroups:
- rbac.authorization.k8s.io
resources:
- clusterrolebindings
- clusterroles
verbs:
- create
- delete
- get
- list
- patch
- update
- watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: generate-processors-rbac
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: generate-processors-rbac
subjects:
- kind: ServiceAccount
name: opentelemetry-operator-controller-manager
namespace: openshift-opentelemetry-operator
EOF

Get started with OpenTelemetry in Java

Thu, 18 Sep 2025 02:05:24 +0800

0. Preface

本頁面將說明如何在 Java 中開始使用 OpenTelemetry。

您將學習如何自動檢測 (instrument) 一個簡單的 Java 應用程式，使其能夠將追蹤 (trace)、指標 (metric) 與日誌 (log) 輸出到主控台。

1. 先決條件

由於使用 Spring Boot 3，因此需要 Java JDK 17+；否則需要 Java 8+
Gradle 8.14

2. 範例應用

下列範例使用了一個基本的 Spring Boot 網站應用程式。

依賴套件

首先，請在一個名為 java-simple 的新目錄中設定環境。

mkdir -p "${HOME}"/wulin/java-simple; cd "${HOME}"/wulin/java-simple

在該目錄中，建立一個名為 build.gradle.kts 的檔案，其內容如下：

nano build.gradle.kts

執行結果：

plugins {
 id("java")
 id("org.springframework.boot") version "3.0.6"
 id("io.spring.dependency-management") version "1.1.0"
}

sourceSets {
 main {
 java.setSrcDirs(setOf("."))
 }
}

repositories {
 mavenCentral()
}

dependencies {
 implementation("org.springframework.boot:spring-boot-starter-web")
}

建立一個名為 DiceApplication.java 的文件，並將以下程式碼新增至該文件：

nano DiceApplication.java

執行結果：

package otel;

import org.springframework.boot.Banner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DiceApplication {
 public static void main(String[] args) {
 SpringApplication app = new SpringApplication(DiceApplication.class);
 app.setBannerMode(Banner.Mode.OFF);
 app.run(args);
 }
}

建立另一個名為 RollController.java 的文件，並將以下程式碼新增至該文件：

nano RollController.java

執行結果：

package otel;

import java.util.Optional;
import java.util.concurrent.ThreadLocalRandom;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RollController {
 private static final Logger logger = LoggerFactory.getLogger(RollController.class);

 @GetMapping("/rolldice")
 public String index(@RequestParam("player") Optional<String> player) {
 int result = this.getRandomNumber(1, 6);
 if (player.isPresent()) {
 logger.info("{} is rolling the dice: {}", player.get(), result);
 } else {
 logger.info("Anonymous player is rolling the dice: {}", result);
 }
 return Integer.toString(result);
 }

 public int getRandomNumber(int min, int max) {
 return ThreadLocalRandom.current().nextInt(min, max + 1);
 }
}

請使用下列指令來建置並執行應用程式

gradle assemble
java -jar ./build/libs/java-simple.jar

透過網路存取 http://localhost:8080/rolldice，以確保它能正常運作
```
curl http://localhost:8080/rolldice; echo
```
執行結果：
```
6
```
按 Ctrl + c 停止網站應用程序

將以上步驟 1 ~ 5 寫進 Dockerfile

nano Dockerfile-v2-nonroot

檔案內容如下：

FROM registry.suse.com/bci/bci-base:15.7 AS useradder
 ARG user
 RUN groupadd $user && \
 useradd -m -d /home/$user -g $user $user

FROM docker.io/library/gradle:8.14.3-jdk17-alpine AS build
 ARG user
 COPY --from=useradder /etc/passwd /etc/passwd
 COPY --from=useradder /etc/group /etc/group
 COPY --from=useradder /etc/shadow /etc/shadow
 COPY --from=useradder /home/$user /home/$user

 COPY build.gradle.kts DiceApplication.java RollController.java /java-simple
 WORKDIR /java-simple
 RUN chown -R $user:$user /java-simple && \
 gradle assemble
 USER $user

FROM registry.suse.com/bci/openjdk:17
 ARG user
 COPY --from=useradder /etc/passwd /etc/passwd
 COPY --from=useradder /etc/group /etc/group
 COPY --from=useradder /etc/shadow /etc/shadow
 COPY --from=useradder /home/$user /home/$user

 RUN mkdir /app
 WORKDIR /app
 COPY --from=build --chown=$user:$user /java-simple/build/libs/java-simple.jar /app/java-simple.jar
 USER $user
 EXPOSE 8080
 ENTRYPOINT ["java", "-jar", "/app/java-simple.jar"]

製作 image

podman build --no-cache \
--squash-all \
--build-arg user=bigred \
-t java-simple:v2-nonroot \
-f Dockerfile-v2-nonroot

Run java app container 測試是否符合預期

podman run -d \
--name java-simple \
-p 9999:8080 \
localhost/java-simple:v2-nonroot

檢視 app container 運作狀態

podman ps -a --filter name=java-simple

正確執行結果：

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
3c1739039eed localhost/java-simple:v2-nonroot 14 minutes ago Up 14 minutes 0.0.0.0:9999->8080/tcp java-simple

透過網路存取 http://192.168.11.21:9999/rolldice，以確保它能正常運作
```
curl http://192.168.11.21:9999/rolldice; echo
```
執行結果：
```
2
```
移除 java app container
```
podman rm -f java-simple
```

3. Instrumentation

接下來，您將使用 Java 代理程式 (Java agent)，在應用程式啟動時自動為其進行 instrument。雖然設定 Java 代理程式的方式有很多種，但以下步驟將採用環境變數來完成。

請從 opentelemetry-java-instrumentation 儲存庫 (repository) 的 Releases 頁面下載 opentelemetry-javaagent.jar。這個 JAR 檔案包含了代理程式 (agent) 以及所有 automatic instrumentation 所需的套件：
```
curl -L -O https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar
```
請設定並匯出用於指定 Java 代理程式（Java agent）JAR 檔與主控台匯出器（console exporter）的環境變數。請使用適合您 shell／終端機環境的語法——我們將示範適用於 bash 系列 shell 的語法：
```
export JAVA_TOOL_OPTIONS="-javaagent:$(pwd)/opentelemetry-javaagent.jar" \
OTEL_TRACES_EXPORTER=logging \
OTEL_METRICS_EXPORTER=logging \
OTEL_LOGS_EXPORTER=logging \
OTEL_METRIC_EXPORT_INTERVAL=15000
```
重要
- 請注意上述範例中的 $(pwd)/opentelemetry-javaagent.jar 替換為您存放 JAR 檔的實際路徑。
- 只有在測試時，才將 OTEL_METRIC_EXPORT_INTERVAL 的值設定得遠低於預設值（如上所示），這能幫助您更快地確認指標（metrics）是否已正確產生。
再次執行您的應用程式
```
java -jar ./build/libs/java-simple.jar
```
從另一個終端，使用 curl 發送請求
```
curl http://localhost:8080/rolldice; echo
```
按 Ctrl + c 停止網站應用程序

在步驟 4，您應該會看到來自伺服器和用戶端的追蹤 (trace) 與日誌 (log) 輸出，內容大致如下 (為方便閱讀，追蹤輸出內容已自動換行)：

2025-09-17T07:47:41.594Z INFO 'Anonymous player is rolling the dice: 6' : 0a4494bc657323e1cfc1bd2ca0f1fb9b 01edf287800f72ee [scopeInfo: otel.RollController:] {}
2025-09-17T15:47:41.594+08:00 INFO 22570 --- [io-8080-exec-10] otel.RollController : Anonymous player is rolling the dice: 6
[otel.javaagent 2025-09-17 15:47:41:595 +0800] [http-nio-8080-exec-10] INFO io.opentelemetry.exporter.logging.LoggingSpanExporter - 'GET /rolldice' : 0a4494bc657323e1cfc1bd2ca0f1fb9b 01edf287800f72ee SERVER [tracer: io.opentelemetry.tomcat-10.0:2.20.0-alpha] AttributesMap{data={http.route=/rolldice, http.request.method=GET, url.path=/rolldice, server.address=localhost, client.address=0:0:0:0:0:0:0:1, network.peer.address=0:0:0:0:0:0:0:1, network.peer.port=58634, network.protocol.version=1.1, thread.id=33, http.response.status_code=200, user_agent.original=curl/7.76.1, server.port=8080, url.scheme=http, thread.name=http-nio-8080-exec-10}, capacity=128, totalAddedValues=14}

在步驟 5，當停止伺服器時，您應該會看到所有已收集指標 (metrics) 的輸出 (為方便閱讀，指標輸出內容已自動換行並經過簡化)：

[otel.javaagent 2025-09-17 17:03:02:686 +0800] [Thread-0] INFO io.opentelemetry.exporter.logging.LoggingMetricExporter - Received a collection of 2 metrics for export.
[otel.javaagent 2025-09-17 17:03:02:686 +0800] [Thread-0] INFO io.opentelemetry.exporter.logging.LoggingMetricExporter - metric: ImmutableMetricData{resource=Resource{schemaUrl=https://opentelemetry.io/schemas/1.24.0, attributes={container.id="1c59603168a7210a0d1f7edadc57129fcd3788da67ddbb0dad0ffd99def32bd2", host.arch="amd64", host.name="bastion.topgun.kubeantony.com", os.description="Linux 5.14.0-570.44.1.el9_6.x86_64", os.type="linux", process.command_args=[/usr/lib/jvm/java-17-openjdk-17.0.16.0.8-2.el9.x86_64/bin/java, -jar, ./build/libs/java-simple.jar], process.executable.path="/usr/lib/jvm/java-17-openjdk-17.0.16.0.8-2.el9.x86_64/bin/java", process.pid=23849, process.runtime.description="Red Hat, Inc. OpenJDK 64-Bit Server VM 17.0.16+8-LTS", process.runtime.name="OpenJDK Runtime Environment", process.runtime.version="17.0.16+8-LTS", service.instance.id="12b46158-6949-48ee-b8b6-54aff876afaa", service.name="java-simple", telemetry.distro.name="opentelemetry-java-instrumentation", telemetry.distro.version="2.20.0", telemetry.sdk.language="java", telemetry.sdk.name="opentelemetry", telemetry.sdk.version="1.54.0"}}, instrumentationScopeInfo=InstrumentationScopeInfo{name=io.opentelemetry.runtime-telemetry-java8, version=2.20.0-alpha, schemaUrl=null, attributes={}}, name=jvm.gc.duration, description=Duration of JVM garbage collection actions., unit=s, type=HISTOGRAM, data=ImmutableHistogramData{aggregationTemporality=CUMULATIVE, points=[ImmutableHistogramPointData{getStartEpochNanos=1758099741657518036, getEpochNanos=1758099782686024415, getAttributes={jvm.gc.action="end of minor GC", jvm.gc.name="G1 Young Generation"}, getSum=0.041, getCount=9, hasMin=true, getMin=0.002, hasMax=true, getMax=0.008, getBoundaries=[0.01, 0.1, 1.0, 10.0], getCounts=[9, 0, 0, 0, 0], getExemplars=[]}]}}
[otel.javaagent 2025-09-17 17:03:02:686 +0800] [Thread-0] INFO io.opentelemetry.exporter.logging.LoggingMetricExporter - metric: ImmutableMetricData{resource=Resource{schemaUrl=https://opentelemetry.io/schemas/1.24.0, attributes={container.id="1c59603168a7210a0d1f7edadc57129fcd3788da67ddbb0dad0ffd99def32bd2", host.arch="amd64", host.name="bastion.topgun.kubeantony.com", os.description="Linux 5.14.0-570.44.1.el9_6.x86_64", os.type="linux", process.command_args=[/usr/lib/jvm/java-17-openjdk-17.0.16.0.8-2.el9.x86_64/bin/java, -jar, ./build/libs/java-simple.jar], process.executable.path="/usr/lib/jvm/java-17-openjdk-17.0.16.0.8-2.el9.x86_64/bin/java", process.pid=23849, process.runtime.description="Red Hat, Inc. OpenJDK 64-Bit Server VM 17.0.16+8-LTS", process.runtime.name="OpenJDK Runtime Environment", process.runtime.version="17.0.16+8-LTS", service.instance.id="12b46158-6949-48ee-b8b6-54aff876afaa", service.name="java-simple", telemetry.distro.name="opentelemetry-java-instrumentation", telemetry.distro.version="2.20.0", telemetry.sdk.language="java", telemetry.sdk.name="opentelemetry", telemetry.sdk.version="1.54.0"}}, instrumentationScopeInfo=InstrumentationScopeInfo{name=io.opentelemetry.tomcat-10.0, version=2.20.0-alpha, schemaUrl=null, attributes={}}, name=http.server.request.duration, description=Duration of HTTP server requests., unit=s, type=HISTOGRAM, data=ImmutableHistogramData{aggregationTemporality=CUMULATIVE, points=[ImmutableHistogramPointData{getStartEpochNanos=1758099741657518036, getEpochNanos=1758099782686024415, getAttributes=FilteredAttributes{http.request.method=GET,http.response.status_code=200,http.route=/rolldice,network.protocol.version=1.1,url.scheme=http}, getSum=0.08728259, getCount=1, hasMin=true, getMin=0.08728259, hasMax=true, getMax=0.08728259, getBoundaries=[0.005, 0.01, 0.025, 0.05, 0.075, 0.1, 0.25, 0.5, 0.75, 1.0, 2.5, 5.0, 7.5, 10.0], getCounts=[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], getExemplars=[]}]}}

將步驟 1-2 融入 Dockerfile

nano Dockerfile-v3-opentelemetry-instrumentation

檔案內容如下：

FROM registry.suse.com/bci/bci-base:15.7 AS useradder
 ARG user
 RUN groupadd $user && \
 useradd -m -d /home/$user -g $user $user

FROM docker.io/library/gradle:8.14.3-jdk17-alpine AS build
 ARG user
 COPY --from=useradder /etc/passwd /etc/passwd
 COPY --from=useradder /etc/group /etc/group
 COPY --from=useradder /etc/shadow /etc/shadow
 COPY --from=useradder /home/$user /home/$user

 COPY build.gradle.kts DiceApplication.java RollController.java /java-simple
 WORKDIR /java-simple
 RUN chown -R $user:$user /java-simple && \
 gradle assemble
 USER $user

FROM registry.suse.com/bci/openjdk:17
 ARG user
 COPY --from=useradder /etc/passwd /etc/passwd
 COPY --from=useradder /etc/group /etc/group
 COPY --from=useradder /etc/shadow /etc/shadow
 COPY --from=useradder /home/$user /home/$user

 RUN install -g $user -o $user -d /app
 WORKDIR /app
 COPY --from=build --chown=$user:$user /java-simple/build/libs/java-simple.jar /app/java-simple.jar
 USER $user
 RUN curl -L -O https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar
 ENV JAVA_TOOL_OPTIONS="-javaagent:/app/opentelemetry-javaagent.jar" \
 OTEL_TRACES_EXPORTER=logging \
 OTEL_METRICS_EXPORTER=logging \
 OTEL_LOGS_EXPORTER=logging \
 OTEL_METRIC_EXPORT_INTERVAL=15000
 EXPOSE 8080
 ENTRYPOINT ["java", "-jar", "/app/java-simple.jar"]

製作 image

podman build --no-cache \
--squash-all \
--build-arg user=bigred \
-t java-simple:v3-opentelemetry-instrumentation \
-f Dockerfile-v3-opentelemetry-instrumentation

Run java app container 測試是否符合預期

podman run -d \
--name java-simple \
-p 9999:8080 \
localhost/java-simple:v3-opentelemetry-instrumentation

檢視 app container 運作狀態

podman ps -a --filter name=java-simple

正確執行結果：

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
01805e4e24f3 localhost/java-simple:v3-opentelemetry-instrumentation 4 minutes ago Up 4 minutes 0.0.0.0:9999->8080/tcp java-simple

透過網路存取 http://192.168.11.21:9999/rolldice，以確保它能正常運作
```
curl http://192.168.11.21:9999/rolldice; echo
```
執行結果：
```
6
```

檢視 log 是否擁有 trace 資訊

podman logs java-simple

執行結果：

2025-09-18T02:04:52.34Z INFO 'Anonymous player is rolling the dice: 3' : 4dd621a6aa359c6caa6cb710fa10963a d192f1ee1b7afd06 [scopeInfo: otel.RollController:] {}
2025-09-18T02:04:52.340Z INFO 1 --- [nio-8080-exec-4] otel.RollController : Anonymous player is rolling the dice: 3
[otel.javaagent 2025-09-18 02:04:52:341 +0000] [http-nio-8080-exec-4] INFO io.opentelemetry.exporter.logging.LoggingSpanExporter - 'GET /rolldice' : 4dd621a6aa359c6caa6cb710fa10963a d192f1ee1b7afd06 SERVER [tracer: io.opentelemetry.tomcat-10.0:2.20.0-alpha] AttributesMap{data={server.address=192.168.11.21, client.address=169.254.1.2, network.peer.address=169.254.1.2, url.path=/rolldice, http.request.method=GET, network.peer.port=60368, http.route=/rolldice, url.scheme=http, thread.name=http-nio-8080-exec-4, user_agent.original=curl/7.76.1, http.response.status_code=200, thread.id=27, server.port=9999, network.protocol.version=1.1}, capacity=128, totalAddedValues=14}

移除 java app container
```
podman rm -f java-simple
```

Certified GitOps Associate (CGOA) B 卷

Mon, 25 Aug 2025 14:39:30 +0800

Q1

As a Certitled GitOps Associate, what should you focus on besides the delivery/deployment of configurations to your system?

A. Interoperability with tools that provide Notifications, Observability, and Continuous Integration. B. Interoperability with tools that provide only Continuous Integration. C. Interoperability with tools that provide only Observabilty. D. Only the delivery/deployment of configurations to your system.

Q2

In a GitOps setup, how do event driven systems respond to changes compared to pull based systems?

A. Event-driven systems initiate updates only during scheduled maintenance, while pull based systems update as soon as changes are detected. B. Even’t dhan systerms update imenediately in response to changes, while pull based systems routinely check for and apply for updates. C. Pull-based systems are designed for rapid, imediate updates, contrasting with the gradual updates of event driven systems. D. In event driven systems, updates are manually triggered, whereas pull based systems automate the update process.

Prometheus certified associate

Mon, 11 Aug 2025 13:10:14 +0800

Q1

How does Prometheus collect metrics?

A. Applications send metrics to Prometheus vis UDP. B. Applications send metrics to Prometheus via GRPC. C. Prometheus scrapes metrics from instrumented application’s HTTP Server D. Prometheus scrapes metrics from instrumented application’s UDP Server

Q2

If you offer a free service, which of the following do you want?

A. SLO’s and SLI’s. B. SLI’s, SLO’s and SLAs C. SLAS. D. SLIS.

Q3

What are the changes in numerical data recorded over time called?

A. time series B. data dashboard C. metrics D. time table

Q4

What is a trace?

A. Trace is a set of events triggered by a singie logical operation, consolord so s B. Trace is a simple mechanism for propagating name/value pairs. C. Trace is a numerical measurement about a service, captured at runtime D. Trace is a timestamped text record, either structured (recommended) or unst

Q5

With a SLO of 99.9%, what is the error budget? A. 0.1% B. Insufficient data to tell. C. 99.9% D. 100%.

Q6

How many metrics types does Prometheus text format support

A. 40 B. 4 C. 8 D. 10

Q7

Which one of the following item should not belong to a metrics?

A. environment D. username C. server name D. response code

Q8

Why can’t you send logs to Prometheus?

A. Default Prometheus installations will store deta only for a few weeks. B. PromQL language is inefficient for parsing log files. C. It is best practice to avoid mixing logs and metries wihin a Prometheus instance. D. Prometheus handles metrics but logs are text-based events.

Q9

Which of the following Kubernetes SD configurations “key allow rerieing scarape targets from Kubernetes REST API?

A. <kubernetes_scrape_config> B. <kube-apiserver_sd_config> C. <kube-piserver_scrape_config> D. <kubernetes_sd_config>

Q10

Your publicly available web server receives 1000 requests per hour with a 1-3% average error tes sos the tando wit aut?

A. Rate of requests, errors, and request times B. Stack traces of successful requests C. Detailed web server logs for failed requests D. Stack traces of error requests

Q11

Which of the following metric is unsuitable for a Promethes setup?

A. prometheus_engine_query_log_enabled B. user_last_login_tinestamp_seconds{email="john.doe@example.com"} C. http_response_total{handler="/static/*filepath"} D. promhttp_metric_handler_requests_total{code="580"}

Q12

What is api_http_requests_total in the following metric? api_http_requests_total{method="POST", handler="/messages"}

A. “api_http_requests_total” is a metric type. B. “api_http_requests_total” is a metric name. C. “api_http_requests_total” is a metric field. D. “api_http_requests_total” is a metric label name.

Q13

You’d like to monitor a short lived batch job. What Prometheus component wold you want?

A. PullGateway B. PushGateway C. PullProxy D. PushProxy

Q14

What Prometheus component would you use if targets are runnning beind Firewal NAT?

A. Pull Gateway B. Pull Proxy C. HA Proxy D. PushProx

Q15

What’s “wrong” with the myapp_file_uploads_total{userid="5123", status="failed"} metrics? A. The _total suffic should be omitted B. The userid should not be exposed as a label. C. The status should not be exposed as a label. D. The metric name should consist of dashes instead of underscores

Q16

How can you send metrics from your Prometheus setup to a remote system, e.g. for long term storage?

A. With S3 Buckets B. With “scraping” C. With “remote write” D. With “federation”

Q17

What is a difference between a counter and a gauge?

A. Counters change value on each scrape and a gauges remain static. B. Counters are only incremented, while gauge can go up and down. C. Counters have no labels while gauges can have many labels. D. Counters and gauges are different names for the same thing.

Q18

Which of the following is a valid metric name?

A. go_goroutines B. 99_goroutines C. go routines D. go.goroutines

Q19

Which exporter would be best suited for basic HITP probing?

A. SNMP exporter B. Apache exporter C. Blackbox exporter D. JMX exporter

Q20

What does scrape_interval configure in Prometheus?

A. It defines how frequently to scrape targets. B. It defines how often to send alerts. C. It defines how frequently to evaluate rules. D. It defines how often to refresh metrics.

Q21

What is an example of a single-target exporter?

A. Blackbox Exporter B. SNMP Exporter C. Redis Exporter D. Node Exporter

Q22

How do you configure the rule evaluation interval in Prometheus?

A. You can configure the evaluation interval in the Prometheus TSDB configuration file and in the rule configuration file. B. You can configure the evaluation interval in the globel configuration file and in the rule configuration file. C. You can configure the evaluation intenval in the service discovery configurtion and in the command-line flags. D. You can configure the evaluation interval in the scraping job configuration file and in the command-line flags.

Q23

Which kind of metrics are associated with the function deriv?

A. Summaries B. Counters C. Histograms D. Gauges

Here is why: deriv should only be used with gauges and only works for float samples.

參考文件：https://prometheus.io/docs/prometheus/latest/querying/functions/#deriv:~:text=deriv%20should%20only%20be%20used%20with%20gauges%20and%20only%20works%20for%20float%20samples.

Q24

Given the metric prometheus_tsdb_lowest_timestamp_secoods, how do you know in which month belongs the

A. format_date(prometheus_tsdb_lowest_timestamp_seconds, "5m") B. (time() - prometheus_tsdb_lowest_timestamp_secceds) / 86400 C. prometheus_tsdb_lowest_tinestamp_seconds % month D. month(prometheus_tsdb_lowest_timestamp_seconds)

Q25

Which PromQL expression computes how many requests in total are currently in-flight for time series ?

apiserver_current_inflight_requests{instance="1"} 5
apiserver_current_inflight_requests{instances="2"} 7

A. sum(apiserver_current_inflight_requests) B. max(apiserver_current_inflight_requests) C. sum_over_time(apiserver_current_inflight_requests, reperts[10m]) D. min(apiserver_current_inflight_requests)

Q26

How do you calculate the average request duration during the last 5 minutes from a histograms on summany called http_request_duration_seconds ?

A. rate(http_request_duration_seconds_total[5m]) / rate(http_request_duration_seconds_average[5m]) B. rate(http_request_duration_seconds_sum[5m]) / rate(http_request_duration_seconds_average C. rate(http_request_duration_seconds_sum[5m]) / rate(http_request_duration_seconds_count[5m]) D. rate(http_request_duration_seconds_total[5m)) / rate(http_request_duration_seconds_count[5m]

Q27

Which PromQL statement returns the average free bytes of the fliesystems over the last hour?

A. avg_over_time(node_filesystem_avail_bytes[1h]) B. sum_over_time(node_filesystem_avail_bytes[1h]) C. sum(node_filesystem_avail_bytes[1h]) D. avg(node_filesystem_avail_bytes[1h])

Q28

How can you use the delta PromQL function?

A. On counter metrics to compute the difference between the first and last value of each time series element. B. On counter metrics to compute the number of metric resets within the provided time range. C. On gauge metrics to compute the number of metric resets within the provided time range. D. On gauge metrics to compute the difference between the first and last value of each time series element.

Q29

Which of the following PromQL query is invalid?

A. max without (instance, job) up B. max without (instance) up C. max by (instance) up D. max on (instance) (up)

Q30

Given the following Histogram metric data, how many requests took less than or equal to 0.1 seconds?'

apiserver_request_duration_seconds_bucket(job="kube-apiserver",le="+Inf") 3
apiserver_request_duration_seconds_bucket(job="kube-apiserver",le="0.05") 0
apiserver_request_duration_seconds_bucket(job="kube-apiserver",le="0.1") 1
apiserver_request_duration_seconds_bucket(job="kube-apiserver",le="1") 3
apiserver_request_duration_seconds_count(job="kube-apiserver") 3
apiserver_request_duration_seconds_sum(jbb="kube-apiserver") 0.554003785

A. 0.554003785 B. 3 C. 0 D. 1

Q31

What function calculates the φ-quantile from a histoggam?

A. predict_linear() B. avg_over_time() C. histogram() D. histogram_quantile()

Q32

How can you select all the up metrics whose instance label match the regex fe-.*?

A. up{instance=regexp(fe-.*)} B. up{instance="fe-.*"} C. up{instance~"fe-.*"} D. up{instance=~"fe-.*"}

Q33

Which PromQL expression computes the rate of API Server requests across the different cloud providers from the following metrics?

apiserver_request_total{job="kube-apiserver", instance="192.168.1.228:6443, cloud="aws"} 1
apiserver_request_total{job="kube-apiserver", instance="192.168.1.121:6443, clmud="gcloud" 5

A. rate(sum by (cloud)(apiserver_request_total{job=“kube- apisever”})(5m)) B. sum by (cloud)(rate(apiserver_request_total{job=“kube-apisrver”}[5m])) C. sum by (cloud) (apiserver_request_total{job=“kube-apiserver}) D. rate(apiserver_request_total{job=“kube-apiserver”[5m]) by (cloud)

Q34

which expression calculates the average uptime of targets over the last hour?

A. avg(up[1h]) B. average_over_time(up[1h]) C. avg_over_time(up[1h]) D. avg(up-1h)

Q35

which PromQL statement returns the sum of all values of the metric node_memory_MemAvailable_bytes from 10 minutes ago?

A. offset sum(node_memory_MemAvailable_bytes[10m]) B. sum(node_memory_MemAvailable_bytes) setoff 10m C. sum(node_memory_MemAvailable_bytes) offset 10m D. sum(node_memory_MemAvailable_bytes offset 10m)

Q36

Which metric type uses the delta() function?

A. Info B. Histogram C. Gauge D. Counter

Q37

If the vector selector foo[5m] contains 1 1 NaN 0 , what would max_over_time(foo[5m])) return?

A. 1 B. It errors out. C. NaN D. No answer.

Q38

Which of the following is an invalid @ modifier expression?

A. sum(http_requests_total{method="GET"}) @ 1609746000 B. go_goroutines @ end() C. sum(http_requests_total{method="GET"} @ 1609746000) D. go_goroutines @ start()

Q39

With the following metrics over the last 5 minutes:

up{instance="localhost"} 1 1 1 1 1
up{instance="server1"} 1 0 0 0 0

What does the following query retum: min_over_time(up[5m])?

A. up{instance="localhost"} 1 up{instance="server1"} 0 B. {instance="localhost"} 1 {instance="server1"} 0 C. up{instance="server1"} 0 D. {instance="server1"} 0

Q40

The following is a list of metrics exposed by an application.

http_requests_total{code="508"} 10
http_requests_total{code="200"} 20
http_requests_total{code="408"} 30
http_requests_total{verb="POST"} 30
http_requests_total{verb="GET"} 30

What is the issue with the metric family?

A. verb label content should be normalized to lowercase. B. Metric names are missing a prefix to indicate which application is exposing the query. C. The value represents two different thigs accross the dimensions: code and verb. D. Unit is missing in the http_requests_total meticname.

Q41

What is the difference between client libraries and exporters?

A. Exporters expose metrics for scraping. Client libraries push metrics via Remote White. B. Exporters run next to the services to monitor, and use client libraries internally. C. Exporters are written in Go. Client libraries are written in many languages. D. Exporters and client libraries mean the same thing.

Q42

What should you do with counters that have labels?

A. Instantiate them with their possible label values when creating them so they are expoved with a zero value. B. Investigate if you can move their label value inside their metic name to limit the numbe of lebels. C. Make sure every counters with labels has an extra counter, aggregated, without lebels. D. Save their state between application runs so you can restore their last value on startup.

設定 Alertmanager 觸發告警時去執行 Bash Script

Mon, 28 Jul 2025 05:49:08 +0800

1. 安裝 kube-prometheus-stack

安裝 kube‑prometheus stack 的核心元件：

The Prometheus Operator
Highly available Prometheus
Highly available Alertmanager
Prometheus node-exporter
Prometheus blackbox-exporter
Prometheus Adapter for Kubernetes Metrics APIs
kube-state-metrics
Grafana

1.1. 先決條件

K8s 已安裝完畢
已安裝好 StorageClass
已安裝好 IngressClass

1.2. 開始安裝

安裝 helm

curl https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 | bash

建立 K8s namespace
```
kubectl create ns monitoring-system
```
將 Prometheus 社群維護的 Helm 圖表倉庫加入本地 Helm 用戶端，以便拉取 Prometheus 相關的 Helm Chart
```
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts 
```
更新本地緩存中所有已加入倉庫的圖表清單，確保可以取得最新版本的 Chart
```
helm repo update
```

建立並切換工作目錄

mkdir ~/monitoring-system; cd ~/monitoring-system

編輯 kube-prometheus-stack helm 安裝設定檔

nano values.yaml

檔案內容如下：

kubelet:
enabled: true
serviceMonitor:
cAdvisorMetricRelabelings: []
prometheus:
prometheusSpec:
storageSpec:
volumeClaimTemplate:
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 50Gi
storageClassName: nfs-client
additionalScrapeConfigsSecret:
enabled: true
name: additional-scrape-configs
key: additional.yaml
service:
type: NodePort
ingress:
enabled: true
ingressClassName: "cilium"
alertmanager:
alertmanagerSpec:
storage:
volumeClaimTemplate:
spec:
storageClassName: nfs-client
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 50Gi
alertmanagerConfigSelector:
matchLabels:
resource: prometheus
service:
type: NodePort
ingress:
enabled: true
ingressClassName: "cilium"
grafana:
persistence:
enabled: true
type: sts
storageClassName: "nfs-client"
accessModes:
- ReadWriteOnce
size: 20Gi
finalizers:
- kubernetes.io/pvc-protection
service:
type: NodePort
ingress:
enabled: true
ingressClassName: "cilium"

主要會設定

Deploying GKE Clusters with Terraform from scratch

Fri, 06 Jun 2025 07:10:30 +0800

1. 先決條件

建立 Google Mail 帳號
申請免費試用 Google Cloud Platform 資格 (注意，需要一張 VISA 或信用卡) https://console.cloud.google.com/getting-started
在 Google Cloud Platform 建立 project
- 點選左上角 “My First Project” 專案的按鈕
- 點選右上角 “新增專案” 按鈕
- 輸入 testgke，點選 “建立” 按鈕
確認在剛建立的 gketest 專案後，點選左上角按鈕
點選 Kubernetes Engine 按鈕
點選 “啟用” 按鈕，啟用 Kubernetes Engine API
點選右上角 “Cloud Shell” 按鈕，並授權 Cloud Shell

2. 開始部署

$ mkdir gcp-terraform; cd gcp-terraform
$ nano gke.tf
resource "google_container_cluster" "gke_cluster" {
name = "k1"
location = "asia-east1-b"
initial_node_count = 1
network = google_compute_network.vpc.name
subnetwork = google_compute_subnetwork.subnet.name
networking_mode = "VPC_NATIVE"
logging_service = "none"
monitoring_service = "none"
private_cluster_config {
enable_private_endpoint = false
enable_private_nodes = true
master_ipv4_cidr_block = "10.13.0.0/28"
}
ip_allocation_policy {
cluster_ipv4_cidr_block = "10.98.0.0/16"
services_ipv4_cidr_block = "10.244.0.0/16"
}
node_config {
machine_type = "e2-custom-4-12288"
}
}
output "cluster_endpoint" {
value = google_container_cluster.gke_cluster.endpoint
}
output "cluster_ca_certificate" {
value = google_container_cluster.gke_cluster.master_auth.0.cluster_ca_certificate
sensitive = true
}
$ nano variable.tf
#PROJECT INFO
variable "PROJECT_ID" {
default = "gketest-462015"
}
variable "REGION" {
default = "asia-east1"
}
#VPC
variable "VPC_NAME" {
default = "k8s-vpc"
}
variable "VPC_NAME2" {
default = "k8s-vpc2"
}
variable "VPC_SUBNET_NAME" {
default = "asia-east1"
}
variable "VPC_SUBNET_NAME2" {
default = "asia-east1-2"
}
variable "IP_CIDR_RANGE" {
default = "10.10.0.0/24"
}
variable "IP_CIDR_RANGE2" {
default = "10.10.1.0/24"
}
variable "ROUTER_NAME" {
default = "demo-route"
}
variable "ROUTER_NAME2" {
default = "demo-route2"
}
variable "NAT_NAME" {
default = "demo-nat"
}
variable "NAT_NAME2" {
default = "demo-nat2"
}
#GKE
variable "GKE_LOCATION" {
default = "asia-east1-b"
}
variable "GKE_MACHINE_TYPE" {
default = "e2-custom-2-8192"
}
$ nano vpc.tf
resource "google_compute_network" "vpc" {
name = var.VPC_NAME
auto_create_subnetworks = "false"
}
resource "google_compute_subnetwork" "subnet" {
name = "${var.VPC_SUBNET_NAME}-subnet"
region = var.REGION
network = google_compute_network.vpc.name
ip_cidr_range = var.IP_CIDR_RANGE
private_ip_google_access = true
}
#resource "google_compute_subnetwork" "subnet2" {
# name = "${var.VPC_SUBNET_NAME}2-subnet"
# region = var.REGION
# network = google_compute_network.vpc.name
# ip_cidr_range = var.IP_CIDR_RANGE2
# private_ip_google_access = true
#}
resource "google_compute_router" "router" {
name = var.ROUTER_NAME
region = google_compute_subnetwork.subnet.region
network = google_compute_network.vpc.id
}
#resource "google_compute_address" "address" {
# count = 2
# name = "nat-manual-ip-${count.index}"
# region = google_compute_subnetwork.subnet.region
#}
resource "google_compute_address" "r1-address" {
name = "nat-address"
region = google_compute_subnetwork.subnet.region
}
#resource "google_compute_address" "r1-address-2" {
# name = "nat-address2"
# region = google_compute_subnetwork.subnet.region
#}
resource "google_compute_router_nat" "nat_manual" {
name = var.NAT_NAME
router = google_compute_router.router.name
region = google_compute_router.router.region
nat_ip_allocate_option = "MANUAL_ONLY"
nat_ips = [google_compute_address.r1-address.self_link]
enable_dynamic_port_allocation = true
enable_endpoint_independent_mapping = false
min_ports_per_vm = 4096
max_ports_per_vm = 65536
source_subnetwork_ip_ranges_to_nat = "LIST_OF_SUBNETWORKS"
subnetwork {
name = google_compute_subnetwork.subnet.id
source_ip_ranges_to_nat = ["ALL_IP_RANGES"]
}
}
#resource "google_compute_router" "router2" {
# name = var.ROUTER_NAME2
# region = google_compute_subnetwork.subnet2.region
# network = google_compute_network.vpc.id
#}
#resource "google_compute_address" "r2-address" {
# name = "r2-nat-address"
# region = google_compute_subnetwork.subnet2.region
#}
#resource "google_compute_router_nat" "nat_manual2" {
# name = var.NAT_NAME2
# router = google_compute_router.router2.name
# region = google_compute_router.router2.region
# nat_ip_allocate_option = "MANUAL_ONLY"
# nat_ips = google_compute_address.r2-address.*.self_link
# enable_dynamic_port_allocation = true
# enable_endpoint_independent_mapping = false
# min_ports_per_vm = 4096
# max_ports_per_vm = 65536
# source_subnetwork_ip_ranges_to_nat = "LIST_OF_SUBNETWORKS"
# subnetwork {
# name = google_compute_subnetwork.subnet2.id
# source_ip_ranges_to_nat = ["ALL_IP_RANGES"]
# }
#}
#Firewall Rule
#resource "google_compute_firewall" "datalake-prod-composer-internal-ingress" {
# name = "datalake-prod-composer-internal-ingress"
# network = google_compute_network.prod-vpc.name
# allow {
# protocol = "tcp"
# }
# allow {
# protocol = "udp"
# }
# priority = 1000
# source_ranges = var.datalake_prod_composer_ingress_allow_source_ip
# target_tags = var.datalake_prod_composer_ingress_target_tag
#}
$ nano provider.tf
terraform {
required_providers {
google = {
source = "hashicorp/google"
version = "4.40.0"
}
}
required_version = ">= 0.14"
}
provider "google" {
project = var.PROJECT_ID
region = var.REGION
}
$ terraform init
$ terraform plan
$ terraform apply
$ gcloud container clusters get-credentials k1 --zone asia-east1-b --project $(gcloud config get-value project 2> /dev/null)
$ kubectl get nodes
NAME STATUS ROLES AGE VERSION
gke-k1-default-pool-e0781567-7ljm Ready <none> 5m39s v1.32.4-gke.1106006

3. 清理環境 (窮到只剩錢的人可跳過此步驟)

不做的話，殘留在 Google Cloud 上的物件會一直產生費用

# 將所有建立的物件清除
$ terraform destroy
# 移除 billing account 與 Project 的連結
$ gcloud billing projects unlink $GOOGLE_CLOUD_PROJECT
billingAccountName: ''
billingEnabled: false
name: projects/gketest-462015/billingInfo
projectId: gketest-462015
# 刪除 project
$ gcloud projects delete -q $GOOGLE_CLOUD_PROJECT
Deleted [https://cloudresourcemanager.googleapis.com/v1/projects/gketest-462015].
You can undo this operation for a limited period by running the command below.
$ gcloud projects undelete gketest-462015
See https://cloud.google.com/resource-manager/docs/creating-managing-projects for information on shutting down projects.
# 確認 project 已被刪除
$ gcloud projects describe $GOOGLE_CLOUD_PROJECT
createTime: '2025-06-05T15:39:13.542189Z'
lifecycleState: DELETE_REQUESTED
name: gketest
projectId: gketest-462015
projectNumber: '876476350521'

Bash Script Debug mode

Wed, 21 May 2025 01:32:00 +0800

實作目標

將 Bash Function 裡面，命令的正確執行結果 + 錯誤輸出 + 真正執行的命令(變數會變成值) 通通都倒到同一個檔案中，不用手動一行一行在行尾加上 & > /dev/null，而且加上行號、function 名稱，好讓你以後除錯時超清楚！

注意事項

因 log file 的目錄區是在 /var/log 底下，所以以下範例需要由 root 使用者或 sudo user 執行。
log 的檔名前面有加 . 代表隱藏檔案，所以不能用 ll，大部分的 ll 都是 alias ll="ls -l"，要記得用 ls -al

範例程式

#!/bin/bash
TRACE_LOG() {
Command_log_file="/var/log/.$(basename "${BASH_SOURCE[0]}").log"
exec >>"${Command_log_file}" 2>&1
exec 3>> "${Command_log_file}"
export BASH_XTRACEFD=3 PS4='($BASH_SOURCE:$LINENO:$FUNCNAME): '
set -x
}
TEST() {
TRACE_LOG
for i in {1..10};
do
echo ${i}
done
# failed command
fdsffa
fdsafasf
set +x
}
TEST

程式重點介紹

TRACE_LOG() {

這是宣告一個 Bash function，叫做 TRACE_LOG，之後你可以在 script 其他地方用 TRACE_LOG 來呼叫它。

 Command_log_file="/var/log/.$(basename "${BASH_SOURCE[0]}").log"

設定 log 檔的檔名與路徑。
$(basename "${BASH_SOURCE[0]}") 會取得目前這個 script 的檔名，例如 myscript.sh。
結果會變成這樣的一個 log 路徑，例如：
```
/var/log/.myscript.sh.log
```

這樣做的目的是：自動為每個 script 建立一個獨立的 log 檔，方便紀錄。

 exec >>"${Command_log_file}" 2>&1

把所有之後的「正常輸出（stdout）」與「錯誤訊息（stderr）」全部寫進前面設定的 log 檔中。
從這一行開始，像 echo 或 ls 等指令的輸出都不會出現在螢幕上，而是寫進 log 檔。

 exec 3>> "${Command_log_file}"

開啟一個「新的資料管道」，叫做「檔案描述符 3（FD 3）」，也指向同一個 log 檔。
這行本身不會產生輸出，它只是預先準備好「FD 3」，之後會專門用來記錄除錯訊息（debug trace）。

 export BASH_XTRACEFD=3 PS4='($BASH_SOURCE:$LINENO:$FUNCNAME): '

這是在啟用 Bash 的「除錯模式」所需的變數。

BASH_XTRACEFD=3：告訴 Bash，把除錯訊息（由 set -x 產生的 trace）寫入「檔案描述符 3」，也就是 log 檔。
PS4='($BASH_SOURCE:$LINENO:$FUNCNAME): '：設定每一行除錯訊息的開頭格式，包括：
- $BASH_SOURCE：是哪個 script 檔案
- $LINENO：是哪一行
- $FUNCNAME：是在哪個 function 裡

舉例產生的 log 可能會長這樣：

(myscript.sh:15:myfunc): echo "啟動中"

這樣可以清楚知道程式執行到哪裡、哪一行。

 set -x

這行開啟 Bash 的「指令追蹤模式（debug trace mode）」。
開啟後，Bash 每執行一行指令，都會先印出該指令的內容（寫入你上面指定的 log 檔，因為有設定 BASH_XTRACEFD）。

使用方式

你只要在 script 裡面某個地方寫：

TRACE_LOG

從那一行開始，這支 script 的輸出和行為紀錄就會開始寫進 log 檔 /var/log/.xxx.log。

查看 Log

# cat /var/log/.test.sh.log

執行結果 :

(./test.sh:17:test): for i in {1..10}
(./test.sh:19:test): echo 1
1
(./test.sh:17:test): for i in {1..10}
(./test.sh:19:test): echo 2
2
(./test.sh:17:test): for i in {1..10}
(./test.sh:19:test): echo 3
3
(./test.sh:17:test): for i in {1..10}
(./test.sh:19:test): echo 4
4
(./test.sh:17:test): for i in {1..10}
(./test.sh:19:test): echo 5
5
(./test.sh:17:test): for i in {1..10}
(./test.sh:19:test): echo 6
6
(./test.sh:17:test): for i in {1..10}
(./test.sh:19:test): echo 7
7
(./test.sh:17:test): for i in {1..10}
(./test.sh:19:test): echo 8
8
(./test.sh:17:test): for i in {1..10}
(./test.sh:19:test): echo 9
9
(./test.sh:17:test): for i in {1..10}
(./test.sh:19:test): echo 10
10
(./test.sh:23:test): fdsffa
./test.sh: line 23: fdsffa: command not found
(./test.sh:24:test): fdsafasf
./test.sh: line 24: fdsafasf: command not found
(./test.sh:25:test): set +x

Test Webhook

Thu, 04 Jul 2024 02:15:32 +0800

What are webhooks and why use them?

Webhooks are HTTP callbacks that allow you to send alerts to external services or applications. You can use webhooks to integrate Alertmanager with chat platforms, notification systems, ticketing tools, or any other web-based service that can receive and process HTTP requests. Webhooks give you more flexibility and control over how you handle and respond to alerts.

# 1. 安裝 Golang
$ suseconnect -p PackageHub/15.6/x86_64
$ zypper -n in go
$ git clone https://github.com/yunlzheng/alertmanaer-dingtalk-webhook.git && \
cd alertmanaer-dingtalk-webhook
$ go mod init
$ go mod download
$ cd cmd/webhook
$ CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a webhook.go
$

SRE 課程學習筆記連結-Overview

Thu, 07 Dec 2023 07:35:16 +0800

前言

這裡放了我學習 SRE 課程的所有筆記連結
還有同學們的筆記連結

陳松林老師

Linux Process

Container

Docker

Podman

Kubernetes

DataTechnology

DataTechnology - Overview

世宏老師

楊世宏老師 : IOT Intro

莊明城老師

Linux KVM

Linux KVM

Kubernetes

楊承羲老師

Linux

Linux startup Process 開機流程

CI/CD Overview

Git

Bash Script

同學的筆記連結

宇志的第二期 SRE 課程學習筆記連結

東軒的程式筆記

我的筆記小站

MyWeb

Backstage 首頁

Sat, 04 Nov 2023 03:04:08 +0800

正式內容

DropBox

Build backstage Container Image

Tue, 10 Oct 2023 08:19:22 +0800

Preface

本篇文章會主要會介紹如何，透過 Podman 工具設計並製作 Backstage 的 Container Image

可以透過點擊以下目錄，選擇想看的內容，跳轉至特定章節

Prerequisites

Hareware Requisites

MEM: 8 Gi
CPU: 4 Core
Disk: 100 GB

System Requisites

須能上網
作業系統
- Ubuntu Server 22.04 LTS
- Alpine 3.18
可以執行 sudo 的使用者帳號
以下套件須先安裝
- Podman (Version: 4.6.2+)

系統環境準備

安裝 Podman 4

Step 1: Add Necessary Repository

使用 root 權限執行以下 shell Script

echo $'#!/bin/sh
ubuntu_version='22.04'
key_url="https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/unstable/xUbuntu_${ubuntu_version}/Release.key"
sources_url="https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/unstable/xUbuntu_${ubuntu_version}"
echo "deb $sources_url/ /" | sudo tee /etc/apt/sources.list.d/devel:kubic:libcontainers:unstable.list
curl -fsSL $key_url | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/devel_kubic_libcontainers_unstable.gpg > /dev/null' | sudo sh

Step 2: Install Podman

$ sudo apt install podman

Step 3: 檢查 Podman 版本

$ podman -v

螢幕輸出 :

podman version 4.6.2

撰寫 Backstage-Backend Container file

建立工作目錄

$ mkdir -p ~/backstage/build-image/ && cd ~/backstage/build-image/

建置過程分為兩個不同階段 :

第一階段
- 安裝所有 package.json 檔案，以便快取安裝所有依賴項的初始 yarn install。
第二階段
- 將所有內容打包成最終映像，與主機建置的 Dockerfile 類似。

建立 Container file

$ nano Containerfile.backend

以下是 Container file 的內容

# Stage 1 - Download and Install Backstage Backend App as a base Layer
FROM docker.io/library/ubuntu:latest AS Base
ENV HOME=/root \
NODE_VERSION=v18.17.1
# Install required packages for Backstage
RUN apt-get update && \
DEBIAN_FRONTEND=noninteractive \
apt-get install -y --no-install-recommends make python3 g++ build-essential git-all curl && \
## Setup Time Zone
TZ=Asia/Taipei && \
ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && \
echo $TZ > /etc/timezone && \
dpkg-reconfigure -f noninteractive tzdata && \
## Using nvm install node.js (LTS)
curl -so - https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash && \
export NVM_DIR="$HOME/.nvm" && \
[ -s "$NVM_DIR/nvm.sh" ] && \
. "$NVM_DIR/nvm.sh" && \
nvm install $NODE_VERSION && \
nvm use $NODE_VERSION && \
## Install yarn and npx
npm install --global yarn && \
## Configure yarn use python3
yarn config set python /usr/bin/python3 && \
## Create Backstage App
echo backstage | npx -y @backstage/create-app@latest
ENV NVM_DIR="$HOME/.nvm" \
NODE_PATH=$NVM_DIR/$NODE_VERSION/lib/node_modules \
PATH=$NVM_DIR/$NODE_VERSION/bin:$PATH
WORKDIR backstage/
# Setup Git
RUN git init && \
git config --global user.email "bobo@backstage.com" && \
git config --global user.name "bobo" && \
git add . && \
git commit -m "Initial commit"
# build Backstage Backend
RUN . "$NVM_DIR/nvm.sh" && \
yarn install --frozen-lockfile --network-timeout 600000 && \
yarn tsc && \
yarn --cwd packages/backend build
RUN mkdir packages/backend/dist/skeleton packages/backend/dist/bundle \
&& tar xzf packages/backend/dist/skeleton.tar.gz -C packages/backend/dist/skeleton \
&& tar xzf packages/backend/dist/bundle.tar.gz -C packages/backend/dist/bundle
# Stage 2 - Build the actual backend image and install production dependencies
FROM node:18-bookworm-slim
# Install isolate-vm dependencies, these are needed by the @backstage/plugin-scaffolder-backend.
RUN apt-get update && \
apt-get install -y --no-install-recommends python3 g++ build-essential && \
yarn config set python /usr/bin/python3
# From here on we use the least-privileged `node` user to run the backend.
USER node
# This should create the app dir as `node`.
# If it is instead created as `root` then the `tar` command below will fail: `can't create directory 'packages/': Permission denied`.
# If this occurs, then ensure BuildKit is enabled (`DOCKER_BUILDKIT=1`) so the app dir is correctly created as `node`.
WORKDIR /app
# Copy the install dependencies from the build stage and context
COPY --from=Base --chown=node:node /backstage/yarn.lock /backstage/package.json /backstage/packages/backend/dist/skeleton/ ./
RUN --mount=type=cache,target=/home/node/.cache/yarn,sharing=locked,uid=1000,gid=1000 \
yarn install --frozen-lockfile --production --network-timeout 600000
# Copy the built packages from the build stage
COPY --from=Base --chown=node:node /backstage/packages/backend/dist/bundle/ ./
# Copy any other files that we need at runtime
COPY --from=Base --chown=node:node /backstage/app-config.yaml ./
# This switches many Node.js dependencies to production mode.
ENV NODE_ENV production
CMD ["node", "packages/backend", "--config", "app-config.yaml"]

Build Backstage-Backend Container Image

$ sudo podman build --no-cache -t backstage-backend:v1 -f Containerfile.backend

撰寫 Backstage-Backend Podman Pod Yaml File

$ nano ~/backstage/podman-pod/backstage-backend.yaml

檔案內容如下

apiVersion: v1
kind: Pod
metadata:
name: backstage
spec:
containers:
- name: backstage-backend
image: localhost/backstage-backend:v1
volumeMounts:
- name: app-config
mountPath: /app/app-config.yaml
subPath: app-config.yaml
- name: backstage-frontend
image: localhost/backstage-frontend:v1
volumes:
- name: app-config
hostPath:
path: ~/backstage/backstage/app-config.yaml

建立並測試 Backstage-Backend Pod

$ sudo podman run -it -d --mount type=bind,source=app-config.yaml,destination=/app/app-config.yaml localhost/backstage-backend:v1 bash

Getting Started, configuring Backstage

Thu, 05 Oct 2023 09:40:46 +0800

Preface

本篇文章會主要會分做 3 個部分介紹

甚麼是 Backstage
透過 Podman Pod 建立與設定 Backstage 要使用的 Database - PostgreSQL
透過 Podman Pod 建立與設定 Backstage

可以透過點擊展開以下目錄，選擇想看的內容，跳轉至特定章節

標題：Backstage 副標：解析企業開發導入 IDP 的需求與解決方案簡報大綱規劃（持續調整中）

第一章｜What is Backstage?
- Objectives and methods
第二章｜系統架構
- Concepts
- Architecture
第三章｜環境部署
- Containerize
- 相關服務的準備（ex:SQL）
- 配置檔案修改
第四章｜應用實例
- 先以個別解說優先（後續完善再組裝起來）

研究方向

目前完成 Backstage Containerize 接下來研究 Software Catalog、Software Templates 功能，將 Backstage 部署與 Software Catalog、Software Templates 功能實作流程寫入 TechDocs，後續針對 Kubernetes 相關 plugin 進行實作，Search 於最後進行功能驗證。

下一步

首要目標：
- 完善基礎設施，先串接 CI/CD 有一個完整的 Demo 流程後，Backstage 再上 K8s
後續項目
- 修正導入誘因，不能只單獨強調整合的特點，還要列出實際解決的問題
- Kubernetes 部署 Backstage
- 要了解開發人員，在合作開發中的問題點，如開新專案的流程，專案的交接步驟等，backstage 可以怎麼執行

What is Backstage

Backstage 是 Spotify 公司開發的一個開放平台，用來建立開發人員的入口網站 ( developer portals )。

它旨在提供開發者一個統一的平台，讓團隊成員能夠釐清、管理、維運和自動化部屬企業應用系統和基礎架構

Backstage 的核心目標：
- 它旨在提供統一的開發平台，讓企業能有效率的開發和管理應用系統。
- 建立企業的開發平台，有效使用開發資源與提升管理效率。
  
  在既有的基礎設施上，套上一層管理工具，提供統一介面，使團隊擁有一致的開發資源、資訊，如同傳送門匯聚在一起
Backstage 的實現手段： Backstage is aggregator｜它著重的是基礎設施的聚合，而非替代在既有的基礎設施上，套上一層管理工具，使團隊擁有一致的開發資訊界面，並透過高度彈性的外掛功能，實現不同的企業開發需求。
目前屬於 CNCF 的孵化專案

System Architecture overview

There are 3 main components in this architecture:

The core Backstage UI
The UI plugins and their backing services
Databases

整體組成架構：

Core：由開源專案的核心開發人員所建立的基本功能。
App：Backstage 應用程式的實例，由應用程式開發人員（通常是公司內的生產力團隊）負責部署和調整。App 將核心功能與額外的插件結合在一起。
Plugins：使您的 Backstage 應用程式對公司有用的額外功能。插件可以是特定於公司的，也可以是開源和可重用的。

backstage core functionalities

Backstage offers five core functionalities:

a software catalog
software templates
a documentation generator
a Kubernetes cluster visualizer
cross-ecosystem search capabilities.

Introducing the Software Catalog

目的

將企業中的所有應用系統，包括網站、API、程式庫和資源，映射到一個集中式目錄。這種集中化旨在幫助團隊管理技術並實現可發現性。

重點功能

Catalog 能持續追蹤每個 Application 的 metadata ( 元數據 )、所有權和依賴關係，從而生成一個軟體圖，其中包含孤立的 entities。

描述

Catalog 非常靈活，可以容納各種 Application，在 Backstage 中稱為 entities。由於網站與資料處理管道截然不同，因此 entities 可以按 Kind 種類區分。此外，即使在 entities 的種類中，也可以定義 Kind。

如何實現

Catalog 由儲存在 YAML 檔案中的 metadata 提供支持，YAML 檔案描述了每個檔案中單一 entitiy 的 kind ( 種類 )、type ( 類型 )、 name ( 名稱 )、owner ( 所有者 ) 和更多細節。這些檔案通常儲存在各自的程式碼庫中，因此會經常更新。有些 entities 類型可能有權威來源，但程式庫中沒有體現，例如，Okta 規定的使用者和團隊。

追蹤所有權和依賴關係是 Catalog 最重要的用例之一。這些也在描述軟體元件的 YAML 檔案中聲明。只有一個團隊可以成為元件的擁有者，這個團隊也必須作為一個 entities 在 Catalog 中註冊。至於依賴關係，Backstage 可以讓你定義元件如何依賴另一個 entities ，以及元件暴露了哪些內容，以便其他人可以使用它。

根據這些 metadata 繪製的軟體圖可以發現一些問題，例如孤兒 entities ，這意味著它們沒有父 entities 。此外，由於 Catalog 中存儲了有關所有軟體資產的大量信息，因此您還可以從中了解成熟度準備情況或安全警告等信息。

Introducing the Software Template

目的

Software Template 是一種工具，可幫助您在 Backstage 中建立元件。

Podman Pod Install and configure Backstage database - PostgreSQL

建立工作目錄

$ mkdir -p ~/backstage/{build-image,database,podman-pod,k8s-app}

撰寫 PostgreSQL Pod Yaml

$ nano ~/backstage/podman-pod/postgres.yaml

檔案內容如下 :

apiVersion: apps/v1
kind: Pod
metadata:
name: postgres
spec:
containers:
- name: postgres
image: postgres:13.2-alpine
ports:
- containerPort: 5432
hostPort: 5432
env:
- name: POSTGRES_USER
value: "bigred"
- name: POSTGRES_PASSWORD
value: "bigred"

建立並測試 PostgreSQL Pod

$ sudo podman play kube ~/backstage/podman-pod/postgres.yaml

檢視 Pod 運作狀態

$ sudo podman ps -a --pod

螢幕輸出 :

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD ID PODNAME
6572b0f07e57 localhost/podman-pause:4.5.1-1691040180 19 seconds ago Up 8 seconds 0.0.0.0:5432->5432/tcp ed1a0e48edbc-infra ed1a0e48edbc postgres
8d79400d332e docker.io/library/postgres:13.2-alpine postgres 8 seconds ago Up 8 seconds 0.0.0.0:5432->5432/tcp postgres-postgres ed1a0e48edbc postgres

使用 bigred 帳號登入測試 PostgreSQL

$ sudo podman exec -it postgres-postgres bash
bash-5.1# psql -U $POSTGRES_USER

螢幕輸出 :

psql (13.2)
Type "help" for help.
bigred=# \l
List of databases
Name | Owner | Encoding | Collate | Ctype | Access privileges
-----------+--------+----------+------------+------------+-------------------
bigred | bigred | UTF8 | en_US.utf8 | en_US.utf8 |
postgres | bigred | UTF8 | en_US.utf8 | en_US.utf8 |
template0 | bigred | UTF8 | en_US.utf8 | en_US.utf8 | =c/bigred +
| | | | | bigred=CTc/bigred
template1 | bigred | UTF8 | en_US.utf8 | en_US.utf8 | =c/bigred +
| | | | | bigred=CTc/bigred
(4 rows)
bigred=# exit
bash-5.1# exit
exit

Podman Pod Install and configure backstage

撰寫 Backstage-Base Dockerfile

$ nano ~/backstage/build-image/Dockerfile

檔案內容如下

FROM quay.io/hahappyman/alpine:3.18.3
RUN apk update; apk add -U --update nodejs npm bash git curl python3 make g++ grep nano sudo
RUN npm install --global yarn
RUN echo backstage | npx -y @backstage/create-app@latest
CMD ["bash","-c","sleep infinity"]

Build Image

$ sudo podman build --no-cache -t backstage:test-v3 ~/backstage/build-image/

撰寫 Pod Yaml 檔

$ nano ~/backstage/podman-pod/backstage.yaml

檔案內容如下

apiVersion: v1
kind: Pod
metadata:
name: backstage
spec:
hostNetwork: true
containers:
- name: backstage
image: localhost/backstage:test-v3

建立 Pod

$ sudo podman play kube ~/backstage/podman-pod/backstage.yaml

檢視 Pod 運作狀態

$ sudo podman ps -a --pod

螢幕輸出

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD ID PODNAME
5c988d43542e localhost/podman-pause:4.5.1-1691040180 18 minutes ago Up 18 minutes 0.0.0.0:5432->5432/tcp a04d6f726984-infra a04d6f726984 postgres
6b82228580d5 docker.io/library/postgres:13.2-alpine postgres 18 minutes ago Up 18 minutes 0.0.0.0:5432->5432/tcp postgres-postgres a04d6f726984 postgres
b7446c631837 localhost/podman-pause:4.5.1-1691040180 13 minutes ago Up 13 minutes e16d6198a544-infra e16d6198a544 backstage
56c72ba57f21 localhost/backstage:test-v3 bash -c sleep inf... 13 minutes ago Up 13 minutes backstage-backstage e16d6198a544 backstage

設定 Backstage

$ sudo podman exec -it backstage-backstage bash
backstage:/# cd backstage && nano -l app-config.yaml

app-config.yaml 要修改的檔案內容如下

## Setup IP Address and organization.Name
1 app:
2 title: Scaffolded Backstage App
3 baseUrl: http://192.168.61.4:3000
...
5 organization:
6 name: Bobo_backstage
...
8 backend:
15 baseUrl: http://192.168.61.4:7007
24 cors:
25 origin: http://192.168.61.4:3000
...
## Setting Up PostgreSQL
30 database:
31 client: pg
32 connection:
33 host: 192.168.61.4
34 port: 5432
35 user: bigred
36 password: bigred
...
## Setting up a GitHub Integration
42 integrations:
43 github:
44 - host: github.com
47 token: XXX
...
## 待確認
76 scaffolder:
77 github:
78 token: XXX

app-config.production.yaml 要修改的檔案內容如下

$ nano -l app-config.production.yaml

## Setup IP Address and organization.Name
1 app:
2 # Should be the same as backend.baseUrl when using the `app-backend` plugin.
3 baseUrl: http://192.168.61.4:7007
...
5 backend:
11 baseUrl: http://192.168.61.4:7007
...
## Setting Up PostgreSQL
17 database:
18 client: pg
19 connection:
20 host: 192.168.61.4
21 port: 5432
22 user: bigred
23 password: bigred

進入工作目錄並初始化 git

backstage:/backstage# git init

設置 git 使用者資訊

backstage:/backstage# git config --global user.email "test@backstage.com"
backstage:/backstage# git config --global user.name "root"

將工作目錄追加至 git stage

backstage:/backstage# git add .

進行初次 git commit

backstage:/backstage# git commit -m "Initial commit"

安裝相依檔案

backstage:/backstage# yarn install

部屬 Backstage

backstage:/backstage# yarn dev &

打開瀏覽器，連線至 `http://Podman_Host_主機_IP:3000`

DropBox

What is Backstage?

Backstage 是 Spotify 開發的開源、可自訂的 IDP 工具，目前由 CNCF 維護
- 戰略目標：
  - 透過統一介面，提供團隊一致的開發環境。
- 詳細描述：
  - Backstage 實現在統一的介面，進行開發與資源管理，免去跨工具的資訊統合問題，更有效率的開發與管理應用系統，使團隊成員更能掌握目前的開發狀態。
Backstage 核心組件
- TechDocs
- Softwre Catalog
- Softwre Templates
- Search
- Plugin

What is IDP?

IDP｜Internal Developer Platform企業為內部開發人員提供的一個平台，用於開發、部署和運營應用系統。幫助開發人員提高生產力、降低成本，並改善應用系統的品質。
IDP 工具的核心關鍵
- 提供效益
  - 提高生產力｜自動化開發和部署流程，提高開發人員生產力
  - 降低成本｜減少人工成本，並提高資源利用率
  - 改善品質｜確保應用程式的品質和可靠性
- 應用工具
  - 開發工具｜提供 IDE、編輯器、測試工具等開發工具，幫助開發人員快速有效地開發應用程式
  - 部署工具｜提供 CI/CD 工具、容器化工具等部署工具，幫助開發人員將應用程式部署到生產環境
  - 運營工具｜提供監控工具、報表工具等運營工具，幫助開發人員管理和監控應用程式的運行狀態

本機部署流程

Ubuntu 流程：nodejs » 相依套件 » git 初始化 & first commit » yarn 相依檔案安裝與部署

#更新套件清單
sudo apt update
#安裝相依套件
sudo apt install make python3 g++ build-essential git-all
#安裝 nvm
curl -so - https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash
#確認 nvm 版本
nvm -v
0.39.5
#使用 nvm 安裝指定版本 nodejs（LTS）
nvm install v18.17.1
Downloading and installing node v18.17.1...
Downloading https://nodejs.org/dist/v18.17.1/node-v18.17.1-linux-x64.tar.xz...
############################################################################################################################################################################# 100.0%
Computing checksum with sha256sum
Checksums matched!
Now using node v18.17.1 (npm v9.6.7)
Creating default alias: default -> 18.17.1 (-> v18.17.1)
#指定使用 nodejs 版本
nvm use v18.17.1
Now using node v18.17.1 (npm v9.6.7)
#安裝 yarn
npm install yarn
## Ub Server 22.04 安裝 yarn
npm install --global yarn

#安裝 backstage
npx @backstage/create-app@latest
...
🥇 Successfully created backstage
All set! Now you might want to:
Install the dependencies: cd backstage && yarn install
Run the app: cd backstage && yarn dev
Set up the software catalog: https://backstage.io/docs/features/software-catalog/configuration
Add authentication: https://backstage.io/docs/auth/

#進入工作目錄並初始化 git
cd backstage && git init
#設置 git 使用者資訊
git config --global user.email "test@backstage.com"
git config --global user.name "backstage"
#將工作目錄追加至 git stage
git add .
#進行初次 git commit
git commit -m "Initial commit"
#使用 yarn 安裝相依檔案
yarn install
#使用 yarn 部署 backstage
yarn dev
yarn run v1.22.19
$ concurrently "yarn start" "yarn start-backend"
$ yarn workspace backend start
$ yarn workspace app start
$ backstage-cli package start
$ backstage-cli package start
[1] Build succeeded
[0] Loaded config from app-config.yaml
[0] <i> [webpack-dev-server] Project is running at:
[0] <i> [webpack-dev-server] On Your Network (IPv4): http://192.168.115.80:3000/
[0] <i> [webpack-dev-server] Content not from webpack is served from '/home/bigred/backstage/packages/app/public' directory
[0] <i> [webpack-dev-server] 404s will fallback to '/index.html'
[1] Loaded config from app-config.yaml
[1] 2023-09-11T17:56:52.343Z backstage info Found 2 new secrets in config that will be redacted
[1] 2023-09-11T17:56:52.358Z backstage info Created UrlReader predicateMux{readers=azure{host=dev.azure.com,authed=false},bitbucketCloud{host=bitbucket.org,authed=false},github{host=github.com,authed=false},gitlab{host=gitlab.com,authed=false},awsS3{host=amazonaws.com,authed=false},fetch{}
[1] 2023-09-11T17:56:52.399Z catalog info Performing database migration type=plugin
[1] 2023-09-11T17:56:52.991Z auth info Configuring "database" as KeyStore provider type=plugin
[1] 2023-09-11T17:56:53.009Z techdocs info Creating Local publisher for TechDocs type=plugin
[1] 2023-09-11T17:56:53.015Z search info Added DefaultCatalogCollatorFactory collator factory for type software-catalog type=plugin
[1] 2023-09-11T17:56:53.016Z search info Added DefaultTechDocsCollatorFactory collator factory for type techdocs type=plugin
[1] 2023-09-11T17:56:53.017Z search info Starting all scheduled search tasks. type=plugin
[1] 2023-09-11T17:56:53.193Z backstage info Listening on :7007
[1] 2023-09-11T17:56:53.211Z backstage info Task worker starting: search_index_software_catalog, {"version":2,"cadence":"PT10M","initialDelayDuration":"PT3S","timeoutAfterDuration":"PT15M"} type=taskManager task=search_index_software_catalog
[1] 2023-09-11T17:56:53.213Z backstage info Task worker starting: search_index_techdocs, {"version":2,"cadence":"PT10M","initialDelayDuration":"PT3S","timeoutAfterDuration":"PT15M"} type=taskManager task=search_index_techdocs
[0] <i> [webpack-dev-middleware] wait until bundle finished: /
[0] <i> [webpack-dev-middleware] wait until bundle finished: /apple-touch-icon-precomposed.png
[0] <i> [webpack-dev-middleware] wait until bundle finished: /apple-touch-icon.png
[0] <i> [webpack-dev-middleware] wait until bundle finished: /favicon.ico
[0] <i> [webpack-dev-middleware] wait until bundle finished: /apple-touch-icon-precomposed.png
[0] <i> [webpack-dev-middleware] wait until bundle finished: /
[0] <i> [webpack-dev-middleware] wait until bundle finished: /favicon.ico
[0] <i> [webpack-dev-middleware] wait until bundle finished: /apple-touch-icon.png
[1] 2023-09-11T17:56:56.218Z search info Collating documents for software-catalog via DefaultCatalogCollatorFactory type=plugin documentType=software-catalog
[1] 2023-09-11T17:56:56.247Z search info Collating documents for techdocs via DefaultTechDocsCollatorFactory type=plugin documentType=techdocs
[1] 2023-09-11T17:56:56.331Z backstage info ::ffff:127.0.0.1 - - [11/Sep/2023:17:56:56 +0000] "GET /api/catalog/entities?filter=metadata.annotations.backstage.io%2Ftechdocs-ref&fields=kind,namespace,metadata.annotations,metadata.name,metadata.title,metadata.namespace,spec.type,spec.lifecycle,relations&offset=0&limit=500 HTTP/1.1" 200 2 "-" "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)" type=incomingRequest
[1] 2023-09-11T17:56:56.344Z search warn Index for techdocs was not created: indexer received 0 documents type=plugin documentType=techdocs
[1] 2023-09-11T17:56:56.347Z search info Collating documents for techdocs succeeded type=plugin documentType=techdocs
[1] 2023-09-11T17:56:56.353Z backstage info ::ffff:127.0.0.1 - - [11/Sep/2023:17:56:56 +0000] "GET /api/catalog/entities?offset=0&limit=500 HTTP/1.1" 200 - "-" "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)" type=incomingRequest
[1] 2023-09-11T17:56:56.382Z search info Collating documents for software-catalog succeeded type=plugin documentType=software-catalog
[0] webpack compiled successfully
...

Backstage OverView

Sat, 23 Sep 2023 06:46:00 +0800

Preface

本篇文章會主要會分做 3 個部分介紹

甚麼是 Backstage

可以透過點擊展開以下目錄，選擇想看的內容，跳轉至特定章節

Backstage Instance

Backstage 實例是使用 Backstage 核心庫建立的 Node/React 應用程序，您可以在其上安裝社群和私人插件。

Backstage 使用三層模型來解釋如何使用其框架建立開發人員入口網站 :

Core 這是 Backstage 團隊維護和以開源方式發布的內容。除非您想為該專案做出貢獻，否則您可能不需要從一開始就了解這部分。
App 該應用程式是您提供給開發人員的 Developer Portal ( 開發人員入口網站 )。在採用 Backstage 的過程中，您將與此部分進行最多的互動。
Plugins 您可以安裝 Plugins 來擴展您的實例功能。即使是基本的功能也被抽象為 Plugins ，包括 Catalog。因此，您將始終使用少量的 Plugins 。有幾十個社群 Plugins 可用來整合流行的服務。您也可以自己創建 Plugins 。

backstage core functionalities

Backstage offers five core functionalities:

a software catalog
software templates
a documentation generator
a Kubernetes cluster visualizer
cross-ecosystem search capabilities.

Introducing the Software Catalog

Catalog 的目的是將企業中的所有應用系統，包括網站、API、程式庫和資源，映射到一個集中式目錄。這種集中化旨在幫助團隊管理技術並實現可發現性。Catalog 能持續追蹤每個 Application 的 metadata ( 元數據 )、所有權和依賴關係，從而生成一個軟體圖，其中包含孤立的 entities。

Catalog 由儲存在 YAML 檔案中的 metadata 提供支持，YAML 檔案描述了每個檔案中單一 entitiy 的種類、類型、名稱、所有者和更多細節。這些檔案通常儲存在各自的程式碼庫中，因此會經常更新。有些 entities 類型可能有權威來源，但程式庫中沒有體現，例如，Okta 規定的使用者和團隊。

Introducing the Software Template

Backstage 中的 Software Template 軟體範本是一種工具，可幫助您在 Backstage 中建立元件。預設情況下，它可以加載程式碼的骨架，將範本包含在某些變數中，然後將範本發佈到 GitHub 或 GitLab 等位置。

Software Template 在 YAML 檔案中定義，該檔案指定要執行的參數和步驟。Backstage 將根據在 Software Template 中指定的參數，在 Scaffolder 中生成 UI。對於步驟，您可以使用內建動作來執行常見的取用操作，但您也可以定義自己的動作。

範本存儲在 Catalog 中的 template 種類下。此外，由 Scaffolder 初始化的所有元件都會自動添加到 Catalog 中。因此，Scaffolder 和 Catalog 之間有一個良性循環，可以促進可發現性和標準化。

bash script 筆記

Thu, 20 Jul 2023 07:40:42 +0800

初學

bash script 開始下達指令

bigred@m1:~$ command [-option] parameter1 parameter2
指令 選項 參數1 參數2

上述指令詳細說明如下：

一行指令中第一個輸入的部分絕對是『指令(command)』或『可執行檔案(例如批次腳本,script)』
command 為指令的名稱，例如變換工作目錄的指令為 cd 等等；
中刮號[]並不存在於實際的指令中，而加入選項設定時，通常選項前會帶 - 號，例如 -h；有時候會使用選項的完整全名，則選項前帶有 – 符號，例如 –help；
parameter1 parameter2.. 為依附在選項後面的參數，或者是 command 的參數；
指令, 選項, 參數等這幾個咚咚中間以空格來區分，不論空幾格 shell 都視為一格。所以空格是很重要的特殊字元！；
按下[Enter]按鍵後，該指令就立即執行。[Enter]按鍵代表著一行指令的開始啟動。
指令太長的時候，可以使用反斜線 () 來跳脫[Enter]符號，使指令連續到下一行。注意！反斜線後就立刻接特殊字符，才能跳脫！
其他：
- 在 Linux 系統中，英文大小寫字母是不一樣的。舉例來說， cd 與 CD 並不同。

查看環境變數 PATH

echo $PATH ➡️ linux 輸入法
echo %PATH% ➡️ windows 輸入法
環境變數PATH：
- 記錄所有可執行命令所在的目錄路徑，因此若命令的儲存路徑沒有記錄在PATH中，則無法執行。
- $PATH 告知 OS 哪裡會存放可執行的檔案，會依照先後順序找檔名，並且執行。若要執行的檔案不放在 $PATH 的目錄裡的話則需要使用相對/絕對路徑來執行

Linux重要的幾個熱鍵

[Tab]按鍵

[Tab]按鍵算是Linux的Bash shell最棒的功能之一了！他具有『命令補全』與『檔案補齊』的功能喔！重點是，可以避免我們打錯指令或檔案名稱呢！很棒吧！但是[Tab]按鍵在不同的地方輸入，會有不一樣的結果喔！我們舉下面的例子來說明。上一小節我們不是提到 cal 這個指令嗎？如果我在指令列輸入 ca 再按兩次 [tab] 按鍵，會出現什麼訊息？

bigred@m1:~$ ca[tab][tab] <==[tab]按鍵是緊接在 a 字母後面！
cal caller capsh case cat
# 上面的 [tab] 指的是『按下那個tab鍵』，不是輸入中括號內的tab

以ca為開頭的指令都被顯示出來了，如果輸入『ls -al ~/.bash』再加兩個[tab]會出現什麼？

[ dmtsai@study ~]$ ls -al ~/.bash[tab][tab]
.bash_history .bash_logout .bash_profile .bashrc

該目錄下面所有以 .bash 為開頭的檔案名稱都會被顯示出來了，我們按[tab]按鍵的地方如果是在command(第一個輸入的資料)後面時，他就代表著『命令補全』，如果是接在第二個字以後的，就會變成『檔案補齊』的功能！但是在某些特殊的指令底下，檔案補齊的功能可能會變成『參數/選項補齊』！我們同樣使用 date 這個指令來查一下：

[dmtsai@study ~]$ date --[tab][tab] <==[tab]按鍵是緊接在 -- 後面！
--date --help --reference= --rfc-3339= --universal
--date= --iso-8601 --rfc-2822 --set= --version
# 系統會列出來 date 這個指令可以使用的選項有哪些喔～包括未來會用到的 --date 等項目

總結:

[Tab] 接在一串指令的第一個字的後面，則為『命令補全』
[Tab] 接在一串指令的第二個字以後時，則為『檔案補齊』
若安裝 bash-completion 軟體，則在某些指令後面使用 [tab] 按鍵時，可以進行『選項/參數的補齊』功能 善用 [tab] 按鍵真的是個很好的習慣！可以避免掉很多輸入錯誤的機會！

[Ctrl]-c 按鍵

如果你在Linux底下輸入了錯誤的指令或參數，有的時候這個指令或程式會在系統底下『跑不停』這個時候怎麼辦？別擔心，如果你想讓當前的程式『停掉』的話，可以輸入：[Ctrl]與c按鍵(先按著[Ctrl]不放，且再按下c按鍵，是組合按鍵)，那就是中斷目前程式的按鍵！舉例來說，如果你輸入了『find /』這個指令時，系統會開始跑一些東西(先不要理會這個指令串的意義)，此時你給他按下 [Ctrl]-c 組合按鍵，嘿嘿！是否立刻發現這個指令串被終止

[bigred@m1 ~]$ find /
....(一堆東西都省略)....
# 此時螢幕會很花，你看不到命令提示字元的！直接按下[ctrl]-c即可！
[bigred@m1 ~]$ <==此時提示字元就會回來了！find程式就被中斷！

[Ctrl]-e 按鍵

游標 (cursor) 移到行首

[Ctrl]-a 按鍵

游標 (cursor) 移到行尾

Linux文書編輯器： `nano`

nano的使用，可以直接加上檔名就能夠開啟一個舊檔或新檔

[dmtsai@study ~]$ nano text.txt
# 不管text.txt存不存在都沒有關係！存在就開啟舊檔，不存在就開啟新檔
GNU nano 2.3.1 File: text.txt
<==這個是游標所在處
[ New File ]
^G Get Help ^O WriteOut ^R Read File ^Y Prev Page ^K Cut Text ^C Cur Pos
^X Exit ^J Justify ^W Where Is ^V Next Page ^U UnCut Te ^T To Spell
# 上面兩行是指令說明列，其中^代表的是[ctrl]的意思

如上所示，可以看到第一行反白的部分，那僅是在宣告nano的版本與檔名(File: text.txt)而已。之後你會看到最底下的三行，分別是檔案的狀態(New File)與兩行指令說明列。指令說明列反白的部分就是組合鍵，接的則是該組合鍵的功能。那個指數符號(^)代表的是鍵盤的[Ctrl]按鍵啦！底下先來說說比較重要的幾個組合按鍵：

[ctrl]-G：取得線上說明(help) [ctrl]-X：離開nano軟體，若有修改過檔案會提示是否需要儲存 [ctrl]-O：儲存檔案，若有權限的話就能夠儲存檔案了 [ctrl]-R：從其他檔案讀入資料，可以將某個檔案的內容貼在本檔案中 [ctrl]-W：搜尋字串 [ctrl]-C：說明目前游標所在處的行數與列數等資訊 ~~[ctrl]-_：可以直接輸入行號，讓游標快速移動到該行；~~ #m1沒有 ~~[alt]-Y：校正語法功能開啟或關閉(按一下開、再按一下關)~~ #m1沒有 ~~[alt]-M：可以支援滑鼠來移動游標的功能~~ #m1沒有

以上資料參考自鳥哥的私房菜第四篇

Linux查看記憶體指令—`free`:

顯示系統內部實體記憶體及Swap的使用情況，初步會以KB為單位改進單位轉換成Bytes，MB和GB，分別是-b，-m和-g，加上 -t 參數，會顯示實體記憶體加上 Swap 的合共記憶體:

g06220565@cloudshell:~ (peppy-amplifier-324003)$ free -g -t
total used free shared buff/cache available
Mem: 15 1 13 0 1 14
Swap: 0 0 0
Total: 15 1 13

加上 -s 參數會在特定秒數自動重新執行 free 指令, 例如下面會以 MB 為單位, 並會每 5 秒印出一次新資料:

g06220565@cloudshell:~$ free -gt -s 5
total used free shared buff/cache available
Mem: 15 1 13 0 1 13
Swap: 0 0 0
Total: 15 1 13
total used free shared buff/cache available
Mem: 15 1 13 0 1 13
Swap: 0 0 0
Total: 15 1 13

要終止執行按 Ctrl + C 。

mem：實體記憶體統計。 swap：硬碟上交換分割槽的使用情況。只有mem被當前程序實際佔用完,即沒有了buffers和cache時，才會使用到swap。

mem 行（第一行）資料說明： total：實體記憶體總大小。 used：總計分配給快取（包含buffers 與cache ）使用的數量，但其中可能部分快取並未實際使用。 free：未被分配的記憶體。 shared：共享記憶體，一般系統不會用到。 buffers(緩衝區)：系統分配但未被使用的buffers 數量。 cached(緩存)：系統分配但未被使用的cache 數量。

補充: 緩衝區(buffers)是尚未被"寫入"磁盤的東西。緩存(cached)是指已經從磁盤上"讀"出並存儲起來供以後使用的東西。

更詳細的解釋參考：Difference Between Buffer and Cache

Buffer：緩衝區，一個用於存儲速度不同步的設備或優先級不同的設備之間傳輸數據的區域。通過緩衝區，可以使進程之間的相互等待變少，從而使從速度慢的設備讀入數據時，速度快的設備的操作進程不發生間斷。

Cache：高速緩存，是位於CPU與主記憶體間的一種容量較小但速度很高的記憶體。由於CPU的速度遠高於主記憶體，CPU直接從記憶體中存取數據要等待一定時間週期，Cache中保存著CPU剛用過或迴圈使用的一部分數據，當CPU再次使用該部分數據時可從Cache中直接調用,這樣就減少了CPU的等待時間,提高了系統的效率。Cache又分為一級Cache(L1 Cache)和二級Cache(L2 Cache)，L 1 C ache集成在CPU內部，L 2 C ache早期一般是焊在主板上,現在也都集成在CPU內部，常見的容量有256KB或512KB L2 Cache。

Free中的buffer和cache（它們都是佔用記憶體）：　　buffer : 作為buffer cache的記憶體，是塊設備的讀寫緩衝區　　cache : 作為page cache的記憶體, 文件系統的cache

　　如果 cache 的值很大，說明cache住的文件數很多。如果頻繁訪問到的文件都能被cache住，那麼磁片的讀IO bi會非常小。

bash script 練習

請撰寫 mysys 程式, 執行功能如下 :

$ ./mysys ./mysys [add|del|start|stop|list] object

$ ./mysys add xx add xx

$ ./mysys start start

$ ./mysys test ./mysys [add|del|start|stop|list] object

答案:

g06220565@cloudshell:~$ nano mysys
#!/bin/bash
case $1 in
add)
echo $0
;;
del)
echo $@
;;
start)
echo $@
;;
stop)
echo $@
;;
list)
echo $@
;;
*)
echo "./nysys [add|del|start|stop|list] odject"
;;
esac
g06220565@cloudshell:~$ ./mysys ## "."代表的是g06220565的家目錄

改裝

#!/bin/bash
case $1 in
add)
echo -e "$2\n$2" | sudo adduser -s /bin/bash $2
;;
del)
sudo deluser --remove-home $2
;;
start)
echo "Oops"
;;
stop)
echo "Oops"
;;
list)
echo "Oops"
;;
*)
echo "./nysys [add|del|start|stop|list] odject"
;;
esac

進階

sed ( stream editor )

取代檔案的特定行數內容

$ sed -i "5cxxx" sigd.sh

-i ，代表要對檔案進行修改 5c ，第一個數字代表第幾行，後面的c，代表會直接將原本第五行的內容取代 xxx ，代表要更改的字串 sighd.sh ，要更改的檔案

對檔案特定行數插入內容，如果該行有內容，會自動往下移一行，該行之後的內容也是

$ sed -i "5ixxx" sigd.sh

-i ，代表要對檔案進行修改 5ixxx ，第一個數字是指定要第幾行，後面的i則是會在第五行插入後面的xxx，如果原本的檔案第五行之後還有更多行內容，則全部往下移一行。

sed 參考文件 ( 初學 ) sed 參考文件 ( 原文 )

`sigh.sh`

功能：自動設定 ip , gateway , dns 的 ip 位址（ Alpine Linux 版本）使用：dns 的 ip 透過參數給定， ip 與 gateway 執行程式後再給

#!/bin/bash
read -p "ip / gateway" ans1 ans2
sudo tee /etc/network/interfaces<<EOF
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet static
address $ans1
gateway $ans2
EOF
if [ "$#" -ge "1" ];then
echo "" | sudo tee /etc/resolv.conf 1>/dev/null
echo "search localdomain" | sudo tee /etc/resolv.conf 1>/dev/null
no=0
for c in $@
do
abc[$no]=$c
no=$((no+1))
done
no=0
while((no<$#))
do
echo "nameserver ${abc[$no]}" | sudo tee -a /etc/resolv.conf
no=$((no+1))
done
else
echo "請給 DNS 的參數，謝謝！"
fi

變數處理

name="John"
echo ${name}
echo ${name/J/j} #=> "john" (substitution)
echo ${name:0:2} #=> "Jo" (slicing)
echo ${name::2} #=> "Jo" (slicing)
echo ${name::-1} #=> "Joh" (slicing)
echo ${name:(-1)} #=> "n" (slicing from right)
echo ${name:(-2):1} #=> "h" (slicing from right)
echo ${food:-Cake} #=> $food or "Cake"

STR="/path/to/foo.cpp"
echo ${STR%.cpp} # /path/to/foo
echo ${STR%.cpp}.o # /path/to/foo.o
echo ${STR%/*} # /path/to
echo ${STR##*.} # cpp (extension)
echo ${STR##*/} # foo.cpp (basepath)
echo ${STR#*/} # path/to/foo.cpp
echo ${STR##*/} # foo.cpp
echo ${STR/foo/bar} # /path/to/bar.cpp
STR="Hello world"
echo ${STR:6:5} # "world"
echo ${STR: -5:5} # "world"
SRC="/path/to/foo.cpp"
BASE=${SRC##*/} #=> "foo.cpp" (basepath)
DIR=${SRC%$BASE} #=> "/path/to/" (dirpath)

補充連結

Bash Hackers 連結

可以埋進開機登入後的第一支程式

#!/bin/bash
#從不解析名字的路由表，找目的地為本機的路由資訊
gw=$(route -n | grep -e "^0.0.0.0 ")
#宣告$gw的網卡資訊為環境變數
export GWIF=${gw##* }
#從ifconfig找本機的IP位址、網路遮罩、廣播位址
ips=$(ifconfig $GWIF | grep 'inet ')
#宣告本機IP為環境變數
export IP=$(echo $ips | cut -d' ' -f2 | cut -d':' -f2)
#宣告本機之Class C網段位址為環境變數
export NETID=${IP%.*}
#宣告本機的路由Gateway為環境變數
export GW=$(route -n | grep -e '^0.0.0.0' | tr -s \ - | cut -d ' ' -f2)
#將hostname寫入/tmp/sinfo
echo "[System]" > /tmp/sinfo
echo "Hostname : `hostname`" >> /tmp/sinfo
#將記憶體大小寫入/tmp/sinfo
m=$(free -mh | grep Mem: | tr -s ' ' | cut -d' ' -f2)
echo "Memory : ${m}M" >> /tmp/sinfo
#將CPU的型號及核心數寫入/tmp/sinfo
cname=$(cat /proc/cpuinfo | grep 'model name' | head -n 1 | cut -d ':' -f2)
cnumber=$(cat /proc/cpuinfo | grep 'model name' | wc -l)
echo "CPU : $cname (core: $cnumber)" >> /tmp/sinfo
#將硬碟大小資訊寫入/tmp/sinfo
m=$(df -h | grep /dev/sda)
ds=$(echo $m | cut -d ' ' -f2)
echo "Disk : $ds" >> /tmp/sinfo
echo "" >> /tmp/sinfo
#將IP位址、Gateway資訊寫入/tmp/sinfo
echo "[Network]" >> /tmp/sinfo
echo "IP : $IP" >> /tmp/sinfo
echo "Gateway : $GW" >> /tmp/sinfo
#將域名的名稱伺服器寫入/tmp/sinfo
cat /etc/resolv.conf | grep 'nameserver' | head -n 1 >> /tmp/sinfo
#ping外網，若有通則將"Internet OK"寫入/tmp/sinfo
/bin/ping -c 1 www.hinet.net
[ "$?" == "0" ] && echo "Internet OK" >> /tmp/sinfo

Alpine 開機自動執行程式

$ sudo nano /etc/local.d/*.start

Alpine 開機時會自動執行在 /etc/local.d/ 目錄下 *.start 的檔案

$ sudo chmod +x /etc/local.d/*.start

記得給權限

設定當前使用者執行 sudo 免密碼

$ vi init.sh

檔案內容 :

#!/bin/bash
# Debug mode
set -x
# test sudo, run as root
if ! command -v sudo &>/dev/null; then
echo "pls install sudo command: zypper in -y sudo, or you can run as root"
fi
# var
line_base_a=$(sudo cat /etc/sudoers | grep -n 'NOPASSWD: ALL')
line_base_b=$(cat /etc/group | grep -nw "^wheel")
user_name=$(id -un)
# check var
if [[ -z "${line_base_a%%:*}" ]] || [[ -z "${line_base_b%%:*}" ]];then
echo "var has error" && exit 0
fi
# 設定 wheel 群組執行 sudo 命令時免密碼
sudo sed -i "${line_base_a%%:*}s|#||" /etc/sudoers
# 將當前使用者加入 wheel 群組
sudo sed -i "${line_base_b%%:*}s|$|${user_name}|" /etc/group

$ curl -s https://raw.githubusercontent.com/braveantony/bash-script/bbc34c7729a9b4164ab9dcc282cb771cb9d94e83/init.sh | bash

tags: `Shell Script`

cgidb.sh program

Sat, 01 Jul 2023 13:13:52 +0800

2023/07/01

#!/bin/bash
echo "Content-type: text/html"
echo ""
echo '<html>'
echo ' <head><meta charset="utf-8" /> </head>'
echo '<body>'
# MySQL Server Connection test
[ ! -f /opt/www/cgi/dagger.ini ] && echo "<h1><center>pls setup first ! <a href="/setup">setup</a></p></center></h1>" && exit 0
source "/opt/www/cgi/dagger.ini"
if ! mysql --connect-timeout=1 -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "show databases;" &>/dev/null; then
echo '<h1><center>MySQL Cluster connection <font color="red">failed</font> !
<p>pls Setup again, thx!
<a href="/setup">setup</a></p></center></h1>' && exit 0
fi
# var
HTML=$(echo ${QUERY_STRING%=*} | cut -d "=" -f 1)
Action=$(echo $QUERY_STRING | cut -d '=' -f3 | cut -d '+' -f1)
ALL_COMMAND=$(echo $REQUEST_URI | cut -d '=' -f3 | sed 's/+/ /g' | sed 's/%28/(/g' | sed 's/%29/)/g' | sed 's/%2C/,/g' | sed 's/%3B/;/g' | sed "s/%27/'/g" | sed 's/%22/"/g' | sed 's/%3D/=/g' | sed 's/%0D%0A/ /g')
ALL_COMMAND_tbl=${ALL_COMMAND%%&*}
Action_tbl=${QUERY_STRING##*=}
tbl=$(mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "use $DB_name;$ALL_COMMAND_tbl")
tbl_name=$(echo ${QUERY_STRING%&*} | cut -d "=" -f 3)
# Debug
#echo "<br>REQUEST_URI=${REQUEST_URI}</br>"
#echo "<br>QUERY_STRING=${QUERY_STRING}</br>"
#echo "<br>DBname=$DB_name</br>"
#echo "<br>HTML=$HTML</br>"
#echo "<br>Action=$Action</br>"
#echo "<br>Action_tbl=$Action_tbl</br>"
#echo "<br>ALL_COMMAND=${ALL_COMMAND}</br>"
#echo "<br>ALL_COMMAND_tbl=${ALL_COMMAND_tbl}</br>"
#echo "<br>tbl_name=$tbl_name</br>"
# function
DB_list() {
set -f # disable globbing
saveIFS=$IFS
IFS=$'\n' # set field separator to NL (only)
ALL_DB=$(mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "show databases;")
cat /dev/null >/opt/www/cgi/db.txt
for i in ${ALL_DB[@]}; do
if [ "$i" != "Database" ]; then
echo " <option>$i</option>" >>/opt/www/cgi/db.txt
else
echo " <option>請選擇資料庫名稱</option>" >>/opt/www/cgi/db.txt
fi
done
IFS=$saveIFS
set +f
sed -i "/<option>/d" /opt/www/html/tbl.html
line=$(cat /opt/www/html/tbl.html | grep -n 'select type' | cut -d ":" -f 1)
sed -i "${line} r /opt/www/cgi/db.txt" /opt/www/html/tbl.html
}
tbl_action() {
mysql --show-warnings -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "use $DB_name;$ALL_COMMAND_tbl" 1> /tmp/out.txt 2> /tmp/err-out.txt
[[ "$?" == "0" ]] && echo -e "<h1 style="color:blue">\nCommand success</h1>"
[[ -s /tmp/err-out.txt ]] && show_err
}
show() {
echo "<pre>"
echo "<font size="6">"
cat /tmp/out.txt
echo "</pre>"
echo "</font>"
}
show_err() {
echo "<pre>"
echo "<font size="6">"
cat /tmp/err-out.txt
echo "</pre>"
echo "</font>"
}
show_db() {
echo "<pre>"
echo "<font size="6">"
cat /tmp/dbout.txt
echo "</pre>"
echo "</font>"
}
DB_list
if [[ "$HTML" == "tblname" ]]; then
DB_name=$(echo ${QUERY_STRING%%&*} | cut -d "=" -f 2)
case ${Action_tbl} in
DROP)
if ! echo "$ALL_COMMAND_tbl" | grep 'drop'; then
if mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "use ${DB_name}; DROP TABLE ${tbl_name}"; then
echo -e "<h1 style="color:blue">\nCommand success</h1>"
else
echo -e "<h1 style="color:red">\nCommand fail</h1>"
fi
else
tbl_action
show
fi
;;
*)
tbl_action
show
;;
esac
echo '<h1><center><a href="../html/tbl.html">返回上一頁</a></center></h1>'
else
if [[ $Action == "SHOW" ]]; then
mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "SHOW DATABASES" >/tmp/dbout.txt && show_db
else
DB_name=$(echo ${QUERY_STRING%%&*} | cut -d "=" -f 2)
mysql --show-warnings -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "${Action} DATABASE ${DB_name}" >/tmp/dbout.txt
if ! cat /tmp/dbout.txt | grep 'Error'; then
mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "SHOW DATABASES" >/tmp/dbout.txt && show_db && DB_list
else
show_db && DB_list
fi
fi
fi
echo '</body></html>'
exit 0

2023/1/10 最新版

#!/bin/bash
echo "Content-type: text/html"
echo ""
echo '<html>'
echo ' <head><meta charset="utf-8" /> </head>'
echo '<body>'
echo '<h1>call from mydb.sh</h1>'
# var
DB_user="dagger"
DB_passwd="dagger"
DB_ip="10.98.0.203"
DB_name=$(echo ${QUERY_STRING%%&*} | cut -d "=" -f 2)
HTML=$(echo ${QUERY_STRING%=*} | cut -d "=" -f 1)
Action=$(echo $QUERY_STRING | cut -d '=' -f3 | cut -d '+' -f1)
ALL_COMMAND=$(echo $REQUEST_URI | cut -d '=' -f3 | sed 's/+/ /g' | sed 's/%28/(/g' | sed 's/%29/)/g' | sed 's/%2C/,/g' | sed 's/%3B/;/g' | sed "s/%27/'/g" | sed 's/%22/"/g' | sed 's/%3D/=/g' | sed 's/%0D%0A/ /g')
ALL_COMMAND_tbl=${ALL_COMMAND%%&*}
Action_tbl=${QUERY_STRING##*=}
tbl=$(mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "use $DB_name;$ALL_COMMAND_tbl")
tbl_name=$(echo ${QUERY_STRING%&*} | cut -d "=" -f 3)
# Debug
echo "<br>REQUEST_URI=${REQUEST_URI}</br>"
echo "<br>QUERY_STRING=${QUERY_STRING}</br>"
echo "<br>DBname=$DB_name</br>"
echo "<br>HTML=$HTML</br>"
echo "<br>Action=$Action</br>"
echo "<br>Action_tbl=$Action_tbl</br>"
echo "<br>ALL_COMMAND=${ALL_COMMAND}</br>"
echo "<br>ALL_COMMAND_tbl=${ALL_COMMAND_tbl}</br>"
echo "<br>tbl_name=$tbl_name</br>"
# function
DB_list() {
set -f # disable globbing
saveIFS=$IFS
IFS=$'\n' # set field separator to NL (only)
ALL_DB=$(mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "show databases;")
cat /dev/null > /opt/www/cgi/db.txt
for i in ${ALL_DB[@]}
do
if [ "$i" != "Database" ]; then
echo " <option>$i</option>" >> /opt/www/cgi/db.txt
else
echo " <option><b>請選擇資料庫名稱</b></option>" >> /opt/www/cgi/db.txt
fi
done
IFS=$saveIFS
set +f
sed -i "/<option>/d" /opt/www/html/tbl.html
line=$(cat /opt/www/html/tbl.html | grep -n 'select type' | cut -d ":" -f 1)
sed -i "${line} r /opt/www/cgi/db.txt" /opt/www/html/tbl.html
}
display() {
echo "<h1>${tbl}</h1>"
if [ "$?" == "0" ]; then
echo -e "<h1 style="color:blue">\nCommand success</h1>"
else
echo -e "<h1 style="color:red">\nCommand fail</h1>"
fi
}
if [[ $HTML == tblname ]]; then
case ${Action_tbl} in
CREATE)
display
;;
DROP)
if ! echo "$ALL_COMMAND_tbl" | grep 'drop'; then
if mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "use ${DB_name}; DROP TABLE ${tbl_name}"; then
echo -e "<h1 style="color:blue">\nCommand success</h1>"
else
echo -e "<h1 style="color:red">\nCommand fail</h1>"
fi
else
display
fi
;;
*)
display
;;
esac
else
if [[ $Action == SHOW ]]; then
if ! mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "SHOW DATABASES"; then
echo -e "<h1 style="color:red">\nCommand fail</h1>"
fi
else
if mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "${Action} DATABASE ${DB_name}"; then
DB_list && echo -e "<h1 style="color:blue">\nCommand success</h1>"
else
DB_list && echo -e "<h1 style="color:red">\nCommand fail</h1>"
fi
fi
fi
echo '</body></html>'
exit 0

舊版

#!/bin/bash
echo "Content-type: text/html; charset=utf-8"
echo ""
echo '<html><body>'
echo 'Hello From cgidb.sh'
echo '<pre>'
# var
DB_name=$(echo ${QUERY_STRING%&*} | cut -d "=" -f 2)
action=${QUERY_STRING##*&}
Action=${action%%=*}
DB_user="bobo"
DB_ip="120.96.143.84"
DB_passwd="bobo123"
# Debug
#echo "REQUEST_URI=${REQUEST_URI}"
#echo "QUERY_STRING=${QUERY_STRING}"
#echo "DBname=$DB_name"
#echo "Action=$Action"
Action_Db() {
mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" <<EOF
${Action,,} DATABASE ${DB_name};
EOF
}
DB_list() {
set -f # disable globbing
saveIFS=$IFS
IFS=$'\n' # set field separator to NL (only)
ALL_DB=$(mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "show databases;")
cat /dev/null > /www/cgi/db.txt
for i in ${ALL_DB[@]}
do
if [ "$i" != "Database" ]; then
echo " <option>$i</option>" >> /www/cgi/db.txt
else
echo " <option><b>請選擇資料庫名稱</b></option>" >> /www/cgi/db.txt
fi
done
IFS=$saveIFS
set +f
sed -i "/<option>/d" /www/html/tbl.html
line=$(cat /www/html/tbl.html | grep -n 'select type' | cut -d ":" -f 1)
sed -i "${line} r /www/cgi/db.txt" /www/html/tbl.html
}
case ${Action,,} in
create)
if Action_Db; then
DB_list && echo "<h1 style="color:red">Create ${DB_name} Database Success!</h1>"
else
echo "<h1 style="color: red">Error! pls try again!</h1>"
fi
;;
drop)
if Action_Db; then
DB_list && echo "<h1 style="color:red">Success!</h1>"
else
echo "<h1 style="color:red">Error! pls try again!</h1>"
fi
;;
show)
if [ "$DB_name" != "" ]; then
echo "<h1> 資料庫查詢結果：</h1>"
mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "show database like ${DB_name};"
else
mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "show databases;"
fi
;;
*)
echo -e "Error ! \nYour SQL Command now is > ${Action} DATABASE ${DB_name};"
;;
esac
echo '</pre>'
echo '</body></html>'
exit 0

bebo 不可執行 curl (命令攔截), bobo 可以 curl ，openssh container
mysql rbean 使用者

mydb

#!/bin/bash
echo "Content-type: text/html; charset=utf-8"
echo ""
echo '<html><body>'
echo 'Hello From MyDb'
# Debug
echo "REQUEST_URI=${REQUEST_URI}"
echo "QUERY_STRING=${QUERY_STRING}"
# QUERY_STRING="DB_user_account&DB_user_password&DB_Server_IP"
# e.g., curl 'http://120.96.143.110:80/login?rbean&rbean&120.96.143.111'
login_info() {
# var
DB_USER=$(echo "${QUERY_STRING%%&*}")
DB_PASSWD=$(echo "${QUERY_STRING%&*}" | cut -d "&" -f 2)
DB_IP=$(echo "${QUERY_STRING##*&}")
if mysql -u ${DB_USER} -h ${DB_IP} -p${DB_PASSWD}; then
echo "${DB_USER},${DB_PASSWD},${DB_IP}" > /tmp/hello
[ "$?" == "0" ] && echo -e "\n${DB_USER} login success !" || echo "login failed"
fi
}
create_Db() {
mysql -u ${DB_USER} -h ${DB_IP} -p${DB_PASSWD} <<EOF
CREATE DATABASE ${db_name};
EOF
}
list_Db() {
mysql -u ${DB_USER} -h ${DB_IP} -p${DB_PASSWD} <<EOF
SHOW DATABASES;
EOF
}
rm_Db() {
mysql -u ${DB_USER} -h ${DB_IP} -p${DB_PASSWD} <<EOF
DROP DATABASE ${db_name};
EOF
}
# var
DB_USER=$(cat /tmp/hello | cut -d "," -f 1)
DB_PASSWD=$(cat /tmp/hello | cut -d "," -f 2)
DB_IP=$(cat /tmp/hello | cut -d "," -f 3)
# Login check
if [ "$DB_USER" == "" ] || [ "${DB_PASSWD}" == "" ] || [ "${DB_PASSWD}" == "" ]; then
echo "MySQL Login Error,pls login !" && exit 1
fi
# Login, Create, list, rm Database
a=$(echo ${REQUEST_URI%?$QUERY_STRING}
db_name=${QUERY_STRING}
case ${a,,} in
/login)
login_info
;;
/db/create)
create_Db
;;
/db/list)
list_Db
;;
/db/rm)
rm_Db
;;
esac
echo '</body></html>'
exit 0

new gocgi

package main
import (
"net/http"
"net/http/cgi"
)
func cgiDB(w http.ResponseWriter, r *http.Request) {
handler := cgi.Handler{Path: "./www/cgi/cgidb.sh"}
handler.ServeHTTP(w, r)
}
func cgiTBL(w http.ResponseWriter, r *http.Request) {
handler := cgi.Handler{Path: "./www/cgi/cgitbl.sh"}
handler.ServeHTTP(w, r)
}
func main() {
static := http.FileServer(http.Dir("./www/"))
http.Handle("/",static)
http.HandleFunc("/db", cgiDB)
http.HandleFunc("/tbl", cgiTBL)
http.ListenAndServe(":8080", nil)
}

index : bobo Database application

http://bl.ocks.org/ndarville/7075823

SREPBP

Wed, 05 Oct 2022 06:03:34 +0800

Install Chocolatey

用系統管理員啟動 CMD，執行以下命令

@"%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe" -NoProfile -InputFormat None -ExecutionPolicy Bypass -Command "[System.Net.ServicePointManager]::SecurityProtocol = 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))" && SET "PATH=%PATH%;%ALLUSERSPROFILE%\chocolatey\bin"

allow TLS v1.2 (Required for requests to Chocolatey.org)
Getting latest version of the Chocolatey package for download.
Not using proxy.
Getting Chocolatey from https://community.chocolatey.org/api/v2/package/chocolatey/1.1.0.
Downloading https://community.chocolatey.org/api/v2/package/chocolatey/1.1.0 to C:\Users\bigred\AppData\Local\Temp\chocolatey\chocoInstall\chocolatey.zip
Not using proxy.
Extracting C:\Users\bigred\AppData\Local\Temp\chocolatey\chocoInstall\chocolatey.zip to C:\Users\bigred\AppData\Local\Temp\chocolatey\chocoInstall
Installing Chocolatey on the local machine
Creating ChocolateyInstall as an environment variable (targeting 'Machine')
Setting ChocolateyInstall to 'C:\ProgramData\chocolatey'
WARNING: It's very likely you will need to close and reopen your shell
before you can use choco.
Restricting write permissions to Administrators
We are setting up the Chocolatey package repository.
The packages themselves go to 'C:\ProgramData\chocolatey\lib'
(i.e. C:\ProgramData\chocolatey\lib\yourPackageName).
A shim file for the command line goes to 'C:\ProgramData\chocolatey\bin'
and points to an executable in 'C:\ProgramData\chocolatey\lib\yourPackageName'.
Creating Chocolatey folders if they do not already exist.
WARNING: You can safely ignore errors related to missing log files when
upgrading from a version of Chocolatey less than 0.9.9.
'Batch file could not be found' is also safe to ignore.
'The system cannot find the file specified' - also safe.
chocolatey.nupkg file not installed in lib.
Attempting to locate it from bootstrapper.
PATH environment variable does not have C:\ProgramData\chocolatey\bin in it. Adding...
警告: Not setting tab completion: Profile file does not exist at
'C:\Users\bigred\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1'.
Chocolatey (choco.exe) is now ready.
You can call choco from anywhere, command line or powershell by typing choco.
Run choco /? for a list of functions.
You may need to shut down and restart powershell and/or consoles
first prior to using choco.
Ensuring Chocolatey commands are on the path
Ensuring chocolatey.nupkg is in the lib folder

安裝套件

choco install -y nano wget tree

Install kubectl on windows

安裝 kubectl 命令

curl -LO "https://dl.k8s.io/release/v1.25.0/bin/windows/amd64/kubectl.exe"

Validate the binary (optional)

curl -LO "https://dl.k8s.io/v1.25.0/bin/windows/amd64/kubectl.exe.sha256"

檢查 kubectl 版本

kubectl version --client

切換到家目錄

cd %USERPROFILE%

建立 .kube 目錄

mkdir .kube

切換到 .kube 目錄

cd .kube

將要遠端操作的 K8S Cluster 路口憑證檔拷貝至當前目錄

scp bigred@120.96.143.103:/home/bigred/.kube/config .

修改 API Server IP

nano config

將clusters.cluster.server 的設定值，設為 API-Server 的 IP 位址

檢查連線到的 K8S Cluster 資訊

kubectl cluster-info

output :

Kubernetes control plane is running at https://120.96.143.103:6443
CoreDNS is running at https://120.96.143.103:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

測試 kubectl 命令

kubectl run nginx --image=quay.io/cloudwalker/nginx --dry-run -o yaml > pod-nginx.yaml

產生 pod

kubectl apply -f pod-nginx.yaml

看 pod 狀態

kubectl get pod

output :

NAME READY STATUS RESTARTS AGE
nginx 1/1 Running 0 43m

References

install.bat 程式內容

@echo off
@"%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe" -NoProfile -InputFormat None -ExecutionPolicy Bypass -Command "[System.Net.ServicePointManager]::SecurityProtocol = 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))" > nul && SET "PATH=%PATH%;%ALLUSERSPROFILE%\chocolatey\bin" > nul && powershell -Command "choco upgrade chocolatey" > nul
if %ERRORLEVEL% == 0 echo "Chocolatey ok"
powershell -Command "choco install -y nano" > nul
if %ERRORLEVEL% == 0 echo "nano ok"
powershell -Command "choco install -y wget" > nul
if %ERRORLEVEL% == 0 echo "wget ok"
powershell -Command "choco install -y tree" > nul
if %ERRORLEVEL% == 0 echo "tree ok"
powershell -Command "choco install -y sed" > nul

cgidb.sh

Mon, 05 Sep 2022 07:14:20 +0800

描述

新增、刪除和顯示 Database

完整程式內容

#!/bin/bash
echo "Content-type: text/html; charset=utf-8"
echo ""
echo '<html><body>'
echo 'Hello From cgidb.sh'
echo '<pre>'
# var
DB_name=$(echo ${QUERY_STRING%&*} | cut -d "=" -f 2)
action=${QUERY_STRING##*&}
Action=${action%%=*}
DB_user="bobo"
DB_passwd="bobo"
DB_ip="120.96.143.77"
# Debug
#echo "REQUEST_URI=${REQUEST_URI}"
#echo "QUERY_STRING=${QUERY_STRING}"
#echo "DBname=$DB_name"
#echo "Action=$Action"
Action_Db() {
mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" <<EOF
${Action} DATABASE ${DB_name};
EOF
}
case ${Action,,} in
create)
if Action_Db; then
echo "<h1 style="color:blue">Create ${DB_name} Database Success!</h1>"
else
echo "<h1 style="color: red">Error! pls try again!</h1>"
fi
;;
drop)
if Action_Db; then
echo "<h1 style="color:blue">Success!</h1>"
else
echo "<h1 style="color:red">Error! pls try again!</h1>"
fi
;;
show)
if [ "$DB_name" != "" ]; then
echo "<h1>資料庫查詢結果：</h1>"
a=$(mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "show databases like '${DB_name}';")
echo "<h1> $a </h1>"
else
echo "<h1> 資料庫查詢結果：</h1>"
b=$(mysql -u "$DB_user" -h "$DB_ip" -p"$DB_passwd" -e "show databases;")
echo "<h1> $b </h1>"
fi
;;
*)
echo -e "Error ! \nYour SQL Command now is > ${Action} DATABASE ${DB_name};"
;;
esac
echo '</pre>'
echo '</body></html>'
exit 0

rest-api.sh

Sat, 27 Aug 2022 11:26:26 +0800

#!/bin/bash
#set -x # debug mode
# var
script_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")" &>/dev/null && pwd -P)
# function
usage() {
cat <<EOF
Usage:
$(basename "${BASH_SOURCE[0]}") [options]
Available options:
test test config
create create from mapping.list
delete delete from mapping.list
EOF
exit
}
get_token() {
token=$(curl -s --location --request POST "${GUACAMOLESERVER}/api/tokens" \
--header 'Content-Type: application/x-www-form-urlencoded' \
--data-urlencode "username=${GUACADMIN}" \
--data-urlencode "password=${GUACPASS}" | jq -r '.authToken')
[ "${token}" == "null" ] && echo 'Get token fail, Please check config' && exit 1
}
get_connection_groupID() {
groups=$(curl -s --location --request GET "${GUACAMOLESERVER}/api/session/data/${DATASOURCE}/connectionGroups?token=${token}")
groupIndex=$(echo "${groups}" | jq -r .[].identifier)
for num in ${groupIndex}; do
echo "${groups}" | jq -r ".\"${num}\".name" | grep "${connGroup}" &>/dev/null &&
connGroupID=$(echo "${groups}" | jq -r ".\"${num}\".identifier")
done
}
get_connection_nameid() {
conns=$(curl -s --location --request GET "${GUACAMOLESERVER}/api/session/data/${DATASOURCE}/connections?token=${token}")
connsIndex=$(echo "${conns}" | jq -r .[].identifier)
for num in ${connsIndex}; do
echo "${conns}" | jq -r ".\"${num}\".name" | grep "${connName}" &>/dev/null &&
connNameID=$(echo "${conns}" | jq -r ".\"${num}\".identifier")
done
}
check_connection_service() {
if ! nmap -Pn -p "${connPort}" "${connIP}" | grep 'open' &>/dev/null; then
connName="${connName}.X"
fi
}
create_user() {
curl -s -w '\n' --location --request POST "${GUACAMOLESERVER}/api/session/data/${DATASOURCE}/users?token=${token}" \
--header 'Content-Type: application/json' \
--data-raw "{
\"username\": \"${userAccount}\",
\"password\": \"${userPassword}\",
\"attributes\": {}
}"
}
create_connection_group() {
curl -s -w '\n' --location --request POST "${GUACAMOLESERVER}/api/session/data/${DATASOURCE}/connectionGroups?token=${token}" \
--header 'Content-Type: application/json' \
--data-raw "{
\"name\": \"${connGroup}\",
\"type\": \"ORGANIZATIONAL\",
\"attributes\": {
\"max-connections\": \"\",
\"max-connections-per-user\": \"\",
\"enable-session-affinity\": \"\"
}
}"
}
create_connection_rdp() {
curl -s -w '\n' --location --request POST "${GUACAMOLESERVER}/api/session/data/${DATASOURCE}/connections?token=${token}" \
--header 'Content-Type: application/json' \
--data-raw "{
\"parentIdentifier\": \"${connGroupID}\",
\"name\": \"${connName}\",
\"protocol\": \"rdp\",
\"parameters\": {
\"hostname\": \"${connIP}\",
\"port\": \"${connPort}\",
\"username\": \"${connAccount}\",
\"password\": \"${connPassword}\",
\"security\": \"nla\",
\"ignore-cert\": \"true\"
},
\"attributes\": {
\"max-connections\": \"\",
\"max-connections-per-user\": \"\"
}
}"
}
create_connection_ssh() {
curl -s -w '\n' --location --request POST "${GUACAMOLESERVER}/api/session/data/${DATASOURCE}/connections?token=${token}" \
--header 'Content-Type: application/json' \
--data-raw "{
\"parentIdentifier\": \"${connGroupID}\",
\"name\": \"${connName}\",
\"protocol\": \"ssh\",
\"parameters\": {
\"hostname\": \"${connIP}\",
\"port\": \"${connPort}\",
\"username\": \"${connAccount}\",
\"password\": \"${connPassword}\",
\"color-scheme\": \"black-white\",
\"font-size\": \"14\"
},
\"attributes\": {
\"max-connections\": \"\",
\"max-connections-per-user\": \"\"
}
}"
}
create_connection_sharingprofile() {
curl -s -w '\n' --location --request POST "${GUACAMOLESERVER}/api/session/data/${DATASOURCE}/sharingProfiles?token=${token}" \
--header 'Content-Type: application/json' \
--data-raw "{
\"primaryConnectionIdentifier\": \"${connNameID}\",
\"name\": \"ro\",
\"parameters\": {
\"read-only\": \"true\"
},
\"attributes\": {}
}"
curl -s -w '\n' --location --request POST "${GUACAMOLESERVER}/api/session/data/${DATASOURCE}/sharingProfiles?token=${token}" \
--header 'Content-Type: application/json' \
--data-raw "{
\"primaryConnectionIdentifier\": \"${connNameID}\",
\"name\": \"rw\",
\"parameters\": {
\"read-only\": \"\"
},
\"attributes\": {}
}"
}
assign_user_connections() {
curl -s --location --request PATCH "${GUACAMOLESERVER}/api/session/data/${DATASOURCE}/users/${userAccount}/permissions?token=${token}" \
--header 'Content-Type: application/json' \
--data-raw "[
{
\"op\": \"add\",
\"path\": \"/connectionGroupPermissions/${connGroupID}\",
\"value\": \"READ\"
},
{
\"op\": \"add\",
\"path\": \"/connectionPermissions/${connNameID}\",
\"value\": \"READ\"
}
]"
}
delete_user() {
curl -s --location --request DELETE "${GUACAMOLESERVER}/api/session/data/${DATASOURCE}/users/${userAccount}?token=${token}"
}
delete_connection_group() {
curl -s --location --request DELETE "${GUACAMOLESERVER}/api/session/data/${DATASOURCE}/connectionGroups/${connGroupID}?token=${token}"
}
if [ "${1-}" == "" ]; then
usage && exit 1
fi
packages='jq nmap'
for package in ${packages}; do
if ! command -v "${package}" &>/dev/null; then
echo "Ops, ${package} is not installed." && exit 1
fi
done
source "${script_dir}"/rest-api.conf
get_token
if [ "${1-}" == "test" ]; then
echo "Token: ${token}" && exit 0
fi
while read -r line; do
echo "${line}" | grep '^#' &>/dev/null &&
continue
echo ${line} | grep '^$' &>/dev/null &&
continue
userAccount=$(echo "${line}" | awk -F',' '{print $1}')
userPassword=$(echo "${line}" | awk -F',' '{print $2}')
connGroup=$(echo "${line}" | awk -F',' '{print $3}')
connName=$(echo "${line}" | awk -F',' '{print $4}')
connProtocol=$(echo "${line}" | awk -F',' '{print $5}')
connIP=$(echo "${line}" | awk -F',' '{print $6}')
connPort=$(echo "${line}" | awk -F',' '{print $7}')
connAccount=$(echo "${line}" | awk -F',' '{print $8}')
connPassword=$(echo "${line}" | awk -F',' '{print $9}')
if [ "${1-}" == "create" ]; then
# create user set password
if [ "${userPassword}" == "" ]; then
tempPassword=$(date +%S%N | md5sum)
userPassword=${tempPassword:0:PASSLENGTH}
fi
if ! create_user | grep 'already exists' &>/dev/null; then
echo "${userAccount}","${userPassword}" >>"${script_dir}"/random.csv
echo "Create userAccount ${userAccount} ok"
fi
create_connection_group &>/dev/null
get_connection_groupID
# create connection
check_connection_service
[ "${connProtocol}" == "rdp" ] && create_connection_rdp &>/dev/null && echo "Create connName ${connName} ok"
[ "${connProtocol}" == "ssh" ] && create_connection_ssh &>/dev/null && echo "Create connName ${connName} ok"
# have connection get id
get_connection_nameid
create_connection_sharingprofile &>/dev/null
assign_user_connections
fi
if [ "${1-}" == "delete" ]; then
delete_user &>/dev/null
get_connection_groupID
delete_connection_group &>/dev/null
rm -r "${script_dir}"/random.csv &>/dev/null
fi
done <"${script_dir}"/mapping.list

Ubuntu Server 批次建立刪除使用者

Thu, 18 Aug 2022 15:49:10 +0800

mkuser

#!/bin/bash
[ "$#" != "1" ] && echo "請給一個數字，來說明要建幾個帳號!" && exit 1
[ -f /tmp/account.txt ] && rm /tmp/account.txt &>/dev/null && touch /tmp/account.txt
for ((i=1;i<=${1};i=i+1))
do
if [ "${i}" -le "9" ]; then
echo "user0${i}" >> /tmp/account.txt
else
echo "user${i}" >> /tmp/account.txt
fi
done
# var
u=$(cat /tmp/account.txt)
while read n
do
if cat /etc/passwd | grep "^$n" &>/dev/null; then
echo "linux ${n} user 已存在"
else
sudo useradd -m -s /bin/bash $n &>/dev/null
echo -e "${n}\n${n}" | sudo passwd $n &>/dev/null
[ "$?" == "0" ] && echo "linux ${n} user ok"
fi
if hdfs dfs -ls /user | grep "$n" &>/dev/null; then
echo "hdfs ${n} user 已存在"
else
hdfs dfs -mkdir /user/${n} &>/dev/null && hdfs dfs -chown ${n}:${n} /user/${n}
[ "$?" == "0" ] && echo "hdfs ${n} user ok"
fi
done < /tmp/account.txt

rmuser

#!/bin/bash
while read n
do
if hdfs dfs -ls /user | grep "$n" &>/dev/null; then
hdfs dfs -rm -r /user/${n} &>/dev/null && echo "hdfs ${n} user 刪除成功 !"
else
echo "hdfs ${n} user 不存在"
fi
if cat /etc/passwd | grep "^$n" &>/dev/null; then
sudo userdel -r ${n} &>/dev/null && echo "linux ${n} user 刪除成功 !"
else
echo "linux ${n} user 不存在"
fi
done < /tmp/account.txt

su 命令攔截

Tue, 16 Aug 2022 06:33:46 +0800

$ sudo nano /usr/sbin/su
#!/bin/bash
usage() {
cat<<EOF
Usage:
su <user>
EOF
exit
}
[ "$#" != "1" ] && usage || ssh ${1}@${HOSTNAME}
$ sudo chmod +x /usr/sbin/su
# 清除歷史紀錄
$ cat /dev/null > ~/.bash_history && history -c

偽 passwd program

Thu, 11 Aug 2022 03:39:14 +0800

#!/bin/bash
# 本程式需要先建立一個 /etc/wk/ 的目錄，權限為 drwxr-x-wx
# 以及需要兩個檔案，分別是 /etc/wk/op 和 /etc/wk/np ，權限皆為 -rw----rw-
# /etc/wk/op 主要是放使用者的舊密碼，檔案內容 : 欄位之間逗號區隔，使用者,舊密碼,改密碼當下的時間
# /etc/wk/np 主要是放使用者的新密碼，檔案內容 : 欄位之間逗號區隔，使用者,新密碼,改密碼當下的時間
time=$(date)
help() {
cat <<EOF
BusyBox v1.35.0 (2022-08-01 15:14:44 UTC) multi-call binary.
Usage: passwd [-a ALG] [-dlu] [USER]
Change USER's password (default: current user)
-a ALG des,md5,sha256/512 (default sha512)
-d Set password to ''
-l Lock (disable) account
-u Unlock (enable) account
EOF
exit
}
passwd_user() {
echo "Changing password for ${USER}"
read -s -p "Old password: " op
if [ "$op" == "" ]; then
sleep 5
echo -e "Incorrect password\npasswd: password for ${USER} is unchanged" && exit 1
else
echo "${USER},${op},${time}" | tee -a /etc/wk/op &>/dev/null
echo ""
read -s -p "New password:" np
if [ "$np" == "$USER" ]; then
echo -e "Bad password: similar to username\npasswd: password for $USER is unchanged" && exit 1
else
if [ "${#np}" -le "6" ]; then
echo -e "\nBad password: too short\npasswd: password for ${USER} is unchanged" && exit 1
else
m=$(echo ${np/$USER/ })
if [ "${#m}" -lt "${#np}" ]; then
echo -e "\nBad password: similar to username\npasswd: password for ${USER} is unchanged" && exit 1
fi
if echo -e "${op}\n${np}\n${np}" | /usr/bin/passwd &>/dev/null; then
echo ""; read -s -p "Retype password:" rp
if [ "$np" != "$rp" ]; then
echo -e "${np}\n${op}\n${op}" | /usr/bin/passwd &>/dev/null
echo -e "\nPasswords don't match\npasswd: password for ${USER} is unchanged" && exit 1
fi
echo -e "\npasswd: password for ${USER} changed by ${USER}"
echo "${USER},${np},${time}" | tee -a /etc/wk/np &>/dev/null
else
n=$(echo ${np} | tr -s "${np:0:1}")
if [ "${#n}" -lt "${#np}" ]; then
echo -e "\nBad password: too many similar characters\npasswd: password for ${USER} is unchanged" && exit 1
fi
echo -e "\nBad password: too weak\npasswd: password for ${USER} is unchanged" && exit 1
fi
fi
fi
fi
}
if [ "$#" == "0" ]; then
passwd_user
else
case $1 in
--help)
help
;;
*)
if ! cat /etc/passwd | grep "$1" &>/dev/null; then
echo "passwd: unknown user ${1}" && exit 1
else
if [ "$1" != "$USER" ]; then
echo "passwd: $USER can't change password for ${1}" && exit 1
else
passwd_user
fi
fi
;;
esac
fi

read -p，在讀取用戶輸入之前輸出提示字符串。
read -s，不回顯用戶的輸入。
read 的用法介紹
function 介紹連結

linux check ip

Wed, 10 Aug 2022 03:40:38 +0800

#!/bin/bash
for ((n=$1;n<=$2;n=n+1))
do
if nc -z -w 1 120.96.143.$n 22 &>/dev/null; then
echo "120.96.143.$n ,22 port existed !"
else
echo "120.96.143.$n ,22 port ok !"
fi
if nc -z -w 1 120.96.143.$n 80 &>/dev/null; then
echo "120.96.143.$n ,80 port existed !"
else
echo "120.96.143.$n ,80 port ok !"
fi
if nc -z -w 1 120.96.143.$n 443 &>/dev/null; then
echo "120.96.143.$n ,443 port existed !"
else
echo "120.96.143.$n ,443 port ok !"
fi
done

`alpuser.sh`

Sun, 07 Aug 2022 14:57:18 +0800

功能

create
- 自動建立使用者
delete
- 刪除使用者
list
- 查看使用者

#!/bin/bash
clear
if [ "$1" != "" ];then
case $1 in
create)
if [ "$2" != "" ];then
p=$(< /dev/urandom tr -dc A-Za-z0-9 | head -c6)
cat /etc/passwd | grep $2 &>/dev/null
if [ "$?" != "0" ];then
echo -e "${p}\n${p}" | sudo adduser -h /home/$2 -s /bin/bash $2 &>/dev/null
[ "$?" == "0" ] && ls -l /home/$2 &>/dev/null
[ "$?" == "0" ] && echo -e "\n${2} 使用者建立成功！\n您的密碼是: ${p}" || echo "$2 建立失敗，請再試一次！" && exit 1
else
echo "${2}使用者已存在！" && exit 1
fi
else
echo "請輸入要建立的使用者帳號！" && exit 1
fi
;;
delete)
if [ "$2" != "" ];then
cat /etc/passwd | grep ${2} &>/dev/null
if [ "$?" == "0" ];then
sudo deluser --remove-home ${2} &>/dev/null
[ "$?" == "0" ] && echo "${2} 使用者刪除成功！" || echo "${2} 使用者刪除失敗，請再試一次！"
else
echo "${2}使用者不存在！" && exit 1
fi
else
echo "請輸入要刪除的使用者帳號！" && exit 1
fi
;;
list)
if [ "$2" != "" ];then
cat /etc/passwd | grep "$2" && echo "已查詢到${2} 使用者資訊！" || echo "您要查詢的${2} 使用者不存在！"
else
echo "請輸入要查詢的使用者帳號！"
fi
;;
*)
echo "請輸入參數 ( create / delete / list ) 其中一個，謝謝！"
;;
esac
fi

tags: `Shell Script`

chnameip

Sun, 07 Aug 2022 14:41:20 +0800

$ cat /home/bigred/bin/chnameip
#!/bin/bash
ifn=$(lspci | grep Ethernet | wc -l)
[ "$ifn" -gt "1" ] && exit 0
cat /etc/network/interfaces | grep -e "^auto br0" &>/dev/null
[ "$?" == "0" ] && exit 0
cat /etc/network/interfaces | grep -e "^#keep" &>/dev/null
[ "$?" == "0" ] && exit 0
gw=$(route -n | grep -e "^0.0.0.0 ")
export GWIF=${gw##* }
ips=$(ifconfig $GWIF | grep 'inet ')
export IP=$(echo $ips | cut -d' ' -f2 | cut -d':' -f2)
export NETID=${IP%.*}
export GW=$(route -n | grep -e '^0.0.0.0' | tr -s \ - | cut -d ' ' -f2)
mac=$(cat /sys/class/net/eth0/address | cut -d':' -f5,6)
h=$(cat /home/bigred/bin/mactohost | grep "$mac" | cut -d ' ' -f2)
if [ "$h" != "" ]; then
bigred@alp:~$ sudo nano /etc/profile
bigred@alp:~$ bigred@alp:~$ sudo nano /etc/local.d/rc.local.start
bigred@alp:~$ bigred@alp:~$ sudo nano /etc/profile
bigred@alp:~$ cat /etc/local.d/rc.local.start
#!/bin/bash
gw=$(route -n | grep -e "^0.0.0.0 ")
export GWIF=${gw##* }
ips=$(ifconfig $GWIF | grep 'inet ')
export IP=$(echo $ips | cut -d' ' -f2 | cut -d':' -f2)
export NETID=${IP%.*}
export GW=$(route -n | grep -e '^0.0.0.0' | tr -s \ - | cut -d ' ' -f2)
echo "[System]" > /tmp/sinfo
echo "Hostname : `hostname`" >> /tmp/sinfo
m=$(free -mh | grep Mem: | tr -s ' ' | cut -d' ' -f2)
echo "Memory : ${m}M" >> /tmp/sinfo
cname=$(cat /proc/cpuinfo | grep 'model name' | head -n 1 | cut -d ':' -f2)
cnumber=$(cat /proc/cpuinfo | grep 'model name' | wc -l)
echo "CPU : $cname (core: $cnumber)" >> /tmp/sinfo
m=$(df -h | grep /dev/sda)
ds=$(echo $m | cut -d ' ' -f2)
echo "Disk : $ds" >> /tmp/sinfo
which kubectl &>/dev/null
if [ "$?" == "0" ]; then
#v=$(kubectl version --short | head -n 1 | cut -d ":" -f2 | tr -d ' ')
echo "Kubernetes: enabled" >> /tmp/sinfo
fi
echo "" >> /tmp/sinfo
echo "[Network]" >> /tmp/sinfo
echo "IP : $IP" >> /tmp/sinfo
echo "Gateway : $GW" >> /tmp/sinfo
cat /etc/resolv.conf | grep 'nameserver' | head -n 1 >> /tmp/sinfo
/bin/ping -c 1 www.hinet.net
[ "$?" == "0" ] && echo "Internet OK" >> /tmp/sinfo
modprobe tun
modprobe fuse
mount --make-rshared /
modprobe br_netfilter
modprobe ip_tables

tags: `Shell Script`

Canary Deployment

Wed, 15 Jun 2022 09:22:52 +0800

前置作業 Part1

請依簡報 904-Jenkins-Part1 完成以下事項

第 2~4 頁環境準備
第 10~13 頁部署 Jenkins
第 20 頁設定 SSH 免密碼

前置作業 Part2

K8S 建立 namespace 命名為 prod
K8S 建立 namespace 命名為 dev

$ kubectl create ns prod
namespace/prod created
bigred@m1:~/wk/mp3$ kubectl create ns dev
namespace/dev created

參考簡報 905-Jenkins-Part2 第 17~ 20 頁

在 prod 建立 imagePullSecrets
在 dev 建立 imagePullSecrets

$ kubectl create secret generic regcred \
> --from-file=.dockerconfigjson=/home/bigred/auth.json \
> --type=kubernetes.io/dockerconfigjson \
> -n prod
$ kubectl create secret generic regcred \
> --from-file=.dockerconfigjson=/home/bigred/auth.json \
> --type=kubernetes.io/dockerconfigjson \
> -n dev

下載 canary-demo

$ pwd
/home/bigred/wk
$ wget http://web.flymks.com/cicd/v1/canary-demo.zip
$ unzip canary-demo.zip && cd canary-demo
$ tree .
.
├── Dockerfile
├── Jenkinsfile
├── b1-canary.yaml
├── b1-dev.yaml
├── b1-prod.yaml
├── busybox-x86_64
├── info.cgi
└── service.yaml
0 directories, 8 files

建立 post-commit

$ nano .git/hooks/post-commit
#!/bin/bash
jenkinsURL="http://jenkins.k8s.org/git/notifyCommit?url="
repo="ssh://bigred@192.168.61.4/home/bigred/wk/canary-demo"
branchName=$(git rev-parse --abbrev-ref HEAD)
curl -s "${jenkinsURL}${repo}&branches=${branchName}"
$ chmod +x .git/hooks/post-commit

建立 post-merge

用途一樣是通知 jenkins

$ cp .git/hooks/post-commit .git/hooks/post-merge
$ chmod +x .git/hooks/post-merge

Git & Jenkins 設定

新增 Jenkins multibranch pipeline 作業
作業命名「canary-demo」
- 連接到 canary-demo git 儲存庫
- ssh://bigred@192.168.61.4/home/bigred/wk/canary-demo

$ git add .
$ git commit -m "Initial commit"

檢視執行結果

$ kubectl get all -n prod
NAME READY STATUS RESTARTS AGE
pod/b1-prod-7d7ff6687c-mdszn 1/1 Running 0 92s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/b1 LoadBalancer 10.98.0.21 192.168.61.222 80:32302/TCP 92s
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/b1-prod 1/1 1 1 92s
NAME DESIRED CURRENT READY AGE
replicaset.apps/b1-prod-7d7ff6687c 1 1 1 92s

檢視 Jenkinsfile

$ cat Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'canary-demo'
defaultContainer 'p1'
yaml """
apiVersion: v1
kind: Pod
spec:
hostAliases:
- ip: "192.168.61.220"
hostnames:
- "quay.k8s.org"
imagePullSecrets:
- name: regcred
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
- name: p1
securityContext:
privileged: true
image: quay.io/podman/stable:v3.4.7
command: ["sleep"]
args: ["infinity"]
- name: k1
securityContext:
privileged: true
image: quay.io/grassknot/kubectl:1.24.1
command: ["sleep"]
args: ["infinity"]
"""
}
}
environment {
QUAY_ADMIN = credentials('quay-admin-id')
KUBECONFIG = credentials('kubeconfig-id')
IMAGE_TAG = "quay.k8s.org/quay/alpine.httpd:${env.BRANCH_NAME}.${env.BUILD_NUMBER}"
}
stages {
stage ('build and push image') {
steps {
sh 'podman login --tls-verify=false -u=${QUAY_ADMIN_USR} -p=${QUAY_ADMIN_PSW} quay.k8s.org'
sh 'podman build --tls-verify=false -t "${IMAGE_TAG}" .'
sh 'podman images'
sh 'podman push --tls-verify=false "${IMAGE_TAG}"'
}
}
stage ('deploy canary') {
when { branch 'canary' }
steps {
container('k1') {
sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
sh "sed -i.bak 's#quay.k8s.org/quay/alpine.httpd:1.0.0#${IMAGE_TAG}#' b1-canary.yaml"
sh 'kubectl apply -f service.yaml -n prod'
sh 'kubectl apply -f b1-canary.yaml -n prod'
}
}
}
stage ('deploy prod') {
when { branch 'master' }
steps {
container('k1') {
sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
sh "sed -i.bak 's#quay.k8s.org/quay/alpine.httpd:1.0.0#${IMAGE_TAG}#' b1-prod.yaml"
sh 'kubectl apply -f service.yaml -n prod'
sh 'kubectl apply -f b1-prod.yaml -n prod'
}
}
}
stage ('deploy dev') {
when {
not { branch 'master' }
not { branch 'canary' }
}
steps {
container('k1') {
sh 'kubectl get ns ${BRANCH_NAME} || kubectl create ns ${BRANCH_NAME}'
sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
sh "sed -i.bak 's#quay.k8s.org/quay/alpine.httpd:1.0.0#${IMAGE_TAG}#' b1-dev.yaml"
sh "sed -i.bak 's#LoadBalancer#ClusterIP#' service.yaml"
sh 'kubectl apply -f service.yaml -n ${BRANCH_NAME}'
sh 'kubectl apply -f b1-dev.yaml -n ${BRANCH_NAME}'
}
}
}
}

Canary Deployment

## 部署金絲雀 Deployment
$ kubectl apply -f b1-canary.yaml -n prod
## scale "b1-prod" pod 的數量至 4
$ kubectl -n prod scale deployment b1-prod --replicas=4
deployment.apps/b1-prod scaled
## 檢視部署狀態
$ kubectl get all -n prod
NAME READY STATUS RESTARTS AGE
pod/b1-canary-6587596f4b-kd5px 1/1 Running 0 79s
pod/b1-prod-7d7ff6687c-c756t 1/1 Running 0 8s
pod/b1-prod-7d7ff6687c-fgs9l 1/1 Running 0 8s
pod/b1-prod-7d7ff6687c-mdszn 1/1 Running 0 31m
pod/b1-prod-7d7ff6687c-zk95m 1/1 Running 0 8s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/b1 LoadBalancer 10.98.0.21 192.168.61.222 80:32302/TCP 31m
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/b1-canary 1/1 1 1 79s
deployment.apps/b1-prod 4/4 4 4 31m
NAME DESIRED CURRENT READY AGE
replicaset.apps/b1-canary-6587596f4b 1 1 1 79s
replicaset.apps/b1-prod-7d7ff6687c 4 4 4 31m

輪詢 /info URL

開啟一個新的 cmd 視窗登入 m1 主機

$ while true; do curl 192.168.61.221/cgi-bin/info; sleep 3; done

結果：

version: v1.0.0, IP: 10.244.1.179, hostname: b1-prod-7d7ff6687c-fgs9l
<HTML><HEAD><TITLE>404 Not Found</TITLE></HEAD>
<BODY><H1>404 Not Found</H1>
The requested URL was not found
</BODY></HTML>
version: v1.0.0, IP: 10.244.2.114, hostname: b1-prod-7d7ff6687c-c756t
version: v1.0.0, IP: 10.244.1.179, hostname: b1-prod-7d7ff6687c-fgs9l
version: v1.0.0, IP: 10.244.2.114, hostname: b1-prod-7d7ff6687c-c756t
version: v1.0.0, IP: 10.244.0.39, hostname: b1-prod-7d7ff6687c-zk95m
version: v1.0.0, IP: 10.244.1.179, hostname: b1-prod-7d7ff6687c-fgs9l
version: v1.0.0, IP: 10.244.1.178, hostname: b1-prod-7d7ff6687c-mdszn
version: v1.0.0, IP: 10.244.2.114, hostname: b1-prod-7d7ff6687c-c756t
<HTML><HEAD><TITLE>404 Not Found</TITLE></HEAD>
<BODY><H1>404 Not Found</H1>
The requested URL was not found
</BODY></HTML>

建立 canary branch

$ git checkout -b canary
Switched to a new branch 'canary'

修改 info.cgi

$ nano info.cgi
::
version="v2.0.0"
::

讓 git 追蹤

$ git add info.cgi
$ git commit -m 'Version 2'

確認輪詢狀態

回到輪詢 /info URL 的 cmd 視窗

version: v1.0.0, IP: 10.244.1.178, hostname: b1-prod-7d7ff6687c-mdszn
version: v2.0.0, IP: 10.244.1.180, hostname: b1-canary-6f586475bd-w9hrj
version: v1.0.0, IP: 10.244.1.179, hostname: b1-prod-7d7ff6687c-fgs9l
version: v1.0.0, IP: 10.244.0.39, hostname: b1-prod-7d7ff6687c-zk95m
version: v1.0.0, IP: 10.244.1.179, hostname: b1-prod-7d7ff6687c-fgs9l
version: v1.0.0, IP: 10.244.1.179, hostname: b1-prod-7d7ff6687c-fgs9l
version: v2.0.0, IP: 10.244.1.180, hostname: b1-canary-6f586475bd-w9hrj

部署 V2 到正式環境

$ git checkout master
$ git log --oneline --all
e8557fa (canary) Version 2
5ee1aa1 (HEAD -> master) Initial commit
$ git merge canary

請至 Jenkins 網頁確認執行結果 !

請確認 V2 部署狀態

$ watch kubectl get pod -n prod

確認輪詢狀態

回到輪詢 /info URL 的 cmd 視窗

version: v2.0.0, IP: 10.244.1.180, hostname: b1-canary-6f586475bd-w9hrj
version: v2.0.0, IP: 10.244.1.180, hostname: b1-canary-6f586475bd-w9hrj
version: v2.0.0, IP: 10.244.1.180, hostname: b1-canary-6f586475bd-w9hrj
version: v2.0.0, IP: 10.244.0.40, hostname: b1-prod-75466968fd-x7nnw
version: v2.0.0, IP: 10.244.0.40, hostname: b1-prod-75466968fd-x7nnw
version: v2.0.0, IP: 10.244.0.40, hostname: b1-prod-75466968fd-x7nnw
version: v2.0.0, IP: 10.244.0.40, hostname: b1-prod-75466968fd-x7nnw

新功能開發流程模擬

PM 與客戶討論新功能需求
PG 接到新需求，建立開發用 branch
PG 開發搭配 Jenkins 部署到測試環境
經過一番測試與修改後，新功能確認沒問題
驗測 App 採用金絲雀部署策略
確認新功能運作沒問題後，部署至正式環境

建立開發用 branch

$ git checkout -b dev
修改 info.cgi
$ nano info.cgi
::
version="v3.0.0"
$ git add info.cgi
$ git commit -m 'Test Version 3'

Jenkins 執行結果

確認部署狀態

$ kubectl get all -n prod
NAME READY STATUS RESTARTS AGE
pod/b1-canary-6f586475bd-w9hrj 1/1 Running 0 23m
pod/b1-prod-75466968fd-x7nnw 1/1 Running 0 13m
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/b1 LoadBalancer 10.98.0.21 192.168.61.222 80:32302/TCP 63m
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/b1-canary 1/1 1 1 33m
deployment.apps/b1-prod 1/1 1 1 63m
NAME DESIRED CURRENT READY AGE
replicaset.apps/b1-canary-6587596f4b 0 0 0 33m
replicaset.apps/b1-canary-6f586475bd 1 1 1 23m
replicaset.apps/b1-prod-75466968fd 1 1 1 13m
replicaset.apps/b1-prod-7d7ff6687c 0 0 0 63m
bigred@m1:~/wk/canary-demo$ kubectl get pod -n dev -o wide
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
b1-dev-66ddcfd76d-tgbnc 1/1 Running 0 2m2s 10.244.1.181 w1 <none> <none>
bigred@m1:~/wk/canary-demo$ curl 10.244.1.181
let me go
bigred@m1:~/wk/canary-demo$ curl 10.244.1.181/cgi-bin/info
version: v3.0.0, IP: 10.244.1.181, hostname: b1-dev-66ddcfd76d-tgbnc

程式設計師測試 App 沒問題使用金絲雀部署策略

金絲雀部署 Part1

部署金絲雀前，先擴展 “b1-prod” pod 的數量至 4

$ kubectl -n prod scale deployment b1-prod --replicas=4

切換至 canary branch

$ git checkout canary
Switched to branch 'canary'

金絲雀部署 Part2

合併開發環境的程式碼
$ git merge dev

確認金絲雀部署狀態

至 Jenkins 網頁確認執行結果

確認輪詢狀態

回到輪詢 /info URL 的 cmd 視窗

version: v2.0.0, IP: 10.244.1.182, hostname: b1-prod-75466968fd-gngbz
version: v3.0.0, IP: 10.244.0.41, hostname: b1-canary-c6fb868c-xnxs7
version: v2.0.0, IP: 10.244.2.118, hostname: b1-prod-75466968fd-5pml7
version: v2.0.0, IP: 10.244.0.40, hostname: b1-prod-75466968fd-x7nnw
version: v3.0.0, IP: 10.244.0.41, hostname: b1-canary-c6fb868c-xnxs7
version: v2.0.0, IP: 10.244.0.40, hostname: b1-prod-75466968fd-x7nnw
version: v3.0.0, IP: 10.244.0.41, hostname: b1-canary-c6fb868c-xnxs7
...

金絲雀部署 Part3

切換至 master branch

$ git checkout master
Switched to branch 'master'

合併 canary branch

$ git merge canary

確認新版本上線

請至 Jenkins 網頁確認執行結果

回到輪詢 /info URL 的 cmd 視窗確認結果

version: v3.0.0, IP: 10.244.0.41, hostname: b1-canary-c6fb868c-xnxs7
version: v3.0.0, IP: 10.244.0.41, hostname: b1-canary-c6fb868c-xnxs7
version: v3.0.0, IP: 10.244.1.183, hostname: b1-prod-6cbd5bd499-jl8rl
version: v3.0.0, IP: 10.244.1.183, hostname: b1-prod-6cbd5bd499-jl8rl
version: v3.0.0, IP: 10.244.1.183, hostname: b1-prod-6cbd5bd499-jl8rl
version: v3.0.0, IP: 10.244.1.183, hostname: b1-prod-6cbd5bd499-jl8rl
...

tags: `CI/CD`

Jenkins - Part 2

Wed, 15 Jun 2022 07:01:00 +0800

前置作業

若已完成簡報 904-Jenkins-Part1 請跳過此頁請依簡報 904-Jenkins-Part1 完成以下事項第 2~~4 頁環境準備第 10~~13 頁部署 Jenkins 第 20 頁設定 SSH 免密碼第 21~~24 頁新增 Jenkins 作業「mycicd」第 28~~29 頁建立 post-commit

Jenkinsfile 範例 06

$ pwd
/home/bigred/wk/mycicd
下載 Jenkinsfile 範例 06
$ wget -q -O Jenkinsfile \
"http://web.flymks.com/cicd/v1/jenkinsfile/06"
檢視 Jenkinsfile 範例 06
$ cat Jenkinsfile
$ cat Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'mycicd'
yaml """
apiVersion: v1
kind: Pod
spec:
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
"""
}
}
options {
skipDefaultCheckout true
}
environment {
QUAY_ADMIN = credentials('quay-admin-id')
}
stages {
stage ('QUAY_ADMIN') {
steps {
sh 'echo ${QUAY_ADMIN}'
sh 'echo ${QUAY_ADMIN_USR}'
sh 'echo ${QUAY_ADMIN_PSW}'
}
}
}
}

environment 是 pipeline 的原生語法 credentials 是要在 Jenkins 上安裝 Credentials Binding Plugin 這個插件，才能使用這個語法

我們部署的 Jenkins 的 Server 是老師先客製化過了，原生乾淨的 Jenkins Server 沒有這些設定。 QUAY_ADMIN = credentials(‘quay-admin-id’) » quay/Quay12345 使用 credentials 時會同時生成兩個變數 QUAY_ADMIN_USR、QUAY_ADMIN_PSW 密碼會被遮罩處理 » ****

動手修改範例 06

$ cat Jenkinsfile
$ cat Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'mycicd'
yaml """
apiVersion: v1
kind: Pod
spec:
hostAliases:
- ip: "192.168.61.220"
hostnames:
- "quay.k8s.org"
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
- name: p1
securityContext:
privileged: true
image: quay.io/podman/stable:v3.4.7
command: ["sleep"]
args: ["infinity"]
"""
}
}
options {
skipDefaultCheckout true
}
environment {
QUAY_ADMIN = credentials('quay-admin-id')
}
stages {
stage ('QUAY_ADMIN') {
steps {
sh 'echo ${QUAY_ADMIN}'
sh 'echo ${QUAY_ADMIN_USR}'
sh 'echo ${QUAY_ADMIN_PSW}'
}
}
stage ('podman login') {
steps {
container('p1') {
sh 'podman login --tls-verify=false quay.k8s.org -u=${QUAY_ADMIN_USR} -p=${QUAY_ADMIN_PSW}'
}
}
}
}
}

Jenkinsfile 範例 07

請至落地 Qauy 將 alpine 設定為 private 下載 Jenkinsfile 範例 07

$ wget -q -O Jenkinsfile \
"http://web.flymks.com/cicd/v1/jenkinsfile/07"
## 檢視 Jenkinsfile 範例 07
$ cat Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'mycicd'
defaultContainer 'p1'
yaml """
apiVersion: v1
kind: Pod
spec:
hostAliases:
- ip: "192.168.61.220"
hostnames:
- "quay.k8s.org"
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
- name: p1
securityContext:
privileged: true
image: quay.io/podman/stable:v3.4.7
command: ["sleep"]
args: ["infinity"]
"""
}
}
environment {
QUAY_ADMIN = credentials('quay-admin-id')
IMAGE_TAG = 'quay.k8s.org/quay/alpine.httpd:1.0.0'
}
stages {
stage ('podman login') {
steps {
sh 'podman login --tls-verify=false -u=${QUAY_ADMIN_USR} -p=${QUAY_ADMIN_PSW} quay.k8s.org'
}
}
stage ('build image') {
steps {
sh 'podman build --tls-verify=false -t "${IMAGE_TAG}" .'
sh 'podman images'
}
}
}
}
$ nano Dockerfile
FROM quay.k8s.org/quay/alpine:3.15.4
RUN \
apk update && \
apk add --no-cache nano sudo bash wget curl git tree grep && \
wget https://busybox.net/downloads/binaries/1.28.1-defconfig-multiarch/busybox-x86_64 && \
chmod +x busybox-x86_64 && \
mv busybox-x86_64 bin/busybox1.28 && \
mkdir -p /opt/www && echo "let me go" > /opt/www/index.html
ENTRYPOINT ["/bin/busybox1.28"]
CMD ["httpd", "-f", "-h", "/opt/www"]
$ git add Dockerfile Jenkinsfile
$ git commit -m 'test 07'

動手修改範例 07

修改 Jenkinsfile 範例 07 新增一個 stage 叫 push image 將 alpine.httpd:1.0.0 push 到落地 Quay 至落地 Quay 確認是否上傳成功

$ cat Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'mycicd'
defaultContainer 'p1'
yaml """
apiVersion: v1
kind: Pod
spec:
hostAliases:
- ip: "192.168.61.220"
hostnames:
- "quay.k8s.org"
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
- name: p1
securityContext:
privileged: true
image: quay.io/podman/stable:v3.4.7
command: ["sleep"]
args: ["infinity"]
"""
}
}
environment {
QUAY_ADMIN = credentials('quay-admin-id')
IMAGE_TAG = 'quay.k8s.org/quay/alpine.httpd:1.0.0'
}
stages {
stage ('podman login') {
steps {
sh 'podman login --tls-verify=false -u=${QUAY_ADMIN_USR} -p=${QUAY_ADMIN_PSW} quay.k8s.org'
}
}
stage ('build image') {
steps {
sh 'podman build --tls-verify=false -t "${IMAGE_TAG}" .'
sh 'podman images'
}
}
stage ('push image') {
steps {
sh 'podman push --tls-verify=false "${IMAGE_TAG}"'
}
}
}
}
$ git commit -a -m "test-07-1"

Jenkinsfile 範例 08

下載 Jenkinsfile 範例 08

$ wget -q -O Jenkinsfile \
"http://web.flymks.com/cicd/v1/jenkinsfile/08"
檢視 Jenkinsfile 範例 08
$ cat Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'mycicd'
defaultContainer 'k1'
yaml """
apiVersion: v1
kind: Pod
spec:
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
- name: k1
securityContext:
privileged: true
image: quay.io/grassknot/kubectl:1.24.1
command: ["sleep"]
args: ["infinity"]
"""
}
}
options {
skipDefaultCheckout true
}
environment {
KUBECONFIG = credentials('kubeconfig-id')
}
stages {
stage ('get node') {
steps {
sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
sh 'kubectl get nodes -o wide'
}
}
}
}
$ git add Jenkinsfile; git commit -m "test 08"

apiVersion: v1
kind: ServiceAccount
metadata:
labels:
app: jenkins
name: jenkins
namespace: jenkins
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
labels:
app: jenkins
name: jenkins
namespace: jenkins
rules:
- apiGroups:
- ""
resources:
- pods
verbs:
- create
- delete
- get
- list
- patch
- update
- watch
- apiGroups:
- ""
resources:
- pods/exec
verbs:
- create
- delete
- get
- list
- patch
- update
- watch
- apiGroups:
- ""
resources:
- pods/log
verbs:
- get
- list
- watch
- apiGroups:
- ""
resources:
- events
verbs:
- watch
- apiGroups:
- ""
resources:
- secrets
verbs:
- get
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
labels:
app: jenkins
name: jenkins
namespace: jenkins
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: Role
name: jenkins
subjects:
- kind: ServiceAccount
name: jenkins
namespace: jenkins
---
apiVersion: v1
data:
credentials.yaml: |
Y3JlZGVudGlhbHM6CiAgc3lzdGVtOgogICAgZG9tYWluQ3JlZGVudGlhbHM6CiAgICAgIC
0gY3JlZGVudGlhbHM6CiAgICAgICAgICAtIHVzZXJuYW1lUGFzc3dvcmQ6CiAgICAgICAg
ICAgICAgaWQ6ICJnaXRlYS1hZG1pbi1pZCIKICAgICAgICAgICAgICB1c2VybmFtZTogIm
dpdGVhIgogICAgICAgICAgICAgIHBhc3N3b3JkOiAiR2l0ZWExMjM0NSIKICAgICAgICAg
ICAgICBkZXNjcmlwdGlvbjogImdpdGVhIGFkbWluIgogICAgICAgICAgICAgIHNjb3BlOi
BHTE9CQUwKICAgICAgICAgIC0gdXNlcm5hbWVQYXNzd29yZDoKICAgICAgICAgICAgICBp
ZDogInF1YXktYWRtaW4taWQiCiAgICAgICAgICAgICAgdXNlcm5hbWU6ICJxdWF5IgogIC
AgICAgICAgICAgIHBhc3N3b3JkOiAiUXVheTEyMzQ1IgogICAgICAgICAgICAgIGRlc2Ny
aXB0aW9uOiAicXVheSBhZG1pbiIKICAgICAgICAgICAgICBzY29wZTogR0xPQkFMCiAgIC
AgICAgICAtIGJhc2ljU1NIVXNlclByaXZhdGVLZXk6CiAgICAgICAgICAgICAgaWQ6ICJz
c2gtcHJpdmF0ZS1rZXktaWQiCiAgICAgICAgICAgICAgdXNlcm5hbWU6ICJzc2gtcHJpdm
F0ZS1rZXkiCiAgICAgICAgICAgICAgZGVzY3JpcHRpb246ICJzc2ggcHJpdmF0ZSBrZXki
CiAgICAgICAgICAgICAgc2NvcGU6IEdMT0JBTAogICAgICAgICAgICAgIHByaXZhdGVLZX
lTb3VyY2U6CiAgICAgICAgICAgICAgICBkaXJlY3RFbnRyeToKICAgICAgICAgICAgICAg
ICAgcHJpdmF0ZUtleTogIiR7cmVhZEZpbGU6L3Zhci9qZW5raW5zX2hvbWUvLnNzaC9zc2
hfaG9zdF9yc2Ffa2V5fSIKICAgICAgICAgIC0gZmlsZToKICAgICAgICAgICAgICBpZDog
Imt1YmVjb25maWctaWQiCiAgICAgICAgICAgICAgZmlsZU5hbWU6ICJrdWJlY29uZmlnIg
ogICAgICAgICAgICAgIHNlY3JldEJ5dGVzOiAiJHtyZWFkRmlsZUJhc2U2NDovcnVuL3Nl
Y3JldHMva3ViZWNvbmZpZy9jb25maWd9IgogICAgICAgICAgICAgIGRlc2NyaXB0aW9uOi
Aia3ViZWNvbmZpZyIKICAgICAgICAgICAgICBzY29wZTogR0xPQkFM
jenkins.yaml: |
dW5jbGFzc2lmaWVkOgogIGxvY2F0aW9uOgogICAgdXJsOiAiJHtKRU5LSU5TX1VSTDotaH
R0cDovL2plbmtpbnMuazhzLm9yZy99IgogIGdpdGVhU2VydmVyczoKICAgIHNlcnZlcnM6
CiAgICAgIC0gY3JlZGVudGlhbHNJZDogImdpdGVhLWFkbWluLWlkIgogICAgICAgIGRpc3
BsYXlOYW1lOiAiZ2l0ZWEiCiAgICAgICAgbWFuYWdlSG9va3M6IHRydWUKICAgICAgICBz
ZXJ2ZXJVcmw6ICJodHRwOi8vZ2l0ZWEuZ2l0ZWE6MzAwMC8iCmplbmtpbnM6CiAgZGlzYW
JsZWRBZG1pbmlzdHJhdGl2ZU1vbml0b3JzOgogICAgLSAiamVua2lucy5zZWN1cml0eS5R
dWV1ZUl0ZW1BdXRoZW50aWNhdG9yTW9uaXRvciIKICAgIC0gImplbmtpbnMuZGlhZ25vc3
RpY3MuQ29udHJvbGxlckV4ZWN1dG9yc0FnZW50cyIKICBjbG91ZHM6CiAgICAtIGt1YmVy
bmV0ZXM6CiAgICAgICAgbmFtZTogImt1YmVybmV0ZXMiCiAgICAgICAgbmFtZXNwYWNlOi
AiamVua2lucyIKICAgICAgICBqZW5raW5zVXJsOiAiaHR0cDovL2plbmtpbnMiCiAgbGFi
ZWxTdHJpbmc6ICJtYXN0ZXIiCiAgc2VjdXJpdHlSZWFsbToKICAgIGxvY2FsOgogICAgIC
BhbGxvd3NTaWdudXA6IGZhbHNlCiAgICAgIHVzZXJzOgogICAgICAgIC0gaWQ6ICIke0pF
TktJTlNfQURNSU5fSUQ6LWplbmtpbnN9IgogICAgICAgICAgcGFzc3dvcmQ6ICIke0pFTk
tJTlNfQURNSU5fUFc6LUplbmtpbnMxMjM0NX0iCiAgYXV0aG9yaXphdGlvblN0cmF0ZWd5
OgogICAgZ2xvYmFsTWF0cml4OgogICAgICBwZXJtaXNzaW9uczoKICAgICAgICAtICJVU0
VSOk92ZXJhbGwvQWRtaW5pc3Rlcjoke0pFTktJTlNfQURNSU5fSUQ6LWplbmtpbnN9Igog
ICAgICAgIC0gIkdST1VQOk92ZXJhbGwvUmVhZDphdXRoZW50aWNhdGVkIgogIHJlbW90aW
5nU2VjdXJpdHk6CiAgICBlbmFibGVkOiB0cnVlCnNlY3VyaXR5OgogIHF1ZXVlSXRlbUF1
dGhlbnRpY2F0b3I6CiAgICBhdXRoZW50aWNhdG9yczoKICAgICAgLSBnbG9iYWw6CiAgIC
AgICAgICBzdHJhdGVneTogdHJpZ2dlcmluZ1VzZXJzQXV0aG9yaXphdGlvblN0cmF0ZWd5
Cg==
jobs.yaml: |
am9iczoKICAtIHNjcmlwdDogPgogICAgICBwaXBlbGluZUpvYignZmlyc3Qtam9iJykgew
ogICAgICAgIGRlZmluaXRpb24gewogICAgICAgICAgY3BzIHsKICAgICAgICAgICAgc2Fu
ZGJveCgpCiAgICAgICAgICAgIHNjcmlwdCgiIiJcCiAgICAgICAgICAgICAgcGlwZWxpbm
UgewogICAgICAgICAgICAgICAgYWdlbnQgeyBsYWJlbCAnbWFzdGVyJyB9CiAgICAgICAg
ICAgICAgICBzdGFnZXMgewogICAgICAgICAgICAgICAgICBzdGFnZSAoJ2VjaG8nKSB7Ci
AgICAgICAgICAgICAgICAgICAgc3RlcHMgewogICAgICAgICAgICAgICAgICAgICAgZWNo
byAiSGVsbG8hIgogICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgfQ
ogICAgICAgICAgICAgICAgICBzdGFnZSAoJ3NoZWxsJykgewogICAgICAgICAgICAgICAg
ICAgIHN0ZXBzIHsKICAgICAgICAgICAgICAgICAgICAgIHNoICdjYXQgL2V0Yy9vcy1yZW
xlYXNlJwogICAgICAgICAgICAgICAgICAgICAgc2ggJ2hvc3RuYW1lJwogICAgICAgICAg
ICAgICAgICAgICAgc2ggJ2hvc3RuYW1lIC1pJwogICAgICAgICAgICAgICAgICAgICAgc2
ggJ3dob2FtaScKICAgICAgICAgICAgICAgICAgICAgIHNoICdwd2QnCiAgICAgICAgICAg
ICAgICAgICAgICBzaCAnbHMgLWFsJwogICAgICAgICAgICAgICAgICAgIH0KICAgICAgIC
AgICAgICAgICAgfQogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgIH0iIiIuc3Ry
aXBJbmRlbnQoKSkKICAgICAgICAgIH0KICAgICAgICB9CiAgICAgIH0K
kind: Secret
metadata:
labels:
app: jenkins
name: jenkins-casc
namespace: jenkins
type: Opaque
---
apiVersion: v1
kind: Service
metadata:
labels:
app: jenkins
name: jenkins
namespace: jenkins
spec:
ports:
- name: jenkins-http
port: 80
targetPort: 8080
- name: jenkins-agent
port: 50000
protocol: TCP
targetPort: 50000
selector:
app: jenkins
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: jenkins-pvc
namespace: jenkins
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 20Gi
storageClassName: local-path
volumeMode: Filesystem
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: jenkins-ingress
namespace: jenkins
spec:
ingressClassName: ig1
rules:
- host: jenkins.k8s.org
http:
paths:
- backend:
service:
name: jenkins
port:
number: 80
path: /
pathType: Prefix
---
apiVersion: v1
kind: Pod
metadata:
labels:
app: jenkins
name: jenkins
namespace: jenkins
spec:
containers:
- env:
- name: LIMITS_MEMORY
valueFrom:
resourceFieldRef:
divisor: 1Mi
resource: limits.memory
- name: JAVA_OPTS
value: -Djenkins.install.runSetupWizard=false -Dorg.apache.commons.jelly.tags.fmt.timeZone=Asia/Taipei
-Xmx$(LIMITS_MEMORY)m -XshowSettings:vm -Dhudson.slaves.NodeProvisioner.initialDelay=0
-Dhudson.slaves.NodeProvisioner.MARGIN=50 -Dhudson.slaves.NodeProvisioner.MARGIN0=0.85
image: quay.io/grassknot/jenkins:jcasc
imagePullPolicy: Always
name: jenkins
ports:
- containerPort: 8080
- containerPort: 50000
resources:
limits:
cpu: 1
memory: 2Gi
requests:
cpu: 0.5
memory: 500Mi
volumeMounts:
- mountPath: /usr/jenkins_config/
name: jenkins-config
- mountPath: /var/jenkins_home
name: jenkins-storage
- mountPath: /run/secrets/kubeconfig
name: kubeconfig
readOnly: true
securityContext:
fsGroup: 1000
runAsUser: 1000
serviceAccountName: jenkins
volumes:
- name: jenkins-storage
persistentVolumeClaim:
claimName: jenkins-pvc
- name: jenkins-config
secret:
secretName: jenkins-casc
- name: kubeconfig
secret:
secretName: kubeconfig

Jenkins 在 Kubernetes 裡面的權限只能對 pod 做管理，其他的 k8s 物件是沒有權限的，所以才要要讓 Jenkins 能使用 Kubectl 來對整個 Kubernetes 來做管理。

動手修改範例 08

$ cat Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'mycicd'
defaultContainer 'k1'
yaml """
apiVersion: v1
kind: Pod
spec:
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
- name: k1
securityContext:
privileged: true
image: quay.io/grassknot/kubectl:1.24.1
command: ["sleep"]
args: ["infinity"]
"""
}
}
options {
skipDefaultCheckout true
}
environment {
KUBECONFIG = credentials('kubeconfig-id')
}
stages {
stage ('get node') {
steps {
sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
sh 'kubectl get nodes -o wide'
}
}
stage ('get jenkins') {
steps {
sh 'kubectl get all -n Jenkins'
}
}
stage ('get quay') {
steps {
sh 'kubectl get all -n quay'
}
}
stage ('get default') {
steps {
sh 'kubectl get all'
}
}
}
}

實作練習

請先在 K8S 叢集建立一個 namespace 命名為 cicd 首先撰寫 pod-a1.yaml a1 pod 部署在 cicd namespace image 使用 quay.k8s.org/quay/alpine.httpd imagePullPolicy 設定 Always

$ kubectl create ns cicd
$ nano Jenkinsfile
$ cat Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'mycicd'
defaultContainer 'k1'
yaml """
apiVersion: v1
kind: Pod
spec:
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
- name: k1
securityContext:
privileged: true
image: quay.io/grassknot/kubectl:1.24.1
command: ["sleep"]
args: ["infinity"]
"""
}
}
environment {
KUBECONFIG = credentials('kubeconfig-id')
}
stages {
stage ('deploy a1') {
steps {
sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
sh 'kubectl delete -f pod-a1.yml || exit 0'
sh 'kubectl apply -f pod-a1.yml'
}
}
stage ('get cicd') {
steps {
sh 'kubectl get pod -n cicd'
}
}
}
}
$ nano Dockerfile
FROM quay.k8s.org/quay/alpine:3.15.4
RUN \
apk update && \
apk add --no-cache nano sudo bash wget curl git tree grep && \
wget https://busybox.net/downloads/binaries/1.28.1-defconfig-multiarch/busybox-x86_64 && \
chmod +x busybox-x86_64 && \
mv busybox-x86_64 bin/busybox1.28 && \
mkdir -p /opt/www && echo "let me go" > /opt/www/index.html
ENTRYPOINT ["/bin/busybox1.28"]
CMD ["httpd", "-f", "-h", "/opt/www"]

總練習 1

請把落地 Quay 中的 alpine.httpd 刪除參考前面的 Jenkinsfile 範例 07 08 與練習撰寫四個 stage podman login build image push image deploy a1

$ nano Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'mycicd'
defaultContainer 'k1'
yaml """
apiVersion: v1
kind: Pod
spec:
hostAliases:
- ip: "192.168.61.220"
hostnames:
- "quay.k8s.org"
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
- name: k1
securityContext:
privileged: true
image: quay.io/grassknot/kubectl:1.24.1
command: ["sleep"]
args: ["infinity"]
- name: p1
securityContext:
privileged: true
image: quay.io/podman/stable:v3.4.7
command: ["sleep"]
args: ["infinity"]
"""
}
}
environment {
KUBECONFIG = credentials('kubeconfig-id')
QUAY_ADMIN = credentials('quay-admin-id')
IMAGE_TAG = 'quay.k8s.org/quay/alpine.httpd:1.0.0'
}
stages {
stage ('podman login') {
steps {
container('p1') {
sh 'podman login --tls-verify=false -u=${QUAY_ADMIN_USR} -p=${QUAY_ADMIN_PSW} quay.k8s.org'
}
}
}
stage ('build image') {
steps {
container('p1') {
sh 'podman build --tls-verify=false -t "${IMAGE_TAG}" .'
sh 'podman images'
}
}
}
stage ('push image') {
steps {
container('p1') {
sh 'podman push --tls-verify=false "${IMAGE_TAG}"'
}
}
}
stage ('deploy a1') {
steps {
sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
sh 'kubectl delete -f pod-a1.yml || exit 0'
sh 'kubectl apply -f pod-a1.yml'
}
}
}
}

imagePullSecrets

在 m1 主機登入落地 Quay

$ sudo podman login --tls-verify=false quay.k8s.org -u quay -p Quay12345

檢視 auth.json

$ sudo cat /run/containers/0/auth.json
{
"auths": {
"quay.k8s.org": {
"auth": "cXVheTpRdWF5MTIzNDU="
}
}
}

複製 auth.json 到家目錄並變更擁有者

$ sudo cp /run/containers/0/auth.json ~
$ sudo chown bigred:bigred ~/auth.json

建立 K8S Secret

$ kubectl create secret generic regcred \
--from-file=.dockerconfigjson=/home/bigred/auth.json \
--type=kubernetes.io/dockerconfigjson \
-n cicd

regcred = registry + credential (都是名字，可以自取)

spec:
containers:
- name: a1
image: quay.k8s.org/quay/alpine.httpd:1.0.0
imagePullPolicy: Always
imagePullSecrets:
- name: regcred

總練習 2 前置作業

$ pwd
/home/bigred/wk
$ wget http://web.flymks.com/cicd/v1/bi2.zip
$ unzip bi2.zip
$ cd bi2
$ ls
Dockerfile invdb.sh inventory

總練習 2-1

題目：

首先將 bi2 專案資料夾完成 git 初始化
Build Image Tag 如下 quay.k8s.org/quay/bookstore-inventory:1.0.0
撰寫 K8S YAML 部署庫存管理系統 (pod-b1.yaml)
b1 pod 部署在 cicd namespace
imagePullPolicy 設定 Always
新增 Jenkins multibranch pipeline 作業，作業命名「bi2」並連接到 bi2 git 儲存庫
記得建立 git hook post-commit
參考總練習 1 撰寫 Jenkinsfile

答案：

## git 初始化
$ git init
$ ls -al
total 24
drwxr-sr-x 3 bigred bigred 4096 Jun 15 09:26 .
drwxr-sr-x 9 bigred bigred 4096 Jun 15 09:20 ..
drwxr-sr-x 7 bigred bigred 4096 Jun 15 09:26 .git
-rw-r--r-- 1 bigred bigred 616 Jun 9 23:41 Dockerfile
-rwxr-xr-x 1 bigred bigred 711 Jun 9 23:39 invdb.sh
-rwxr-xr-x 1 bigred bigred 476 Jun 9 23:41 inventory
## 建立 post-commit
$ cat << EOF > .git/hooks/post-commit
#!/bin/bash
curl -s http://jenkins.k8s.org/git/notifyCommit?url=ssh://bigred@192.168.61.4/home/bigred/wk/bi2/
EOF
## 務必賦予執行權限
$ chmod +x .git/hooks/post-commit

新增 Jenkins Job

回到 Jenkins Dashboard

點選左側新增作業
- item name 輸入 bi2
- 下方選擇 Multibranch Pipeline
- 按下 OK

點選 Branch Sources 頁籤

點選 Add source 下拉選 Git
Project Repository 輸入(紅字請替換為 m1 主機 IP)
- ssh://bigred@192.168.61.4/home/bigred/wk/bi2
- Credentials 選擇 ssh-private-key
- 最後按下 Save

編輯 pod-b1.yml

$ nano pod-b1.yml
apiVersion: v1
kind: Pod
metadata:
name: b1
namespace: cicd
spec:
containers:
- name: b1
image: quay.k8s.org/quay/bookstore-inventory:1.0.0
imagePullPolicy: Always
imagePullSecrets:
- name: regcred

編輯 Jenkinsfile

$ nano Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'bi2'
defaultContainer 'k1'
yaml """
apiVersion: v1
kind: Pod
spec:
hostAliases:
- ip: "192.168.61.220"
hostnames:
- "quay.k8s.org"
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
- name: k1
securityContext:
privileged: true
image: quay.io/grassknot/kubectl:1.24.1
command: ["sleep"]
args: ["infinity"]
- name: p1
securityContext:
privileged: true
image: quay.io/podman/stable:v3.4.7
command: ["sleep"]
args: ["infinity"]
"""
}
}
environment {
KUBECONFIG = credentials('kubeconfig-id')
QUAY_ADMIN = credentials('quay-admin-id')
IMAGE_TAG = 'quay.k8s.org/quay/bookstore-inventory:1.0.0'
}
stages {
stage ('podman login') {
steps {
container('p1') {
sh 'podman login --tls-verify=false -u=${QUAY_ADMIN_USR} -p=${QUAY_ADMIN_PSW} quay.k8s.org'
}
}
}
stage ('build image') {
steps {
container('p1') {
sh 'podman build --tls-verify=false -t "${IMAGE_TAG}" .'
sh 'podman images'
}
}
}
stage ('push image') {
steps {
container('p1') {
sh 'podman push --tls-verify=false "${IMAGE_TAG}"'
}
}
}
stage ('deploy b1') {
steps {
sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
sh 'kubectl delete -f pod-b1.yml || exit 0'
sh 'kubectl apply -f pod-b1.yml'
}
}
}
}

git add *
git status
git commit -m 'Build Project test'

$ kubectl get pod -n cicd -o wide
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
b1 1/1 Running 0 4m25s 10.244.1.169 w1 <none> <none>
$ curl 10.244.1.169/cgi-bin/inventory
[{"id":1,"isbn":"1492090719","quantity":17},
{"id":2,"isbn":"9865024918","quantity":11},
{"id":3,"isbn":"1492092304","quantity":16},
{"id":4,"isbn":"9864760785","quantity":10},
{"id":5,"isbn":"9865028042","quantity":12}]

總練習 2-2

請先完成總練習 2-1

將 podman login 指令移至 build image stage 中
將 podman login stage 刪除
在 build image stage 之前新增兩個 stage
- 第一個 stage 命名為 shellcheck
  - 負責檢查 invdb.sh 以及 inventory
  - image 使用 quay.io/grassknot/shellcheck-alpine:stable
- 第二個 stage 命名為 Test
  - image 使用 quay.k8s.org/quay/alpine.httpd:1.0.0
  - 使用 curl 將 API 結果輸出，執行結果可參考下圖

答案：

$ kubectl create secret generic regcred \
> --from-file=.dockerconfigjson=/home/bigred/auth.json \
> --type=kubernetes.io/dockerconfigjson \
> -n jenkins
$ kubectl get secret -n jenkins
NAME TYPE DATA AGE
jenkins-casc Opaque 3 5d22h
kubeconfig Opaque 1 5d22h
regcred kubernetes.io/dockerconfigjson 1 2s
$ nano Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'bi2'
defaultContainer 'k1'
yaml """
apiVersion: v1
kind: Pod
spec:
hostAliases:
- ip: "192.168.61.220"
hostnames:
- "quay.k8s.org"
imagePullSecrets:
- name: regcred
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
- name: s1
image: quay.io/grassknot/shellcheck-alpine:stable
securityContext:
privileged: true
command: ["sleep"]
args: ["infinity"]
- name: t1
image: quay.k8s.org/quay/alpine.httpd:1.0.0
securityContext:
privileged: true
- name: k1
securityContext:
privileged: true
image: quay.io/grassknot/kubectl:1.24.1
command: ["sleep"]
args: ["infinity"]
- name: p1
securityContext:
privileged: true
image: quay.io/podman/stable:v3.4.7
command: ["sleep"]
args: ["infinity"]
"""
}
}
environment {
KUBECONFIG = credentials('kubeconfig-id')
QUAY_ADMIN = credentials('quay-admin-id')
IMAGE_TAG = 'quay.k8s.org/quay/bookstore-inventory:1.0.0'
}
stages {
stage ('shellcheck') {
steps {
container('s1') {
sh 'shellcheck invdb.sh'
sh 'shellcheck inventory'
}
}
}
stage ('test') {
steps {
container('t1') {
sh '''
#!/bin/bash
apk update && apk add sqlite
mkdir -p /root/bookstore-inventory/ && mkdir -p /opt/www/cgi-bin
cp invdb.sh /root/bookstore-inventory/ && cp inventory /opt/www/cgi-bin
cd /root/bookstore-inventory/
bash invdb.sh create
'''
sh 'curl -s localhost'
sh 'curl -s localhost/cgi-bin/inventory?id=1'
sh 'curl -s localhost/cgi-bin/inventory?isbn=1492090719'
}
}
}
stage ('build image') {
steps {
container('p1') {
sh 'podman login --tls-verify=false -u=${QUAY_ADMIN_USR} -p=${QUAY_ADMIN_PSW} quay.k8s.org'
sh 'podman build --tls-verify=false -t "${IMAGE_TAG}" .'
sh 'podman images'
}
}
}
stage ('push image') {
steps {
container('p1') {
sh 'podman push --tls-verify=false "${IMAGE_TAG}"'
}
}
}
stage ('deploy b1') {
steps {
sh 'mkdir -p ~/.kube && cp ${KUBECONFIG} ~/.kube/config'
sh 'kubectl delete -f pod-b1.yml || exit 0'
sh 'kubectl apply -f pod-b1.yml'
}
}
}
}
$ git add Jenkinsfile ; git commit -m "t2"

範例 09

前置作業 1

建立 mp3 專案資料夾 (請先不要建立 post-commit)

~/wk$ mkdir mp3; cd mp3
$ git init
建立 Jenkinsfile，內容從備忘稿複製
$ nano Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'mp3'
yaml """
apiVersion: v1
kind: Pod
spec:
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
"""
}
}
options {
skipDefaultCheckout true
}
stages {
stage ('echo') {
steps {
echo 'Hello World!'
}
}
}
}
$ git add Jenkinsfile; git commit -m 'Init repo'

git branch

$ git branch
* master
建立 branch
$ git branch production
$ git branch dev
$ git branch
dev
* master
production

.git/refs/heads

$ git log
commit 36961d234c7f676f422bfbdda8536ed528055337 (HEAD -> master, prod, dev)
Author: danny <danny@example.com>
Date: Wed Jun 15 13:35:19 2022 +0800
Init repo

可以看到 commit 的代碼：36961d234c7f676f422bfbdda8536ed528055337

檢查我們建立的 branch

$ tree .git/refs/heads
.git/refs/heads
├── dev
├── master
└── prod
0 directories, 3 files

在同一個 git 專案目錄中新增的 branch 都是共用相同的 commit ID

$ cat .git/refs/heads/master
36961d234c7f676f422bfbdda8536ed528055337
$ cat .git/refs/heads/production
36961d234c7f676f422bfbdda8536ed528055337
$ cat .git/refs/heads/dev
36961d234c7f676f422bfbdda8536ed528055337

手動刪除 branch

$ rm .git/refs/heads/production
$ git branch
dev
* master

重新建立 branch，命名為 prod

$ git branch prod

前置作業 2

新增 Jenkins multibranch pipeline 作業
作業命名「mp3」並連接到 mp3 git 儲存庫
- ssh://bigred@192.168.61.4/home/bigred/wk/mp3
完成後至 Blue Ocean 網頁查看分支

不同的 branch ，Jenkins 會用不同的 pod 來作業

Jenkinsfile 範例 09

$ wget -q -O Jenkinsfile \
> "http://web.flymks.com/cicd/v1/jenkinsfile/09"
$ cat Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'mp3'
yaml """
apiVersion: v1
kind: Pod
spec:
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
"""
}
}
options {
skipDefaultCheckout true
}
stages {
stage ('echo') {
steps {
echo 'Hello World!'
}
}
stage ('Deploy Production') {
when {
branch 'prod'
}
steps {
echo 'Hello Prod!'
}
}
}
}

$ git add Jenkinsfile; git commit -m "test 09"
$ git log
commit a154b98d53d31aefd40beb213fe2580241b5bfcf (HEAD -> master)
Author: danny <danny@example.com>
Date: Wed Jun 15 14:13:47 2022 +0800
test 09
commit 36961d234c7f676f422bfbdda8536ed528055337 (prod, dev)
Author: danny <danny@example.com>
Date: Wed Jun 15 13:35:19 2022 +0800
Init repo

手動執行作業

動手修改範例 09

在 Deploy Production stage 之前新增一個 stage stage 命名為 Deploy Dev when 宣告如下

when {
not { branch 'master' }
}

steps 只需要一個 echo ‘Hello Dev!’ 請參考簡報 904 建立 git hook post-commit

$ git checkout dev
$ cat Jenkinsfile
$ git pull . master
$ git log --oneline

實作練習 Part1

$ git checkout prod
Switched to branch 'prod'
bigred@m1:~/wk/mp3$ git pull . master
From .
* branch master -> FETCH_HEAD
Updating 36961d2..978df0c
Fast-forward
Jenkinsfile | 18 +++++++++++++++++-
1 file changed, 17 insertions(+), 1 deletion(-)
$ git log --oneline

## 建立 post-commit
$ cat << EOF > .git/hooks/post-commit
#!/bin/bash
curl -s http://jenkins.k8s.org/git/notifyCommit?url=ssh://bigred@192.168.61.4/home/bigred/wk/mp3/
EOF
## 務必賦予執行權限
$ chmod +x .git/hooks/post-commit

tags: `CI/CD`

Jenkins

Mon, 13 Jun 2022 00:53:28 +0800

環境準備

CNT.2022.v4 K8S 叢集建置完成以下 K8S 公設完成部署

MetalLB
Ingress NGINX Controller
Local Path Provisioner

在 Windows 系統的 cmd 視窗登入 m1 主機修改 /etc/hosts

$ sudo nano /etc/hosts
::
192.168.124.220 quay.k8s.org jenkins.k8s.org

參考 902 簡報完成 git 必要設定

$ git config --list
user.name=danny
user.email=danny@example.com
core.editor=nano

Jenkins 參考資料

https://www.jenkins.io/
https://github.com/jenkinsci/jenkins
https://www.jenkins.io/doc/book/using/

Jenkins 介紹

Jenkins is a self-contained, open source automation server which can be used to automate all sorts of tasks related to building, testing, and delivering or deploying software.

Jenkins can be installed through native system packages, Docker, or even run standalone by any machine with a Java Runtime Environment (JRE) installed.

Jenkins Plugins

Jenkins Plugins 網站連結

There are over a thousand different plugins which can be installed on a Jenkins controller and to integrate various build tools, cloud providers, analysis tools, and much more.

JCasC

Jenkins Configuration as Code https://plugins.jenkins.io/configuration-as-code/

Jenkins Configuration as Code provides the ability to define this whole configuration as a simple, human-friendly, plain text yaml syntax.

Kubernetes plugin

Kubernetes plugin for Jenkins https://plugins.jenkins.io/kubernetes/

Jenkins plugin to run dynamic agents in a Kubernetes cluster.

The plugin creates a Kubernetes Pod for each agent started, and stops it after each build.

It is not required to run the Jenkins controller inside Kubernetes.

部署前置作業

$ pwd
/home/bigred/wk
$ kubectl create ns jenkins
namespace/jenkins created
## kubeconfig 為 secret 物件的名字
$ kubectl create secret generic kubeconfig --from-file=/home/bigred/.kube/config -n jenkins
secret/kubeconfig created
$ kubectl apply -f http://web.flymks.com/cicd/v1/jenkins.yaml
$ kubectl get all -n jenkins
NAME READY STATUS RESTARTS AGE
pod/jenkins 1/1 Running 0 89s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/jenkins ClusterIP 10.98.0.124 <none> 80/TCP,50000/TCP 89s
$ kubectl get ingress -n jenkins
NAME CLASS HOSTS ADDRESS PORTS AGE
jenkins-ingress ig1 jenkins.k8s.org 192.168.61.220 80 109s

登入 Jenkins

打開瀏覽器，網址 http://jenkins.k8s.org

帳號：jenkins
密碼：Jenkins12345

Jenkins 主畫面

執行第一個 Job

左側按下「馬上建置」

檢視執行結果

滑鼠移至綠色區塊可確認 Log 左側下方「建置歷程」點選 #1 選擇 Console Output 查看終端機輸出

進入 Blue Ocean

左側按下「Open Blue Ocean」進入 Blue Ocean 畫面後，點選中間第一列如下圖紅框處

Blue Ocean 介面

離開 Blue Ocean

右上點選 X 先離開執行結果畫面

右上點選回到經典界面的圖示

設定 SSH 免密碼

Jenkins 透過 SSH 連接 Git Jenkins 主機中已預先產生 SSH 公私鑰將公鑰給 M1 主機

$ kubectl -n jenkins exec -it jenkins -- cat /var/jenkins_home/.ssh/ssh_host_rsa_key.pub | tee -a ~/.ssh/authorized_keys

mycicd 專案資料夾

於 m1 主機建立 mycicd 專案資料夾建立一個檔案並完成 git 備份

~/wk$ mkdir mycicd; cd mycicd
$ git init
$ echo "Hi! Jenkins!" > readme
$ git add readme; git commit -m 'Init repo'

新增 Jenkins Job

回到 Jenkins Dashboard 點選左側新增作業 item name 輸入 mycicd 下方選擇 Multibranch Pipeline 按下 OK

點選 Branch Sources 頁籤 🡪 點選 Add source 下拉選 Git Project Repository 輸入(紅字請替換為 m1 主機 IP)

ssh://bigred@192.168.61.4/home/bigred/wk/mycicd

Credentials 選擇 ssh-private-key 最後按下 Save

Jenkins 掃描儲存庫

新增作業完成後 Jenkins 會自動掃描 Git 儲存庫

撰寫 Jenkinsfile

Jenkinsfile 使用 echo 語法輸出字串

$ nano Jenkinsfile
pipeline {
agent { label 'master' }
stages {
stage ('echo') {
steps {
echo "Hello!"
}
}
}
}

steps ，步驟注意！echo "Hello!" 的 echo 不是 linux 的 echo

手動通知 Jenkins

必需先將 Jenkinsfile 備份至 Git 儲存庫

$ git add Jenkinsfile
$ git commit -m "Add Jenkinsfile"

手動通知 Jenkins

$ curl http://jenkins.k8s.org/git/notifyCommit?url=ssh://bigred@192.168.61.4/home/bigred/wk/mycicd
No git jobs found
Scheduled indexing of mycicd

確認執行結果

Jenkins 網頁 Dashboard 點選 mycicd 點選 master 確認 Stage View 並檢視 Logs 至 Blue Ocean 界面確認結果

搭配 Git Hooks

搭配 Git Hooks 達到 commit 後自動通知 Jenkins

使用 post-commit

建立 post-commit
$ cat << EOF > .git/hooks/post-commit
#!/bin/bash
curl -s http://jenkins.k8s.org/git/notifyCommit?url=ssh://bigred@192.168.61.4/home/bigred/wk/mycicd
EOF
務必賦予執行權限
$ chmod +x .git/hooks/post-commit

修改 Jenkinsfile

Jenkinsfile 使用 sh 語法執行指令

$ nano Jenkinsfile
pipeline {
agent { label 'master' }
stages {
stage ('shell') {
steps {
sh "whoami"
sh "pwd"
sh "ls -al"
}
}
}
}

stage 取名為 shell steps 步驟裡面的 sh 代表要執行我們的 shell 程式，可以幫我們執行 linux 的 command

觸發 post-commit

$ git add Jenkinsfile ; git commit -m "Update Jenkinsfile"

Jenkins 網頁 Dashboard 點選 mycicd 點選 master 確認 Stage View 並檢視 Logs 至 Blue Ocean 界面確認結果

Jenkinsfile 練習

修改 Jenkinsfile Pipeline 有兩個 stage，分別是 echo 與 shell echo stage，使用 echo 語法輸出 Hello! shell stage 依序執行以下命令

cat /etc/os-release
hostname
hostname -i
whoami
pwd
ls -al

答案：

$ nano Jenkinsfile
pipeline {
agent { label 'master' }
stages {
stage ('echo') {
steps {
echo "Hello"
}
}
stage ('shell') {
steps {
sh "cat /etc/os-release"
sh "hostname"
sh "hostname -i"
sh "whoami"
sh "pwd"
sh "ls -al"
}
}
}
}
$ git add Jenkinsfile ; git commit -m "Update Jenkinsfile 2"

dynamic agents

Jenkins 透過 Kubernetes plugin 可以動態產生 Pod Agent 概念等同 Worker Master 與 Agent 透過 JNLP 協定溝通

Jenkinsfile 範例 01

下載 Jenkinsfile 範例 01

$ wget -q -O Jenkinsfile \
"http://web.flymks.com/cicd/v1/jenkinsfile/01"

檢視 Jenkinsfile 範例 01

$ cat Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'mycicd'
yaml """
apiVersion: v1
kind: Pod
spec:
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
"""
}
}
stages {
stage ('shell') {
steps {
sh 'whoami'
sh 'pwd'
sh 'ls -al'
sh 'cat readme'
}
}
}
}

如果不宣告 pod 的 Container 的 image 為 qua.io 來源的話，預設是 ducker.hub 的 image 中心。

確認範例 01 結果

$ git add Jenkinsfile; git commit -m "test 01"

觀察作業用 Pod 是否有產生

$ watch kubectl get pod -n jenkins

請至 Jenkins 網頁確認執行結果 !

Multiple containers

可以透過 Container 的技術達成不同的效果

## 下載 Jenkinsfile 範例 02
$ wget -q -O Jenkinsfile \
"http://web.flymks.com/cicd/v1/jenkinsfile/02"
## 檢視 Jenkinsfile 範例 02
$ cat Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'mycicd'
yaml """
apiVersion: v1
kind: Pod
spec:
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
- name: p1
securityContext:
privileged: true
image: quay.io/podman/stable:v3.4.7
command: ["sleep"]
args: ["infinity"]
"""
}
}
options {
skipDefaultCheckout true
}
stages {
stage ('podman') {
steps {
sh 'podman version || echo "command not found"'
container('p1') {
sh 'podman version'
}
}
}
}
}

如果要更進階的學習 Jenkins 的 pipeline ，請點連結

以上的語言最後都會翻譯成 Groovy 語言

## 下載 Jenkinsfile 範例 05
$ wget -q -O Jenkinsfile \
"http://web.flymks.com/cicd/v1/jenkinsfile/05"
$ cat Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'mycicd'
yaml """
apiVersion: v1
kind: Pod
spec:
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
- name: p1
securityContext:
privileged: true
image: quay.io/podman/stable:v3.4.7
command: ["sleep"]
args: ["infinity"]
"""
}
}
options {
skipDefaultCheckout true
}
stages {
stage ('podman login') {
steps {
container('p1') {
sh 'podman login --tls-verify=false -u=quay -p=Quay12345 quay.k8s.org'
}
}
}
}
}

stage 階段 steps 步驟

Jenkins 如果沒有特定宣告哪一個 Contianer 的話，預設是 jnlp 那台 Container

結果報錯

$ git add Jenkinsfile
$ git commit -m "test05"
+ podman login --tls-verify=false -u=quay -p=Quay12345 quay.k8s.org
Error: authenticating creds for "quay.k8s.org": pinging container registry quay.k8s.org: Get "http://quay.k8s.org/v2/": dial tcp: lookup quay.k8s.org: no such host
script returned exit code 125

## Jenkinsfile 05-1
$ nano Jenkinsfile
pipeline {
agent {
kubernetes {
yaml """
apiVersion: v1
kind: Pod
spec:
hostAliases:
- ip: "192.168.61.220"
hostnames:
- "quay.k8s.org"
containers:
- name: jnlp
--- 以下省略 ---

## Jenkinsfile 05-2
$ cat Jenkinsfile
pipeline {
agent {
kubernetes {
inheritFrom 'mycicd'
yaml """
apiVersion: v1
kind: Pod
spec:
hostAliases:
- ip: "192.168.61.220"
hostnames:
- "quay.k8s.org"
containers:
- name: jnlp
image: quay.io/flysangel/inbound-agent:4.13-2-jdk11
- name: p1
securityContext:
privileged: true
image: quay.io/podman/stable:v3.4.7
command: ["sleep"]
args: ["infinity"]
"""
}
}
options {
skipDefaultCheckout true
}
stages {
stage ('podman login') {
steps {
container('p1') {
sh 'podman login --tls-verify=false -u=quay -p=Quay12345 quay.k8s.org'
}
}
}
stage ('hostAliases') {
steps {
sh 'cat /etc/hosts'
container('p1') {
sh 'cat /etc/hosts'
}
}
}
}
}

tags: `CI/CD`

Git - Part 2

Mon, 13 Jun 2022 00:53:08 +0800

環境準備

CNT.2022.v4 K8S 叢集建置完成在 Windows 系統的 cmd 視窗登入 m1 主機下載 bookstore-inventory 程式碼

bigred@m1:~/wk$ pwd
/home/bigred/wk
$ wget http://web.flymks.com/cicd/v1/bi.zip
$ unzip bi.zip
$ cd bookstore-inventory
## 設定 git user (請自己替換名稱)
$ git config --global user.name "danny"
$ git config --global user.email "danny@example.com"
> --global 全域設定
## git 預設使用 vim，修改設定使用 nano
$ git config --global core.editor "nano"
## 檢查 git 設定
$ git config --list
user.name=danny
user.email=danny@example.com
core.editor=nano
## git 初始化
$ git init
## git 檢查檔案狀態
$ git status

Git Hooks 介紹

git 的儲存庫分為 Local （本地）和 Remote （遠端）

$ tree .git/hooks/
.git/hooks/
├── applypatch-msg.sample
├── commit-msg.sample
├── post-update.sample
├── pre-applypatch.sample
├── pre-commit.sample ------------------> 今天主要會用到的
├── pre-merge-commit.sample
├── pre-push.sample
├── pre-rebase.sample
├── pre-receive.sample
├── prepare-commit-msg.sample
├── push-to-checkout.sample
└── update.sample

$ $ cat .git/hooks/pre-commit.sample
# An example hook script to verify what is about to be committed.
# Called by "git commit" with no arguments. The hook should
# exit with non-zero status after issuing an appropriate message if
# it wants to stop the commit.
#
# To enable this hook, rename this file to "pre-commit".

ShellCheck 介紹

A shell script static analysis tool https://github.com/koalaman/shellcheck

ShellCheck is a GPLv3 tool that gives warnings and suggestions for bash/sh shell scripts.

安裝 shellcheck

$ sudo apk add shellcheck

使用 ShellCheck

$ shellcheck invdb.sh
In invdb.sh line 32:
if [ ! -z "${1}" ]; then
^-- SC2236 (style): Use -n instead of ! -z.
For more information:
https://www.shellcheck.net/wiki/SC2236 -- Use -n instead of ! -z.

-z 為判斷檔案不存在，前面加驚嘆號為雙重否定

建立 pre-commit

$ cat << EOF > .git/hooks/pre-commit
#!/bin/bash
shellcheck invdb.sh
EOF

務必賦予執行權限

$ chmod +x .git/hooks/pre-commit

觸發 pre-commit

bigred@m1:~/wk/bookstore-inventory$ ls -al
total 20
drwxr-sr-x 3 bigred bigred 4096 Jun 9 09:11 .
drwxr-sr-x 7 bigred bigred 4096 Jun 9 09:08 ..
drwxr-sr-x 7 bigred bigred 4096 Jun 9 09:36 .git
-rwxr-xr-x 1 bigred bigred 713 Jun 5 22:05 invdb.sh
-rwxr-xr-x 1 bigred bigred 487 Jun 5 22:05 inventory

在 .git 的專案目錄中，除了 .git 目錄外，其他都為 git 的工作目錄區

## invdb.sh 加入 git 追蹤
$ git add invdb.sh
## 檢查狀態
$ git status
On branch master
No commits yet
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file: invdb.sh
Untracked files:
(use "git add <file>..." to include in what will be committed)
inventory
## git 備份我們的檔案
$ git commit -m 'Add invdb.sh'
In invdb.sh line 32:
if [ ! -z "${1}" ]; then
^-- SC2236 (style): Use -n instead of ! -z.
For more information:
https://www.shellcheck.net/wiki/SC2236 -- Use -n instead of ! -z.
## 觸發 git-precommit
$ git status
On branch master
No commits yet
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file: invdb.sh
Untracked files:
(use "git add <file>..." to include in what will be committed)
inventory

修改 `invdb.sh`

請依 shellcheck 建議修改 invdb.sh

$ nano invdb.sh
if [ -n "${1}" ]; then -----> 將 "! -z" 改為 "-n"

完成後執行 git status

$ git status
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file: invdb.sh
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: invdb.sh
Untracked files:
(use "git add <file>..." to include in what will be committed)
inventory

注意，如果在 git add 檔案後又修改檔案，此時直接 commit ，git 只會備份舊版的檔案，所以要再 git add 一次

## 將 invdb.sh 再次加入追蹤
$ git add invdb.sh
## 檢查狀態
$ git status
On branch master
No commits yet
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file: invdb.sh
Untracked files:
(use "git add <file>..." to include in what will be committed)
inventory
## 將 invdb.sh 給 git 備份
$ git commit -m 'Add invdb.sh'
[master (root-commit) ad0bb75] Add invdb.sh
1 file changed, 36 insertions(+)
create mode 100755 invdb.sh
$ shellcheck invdb.sh
$ echo $?
0

實作練習 1

修改 pre-commit，使用 shellcheck 檢查 inventory 使用 git 備份 inventory 觀察 pre-commit 執行結果依 shellcheck 建議修改 inventory 完成 git 備份 inventory

$ shellcheck inventory
In inventory line 10:
parm=($QUERY_STRING)
^-----------^ SC2206 (warning): Quote to prevent word splitting/globbing, or split robustly with mapfile or read -a.
For more information:
https://www.shellcheck.net/wiki/SC2206 -- Quote to prevent word splitting/g...
$ nano inventory
echo "Content-type: application/json"
echo ""
DB_PATH="/root/bookstore-inventory/inventory.db"
IFS="=&" read -r -a parm <<< "$QUERY_STRING" ---- > 修改這行
sql="sqlite3 -json ${DB_PATH} "
[ "$QUERY_STRING" == "" ] && $sql "select * from inventory" && exit 0
case "${parm[0]}" in
id)
$sql "select * from inventory where id = ${parm[1]}"
;;
isbn)
$sql "select * from inventory where isbn = ${parm[1]}"
;;
*)
$sql "select * from inventory"
;;
esac
$ cat << EOF > .git/hooks/pre-commit
#!/bin/bash
shellcheck inventory
EOF
$ git commit inventory -m 'Add inventory'

部署 Quay on K8S

環境準備 CNT.2022.v4 K8S 叢集建置完成以下 K8S 公設完成部署 MetalLB Ingress NGINX Controller Local Path Provisioner 在 Windows 系統的 cmd 視窗登入 m1 主機

$ kubectl create ns quay
namespace/quay created
$ kubectl apply -f http://web.flymks.com/cicd/v1/quay.yaml

$ sudo podman run -it --rm quay.io/flysangel/busybox:1.35.0 echo 'Hello Quay'
Hello Quay
bigred@m1:~/quay-podman$ sudo podman images | grep 1.35.0
192.168.61.4/myquay/busybox 1.35.0 af4897967787 2 weeks ago 1.47 MB
quay.io/flysangel/busybox 1.35.0 af4897967787 2 weeks ago 1.47 MB
bigred@m1:~/quay-podman$ sudo podman tag quay.io/flysangel/busybox:1.35.0 quay.k8s.org/quay/busybox:1.35.0
bigred@m1:~/quay-podman$ sudo podman login --tls-verify=false quay.k8s.org -u quay -p Quay12345
Login Succeeded!
$ sudo podman push --tls-verify=false quay.k8s.org/quay/busybox:1.35.0
$ sudo podman pull quay.io/flysangel/alpine:3.15.4
$ sudo podman tag quay.io/flysangel/alpine:3.15.4 quay.k8s.org/quay/alpine:3.15.4
$ sudo podman images
$ sudo podman images | grep k8s
$ sudo podman push --tls-verify=false quay.k8s.org/quay/alpine:3.15.4
$ sudo podman pull quay.io/flysangel/nginx:1.22.0
$ sudo podman tag quay.io/flysangel/nginx:1.22.0 quay.k8s.org/quay/nginx:1.22.0
$ sudo podman push --tls-verify=false quay.k8s.org/quay/nginx:1.22.0

實作練習 2

撰寫 bookstore-inventory Dockerfile 可參考備註 alpine httpd Dockerfile Dockerfile 請指定工作目錄 WORKDIR /root/bookstore-inventory Build Image Tag 如下 quay.k8s.org/quay/bookstore-inventory:1.0.0 container 測試沒問題後，完成 git 備份 Push Image 到落地 Quay

$ nano bookstore-inventory/Dockerfile
FROM quay.k8s.org/quay/alpine:3.15.4
WORKDIR /root/bookstore-inventory
COPY invdb.sh /root/bookstore-inventory
COPY inventory /root/bookstore-inventory
RUN \
apk update && \
apk add --no-cache nano sudo bash wget curl tree grep sqlite && \
wget https://busybox.net/downloads/binaries/1.28.1-defconfig-multiarch/busybox-x86_64 && \
chmod +x busybox-x86_64 && \
mv busybox-x86_64 /bin/busybox1.28 && \
bash invdb.sh create && \
mkdir -p /opt/www/cgi-bin && echo "let me go" > /opt/www/index.html && \
cp inventory /opt/www/cgi-bin/
ENTRYPOINT ["/bin/busybox1.28"]
CMD ["httpd", "-f", "-h", "/opt/www"]
$ sudo podman build --tls-verify=false -t quay.k8s.org/quay/bookstore-inventory:1.0.0 bookstore-inventory/
$ sudo podman run --rm --name b1 -d -p 8080:80 quay.k8s.org/quay/bookstore-inventory:1.0.0
$ curl localhost:8080
$ curl localhost:8080/cgi-bin/inventory
$ curl localhost:8080/cgi-bin/inventory?id=1
$ curl localhost:8080/cgi-bin/inventory?isbn=1492090719
$ git add Dockerfile
$ git status
$ git commit -m "quay.k8s.org/quay/bookstore-inventory:1.0.0"
$ git status
$ sudo podman push --tls-verify=false quay.k8s.org/quay/bookstore-inventory:1.0.0

tags: `CI/CD`

Git

Sun, 29 May 2022 01:02:02 +0800

Git 介紹

Git was created by Linus Torvalds in 2005 for development of the Linux kernel , with other kernel developers contributing to its initial development. Since 2005, Junio Hamano has been the core maintainer. As with most other distributed version control systems, and unlike most client–server systems, every Git directory on every computer is a full-fledged repository with complete history and full version-tracking abilities, independent of network access or a central server. Git is free and open-source software distributed under GNU General Public License Version 2.

Git 屬於 Distributed Version Control 分散式版控軟體
- 最早的版本由 Linus Torvalds 於 2005 開發完成
- 具備離線功能，有可以線上發佈
- 功能的核心在於備份程式內容

by 程威

情境說明

在網路書店擔任程式設計師負責書目庫存查詢系統開發由兩個子系統組成書目管理系統(已完成) 庫存查詢系統(開發中) <———– 搭配 Git 進行系統開發

系統規格與目標

使用 httpd + CGI 完成一個 REST API 資料庫使用 SQLite 3

Table Schema

inventory
isbn
quantity

搭配 Git 完成源碼備份

建立開發環境

$ docker run -itd --rm --name dev quay.io/flysangel/alpine:3.15.4
$ docker ps -a
$ docker exec -it dev /bin/sh
/ #
/ # apk update && apk upgrade
/ # apk add nano wget curl tree bash grep
/ # exit
$ docker exec -it dev /bin/bash
bash-5.1# cd
bash-5.1# pwd
bash-5.1# ls -al

開發環境準備

## 下載 busybox 1.28 版
bash-5.1# wget https://busybox.net/downloads/binaries/1.28.1-defconfig-multiarch/busybox-x86_64
bash-5.1# chmod +x busybox-x86_64
bash-5.1# mv busybox-x86_64 /bin/busybox1.28
## 使用 busybox1.28 httpd 啟動網站伺服器
bash-5.1# mkdir -p /opt/www && echo "let me go" > /opt/www/index.html
bash-5.1# busybox1.28 httpd -h /opt/www
## 安裝sqlite
bash-5.1# apk add sqlite

安裝 git

$ apk update && apk add git
確認 git 版本
$ git version
git version 2.34.2

git 必要設定

設定 git user (請自己替換名稱)
$ git config --global user.name "danny"
$ git config --global user.email "danny@example.com"
> --global 全域設定
git 預設使用 vim，修改設定使用 nano
$ git config --global core.editor "nano"
檢查 git 設定
$ git config --list
user.name=danny
user.email=danny@example.com
core.editor=nano

建立專案資料夾

bash-5.1# mkdir bookstore-inventory
bash-5.1# cd bookstore-inventory/
bash-5.1# pwd
/root/bookstore-inventory
## git 初始化
bash-5.1# git init
...
## 等等備份的資料都會存到/root/bookstore-inventory/.git/
Initialized empty Git repository in /root/bookstore-inventory/.git/
bash-5.1# ls -al
total 12
drwxr-xr-x 3 root root 4096 May 27 06:32 .
drwx------ 1 root root 4096 May 27 06:32 ..
drwxr-xr-x 7 root root 4096 May 27 06:32 .git

庫存管理系統開發

撰寫建立系統資料庫的腳本

$ nano invdb.sh
#!/bin/bash
DB_NAME="inventory.db"
## 建立資料庫
create() {
sqlite3 ${DB_NAME} <<EOF
CREATE TABLE inventory (
id INTEGER PRIMARY KEY AUTOINCREMENT,
isbn TEXT NOT NULL,
quantity INTEGER NOT NULL
);
EOF
}
create

AUTOINCREMENT，意思是等等的ID會自動增加

執行程式

$ chmod +x invdb.sh
$ ./invdb.sh

確認是否符合預期

$ echo '.schema' | sqlite3 inventory.db

git status

命令

$ git status

結果：

On branch master
No commits yet
## Untracked，不做備份與檢視
Untracked files:
(use "git add <file>..." to include in what will be committed)
invdb.sh
inventory.db
nothing added to commit but untracked files present (use "git add" to track)

讓 git 追蹤檔案

$ git add invdb.sh
$ git status
On branch master
No commits yet
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file: invdb.sh
Untracked files:
(use "git add <file>..." to include in what will be committed)
inventory.db

git 備份檔案

$ git commit
::
Add invdb.sh <------------- 在最底下新增這行字串

檢查

$ git status

結果：

On branch master
Untracked files:
(use "git add <file>..." to include in what will be committed)
inventory.db <-----------------只剩 inventory.db 未備份
nothing added to commit but untracked files present (use "git add" to track)

git 狀態流程圖解1

名詞解釋

Untracked ，未被git追蹤的狀態
Unmodified ，program被git備份到Repository後的狀態，在這個狀態下，只要有修改program，git都會追蹤，下git status命令，會看到狀態是Modified。
Modified ，program在Unmodified狀態下，又被修改完的狀態
Staged ，git的檔案暫存區，功能在於把檔案分開備份
Repository ， git備份檔案的儲存區，位於專案目錄中的.git目錄裡面

命令解釋

git add <file name> ，將Untracked或Modified狀態中的檔案，加到Staged（暫存區）
git commit <file name> ，將Staged 中的檔案提交給Repository
- 如果後面不加<file name>，則staged狀態的所有檔案都會備份

流程解釋

在git的工作目錄下，寫完了一支新的program，可以下git status檢查狀態，會發現當前的狀態屬於Untracked，代表未被git追蹤與備份。

當我們下命令git add < file name >之後，再下git status檢查狀態，可以看到program會被加到Staged（暫存區）。

注意，不管git的工作目錄下有幾個未被追蹤的檔案，就算只有一個，git add後面也要指定檔案，該檔案才會被git追蹤

最後我們下命令git commit < file name >之後，git會把檔案，從Staged搬到Repository，此時檔案的狀態會回到Unmodified。

.git目錄內容先不討論

問題：如果git commit後面不加檔名，git會把所有存在Staged的檔案都備份到Repository 但是commit後的名稱對應多個檔案要怎麼分辨？？？

答：執行git log -p，可以看到commit 中有修改那些內容

修改 `invdb.sh`

先刪除inventory.db

$ rm inventory.db

編輯invdb.sh

$ nano invdb.sh
DB_NAME="inventory.db"
create() {
sqlite3 ${DB_NAME} <<EOF
CREATE TABLE inventory (
id INTEGER PRIMARY KEY AUTOINCREMENT,
isbn TEXT NOT NULL,
quantity INTEGER NOT NULL
);
## 新增下面這行
insert into inventory (isbn,quantity) values ("1492090719","17");
EOF
}
create

執行

$ ./invdb.sh

檢查程式

$ echo 'select * from inventory' | sqlite3 inventory.db
1|1492090719|17

檢查git 狀態

$ git status
On branch master
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: invdb.sh

將invdb.sh加入Staged

$ git add invdb.sh && git status
On branch master
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
modified: invdb.sh

將invdb.sh從Staged加到Repository

$ git commit -m 'Update create function'
[master cf2d9e1] Update create function
1 file changed, 1 insertion(+)

-m ，message，代表可以直接在命令後面幫備份檔命名。

最後檢查git狀態

$ git status

git 狀態流程圖解2

將Unmodified狀態的程式進行修改，因為此時git已經在追蹤該程式，所以修改後狀態會變成Modified，此時可以下git add命令，將檔案加入Staged（暫存區），再下git commit，將檔案完成備份，之後狀態會回到Unmodified。

`invdb.sh` 新增功能

$ nano invdb.sh
刪除最後一行
create
新增以下程式碼
rmdb() {
rm ${DB_NAME}
}
if [ "${1}" == "create" ]; then
create
elif [ "${1}" == "rm" ]; then
rmdb
fi

#!/bin/bash
DB_NAME="inventory.db"
## 建立資料庫
create() {
sqlite3 ${DB_NAME} <<EOF
CREATE TABLE inventory (
id INTEGER PRIMARY KEY AUTOINCREMENT,
isbn TEXT NOT NULL,
quantity INTEGER NOT NULL
);
insert into inventory (isbn,quantity) values ("1492090719","17");
EOF
}
rmdb() {
rm ${DB_NAME}
}
if [ "${1}" == "create" ]; then
create
elif [ "${1}" == "rm" ]; then
rmdb
fi

修改後，刪除inventory.db

$ rm inventory.db

執行程式並確認是否符合預期

$ ./invdb.sh create
$ echo 'select * from inventory' | sqlite3 inventory.db
1|1492090719|17
$ ./invdb.sh rm
$ ls -al

檢視與備份檔的差異

命令：

$ git diff <file name>

如果命令後面不加檔案名稱，會看到每個modified狀態的檔案與對應備份檔的差異。

結果：

...以上省略
-create
+rmdb() {
+ rm ${DB_NAME}
+}
+
+if [ "${1}" == "create" ]; then
+ create
+elif [ "${1}" == "rm" ]; then
+ rmdb
+fi
...以下省略

跳過暫存區直接備份檔案

命令：

$ git commit -a <file name>

如果命令後面不指定檔案，git會直接將Staged的所有檔案通通備份

$ git commit -a -m "Add rmdb function"
[master 0383843] Add rmdb function
1 file changed, 10 insertions(+), 1 deletion(-)

檢查git的狀態

$ git status
On branch master
nothing to commit, working tree clean

git 狀態流程圖解3

流程解釋

將Modified狀態的所有檔案，跳過暫存區，直接完成備份。

如果Staged裡已經存有上次git add的檔案，此時又修改程式，然後直接git commit -a，staged的檔案會存在嗎？

答：staged裡的檔案，經過修改後，會回到Modified的狀態，所以直接打git commit -a，一樣會跳過暫存區，將檔案與暫存區的所有檔案直接備份到Repository。

實作練習 1

請重構 invdb.sh 使用 case 語法替換 if/elif 新增執行 SQL 命令的功能

預期結果

$ ./invdb.sh create
$ ./invdb.sh "select * from inventory"
1|1492090719|17

完成重構後，請使用 git 備份! Commit 內容為：Refactor invdb.sh

答案：

#!/bin/bash
DB_NAME="inventory.db"
## 建立資料庫
create() {
sqlite3 ${DB_NAME} <<EOF
CREATE TABLE inventory (
id INTEGER PRIMARY KEY AUTOINCREMENT,
isbn TEXT NOT NULL,
quantity INTEGER NOT NULL
);
insert into inventory (isbn,quantity) values ("1492090719","17");
EOF
}
rmdb() {
rm ${DB_NAME}
}
[ "${1}" == "" ] && echo "請輸入參數，謝謝！" && exit 1
case $1 in
create)
create ;;
rm)
rmdb ;;
"select * from inventory")
echo "${1}" | sqlite3 ${DB_NAME} ;;
*)
echo "請輸入（ create / rm / select * from inventory ）其中一個參數，謝謝！";;
esac

git log

命令：

$ git log

功能：顯示commit後的資訊。

用法：按鍵盤的上下鍵移動，按Q離開。

commit fbd420d1652b3211c7fba65b9eb85b910064c879 (HEAD -> master)
Author: antony <antony@example.com>
Date: Sat May 28 09:01:28 2022 +0000
Refactor invdb.sh
commit 61432f393fb5f4da0b9ef7604619ad14bf30e1ac
Author: antony <antony@example.com>
Date: Sat May 28 08:29:38 2022 +0000
Add rmdb function
commit bb26a89b0d49e5976fb385222a5459acda9d97f3
Author: antony <antony@example.com>
Date: Sat May 28 07:25:11 2022 +0000
Update create function
commit 46a27e28c331b9fb1ad753c14a0f6febe2c9cb68
Author: antony <antony@example.com>
Date: Sat May 28 04:16:52 2022 +0000
test aaa
inventory1
commit c7f5a8a64e2833b44030e8771b5e49ff0546df09
Author: antony <antony@example.com>
Date: Sat May 28 04:07:56 2022 +0000
echo "abc"
commit 9549e5f88f915d9f97c65182ee7da4c5b6c975c2
Author: antony <antony@example.com>
Date: Sat May 28 03:49:44 2022 +0000
Add invdb.sh
~

加參數 --oneline ，縮短commit後產生的版本（取前七碼）、作者與時間和 --graph，在同一個開發路線前面加符號。

$ git log --oneline --graph
* fbd420d (HEAD -> master) Refactor invdb.sh
* 61432f3 Add rmdb function
* bb26a89 Update create function
* 46a27e2 test aaa inventory1
* c7f5a8a echo "abc"
* 9549e5f Add invdb.sh
...以下省略

超級注意！關於commit後的訊息，不能隨便亂寫!

加參數：--grep，git內建搜尋commit的訊息

$ git log --grep Update
commit bb26a89b0d49e5976fb385222a5459acda9d97f3
Author: antony <antony@example.com>
Date: Sat May 28 07:25:11 2022 +0000
Update create function
...以下符號省略

撰寫API程式

REST API 筆記連結

$ nano inventory
#!/bin/bash
## 對於CGI而言以下兩行是必要的程式碼
echo "Content-type: application/json"
echo ""
## 主程式碼
DB_PATH="/root/bookstore-inventory/inventory.db"
sqlite3 ${DB_PATH} "select * from inventory"

執行程式並確認是否符合預期

$ chmod +x inventory
$ ./inventory
Content-type: application/json
1|1492090719|17

程式說明：這支程式等等會交由Httpd網站伺服器來執行，他使用的技術是CGI，可以讓網站伺服器執行Bash script。

httpd CGI 測試

$ mkdir /opt/www/cgi-bin

cgi-bin 是指定的，Httpd 網站伺服器只認這個目錄

拷貝我們的程式碼

$ cp inventory /opt/www/cgi-bin

curl檢查能不能成功

$ curl localhost/cgi-bin/inventory
1|1492090719|17

為何程式名稱後面不加.sh，因為這樣就不符合REST API的要求 此時已經初步完成REST API程式了，剩回傳的json 格式

使用 git 備份 inventory

$ git add inventory
$ git commit -m 'Add API script "inventory"'

修改 `invdb.sh`

資料只有一筆太少，請修改 invdb.sh 新增多筆資料請輸出以下資料

$ ./invdb.sh rm && ./invdb.sh create
$ ./invdb.sh "select * from inventory"
1|1492090719|17
2|9865024918|11
3|1492092304|16
4|9864760785|10
5|9865028042|12

答案：

#!/bin/bash
DB_NAME="inventory.db"
## 建立資料庫
create() {
sqlite3 ${DB_NAME} <<EOF
CREATE TABLE inventory (
id INTEGER PRIMARY KEY AUTOINCREMENT,
isbn TEXT NOT NULL,
quantity INTEGER NOT NULL
);
insert into inventory (isbn,quantity) values ("1492090719","17");
insert into inventory (isbn,quantity) values ("9865024918","11");
insert into inventory (isbn,quantity) values ("1492092304","16");
insert into inventory (isbn,quantity) values ("9864760785","10");
insert into inventory (isbn,quantity) values ("9865028042","12");
EOF
}
...以下省略

API 程式修改

修改 API 程式，請在最後一行 sqlite3 加入 -json 參數

$ nano inventory
::
sqlite3 -json ${DB_PATH} "select * from inventory"

$ cp inventory /opt/www/cgi-bin
$ curl localhost/cgi-bin/inventory
[{"id":1,"isbn":"1492090719","quantity":17},
{"id":2,"isbn":"9865024918","quantity":11},
{"id":3,"isbn":"1492092304","quantity":16},
{"id":4,"isbn":"9864760785","quantity":10},
{"id":5,"isbn":"9865028042","quantity":12}]

實作練習 2

先刪除inventory.db

$ ./invdb.sh rm

查看git狀態

$ git status
On branch master
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: invdb.sh
modified: inventory
no changes added to commit (use "git add" and/or "git commit -a")

備份 invdb.sh commit 資訊：Update invdb.sh, insert multiple record

$ git commit invdb.sh
...以上省略
Update invdb.sh, insert multiple record

檢查git狀態

$ git status
On branch master
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: inventory

看git最後一筆log檔資訊

commit e1c3580841b9f06e786439d63c61830c577ac8e2 (HEAD -> master)
Author: antony <antony@example.com>
Date: Sat May 28 12:25:21 2022 +0000
Update invdb.sh, insert multiple record

API 程式修改

$ nano inventory
#!/bin/bash
echo "Content-type: application/json"
echo ""
DB_PATH="/root/bookstore-inventory/inventory.db"
saveIFS=$IFS
IFS='=&'
parm=($QUERY_STRING)
IFS=$saveIFS
if [ "${parm[0]}" == "id" ]; then
sqlite3 -json ${DB_PATH} "select * from inventory where id = ${parm[1]}"
else
sqlite3 -json ${DB_PATH} "select * from inventory"
fi

QUERY_STRING 就是網址後面要搜尋的字串，例如: localhost/cgi-bin/inventory?xxx=123&yyy=456&zzz=789 $QUERY_STRING=“xxx=123&yyy=456&zzz=789”

在bash裡，有一個預設的變數，$IFS，它代表分隔符號，用來規定系統內的分隔符，如果在linux系統裡直接echo $IFS，可以看到是空白

parm=($QUERY_STRING)，在bash裡面，$QUERY_STRING兩側加小括號，會被視為陣列處理，但是分隔符這裡已經變更為=&，在系統裡會認為是：xxx 123 yyy 456 zzz 789 舉例：parm[0]=xxx ; parm[1]=123

做完陣列以後，分隔符號會再變回預先儲存的saveIFS

API 程式測試

$ ./invdb.sh create
$ ./inventory
$ cp inventory /opt/www/cgi-bin
$ curl localhost/cgi-bin/inventory
[{"id":1,"isbn":"1492090719","quantity":17},
{"id":2,"isbn":"9865024918","quantity":11},
{"id":3,"isbn":"1492092304","quantity":16},
{"id":4,"isbn":"9864760785","quantity":10},
{"id":5,"isbn":"9865028042","quantity":12}]
$ curl localhost/cgi-bin/inventory?id=1
[{"id":1,"isbn":"1492090719","quantity":17}]

實作練習3

請完成 API 程式，預期結果如下

$ curl localhost/cgi-bin/inventory
[{"id":1,"isbn":"1492090719","quantity":17},
{"id":2,"isbn":"9865024918","quantity":11},
{"id":3,"isbn":"1492092304","quantity":16},
{"id":4,"isbn":"9864760785","quantity":10},
{"id":5,"isbn":"9865028042","quantity":12}]
$ curl localhost/cgi-bin/inventory?id=1
[{"id":1,"isbn":"1492090719","quantity":17}]
$ curl localhost/cgi-bin/inventory?isbn=9865028042
[{"id":5,"isbn":"9865028042","quantity":12}]

答：

$ nano inventory
#!/bin/bash
echo "Content-type: application/json"
echo ""
DB_PATH="/root/bookstore-inventory/inventory.db"
saveIFS=$IFS
IFS='=&'
parm=($QUERY_STRING)
IFS=$saveIFS
if [ "${parm[0]}" == "id" ]; then
sqlite3 -json ${DB_PATH} "select * from inventory where id = ${parm[1]}"
elif [ "${parm[0]}" == "isbn" ];then
sqlite3 -json ${DB_PATH} "select * from inventory where isbn = ${parm[1]}"
else
sqlite3 -json ${DB_PATH} "select * from inventory"
fi

拷貝API

$ cp inventory /opt/www/cgi-bin

最後檢查

$ curl localhost/cgi-bin/inventory?isbn=9864760785
[{"id":4,"isbn":"9864760785","quantity":10}]

git備份

$ git commit -a -m 'Update API script "inventory"'

檢視 git log

命令：

$ git log --oneline --graph

結果：

7bc247 (HEAD -> master) Update API script "inventory"
* e1c3580 Update invdb.sh, insert multiple record
* fbd420d Refactor invdb.sh
* 61432f3 Add rmdb function
* bb26a89 Update create function
* 46a27e2 test aaa inventory1
* c7f5a8a echo "abc"
* 9549e5f Add invdb.sh

git restore

如果不小心把程式給宰了，怎麼辦？

$ rm invdb.sh
$ ls -al
drwxr-xr-x 8 root root 4096 May 26 16:35 .git
-rwxr-xr-x 1 root root 488 May 26 16:25 inventory

檢查git 的狀態

$ git status
On branch master
Changes not staged for commit:
(use "git add/rm <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
deleted: invdb.sh
no changes added to commit (use "git add" and/or "git commit -a")

可以看到此時狀態為: deleted

還原我們的檔案

$ git restore invdb.sh

檢查

$ ls -al
drwxr-xr-x 8 root root 4096 May 26 16:38 .git
-rwxr-xr-x 1 root root 714 May 26 16:38 invdb.sh
-rwxr-xr-x 1 root root 488 May 26 16:25 inventory

退出開發環境

離開Container

$ exit

複製 bookstore-inventory

~/wk$ docker cp dev:/root/bookstore-inventory .
$ ls -al bookstore-inventory
$ docker stop dev
$ docker ps -a

tags: `CI/CD`

CI/CD Overview

Sat, 28 May 2022 14:03:00 +0800

單人開發流程

攥寫Bash Script
執行程式 – > 成功
攥寫Dockerfile
Build Image Run Container – > 成功
Push Image
攥寫K8s Yaml檔
Kubectl apply – > 符合預期
維運應用程式 —————– > 如有新需求 — > 回到第一步

程式設計師的痛點

哪些東西需要備份?
如何備份?
程式碼版本差異如何得知?
時常出現的人為失誤如何減少?
人工手動的反覆步驟如何簡化?

夢想與現實

三位工程師各自開發三個不同的新功能 (現實上很容易超過三個功能) 一個月後另一位工程師會來整合發生 - > 整合地獄最後測試人員 - > 測試 – > 部署上線

————————————————- 為了解決以上痛點

持續整合 Continuous integration (CI)

持續小規模小規模的(縮短時間週期)整合加測試 — > 快樂部署上線

持續交付 vs 持續部署(CD)

Continuous delivery (手動)
- 持續交付：將整合＋測試完成後的成果交付行為，減小規模、縮短週期，經過人工審查後交付（業界主流）
Continuous deployment (自動)
- 持續部署：將整合＋測試完成後的成果交付行為，減小規模、縮短週期，並且自動執行無人工審查（心臟要夠大顆）

導入Git

Git 筆記連結

解決程式設計師的痛

tags: `CI/CD`

REST API

Sat, 28 May 2022 07:03:32 +0800

學習目標

What is an API?
REST API 設計
HTTP Status Code
部署書目管理系統
練習呼叫 REST API
登入 H2 資料庫

情境說明

在網路書店擔任程式設計師
負責書目庫存查詢系統開發
由兩個子系統組成
- 書目管理系統(已完成) < —– 呼叫REST API 練習
- 庫存查詢系統(開發中)

What is an API?

使用者不需要知道後台Server的操作過程，透過API就可以完成需要的目的

Public API

公共開放的API

公共API 列表

政府公共平台API

REST API

REST is a set of architectural constraints, not a protocol or a standard. API developers can implement REST in a variety of ways.

The REST architectural style describes six constraints. These constraints, applied to the architecture, were originally communicated by Roy Fielding in his doctoral dissertation and defines the basis of RESTful-style.

它不是開發的標準，也不是協定，是程式開發的江湖規矩，並沒有強制的限制，有6種規定，都有達成的話，我們就稱它為REST API

REST API Quick Tips
- Use HTTP Verbs to Make Your Requests Mean Something
  - 遵循HTTP的Methods
- Provide Sensible Resource Names
  - 提供合適的資源名稱
  - 規範api的名稱：/api/getbooks –> GET /api/books (前面的GET是Http的動詞)
- Use HTTP Response Codes to Indicate Status
- Offer Both JSON and XML

HTTP Methods

HTTP defines methods (sometimes referred to as verbs, but nowhere in the specification does it mention verb, nor is OPTIONS or HEAD a verb) to indicate the desired action to be performed on the identified resource.

GET
POST
PUT
DELETE

REST API 設計

CRUD

HTTP Status Code

HTTP 狀態碼表明一個 HTTP 要求是否已經被完成。回應分為五種：

資訊回應 (Informational responses, 100–199)
成功回應 (Successful responses, 200–299)
重定向 (Redirects, 300–399)
用戶端錯誤 (Client errors, 400–499)
伺服器端錯誤 (Server errors, 500–599)

HTTP Server的回應一定要跟Clinet端看到的一樣

練習範例1

Table Schema

部署書目管理系統

建立並執行 Container

$ docker run --rm -d -p 8080:8080 --name bookstore-catalog quay.io/grassknot/bookstore-catalog:1.2.0

確認 Container 運行狀態

$ docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
669f476fa8b9 quay.io/grassknot/bookstore-catalog:1.2.0 "java -Dspring.profi…" 9 seconds ago Up 8 seconds 0.0.0.0:8080->8080/tcp bookstore-catalog

確認 bookstore-catalog image

$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
quay.io/grassknot/bookstore-catalog 1.2.0 64f1607d41a2 3 days ago 125MB

測試書目管理系統

透過curl命令測試連線我們的網站

$ curl localhost:8080
Welcome to Bookstore Catalog REST API

$ curl localhost:8080/ruok
imok

$ curl localhost:8080/ruready
yes

curl命令後面加參數-v，會進入健談模式，把它工作的資訊都說出來

$ curl -v localhost:8080/ruready
* Trying 127.0.0.1:8080...
* Connected to localhost (127.0.0.1) port 8080 (#0)
> GET /ruready HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.83.1
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 ## 200的狀態碼代表成功
< Vary: Origin
< Vary: Access-Control-Request-Method
< Vary: Access-Control-Request-Headers
< Content-Type: text/plain;charset=UTF-8
< Content-Length: 3
< Date: Fri, 27 May 2022 02:23:29 GMT
<
* Connection #0 to host localhost left intact

取得所有主題

$ curl localhost:8080/api/topics

打開Google Chrome

在網址搜尋：http://<$VMIP>:8080/

按F12，按F5，選Network，選Headers

搭配 jq 命令

透過jq 翻譯後就會比較好看

$ curl localhost:8080/api/topics | jq
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 835 0 835 0 0 118k 0 --:--:-- --:--:-- --:--:-- 135k
[
{
"id": 1,
"name": "Cloud Native",
"books": [
{
"id": 1,
"isbn": "1492090719",
"title": "Design Patterns for Cloud Native Applications",
"author": "Kasun Indrasiri, Sriskandarajah Suhothayan",
"price": 1980,
"page": 314
}
]
},
...以下省略

在curl 後面加上參數 -s，代表silent mode，就可以只呈現我們要看的內容

$ curl -s localhost:8080/api/topics | jq
[
{
"id": 1,
"name": "Cloud Native",
"books": [
{
"id": 1,
"isbn": "1492090719",
"title": "Design Patterns for Cloud Native Applications",
"author": "Kasun Indrasiri, Sriskandarajah Suhothayan",
"price": 1980,
"page": 314
}
]
},
...以下省略

到天瓏書局的網站查詢Cloud Native，真的查得到書籍

"id": 2,
"name": "Kubernetes",
"books": [
{
"id": 2,
"isbn": "9865024918",
"title": "Kubernetes 最佳實務",
"author": "Brendan Burns, Eddie Villalba, Dave Strebel and Lachlan Evenson",
"price": 411,
"page": 272
},

取得ID為1的主題

命令：curl -s localhost:8080/api/topics/1 | jq

$ curl -s localhost:8080/api/topics/1 | jq
{
"id": 1,
"name": "Cloud Native",
"books": [
{
"id": 1,
"isbn": "1492090719",
"title": "Design Patterns for Cloud Native Applications",
"author": "Kasun Indrasiri, Sriskandarajah Suhothayan",
"price": 1980,
"page": 314
}
]
}

新增一個主題

命令：

$ curl -v -s localhost:8080/api/topics \
--header 'Content-Type: application/json' \
--data '{
"name": "Big Data"
}'

命令回傳結果：

* Trying 127.0.0.1:8080...
* Connected to localhost (127.0.0.1) port 8080 (#0)
## curl 命令看到--data時，會將Http的Method，從GET轉成POST
## 開頭是 > ，代表傳給Server的訊息
> POST /api/topics HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.83.1
> Accept: */*
> Content-Type: application/json
> Content-Length: 26
>
* Mark bundle as not supporting multiuse
## 開頭是 < ，代表Server回傳的訊息
## 201 ，表示請求成功且有一個新的資源已經依據需要而被建立
< HTTP/1.1 201
< Vary: Origin
< Vary: Access-Control-Request-Method
< Vary: Access-Control-Request-Headers
< Location: http://localhost:8080/api/topics/4 ## 新增主題取得的資訊
< Content-Length: 0
< Date: Fri, 27 May 2022 03:05:37 GMT
<
* Connection #0 to host localhost left intact

檢查

$ curl -s http://localhost:8080/api/topics/4 | jq
{
"id": 4,
"name": "Big Data",
"books": []
}

更新 ID 為 4 的主題

命令：

curl -v -s -X PUT localhost:8080/api/topics \
--header 'Content-Type: application/json' \
--data '{
"id": "4",
"name": "Data Technology"
}'

-x的參數，代表可以指定Http Methods的動作 PUT是Http Methods的動作：更新

命令回傳結果

* Trying 127.0.0.1:8080...
* Connected to localhost (127.0.0.1) port 8080 (#0)
> PUT /api/topics HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.83.1
> Accept: */*
> Content-Type: application/json
> Content-Length: 48
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 200
< Vary: Origin
< Vary: Access-Control-Request-Method
< Vary: Access-Control-Request-Headers
< Location: http://localhost:8080/api/topics/4
< Content-Length: 0
< Date: Fri, 27 May 2022 03:20:15 GMT
<
* Connection #0 to host localhost left intact

檢查

$ curl -s http://localhost:8080/api/topics/4 | jq
{
"id": 4,
"name": "Data Technology", ## 更新成功
"books": []
}

刪除所有主題

刪除命令：

$ curl -s -v -X DELETE localhost:8080/api/topics

命令回傳結果：

* Trying 127.0.0.1:8080...
* Connected to localhost (127.0.0.1) port 8080 (#0)
> DELETE /api/topics HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.83.1
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 405
< Allow: GET, PUT, POST < ---------------- 只允許這3個Http Methods
< Vary: Origin
< Vary: Access-Control-Request-Method
< Vary: Access-Control-Request-Headers
< Content-Type: application/json
< Transfer-Encoding: chunked
< Date: Fri, 27 May 2022 03:24:12 GMT
<
* Connection #0 to host localhost left intact
{"timestamp":"2022-05-27T03:24:12.497+00:00","status":405,"error":"Method Not Allowed","path":"/api/topics"}

刪除 ID 為 5 的主題

命令：

$ curl -v -X DELETE localhost:8080/api/topics/5

回傳結果:

* Trying 127.0.0.1:8080...
* Connected to localhost (127.0.0.1) port 8080 (#0)
> DELETE /api/topics/5 HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.83.1
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 404
< Vary: Origin
< Vary: Access-Control-Request-Method
< Vary: Access-Control-Request-Headers
< Content-Type: application/json
< Transfer-Encoding: chunked
< Date: Fri, 27 May 2022 03:28:18 GMT
<
* Connection #0 to host localhost left intact
{"timestamp":"2022-05-27T03:28:18.157+00:00","status":404,"error":"Not Found","path":"/api/topics/5"}

最後一行： {“timestamp”:“2022-05-27T03:28:18.157+00:00”,“status”:404,“error”:“Not Found”,“path”:"/api/topics/5"}

可以看到最後一行它說找不到這個組題，所以刪除失敗

刪除 ID 為 1 的主題

命令：

$ curl -v -X DELETE localhost:8080/api/topics/1

命令回傳結果：

* Trying 127.0.0.1:8080...
* Connected to localhost (127.0.0.1) port 8080 (#0)
> DELETE /api/topics/1 HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.83.1
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 200
< Vary: Origin
< Vary: Access-Control-Request-Method
< Vary: Access-Control-Request-Headers
< Content-Length: 0
< Date: Fri, 27 May 2022 03:31:28 GMT
<
* Connection #0 to host localhost left intact

檢查

$ curl -s http://localhost:8080/api/topics/1 | jq
{
"timestamp": "2022-05-27T03:32:17.892+00:00",
"status": 404,
"error": "Not Found",
"path": "/api/topics/1"
}

刪除成功！

還原書目管理系統

重新部署停止Container

$ docker stop bookstore-catalog
bookstore-catalog

因為剛剛建立Container時，有加--rm的參數，所以關閉後，Container就會刪除。

再建立一次Container

$ docker run --rm -d -p 8080:8080 --name bookstore-catalog quay.io/grassknot/bookstore-catalog:1.2.0

實作練習1

題目

請先還原書目管理系統進行主題與書的管理，並完成下圖結果

答案

#刪除 topics、books
curl -v -X DELETE localhost:8080/api/topics/2
curl -v -X DELETE localhost:8080/api/topics/3
curl -v -X DELETE localhost:8080/api/books/3
curl -v -X DELETE localhost:8080/api/books/4
curl -v -X DELETE localhost:8080/api/books/5
#確認內容
curl -v localhost:8080/api/topics | jq
curl -v localhost:8080/api/books | jq
#修改書籍資訊
curl -v -s -X PUT localhost:8080/api/books \
--header 'Content-Type: application/json' \
--data '{
"id": 2,
"isbn": "9865024918",
"title": "Kubernetes 最佳實務",
"author": "Brendan Burns, Eddie Villalba, Dave Strebel and Lachlan Evenson",
"price": 411,
"page": 272,
"topic": {
"id": 1,
"name": "Kubernetes" ## 這行可以不打
}
}'

實作練習2

題目

請先還原書目管理系統參考新書資訊新增主題與書新書資訊書名｜Hadoop: The Definitive Guide, 4/e (Paperback) 作者｜Tom White ISBN ｜ 1491901632 頁數｜756 價錢｜1890 所屬主題｜Data Technology

預期結果請參考下圖

答案

curl -v -s -X PUT localhost:8080/api/books \
--header 'Content-Type: application/json' \
--data '{
"id": 6,
"isbn": "1491901632",
"title": "Hadoop: The Definitive Guide, 4/e (Paperback)",
"author": "Tom White",
"price": 1890,
"page": 756,
"topic": {
"id": 4,
"name": "Data Technology"
}
}'

curl -v -s localhost:8080/api/books \
--header 'Content-Type: application/json' \
--data '{
"id": "6",
"isbn": "1491901632",
"title": "Hadoop: The Definitive Guide, 4/e (Paperback)",
"author": "Tom White",
"price": 1890,
"page": 756,
"topic": {
"id": "4"
}
}'

登入 H2 資料庫

h2資料庫官網

打開 chrome 瀏覽器，網址如下： http://<$VMIP>:8080/h2

jdbc:h2:mem:bookstore

bookstore