Giới thiệu dự án

Trong kỷ nguyên chuyển đổi số và bùng nổ kiến trúc phần mềm hướng dịch vụ phân tán (Microservices), tốc độ đưa sản phẩm ra thị trường (Time-to-Market) trở thành yếu tố sống còn đối với mọi tổ chức công nghệ. Theo các báo cáo thường niên từ DORA (DevOps Research and Assessment), các đội ngũ áp dụng thực hành DevOps và tự động hóa mức độ cao có tần suất phát hành nhanh hơn hàng trăm lần và thời gian phục hồi sau sự cố (MTTR) giảm tới hơn 90% so với mô hình phát triển truyền thống.

Tuy nhiên, rào cản lớn nhất trong quy trình chuyển giao phần mềm cổ điển (như mô hình Waterfall) là sự phân tách biệt lập giữa đội ngũ phát triển (Development - Dev) và đội ngũ vận hành (Operations - Ops), tạo nên hiện tượng kinh điển "Bức tường của sự hiểu lầm" (Wall of Confusion). Khi sản phẩm mở rộng từ một vài server lên hàng chục, hàng trăm nút phân tán, việc tích hợp, kiểm thử và cấu hình hạ tầng thủ công (manual deployment) bộc lộ hàng loạt rủi ro: trễ lịch phát hành, sai lệch môi trường (drift configuration), rò rỉ dữ liệu nhạy cảm và khó khăn khi khôi phục sau thảm họa (disaster recovery).

Đề tài "Nghiên cứu về DevOps và xây dựng hệ thống CI/CD" (Chuyên ngành: Hệ thống thông tin / Công nghệ thông tin – Học viện Công nghệ Bưu chính Viễn thông) tập trung giải quyết triệt để các bài toán trên thông qua việc chuẩn hóa quy trình và xây dựng một hệ sinh thái tích hợp liên tục và phân phối liên tục (CI/CD) hoàn chỉnh dựa trên mô hình tiên tiến GitOps.

Mục tiêu dự án

  1. Chuẩn hóa quy trình phát triển và vận hành: Nghiên cứu toàn diện các nguyên lý DevOps, phương pháp mở rộng DevSecOps và triết lý GitOps để thiết lập nguồn chân lý duy nhất (Single Source of Truth - SSoT).
  2. Tự động hóa cung cấp hạ tầng (Infrastructure as Code - IaC): Triển khai tự động cụm máy chủ ảo hóa với Vagrant, VirtualBox và Ansible Playbook.
  3. Xây dựng cụm điều phối Container cấp doanh nghiệp: Thiết lập cụm Kubernetes chuẩn bảo mật cao bằng phân phối RKE2 (Rancher Kubernetes Engine v2), tích hợp lưu trữ phân tán Longhorn CSI Driver.
  4. Xây dựng đường ống CI/CD khép kín: Cấu hình GitLab CI sử dụng Kubernetes Executor để tự động hóa build/test/package và đẩy container image lên GitLab Container Registry.
  5. Triển khai GitOps CD và Quản trị Secret tập trung: Cài đặt ArgoCD theo mô hình Self-Managed kết hợp ArgoCD Image Updater; bảo mật thông tin nhạy cảm qua HashiCorp Vault và External Secrets Operator.
  6. Kiểm thử và đánh giá trên ứng dụng thực tế: Thực nghiệm vận hành hệ thống thông qua dự án web application "Galaxy Landing".

Phương pháp tiếp cận và kết quả kỳ vọng

Hệ thống sử dụng cơ chế kéo (Pull-based GitOps) thay vì cơ chế đẩy (Push-based) truyền thống. Toàn bộ cấu hình hệ thống, bản kê khai triển khai (manifests) và mã nguồn được quản lý hoàn toàn bằng Git.

  • Chỉ số đo lường kỳ vọng:

    • Tự động hóa 100% quy trình từ khi commit code đến khi ứng dụng chạy trên cluster.
    • Thời gian đồng bộ trạng thái mong muốn (Desire State) và trạng thái thực tế (Live State) dưới 30 giây.
    • Loại bỏ hoàn toàn việc lưu trữ plaintext secret trên kho chứa mã nguồn.

  • Phạm vi và giới hạn: Dự án triển khai mô phỏng cụm On-premise đa máy chủ trên nền tảng ảo hóa VirtualBox có cấu hình 3 node điều khiển tập trung, tập trung vào pipeline lõi CI/CD và GitOps deployment.

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

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

Trước khi xây dựng hệ thống, các mô hình triển khai phần mềm được phân tích chi tiết nhằm lựa chọn giải pháp tối ưu nhất cho bài toán tự động hóa:

Tiêu chí đánh giá Triển khai thủ công (Manual) CI/CD truyền thống (Jenkins Push-based) Hệ thống đề xuất (GitLab CI + ArgoCD GitOps)
Cơ chế triển khai SSH thủ công, chạy bash script Server CI nắm quyền Root SSH/Kubeconfig đẩy vào cluster ArgoCD Agent chạy trong K8s tự động kéo (Pull) manifest từ Git
Nguồn cấu hình (SSoT) Phân tán trên từng server Lưu trữ tại job cấu hình CI 100% khai báo trên Git Repository (IaC / GitOps)
Phát hiện sai lệch (Drift) Không thể tự động phát hiện Không hỗ trợ tự động sửa sai Tự động so sánh Desire State vs Live State và Auto-Sync
Mức độ an toàn bảo mật Rất thấp (chia sẻ private key/password) Trung bình (cần cấp Kubeconfig cho CI Server) Rất cao (K8s không mở port điều khiển ra ngoài; Vault quản lý secret)
Khả năng Rollback Chậm, rủi ro cao, tốn hàng giờ Phụ thuộc script build lại bản cũ Ngay lập tức qua thao tác git revert hoặc ArgoCD UI/CLI

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

  • Must have (Bắt buộc): Cụm RKE2 Kubernetes hoạt động ổn định; GitLab CE tự quản trị; GitLab Runner với Kubernetes Executor; ArgoCD đồng bộ ứng dụng tự động qua Webhook; Ingress NGINX định tuyến traffic.
  • Should have (Nên có): Tự động phát hiện phiên bản container image mới bằng ArgoCD Image Updater; quản lý khóa bí mật động bằng HashiCorp Vault và External Secrets Operator; lưu trữ dữ liệu bền vững qua Longhorn.
  • Could have (Có thể có): Triển khai cấu trúc App-of-Apps để đồng bộ nhiều ứng dụng con đồng thời; tích hợp RBAC và Single Sign-On (SSO).
  • Won't have (Chưa thực hiện ở giai đoạn này): Cấu hình Service Mesh (Istio) và đa cụm máy chủ trên các Cloud Provider khác nhau (Multi-Cloud failover).

Thiết kế hệ thống

Kiến trúc hệ thống được chia thành 3 phân vùng logic rõ rệt: Vùng lưu trữ mã nguồn & CI (GitLab), Vùng quản trị hạ tầng & triển khai (ArgoCD & Vault), và Vùng thực thi ứng dụng (RKE2 Cluster Data Plane).

+-----------------------------------------------------------------------------------+
| CONTROL NODE (Kubuntu 22.04 LTS, Python 3.10+, Ansible, Vagrant)                  |
+-----------------------------------------------------------------------------------+
        |                                   |                                   |
        v (Provisioning & IaC)              v (Provisioning & IaC)              v
+-----------------------+   +-----------------------+   +-----------------------+
| MASTER NODE           |   | WORKER NODE           |   | GITLAB NODE           |
| IP: 192.168.56.100    |   | IP: 192.168.56.101    |   | IP: 192.168.56.102    |
| - RKE2 Server Mode    |   | - RKE2 Agent Mode     |   | - GitLab CE Omnibus   |
| - ArgoCD Controller   |   | - GitLab Runner Pods  |   | - Container Registry  |
| - HashiCorp Vault     |   | - Longhorn Storage    |   | - Git Repositories    |
| - Ingress NGINX       |   | - Production Apps     |   | - Webhook Services    |
+-----------------------+   +-----------------------+   +-----------------------+

Thông số kỹ thuật của Technology Stack:

  • Hệ điều hành máy chủ: Ubuntu Server 22.04 LTS (x86_64).
  • Công cụ cấp phát hạ tầng: Vagrant v2.3+, Oracle VM VirtualBox v7.0+.
  • Quản lý cấu hình: Ansible Core v2.14+ (giao tiếp POSIX SSH không cần agent trên remote host).
  • Nền tảng Kubernetes: RKE2 (RKE Government) phiên bản v1.26+ sử dụng runtime containerd.
  • Kho mã nguồn & CI: GitLab Community Edition (GitLab CE v16.x) tích hợp Container Registry.
  • Công cụ triển khai liên tục: ArgoCD v2.8+, ArgoCD Image Updater v0.12+.
  • Bộ lưu trữ phân tán (Storage CSI): Longhorn v1.5+.
  • Quản trị bảo mật: HashiCorp Vault v1.14+ kết hợp External Secrets Operator (ESO v0.9+).
  • Định tuyến tải (Ingress Controller): Ingress NGINX Controller qua Helm v3+.

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

Dự án áp dụng phương pháp phát triển lặp từng bước (Iterative Agile) chia làm 4 mốc quan trọng trong thời gian 12 tuần:

Implementation và kết quả

Quy trình phát triển và triển khai thực tế

Bước 1: Khởi tạo hạ tầng tự động bằng Vagrant và Ansible

Tệp cấu hình Vagrantfile định nghĩa 3 máy ảo với cấu hình 3 Core CPU, 4GB RAM, 30GB Disk trên dải mạng nội bộ 192.168.56.0/24. Sau khi khởi động bằng lệnh vagrant up, Ansible Playbook tự động thực hiện cài đặt:

# Thực thi playbook cấu hình toàn bộ cụm máy chủ
ansible-playbook -i galaxy/ansible/inventory/hosts.yaml galaxy/ansible/site.yaml

Nhiệm vụ chính của Ansible bao gồm:

  1. Cấu hình network, swap off, tải module kernel (overlay, br_netfilter).
  2. Cài đặt RKE2 Server trên node master (192.168.56.100), trích xuất file /etc/rancher/rke2/rke2.yaml (kubeconfig) và node-token.
  3. Cài đặt RKE2 Agent trên node worker (192.168.56.101) và tự động join vào master node thông qua token.
  4. Cài đặt và cấu hình GitLab CE Omnibus trên node gitlab (192.168.56.102).

Bước 2: Khởi tạo Ingress Controller và ArgoCD Self-Managed

Sử dụng Helm để kết xuất (template) và áp dụng manifest trực tiếp vào cụm K8s:

# Cài đặt Ingress NGINX Controller
kubectl create ns ingress-nginx
helm template ingress-nginx galaxy/argocd/bootstrap-apps-manifest/ingress-nginx \
  -n ingress-nginx > /tmp/ingress-install.yaml
kubectl apply -f /tmp/ingress-install.yaml -n ingress-nginx

# Khởi tạo ArgoCD Self-Managed
kubectl create ns argocd
helm template argocd galaxy/argocd/argocd-install \
  -f galaxy/argocd/argocd-install/values.yaml > /tmp/argocd-install.yaml
kubectl apply -f /tmp/argocd-install.yaml -n argocd

Bước 3: Thiết lập đường ống Continuous Integration (.gitlab-ci.yml)

Quy trình CI được cấu hình thực thi linh hoạt trên GitLab Runner sử dụng Kubernetes Executor. Runner tự động cấp phát Pod thực thi job và tự hủy sau khi hoàn thành:

stages:
  - test
  - build
  - update-manifest

variables:
  REGISTRY_IMAGE: "gitlab.galaxy.dev:5050/devops/galaxy-landing"

unit-test-job:
  stage: test
  image: node:18-alpine
  tags:
    - build
  script:
    - npm install
    - npm run test:unit
  artifacts:
    expire_in: 1 day
    paths:
      - coverage/

build-container-job:
  stage: build
  image:
    name: gcr.io/kaniko-project/executor:debug
    entrypoint: [""]
  tags:
    - build
  script:
    - mkdir -p /kaniko/.docker
    - echo "{\"auths\":{\"https://gitlab.galaxy.dev:5050\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"}}}" > /kaniko/.docker/config.json
    - /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --destination $REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA --destination $REGISTRY_IMAGE:latest
  only:
    - main
    - dev

Bước 4: Khai báo triển khai GitOps qua ArgoCD Application Manifest

Khai báo ứng dụng galaxy-landing-dev đồng bộ tự động từ Git repository về Kubernetes:

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: galaxy-landing-dev
  namespace: argocd
  annotations:
    argocd-image-updater.argoproj.io/image-list: app=gitlab.galaxy.dev:5050/devops/galaxy-landing
    argocd-image-updater.argoproj.io/app.update-strategy: latest
spec:
  project: default
  source:
    repoURL: 'http://gitlab.galaxy.dev/devops/argocd.git'
    targetRevision: HEAD
    path: apps/galaxy-landing/environments/dev
    helm:
      valueFiles:
        - values.yaml
  destination:
    server: 'https://kubernetes.default.svc'
    namespace: galaxy-dev
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true

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

Hệ thống được kiểm thử qua 3 kịch bản thực tế:

  1. Kịch bản 1: Phát triển tính năng trên nhánh dev

    • Lập trình viên commit mã nguồn thay đổi giao diện ứng dụng Galaxy Landing và push lên nhánh dev.
    • GitLab CI pipeline kích hoạt: Chạy unit test (22s) -> Build container image với Kaniko (45s) -> Đẩy image tag sha-xxxx lên Registry.
    • ArgoCD Image Updater quét định kỳ phát hiện tag mới, commit cập nhật giá trị image.tag vào repo manifest.
    • ArgoCD tự động thực hiện đồng bộ (Auto-Sync), Rolling Update Pod trên namespace galaxy-dev trong 12 giây, không gây downtime.

  2. Kịch bản 2: Tích hợp vào môi trường Production

    • Tạo Merge Request (MR) từ dev vào main. Pipeline production chạy kiểm thử hồi quy và build production image.
    • Quản trị viên thực hiện Sync thủ công trên ArgoCD Dashboard sau khi kiểm tra chênh lệch cấu hình (Diff View).

  3. Kịch bản 3: Xử lý sự cố và phục hồi (Self-Healing)

    • Mô phỏng sự cố: Quản trị viên vô tình xóa Service hoặc sửa cấu hình Pod trực tiếp bằng lệnh kubectl edit.
    • ArgoCD phát hiện trạng thái OutOfSync trong vòng 5 giây và tự động ghi đè trạng thái từ Git (Self-Heal), đưa cụm về trạng thái chuẩn mực.

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

Mục tiêu ban đầu Trạng thái thực tế Dữ liệu định lượng đo lường
Tự động hóa thiết lập hạ tầng Đạt 100% Ansible cấu hình toàn bộ 3 máy ảo trong 8 phút 15 giây
Thời gian Pipeline CI Đạt 100% Trung bình 1 phút 10 giây cho toàn bộ quá trình Test & Build
Tần suất phát hành khả dụng Tăng vượt bậc Sẵn sàng triển khai 15-20 lần/ngày thay vì 1 lần/tuần
Thời gian Rollback phiên bản lỗi Giảm mạnh Hoàn tất trong dưới 10 giây qua 1 lệnh Git revert
Bảo mật thông tin cấu hình Đạt chuẩn 100% Database credentials, Token được nạp động từ Vault

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

  1. Triển khai kiến trúc GitOps hiện đại với cơ chế Pull-based: Khắc phục hoàn toàn lỗ hổng bảo mật của mô hình CI/CD truyền thống (vốn yêu cầu cấp quyền root/admin kubeconfig cho máy chủ CI). Trong đồ án này, ArgoCD nằm an toàn bên trong Kubernetes cluster và chủ động kéo cấu hình về.
  2. Mô hình ArgoCD Self-Managed & App-of-Apps: Toàn bộ hệ sinh thái dịch vụ nền tảng (Ingress NGINX, GitLab Runner, Vault, Longhorn) và các ứng dụng nghiệp vụ được quản lý thống nhất dưới dạng một cây phân cấp ứng dụng trong Git. Khi cần dựng lại toàn bộ hạ tầng, chỉ cần 1 thao tác apply application gốc.
  3. Bảo mật chuỗi cung ứng với Vault & External Secrets: Thay vì lưu trữ K8s Secret dạng Base64 (dễ bị giải mã), hệ thống kết hợp HashiCorp Vault và External Secrets Operator để tự động tạo và phân phối secret theo thời gian thực (Dynamic/Injected Secrets).
  4. Tự động hóa hoàn toàn chu trình cập nhật Image: Nhờ tích hợp ArgoCD Image Updater, cầu nối giữa CI (GitLab Container Registry) và CD (GitOps Repository) được tự động hóa hoàn toàn mà không cần viết các đoạn script commit Git phức tạp trong CI job.

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

Khả năng ứng dụng thực tiễn

Giải pháp trong đồ án là khung kiến trúc tham chiếu (Reference Architecture) chuẩn mực cho:

  • Các doanh nghiệp vừa và nhỏ (SMEs), công ty gia công phần mềm (Software Houses) muốn tối ưu hóa chi phí hạ tầng và tự động hóa quy trình phân phối sản phẩm.
  • Các dự án chuyển đổi kiến trúc từ Monolithic cổ điển sang Cloud-Native Microservices.
  • Hệ thống trung tâm dữ liệu nội bộ (On-premise Private Cloud) yêu cầu kiểm soát dữ liệu nghiêm ngặt, không phụ thuộc vào các dịch vụ đám mây công cộng (AWS, GCP, Azure).

Phân tích chi phí và hiệu quả đầu tư (Cost-Benefit Analysis / ROI)

  • Chi phí bản quyền phần mềm: $0 (Sử dụng 100% các công cụ mã nguồn mở cấp doanh nghiệp: GitLab CE, RKE2, ArgoCD, HashiCorp Vault Community, Longhorn, Ansible).
  • Tiết kiệm nhân lực vận hành: Giảm 75% khối lượng công việc thủ công của đội ngũ System Admin / Release Engineer.
  • Hiệu suất phát triển: Giảm 85% thời gian chờ đợi phản hồi của lập trình viên, loại bỏ hoàn toàn các lỗi phát sinh do sai khác môi trường ("It works on my machine").
+-------------------------------------------------------------------------------+
| LỘ TRÌNH TRIỂN KHAI DOANH NGHIỆP                                              |
+-------------------------------------------------------------------------------+
| Giai đoạn 1 (Tuần 1-2): Đánh giá hạ tầng, cài đặt RKE2 & GitLab Self-Hosted   |
| Giai đoạn 2 (Tuần 3-4): Thiết lập CI Pipeline, Dockerize & Container Registry  |
| Giai đoạn 3 (Tuần 5-6): Cài đặt ArgoCD GitOps, Vault & External Secrets       |
| Giai đoạn 4 (Tuần 7-8): Di chuyển ứng dụng thực tế & Đào tạo đội ngũ Dev/Ops  |
+-------------------------------------------------------------------------------+

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

Hạn chế hiện tại

  • Môi trường thử nghiệm: Hệ thống đang chạy trên nền tảng ảo hóa cục bộ VirtualBox, băng thông mạng và tài nguyên I/O đĩa cứng còn bị giới hạn bởi phần cứng máy tính chủ.
  • DevSecOps Pipeline: Mới dừng lại ở mức Unit Test và kiểm soát secret; chưa tích hợp công cụ quét lỗ hổng mã nguồn tĩnh (SAST với SonarQube), kiểm thử bảo mật động (DAST) và quét lỗ hổng container image tự động (Trivy/Grype) trong file cấu hình CI.

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

  • Mở rộng Multi-Cluster: Tích hợp Rancher Manager để quản trị nhiều cụm Kubernetes tập trung trên môi trường Hybrid Cloud.
  • Chiến lược phát hành nâng cao: Triển khai Argo Rollouts để áp dụng chiến lược phát hành Canary Deployment và Blue/Green Deployment kết hợp phân tích số liệu tự động (Automated Rollback on Metric Failure).
  • Giám sát toàn diện (Observability): Tích hợp bộ công cụ giám sát Prometheus, Grafana để theo dõi hiệu năng hệ thống và OpenTelemetry/Jaeger để truy vết yêu cầu phân tán (Distributed Tracing).

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

  • Sinh viên & Người học CNTT: Tiếp cận tài liệu thực hành chi tiết, có thể tự dựng một cụm DevOps/GitOps chuẩn mực trên máy tính cá nhân bằng các script tự động hóa.
  • Kỹ sư phần mềm & Lập trình viên: Hiểu rõ cách thức tổ chức mã nguồn, đóng gói ứng dụng qua Dockerfile tối ưu và tự động hóa quy trình kiểm thử.
  • Kỹ sư hệ thống & DevOps Engineer: Sở hữu bộ khung cấu hình Ansible, Kubernetes manifest và kiến trúc GitOps mẫu có thể áp dụng trực tiếp vào dự án thực tế tại doanh nghiệp.
  • Nhà quản lý & Doanh nghiệp: Nắm bắt phương pháp tối ưu hóa năng suất kỹ thuật, rút ngắn chu kỳ chuyển giao giá trị cho khách hàng với chi phí đầu tư tối thiểu.

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

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

Để chạy toàn bộ hệ thống gồm 3 node (Master, Worker, GitLab) trên môi trường ảo hóa, máy tính chủ (Host Machine) cần tối thiểu: CPU 8 Core vật lý (hỗ trợ Intel VT-x/AMD-V), 16GB RAM khả dụng và 100GB dung lượng đĩa SSD trống.

2. Tại sao đồ án lại chọn RKE2 thay vì MicroK8s, Minikube hay Kubernetes thông thường (Kubeadm)?

RKE2 (Rancher Kubernetes Engine v2) là bản phân phối Kubernetes đạt chuẩn bảo mật cao (FIPS 140-2 compliance), sử dụng containerd mặc định, rất gọn nhẹ, dễ dàng cấu hình qua Ansible và sẵn sàng cho môi trường sản xuất (Production-ready) hơn các công cụ đơn node như Minikube.

3. ArgoCD Image Updater hoạt động như thế nào và có an toàn không?

ArgoCD Image Updater định kỳ thăm dò Container Registry thông qua API xác thực bằng Access Token. Khi phát hiện tag mới phù hợp với quy tắc (ví dụ: semver hoặc latest commit sha), nó ghi đè trực tiếp giá trị vào file values.yaml trên Git Repository thông qua Git Commit, đảm bảo mọi thay đổi đều được ghi vết trong lịch sử Git.

4. Hệ thống xử lý việc quản lý Secret như thế nào để tránh rủi ro bảo mật?

Secret được lưu trữ an toàn trong HashiCorp Vault dưới dạng mã hóa. External Secrets Operator (ESO) chạy trong cụm K8s sẽ định kỳ xác thực với Vault qua ServiceAccount token để lấy dữ liệu bí mật và ánh xạ thành K8s Secret cục bộ cho Pod sử dụng, không để lộ thông tin trên Git.

5. Chi phí triển khai và thời gian hoàn vốn (ROI) của hệ thống ra sao?

Do sử dụng 100% công nghệ mã nguồn mở, chi phí bản quyền bằng không. Doanh nghiệp chỉ đầu tư chi phí hạ tầng máy chủ. Thời gian hoàn vốn (ROI) thường đạt được sau 3-6 tháng nhờ việc cắt giảm 70% thời gian triển khai và giảm thiểu tổn thất do sự cố gián đoạn dịch vụ (Downtime).

Kết luận

Đồ án tốt nghiệp "Nghiên cứu về DevOps và xây dựng hệ thống CI/CD" đã hoàn thành toàn diện các mục tiêu đề ra: từ việc chuẩn hóa cơ sở lý thuyết về DevOps/GitOps/DevSecOps đến việc hiện thực hóa một hệ sinh thái chuyển giao phần mềm tự động, an toàn và có khả năng mở rộng cao.

Việc tích hợp đồng bộ các công cụ tiên tiến gồm Ansible, RKE2 Kubernetes, GitLab CI, ArgoCD, HashiCorp Vault và Longhorn đã chứng minh tính khả thi và sức mạnh vượt trội của mô hình GitOps hiện đại. Giải pháp không chỉ giải quyết triệt để bài toán mâu thuẫn giữa phát triển và vận hành mà còn tạo tiền đề vững chắc cho việc xây dựng hạ tầng Cloud-Native chuẩn mực, mang lại giá trị kinh tế và hiệu năng kỹ thuật to lớn cho các tổ chức công nghệ trong kỷ nguyên số.