Elastic Stack in GKE einrichten

Autopilot

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

Elastic Stack ist eine beliebte Open-Source-Lösung, mit der Daten in Echtzeit protokolliert, überwacht und analysiert werden. Durch die Verwendung von Elastic Stack in GKE können Sie von der Skalierbarkeit und Zuverlässigkeit von GKE Autopilot und den leistungsstarken Elastic Stack-Features profitieren.

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

Ziele

einen GKE-Cluster installieren
ECK-Operator bereitstellen
Konfigurieren Sie Elasticsearch-Cluster und Kibana mithilfe des ECK-Operators.
Mithilfe des ECK-Operators einen vollständigen Elastic Stack bereitstellen
Elasticsearch-Cluster automatisch skalieren und die Elastic Stack-Bereitstellung aktualisieren
Kubernetes-Umgebungen mit Elastic Stack überwachen

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweise

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

Sie müssen Inhaber des Domainnamens sein. Der Domainname darf maximal 63 Zeichen haben. Sie können Google Domains oder einen anderen Registrator verwenden.

Umgebung vorbereiten

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

So richten Sie Ihre Umgebung mit Cloud Shell ein:

Starten Sie eine Cloud Shell-Sitzung über die Google Cloud Console. Klicken Sie dazu in der Google Cloud Console auf Cloud Shell aktivieren. Dadurch wird im unteren Bereich der Google Cloud Console eine Sitzung gestartet.
Fügen Sie ein Helm-Diagramm-Repository hinzu und aktualisieren Sie es:
```
helm repo add elastic https://helm.elastic.co
helm repo update
```

Klonen Sie das GitHub-Repository:

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

Wechseln Sie in das Arbeitsverzeichnis:

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

GKE-Cluster erstellen

Erstellen Sie einen GKE-Cluster mit aktivierter Erfassung von Messwerten der Steuerungsebene:

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 auf Kubernetes-Clustern.

ECK automatisiert die Bereitstellung und Verwaltung von Elastic Stack-Clustern und vereinfacht die Einrichtung und Wartung von Elastic Stack auf 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. Auf diese Weise können Entwickler und DevOps-Teams Elastic Stack-Cluster in großem Maßstab konfigurieren und verwalten.

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

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"

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 Elastic Stack mit Elasticsearch, Kibana und Elastic Agent im Fleet-Modus 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 zur 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 die Verwaltung großer und komplexer Bereitstellungen.

Das Elasticsearch-Autoscaling ist ein selbst überwachendes Feature, das auf der Grundlage einer vom Operator definierten Richtlinie Informationen darüber senden kann, wann zusätzliche Ressourcen benötigt werden. Eine Richtlinie kann beispielsweise festlegen, dass eine bestimmte Stufe 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 in der Verantwortung des Betreibers, die erforderlichen Ressourcen hinzuzufügen. Weitere Informationen zum Autoscaling in Elasticsearch finden Sie in der Elasticsearch-Dokumentation unter Autoscaling.

Elasticsearch-Cluster konfigurieren

Elasticsearch ist eine verteilte, RESTful-Such- und Analyse-Engine, die für das schnelle und effiziente Speichern und Suchen großer Datenmengen entwickelt wurde.

Wenn Sie den Elastic Stack in Kubernetes bereitstellen, sollten Sie die VM-Einstellungen verwalten, insbesondere die vm.max_map_count setting, die von Elasticsearch benötigt wird. vm.max_map_count gibt die Anzahl der Speicherbereiche an, die ein Prozess einer Datei zuweisen kann. Für Elasticsearch muss dieser Wert auf mindestens 262144 festgelegt sein, um eine optimale Ausführung zu erzielen. Weitere Informationen finden Sie in der ECK-Dokumentation unter Virtueller Arbeitsspeicher.

Prüfen Sie das folgende Manifest:
```
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: user-daemonset-priority
value: 999999999
preemptionPolicy: PreemptLowerPriority
globalDefault: false
description: "User DaemonSet priority"
```
Dieses Manifest beschreibt ein DaemonSet, das die Kernel-Einstellung direkt auf dem Host konfiguriert. Dieses Manifest steht auf einer Zulassungsliste, um in Autopilot ausgeführt zu werden. Ändern Sie dieses Manifest nicht, einschließlich der Container-Images.

Wenden Sie dieses Manifest auf Ihren Cluster an:

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

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

Dieses Manifest definiert einen Elasticsearch-Cluster mit den folgenden Feldern:

initContainers: wartet, bis sich die Kerneleinstellungen des virtuellen Arbeitsspeicher-Hosts ändern.
podDisruptionBudget: gibt an, dass der Cluster während des Defragmentierungsprozesses der Pods nicht gelöscht wird.
config.node.roles: Konfiguration der Elasticsearch-Knotenrollen Weitere Informationen zu Knotenrollen finden Sie in der Elasticsearch-Dokumentation unter Knoten.

Wenden Sie dieses Manifest auf Ihren Cluster an:
```
kubectl apply -f elasticsearch.yaml
```
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

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, die Agent-Richtlinien für den Flottenserver und die Agents konfiguriert.

Wenden Sie dieses Manifest auf Ihren Cluster an:
```
kubectl apply -f kibana.yaml
```
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

Für den Zugriff auf Kibana erstellen Sie ein Kubernetes-Ingress-Objekt, ein von Google verwaltetes Zertifikat, eine globale IP-Adresse und eine DNS-Zone.

Erstellen Sie eine globale externe IP-Adresse:

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

So erstellen Sie eine verwaltete Zone und einen verwalteten Datensatz in 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"

Delegieren Sie die DNS-Zone als Subdomain der Basisdomain, indem Sie einen NS-Eintrag mit einer Nameserver-Liste 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)"
```

Prüfen Sie das folgende Manifest:

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

Dieses Manifest beschreibt ein ManagedCertificate, das ein SSL-Zertifikat für die TLS-Verbindung bereitstellt.

Wenden Sie das Manifest auf Ihren Cluster an:
```
kubectl apply -f ingress.yaml
```

Elastic-Agents konfigurieren

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.

Wenden Sie dieses Manifest auf Ihren Cluster an:

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

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

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

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

Rufen Sie die standardmäßigen elastic-Nutzeranmeldedaten für Kibana ab:

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

Öffnen Sie https://elk.BASE_DOMAIN im Browser und melden Sie sich mit den Anmeldedaten in Kibana an.
Wählen Sie im Menü Analytics und dann Dashboards aus.
Geben Sie in das Suchfeld Kubernetes-Übersicht ein und wählen Sie Übersichtsdashboard aus, um grundlegende Messwerte zu sehen.

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

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Projekt löschen

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Einzelne Ressourcen löschen

Wenn Sie ein vorhandenes Projekt verwendet haben und es nicht löschen möchten, können Sie die einzelnen Ressourcen löschen.

Löschen Sie die Elastic Stack-Komponenten, den ECK-Operator und kube-state-metrics:

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

Löschen Sie den DNS-Eintragssatz, die IP-Adresse, die verwaltete DNS-Zone und den GKE-Cluster:

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

Nächste Schritte

Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center