Elastic Stack in GKE einrichten

In dieser Anleitung erfahren Sie, wie Sie den Elastic Stack mit dem Elastic Cloud on Kubernetes (ECK)-Operator in GKE ausführen.

Elastic Stack ist eine beliebte Open-Source-Lösung, die zum Protokollieren, Überwachen und Analysieren von Daten in Echtzeit verwendet wird. Wenn Sie den Elastic Stack in GKE verwenden, profitieren Sie von der Skalierbarkeit und Zuverlässigkeit von GKE Autopilot und den leistungsstarken Elastic Stack-Funktionen.

Diese Anleitung richtet sich an Kubernetes-Administratoren oder Site Reliability Engineers.

Umgebung vorbereiten

In dieser Anleitung verwenden Sie Cloud Shell zum Verwalten von Ressourcen, die in Google Cloudgehostet werden. Die Software, die Sie für diese Anleitung benötigen, ist in Cloud Shell vorinstalliert, einschließlich kubectl, Helm und der gcloud CLI.

So richten Sie Ihre Umgebung mit Cloud Shell ein:

  1. Starten Sie eine Cloud Shell-Sitzung über die Google Cloud Console. Klicken Sie dazu in der Google Cloud Console auf Symbol für die Cloud Shell-Aktivierung Cloud Shell aktivieren. Dadurch wird im unteren Bereich der Google Cloud Console eine Sitzung gestartet.

  2. Fügen Sie ein Helm-Diagramm-Repository hinzu und aktualisieren Sie es:

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

  3. Klonen Sie das GitHub-Repository:

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

  4. Wechseln Sie in das Arbeitsverzeichnis:

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

GKE-Cluster erstellen

GKE-Cluster mit aktivierter Erfassung von Messwerten der Steuerungsebene erstellen:

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

ECK-Operator bereitstellen

Elastic Cloud on Kubernetes (ECK) ist eine Plattform zum Bereitstellen und Verwalten des Elastic Stack in Kubernetes-Clustern.

ECK automatisiert die Bereitstellung und Verwaltung von Elastic Stack-Clustern und vereinfacht so die Einrichtung und Wartung von Elastic Stack in Kubernetes. Es bietet eine Reihe von benutzerdefinierten Kubernetes-Ressourcen, mit denen Sie Elasticsearch, Kibana, Application Performance Management-Server und andere Elastic Stack-Komponenten in Kubernetes erstellen und konfigurieren können. So können Entwickler und DevOps-Teams Elastic Stack-Cluster in großem Umfang konfigurieren und verwalten.

ECK unterstützt mehrere Elasticsearch-Knoten, automatisches Anwendungs-Failover, nahtlose Upgrades und SSL-Verschlüsselung. ECK bietet auch Funktionen, mit denen Sie die Elasticsearch-Leistung überwachen und Fehler beheben können.

  1. Installieren Sie das ECK-Helm-Diagramm:

    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. Warten Sie, bis der Operator bereit ist:

    watch kubectl get pods -n elastic-system

    Die Ausgabe sieht in etwa so aus:

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

    Wenn der Operator STATUS den Wert Running hat, kehren Sie zur Befehlszeile zurück. Drücken Sie dazu Ctrl+C.

Elastic Stack mit ECK konfigurieren

Wenn Sie den Elastic Stack mit Elasticsearch, Kibana und Elastic Agent im Flottenmodus verwenden, können Sie eine leistungsstarke, skalierbare und vollständig verwaltete Lösung zum Verwalten und Visualisieren von Daten mit Kibana einrichten.

Kibana ist ein Open-Source-Tool für Datenanalyse und ‑visualisierung, mit dem Sie Daten in Elasticsearch suchen, analysieren und visualisieren können.

Elastic Agent ist ein leichter Datenversand, der Daten aus verschiedenen Quellen wie Logs oder Messwerten erfasst und automatisch an Elasticsearch sendet.

Elastic Fleet ist ein Betriebsmodus, in dem Elastic-Agents Informationen an einen zentralen Flottenserver senden, der für die Konfiguration und Verwaltung zuständig ist. Der Flottenserver vereinfacht die Bereitstellung, Konfiguration und Skalierung von Elastic Agents und erleichtert so die Verwaltung großer und komplexer Bereitstellungen.

Elasticsearch-Autoscaling ist eine Funktion zur Selbstüberwachung, die auf Grundlage einer vom Operator definierten Richtlinie melden kann, wenn zusätzliche Ressourcen erforderlich sind. Eine Richtlinie kann beispielsweise festlegen, dass eine bestimmte Ebene basierend auf dem verfügbaren Speicherplatz skaliert werden soll. Elasticsearch kann den Speicherplatz überwachen und eine Skalierung vorschlagen, wenn ein Engpass vorhergesagt wird. Es liegt jedoch weiterhin am Betreiber, die erforderlichen Ressourcen hinzuzufügen. Weitere Informationen zum Elasticsearch-Autoscaling finden Sie in der Elasticsearch-Dokumentation unter Autoscaling.

Elasticsearch-Cluster konfigurieren

Elasticsearch ist eine verteilte, RESTful-Such- und Analyse-Engine, die zum schnellen und effizienten Speichern und Suchen großer Datenmengen entwickelt wurde.

Wenn Sie den Elastic Stack in Kubernetes bereitstellen, sollten Sie die VM-Einstellungen verwalten, insbesondere vm.max_map_count setting, das für Elasticsearch erforderlich ist. vm.max_map_count gibt die Anzahl der Speicherbereiche an, die ein Prozess einer Datei zuweisen kann. In Elasticsearch muss dieser Wert auf mindestens 262144 festgelegt sein, damit die Software optimal ausgeführt werden kann. Weitere Informationen finden Sie in der ECK-Dokumentation unter Virtueller Speicher.

  1. Prüfen Sie das folgende Manifest:

    # 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

    Dieses Manifest beschreibt ein DaemonSet, das die Kerneleinstellung direkt auf dem Host konfiguriert. Ein DaemonSet ist ein Kubernetes-Controller, der dafür sorgt, dass auf jedem Knoten in einem Cluster eine Kopie eines Pods ausgeführt wird.

    Das vorherige Manifest befindet sich auf einer Zulassungsliste für die Ausführung auf Autopilot. Ändern Sie dieses Manifest nicht, auch nicht die Containerbilder.

  2. Wenden Sie dieses Manifest auf Ihren Cluster an:

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

  3. Prüfen Sie das folgende Manifest:

    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

    In diesem Manifest wird ein Elasticsearch-Cluster mit den folgenden Feldern definiert:

    • initContainers: Wartet, bis sich die Kerneleinstellungen des virtuellen Arbeitsspeicherhosts ändern.
    • podDisruptionBudget: Gibt an, dass der Cluster während der Defragmentierung der Pods nicht zerstört wird.
    • config.node.roles: Konfiguration der Elasticsearch-Knotenrollen. Weitere Informationen zu Knotenrollen finden Sie in der Elasticsearch-Dokumentation unter Knoten.

  4. Wenden Sie dieses Manifest auf Ihren Cluster an:

    kubectl apply -f elasticsearch.yaml

  5. Warten Sie, bis der Elasticsearch-Cluster bereit ist:

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

    Die Ausgabe sieht in etwa so aus:

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

    Wenn der Elasticsearch-Cluster HEALTH den Wert green und PHASE den Wert Ready hat, kehren Sie zur Befehlszeile zurück. Drücken Sie dazu Ctrl+C.

Kibana konfigurieren

  1. Prüfen Sie das folgende Manifest:

    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

    Dieses Manifest beschreibt eine benutzerdefinierte Kibana-Ressource, mit der Agent-Richtlinien für den Flottenserver und die Agents konfiguriert werden.

  2. Wenden Sie dieses Manifest auf Ihren Cluster an:

    kubectl apply -f kibana.yaml

  3. Warten Sie, bis die Pods bereit sind:

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

    Die Ausgabe sieht in etwa so aus:

    NAME     HEALTH   NODES   VERSION   AGE
kibana   green    1       8.8.0     6m47s

    Wenn die Pods-HEALTH den Wert green hat, kehren Sie zur Befehlszeile zurück. Drücken Sie dazu Ctrl+C.

Load-Balancer für den Zugriff auf Kibana konfigurieren

Um auf Kibana zuzugreifen, erstellen Sie ein Kubernetes Ingress-Objekt, ein von Google verwaltetes Zertifikat, eine globale IP-Adresse und eine DNS-Zone.

  1. Globale externe IP-Adresse erstellen:

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

  2. Verwaltete Zone und Datensatz in Cloud DNS erstellen:

    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. Delegieren Sie die DNS-Zone als Subdomain der Basisdomain, indem Sie einen NS-Eintragssatz mit einer Liste von Nameservern erstellen. Mit dem folgenden Befehl können Sie eine Liste der Nameserver abrufen:

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

  4. Prüfen Sie das folgende Manifest:

    # 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

    Dieses Manifest beschreibt ein ManagedCertificate, mit dem ein SSL-Zertifikat für die TLS-Verbindung bereitgestellt wird.

  5. Wenden Sie das Manifest auf Ihren Cluster an:

    kubectl apply -f ingress.yaml

Elastic Agents konfigurieren

  1. Prüfen Sie das folgende Manifest:

    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

    Dieses Manifest beschreibt einen Elastic Agent, der einen Flottenserver mit ECK konfiguriert.

  2. Wenden Sie dieses Manifest auf Ihren Cluster an:

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

  3. Warten Sie, bis die Pods bereit sind:

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

    Die Ausgabe sieht in etwa so aus:

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

    Wenn die Pods-HEALTH den Wert green hat, kehren Sie zur Befehlszeile zurück. Drücken Sie dazu Ctrl+C.

Logging und Monitoring konfigurieren

Der Elastic Stack kann den kube-state-metrics-Exporter verwenden, um Messwerte auf Clusterebene zu erfassen.

  1. Installieren Sie 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. Rufen Sie die Standardanmeldedaten für den Kibana-Nutzer elastic ab:

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

  3. Öffnen Sie https://elk.BASE_DOMAIN in Ihrem Browser und melden Sie sich mit den Anmeldedaten in Kibana an.

  4. Wählen Sie im Menü Analytics und dann Dashboards aus.

  5. Geben Sie in das Suchfeld Kubernetes-Übersicht ein und wählen Sie Übersichts-Dashboard aus, um die grundlegenden Messwerte aufzurufen.

    In einigen Dashboard-Feldern werden möglicherweise keine Daten oder Fehlermeldungen angezeigt, da GKE den Zugriff auf einige der Steuerungsebenen-Endpunkte einschränkt, die Kibana zum Abrufen von Clustermesswerten verwendet.