Configurar Elastic Stack en GKE

En este tutorial se explica cómo ejecutar Elastic Stack en GKE mediante el operador Elastic Cloud on Kubernetes (ECK).

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

Este tutorial está dirigido a administradores de Kubernetes o ingenieros de fiabilidad de sitios.

Objetivos

  • Crea un clúster de GKE.
  • Implementa el operador ECK.
  • Configura clústeres de Elasticsearch y Kibana con el operador ECK.
  • Despliega un Elastic Stack completo con el operador ECK.
  • Autoescalar clústeres de Elasticsearch y actualizar la implementación de Elastic Stack.
  • Usa Elastic Stack para monitorizar entornos de Kubernetes.

Costes

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos Google Cloud pueden disfrutar de una prueba gratuita.

Cuando termines las tareas que se describen en este documento, puedes evitar que se te siga facturando eliminando los recursos que has creado. Para obtener más información, consulta la sección Limpiar.

Antes de empezar

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

  2. Install the Google Cloud CLI.

  3. Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

  4. Para inicializar gcloud CLI, ejecuta el siguiente comando: 

    gcloud init

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

  6. Verify that billing is enabled for your Google Cloud project.

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

  8. Install the Google Cloud CLI.

  9. Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

  10. Para inicializar gcloud CLI, ejecuta el siguiente comando: 

    gcloud init

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

  12. Verify that billing is enabled for your Google Cloud project.

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

  14. 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.
    • Debes tener un nombre de dominio. El nombre de dominio no puede tener más de 63 caracteres. Puedes usar Cloud Domains u otro registrador.

    Preparar el entorno

    En este tutorial, usarás Cloud Shell para gestionar los recursos alojados en Google Cloud. Cloud Shell tiene preinstalado el software que necesitas para este tutorial, como kubectl, Helm y la CLI de gcloud.

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

    1. Inicia una sesión de Cloud Shell desde la Google Cloud consolaIcono de activación de Cloud Shell haciendo clic en Activar Cloud Shell en la Google Cloud consola. Se iniciará una sesión en el panel inferior de la consola Google Cloud .

    2. Añade 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

    Crear un clúster de GKE

    Crea un clúster de GKE con la recogida 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"

    Desplegar el operador de ECK

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

    ECK automatiza el despliegue y la gestió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, Application Performance Management Server y otros componentes de Elastic Stack en Kubernetes. Esto permite a los desarrolladores y a los equipos de DevOps configurar y gestionar clústeres de Elastic Stack a gran escala.

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

    1. Instala el gráfico de Helm de 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 el operador esté preparado:

      watch kubectl get pods -n elastic-system

      El resultado debería ser similar al siguiente:

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

      Si el operador STATUS es Running, vuelve a la línea de comandos pulsando Ctrl+C.

    Configurar Elastic Stack con ECK

    Si usas Elastic Stack con Elasticsearch, Kibana y Elastic Agent en modo Fleet, puedes configurar una solución potente, escalable y totalmente gestionada para gestionar y visualizar datos con Kibana.

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

    Elastic Agent es un transportador de datos ligero que recoge datos de diferentes fuentes, como registros o métricas, y los envía automáticamente a Elasticsearch.

    Elastic Fleet es un modo de funcionamiento en el que los agentes de Elastic envían informes a un servidor de flota central, que gestiona su configuración. El servidor de flota simplifica el despliegue, la configuración y el escalado de los agentes de Elastic, lo que facilita la gestión de despliegues grandes y complejos.

    El autoescalado de Elasticsearch es una función de automonitorización que puede informar cuando se necesitan recursos adicionales en función de una política definida por el operador. Por ejemplo, una política puede especificar que un determinado nivel debe escalarse en función del espacio de disco disponible. Elasticsearch puede monitorizar el espacio en disco y sugerir un escalado si predice una escasez, aunque sigue siendo responsabilidad del operador añadir los recursos necesarios. Para obtener más información sobre el autoescalado de Elasticsearch, consulta Autoescalado en la documentación de Elasticsearch.

    Configurar un clúster de Elasticsearch

    Elasticsearch proporciona un motor de búsqueda y analíticas distribuido basado en REST diseñado para almacenar y buscar grandes volúmenes de datos de forma rápida y eficiente.

    Cuando despliegues Elastic Stack en Kubernetes, debes gestionar la configuración de la VM, en concreto la vm.max_map_count setting, que es necesaria para Elasticsearch. vm.max_map_count especifica el número de áreas de memoria que un proceso puede asignar a un archivo. Elasticsearch debe tener este valor definido en 262144 como mínimo para funcionar de forma óptima. Para obtener más información, consulta Memoria virtual en la documentación de ECK.

    1. Revisa el siguiente archivo de 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

      Este manifiesto describe un DaemonSet que configura directamente el ajuste del kernel en el host. Un DaemonSet es un controlador de Kubernetes que se asegura de que se ejecute una copia de un Pod en cada nodo de un clúster.

      El manifiesto anterior está en una lista de permitidos para ejecutarse en Autopilot. No modifiques este archivo de 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 archivo de 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

      Este manifiesto 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 los roles de los nodos de Elasticsearch. Para obtener más información sobre los roles de los nodos, 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 debería ser similar al siguiente:

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

      Cuando el clúster de Elasticsearch HEALTH esté green y PHASE esté Ready, vuelve a la línea de comandos pulsando Ctrl+C.

    Configurar Kibana

    1. Revisa el siguiente archivo de 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

      Este manifiesto describe un recurso personalizado de Kibana que configura las políticas de agente para el servidor de 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 debería ser similar al siguiente:

      NAME     HEALTH   NODES   VERSION   AGE
kibana   green    1       8.8.0     6m47s

      Cuando los pods HEALTH estén green, vuelve a la línea de comandos pulsando Ctrl+C.

    Configurar un balanceador de carga para acceder a Kibana

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

    1. Crea una dirección IP externa global:

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

    2. Crea una zona gestionada 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. Delega la zona DNS como subdominio del dominio base creando 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 archivo de manifiesto:

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

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

    5. Aplica el manifiesto a tu clúster:

      kubectl apply -f ingress.yaml

    Configurar agentes elásticos

    1. Revisa el siguiente archivo de 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

      Este manifiesto describe un agente elástico 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 debería ser 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 los pods HEALTH estén green, vuelve a la línea de comandos pulsando Ctrl+C.

    Configurar el almacenamiento de registros y la monitorización

    Elastic Stack puede usar el exportador kube-state-metrics para recoger 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 predeterminadas de Kibana elastic:

      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 e inicia sesión en Kibana con las credenciales.

    4. En el menú, selecciona Estadísticas y, a continuación, Paneles de control.

    5. En el campo de texto de búsqueda, introduce Resumen de Kubernetes y selecciona Panel de control de resumen para ver las métricas básicas.

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

    Limpieza

    Para evitar que los recursos utilizados en este tutorial se cobren en tu cuenta de Google Cloud, elimina el proyecto que contiene los recursos o conserva el proyecto y elimina los recursos.

    Eliminar el proyecto

      Delete a Google Cloud project:

      gcloud projects delete PROJECT_ID

    Eliminar los recursos concretos

    Si has usado un proyecto que ya existía y no quieres eliminarlo, elimina los recursos concretos.

    1. Elimina los componentes de Elastic Stack, el operador 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. Elimina el conjunto de registros DNS, la dirección IP, la zona gestionada 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

    Siguientes pasos