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.

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 de Google Cloudsuivants :

Vous pouvez obtenir 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.

Avant de commencer

  1. 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.
  2. Install the Google Cloud CLI.

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

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

    gcloud init
  5. 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.

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

  7. Enable the GKE API:

    gcloud services enable container.googleapis.com
  8. Install the Google Cloud CLI.

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

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

    gcloud init
  11. 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.

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

  13. Enable the GKE API:

    gcloud services enable container.googleapis.com
  14. 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 :

    1. Lancez une session Cloud Shell depuis la console Google Cloud en cliquant sur Icône d'activation Cloud Shell 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.

    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.

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

    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 :

      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.

    5. Appliquez le fichier manifeste à votre cluster :

      kubectl apply -f ingress.yaml
      

    Configurer les agents 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.

    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

      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.

    1. 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
      
    2. 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.