你還記得「聊天室」最熱鬧的時代嗎？
曾經的它，是交朋友、聊天、分享生活最溫暖的地方。如今，它幾乎被演算法社群取代。

我一直在想：
如果把最新的 AI 技術放進聊天室，會不會重新變得好玩？

帶著這個念頭，我用半年時間，一個人從零打造了 EchoMind ——
一個能和 AI 一起聊天、一起探索、一起創造的實驗性聊天室。

為什麼做 EchoMind？

我想用 AI，為快消失的聊天室文化點一把新火

大多數 AI 都停留在一問一答、工具性、缺乏人味。
而聊天室，曾經是最有溫度的互動場域。

我開始想像：

🤖 如果 AI 是聊天室中的一個角色，而不是客服？
🔥 如果讓人類與 AI 一起聊天，而不是輪流輸入？
🎭 如果進聊天室就能擁有 AI 為你生成的獨特身份？

我想用 AI 重新賦予「聊天」新的形式。
EchoMind 就是這個念頭的實驗。

我如何讓 AI「像在聊天」

我想讓 EchoMind 的 AI 更像一個會聊天的角色，因此做了三件事：

• Token 串流回覆（WebSocket）
  AI 不是等想完才回，而是像人在打字，一句一句出來，節奏更自然

• Redis 短期記憶（依使用者）
  AI 會記住最近聊過的內容，不會每句都像第一次見面

• RAG（Postgres + pgvector + BGE-M3）
  用向量搜尋補強知識，不只陪聊，也能講得準、有內容

這 3 件事的目標很簡單：
AI 不只是回你，而是能接你話、記得你、講得更貼近你。

技術架構亮點

EchoMind 的架構不是堆技術，而是為了能長大。

• 前端：React + WebSocket
  多人聊天室、即時互動、AI 串流都在這層體現

• 後端：Spring Boot
  管理房間、消息轉發、使用者狀態，並直接在 Java 生態執行 ONNX Runtime
  GAN 生圖放這層，是為了更順的進場體驗與更低延遲，並使用cpu推論onnx

• AI 層：FastAPI（LLM + RAG）
  與聊天服務解耦，模型可替換，可擴展不同 AI 角色

我為什麼用 ONNX 在 Spring Boot 做生成？

我把 GAN 模型從 PyTorch 轉為 ONNX，並在 Spring Boot 直接推理，而不是放 AI 層，原因有兩個：

• CPU推論我訓練的Gan速度非常快
• 讓「進入聊天室就拿到角色」這件事更即時、更順暢。

這是一個 體驗優先 × 架構思考 的取捨：

• 不用跨服務請求 → 延遲更低

• 角色生成與登入體驗緊密結合

• AI 層維持乾淨，專注對話與 RAG

部署與對外體驗：Cloudflare Pages × minikube × Cloudflare Tunnel

我希望 EchoMind 不只是「我自己能跑」，而是任何人都能直接體驗。
因此我採用了前後端分離且具產品化思維的部署方式：

• 前端（React）：部署於 Cloudflare Pages，由全球 CDN 加速提供 HTTPS 入口，同時具備 SEO 友善特性，讓使用者第一眼就像在使用正式產品

• 後端（Spring Boot + ONNX、生圖、FastAPI、Postgres、Redis、Rabbitmq）：運行在本機 minikube，保持低成本、高掌控度

• 對外連線：透過 Cloudflare Tunnel 將後端 API 安全公開成自有子網域 api.bardcloud.online，不需公網 IP，也不用自己處理 SSL

如果你願意，我希望你能親自進來玩玩

🔗 Demo 入口：AI聊天室專案-EchoMind

💻 GitHub：前後端原碼, AI層原碼

如果你想聊聊這個專案、AI、產品開發，或你覺得我們可以激出什麼火花，歡迎找我。

使用教學

要使用ai功能需選擇Ai為說話對象

手機版

電腦版

畫柴犬教學

1.輸入「畫柴犬」至輸入框後送出

2.可點擊圖放大檢視

3.位於圖片右上角的X可關閉圖片

👍Demo

Streaming回覆

Onnx柴犬成像圖片

上下文記憶

IPhone17 rag回覆

前期進入遊戲產業以C# Unity為主, pixi無輔的開發了約接近4年的遊戲

後來接續開發過python為主 爬蟲, tkinder DeviceTree產生器, pyside 電動起子控制器

C#為主的 WPF, Asp.net MVC, Azure, WebAPi ,python為輔助的專案 智能包廂,智能咖啡機, Beacon, 行動電源, appium 爬蟲等等

智能包廂系統

下載原始 PDF

Beacon廣播系統

下載原始 PDF

app爬蟲系統

下載原始 PDF

行動電源維運系統

下載原始 PDF

咖啡機設備控制程式

下載原始 PDF

$(rpm -E %fedora) 會自動替換成你的 Fedora 版本。

sudo dnf install https://dev.mysql.com/get/mysql80-community-release-fc$(rpm -E %fedora)-1.noarch.rpm

後來發現Mysql沒有Fedora42版本

可以安裝上一版41

sudo dnf install https://dev.mysql.com/get/mysql80-community-release-fc41-1.noarch.rpm
sudo dnf install mysql-community-server

但dnf update

• 會升級你目前 repo 綁定的版本（例如 8.0.36 → 8.0.37）。
• 不會升級到 8.1 或 9.0，除非你手動更換 repo。
• 官方會維持 mysql80-community.repo、mysql81-community.repo、mysql57-community.repo 等彼此獨立。

安裝SQL各版本更新規則

為什麼 Fedora 官方只支援 MariaDB？

• Fedora 是 Red Hat 支系，Red Hat 決定全面轉向使用 MariaDB（避免 Oracle 授權問題）。
• dnf install mysql-server 時實際上裝的是 mariadb-server。
• 如果安裝 mysql-community-server，那就是來自 Oracle 的 repo，需要手動維護。

MariaDB vs MySQL 差異一覽

安裝MariaDB

sudo dnf install mariadb-server
sudo systemctl enable --now mariadb
sudo mysql_secure_installation

MariaDB Server（官方社群版）

• mariadb-server（資料庫核心）
• 所需的 systemd 服務、socket 等

啟動並設為開機自動啟動

sudo systemctl enable --now mariadb

進行安全性初始化

sudo mysql_secure_installation

• Switch to unix_socket authentication [Y/n]
  • unix_socket 認證方式就是透過 Linux 系統帳號來驗證 MariaDB 使用者身份，不需要密碼。
  • 讓 mysql -u root 不需要輸入密碼，只要你是用系統的 root 或 sudo 使用者登入，系統就會自動讓你以 root 權限登入 MariaDB
  • y 可以輸入sudo mysql，直接登入
• Change the root password? [Y/n]
  • unix_socket 為 y 時 不能change
• 查帳號用的是哪種驗證

  SELECT user, host, plugin FROM mysql.user WHERE user='root';
  

#系統帳號登入
root | localhost | unix_socket
#傳統輸入密碼
root | localhost | mysql_native_password

建立新的帳號給程式用

CREATE USER 'appuser'@'localhost' IDENTIFIED BY 'yourpassword';
GRANT ALL PRIVILEGES ON your_database.* TO 'appuser'@'localhost';
FLUSH PRIVILEGES;

SQL的GUI

用flatpak安裝

#install
flatpak install flathub io.dbeaver.DBeaverCommunity
#run
flatpak run io.dbeaver.DBeaverCommunity

介紹

引入 Functional Interface（函數式介面） 的目的，主要是為了引進 函數式編程（Functional Programming） 的特性，並解決 Java 傳統物件導向程式設計的一些限制。這個改變是從 Java 8 開始的一個重大語言演進

1. 支援 Lambda 表達式

• Java 長期以來缺乏函數作為一等公民（first-class function），不能把行為當作參數傳遞。

• 為了支援 Lambda 表達式（匿名函數），Java 必須有一種語法結構來接收「一段邏輯」作為參數 → 這就是函數式介面。

Functional Interface 是 Lambda 的語法依附對象。

請先參考 Lambda 表達式介紹。

2. 簡化匿名類別的繁瑣寫法

在 Java 8 以前，若要傳遞一段邏輯（例如事件處理、callback），只能寫匿名類別

new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        System.out.println("Clicked");
    }
};
//透過函數式介面 + Lambda
e -> System.out.println("Clicked");

• 更簡潔
• 可讀性更高
• 少寫很多 boilerplate code

3. 強化 API 的可組合性與彈性（如 Stream）

Java 8 新增的 Stream API、Optional、CompletableFuture 等都使用函數式介面來設計。

這讓邏輯可以像資料一樣「流動與組合」，提升 API 的表達力與擴展性

list.stream()
    .filter(x -> x > 10)
    .map(x -> x * 2)
    .forEach(System.out::println);

4. 兼容物件導向與函數式風格

Java 沒有放棄 OOP，而是「用 Functional Interface 作為橋梁」，將兩種編程風格融合在一起

// 接口仍是 class-based 的物件導向結構
@FunctionalInterface
interface MyFunction {
    int apply(int x);
    
// int doMore(int y); // ❌ 編譯會錯，因為違反 Functional Interface 要求
//只能有一個抽象方法
	}
}

5. 讓行為（函數）變成參數或變數

邏輯（方法）當作值傳遞，這實現了「行為即資料」的概念

public static void doOperation(int x, Function<Integer, Integer> operation) {
    System.out.println(operation.apply(x));
}

doOperation(5, y -> y + 10);  // 輸出 15

Functional Interface的實做

是一種只定義一個抽象方法”的介面，它可以：

• 由「具名類別」實作
• 由「匿名類別」實作
• 由「Lambda 表達式」實作 （Java 8+ 最簡潔的做法）

@FunctionalInterface
interface MyFunction {
    int apply(int x);
}

特點：

• 只有一個抽象方法（比如 apply()）
• 可加 @FunctionalInterface 註解（非必要，但建議）
• 代表「可以被當作 Lambda 的目標」

實作 Functional Interface 的 3 種方式對比

1. 使用具名類別

   class Square implements MyFunction {
    @Override
    public int apply(int x) {
        return x * x;
    }
   }
   

2. 使用匿名類別（Anonymous Class）

   @FunctionalInterface
   MyFunction f = new MyFunction() {
    @Override
    public int apply(int x) {
        return x * x;
    }
   };
   

3. 使用 Lambda（Java 8+ 最推薦）

   MyFunction f = x -> x * x;
   

三種寫法對應 Java 中實作 Functional Interface Consumer<T>

• Consumer 是「接受一個值但不回傳」的功能介面。
• 適用場景：列印、儲存、觸發副作用等。

class test1 implements Consumer<Integer>{
	public void accept(Integer v){
	
	}
}

Consumer<Integer> _test1 = new Consumer<Integer>() {

	public void accept(Integer v){
	}

};

Consumer<Integer> _test1_1 = (Integer v) -> {};

對照表

策略模式的應用

// 定義 Functional Interface
@FunctionalInterface
interface Strategy {
    int apply(int a, int b);
}
// 建立策略表

import java.util.Map;

//可換成 `new HashMap<>()` + `put()` 若需動態新增策略
// Map.of後若更動，將會報錯

Map<String, Strategy> strategyMap = Map.of(
    "add", (a, b) -> a + b,
    "sub", (a, b) -> a - b,
    "mul", (a, b) -> a * b,
    "div", (a, b) -> b != 0 ? a / b : 0
);

// 執行
public static int execute(String type, int a, int b, Map<String, Strategy> map) {
    Strategy strategy = map.get(type);
    if (strategy == null) {
        throw new IllegalArgumentException("未知策略：" + type);
    }
    return strategy.apply(a, b);
}

//測試

System.out.println(execute("add", 10, 5, strategyMap)); // 15
System.out.println(execute("mul", 10, 5, strategyMap)); // 50
System.out.println(execute("div", 10, 0, strategyMap)); // 0

注意 可換成 new HashMap<>() + put() 若需動態新增策略 Map.of後若更動，將會報錯

常見 Functional Interface 函式式介面對照表

針對原始型別的特殊介面

背後結合了 函數式編程（Functional Programming） 與 物件導向 的概念。它跟 C# 的 delegate 類似，但底層實作方式不同

Lambda 模板

(parameters) -> { statement }

使用心法

• 只有一行可以省略 {} 和 return
• 儘量搭配 Stream API 做資料處理
• 避免在 Lambda 裡寫太複雜的邏輯，保持簡潔

方法參考（Method Reference）

方法參考是 Java 8 引入的一種 簡化 Lambda 表達式的語法 當 Lambda 的內容只是「直接呼叫某個已存在的方法」時，可以用 :: 替代

//靜態方法參考----------------------------
public class Utils {
    public static boolean isPositive(int x) {
        return x > 0;
    }
}
//執行
Predicate<Integer> p = Utils::isPositive;
// 相當於：x -> Utils.isPositive(x)
System.out.println(p.test(10)); // true

//物件實例方法參考----------------------------
public class Printer {
    public void print(String s) {
        System.out.println(">> " + s);
    }
}
//執行
Printer printer = new Printer();
Consumer<String> c = printer::print;
// 相當於：s -> printer.print(s)
c.accept("Hello");

//類別的實例方法參考（重點）----------------------------
List<String> list = Arrays.asList("a", "b", "c");
list.forEach(System.out::println);
// 相當於：s -> System.out.println(s)
//or
BiPredicate<String, String> equals = String::equals;
// 相當於：(a, b) -> a.equals(b)

//建構子參考----------------------------
Supplier<List<String>> listSupplier = ArrayList::new;
List<String> list = listSupplier.get(); // new ArrayList()

關於類別的實例方法參考

為什麼能用在 list.forEach(System.out::println)？

• forEach 方法需要一個 Consumer<T> 介面實作。
• Consumer<T> 是一個 函式式介面，定義方法：

  void accept(T t);
  

• System.out::println 實際上是「指向 PrintStream 物件的 println 方法」的方法參考，

• 它的簽名跟 Consumer<String> 的 accept(String) 一致，
  因此可以視為一個 Consumer<String> 實例（底層由 JVM 幫你轉換）。

• System.out::println 是一個方法參考（method reference），符合 Lambda 所要求的函式介面（Consumer）的單一抽象方法簽名。
• 它本質上是符合 Consumer<String> 的實作，可以賦值給該介面型態的變數或參數。

自轉轉換的條件

JVM（編譯器）自動轉換的條件：

• 只要 你的目標類型是 Functional Interface，且Lambda 表達式或方法參考的簽名（參數和回傳型態）符合該介面唯一抽象方法的簽名

詳細說明：

• 函式介面（Functional Interface）：必須有且只有一個抽象方法

• Lambda 表達式或方法參考：編譯器會檢查它們的參數與回傳型態，是否可以對應介面方法

• 只要匹配，就會自動幫你轉換成該介面的實例

BiPredicate<String, String> equals = String::equals說明

BiPredicate<T, U> 介面有一個抽象方法

//`BiPredicate<T, U>` 介面有一個抽象方法
boolean test(T t, U u);

//執行
boolean result1 = equals.test("hello", "hello"); // true
boolean result2 = equals.test("hello", "world"); // false

小結

Lambda 表達式的限制與注意事項

• 無法直接丟 checked exception（需 try-catch 包起來或改成 unchecked）
• 不可使用非 final 或 effectively final 的外部區域變數（closure 限制）

int x = 10;
Runnable r = () -> {
    // x++; //  編譯錯誤
    System.out.println(x); //  ok，因為 x 未被修改
};

Function<String, String> f = s -> {
    Thread.sleep(1000); //  sleep 會丟 InterruptedException（checked）
    return s;
};

Lambda 中只能使用 “final 或 effectively final” 的變數

• Java 為了確保 Lambda 是 可安全封閉（closure），不允許修改外部區域變數。

• 雖然你沒加 final，但只要沒改變它，Java 編譯器會自動視為 effectively final。

• 一旦你想做 x++，它就不是 final，會 編譯錯誤。

Lambda 表達式中不能直接丟出 checked exception（受檢例外），除非顯式處理

Java 的內建函數式介面（像 Function<T, R>）方法簽章並未宣告 throws

• 所以你不能丟出任何 checked exception，否則會編譯錯。
• 若你真的需要，可以：
  • 包 try-catch（如上）
  • 使用自定義會 throws 的函數式介面（例如 ThrowingFunction<T, R>）

Thread.sleep

public static void sleep(long millis) throws InterruptedException

多重型態參數

在 Java 中，泛型（Generics）讓我們可以將「型態」延後到使用時才指定，讓程式更具彈性與可重用性。

舉例來說，你可以建立一個通用的 Example<K, V> 類別，用來表示一個 key 對應一個 value

class Example<K, V>{
}

//人對應一個名子(字串)
Example<String, Person> ex1 = new Example<String, Person>(); 

//區域對應一個數字
Example<Integer, Region> ex2 = new Example<Integer, Region>();

泛型參數的使用範圍

有兩個地方你無法在類別裡面使用泛型參數

1. 不能用在靜態變數上
2. 泛型類別的型別參數（例如 T）不能直接用在靜態方法中，不論是方法的參數還是回傳值，因為靜態方法不屬於任何具體型別的物件

錯誤範例

class Gen<T>{
    static T value;
    public static void test1(T v1){
    }
    public static T test2(){
    }
}

泛型的靜態變數

即使你使用不同的型別來建立泛型類別實例，這些實例共用同一個靜態變數。因為靜態變數是類別層級的，而不是泛型實例化後各自擁有的。

方法自帶的泛型

class Box<T> {
    public static <U> U echo(U value) {
        return value;
    }
}

這裡的 <U> 是屬於這個方法本身的泛型參數，與類別的 T 無關，因此合法、可編譯

小結

Java 的泛型（Generics）只能使用參考型別（Reference Type），不能用原始型別（Primitive Type）

• 原始型別（primitive types）：像 int、double、char、boolean，這些是效率較高的基本資料型別，不是物件。

• 參考型別（reference types）：像 Integer、Double、Character、Boolean，這些是物件（classes），包裝了原始型別。

List<int> numbers = new ArrayList<>(); // 錯誤！不能用原始型別 int

List<Integer> numbers = new ArrayList<>(); // 用 Integer（參考型別）包裝 int

這是因為 Java 的泛型設計時，是用「類別」來實作的，所以泛型只能接受 物件型別（即參考型別）

一般方法參數可以用 int 嗎

泛型的限制只出現在「泛型參數」中，但一般方法中的參數可以是任何型別

public void printInt(int value) {
    System.out.println(value);
}

Java 有一種自動轉換稱為「裝箱與拆箱（Boxing / Unboxing）

List<Integer> list = new ArrayList<>();
list.add(10); // 自動 boxing: int → Integer
int x = list.get(0); // 自動 unboxing: Integer → int

泛型支援原始型別，可以考慮 Java 8 之後的 IntStream、OptionalInt 或一些特殊的泛型工具（如 Guava 的 PrimitiveSpecialized），或使用泛型+手動處理 boxing/unboxing

安裝步驟

1. 安裝docker

   sudo dnf install docker-ce docker-ce-cli containerd.io
   

2. 啟用並啟動服務

     sudo systemctl enable --now docker
   

核心部件

1. docker-ce（Docker Community Edition Daemon）
   • 是 Docker 的核心守護程式（daemon），也就是 dockerd。

   • 負責管理：

     • 容器的啟動、停止、監控

     • 與 Linux kernel 的整合（如 Cgroups、namespaces）

     • 呼叫 containerd 來執行容器

   • 啟動後會常駐於系統背景：/usr/bin/dockerd
2. docker-ce-cli（Docker Command-Line Interface）

   • 也就是 docker 指令本體（終端機輸入的 `docker run ）。

   • 與 dockerd（Daemon）透過 Unix socket 或 REST API 通訊。

   • 單獨安裝 CLI 沒辦法真正啟動容器，需要 docker-ce 搭配使用。

3. containerd.io

   • 是 Docker 使用的 容器執行引擎（container runtime）。

   • 原本是 Docker 的一部分，現在獨立發展，由 CNCF 維護。

   • Docker 的 daemon（dockerd）會呼叫 containerd 來管理容器生命週期。

   • Kubernetes 等也可直接使用 containerd，不需要 Docker。

與Docker Desktop的差異

一直以為我都安裝Docker Desktop，直到我開始同時使用vm ，兩個服務就會互相衝突，必須一直手動關閉重起虛擬化服務

為什麼 docker-ce 不會跟 VirtualBox 衝突？

docker-ce 是「原生」安裝在 Linux 上的 Docker Daemon：

• 它 直接使用 Linux 的 kernel 功能（如 namespaces、cgroups）來執行容器，不需要任何虛擬機（VM）。

• 所以只要是 **Linux 原生環境，Docker CE 就能直接跑，不會跟 VirtualBox 衝突。

為什麼 Docker Desktop 會跟 VirtualBox 衝突

Docker Desktop 在 Linux/macOS/Windows 上用的是 虛擬機（VM）：

• 即使是在 Linux 上裝 Docker Desktop，它還是會 用一台內建的虛擬機（如使用 qemu、virt-manager、systemd-nspawn） 來跑 Docker 引擎。

• 它會啟動一個 daemon VM（叫 docker-desktop 或 docker-desktop-data），並建立 bridge 網路介面、用 iptables 設定轉發。

總結比較

這兩次升級的主要差異在於：

1. 桌機有安裝 Nvidia 官方驅動。

2. 這次使用手機 USB 網路分享，升級重開機後，疑似未自動連上網路，導致升級過程中部分套件未能完整更新。

升級後進入系統時，畫面只有白屏，並顯示「系統有錯誤，請聯絡管理員」，無法進入登入畫面，也無法進行任何操作（0716修正） 應該能進tty模式。

0716新增 應是安裝Nvidia專用驅動後，系統衝突，連白畫面都無法到達，所以透過Grub

透過 Grub，在對應 kernel 的 linux 行加入 nomodeset 3，強制以文字模式啟動，進入 TTY 修復模式。

一開始懷疑是 Nvidia 驅動與新版 GNOME 相容性問題，嘗試過移除與重裝官方及 Rpmfusion 驅動，但無法解決，系統依然無法進入圖形介面。

進一步檢查發現，cat /etc/os-release 顯示已為 Fedora 42，但系統內部仍有不少套件維持在 41 版本（例如 GNOME 與某些核心元件）。
這種版本混雜，導致 GNOME 啟動時崩潰，無法進入桌面，只能進 TTY 模式維修。

操作紀錄

由於先前曾誤刪 NetworkManager，導致開機時網路完全沒啟動，網卡也沒拿到 IP。

網路完全沒啟動，網卡沒 IP

修復步驟（臨時手動啟用網卡）

1. 啟動網卡

   先透過ip addr找到網卡 如enp6s0
   sudo ip link set enp6s0 up
   

2. 手動分配 IP（路由器所在網段）

   sudo ip addr add 192.168.1.123/24 dev enp6s0
   sudo ip route add default via 192.168.1.1
   

   （這邊 192.168.1.1 家 or 公司的閘道器，通常是路由器 IP）

3. 設置 DNS 解析（臨時）

   echo "nameserver 8.8.8.8" | sudo tee /etc/resolv.conf
   

4. 測試網路是否通

   ping -c 3 8.8.8.8
   ping -c 3 mirrors.fedoraproject.org
   

處理套件同步與衝突

使用 dnf distro-sync 同步時，遇到多個套件依賴衝突或版本錯誤。

目前解法為：

• 先移除出錯套件

      sudo dnf remove <出錯套件>
  

  • 先將有問題（如升級衝突、版本錯誤或殘留）的套件移除，讓依賴樹恢復乾淨，避免後續操作又被同一個問題卡住。
• 再安裝必要套件

    sudo dnf install <必要套件>
  

  • 重新安裝所需的核心/重要套件，確保使用的是新版本並補齊所有依賴。
• 重複執行 distro-sync，直到全部同步完成。必要時可加上 --allowerasing 參數強制排除有衝突的舊套件。

補充建議

• 網路連線不穩或升級途中網路中斷，是造成系統版本混雜的主因，升級時建議全程使用穩定的有線網路，並確認所有套件都已完整升級。

• 針對無法同步或依賴衝突，建議每次遇到報錯時，先確認錯誤訊息，針對特定套件移除再安裝，並多次重複同步，直到不再出現衝突。

目前持續Debug中

20240716 終於升版成功

總結以下幾點問題

一、Fedora 系統版本升級

我原先使用

sudo dnf system-upgrade download --releasever=42
sudo dnf system-upgrade reboot

但後來因 Fedora 42 已採用新工具（dnf5）

sudo dnf5 offline upgrade --releasever=42
sudo dnf5 offline reboot

但因為沒有正確完成離線升級步驟，導致系統套件版本部分仍停留在 Fedora 41，發生嚴重相依性衝突。

有可能是因為發現指令的修改 讓我reboot並未打在 upgrade後，造成升級錯誤 這要追蹤紀錄

二、NVIDIA 專有驅動重新安裝

升級後，原本的 NVIDIA 驅動 (run file: 570.153.02) 無法正常運作，畫面黑屏

進入 TTY (Ctrl+Alt+F3)

sudo ./NVIDIA-Linux-x86_64-570.153.02.run

安裝失敗或成功但啟動畫面仍然異常（可能 Wayland 衝突）

編輯 /etc/gdm/custom.conf，設置 強制使用 Xorg 而非 Wayland

WaylandEnable=false
DefaultSession=gnome-xorg.desktop

安裝了 NVIDIA .run 專有驅動
嘗試強制用 X11 (WaylandEnable=false) 但反而完全黑畫面，連 tty 都進不去

通常表示：.run 驅動與 kernel 模組或 framebuffer 設定發生衝突，導致整個顯示系統（包含 TTY）也壞了

開機進 GRUB，編輯 kernel 參數，按ｅ編輯

nomodeset：避免驅動初始化 framebuffer，能避免黑畫面
3：強制進入 runlevel 3（multi-user.target），不載入 GUI

卸載NVIDIA驅動後，終於能進指令模式

三、系統升級問題排查與修復

GPU問題解決後，系統仍異常

嘗試了許多操作

• 清理 repo 快取，重建 dnf metadata

  sudo dnf clean all
  sudo dnf makecache
  

• 多個libicu 衝突
• 因為 libicu 套件衝突（版本混亂，Fedora 41 與 42 混合）

sudo dnf remove libicu\* libtiny\*
sudo dnf install libicu libicu-devel

• 使用 distro-sync 同步套件

  sudo dnf distro-sync --releasever=42 --allowerasing --skip-broken -y
  

  用以強制同步系統套件到 Fedora 42，過程中遇到許多受保護的套件無法同步。

• 強制手動移除 Fedora 41 套件資料庫記錄

sudo rpm -e --justdb --nodeps grub2-tools-minimal selinux-policy selinux-policy-targeted

此步驟是為了解決嚴重的相依性循環

四、網路問題處理 (DNS & NetworkManager)

因無法同步我一度移除 NetworkManager，導致網路中斷與無 DNS

• 手動恢復網路連線

sudo ip link set dev enp6s0 up
sudo ip addr add 192.168.50.199/24 dev enp6s0
sudo ip route add default via 192.168.50.1
echo 'nameserver 8.8.8.8' | sudo tee /etc/resolv.conf

• 測試 DNS 和網路連通性

ping 8.8.8.8
nslookup mirrors.fedoraproject.org

• 修正 DNS 解析異常 (IPv6 precedence issue)

echo 'precedence ::ffff:0:0/96 100' | sudo tee -a /etc/gai.conf

後來發現修改這個nslookup還是無法解析host

• 最終透過修改 /etc/nsswitch.conf

從
hosts: myhostname mdns4_minimal [NOTFOUND=return] resolve [!UNAVAIL=return] dns files
修正為
hosts: files dns

問題根源是nsswitch.conf 配置異常

• 重新安裝 NetworkManager

sudo dnf install NetworkManager -y
sudo systemctl enable --now NetworkManager

網路與 DNS 終於正常運作

五、EFI 與 GRUB2 問題處理

系統載入新內核

# 找出 grub.cfg 位置
sudo find /boot -name "grub.cfg"
# 重新生成 grub.cfg  位置若有更動 os 會提示
sudo grub2-mkconfig -o  新位置

六、安裝 GNOME 桌面環境並啟用 GDM

# 安裝 GNOME 桌面環境
sudo dnf-3 groupinstall "GNOME Desktop Environment" -y
# 啟用 GDM（圖形登入管理）
sudo systemctl set-default graphical.target
sudo systemctl enable --now gdm

sudo reboot

使用dnf(連結到dnf5)碰上語法已異動，修正為dnf-3

• dnf-3 是 Fedora 傳統的 dnf 版本，通常穩定度高。
• 在升級災難發生後，使用 dnf-3 通常能有效避開 dnf5 的問題，提供更穩定的套件解析

關鍵指令

# Fedora 離線升級
sudo dnf5 offline upgrade --releasever=42
# rpm 強制清空舊資料庫
sudo rpm -e --justdb --nodeps $(rpm -qa | grep fc41)
# DNS/nsswitch.conf 修正
# /etc/nsswitch.conf:
hosts: files dns
# 強制指定 IPv4 DNS
echo 'nameserver 8.8.8.8' | sudo tee /etc/resolv.conf
# GNOME 桌面重裝
sudo dnf-3 groupinstall "GNOME Desktop Environment" -y
sudo systemctl enable --now gdm

這次問題與操作的總結

在使用 Cookie 紀錄登入狀態的 ASP.NET MVC 系統中，
若攻擊者能成功竊取使用者的認證 Cookie（例如 Session ID 或身份憑證），
只要將該 Cookie 複製到自己的瀏覽器中，即可冒用該用戶，繞過伺服器的身份驗證。

透過以下兩個方法做防禦

1. DB 綁定來源資訊（IP、User-Agent等）

// 在登入成功後
 user.LoginIP = Request.UserHostAddress;
 db.SaveChanges();

在用戶登入後，記錄來源 IP 或 User-Agent，之後每次請求都驗證

2. 請求時的監控

此步驟為關鍵安全機制之一：

1. 驗證使用者登入狀態
   每當有請求進入時，系統會在 Application_AcquireRequestState 事件中檢查使用者是否已登入（IsAuthenticated == true）。

2. IP 驗證邏輯
   若使用者已登入，系統會比對：

   • 當前請求的 IP（Request.UserHostAddress）

   • 使用者登入時儲存的原始 IP（由資料庫取得）

   若兩者不一致，視為潛在異常行為，系統會強制導向登出（/Account/Logout）。

3. 避免登出遞迴陷阱
   由於 Application_AcquireRequestState 會在每次請求前執行，若沒有排除登入、登出、驗證等網址，將導致如下無限循環：

   • 使用者發送請求 → 偵測到 IP 不一致 → 導向 /Account/Logout

   • /Account/Logout 也觸發 AcquireRequestState → 再次驗證失敗 → 再次導向 /Account/Logout…

   • 造成實際登出流程永遠無法執行

   為避免此情況，需排除以下路徑的檢查：

   • /account/login

   • /account/logout

   • /account/verify

  protected void Application_AcquireRequestState(object sender, EventArgs e)
  {
      var ctx = HttpContext.Current;
      var path = ctx.Request.Path.ToLower();
      if (ctx.User.Identity.IsAuthenticated && 
          !path.Contains("account/logout") && 
          !path.Contains("account/login") &&  
          !path.Contains("account/verify"))
      {
          // 取得當前 IP

          var currentIP = ctx.Request.UserHostAddress;

          var originalIP = UserRepository.GetUserById(ctx.User.Identity.Name);

          // 驗證 IP
          if (originalIP != null && originalIP != currentIP)
          {
              // IP 不一致，強制登出
              ctx.Response.Redirect("/Account/Logout");
          }
      }
  }

• np.argsort(scores)：傳回的是分數排序後的原始索引（預設是升冪）
• [::-1]：反轉 array → 降冪排序
• 利用 names[indices] 可以對 array 根據 index 重排

import numpy as np

names = np.array(['Alice', 'Bob', 'Charlie', 'David', 'Eva'])
scores = np.array([85, 92, 88, 76, 90])

# 取得分數排序（從大到小）的 index
sorted_indices = np.argsort(scores)[::-1]

# 取前三名
top3_indices = sorted_indices[:3]

# 對應姓名
top3_names = names[top3_indices]
top3_scores = scores[top3_indices]

print(top3_names)
print(top3_scores)

# 輸出
['Bob' 'Eva' 'Charlie']
[92 90 88]

2. np.sort

排序多維陣列的每一列

• np.sort(arr, axis=1)：對每一 row 做升冪排序
• axis=0 則會針對每一「欄」做排序（column-wise）
• [:, ::-1]：反轉每列順序，從升冪變降冪

import numpy as np

arr = np.array([[3, 1, 2],
                [9, 7, 5],
                [6, 8, 4]])

sorted_arr = np.sort(arr, axis=1)
print(sorted_arr)

3. np.lexsort

用來多欄位排序（lexicographical sort，字典序排序）的方法

import numpy as np

# 先依「班級」排序，再依「成績」排序
classes = np.array([1, 2, 1, 2, 1])
scores  = np.array([60, 80, 90, 60, 70])
idx = np.lexsort((scores, classes))
print(idx)
print(classes[idx])
print(scores[idx])

• np.lexsort((次要, 主要))
  — 右邊最後一個是「最主要的排序依據」。
• 回傳排序後的 index，可用於重排原本的陣列。
• -np.lexsort 永遠是升序。
• 要降序→對 key 做處理 給Key負值即可。

4. np.argmax

取得指定維度最大索引

max_index = np.argmax(arr, axis=1)
print(max_index)

5. np.max

取得指定維度最大值

max_value = np.max(arr, axis=1)
print(max_value)

按條件排序應用

import numpy as np
names = np.array(['Ann', 'Ben', 'Cathy', 'David', 'Eve'])
scores = np.array([95, 55, 80, 45, 70])

pass_mask = scores >= 60
# 只對通過的分數排序
sorted_indices = np.argsort(scores[pass_mask])
# 原始及格的 index
pass_indices = np.where(pass_mask)[0]
# 新順序
new_order = pass_indices[sorted_indices]

# 建立新 array：不及格的留在原位
sorted_scores = scores.copy()
sorted_names = names.copy()
sorted_scores[pass_mask] = scores[new_order]
sorted_names[pass_mask] = names[new_order]

print(sorted_names)
print(sorted_scores)

• np.where 的輸出為tupple

維度的Mask重點

一維

import numpy as np
arr = np.array([5, 7, 2, 8])
mask = arr > 5

print(np.where(mask))    # 輸出: (array([1, 3]),)

二維

arr = np.array([[1, 2], [3, 4]])
mask = arr > 2
idx_tuple = np.where(mask)
print(idx_tuple)       # (array([1, 1]), array([0, 1]))

• 這裡 [1, 1] 是 row index，[0, 1] 是 column index