Gestionar particiones
Esta guía le explica cómo crear y gestionar particiones en una colección.
Visión general
Una partición en Milvus representa una subdivisión de una colección. Esta funcionalidad permite dividir el almacenamiento físico de una colección en múltiples partes, lo que contribuye a mejorar el rendimiento de las consultas al limitar el enfoque a un subconjunto más pequeño de datos en lugar de a toda la colección.
Al crear una colección, se crea automáticamente al menos una partición por defecto denominada _default. Puede crear un máximo de 1.024 particiones dentro de una colección.
notas
Milvus introduce una característica llamada Partition Key, que aprovecha las particiones subyacentes para almacenar entidades basadas en los valores hash de un campo específico. Esta característica facilita la implementación de multi-tenancy, mejorando el rendimiento de la búsqueda. Para más información, consulte Utilizar la clave de partición.
Si la función Partition Key está activada en una colección, Milvus se encarga de gestionar todas las particiones, liberándole a usted de esta responsabilidad.
Preparativos
El fragmento de código a continuación reutiliza el código existente para establecer una conexión con Milvus y crear una colección en un modo de preparación rápida, indicando que la colección se carga al crearse.
Para los preparativos, utilice MilvusClient
para conectarse a Milvus y create_collection()
para crear una colección en modo de configuración rápida.
Para las preparaciones, utilice MilvusClientV2
para conectarse a Milvus y createCollection()
para crear una colección en modo de configuración rápida.
Para los preparativos, utilice MilvusClient
para conectarse a Milvus y createCollection()
para crear una colección en modo de configuración rápida.
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,
});
notas
En el fragmento de código anterior, el índice de la colección se ha creado junto con la colección, lo que indica que la colección se carga en el momento de la creación.
Listar particiones
Una vez que la colección está lista, puedes listar sus particiones.
Para listar particiones, utilice list_partitions()
.
Para listar particiones, utilice listPartitions()
.
Para listar particiones, utilice 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' ]
//
La salida del fragmento de código anterior incluye los nombres de las particiones dentro de la colección especificada.
notas
Si ha establecido un campo como clave de partición en una colección, Milvus crea al menos 64 particiones junto con la colección. Al listar las particiones, los resultados pueden diferir de la salida de los fragmentos de código anteriores.
Para más detalles, consulte Utilizar clave de partición.
Crear particiones
Puede añadir más particiones a la colección. Una colección puede tener hasta 1.024 particiones.
Para crear particiones, utilice create_partition()
.
Para crear particiones, utilice createPartition()
.
Para crear particiones, utilice 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' ]
//
El fragmento de código anterior crea una partición en una colección y lista las particiones de la colección.
notas
Si ha establecido un campo como clave de partición en una colección, Milvus se encarga de gestionar las particiones de la colección. Por lo tanto, es posible que se produzcan errores al intentar crear particiones.
Para más detalles, consulte Utilizar clave de partición.
Comprobar la existencia de una partición específica
También puede comprobar la existencia de una partición específica.
Para comprobar la existencia de una partición específica, utilice has_partition()
.
Para buscar una partición específica, utilice hasPartition()
.
Para buscar una partición específica, utilice 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
//
El fragmento de código anterior comprueba si la colección tiene una partición llamada partitionA
y partitionC
.
Cargar y liberar particiones
Puedes cargar y liberar particiones específicas para hacerlas disponibles o no para búsquedas y consultas.
Obtener el estado de carga
Para comprobar el estado de carga de una colección y sus particiones, utilice get_load_state()
.
Para comprobar el estado de carga de una colección y sus particiones, utilice getLoadState()
.
Para comprobar el estado de carga de una colección y sus particiones, utilice 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
//
Los posibles estados de carga pueden ser
Cargada
Una colección se marca como
Loaded
si al menos una de sus particiones se ha cargado.NoCargado
Una colección se marca como
NotLoad
si no se ha cargado ninguna de sus particiones.Cargando
Una colección se marca como Cargando si al menos una de sus particiones está en proceso de carga.
Cargar particiones
Para cargar todas las particiones de una colección, basta con llamar al comando load_collection()
. Para cargar particiones específicas de una colección, utilice load_partitions()
.
Para cargar todas las particiones de una colección, basta con llamar a loadCollection()
. Para cargar particiones específicas de una colección, utilice loadPartitions()
.
Para cargar todas las particiones de una colección, basta con llamar a loadCollection()
. Para cargar particiones específicas de una colección, utilice 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
//
Para cargar múltiples particiones a la vez, haz lo siguiente:
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
//
Para cargar campos específicos en una o más particiones, haga lo siguiente:
client.load_partitions(
collection_name="quick_setup",
partition_names=["partitionA"],
load_fields=["id", "vector"],
skip_load_dynamic_field=True
)
Tenga en cuenta que sólo los campos listados en load_fields
pueden utilizarse como condiciones de filtrado y campos de salida en búsquedas y consultas. Debe incluir siempre la clave primaria en la lista. Los nombres de campo excluidos de la carga no estarán disponibles para el filtrado o la salida.
Puede utilizar skip_load_dynamic_field=True
para omitir la carga del campo dinámico. Milvus trata el campo dinámico como un único campo, por lo que todas las claves del campo dinámico se incluirán o excluirán juntas.
Liberar particiones
Para liberar todas las particiones de una colección, basta con llamar a release_collection()
. Para liberar particiones específicas de una colección, utilice release_partitions()
.
Para liberar todas las particiones de una colección, basta con llamar a releaseCollection()
. Para liberar particiones específicas de una colección, utilice releasePartitions()
.
Para liberar todas las particiones de una colección, basta con llamar a releaseCollection()
. Para liberar particiones específicas de una colección, utilice 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
//
Para liberar múltiples particiones a la vez, haz lo siguiente:
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>"
# }
Liberar particiones
Una vez liberada una partición, puede eliminarla si ya no la necesita.
Para eliminar una partición, utilice drop_partition()
.
Para soltar una partición, utilice dropPartition()
.
Para soltar una partición, utilice 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'
// }
//
notas
Antes de eliminar una partición, debes liberarla de la memoria.
PREGUNTAS FRECUENTES
¿Cuántos datos se pueden almacenar en una partición?
Se recomienda almacenar menos de 1B de datos en una partición.
¿Cuál es el número máximo de particiones que se pueden crear?
Por defecto, Milvus permite crear un máximo de 1.024 particiones. Puede ajustar el número máximo de particiones configurando
rootCoord.maxPartitionNum
. Para más detalles, consulte Configuraciones del sistema.¿Cómo puedo diferenciar entre particiones y claves de partición?
Las particiones son unidades físicas de almacenamiento, mientras que las claves de partición son conceptos lógicos que asignan automáticamente datos a particiones específicas basándose en una columna designada.
Por ejemplo, en Milvus, si tiene una colección con una clave de partición definida como el campo
color
, el sistema asigna automáticamente los datos a las particiones basándose en los valores hash del campocolor
para cada entidad. Este proceso automatizado libera al usuario de la responsabilidad de especificar manualmente la partición al insertar o buscar datos.Por otro lado, cuando se crean particiones manualmente, es necesario asignar datos a cada partición basándose en los criterios de la clave de partición. Si tiene una colección con un campo
color
, asignaría manualmente las entidades con un valorcolor
dered
apartition A
, y las entidades con un valorcolor
deblue
apartition B
. Esta gestión manual requiere más esfuerzo.En resumen, tanto las particiones como las claves de partición se utilizan para optimizar el cálculo de datos y mejorar la eficiencia de las consultas. Es esencial reconocer que habilitar una clave de partición significa renunciar al control sobre la gestión manual de la inserción y carga de datos de partición, ya que estos procesos están totalmente automatizados y son gestionados por Milvus.