Giới thiệu dự án

Sự bùng nổ của các thiết bị Internet vạn vật (IoT - Internet of Things) và ứng dụng thời gian thực đang tạo ra khối lượng dữ liệu khổng lồ tại các vùng biên mạng. Theo các báo cáo công nghiệp viễn thông, đến năm 2025 có hơn 75% lượng dữ liệu doanh nghiệp được tạo ra và xử lý ngoài các trung tâm dữ liệu tập trung truyền thống. Mô hình Điện toán đám mây (Cloud Computing) bộc lộ hạn chế rõ rệt về độ trễ truyền dẫn (latency), thắt nút cổ chai băng thông và rủi ro quyền riêng tư khi buộc phải chuyển toàn bộ dữ liệu về trung tâm máy chủ xa xôi. Để giải quyết thách thức này, Điện toán cận biên (Edge Computing) đã trở thành kiến trúc trọng tâm, chuyển dịch năng lực tính toán và xử lý dữ liệu trực tiếp về các nút cận biên (Edge Nodes) gần nguồn phát sinh dữ liệu.

Tuy nhiên, các hệ thống máy chủ cận biên thường có tài nguyên phần cứng (CPU, RAM) bị giới hạn nghiêm ngặt. Việc triển khai ứng dụng bằng các máy ảo truyền thống (Virtual Machine - VM) dựa trên kiến trúc phần mềm giám sát máy ảo (Hypervisor) gây lãng phí tài nguyên do kích thước hệ điều hành khách (Guest OS) nặng nề và thời gian khởi động kéo dài. Công nghệ ảo hóa container (Containerization) kết hợp cùng mô hình Điện toán không máy chủ (Serverless Computing / Function as a Service - FaaS) mang lại khả năng đóng gói siêu nhẹ, tự động co giãn theo sự kiện (event-driven auto-scaling) và tối ưu hóa sử dụng tài nguyên. Dù vậy, các dịch vụ Serverless thương mại (AWS Lambda, Google Cloud Functions, Azure Functions) mang tính độc quyền, gắn chặt với hạ tầng đám mây công cộng và khó tùy biến trực tiếp trên thiết bị biên.

+-------------------------------------------------------------------------+
|                          CLOUD DATA CENTER                              |
|          (Central Storage, Deep Analytics, Big Data Training)           |
+-------------------------------------------------------------------------+
                                    ^
                                    | (Reduced Traffic / Summary Only)
                                    v
+-------------------------------------------------------------------------+
|                           EDGE SERVER TIER                              |
|  +-------------------------------------------------------------------+  |
|  |                 Kubernetes Cluster (Master & Workers)             |  |
|  |  +-------------------+  +-------------------+  +---------------+  |  |
|  |  | Apache OpenWhisk  |  |     Kubeless      |  |   OpenFaaS    |  |  |
|  |  +-------------------+  +-------------------+  +---------------+  |  |
|  |  |           FaaS Functions (pigo-face-detector, Math, ETL)    |  |  |
|  +-------------------------------------------------------------------+  |
+-------------------------------------------------------------------------+
                                    ^
                                    | (Sub-second Invocations)
                                    v
+-------------------------------------------------------------------------+
|                         IOT & EDGE DEVICE TIER                          |
|         (Surveillance Cameras, Sensors, Mobile Clients, Drones)         |
+-------------------------------------------------------------------------+

Đồ án tập trung nghiên cứu, triển khai thực nghiệm và đánh giá định lượng ba nền tảng Serverless mã nguồn mở hàng đầu dựa trên nền tảng điều phối container Kubernetes: Apache OpenWhisk, Kubeless, và OpenFaaS.

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

  1. Nghiên cứu cơ sở lý thuyết: Phân tích chuyên sâu kiến trúc ảo hóa (Hypervisor vs Container), điều phối container với Kubernetes và mô hình lập trình FaaS.
  2. Thiết kế và triển khai cụm thực nghiệm: Xây dựng cụm Kubernetes Cluster đa nút trên môi trường máy chủ cận biên mô phỏng.
  3. Triển khai 03 nền tảng Serverless mã nguồn mở: Cài đặt, định cấu hình hoàn chỉnh Apache OpenWhisk, Kubeless và OpenFaaS trên nền tảng Kubernetes.
  4. Thực nghiệm ứng dụng AI và xử lý tính toán: Đóng gói và chạy thử nghiệm chức năng nhận diện khuôn mặt qua ảnh (Pigo Face Detector) và thuật toán tính toán toán học.
  5. Đo lường và đánh giá hiệu năng (Benchmarking): Sử dụng Apache JMeter để đánh giá thời gian phản hồi (Response Time), ảnh hưởng của ngôn ngữ lập trình, giới hạn bộ nhớ và thuật toán đến hiệu suất của từng nền tảng.

Phạm vi và giới hạn

  • Phạm vi hạ tầng: Môi trường phân tán gồm 01 Master Node, 02 Worker Nodes và 01 Client Node chạy Linux Ubuntu.
  • Giới hạn kỹ thuật: Tập trung vào các giao thức kích hoạt đồng bộ (Synchronous HTTP Trigger), đánh giá độ trễ và khả năng chịu tải trên cụm máy chủ cận biên cục bộ.

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

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

Trước khi thiết kế hệ thống, việc so sánh các nền tảng Serverless mã nguồn mở được thực hiện dựa trên các tiêu chí kỹ thuật: cơ chế mở rộng, hỗ trợ ngôn ngữ, mức độ tích hợp với Kubernetes và cộng đồng phát triển.

Tiêu chí Apache OpenWhisk Kubeless OpenFaaS
Giấy phép (License) Apache License 2.0 Apache License 2.0 MIT License
Kiến trúc tích hợp K8s Độc lập, chạy qua Controller riêng Tích hợp sâu qua Kubernetes CRD Tích hợp qua API Gateway & Watchdog
Ngôn ngữ hỗ trợ NodeJS, Python, Java, Swift, PHP, Go Python, NodeJS, Ruby, PHP, Go, .NET Go, Python, NodeJS, Ruby, C#, Java
Cơ chế Trigger HTTP, Kafka, Cron, Data Sources HTTP, Kafka, NATS, Scheduled Cron HTTP, NATS Streaming, Event-connector
Cơ chế Auto-scaling OpenWhisk Controller quản lý Dựa trên Kubernetes HPA (CPU/Metrics) Dựa trên Prometheus & Alertmanager
Thời gian triển khai ~15 phút (Phức tạp, nhiều Pod) ~5 phút (Đơn giản, gọn nhẹ) ~10 phút (Trung bình)
Mức độ chiếm dụng RAM Rất cao (CouchDB, Kafka, Zookeeper) Rất thấp (Chỉ cần Controller CRD) Trung bình (Gateway, Watchdog, NATS)

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

  • Must-have (Bắt buộc có):
    • Cài đặt thành công cụm Kubernetes v1.20 đa nút với mạng Weave Net CNI.
    • Triển khai hoạt động ổn định 3 nền tảng: Apache OpenWhisk v1.0.0, Kubeless v1.0.8, OpenFaaS.
    • Đo lường chính xác thời gian phản hồi qua Apache JMeter dưới tải đa luồng.
  • Should-have (Nên có):
    • Triển khai ứng dụng trí tuệ nhân tạo (Computer Vision) xử lý ảnh trực tiếp tại biên.
    • Khảo sát sự khác biệt giữa các độ phức tạp thuật toán $O(2^n)$, $O(n)$, $O(\log n)$.
  • Could-have (Có thể có):
    • Xây dựng giao diện Web Client (PHP/Bootstrap) để gọi Function trực quan.
  • Won't-have (Chưa thực hiện đợt này):
    • Kiểm thử trên phần cứng nhúng thực tế (Raspberry Pi/NVIDIA Jetson).

Thiết kế hệ thống

Kiến trúc thử nghiệm được phân bổ thành mô hình cụm phân tán tiêu chuẩn nhằm tái lập môi trường máy chủ cận biên:

+-------------------------------------------------------------------------------+
|                            CLIENT NODE (Ubuntu x86_64)                        |
|   +------------------------------------+ +--------------------------------+   |
|   | Apache JMeter 5.4 Benchmark Engine | | PHP Web UI Consumer Application|   |
|   +------------------------------------+ +--------------------------------+   |
+-------------------------------------------------------------------------------+
                                      | HTTP REST / Invocations
                                      v
+===============================================================================+
|                   KUBERNETES CLUSTER (Edge Server Infrastructure)             |
|                                                                               |
|  +-------------------------------------------------------------------------+  |
|  | MASTER NODE: Kubernetes API Server, Controller Manager, Scheduler, etcd |  |
|  | Pod Network CNI: Weave Net | Monitoring: Prometheus Server              |  |
|  +-------------------------------------------------------------------------+  |
|                                     |                                         |
|                 +-------------------+-------------------+                     |
|                 |                                       |                     |
|                 v                                       v                     |
|  +-----------------------------+         +-----------------------------+      |
|  |        WORKER NODE 1        |         |        WORKER NODE 2        |      |
|  | +-------------------------+ |         | +-------------------------+ |      |
|  | | Container Runtime Docker| |         | | Container Runtime Docker| |      |
|  | | Kubelet, Kube-Proxy     | |         | | Kubelet, Kube-Proxy     | |      |
|  | +-------------------------+ |         | +-------------------------+ |      |
|  | | Function Pods:          | |         | | Function Pods:          | |      |
|  | | - Kubeless Func Pods    | |         | | - OpenFaaS Function Pods| |      |
|  | | - OpenWhisk Invoker     | |         | | - OpenFaaS Watchdogs    | |      |
|  | +-------------------------+ |         | +-------------------------+ |      |
|  +-----------------------------+         +-----------------------------+      |
+===============================================================================+

Thông số kỹ thuật của hệ thống thực nghiệm

  • Hệ điều hành: Ubuntu Linux 20.04 LTS (Kernel 5.4.0-generic, x86_64).
  • Công nghệ ảo hóa: Docker Community Engine v20.10.2 (containerd v1.3.9, runc v1.0.0-rc92).
  • Hệ thống điều phối: Kubernetes v1.20.1 (kubeadm, kubectl, kubelet).
  • Mạng mạng Pod (CNI Plugin): Weave Net CNI.
  • Cấu hình phần cứng máy ảo:
    • Master Node (01): 4 vCPU Cores, 8GB RAM, 50GB Disk Storage.
    • Worker Nodes (02): 4 vCPU Cores, 8GB RAM, 50GB Disk Storage mỗi node.
    • Client Node (01): 4 vCPU Cores, 8GB RAM (Chạy JMeter & Apache PHP Web Client).

Cơ chế bảo mật và hiệu năng

  • Phân lập không gian tên (Kubernetes Namespaces) riêng biệt: openwhisk, kubeless, openfaas, openfaas-fn.
  • Giới hạn tài nguyên thực thi (Resource Limits: requests.cpu, limits.cpu, requests.memory, limits.memory) trên từng Function Pod.
  • Đảm bảo an toàn qua cơ chế xác thực Token và RBAC (Role-Based Access Control) trên API Server.

Methodology

Nghiên cứu áp dụng phương pháp nghiên cứu thực nghiệm định lượng kết hợp quy trình lặp:

  1. Thiết lập chuẩn hóa hạ tầng: Cài đặt nền tảng theo chuẩn Infrastructure-as-Code (kịch bản Bash shell/YAML manifests).
  2. Triển khai ứng dụng thử nghiệm: Sử dụng các workload đại diện gồm tải tính toán thuật toán Fibonacci và tải xử lý thị giác máy tính AI.
  3. Thu thập dữ liệu thực nghiệm: Thiết lập kịch bản kiểm thử tải trên JMeter với số lượng luồng (Threads/Concurrent Users) tăng dần từ 1, 10, 50 đến 100 kết nối đồng thời.
  4. Phân tích đối sánh: Đánh giá định lượng dựa trên các chỉ số thời gian phản hồi trung bình (Average Response Time), tỷ lệ lỗi và năng lực xử lý CPU/RAM.

Implementation và kết quả

Development process

Quá trình triển khai được cấu trúc thành các giai đoạn tuần tự từ khởi tạo cụm Kubernetes đến build và deploy functions.

1. Khởi tạo cụm Kubernetes và thiết lập mạng CNI

Khởi tạo nút Master và kết nối các Worker Nodes vào cụm:

# Khởi tạo Kubernetes Master Node với dải mạng Pod
sudo kubeadm init --pod-network-cidr=10.244.0.0/16 --apiserver-advertise-address=192.168.1.100

# Cấu hình kubeconfig cho tài khoản quản trị
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

# Cài đặt Network Plugin Weave Net
kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"

2. Cài đặt các nền tảng Serverless

  • Triển khai Kubeless v1.0.8 (Sử dụng CRD gốc):
kubectl create ns kubeless
kubectl create -f https://github.com/kubeless/kubeless/releases/download/v1.0.8/kubeless-v1.0.8.yaml
# Kiểm tra trạng thái triển khai Controller
kubectl get pods -n kubeless
  • Triển khai OpenFaaS:
# Cài đặt CLI faas-cli
curl -sSL https://cli.openfaas.com | sudo sh

# Triển khai OpenFaaS Namespaces và Core Components
kubectl apply -f https://raw.githubusercontent.com/openfaas/faas-netes/master/namespaces.yml
kubectl apply -f https://raw.githubusercontent.com/openfaas/faas-netes/master/yaml/
  • Triển khai Apache OpenWhisk:
# Sử dụng Helm Chart triển khai OpenWhisk trên cụm K8s
helm repo add openwhisk https://openwhisk.apache.org/charts
helm install owdev openwhisk/openwhisk -n openwhisk --create-namespace -f mycluster.yaml

3. Xây dựng và triển khai Function thuật toán Fibonacci

Khảo sát các hàm tính toán Fibonacci với 3 mức độ phức tạp thuật toán khác nhau:

  • Giải thuật đệ quy cổ điển (Độ phức tạp $O(2^n)$):
def fibonacci_recursive(event, context):
    req = event['data']
    n = int(req.get('n', 10))
    def fib(num):
        if num <= 0: return 0
        elif num == 1: return 1
        return fib(num - 1) + fib(num - 2)
    return {"result": fib(n), "complexity": "O(2^n)"}
  • Giải thuật tuyến tính quy hoạch động (Độ phức tạp $O(n)$):
def fibonacci_linear(event, context):
    req = event['data']
    n = int(req.get('n', 10))
    if n <= 0: return {"result": 0}
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return {"result": b, "complexity": "O(n)"}
  • Giải thuật nhân ma trận tối ưu (Độ phức tạp $O(\log n)$):
def multiply_matrix(A, B):
    return [
        [A[0][0]*B[0][0] + A[0][1]*B[1][0], A[0][0]*B[0][1] + A[0][1]*B[1][1]],
        [A[1][0]*B[0][0] + A[1][1]*B[1][0], A[1][0]*B[0][1] + A[1][1]*B[1][1]]
    ]

def power_matrix(M, p):
    res = [[1, 0], [0, 1]]
    base = M
    while p > 0:
        if p % 2 == 1:
            res = multiply_matrix(res, base)
        base = multiply_matrix(base, base)
        p //= 2
    return res

def fibonacci_log(event, context):
    req = event['data']
    n = int(req.get('n', 10))
    if n <= 0: return {"result": 0}
    T = [[1, 1], [1, 0]]
    res_matrix = power_matrix(T, n - 1)
    return {"result": res_matrix[0][0], "complexity": "O(log n)"}

4. Triển khai ứng dụng AI Pigo Face Detector trên OpenFaaS

Đóng gói ứng dụng phát hiện khuôn mặt bằng ngôn ngữ Go tối ưu hóa cho môi trường biên:

# File cấu hình stack.yml
provider:
  name: openfaas
  gateway: http://192.168.1.100:8080
functions:
  pigo-face-detector:
    lang: dockerfile
    handler: ./pigo-openfaas
    image: esimov/pigo-openfaas:0.1
    environment:
      fprocess: "./handler"

Lệnh build và triển khai:

cd pigo-openfaas/
faas-cli build -f stack.yml
faas-cli deploy -f stack.yml

Testing và validation

Quá trình kiểm thử hiệu năng được thực hiện bằng Apache JMeter 5.4 chạy từ Client Node, thực hiện đo lường chỉ số Thời gian phản hồi trung bình (Average Response Time - đơn vị ms) qua 4 kịch bản thực nghiệm:

Thực nghiệm 1: Đo lường thời gian phản hồi theo số lượng người dùng đồng thời (Function cơ bản)

Nền tảng 1 User (ms) 10 Users (ms) 50 Users (ms) 100 Users (ms)
Apache OpenWhisk 128.4 382.1 1420.5 3210.8
OpenFaaS 42.6 115.3 480.2 962.4
Kubeless 18.2 45.8 210.6 435.1

Đánh giá: Kubeless đạt thời gian phản hồi nhanh nhất do thiết kế tinh gọn chạy trực tiếp trên Kubernetes Core API. OpenWhisk có độ trễ lớn nhất do quy trình pipeline phức tạp qua Nginx, Controller, Kafka và CouchDB.

Response Time (ms) Comparison - 100 Concurrent Users
+--------------------+-----------------------------------------------------+
| Kubeless           | [####] 435.1 ms                                     |
| OpenFaaS           | [#########] 962.4 ms                                |
| Apache OpenWhisk   | [###############################] 3210.8 ms         |
+--------------------+-----------------------------------------------------+

Thực nghiệm 2: Ảnh hưởng của ngôn ngữ lập trình đến thời gian phản hồi (trên Kubeless)

Ngôn ngữ 1 User (ms) 10 Users (ms) 50 Users (ms)
Golang 8.4 22.1 94.5
NodeJS 16.5 41.2 185.0
Python 18.2 45.8 210.6
Ruby 24.7 62.4 289.3

Đánh giá: Golang cho hiệu năng vượt trội nhất nhờ biên dịch nhị phân trực tiếp và tiêu tốn cực ít bộ nhớ heap.

Thực nghiệm 3: Đánh giá mối quan hệ giữa giới hạn bộ nhớ (Memory Limit) và giải thuật

Thực hiện tính Fibonacci với $N = 35$ trên nền tảng Kubeless:

  • Đệ quy $O(2^n)$: Thời gian phản hồi ~1820 ms; khi cấp phát RAM từ 128MB lên 512MB, thời gian phản hồi giảm không đáng kể do thuật toán bị nghẽn chủ yếu tại CPU (CPU-bound).
  • Quy hoạch động $O(n)$: Thời gian phản hồi giảm xuống chỉ còn 19.4 ms (nhanh hơn xấp xỉ 93.8 lần so với đệ quy).
  • Nhân ma trận $O(\log n)$: Thời gian phản hồi đạt 18.6 ms và duy trì ổn định ngay cả khi $N$ tăng lên 1,000,000.

Kết quả đạt được

  • Tính khả thi của AI tại biên: Đã tích hợp thành công mô hình nhận diện khuôn mặt Pigo trên OpenFaaS, xử lý ảnh đầu vào kích thước $1920 \times 1080$ với thời gian trả kết quả trung bình đạt dưới 350 ms, chứng minh tính khả thi cao khi ứng dụng cho các camera an ninh tại biên mạng.
  • Hoàn thành mục tiêu đề ra: Triển khai đầy đủ 3 nền tảng FaaS trên Kubernetes, xây dựng thành công bộ đo chuẩn hóa, hoàn thành 100% các kịch bản thực nghiệm đo lường hiệu năng.

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

  1. Khảo sát toàn diện các nền tảng Serverless mã nguồn mở trên Kubernetes: Cung cấp bức tranh so sánh chi tiết giữa Kubeless, OpenFaaS và Apache OpenWhisk trên cùng một môi trường máy chủ cận biên chuẩn hóa.
  2. Chứng minh tính ưu việt của kiến trúc Kubernetes-native (CRD): Phân tích sâu nguyên nhân giúp Kubeless đạt hiệu suất cao hơn OpenFaaS (nhanh hơn ~54.8% ở mức 100 users) và OpenWhisk (nhanh hơn ~86.4% ở mức 100 users) là nhờ loại bỏ các thành phần trung gian (Middlewares như Kafka, CouchDB) và ủy quyền hoàn toàn cho Kubernetes API Server.
  3. Đánh giá đa chiều về hiệu năng FaaS: Không chỉ dừng lại ở thời gian phản hồi cơ bản, nghiên cứu đã phân tích mối tương quan giữa ngôn ngữ thực thi (Golang vs Python/NodeJS), tối ưu hóa thuật toán ($O(2^n)$ vs $O(\log n)$) và ràng buộc phần cứng (CPU/RAM bounds) trong điện toán biên.
  4. Hiện thực hóa mô hình AI-as-a-Function tại biên: Cung cấp mã nguồn và quy trình đóng gói container cho ứng dụng thị giác máy tính xử lý thời gian thực, mở ra giải pháp giảm tải băng thông cho các hệ thống IoT.

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

Kịch bản ứng dụng thực tế

  • Hệ thống giao thông thông minh (Smart Traffic Monitoring): Các máy chủ biên đặt tại ngã tư tiếp nhận luồng video từ camera, kích hoạt Function AI nhận diện biển số xe và mật độ phương tiện theo thời gian thực mà không cần tải video thô lên Cloud.
  • Giám sát nông nghiệp thông minh (Smart Agriculture): Tiếp nhận tín hiệu từ các cảm biến nhiệt độ, độ ẩm qua MQTT/HTTP; kích hoạt Function phân tích bất thường và tự động bật hệ thống tưới tiêu chỉ trong vài mili-giây.
  • Xử lý dữ liệu biên trong nhà máy công nghiệp (Industrial IoT): Lọc, làm sạch và tổng hợp dữ liệu cảm biến rung chấn của máy móc trước khi truyền báo cáo định kỳ về máy chủ trung tâm.

Hướng dẫn triển khai nhanh trên Edge Server

  1. Yêu cầu phần cứng tối thiểu:
    • 01 Máy chủ Edge Master: 2 Cores CPU, 4GB RAM.
    • 01-03 Máy chủ Edge Worker: 2 Cores CPU, 4GB RAM.
  2. Cài đặt:
    • Cài đặt Docker và Kubernetes v1.20+ trên tất cả các node.
    • Khởi tạo cụm qua kubeadm và áp dụng mạng CNI (Weave Net hoặc Flannel).
    • Triển khai Kubeless làm nền tảng FaaS nhẹ nhất cho môi trường tài nguyên hạn chế.
  3. Đóng gói Function:
    • Định nghĩa mã nguồn hàm trong file xử lý (Python/Go).
    • Sử dụng lệnh kubeless function deploy để phát hành function lên cụm.

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

Hạn chế kỹ thuật

  • Vấn đề Cold Start (Khởi động lạnh): Thời gian khởi tạo container mới cho lần gọi đầu tiên vẫn tồn tại độ trễ nhất định (~1-2 giây tùy kích thước image).
  • Giới hạn môi trường thực nghiệm: Thử nghiệm được thực hiện trên hệ thống máy ảo mô phỏng, chưa đánh giá trực tiếp trên các vi xử lý kiến trúc ARM (như Raspberry Pi 4, Jetson Nano).
  • Cơ chế lưu trữ trạng thái: Các nền tảng FaaS hoạt động theo cơ chế phi trạng thái (Stateless), việc xử lý các tác vụ có trạng thái (Stateful) đòi hỏi tích hợp thêm cơ sở dữ liệu ngoài.

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

  • Nghiên cứu Serverless dựa trên WebAssembly (Wasm): Khảo sát giải pháp thay thế Container bằng WebAssembly (như WasmEdge, Wasmer) giúp giảm thời gian khởi động xuống cấp độ micro-giây và giảm dung lượng chiếm dụng RAM xuống dưới 10MB.
  • Tối ưu hóa lập lịch cận biên (Edge Scheduling Optimization): Phát triển thuật toán lập lịch thông minh cho Kubernetes dựa trên mức độ sẵn sàng tài nguyên và vị trí địa lý của thiết bị biên.
  • Thử nghiệm trên cụm phần cứng nhúng ARM: Triển khai trên cụm thiết bị máy tính nhúng thực tế kết hợp mạng 5G/LoRaWAN.

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

  • Sinh viên & Học viên cao học ngành Mạng & CNTT: Nắm vững tài liệu tham khảo thực nghiệm chuẩn mực về điện toán cận biên, ảo hóa container và công nghệ Serverless.
  • Kỹ sư DevOps & Cloud/Edge Native: Có được dữ liệu benchmark định lượng khách quan để lựa chọn nền tảng FaaS phù hợp cho hệ thống doanh nghiệp (chọn Kubeless nếu cần hiệu năng cao trên K8s; chọn OpenFaaS nếu cần tính linh hoạt mẫu template).
  • Doanh nghiệp phát triển giải pháp IoT: Tiết kiệm từ 40% - 60% chi phí băng thông và hạ tầng điện toán đám mây bằng cách chuyển dịch các vi chức năng xử lý dữ liệu xuống các nút biên.
  • Nhà nghiên cứu học thuật: Nền tảng phương pháp luận đo lường và kịch bản thực nghiệm sẵn có để tiếp tục mở rộng các hướng nghiên cứu sâu hơn về Serverless Scheduling.

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

1. Cấu hình phần cứng tối thiểu để triển khai cụm Serverless Kubernetes tại biên là gì?

Hệ thống yêu cầu tối thiểu 02 nút (01 Master, 01 Worker), mỗi nút có tối thiểu 2 vCPU Cores và 4GB RAM, ổ cứng trống 20GB. Nên sử dụng hệ điều hành Ubuntu Server 20.04 LTS hoặc các bản phân phối Linux tối ưu cho biên như K3s / MicroK8s.

2. Vì sao Kubeless lại đạt hiệu năng phản hồi tốt hơn Apache OpenWhisk trong các bài test?

Kubeless được thiết kế theo kiến trúc "Kubernetes-native", sử dụng trực tiếp Custom Resource Definitions (CRD) và tận dụng các thành phần cốt lõi của Kubernetes (API Server, HPA, Kubelet). Ngược lại, Apache OpenWhisk duy trì một ngăn xếp phần mềm quản lý riêng gồm Nginx Proxy, Controller, Kafka Message Queue, ZooKeeper và CouchDB, dẫn đến việc tăng số bước trung gian khi điều hướng request.

3. OpenFaaS có ưu điểm gì nổi bật so với Kubeless?

OpenFaaS sở hữu hệ sinh thái công cụ (faas-cli), kho mẫu Function Templates phong phú, giao diện Web trực quan và khả năng triển khai linh hoạt không chỉ trên Kubernetes mà còn trên Docker Swarm và HashiCorp Nomad. OpenFaaS phù hợp cho quy trình đóng gói nhanh và các nhóm phát triển đa nền tảng.

4. Vấn đề "Khởi động lạnh" (Cold Start) trong Serverless tại biên được khắc phục như thế nào?

Có thể giải quyết bằng các kỹ thuật:

  • Cấu hình số lượng bản sao dự phòng tối thiểu (min-replicas: 1 hoặc pre-warmed containers).
  • Tối ưu hóa kích thước Docker Image (sử dụng Docker Alpine hoặc Scratch cho Golang binary).
  • Sử dụng các runtime nhẹ như WebAssembly (Wasm) thay cho container truyền thống.

5. Chi phí và lợi ích đầu tư (ROI) khi chuyển dịch sang Edge Serverless?

Chuyển đổi từ mô hình VM truyền thống sang Container Serverless tại biên giúp tăng mật độ triển khai ứng dụng trên cùng một phần cứng lên 3-5 lần, giảm thiểu chi phí truyền dữ liệu lên đám mây từ 50-70%, đồng thời rút ngắn thời gian phát triển tính năng mới từ vài tuần xuống còn vài giờ thông qua kiến trúc Function độc lập.

Kết luận

Khóa luận tốt nghiệp đã hoàn thành xuất sắc các mục tiêu nghiên cứu về việc triển khai và đánh giá định lượng các nền tảng Serverless mã nguồn mở trên nền tảng điều phối container Kubernetes cho hệ thống máy chủ cận biên. Kết quả thực nghiệm khẳng định Kubeless là giải pháp đạt hiệu năng tối ưu nhất về thời gian phản hồi và mức độ chiếm dụng tài nguyên nhờ kiến trúc Kubernetes-native tinh gọn, trong khi OpenFaaS mang lại sự thuận tiện vượt trội trong quy trình đóng gói và triển khai ứng dụng thực tế. Việc kết hợp thành công mô hình FaaS với các ứng dụng trí tuệ nhân tạo (AI Computer Vision) tại biên mở ra tiềm năng ứng dụng to lớn cho các hệ thống IoT thông minh trong kỷ nguyên chuyển đổi số.