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.

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 el estado de los pods HEALTH sea 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:

    # 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 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 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 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 el estado de los pods HEALTH sea 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.