Halaman ini diterjemahkan oleh Cloud Translation API.

Men-deploy database vektor Qdrant di GKE

Autopilot Standard

Panduan ini menunjukkan cara men-deploy cluster database vektor Qdrant di Google Kubernetes Engine (GKE).

Database vektor adalah penyimpanan data yang dirancang khusus untuk mengelola dan menelusuri kumpulan besar vektor berdimensi tinggi. Vektor ini merepresentasikan data seperti teks, gambar, audio, video, atau data apa pun yang dapat dienkode secara numerik. Tidak seperti database tradisional yang mengandalkan kecocokan persis, database vektor dikhususkan untuk menemukan item serupa atau mengidentifikasi pola dalam set data yang sangat besar. Karakteristik ini menjadikan Qdrant pilihan yang cocok untuk berbagai aplikasi, termasuk pencocokan berbasis semantik atau jaringan neural, penelusuran berfacet, dan banyak lagi. Qdrant tidak hanya berfungsi sebagai database vektor, tetapi juga sebagai mesin penelusuran kemiripan vektor.

Tutorial ini ditujukan untuk administrator dan arsitek platform cloud, engineer ML, dan profesional MLOps (DevOps) yang tertarik untuk men-deploy cluster database Qdrant di GKE.

Manfaat

Qdrant menawarkan manfaat berikut:

Berbagai library untuk berbagai bahasa pemrograman dan API terbuka untuk berintegrasi dengan layanan lain.
Penskalaan horizontal, serta dukungan untuk sharding dan replikasi yang menyederhanakan penskalaan dan ketersediaan tinggi.
Dukungan Container dan Kubernetes yang memungkinkan deployment dan pengelolaan di lingkungan berbasis cloud modern.
Payload fleksibel dengan pemfilteran lanjutan untuk menyesuaikan kriteria penelusuran secara tepat.
Berbagai opsi kuantisasi dan pengoptimalan lainnya untuk mengurangi biaya infrastruktur dan meningkatkan performa.

Tujuan

Dalam tutorial ini, Anda akan mempelajari cara:

Merencanakan dan men-deploy infrastruktur GKE untuk Qdrant.
Deploy operator StatefulHA untuk memastikan ketersediaan tinggi Qdrant.
Deploy dan konfigurasi cluster Qdrant.
Upload set data demo dan jalankan kueri penelusuran sederhana.
Kumpulkan metrik dan jalankan dasbor.

Arsitektur deployment

Arsitektur ini menyiapkan cluster GKE yang fault-tolerant dan skalabel untuk Qdrant di beberapa zona ketersediaan, sehingga memastikan waktu beroperasi dan ketersediaan dengan update berkelanjutan dan gangguan minimal. Hal ini mencakup penggunaan operator StatefulHA untuk pengelolaan failover yang efisien. Untuk mengetahui informasi selengkapnya, lihat Cluster regional.

Diagram arsitektur

Diagram berikut menunjukkan cluster Qdrant yang berjalan pada beberapa node dan zona dalam cluster GKE:

Arsitektur deployment Qdrant

Dalam arsitektur ini, StatefulSet Qdrant di-deploy di tiga node dalam tiga zona berbeda.

Anda dapat mengontrol cara GKE mendistribusikan Pod di seluruh node dengan mengonfigurasi aturan afinitas Pod dan batasan penyebaran topologi yang diperlukan dalam file nilai diagram Helm.
Jika satu zona gagal, GKE akan menjadwalkan ulang Pod pada node baru berdasarkan konfigurasi yang direkomendasikan.

Untuk persistensi data, arsitektur dalam tutorial ini memiliki karakteristik berikut:

Cluster ini menggunakan disk SSD regional (StorageClass regional-pdkustom) untuk mempertahankan data. Kami merekomendasikan disk SSD regional untuk database karena latensinya yang rendah dan IOPS yang tinggi.
Semua data disk direplikasi antara zona primer dan sekunder di region, sehingga meningkatkan toleransi terhadap potensi kegagalan zona.

Biaya

Dalam dokumen ini, Anda akan menggunakan komponen Google Cloudyang dapat ditagih berikut:

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga.

Pengguna Google Cloud baru mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Setelah menyelesaikan tugas yang dijelaskan dalam dokumen ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk mengetahui informasi selengkapnya, lihat Pembersihan.

Sebelum memulai

Dalam tutorial ini, Anda akan menggunakan Cloud Shell untuk menjalankan perintah. Cloud Shell adalah lingkungan shell untuk mengelola resource yang dihosting di Google Cloud. Cloud Shell telah diinstal lebih dulu dengan alat command line Google Cloud CLI, kubectl, Helm, dan Terraform. Jika tidak menggunakan Cloud Shell, Anda harus menginstal Google Cloud CLI.

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

Install the Google Cloud CLI.

Catatan: Jika Anda telah menginstal gcloud CLI sebelumnya, pastikan Anda memiliki versi terbaru dengan menjalankan gcloud components update.

Jika Anda menggunakan penyedia identitas (IdP) eksternal, Anda harus login ke gcloud CLI dengan identitas gabungan Anda terlebih dahulu.

Untuk melakukan inisialisasi gcloud CLI, jalankan perintah berikut:

gcloud init

Create or select a Google Cloud project.

Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
Replace PROJECT_ID with a name for the Google Cloud project you are creating.
Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
Replace PROJECT_ID with your Google Cloud project name.

Verify that billing is enabled for your Google Cloud project.

Enable the Resource Manager, Compute Engine, GKE, IAM Service Account Credentials, and Backup for GKE APIs:

gcloud services enable cloudresourcemanager.googleapis.com compute.googleapis.com container.googleapis.com iamcredentials.googleapis.com gkebackup.googleapis.com

Install the Google Cloud CLI.

Catatan: Jika Anda telah menginstal gcloud CLI sebelumnya, pastikan Anda memiliki versi terbaru dengan menjalankan gcloud components update.

Jika Anda menggunakan penyedia identitas (IdP) eksternal, Anda harus login ke gcloud CLI dengan identitas gabungan Anda terlebih dahulu.

Untuk melakukan inisialisasi gcloud CLI, jalankan perintah berikut:

gcloud init

Create or select a Google Cloud project.

Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
Replace PROJECT_ID with a name for the Google Cloud project you are creating.
Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
Replace PROJECT_ID with your Google Cloud project name.

Verify that billing is enabled for your Google Cloud project.

Enable the Resource Manager, Compute Engine, GKE, IAM Service Account Credentials, and Backup for GKE APIs:

gcloud services enable cloudresourcemanager.googleapis.com compute.googleapis.com container.googleapis.com iamcredentials.googleapis.com gkebackup.googleapis.com

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/storage.objectViewer, roles/container.admin, roles/iam.serviceAccountAdmin, roles/compute.admin, roles/gkebackup.admin, roles/monitoring.viewer
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
Replace the following:
- PROJECT_ID: your project ID.
- USER_IDENTIFIER: the identifier for your user account—for example, myemail@example.com.
- ROLE: the IAM role that you grant to your user account.

Menyiapkan lingkungan Anda

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

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.

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

Clone repositori kode contoh dari GitHub:

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

Buka direktori qdrant untuk mulai membuat resource deployment:
```
cd kubernetes-engine-samples/databases/qdrant
```

Membuat infrastruktur cluster

Bagian ini melibatkan menjalankan 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 Standard atau Autopilot. Setiap opsi memiliki kelebihannya sendiri dan model penetapan harga yang berbeda.

Autopilot

Diagram berikut menunjukkan cluster GKE regional Autopilot yang di-deploy ke tiga zona berbeda.

Cluster GKE Autopilot

Untuk men-deploy infrastruktur cluster, jalankan perintah berikut di Cloud Shell:

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}

Variabel berikut diganti saat runtime:

GOOGLE_OAUTH_ACCESS_TOKEN: Digantikan oleh token akses yang diambil oleh perintah gcloud auth print-access-token untuk mengautentikasi interaksi dengan berbagai Google Cloud API
PROJECT_ID, REGION, dan KUBERNETES_CLUSTER_PREFIX adalah variabel lingkungan yang ditentukan di bagian Siapkan lingkungan Anda dan ditetapkan ke variabel baru yang relevan untuk cluster Autopilot yang Anda buat.

Saat diminta, ketik yes.

Outputnya mirip dengan hal berikut ini:

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

Outputs:

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

Terraform membuat resource berikut:

Jaringan VPC kustom dan subnet pribadi untuk node Kubernetes.
Cloud Router untuk mengakses internet melalui Network Address Translation (NAT).
Cluster GKE pribadi di region us-central1.
ServiceAccount dengan izin logging dan pemantauan untuk cluster.
Konfigurasi Google Cloud Managed Service for Prometheus untuk pemantauan dan pemberitahuan cluster.

Standar

Diagram berikut menunjukkan cluster GKE regional pribadi Standard yang di-deploy ke tiga zona yang berbeda.

Cluster GKE Standard

Untuk men-deploy infrastruktur cluster, jalankan perintah berikut di Cloud Shell:

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}

Variabel berikut diganti saat runtime:

GOOGLE_OAUTH_ACCESS_TOKEN digantikan oleh token akses yang diambil oleh perintah gcloud auth print-access-token untuk mengautentikasi interaksi dengan berbagai Google Cloud API.
PROJECT_ID, REGION, dan KUBERNETES_CLUSTER_PREFIX adalah variabel lingkungan yang ditentukan di bagian Siapkan lingkungan Anda dan ditetapkan ke variabel baru yang relevan untuk cluster Standar yang Anda buat.

Saat diminta, ketik yes. Anda mungkin perlu menunggu beberapa menit agar perintah ini selesai dan cluster akan menampilkan status siap.

Outputnya mirip dengan hal berikut ini:

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

Outputs:

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

Terraform membuat resource berikut:

Jaringan VPC kustom dan subnet pribadi untuk node Kubernetes.
Cloud Router untuk mengakses internet melalui Network Address Translation (NAT).
Cluster GKE pribadi di region us-central1 dengan penskalaan otomatis diaktifkan (satu hingga dua node per zona).
ServiceAccount dengan izin logging dan pemantauan untuk cluster.
Konfigurasi Google Cloud Managed Service for Prometheus untuk pemantauan dan pemberitahuan cluster.

Hubungkan ke cluster

Konfigurasi kubectl untuk mengambil kredensial dan berkomunikasi dengan cluster GKE baru Anda:

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

Deploy database Qdrant ke cluster Anda

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

Deployment ini 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. StatefulSet adalah pengontrol Kubernetes yang mempertahankan identitas unik persisten untuk setiap Pod-nya.
Untuk autentikasi, database membuat secret Kubernetes yang berisi kunci API.

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

Aktifkan add-on StatefulHA:
Autopilot
GKE secara otomatis mengaktifkan add-on StatefulHA saat pembuatan cluster.
Standar
Jalankan perintah berikut:
```
gcloud container clusters update ${KUBERNETES_CLUSTER_PREFIX}-cluster \
    --project=${PROJECT_ID} \
    --location=${REGION} \
    --update-addons=StatefulHA=ENABLED
```
Anda mungkin perlu menunggu 15 menit agar perintah ini selesai dan cluster menampilkan status siap.
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
```
Buat namespace qdrant untuk database:
```
kubectl create ns qdrant
```

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 StorageClass disk SSD persisten:

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

Deploy configmap Kubernetes dengan konfigurasi sidecar 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 ConfigMap sidecar metrics:

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:
  service:
    enable_tls: false
  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.28
    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.

Tambahkan label ke statefulset Qdrant:

kubectl label statefulset qdrant-database examples.ai.gke.io/source=qdrant-guide -n qdrant

Deploy load balancer internal untuk mengakses database Qdrant yang berjalan di VPC yang sama dengan cluster GKE Anda:

kubectl apply -n qdrant -f manifests/02-values-file/ilb.yaml

Manifes ilb.yaml menjelaskan Layanan LoadBalancer:

apiVersion: v1
kind: Service
metadata:
  annotations:
    #cloud.google.com/neg: '{"ingress": true}'
    networking.gke.io/load-balancer-type: "Internal"
  labels:
    app.kubernetes.io/name: qdrant
  name: qdrant-ilb
spec:
  ports:
  - name: http
    port: 6333
    protocol: TCP
    targetPort: 6333
  - name: grpc
    port: 6334
    protocol: TCP
    targetPort: 6334
  selector:
    app: qdrant
    app.kubernetes.io/instance: qdrant-database
  type: LoadBalancer

Periksa status deployment:

helm ls -n qdrant

Outputnya 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

Tunggu hingga GKE memulai workload yang diperlukan:
```
kubectl wait pods -l app.kubernetes.io/instance=qdrant-database --for condition=Ready --timeout=300s -n qdrant
```
Pemrosesan perintah ini mungkin memerlukan waktu beberapa menit hingga berhasil diselesaikan.
Setelah GKE memulai workload, pastikan GKE telah membuat workload Qdrant:
```
kubectl get pod,svc,statefulset,pdb,secret -n qdrant
```
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 dibuat untuk cluster Qdrant:
- StatefulSet Qdrant yang mengontrol tiga replika Pod.
- A PodDisruptionBudget, memastikan maksimum satu replika 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 HA stateful dan resource HighlyAvailableApplication, yang secara aktif memantau aplikasi Qdrant. Resource HighlyAvailableApplication menentukan aturan failover yang akan diterapkan terhadap Qdrant.

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

Menjalankan kueri dengan notebook Colab Enterprise Vertex AI

Qdrant mengatur vektor dan payload dalam koleksi. Embedding vektor adalah teknik yang merepresentasikan kata atau entitas sebagai vektor numerik sekaligus mempertahankan hubungan semantiknya. Hal ini penting untuk penelusuran kesamaan karena memungkinkan menemukan kesamaan berdasarkan makna, bukan kecocokan persis, sehingga membuat tugas seperti sistem penelusuran dan rekomendasi menjadi lebih efektif dan bernuansa.

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

Dalam contoh ini, Anda menggunakan set data dari file CSV yang berisi daftar buku dalam berbagai genre. Anda membuat notebook Colab Enterprise untuk menjalankan kueri penelusuran di database Qdrant.

Untuk mengetahui informasi selengkapnya tentang Vertex AI Colab Enterprise, lihat dokumentasi Colab Enterprise.

Membuat template runtime

Untuk membuat template runtime Colab Enterprise:

Di konsol Google Cloud , buka halaman Runtime Templates Colab Enterprise, lalu pastikan project Anda dipilih:

Buka Template Runtime
Klik Template Baru. Halaman Create new runtime template akan muncul.
Di bagian Runtime basics:
- Di kolom Nama tampilan, masukkan qdrant-connect.
- Di menu drop-down Region, pilih us-central1. Regionnya sama dengan cluster GKE Anda.
Di bagian Konfigurasi komputasi:
- Di menu drop-down Machine type, pilih e2-standard-2.
- Di kolom Disk size, masukkan 30.
Di bagian Networking and security:
- Di menu drop-down Network, pilih jaringan tempat cluster GKE Anda berada.
- Di menu drop-down Subnetwork, pilih subnetwork yang sesuai.
- Hapus centang pada kotak Aktifkan akses internet publik.
Untuk menyelesaikan pembuatan template runtime, klik Buat. Template runtime Anda akan muncul dalam daftar di tab Runtime templates.

Membuat runtime

Untuk membuat runtime Colab Enterprise:

Dalam daftar template runtime untuk template yang baru saja Anda buat, di kolom Tindakan, klik , lalu klik Buat runtime. Panel Create Vertex AI Runtime akan muncul.
Untuk membuat runtime berdasarkan template Anda, klik Buat.
Pada tab Runtimes yang terbuka, tunggu hingga status berubah menjadi Healthy.

Mengimpor notebook

Untuk mengimpor notebook di Colab Enterprise:

Buka tab Notebook Saya, lalu klik Impor. Panel Import notebooks akan muncul.
Di Sumber impor, pilih URL.

Di bagian URL Notebook, masukkan link berikut:

https://raw.githubusercontent.com/GoogleCloudPlatform/kubernetes-engine-samples/refs/heads/main/databases/qdrant/manifests/04-notebook/vector-database.ipynb

Klik Import.

Menghubungkan ke runtime dan menjalankan kueri

Untuk terhubung ke runtime dan menjalankan kueri:

Di notebook, di samping tombol Connect, klik Additional connection options. Panel Connect to Vertex AI Runtime akan muncul.
Pilih Connect to a runtime, lalu pilih Connect to an existing Runtime.
Pilih runtime yang Anda luncurkan, lalu klik Connect.
Untuk menjalankan sel notebook, klik tombol Jalankan sel di samping setiap sel kode.

Notebook berisi sel kode dan teks yang menjelaskan setiap blok kode. Menjalankan sel kode akan mengeksekusi perintahnya dan menampilkan output. Anda dapat menjalankan sel secara berurutan, atau menjalankan sel satu per satu sesuai kebutuhan.

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 menyediakan 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:

Pengumpulan metrik Prometheus

Cluster pribadi GKE dalam diagram berisi komponen berikut:

Pod Qdrant yang mengekspos metrik di jalur / dan port 80. Metrik ini disediakan oleh container file bantuan bernama metrics.
Pengumpul berbasis Prometheus yang memproses metrik dari Pod Qdrant.
Resource PodMonitoring yang mengirim metrik ke Cloud Monitoring.

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

Buat resource PodMonitoring untuk meng-scrape 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: /

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

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

Setelah perintah berhasil dijalankan, buka Dasbor Cloud Monitoring:

Buka Ringkasan dasbor
Dari daftar dasbor, buka dasbor Qdrant Overview. Mungkin perlu waktu 1-2 menit untuk mengumpulkan dan menampilkan metrik.

Dasbor menampilkan jumlah metrik utama:
- Koleksi
- Vektor tersemat
- Operasi tertunda
- Menjalankan node

Mencadangkan konfigurasi cluster Anda

Fitur Pencadangan untuk GKE memungkinkan Anda menjadwalkan pencadangan rutin seluruh konfigurasi cluster GKE, termasuk workload yang di-deploy dan datanya.

Dalam tutorial ini, Anda akan mengonfigurasi rencana pencadangan untuk cluster GKE guna melakukan pencadangan semua workload, termasuk Secret dan Volume, setiap hari pada pukul 03.00. Untuk memastikan pengelolaan penyimpanan yang efisien, cadangan yang lebih lama dari tiga hari akan dihapus secara otomatis.

Untuk mengonfigurasi Rencana pencadangan, ikuti langkah-langkah berikut:

Aktifkan fitur Pencadangan untuk GKE bagi cluster Anda:

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

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 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 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 memerlukan waktu beberapa menit hingga berhasil diselesaikan. Setelah eksekusi selesai, output-nya akan mirip dengan berikut ini:

Created backup plan [qdrant-cluster-backup].

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

Buka Pencadangan untuk GKE

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

Pembersihan

Agar tidak perlu membayar biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

Menghapus project

Cara termudah untuk menghindari penagihan adalah dengan menghapus project yang Anda buat untuk tutorial ini.

Perhatian: Menghapus project memiliki efek berikut:

Semua hal dalam project akan dihapus. Jika menggunakan project yang sudah ada untuk tugas dalam dokumen ini, saat Anda menghapusnya, pekerjaan lain yang telah Anda lakukan dalam project tersebut juga akan terhapus.
Project ID kustom hilang. Saat membuat project ini, Anda mungkin telah membuat project ID kustom yang ingin digunakan di masa mendatang. Untuk mempertahankan URL yang menggunakan project ID, seperti URL appspot.com, hapus resource yang dipilih di dalam project, bukan menghapus seluruh project.

Jika Anda berencana mempelajari beberapa arsitektur, tutorial atau panduan memulai, dengan menggunakan kembali project dapat membantu Anda agar tidak melampaui batas kuota project.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Jika Anda menghapus project ini, berarti pembersihan telah selesai. Jika Anda tidak menghapus project, lanjutkan dengan menghapus resource satu per satu.

Menghapus resource satu per satu

Menetapkan variabel lingkungan.

export PROJECT_ID=${PROJECT_ID}
export KUBERNETES_CLUSTER_PREFIX=qdrant
export REGION=us-central1

Jalankan perintah terraform destroy:

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

Ganti FOLDER dengan gke-autopilot atau gke-standard, bergantung pada jenis cluster GKE yang Anda buat.

Saat diminta, ketik yes.

Temukan semua disk yang tidak terpasang:

export disk_list=$(gcloud compute disks list --filter="-users:* AND labels.name=${KUBERNETES_CLUSTER_PREFIX}-cluster" --format "value[separator=|](name,region)")

Hapus disk:

for i in $disk_list; do
 disk_name=$(echo $i| cut -d'|' -f1)
 disk_region=$(echo $i| cut -d'|' -f2|sed 's|.*/||')
 echo "Deleting $disk_name"
 gcloud compute disks delete $disk_name --region $disk_region --quiet
done

Hapus repositori GitHub:
```
rm -r ~/kubernetes-engine-samples/
```

Langkah berikutnya

Jelajahi Qdrant di marketplace GKE.
Pelajari software open source Qdrant.
Coba operator Qdrant yang menawarkan pengelolaan kunci API, dukungan TLS dengan pengelolaan sertifikat, dan penjadwalan pencadangan.
Pelajari praktik terbaik untuk men-deploy database di GKE.
Temukan solusi untuk menjalankan workload yang memproses banyak data dengan GKE.

Men-deploy database vektor Qdrant di GKE Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Manfaat

Tujuan

Arsitektur deployment

Diagram arsitektur

Biaya

Sebelum memulai

Menyiapkan lingkungan Anda

Membuat infrastruktur cluster

Autopilot

Standar

Hubungkan ke cluster

Deploy database Qdrant ke cluster Anda

Autopilot

Standar

Menjalankan kueri dengan notebook Colab Enterprise Vertex AI

Membuat template runtime

Membuat runtime

Mengimpor notebook

Menghubungkan ke runtime dan menjalankan kueri

Melihat metrik Prometheus untuk cluster Anda

Mencadangkan konfigurasi cluster Anda

Pembersihan

Menghapus project

Menghapus resource satu per satu

Langkah berikutnya

Men-deploy database vektor Qdrant di GKE