Men-deploy database vektor Qdrant di GKE

Menyiapkan lingkungan Anda

Untuk menyiapkan lingkungan Anda dengan Cloud Shell, ikuti langkah-langkah berikut:

1. Tetapkan variabel lingkungan untuk project, region, dan awalan resource cluster Kubernetes Anda:

   Untuk tujuan tutorial ini, gunakan region us-central1 untuk membuat resource deployment Anda.

   export PROJECT_ID=PROJECT_ID
   export KUBERNETES_CLUSTER_PREFIX=qdrant
   export REGION=us-central1
   

   • Ganti PROJECT_ID dengan project ID Google Cloud Anda.

2. Periksa versi Helm:

   helm version
   

   Update versi jika lebih lama dari 3.13:

   curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
   

3. Clone repositori kode contoh dari GitHub:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   

4. Buka direktori qdrant untuk mulai membuat resource deployment:

   cd kubernetes-engine-samples/databases/qdrant
   

Membuat infrastruktur cluster

Bagian ini melibatkan pengoperasian skrip Terraform untuk membuat cluster GKE regional pribadi yang sangat tersedia untuk men-deploy database Qdrant Anda.

Anda dapat memilih untuk men-deploy Qdrant menggunakan cluster Standar atau Autopilot. Masing-masing memiliki keunggulan dan model penetapan harga yang berbeda.

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=terraform/gke-autopilot init
terraform -chdir=terraform/gke-autopilot apply \
-var project_id=${PROJECT_ID} \
-var region=${REGION} \
-var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

...
Apply complete! Resources: 9 added, 0 changed, 0 destroyed.

Outputs:

kubectl_connection_command = "gcloud container clusters get-credentials qdrant-cluster --region us-central1"

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=terraform/gke-standard init
terraform -chdir=terraform/gke-standard apply \
-var project_id=${PROJECT_ID} \
-var region=${REGION} \
-var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

...
Apply complete! Resources: 10 added, 0 changed, 0 destroyed.

Outputs:

kubectl_connection_command = "gcloud container clusters get-credentials qdrant-cluster --region us-central1"

Hubungkan ke cluster

Konfigurasikan kubectl untuk mengambil kredensial dan berkomunikasi dengan cluster GKE baru:

gcloud container clusters get-credentials \
    ${KUBERNETES_CLUSTER_PREFIX}-cluster --region ${REGION}

Men-deploy database Qdrant ke cluster Anda

Dalam tutorial ini, Anda akan men-deploy database Qdrant (dalam mode terdistribusi) dan operator Stateful HA ke cluster cluster GKE Anda menggunakan Diagram Helm.

Deployment tersebut akan membuat cluster GKE dengan konfigurasi berikut:

• Tiga replika node Qdrant.
• Toleransi, afinitas node, dan batasan penyebaran topologi dikonfigurasi untuk memastikan distribusi yang tepat di seluruh node Kubernetes. Hal ini memanfaatkan kumpulan node dan zona ketersediaan yang berbeda.
• Volume RePD dengan jenis disk SSD disediakan untuk penyimpanan data.
• Operator HA Stateful digunakan untuk mengelola proses failover dan memastikan ketersediaan tinggi.
• Untuk autentikasi, database membuat rahasia Kubernetes yang berisi kunci API.

Untuk menggunakan chart Helm guna men-deploy database Qdrant, ikuti langkah-langkah berikut:

1. Aktifkan add-on StatefulHA:

   Autopilot

   GKE otomatis mengaktifkan add-on StatefulHA saat pembuatan cluster.

   Standar

   Jalankan perintah berikut:

   gcloud container clusters update ${KUBERNETES_CLUSTER_PREFIX}-cluster \
       --project=${PROJECT_ID} \
       --region=${REGION} \
       --update-addons=StatefulHA=ENABLED
   

   Mungkin perlu waktu 15 menit untuk menyelesaikan perintah ini dan cluster menampilkan status siap.

2. Tambahkan repositori Helm Chart database Qdrant sebelum Anda dapat men-deploy-nya di cluster GKE:

   helm repo add qdrant https://qdrant.github.io/qdrant-helm
   

3. Buat qdrant namespace untuk database:

   kubectl create ns qdrant
   

4. Terapkan manifes untuk membuat disk SSD persisten regional StorageClass:

   kubectl apply -n qdrant -f manifests/01-regional-pd/regional-pd.yaml
   

   Manifes regional-pd.yaml menjelaskan disk SSD persisten StorageClass:

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   allowVolumeExpansion: true
   metadata:
     name: ha-regional
   parameters:
     replication-type: regional-pd
     type: pd-ssd
     availability-class: regional-hard-failover
   provisioner: pd.csi.storage.gke.io
   reclaimPolicy: Retain
   volumeBindingMode: WaitForFirstConsumer

5. Deploy configmap Kubernetes dengan konfigurasi file bantuan metrics dan cluster Qdrant menggunakan Helm:

   kubectl apply -n qdrant -f manifests/03-prometheus-metrics/metrics-cm.yaml
   helm install qdrant-database qdrant/qdrant -n qdrant \
   -f manifests/02-values-file/values.yaml
   

   Manifes metrics-cm.yaml menjelaskan file bantuan metrics ConfigMap:

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: nginx-conf
   data:
     default.conf.template: |
       server {
         listen 80;
         location / {
           proxy_pass http://localhost:6333/metrics;
           proxy_http_version 1.1;
           proxy_set_header Host $http_host;
           proxy_set_header api-key ${QDRANT_APIKEY};
           proxy_set_header X-Forwarded-For $remote_addr;
         }
       }

   Manifes values.yaml menjelaskan konfigurasi cluster Qdrant :

   replicaCount: 3
   
   config:
     cluster:
       enabled: true
     storage:
       optimizers:
         deleted_threshold: 0.5
         vacuum_min_vector_number: 1500
         default_segment_number: 2
         max_segment_size_kb: null
         memmap_threshold_kb: null
         indexing_threshold_kb: 25000
         flush_interval_sec: 5
         max_optimization_threads: 1
   
   livenessProbe:
     enabled: true
     initialDelaySeconds: 60
   
   resources:
     limits:
       cpu: "2"
       memory: 4Gi
     requests:
       cpu: "1"
       memory: 4Gi
   
   tolerations:
     - key: "app.stateful/component"
       operator: "Equal"
       value: "qdrant"
       effect: NoSchedule
   
   affinity:
     nodeAffinity:
       preferredDuringSchedulingIgnoredDuringExecution:
       - weight: 1
         preference:
           matchExpressions:
           - key: "app.stateful/component"
             operator: In
             values:
             - "qdrant"
   
   topologySpreadConstraints:
     - maxSkew: 1
       topologyKey: "topology.kubernetes.io/zone"
       whenUnsatisfiable: ScheduleAnyway
       labelSelector:
         matchLabels:
           app.kubernetes.io/name: qdrant
           app.kubernetes.io/instance: qdrant
   
   podDisruptionBudget:
     enabled: true
     maxUnavailable: 1
   
   persistence:
     accessModes: ["ReadWriteOnce"]
     size: 10Gi
     storageClassName: ha-regional
   
   apiKey: true
   
   sidecarContainers:
     - name: metrics
       image: nginx:1.27
       resources:
         requests:
           memory: "128Mi"
           cpu: "250m"
         limits:
           memory: "128Mi"
           cpu: "500m"
       ports:
       - containerPort: 80
       env:
       - name: QDRANT_APIKEY 
         valueFrom:
           secretKeyRef:
             name: qdrant-database-apikey          
             key: api-key
       volumeMounts:
           - name: nginx-conf
             mountPath: /etc/nginx/templates/default.conf.template
             subPath: default.conf.template
             readOnly: true
   additionalVolumes:
     - name: nginx-conf
       configMap:
         name: nginx-conf
         items:
           - key: default.conf.template
             path: default.conf.template 

   Konfigurasi ini mengaktifkan mode cluster, sehingga Anda dapat menyiapkan cluster Qdrant yang sangat tersedia dan terdistribusi.

6. Periksa status deployment:

   helm ls -n qdrant
   

   Output-nya akan mirip dengan berikut ini, jika database qdrant berhasil di-deploy:

   NAME    NAMESPACE       REVISION        UPDATED                                 STATUS          CHART           APP VERSION
   qdrant-database  qdrant          1               2024-02-06 20:21:15.737307567 +0000 UTC deployed        qdrant-0.7.6    v1.7.4
   

7. Tunggu GKE memulai workload yang diperlukan:

   kubectl wait pods -l app.kubernetes.io/instance=qdrant-database --for condition=Ready --timeout=300s -n qdrant
   

   Perintah ini mungkin memerlukan waktu beberapa menit agar berhasil diselesaikan.

8. Setelah GKE memulai workload, verifikasi bahwa GKE telah membuat workload Qdrant:

   kubectl get pod,svc,statefulset,pdb,secret -n qdrant
   

9. Mulai resource HighAvailabilityApplication (HAA) untuk Qdrant:

   kubectl apply -n qdrant -f manifests/01-regional-pd/ha-app.yaml
   

   Manifes ha-app.yaml menjelaskan resource HighAvailabilityApplication:

   kind: HighAvailabilityApplication
   apiVersion: ha.gke.io/v1
   metadata:
     name: qdrant-database
     namespace: qdrant
   spec:
     resourceSelection:
       resourceKind: StatefulSet
     policy:
       storageSettings:
         requireRegionalStorage: true
       failoverSettings:
         forceDeleteStrategy: AfterNodeUnreachable
         afterNodeUnreachable:
           afterNodeUnreachableSeconds: 20 # 60 seconds total

   Resource GKE berikut ini dibuat untuk cluster Qdrant:

   • StatefulSet Qdrant yang mengontrol tiga replika Pod.
   • A PodDisruptionBudget, memastikan maksimal satu replika yang tidak tersedia.
   • Layanan qdrant-database, yang mengekspos port Qdrant untuk koneksi masuk dan replikasi antar-node.
   • Layanan qdrant-database-headless, yang menyediakan daftar Pod Qdrant yang sedang berjalan.
   • Secret qdrant-database-apikey, yang memfasilitasi koneksi database yang aman.
   • Pod operator dengan HA stateful dan resource HighlyAvailableApplication, yang secara aktif memantau aplikasi Qdrant. Resource HighlyAvailableApplication menentukan aturan failover untuk diterapkan terhadap Qdrant.

10. Untuk memeriksa apakah aturan failover diterapkan, jelaskan resource dan konfirmasi Status: Message: Application is protected.

    kubectl describe highavailabilityapplication qdrant-database -n qdrant
    

    Outputnya mirip dengan hal berikut ini:

    Status:
    Conditions:
        Last Transition Time:  2023-11-30T09:54:52Z
        Message:               Application is protected
        Observed Generation:   1
        Reason:                ApplicationProtected
        Status:                True
        Type:                  Protected
    

Unggah {i>dataset<i} dan jalankan kueri penelusuran dengan Jupyter Notebook

Qdrant menyusun vektor dan payload dalam koleksi. Penyematan vektor adalah teknik yang merepresentasikan kata atau entity sebagai vektor numerik dengan tetap mempertahankan hubungan semantiknya. Hal ini penting untuk penelusuran kesamaan karena memungkinkan menemukan kesamaan berdasarkan makna, bukan kecocokan persis, sehingga tugas seperti sistem penelusuran dan rekomendasi lebih efektif dan lebih spesifik.

Bagian ini menunjukkan cara mengupload Vektor ke Koleksi Qdrant baru dan menjalankan kueri penelusuran sederhana.

Dalam contoh ini, Anda menggunakan set data dari file CSV yang berisi daftar buku dalam genre yang berbeda. Qdrant akan berfungsi sebagai mesin telusur, dan Pod notebook Jupyter yang Anda buat akan berfungsi sebagai klien yang mengkueri database Qdrant.

1. Buat ConfigMaps books-dataset dan demo-app lalu deploy notebook Jupyter:

   kubectl create -n qdrant configmap books-dataset --from-file=manifests/04-notebook/dataset.csv
   kubectl create -n qdrant configmap notebook --from-file=manifests/04-notebook/vector-database.ipynb
   kubectl apply -n qdrant -f manifests/04-notebook/jupyter.yaml
   

   • Secret bernama qdrant-apikey yang dibuat sebelumnya dipasang ke Pod klien sebagai variabel lingkungan bernama APIKEY.
   • ConfigMap books-dataset berisi file csv dengan data buku untuk koleksi Qdrant
   • ConfigMap notebook berisi notebook Jupyter untuk membuat koleksi Qdrant dari books-dataset.

2. Tunggu GKE memulai Pod Jupyter:

   kubectl wait pods -l app=jupyter-notebook --for condition=Ready --timeout=300s -n qdrant
   

3. Buka URL ini dan klik file vector-database.ipynb. Tekan Run -> Run all cells. Jupyter akan mengeksekusi semua kode dan melakukan kueri pencarian.

   Kueri ini melakukan penelusuran semantik terhadap koleksi my_books di Qdrant, yang mengambil maksimum dua hasil dengan skor kecocokan tertinggi yang relevan dengan teks kueri Anda.

   Fitur ini mencetak setiap hasil yang dipisahkan oleh garis tanda hubung, dalam format berikut :

   • Title: Judul buku
   • Author: Penulis buku
   • Description: Seperti yang disimpan di kolom metadata description pada dokumen Anda
   • Published: Tanggal publikasi buku
   • Score: Skor relevansi Qdrant

   Outputnya mirip dengan hal berikut ini:

   Title: Romeo and Juliet
   Author: William Shakespeare, Paul Werstine (Editor), Barbara A. Mowat (Editor),
   Paavo Emil Cajander (Translator)
   Description: In Romeo and Juliet, Shakespeare creates a violent world, in which
   two young people fall in love. It is not simply that their families disapprove;
   the Montagues and the Capulets are engaged in a blood feud.In this death-filled
   setting, the movement from love at first sight to the lovers' final union in
   death seems almost inevitable. And yet, this play set in an extraordinary world
   has become the quintessential story of young love. In part because of its exquisite
   language, it is easy to respond as if it were about all young lovers. Published: 01/01/04
   Score: 0.8935013
   -----
   Title: The Unbearable Lightness of Being
   Author: Milan Kundera, Michael Henry Heim (Translator)
   Description: In The Unbearable Lightness of Being, Milan Kundera tells the story
   of a young woman in love with a man torn between his love for her and his incorrigible
   womanizing and one of his mistresses and her humbly faithful lover. This magnificent
   novel juxtaposes geographically distant places, brilliant and playful reflections,
   and a variety of styles, to take its place as perhaps the major achievement of
   one of the world's truly great writers. Published: 10/27/09
   Score: 0.8931863
   -----
   

Melihat metrik Prometheus untuk cluster Anda

Cluster GKE dikonfigurasi dengan Google Cloud Managed Service for Prometheus, yang memungkinkan pengumpulan metrik dalam format Prometheus. Layanan ini memberikan solusi terkelola sepenuhnya untuk pemantauan dan pemberitahuan, yang memungkinkan pengumpulan, penyimpanan, dan analisis metrik dari cluster dan aplikasinya.

Diagram berikut menunjukkan cara Prometheus mengumpulkan metrik untuk cluster Anda:

Cluster pribadi GKE dalam diagram berisi komponen berikut:

• Pod Qdrant yang mengekspos metrik pada jalur / dan port 80. Metrik ini disediakan oleh penampung file bantuan bernama metrics.
• Kolektor berbasis Prometheus yang memproses metrik dari Pod Qdrant.
• Resource PodMonitoring yang mengirimkan metrik ke Cloud Monitoring.

Untuk mengekspor dan melihat metrik, ikuti langkah-langkah berikut:

1. Buat resource PodMonitoring untuk menyalin metrik menurut labelSelector:

   kubectl apply -n qdrant -f manifests/03-prometheus-metrics/pod-monitoring.yaml
   

   Manifes pod-monitoring.yaml menjelaskan resource PodMonitoring:

   apiVersion: monitoring.googleapis.com/v1
   kind: PodMonitoring
   metadata:
     name: qdrant
   spec:
     selector:
       matchLabels:
         app: qdrant
         app.kubernetes.io/instance: qdrant-database
     endpoints:
     - port: 80
       interval: 30s
       path: / 

2. Buat dasbor Cloud Monitoring dengan konfigurasi yang ditentukan di dashboard.json :

   gcloud --project "${PROJECT_ID}" monitoring dashboards create --config-from-file monitoring/dashboard.json
   

3. Setelah perintah berhasil berjalan, buka Dashboard Cloud Monitoring:

   Buka ringkasan Dasbor

4. Dari daftar dasbor, buka dasbor Qdrant Overview. Mungkin diperlukan waktu 1-2 menit untuk mengumpulkan dan menampilkan metrik.

   Dasbor menampilkan jumlah metrik utama:

   • Koleksi
   • Vektor tersemat
   • Operasi tertunda
   • Node yang berjalan

Mencadangkan konfigurasi cluster Anda

Dengan fitur Pencadangan untuk GKE, Anda dapat menjadwalkan pencadangan reguler untuk seluruh konfigurasi cluster GKE, termasuk workload yang di-deploy beserta datanya.

Dalam tutorial ini, Anda mengonfigurasi rencana pencadangan untuk cluster GKE agar dapat menjalankan pencadangan semua beban kerja, termasuk Secret dan Volumes, setiap hari pada pukul 03.00 dini hari. Untuk memastikan pengelolaan penyimpanan yang efisien, cadangan yang lebih lama dari tiga hari akan otomatis dihapus.

Untuk mengonfigurasi Paket cadangan, ikuti langkah-langkah berikut:

1. Aktifkan fitur Pencadangan untuk GKE pada cluster Anda:

   gcloud container clusters update ${KUBERNETES_CLUSTER_PREFIX}-cluster \
   --project=${PROJECT_ID} \
   --region=${REGION} \
   --update-addons=BackupRestore=ENABLED
   

2. Buat rencana cadangan dengan jadwal harian untuk semua namespace dalam cluster:

   gcloud beta container backup-restore backup-plans create ${KUBERNETES_CLUSTER_PREFIX}-cluster-backup \
   --project=${PROJECT_ID} \
   --location=${REGION} \
   --cluster="projects/${PROJECT_ID}/locations/${REGION}/clusters/${KUBERNETES_CLUSTER_PREFIX}-cluster" \
   --all-namespaces \
   --include-secrets \
   --include-volume-data \
   --cron-schedule="0 3 * * *" \
   --backup-retain-days=3
   

   Perintah menggunakan variabel lingkungan yang relevan pada saat runtime.

   Format nama cluster relatif terhadap project dan region Anda sebagai berikut:

   projects/PROJECT_ID/locations/REGION/clusters/CLUSTER_NAME
   

   Saat diminta, ketik y.Outputnya mirip dengan yang berikut ini:

   Create request issued for: [qdrant-cluster-backup]
   Waiting for operation [projects/PROJECT_ID/locations/us-central1/operations/operation-1706528750815-610142ffdc9ac-71be4a05-f61c99fc] to complete...⠹
   

   Operasi ini mungkin perlu waktu beberapa menit agar berhasil diselesaikan. Setelah eksekusi selesai, outputnya akan serupa dengan berikut ini:

   Created backup plan [qdrant-cluster-backup].
   

3. Anda dapat melihat rencana pencadangan qdrant-cluster-backup yang baru dibuat tercantum di konsol Pencadangan untuk GKE.

   Buka Pencadangan untuk GKE

Jika Anda ingin memulihkan konfigurasi cadangan yang tersimpan, lihat Memulihkan cadangan.