Mengelola Grup Sumber Daya

Di Milvus, Anda dapat menggunakan grup sumber daya untuk mengisolasi secara fisik node kueri tertentu dari yang lain. Panduan ini memandu Anda tentang cara membuat dan mengelola grup sumber daya khusus serta mentransfer node di antara mereka.

Apa yang dimaksud dengan grup sumber daya

Grup sumber daya dapat menampung beberapa atau semua node kueri dalam cluster Milvus. Anda dapat menentukan bagaimana Anda ingin mengalokasikan node kueri di antara kelompok sumber daya berdasarkan apa yang paling masuk akal bagi Anda. Sebagai contoh, dalam skenario multi-koleksi, Anda dapat mengalokasikan jumlah node kueri yang sesuai untuk setiap kelompok sumber daya dan memuat koleksi ke dalam kelompok sumber daya yang berbeda, sehingga operasi di dalam setiap koleksi secara fisik tidak bergantung pada koleksi lain.

Perhatikan bahwa sebuah instance Milvus mempertahankan sebuah grup sumber daya default untuk menampung semua node kueri pada saat start-up dan menamainya dengan __default_resource_group.

Mulai dari versi 2.4.1, Milvus menyediakan API grup sumber daya deklaratif, sementara API grup sumber daya yang lama sudah tidak digunakan lagi. API deklaratif yang baru memungkinkan pengguna untuk mencapai idempoten, untuk melakukan pengembangan sekunder di lingkungan cloud-native dengan lebih mudah.

Konsep kelompok sumber daya

Grup sumber daya dijelaskan oleh konfigurasi grup sumber daya:

{
    "requests": { "nodeNum": 1 },
    "limits": { "nodeNum": 1 },
    "transfer_from": [{ "resource_group": "rg1" }],
    "transfer_to": [{ "resource_group": "rg2" }]
}

• Atribut permintaan menentukan kondisi yang harus dipenuhi oleh grup sumber daya.
• Atribut batas menentukan batas maksimum untuk grup sumber daya.
• Atribut transfer_from dan transfer_to menjelaskan dari grup sumber daya mana grup sumber daya sebaiknya memperoleh sumber daya dan ke grup sumber daya mana grup sumber daya harus mentransfer sumber daya.

Setelah konfigurasi kelompok sumber daya berubah, Milvus akan menyesuaikan sumber daya Query Node saat ini sebanyak mungkin sesuai dengan konfigurasi baru, memastikan bahwa semua kelompok sumber daya pada akhirnya memenuhi kondisi berikut:

.requests.nodeNum < nodeNumOfResourceGroup < .limits.nodeNum.

Kecuali dalam kasus-kasus berikut ini:

• Ketika jumlah QueryNode dalam cluster Milvus tidak mencukupi, misalnya, NumOfQueryNode < sum(.requests.nodeNum), akan selalu ada kelompok sumber daya tanpa QueryNode yang cukup.
• Ketika jumlah QueryNode dalam cluster Milvus berlebihan, misalnya, NumOfQueryNode > sum(.limits.nodeNum), QueryNode yang berlebihan akan selalu ditempatkan di __default_resource_group terlebih dahulu.

Tentu saja, jika jumlah QueryNode dalam klaster berubah, Milvus akan terus berusaha menyesuaikan untuk memenuhi kondisi akhir. Oleh karena itu, Anda dapat menerapkan perubahan konfigurasi grup sumber daya terlebih dahulu, lalu melakukan penskalaan QueryNode.

Gunakan api deklaratif untuk mengelola kelompok sumber daya

1. Membuat grup sumber daya.

   Untuk membuat grup sumber daya, jalankan kode berikut setelah Anda terhubung ke sebuah instans Milvus. Cuplikan berikut ini mengasumsikan bahwa default adalah nama alias dari koneksi Milvus Anda.

   import pymilvus
   
   # A resource group name should be a string of 1 to 255 characters, starting with a letter or an underscore (_) and containing only numbers, letters, and underscores (_).
   name = "rg"
   node_num = 0
   
   # create a resource group that exactly hold no query node.
   try:
       milvus_client.create_resource_group(name, config=ResourceGroupConfig(
           requests={"node_num": node_num},
           limits={"node_num": node_num},
       ))
       print(f"Succeeded in creating resource group {name}.")
   except Exception:
       print("Failed to create the resource group.")
   

2. Membuat daftar grup sumber daya.

   Setelah Anda membuat grup sumber daya, Anda dapat melihatnya di daftar grup sumber daya.

   Untuk melihat daftar grup sumber daya dalam instans Milvus, lakukan hal berikut:

   rgs = milvus_client.list_resource_groups()
   print(f"Resource group list: {rgs}")
   
   # Resource group list: ['__default_resource_group', 'rg']
   

3. Mendeskripsikan sebuah grup sumber daya.

   Anda dapat meminta Milvus mendeskripsikan grup sumber daya yang menjadi perhatian sebagai berikut:

   info = milvus_client.describe_resource_group(name)
   print(f"Resource group description: {info}")
   
   # Resource group description: 
   # ResourceGroupInfo:
   #   <name:rg1>,     // resource group name
   #   <capacity:0>,   // resource group capacity
   #   <num_available_node:1>,  // resource group node num
   #   <num_loaded_replica:{}>, // collection loaded replica num in resource group
   #   <num_outgoing_node:{}>, // node num which still in use by replica in other resource group
   #   <num_incoming_node:{}>, // node num which is in use by replica but belong to other resource group 
   #   <config:{}>,            // resource group config
   #   <nodes:[]>              // node detail info
   

4. Mentransfer node di antara grup sumber daya.

   Anda mungkin memperhatikan bahwa grup sumber daya yang dideskripsikan belum memiliki node kueri. Pindahkan beberapa node dari grup sumber daya default ke grup yang Anda buat sebagai berikut: Asumsikan saat ini ada 1 QueryNodes dalam __default_resource_group pada klaster, dan kita ingin mentransfer satu node ke dalam rg yang telah dibuat.update_resource_groups memastikan atomisitas untuk beberapa perubahan konfigurasi, sehingga tidak ada status peralihan yang akan terlihat oleh Milvus.

   source = '__default_resource_group'
   target = 'rg'
   expected_num_nodes_in_default = 0
   expected_num_nodes_in_rg = 1
   
   try:
       milvus_client.update_resource_groups({
           source: ResourceGroupConfig(
               requests={"node_num": expected_num_nodes_in_default},
               limits={"node_num": expected_num_nodes_in_default},
           ),
           target: ResourceGroupConfig(
               requests={"node_num": expected_num_nodes_in_rg},
               limits={"node_num": expected_num_nodes_in_rg},
           )
       })
       print(f"Succeeded in move 1 node(s) from {source} to {target}.")
   except Exception:
       print("Something went wrong while moving nodes.")
   
   # After a while, succeeded in moving 1 node(s) from __default_resource_group to rg.
   

5. Memuat koleksi dan partisi ke sebuah grup sumber daya.

   Setelah ada node kueri dalam sebuah grup sumber daya, Anda dapat memuat koleksi ke grup sumber daya ini. Cuplikan berikut ini mengasumsikan bahwa koleksi bernama demo sudah ada.

   from pymilvus import Collection
   
   collection_name = "demo"
   
   # Milvus loads the collection to the default resource group.
   milvus_client.load_collection(collection_name, replica_number=2)
   
   # Or, you can ask Milvus load the collection to the desired resource group.
   # make sure that query nodes num should be greater or equal to replica_number
   resource_groups = ['rg']
   milvus_client.load_collection(replica_number=2, _resource_groups=resource_groups) 
   

   Selain itu, Anda juga dapat memuat partisi ke dalam grup sumber daya dan membuat replikanya terdistribusi di antara beberapa grup sumber daya. Berikut ini mengasumsikan bahwa koleksi bernama Books sudah ada dan memiliki partisi bernama Novels.

   collection = "Books"
   partition = "Novels"
   
   # Use the load method of a collection to load one of its partition
   milvus_client.load_partitions(collection, [partition], replica_number=2, _resource_groups=resource_groups)
   

   Perhatikan bahwa _resource_groups adalah parameter opsional, dan jika tidak ditentukan, Milvus akan memuat replika ke node kueri dalam grup sumber daya default.

   Agar Milus memuat setiap replika koleksi dalam grup sumber daya yang terpisah, pastikan jumlah grup sumber daya sama dengan jumlah replika.

6. Mentransfer replika di antara grup sumber daya.

   Milvus menggunakan replika untuk mencapai penyeimbangan beban di antara segmen-segmen yang didistribusikan di beberapa node kueri. Anda dapat memindahkan replika tertentu dari sebuah koleksi dari satu grup sumber daya ke grup sumber daya lainnya sebagai berikut:

   source = '__default_resource_group'
   target = 'rg'
   collection_name = 'c'
   num_replicas = 1
   
   try:
       milvus_client.transfer_replica(source, target, collection_name, num_replicas)
       print(f"Succeeded in moving {num_replicas} replica(s) of {collection_name} from {source} to {target}.")
   except Exception:
       print("Something went wrong while moving replicas.")
   
   # Succeeded in moving 1 replica(s) of c from __default_resource_group to rg.
   

7. Menghapus grup sumber daya.

   Anda dapat menghapus grup sumber daya yang tidak memiliki simpul kueri (limits.node_num = 0) kapan saja. Dalam panduan ini, grup sumber daya rg sekarang memiliki satu simpul kueri. Anda perlu mengubah konfigurasi limits.node_num grup sumber daya menjadi nol terlebih dahulu.

   resource_group = "rg
   try:
       milvus_client.update_resource_groups({
           resource_group: ResourceGroupConfig(
               requests={"node_num": 0},
               limits={"node_num": 0},
           ),
       })
       milvus_client.drop_resource_group(resource_group)
       print(f"Succeeded in dropping {resource_group}.")
   except Exception:
       print(f"Something went wrong while dropping {resource_group}.")
   

Untuk lebih jelasnya, silakan lihat contoh yang relevan di pymilvus

Praktik yang baik untuk mengelola penskalaan cluster

Saat ini, Milvus tidak dapat melakukan penskalaan masuk dan keluar secara mandiri di lingkungan cloud-native. Namun, dengan menggunakan Declarative Resource Group API bersama dengan orkestrasi kontainer, Milvus dapat dengan mudah mencapai isolasi sumber daya dan manajemen untuk QueryNodes. Berikut ini adalah praktik yang baik untuk mengelola QueryNodes di lingkungan cloud:

1. Secara default, Milvus membuat __default_resource_group. Grup sumber daya ini tidak dapat dihapus dan juga berfungsi sebagai grup sumber daya pemuatan default untuk semua koleksi dan QueryNode yang berlebihan selalu ditugaskan ke grup tersebut. Oleh karena itu, kita dapat membuat grup sumber daya yang tertunda untuk menampung sumber daya QueryNode yang tidak digunakan, sehingga sumber daya QueryNode tidak digunakan oleh __default_resource_group.

   Selain itu, jika kita secara ketat menerapkan batasan sum(.requests.nodeNum) <= queryNodeNum, kita dapat secara tepat mengontrol penugasan QueryNode dalam cluster. Mari kita asumsikan saat ini hanya ada satu QueryNode di dalam cluster dan menginisialisasi cluster. Berikut ini adalah contoh pengaturannya:

   from pymilvus.client.types import ResourceGroupConfig
   
   _PENDING_NODES_RESOURCE_GROUP="__pending_nodes"
   
   def init_cluster(node_num: int):
       print(f"Init cluster with {node_num} nodes, all nodes will be put in default resource group")
       # create a pending resource group, which can used to hold the pending nodes that do not hold any data.
       milvus_client.create_resource_group(name=_PENDING_NODES_RESOURCE_GROUP, config=ResourceGroupConfig(
           requests={"node_num": 0}, # this resource group can hold 0 nodes, no data will be load on it.
           limits={"node_num": 10000}, # this resource group can hold at most 10000 nodes 
       ))
   
       # update default resource group, which can used to hold the nodes that all initial node in it.
       milvus_client.update_resource_groups({
           "__default_resource_group": ResourceGroupConfig(
               requests={"node_num": node_num},
               limits={"node_num": node_num},
               transfer_from=[{"resource_group": _PENDING_NODES_RESOURCE_GROUP}], # recover missing node from pending resource group at high priority.
               transfer_to=[{"resource_group": _PENDING_NODES_RESOURCE_GROUP}], # recover redundant node to pending resource group at low priority.
           )})
       milvus_client.create_resource_group(name="rg1", config=ResourceGroupConfig(
           requests={"node_num": 0},
           limits={"node_num": 0},
           transfer_from=[{"resource_group": _PENDING_NODES_RESOURCE_GROUP}], 
           transfer_to=[{"resource_group": _PENDING_NODES_RESOURCE_GROUP}],
       ))
       milvus_client.create_resource_group(name="rg2", config=ResourceGroupConfig(
           requests={"node_num": 0},
           limits={"node_num": 0},
           transfer_from=[{"resource_group": _PENDING_NODES_RESOURCE_GROUP}], 
           transfer_to=[{"resource_group": _PENDING_NODES_RESOURCE_GROUP}],
       ))
   
   init_cluster(1)
   

   Dengan menggunakan contoh kode di atas, kita membuat grup sumber daya bernama __pending_nodes untuk menampung QueryNode tambahan. Kita juga membuat dua Resource Group khusus pengguna bernama rg1 dan rg2. Selain itu, kami memastikan bahwa grup sumber daya lainnya memprioritaskan pemulihan QueryNode yang hilang atau berlebihan dari __pending_nodes.

2. Skala klaster

   Anggaplah kita memiliki fungsi penskalaan berikut ini:

   
   def scale_to(node_num: int):
       # scale the querynode number in Milvus into node_num.
       pass
   

   Kita dapat menggunakan API untuk menskalakan kelompok sumber daya tertentu ke sejumlah QueryNode yang ditentukan tanpa memengaruhi kelompok sumber daya lainnya.

   # scale rg1 into 3 nodes, rg2 into 1 nodes
   milvus_client.update_resource_groups({
       "rg1": ResourceGroupConfig(
           requests={"node_num": 3},
           limits={"node_num": 3},
           transfer_from=[{"resource_group": _PENDING_NODES_RESOURCE_GROUP}],
           transfer_to=[{"resource_group": _PENDING_NODES_RESOURCE_GROUP}],
       ),
       "rg2": ResourceGroupConfig(
           requests={"node_num": 1},
           limits={"node_num": 1},
           transfer_from=[{"resource_group": _PENDING_NODES_RESOURCE_GROUP}],
           transfer_to=[{"resource_group": _PENDING_NODES_RESOURCE_GROUP}],
       ),
   })
   scale_to(5)
   # rg1 has 3 nodes, rg2 has 1 node, __default_resource_group has 1 node.
   

3. Skala cluster masuk

   Demikian pula, kita dapat membuat aturan penskalaan yang memprioritaskan pemilihan QueryNode dari kelompok sumber daya __pending_nodes. Informasi ini dapat diperoleh melalui API describe_resource_group. Mencapai tujuan penskalaan pada kelompok sumber daya tertentu.

   # scale rg1 from 3 nodes into 2 nodes
   milvus_client.update_resource_groups({
       "rg1": ResourceGroupConfig(
           requests={"node_num": 2},
           limits={"node_num": 2},
           transfer_from=[{"resource_group": _PENDING_NODES_RESOURCE_GROUP}],
           transfer_to=[{"resource_group": _PENDING_NODES_RESOURCE_GROUP}],
       ),
   })
   
   # rg1 has 2 nodes, rg2 has 1 node, __default_resource_group has 1 node, __pending_nodes has 1 node.
   scale_to(4)
   # scale the node in __pending_nodes
   

Bagaimana kelompok sumber daya berinteraksi dengan beberapa replika

• Replika dari satu koleksi dan kelompok sumber daya memiliki hubungan N-ke-N.
• Ketika beberapa replika dari satu koleksi dimuat ke dalam satu kelompok sumber daya, QueryNode dari kelompok sumber daya tersebut didistribusikan secara merata di antara replika, memastikan bahwa perbedaan jumlah QueryNode yang dimiliki setiap replika tidak melebihi 1.

Selanjutnya

Untuk menerapkan instans Milvus multi-penyewa, baca yang berikut ini:

• Mengaktifkan RBAC
• Pengguna dan peran