🚀 Testen Sie Zilliz Cloud, die vollständig verwaltete Milvus, kostenlos – erleben Sie 10x schnellere Leistung! Jetzt testen>>

milvus-logo
LFAI
  • Home
  • Blog
  • Milvus unterstützt den Import von Apache Parquet-Dateien für eine effizientere Datenverarbeitung

Milvus unterstützt den Import von Apache Parquet-Dateien für eine effizientere Datenverarbeitung

  • Engineering
March 08, 2024
Cai Zhang, Fendy Feng

Milvus, die hoch skalierbare Vektordatenbank, die für ihre Fähigkeit bekannt ist, große Datenmengen zu verarbeiten, macht einen bedeutenden Schritt nach vorn, indem sie in Version 2.3.4 die Unterstützung von Parquet-Dateien einführt. Durch den Einsatz von Apache Parquet können Benutzer ihre Datenimportprozesse rationalisieren und erhebliche Einsparungen bei den Speicher- und Berechnungskosten erzielen.

In unserem letzten Beitrag gehen wir auf die Vorteile von Parquet und die Vorteile für Milvus-Benutzer ein. Wir erörtern die Beweggründe für die Integration dieser Funktion und bieten eine Schritt-für-Schritt-Anleitung für den nahtlosen Import von Parquet-Dateien in Milvus, wodurch neue Möglichkeiten für eine effiziente Datenverwaltung und -analyse erschlossen werden.

Was ist Apache Parquet?

Apache Parquet ist ein beliebtes, spaltenorientiertes Open-Source-Datendateiformat, das die Effizienz der Speicherung und Verarbeitung großer Datensätze verbessern soll. Im Gegensatz zu herkömmlichen zeilenorientierten Datenformaten wie CSV oder JSON speichert Parquet Daten spaltenweise und bietet effizientere Datenkomprimierungs- und Kodierungsverfahren. Dieser Ansatz führt zu einer verbesserten Leistung, einem geringeren Speicherbedarf und einer verbesserten Verarbeitungsleistung und ist damit ideal für die Verarbeitung komplexer Daten in großen Mengen.

Wie Milvus-Benutzer von der Unterstützung für Parquet-Datei-Importe profitieren

Milvus erweitert die Unterstützung für Parquet-Datei-Importe und bietet den Anwendern optimierte Erfahrungen und verschiedene Vorteile, einschließlich geringerer Speicher- und Rechenkosten, rationalisierter Datenverwaltung und eines vereinfachten Importprozesses.

Optimierte Speichereffizienz und gestrafftes Datenmanagement

Parquet bietet flexible Komprimierungsoptionen und effiziente Kodierungsschemata für unterschiedliche Datentypen, die eine optimale Speichereffizienz gewährleisten. Diese Flexibilität ist besonders in Cloud-Umgebungen wertvoll, wo jedes Gramm Speicherplatzersparnis direkt mit einer spürbaren Kostenreduzierung korreliert. Mit dieser neuen Funktion in Milvus können Benutzer mühelos all ihre unterschiedlichen Daten in einer einzigen Datei konsolidieren, was die Datenverwaltung rationalisiert und die allgemeine Benutzererfahrung verbessert. Besonders vorteilhaft ist diese Funktion für Benutzer, die mit Array-Datentypen mit variabler Länge arbeiten, da diese nun von einem vereinfachten Datenimportprozess profitieren können.

Verbesserte Abfrageleistung

Das spaltenförmige Speicherdesign von Parquet und die fortschrittlichen Komprimierungsmethoden verbessern die Abfrageleistung erheblich. Bei der Durchführung von Abfragen können sich die Benutzer ausschließlich auf die relevanten Daten konzentrieren, ohne die irrelevanten Daten zu durchsuchen. Dieses selektive Spaltenlesen minimiert die CPU-Auslastung, was zu schnelleren Abfragezeiten führt.

Breite Sprachkompatibilität

Parquet ist in mehreren Sprachen wie Java, C++ und Python verfügbar und mit einer großen Anzahl von Datenverarbeitungswerkzeugen kompatibel. Durch die Unterstützung von Parquet-Dateien können Milvus-Benutzer, die verschiedene SDKs verwenden, nahtlos Parquet-Dateien zum Parsen innerhalb der Datenbank erzeugen.

Wie man Parquet-Dateien in Milvus importiert

Wenn Ihre Daten bereits im Parquet-Dateiformat vorliegen, ist das Importieren einfach. Laden Sie die Parquet-Datei in ein Objektspeichersystem wie MinIO hoch, und schon können Sie importieren.

Das folgende Code-Snippet ist ein Beispiel für den Import von Parquet-Dateien in Milvus.

remote_files = []
try:
    print("Prepare upload files")
    minio_client = Minio(endpoint=MINIO_ADDRESS, access_key=MINIO_ACCESS_KEY, secret_key=MINIO_SECRET_KEY,
                         secure=False)
    found = minio_client.bucket_exists(bucket_name)
    if not found:
        minio_client.make_bucket(bucket_name)
        print("MinIO bucket '{}' doesn't exist".format(bucket_name))
        return False, []

    # set your remote data path
    remote_data_path = "milvus_bulkinsert"

    def upload_file(f: str):
        file_name = os.path.basename(f)
        minio_file_path = os.path.join(remote_data_path, "parquet", file_name)
        minio_client.fput_object(bucket_name, minio_file_path, f)
        print("Upload file '{}' to '{}'".format(f, minio_file_path))
        remote_files.append(minio_file_path)

    upload_file(data_file)

except S3Error as e:
    print("Failed to connect MinIO server {}, error: {}".format(MINIO_ADDRESS, e))
    return False, []

print("Successfully upload files: {}".format(remote_files))
return True, remote_files

Wenn Ihre Daten keine Parquet-Dateien sind oder dynamische Felder haben, können Sie BulkWriter, unser Datenformat-Konvertierungstool, nutzen, um Parquet-Dateien zu erzeugen. BulkWriter hat nun Parquet als Standard-Ausgabeformat übernommen, was eine intuitivere Erfahrung für Entwickler gewährleistet.

Das folgende Code-Snippet ist ein Beispiel für die Verwendung von BulkWriter zur Erzeugung von Parquet-Dateien.

import numpy as np
import json

from pymilvus import (
    RemoteBulkWriter,
    BulkFileType,
)

remote_writer = RemoteBulkWriter(
        schema=your_collection_schema,
        remote_path="your_remote_data_path",
        connect_param=RemoteBulkWriter.ConnectParam(
            endpoint=YOUR_MINIO_ADDRESS,
            access_key=YOUR_MINIO_ACCESS_KEY,
            secret_key=YOUR_MINIO_SECRET_KEY,
            bucket_name="a-bucket",
        ),
        file_type=BulkFileType.PARQUET,
)

# append your data
batch_count = 10000
for i in range(batch_count):
    row = {
        "id": i,
        "bool": True if i % 5 == 0 else False,
        "int8": i % 128,
        "int16": i % 1000,
        "int32": i % 100000,
        "int64": i,
        "float": i / 3,
        "double": i / 7,
        "varchar": f"varchar_{i}",
        "json": {"dummy": i, "ok": f"name_{i}"},
        "vector": gen_binary_vector() if bin_vec else gen_float_vector(),
        f"dynamic_{i}": i,
    }
    remote_writer.append_row(row)

# append rows by numpy type
for i in range(batch_count):
    remote_writer.append_row({
        "id": np.int64(i + batch_count),
        "bool": True if i % 3 == 0 else False,
        "int8": np.int8(i % 128),
        "int16": np.int16(i % 1000),
        "int32": np.int32(i % 100000),
        "int64": np.int64(i),
        "float": np.float32(i / 3),
        "double": np.float64(i / 7),
        "varchar": f"varchar_{i}",
        "json": json.dumps({"dummy": i, "ok": f"name_{i}"}),
        "vector": gen_binary_vector() if bin_vec else gen_float_vector(),
        f"dynamic_{i}": i,
    })

print(f"{remote_writer.total_row_count} rows appends")
print(f"{remote_writer.buffer_row_count} rows in buffer not flushed")
print("Generate data files...")
remote_writer.commit()
print(f"Data files have been uploaded: {remote_writer.batch_files}")
remote_files = remote_writer.batch_files

Anschließend können Sie damit beginnen, Ihre Parquet-Dateien in Milvus zu importieren.

remote_files = [remote_file_path]
task_id = utility.do_bulk_insert(collection_name=collection_name,
                                 files=remote_files)

task_ids = [task_id]         
states = wait_tasks_to_state(task_ids, BulkInsertState.ImportCompleted)
complete_count = 0
for state in states:
    if state.state == BulkInsertState.ImportCompleted:
        complete_count = complete_count + 1

Jetzt sind Ihre Daten nahtlos in Milvus integriert.

Was kommt als nächstes?

Da Milvus immer größere Datenmengen unterstützt, ergibt sich die Herausforderung, große Importe zu verwalten, insbesondere wenn die Parquet-Dateien 10 GB überschreiten. Um diese Herausforderung zu bewältigen, planen wir, die Importdaten in skalare und vektorielle Spalten aufzuteilen und zwei Parquet-Dateien pro Import zu erstellen, um den E/A-Druck zu verringern. Bei Datensätzen, die mehrere hundert Gigabyte überschreiten, empfehlen wir, die Daten mehrfach zu importieren.

Like the article? Spread the word

Weiterlesen