Menyiapkan Elastic Stack di GKE

Tutorial ini menunjukkan cara menjalankan Elastic Stack di GKE menggunakan operator Elastic Cloud on Kubernetes (ECK).

Elastic Stack adalah solusi open source populer yang digunakan untuk mencatat log, memantau, dan menganalisis data secara real-time. Dengan menggunakan Elastic Stack di GKE, Anda dapat memanfaatkan skalabilitas dan keandalan yang disediakan oleh GKE Autopilot dan fitur Elastic Stack yang canggih.

Tutorial ini ditujukan untuk administrator Kubernetes atau engineer keandalan situs.

Menyiapkan lingkungan

Dalam tutorial ini, Anda akan menggunakan Cloud Shell untuk mengelola resource yang dihosting di Google Cloud. Cloud Shell telah diinstal dengan software yang Anda perlukan untuk tutorial ini, termasuk kubectl, Helm, dan gcloud CLI.

Untuk menyiapkan lingkungan Anda dengan Cloud Shell, ikuti langkah-langkah berikut:

  1. Luncurkan sesi Cloud Shell dari Google Cloud konsol, dengan mengklik Ikon aktivasi Cloud Shell Aktifkan Cloud Shell di Google Cloud konsol. Tindakan ini akan meluncurkan sesi di panel bawah konsol Google Cloud .

  2. Tambahkan repositori diagram Helm dan perbarui:

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

  3. Buat clone repositori GitHub:

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

  4. Ubah ke direktori kerja:

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

Membuat cluster GKE

Buat cluster GKE dengan pengumpulan metrik bidang kontrol yang diaktifkan:

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

Men-deploy operator ECK

Elastic Cloud on Kubernetes (ECK) adalah platform untuk men-deploy dan mengelola Elastic Stack di cluster Kubernetes.

ECK mengotomatiskan deployment dan pengelolaan cluster Elastic Stack, sehingga menyederhanakan proses penyiapan dan pemeliharaan Elastic Stack di Kubernetes. ECK menyediakan serangkaian resource kustom Kubernetes yang dapat Anda gunakan untuk membuat dan mengonfigurasi Elasticsearch, Kibana, Server Application Performance Management, dan komponen Elastic Stack lainnya di Kubernetes. Hal ini memungkinkan developer dan tim DevOps mengonfigurasi dan mengelola cluster Elastic Stack dalam skala besar.

ECK mendukung beberapa node Elasticsearch, failover aplikasi otomatis, upgrade lancar, dan enkripsi SSL. ECK juga menyertakan fitur yang memungkinkan Anda memantau dan memecahkan masalah performa Elasticsearch.

  1. Instal diagram 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. Tunggu hingga operator siap:

    watch kubectl get pods -n elastic-system

    Outputnya mirip dengan hal berikut ini:

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

    Jika operator STATUS adalah Running, kembali ke command line dengan menekan Ctrl+C.

Mengonfigurasi Elastic Stack dengan ECK

Dengan menggunakan Elastic Stack dengan Elasticsearch, Kibana, dan Elastic Agent yang berfungsi dalam mode Fleet, Anda dapat menyiapkan solusi yang canggih, skalabel, dan terkelola sepenuhnya untuk mengelola dan memvisualisasikan data menggunakan Kibana.

Kibana adalah alat analisis dan visualisasi data open source yang memungkinkan Anda menelusuri, menganalisis, dan memvisualisasikan data di Elasticsearch.

Elastic Agent adalah pengirim data ringan yang mengumpulkan data dari berbagai sumber, seperti log atau metrik, dan mengirimkannya secara otomatis ke Elasticsearch.

Elastic Fleet adalah mode operasi saat agen Elastic melaporkan ke server fleet pusat, yang menangani konfigurasi dan pengelolaannya. Server fleet menyederhanakan deployment, konfigurasi, dan penskalaan agen Elastic, sehingga mempermudah pengelolaan deployment yang besar dan kompleks.

Penskalaan otomatis Elasticsearch adalah fitur pemantauan mandiri yang dapat melaporkan kapan resource tambahan diperlukan berdasarkan kebijakan yang ditentukan operator. Misalnya, kebijakan dapat menentukan bahwa tingkat tertentu harus diskalakan berdasarkan ruang disk yang tersedia. Elasticsearch dapat memantau ruang disk dan menyarankan penskalaan jika memprediksi kekurangan, meskipun operator tetap harus menambahkan resource yang diperlukan. Untuk mengetahui informasi selengkapnya tentang penskalaan otomatis Elasticsearch, lihat Penskalaan otomatis dalam dokumentasi Elasticsearch.

Mengonfigurasi cluster Elasticsearch

Elasticsearch menyediakan mesin analisis dan penelusuran RESTful terdistribusi yang dirancang untuk menyimpan dan menelusuri data dalam jumlah besar dengan cepat dan efisien.

Saat men-deploy Elastic Stack di Kubernetes, Anda harus mengelola setelan VM, khususnya vm.max_map_count setting, yang diperlukan oleh Elasticsearch. vm.max_map_count menentukan jumlah area memori yang dapat dialokasikan proses ke file. Elasticsearch harus menetapkan nilai ini ke setidaknya 262144 agar dapat berjalan secara optimal. Untuk mengetahui informasi selengkapnya, lihat Memori virtual dalam dokumentasi ECK.

  1. Tinjau manifes berikut:

    # 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

    Manifes ini menjelaskan DaemonSet yang mengonfigurasi setelan kernel langsung di host. DaemonSet adalah pengontrol Kubernetes yang memastikan bahwa salinan Pod berjalan di setiap node dalam cluster.

    Manifes sebelumnya ada dalam daftar yang diizinkan untuk dijalankan di Autopilot. Jangan ubah manifes ini, termasuk gambar penampung.

  2. Terapkan manifes ini ke cluster Anda:

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

  3. Tinjau manifes berikut:

    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

    Manifes ini menentukan cluster Elasticsearch dengan kolom berikut:

    • initContainers: menunggu setelan kernel host memori virtual berubah.
    • podDisruptionBudget: menentukan bahwa cluster tidak akan dihancurkan selama proses defragmentasi Pod.
    • config.node.roles: Konfigurasi peran node Elasticsearch. Untuk mengetahui informasi selengkapnya tentang peran node, lihat Node dalam dokumentasi Elasticsearch.

  4. Terapkan manifes ini ke cluster Anda:

    kubectl apply -f elasticsearch.yaml

  5. Tunggu hingga cluster Elasticsearch siap:

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

    Outputnya mirip dengan hal berikut ini:

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

    Jika cluster Elasticsearch HEALTH adalah green dan PHASE adalah Ready, kembali ke command line dengan menekan Ctrl+C.

Mengonfigurasi Kibana

  1. Tinjau manifes berikut:

    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

    Manifes ini menjelaskan resource kustom Kibana yang mengonfigurasi kebijakan agen untuk server dan agen fleet.

  2. Terapkan manifes ini ke cluster Anda:

    kubectl apply -f kibana.yaml

  3. Tunggu hingga Pod siap:

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

    Outputnya mirip dengan hal berikut ini:

    NAME     HEALTH   NODES   VERSION   AGE
kibana   green    1       8.8.0     6m47s

    Jika Pod HEALTH adalah green, kembali ke command line dengan menekan Ctrl+C.

Mengonfigurasi load balancer untuk mengakses Kibana

Untuk mengakses Kibana, buat objek Ingress Kubernetes, sertifikat yang dikelola Google, alamat IP global, dan Zona DNS.

  1. Buat alamat IP eksternal global:

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

  2. Buat zona terkelola dan set data di 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. Delegasikan zona DNS sebagai subdomain dari domain dasar dengan membuat set data NS dengan daftar server nama. Anda bisa mendapatkan daftar server nama menggunakan perintah berikut:

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

  4. Tinjau manifes berikut:

    # 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

    Manifes ini menjelaskan ManagedCertificate yang menyediakan sertifikat SSL untuk membuat koneksi TLS.

  5. Terapkan manifes ke cluster Anda:

    kubectl apply -f ingress.yaml

Mengonfigurasi Agen Elastic

  1. Tinjau manifes berikut:

    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

    Manifes ini menjelaskan Elastic Agent yang mengonfigurasi server fleet dengan ECK.

  2. Terapkan manifes ini ke cluster Anda:

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

  3. Tunggu hingga Pod siap:

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

    Outputnya mirip dengan hal berikut ini:

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

    Jika Pod HEALTH adalah green, kembali ke command line dengan menekan Ctrl+C.

Mengonfigurasi logging dan pemantauan

Elastic Stack dapat menggunakan kube-state-metrics exporter untuk mengumpulkan metrik tingkat cluster.

  1. Instal 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. Dapatkan kredensial pengguna elastic Kibana default:

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

  3. Buka https://elk.BASE_DOMAIN di browser Anda, lalu login ke Kibana dengan kredensial.

  4. Dari menu, pilih Analytics, lalu Dasbor.

  5. Di kolom teks penelusuran, masukkan Ringkasan Kubernetes, lalu pilih Dasbor ringkasan untuk melihat metrik dasar.

    Beberapa panel dasbor mungkin tidak menampilkan data atau pesan error karena GKE membatasi akses ke beberapa endpoint bidang kontrol yang digunakan Kibana untuk mendapatkan metrik cluster.