One place for hosting & domains

      Logstash

      How To Install Elasticsearch, Logstash, and Kibana (Elastic Stack) on Ubuntu 20.04

      Introduction

      The Elastic Stack — formerly known as the ELK Stack — is a collection of open-source software produced by Elastic which allows you to search, analyze, and visualize logs generated from any source in any format, a practice known as centralized logging. Centralized logging can be useful when attempting to identify problems with your servers or applications as it allows you to search through all of your logs in a single place. It’s also useful because it allows you to identify issues that span multiple servers by correlating their logs during a specific time frame.

      The Elastic Stack has four main components:

      • Elasticsearch: a distributed RESTful search engine which stores all of the collected data.
      • Logstash: the data processing component of the Elastic Stack which sends incoming data to Elasticsearch.
      • Kibana: a web interface for searching and visualizing logs.
      • Beats: lightweight, single-purpose data shippers that can send data from hundreds or thousands of machines to either Logstash or Elasticsearch.

      In this tutorial, you will install the Elastic Stack on an Ubuntu 20.04 server. You will learn how to install all of the components of the Elastic Stack — including Filebeat, a Beat used for forwarding and centralizing logs and files — and configure them to gather and visualize system logs. Additionally, because Kibana is normally only available on the localhost, we will use Nginx to proxy it so it will be accessible over a web browser. We will install all of these components on a single server, which we will refer to as our Elastic Stack server.

      Note: When installing the Elastic Stack, you must use the same version across the entire stack. In this tutorial we will install the latest versions of the entire stack which are, at the time of this writing, Elasticsearch 7.7.1, Kibana 7.7.1, Logstash 7.7.1, and Filebeat 7.7.1.

      To complete this tutorial, you will need the following:

      Additionally, because the Elastic Stack is used to access valuable information about your server that you would not want unauthorized users to access, it’s important that you keep your server secure by installing a TLS/SSL certificate. This is optional but strongly encouraged.

      However, because you will ultimately make changes to your Nginx server block over the course of this guide, it would likely make more sense for you to complete the Let’s Encrypt on Ubuntu 20.04 guide at the end of this tutorial’s second step. With that in mind, if you plan to configure Let’s Encrypt on your server, you will need the following in place before doing so:

      • A fully qualified domain name (FQDN). This tutorial will use your_domain throughout. You can purchase a domain name on Namecheap, get one for free on Freenom, or use the domain registrar of your choice.

      • Both of the following DNS records set up for your server. You can follow this introduction to DigitalOcean DNS for details on how to add them.

        • An A record with your_domain pointing to your server’s public IP address.
        • An A record with www.your_domain pointing to your server’s public IP address.

      The Elasticsearch components are not available in Ubuntu’s default package repositories. They can, however, be installed with APT after adding Elastic’s package source list.

      All of the packages are signed with the Elasticsearch signing key in order to protect your system from package spoofing. Packages which have been authenticated using the key will be considered trusted by your package manager. In this step, you will import the Elasticsearch public GPG key and add the Elastic package source list in order to install Elasticsearch.

      To begin, use cURL, the command line tool for transferring data with URLs, to import the Elasticsearch public GPG key into APT. Note that we are using the arguments -fsSL to silence all progress and possible errors (except for a server failure) and to allow cURL to make a request on a new location if redirected. Pipe the output of the cURL command into the apt-key program, which adds the public GPG key to APT.

      1. curl -fsSL https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

      Next, add the Elastic source list to the sources.list.d directory, where APT will search for new sources:

      1. echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-7.x.list

      Next, update your package lists so APT will read the new Elastic source:

      1. sudo apt update

      Then install Elasticsearch with this command:

      1. sudo apt install elasticsearch

      Elasticsearch is now installed and ready to be configured. Use your preferred text editor to edit Elasticsearch’s main configuration file, elasticsearch.yml. Here, we’ll use nano:

      1. sudo nano /etc/elasticsearch/elasticsearch.yml

      Note: Elasticsearch’s configuration file is in YAML format, which means that we need to maintain the indentation format. Be sure that you do not add any extra spaces as you edit this file.

      The elasticsearch.yml file provides configuration options for your cluster, node, paths, memory, network, discovery, and gateway. Most of these options are preconfigured in the file but you can change them according to your needs. For the purposes of our demonstration of a single-server configuration, we will only adjust the settings for the network host.

      Elasticsearch listens for traffic from everywhere on port 9200. You will want to restrict outside access to your Elasticsearch instance to prevent outsiders from reading your data or shutting down your Elasticsearch cluster through its [REST API] (https://en.wikipedia.org/wiki/Representational_state_transfer). To restrict access and therefore increase security, find the line that specifies network.host, uncomment it, and replace its value with localhost like this:

      /etc/elasticsearch/elasticsearch.yml

      . . .
      # ---------------------------------- Network -----------------------------------
      #
      # Set the bind address to a specific IP (IPv4 or IPv6):
      #
      network.host: localhost
      . . .
      

      We have specified localhost so that Elasticsearch listens on all interfaces and bound IPs. If you want it to listen only on a specific interface, you can specify its IP in place of localhost. Save and close elasticsearch.yml. If you’re using nano, you can do so by pressing CTRL+X, followed by Y and then ENTER .

      These are the minimum settings you can start with in order to use Elasticsearch. Now you can start Elasticsearch for the first time.

      Start the Elasticsearch service with systemctl. Give Elasticsearch a few moments to start up. Otherwise, you may get errors about not being able to connect.

      1. sudo systemctl start elasticsearch

      Next, run the following command to enable Elasticsearch to start up every time your server boots:

      1. sudo systemctl enable elasticsearch

      You can test whether your Elasticsearch service is running by sending an HTTP request:

      1. curl -X GET "localhost:9200"

      You will see a response showing some basic information about your local node, similar to this:

      Output

      { "name" : "Elasticsearch", "cluster_name" : "elasticsearch", "cluster_uuid" : "qqhFHPigQ9e2lk-a7AvLNQ", "version" : { "number" : "7.7.1", "build_flavor" : "default", "build_type" : "deb", "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f", "build_date" : "2020-03-26T06:34:37.794943Z", "build_snapshot" : false, "lucene_version" : "8.5.1", "minimum_wire_compatibility_version" : "6.8.0", "minimum_index_compatibility_version" : "6.0.0-beta1" }, "tagline" : "You Know, for Search" }

      Now that Elasticsearch is up and running, let’s install Kibana, the next component of the Elastic Stack.

      According to the official documentation, you should install Kibana only after installing Elasticsearch. Installing in this order ensures that the components each product depends on are correctly in place.

      Because you’ve already added the Elastic package source in the previous step, you can just install the remaining components of the Elastic Stack using apt:

      1. sudo apt install kibana

      Then enable and start the Kibana service:

      1. sudo systemctl enable kibana
      2. sudo systemctl start kibana

      Because Kibana is configured to only listen on localhost, we must set up a reverse proxy to allow external access to it. We will use Nginx for this purpose, which should already be installed on your server.

      First, use the openssl command to create an administrative Kibana user which you’ll use to access the Kibana web interface. As an example we will name this account kibanaadmin, but to ensure greater security we recommend that you choose a non-standard name for your user that would be difficult to guess.

      The following command will create the administrative Kibana user and password, and store them in the htpasswd.users file. You will configure Nginx to require this username and password and read this file momentarily:

      1. echo "kibanaadmin:`openssl passwd -apr1`" | sudo tee -a /etc/nginx/htpasswd.users

      Enter and confirm a password at the prompt. Remember or take note of this login, as you will need it to access the Kibana web interface.

      Next, we will create an Nginx server block file. As an example, we will refer to this file as your_domain, although you may find it helpful to give yours a more descriptive name. For instance, if you have a FQDN and DNS records set up for this server, you could name this file after your FQDN.

      Using nano or your preferred text editor, create the Nginx server block file:

      1. sudo nano /etc/nginx/sites-available/your_domain

      Add the following code block into the file, being sure to update your_domain to match your server’s FQDN or public IP address. This code configures Nginx to direct your server’s HTTP traffic to the Kibana application, which is listening on localhost:5601. Additionally, it configures Nginx to read the htpasswd.users file and require basic authentication.

      Note that if you followed the prerequisite Nginx tutorial through to the end, you may have already created this file and populated it with some content. In that case, delete all the existing content in the file before adding the following:

      /etc/nginx/sites-available/your_domain

      server {
          listen 80;
      
          server_name your_domain;
      
          auth_basic "Restricted Access";
          auth_basic_user_file /etc/nginx/htpasswd.users;
      
          location / {
              proxy_pass http://localhost:5601;
              proxy_http_version 1.1;
              proxy_set_header Upgrade $http_upgrade;
              proxy_set_header Connection 'upgrade';
              proxy_set_header Host $host;
              proxy_cache_bypass $http_upgrade;
          }
      }
      

      When you’re finished, save and close the file.

      Next, enable the new configuration by creating a symbolic link to the sites-enabled directory. If you already created a server block file with the same name in the Nginx prerequisite, you do not need to run this command:

      1. sudo ln -s /etc/nginx/sites-available/your_domain /etc/nginx/sites-enabled/your_domain

      Then check the configuration for syntax errors:

      1. sudo nginx -t

      If any errors are reported in your output, go back and double check that the content you placed in your configuration file was added correctly. Once you see syntax is ok in the output, go ahead and restart the Nginx service:

      1. sudo systemctl reload nginx

      If you followed the initial server setup guide, you should have a UFW firewall enabled. To allow connections to Nginx, we can adjust the rules by typing:

      1. sudo ufw allow 'Nginx Full'

      Note: If you followed the prerequisite Nginx tutorial, you may have created a UFW rule allowing the Nginx HTTP profile through the firewall. Because the Nginx Full profile allows both HTTP and HTTPS traffic through the firewall, you can safely delete the rule you created in the prerequisite tutorial. Do so with the following command:

      1. sudo ufw delete allow 'Nginx HTTP'

      Kibana is now accessible via your FQDN or the public IP address of your Elastic Stack server. You can check the Kibana server’s status page by navigating to the following address and entering your login credentials when prompted:

      http://your_domain/status
      

      This status page displays information about the server’s resource usage and lists the installed plugins.

      |Kibana status page

      Note: As mentioned in the Prerequisites section, it is recommended that you enable SSL/TLS on your server. You can follow the Let’s Encrypt guide now to obtain a free SSL certificate for Nginx on Ubuntu 20.04. After obtaining your SSL/TLS certificates, you can come back and complete this tutorial.

      Now that the Kibana dashboard is configured, let’s install the next component: Logstash.

      Although it’s possible for Beats to send data directly to the Elasticsearch database, it is common to use Logstash to process the data. This will allow you more flexibility to collect data from different sources, transform it into a common format, and export it to another database.

      Install Logstash with this command:

      1. sudo apt install logstash

      After installing Logstash, you can move on to configuring it. Logstash’s configuration files reside in the /etc/logstash/conf.d directory. For more information on the configuration syntax, you can check out the configuration reference that Elastic provides. As you configure the file, it’s helpful to think of Logstash as a pipeline which takes in data at one end, processes it in one way or another, and sends it out to its destination (in this case, the destination being Elasticsearch). A Logstash pipeline has two required elements, input and output, and one optional element, filter. The input plugins consume data from a source, the filter plugins process the data, and the output plugins write the data to a destination.

      Logstash pipeline

      Create a configuration file called 02-beats-input.conf where you will set up your Filebeat input:

      1. sudo nano /etc/logstash/conf.d/02-beats-input.conf

      Insert the following input configuration. This specifies a beats input that will listen on TCP port 5044.

      /etc/logstash/conf.d/02-beats-input.conf

      input {
        beats {
          port => 5044
        }
      }
      

      Save and close the file.

      Next, create a configuration file called 30-elasticsearch-output.conf:

      1. sudo nano /etc/logstash/conf.d/30-elasticsearch-output.conf

      Insert the following output configuration. Essentially, this output configures Logstash to store the Beats data in Elasticsearch, which is running at localhost:9200, in an index named after the Beat used. The Beat used in this tutorial is Filebeat:

      /etc/logstash/conf.d/30-elasticsearch-output.conf

      output {
        if [@metadata][pipeline] {
      	elasticsearch {
        	hosts => ["localhost:9200"]
        	manage_template => false
        	index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
        	pipeline => "%{[@metadata][pipeline]}"
      	}
        } else {
      	elasticsearch {
        	hosts => ["localhost:9200"]
        	manage_template => false
        	index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
      	}
        }
      }
      
      
      

      Save and close the file.

      Test your Logstash configuration with this command:

      1. sudo -u logstash /usr/share/logstash/bin/logstash --path.settings /etc/logstash -t

      If there are no syntax errors, your output will display Config Validation Result: OK. Exiting Logstash after a few seconds. If you don’t see this in your output, check for any errors noted in your output and update your configuration to correct them. Note that you’ll receive warnings from OpenJDK, but they should not cause any problems and can be ignored.

      If your configuration test is successful, start and enable Logstash to put the configuration changes into effect:

      1. sudo systemctl start logstash
      2. sudo systemctl enable logstash

      Now that Logstash is running correctly and is fully configured, let’s install Filebeat.

      The Elastic Stack uses several lightweight data shippers called Beats to collect data from various sources and transport them to Logstash or Elasticsearch. Here are the Beats that are currently available from Elastic:

      • Filebeat: collects and ships log files.
      • Metricbeat: collects metrics from your systems and services.
      • Packetbeat: collects and analyzes network data.
      • Winlogbeat: collects Windows event logs.
      • Auditbeat: collects Linux audit framework data and monitors file integrity.
      • Heartbeat: monitors services for their availability with active probing.

      In this tutorial we will use Filebeat to forward local logs to our Elastic Stack.

      Install Filebeat using apt:

      1. sudo apt install filebeat

      Next, configure Filebeat to connect to Logstash. Here, we will modify the example configuration file that comes with Filebeat.

      Open the Filebeat configuration file:

      1. sudo nano /etc/filebeat/filebeat.yml

      Note: As with Elasticsearch, Filebeat’s configuration file is in YAML format. This means that proper indentation is crucial, so be sure to use the same number of spaces that are indicated in these instructions.

      Filebeat supports numerous outputs, but you’ll usually only send events directly to Elasticsearch or to Logstash for additional processing. In this tutorial, we’ll use Logstash to perform additional processing on the data collected by Filebeat. Filebeat will not need to send any data directly to Elasticsearch, so let’s disable that output. To do so, find the output.elasticsearch section and comment out the following lines by preceding them with a #:

      /etc/filebeat/filebeat.yml

      ...
      #output.elasticsearch:
        # Array of hosts to connect to.
        #hosts: ["localhost:9200"]
      ...
      

      Then, configure the output.logstash section. Uncomment the lines output.logstash: and hosts: ["localhost:5044"] by removing the #. This will configure Filebeat to connect to Logstash on your Elastic Stack server at port 5044, the port for which we specified a Logstash input earlier:

      /etc/filebeat/filebeat.yml

      output.logstash:
        # The Logstash hosts
        hosts: ["localhost:5044"]
      

      Save and close the file.

      The functionality of Filebeat can be extended with Filebeat modules. In this tutorial we will use the system module, which collects and parses logs created by the system logging service of common Linux distributions.

      Let’s enable it:

      1. sudo filebeat modules enable system

      You can see a list of enabled and disabled modules by running:

      1. sudo filebeat modules list

      You will see a list similar to the following:

      Output

      Enabled: system Disabled: apache2 auditd elasticsearch icinga iis kafka kibana logstash mongodb mysql nginx osquery postgresql redis traefik

      By default, Filebeat is configured to use default paths for the syslog and authorization logs. In the case of this tutorial, you do not need to change anything in the configuration. You can see the parameters of the module in the /etc/filebeat/modules.d/system.yml configuration file.

      Next, we need to set up the Filebeat ingest pipelines, which parse the log data before sending it through logstash to elasticsearch. To load the ingest pipeline for the system module, enter the following command:

      1. sudo filebeat setup --pipelines --modules system

      Next, load the index template into Elasticsearch. An Elasticsearch index is a collection of documents that have similar characteristics. Indexes are identified with a name, which is used to refer to the index when performing various operations within it. The index template will be automatically applied when a new index is created.

      To load the template, use the following command:

      1. sudo filebeat setup --index-management -E output.logstash.enabled=false -E 'output.elasticsearch.hosts=["localhost:9200"]'

      Output

      Index setup finished.

      Filebeat comes packaged with sample Kibana dashboards that allow you to visualize Filebeat data in Kibana. Before you can use the dashboards, you need to create the index pattern and load the dashboards into Kibana.

      As the dashboards load, Filebeat connects to Elasticsearch to check version information. To load dashboards when Logstash is enabled, you need to disable the Logstash output and enable Elasticsearch output:

      1. sudo filebeat setup -E output.logstash.enabled=false -E output.elasticsearch.hosts=['localhost:9200'] -E setup.kibana.host=localhost:5601

      You should receive output similar to this:

      Output

      Overwriting ILM policy is disabled. Set `setup.ilm.overwrite:true` for enabling. Index setup finished. Loading dashboards (Kibana must be running and reachable) Loaded dashboards Setting up ML using setup --machine-learning is going to be removed in 8.0.0. Please use the ML app instead. See more: https://www.elastic.co/guide/en/elastic-stack-overview/current/xpack-ml.html Loaded machine learning job configurations Loaded Ingest pipelines

      Now you can start and enable Filebeat:

      1. sudo systemctl start filebeat
      2. sudo systemctl enable filebeat

      If you’ve set up your Elastic Stack correctly, Filebeat will begin shipping your syslog and authorization logs to Logstash, which will then load that data into Elasticsearch.

      To verify that Elasticsearch is indeed receiving this data, query the Filebeat index with this command:

      1. curl -XGET 'http://localhost:9200/filebeat-*/_search?pretty'

      You should receive output similar to this:

      Output

      ... { { "took" : 4, "timed_out" : false, "_shards" : { "total" : 2, "successful" : 2, "skipped" : 0, "failed" : 0 }, "hits" : { "total" : { "value" : 4040, "relation" : "eq" }, "max_score" : 1.0, "hits" : [ { "_index" : "filebeat-7.7.1-2020.06.04", "_type" : "_doc", "_id" : "FiZLgXIB75I8Lxc9ewIH", "_score" : 1.0, "_source" : { "cloud" : { "provider" : "digitalocean", "instance" : { "id" : "194878454" }, "region" : "nyc1" }, "@timestamp" : "2020-06-04T21:45:03.995Z", "agent" : { "version" : "7.7.1", "type" : "filebeat", "ephemeral_id" : "cbcefb9a-8d15-4ce4-bad4-962a80371ec0", "hostname" : "june-ubuntu-20-04-elasticstack", "id" : "fbd5956f-12ab-4227-9782-f8f1a19b7f32" }, ...

      If your output shows 0 total hits, Elasticsearch is not loading any logs under the index you searched for, and you will need to review your setup for errors. If you received the expected output, continue to the next step, in which we will see how to navigate through some of Kibana’s dashboards.

      Let’s return to the Kibana web interface that we installed earlier.

      In a web browser, go to the FQDN or public IP address of your Elastic Stack server. After entering the login credentials you defined in Step 2, you will see the Kibana homepage:

      Kibana Homepage

      Click the Discover link in the left-hand navigation bar (you may have to click the the Expand icon at the very bottom left to see the navigation menu items). On the Discover page, select the predefined filebeat-* index pattern to see Filebeat data. By default, this will show you all of the log data over the last 15 minutes. You will see a histogram with log events, and some log messages below:

      Discover page

      Here, you can search and browse through your logs and also customize your dashboard. At this point, though, there won’t be much in there because you are only gathering syslogs from your Elastic Stack server.

      Use the left-hand panel to navigate to the Dashboard page and search for the Filebeat System dashboards. Once there, you can select the sample dashboards that come with Filebeat’s system module.

      For example, you can view detailed stats based on your syslog messages:

      Syslog Dashboard

      You can also view which users have used the sudo command and when:

      Sudo Dashboard

      Kibana has many other features, such as graphing and filtering, so feel free to explore.

      In this tutorial, you’ve learned how to install and configure the Elastic Stack to collect and analyze system logs. Remember that you can send just about any type of log or indexed data to Logstash using Beats, but the data becomes even more useful if it is parsed and structured with a Logstash filter, as this transforms the data into a consistent format that can be read easily by Elasticsearch.

      Installieren von Elasticsearch, Logstash und Kibana (Elastic Stack) unter Ubuntu 20.04


      Einführung

      Der Elastic Stack (früher ELK Stack genannt) ist eine Sammlung von Open-Source-Software, die von Elastic produziert wird. Damit können Sie Protokolle, die aus beliebigen Quellen in beliebigen Formaten generiert werden, durchsuchen, analysieren und visualisieren – diese Praktik wird* zentrale Protokollierung* genannt. Zentrale Protokollierung kann dabei helfen, Probleme mit Ihren Servern oder Anwendungen zu identifizieren, da Sie so alle Protokolle an einem Ort durchsuchen können. Außerdem können Sie Probleme ermitteln, die mehrere Server umfassen, indem Sie ihre Protokolle für einen bestimmten Zeitraum miteinander korrelieren.

      Der Elastic Stack verfügt über vier Hauptkomponenten:

      • Elasticsearch: eine verteilte RESTful-Suchmaschine, die alle erfassten Daten speichert.
      • Logstash: die Datenverarbeitungskomponente von Elastic Stack, die eingehende Daten an Elasticsearch sendet.
      • Kibana: eine Weboberfläche zum Durchsuchen und Visualisieren von Protokollen.
      • Beats: schlanke Datenversender mit einem Zweck, die Daten von Hunderten oder Tausenden von Geräten an Logstash oder Elasticsearch senden können.

      In diesem Tutorial installieren Sie den Elastic Stack auf einem Ubuntu 20.04-Server. Sie erfahren, wie Sie alle Komponenten des Elastic Stacks installieren – darunter Filebeat, ein Beat, das zum Weiterleiten und Zentralisieren von Protokollen und Dateien dient – und so konfigurieren, dass Systemprotokolle gesammelt und visualisiert werden. Da Kibana in der Regel nur auf dem localhost verfügbar ist, verwenden wir außerdem Nginx als Proxy, sodass es über einen Webbrowser aufrufbar ist. Wir installieren alle diese Komponenten auf einem einzigen Server, den wir als Elastic Stack-Server bezeichnen werden.

      Hinweis: Bei der Installation des Elastic Stacks müssen Sie im gesamten Stack die gleiche Version verwenden. In diesem Tutorial installieren wir die neuesten Versionen des gesamten Stacks (zum Zeitpunkt der Verfassung dieses Textes Elasticsearch 7.7.1, Kibana 7.7.1, Logstash 7.7.1 und Filebeat 7.7.1).

      Voraussetzungen

      Um dieses Tutorial zu absolvieren, benötigen Sie Folgendes:

      • Einen Ubuntu 20.04-Server mit 4 GB RAM und 2 CPUs, eingerichtet mit einem non-root sudo user. Sie können hierzu der Ersteinrichtung eines Servers mit Ubuntu 20.04 folgen. In diesem Tutorial arbeiten wir mit der Mindestmenge von CPUs und RAM, die zur Ausführung von Elasticsearch benötigt werden. Beachten Sie, dass die Menge von CPU, RAM und Speicher, die Ihr Elasticsearch-Server benötigt, von der Menge der Protokolle abhängt, die Sie erwarten.

      • Installiertes OpenJDK 11. Siehe Abschnitt Installieren der standardmäßigen JRE/JDK in our guide Installieren von Java mit Apt unter Ubuntu 20.04, um die Einrichtung vorzunehmen.

      • Nginx, installiert auf Ihrem Server; Nginx werden wir in diesem Leitfaden später als Reverseproxy für Kibana konfigurieren. Folgen Sie unserem Leitfaden Installieren von Nginx unter Ubuntu 20.04, um die Einrichtung vorzunehmen.

      Da der Elastic Stack dazu dient, wertvolle Informationen über Ihren Server aufzurufen, auf die nicht autorisierte Benutzer nicht zugreifen sollen, sollten Sie Ihren Server unbedingt schützen, indem Sie ein TLS/SSL-Zertifikat installieren. Dieser Schutz ist optional, wird jedoch ausdrücklich empfohlen.

      Da Sie im Laufe des Leitfadens jedoch Änderungen an Ihrem Nginx-Serverblock vornehmen werden, ist es wahrscheinlich sinnvoller, dem Leitfaden Let’s Encrypt unter Ubuntu 20.04 am Ende des zweiten Schritts dieses Tutorials zu folgen. Wenn Sie vor diesem Hintergrund planen, Let’s Encrypt auf Ihrem Server zu konfigurieren, benötigen Sie dazu Folgendes:

      • Einen vollständig qualifizierten Domänennamen (FQDN). In diesem Tutorial wird überall your_domain verwendet. Sie können einen Domänennamen unter Namecheap günstig erwerben oder einen kostenlosen von Freenom herunterladen oder einfach die Domänenregistrierungsstelle Ihrer Wahl verwenden.
      • Die beiden folgenden DNS-Einträge wurden für Ihren Server eingerichtet. Sie finden in dieser Einführung in DigitalOcean DNS Details dazu, wie Sie sie hinzufügen können.

        • Einen A-Datensatz mit your-domain, der auf die öffentliche IP-Adresse Ihres Servers verweist.
        • Einen A-Eintrag mit www.your_domain, der auf die öffentliche IP-Adresse Ihres Servers verweist.

      Schritt 1 — Installieren und Konfigurieren von Elasticsearch

      Die Elasticsearch-Komponenten sind in Standard-Paket-Repositorys von Ubuntu nicht verfügbar. Sie können jedoch mit APT installiert werden, nachdem Sie die Paketquellliste von Elastic hinzugefügt haben.

      Alle Pakete werden mit dem Signierschlüssel von Elasticsearch signiert, um das System vor Paket-Spoofing zu schützen. Pakete, die mit dem Schlüssel authentifiziert wurden, werden von Ihrem Paketmanager als vertrauenswürdig eingestuft. In diesem Schritt importieren Sie den öffentlichen GPG-Schlüssel von Elasticsearch und fügen die Paketquellliste von Elastic hinzu, um Elasticsearch zu installieren.

      Verwenden Sie zunächst cURL, das Befehlszeilentool zur Übertragung von Daten mit URLs, um den öffentlichen GPG-Schlüssel von Elasticsearch in APT zu importieren. Beachten Sie, dass wir die Argumente -fsSL nutzen, um alle Fortschritte und möglichen Fehler stumm zu schalten (ausgenommen Serverfehler) und um zuzulassen, dass cURL bei einer Umleitung eine Anfrage an einem neuen Ort stellt. Leiten Sie die Ausgabe des cURL-Befehls in das APT-Schlüsselprogramm weiter, das den öffentlichen GPG-Schlüssel zu APT hinzufügt.

      • curl -fsSL https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

      Fügen Sie als Nächstes die Elastic-Quellliste in das Verzeichnis sources.list.d ein, in dem APT nach neuen Quellen sucht:

      • echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-7.x.list

      Aktualisieren Sie als Nächstes Ihre Paketlisten, damit APT die neue Elastic-Quelle liest:

      Installieren Sie dann Elasticsearch mit diesem Befehl:

      • sudo apt install elasticsearch

      Elasticsearch ist nun installiert und bereit für die Konfiguration. Verwenden Sie zur Bearbeitung der Konfigurationsdatei von Elasticsearch (elasticsearch.yml) Ihren bevorzugten Texteditor. Wir verwenden hier nano:

      • sudo nano /etc/elasticsearch/elasticsearch.yml

      Anmerkung: Die Konfigurationsdatei von Elasticsearch liegt im YAML-Format vor. Das bedeutet, dass wir das Einrückungsformat beibehalten müssen. Achten Sie darauf, dass Sie beim Bearbeiten der Datei keine zusätzlichen Leerzeichen hinzufügen.

      Die Datei elasticsearch.yml bietet Konfigurationsoptionen für Cluster, Knoten, Pfade, Arbeitsspeicher, Netzwerk, Suche und Gateway. Die meisten dieser Optionen sind in der Datei vorkonfiguriert, aber Sie können sie je nach Ihren Bedürfnissen ändern. Im Sinne unserer Demonstration einer Konfiguration mit einem Server werden wir nur die Einstellungen für den Netzwerkhost anpassen.

      Elasticsearch lauscht an Port 9200 auf Verkehr von überall. Sie werden externen Zugriff auf Ihre Elasticsearch-Instanz einschränken wollen, um zu verhindern, dass externe Personen Ihre Daten lesen oder Ihren Elasticsearch-Cluster mit der REST-API herunterfahren. Um Zugriff zu beschränken und damit die Sicherheit zu erhöhen, suchen Sie nach der Zeile, die network.host angibt, heben Sie die Kommentierung auf und ersetzen den Wert durch localhost, sodass die Zeile wie folgt aussieht:

      /etc/elasticsearch/elasticsearch.yml

      . . .
      # ---------------------------------- Network -----------------------------------
      #
      # Set the bind address to a specific IP (IPv4 or IPv6):
      #
      network.host: localhost
      . . .
      

      Wir haben localhost angegeben, damit Elasticsearch an allen Schnittstellen und gebundenen IPs lauscht. Wenn Sie möchten, dass nur an einer bestimmten Schnittstelle gelauscht werden soll, können Sie deren IP-Adresse an Stelle von localhost angeben. Speichern und schließen Sie elasticsearch.yml. Wenn Sie nano verwenden, können Sie dazu STRG+X drücken, gefolgt von Y und dann ENTER.

      Das sind die Mindesteinstellungen, mit denen Sie anfangen können, um Elasticsearch zu nutzen. Sie können Elasticsearch jetzt zum ersten Mal starten.

      Starten Sie den Elasticsearch-Dienst mit systemctl. Geben Sie Elasticsearch einige Momente zum Starten. Andernfalls erhalten Sie möglicherweise Fehlermeldungen, dass Sie keine Verbindung herstellen können.

      • sudo systemctl start elasticsearch

      Führen Sie als Nächstes den folgenden Befehl aus, damit Elasticsearch bei jedem Server-Boot gestartet wird:

      • sudo systemctl enable elasticsearch

      Sie können testen, ob Ihr Elasticsearch-Dienst ausgeführt wird, indem Sie eine HTTP-Anfrage senden:

      • curl -X GET "localhost:9200"

      Sie erhalten eine Antwort, die einige grundlegende Informationen zu Ihrem lokalen Knoten enthält und in etwa wie folgt aussieht:

      Output

      { "name" : "Elasticsearch", "cluster_name" : "elasticsearch", "cluster_uuid" : "qqhFHPigQ9e2lk-a7AvLNQ", "version" : { "number" : "7.7.1", "build_flavor" : "default", "build_type" : "deb", "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f", "build_date" : "2020-03-26T06:34:37.794943Z", "build_snapshot" : false, "lucene_version" : "8.5.1", "minimum_wire_compatibility_version" : "6.8.0", "minimum_index_compatibility_version" : "6.0.0-beta1" }, "tagline" : "You Know, for Search" }

      Nachdem Elasticsearch ausgeführt wird, installieren wir nun Kibana, die nächste Komponente des Elastic Stacks.

      Schritt 2 — Installieren und Konfigurieren des Kibana-Dashboards

      Laut der offiziellen Dokumentation sollten Sie Kibana erst nach der Installation von Elasticsearch installieren. Durch eine Installation in dieser Reihenfolge wird sichergestellt, dass die Komponenten, auf die die einzelnen Produkte angewiesen sind, korrekt eingerichtet werden.

      Da Sie die Elastic-Paketquelle bereits im vorherigen Schritt hinzugefügt haben, können Sie die verbleibenden Komponenten des Elastic Stacks einfach mit apt installieren:

      Aktivieren und starten Sie dann den Kibana-Dienst:

      • sudo systemctl enable kibana
      • sudo systemctl start kibana

      Da Kibana so konfiguriert ist, dass nur an localhost gelauscht wird, müssen wir einen Reverseproxy einrichten, um externen Zugriff darauf zu ermöglichen. Dazu verwenden wir Nginx, das bereits auf Ihrem Server installiert sein sollte.

      Verwenden Sie zunächst den Befehl openssl, um einen administrativen Kibana-Benutzer zu erstellen, den Sie für den Zugriff auf die Kibana-Weboberfläche verwenden werden. Als Beispiel nennen wir dieses Konto kibanaadmin; für mehr Sicherheit empfehlen wir aber, einen nicht standardmäßigen Namen für Ihren Benutzer zu wählen, der sich nur schwer erraten lässt.

      Mit dem folgenden Befehl werden der administrative Kibana-Benutzer und das Passwort erstellt und in der Datei htpasswd.users gespeichert. Sie werden Nginx so konfigurieren, dass dieser Benutzername und das Passwort erforderlich sind und die Datei vorübergehend gelesen wird:

      • echo "kibanaadmin:`openssl passwd -apr1`" | sudo tee -a /etc/nginx/htpasswd.users

      Geben Sie in der Eingabeaufforderung ein Passwort ein und bestätigen Sie es. Merken oder notieren Sie sich die Anmeldedaten, da Sie sie benötigen werden, um auf die Kibana-Weboberfläche zuzugreifen.

      Als Nächstes erstellen wir eine Nginx-Serverblockdatei. Als Beispiel werden wir diese Datei als your_domain bezeichnen; vielleicht finden Sie es jedoch hilfreich, Ihrer Datei einen beschreibenden Namen zu geben. Wenn Sie für diesen Server beispielsweise einen FQDN und DNS-Einträge eingerichtet haben, könnten Sie diese Datei nach Ihrem FQDN benennen.

      Erstellen Sie mit nano oder Ihrem bevorzugten Texteditor die Nginx-Serverblockdatei:

      • sudo nano /etc/nginx/sites-available/your_domain

      Fügen Sie der Datei den folgenden Codeblock hinzu; vergessen Sie dabei nicht, your_domain durch den FQDN oder die öffentliche IP-Adresse Ihres Servers zu ersetzen. Dieser Code konfiguriert Nginx so, dass HTTP-Datenverkehr Ihres Servers an die Kibana-Anwendung geleitet wird, die an localhost:5601 lauscht. Außerdem konfiguriert er Nginx so, dass die Datei htpasswd.users gelesen und eine grundlegende Authentifizierung vorgeschrieben wird.

      Hinweis: Wenn Sie das Nginx-Voraussetzungstutorial bis zum Ende befolgt haben, haben Sie diese Datei möglicherweise bereits erstellt und mit Inhalten ausgefüllt. Löschen Sie in diesem Fall alle vorhandenen Inhalte in der Datei, bevor Sie Folgendes hinzufügen:

      /etc/nginx/sites-available/your_domain

      server {
          listen 80;
      
          server_name your_domain;
      
          auth_basic "Restricted Access";
          auth_basic_user_file /etc/nginx/htpasswd.users;
      
          location / {
              proxy_pass http://localhost:5601;
              proxy_http_version 1.1;
              proxy_set_header Upgrade $http_upgrade;
              proxy_set_header Connection 'upgrade';
              proxy_set_header Host $host;
              proxy_cache_bypass $http_upgrade;
          }
      }
      

      Wenn Sie fertig sind, speichern und schließen Sie die Datei.

      Aktivieren Sie als Nächstes die neue Konfiguration, indem Sie eine symbolische Verknüpfung zum Verzeichnis sites-enabled erstellen. Wenn Sie bereits eine Serverblockdatei mit dem gleichen Namen in der Nginx-Voraussetzung erstellt haben, müssen Sie diesen Befehl nicht ausführen:

      • sudo ln -s /etc/nginx/sites-available/your_domain /etc/nginx/sites-enabled/your_domain

      Prüfen Sie die Konfiguration dann auf Syntaxfehler:

      Wenn in Ihrer Ausgabe Fehler angezeigt werden, vergewisserrn Sie sich noch einmal, dass die in Ihrer Konfigurationsdatei platzierten Inhalte richtig hinzugefügt wurden. Sobald Sie sehen, dass in der Ausgabe syntax is ok (Syntax in Ordnung) steht, fahren Sie fort und starten Sie den Nginx-Dienst neu:

      • sudo systemctl reload nginx

      Wenn Sie den Leitfaden zur Servereinrichtung befolgt haben, sollte Ihre UFW-Firewall aktiviert sein. Um Verbindungen zu Nginx zu ermöglichen, können wir die Regeln anpassen, indem wir Folgendes eingeben:

      • sudo ufw allow 'Nginx Full'

      Hinweis: Wenn Sie dem Nginx-Voraussetzungstutorial gefolgt sind, haben Sie ggf. eine UFW-Regel erstellt, um das Profil Nginx HTTP über die Firewall zuzulassen. Da das Profil Nginx Full sowohl HTTP- als auch HTTPS-Datenverkehr über die Firewall zulässt, können Sie die von Ihnen im Voraussetzungstutorial erstellte Regel problemlos löschen. Führen Sie dazu folgenden Befehl aus:

      • sudo ufw delete allow 'Nginx HTTP'

      Kibana ist nun über Ihren FQDN oder die öffentliche IP-Adresse des Elastic Stack-Servers zugänglich. Sie können die Statusseite des Kibana-Servers überprüfen, indem Sie zur folgenden Adresse navigieren und Ihre Anmeldedaten eingeben, wenn Sie dazu aufgefordert werden:

      http://your_domain/status
      

      Auf dieser Statusseite werden Informationen zur Ressourcennutzung des Servers angezeigt und die installierten Plugins aufgelistet.

      |Kibana-Statusseite

      Hinweis: Wie im Voraussetzungsbereich erwähnt, sollten Sie auf Ihrem Server SSL/TLS aktivieren. Sie können dem Leitfaden zu Let’s Encrypt folgen, um unter Ubuntu 20.04 ein kostenloses SSL-Zertifikat für Nginx zu erhalten. Nach der Erlangung Ihrer SSL/TLS-Zertifikate können Sie zurückkehren und dieses Tutorial abschließen.

      Nach der Installation des Kibana-Dashboards installieren wir nun die nächste Komponente: Logstash.

      Schritt 3 — Installieren und Konfigurieren von Logstash

      Zwar kann Beats Daten direkt an die Elasticsearch-Datenbank senden, doch ist es üblich, Logstash zur Verarbeitung der Daten zu verwenden. So können Sie flexibler Daten aus verschiedenen Quellen erfassen, in ein einheitliches Format umwandeln und in eine andere Datenbank exportieren.

      Installieren Sie Logstash mit diesem Befehl:

      • sudo apt install logstash

      Nach der Installation von Logstash können Sie mit der Konfiguration fortfahren. Die Konfigurationsdateien von Logstash befinden sich im Verzeichnis /etc/logstash/conf.d. Weitere Informationen zur Konfigurationssyntax finden Sie in der von Elastic bereitgestellten Konfigurationsreferenz. Beim Konfigurieren der Datei ist es hilfreich, sich Logstash als Pipeline vorzustellen, die Daten an einem Ende annimmt, auf die eine oder andere Weise verarbeitet und dann an das Ziel sendet (in diesem Fall an Elasticsearch). Eine Logstash-Pipeline verfügt über zwei erforderliche Elemente (input und output) sowie ein optionales Element (filter). Die Input-Plugins konsumieren Daten aus einer Quelle, die Filter-Plugins verarbeiten die Daten und die Output-Plugins schreiben die Daten an ein Ziel.

      Logstash-Pipeline

      Erstellen Sie eine Konfigurationsdatei namens 02-beats-input.conf, in der Sie Ihren Filebeat-Input einrichten werden:

      • sudo nano /etc/logstash/conf.d/02-beats-input.conf

      Geben Sie die folgende input-Konfiguration ein. Dadurch wird ein beats-Input angegeben, der an TCP-Port 5044 lauschen wird.

      /etc/logstash/conf.d/02-beats-input.conf

      input {
        beats {
          port => 5044
        }
      }
      

      Speichern und schließen Sie die Datei.

      Erstellen Sie als Nächstes eine Konfigurationsdatei namens 30-elasticsearch-output.conf:

      • sudo nano /etc/logstash/conf.d/30-elasticsearch-output.conf

      Fügen Sie die folgende output-Konfiguration ein. Im Wesentlichen konfiguriert dieser Output Logstash so, dass die Beats-Daten in Elasticsearch, das bei localhost:9200 ausgeführt wird, gespeichert werden – und zwar in einem nach dem verwendeten Beat benannten Index. Der in diesem Tutorial verwendete Beat ist Filebeat:

      /etc/logstash/conf.d/30-elasticsearch-output.conf

      output {
        if [@metadata][pipeline] {
          elasticsearch {
          hosts => ["localhost:9200"]
          manage_template => false
          index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
          pipeline => "%{[@metadata][pipeline]}"
          }
        } else {
          elasticsearch {
          hosts => ["localhost:9200"]
          manage_template => false
          index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
          }
        }
      }
      
      
      

      Speichern und schließen Sie die Datei.

      Testen Sie Ihre Logstash-Konfiguration mit diesem Befehl:

      • sudo -u logstash /usr/share/logstash/bin/logstash --path.settings /etc/logstash -t

      Wenn keine Syntaxfehler vorhanden sind, wird Ihre Ausgabe nach ein paar Sekunden Config Validation Result: OK. Exiting Logstash anzeigen. Wenn Sie das nicht in Ihrer Ausgabe sehen, prüfen Sie auf Fehler, die in Ihrer Ausgabe aufgeführt sind, und aktualisieren Sie Ihre Konfiguration, um sie zu korrigieren. Beachten Sie, dass Sie Warnungen von OpenJDK erhalten werden; diese sollten jedoch keine Probleme verursachen und können ignoriert werden.

      Wenn Ihr Konfigurationstest erfolgreich war, starten und aktivieren Sie Logstash, um die Konfigurationsänderungen anzuwenden:

      • sudo systemctl start logstash
      • sudo systemctl enable logstash

      Nachdem Logstash nun korrekt ausgeführt wird und vollständig konfiguriert ist, installieren wir Filebeat.

      Schritt 4 — Installieren und Konfigurieren von Filebeat

      Der Elastic Stack verwendet verschiedene schlanke Datenversender namens Beats, um Daten aus verschiedenen Quellen zu erfassen und zu Logstash oder Elasticsearch zu transportieren. Hier sind die Beats, die derzeit bei Elastic verfügbar sind:

      • Filebeat: erfasst und versendet Protokolldateien.
      • Metricbeat: erfasst Metriken aus Ihren Systemen und Diensten.
      • Packetbeat: erfasst und analysiert Netzwerkdaten.
      • Winlogbeat: erfasst Windows-Ereignisprotokolle.
      • Auditbeat: erfasst Linux-Audit-Frameworkdaten und überwacht die Dateiintegrität.
      • Heartbeat: überwacht Dienste durch aktive Sondierung auf ihre Verfügbarkeit.

      In diesem Tutorial werden wir Filebeat verwenden, um lokale Protokolle an unseren Elastic Stack weiterzuleiten.

      Installieren Sie Filebeat mit apt:

      • sudo apt install filebeat

      Konfigurieren Sie als Nächstes Filebeat so, dass eine Verbindung zu Logstash hergestellt wird. Hier werden wir die Beispielkonfigurationsdatei ändern, die mit Filebeat geliefert wird.

      Öffnen Sie die Filebeat-Konfigurationsdatei:

      • sudo nano /etc/filebeat/filebeat.yml

      Hinweis: Wie bei Elasticsearch liegt die Konfigurationsdatei von Filebeat im YAML-Format vor. Das bedeutet, dass eine richtige Einrückung von entscheidender Bedeutung ist; stellen Sie also sicher, dass Sie die gleiche Anzahl von Leerzeichen verwenden, die in diesen Anweisungen angegeben ist.

      Filebeat unterstützt verschiedene Ausgaben; Sie werden in der Regel Ereignisse jedoch nur zur weiteren Verarbeitung direkt an Elasticsearch oder Logstash senden. In diesem Tutorial verwenden wir Logstash, um eine weitere Verarbeitung der von Filebeat erfassten Daten vorzunehmen. Filebeat muss Daten nicht direkt an Elasticsearch senden; lassen Sie uns diese Ausgabe also deaktivieren. Suchen Sie dazu nach dem Abschnitt output.elasticsearch und kommentieren Sie die folgenden Zeilen aus, indem Sie ihnen ein # voranstellen:

      /etc/filebeat/filebeat.yml

      ...
      #output.elasticsearch:
        # Array of hosts to connect to.
        #hosts: ["localhost:9200"]
      ...
      

      Konfigurieren Sie dann den Abschnitt output.logstash. Heben Sie die Kommentierung der Zeilen output.logstash: und hosts: ["localhost:5044"] auf, indem Sie das # entfernen. Dadurch wird Filebeat so konfiguriert, dass auf Ihrem Elastic Stack-Server an Port 5044 eine Verbindung hergestellt wird. Das ist der Port, für den wir zuvor ein Logstash-Input angegeben haben:

      /etc/filebeat/filebeat.yml

      output.logstash:
        # The Logstash hosts
        hosts: ["localhost:5044"]
      

      Speichern und schließen Sie die Datei.

      Die Funktionalität von Filebeat kann mit Filebeat-Modulen erweitert werden. In diesem Tutorial werden wir das system-Modul verwenden, das Protokolle erfasst und analysiert, die vom Systemprotokollierungsdienst gängiger Linux-Distributionen erstellt werden.

      Aktivieren wir es:

      • sudo filebeat modules enable system

      Sie können eine Liste aktivierter und deaktivierter Module anzeigen, indem Sie Folgendes ausführen:

      • sudo filebeat modules list

      Sie sehen eine Liste, die der folgenden ähnelt:

      Output

      Enabled: system Disabled: apache2 auditd elasticsearch icinga iis kafka kibana logstash mongodb mysql nginx osquery postgresql redis traefik ...

      Standardmäßig ist Filebeat so konfiguriert, dass für die syslog- und authorization-Protokolle Standardpfade verwendet werden. Im Fall dieses Tutorials müssen Sie in der Konfiguration nichts ändern. Sie können die Parameter des Moduls in der Konfigurationsdatei /etc/filebeat/modules.d/system.yml anzeigen.

      Als Nächstes müssen wir die Filebeat-Aufnahme-Pipelines einrichten, die die Protokolldaten analysieren, bevor sie über Logstash an Elasticsearch gesendet werden. Um die Aufnahme-Pipeline für das system-Modul zu laden, geben Sie folgenden Befehl ein:

      • sudo filebeat setup --pipelines --modules system

      Laden Sie als Nächstes die Indexvorlage in Elasticsearch. Ein Elasticsearch-Index ist eine Sammlung von Dokumenten, die ähnliche Merkmale aufweisen. Indizes werden mit einem Namen identifiziert, der bei der Ausführung verschiedener Operationen darin zum Verweisen auf den Index verwendet wird. Die Indexvorlage wird bei Erstellung eines neuen Index automatisch angewendet.

      Um die Vorlage zu laden, verwenden Sie folgenden Befehl:

      • sudo filebeat setup --index-management -E output.logstash.enabled=false -E 'output.elasticsearch.hosts=["localhost:9200"]'

      Output

      Index setup finished.

      Filebeat ist mit beispielhaften Kibana-Dashboards ausgestattet, mit denen Sie Filebeat-Daten in Kibana visualisieren können. Bevor Sie die Dashboards verwenden können, müssen Sie das Indexmuster erstellen und die Dashboards in Kibana laden.

      Während die Dashboards geladen werden, verbindet sich Filebeat mit Elasticsearch, um Versionsdaten zu überprüfen. Um Dashboards zu laden, wenn Logstash aktiviert ist, müssen Sie die Logstash-Ausgabe deaktivieren und die Elasticsearch-Ausgabe aktivieren:

      • sudo filebeat setup -E output.logstash.enabled=false -E output.elasticsearch.hosts=['localhost:9200'] -E setup.kibana.host=localhost:5601

      Sie sollten eine Ausgabe erhalten, die der folgenden ähnelt:

      Output

      Overwriting ILM policy is disabled. Set `setup.ilm.overwrite:true` for enabling. Index setup finished. Loading dashboards (Kibana must be running and reachable) Loaded dashboards Setting up ML using setup --machine-learning is going to be removed in 8.0.0. Please use the ML app instead. See more: https://www.elastic.co/guide/en/elastic-stack-overview/current/xpack-ml.html Loaded machine learning job configurations Loaded Ingest pipelines

      Jetzt können Sie Filebeat starten und aktivieren:

      • sudo systemctl start filebeat
      • sudo systemctl enable filebeat

      Wenn Sie Ihren Elastic Stack richtig eingerichtet haben, wird Filebeat mit dem Versand Ihrer syslog- und authorization-Protokolle an Logstash beginnen, was die Daten dann in Elasticsearch laden wird.

      Um zu prüfen, ob Elasticsearch diese Daten tatsächlich erhält, fragen Sie den Filebeat-Index mit folgendem Befehl ab:

      • curl -XGET 'http://localhost:9200/filebeat-*/_search?pretty'

      Sie sollten eine Ausgabe erhalten, die der folgenden ähnelt:

      Output

      ... { { "took" : 4, "timed_out" : false, "_shards" : { "total" : 2, "successful" : 2, "skipped" : 0, "failed" : 0 }, "hits" : { "total" : { "value" : 4040, "relation" : "eq" }, "max_score" : 1.0, "hits" : [ { "_index" : "filebeat-7.7.1-2020.06.04", "_type" : "_doc", "_id" : "FiZLgXIB75I8Lxc9ewIH", "_score" : 1.0, "_source" : { "cloud" : { "provider" : "digitalocean", "instance" : { "id" : "194878454" }, "region" : "nyc1" }, "@timestamp" : "2020-06-04T21:45:03.995Z", "agent" : { "version" : "7.7.1", "type" : "filebeat", "ephemeral_id" : "cbcefb9a-8d15-4ce4-bad4-962a80371ec0", "hostname" : "june-ubuntu-20-04-elasticstack", "id" : "fbd5956f-12ab-4227-9782-f8f1a19b7f32" }, ...

      Wenn Ihre Ausgabe insgesamt 0 Treffer anzeigt, lädt Elasticsearch keine Protokolle unter dem Index, den Sie angefragt haben; in diesem Fall müssen Sie Ihre Einrichtung auf Fehler prüfen. Wenn Sie die erwartete Ausgabe erhalten haben, fahren Sie mit dem nächsten Schritt fort, in dem Sie erfahren werden, wie Sie durch einige Kibana-Dashboards navigieren können.

      Schritt 5 — Erkunden von Kibana-Dashboards

      Kehren wir zurück zur Kibana-Weboberfläche, die wir zuvor installiert haben.

      Rufen Sie in einem Webbrowser den FQDN oder die öffentliche IP-Adresse Ihres Elastic Stack-Servers auf. Wenn Ihre Sitzung unterbrochen wurde, müssen Sie die in Schritt 2 festgelegten Anmeldedaten erneut eingeben. Sobald Sie sich angemeldet haben, sollten Sie die Homepage von Kibana angezeigt werden:

      Kibana-Homepage

      Klicken Sie in der linken Navigationsleiste auf den Link Discover (Erkunden) (Sie müssen möglicherweise links unten auf das Symbol zum Erweitern klicken, um die Elemente des Navigationsmenüs anzuzeigen). Wählen Sie auf der Seite Discover das vordefinierte filebeat-*-Indexmuster aus, um Filebeat-Daten anzuzeigen. Standardmäßig werden Ihnen die Protokolldaten der letzten 15 Minuten angezeigt. Im Folgenden sehen Sie ein Histogramm mit Protokollereignissen und einige Protokollnachrichten:

      Seite „Discover“ (Erkunden)

      Hier können Sie Ihre Protokolle durchsuchen sowie Ihr Dashboard anpassen. An diesem Punkt wird es hier jedoch nicht viel geben, da Sie nur Syslogs von Ihrem Elastic Stack-Server erfassen.

      Verwenden Sie den linken Bereich, um zur Dashboard-Seite zu navigieren und nach den Filebeat System-Dashboards zu suchen. Nun können Sie die Beispiel-Dashboards auswählen, die mit dem system-Modul von Filebeat geliefert werden.

      Beispielsweise können Sie anhand Ihrer syslog-Nachrichten genaue Statistiken anzeigen:

      Syslog-Dashboard

      Außerdem können Sie sehen, welche Benutzer den sudo-Befehl verwendet haben und wann:

      Sudo-Dashboard

      Kibana verfügt über viele andere Funktionen wie Diagrammerstellung und Filter; sehen Sie sich diese Funktionen bei Interesse genauer an.

      Zusammenfassung

      In diesem Tutorial haben Sie gelernt, wie Sie den Elastic Stack installieren und so konfigurieren können, dass er Systemprotokolle erfasst und analysiert. Denken Sie daran, dass Sie mit Beats fast jede Art von Protokoll oder indizierten Daten an Logstash senden können. Die Daten werden jedoch noch nützlicher, wenn sie mit einem Logstash-Filter analysiert und strukturiert werden; dabei werden die Daten in ein konsistentes Format umgewandelt, das von Elasticsearch leicht gelesen werden kann.



      Source link

      Cómo instalar Elasticsearch, Logstash y Kibana (Elastic Stack) en Ubuntu 20.04


      Introducción

      Elastic Stack, previamente conocida como la pila ELK, es una colección de software de código abierto producido por Elastic que le permite buscar, analizar, y visualizar registros generados desde cualquier fuente y en cualquier formato, una práctica conocida como registro centralizado. El registro centralizado puede ser muy útil al intentar identificar problemas en sus servidores o aplicaciones, ya que le permite realizar búsquedas en todos sus registros desde un solo sitio. También es útil porque le permite identificar problemas que abarcan varios servidores vinculando sus registros durante un período de tiempo específico.

      Elastic Stack cuenta con cuatro componentes principales:

      • Elasticsearch: motor de búsqueda de RESTfuldistribuido que almacena todos los datos recopilados.
      • Logstash: componente de procesamiento de datos de Elastic Stack que envía datos entrantes a Elasticsearch.
      • Kibana: interfaz web para buscar y visualizar registros.
      • Beats: transportadores de datos ligeros de uso único que pueden enviar datos de cientos o miles de máquinas a Logstash o Elasticsearch.

      A través de este tutorial, instalará Elastic Stack en un servidor de Ubuntu 20.04. Aprenderá a instalar todos los componentes de Elastic Stack, incluido Filebeat, un Beat que se usa para reenviar y centralizar registros y archivos, y los configurará para recopilar y visualizar registros del sistema. Además, debido a que Kibana normalmente está solo disponible en el localhost, usaremos Nginx para hacer un proxy de modo que el acceso sea posible a través de un navegador web. Instalaremos todos estos componentes en un único servidor al que nos referiremos como nuestro servidor de pila de Elastic.

      Nota: Al instalar Elastic Stack, debe usar la misma versión en toda la pila. En este tutorial, instalaremos las últimas versiones de toda la pila que, al redactarse el presente artículo, eran Elasticsearch 7.7.1, Kibana 7.7.1, Logstash 7.7.1 y Filebeat 7.7.1.

      Requisitos previos

      Para completar este tutorial, necesitará lo siguiente:

      Además, debido a que Elastic Stack se usa para acceder a información valiosa sobre su servidor a la que no quiere que accedan usuarios no autorizados, es importante que mantenga su servidor protegido instalando un certificado TLS o SSL. Esto es opcional, pero se recomienda enfáticamente.

      Sin embargo, ya que eventualmente realizará cambios en su bloque de servidor de Nginx a lo largo de esta guía, es probable que tenga más sentido completar la guía de Let´s Encrypt sobre Ubuntu 20.04 al final del segundo paso de este tutorial. Teniendo eso en cuenta, si planea configurar Let´s Encrypt en su servidor, necesitará lo siguiente antes de hacerlo:

      • Un nombre de dominio totalmente apto (FQDN). Para este tutorial, se utilizará your_domain en todo momento. Puede adquirir un nombre de dominio en Namecheap, obtener uno gratuito en Freenom o utilizar un registrador de dominios de su elección.
      • Los dos registros DNS que se indican a continuación se han configurado para su servidor. Puede utilizar esta introducción al DNS de DigitalOcean para obtener más información sobre cómo agregarlos.

        • Un registro A con your_domain orientado a la dirección IP pública de su servidor.
        • Un registro A con www.your_domain orientado a la dirección IP pública de su servidor.

      Paso 1: Instalar y configurar Elasticsearch

      Los componentes de Elasticsearch no están disponibles en los repositorios de paquetes predeterminados de Ubuntu. Sin embargo, pueden instalarse con APT una vez que agregue la lista de fuentes de paquetes de Elastic.

      Todos los paquetes de Elasticsearch están firmados con la clave de firma de Elasticsearch para proteger su sistema contra la suplantación de paquetes. Su administrador de paquetes considerará confiables los paquetes autenticados con la clave. En este paso, importará la clave GPG pública de Elasticsearch y agregará la lista de fuentes de paquetes de Elastic para instalar Elasticsearch.

      Para comenzar, utilice cURL, la herramienta de línea de comandos para transferir datos con URL, para importar la clave GPG pública de Elasticsearch a APT. Tenga en cuenta que estamos usando los argumentos -fsSL para silenciar todos los progresos y posibles errores (excepto los de errores del servidor) y para permitir a cURL hacer una solicitud en una ubicación nueva si se redirige.  Canalice el resultado del comando cURL al programa apt-key, que añade la clave GPG pública a APT.

      • curl -fsSL https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

      A continuación, agregue la lista de fuentes de Elastic al directorio sources.list.d, donde APT buscará nuevas fuentes:

      • echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-7.x.list

      A continuación, actualice sus listas de paquetes para que APT lea la nueva fuente de Elastic:

      Luego, instale Elasticsearch con este comando:

      • sudo apt install elasticsearch

      Ahora, Elasticsearch está instalada y lista para usarse. Utilice su editor de texto preferido para editar el archivo de configuración principal de Elasticsearch, elasticsearch.yml. En este caso, utilizaremos nano:

      • sudo nano /etc/elasticsearch/elasticsearch.yml

      Nota: El archivo de configuración de Elasticsearch se encuentra en formato YAML, lo que significa que debemos mantener el formato de sangrías. Asegúrese de no añadir espacios adicionales al editar este archivo.

      El archivo elasticsearch.yml ofrece opciones de configuración para su clúster, nodo, rutas, memoria, red, detección y puerta de enlace. La mayoría de estas opciones están preconfiguradas en el archivo, pero las puede cambiar según sus necesidades. Para los fines de nuestra demostración de una configuración de un solo servidor, modificaremos únicamente la configuración del host de red.

      Elasticsearch escucha el tráfico de todos los lugares en el puerto 9200. Es conveniente restringir el acceso externo a su instancia de Elasticsearch para evitar que terceros lean sus datos o cierren su clúster de Elasticsearch a través de su API REST.  Para restringir el acceso y, por lo tanto, aumentar la seguridad, busque la línea que especifica network.host, elimine los comentarios y reemplace su valor por localhost para que tenga el siguiente aspecto:

      /etc/elasticsearch/elasticsearch.yml

      . . .
      # ---------------------------------- Network -----------------------------------
      #
      # Set the bind address to a specific IP (IPv4 or IPv6):
      #
      network.host: localhost
      . . .
      

      Hemos especificado localhost para que Elasticsearch escuche en todas las interfaces y las IP vinculadas. Si desea que escuche únicamente en una interfaz específica, puede especificar su IP en lugar de localhost. Guarde y cierre elasticsearch.yml. Si utiliza nano, puede hacerlo pulsando CTRL+X, seguido de Y y, luego, ENTER.

      Estos son los ajustes mínimos con los que puede comenzar para usar Elasticsearch. Ahora, puede iniciar Elasticsearch por primera vez.

      Inicie el servicio de Elasticsearch con systemctl. Elasticsearch tardará unos minutos en iniciarse. Espere, de lo contrario, es posible que reciba errores de que no se puede conectar.

      • sudo systemctl start elasticsearch

      Luego, ejecute el siguiente comando para permitir que Elasticsearch se cargue cada vez que su servidor se inicia:

      • sudo systemctl enable elasticsearch

      Puede comprobar si su servicio de Elasticsearch se está ejecutando enviando una solicitud HTTP:

      • curl -X GET "localhost:9200"

      Visualizará una respuesta que mostrará información básica sobre su nodo local, similar a la siguiente:

      Output

      { "name" : "Elasticsearch", "cluster_name" : "elasticsearch", "cluster_uuid" : "qqhFHPigQ9e2lk-a7AvLNQ", "version" : { "number" : "7.7.1", "build_flavor" : "default", "build_type" : "deb", "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f", "build_date" : "2020-03-26T06:34:37.794943Z", "build_snapshot" : false, "lucene_version" : "8.5.1", "minimum_wire_compatibility_version" : "6.8.0", "minimum_index_compatibility_version" : "6.0.0-beta1" }, "tagline" : "You Know, for Search" }

      Ahora que Elasticsearch está configurado y activo, instalaremos Kibana, el siguiente componente de Elastic Stack.

      Paso 2: Instalar y configurar el panel de Kibana

      De acuerdo con la documentación oficial, deberá instalar Kibana solo después de instalar Elasticsearch. La instalación en este orden garantiza que los componentes de los que depende cada producto estén correctamente implementados.

      Debido a que ya agregó la fuente de paquetes de Elastic en el paso anterior, puede instalar los componentes restantes de Elastic Stack usando apt:

      A continuación, habilite e inicie el servicio de Kibana:

      • sudo systemctl enable kibana
      • sudo systemctl start kibana

      Debido a que Kibana está configurado para escuchar solo en localhost, debemos configurar un proxy inverso para permitir el acceso externo a este. Utilizaremos Nginx para este propósito, que ya debería estar instalado en su servidor.

      Primero, utilice el comando openssl para crear un usuario administrativo de Kibana que usará para acceder a la interfaz web de Kibana. Como ejemplo, nombraremos esta cuenta kibanaadmin, pero, para garantizar una mayor seguridad, le recomendamos elegir un nombre no estándar para su usuario que sea difícil de adivinar.

      Con el siguiente comando se crearán el usuario y la contraseña administrativa de Kibana, y se almacenarán en el archivo htpasswd.users. Configurará Nginx para que requiera este nombre de usuario y contraseña, y lea este archivo de manera momentánea:

      • echo "kibanaadmin:`openssl passwd -apr1`" | sudo tee -a /etc/nginx/htpasswd.users

      Introduzca y confirme una contraseña cuando se le solicite. Recuerde este dato de inicio de sesión o tome nota de él, ya que lo necesitará para acceder a la interfaz web de Kibana.

      A continuación, crearemos un archivo de bloque de servidor de Nginx. Como ejemplo, nos referiremos a este archivo como your_domain, aunque podría resultarle más útil darle al suyo un nombre más descriptivo. Por ejemplo, si tiene un FQDN y registros de DNS configurados para este servidor, podría darle a este archivo el nombre de su FQDN.

      Cree el archivo de bloque de servidor de Nginx usando nano o su editor de texto preferido:

      • sudo nano /etc/nginx/sites-available/your_domain

      Añada el siguiente bloque de código al archivo, y asegúrese de actualizar your_domain para que coincida con la FQDN o la dirección IP pública de su servidor. Con este código, se configura Nginx para dirigir el tráfico HTTP de su servidor a la aplicación de Kibana, que escucha en localhost:5601. También se configura Nginx para leer el archivo htpasswd.users y requerir la autenticación básica.

      Tenga en cuenta que, si siguió todo el tutorial de los requisitos previos de Nginx, es posible que ya haya creado este archivo y lo haya completado con contenido. En ese caso, elimine todo el contenido existente en el archivo antes de añadir lo siguiente:

      /etc/nginx/sites-available/your_domain

      server {
          listen 80;
      
          server_name your_domain;
      
          auth_basic "Restricted Access";
          auth_basic_user_file /etc/nginx/htpasswd.users;
      
          location / {
              proxy_pass http://localhost:5601;
              proxy_http_version 1.1;
              proxy_set_header Upgrade $http_upgrade;
              proxy_set_header Connection 'upgrade';
              proxy_set_header Host $host;
              proxy_cache_bypass $http_upgrade;
          }
      }
      

      Cuando termine, guarde y cierre el archivo.

      A continuación, habilite la nueva configuración creando un enlace simbólico al directorio sites-enabled. Si ya creó un archivo de bloque de servidor con el mismo nombre en el requisito previo de Nginx, no necesitará ejecutar este comando:

      • sudo ln -s /etc/nginx/sites-available/your_domain /etc/nginx/sites-enabled/your_domain

      A continuación, compruebe que no haya errores de sintaxis en la configuración:

      Si se muestran errores en su resultado, regrese y verifique bien que el contenido que ingresó en su archivo de configuración se haya agregado correctamente. Una vez que vea syntax is ok en el resultado, reinicie el servicio de Nginx:

      • sudo systemctl reload nginx

      Si siguió la guía de configuración inicial para servidores, debería tener activado un firewall UFW. Para permitir las conexiones con Nginx, podemos ajustar las reglas escribiendo lo siguiente:

      • sudo ufw allow 'Nginx Full'

      Nota: Si siguió el tutorial de los requisitos previos de Nginx, es posible que haya creado una regla de UFW que admita el perfil Nginx HTTP en el firewall. Debido a que el perfil Nginx Full admite el paso del tráfico HTTP y HTTPS por el firewall, puede eliminar de forma segura la regla que creó en el tutorial de los requisitos previos. Hágalo con el siguiente comando:

      • sudo ufw delete allow 'Nginx HTTP'

      Con esto, el acceso a Kibana será posible a través de su FQDN o de la dirección IP pública de su servidor de Elastic Stack. Puede comprobar la página de estado del servidor de Kibana visitando la siguiente dirección e ingresando sus credenciales de inicio de sesión cuando se le soliciten:

      http://your_domain/status
      

      En esta página de estado, se muestra información sobre el uso de los recursos del servidor y se enumeran los complementos instalados.

      Página de estado de |Kibana

      Nota: Como se indica en la sección de requisitos previos, se le recomienda habilitar SSL o TLS en su servidor. Ahora, puede seguir la guía de Let’s Encrypt para obtener un certificado SSL gratuito para Nginx en Ubuntu 20.04. Una vez que obtenga sus certificados SSL y TLS, puede volver y completar este tutorial.

      Ahora que el panel de Kibana está configurado, instalaremos el siguiente componente: Logstash.

      Paso 3: Instalar y configurar Logstash

      Aunque es posible que Beats envíe datos de manera directa a la base de datos de Elasticsearch, recomendamos usar Logstash para procesar los datos. Esto le permitirá, de forma más flexible, recopilar datos de diferentes fuentes, transformarlos en un formato común y exportarlos a otra base de datos.

      Instale Logstash con este comando:

      • sudo apt install logstash

      Después de instalar Logstash, puede seguir configurándolo. Los archivos de configuración de Logstash residen en el directorio /etc/logstash/conf.d. Para obtener más información sobre la sintaxis de configuración, puede consultar la referencia de configuración que proporciona Elastic. A medida que configura el archivo, le resultará útil pensar que Logstash es un proceso que toma datos en un extremo, los procesa de una u otra manera y los envía a su destino (en este caso, el destino es Elasticsearch). Un proceso de Logstash tiene dos elementos necesarios, input y output, y un elemento opcional, filter. Los complementos de entrada consumen datos de una fuente, los complementos del filtro procesan los datos, y los complementos de salida escriben los datos en un destino.

      Proceso de Logstash

      Cree un archivo de configuración llamado 02-beats-input.conf en el que establecerá su entrada de Filebeat:

      • sudo nano /etc/logstash/conf.d/02-beats-input.conf

      Introduzca la siguiente configuración de input. Con esto, se especifica una entrada de beats que escuchará en el puerto TCP 5044.

      /etc/logstash/conf.d/02-beats-input.conf

      input {
        beats {
          port => 5044
        }
      }
      

      Guarde y cierre el archivo.

      A continuación, cree un archivo de configuración llamado 30-elasticsearch-output.conf:

      • sudo nano /etc/logstash/conf.d/30-elasticsearch-output.conf

      Introduzca la siguiente configuración de output. Básicamente, con este resultado, se configura Logstash para almacenar los datos de Beats en Elasticsearch, que se ejecuta en localhost:9200, en un índice con el nombre del Beat utilizado. El Beat utilizado en este tutorial es Filebeat:

      /etc/logstash/conf.d/30-elasticsearch-output.conf

      output {
        if [@metadata][pipeline] {
          elasticsearch {
          hosts => ["localhost:9200"]
          manage_template => false
          index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
          pipeline => "%{[@metadata][pipeline]}"
          }
        } else {
          elasticsearch {
          hosts => ["localhost:9200"]
          manage_template => false
          index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
          }
        }
      }
      
      
      

      Guarde y cierre el archivo.

      Pruebe su configuración de Logstash con el siguiente comando:

      • sudo -u logstash /usr/share/logstash/bin/logstash --path.settings /etc/logstash -t

      Si no hay errores de sintaxis, su resultado mostrará Config Validation Result: OK. Existing Logstash después de unos segundos. Si no visualiza esto en su resultado, verifique cualquier error que aparezca en su resultado y actualice su configuración para corregirlo. Tenga en cuenta que recibirá advertencias de OpenJDK, pero no deberían causar ningún problema y pueden ignorarse.

      Si su prueba de configuración tiene éxito, inicie y habilite Logstash para implementar los cambios de configuración:

      • sudo systemctl start logstash
      • sudo systemctl enable logstash

      Ahora que Logstash se ejecuta de manera correcta y está totalmente configurado, instalaremos Filebeat.

      Paso 4: Instalar y configurar Filebeat

      La pila de Elastic utiliza varios transportadores de datos ligeros llamados Beats para recopilar datos de varias fuentes y transportarlos a Logstash o Elasticsearch. Aquí se muestran los Beats que ahora están disponibles en Elastic:

      • Filebeat: recopila y envía archivos de registro.
      • Metricbeat: recopila métricas de sus sistemas y servicios.
      • Packetbeat: recopila y analiza datos de red.
      • Winlogbeat: recopila registros de eventos de Windows.
      • Auditbeat: recopila datos del marco de trabajo de auditoría de Linux y supervisa la integridad de los archivos.
      • Heartbeat: supervisa la disponibilidad de los servicios con sondeo activo.

      En este tutorial, usaremos Filebeat para reenviar registros locales a nuestra pila de Elastic.

      Instale Filebeat usando apt:

      • sudo apt install filebeat

      A continuación, configure Filebeat para que se conecte a Logstash. Aquí, modificaremos el archivo de configuración de ejemplo que viene con Filebeat.

      Abra el archivo de configuración de Filebeat:

      • sudo nano /etc/filebeat/filebeat.yml

      Nota: Al igual que con Elasticsearch, el archivo de configuración de Filebeat está en formato YAML. Esto significa que una correcta sangría es esencial. Por lo tanto, asegúrese de usar el mismo número de espacios que se indican en estas instrucciones.

      Filebeat admite numerosas salidas, pero por lo general solo enviará eventos directamente a Elasticsearch o a Logstash para su procesamiento adicional. En este tutorial, usaremos Logstash para aplicar procesamiento adicional a los datos recopilados por Filebeat. Filebeat no tendrá que enviar datos de manera directa a Elasticsearch, por lo que desactivaremos esa salida. Para hacerlo, encuentre la sección output.elasticsearch y comente las siguientes líneas anteponiéndoles #:

      /etc/filebeat/filebeat.yml

      ...
      #output.elasticsearch:
        # Array of hosts to connect to.
        #hosts: ["localhost:9200"]
      ...
      

      A continuación, configure la sección output.logstash. Elimine el comentario de las líneas output.logstash: y hosts: ["localhost:5044"] quitando #. Con esto, se configurará Filebeat para establecer conexión con Logstash en su servidor de Elastic Stack en el puerto 5044, para el que especificamos una entrada de Logstash previamente:

      /etc/filebeat/filebeat.yml

      output.logstash:
        # The Logstash hosts
        hosts: ["localhost:5044"]
      

      Guarde y cierre el archivo.

      La funcionalidad de Filebeat puede ampliarse con módulos de Filebeat. En este tutorial usaremos el módulo de sistema, que recopila y analiza registros creados por el servicio de registro del sistema de distribuciones comunes de Linux.

      Vamos a habilitarlo:

      • sudo filebeat modules enable system

      Puede ver una lista de módulos habilitados y desactivados ejecutando lo siguiente:

      • sudo filebeat modules list

      Verá una lista similar a la siguiente:

      Output

      Enabled: system Disabled: apache2 auditd elasticsearch icinga iis kafka kibana logstash mongodb mysql nginx osquery postgresql redis traefik ...

      Por defecto, Filebeat está configurado para usar rutas predeterminadas para los registros syslog y de autorización. En el caso de este tutorial, no necesita aplicar cambios en la configuración. Puede ver los parámetros del módulo en el archivo de configuración /etc/filebeat/modules.d/system.yml.

      A continuación, debemos configurar los procesos de ingesta de Filebeat, que analizan los datos de registro antes de enviarlos a través de Logstash a Elasticsearch. Para cargar el proceso de ingesta para el módulo de sistema, introduzca el siguiente comando:

      • sudo filebeat setup --pipelines --modules system

      A continuación, cargue la plantilla de índice en Elasticsearch. Un índice de Elasticsearch es un conjunto de documentos que tienen características similares. Los índices se identifican con un nombre, que se utiliza para referirse al índice cuando se realizan varias operaciones dentro de este. La plantilla de índice se aplicará de forma automática al crear un nuevo índice.

      Para cargar la plantilla, utilice el siguiente comando:

      • sudo filebeat setup --index-management -E output.logstash.enabled=false -E 'output.elasticsearch.hosts=["localhost:9200"]'

      Output

      Index setup finished.

      Filebeat incluye paneles de muestra de Kibana que le permiten visualizar datos de Filebeat en Kibana. Para poder usar los paneles, deberá crear el patrón de índice y cargar los paneles en Kibana.

      Al cargarse los paneles, Filebeat se conecta a Elasticsearch para verificar la información de la versión. Para cargar paneles cuando se habilite Logstash, deberá desactivar el resultado de Logstash y habilitar el de Elasticsearch:

      • sudo filebeat setup -E output.logstash.enabled=false -E output.elasticsearch.hosts=['localhost:9200'] -E setup.kibana.host=localhost:5601

      Debería recibir un resultado similar a este:

      Output

      Overwriting ILM policy is disabled. Set `setup.ilm.overwrite:true` for enabling. Index setup finished. Loading dashboards (Kibana must be running and reachable) Loaded dashboards Setting up ML using setup --machine-learning is going to be removed in 8.0.0. Please use the ML app instead. See more: https://www.elastic.co/guide/en/elastic-stack-overview/current/xpack-ml.html Loaded machine learning job configurations Loaded Ingest pipelines

      Ahora podrá iniciar y habilitar Filebeat:

      • sudo systemctl start filebeat
      • sudo systemctl enable filebeat

      Si configuró su pila de Elastic de manera correcta, Filebeat iniciará el envío de sus registros syslog y de autorización a Logstash, que a su vez cargará esos datos en Elasticsearch.

      Para verificar que Elasticsearch realmente reciba estos datos, consulte el índice de Filebeat con este comando:

      • curl -XGET 'http://localhost:9200/filebeat-*/_search?pretty'

      Debería recibir un resultado similar a este:

      Output

      ... { { "took" : 4, "timed_out" : false, "_shards" : { "total" : 2, "successful" : 2, "skipped" : 0, "failed" : 0 }, "hits" : { "total" : { "value" : 4040, "relation" : "eq" }, "max_score" : 1.0, "hits" : [ { "_index" : "filebeat-7.7.1-2020.06.04", "_type" : "_doc", "_id" : "FiZLgXIB75I8Lxc9ewIH", "_score" : 1.0, "_source" : { "cloud" : { "provider" : "digitalocean", "instance" : { "id" : "194878454" }, "region" : "nyc1" }, "@timestamp" : "2020-06-04T21:45:03.995Z", "agent" : { "version" : "7.7.1", "type" : "filebeat", "ephemeral_id" : "cbcefb9a-8d15-4ce4-bad4-962a80371ec0", "hostname" : "june-ubuntu-20-04-elasticstack", "id" : "fbd5956f-12ab-4227-9782-f8f1a19b7f32" }, ...

      Si su resultado no muestra coincidencias, Elasticsearch no está cargando ningún registro bajo el índice que buscó, y deberá verificar su configuración en busca de errores. Si obtuvo el resultado esperado, continúe con el siguiente paso, en el que veremos la manera de explorar algunos de los paneles de Kibana.

      Paso 5: Explorar los paneles de Kibana

      Volvamos a la interfaz web de Kibana que instalamos antes.

      En un navegador web, diríjase al FQDN o a la dirección IP pública de su servidor de Elastic Stack. Si su sesión se ha interrumpido, deberá volver a introducir las credenciales que definió en el paso 2. Una vez que haya iniciado sesión, debería recibir la página de inicio de Kibana:

      Página de inicio de Kibana

      Haga clic en el enlace Descubrir de la barra de navegación a la izquierda (puede tener que hacer clic en el icono Expandir de la parte inferior izquierda para ver los elementos del menú de navegación). En la página Discover, seleccione el patrón de índice predeterminado de filebeat-* para ver datos de Filebeat. Por defecto, esto le mostrará todos los datos de registro de los últimos 15 minutos. Visualizará un histograma con eventos de registro y algunos mensajes de registro a continuación:

      Página de Discover

      Aquí puede buscar y explorar sus registros y también personalizar su panel. Sin embargo, en este punto, no habrá muchos registros porque solo recopila syslogs de su servidor de Elastic Stack.

      Utilice el panel del lado izquierdo para acceder a la página Dashboard y buscar los paneles de Filebeat System. Ahí puede seleccionar los paneles de muestra que vienen con el módulo system de Filebeat.

      Por ejemplo, puede ver estadísticas detalladas basadas en sus mensajes de syslog:

      Panel Syslog

      También puede ver los usuarios que utilizaron el comando sudo y el momento en que lo hicieron:

      Panel Sudo

      Kibana tiene muchas otras características, como graficar y filtrar. No dude en explorarlas.

      Conclusión

      A través de este tutorial, aprendió a instalar y configurar Elastic Stack para recopilar y analizar registros del sistema. Recuerde que puede enviar casi cualquier tipo de datos de registro o de índice a Logstash usando Beats, pero los datos se vuelven aún más útiles si se analizan y estructuran con un filtro de Logstash, ya que transforma los datos en un formato uniforme que Elasticsearch puede leer de forma sencilla.



      Source link