Configurer Elastic Stack sur GKE

Ce tutoriel vous explique comment exécuter Elastic Stack sur GKE à l'aide de l'opérateur Elastic Cloud sur Kubernetes (ECK).

Elastic Stack est une solution Open Source populaire utilisée pour la journalisation, la surveillance et l'analyse des données en temps réel. En utilisant Elastic Stack sur GKE, vous pouvez bénéficier de l'évolutivité et de la fiabilité fournies par GKE Autopilot, ainsi que des puissantes fonctionnalités d'Elastic Stack.

Ce tutoriel est destiné aux administrateurs Kubernetes ou aux ingénieurs en fiabilité des sites.

Préparer l'environnement

Dans ce tutoriel, vous utilisez Cloud Shell pour gérer les ressources hébergées sur Google Cloud. Cloud Shell est préinstallé avec les logiciels dont vous avez besoin dans ce tutoriel, y compris kubectl, Helm et gcloud CLI.

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

1. Lancez une session Cloud Shell depuis la console Google Cloud en cliquant sur Activer Cloud Shell dans la consoleGoogle Cloud . Une session s'ouvre dans le volet inférieur de la console Google Cloud .

2. Ajoutez un dépôt de chart Helm et mettez-le à jour :

   helm repo add elastic https://helm.elastic.co
   helm repo update
   

3. Clonez le dépôt GitHub.

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

4. Accédez au répertoire de travail :

   cd kubernetes-engine-samples/observability/elastic-stack-tutorial
   

Créer un cluster GKE

Créez un cluster GKE avec la collecte de métriques du plan de contrôle activée :

gcloud container clusters create-auto elk-stack \
    --location="us-central1" \
    --monitoring="SYSTEM,WORKLOAD,API_SERVER,SCHEDULER,CONTROLLER_MANAGER"

Déployer l'opérateur ECK

Elastic Cloud sur Kubernetes (ECK) est une plate-forme de déploiement et de gestion de clusters Elastic Stack sur Kubernetes.

ECK automatise le déploiement et la gestion des clusters Elastic Stack, ce qui simplifie le processus de configuration et de maintenance de Elastic Stack sur Kubernetes. Il fournit un ensemble de ressources Kubernetes personnalisées que vous pouvez utiliser pour créer et configurer Elasticsearch, Kibana, Application Performance Management Server et d'autres composants Elastic Stack dans Kubernetes. Cela permet aux développeurs et aux équipes DevOps de configurer et de gérer des clusters Elastic Stack à grande échelle.

ECK est compatible avec plusieurs nœuds Elasticsearch, le basculement automatique des applications, les mises à niveau fluides et le chiffrement SSL. ECK inclut également des fonctionnalités qui vous permettent de surveiller et de dépanner les performances d'Elasticsearch.

Remarque : Ce tutoriel fournit des instructions d'utilisation pour l'application suivante : ECK version 2.8.0. Ces instructions peuvent ne pas représenter les versions les plus récentes de l'application. Pour en savoir plus, consultez la documentation : ECK.

1. Installez le chart Helm ECK :

   helm upgrade --install "elastic-operator" "elastic/eck-operator" \
       --version="2.8.0" \
       --create-namespace \
       --namespace="elastic-system" \
       --set="resources.limits.cpu=250m" \
       --set="resources.limits.memory=512Mi" \
       --set="resources.limits.ephemeral-storage=1Gi" \
       --set="resources.requests.cpu=250m" \
       --set="resources.requests.memory=512Mi" \
       --set="resources.requests.ephemeral-storage=1Gi"
   

2. Attendez que l'opérateur soit prêt :

   watch kubectl get pods -n elastic-system
   

   Le résultat ressemble à ce qui suit :

   NAME                 READY   STATUS    RESTARTS   AGE
   elastic-operator-0   1/1     Running   0          31s
   

   Lorsque l'opérateur STATUS est Running, revenez à la ligne de commande en appuyant sur Ctrl+C.

Configurer Elastic Stack avec ECK

En utilisant Elastic Stack avec Elasticsearch, Kibana et Elastic Agent en mode parc, vous pouvez configurer une solution puissante, évolutive et entièrement gérée pour gérer et visualiser des données à l'aide de Kibana.

Kibana est un outil d'analyse et de visualisation de données Open Source qui vous permet de rechercher, d'analyser et de visualiser des données dans Elasticsearch.

L'agent Elastic est un transporteur de données léger qui collecte les données provenant de différentes sources, telles que les journaux ou les métriques, et les envoie automatiquement à Elasticsearch.

Elastic Fleet est un mode de fonctionnement dans lequel les agents Elastic se rapportent à un serveur central de parc qui gère leur configuration et leur gestion. Le serveur de parc simplifie le déploiement, la configuration et le scaling des agents Elastic, ce qui facilite la gestion des déploiements complexes et de grande envergure.

L'autoscaling Elasticsearch est une fonctionnalité d'auto-surveillance qui permet de signaler quand des ressources supplémentaires sont nécessaires en fonction d'une règle définie par l'opérateur. Par exemple, une règle peut spécifier qu'un certain niveau doit évoluer en fonction de l'espace disque disponible. Elasticsearch peut surveiller l'espace disque et suggérer un scaling s'il prédit une pénurie, bien qu'il incombe encore à l'opérateur d'ajouter les ressources nécessaires. Pour en savoir plus sur l'autoscaling Elasticsearch, consultez la page Autoscaling dans la documentation d'Elasticsearch.

Configurer un cluster Elasticsearch

Elasticsearch fournit un moteur de recherche et d'analyse RESTful distribué, conçu pour stocker et rechercher rapidement et efficacement de grands volumes de données.

Lorsque vous déployez Elastic Stack sur Kubernetes, vous devez gérer les paramètres de VM, en particulier le vm.max_map_count setting, requis par Elasticsearch. vm.max_map_count spécifie le nombre de zones de mémoire qu'un processus peut allouer à un fichier. Elasticsearch doit avoir cette valeur définie sur au moins 262144 pour fonctionner de manière optimale. Pour en savoir plus, consultez la section Mémoire virtuelle de la documentation ECK.

Remarque : Ce tutoriel fournit des instructions d'utilisation pour l'application suivante : Elastic version 8.9.0. Ces instructions peuvent ne pas représenter les versions les plus récentes de l'application. Pour en savoir plus, consultez la documentation : Elastic.

1. Examinez le fichier manifeste suivant :

   # Copyright 2023 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #      https://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   apiVersion: scheduling.k8s.io/v1
   kind: PriorityClass
   metadata:
     name: user-daemonset-priority
   value: 999999999
   preemptionPolicy: PreemptLowerPriority
   globalDefault: false
   description: "User DaemonSet priority"
   ---
   apiVersion: apps/v1
   kind: DaemonSet
   metadata:
     name: max-map-count-setter
     namespace: elastic-system
     labels:
       k8s-app: max-map-count-setter
   spec:
     selector:
       matchLabels:
         name: max-map-count-setter
     template:
       metadata:
         labels:
           name: max-map-count-setter
       spec:
         priorityClassName: user-daemonset-priority
         nodeSelector:
           cloud.google.com/compute-class: "Balanced"
         initContainers:
           - name: max-map-count-setter
             image: docker.io/bash:5.2.15
             resources:
               requests:
                 cpu: 10m
                 memory: 10Mi
                 ephemeral-storage: 10Mi
               limits:
                 cpu: 50m
                 memory: 32Mi
                 ephemeral-storage: 10Mi
             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.15
             command: ["sleep", "infinity"]
             resources:
               requests:
                 cpu: 10m
                 memory: 10Mi
                 ephemeral-storage: 10Mi
               limits:
                 cpu: 10m
                 memory: 10Mi
                 ephemeral-storage: 10Mi
   

   Ce fichier manifeste décrit un DaemonSet qui configure directement le paramètre du noyau sur l'hôte. 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.

   Le fichier manifeste précédent figure sur une liste d'autorisation pour s'exécuter sur Autopilot. Ne modifiez pas ce fichier manifeste, ni les images de conteneur.

2. Appliquez ce fichier manifeste à votre cluster :

   kubectl apply -f max-map-count-setter-ds.yaml
   

3. Examinez le fichier manifeste suivant :

   apiVersion: elasticsearch.k8s.elastic.co/v1
   kind: Elasticsearch
   metadata:
     name: elasticsearch
     namespace: elastic-system
   spec:
     version: "8.9.0"
     volumeClaimDeletePolicy: DeleteOnScaledownOnly
     podDisruptionBudget:
       spec:
         minAvailable: 2
         selector:
           matchLabels:
             elasticsearch.k8s.elastic.co/cluster-name: elasticsearch
     nodeSets:
       - name: default
         config:
           node.roles: ["master", "data", "ingest", "ml", "remote_cluster_client"]
         podTemplate:
           metadata:
             labels:
               app.kubernetes.io/name: elasticsearch
               app.kubernetes.io/version: "8.9.0"
               app.kubernetes.io/component: "elasticsearch"
               app.kubernetes.io/part-of: "elk"
           spec:
             nodeSelector:
               cloud.google.com/compute-class: "Balanced"
             initContainers:
               - name: max-map-count-check
                 command:
                   - sh
                   - -c
                   - while true; do mmc=$(cat /proc/sys/vm/max_map_count); if test ${mmc} -eq 262144; then exit 0; fi; sleep 1; done
                 resources:
                   requests:
                     cpu: 10m
                     memory: 16Mi
                     ephemeral-storage: 16Mi
                   limits:
                     cpu: 10m
                     memory: 16Mi
                     ephemeral-storage: 16Mi
             containers:
               - name: elasticsearch
                 resources:
                   requests:
                     cpu: 990m
                     memory: 4080Mi
                     ephemeral-storage: 1008Mi
                   limits:
                     cpu: 1000m
                     memory: 4080Mi
                     ephemeral-storage: 1008Mi
                 env:
                   - name: ES_JAVA_OPTS
                     value: "-Xms2g -Xmx2g"
         count: 3
         volumeClaimTemplates:
           - metadata:
               name: elasticsearch-data # Do not change this name unless you set up a volume mount for the data path.
             spec:
               accessModes:
                 - ReadWriteOnce
               resources:
                 requests:
                   storage: 2Gi
               storageClassName: standard-rwo

   Ce fichier manifeste définit un cluster Elasticsearch avec les champs suivants :

   • initContainers : attend que les paramètres du noyau de l'hôte de mémoire virtuelle changent.
   • podDisruptionBudget : indique que le cluster ne sera pas détruit pendant le processus de défragmentation des pods.
   • config.node.roles : configuration des rôles de nœud Elasticsearch. Pour en savoir plus sur les rôles de nœud, consultez la section Nœud dans la documentation d'Elasticsearch.

4. Appliquez ce fichier manifeste à votre cluster :

   kubectl apply -f elasticsearch.yaml
   

5. Attendez que le cluster Elasticsearch soit prêt :

   watch kubectl --namespace elastic-system get elasticsearches.elasticsearch.k8s.elastic.co
   

   Le résultat ressemble à ce qui suit :

   NAME            HEALTH   NODES   VERSION   PHASE   AGE
   elasticsearch   green    3       8.8.0     Ready   5m3s
   

   Une fois le cluster Elasticsearch HEALTH défini sur green et la valeur de PHASE définie sur Ready, revenez à la ligne de commande en appuyant sur Ctrl+C.

Configurer Kibana

Remarque : Ce tutoriel fournit des instructions d'utilisation pour l'application suivante : Elastic version 8.9.0. Ces instructions peuvent ne pas représenter les versions les plus récentes de l'application. Pour en savoir plus, consultez la documentation : Elastic.

1. Examinez le fichier manifeste suivant :

   apiVersion: kibana.k8s.elastic.co/v1
   kind: Kibana
   metadata:
     name: kibana
     namespace: elastic-system
   spec:
     version: "8.9.0"
     count: 1
     elasticsearchRef:
       name: elasticsearch
       namespace: elastic-system
     http:
       tls:
         selfSignedCertificate:
           disabled: true
     config:
       server.publicBaseUrl: https://elk.BASE_DOMAIN
       xpack.reporting.kibanaServer.port: 5601
       xpack.reporting.kibanaServer.protocol: http
       xpack.reporting.kibanaServer.hostname: kibana-kb-http.elastic-system.svc
       xpack.fleet.agents.elasticsearch.hosts: ["https://elasticsearch-es-http.elastic-system.svc:9200"]
       xpack.fleet.agents.fleet_server.hosts: ["https://fleet-server-agent-http.elastic-system.svc:8220"]
       xpack.fleet.packages:
       - name: system
         version: latest
       - name: elastic_agent
         version: latest
       - name: fleet_server
         version: latest
       - name: kubernetes
         version: latest
       xpack.fleet.agentPolicies:
       - name: Fleet Server on ECK policy
         id: eck-fleet-server
         namespace: default
         monitoring_enabled:
         - logs
         - metrics
         unenroll_timeout: 900
         package_policies:
         - name: fleet_server-1
           id: fleet_server-1
           package:
             name: fleet_server
       - name: Elastic Agent on ECK policy
         id: eck-agent
         namespace: default
         monitoring_enabled:
         - logs
         - metrics
         unenroll_timeout: 900
         package_policies:
         - package:
             name: system
           name: system-1
         - package:
             name: kubernetes
           name: kubernetes-1
     podTemplate:
       metadata:
         labels:
           app.kubernetes.io/name: kibana
           app.kubernetes.io/version: "8.9.0"
           app.kubernetes.io/component: "ui"
           app.kubernetes.io/part-of: "elk"
       spec:
         containers:
         - name: kibana
           resources:
             requests:
               memory: 1Gi
               cpu: 500m
               ephemeral-storage: 1Gi
             limits:
               memory: 1Gi
               cpu: 500m
               ephemeral-storage: 1Gi

   Ce fichier manifeste décrit une ressource personnalisée Kibana qui configure les règles d'agent pour le serveur de parcs et les agents.

2. Appliquez ce fichier manifeste à votre cluster :

   kubectl apply -f kibana.yaml
   

3. Attendez que les pods soient prêts :

   watch kubectl --namespace elastic-system get kibanas.kibana.k8s.elastic.co
   

   Le résultat ressemble à ce qui suit :

   NAME     HEALTH   NODES   VERSION   AGE
   kibana   green    1       8.8.0     6m47s
   

   Lorsque la valeur HEALTH des pods est green, revenez à la ligne de commande en appuyant sur Ctrl+C.

Configurer un équilibreur de charge pour accéder à Kibana

Pour accéder à Kibana, créez un objet Kubernetes, un certificat géré par Google, une adresse IP globale et une zone DNS.

1. Créez une adresse IP externe globale :

   gcloud compute addresses create "elastic-stack" --global
   

2. Créez une zone gérée et un jeu d'enregistrements dans Cloud DNS :

   gcloud dns managed-zones create "elk" \
       --description="DNS Zone for Airflow" \
       --dns-name="elk.BASE_DOMAIN" \
       --visibility="public"
   
   gcloud dns record-sets create "elk.BASE_DOMAIN" \
       --rrdatas="$(gcloud compute addresses describe "elastic-stack" --global --format="value(address)")" \
       --ttl="300" \
       --type="A" \
       --zone="elk"
   

3. Déléguez la zone DNS en tant que sous-domaine du domaine de base en créant un jeu d'enregistrements NS avec une liste de serveurs de noms. Vous pouvez obtenir la liste des serveurs de noms à l'aide de la commande suivante :

   gcloud dns record-sets describe elk.BASE_DOMAIN \
       --type="NS" \
       --zone="elk" \
       --format="value(DATA)"
   

4. Examinez le fichier manifeste suivant :

   # Copyright 2023 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #      https://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   apiVersion: networking.gke.io/v1beta1
   kind: FrontendConfig
   metadata:
     name: elastic-stack
     namespace: elastic-system
   spec:
     redirectToHttps:
       enabled: true
       responseCodeName: MOVED_PERMANENTLY_DEFAULT
   ---
   apiVersion: networking.gke.io/v1
   kind: ManagedCertificate
   metadata:
     name: elastic-stack
     namespace: elastic-system
   spec:
     domains:
       - elk.BASE_DOMAIN
   ---
   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: kibana
     namespace: elastic-system
     annotations:
       networking.gke.io/managed-certificates: elastic-stack
       networking.gke.io/v1beta1.FrontendConfig: elastic-stack
       kubernetes.io/ingress.global-static-ip-name: elastic-stack
       kubernetes.io/ingress.class: gce
   spec:
     defaultBackend:
       service:
         name: kibana-kb-http
         port:
           number: 5601
   

   Ce fichier manifeste décrit un certificat géré qui provisionne un certificat SSL pour établir la connexion TLS.

5. Appliquez le fichier manifeste à votre cluster :

   kubectl apply -f ingress.yaml
   

Configurer les agents Elastic

Remarque : Ce tutoriel fournit des instructions d'utilisation pour l'application suivante : Elastic version 8.9.0. Ces instructions peuvent ne pas représenter les versions les plus récentes de l'application. Pour en savoir plus, consultez la documentation : Elastic.

1. Examinez le fichier manifeste suivant :

   apiVersion: agent.k8s.elastic.co/v1alpha1
   kind: Agent
   metadata:
     name: fleet-server
     namespace: elastic-system
   spec:
     version: 8.9.0
     kibanaRef:
       name: kibana
       namespace: elastic-system
     elasticsearchRefs:
       - name: elasticsearch
         namespace: elastic-system
     mode: fleet
     fleetServerEnabled: true
     policyID: eck-fleet-server
     deployment:
       replicas: 1
       podTemplate:
         metadata:
           labels:
             app.kubernetes.io/name: fleet-server
             app.kubernetes.io/version: "8.9.0"
             app.kubernetes.io/component: "agent"
             app.kubernetes.io/part-of: "elk"
         spec:
           containers:
             - name: agent
               resources:
                 requests:
                   memory: 512Mi
                   cpu: 250m
                   ephemeral-storage: 10Gi
                 limits:
                   memory: 512Mi
                   cpu: 250m
                   ephemeral-storage: 10Gi
           volumes:
             - name: "agent-data"
               ephemeral:
                 volumeClaimTemplate:
                   spec:
                     accessModes: ["ReadWriteOnce"]
                     storageClassName: "standard-rwo"
                     resources:
                       requests:
                         storage: 10Gi
           serviceAccountName: fleet-server
           automountServiceAccountToken: true
           securityContext:
             runAsUser: 0

   Ce fichier manifeste décrit un agent Elastic qui configure un serveur de parc avec ECK.

2. Appliquez ce fichier manifeste à votre cluster :

   kubectl apply -f fleet-server-and-agents.yaml
   

3. Attendez que les pods soient prêts :

   watch kubectl --namespace elastic-system get agents.agent.k8s.elastic.co
   

   Le résultat ressemble à ce qui suit :

   NAME            HEALTH   AVAILABLE   EXPECTED   VERSION   AGE
   elastic-agent   green    5           5          8.8.0     14m
   fleet-server    green    1           1          8.8.0     16m
   

   Lorsque la valeur HEALTH des pods est green, revenez à la ligne de commande en appuyant sur Ctrl+C.

Configurer la journalisation et la surveillance

Elastic Stack peut utiliser l'exportateur kube-state-metrics pour collecter des métriques au niveau du cluster.

1. Installer kube-state-metrics :

   helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
   helm repo update
   helm install kube-state-metrics prometheus-community/kube-state-metrics --namespace elastic-system
   

2. Obtenez les identifiants utilisateur elastic Kibana par défaut :

   kubectl get secret elasticsearch-es-elastic-user -o yaml -n elastic-system -o jsonpath='{.data.elastic}' | base64 -d
   

3. Ouvrez https://elk.BASE_DOMAIN dans votre navigateur et connectez-vous à Kibana avec les identifiants.

4. Dans le menu, sélectionnez Analytics, puis Tableaux de bord.

5. Dans le champ de texte de recherche, saisissez Présentation de Kubernetes et sélectionnez Tableau de bord "Présentation" pour afficher les métriques de base.

   Certains panneaux du tableau de bord peuvent ne présenter aucun message de données ni d'erreur, car GKE limite l'accès à certains points de terminaison du plan de contrôle permettant à Kibana d'obtenir les métriques du cluster.