Gestione degli snapshotCompatible with Milvus 3.0.x

In questa guida imparerai come creare e gestire le istantanee, tra cui

• Creare uno snapshot,
• Elencare gli snapshot,
• Descrivere uno snapshot,
• Fissare/sbloccare i dati di uno snapshot,
• ripristinare uno snapshot,
• Eliminare uno snapshot,
• Elencare i processi di ripristino e
• Ottenere lo stato del ripristino.

Creare uno snapshot

Prima di creare uno snapshot, si consiglia di interrompere la scrittura dei dati nella raccolta di destinazione e di chiamare flush() per evitare possibili perdite di dati.

Quando si assegna un nome a uno snapshot, utilizzare nomi chiari e descrittivi, come "daily_backup_20240101" o "v2.1_production_release", ed evitare termini generici, come "backup1" e "test". Utilizzare i nomi degli snapshot con attenzione per distinguerli tra versioni, ambienti e fasi.

Gli esempi di codice riportati di seguito presuppongono che si disponga già di una raccolta denominata 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

Elencare gli snapshot

È possibile elencare i nomi degli snapshot esistenti.

# 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

Descrizione di uno snapshot

È possibile ottenere informazioni dettagliate su uno snapshot specifico.

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

Bloccare/sbloccare i dati di uno snapshot

Durante il ripristino, è possibile fissare uno snapshot per proteggere temporaneamente i dati sottostanti dalla garbage collection e sbloccarlo per liberare i dati.

È inoltre possibile impostare una durata (time-to-live, TTL) per l'operazione di blocco, in modo che i dati bloccati vengano rilasciati allo scadere di tale durata.

pin_id = client.pin_snapshot_data(
    snapshot_name="backup_20240101",
    collection_name="my_collection",
    ttl_seconds=3600,
)

client.unpin_snapshot_data(
    pin_id=pin_id
)

// java

pinID, err := client.PinSnapshotData(
    context.Background(),
    milvusclient.NewPinSnapshotDataOption("backup_20240101", "my_collection").WithTTL(3600),
)
if err != nil {
    log.Fatal(err)
}

defer func() {
    _ = client.UnpinSnapshotData(
        context.Background(),
        milvusclient.NewUnpinSnapshotDataOption(pinID),
    )
}()

// Do work with pinned snapshot data.

// node.js

# restful

Ripristino di uno snapshot

È possibile ripristinare uno snapshot in una nuova raccolta. Questa operazione è asincrona e restituisce un ID del processo per monitorare lo stato di avanzamento del ripristino.

Il ripristino utilizza un meccanismo di copia dei segmenti anziché l’importazione dei dati, il che risulta più efficiente poiché

• copia direttamente i file di segmento (binlog, deltalog, file di indice) dall’archivio degli snapshot
• conserva gli ID dei campi e gli ID degli indici per garantire la compatibilità con i file di dati esistenti
• evita la riscrittura dei dati e la ricostruzione degli indici, con tempi di ripristino notevolmente più rapidi, e
• garantisce un aumento delle prestazioni da 10 a 100 volte rispetto ai metodi tradizionali di backup e ripristino

Per ripristinare uno snapshot, procedere come segue:

# 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

Per ulteriori dettagli sul monitoraggio dello stato di avanzamento di un'operazione di ripristino, consultare la sezione Ottenere lo stato del ripristino.

Eliminazione di uno snapshot

È possibile eliminare uno snapshot se non è più necessario. Si consiglia di rimuovere regolarmente gli snapshot obsoleti per risparmiare spazio di archiviazione.

client.drop_snapshot(
    snapshot_name="backup_20240101"
)

// java

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

// node.js

# restful

Elenco dei processi di ripristino

È possibile utilizzare questa API per ottenere un elenco degli snapshot già creati per la raccolta di destinazione.

# 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

Ottenere lo stato del ripristino

Una volta ottenuto l'ID di un'operazione di ripristino, è possibile utilizzarlo per recuperare lo stato di avanzamento del ripristino.

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