Configura Elastic Stack en GKE

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.

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.

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 ayuda a garantizar 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

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

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.