Diese Seite wurde von der Cloud Translation API übersetzt.

Elastic Stack in GKE einrichten

Autopilot

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.

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:

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

Neuen Nutzern von Google Cloud 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.

Hinweis:Wenn Sie die gcloud CLI bereits installiert haben, prüfen Sie mit dem Befehl gcloud components update, ob Sie die aktuelle Version verwenden.

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 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 (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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 mit dem Befehl gcloud components update, ob Sie die aktuelle Version verwenden.

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 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 (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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

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, myemail@example.com.
- 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:

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

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.

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

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.

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

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.

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

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

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

Globale externe IP-Adresse erstellen:

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

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"

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

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, mit dem ein SSL-Zertifikat für die TLS-Verbindung bereitgestellt wird.

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

Der Elastic Stack kann den kube-state-metrics-Exporter 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 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

Öffnen Sie https://elk.BASE_DOMAIN in Ihrem 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 Ü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.

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 die DNS-Eintragsgruppe, 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

Elastic Stack in GKE einrichten Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Ziele

Kosten

Hinweise

Umgebung vorbereiten

GKE-Cluster erstellen

ECK-Operator bereitstellen

Elastic Stack mit ECK konfigurieren

Elasticsearch-Cluster konfigurieren

Kibana konfigurieren

Load-Balancer für den Zugriff auf Kibana konfigurieren

Elastic Agents konfigurieren

Logging und Monitoring konfigurieren

Bereinigen

Projekt löschen

Einzelne Ressourcen löschen

Nächste Schritte

Elastic Stack in GKE einrichten