Membangun tumpukan wapitic yang menguntungkan untuk jurnalisasi terpusat

[ad_1]

Jika bisnis Anda memiliki kendala anggaran, pembelian produk lisensi seperti Splunk untuk infrastruktur logging mungkin tidak mungkin. Untungnya, ada alternatif open source yang kuat: rusa (Elasticsearch, Logstash dan Kibana). Elk menawarkan kapasitas jurnalisasi dan visualisasi yang kuat.

Dalam sebuah startup di mana saya bekerja, minimalisasi biaya adalah prioritas, jadi saya menerapkan wapitis untuk penebangan.

Dalam artikel ini, saya akan memandu Anda melalui konfigurasi dan konfigurasi versi gratis baterai Wapiti di GCP menggunakan Terraform dan Ansible. Namun, instruksi yang sama dapat diikuti untuk menggunakannya di platform cloud lain seperti AWS dan Azure.

Mengapa Memilih Elk?

Setelah dalam penelitian -Depth, saya memutuskan untuk mengimplementasikan baterai Wapitis pada GCP menggunakan mesin virtual (VM) untuk penebangan karena kemudahan penggunaannya, dasbor kaya dan proses konfigurasi sederhana. Meskipun saya bisa menggunakannya pada cluster GKE, saya memilih mesin virtual pada saat itu karena berbagai alasan.

Elasticsearch adalah mesin pencarian dan analisis open source yang memungkinkan Anda untuk mengumpulkan dan menganalisis surat kabar dari beberapa sumber, termasuk perangkat IoT, server aplikasi, server web, dan layanan cloud. Baterai wapitic terdiri dari komponen berikut:

Elasticsearch – Menyimpan dan indeks data jurnal
Trotoar – Filter dan format koran sebelum konsumsi
Kibana – Menyediakan antarmuka pengguna grafis (GUI) untuk pencarian dan visualisasi surat kabar
Garis – Pengirim surat kabar ringan yang diinstal sebagai agen di mesin yang menghasilkan koran

Gambar 1

Prasyarat

Sebelum mengkonfigurasi wapitis, pastikan Anda memiliki yang berikut:

Akun cloud (Google Cloud, AWS atau Azure). Panduan ini menggunakan GCP.
Terraform dan enmubligne dipasang di mesin lokal Anda.
Otentikasi yang tepat yang dikonfigurasi antara mesin lokal Anda dan pemasok cloud (Google Cloud atau lainnya) dengan otorisasi akses yang diperlukan untuk Terraform dan Ansible.

Bagian 1: Konfigurasi Infrastruktur Wapitiss Menggunakan Terraform di GCP

Baterai Wapiti terdiri dari berbagai node, masing -masing menyajikan fungsi tertentu untuk meningkatkan skalabilitas dan miring:

Knot Master – Kelola operasi dan pengindeksan cluster.
Node data – Simpan dan indeks data dari surat kabar untuk penelitian dan analisis.
Kibana Knot – Menyediakan antarmuka grafis untuk visualisasi dan analisis surat kabar.
Node logstash – Menyaring, mengubah dan menelan koran dari berbagai sumber.

Meskipun semua fitur dapat dikombinasikan pada satu node, memisahkannya menjadi lingkungan produksi meningkatkan skalabilitas dan toleransi cacat, tergantung pada beban kerja.

Buat file -file berikut di folder tempat Anda berencana untuk menjalankan kode terraform, atau mengkloning repositori git saya, yang berisi semua kode: GitHub – Pradeep -gaddamidi / Elk.

1. Create_elk_instances.tf

locals {
  config = var.environment_config[terraform.workspace]
  instances = [for key, value in local.config.nodes : {
    name = key
    machine_type = (
      can(regex("master_.*", value)) ? local.config.master_machine_type :
      can(regex("kibana_.*", value)) ? local.config.kibana_machine_type :
      can(regex("logstash_.*", value)) ? local.config.logstash_machine_type :
      local.config.node_machine_type
    )
    zone = (
      can(regex(".*_zoneb", value)) ? local.config.region_zones[1] :
      can(regex(".*_zonec", value)) ? local.config.region_zones[2] :
      local.config.region_zones[0]
    )
    network_tags         = local.config.network_tags
    ssh_keys      = local.config.ssh_keys
    static_ip_name       = key           # Modify or leave null as needed
    service_account_name = "elastic"     # Modify or leave null as needed
    disk_name            = key           # Modify or leave null as needed
    disk_type            = "pd-standard" # Modify as needed
    disk_size = (
      can(regex("master_.*", value)) ? local.config.master_disk_size :
      can(regex("kibana_.*", value)) ? local.config.kibana_disk_size :
      can(regex("logstash_.*", value)) ? local.config.logstash_disk_size :
      local.config.node_disk_size
    )
    disk_zone = (
      can(regex(".*_zoneb", value)) ? local.config.region_zones[1] :
      can(regex(".*_zonec", value)) ? local.config.region_zones[2] :
      local.config.region_zones[0]
    )
    disk_project = local.config.project_name
  }]
}

module "gcp_instance" {
  source                = "../../modules/gcp_custom_instance"
  gce_image             = local.config.gce_image
  subnet                = local.config.subnet
  region                = local.config.region  # Provide only when creating static IPS
  instances             = local.instances
  use_common_service_account = local.config.use_common_service_account # Provide only when creating a common service account accross all the instances
}

2.TF Variabel

variable "environment_config" {
  description = "Configuration per environment"
  type = map(object({
    project_name         = string
    region               = string
    region_zones         = list(string)
    master_machine_type  = string
    node_machine_type    = string
    kibana_machine_type  = string
    logstash_machine_type= string
    network_tags         = list(string)
    network              = string
    subnet               = string
    gce_image            = string
    ca_bucket_location   = string
    backup_bucket        = string
    master_disk_size     = number
    node_disk_size       = number
    kibana_disk_size     = number
    logstash_disk_size   = number
    use_common_service_account = bool
    machine_access_scopes= list(string)
    nodes                = map(string)
    ssh_keys             = list(string)
  }))
  default = {
    nonprod = {
      project_name         = "nonprod-infra-monitoring"
      region               = "us-central1"
      region_zones         = ["us-central1-a", "us-central1-b"]
      master_machine_type  = "n1-standard-2"
      node_machine_type    = "n1-standard-2"
      kibana_machine_type  = "n1-standard-2"
      logstash_machine_type= "n1-standard-2"
      network_tags         = ["elastic", "nonprod"]
      network              = "projects/nonprod-networking/global/networks/nonprod-vpc"
      subnet               = "projects/nonprod-networking/regions/us-central1/subnetworks/nonprod-sub01"
      gce_image            = "debian-cloud/debian-12"
      ca_bucket_location   = "nonprod-elastic-certificates"
      backup_bucket        = "nonprod-elastic-backup"
      master_disk_size     = 100
      node_disk_size       = 510
      kibana_disk_size     = 100
      logstash_disk_size   = 100
      use_common_service_account = true
      machine_access_scopes = ["cloud-platform"]
      ssh_keys              = []
      nodes = {
        "nonprod-elastic-master-node1" = "master_zonea"
        "nonprod-elastic-data-node1"   = "data_zonea"
        "nonprod-elastic-data-node2"   = "data_zoneb"
        "nonprod-elastic-kibana"       = "kibana_zonea"
        "nonprod-elastic-logstash"     = "logstash_zonea"
      }
    }
    prod = {
      project_name         = "prod-infra-monitoring"
      region               = "us-central1"
      region_zones         = ["us-central1-a", "us-central1-b", "us-central1-c"]
      master_machine_type  = "n2-standard-2"
      node_machine_type    = "n2-highmem-4"
      kibana_machine_type  = "n2-standard-2"
      logstash_machine_type= "n2-standard-2"
      network_tags         = ["elastic", "prod"]
      network              = "projects/prod-networking/global/networks/prod-vpc"
      subnet               = "projects/prod-networking/regions/us-central1/subnetworks/prod-sub01"
      gce_image            = "debian-cloud/debian-12"
      ca_bucket_location   = "prod-elastic-certificates"
      backup_bucket        = "prod-elastic-backup"
      master_disk_size     = 100
      node_disk_size       = 3000
      kibana_disk_size     = 100
      logstash_disk_size   = 100
      use_common_service_account = true
      machine_access_scopes = ["cloud-platform"]
      ssh_keys              = []
      nodes = {
        "elastic-master-node1" = "master_zonea"
        "elastic-master-node2" = "master_zoneb"
        "elastic-master-node3" = "master_zonec"
        "elastic-data-node1"   = "data_zonea"
        "elastic-data-node2"   = "data_zonea"
        "elastic-data-node3"   = "data_zoneb"
        "elastic-data-node4"   = "data_zoneb"
        "elastic-data-node5"   = "data_zonea"
        "elastic-data-node6"   = "data_zoneb"
        "elastic-kibana"       = "kibana_zonea"
        "elastic-logstash"     = "logstash_zonea"
        "elastic-logstash2"     = "logstash_zoneb"
        "elastic-logstash3"    = "logstash_zonec"
      }
    }
  }
}

Saya membuat modul yang dipersonalisasi untuk menyediakan instance GCP dan menggunakannya di create_elk_instances.tf deposito. Namun, Anda juga dapat menggunakan modul GCP Terraform resmi untuk membuat instance VM.

module "gcp_instance" {
  source                = "./modules/gcp_custom_instance"

ITU ./modules/gcp_custom_instance Folder harus memiliki file, gcp_custom_vm.tf Dan variables_custom.tf).

Anda akan menemukan di bawah kode modul pribadi saya:

3. GCP_CUSTOM_VM.TF

locals {
  common_service_account_email = var.use_common_service_account ? google_service_account.common_service_account[0].email : null
}

resource "google_compute_instance" "google-compute-instance" {
  for_each = { for index, inst in var.instances : inst.name => inst }
  name         = each.value.name
  machine_type = each.value.machine_type
  zone = each.value.zone
#  allow_stopping_for_update = true
  tags         = each.value.network_tags
  metadata = {
    ssh-keys = join("\n", each.value.ssh_keys)
  }

  boot_disk {
    initialize_params {
      image = var.gce_image
    }
  }

  network_interface {
    subnetwork = var.subnet
    network_ip = each.value.static_ip_name != null ? google_compute_address.static_ips[each.value.static_ip_name].address : null
  }

  dynamic "service_account" {
    for_each = each.value.service_account_name != null ? [1] : []
    content {
      scopes = var.machine_access_scopes
      email  = var.use_common_service_account ? google_service_account.common_service_account[0].email :               google_service_account.individual_service_account[each.value.name].email
    }
  }

  dynamic "attached_disk" {
    for_each = each.value.disk_name != null ? [1] : []
    content {
      source      = google_compute_disk.google-compute-disk[each.value.disk_name].self_link
      device_name = "${each.value.disk_name}-data"
      mode        = "READ_WRITE"
    }
  }

}


resource "google_compute_disk" "google-compute-disk" {
  for_each = { for index, inst in var.instances : inst.disk_name => inst if inst.disk_name != null }

  name = "${each.value.disk_name}-data"
  type = each.value.disk_type
  size = each.value.disk_size
  zone = each.value.disk_zone
  project = each.value.disk_project
}

resource "google_service_account" "common_service_account" {
  count        = var.use_common_service_account ? 1 : 0
  account_id   = var.use_common_service_account ? lookup(var.instances[0], "service_account_name", null) : null
  display_name = "Service Account"
}

resource "google_service_account" "individual_service_account" {
  for_each     = { for index, inst in var.instances : inst.service_account_name => inst if inst.service_account_name != null && !var.use_common_service_account }

  account_id   = each.value.service_account_name
  display_name = "Service account for ${each.value.name}"
}

resource "google_compute_address" "static_ips" {
  # Only include instances that have static_ip_name defined
  for_each = { for index, inst in var.instances : inst.static_ip_name => inst if inst.static_ip_name != null }

  name         = each.value.static_ip_name
  address_type = "INTERNAL"
  region       = var.region
  subnetwork   = var.subnet
}

output "common_service_account_email" {
  value       = local.common_service_account_email
  description = "The email of the common service account"
}

4 variabel_custom.tf

variable "instances" {
  description = "List of instance configurations"
  type = list(object({
    name                = string
    machine_type        = string
    zone                = string
    network_tags        = optional(list(string))
    ssh_keys	        = optional(list(string))
    static_ip_name      = optional(string)
    service_account_name = optional(string)
    disk_name           = optional(string)
    disk_type           = optional(string)
    disk_size           = optional(number)
    disk_zone           = optional(string)
    disk_project        = optional(string)
  }))
}

variable "gce_image" {
  description = "GCE image for the instances"
  type        = string
  default     = "debian-cloud/debian-12"
}

variable "subnet" {
  description = "Subnet for the network"
  type        = string
}

variable "region" {
  description = "GCP region"
  type        = string
  default     = "us-central1"
}

variable "use_common_service_account" {
  description = "Flag to determine if a common service account should be used for all instances"
  type        = bool
  default     = false
}

variable "machine_access_scopes" {
  description = "Scopes for machine access"
  type        = list(string)
  default     = ["cloud-platform"]
}

Tetapkan izin ke akun layanan yang dibuat sebelumnya dalam kode:

locals {
  bucket_config = var.environment_config[terraform.workspace]
}

resource "google_storage_bucket_iam_binding" "elastic-backup" {
  bucket  = local.bucket_config.backup_bucket
  role    = "roles/storage.objectAdmin"
  members = local.config.use_common_service_account ? ["serviceAccount:${module.gcp_instance.common_service_account_email}"] : []
}

resource "google_storage_bucket_iam_binding" "elastic-certs" {
  bucket  = local.bucket_config.ca_bucket_location
  role    = "roles/storage.objectViewer"
  members = local.config.use_common_service_account ? ["serviceAccount:${module.gcp_instance.common_service_account_email}"] : []
}

Buat ember GCP yang digunakan untuk sertifikat dan cadangan elastis:

resource "google_storage_bucket" "elastic-backup" {
  name          = local.bucket_config.backup_bucket
  location      = "US"
  storage_class = "STANDARD"

  uniform_bucket_level_access = true
}
resource "google_storage_bucket" "elastic-certs" {
  name          = local.bucket_config.ca_bucket_location
  location      = "US"
  storage_class = "STANDARD"

  uniform_bucket_level_access = true
}

Anda dapat menggunakan perintah terraform di bawah ini untuk membuat sumber daya di atas:

terraform workspace set nonprod (if you use workspaces)
terraform init
terraform plan
terraform apply

Anda dapat menambahkan node baru sesuai kebutuhan dengan memperbarui variabel, yaitu dengan menambahkan node baru ke bagian file file dan mengurangi kode terraform. Ini akan secara otomatis menyediakan node data baru. Sekarang setelah infrastruktur Wapitis dikonfigurasi, langkah selanjutnya adalah menginstal dan mengonfigurasi perangkat lunak rusa.

Bagian 2: Mengkonfigurasi Infrastruktur Wapition Menggunakan Terkenal

Prasyarat

1. Generasi sertifikat yang diperlukan untuk komunikasi yang aman antara berbagai node elastis dapat diotomatisasi. Namun, saya memilih untuk menghasilkannya secara manual dengan mengikuti panduan wapitis.

Setelah sertifikat dihasilkan, taruh di situs di ember GCP elastic-certificates.

2. Pastikan file ansibl host Anda diatur seperti di bawah ini:

Semua data dan master dikelompokkan di bawah elastic bagian
Node kibana di bawah kibana bagian
Logsh Knots Under logstash
Node data di bawah data
Master Knots Under master

Buat file berikut di folder di mana Anda berencana untuk menjalankan buku pedoman kuno. Kemudian jalankan Playbook Ansible di bawah ini untuk menginstal dan mengkonfigurasi wapitis.

Ancible.yaml

---
- name: Install Elasticsearch pre-reqs on Debian
  hosts: all
  become: yes
  tasks:
    - name: Update apt repository
      apt:
        update_cache: yes

    - name: Install default-jre
      apt:
        name:
          - default-jre
        state: present

    - name: Add Elasticsearch GPG key
      apt_key:
        url: 
        state: present

    - name: Install apt-transport-https
      apt:
        name: apt-transport-https
        state: present

    - name: Add Elasticsearch repository
      apt_repository:
        repo: "deb  stable main"
        state: present
        filename: elastic-8.x

    - name: Update apt repository
      apt:
        update_cache: yes

- name: Install Elasticsearch on Debian
  hosts: elastic
  become: yes
  tasks:
    - name: Install Elasticsearch
      apt:
        name: elasticsearch=8.11.2
        state: present
    - name: Enable Elasticsearch service
      ansible.builtin.systemd:
        name: elasticsearch.service
        enabled: yes

- name: Install Kibana on Debian
  hosts: kibana
  become: yes
  tasks:
    - name: Install Kibana
      apt:
        name: kibana=8.11.2
        state: present
    - name: Enable kibana service
      ansible.builtin.systemd:
        name: kibana.service
        enabled: yes

- name: Install logstash on Debian
  hosts: logstash
  become: yes
  tasks:
    - name: Install logstash
      apt:
        name: logstash=1:8.11.2-1
        state: present
    - name: Enable logstash service
      ansible.builtin.systemd:
        name: logstash.service
        enabled: yes

- name: Copy the kibana.yml configuration file to the kibana nodes
  hosts: kibana
  become: yes
  tasks:
    - name: Copy a kibana.yml file
      template:
        src: "{{ playbook_dir }}/files/kibana.j2"
        dest: /etc/kibana/kibana.yml

- name: Copy the pipelines.yml configuration file to the logstash nodes
  hosts: logstash
  become: yes
  tasks:
    - name: Copy a logstash pipelines.yml file
      template:
        src: "{{ playbook_dir }}/files/logstash.j2"
        dest: /etc/logstash/conf.d/pipelines.conf

- name: Copy the elasticsearch_node.yml configuration file to the nodes
  hosts: data
  gather_facts: yes
  become: yes
  tasks:
    - name: Get zone info from metadata server
      ansible.builtin.uri:
        url: 
        method: GET
        return_content: yes  # Ensures that the content is returned
        headers:
          Metadata-Flavor: "Google"
      register: zone_info
      check_mode: no
    - name: Extract the zone name
      set_fact:
        zone_name: "{{ zone_info.content.split("https://dzone.com/")[-1] }}"
    - name: Copy a elasticsearch_node.yml file
      template:
        src: "{{ playbook_dir }}/files/elasticsearch_node.j2"
        dest: /etc/elasticsearch/elasticsearch.yml

- name: Copy the elasticsearch_node.yml configuration file to the nodes
  hosts: master
  gather_facts: yes
  become: yes
  tasks:
    - name: Copy a elasticsearch_master.yml file
      template:
        src: "{{ playbook_dir }}/files/elasticsearch_master.j2"
        dest: /etc/elasticsearch/elasticsearch.yml
- name: Download the certificates from the GCS bucket
  hosts: elastic
  become: yes
  tasks:
    - name: certificates
      command: gsutil cp gs://nonprod-elastic-certificates/* /etc/elasticsearch/certs
- name: Download the certificates from the GCS bucket
  hosts: kibana
  become: yes
  tasks:
    - name: certificates
      command: gsutil cp gs://nonprod-elastic-certificates/elasticsearch-ca.pem /etc/kibana

- name: Download the certificates from the GCS bucket
  hosts: logstash
  become: yes
  tasks:
    - name: certificates
      command: gsutil cp gs://nonprod-elastic-certificates/elasticsearch-ca.pem /usr/share/logstash/pipeline/elasticsearch-ca.pem

File konfigurasi yang diperlukan oleh buku pedoman kuno harus ditempatkan di files direktori. File yang diharapkan tercantum di bawah ini:

1 dan 1 Elasticsearch_master.j2

node.name: {{ ansible_default_ipv4.address }}
node.roles: [ master ]
discovery.seed_hosts:
 - 10.x.x.x
 - 10.x.x.x
 - 10.x.x.x
#cluster.initial_master_nodes:
# - 10.x.x.x
# - 10.x.x.x
# - 10.x.x.x
network.host : {{ ansible_default_ipv4.address }}
cluster.name: prod-monitoring
path:
  data: /mnt/disks/elasticsearch
  logs: /var/log/elasticsearch
cluster.routing.allocation.awareness.attributes: zone
cluster.routing.allocation.awareness.force.zone.values: us-central1-a,us-central1-b
xpack.security.http.ssl.enabled: true
xpack.security.http.ssl.keystore.path: /etc/elasticsearch/certs/http.p12
xpack.security.enabled: true
xpack.security.transport.ssl.enabled: true
xpack.security.audit.enabled: true
xpack.security.transport.ssl.verification_mode: certificate
xpack.security.transport.ssl.keystore.path: /etc/elasticsearch/certs/elastic-certificates.p12
xpack.security.transport.ssl.client_authentication: required
xpack.security.transport.ssl.truststore.path: /etc/elasticsearch/certs/elastic-certificates.p12
xpack.license.self_generated.type: basic

Beberapa titik yang perlu diperhatikan pada konfigurasi node master elastis di atas:

Kami menggunakan lisensi dasar (gratis), bukan lisensi premium.
Ketika anible berjalan pada node master, secara otomatis mengisi alamat IPv4 dari node master default.
Membusuk cluster.initial_master_nodes hanya Saat membuat cluster untuk pertama kalinya.
Keamanan diaktifkan antara:
- Master Knot menggunakan xpack.security.transport.ssl.enabled
- Node data dan kibana / logstash menggunakan xpack.security.http.ssl.enabled

2. Elasticsearch_node.j2

node.name: {{ ansible_default_ipv4.address }}
node.roles: [ data, transform, ingest ]
discovery.seed_hosts:
 - 10.x.x.x
 - 10.x.x.x
 - 10.x.x.x
#cluster.initial_master_nodes:
# - 10.x.x.x
# - 10.x.x.x
# - 10.x.x.x
network.host : {{ ansible_default_ipv4.address }}
cluster.name: prod-monitoring
path:
  data: /mnt/disks/elasticsearch
  logs: /var/log/elasticsearch
node.attr.zone: {{ zone_name }}
xpack.security.http.ssl.enabled: true
xpack.security.http.ssl.keystore.path: /etc/elasticsearch/certs/http.p12
xpack.security.enabled: true
xpack.security.transport.ssl.enabled: true
xpack.security.audit.enabled: true
xpack.security.transport.ssl.verification_mode: certificate
xpack.security.transport.ssl.keystore.path: /etc/elasticsearch/certs/elastic-certificates.p12
xpack.security.transport.ssl.client_authentication: required
xpack.security.transport.ssl.truststore.path: /etc/elasticsearch/certs/elastic-certificates.p12
xpack.license.self_generated.type: basic

3 dan 3 Kibana.j2

elasticsearch.hosts: ["
server.name: kibana
server.host: {{ ansible_default_ipv4.address }}
server.port: 443
elasticsearch.username: 'kibana_system'
elasticsearch.password: 'somepassxxxxx'
elasticsearch.ssl.certificateAuthorities: ['/etc/kibana/elasticsearch-ca.pem']
elasticsearch.ssl.verificationMode: 'certificate'
server.ssl.enabled: true
server.ssl.certificate: /etc/ssl/kibana/kibana-cert.crt
server.ssl.key: /etc/ssl/kibana/kibana-key.key
server.publicBaseUrl: 
xpack.encryptedSavedObjects.encryptionKey: zxy123f1318d633817xyz1234
xpack.reporting.encryptionKey: 1xfsyc4ad24176a902f2xyz123
xpack.security.encryptionKey: cskcjsn60e148a70308d39dxyz123
logging:
  appenders:
    file:
      type: file
      fileName: /var/log/kibana/kibana.log
      layout:
        type: json
  root:
    appenders:
      - default
      - file
pid.file: /run/kibana/kibana.pid

4 Logstash.j2

input {
        beats {
                port => 5044
        }

        tcp {
                port => 50000
        }
    tcp {
        port => 5000
        codec => "line"
        type => "syslog"
    }

    http {
        port => 5050
    }
        google_pubsub {
        type => "pubsub"
        project_id => "my-project-123"
        topic => "cloud_functions_logs"
        subscription => "cloud_functions_logs-sub"
###        json_key_file => "/etc/logstash/keys/logstash-sa.json"
        codec => "json"
                      }
        google_pubsub {
        type => "pubsub"
        project_id => "my-project-123"
        topic => "cloud_run_logs"
        subscription => "cloud_run_logs-sub"
###        json_key_file => "/etc/logstash/keys/logstash-sa.json"
        codec => "json"
                      }
}

filter {
    grok {
        match => { "message" => "^%{SYSLOGTIMESTAMP:timestamp} %{SYSLOGHOST:hostname} %{DATA:program}(?:\[%{POSINT:pid}\])?: %{GREEDYDATA:log_message}" }
    }
    
    date {
        match => [ "timestamp", "MMM  d HH:mm:ss", "MMM dd HH:mm:ss" ]
        target => "@timestamp"
    }
    
    kv {
        source => "log_message"
        field_split => ",| "
        value_split => "="
    }
    
    mutate {
        remove_field => [ "timestamp" ]
        convert => { "pid" => "integer" }
    }
}

### Add your filters / logstash plugins configuration here

output {
        elasticsearch {
                hosts => ["
                user => "logstash_writer"
                password => "mypassxyz"
                index => "logs-my-index-%{+yyyy.MM.dd}"
                action => "create"
                ssl => true
                cacert => '/usr/share/logstash/pipeline/elasticsearch-ca.pem'
        }
}

Beberapa titik yang perlu diperhatikan pada konfigurasi logsh di atas:

Dalam konfigurasi logsh di atas, kami menggunakan berbagai filter seperti grok,, date,, kvDan mutate Untuk mencocokkan dan memodifikasi koran yang masuk. Sesuaikan sesuai dengan kebutuhan Anda.
Di keduanya kibana.j2 Dan logstash.j2Untuk “Elasticsearch.hosts”, Anda dapat menentukan semua node data sebagai daftar, yang memungkinkan permintaan didistribusikan di sekitar. Atau, konfigurasikan penyeimbang beban internal dengan node data seperti backend dan hanya menyediakan IP penyeimbang beban.
Memastikan bahwa index Dan logstash_writer Pengguna dibuat melalui konsol Kibana. Selain itu, konfigurasikan indeks yang diperlukan untuk menelan data dari sumber lain seperti FileBeat dan tetapkan otorisasi yang sesuai untuk pengguna masing -masing.
Data dapat dicerna di Elasticsearch melalui logstash, memungkinkan penyaringan yang diperlukan, atau dapat dikirim langsung ke node data menggunakan agen seperti FileBeat.
Jika Anda menyimpan salah satu elemen di atas .j2 File jinja dalam tolok ukur git, dan mereka berisi informasi sensitif, mengukurnya menggunakan ansible-vault. Merujuk ke Dokumentasi yang bisa dibayangkan Untuk mengetahui lebih lanjut tentang penggunaan ansible-vault.

Berikut adalah konfigurasi FileBeat jika Anda ingin mengirim surat kabar langsung dari aplikasi Docker. Anda juga dapat menggunakannya untuk mengirim surat kabar dari aplikasi lainnya.

FileBeat.conf

logging.json: true
logging.level: info
logging.metrics.enabled: false

setup.kibana.host: ${KIBANA_HOST}
setup.ilm.enabled: true

output.elasticsearch:
  hosts: ${ELASTIC_HOST}
  indices:
    - index: "audit-%{+yyyy.MM.dd}"
      when.has_fields: ["_audit"]
    - index: "logs-%{+yyyy.MM.dd}"
      when.has_fields: ["app", "env"]
    - index: "invalid-stream-%{+yyyy.MM.dd}"
      when.has_fields: ["error.data", "error.message"]

filebeat.autodiscover:
  providers:
    - type: docker
      templates:
        - config:
            - type: container
              paths:
                - /var/lib/docker/containers/${data.docker.container.id}/*.log

processors:
  - decode_json_fields:
      fields: ["message"]
      process_array: false
      max_depth: 1
      target: ""
      overwrite_keys: false
      add_error_key: true

Setelah wapitis dikonfigurasi, Anda dapat mengkonfigurasi cadangan data yang disebut snapshot di ember elastis 'elastis' melalui konsol Kibana.

Kesimpulan

Gambar 2

Dengan data yang dicerna dari berbagai sumber, seperti FileBeat, di kluster Elasticsearch, Anda dapat mengakses antarmuka pengguna Kibana untuk mencari surat kabar (Gambar 2), membuat visualisasi, memantau surat kabar dan secara efektif mengkonfigurasi peringatan.

Dengan memasang dan mengkonfigurasi baterai sumber terbuka Wapiti, Anda dapat sangat mengurangi biaya lisensi sambil hanya membayar infrastruktur GCP yang Anda gunakan. Otomasi Terraform dan Ansible membantu Anda beroperasi dengan cepat, memungkinkan penskalaan yang mudah dengan upaya minimum.

Semoga beruntung! Jangan ragu untuk terhubung dengan saya Liendin.

[ad_2]

Blog

Mengapa Memilih Elk?

Prasyarat

Bagian 1: Konfigurasi Infrastruktur Wapitiss Menggunakan Terraform di GCP

1. Create_elk_instances.tf

2.TF Variabel

3. GCP_CUSTOM_VM.TF

4 variabel_custom.tf

Bagian 2: Mengkonfigurasi Infrastruktur Wapition Menggunakan Terkenal

Prasyarat

Ancible.yaml

1 dan 1 Elasticsearch_master.j2

2. Elasticsearch_node.j2

3 dan 3 Kibana.j2

4 Logstash.j2

FileBeat.conf

Kesimpulan

GitHub Copilot Menambahkan Mode Agen, Dukungan MCP Di Versi Terbaru

The Need for Thermal Comfort in Lecture Theatres

Search

Recent Posts

Jajaki potensi bisnis Anda dan temukan peluang untuk sukses yang lebih besar

Home

Profil

Layanan

Mengapa Kami

Blog

Dukungan

Konsultasi Gratis

Hubungi Kami

Pusat Bantuan

Kebijakan Cookies

Blog