Gérer les instantanésCompatible with Milvus 3.0.x

Dans ce guide, vous apprendrez à créer et à gérer des instantanés.

Créer un instantané

Avant de créer un instantané, il est conseillé d'arrêter d'écrire des données dans la collection cible et d'appeler flush() pour éviter toute perte de données.

Lorsque vous nommez un instantané, utilisez des noms clairs et descriptifs, tels que "daily_backup_20240101" ou "v2.1_production_release", et évitez les termes génériques, tels que "backup1" et "test". Utilisez les noms d'instantanés à bon escient pour distinguer les instantanés entre les versions, les environnements et les étapes.

Les exemples de code ci-dessous supposent que vous disposez déjà d'une collection nommée my_collection.

from pymilvus import MilvusClient

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

# Recommended: Flush data before creating snapshot to ensure all data is included
client.flush(collection_name="my_collection")

# Create snapshot for entire collection
client.create_snapshot(
    collection_name="my_collection",
    snapshot_name="backup_20240101",
    description="Daily backup for January 1st, 2024"
)

// java

import (
    "context"
    "github.com/milvus-io/milvus/client/v2/milvusclient"
)

client, err := milvusclient.New(context.Background(), &milvusclient.ClientConfig{
    Address: "localhost:19530",
    Token: "root:Milvus",
})

// Recommended: Flush data before creating snapshot to ensure all data is included
err = client.Flush(context.Background(), milvusclient.NewFlushOption("my_collection"))
if err != nil {
    log.Fatal(err)
}

// Create snapshot
createOpt := milvusclient.NewCreateSnapshotOption("backup_20240101", "my_collection").
    WithDescription("Daily backup for January 1st, 2024")

err = client.CreateSnapshot(context.Background(), createOpt)

// node.js

# restful

Lister les instantanés

Vous pouvez dresser la liste des noms des instantanés existants.

# List all snapshots for a collection
snapshots = client.list_snapshots(
    collection_name="my_collection"
)

// java

// List snapshots for collection
listOpt := milvusclient.NewListSnapshotsOption().
    WithCollectionName("my_collection")

snapshots, err := client.ListSnapshots(context.Background(), listOpt)

// node.js

# bash

Décrire un instantané

Vous pouvez obtenir des informations détaillées sur un instantané spécifique.

snapshot_info = client.describe_snapshot(
    snapshot_name="backup_20240101",
    include_collection_info=True
)

print(f"Snapshot ID: {snapshot_info.id}")
print(f"Collection: {snapshot_info.collection_name}")
print(f"Created: {snapshot_info.create_ts}")
print(f"Description: {snapshot_info.description}")

// java

describeOpt := milvusclient.NewDescribeSnapshotOption("backup_20240101")
resp, err := client.DescribeSnapshot(context.Background(), describeOpt)

fmt.Printf("Snapshot ID: %d\n", resp.GetSnapshotInfo().GetId())
fmt.Printf("Collection: %s\n", resp.GetSnapshotInfo().GetCollectionName())

// node.js

# restful

Restaurer un instantané

Vous pouvez restaurer un instantané dans une nouvelle collection. Cette opération est asynchrone et renvoie un identifiant de travail permettant de suivre la progression de la restauration.

La restauration utilise un mécanisme de copie de segments au lieu d'une importation de données, ce qui est plus efficace car cela permet de

• copie directement les fichiers de segments (binlogs, deltalogs, fichiers d'index) à partir du stockage d'instantanés

• préserve les identifiants des champs et des index pour assurer la compatibilité avec les fichiers de données existants

• évite la réécriture des données et la reconstruction des index, ce qui accélère considérablement les temps de restauration, et

• garantit une augmentation des performances de 10 à 100 fois par rapport aux méthodes de sauvegarde et de restauration traditionnelles.

Pour restaurer un instantané, procédez comme suit :

# Restore snapshot to new collection
job_id = client.restore_snapshot(
    snapshot_name="backup_20240101",
    collection_name="restored_collection",
)

// java

restoreOpt := milvusclient.NewRestoreSnapshotOption(
    "backup_20240101",
    "restored_collection"
)

jobID, err := client.RestoreSnapshot(context.Background(), restoreOpt)
if err != nil {
    log.Fatal(err)
}

// node.js

# restful

Pour plus d'informations sur la surveillance de la progression d'une tâche de restauration, reportez-vous à la section Surveillance de la progression de la restauration.

Abandonner un instantané

Vous pouvez abandonner un instantané s'il n'est plus nécessaire. Il est conseillé de supprimer régulièrement les anciens clichés pour économiser de l'espace de stockage.

client.drop_snapshot(
    snapshot_name="backup_20240101"
)

// java

dropOpt := milvusclient.NewDropSnapshotOption("backup_20240101")
err := client.DropSnapshot(context.Background(), dropOpt)

// node.js

# restful

Liste des travaux de restauration

Vous pouvez utiliser cette API pour obtenir une liste des instantanés déjà créés pour la collection cible.

# List all restore jobs
jobs = client.list_restore_snapshot_jobs()

for job in jobs:
    print(f"Job {job.job_id}: {job.snapshot_name} -> Collection {job.collection_id}")
    print(f"  State: {job.state}, Progress: {job.progress}%")

# List restore jobs for a specific collection
jobs = client.list_restore_snapshot_jobs(collection_name="my_collection")

// java

// List all restore jobs
listOpt := milvusclient.NewListRestoreSnapshotJobsOption()
jobs, err := client.ListRestoreSnapshotJobs(context.Background(), listOpt)
if err != nil {
    log.Fatal(err)
}

for _, job := range jobs {
    fmt.Printf("Job %d: %s -> Collection %d\n",
        job.GetJobId(), job.GetSnapshotName(), job.GetCollectionId())
    fmt.Printf("  State: %s, Progress: %d%%\n",
        job.GetState(), job.GetProgress())
}

// List restore jobs for a specific collection
listOpt = milvusclient.NewListRestoreSnapshotJobsOption().
    WithCollectionName("my_collection")
jobs, err = client.ListRestoreSnapshotJobs(context.Background(), listOpt)

// node.js

# restful

Obtenir l'état de la restauration

Une fois que vous avez l'identifiant d'un travail de restauration, vous pouvez l'utiliser pour récupérer l'état d'avancement de la restauration.

state = client.get_restore_snapshot_state(job_id=12345)

print(f"Job ID: {state.job_id}")
print(f"Snapshot Name: {state.snapshot_name}")
print(f"Collection ID: {state.collection_id}")
print(f"State: {state.state}")
print(f"Progress: {state.progress}%")
if state.state == "RestoreSnapshotFailed":
    print(f"Failure Reason: {state.reason}")
print(f"Time Cost: {state.time_cost}ms")

// java

stateOpt := milvusclient.NewGetRestoreSnapshotStateOption(12345)
state, err := client.GetRestoreSnapshotState(context.Background(), stateOpt)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Job ID: %d\n", state.GetJobId())
fmt.Printf("Snapshot Name: %s\n", state.GetSnapshotName())
fmt.Printf("Collection ID: %d\n", state.GetCollectionId())
fmt.Printf("State: %s\n", state.GetState())
fmt.Printf("Progress: %d%%\n", state.GetProgress())
if state.GetState() == milvuspb.RestoreSnapshotState_RestoreSnapshotFailed {
    fmt.Printf("Failure Reason: %s\n", state.GetReason())
}
fmt.Printf("Time Cost: %dms\n", state.GetTimeCost())

// node.js

# restful