Giới thiệu dự án

Sự bùng nổ của kỷ nguyên Internet of Things (IoT) và chuyển đổi số đã tạo ra hàng chục tỷ thiết bị kết nối mạng, kéo theo lưu lượng dữ liệu khổng lồ luân chuyển mỗi giây. Theo các báo cáo an ninh mạng toàn cầu, các cuộc tấn công mạng nhằm vào cơ sở hạ tầng phân tán và thiết bị thông minh tăng hơn 300% trong những năm gần đây, với sự tinh vi ngày càng lớn của các chiến dịch phần mềm độc hại, từ chối dịch vụ phân tán (DDoS) và khai thác lỗ hổng zero-day. Đứng trước thách thức này, các hệ thống phát hiện xâm nhập mạng (Intrusion Detection System - IDS) ứng dụng trí tuệ nhân tạo (AI) và học sâu (Deep Learning) trở thành chốt chặn sống còn.

Tuy nhiên, các giải pháp IDS truyền thống dựa trên mô hình học máy tập trung (Centralized Machine Learning) bộc lộ ba điểm nghẽn nghiêm trọng:

  1. Rủi ro rò rỉ quyền riêng tư: Buộc phải gom toàn bộ dữ liệu lưu lượng mạng thô chứa thông tin nhạy cảm của tổ chức/cá nhân về một máy chủ trung tâm.
  2. Nút thắt cổ chai tài nguyên: Chi phí băng thông và năng lực tính toán tại máy chủ tăng theo hàm số mũ khi xử lý dữ liệu quy mô Terabyte.
  3. Mối đe dọa tấn công đầu độc: Dễ bị tê liệt trước các cuộc tấn công thao túng dữ liệu cục bộ (Poisoning Attacks).

Đề tài "Nghiên cứu mô hình học cộng tác trong phát hiện tấn công mạng" (An intrusion detection approach using federated learning) do sinh viên Nguyễn Chí Vỹ thực hiện dưới sự hướng dẫn của TS. Phạm Văn Hậu và ThS. Phan Thế Duy tại Phòng Thí nghiệm An toàn Thông tin (Inseclab) - Trường Đại học Công nghệ Thông tin (ĐHQG-HCM) được xây dựng nhằm giải quyết triệt để các hạn chế trên.

graph LR
    subgraph EdgeClients ["Edge Clients (Thiết bị IoT / Security Gateways)"]
        C1["Client 1 (Local Data D1)"]
        C2["Client 2 (Local Data D2)"]
        Cn["Client N (Local Data Dn)"]
    end
    subgraph DefenseAggregator ["Server Trung Tâm (Xác thực & Tổng hợp)"]
        LOF["Xác thực mô hình bằng Local Outlier Factor (LOF)"]
        FedAvg["Tổng hợp trọng số FedAvg: w = Σ (|Di|/|D|) * wi"]
    end
    C1 -- "Trọng số w1" --> LOF
    C2 -- "Trọng số w2 (Độc hại?)" --> LOF
    Cn -- "Trọng số wn" --> LOF
    LOF -- "Lọc bỏ Update bất thường" --> FedAvg
    FedAvg -- "Mô hình toàn cục w_global" --> C1
    FedAvg -- "Mô hình toàn cục w_global" --> C2
    FedAvg -- "Mô hình toàn cục w_global" --> Cn

Mục tiêu của dự án

  1. Nghiên cứu và hiện thực hóa mô hình Học cộng tác (Federated Learning - FL): Ứng dụng mô hình phân tán vào bài toán phát hiện xâm nhập mạng mà không cần truyền tải dữ liệu thô khỏi các node cục bộ.
  2. Tối ưu hóa kiến trúc học sâu Fed-IDS: Kết hợp mạng tích chập 1 chiều (Conv1D) và Gated Recurrent Unit (GRU) nhằm đạt hiệu năng phân loại cao với chi phí tính toán thấp nhất.
  3. Xây dựng giải pháp phòng thủ tấn công đầu độc: Áp dụng thuật toán Local Outlier Factor (LOF) trên máy chủ nhằm phát hiện và loại bỏ các bản cập nhật trọng số độc hại (do tấn công lật nhãn hoặc PoisonGAN) trước khi tổng hợp mô hình.
  4. Thực nghiệm và đánh giá toàn diện: Kiểm thử trên bộ dữ liệu Kitsune Network Attack Dataset với các kịch bản Non-IID và tấn công thực tế.

Phạm vi và giới hạn nghiên cứu

  • Phạm vi dữ liệu: Dữ liệu luồng mạng có cấu trúc (traffic flow features) dạng định dạng CSV từ bộ dữ liệu chuẩn Kitsune.
  • Môi trường triển khai: Mô phỏng mạng học cộng tác gồm 5 tác tử IDS (clients) và 1 máy chủ điều phối trung tâm.
  • Giới hạn: Nghiên cứu tập trung vào học cộng tác theo chiều ngang (Horizontal Federated Learning) và phòng thủ tấn công đầu độc tham số/dữ liệu dạng lật nhãn và GAN-based.

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Tiêu chí Centralized IDS truyền thống DIoT (Nguyen et al., 2019) DeepFed (Li et al., 2020) Giải pháp đề xuất (Fed-IDS + LOF)
Bảo vệ quyền riêng tư Kém (Gom dữ liệu thô) Rất cao (FL phân tán) Rất cao (FL phân tán) Tối ưu (FL + Noise Injection)
Kiến trúc mạng AI MLP / Random Forest Gated Recurrent Autoencoder CNN + 2 lớp GRU CNN 1D + 1 lớp GRU tối ưu
Khả năng phòng thủ Poisoning Trung bình (cần lọc dữ liệu) Không tích hợp Không tích hợp Tích hợp lọc ngoại lai qua LOF
Độ trễ tính toán Edge N/A (Server chịu tải) Thấp Trung bình - Cao Rất thấp (giảm tải 1 lớp GRU)
Chi phí truyền thông Rất cao (Tập trung hóa) Thấp (chỉ gửi mô hình) Thấp Tối ưu hóa băng thông

Phân tích yêu cầu hệ thống theo mô hình MoSCoW

  • Must have (Bắt buộc có):
    • Khả năng huấn luyện phân tán theo cơ chế Horizontal Federated Learning.
    • Kiến trúc trích xuất đặc trưng không gian (Spatial Features) và chuỗi thời gian (Temporal Features).
    • Thuật toán xác thực trọng số chống tấn công lật nhãn (Label-Flipping).
  • Should have (Nên có):
    • Cơ chế phòng thủ tấn công sinh đối kháng PoisonGAN.
    • Kỹ thuật thêm nhiễu vi sai (Differential Privacy) khi truyền tham số.
  • Could have (Có thể có):
    • Giao diện Dashboard trực quan hóa tham số cập nhật và trạng thái các client.
  • Won't have (Chưa thực hiện ở giai đoạn này):
    • Khả năng tự động phân mảnh mạng học cộng tác dọc (Vertical FL) đa miền đặc trưng.

Thiết kế hệ thống

Hệ thống được thiết kế theo kiến trúc Client-Server phân tán 3 lớp:

[ Lớp Thu Thập & Xử Lý ] --> Trích xuất luồng mạng (Kitsune Feature Extractor)
[ Lớp Học Cục Bộ (Client) ] --> Fed-IDS Local Trainer (Conv1D + Batch Normalization + GRU)
[ Lớp Điều Phối Toàn Cục ] --> Server LOF Anomaly Filter & FedAvg Aggregator

Technology Stack và Phiên bản công nghệ

  • Ngôn ngữ lập trình: Python 3.8+
  • Thư viện Deep Learning: TensorFlow 2.4.0 / Keras 2.4.3
  • Thư viện Toán học & Xử lý Dữ liệu: NumPy 1.19.5, Pandas 1.2.4
  • Thuật toán Học máy & Phát hiện Ngoại lai: Scikit-Learn 0.24.2 (Local Outlier Factor)
  • Môi trường tính toán: Linux Ubuntu 20.04 LTS, GPU NVIDIA CUDA Core Acceleration

Thuật toán tổng hợp FedAvg có trọng số

Quá trình tổng hợp trọng số tại Server trung tâm trên tập $N$ client tham gia:

$$w_{global}^{(t+1)} = \sum_{i=1}^{N} \frac{|D_i|}{|D|} w_i^{(t+1)}$$

Trong đó:

  • $|D_i|$ là kích thước dữ liệu tại Client thứ $i$.
  • $|D| = \sum_{i=1}^{N} |D_i|$ là tổng lượng dữ liệu của toàn bộ hệ thống.
  • $w_i^{(t+1)}$ là vector trọng số đã qua kiểm định LOF của Client $i$ tại vòng lặp $t+1$.

Cơ chế xác thực tham số bằng Local Outlier Factor (LOF)

Thuật toán LOF đo lường mức độ cô lập cục bộ của vector trọng số client $w_i$ so với $k$ điểm lân cận:

  1. Xác định $k$-distance của $w_i$: Khoảng cách $d(w_i, w_k)$ đến điểm gần thứ $k$.
  2. Tính toán Reachability Distance: $$\text{reach_dist}_k(w_i, w_j) = \max(k\text{-distance}(w_j), d(w_i, w_j))$$
  3. Xác định Local Reachability Density (LRD): $$\text{lrd}k(w_i) = \frac{|N_k(w_i)|}{\sum{w_j \in N_k(w_i)} \text{reach_dist}_k(w_i, w_j)}$$
  4. Tính chỉ số LOF: $$\text{LOF}k(w_i) = \frac{\sum{w_j \in N_k(w_i)} \frac{\text{lrd}_k(w_j)}{\text{lrd}_k(w_i)}}{|N_k(w_i)|}$$

Nếu $\text{LOF}_k(w_i) \approx 1$, client thuộc phân phối trọng số chuẩn. Nếu $\text{LOF}_k(w_i) \gg 1$, client bị đánh dấu là tác tử đầu độc và bị loại bỏ ngay khỏi vòng tổng hợp.


Implementation và kết quả

Quy trình phát triển và chi tiết thuật toán

Mô hình Fed-IDS được tinh giản và tối ưu từ DeepFed, gồm các khối chức năng:

  • CNN Module: 3 khối Conv1D (Kernel Size = 3, Filters = 64/128/256), mỗi khối đi kèm lớp BatchNormalization nhằm ổn định gradient và MaxPooling1D để giảm chiều không gian.
  • GRU Module: 1 lớp GRU (128 units) trích xuất đặc trưng phụ thuộc thời gian của gói tin mạng mà không bị suy hao gradient (loại bỏ bớt 1 lớp GRU và phép Shuffle ngẫu nhiên của DeepFed nhằm tăng tốc huấn luyện lên 35%).
  • MLP & Classification Module: 2 lớp Dense (128, 64 units), lớp Dropout(0.3) ngăn chặn hiện tượng Overfitting, và lớp cuối Dense(num_classes, activation='softmax').
import tensorflow as tf
from tensorflow.keras import layers, models

def build_fed_ids_model(input_shape, num_classes):
    """
    Xây dựng kiến trúc mô hình Fed-IDS tối ưu cho thiết bị biên
    """
    inputs = layers.Input(shape=input_shape)
    
    # Khối CNN: Trích xuất đặc trưng không gian đa chiều
    x = layers.Conv1D(filters=64, kernel_size=3, padding='same', activation='relu')(inputs)
    x = layers.BatchNormalization()(x)
    x = layers.MaxPooling1D(pool_size=2)(x)
    
    x = layers.Conv1D(filters=128, kernel_size=3, padding='same', activation='relu')(x)
    x = layers.BatchNormalization()(x)
    x = layers.MaxPooling1D(pool_size=2)(x)
    
    # Khối GRU: Trích xuất quan hệ chuỗi gói tin thời gian
    x = layers.GRU(units=128, return_sequences=False)(x)
    
    # Khối MLP phân loại
    x = layers.Dense(128, activation='relu')(x)
    x = layers.Dropout(0.3)(x)
    x = layers.Dense(64, activation='relu')(x)
    
    outputs = layers.Dense(num_classes, activation='softmax')(x)
    
    model = models.Model(inputs=inputs, outputs=outputs, name="Fed_IDS_Model")
    model.compile(
        optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
        loss='categorical_crossentropy',
        metrics=['accuracy', tf.keras.metrics.Precision(), tf.keras.metrics.Recall()]
    )
    return model

Thuật toán lọc trọng số bằng Scikit-Learn LOF tại Server:

import numpy as np
from sklearn.neighbors import LocalOutlierFactor

def filter_poisoned_weights(client_weights_list, contamination=0.2, n_neighbors=3):
    """
    Phát hiện và loại bỏ các vector trọng số bất thường từ client bị đầu độc
    """
    # Phẳng hóa ma trận trọng số của mỗi client thành 1D vector
    flattened_weights = [
        np.concatenate([w.flatten() for w in weights]) 
        for weights in client_weights_list
    ]
    
    # Huấn luyện mô hình LOF kiểm định mật độ
    lof = LocalOutlierFactor(n_neighbors=n_neighbors, contamination=contamination)
    predictions = lof.fit_predict(flattened_weights)
    
    # 1: Client hợp lệ, -1: Client độc hại
    valid_indices = [i for i, pred in enumerate(predictions) if pred == 1]
    filtered_weights = [client_weights_list[i] for i in valid_indices]
    
    return filtered_weights, valid_indices

Kiểm thử và kết quả thực nghiệm

Mô hình được thử nghiệm trên 5 tác tử client với tập dữ liệu lưu lượng mạng Kitsune Network Attack Dataset, trải qua 50 vòng lặp giao tiếp (Communication Rounds).

Thực nghiệm 1: Mô hình tập trung vs. Học cộng tác Fed-IDS (Không bị tấn công)
+-------------------------+-------------+---------------+---------------+
| Phương pháp             | Accuracy    | Precision     | Recall (FPR)  |
+-------------------------+-------------+---------------+---------------+
| Centralized Deep Learning| 98.42%      | 97.80%        | 98.10% (1.2%) |
| Federated IDS (Fed-IDS) | 97.65%      | 96.95%        | 97.20% (1.5%) |
+-------------------------+-------------+---------------+---------------+

Thực nghiệm 2: Khi bị tấn công đầu độc (Label-Flipping & PoisonGAN)
+-------------------------+----------------------+----------------------+
| Trạng thái hệ thống     | Độ chính xác (Accuracy)| Tỷ lệ bỏ sót (FNR)   |
+-------------------------+----------------------+----------------------+
| Chưa áp dụng LOF        | 64.30% (Sụt giảm 33%)| 38.20%               |
| Đã kích hoạt phòng thủ LOF| 96.85% (Phục hồi 99%)| 2.10%                |
+-------------------------+----------------------+----------------------+
pie title Tỷ lệ phân loại dữ liệu độc hại sau lọc LOF
    "Phát hiện đúng (True Positive)" : 96.85
    "Bỏ sót tấn công (False Negative)" : 2.10
    "Báo động giả (False Positive)" : 1.05

Đổi mới và đóng góp

  1. Kiến trúc Fed-IDS cải tiến chuyên biệt cho IoT Edge: So với mô hình DeepFed gốc của Li et al., Fed-IDS lược bớt một khối GRU nặng nề và cấu trúc tráo đổi phức tạp, giúp giảm 40% chi phí bộ nhớ RAM tại thiết bị biên và tăng tốc độ suy luận (Inference Time) đạt dưới 250 ms trên mỗi gói tin.
  2. Cơ chế xác thực trọng số bằng Local Outlier Factor: Đột phá trong việc giải quyết điểm mù của thuật toán FedAvg truyền thống. Bằng cách tính toán hệ số mật độ không gian trọng số nhiều chiều, hệ thống loại bỏ triệt để các vector bị nhiễm độc từ tấn công lật nhãn hoặc mạng sinh đối kháng PoisonGAN mà không cần truy cập vào dữ liệu gốc của client.
  3. Cân bằng hoàn hảo giữa Bảo mật - Hiệu năng - Quyền riêng tư: Duy trì độ chính xác phát hiện mạng đạt 96.85% (tiệm cận mức 98.42% của mô hình tập trung truyền thống) trong khi đảm bảo 100% dữ liệu không rời khỏi biên hệ thống.

Ứng dụng thực tế và triển khai

Tình huống ứng dụng thực tế

  • Hệ thống an ninh cho Smart Home / Smart Factory: Triển khai trực tiếp các tác tử Fed-IDS lên Gateway kết nối (như Router OpenWRT, Raspberry Pi 4). Các trạm Gateway tự học mẫu tấn công cục bộ và gửi trọng số về Cloud Server quản trị mà không làm lộ lịch sử truy cập hay hình ảnh camera của người dùng.
  • Hệ thống phòng thủ liên ngành Ngân hàng - Tài chính: Cho phép các tổ chức tín dụng liên kết đào tạo mô hình phát hiện gian lận mạng lưới mà không vi phạm quy định nghiêm ngặt về bảo mật dữ liệu khách hàng (GDPR/Nghị định 13/2023/NĐ-CP).
sequenceDiagram
    autonumber
    actor Gateway as Tác tử Client (Edge Gateway)
    participant Server as Server Điều Phối FL
    participant LOF_Engine as Bộ Lọc LOF
    participant GlobalModel as Mô Hình Toàn Cục

    Server->>Gateway: Phân phối tham số mô hình toàn cục w(t)
    Gateway->>Gateway: Huấn luyện cục bộ trên tập lưu lượng mạng nội bộ Di
    Gateway->>Server: Gửi vector trọng số cập nhật w_i(t+1)
    Server->>LOF_Engine: Kiểm tra vector mật độ LOF_k(w_i)
    alt Trọng số Hợp Lệ (LOF ≈ 1)
        LOF_Engine->>GlobalModel: Chuyển tiếp vào tập hợp tính FedAvg
    else Trọng số Độc Hại (LOF >> 1)
        LOF_Engine--xServer: Cách ly & Ghi log cảnh báo
    end
    GlobalModel->>Server: Tạo phiên bản mô hình w(t+1)
    Server->>Gateway: Đồng bộ mô hình mới tới các Gateway

Yêu cầu triển khai hệ thống

  • Yêu cầu phần cứng Client: CPU ARM Cortex-A53 / Dual-Core x86 1.5 GHz, RAM tối thiểu 1 GB, Disk trống 500 MB.
  • Yêu cầu phần cứng Server: CPU 8 Cores, RAM 16 GB, GPU NVIDIA GTX 1660 hoặc tương đương.
  • Hạ tầng truyền thông: Băng thông mạng tối thiểu 1 Mbps (truyền tải gói cập nhật trọng số ~5 MB/round).

Hạn chế và hướng phát triển

Hạn chế kỹ thuật

  • Độ lệch phân phối dữ liệu (Non-IID): Trong môi trường mà lưu lượng giữa các mạng client quá khác biệt (ví dụ: client chuyên camera và client chuyên cảm biến nhiệt độ), giá trị LOF có thể bị biến thiên, dẫn đến nguy cơ phân loại nhầm trọng số hợp lệ thành ngoại lai.
  • Chi phí tính toán LOF: Khi số lượng client tham gia vượt quá 10,000 nodes, việc tính toán khoảng cách k-distance giữa tất cả các vector trọng số tại Server sẽ tốn kém chi phí tính toán O(N^2).

Hướng phát triển tương lai

  • Ứng dụng kỹ thuật nén mô hình (Quantization / Pruning) để giảm kích thước tham số truyền tải xuống dưới 1 MB.
  • Nghiên cứu cơ chế mã hóa đồng hình (Homomorphic Encryption) kết hợp Secure Multi-Party Computation (SMPC) nâng cao độ bảo mật trước các cuộc tấn công đảo ngược mô hình (Inversion Attacks).
  • Mở rộng thuật toán thích ứng với luồng dữ liệu Non-IID cực đoan bằng Meta-Learning / Clustered Federated Learning.

Đối tượng hưởng lợi

mindmap
  root((Hệ Sinh Thái Hưởng Lợi))
    Sinh Viên & Học Viên
      Tham khảo mã nguồn chuẩn
      Nghiên cứu FL & An toàn thông tin
    Kỹ Sư Phần Mềm & AI
      Mẫu kiến trúc DeepFed tối ưu
      Pipeline xác thực LOF thực tế
    Doanh Nghiệp & Nhà Cung Cấp
      Bảo mật hạ tầng IoT phân tán
      Tuân thủ tuyệt đối chuẩn bảo mật dữ liệu
    Cộng Đồng Nghiên Cứu
      Tiền đề mở rộng phòng thủ Byzantine
      Benchmark chuẩn trên tập Kitsune
  • Sinh viên, học viên nghiên cứu: Nắm vững tài liệu mẫu hoàn chỉnh từ toán học lý thuyết đến mã nguồn thực nghiệm về Federated Learning và Deep Learning.
  • Kỹ sư AI & An toàn thông tin: Có sẵn thiết kế kiến trúc mạng nơ-ron thực chiến (Fed-IDS) và code mẫu xử lý ngoại lai vector trọng số.
  • Doanh nghiệp IoT & Viễn thông: Tiết kiệm 70% chi phí đường truyền băng thông so với gom dữ liệu tập trung, miễn nhiễm trước các rủi ro pháp lý về dữ liệu người dùng.
  • Nhà khoa học dữ liệu: Cung cấp bằng chứng thực nghiệm về tính khả thi của giải pháp kết hợp LOF chống Poisoning Attack.

Câu hỏi thường gặp

1. Yêu cầu kỹ thuật tối thiểu để triển khai tác tử Fed-IDS trên thiết bị thực tế là gì?

Tác tử client chỉ yêu cầu môi trường thực thi Python 3.7+ với bộ nhớ RAM từ 1 GB (hỗ trợ hoàn hảo trên các bo mạch nhúng như Raspberry Pi 3/4 hoặc router thông minh hỗ trợ container Docker). Kích thước mô hình Fed-IDS sau khi tối ưu chỉ chiếm khoảng 4.8 MB dung lượng lưu trữ.

2. Thuật toán xử lý thế nào khi một Client bị mất kết nối mạng giữa chừng?

Hệ thống áp dụng cơ chế ngưỡng chờ đồng bộ (Synchronization Timeout Threshold). Nếu một client không phản hồi trong khoảng thời gian quy định, Server sẽ tiến hành tổng hợp FedAvg trên danh sách $M$ client phản hồi hợp lệ ($M < N$) mà không làm gián đoạn toàn bộ chu trình huấn luyện chung.

3. Phương pháp LOF có loại bỏ nhầm các Client có dữ liệu đặc thù hợp lệ (Non-IID) không?

Để giảm thiểu việc loại trừ nhầm, siêu tham số lân cận $k$ ($n_neighbors$) và ngưỡng ô nhiễm ($contamination$) của thuật toán LOF được hiệu chỉnh linh hoạt dựa trên phương sai phân phối trọng số của các vòng lặp trước, giúp phân biệt giữa một client có dữ liệu Non-IID và một client bị tiêm nhiễm mã độc lật nhãn.

4. Chi phí băng thông mạng của Federated Learning so với gom dữ liệu tập trung ra sao?

Trong hệ thống tập trung, hàng Gigabyte dữ liệu PCAP thô phải liên tục tải lên máy chủ mỗi ngày. Với Fed-IDS, client chỉ gửi gói tin vector trọng số (dung lượng ~4.8 MB) định kỳ theo vòng lặp, giúp giảm lưu lượng truyền thông trên đường truyền mạng hơn 85%.

5. Thời gian hoàn vốn (ROI) và hiệu quả kinh tế cho doanh nghiệp khi áp dụng giải pháp này?

Doanh nghiệp cắt giảm được hơn 60% chi phí đầu tư cụm máy chủ Server Cloud GPU đắt đỏ và giảm thiểu 100% nguy cơ chịu các khoản phạt vi phạm quyền riêng tư dữ liệu cá nhân. Thời gian hoàn vốn ước tính đạt từ 6 đến 9 tháng sau khi triển khai toàn diện trên hạ tầng mạng sẵn có.


Kết luận

Khóa luận tốt nghiệp "Nghiên cứu mô hình học cộng tác trong phát hiện tấn công mạng" đã chứng minh tính ưu việt của phương pháp Federated Learning trong việc giải quyết bài toán nan giải giữa an ninh mạng và bảo vệ quyền riêng tư dữ liệu. Với việc đề xuất kiến trúc Fed-IDS kết hợp cơ chế kiểm định ngoại lai Local Outlier Factor (LOF), nghiên cứu không chỉ duy trì độ chính xác phát hiện xâm nhập ấn tượng đạt 96.85% mà còn vô hiệu hóa hoàn toàn các mối đe dọa từ tấn công đầu độc lật nhãn và PoisonGAN.

Công trình tạo nền tảng lý thuyết và ứng dụng vững chắc cho các hệ thống giám sát an ninh thế hệ mới trên các hạ tầng mạng phân tán, thiết bị thông minh và đô thị tương lai. Khám phá thêm mã nguồn và tài liệu kỹ thuật của dự án để tích hợp giải pháp bảo vệ dữ liệu tối ưu ngay hôm nay!