Configurare Elastic Stack su GKE

Autopilot

---

Questo tutorial mostra come eseguire Elastic Stack su GKE utilizzando l'operatore Elastic Cloud on Kubernetes (ECK).

Elastic Stack è una popolare soluzione open source utilizzata per il logging, il monitoraggio e l'analisi dei dati in tempo reale. Utilizzando Elastic Stack su GKE, possono trarre vantaggio dalla scalabilità e dall'affidabilità offerte da GKE Autopilot e le potenti funzionalità di Elastic Stack.

Questo tutorial è destinato agli amministratori di Kubernetes o all'affidabilità del sito ingegneristici.

Obiettivi

• Creare un cluster GKE.
• Esegui il deployment dell'operatore ECK.
• Configurare i cluster Elasticsearch e Kibana utilizzando l'operatore ECK.
• Esegui il deployment di uno stack Elastic completo utilizzando l'operatore ECK.
• Scala automaticamente i cluster Elasticsearch ed esegui l'upgrade del deployment di Elastic Stack.
• Utilizzare Elastic Stack per monitorare gli ambienti Kubernetes.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

• GKE

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

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

4. Create or select a Google Cloud project.

   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.

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

6. Enable the GKE API:

   gcloud services enable container.googleapis.com

7. Install the Google Cloud CLI.

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

9. Create or select a Google Cloud project.

   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.

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

11. Enable the GKE API:

    gcloud services enable container.googleapis.com

12. 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:[e-mail].

    • Replace ROLE with each individual role.

• Devi possedere un nome di dominio. Il nome di dominio non deve essere più lungo di 63 caratteri. Puoi utilizzare Cloud Domains o un altro registrar.

Prepara l'ambiente

In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su Google Cloud. Cloud Shell è preinstallato con il software necessario per questo tutorial, tra cui kubectl, Helm e gcloud CLI.

Per configurare l'ambiente con Cloud Shell:

1. Avvia una sessione di Cloud Shell dalla console Google Cloud. clic su Attiva Cloud Shell nella Console Google Cloud: Viene avviata una sessione nel riquadro inferiore della console Google Cloud.

2. Aggiungi un repository di grafici Helm e aggiornalo:

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

3. Clona il repository GitHub:

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

4. Passa alla directory di lavoro:

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

Crea un cluster GKE

Crea un cluster GKE con la raccolta delle metriche del piano di controllo attivato:

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

esegui il deployment dell'operatore ECK

Elastic Cloud on Kubernetes (ECK) è una piattaforma per il deployment e la gestione Elastic Stack su cluster Kubernetes.

ECK automatizza il deployment e la gestione dei cluster Elastic Stack, semplificando la procedura di configurazione e manutenzione di Elastic Stack su Kubernetes. Offre un insieme di risorse personalizzate di Kubernetes che puoi utilizzare crea e configura Elasticsearch, Kibana, Application Performance Management Server e altri componenti di Elastic Stack in Kubernetes. In questo modo, gli sviluppatori e i team DevOps possono configurare e gestire i cluster Elastic Stack su larga scala.

ECK supporta più nodi Elasticsearch, failover automatico dell'applicazione, per gli upgrade senza interruzioni e la crittografia SSL. ECK include anche funzionalità che ti consentono monitorare le prestazioni di Elasticsearch e risolvere i relativi problemi.

Nota: questo tutorial fornisce istruzioni per lavorare con questa app: ECK version 2.8.0. Le istruzioni potrebbero non rappresentare versioni più recenti dell'app. Per saperne di più, consulta la documentazione: ECK.

1. Installa il grafico Helm 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. Attendi che l'operatore sia pronto:

   watch kubectl get pods -n elastic-system
   

   L'output è simile al seguente:

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

   Quando l'operatore STATUS è Running, torna alla riga di comando premendo Ctrl+C.

Configurare Elastic Stack con ECK

Utilizzando Elastic Stack in combinazione con Elasticsearch, Kibana ed Elastic Agent In modalità parco risorse, puoi configurare una soluzione potente, scalabile e completamente gestita per gestire e visualizzare i dati con Kibana.

Kibana è uno strumento di analisi e visualizzazione dei dati open source che ti consente di eseguire ricerche, analizzare e visualizzare i dati in Elasticsearch.

Elastic Agent è un'applicazione di invio dati leggera che raccoglie dati da diverse origini, come log o metriche, e li invia automaticamente a Elasticsearch.

Elastic Fleet è una modalità di funzionamento in cui gli agenti Elastic inviano report a un server di parco risorse centrale, che gestisce la loro configurazione e gestione. Il server del parco risorse semplifica il deployment, la configurazione e la scalabilità degli agenti Elastic, semplificando la gestione di deployment di grandi dimensioni e complessi.

La scalabilità automatica di Elasticsearch è una funzionalità di monitoraggio autonomo che può segnalare quando sono necessarie risorse aggiuntive in base a un criterio definito dall'operatore. Ad esempio, un criterio potrebbe specificare che un determinato livello deve essere scalato in base allo spazio su disco disponibile. Elasticsearch può monitorare lo spazio su disco e suggerire il ridimensionamento se prevede una carenza, anche se è sempre compito dell'operatore aggiungere le risorse necessarie. Per saperne di più sulla scalabilità automatica di Elasticsearch, consulta Scalabilità automatica nella documentazione di Elasticsearch.

Configura un cluster Elasticsearch

Elasticsearch fornisce un motore di ricerca e analisi RESTful distribuito progettato per archiviare e cercare grandi volumi di dati in modo rapido ed efficiente.

Quando esegui il deployment di Elastic Stack su Kubernetes, devi gestire le impostazioni della VM, e nello specifico vm.max_map_count setting, che è richiesto Elasticsearch. vm.max_map_count specifica il numero di aree di memoria che un processo può allocare a un file. Per Elasticsearch questo valore deve essere impostato su almeno 262144 per un'esecuzione ottimale. Per ulteriori informazioni, vedi Memoria virtuale nella documentazione di ECK.

Nota: questo tutorial fornisce istruzioni per lavorare con questa app: Elastic version 8.9.0. Le istruzioni potrebbero non rappresentare versioni più recenti dell'app. Per saperne di più, consulta la documentazione: Elastic.

1. Esamina il seguente manifest:

   apiVersion: scheduling.k8s.io/v1
   kind: PriorityClass
   metadata:
     name: user-daemonset-priority
   value: 999999999
   preemptionPolicy: PreemptLowerPriority
   globalDefault: false
   description: "User DaemonSet priority"

   Questo manifest descrive un DaemonSet che configura l'impostazione del kernel direttamente sull'host. Questo manifest si trova in una lista consentita su cui è possibile eseguire Autopilot. Non modificare questo manifest, incluso il contenitore in formato Docker.

2. Applica questo manifest al tuo cluster:

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

3. Esamina il seguente manifest:

   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

   Questo manifest definisce un cluster Elasticsearch con i seguenti campi:

   • initContainers: attende che le impostazioni del kernel dell'host della memoria virtuale vengano modificate.
   • podDisruptionBudget: specifica che il cluster non verrà distrutto durante il processo di deframmentazione dei pod.
   • config.node.roles: configurazione dei ruoli del nodo Elasticsearch. Per ulteriori informazioni sui ruoli dei nodi, consulta Nodo nella documentazione di Elasticsearch.

4. Applica questo manifest al tuo cluster:

   kubectl apply -f elasticsearch.yaml
   

5. Attendi che il cluster Elasticsearch sia pronto:

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

   L'output è simile al seguente:

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

   Quando il cluster Elasticsearch HEALTH è green e PHASE è Ready, torna alla riga di comando premendo Ctrl+C.

Configura Kibana

Nota: questo tutorial fornisce istruzioni per lavorare con questa app: Elastic version 8.9.0. Le istruzioni potrebbero non rappresentare versioni più recenti dell'app. Per saperne di più, consulta la documentazione: Elastic.

1. Esamina il seguente manifest:

   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

   Questo manifest descrive una risorsa personalizzata di Kibana che configura i criteri agenti per il server e gli agenti del parco risorse.

2. Applica questo manifest al tuo cluster:

   kubectl apply -f kibana.yaml
   

3. Attendi che i pod siano pronti:

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

   L'output è simile al seguente:

   NAME     HEALTH   NODES   VERSION   AGE
   kibana   green    1       8.8.0     6m47s
   

   Quando HEALTH dei pod è green, torna alla riga di comando premendo Ctrl+C.

Configurare un bilanciatore del carico per accedere a Kibana

Per accedere a Kibana, crea un oggetto Kubernetes Ingress, un oggetto Kubernetes Ingress un certificato di servizio, un indirizzo IP globale e una zona DNS.

1. Crea un indirizzo IP esterno globale:

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

2. Crea una zona gestita e un insieme di record in 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 come sottodominio del dominio di base creando un NS con un elenco di server dei nomi. Puoi ottenere un elenco di server dei nomi utilizzando il seguente comando:

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

4. Esamina il seguente manifest:

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

   Questo manifest descrive un ManagedCertificate che esegue il provisioning di un certificato SSL per stabilire la connessione TLS.

5. Applica il manifest al cluster:

   kubectl apply -f ingress.yaml
   

Configura gli agenti Elastic

Nota: questo tutorial fornisce istruzioni per lavorare con questa app: Elastic version 8.9.0. Le istruzioni potrebbero non rappresentare versioni più recenti dell'app. Per saperne di più, consulta la documentazione: Elastic.

1. Esamina il seguente manifest:

   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

   Questo manifest descrive un agente Elastic che configura un server del parco risorse con ECK.

2. Applica questo manifest al tuo cluster:

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

3. Attendi che i pod siano pronti:

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

   L'output è simile al seguente:

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

   Quando HEALTH dei pod è green, torna alla riga di comando premendo Ctrl+C.

Configurazione di logging e monitoraggio

Elastic Stack può utilizzare l'utilità di esportazione kube-state-metrics per raccogliere i dati a livello di cluster metriche di valutazione.

1. Installa 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. Ottieni le credenziali utente predefinite di Kibana elastic:

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

3. Apri https://elk.BASE_DOMAIN nel browser e accedi a Kibana con le credenziali.

4. Nel menu, seleziona Analytics e poi Dashboard.

5. Nel campo di testo di ricerca, inserisci Panoramica di Kubernetes e seleziona Dashboard Panoramica per visualizzare le metriche di base.

   Alcuni riquadri della dashboard potrebbero non mostrare dati o messaggi di errore GKE limita l'accesso ad alcuni endpoint del piano di controllo Kibana usa per ottenere le metriche del cluster.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini elimini anche tutto il lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Elimina le singole risorse

Se hai utilizzato un progetto esistente e non vuoi eliminarlo, elimina il alle singole risorse.

1. Elimina i componenti dell'Elastic Stack, l'operatore ECK e 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 il set di record DNS, l'indirizzo IP, la zona DNS gestita e il cluster 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
   

Passaggi successivi

• Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Dai un'occhiata al nostro Centro architetture cloud.