Cette page a été traduite par l'API Cloud Translation.

Déployer une base de données vectorielles Elasticsearch sur GKE

Autopilot Standard

Ce tutoriel explique comment déployer un cluster de base de données vectorielles Elasticsearch sur Google Kubernetes Engine (GKE).

Les bases de données vectorielles sont des data stores spécialement conçus pour gérer de vastes collections de vecteurs de grande dimension et faire des recherches dans celles-ci. Ces vecteurs représentent des données telles que du texte, des images, de l'audio, des vidéos ou toute autre donnée pouvant être encodée numériquement. Contrairement aux bases de données relationnelles qui reposent sur des correspondances exactes, les bases de données vectorielles sont spécialisées dans la recherche d'éléments similaires ou dans l'identification de modèles dans des ensembles de données volumineux.

Elasticsearch est une base de données vectorielle qui combine des fonctionnalités de recherche et d'analyse. Elle est fournie avec une API REST ouverte pour la gestion de clusters. Elle est compatible avec les requêtes structurées, les requêtes en texte intégral et les requêtes complexes. Elasticsearch vous permet d'effectuer des recherches par expression, par similarité et par préfixe, avec des suggestions de saisie semi-automatique.

Ce tutoriel est destiné aux administrateurs et architectes de plate-forme cloud, aux ingénieurs en ML et aux professionnels du MLOps (DevOps) qui souhaitent déployer des clusters de base de données Qdrant sur GKE.

Avantages

Elasticsearch offre les avantages suivants :

Large éventail de bibliothèques pour différents langages de programmation et API ouverte à intégrer à d'autres services
Scaling horizontal, et compatibilité avec la segmentation et la réplication afin de faciliter le scaling et la haute disponibilité
Équilibrage de charge des clusters à nœuds multiples pour une utilisation optimale des ressources.
Prise en charge des conteneurs et de Kubernetes pour une intégration parfaite dans des environnements cloud natifs modernes.

Objectifs

Dans ce tutoriel, vous allez apprendre à effectuer les opérations suivantes :

Planifier et déployer l'infrastructure GKE pour Elasticsearch.
Déployer et configurer Elasticsearch dans un cluster GKE.
Déployer l'opérateur StatefulHA pour garantir la haute disponibilité d'Elasticsearch.
Exécutez un notebook pour générer et stocker des exemples d'embeddings vectoriels dans votre base de données, et effectuez des requêtes de recherche vectorielles.
Collectez et visualisez des métriques dans un tableau de bord.

Architecture de déploiement

Dans ce tutoriel, vous allez déployer un cluster GKE régional à disponibilité élevée pour Elasticsearch, avec plusieurs nœuds Kubernetes répartis sur plusieurs zones de disponibilité. Cette configuration permet d'assurer la tolérance aux pannes, l'évolutivité et la redondance géographique. Il permet d'effectuer des mises à jour et des opérations de maintenance progressives tout en fournissant des contrats de niveau de service en matière de disponibilité et de disponibilité. Pour en savoir plus, consultez la page Clusters régionaux.

Lorsqu'un nœud devient inaccessible, un pod de ce nœud n'est pas reprogrammé immédiatement. Avec les pods utilisant un StatefulSet, la suppression et le replanification des pods d'application sur de nouveaux nœuds peuvent prendre plus de huit minutes.

Pour résoudre ce problème, l'opérateur StatefulHA effectue les opérations suivantes :

Résout le délai de replanification, gère les paramètres de basculement et réduit le temps de récupération avec .forceDeleteStrategy : paramètres AfterNodeUnreachable.
Garantit que l'application du StatefulSet utilise un disque persistant régional.
Étend GKE avec une ressource HighAvailabilityApplication personnalisée déployée dans le même espace de noms qu'Elasticsearch. Cela permet à l'opérateur StatefulHA de surveiller les événements de basculement et d'y répondre.

Le schéma suivant montre un cluster Elasticsearch s'exécutant sur plusieurs nœuds et zones dans un cluster GKE :

Architecture de déploiement d'Elasticsearch

Coûts

Dans ce document, vous utilisez les composants facturables de Google Cloudsuivants :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, supprimez les ressources que vous avez créées pour éviter que des frais vous soient facturés. Pour en savoir plus, consultez la section Effectuer un nettoyage.

L'utilisation d'Elasticsearch est gratuite dans le cadre de la licence publique côté serveur (SSPL, Server Side Public License).

Avant de commencer

Dans ce tutoriel, vous utilisez Cloud Shell pour exécuter des commandes. Cloud Shell est un environnement shell permettant de gérer les ressources hébergées sur Google Cloud. Il est doté des outils de ligne de commande préinstallés suivants : Google Cloud CLI, kubectl, Helm et Terraform. Si vous n'utilisez pas Cloud Shell, vous devez installer 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.

Remarque : Si vous avez déjà installé la gcloud CLI, vérifiez que vous disposez de la dernière version en exécutant gcloud components update.

Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

Pour initialiser la gcloud CLI, exécutez la commande suivante :

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 Cloud 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.

Remarque : Si vous avez déjà installé la gcloud CLI, vérifiez que vous disposez de la dernière version en exécutant gcloud components update.

Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

Pour initialiser la gcloud CLI, exécutez la commande suivante :

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 Cloud 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.

Configurer votre environnement

Pour configurer votre environnement avec Cloud Shell, procédez comme suit :

Définissez des variables d'environnement pour votre projet, une région et un préfixe de ressource de cluster Kubernetes :
```
export PROJECT_ID=PROJECT_ID
export KUBERNETES_CLUSTER_PREFIX=elasticsearch
export REGION=us-central1
```
- Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.
Ce tutoriel utilise la région us-central1 pour créer les ressources de déploiement.
Vérifiez la version de Helm :
```
helm version
```
Mettez à jour la version si elle est antérieure à la version 3.13 :
```
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
```

Clonez l'exemple de dépôt de code depuis GitHub :

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

Accédez au répertoire elasticsearch pour commencer à créer des ressources de déploiement :
```
cd kubernetes-engine-samples/databases/elasticsearch
```

Créer l'infrastructure de votre cluster

Dans cette section, vous allez exécuter un script Terraform pour créer un cluster GKE régional, privé et à disponibilité élevée pour déployer votre base de données Elasticsearch.

Vous pouvez choisir de déployer Elasticsearch à l'aide d'un cluster Standard ou Autopilot. Chacun présente ses propres avantages et différents modèles de tarification.

Autopilot

Le schéma suivant présente un cluster GKE Autopilot déployé dans le projet.

Cluster GKE Autopilot

Pour déployer l'infrastructure du cluster, exécutez les commandes suivantes dans 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}

GKE remplace les variables suivantes lors de l'exécution :

GOOGLE_OAUTH_ACCESS_TOKEN utilise la commande gcloud auth print-access-token pour récupérer un jeton d'accès qui authentifie les interactions avec diverses API Google Cloud.
PROJECT_ID, REGION et KUBERNETES_CLUSTER_PREFIX sont les variables d'environnement définies dans la section Configurer votre environnement et attribuées aux nouvelles variables pertinentes pour le cluster Autopilot que vous êtes en train de créer.

Lorsque vous y êtes invité, saisissez yes.

Le résultat ressemble à ce qui suit :

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

Outputs:

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

Terraform crée les ressources suivantes :

Un réseau VPC personnalisé et un sous-réseau privé pour les nœuds Kubernetes
Un routeur cloud pour accéder à Internet via la traduction d'adresse réseau (NAT)
Un cluster GKE privé dans la région us-central1.
Un ServiceAccount avec les autorisations de journalisation et de surveillance pour le cluster
Configuration de Google Cloud Managed Service pour Prometheus pour la surveillance et les alertes relatives au cluster.

Standard

Le schéma suivant présente un cluster GKE régional privé Standard déployé dans trois zones différentes.

Cluster GKE standard

Pour déployer l'infrastructure du cluster, exécutez les commandes suivantes dans 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}

GKE remplace les variables suivantes lors de l'exécution :

GOOGLE_OAUTH_ACCESS_TOKEN utilise la commande gcloud auth print-access-token pour récupérer un jeton d'accès qui authentifie les interactions avec diverses API Google Cloud.
PROJECT_ID, REGION et KUBERNETES_CLUSTER_PREFIX sont les variables d'environnement définies dans la section Configurer votre environnement et attribuées aux nouvelles variables pertinentes pour le cluster Standard que vous êtes en train de créer.

Lorsque vous y êtes invité, saisissez yes. L'exécution de ces commandes et le passage du cluster à l'état prêt peuvent prendre plusieurs minutes.

Le résultat ressemble à ce qui suit :

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

Outputs:

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

Terraform crée les ressources suivantes :

Un réseau VPC personnalisé et un sous-réseau privé pour les nœuds Kubernetes
Un routeur cloud pour accéder à Internet via la traduction d'adresse réseau (NAT)
Un cluster GKE privé dans la région us-central1 avec l'autoscaling activé (un à deux nœuds par zone)
Un ServiceAccount avec les autorisations de journalisation et de surveillance pour le cluster
Configuration de Google Cloud Managed Service pour Prometheus pour la surveillance et les alertes relatives au cluster.

Se connecter au cluster

Configurez kubectl pour récupérer les identifiants et communiquer avec votre nouveau cluster GKE :

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

Déployer la base de données Elasticsearch et l'opérateur StatefulHA

Dans cette section, vous allez déployer la base de données Elasticsearch (en mode cluster) et l'opérateur StatefulHA dans votre cluster GKE à l'aide du chart Helm de l'opérateur ECK.

Le déploiement crée un cluster GKE avec la configuration suivante :

Trois instances répliquées des nœuds Elasticsearch.
DaemonSet permettant de modifier les paramètres de mémoire virtuelle, afin d'optimiser les performances d'Elasticsearch. Un DaemonSet est un contrôleur Kubernetes qui garantit qu'une copie d'un pod s'exécute sur chaque nœud d'un cluster.
Configuration de NodeAffinity et PodAntiAffinity pour assurer une répartition appropriée entre les nœuds Kubernetes, optimiser l'utilisation des pools de nœuds et maximiser la disponibilité dans différentes zones.
Un opérateur HA avec état qui gère les processus de basculement et garantit la haute disponibilité. Un StatefulSet est un contrôleur Kubernetes qui conserve une identité unique et persistante pour chacun de ses pods.
Pour l'authentification, la base de données crée des secrets Kubernetes avec des identifiants, des mots de passe et des certificats d'authentification.

Pour déployer la base de données Elasticsearch à l'aide du chart Helm, procédez comme suit :

Activez le module complémentaire StatefulHA :
Autopilot
GKE active automatiquement le module complémentaire StatefulHA lors de la création du cluster.
Standard
Exécutez la commande ci-dessous.
```
gcloud container clusters update ${KUBERNETES_CLUSTER_PREFIX}-cluster \
    --project=${PROJECT_ID} \
    --location=${REGION} \
    --update-addons=StatefulHA=ENABLED
```
L'exécution de cette commande et le passage du cluster à l'état prêt peuvent prendre 15 minutes.
Créez une définition de ressource personnalisée (CRD) Elastic Cloud sur Kubernetes (ECK) :
```
kubectl apply -f https://download.elastic.co/downloads/eck/2.11.1/crds.yaml
```

Déployez l'opérateur ECK :

kubectl apply -f https://download.elastic.co/downloads/eck/2.11.1/operator.yaml

Créez l'espace de noms elastic pour la base de données :
```
kubectl create ns elastic
```

Installez la ressource HighAvailabilityApplication (HAA), qui définit les règles de basculement pour Elasticsearch.

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

Le fichier manifeste ha-app.yaml décrit la ressource HighAvailabilityApplication :

kind: HighAvailabilityApplication
apiVersion: ha.gke.io/v1
metadata:
  name: elasticsearch-ha-es-main
  namespace: elastic
spec:
  resourceSelection:
    resourceKind: StatefulSet
  policy:
    storageSettings:
      requireRegionalStorage: false
    failoverSettings:
      forceDeleteStrategy: AfterNodeUnreachable
      afterNodeUnreachable:
        afterNodeUnreachableSeconds: 20 # 60 seconds total

Appliquez le fichier manifeste pour créer un disque SSD persistant régional StorageClass :

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

Le fichier manifeste regional-pd.yaml décrit le disque SSD persistant 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

Déployez la ressource DaemonSet pour définir la mémoire virtuelle dans chaque nœud :

kubectl apply -n elastic -f manifests/02-elasticsearch/mmap-count.yaml

Le fichier manifeste mmap-count.yaml décrit l'objet DaemonSet :

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: max-map-count-setter
  labels:
    k8s-app: max-map-count-setter
spec:
  selector:
    matchLabels:
      name: max-map-count-setter
  template:
    metadata:
      labels:
        name: max-map-count-setter
    spec:
      initContainers:
        - name: max-map-count-setter
          image: docker.io/bash:5.2.21
          resources:
            limits:
              cpu: 100m
              memory: 32Mi
          securityContext:
            privileged: true
            runAsUser: 0
          command: ['/usr/local/bin/bash', '-e', '-c', 'echo 262144 > /proc/sys/vm/max_map_count']
      containers:
        - name: sleep
          image: docker.io/bash:5.2.21
          command: ['sleep', 'infinity']

Appliquez le fichier manifeste pour déployer le cluster Elasticsearch :

kubectl apply -n elastic -f manifests/02-elasticsearch/elasticsearch.yaml

Le fichier manifeste elasticsearch.yaml décrit le déploiement :

apiVersion: elasticsearch.k8s.elastic.co/v1
kind: Elasticsearch
metadata:
  name: elasticsearch-ha
spec:
  version: 8.11.4
  nodeSets:
  - name: main
    count: 3
    volumeClaimTemplates:
    - metadata:
        name: elasticsearch-data 
      spec:
        accessModes:
        - ReadWriteOnce
        resources:
          requests:
            storage: 10Gi
        storageClassName: ha-regional
    config:
    podTemplate:
      metadata:
        labels:
          app.stateful/component: elasticsearch
      spec:
        initContainers:
        - name: max-map-count-check
          command: ['sh', '-c', "while true; do mmc=$(cat /proc/sys/vm/max_map_count); if [ ${mmc} -eq 262144 ]; then exit 0; fi; sleep 1; done"]
        containers:
        - name: metrics
          image: quay.io/prometheuscommunity/elasticsearch-exporter:v1.7.0
          command:
            - /bin/elasticsearch_exporter
            - --es.ssl-skip-verify
            - --es.uri=https://$(ES_USER):$(ES_PASSWORD)@localhost:9200
          securityContext:
            runAsNonRoot: true
            runAsGroup: 10000
            runAsUser: 10000
          resources:
            requests:
              memory: "128Mi"
              cpu: "25m"
            limits:
              memory: "128Mi"
              cpu: "100m"
          ports:
          - containerPort: 9114
          env:
          - name: ES_USER
            value: "elastic"
          - name: ES_PASSWORD
            valueFrom:
              secretKeyRef:
                name: elasticsearch-ha-es-elastic-user
                key: elastic
        - name: elasticsearch
          resources:
            limits:
              memory: 4Gi
              cpu: 1
        affinity:
          nodeAffinity:
            preferredDuringSchedulingIgnoredDuringExecution:
              - weight: 1
                preference:
                  matchExpressions:
                  - key: app.stateful/component
                    operator: In
                    values:
                    - elasticsearch
          podAntiAffinity:
            preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 1
              podAffinityTerm:
                labelSelector:
                  matchLabels:
                    app.stateful/component: elasticsearch
                topologyKey: topology.kubernetes.io/zone

Attendez quelques minutes que le cluster Elasticsearch démarre complètement.

Vérifiez l'état du déploiement :
```
kubectl get elasticsearch -n elastic --watch
```
Le résultat ressemble à ce qui suit, si la base de données elasticsearch est bien déployée :
```
NAME               HEALTH   NODES   VERSION   PHASE   AGE
elasticsearch-ha   green    3       8.11.4    Ready   2m30s
```
Attendez que HEALTH s'affiche comme green. Si nécessaire, appuyez sur Ctrl+C pour quitter la commande.

Déployez un équilibreur de charge interne pour accéder à votre base de données Elasticsearch qui s'exécute dans le même VPC que votre cluster GKE :

kubectl apply -n elastic -f manifests/02-elasticsearch/ilb.yaml

Le fichier manifeste ilb.yaml décrit le service 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: elasticsearch
  name: elastic-ilb
spec:
  ports:
  - name: https
    port: 9200
    protocol: TCP
    targetPort: 9200
  selector:
    common.k8s.elastic.co/type: elasticsearch
    elasticsearch.k8s.elastic.co/cluster-name: elasticsearch-ha
  type: LoadBalancer

Pour vérifier si les règles de basculement sont appliquées, décrivez la ressource et confirmez Status: Message: Application is protected.

kubectl describe highavailabilityapplication elasticsearch-ha-es-main -n elastic

Le résultat est semblable à celui-ci :

Status:
  Conditions:
    Last Transition Time:  2024-02-01T13:27:50Z
    Message:               Application is protected
    Observed Generation:   1
    Reason:                ApplicationProtected
    Status:                True
    Type:                  Protected
Events:                    <none>

Une fois que GKE a démarré les charges de travail, vérifiez qu'il a créé les charges de travail Elasticsearch :

kubectl get pod,svc,statefulset,pdb,secret,daemonset -n elastic

Le résultat ressemble à ce qui suit :

NAME                             READY   STATUS    RESTARTS   AGE
pod/elasticsearch-ha-es-main-0   2/2     Running   0          7m16s
pod/elasticsearch-ha-es-main-1   2/2     Running   0          7m16s
pod/elasticsearch-ha-es-main-2   2/2     Running   0          7m16s
pod/max-map-count-setter-28wt9   1/1     Running   0          7m27s
pod/max-map-count-setter-cflsw   1/1     Running   0          7m27s
pod/max-map-count-setter-gzq9k   1/1     Running   0          7m27s

NAME                                        TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)    AGE
service/elasticsearch-ha-es-http            ClusterIP   10.52.8.28   <none>        9200/TCP   7m18s
service/elasticsearch-ha-es-internal-http   ClusterIP   10.52.3.48   <none>        9200/TCP   7m18s
service/elasticsearch-ha-es-main            ClusterIP   None         <none>        9200/TCP   7m16s
service/elasticsearch-ha-es-transport       ClusterIP   None         <none>        9300/TCP   7m18s

NAME                                        READY   AGE
statefulset.apps/elasticsearch-ha-es-main   3/3     7m16s

NAME                                                     MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
poddisruptionbudget.policy/elasticsearch-ha-es-default   2               N/A               1                     7m16s

NAME                                                 TYPE     DATA   AGE
secret/elasticsearch-ha-es-elastic-user              Opaque   1      7m18s
secret/elasticsearch-ha-es-file-settings             Opaque   1      7m16s
secret/elasticsearch-ha-es-http-ca-internal          Opaque   2      7m17s
secret/elasticsearch-ha-es-http-certs-internal       Opaque   3      7m17s
secret/elasticsearch-ha-es-http-certs-public         Opaque   2      7m17s
secret/elasticsearch-ha-es-internal-users            Opaque   4      7m18s
secret/elasticsearch-ha-es-main-es-config            Opaque   1      7m16s
secret/elasticsearch-ha-es-main-es-transport-certs   Opaque   7      7m16s
secret/elasticsearch-ha-es-remote-ca                 Opaque   1      7m16s
secret/elasticsearch-ha-es-transport-ca-internal     Opaque   2      7m16s
secret/elasticsearch-ha-es-transport-certs-public    Opaque   1      7m16s
secret/elasticsearch-ha-es-xpack-file-realm          Opaque   4      7m18s

NAME                                  DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
daemonset.apps/max-map-count-setter   6         6         6       6            6           <none>          13m

Les ressources GKE suivantes sont créées pour le cluster Elasticsearch :

Le StatefulSet Elasticsearch qui contrôle trois instances répliquées de pod.
Un DaemonSet pour configurer les paramètres de mémoire virtuelle.
Services permettant de se connecter à Elasticsearch.
Secrets avec identifiants de superutilisateur et certificats liés au service.
Le pod de l'opérateur HA avec état et la ressource HighlyAvailableApplication, qui surveillent activement l'application Elasticsearch.

Exécuter des requêtes avec un notebook Vertex AI Colab Enterprise

Cette section explique comment générer des embeddings dans des documents Elasticsearch et effectuer des requêtes de recherche sémantique à l'aide du client Python Elasticsearch officiel dans un notebook Colab Enterprise. Dans Elasticsearch, un document est composé de différents champs, chacun associé à sa valeur correspondante.

Pour en savoir plus sur Vertex AI Colab Enterprise, consultez la documentation Colab Enterprise.

Bonne pratique:

Pour utiliser efficacement Elasticsearch, nous vous recommandons de structurer vos données dans ces documents, qui sont ensuite indexés à des fins de recherche.

Dans cet exemple, vous utilisez un ensemble de données issu d'un fichier CSV contenant une liste de livres de différents genres. Elasticsearch sert de moteur de recherche, et le pod que vous créez sert de client interrogeant la base de données Elasticsearch.

Vous pouvez utiliser un modèle de runtime dédié pour effectuer un déploiement sur le VPC (cloud privé virtuel) elasticsearch-vpc. Le notebook peut ainsi communiquer avec les ressources de votre cluster GKE.

Créer un modèle d'environnement d'exécution

Pour créer un modèle d'exécution Colab Enterprise :

Dans la console Google Cloud , accédez à la page Modèles d'exécution de Colab Enterprise et assurez-vous que votre projet est sélectionné :

Accéder aux modèles d'exécution
Cliquez sur Nouveau modèle. La page Créer un modèle d'exécution s'affiche.
Dans la section Principes de base de l'exécution :
- Dans le champ Nom à afficher, saisissez elastic-connect.
- Dans la liste déroulante Région, sélectionnez us-central1. Il s'agit de la même région que votre cluster GKE.
Dans la section Configurer le calcul :
- Dans la liste déroulante Type de machine, sélectionnez e2-standard-2.
- Dans le champ Taille de disque disponible, saisissez 30.
Dans la section Mise en réseau et sécurité :
- Dans la liste déroulante Réseau, sélectionnez le réseau sur lequel réside votre cluster GKE.
- Dans la liste déroulante Sous-réseau, sélectionnez le sous-réseau correspondant.
- Décochez la case Activer l'accès Internet public.
Pour terminer la création du modèle d'exécution, cliquez sur Créer. Votre modèle d'exécution apparaît dans la liste sur l'onglet Modèles d'exécution.

Créer un environnement d'exécution

Pour créer un environnement d'exécution Colab Enterprise :

Dans la liste des modèles d'exécution, pour le modèle que vous venez de créer, cliquez sur dans la colonne Actions, puis sur Créer une exécution. Le volet Créer un environnement d'exécution Vertex AI s'affiche.
Pour créer un environnement d'exécution basé sur votre modèle, cliquez sur Créer.
Dans l'onglet Environnements d'exécution qui s'ouvre, attendez que l'état passe à Sain.

Importer le notebook

Pour importer le notebook dans Colab Enterprise :

Accédez à l'onglet Mes notebooks, puis cliquez sur Importer. Le volet Importer des notebooks s'affiche.
Dans Source d'importation, sélectionnez URL.

Sous URL de notebook, saisissez le lien suivant :

https://raw.githubusercontent.com/GoogleCloudPlatform/kubernetes-engine-samples/main/databases/elasticsearch/manifests/03-notebook/vector-database.ipynb

Cliquez sur Importer.

Se connecter à l'environnement d'exécution et exécuter des requêtes

Pour vous connecter à l'environnement d'exécution et exécuter des requêtes :

Dans le notebook, à côté du bouton Connecter, cliquez sur Options de connexion supplémentaires. Le volet Se connecter à l'environnement d'exécution Vertex AI s'affiche.
Sélectionnez Se connecter à un environnement d'exécution, puis Se connecter à un environnement d'exécution existant.
Sélectionnez l'environnement d'exécution que vous avez lancé, puis cliquez sur Connect (Se connecter).
Pour exécuter les cellules du notebook, cliquez sur le bouton Exécuter la cellule à côté de chaque cellule de code.

Le notebook contient à la fois des cellules de code et du texte décrivant chaque bloc de code. L'exécution d'une cellule de code exécute ses commandes et affiche un résultat. Vous pouvez exécuter les cellules dans l'ordre ou exécuter des cellules individuelles selon vos besoins.

Afficher les métriques Prometheus pour votre cluster

Le cluster GKE est configuré avec Google Cloud Managed Service pour Prometheus, ce qui permet de collecter des métriques au format Prometheus. Ce service fournit une solution entièrement gérée pour la surveillance et les alertes, permettant la collecte, le stockage et l'analyse des métriques du cluster et de ses applications.

Le schéma suivant montre comment Prometheus collecte les métriques pour votre cluster :

Collecte de métriques Prometheus

Le cluster privé GKE du schéma contient les composants suivants :

Pods Elasticsearch qui exposent des métriques sur le chemin d'accès / et le port 9114. Ces métriques sont fournies par le conteneur side-car nommé metrics qui contient elasticsearch_exporter.
Collecteurs basés sur Prometheus qui traitent les métriques à partir du pod Elasticsearch.
Une ressource PodMonitoring qui envoie des métriques à Cloud Monitoring.

La configuration du cluster définit un conteneur side-car avec un exportateur de métriques au format Prometheus :

apiVersion: elasticsearch.k8s.elastic.co/v1
kind: Elasticsearch
metadata:
  name: elasticsearch-ha
spec:
  ...
  nodeSets:
  - name: main
    ...
    podTemplate:
      spec:
        containers:
        ...
        - name: metrics
          image: quay.io/prometheuscommunity/elasticsearch-exporter:v1.7.0
          command:
          - /bin/elasticsearch_exporter
          - --es.ssl-skip-verify
          - --es.uri=https://$(ES_USER):$(ES_PASSWORD)@localhost:9200
          ...
          env:
          - name: ES_USER
            value: "elastic"
          - name: ES_PASSWORD
            valueFrom:
            secretKeyRef:
              name: elasticsearch-ha-es-elastic-user
              key: elastic

Pour exporter et afficher les métriques, procédez comme suit :

Créez la ressource PodMonitoring pour extraire les métriques par labelSelector :

kubectl apply -n elastic -f manifests/04-prometheus-metrics/pod-monitoring.yaml

Le fichier manifeste pod-monitoring.yaml décrit la ressource PodMonitoring :

apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: elasticsearch
spec:
  selector:
    matchLabels:
      app.stateful/component: elasticsearch
      elasticsearch.k8s.elastic.co/cluster-name: elasticsearch-ha
  endpoints:
  - port: 9114
    interval: 30s
    path: /metrics

Après quelques minutes, le tableau de bord intégré "Présentation de Elasticsearch Prometheus" s'affiche.

Pour afficher plus de graphiques liés aux données, importez un tableau de bord Cloud Monitoring personnalisé avec les configurations définies dans dashboard.json :
```
gcloud --project "${PROJECT_ID}" monitoring dashboards create --config-from-file monitoring/dashboard.json
```
Une fois la commande exécutée, accédez aux tableaux de bord Cloud Monitoring :

Accéder à la page de présentation des tableaux de bord
Dans la liste des tableaux de bord, ouvrez le tableau de bord ElasticSearch Overview. La collecte et l'affichage des métriques peuvent prendre une à deux minutes.

Le tableau de bord affiche le nombre de métriques clés :
- Index
- Documents et segments
- Opérations en attente
- Nœuds en cours d'exécution avec leur état de santé

Sauvegarder la configuration de votre cluster

La fonctionnalité Sauvegarde pour GKE vous permet de planifier des sauvegardes régulières de l'intégralité de la configuration de votre cluster GKE, y compris les charges de travail déployées et leurs données.

Dans ce tutoriel, vous allez configurer un plan de sauvegarde pour votre cluster GKE afin d'effectuer des sauvegardes de toutes les charges de travail, y compris les secrets et les volumes, tous les jours à 3h. Pour assurer une gestion efficace du stockage, les sauvegardes de plus de trois jours sont automatiquement supprimées.

Activez la fonctionnalité Sauvegarde pour GKE pour votre cluster :

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

Créez un plan de sauvegarde avec une programmation quotidienne pour tous les espaces de noms du 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

La commande utilise les variables d'environnement pertinentes lors de l'exécution.

Le format du nom du cluster est associé à votre projet et à votre région, comme suit :

projects/PROJECT_ID/locations/REGION/clusters/CLUSTER_NAME

Lorsque vous y êtes invité, saisissez y.. Le résultat ressemble à ce qui suit :

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

Cette opération peut prendre quelques minutes. Une fois l'exécution terminée, le résultat ressemble à ce qui suit :

Created backup plan [elasticsearch-cluster-backup].

Vous pouvez voir le plan de sauvegarde elasticsearch-cluster-backup que vous venez de créer dans la console Sauvegarde pour GKE.

Accéder à Sauvegarde pour GKE

Si vous souhaitez restaurer les configurations de sauvegarde enregistrées, consultez la page Restaurer une sauvegarde.

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Attention : La suppression d'un projet a les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Si vous avez supprimé le projet, le nettoyage est terminé. Si vous n'avez pas supprimé le projet, suivez les étapes ci-après afin de supprimer les ressources individuelles.

Supprimer des ressources individuelles

Définissez les variables d'environnement.

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

Exécutez la commande 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}

Remplacez FOLDER par gke-autopilot ou gke-standard, selon le type de cluster GKE que vous avez créé.

Lorsque vous y êtes invité, saisissez yes.

Recherchez tous les disques non associés :

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

Supprimez les disques :

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

Supprimez le dépôt GitHub :
```
rm -r ~/kubernetes-engine-samples/
```

Étapes suivantes

Découvrez les logiciels Open Source Elasticsearch.
Découvrez les bonnes pratiques pour le déploiement de bases de données sur GKE.
Découvrez des solutions pour exécuter des charges de travail utilisant beaucoup de données avec GKE.

Déployer une base de données vectorielles Elasticsearch sur GKE Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Avantages

Objectifs

Architecture de déploiement

Coûts

Avant de commencer

Configurer votre environnement

Créer l'infrastructure de votre cluster

Autopilot

Standard

Se connecter au cluster

Déployer la base de données Elasticsearch et l'opérateur StatefulHA

Autopilot

Standard

Exécuter des requêtes avec un notebook Vertex AI Colab Enterprise

Créer un modèle d'environnement d'exécution

Créer un environnement d'exécution

Importer le notebook

Se connecter à l'environnement d'exécution et exécuter des requêtes

Afficher les métriques Prometheus pour votre cluster

Sauvegarder la configuration de votre cluster

Effectuer un nettoyage

Supprimer le projet

Supprimer des ressources individuelles

Étapes suivantes

Déployer une base de données vectorielles Elasticsearch sur GKE