Giới thiệu dự án

Trong kỷ nguyên chuyển đổi số và bùng nổ kiến trúc vi dịch vụ (Microservices), giao diện lập trình ứng dụng (Application Programming Interface - API) đã trở thành huyết mạch kết nối toàn bộ hệ thống phân tán. Tuy nhiên, theo báo cáo an ninh mạng toàn cầu của Cloudflare, lưu lượng API chiếm hơn 57% tổng lưu lượng web động, đồng thời là mục tiêu của hơn 60.7% các cuộc tấn công bất thường qua giao thức HTTP (HTTP Anomaly) và 26.3% các cuộc tấn công chèn mã độc như SQL Injection (SQLi) và Cross-Site Scripting (XSS). Song song đó, các đợt tấn công từ chối dịch vụ phân tán (Distributed Denial of Service - DDoS) ở tầng hạ tầng và ứng dụng ghi nhận mức tăng trưởng đột biến 117% theo từng năm, đe dọa trực tiếp tính sẵn sàng của các hạ tầng thuần đám mây (Cloud-Native).

   +-------------------------------------------------------------------------+
   |                        Client HTTPS Traffic                             |
   +------------------------------------+------------------------------------+
                                        |
                                        v
   +-------------------------------------------------------------------------+
   |             Data Input Module (Nginx SSL Termination & LB)              |
   +------------------------------------+------------------------------------+
                                        |
                 +----------------------+----------------------+
                 | (Authentication & Authorization)            | (Packet Mirroring)
                 v                                             v
   +----------------------------+             +------------------------------+
   |   SECURE DESIGN PIPELINE   |             |   SECURE MONITOR PIPELINE    |
   | - Auth Module (TOTP/SHA3)  |             | - Centralized Loading        |
   | - AuthZ Module (ABAC/UUID) |             | - Feature Extraction         |
   | - Session Mgmt (Click-base)|             | - DL-Detection (ALBERT + GRU)|
   | - Service Discovery (Mesos)|             | - Classification & Honeynet  |
   +-------------+--------------+             +--------------+---------------+
                 |                                           |
                 +----------------------+--------------------+ (Alert / Block)
                                        |
                                        v
   +-------------------------------------------------------------------------+
   |            Application Endpoint -> Microservices Backend                |
   |              (Orchestrated via Apache Mesos & Marathon)                 |
   +-------------------------------------------------------------------------+

Vấn đề thực tiễn (Problem Statement)

Các hệ thống API Gateway đơn khối truyền thống (Monolithic API Gateway) đang bộc lộ những điểm yếu chí tử khi đối mặt với các kịch bản tấn công hiện đại:

  1. Điểm lỗi đơn lẻ (Single Point of Failure - SPoF) và thắt nút cổ chai hiệu năng: Không có khả năng co giãn linh hoạt độc lập cho từng module chức năng (xác thực, phân quyền, kiểm tra gói tin).
  2. Cơ chế phòng thủ tĩnh (Rule-based WAF): Dễ dàng bị vượt qua (bypass) bởi các biến thể mã độc obfuscated SQLi, XSS hoặc các cuộc tấn công DDoS phân tán tốc độ thấp (Low-and-Slow DDoS) không trùng khớp chữ ký mẫu (signature).
  3. Lỗ hổng kiểm soát truy cập: Tình trạng chiếm đoạt phiên làm việc (Session Hijacking), lỗi kiểm soát quyền cấp đối tượng bị hỏng (Broken Object Level Authorization - BOLA), và xác thực người dùng yếu.

Mục tiêu dự án

  1. Xây dựng kiến trúc Multi-API Gateways phân tán theo mô hình Secure Design, chia nhỏ các tác vụ: Giải mã SSL/TLS (SSL Termination), Xác thực đa yếu tố (MFA - TOTP), Phân quyền theo thuộc tính (ABAC), và Quản lý phiên động (Click-based Dynamic Session).
  2. Phát triển hệ thống giám sát an toàn thông minh (Secure Monitor) ứng dụng mô hình Học sâu (Deep Learning): Sử dụng mô hình ALBERT để phát hiện mã độc API (SQLi, XSS, HTTP Anomaly) và mô hình GRU (Gated Recurrent Unit) để phát hiện tấn công DDoS trong thời gian thực.
  3. Hiện thực hóa trên nền tảng Cloud-Native thông qua cụm điều phối container Apache Mesos kết hợp bộ lập lịch Marathon Framework, đảm bảo tính cô lập, tự phục hồi và khả năng mở rộng quy mô linh hoạt.

Giải pháp và Kết quả kỳ vọng

Giải pháp kết hợp chặt chẽ giữa thiết kế an toàn từ gốc (Secure by Design) và giám sát chủ động (Secure by Monitoring). Cụm cổng Multi-API Gateways đảm bảo độ chính xác phát hiện tấn công tầng ứng dụng đạt Accuracy > 99.0% với ALBERT, nhận diện bất thường lưu lượng DDoS với Accuracy > 99.9% với GRU, đồng thời duy trì độ trễ xử lý gói tin chuyển tiếp (Gateway Overhead Latency) dưới 30ms.

Phạm vi và Giới hạn hệ thống

  • Phạm vi: Triển khai thử nghiệm trên cụm máy tính phân tán (Computer Cluster) chạy Apache Mesos; kiểm nghiệm với bộ dữ liệu chuẩn quốc tế CICDDoS2019 và các tập dữ liệu tấn công Web Payload (OWASP Top 10 API Security Risks).
  • Giới hạn: Tập trung xử lý các giao thức HTTP/HTTPS RESTful APIs; chưa bao gồm việc giải mã sâu các luồng dữ liệu nhị phân chuyên biệt (gRPC qua HTTP/2 dạng raw payload streaming).

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

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

Để giải quyết bài toán an toàn API, việc so sánh các hướng tiếp cận hiện nay là cơ sở xác lập tính ưu việt của giải pháp:

Tiêu chí phân tích Monolithic API Gateway truyền thống Cloud-Managed Gateway (AWS API Gateway, Cloudflare) Multi-API Gateways kết hợp Deep Learning (Đề xuất)
Kiến trúc triển khai Đơn khối, tập trung Thuần đám mây, phụ thuộc Vendor Cloud-Native phân tán (Apache Mesos + Marathon)
Cơ chế phát hiện tấn công Rule-based / Regex WAF Rule-based + Rate Limiting cơ bản Deep Learning đa mô hình (ALBERT + GRU)
Xác thực & Phiên làm việc Session cố định / JWT tĩnh API Key / OAuth 2.0 cơ bản TOTP (RFC 6238) + ABAC + Click-based sliding token
Mở rộng quy mô (Scale) Khó mở rộng từng module Tự động mở rộng (Chi phí cao) Tự động cô lập & co giãn theo Container trên Mesos
Khả năng bẫy mẫu mới Không hỗ trợ Phụ thuộc cập nhật từ nhà cung cấp Tích hợp mạng lưới Honeynet động

Yêu cầu hệ thống theo mô hình MoSCoW

  • Must have (Bắt buộc): Giải mã SSL Termination tại Data Input Module; Xác thực MFA qua TOTP kết hợp mã hóa AES-CBC-256; Phân quyền ABAC; Mô hình Deep Learning phát hiện DDoS và Web Attack thời gian thực; Quản lý triển khai qua Apache Mesos/Marathon.
  • Should have (Nên có): Kiểm tra Fingerprint của trình duyệt kết hợp với phiên làm việc; Cơ chế gia hạn phiên trượt (Click-based Token 2 phút); Tự động phân giải dịch vụ qua Mesos-DNS (Service Discovery).
  • Could have (Có thể có): Chuyển hướng lưu lượng bất thường chưa nhận dạng sang Module Honeynet để ghi nhận chữ ký tấn công mới.
  • Won't have (Chưa hỗ trợ): Hỗ trợ kiểm tra payload giao thức WebSocket và mã hóa homomorphic trên luồng xử lý thời gian thực.

Thiết kế hệ thống

+-----------------------------------------------------------------------------------+
|                        MULTI-API GATEWAYS SYSTEM ARCHITECTURE                     |
|                                                                                   |
|   +---------------------------------------------------------------------------+   |
|   | 1. DATA INPUT MODULE (Nginx 1.24 - Reverse Proxy & SSL Termination)       |   |
|   +-------------------------------------+-------------------------------------+   |
|                                         |                                         |
|                 +-----------------------+-----------------------+                 |
|                 | (Internal HTTP Forwarding)                    |                 |
|                 v                                               v                 |
|   +---------------------------+                   +---------------------------+   |
|   | 2. AUTHENTICATION MODULE  |                   | 5. FEATURE EXTRACTION     |   |
|   | - Django 4.2 REST         |                   | - Flow / Packet Parsing   |   |
|   | - SHA3-256 Password Hash  |                   | - Vectorization Pipeline  |   |
|   | - TOTP Key (AES-CBC-256)  |                   +-------------+-------------+   |
|   +-------------+-------------+                                 |                 |
|                 |                                               v                 |
|                 v                                 +---------------------------+   |
|   +---------------------------+                   | 6. DEEP LEARNING DETECTOR |   |
|   | 3. AUTHORIZATION MODULE   |                   | - ALBERT: HTTP/API Attack |   |
|   | - ABAC Engine             |                   | - GRU: L4/L7 DDoS Attack  |   |
|   | - Browser Fingerprint     |                   +-------------+-------------+   |
|   +-------------+-------------+                                 |                 |
|                 |                                               v                 |
|                 v                                 +---------------------------+   |
|   +---------------------------+                   | 7. CLASSIFIER & HONEYNET  |   |
|   | 4. SESSION MANAGEMENT     |                   | - Attack Category Label   |   |
|   | - Sliding 2-Min Window    |                   | - Dynamic Threat Capture  |   |
|   | - UUID Validation         |                   +---------------------------+   |
|   +-------------+-------------+                                                   |
|                 |                                                                 |
|                 +-----------------------+-----------------------------------------+
|                                         |
|                                         v
|   +---------------------------------------------------------------------------+   |
|   | 8. APPLICATION ENDPOINT & SERVICE DISCOVERY (Mesos-DNS + Python Microservices)|
|   +---------------------------------------------------------------------------+   |
+-----------------------------------------------------------------------------------+

Danh mục Technology Stack và Phiên bản

  • Proxy & Load Balancer: Nginx v1.24 (Hỗ trợ SSL Termination, Upstream Reverse Proxy).
  • Backend Framework: Python v3.9+, Django v4.2 REST Framework.
  • Cơ sở dữ liệu: MySQL v8.0 Enterprise Server (Lưu trữ Metadata, Credentials băm, Token state).
  • Hệ sinh thái Cloud-Native & Điều phối Container: Apache Mesos v1.9, Marathon Framework v1.10, Mesos-DNS.
  • Deep Learning Frameworks: PyTorch v2.1, Hugging Face Transformers (mô hình ALBERT-base), Scikit-Learn, NumPy.
  • Mã hóa & An mật: OpenSSL v3.0, PyCryptodome (AES-256-CBC, SHA3-256), PyOTP (TOTP RFC 6238).

Thiết kế An toàn và Quản lý Phiên (Security & Session Design)

  1. Xác thực 2 lớp (2FA/MFA): Mật khẩu người dùng được băm một chiều với hàm chuẩn SHA3-256 trước khi lưu vào Authentication DB. Khóa bí mật TOTP tạo ngẫu nhiên được mã hóa bằng thuật toán AES-256-CBC với vector khởi tạo (IV) động: $$C = E_{AES-256-CBC}(K, P \oplus IV)$$
  2. Cơ chế Token trượt theo tương tác (Click-based Token Mechanism): Token phiên kết hợp các thuộc tính: $$\text{SessionToken} = \text{HMAC-SHA256}(\text{UUID} \parallel \text{Fingerprint} \parallel \text{ServiceScope} \parallel \text{EpochTime}, K_{secret})$$ Phiên có thời gian tồn tại tối đa 2 phút kể từ tương tác cuối. Mỗi lượt gửi request hợp lệ, hệ thống tự động cập nhật Epoch Time thêm 120 giây.

Phương pháp luận (Methodology)

Dự án áp dụng quy trình phát triển lặp linh hoạt Agile/Scrum kết hợp quy trình vận hành an ninh DevSecOps:

  • Milestone 1 (Tuần 1-4): Nghiên cứu lý thuyết, trích xuất dữ liệu tấn công, thiết kế kiến trúc phân rã Multi-API Gateways.
  • Milestone 2 (Tuần 5-8): Xây dựng các module Secure Design (Data Input, Authentication, Authorization, Session Management).
  • Milestone 3 (Tuần 9-12): Huấn luyện, tinh chỉnh (Fine-tune) mô hình ALBERT và GRU; xây dựng đường ống trích xuất đặc trưng (Feature Extraction).
  • Milestone 4 (Tuần 13-16): Đóng gói Container, cấu hình Marathon/Mesos Cluster, tích hợp toàn diện hệ thống và kiểm thử tải/xâm nhập.

Implementation và kết quả

Quá trình phát triển và Thuật toán cốt lõi

1. Thuật toán phân loại tấn công API bằng mô hình ALBERT

Mô hình ALBERT sử dụng cơ chế chia sẻ tham số giữa các tầng (Cross-layer parameter sharing) và phân tách ma trận Embedding giúp tối ưu kích thước mô hình, phù hợp cho việc suy luận (inference) thời gian thực tại API Gateway.

import torch
import torch.nn as nn
from transformers import AlbertModel, AlbertTokenizer

class AlbertAPIAttackDetector(nn.Module):
    def __init__(self, pretrained_model_name="albert-base-v2", num_classes=3):
        super(AlbertAPIAttackDetector, self).__init__()
        self.albert = AlbertModel.from_pretrained(pretrained_model_name)
        self.dropout = nn.Dropout(p=0.3)
        # Classify: 0: Normal HTTP, 1: SQL Injection, 2: Cross-Site Scripting (XSS)
        self.classifier = nn.Linear(self.albert.config.hidden_size, num_classes)

    def forward(self, input_ids, attention_mask):
        outputs = self.albert(input_ids=input_ids, attention_mask=attention_mask)
        # Lấy vector đại diện [CLS] tại vị trí đầu tiên
        cls_output = outputs.last_hidden_state[:, 0, :]
        x = self.dropout(cls_output)
        logits = self.classifier(x)
        return logits

def inspect_http_request(raw_payload: str, model, tokenizer, max_len=128):
    model.eval()
    encoded = tokenizer(
        raw_payload,
        padding='max_length',
        truncation=True,
        max_length=max_len,
        return_tensors='pt'
    )
    with torch.no_grad():
        outputs = model(encoded['input_ids'], encoded['attention_mask'])
        pred_label = torch.argmax(outputs, dim=1).item()
    return pred_label # 0: Hợp lệ, 1/2: Bất thường/Tấn công

2. Thuật toán phát hiện bất thường lưu lượng DDoS bằng GRU

GRU loại bỏ Cell State phức tạp của LSTM, chỉ sử dụng Reset Gate ($r_t$) và Update Gate ($z_t$), giúp giảm thiểu 33% số lượng phép tính ma trận:

$$\begin{aligned} r_t &= \sigma(W_r \cdot [h_{t-1}, x_t] + b_r) \ z_t &= \sigma(W_z \cdot [h_{t-1}, x_t] + b_z) \ \tilde{h}t &= \tanh(W \cdot [r_t \odot h{t-1}, x_t] + b) \ h_t &= (1 - z_t) \odot h_{t-1} + z_t \odot \tilde{h}_t \end{aligned}$$

import torch
import torch.nn as nn

class GRUDDoSClassifier(nn.Module):
    def __init__(self, input_dim=78, hidden_dim=64, num_layers=2, num_classes=2):
        super(GRUDDoSClassifier, self).__init__()
        self.gru = nn.GRU(
            input_size=input_dim,
            hidden_size=hidden_dim,
            num_layers=num_layers,
            batch_first=True,
            dropout=0.2
        )
        self.fc = nn.Linear(hidden_dim, num_classes)
        self.softmax = nn.Softmax(dim=1)

    def forward(self, x):
        # x shape: (batch_size, sequence_length, input_dim)
        out, _ = self.gru(x)
        out = self.fc(out[:, -1, :])
        return self.softmax(out)

3. Cấu hình triển khai trên cụm Apache Mesos & Marathon

Cấu hình manifest của Module Authentication được quản lý và tự động scale thông qua Marathon:

{
  "id": "/security/authentication-module",
  "cmd": "gunicorn auth_service.wsgi:application --bind 0.0.0.0:8000 --workers 4",
  "cpus": 1.0,
  "mem": 1024,
  "instances": 3,
  "container": {
    "type": "DOCKER",
    "docker": {
      "image": "registry.internal/auth-module:v1.2",
      "network": "BRIDGE",
      "portMappings": [
        { "containerPort": 8000, "hostPort": 0, "protocol": "tcp", "name": "http" }
      ]
    }
  },
  "healthChecks": [
    {
      "protocol": "HTTP",
      "path": "/healthz",
      "portIndex": 0,
      "intervalSeconds": 10,
      "timeoutSeconds": 5,
      "maxConsecutiveFailures": 3
    }
  ]
}

Thử nghiệm và Đánh giá thực nghiệm

Kịch bản 1: Đánh giá mô hình học sâu ALBERT và GRU

Huấn luyện trên tập dữ liệu chuẩn hóa gồm 100,000 mẫu HTTP Request (SQLi, XSS, Benign) và tập dữ liệu CICDDoS2019 (SYN Flood, UDP Flood, NetBIOS Attack).

Mô hình kiểm nghiệm Độ chính xác (Accuracy) Precision Recall F1-Score Thời gian suy luận trung bình (Inference Latency)
BERT (Pre-trained Base) 98.2% 97.8% 97.5% 97.6% 48.5 ms
ALBERT (Rebuilt - Đề xuất) 99.1% 98.9% 99.0% 98.9% 18.2 ms
LSTM (Long Short-Term Memory) 99.4% 99.1% 99.2% 99.1% 14.8 ms
GRU (Gated Recurrent Unit) 99.9% 99.8% 99.9% 99.9% 9.1 ms

Nhận xét: ALBERT cho tốc độ phản hồi nhanh hơn 2.6 lần so với BERT tiêu chuẩn nhờ cấu trúc nén embedding. GRU giảm 38.5% thời gian xử lý so với LSTM trong khi vẫn duy trì độ chính xác phát hiện DDoS đạt 99.9%.

   [Inference Latency Comparison (ms) - Lower is Better]
   BERT (Standard)      |================================================| 48.5 ms
   ALBERT (Rebuilt)     |==================| 18.2 ms
   LSTM                 |===============| 14.8 ms
   GRU (Proposed)       |=========| 9.1 ms

Kịch bản 2: Kiểm thử tải và tấn công thực tế (Live Penetration Testing)

Sử dụng công cụ Hping3 thực hiện tấn công SYN Flood với lưu lượng 50,000 packets/giây vào Node điều phối Nginx, đồng thời gửi đồng thời 1,000 request chèn mã độc SQLi/XSS qua sqlmap:

  • Module Data Input & Service Discovery: Phân tải thành công qua 3 instance của Auth Module, CPU các worker node duy trì ổn định mức 62-68%.
  • Module Session Management: Ngăn chặn 100% các request giả mạo token hoặc request cố gắng thực hiện lại sau khoảng thời gian 2 phút không hoạt động (Inactivity timeout).
  • Module Deep Learning Detector: Tách luồng thành công và cô lập hoàn toàn 1,000 request độc hại, chuyển hướng dữ liệu dị biệt sang Honeynet mà không gây nghẽn các request hợp lệ (Benign traffic) đến Epoch Service và Quote Service.

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

  1. Kiến trúc phòng thủ kép (Dual-Pipeline Architecture): Đột phá kết hợp pipeline Secure Design (xác thực đa tầng, ABAC, bảo vệ danh tính phiên) và pipeline Secure Monitor (phát hiện xâm nhập chủ động bằng AI).
  2. Ứng dụng mô hình AI nén hiệu năng cao: Triển khai thành công mô hình ALBERT vào phân tích cú pháp Payload HTTP tầng ứng dụng và GRU cho chuỗi thời gian phân tích gói tin mạng, giải quyết triệt để bài toán thắt nút cổ chai về thời gian trễ của các hệ thống AI-WAF truyền thống.
  3. Mô hình quản lý phiên chống chiếm quyền (Click-based Anti-Hijacking Session): Gắn kết chặt chẽ mã định danh duy nhất UUID, Fingerprint thiết bị và cơ chế trượt thời gian 2 phút, vô hiệu hóa nguy cơ đánh cắp Cookie và tấn công Man-In-The-Middle (MITM).
  4. Tích hợp mạng bẫy Honeynet tự thích ứng: Tự động thu thập các mẫu tấn công không phân loại được (Zero-Day Anomaly), lưu trữ vào kho dữ liệu để tái huấn luyện (Retrain) mô hình định kỳ, thiết lập vòng lặp an ninh tự hoàn thiện (Self-evolving Security Loop).

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

Trường hợp sử dụng thực tế (Use Cases)

  • Hệ thống Ngân hàng số & Fintech: Bảo vệ các API giao dịch chuyển tiền trực tiếp, xác thực người dùng chặt chẽ qua TOTP và ngăn chặn khai thác tham số BOLA/IDOR.
  • Thương mại điện tử quy mô lớn: Đảm bảo hệ thống đứng vững trước các cuộc tấn công DDoS vào các dịp cao điểm mua sắm, đồng thời ngăn chặn bot thu thập dữ liệu trái phép qua API.
  • Cổng thông tin Doanh nghiệp SaaS: Quản lý hàng trăm Microservices nội bộ độc lập, tự động hóa phát hiện dịch vụ mới thông qua Mesos-DNS mà không cần cấu hình thủ công.

Hướng dẫn triển khai cụm (Deployment Guide)

# 1. Khởi động cụm Apache Mesos Master & Slave
sudo systemctl start mesos-master
sudo systemctl start mesos-slave

# 2. Khởi chạy Marathon Framework Orchestrator
sudo systemctl start marathon

# 3. Triển khai các thành phần Secure Design qua Marathon REST API
curl -X POST -H "Content-Type: application/json" \
  http://localhost:8080/v2/apps -d @nginx-datainput.json

curl -X POST -H "Content-Type: application/json" \
  http://localhost:8080/v2/apps -d @auth-service.json

# 4. Kích hoạt Worker phát hiện tấn công Deep Learning
python3 dl_monitor_worker.py --model-albert ./weights/albert_api.pt --model-gru ./weights/gru_ddos.pt

Phân tích hiệu quả kinh tế (Cost-Benefit & ROI)

  • Tiết kiệm chi phí phần cứng: Nền tảng Apache Mesos cho phép tăng mật độ sử dụng tài nguyên máy chủ lên 45% so với việc cấp phát máy ảo truyền thống.
  • Giảm thiểu thiệt hại gián đoạn: Ngăn ngừa nguy cơ sập hệ thống do DDoS, ước tính tiết kiệm hàng chục nghìn USD cho mỗi giờ gián đoạn dịch vụ của doanh nghiệp.

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

Hạn chế kỹ thuật

  • Tài nguyên khởi động mô hình AI: Mô hình ALBERT và GRU yêu cầu phân bổ GPU hoặc tài nguyên CPU tối thiểu 2 Cores cho worker phân tích thời gian thực để tránh nghẽn hàng đợi (Queue Backlog) khi lưu lượng mạng tăng đột biến.
  • Hệ sinh thái điều phối: Apache Mesos hiện tại có cộng đồng hẹp hơn so với Kubernetes (K8s), đòi hỏi kỹ sư vận hành có chuyên môn sâu về kiến trúc nội tại của Mesos Master/Agent.

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

  1. Chuyển dịch sang kiến trúc eBPF: Ứng dụng công nghệ Extended Berkeley Packet Filter (eBPF) tại tầng nhân Linux Kernel để trích xuất đặc trưng lưu lượng mạng với thời gian trễ cận zero trước khi đưa vào mô hình Deep Learning.
  2. Mở rộng mô hình giải thích được (Explainable AI - XAI): Tích hợp kỹ thuật SHAP hoặc Attention Map Visualization giúp chuyên viên bảo mật (SOC Analyst) hiểu rõ lý do mô hình ALBERT phân loại một chuỗi ký tự là mã độc.
  3. Đóng gói chuẩn Kubernetes Operator / Helm Charts: Mở rộng khả năng tương thích của giải pháp sang môi trường K8s và Red Hat OpenShift.

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

  • Sinh viên & Nghiên cứu sinh: Tài liệu tham khảo toàn diện về cách kết hợp giữa An toàn thông tin, Kiến trúc Vi dịch vụ Cloud-Native và Kỹ thuật Học sâu ứng dụng.
  • Kỹ sư DevOps / DevSecOps: Mẫu thiết kế chuẩn (Design Pattern) về phân chia module API Gateway, xử lý SSL Termination tập trung và kiểm soát phiên trượt.
  • Doanh nghiệp vừa và lớn: Một giải pháp kiến trúc Gateway mã nguồn mở, tối ưu chi phí bản quyền giải pháp WAF thương mại đắt đỏ mà vẫn đảm bảo năng lực phòng vệ thông minh.
  • Nhóm chuyên gia SOC/Security: Nền tảng mở có khả năng mở rộng để tự huấn luyện mô hình phát hiện mối đe dọa với dữ liệu đặc thù của tổ chức.

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

1. Yêu cầu cấu hình phần cứng tối thiểu để triển khai hệ thống là gì?

Cụm tối thiểu bao gồm 3 Node (1 Master, 2 Agents): Master cần tối thiểu 2 vCPU, 4GB RAM; mỗi Worker Node chạy Module Deep Learning cần tối thiểu 4 vCPU, 8GB RAM (khuyến nghị có GPU NVIDIA chuẩn bị sẵn CUDA để tối ưu tốc độ suy luận).

2. Mô hình ALBERT có thể phân loại được các biến thể tấn công zero-day trên API không?

Mô hình ALBERT học ngữ nghĩa không gian vector của toàn bộ chuỗi ký tự thay vì so khớp regex. Do đó, các biến thể tấn công bị làm mờ (Obfuscation) như nối chuỗi CONCAT(), mã hóa hex hay chèn ký tự rác vẫn bị phát hiện với độ chính xác cao. Nếu gặp mẫu hoàn toàn mới, dữ liệu sẽ được chuyển tiếp về Honeynet để phân tích và bổ sung tập huấn luyện.

3. Cơ chế Click-based Token hoạt động thế nào nếu người dùng gửi liên tiếp hàng trăm request mỗi giây?

Hệ thống sử dụng bộ nhớ đệm phân tán Redis/MySQL để so khớp Epoch Time. Nếu request hợp lệ, hệ thống chỉ cập nhật thời gian trượt theo chu kỳ micro-batching, không ghi đè liên tục xuống đĩa cứng, đảm bảo thông lượng (Throughput) đạt hơn 10,000 req/s.

4. Tại sao đồ án lựa chọn Apache Mesos & Marathon thay vì Kubernetes?

Apache Mesos cung cấp khả năng quản trị tài nguyên ở cấp độ hạ tầng cấp thấp cực kỳ mạnh mẽ, quản lý tài nguyên linh hoạt cho cả ứng dụng phân tán dạng container lẫn non-container, tạo môi trường nghiên cứu độc lập lý tưởng để đánh giá cơ chế phân phối tải của Multi-API Gateways.

5. Chi phí duy trì và thời gian hoàn vốn (ROI) của giải pháp như thế nào?

Toàn bộ giải pháp được xây dựng trên các công nghệ mã nguồn mở (Nginx, Django, PyTorch, Mesos, MySQL), loại bỏ 100% chi phí license phần mềm định kỳ. Thời gian hoàn vốn đầu tư kỹ thuật ước tính từ 3 đến 6 tháng thông qua việc cắt giảm chi phí dịch vụ WAF bên thứ ba và tự động hóa giám sát an ninh mạng.

Kết luận

Khóa luận tốt nghiệp "Phát hiện các cuộc tấn công mạng trên Multi-API gateways trong môi trường Cloud-Native sử dụng Deep Learning và Apache Mesos với Marathon" của nhóm tác giả Trần Lê Khôi và Nguyễn Đức Toàn, dưới sự hướng dẫn của TS. Nguyễn Ngọc Tự (Trường ĐH Công nghệ Thông tin - ĐHQG TPHCM), đã giải quyết triệt để bài toán an toàn thông tin trọng yếu cho kiến trúc vi dịch vụ hiện đại. Bằng việc phối hợp linh hoạt giữa phương pháp tiếp cận Secure Design (Nginx SSL Termination, xác thực MFA TOTP, kiểm soát truy cập ABAC, Click-based Session) và Secure Monitor (mô hình học sâu ALBERT cho Web Attack đạt F1-Score 98.9% và mô hình GRU cho DDoS đạt Accuracy 99.9%), đề tài đã chứng minh tính khả thi, độ tin cậy và khả năng mở rộng cao trên nền tảng Cloud-Native. Đây là đóng góp học thuật và kỹ thuật thực tiễn giá trị, mở ra hướng đi bền vững cho các giải pháp cổng API thông minh thế hệ mới.