Elastic Stack in GKE einrichten

Autopilot

In dieser Anleitung erfahren Sie, wie Sie den Elastic Stack in GKE mit dem ECK-Operator (Elastic Cloud on Kubernetes) 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.

Ziele

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

Kosten

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

• GKE

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.

Neuen Nutzern von Google Cloud steht möglicherweise ein kostenloser Testzeitraum 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.

Hinweis: Wenn Sie die gcloud CLI bereits installiert haben, prüfen Sie, ob Sie die aktuelle Version haben, indem Sie gcloud components update ausführen.

Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

Führen Sie den folgenden Befehl aus, um die gcloud CLI zu initialisieren:

gcloud init

Create or select a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the 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.

Verify that billing is enabled for your Google Cloud project.

Enable the GKE API:

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

gcloud services enable container.googleapis.com

Install the Google Cloud CLI.

Hinweis: Wenn Sie die gcloud CLI bereits installiert haben, prüfen Sie, ob Sie die aktuelle Version haben, indem Sie gcloud components update ausführen.

Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

Führen Sie den folgenden Befehl aus, um die gcloud CLI zu initialisieren:

gcloud init

Create or select a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the 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.

Verify that billing is enabled for your Google Cloud project.

Enable the GKE API:

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

gcloud services enable container.googleapis.com

1. 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 the following:

   • PROJECT_ID: Your project ID.
   • USER_IDENTIFIER: The identifier for your user account. For example, [e-mail].
   • ROLE: The IAM role that you grant to your user account.
• 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 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 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.

Hinweis: Dieses Tutorial enthält eine Anleitung für die Arbeit mit der App ECK version 2.8.0. Die Anleitung bezieht sich möglicherweise nicht auf neuere Versionen der App. Weitere Informationen finden Sie in der Dokumentation: ECK.

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 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 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 benötigt werden. In einer Richtlinie kann beispielsweise festgelegt werden, dass eine bestimmte Ebene basierend auf dem verfügbaren Speicherplatz skaliert werden soll. Elasticsearch kann den Speicherplatz überwachen und Skalierungsvorschläge machen, 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 Durchsuchen 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.

Hinweis: Dieses Tutorial enthält eine Anleitung für die Arbeit mit der App Elastic version 8.9.0. Die Anleitung bezieht sich möglicherweise nicht auf neuere Versionen der App. Weitere Informationen finden Sie in der Dokumentation: Elastic.

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 oben genannte 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

Hinweis: Dieses Tutorial enthält eine Anleitung für die Arbeit mit der App Elastic version 8.9.0. Die Anleitung bezieht sich möglicherweise nicht auf neuere Versionen der App. Weitere Informationen finden Sie in der Dokumentation: Elastic.

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

Hinweis: Dieses Tutorial enthält eine Anleitung für die Arbeit mit der App Elastic version 8.9.0. Die Anleitung bezieht sich möglicherweise nicht auf neuere Versionen der App. Weitere Informationen finden Sie in der Dokumentation: Elastic.

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.

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, zum Beispiel eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, anstatt 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.

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

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