milvus-logo
LFAI
Home
  • Guide de l'utilisateur

Gérer les partitions

Ce guide vous explique comment créer et gérer des partitions dans une collection.

Vue d'ensemble

Dans Milvus, une partition représente une sous-division d'une collection. Cette fonctionnalité permet de diviser le stockage physique d'une collection en plusieurs parties, ce qui contribue à améliorer les performances des requêtes en se concentrant sur un sous-ensemble de données plus petit plutôt que sur l'ensemble de la collection.

Lors de la création d'une collection, au moins une partition par défaut nommée _default est automatiquement créée. Vous pouvez créer un maximum de 1 024 partitions dans une collection.

notes

Milvus introduit une fonctionnalité appelée Clé de partition, qui exploite les partitions sous-jacentes pour stocker des entités sur la base des valeurs hachées d'un champ spécifique. Cette fonctionnalité facilite la mise en œuvre de la multi-location, améliorant ainsi les performances de recherche. Pour plus d'informations, lisez Utiliser la clé de partition.

Si la fonction Clé de partition est activée dans une collection, Milvus prend en charge la gestion de toutes les partitions, vous déchargeant ainsi de cette responsabilité.

Préparations

L'extrait de code ci-dessous reprend le code existant pour établir une connexion avec Milvus et créer une collection dans un mode de configuration rapide, indiquant que la collection est chargée lors de la création.

Pour les préparations, utilisez MilvusClient pour se connecter à Milvus et create_collection() pour créer une collection en mode d'installation rapide.

Pour les préparations, utilisez MilvusClientV2 pour se connecter à Milvus et createCollection() pour créer une collection en mode installation rapide.

Pour les préparations, utilisez MilvusClient pour se connecter à Milvus et createCollection() pour créer une collection en mode installation rapide.

from pymilvus import MilvusClient, DataType

# 1. Set up a Milvus client
client = MilvusClient(
    uri="http://localhost:19530"
)

# 2. Create a collection
client.create_collection(
    collection_name="quick_setup",
    dimension=5,
)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

String CLUSTER_ENDPOINT = "http://localhost:19530";

// 1. Connect to Milvus server
ConnectConfig connectConfig = ConnectConfig.builder()
    .uri(CLUSTER_ENDPOINT)
    .build();

MilvusClientV2 client = new MilvusClientV2(connectConfig);

// 2. Create a collection in quick setup mode
CreateCollectionReq quickSetupReq = CreateCollectionReq.builder()
    .collectionName("quick_setup")
    .dimension(5)
    .build();

client.createCollection(quickSetupReq);
const address = "http://localhost:19530"

// 1. Set up a Milvus Client
client = new MilvusClient({address});

// 2. Create a collection in quick setup mode
await client.createCollection({
    collection_name: "quick_setup",
    dimension: 5,
});  

Remarques

Dans l'extrait de code ci-dessus, l'index de la collection a été créé en même temps que la collection, ce qui indique que la collection est chargée lors de la création.

Lister les partitions

Une fois qu'une collection est prête, vous pouvez dresser la liste de ses partitions.

Pour lister les partitions, utilisez list_partitions().

Pour lister les partitions, utilisez listPartitions().

Pour répertorier les partitions, utilisez listPartitions().

# 3. List partitions
res = client.list_partitions(collection_name="quick_setup")
print(res)

# Output
#
# ["_default"]
import io.milvus.v2.service.partition.request.ListPartitionsReq;

// 3. List all partitions in the collection
ListPartitionsReq listPartitionsReq = ListPartitionsReq.builder()
    .collectionName("quick_setup")
    .build();

List<String> partitionNames = client.listPartitions(listPartitionsReq);

System.out.println(partitionNames);

// Output:
// ["_default"]
// 3. List partitions
res = await client.listPartitions({
    collection_name: "quick_setup"
})

console.log(res.partition_names)

// Output
// 
// [ '_default' ]
// 

Le résultat de l'extrait de code ci-dessus comprend les noms des partitions de la collection spécifiée.

notes

Si vous avez défini un champ comme clé de partition dans une collection, Milvus crée au moins 64 partitions avec la collection. Lors de l'énumération des partitions, les résultats peuvent différer de la sortie des extraits de code ci-dessus.

Pour plus de détails, reportez-vous à la section Utiliser une clé de partition.

Créer des partitions

Vous pouvez ajouter des partitions à la collection. Une collection peut comporter jusqu'à 1 024 partitions.

Pour créer des partitions, utilisez create_partition().

Pour créer des partitions, utilisez createPartition().

Pour créer des partitions, utilisez createPartition().

# 4. Create more partitions
client.create_partition(
    collection_name="quick_setup",
    partition_name="partitionA"
)

client.create_partition(
    collection_name="quick_setup",
    partition_name="partitionB"
)

res = client.list_partitions(collection_name="quick_setup")
print(res)

# Output
#
# ["_default", "partitionA", "partitionB"]
import io.milvus.v2.service.partition.request.CreatePartitionReq;

// 4. Create more partitions
CreatePartitionReq createPartitionReq = CreatePartitionReq.builder()
    .collectionName("quick_setup")
    .partitionName("partitionA")
    .build();

client.createPartition(createPartitionReq);

createPartitionReq = CreatePartitionReq.builder()
    .collectionName("quick_setup")
    .partitionName("partitionB")
    .build();

client.createPartition(createPartitionReq);

listPartitionsReq = ListPartitionsReq.builder()
    .collectionName("quick_setup")
    .build();

partitionNames = client.listPartitions(listPartitionsReq);

System.out.println(partitionNames);

// Output:
// [
//     "_default",
//     "partitionA",
//     "partitionB"
// ]
// 4. Create more partitions
await client.createPartition({
    collection_name: "quick_setup",
    partition_name: "partitionA"
})

await client.createPartition({
    collection_name: "quick_setup",
    partition_name: "partitionB"
})

res = await client.listPartitions({
    collection_name: "quick_setup"
})

console.log(res.partition_names)

// Output
// 
// [ '_default', 'partitionA', 'partitionB' ]
// 

L'extrait de code ci-dessus crée une partition dans une collection et répertorie les partitions de la collection.

notes

Si vous avez défini un champ comme clé de partition dans une collection, Milvus se charge de gérer les partitions dans la collection. Par conséquent, vous pouvez rencontrer des erreurs d'invite lorsque vous tentez de créer des partitions.

Pour plus de détails, voir Utiliser la clé de partition.

Vérification de l'existence d'une partition spécifique

Vous pouvez également vérifier l'existence d'une partition spécifique.

Pour vérifier l'existence d'une partition spécifique, utilisez has_partition().

Pour vérifier l'existence d'une partition spécifique, utilisez hasPartition().

Pour vérifier l'existence d'une partition spécifique, utilisez hasPartition().

# 5. Check whether a partition exists
res = client.has_partition(
    collection_name="quick_setup",
    partition_name="partitionA"
)
print(res)

# Output
#
# True

res = client.has_partition(
    collection_name="quick_setup",
    partition_name="partitionC"
)
print(res)

# Output
#
# False
import io.milvus.v2.service.partition.request.HasPartitionReq;

// 5. Check whether a partition exists
HasPartitionReq hasPartitionReq = HasPartitionReq.builder()
    .collectionName("quick_setup")
    .partitionName("partitionA")
    .build();

boolean exists = client.hasPartition(hasPartitionReq);

System.out.println(exists);

// Output:
// true

hasPartitionReq = HasPartitionReq.builder()
    .collectionName("quick_setup")
    .partitionName("partitionC")
    .build();

exists = client.hasPartition(hasPartitionReq);

System.out.println(exists);

// Output:
// false
// 5. Check whether a partition exists
res = await client.hasPartition({
    collection_name: "quick_setup",
    partition_name: "partitionA"
})

console.log(res.value)

// Output
// 
// true
// 

res = await client.hasPartition({
    collection_name: "quick_setup",
    partition_name: "partitionC"
})

console.log(res.value)

// Output
// 
// false
// 

L'extrait de code ci-dessus vérifie si la collection possède une partition nommée partitionA et partitionC.

Charger et libérer des partitions

Vous pouvez charger et libérer des partitions spécifiques pour les rendre disponibles ou non pour les recherches et les requêtes.

Obtenir l'état de chargement

Pour vérifier l'état de chargement d'une collection et de ses partitions, utilisez la commande get_load_state().

Pour vérifier l'état de charge d'une collection et de ses partitions, utilisez la commande getLoadState().

Pour vérifier l'état de charge d'une collection et de ses partitions, utilisez la commande getLoadState().

# Release the collection
client.release_collection(collection_name="quick_setup")

# Check the load status
res = client.get_load_state(collection_name="quick_setup")
print(res)

# Output
#
# {
#     "state": "<LoadState: Loaded>"
# }

res = client.get_load_state(
    collection_name="quick_setup", 
    partition_name="partitionA"
)

print(res)

# Output
#
# {
#     "state": "<LoadState: Loaded>"
# }

res = client.get_load_state(
    collection_name="quick_setup", 
    partition_name="partitionB"
)

print(res)

# Output
#
# {
#     "state": "<LoadState: NotLoad>"
# }

import io.milvus.v2.service.collection.request.GetLoadStateReq;
import io.milvus.v2.service.collection.request.ReleaseCollectionReq;
import io.milvus.v2.service.partition.request.LoadPartitionsReq;
import io.milvus.v2.service.partition.request.ReleasePartitionsReq;

// 6. Load a partition independantly
// 6.1 Release the collection
ReleaseCollectionReq releaseCollectionReq = ReleaseCollectionReq.builder()
    .collectionName("quick_setup")
    .build();

client.releaseCollection(releaseCollectionReq);

// 6.2 Load partitionA
LoadPartitionsReq loadPartitionsReq = LoadPartitionsReq.builder()
    .collectionName("quick_setup")
    .partitionNames(List.of("partitionA"))
    .build();

client.loadPartitions(loadPartitionsReq);

Thread.sleep(3000);

// 6.3 Check the load status of the collection and its partitions
GetLoadStateReq getLoadStateReq = GetLoadStateReq.builder()
    .collectionName("quick_setup")
    .build();

boolean state = client.getLoadState(getLoadStateReq);

System.out.println(state);

// Output:
// true

getLoadStateReq = GetLoadStateReq.builder()
    .collectionName("quick_setup")
    .partitionName("partitionA")
    .build();

state = client.getLoadState(getLoadStateReq);

System.out.println(state);

// Output:
// true

getLoadStateReq = GetLoadStateReq.builder()
    .collectionName("quick_setup")
    .partitionName("partitionB")
    .build();

state = client.getLoadState(getLoadStateReq);

System.out.println(state);

// Output:
// false
// 6. Load a partition indenpendantly
await client.releaseCollection({
    collection_name: "quick_setup"
})

res = await client.getLoadState({
    collection_name: "quick_setup"
})

console.log(res.state)

// Output
// 
// LoadStateNotLoad
// 

await client.loadPartitions({
    collection_name: "quick_setup",
    partition_names: ["partitionA"]
})

await sleep(3000)

res = await client.getLoadState({
    collection_name: "quick_setup"
})

console.log(res.state)

// Output
// 
// LoadStateLoaded
// 

res = await client.getLoadState({
    collection_name: "quick_setup",
    partition_name: "partitionA"
})

console.log(res.state)

// Output
// 
// LoadStateLoaded
// 

res = await client.getLoadState({
    collection_name: "quick_setup",
    partition_name: "partitionB"
})

console.log(res.state)

// Output
// 
// LoadStateLoaded
// 

L'état de chargement possible peut être l'un des suivants

  • Chargé

    Une collection est marquée comme Loaded si au moins une de ses partitions a été chargée.

  • Non chargé

    Une collection est marquée comme NotLoad si aucune de ses partitions n'a été chargée.

  • Chargement

    Une collection est marquée comme étant en cours de chargement si au moins une de ses partitions est en cours de chargement.

Charger les partitions

Pour charger toutes les partitions d'une collection, il suffit d'appeler load_collection(). Pour charger des partitions spécifiques d'une collection, utilisez load_partitions().

Pour charger toutes les partitions d'une collection, il suffit d'appeler loadCollection(). Pour charger des partitions spécifiques d'une collection, utilisez loadPartitions().

Pour charger toutes les partitions d'une collection, il suffit d'appeler loadCollection(). Pour charger des partitions spécifiques d'une collection, utilisez loadPartitions().

client.load_partitions(
    collection_name="quick_setup",
    partition_names=["partitionA"]
)

res = client.get_load_state(collection_name="quick_setup")
print(res)

# Output
#
# {
#     "state": "<LoadState: Loaded>"
# }
LoadPartitionsReq loadPartitionsReq = LoadPartitionsReq.builder()
    .collectionName("quick_setup")
    .partitionNames(List.of("partitionA"))
    .build();

client.loadPartitions(loadPartitionsReq);

getLoadStateReq = GetLoadStateReq.builder()
    .collectionName("quick_setup")
    .partitionName("partitionA")
    .build();

state = client.getLoadState(getLoadStateReq);

System.out.println(state);

// Output:
// true
await client.loadPartitions({
    collection_name: "quick_setup",
    partition_names: ["partitionA"]
})

res = await client.getLoadState({
    collection_name: "quick_setup",
    partition_name: "partitionA"
})

console.log(res.state)

// Output
// 
// LoadStateLoaded
//

Pour charger plusieurs partitions à la fois, procédez comme suit :

client.load_partitions(
    collection_name="quick_setup",
    partition_names=["partitionA", "partitionB"]
)

res = client.get_load_state(
    collection_name="quick_setup",
    partition_name="partitionA"
)

# Output
#
# {
#     "state": "<LoadState: Loaded>"
# }

res = client.get_load_state(
    collection_name="quick_setup",
    partition_name="partitionB"
)

# Output
#
# {
#     "state": "<LoadState: Loaded>"
# }
LoadPartitionsReq loadPartitionsReq = LoadPartitionsReq.builder()
    .collectionName("quick_setup")
    .partitionNames(List.of("partitionA", "partitionB"))
    .build();

client.loadPartitions(loadPartitionsReq);

getLoadStateReq = GetLoadStateReq.builder()
    .collectionName("quick_setup")
    .partitionName("partitionA")
    .build();

state = client.getLoadState(getLoadStateReq);

System.out.println(state);

// Output:
// true

getLoadStateReq = GetLoadStateReq.builder()
    .collectionName("quick_setup")
    .partitionName("partitionB")
    .build();

state = client.getLoadState(getLoadStateReq);

System.out.println(state);

// Output:
// true
await client.loadPartitions({
    collection_name: "quick_setup",
    partition_names: ["partitionA", "partitionB"]
})

res = await client.getLoadState({
    collection_name: "quick_setup",
    partition_name: "partitionA"
})

console.log(res)

// Output
// 
// LoadStateLoaded
// 

res = await client.getLoadState({
    collection_name: "quick_setup",
    partition_name: "partitionB"
})

console.log(res)

// Output
// 
// LoadStateLoaded
// 

Pour charger des champs spécifiques dans une ou plusieurs partitions, procédez comme suit :

client.load_partitions(
    collection_name="quick_setup",
    partition_names=["partitionA"],
    load_fields=["id", "vector"],
    skip_load_dynamic_field=True
)

Notez que seuls les champs répertoriés dans load_fields peuvent être utilisés comme conditions de filtrage et champs de sortie dans les recherches et les requêtes. Vous devez toujours inclure la clé primaire dans la liste. Les noms de champs exclus du chargement ne seront pas disponibles pour le filtrage ou la sortie.

Vous pouvez utiliser skip_load_dynamic_field=True pour ne pas charger le champ dynamique. Milvus traite le champ dynamique comme un champ unique, de sorte que toutes les clés du champ dynamique seront incluses ou exclues ensemble.

Libération des partitions

Pour libérer toutes les partitions d'une collection, il suffit d'appeler release_collection(). Pour libérer des partitions spécifiques d'une collection, utilisez release_partitions().

Pour libérer toutes les partitions d'une collection, il suffit d'appeler releaseCollection(). Pour libérer des partitions spécifiques d'une collection, utilisez releasePartitions().

Pour libérer toutes les partitions d'une collection, il suffit d'appeler releaseCollection(). Pour libérer des partitions spécifiques d'une collection, utilisez releasePartitions().

# 7. Release a partition
client.release_partitions(
    collection_name="quick_setup",
    partition_names=["partitionA"]
)

res = client.get_load_state(
    collection_name="quick_setup", 
    partition_name="partitionA"
)

print(res)

# Output
#
# {
#     "state": "<LoadState: NotLoad>"
# }

import io.milvus.v2.service.partition.request.ReleasePartitionsReq;

// 7. Release a partition
ReleasePartitionsReq releasePartitionsReq = ReleasePartitionsReq.builder()
    .collectionName("quick_setup")
    .partitionNames(List.of("partitionA"))
    .build();

client.releasePartitions(releasePartitionsReq);

getLoadStateReq = GetLoadStateReq.builder()
    .collectionName("quick_setup")
    .partitionName("partitionA")
    .build();

state = client.getLoadState(getLoadStateReq);

System.out.println(state);

// Output:
// false
// 7. Release a partition
await client.releasePartitions({
    collection_name: "quick_setup",
    partition_names: ["partitionA"]
})

res = await client.getLoadState({
    collection_name: "quick_setup"
})

console.log(res.state)

// Output
// 
// LoadStateNotLoad
// 

Pour libérer plusieurs partitions à la fois, procédez comme suit :

client.release_partitions(
    collection_name="quick_setup",
    partition_names=["_default", "partitionA", "partitionB"]
)

res = client.get_load_state(
    collection_name="quick_setup",
)

# Output
#
# {
#     "state": "<LoadState: NotLoad>"
# }

Abandonner des partitions

Une fois que vous avez libéré une partition, vous pouvez la supprimer si elle n'est plus nécessaire.

Pour supprimer une partition, utilisez drop_partition().

Pour supprimer une partition, utilisez dropPartition().

Pour déposer une partition, utilisez dropPartition().

# 8. Drop a partition
client.drop_partition(
    collection_name="quick_setup",
    partition_name="partitionB"
)

res = client.list_partitions(collection_name="quick_setup")
print(res)

# Output
#
# ["_default", "partitionA"]
import io.milvus.v2.service.partition.request.ReleasePartitionsReq;

ReleasePartitionsReq releasePartitionsReq = ReleasePartitionsReq.builder()
    .collectionName("quick_setup")
    .partitionNames(List.of("_default", "partitionA", "partitionB"))
    .build();

client.releasePartitions(releasePartitionsReq);

getLoadStateReq = GetLoadStateReq.builder()
    .collectionName("quick_setup")
    .build();

state = client.getLoadState(getLoadStateReq);

System.out.println(state);

// Output:
// false

await client.releasePartitions({
    collection_name: "quick_setup",
    partition_names: ["_default", "partitionA", "partitionB"]
})

res = await client.getLoadState({
    collection_name: "quick_setup"
})

console.log(res)

// Output
// 
// {
//   status: {
//     error_code: 'Success',
//     reason: '',
//     code: 0,
//     retriable: false,
//     detail: ''
//   },
//   state: 'LoadStateNotLoad'
// }
// 

Remarques

Avant d'abandonner une partition, vous devez la libérer de la mémoire.

FAQ

  • Combien de données peuvent être stockées dans une partition ?

    Il est recommandé de stocker moins de 1B de données dans une partition.

  • Quel est le nombre maximum de partitions pouvant être créées ?

    Par défaut, Milvus permet de créer un maximum de 1 024 partitions. Vous pouvez ajuster le nombre maximum de partitions en configurant rootCoord.maxPartitionNum. Pour plus de détails, voir Configurations du système.

  • Comment puis-je faire la différence entre les partitions et les clés de partition ?

    Les partitions sont des unités de stockage physiques, tandis que les clés de partition sont des concepts logiques qui affectent automatiquement les données à des partitions spécifiques en fonction d'une colonne désignée.

    Par exemple, dans Milvus, si vous avez une collection dont la clé de partition est définie comme le champ color, le système affecte automatiquement les données aux partitions en fonction des valeurs hachées du champ color pour chaque entité. Ce processus automatisé libère l'utilisateur de la responsabilité de spécifier manuellement la partition lors de l'insertion ou de la recherche de données.

    En revanche, lorsque vous créez manuellement des partitions, vous devez affecter des données à chaque partition en fonction des critères de la clé de partition. Si vous avez une collection avec un champ color, vous devez affecter manuellement les entités dont la valeur color est red à partition A, et les entités dont la valeur color est blue à partition B. Cette gestion manuelle demande plus d'efforts.

    En résumé, les partitions et les clés de partition sont utilisées pour optimiser le calcul des données et améliorer l'efficacité des requêtes. Il est essentiel de reconnaître que l'activation d'une clé de partition signifie l'abandon du contrôle de la gestion manuelle de l'insertion et du chargement des données de partition, car ces processus sont entièrement automatisés et gérés par Milvus.

Traduit parDeepL

Try Managed Milvus for Free

Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.

Get Started
Feedback

Cette page a-t - elle été utile ?