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:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar 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.

To initialize the gcloud CLI, run the following command:

gcloud init

Note: If you installed the gcloud CLI previously, make sure you have the latest version by running

gcloud components
      update

Create or select a Google Cloud 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.

Make sure that billing is enabled for your Google Cloud project.

Enable the GKE API:

gcloud services enable container.googleapis.com

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Note: If you installed the gcloud CLI previously, make sure you have the latest version by running

gcloud components
      update

Create or select a Google Cloud 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.

Make sure that billing is enabled for your Google Cloud project.

Enable the GKE API:

gcloud services enable container.googleapis.com

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/container.clusterAdmin
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="USER_IDENTIFIER" --role=ROLE
```
- Replace PROJECT_ID with your project ID.
- Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.
- Replace ROLE with each individual role.

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

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

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

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

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

Clona el repositorio de GitHub:

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

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.

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"

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.

Revisa el siguiente manifiesto:
```
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: user-daemonset-priority
value: 999999999
preemptionPolicy: PreemptLowerPriority
globalDefault: false
description: "User DaemonSet priority"
```
En este manifiesto, se describe un DaemonSet que configura la configuración del kernel directamente en el host. Este manifiesto está en una lista de anunciantes permitidos para ejecutarse en Autopilot. No modifiques este manifiesto, incluidas las imágenes del contenedor.

Aplica este manifiesto a tu clúster:

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

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.

Aplica este manifiesto a tu clúster:
```
kubectl apply -f elasticsearch.yaml
```

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

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.

Aplica este manifiesto a tu clúster:
```
kubectl apply -f kibana.yaml
```

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.

Crea una dirección IP externa global:

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

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"

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

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

Aplica el manifiesto al clúster:
```
kubectl apply -f ingress.yaml
```

Configura los agentes de Elastic

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.

Aplica este manifiesto a tu clúster:

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

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.

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

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

Abre https://elk.BASE_DOMAIN en tu navegador y accede a Kibana con las credenciales.
En el menú, selecciona Analytics y, luego, Paneles.
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 en el proyecto. 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 ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

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.

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

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.