Acerca de Milvus
Comenzar
Conceptos
Guía del usuario
Modelos
Migración Milvus
Guía de administración
Herramientas
Integraciones
Tutoriales
Preguntas frecuentes
API Reference

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.

Python Java Node.js

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().

Python Java Node.js

# 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().

Python Java Node.js

# 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().

Python Java Node.js

# 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().

Python Java Node.js

# 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().

Python Java Node.js

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:

Python Java Node.js

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().

Python Java Node.js

# 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().

Python Java Node.js

# 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 campo color 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 valor color de red a partition A, y las entidades con un valor color de blue a partition 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.

Traducido por DeepLogo

Tabla de contenidos

Gestionar particiones
Visión general
Preparativos
Listar particiones
Crear particiones
Comprobar la existencia de una partición específica
Cargar y liberar particiones
Liberar particiones
PREGUNTAS FRECUENTES

Try Managed Milvus for Free

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

Get Started

Feedback

¿Fue útil esta página?