Giới thiệu dự án

Thương mại điện tử (E-Commerce) tại Việt Nam duy trì tốc độ tăng trưởng ấn tượng từ 16% đến 30%/năm liên tục trong giai đoạn 2015–2022. Theo số liệu thống kê từ VnEconomy, với hơn 75% dân số tiếp cận Internet, có tới 74,8% người dùng tham gia mua sắm trực tuyến. Tuy nhiên, các mô hình bán lẻ truyền thống (Fixed-price B2C/C2C) dần bão hòa, tạo ra nhu cầu cấp thiết về các hình thức giao dịch mang tính tương tác cao, minh bạch và tối ưu giá trị hàng hóa như đấu giá trực tuyến (Online Auction).

Đồ án khóa luận "Phát triển hệ thống đấu giá trực tuyến tích hợp ví MoMo dựa trên kiến trúc Microservice" của tác giả Lê Đoàn (Khoa Kỹ thuật Phần mềm, Trường Đại học Công nghệ Thông tin – ĐHQG-HCM, 2022, dưới sự hướng dẫn của TS. Nguyễn Trịnh Đông) giải quyết bài toán cốt lõi: Xây dựng một sàn đấu giá trực tuyến hiệu năng cao, giảm thiểu độ trễ dữ liệu khi có hàng ngàn lượt trả giá đồng thời, đồng thời tự động hóa quy trình thanh toán không tiền mặt bảo mật chuẩn PCI-DSS.

Problem Statement và Pain Points

  • Nghẽn cổ chai hệ thống (Monolithic Bottleneck): Các nền tảng đấu giá nguyên khối thường gặp lỗi sập server hoặc trễ dữ liệu nghiêm trọng ở những giây cuối cùng của phiên đấu giá khi lượng request tăng đột biến.
  • Gian lận và bùng hàng (Auction Fraud): Tình trạng người tham gia trả giá ảo đẩy giá sàn rồi không thanh toán, gây thiệt hại nặng nề cho người bán.
  • Thanh toán thủ công, rời rạc: Quy trình chuyển khoản và đối soát thủ công gây chậm trễ trong việc xác nhận đơn hàng sau khi thắng đấu giá.
graph TD
    A[Người dùng / Trình duyệt] -->|HTTP / REST| B[API Gateway]
    B -->|gRPC / Protobuf| C[User Service]
    B -->|gRPC / Protobuf| D[Product Service]
    B -->|gRPC / Protobuf| E[Auction Service]
    B -->|gRPC / Protobuf| F[Order Service]
    B -->|gRPC / Protobuf| G[Payment MoMo Service]
    C --> H[(MySQL Database)]
    D --> H
    E --> H
    F --> H
    G --> H
    G -->|HTTPS IPN / QR Code| I[MoMo Payment Gateway]

Mục tiêu dự án

  1. Kiến trúc hóa hệ thống: Phân rã nghiệp vụ thương mại điện tử thành các Microservices độc lập viết bằng Golang, giao tiếp nội bộ qua giao thức gRPC.
  2. Cơ chế đấu giá thời gian thực: Xây dựng luồng xử lý đồng thời (concurrency) với Goroutines và Mutex lock nhằm đảm bảo tính toàn vẹn dữ liệu cho từng bước giá.
  3. Tích hợp cổng thanh toán MoMo: Triển khai phương thức thanh toán tự động qua mã QR Code động và xử lý webhook IPN (Instant Payment Notification).
  4. Hệ thống đánh giá độ tin cậy: Thiết lập bộ quy tắc kiểm soát điểm uy tín (Credit Score >= 80) và số dư ví trước khi cho phép người dùng vào phòng đấu giá.
  5. Giao diện Single Page Application (SPA): Phát triển Client bằng ReactJS và Material-UI tối ưu trải nghiệm tương tác với độ phân giải chuẩn 1920x1080.

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

  • Phạm vi: Nghiệp vụ quản trị tài khoản, danh mục sản phẩm, phòng đấu giá trực tuyến, giỏ hàng, đơn hàng và module thanh toán ví MoMo (Sandbox/Production environment).
  • Giới hạn kỹ thuật: Hệ thống hiện tại sử dụng chung một cơ sở dữ liệu quan hệ MySQL tập trung cho các service; client được tối ưu hóa hiển thị tốt nhất trên desktop browser (1920x1080).

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

Phân tích hiện trạng và So sánh giải pháp

Tiêu chí Hệ thống Monolithic truyền thống Sàn TMĐT tổng hợp (Shopee/Lazada) Hệ thống Microservice Golang - MoMo
Kiến trúc Nguyên khối (Monolith) Phân tán quy mô lớn Microservices hướng mô-đun hóa
Giao thức nội bộ In-memory function call Message Queue / RPC / REST gRPC trên nền HTTP/2 & Protobuf
Xử lý Concurrency Kém khi tải cao, dễ race condition Rất cao, phân tán đa cụm Tối ưu bằng Goroutines & Mutex Lock
Thanh toán đấu giá Chuyển khoản thủ công / COD Tích hợp ví sàn Tự động hóa qua QR MoMo & IPN
Chi phí hạ tầng Trung bình, khó scale từng phần Cực lớn Tối ưu tài nguyên CPU/RAM nhờ Golang

Bảng phân loại yêu cầu người dùng theo mô hình MoSCoW

Mức độ ưu tiên Tính năng / Yêu cầu kỹ thuật Mô tả chi tiết
Must-Have (Bắt buộc) Quản lý phiên đấu giá, Đặt giá (Bid Engine), Xác thực Auth, Thanh toán MoMo QR Xử lý transaction đặt giá tức thời; khóa luồng khi ghi nhận giá mới; tạo giao dịch MoMo tự động.
Should-Have (Nên có) Hệ thống điểm uy tín (Credit Score), Quản lý địa chỉ giao hàng, Bộ lọc trạng thái đơn Kiểm tra điều kiện điểm >= 80; quản lý 1 địa chỉ mặc định; cập nhật trạng thái hủy/đang giao.
Could-Have (Có thể có) Lọc sản phẩm nhiều tiêu chí, Upload đa hình ảnh (tối đa 6 ảnh), Đổi avatar Tối ưu hóa UI/UX hiển thị hình ảnh sản phẩm đấu giá.
Won't-Have (Chưa triển khai) Đấu thầu ngược (Reverse Auction), Đa ví (ZaloPay/VNPay), Dynamic Micro-frontend Dành cho lộ trình phát triển giai đoạn tiếp theo.

Thiết kế hệ thống và Kiến trúc công nghệ

Hệ thống được thiết kế theo mô hình Microservices phân tầng. Các request từ client đi qua lớp API Gateway để định tuyến và chuyển đổi từ HTTP RESTful sang gRPC calls:

  • Ngôn ngữ Backend: Golang v1.19 (Tối ưu hóa đa nhiệm qua Goroutines).
  • Giao thức liên kết: gRPC v1.50 & Protocol Buffers v3 (Payload nhị phân nhỏ gọn, tốc độ serialize/deserialize nhanh gấp 5-10 lần JSON).
  • Cơ sở dữ liệu: MySQL 8.0 với InnoDB Engine, hỗ trợ ACID transactions.
  • Frontend Framework: ReactJS 18.2, Material-UI (MUI) v5.10, Axios Client.
  • Containerization & Orchestration: Docker v20.10, Docker-compose, Docker Swarm.

Lược đồ Cơ sở dữ liệu (Database Schema DDL cốt lõi)

-- Bảng tài khoản người dùng
CREATE TABLE `users` (
  `id` VARCHAR(36) PRIMARY KEY,
  `email` VARCHAR(100) NOT NULL UNIQUE,
  `password_hash` VARCHAR(255) NOT NULL,
  `full_name` VARCHAR(100) NOT NULL,
  `credit_score` INT DEFAULT 100,
  `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- Bảng phiên đấu giá
CREATE TABLE `auctions` (
  `id` VARCHAR(36) PRIMARY KEY,
  `product_id` VARCHAR(36) NOT NULL,
  `seller_id` VARCHAR(36) NOT NULL,
  `start_price` DECIMAL(15, 2) NOT NULL,
  `step_price` DECIMAL(15, 2) NOT NULL,
  `max_price` DECIMAL(15, 2) NOT NULL,
  `current_bid` DECIMAL(15, 2) DEFAULT 0.00,
  `winner_id` VARCHAR(36) NULL,
  `status` ENUM('PENDING', 'ACTIVE', 'COMPLETED', 'CANCELLED') DEFAULT 'PENDING',
  `start_time` DATETIME NOT NULL,
  `end_time` DATETIME NOT NULL,
  INDEX `idx_auction_status` (`status`),
  FOREIGN KEY (`seller_id`) REFERENCES `users`(`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- Bảng lịch sử đặt giá
CREATE TABLE `bids` (
  `id` BIGINT AUTO_INCREMENT PRIMARY KEY,
  `auction_id` VARCHAR(36) NOT NULL,
  `bidder_id` VARCHAR(36) NOT NULL,
  `bid_amount` DECIMAL(15, 2) NOT NULL,
  `bid_time` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  FOREIGN KEY (`auction_id`) REFERENCES `auctions`(`id`),
  FOREIGN KEY (`bidder_id`) REFERENCES `users`(`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

Đặc tả gRPC Interface (auction_service.proto)

syntax = "proto3";
package auction;
option go_package = "./proto";

service AuctionService {
  rpc PlaceBid (BidRequest) returns (BidResponse);
  rpc GetAuctionDetail (AuctionQuery) returns (AuctionDetailResponse);
}

message BidRequest {
  string auction_id = 1;
  string bidder_id = 2;
  double bid_amount = 3;
}

message BidResponse {
  bool success = 1;
  string message = 2;
  double new_current_bid = 3;
  string winner_id = 4;
}

message AuctionQuery {
  string auction_id = 1;
}

message AuctionDetailResponse {
  string auction_id = 1;
  double current_bid = 2;
  string status = 3;
  int32 total_bidders = 4;
}

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

Dự án áp dụng mô hình Agile/Scrum gồm 5 giai đoạn chính từ tháng 09/2022 đến tháng 12/2022:

  • Milestone 1 (05/09 – 17/09/2022): Nghiệp vụ khảo sát luật (Luật Thương mại 2005, Luật Đấu giá tài sản 2016, Luật Giao dịch điện tử 2005) & Phân rã chức năng (FDD).
  • Milestone 2 (19/09 – 29/10/2022): Hiện thực Backend Microservices trên Golang, định nghĩa Schema Protobuf & gRPC services.
  • Milestone 3 (31/10 – 26/11/2022): Phát triển Frontend ReactJS, tích hợp REST API Gateway và Material-UI.
  • Milestone 4 (28/11 – 10/10/2022): Tích hợp MoMo Payment Gateway API (Signature HMAC_SHA256, IPN callback), đóng gói Docker Swarm.
  • Milestone 5 (12/12 – 22/12/2022): Kiểm thử hệ thống, nghiệm thu và hoàn thiện khóa luận.

Implementation và kết quả

Xử lý tranh chấp đặt giá thời gian thực (Concurrency Bidding Engine)

Để đảm bảo quy tắc nghiệp vụ BR18, BR19, BR20 (Người tham gia phải có credit_score >= 80, mức giá mới phải lớn hơn giá hiện tại ít nhất 1 step_price, và không tự outbid chính mình), Golang sử dụng cơ chế sync.Mutex để cô lập phiên đấu giá trong bộ nhớ:

package service

import (
	"context"
	"errors"
	"sync"
	pb "auction-system/proto"
)

type AuctionServer struct {
	pb.UnimplementedAuctionServiceServer
	mu sync.Mutex
}

func (s *AuctionServer) PlaceBid(ctx context.Context, req *pb.BidRequest) (*pb.BidResponse, error) {
	s.mu.Lock()
	defer s.mu.Unlock()

	// 1. Kiểm tra trạng thái phiên và lấy dữ liệu đấu giá hiện tại từ database
	auction, err := getAuctionFromDB(req.AuctionId)
	if err != nil {
		return &pb.BidResponse{Success: false, Message: "Phiên đấu giá không tồn tại"}, err
	}

	if auction.Status != "ACTIVE" {
		return &pb.BidResponse{Success: false, Message: "Phiên đấu giá đã kết thúc hoặc chưa bắt đầu"}, nil
	}

	// 2. Kiểm tra Business Rules (BR20: Không thể tự đặt giá khi đang là người trả giá cao nhất)
	if auction.WinnerID == req.BidderId {
		return &pb.BidResponse{Success: false, Message: "Bạn đang là người trả giá cao nhất"}, nil
	}

	// 3. Kiểm tra tính hợp lệ của giá đặt mới (Price Step Validation)
	minValidPrice := auction.CurrentBid + auction.StepPrice
	if req.BidAmount < minValidPrice {
		return &pb.BidResponse{Success: false, Message: "Giá đặt phải lớn hơn hoặc bằng bước giá quy định"}, nil
	}

	// 4. Cập nhật lượt đặt giá mới vào Database trong Transaction
	err = recordBidTransaction(req.AuctionId, req.BidderId, req.BidAmount)
	if err != nil {
		return &pb.BidResponse{Success: false, Message: "Lỗi ghi nhận đặt giá"}, err
	}

	return &pb.BidResponse{
		Success:        true,
		Message:        "Đặt giá thành công!",
		NewCurrentBid: req.BidAmount,
		WinnerId:      req.BidderId,
	}, nil
}

Xử lý Thanh toán Ví MoMo (Capture Wallet & Webhook IPN)

Quy trình thanh toán được mã hóa dữ liệu với thuật toán ký chữ ký số HMAC-SHA256 trước khi gọi tới endpoint của MoMo:

// Cấu trúc khởi tạo đơn hàng MoMo QR Code từ Backend
const crypto = require('crypto');

function createMoMoPaymentUrl(orderInfo) {
  const { partnerCode, accessKey, secretKey, orderId, amount, returnUrl, notifyUrl } = orderInfo;
  const requestId = orderId;
  const requestType = "captureWallet";
  const extraData = "";

  // Tạo Raw Signature String theo tiêu chuẩn MoMo API v2
  const rawSignature = `accessKey=${accessKey}&amount=${amount}&extraData=${extraData}&ipnUrl=${notifyUrl}&orderId=${orderId}&orderInfo=${orderInfo.title}&partnerCode=${partnerCode}&redirectUrl=${returnUrl}&requestId=${requestId}&requestType=${requestType}`;

  const signature = crypto
    .createHmac('sha256', secretKey)
    .update(rawSignature)
    .digest('hex');

  const requestBody = {
    partnerCode,
    accessKey,
    requestId,
    amount,
    orderId,
    orderInfo: orderInfo.title,
    redirectUrl: returnUrl,
    ipnUrl: notifyUrl,
    extraData,
    requestType,
    signature,
    lang: 'vi'
  };

  return requestBody;
}

Kiểm thử và Đánh giá hiệu năng (Testing & Benchmarks)

Hệ thống được kiểm thử tự động với bộ test suite tích hợp trong Go (go test -race -v ./...) và tải giả lập thông qua công cụ Apache JMeter:

  • Test Scenarios: 10 Use Cases lớn (UC_REGISTER đến UC_BID_PROCESS), 21 quy tắc nghiệp vụ (BR1 - BR21).
  • Tỷ lệ Test Coverage: Đạt 91,4% logic core của Auction Service và Order Service.
  • Hiệu năng xử lý đặt giá (Benchmark):
    • Số lượng request đồng thời: 1.200 request/giây (RPS).
    • Độ trễ phản hồi trung bình (gRPC RPC Latency): 18.4 ms.
    • Tỷ lệ lỗi dưới tải cao (Error rate): 0.00% (Không xảy ra tình trạng Deadlock hay Race Condition khi ghi nhận giá).
    • Thời gian khởi tạo mã QR thanh toán MoMo: 320 ms.

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

Điểm cải tiến kỹ thuật nổi bật

  1. Loại bỏ hiện tượng "Biding Race Collision": Việc sử dụng Golang kết hợp cơ chế kiểm soát đồng thời in-memory giảm thiểu 95% độ trễ I/O database so với kiến trúc thông thường dùng SQL Raw Update Lock.
  2. Cơ chế chống bùng hàng đa tầng: Tích hợp bộ quy tắc phạt: Nếu người thắng không tiến hành thanh toán đơn hàng, hệ thống tự động trừ 5 điểm uy tín (Credit Score). Khi điểm tụt dưới 80, tài khoản bị thu hồi quyền tham gia mọi phiên đấu giá trong tương lai.
  3. Mô-đun hóa độc lập (High Decoupling): Khi Payment Service của MoMo bảo trì hoặc gặp sự cố, Auction Service và Product Service vẫn vận hành bình thường, cho phép phiên đấu giá diễn ra liên tục không gián đoạn.
+-----------------------------------------------------------------------------------+
|               SO SÁNH CẢI TIẾN HIỆU NĂNG SO VỚI HỆ THỐNG CŨ                       |
+------------------------------------+-----------------------+----------------------+
| Chỉ số đánh giá                    | Monolith (PHP/NodeJS) | Microservice (Go/RPC)|
+------------------------------------+-----------------------+----------------------+
| Thời gian phản hồi đặt giá (ms)   | 145 ms                | 18.4 ms (Giảm 87.3%) |
| Thông lượng xử lý tối đa (RPS)    | 320 RPS               | 1200 RPS (Tăng 275%) |
| Thời gian đối soát thanh toán      | 15 - 30 phút          | Tức thì (IPN < 1s)   |
| Mức tiêu hao RAM máy chủ lúc đỉnh  | ~1.8 GB               | ~210 MB (Giảm 88.3%) |
+------------------------------------+-----------------------+----------------------+

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

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

  • Sàn đấu giá sản phẩm công nghệ & đồ sưu tầm: Áp dụng cho các mặt hàng phiên bản giới hạn (Limited Edition), đồ cổ hoặc đồ điện tử đã qua sử dụng với tính năng xác minh độ tin cậy hai chiều.
  • Thanh lý tài sản doanh nghiệp minh bạch: Doanh nghiệp có thể tạo các phiên đấu giá công khai cho thiết bị văn phòng, máy móc với chi phí vận hành nền tảng thấp.

Hướng dẫn triển khai với Docker Swarm

Hệ thống được đóng gói thông qua Docker Compose và triển khai lên cụm Swarm:

version: '3.8'

services:
  api-gateway:
    image: auction-system/api-gateway:v1.0
    ports:
      - "8080:8080"
    networks:
      - auction-network
    deploy:
      replicas: 2
      restart_policy:
        condition: on-failure

  auction-service:
    image: auction-system/auction-service:v1.0
    environment:
      - DB_HOST=db-mysql
      - GRPC_PORT=50051
    networks:
      - auction-network
    deploy:
      replicas: 3

  momo-payment-service:
    image: auction-system/payment-service:v1.0
    environment:
      - MOMO_PARTNER_CODE=MOMOIOC202209
      - MOMO_ACCESS_KEY=klmno123456
      - MOMO_SECRET_KEY=secret_key_hash
    networks:
      - auction-network

  db-mysql:
    image: mysql:8.0
    environment:
      - MYSQL_ROOT_PASSWORD=secure_root_password
      - MYSQL_DATABASE=auction_db
    volumes:
      - db_data:/var/lib/mysql
    networks:
      - auction-network

networks:
  auction-network:
    driver: overlay

volumes:
  db_data:

Phân tích hiệu quả kinh tế và Chi phí (Cost-Benefit Analysis)

  • Tối ưu chi phí hạ tầng: Ứng dụng Golang tiêu tốn ít hơn 80% RAM và CPU so với Java/Node.js, giúp giảm chi phí thuê máy chủ cloud (AWS EC2 / Google Cloud Compute Engine) từ $150/tháng xuống còn $30/tháng.
  • Tỷ suất sinh lời (ROI): Việc tự động hóa quy trình thanh toán MoMo giúp giảm 100% chi phí nhân sự đối soát đơn hàng thủ công, loại bỏ sai sót tài chính trong vận hành.

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

Hạn chế kỹ thuật hiện tại

  • Cơ sở dữ liệu tập trung (Shared Database): Các microservices vẫn đang trỏ chung về một instance MySQL, chưa hoàn toàn tách rời Database-per-Service do giới hạn tài nguyên đồ án.
  • Thiếu lớp Caching phân tán: Chưa áp dụng Redis Cache để lưu cache thông tin bảng xếp hạng đấu giá (Leaderboard), dẫn tới việc đọc database định kỳ.
  • Phạm vi hiển thị UI: Giao diện ReactJS mới chỉ tối ưu tốt nhất trên độ phân giải màn hình Desktop tiêu chuẩn (1920x1080), chưa có giao diện Native Mobile App.

Hướng phát triển mở rộng

  1. Tích hợp Redis Pub/Sub & WebSocket: Cập nhật bảng giá thầu theo thời gian thực tới hàng triệu client mà không cần HTTP Polling.
  2. Triển khai kiến trúc Database-per-Service: Tách riêng database cho từng service và sử dụng Kafka làm Event Bus để đồng bộ dữ liệu theo mô hình Saga Pattern.
  3. Mở rộng phương thức thanh toán: Tích hợp thêm cổng VNPay, ZaloPay, Viettel Money và thẻ quốc tế (Visa/Mastercard).

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

  • Sinh viên ngành Kỹ thuật Phần mềm / CNTT: Tài liệu tham khảo toàn diện về cách tổ chức mã nguồn Golang theo kiến trúc Microservice, thiết kế Protobuf và triển khai gRPC trong thực tế.
  • Kỹ sư Lập trình (Developers): Nắm bắt mô hình giải quyết bài toán Concurrency, kỹ thuật đồng bộ hóa thanh toán qua Webhook MoMo IPN chuẩn bảo mật.
  • Doanh nghiệp & Startup E-Commerce: Khung giải pháp sẵn có để triển khai mô hình đấu giá trực tuyến với chi phí vận hành tối thiểu và độ ổn định cao.
  • Nhà nghiên cứu: Cơ sở dữ liệu thực nghiệm về đánh giá độ trễ và thông lượng giữa RESTful API truyền thống và gRPC trên nền Microservice.

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

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

Máy chủ chạy hệ điều hành Linux (Ubuntu 20.04 LTS trở lên), tối thiểu 2 Cores CPU, 2GB RAM, đã cài đặt Docker v20.10+ và Docker-compose. Phía người dùng chỉ cần trình duyệt web hiện đại (Google Chrome, Firefox, Safari) hỗ trợ chuẩn HTML5/ES6.

2. Hệ thống xử lý thế nào nếu người dùng thắng đấu giá nhưng không trả tiền?

Hệ thống tự động hủy đơn sau thời gian quy định (Timeout), hoàn trả sản phẩm về trạng thái chờ và khấu trừ trực tiếp 5 điểm uy tín (credit_score) của tài khoản vi phạm. Nếu điểm uy tín dưới 80, người dùng sẽ bị hệ thống chặn vĩnh viễn quyền tham gia đặt giá ở tất cả các phiên đấu giá sau đó.

3. Tại sao chọn gRPC thay vì RESTful API cho giao tiếp nội bộ giữa các Service?

gRPC sử dụng Protocol Buffers định dạng nhị phân chạy trên HTTP/2, hỗ trợ multiplexing nhiều request trên 1 kết nối TCP duy nhất, giảm kích thước gói tin đến 70% và giảm thời gian trễ tới 80% so với việc truyền tải JSON qua RESTful HTTP/1.1.

4. Quá trình thanh toán MoMo có đảm bảo an toàn không?

Giao dịch được bảo mật tuyệt đối thông qua chuẩn mã hóa HMAC-SHA256 với khóa bí mật (secretKey). Mọi yêu cầu gọi lại từ cổng MoMo đều được xác thực chữ ký số trước khi cập nhật trạng thái đơn hàng trong database, loại bỏ hoàn toàn nguy cơ giả mạo dữ liệu giao dịch.

5. Có thể mở rộng (Scale) hệ thống khi lượng người tham gia đấu giá tăng đột biến không?

Nhờ kiến trúc Microservice và Docker Swarm, bạn có thể dễ dàng tăng số lượng bản sao (Replicas) của riêng auction-service và api-gateway lên hàng chục container chỉ bằng một dòng lệnh docker service scale auction-service=10 mà không cần khởi động lại toàn bộ hệ thống.

Kết luận

Đồ án "Phát triển hệ thống đấu giá trực tuyến tích hợp ví MoMo dựa trên kiến trúc Microservice" của sinh viên Lê Đoàn đã giải quyết thành công những thách thức trọng tâm của sàn thương mại điện tử thế hệ mới: Đảm bảo hiệu năng cao, chống nghẽn mạng trong các phiên đấu giá căng thẳng bằng Golang & gRPC, đồng thời hoàn thiện chu trình thanh toán không tiền mặt bảo mật qua ví điện tử MoMo.

Dự án không chỉ là một công trình học thuật xuất sắc tại Trường Đại học Công nghệ Thông tin – ĐHQG-HCM, mà còn mang giá trị thực tiễn cao, sẵn sàng chuyển giao và ứng dụng cho các doanh nghiệp TMĐT trong kỷ nguyên số hóa 4.0.