Milvus Mendukung Impor File Parket Apache untuk Meningkatkan Efisiensi Pemrosesan Data

Milvus, basis data vektor yang sangat skalabel dan terkenal dengan kemampuannya untuk menangani kumpulan data yang sangat besar, mengambil langkah maju yang signifikan dengan memperkenalkan dukungan file Parquet di versi 2.3.4. Dengan menggunakan Apache Parquet, pengguna dapat menyederhanakan proses impor data mereka dan menikmati penghematan yang besar dalam biaya penyimpanan dan komputasi.

Dalam artikel terbaru kami, kami mengeksplorasi keunggulan Parquet dan manfaat yang diberikannya kepada pengguna Milvus. Kami membahas motivasi di balik integrasi fitur ini dan memberikan panduan langkah demi langkah untuk mengimpor file Parquet dengan lancar ke Milvus, membuka kemungkinan baru untuk manajemen dan analisis data yang efisien.

Apa itu Apache Parquet?

Apache Parquet adalah format file data berorientasi kolom sumber terbuka yang populer yang dirancang untuk meningkatkan efisiensi penyimpanan dan pemrosesan kumpulan data berskala besar. Berbeda dengan format data berorientasi baris tradisional seperti CSV atau JSON, Parquet menyimpan data per kolom, menawarkan kompresi data dan skema penyandian yang lebih efisien. Pendekatan ini menghasilkan peningkatan kinerja, pengurangan kebutuhan penyimpanan, dan peningkatan daya pemrosesan, sehingga ideal untuk menangani data yang kompleks dalam jumlah besar.

Bagaimana Pengguna Milvus Mendapatkan Manfaat dari Dukungan untuk Impor File Parket

Milvus memperluas dukungan untuk impor file Parquet, memberikan pengalaman yang dioptimalkan dan berbagai keuntungan kepada pengguna, termasuk biaya penyimpanan dan komputasi yang lebih rendah, manajemen data yang efisien, dan proses impor yang disederhanakan.

Efisiensi Penyimpanan yang Dioptimalkan dan Manajemen Data yang Efisien

Parquet menyediakan opsi kompresi yang fleksibel dan skema pengodean yang efisien yang melayani berbagai jenis data, memastikan efisiensi penyimpanan yang optimal. Fleksibilitas ini sangat berharga dalam lingkungan cloud di mana setiap ons penghematan penyimpanan berkorelasi langsung dengan pengurangan biaya yang nyata. Dengan fitur baru di Milvus ini, pengguna dapat dengan mudah mengkonsolidasikan semua data mereka yang beragam ke dalam satu file, menyederhanakan manajemen data dan meningkatkan pengalaman pengguna secara keseluruhan. Fitur ini sangat bermanfaat bagi pengguna yang bekerja dengan tipe data Array dengan panjang variabel, yang sekarang dapat menikmati proses impor data yang disederhanakan.

Peningkatan Performa Kueri

Desain penyimpanan kolumnar dan metode kompresi canggih dari Parquet secara signifikan meningkatkan kinerja kueri. Saat melakukan kueri, pengguna dapat fokus hanya pada data yang relevan tanpa memindai data yang tidak relevan. Pembacaan kolom yang selektif ini meminimalkan penggunaan CPU, sehingga menghasilkan waktu kueri yang lebih cepat.

Kompatibilitas Bahasa yang Luas

Parket tersedia dalam berbagai bahasa seperti Java, C, dan Python dan kompatibel dengan sejumlah besar alat pemrosesan data. Dengan dukungan file Parquet, pengguna Milvus yang menggunakan SDK yang berbeda dapat dengan mudah menghasilkan file Parquet untuk diurai dalam database.

Cara Mengimpor File Parquet ke Milvus

Jika data Anda sudah dalam format file Parquet, mengimpornya mudah. Unggah file Parquet ke sistem penyimpanan objek seperti MinIO, dan Anda siap untuk mengimpor.

Cuplikan kode di bawah ini adalah contoh mengimpor file Parquet ke 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

Jika data Anda bukan file Parquet atau memiliki bidang dinamis, Anda dapat memanfaatkan BulkWriter, alat konversi format data kami, untuk membantu Anda menghasilkan file Parquet. BulkWriter kini telah menggunakan Parquet sebagai format data keluaran default, memastikan pengalaman yang lebih intuitif bagi pengembang.

Cuplikan kode di bawah ini adalah contoh penggunaan BulkWriter untuk menghasilkan file Parquet.

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

Kemudian, Anda dapat mulai mengimpor file Parquet Anda ke Milvus.

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

Sekarang, data Anda telah terintegrasi dengan mulus ke dalam Milvus.

Apa Selanjutnya?

Karena Milvus terus mendukung volume data yang terus bertambah, tantangan muncul dalam mengelola impor yang cukup besar, terutama ketika file Parquet melebihi 10GB. Untuk mengatasi tantangan ini, kami berencana untuk memisahkan data impor ke dalam kolom skalar dan vektor, membuat dua file Parquet per impor untuk mengurangi tekanan I/O. Untuk kumpulan data yang melebihi beberapa ratus gigabyte, kami sarankan untuk mengimpor data beberapa kali.