Configurer Elastic Stack sur GKE

Autopilot

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.

Objectifs

Créer un cluster GKE.
Déployer l'opérateur ECK.
Configurer les clusters Elasticsearch et Kibana à l'aide de l'opérateur ECK.
Déployer une pile Elastic Stack complète à l'aide de l'opérateur ECK.
Autoscaling des clusters Elasticsearch et mise à niveau du déploiement Elastic Stack
Utiliser Elastic Stack pour surveiller les environnements Kubernetes.

Coûts

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

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, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

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.

To initialize the gcloud CLI, run the following command:

gcloud init

Note: If you installed the gcloud CLI previously, make sure you have the latest version by running

gcloud components
      update

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.

Make sure that billing is enabled for your Google Cloud project.

Enable the GKE API:

gcloud services enable container.googleapis.com

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Note: If you installed the gcloud CLI previously, make sure you have the latest version by running

gcloud components
      update

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.

Make sure that billing is enabled for your Google Cloud project.

Enable the GKE API:

gcloud services enable container.googleapis.com

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/container.clusterAdmin
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
- Replace PROJECT_ID with your project ID.
- Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.
- Replace ROLE with each individual role.

Vous devez détenir un nom de domaine. Celui-ci ne doit pas dépasser 63 caractères. Vous pouvez utiliser Cloud Domains ou un autre bureau d'enregistrement.

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 :

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

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

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

Clonez le dépôt GitHub.

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

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.

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"

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.

Examinez le fichier manifeste suivant :
```
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: user-daemonset-priority
value: 999999999
preemptionPolicy: PreemptLowerPriority
globalDefault: false
description: "User DaemonSet priority"
```
Ce fichier manifeste décrit un DaemonSet qui configure directement le paramètre du noyau sur l'hôte. Ce fichier manifeste figure sur une liste d'autorisation pour s'exécuter sur Autopilot. Ne modifiez pas ce fichier manifeste, ni les images de conteneur.

Appliquez ce fichier manifeste à votre cluster :

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

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.

Appliquez ce fichier manifeste à votre cluster :
```
kubectl apply -f elasticsearch.yaml
```
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

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.

Appliquez ce fichier manifeste à votre cluster :
```
kubectl apply -f kibana.yaml
```
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.

Créez une adresse IP externe globale :

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

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"

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)"
```

Examinez le fichier manifeste suivant :

apiVersion: networking.gke.io/v1
kind: ManagedCertificate
metadata:
  name: elastic-stack
  namespace: elastic-system
spec:
  domains:
    - elk.BASE_DOMAIN

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

Appliquez le fichier manifeste à votre cluster :
```
kubectl apply -f ingress.yaml
```

Configurer les agents Elastic

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.

Appliquez ce fichier manifeste à votre cluster :

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

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.

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

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

Ouvrez https://elk.BASE_DOMAIN dans votre navigateur et connectez-vous à Kibana avec les identifiants.
Dans le menu, sélectionnez Analytics, puis Tableaux de bord.
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.

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

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

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

Supprimer les ressources individuelles

Si vous avez utilisé un projet existant et que vous ne souhaitez pas le supprimer, supprimez les ressources individuelles.

Supprimez les composants Elastic Stack, l'opérateur ECK et les métriques kube-state :

kubectl --namespace elastic-system delete ingresses.networking.k8s.io elastic-stack
kubectl --namespace elastic-system delete managedcertificates.networking.gke.io elastic-stack
kubectl --namespace elastic-system delete frontendconfigs.networking.gke.io elastic-stack
kubectl --namespace elastic-system delete agents.agent.k8s.elastic.co elastic-agent
kubectl --namespace elastic-system delete agents.agent.k8s.elastic.co fleet-server
kubectl --namespace elastic-system delete kibanas.kibana.k8s.elastic.co kibana
kubectl --namespace elastic-system delete elasticsearches.elasticsearch.k8s.elastic.co elasticsearch
kubectl --namespace elastic-system delete daemonsets.apps max-map-count-setter
kubectl --namespace elastic-system delete pvc --selector='elasticsearch.k8s.elastic.co/cluster-name=elasticsearch'
helm --namespace elastic-system uninstall kube-state-metrics
helm --namespace elastic-system uninstall elastic-operator

Supprimez le jeu d'enregistrements DNS, l'adresse IP, la zone gérée DNS et le cluster GKE :

gcloud dns record-sets delete "elk.BASE_DOMAIN" \
    --type="A" \
    --zone="elk" \
    --quiet

gcloud compute addresses delete "elastic-stack" \
    --global \
    --quiet

gcloud dns managed-zones delete "elk" --quiet

gcloud container clusters delete "elk-stack" \
    --location="us-central1" \
    --quiet

Étapes suivantes

Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Cloud Architecture Center.