> For the complete documentation index, see [llms.txt](https://docs.verge.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.verge.io/learn-the-platform/vi/module-10-thuc-hanh-tinh-huong/lab-multi-tenancy.md).

# Thực hành: Triển khai đa tenant / MSP

## Mục tiêu

Xây dựng một môi trường Nhà cung cấp Dịch vụ Quản lý (MSP) đa thuê bao trên VergeOS. Bạn sẽ tạo các tenant bằng cả Tenant Wizard và Tenant Recipes, cấu hình hạn ngạch tài nguyên, thiết lập mạng cho tenant (bao gồm cả Layer 2 pass-through), xác minh sự cô lập giữa các tenant, và xem lại nhật ký kiểm tra ở cấp host cùng các báo cáo sử dụng.

## Yêu cầu tiên quyết

* Đã hoàn thành tất cả các mô-đun trước đó (1–9)
* Quyền truy cập vào môi trường VergeOS đang chạy với ít nhất 2 node
* Quyền truy cập cấp quản trị vào hệ thống VergeOS của host
* Ít nhất 2 địa chỉ IP bên ngoài khả dụng (Virtual IP) để truy cập giao diện người dùng tenant
* Ít nhất 32 GB RAM và 8 lõi khả dụng để phân bổ cho tenant
* Quen thuộc với các khái niệm mạng của VergeOS (mạng nội bộ, mạng bên ngoài, VLAN)

## Độ khó

**Trung cấp** — Cần hiểu về tenancy, mạng và quản lý tài nguyên của VergeOS

## Thời gian ước tính

**1,5 giờ**

***

## Bối cảnh: Kiến trúc đa thuê bao của VergeOS

Trước khi bắt đầu lab, hãy xem VergeOS triển khai đa thuê bao như thế nào:

```mermaid
graph TB
    subgraph "Hệ thống VergeOS của host"
        Host["Bảng điều khiển host<br/>Quản trị hệ thống"]
        ExtNet["Mạng bên ngoài<br/>Virtual IP"]
        vSAN["Kho lưu trữ vSAN<br/>Các đĩa vật lý dùng chung"]
    end
    subgraph "Tenant A (VDC)"
        TA_UI["Giao diện Tenant A<br/>URL duy nhất"]
        TA_Net["Mạng Tenant A<br/>Được bao gói hoàn toàn"]
        TA_Store["Lưu trữ Tenant A<br/>Volume cô lập"]
        TA_VMs["Các VM của Tenant A"]
    end
    subgraph "Tenant B (VDC)"
        TB_UI["Giao diện Tenant B<br/>URL duy nhất"]
        TB_Net["Mạng Tenant B<br/>Được bao gói hoàn toàn"]
        TB_Store["Lưu trữ Tenant B<br/>Volume cô lập"]
        TB_VMs["Các VM của Tenant B"]
    end
    Host --> TA_UI
    Host --> TB_UI
    ExtNet --> TA_UI
    ExtNet --> TB_UI
    vSAN --> TA_Store
    vSAN --> TB_Store
    TA_Net -.- |"Không có lưu lượng giữa các tenant"| TB_Net
```

**Nguyên tắc chính:**

* Mỗi **thuê bao** là một Trung tâm Dữ liệu Ảo (VDC) hoàn chỉnh với giao diện riêng, mạng riêng, lưu trữ riêng và quản lý người dùng riêng
* **Cô lập** được thực thi thông qua bao gói mạng hoàn toàn và các volume lưu trữ độc quyền — không phải phân đoạn dựa trên VLAN
* **Đa thuê bao lồng nhau** cho phép các tenant tạo các tenant con từ tài nguyên được phân bổ của chính họ
* **Theo dõi tài nguyên** cung cấp thống kê sử dụng theo từng tenant, bao gồm các chỉ số deduplication cho việc tính phí và lập kế hoạch dung lượng
* **Mẫu tenant** tự động hóa việc triển khai các cấu hình tenant tiêu chuẩn để đưa vào sử dụng nhanh chóng

***

## Các bước

### Phần 1: Tạo tenant bằng trình hướng dẫn

Sử dụng Tenant Wizard tích hợp sẵn để tạo thủ công tenant đầu tiên của bạn.

1. **Đi tới Tenants:**
   * Từ giao diện VergeOS của host, nhấp **Tenants** trong menu trên cùng
   * Nhấp **+ Tenant mới**
   * Ở góc trên bên trái, chọn **Từ Trình hướng dẫn** và nhấp **Tiếp theo**
2. **Cấu hình cài đặt tenant:**
   * **Tên:** Nhập `MSP-Tenant-A`
   * **Mật khẩu người dùng quản trị:** Đặt một mật khẩu mạnh (tối thiểu 8 ký tự) — ghi lại để dùng sau
   * **Yêu cầu đổi mật khẩu:** Bỏ chọn cho mục đích lab
   * **Mô tả:** Nhập `Tenant lab được tạo qua trình hướng dẫn`
   * **Hiển thị System Snapshots:** Giữ nguyên được chọn (cho phép tenant duyệt các snapshot của host)
   * **Quyền truy cập theme:** Chọn `Không thể tạo giao diện mới, chỉ có quyền đọc đối với tất cả giao diện của máy chủ`
   * Nhấp **Gửi** để tiếp tục đến cấu hình Node
3. **Cấu hình Node của tenant:**
   * **Lõi:** Chọn `4` lõi
   * **RAM:** Chọn `8192 MB` (8 GB)
   * **Cluster:** Để ở `--Mặc định--`
   * **Khi mất điện:** Chọn `Trạng thái cuối cùng`
   * Nhấp **Gửi** để tiếp tục đến cấu hình Storage
4. **Cấu hình lưu trữ tenant:**
   * **Tier:** Chọn tier lưu trữ chính của bạn (thường là Tier 1)
   * **Được cấp phát:** Nhập `100 GB`
   * Nhấp **Gửi** để tiếp tục đến Quản lý UI
5. **Gán IP bên ngoài:**
   * Từ **Gán IP ngoài** menu thả xuống, chọn một Virtual IP khả dụng
   * Nếu không có Virtual IP khả dụng, nhấp **Tạo IP ngoài mới**:
     * **Mạng:** Chọn mạng ngoài của bạn
     * **Loại:** Virtual IP
     * **Địa chỉ IP:** Nhập một IP khả dụng hoặc để trống để tự động gán
     * **Chủ sở hữu:** Chọn `MSP-Tenant-A`
   * Nhấp **Gửi** để hoàn tất
6. **Áp dụng quy tắc mạng và bật nguồn:**
   * Trên bảng điều khiển tenant, nhấp vào màu cam **Cần áp dụng quy tắc** thông báo để áp dụng các quy tắc tường lửa
   * Nhấp **Bật nguồn** từ menu bên trái để khởi động tenant
   * Chờ tenant khởi động — bảng điều khiển sẽ hiển thị trạng thái đang chạy
7. **Xác minh quyền truy cập tenant:**
   * Nhấp **Kết nối tới UI** từ menu bên trái của bảng điều khiển tenant
   * Đăng nhập bằng `admin` và mật khẩu bạn đã cấu hình
   * Xác minh tenant có bảng điều khiển, mạng và chế độ xem lưu trữ độc lập của riêng mình

### Phần 2: Tạo tenant bằng công thức

Sử dụng Tenant Recipe để triển khai tự động, tiêu chuẩn hóa.

1. **Khám phá các tenant recipe khả dụng:**
   * Từ giao diện host, đi tới **Repositories** > **Tenant Recipes**
   * Duyệt các danh mục có sẵn — lưu ý các recipe và mô tả của chúng
   * Nếu không có tenant recipe nào, bạn sẽ tạo một từ MSP-Tenant-A
2. **Tạo tenant recipe (nếu cần):**
   * Trước tiên, **tắt nguồn** MSP-Tenant-A (nó phải ở trạng thái dừng để làm cơ sở cho recipe)
   * Đi tới **Repositories** > **Tenant Recipes** và nhấp **Mới**
   * Cấu hình recipe:
     * **Tên:** `MSP-Standard-Tenant`
     * **Mô tả:** `Tenant MSP tiêu chuẩn với 4 lõi, 8 GB RAM, 100 GB lưu trữ`
     * **Danh mục:** Chọn hoặc tạo một danh mục (ví dụ, `Mẫu MSP`)
     * **Tenant:** Chọn `MSP-Tenant-A`
   * Nhấp **Gửi**
3. **Xem lại và tùy chỉnh các câu hỏi của recipe:**
   * Trên bảng điều khiển tenant recipe, nhấp **Câu hỏi**
   * Xem lại các câu hỏi hệ thống được tạo tự động — lưu ý các phần:
     * **Phần Tenant:** Tên, URL, thông tin đăng nhập quản trị, quyền truy cập theme
     * **Phần Node:** Số lõi, phân bổ RAM
     * **Phần mạng:** Địa chỉ IP bên ngoài
   * Bật bất kỳ câu hỏi nào bị vô hiệu hóa mà bạn muốn hiển thị (ví dụ, `YB_USER_EMAIL`)
   * Nhấp **Xuất bản** để làm cho recipe khả dụng
4. **Triển khai một tenant từ recipe:**
   * Đi tới **Tenants** > **+ Tenant mới**
   * Chọn **Mẫu MSP** danh mục ở bên trái
   * Chọn `MSP-Standard-Tenant` recipe và nhấp **Tiếp theo**
   * Điền các câu hỏi của recipe:
     * **Tên:** `MSP-Tenant-B`
     * **Mật khẩu quản trị:** Đặt một mật khẩu
     * **Số lõi Node 1:** `4`
     * **RAM Node 1:** `8192`
     * Gán một địa chỉ IP bên ngoài
   * Nhấp **Gửi** để tạo tenant
   * Bật nguồn MSP-Tenant-B và xác minh nó khởi động thành công
5. **So sánh hai phương pháp tạo:**

   | Khía cạnh        | Trình hướng dẫn                               | Recipe                                          |
   | ---------------- | --------------------------------------------- | ----------------------------------------------- |
   | Tốc độ           | 5–10 phút cấu hình thủ công                   | 1–2 phút với các giá trị mặc định đã điền sẵn   |
   | Tính nhất quán   | Phụ thuộc vào độ chính xác của người vận hành | Cấu hình cơ sở giống hệt được đảm bảo           |
   | Tùy chỉnh        | Tính linh hoạt đầy đủ tại thời điểm tạo       | Được kiểm soát thông qua các câu hỏi của recipe |
   | Phù hợp nhất cho | Tenant dùng một lần hoặc độc nhất             | Triển khai chuẩn hóa, lặp lại được              |
   | Bao gồm VM/mạng  | Chỉ cơ sở hạ tầng tenant cơ bản               | Có thể bao gồm VM, mạng được cấu hình sẵn       |

### Phần 3: Cấu hình hạn ngạch tài nguyên

Thực hành quản lý phân bổ tài nguyên tenant từ host.

1. **Xem lại phân bổ tài nguyên hiện tại:**
   * Từ bảng điều khiển host, đi tới **Tenants**
   * Nhấp vào **MSP-Tenant-A** để mở bảng điều khiển của nó
   * Lưu ý tài nguyên đã được phân bổ: lõi, RAM và lưu trữ đã cấp phát
   * Cuộn xuống **Storage** phần và quan sát phân bổ tier
2. **Sửa đổi tài nguyên tenant:**
   * Khi MSP-Tenant-A được chọn, nhấp **Nút** trong menu bên trái
   * Nhấp đúp vào node của tenant, sau đó nhấp **Chỉnh sửa**
   * Tăng **Số lõi** thành `6` và **RAM** thành `12288 MB` (12 GB)
   * Nhấp **Gửi**
   * Lưu ý: Lõi và RAM của node tenant có thể hot-plug — các thay đổi có hiệu lực ngay lập tức, không cần khởi động lại tenant hoặc các workload của nó. Hệ thống xác thực rằng tài nguyên yêu cầu khả dụng trên host/cluster khi bạn gửi.
3. **Thêm lưu trữ cho tenant:**
   * Từ bảng điều khiển MSP-Tenant-A, nhấp **Thêm bộ nhớ lưu trữ** trong menu bên trái
   * Nếu có tier thứ hai khả dụng, cấp phát `50 GB` trên một tier khác
   * Nếu không, hãy chỉnh sửa tier hiện có và tăng lượng được cấp phát lên `150 GB`
   * Lưu ý: Hạn ngạch lưu trữ trong VergeOS là **giới hạn mềm** — hệ thống ghi lại cảnh báo khi một tenant tiến gần ngưỡng được cấp phát, nhưng không chặn cứng việc ghi ở đúng ranh giới
   * Xác minh thay đổi lưu trữ được phản ánh trong bảng điều khiển tenant
4. **Hiểu ranh giới tài nguyên:**
   * Lưu ý rằng hệ thống host cho phép cấp phát vượt mức tài nguyên — bạn có thể phân bổ cho các tenant nhiều lõi và RAM hơn so với thực tế sẵn có
   * Tuy nhiên, tất cả tài nguyên được cấp phát phải thực sự khả dụng để **bật nguồn** một node tenant
   * Ghi lại tổng tài nguyên đã phân bổ cho cả hai tenant so với tổng tài nguyên khả dụng của host

### Phần 4: Thiết lập mạng cho tenant

Cấu hình mạng nâng cao bao gồm Layer 2 pass-through.

1. **Xem lại mạng mặc định của tenant:**
   * Đăng nhập vào UI của MSP-Tenant-A
   * Đi tới **Mạng** — quan sát các mạng được tạo tự động:
     * Một **Mạng nội bộ** cho workload của tenant
     * Một **Mạng bên ngoài** cung cấp kết nối tới host
   * Lưu ý ngăn xếp mạng của tenant được bao gói hoàn toàn và độc lập như thế nào
2. **Cấu hình chuyển tiếp mạng Layer 2:**
   * Quay lại **host** giao diện VergeOS
   * Đi tới **Tenants** > chọn `MSP-Tenant-A` > **Mạng Layer2** > **Mới**
   * Cấu hình chuyển tiếp Layer 2:
     * **Mạng vật lý:** Chọn mạng vật lý chứa VLAN cần chuyển tiếp
     * **VLAN ID:** Nhập thẻ VLAN cần chuyển cho tenant
     * **Đã bật:** Đặt thành `Có`
   * Nhấp **Gửi**
   * VergeOS tự động tạo các **mạng bên ngoài** và **Vật lý** mạng tương ứng bên trong tenant
3. **Xác minh kết nối Layer 2 bên trong tenant:**
   * Đăng nhập vào UI của MSP-Tenant-A
   * Đi tới **Mạng** — xác nhận rằng các mạng External và Physical mới đã được tạo tự động
   * Tạo một VM thử nghiệm bên trong tenant và gắn NIC của nó vào mạng được chuyển tiếp
   * Xác minh VM có thể nhận địa chỉ IP từ VLAN (nếu có DHCP) hoặc cấu hình IP tĩnh và kiểm tra kết nối
4. **Ghi lại kiến trúc mạng:**

   | Loại mạng                      | Mục đích                                               | Được quản lý bởi |
   | ------------------------------ | ------------------------------------------------------ | ---------------- |
   | Mạng nội bộ                    | Giao tiếp workload của tenant (được bao gói hoàn toàn) | Tenant           |
   | Mạng External của tenant       | Kết nối từ tenant tới host                             | Tenant           |
   | External / Virtual IP của host | Kết nối ra thế giới bên ngoài                          | Máy chủ          |
   | Chuyển tiếp Layer 2            | Truy cập VLAN trực tiếp từ hạ tầng vật lý              | Host + Tự động   |

### Phần 5: Xác minh sự cô lập giữa các tenant

Xác nhận rằng các tenant thực sự được cô lập với nhau.

1. **Kiểm tra cô lập mạng:**
   * Đăng nhập vào **MSP-Tenant-A** và tạo một VM đơn giản (ví dụ, một VM Linux nhẹ)
   * Gán cho nó một địa chỉ IP nội bộ (ví dụ, `10.0.0.10/24`)
   * Đăng nhập vào **MSP-Tenant-B** và tạo một VM tương tự
   * Gán cho nó **cùng** địa chỉ IP nội bộ (`10.0.0.10/24`)
   * Xác minh rằng cả hai VM khởi động mà không xung đột — vì mỗi tenant có một mạng được bao gói hoàn toàn, nên có thể dùng địa chỉ IP giống nhau
   * Từ VM của Tenant A, thử ping IP bên ngoài của Tenant B — lưu lượng sẽ bị chặn theo mặc định (không có định tuyến giữa các tenant)
2. **Xác minh cô lập lưu trữ:**
   * Từ bảng điều khiển host, xem xét phân bổ lưu trữ của từng tenant
   * Xác nhận rằng mỗi tenant có volume lưu trữ riêng dành riêng cho mình
   * Xác minh Tenant A không thể thấy hoặc truy cập lưu trữ của Tenant B
   * Đăng nhập vào từng tenant và xác minh bảng điều khiển lưu trữ chỉ hiển thị dung lượng đã cấp phát của chính họ
3. **Kiểm tra cô lập quản trị:**
   * Đăng nhập vào MSP-Tenant-A với tư cách admin — xác minh bạn không thể thấy MSP-Tenant-B trong bất kỳ menu nào
   * Đăng nhập vào MSP-Tenant-B với tư cách admin — xác minh bạn không thể thấy MSP-Tenant-A
   * Từ **host**, xác minh bạn có thể thấy và quản lý cả hai tenant
   * Ghi lại mô hình cô lập ba lớp:
     * **Mạng:** Bao gói hoàn toàn Layer 2/3 — không có miền quảng bá dùng chung
     * **Lưu trữ:** Các volume lưu trữ độc quyền cho từng tenant
     * **Quản trị:** Quản lý người dùng và UI độc lập cho từng tenant
4. **Kiểm tra thực thi hạn ngạch:**
   * Trong MSP-Tenant-A, thử tạo một VM vượt quá tài nguyên được cấp phát (ví dụ, yêu cầu nhiều RAM hơn mức đã phân bổ)
   * Quan sát cách VergeOS thực thi ranh giới tài nguyên — VM sẽ không thể bật nguồn nếu tài nguyên không đủ
   * Ghi lại thông báo lỗi và hành vi

### Phần 6: Xem nhật ký kiểm tra và báo cáo sử dụng

Sử dụng giám sát ở cấp host để theo dõi hoạt động của tenant.

1. **Xem nhật ký kiểm tra của host:**
   * Từ bảng điều khiển host, đi tới **Hệ thống** > **Nhật ký**
   * Lọc các sự kiện liên quan đến tenant — tìm:
     * Sự kiện tạo tenant
     * Sự kiện bật/tắt nguồn tenant
     * Sự kiện sửa đổi tài nguyên
   * Lưu ý các dấu thời gian, người dùng và hành động được ghi lại
   * Xác minh rằng các hành động quản trị được thực hiện bên trong tenant (ví dụ: tạo VM) hiển thị ở cấp host
2. **Tạo báo cáo sử dụng của tenant:**
   * Đi tới **Tenants** và chọn một tenant
   * Nhấp **Báo cáo sử dụng** (hoặc đi tới phần báo cáo)
   * Xem các chỉ số khả dụng:
     * Mức sử dụng CPU theo thời gian
     * Mức tiêu thụ RAM
     * Mức sử dụng lưu trữ và thống kê deduplication
     * Thông lượng mạng
   * So sánh mức sử dụng giữa MSP-Tenant-A và MSP-Tenant-B
   * Hãy cân nhắc cách các báo cáo này sẽ hỗ trợ tính phí trong một môi trường MSP thực tế
3. **Theo dõi tình trạng tenant từ host:**
   * Từ bảng điều khiển host, xem các chỉ báo trạng thái của tenant
   * Kiểm tra tình trạng node, tình trạng lưu trữ và trạng thái mạng của từng tenant
   * Đi tới **Tenants** > **Giám sát** để xem tình trạng tổng hợp của tenant
   * Ghi lại các chỉ số nào là quan trọng nhất cho vận hành MSP

***

## Dọn dẹp

Khi hoàn thành bài lab:

1. Tắt tất cả VM bên trong mỗi tenant
2. Tắt nguồn cả hai tenant (MSP-Tenant-A và MSP-Tenant-B)
3. Xóa chuyển tiếp mạng Layer 2 khỏi host
4. Xóa cả hai tenant khỏi host (Tenants > chọn tenant > Delete)
5. Xóa tenant recipe nếu đã tạo (Repositories > Tenant Recipes > xóa)
6. Giải phóng mọi Virtual IP đã được gán cho các tenant
7. Áp dụng các quy tắc trên mạng bên ngoài để dọn sạch các mục tường lửa

***

## Xác minh

Lab Đa thuê bao / MSP của bạn hoàn tất khi bạn có thể trả lời **có** cho tất cả các mục sau:

* [ ] Đã tạo thành công một tenant bằng Tenant Wizard (MSP-Tenant-A)
* [ ] Đã tạo hoặc triển khai thành công một tenant bằng Tenant Recipe (MSP-Tenant-B)
* [ ] Đã cấu hình và sửa đổi hạn ngạch tài nguyên (lõi, RAM, lưu trữ) cho tenant
* [ ] Đã thiết lập chuyển tiếp mạng Layer 2 tới một tenant và xác minh kết nối
* [ ] Đã xác minh cô lập mạng — các IP giống nhau trong các tenant khác nhau cùng tồn tại mà không xung đột
* [ ] Đã xác minh cô lập lưu trữ — các tenant không thể truy cập volume lưu trữ của nhau
* [ ] Đã xác minh cô lập quản trị — các tenant không thể thấy tài nguyên của nhau
* [ ] Đã kiểm tra thực thi hạn ngạch tài nguyên — VM không thể bật nguồn khi vượt quá phân bổ
* [ ] Đã xem nhật ký kiểm tra của host về các sự kiện liên quan đến tenant
* [ ] Đã tạo và xem báo cáo sử dụng tenant cho các chỉ số tính phí
* [ ] Đã dọn dẹp tất cả tài nguyên lab (tenant, recipe, Virtual IP, mạng Layer 2)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.verge.io/learn-the-platform/vi/module-10-thuc-hanh-tinh-huong/lab-multi-tenancy.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
