Configura Elastic Stack en GKE

Autopilot

En este instructivo, se muestra cómo ejecutar Elastic Stack en GKE con el operador de Elastic Cloud on Kubernetes (ECK).

Elastic Stack es una solución de código abierto popular que se usa para registrar, supervisar y analizar datos en tiempo real. Cuando usas Elastic Stack en GKE, puedes beneficiarte de la escalabilidad y la confiabilidad que proporcionan Autopilot de GKE y las potentes funciones de Elastic Stack.

Este instructivo está dirigido a los administradores de Kubernetes o ingenieros de confiabilidad de sitios.

Objetivos

• Crear un clúster de GKE
• Implementar el operador de ECK.
• Configurar los clústeres de Elasticsearch y Kibana con el operador de ECK.
• Implementar Elastic Stack completo con el operador de ECK.
• Ajusta la escala de los clústeres de Elasticsearch automáticamente y actualiza la implementación de Elastic Stack.
• Usar Elastic Stack para supervisar los entornos de Kubernetes.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

• GKE

Para obtener una estimación de costos en función del uso previsto, usa la calculadora de precios.

Es posible que los usuarios de Google Cloud nuevos cumplan con los requisitos para acceder a una prueba gratuita.

Cuando completes las tareas que se describen en este documento, podrás borrar los recursos que creaste para evitar que se te siga facturando. Para obtener más información, consulta Realiza una limpieza.

Antes de comenzar

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.

Nota: Si ya instalaste la gcloud CLI, asegúrate de tener la versión más reciente. Para esto, ejecuta gcloud components update.

Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

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.

Nota: Si ya instalaste la gcloud CLI, asegúrate de tener la versión más reciente. Para esto, ejecuta gcloud components update.

Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

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.
• Debes tener un nombre de dominio. El nombre de dominio no debe tener más de 63 caracteres. Puedes usar Cloud Domains o algún otro registrador.

Prepare el entorno

En este instructivo, usarás Cloud Shell para administrar recursos alojados en Google Cloud. Cloud Shell tiene preinstalado el software que necesitas para este instructivo, incluidos kubectl, Helm y la CLI de gcloud.

Para configurar tu entorno con Cloud Shell, sigue estos pasos:

1. Para iniciar una sesión de Cloud Shell desde la Google Cloud consola, haz clic en Activar Cloud Shell en la Google Cloud consola. Esto inicia una sesión en el panel inferior de la consola de Google Cloud .

2. Agrega un repositorio de gráficos de Helm y actualízalo:

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

3. Clona el repositorio de GitHub:

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

4. Cambia al directorio de trabajo:

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

Crea un clúster de GKE

Crea un clúster de GKE con la recopilación de métricas del plano de control habilitada:

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

Implementar el operador de ECK

Elastic Cloud on Kubernetes (ECK) es una plataforma para implementar y administrar Elastic Stack en clústeres de Kubernetes.

ECK automatiza la implementación y administración de clústeres de Elastic Stack, lo que simplifica el proceso de configuración y mantenimiento de Elastic Stack en Kubernetes. Proporciona un conjunto de recursos personalizados de Kubernetes que puedes usar para crear y configurar Elasticsearch, Kibana, el servidor de administración del rendimiento de las aplicaciones y otros componentes de Elastic Stack en Kubernetes. Esto permite que los desarrolladores y los equipos de DevOps configuren y administren clústeres de Elastic Stack a gran escala.

ECK admite varios nodos de Elasticsearch, conmutación por error automática de aplicaciones, actualizaciones sin interrupciones y encriptación SSL. ECK también incluye funciones que te permiten supervisar y solucionar problemas de rendimiento de Elasticsearch.

Nota: En este instructivo, se proporcionan instrucciones para trabajar con esta app: ECK version 2.8.0. Es posible que las instrucciones no representen las versiones más recientes de la app. Para obtener más información, consulta la documentación: ECK.

1. Instala el gráfico de Helm para ECK:

   helm upgrade --install "elastic-operator" "elastic/eck-operator" \
       --version="2.8.0" \
       --create-namespace \
       --namespace="elastic-system" \
       --set="resources.limits.cpu=250m" \
       --set="resources.limits.memory=512Mi" \
       --set="resources.limits.ephemeral-storage=1Gi" \
       --set="resources.requests.cpu=250m" \
       --set="resources.requests.memory=512Mi" \
       --set="resources.requests.ephemeral-storage=1Gi"
   

2. Espera a que la aplicación esté lista:

   watch kubectl get pods -n elastic-system
   

   El resultado es similar al siguiente:

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

   Cuando el operador STATUS sea Running, presiona Ctrl+C para volver a la línea de comandos.

Configura Elastic Stack con ECK

Si usas Elastic Stack con Elasticsearch, Kibana y Elastic Agent en modo de flota, puedes configurar una solución potente, escalable y completamente administrada para administrar y visualizar datos mediante Kibana.

Kibana es una herramienta de visualización y análisis de datos de código abierto que te permite buscar, analizar y visualizar datos en Elasticsearch.

Elastic Agent es un transportador de datos liviano que recopila datos de diferentes fuentes, como registros o métricas, y los envía de forma automática a Elasticsearch.

Elastic Fleet es un modo de operación en el que los agentes de Elastic se informan a un servidor de flota central, que controla su configuración y administración. El servidor de flota simplifica la implementación, la configuración y el escalamiento de los agentes de Elastic, lo que facilita la administración de implementaciones grandes y complejas.

El ajuste de escala automático de Elasticsearch es una función de autosupervisión que puede informar cuando se necesitan recursos adicionales según una política definida por el operador. Por ejemplo, una política puede especificar que un nivel determinado debe escalar en función del espacio disponible en el disco. Elasticsearch puede supervisar el espacio en el disco y sugerir escalamiento si predice una escasez, aunque todavía depende del operador agregar los recursos necesarios. Para obtener más información sobre el ajuste de escala automático de Elasticsearch, consulta Ajuste de escala automático en la documentación de Elasticsearch.

Configura un clúster de Elasticsearch

Elasticsearch proporciona un motor distribuido de búsqueda y estadísticas RESTful diseñado para almacenar y buscar grandes volúmenes de datos con rapidez y eficiencia.

Cuando implementas Elastic Stack en Kubernetes, debes administrar la configuración de la VM, en particular el vm.max_map_count setting, que requiere Elasticsearch. vm.max_map_count especifica la cantidad de áreas de memoria que un proceso puede asignar a un archivo. Elasticsearch debe tener este valor configurado como al menos 262144 para ejecutarse de manera óptima. Para obtener más información, consulta Memoria virtual en la documentación de ECK.

Nota: En este instructivo, se proporcionan instrucciones para trabajar con esta app: Elastic version 8.9.0. Es posible que las instrucciones no representen las versiones más recientes de la app. Para obtener más información, consulta la documentación: Elastic.

1. Revisa el siguiente manifiesto:

   # 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
   

   En este manifiesto, se describe un DaemonSet que configura la configuración del kernel directamente en el host. Un DaemonSet es un controlador de Kubernetes que garantiza que se ejecute una copia de un Pod en cada nodo de un clúster.

   El manifiesto anterior está en una lista de anunciantes permitidos para ejecutarse en Autopilot. No modifiques este manifiesto, incluidas las imágenes del contenedor.

2. Aplica este manifiesto a tu clúster:

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

3. Revisa el siguiente manifiesto:

   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

   En este manifiesto, se define un clúster de Elasticsearch con los siguientes campos:

   • initContainers: Espera a que cambie la configuración del kernel del host de memoria virtual.
   • podDisruptionBudget: especifica que el clúster no se destruirá durante el proceso de desfragmentación de los Pods.
   • config.node.roles: configuración de roles del nodo de Elasticsearch. Para obtener más información sobre los roles del nodo, consulta Nodo en la documentación de Elasticsearch.

4. Aplica este manifiesto a tu clúster:

   kubectl apply -f elasticsearch.yaml
   

5. Espera a que el clúster de Elasticsearch esté listo:

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

   El resultado es similar al siguiente:

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

   Cuando el clúster de Elasticsearch HEALTH sea green y PHASE sea Ready, presiona Ctrl+C para volver a la línea de comandos.

Configura Kibana

Nota: En este instructivo, se proporcionan instrucciones para trabajar con esta app: Elastic version 8.9.0. Es posible que las instrucciones no representen las versiones más recientes de la app. Para obtener más información, consulta la documentación: Elastic.

1. Revisa el siguiente manifiesto:

   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

   En este manifiesto, se describe un recurso personalizado de Kibana que configura las políticas de agentes para el servidor de la flota y los agentes.

2. Aplica este manifiesto a tu clúster:

   kubectl apply -f kibana.yaml
   

3. Espera a que los Pods estén listos.

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

   El resultado es similar al siguiente:

   NAME     HEALTH   NODES   VERSION   AGE
   kibana   green    1       8.8.0     6m47s
   

   Cuando HEALTH de los Pods sea green, vuelve a la línea de comandos presionando Ctrl+C.

Configura un balanceador de cargas para acceder a Kibana

Para acceder a Kibana, crea un objeto Ingress de Kubernetes, un certificado administrado por Google, una dirección IP global y una zona de DNS.

1. Crea una dirección IP externa global:

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

2. Crea una zona administrada y un conjunto de registros en Cloud DNS:

   gcloud dns managed-zones create "elk" \
       --description="DNS Zone for Airflow" \
       --dns-name="elk.BASE_DOMAIN" \
       --visibility="public"
   
   gcloud dns record-sets create "elk.BASE_DOMAIN" \
       --rrdatas="$(gcloud compute addresses describe "elastic-stack" --global --format="value(address)")" \
       --ttl="300" \
       --type="A" \
       --zone="elk"
   

3. Para delegar la zona DNS como un subdominio del dominio base, crea un conjunto de registros NS con una lista de servidores de nombres. Puedes obtener una lista de servidores de nombres con el siguiente comando:

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

4. Revisa el siguiente manifiesto:

   # 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
   

   Este manifiesto describe un ManagedCertificate que aprovisiona un certificado SSL para establecer la conexión TLS.

5. Aplica el manifiesto al clúster:

   kubectl apply -f ingress.yaml
   

Configura los agentes de Elastic

Nota: En este instructivo, se proporcionan instrucciones para trabajar con esta app: Elastic version 8.9.0. Es posible que las instrucciones no representen las versiones más recientes de la app. Para obtener más información, consulta la documentación: Elastic.

1. Revisa el siguiente manifiesto:

   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

   En este manifiesto, se describe un agente de Elastic que configura un servidor de flota con ECK.

2. Aplica este manifiesto a tu clúster:

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

3. Espera a que los Pods estén listos.

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

   El resultado es similar al siguiente:

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

   Cuando HEALTH de los Pods sea green, vuelve a la línea de comandos presionando Ctrl+C.

Configurar el registro y la supervisión

Elastic Stack puede usar el exportador de kube-state-metrics para recopilar métricas a nivel de clúster.

1. Instala 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. Obtén las credenciales de usuario elastic de Kibana predeterminadas:

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

3. Abre https://elk.BASE_DOMAIN en tu navegador y accede a Kibana con las credenciales.

4. En el menú, selecciona Analytics y, luego, Paneles.

5. En el campo de texto de búsqueda, ingresa Descripción general de Kubernetes y selecciona Panel de descripción general para ver las métricas básicas.

   Es posible que algunos de los paneles del panel no muestren datos ni mensajes de error porque GKE limita el acceso a algunos de los extremos del plano de control que Kibana usa para obtener métricas del clúster.

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

Precaución: Borrar un proyecto tiene las siguientes consecuencias:

• Se borra todo su contenido. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
• Se pierden los IDs personalizados de los proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID personalizado del proyecto que desees utilizar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto, en lugar de todo el proyecto.

Si planeas explorar varios instructivos, arquitecturas o guías de inicio rápido, reutilizar proyectos puede ser útil para no exceder los límites de cuota de los proyectos.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Borra los recursos individuales

Si usaste un proyecto existente y no quieres borrarlo, borra los recursos individuales.

1. Borra los componentes de Elastic Stack, el operador de ECK y 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. Borra el conjunto de registros DNS, la dirección IP, la zona administrada de DNS y el clúster de GKE:

   gcloud dns record-sets delete "elk.BASE_DOMAIN" \
       --type="A" \
       --zone="elk" \
       --quiet
   
   gcloud compute addresses delete "elastic-stack" \
       --global \
       --quiet
   
   gcloud dns managed-zones delete "elk" --quiet
   
   gcloud container clusters delete "elk-stack" \
       --location="us-central1" \
       --quiet
   

¿Qué sigue?

• Explora arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.