ansible-install-elk-debian

Installation de la version 8.9 de l'empilement ELK avec Ansible

Prérequis:

Qu'est-ce qu'ELK Stack
Qu'est-ce qu'Ansible et comment l'installer
Installation d'une pile ELK avec Ansible

1. ÉTAPE SÉLECTION

ELK Stack est un logiciel open source utilisé pour la gestion et l'analyse des journaux. «ELK» signifie les initiales de trois composants logiciels différents:

Elasticsearch: Utilisé comme moteur de stockage et d'interrogation de données, Elasticsearch peut rapidement stocker de grandes quantités de données et traiter des requêtes complexes. En envoyant des données de journal à Elasticsearch, vous pouvez accéder rapidement à ces données.
Logstash: Utilisé pour collecter, traiter et transmettre des données de journal à partir de diverses sources à Elasticsearch ou à une autre base de données. Logstash traite les données du journal de manière configurable, en les organisant et en les préparant pour l'analyse.
Kibana: Utilisé pour visualiser et analyser les données. Kibana fournit une interface conviviale et fonctionne de manière transparente avec Elasticsearch pour transformer les données logarithmiques en informations significatives au moyen de graphiques, de tableaux et de tableaux de bord visuels. Kibana est un outil utile pour surveiller les journaux, le débogage et le suivi des performances.

ELK Stack est un choix populaire pour la surveillance et l'analyse des journaux, en particulier pour les applications ou les systèmes à grande échelle.

2. ANSIBLE

Ansible est un outil d'automatisation qui vous permet d'effectuer des tâches d'installation et de configuration sur vos serveurs.

Installation de ansible

sudo apt install ansible

3. Installation d'une pile ELK avec Ansible

Pour utiliser Ansible dans une approche basée sur les rôles, vous pouvez vous référer à la documentation d'Ansible sur l'utilisation des rôles et la structure des répertoires ici.

Pour ELK Stack, vous aurez besoin de trois rôles différents:

Elasticsearch
Kibana
Logstash. Vous aurez besoin de créer des rôles distincts pour chacun d'eux.

ansible-galaxy init roles/elasticsearch kibana logstash

Architecture fichiers:

group_vars
- all.yml
host_vars
- 192.168.1.10.yml
playbooks
- elasticsearch.yml
- logstash.yml
- kibana.yml
roles
- elasticsearch
- kibana
- logstash
ancible.cfg
Readmed
.ansible-lint

Après avoir exécuté ces commandes, vous aurez les modèles pour vos rôles. Vous pouvez commencer à créer des fichiers role.yaml dans le répertoire ./roles/elasticsearch/tasks.

Pour l'installation d'Elasticsearch, commencez par installer les outils nécessaires sur le serveur :

- name: Install apt package requirements
  apt:
    name: "{{ item }}"
    state: present
    update_cache: yes
  with_items:
    - gpg-agent
    - curl
    - procps
    - net-tools
    - gnupg

Ensuite, installez Elasticsearch en ajoutant les commandes suivantes. Pour des informations détaillées, reportez-vous à Elasticsearch oficiel

- name: Install Elasticsearch
  block:
    - name: elasticsearch-install | Import Elasticsearch GPG Key
      ansible.builtin.shell: "curl -fsSL https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg"
- name: Add Elasticsearch APT Repository
      ansible.builtin.apt_repository:
        repo: "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main"
        state: present
        filename: "elastic-8.x.list"
    - name: Install Elasticsearch package
      ansible.builtin.apt:
        name: elasticsearch
        state: present

Après avoir effectué l'installation nécessaire, vous devez configurer Elasticsearch. Tout d'abord, mettez à jour le fichier de configuration Elasticsearch, /etc/elasticsearch/elasticsearch.yml

Avec les paramètres requis tels que network.host et http.port. Ces paramètres doivent être paramétrés et vous les définirez dans le fichier main.yaml de votre playbook :

- name: Update Elasticsearch Configuration File
  lineinfile:
    path: /etc/elasticsearch/elasticsearch.yml
    regexp: "{{ item.regexp }}"
    line: "{{ item.line }}"
  loop:
    - { regexp: '^network\.host:', line: 'network.host: {{ inventory_hostname }}' }
    - { regexp: '^http\.port:', line: '{{ elasticsearch.http_port }}' }

Dans l’extrait ci-dessus, elasticsearch.http_port sera défini comme une variable dans le fichier main.yaml de votre playbook, et inventor_hostname représente le nom d’hôte du serveur actuel.

Après avoir mis à jour la configuration, activez et démarrez le service Elasticsearch :

- name: Enable and start Elasticsearch service
  service:
    name: elasticsearch
    state: started
    enabled: yes

Générer un mot de passe pour Elasticsearch :

- name: Run Elasticsearch Reset Password Command
  command: /usr/share/elasticsearch/bin/elasticsearch-reset-password auto -u elastic
  args:
    stdin: "y\n"  
  register: reset_password_output

La valeur enregistrée, reset_password_output, sera utilisée dans les fichiers de configuration de Logstash.

Enfin, redémarrez Elasticsearch :

- name: Enable and start Elasticsearch service
  service:
    name: elasticsearch
    state: restarted

Incluez ces fichiers YAML dans ./roles/elasticsearch/tasks/main.yaml :

---
- include_tasks: elasticsearch-install.yml

- import_tasks: elasticsearch-configure.yml

Ceci termine l'installation et la configuration d'Elasticsearch.

Configuration kibana

Vous pouvez suivre des étapes similaires pour l'installation de Kibana. Dans le répertoire ./roles/kibana/tasks, créez les fichiers kibana-install.yaml et kibana-configure.yaml.

Pour l'installation de Kibana, utilisez les commandes suivantes dans kibana-install.yaml :

- name: Install kibana
  block:
    - name: Import kibana GPG Key
      ansible.builtin.shell: "curl -fsSL https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg"
    - name: Add kibana APT Repository
      ansible.builtin.apt_repository:
        repo: "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main"
        state: present
        filename: "elastic-8.x.list"
    - name: Install kibana package
      ansible.builtin.apt:
        name: kibana
        state: present

À ce stade, nous ajoutons les étapes nécessaires au fichier kibana-configure.yaml pour la configuration. Dans notre configuration, l'intégration SSL n'a pas été implémentée. Si SSL est requis, vous pouvez personnaliser les configurations en conséquence.

Dans le fichier /etc/kibana/kibana.yml, nous gérons les intégrations telles que « server.port, server.host et server.publicBaseUrl », et pour ces intégrations, nous aurons les variables requises définies dans le fichier main.yaml de notre playbook.

- name: Update Elasticsearch Configuration File
  lineinfile:
    path: /etc/kibana/kibana.yml
    regexp: "{{ item.regexp }}"
    line: "{{ item.line }}"
  loop:
    - { regexp: '^server\.port:', line: 'server.port: {{ kibana.server_port }}' }
    - { regexp: '^server\.host:', line: 'server.host: "{{ kibana.server_host }}"' }
    - { regexp: '^server\.publicBaseUrl:', line: 'server.publicBaseUrl: {{ kibana.publicBaseUrl }}' }

Dans la version 8.9 de Kibana, nous effectuons l'installation en nous connectant à l'interface et en effectuant automatiquement l'installation à l'aide d'un jeton obtenu à partir du serveur. Nous le ferons depuis le serveur.

Générez un jeton d'inscription et configurez Kibana avec celui-ci :

- name: Run Elasticsearch Create Enrollment Token Command
  shell: /usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s kibana
  register: token_response
- name: Extract Token from Response
  set_fact:
    enrollment_token: "{{ token_response.stdout }}"
- name: Run Kibana Enrollment Token Command
  shell: /usr/share/kibana/bin/kibana-setup --enrollment-token {{ enrollment_token }}
  args:
    stdin: "y\n"

Le script kibana-setup situé dans le chemin /usr/share/kibana/bin/ effectue l'installation nécessaire. Nous pouvons obtenir le jeton requis en utilisant le script elasticsearch-create-enrollment-token situé dans le chemin /usr/share/elasticsearch/bin/ avec les paramètres "-s kibana". Une fois l'installation terminée, nous ajoutons la commande pour activer et démarrer Kibana.

- name: Enable and start kibana service
  service:
    name: kibana
    state: started
    enabled: yes

Comme avec Elasticsearch, nous appelons ces deux fichiers YAML que nous avons créés dans le fichier main.yaml.

---
- include_tasks: kibana-install.yml

- import_tasks: kibana-configure.yml

Nous pouvons procéder à l’installation du dernier rôle, qui est Logstash.

Créez les fichiers « logstash-install.yaml » et « logstash-configure.yaml » dans le répertoire « ./roles/logstash/tasks », comme nous l’avons fait pour les autres rôles.

Pour le processus d'installation, vous pouvez vous référer à la documentation correspondante à ce lien : Guide d'installation de Logstash. Vous y trouverez des instructions détaillées.

Dans le fichier « logstash-install.yaml », suivez la documentation pour saisir les commandes nécessaires à l’installation de Logstash.

Veuillez noter que le processus d'installation et les commandes sont expliqués en détail dans le lien fourni.

- name: Install logstash
  block:
    - name: Import logstash GPG Key
      ansible.builtin.shell: "curl -fsSL https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg"
- name: Add logstash APT Repository
      ansible.builtin.apt_repository:
        repo: "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main"
        state: present
        filename: "elastic-8.x.list"
    - name: Install logstash package
      ansible.builtin.apt:
        name: logstash
        state: present

Après avoir terminé l'installation, nous configurons notre Logstash à l'aide du fichier « logstash-configure.yaml ».

Tout d'abord, dans le répertoire "./roles/logstash", créez un fichier modèle Jinja nommé "30-elasticsearch-output.conf.j2" dans la section "templates". Dans ce fichier, vous allez spécifier les informations de sortie pour Logstash, mais vous devriez rendre les parties pertinentes paramétriques.

output {
  if [@metadata][pipeline] {
        elasticsearch {
          hosts => ["https://{{ elastic_host }}:9200"]
          user => 'elastic'
          password => '{{ hostvars[play_hosts[0]]['elastic_password'] }}'

Dans cet exemple, nous avons rendu certaines parties du fichier de configuration Logstash paramétriques, telles que elastic_host et elastic_password. Ces variables doivent être définies dans le fichier main.yaml de votre playbook ou dans le cadre de votre inventaire.

Cela vous permet de personnaliser la configuration de Logstash en fonction de vos besoins spécifiques.

- name: Copy Logstash Output Configuration
  ansible.builtin.template:
    src: templates/30-elasticsearch-output.conf.j2
    dest: /etc/logstash/conf.d/30-elasticsearch-output.conf
    mode: 0640
    owner: logstash
    group: logstash
  vars:
    elastic_host: "{{ inventory_hostname }}"

Après avoir fait les ajouts nécessaires pour la configuration de sortie, vous devez suivre un processus similaire pour créer un fichier modèle Jinja nommé "02-beats-input.conf.j2" dans le répertoire modèle. Dans ce fichier, vous spécifierez les paramètres requis pour l'entrée Logstash.

input {
  beats {
    port => 5044
  }
}

Cette configuration représente les paramètres d'entrée Logstash pour la réception de données via Beats sur le port 5044. Comme précédemment, vous pouvez rendre certaines parties de cette configuration paramétriques si nécessaire.

Une fois ce modèle d’entrée créé, il peut être utilisé pour personnaliser le comportement d’entrée de Logstash selon les besoins de votre cas d’utilisation spécifique.

Nous ajoutons l'étape de copie de la configuration d'entrée sur le serveur, tout comme nous l'avons fait pour la configuration de sortie, dans notre fichier YAML. Ensuite, nous activons et démarrons Logstash.

- name: Copy Logstash Input Configuration
  ansible.builtin.template:
    src: templates/02-beats-input.conf.j2
    dest: /etc/logstash/conf.d/02-beats-input.conf
    mode: 0640
    owner: logstash
    group: logstash
- name: Enable and start logstash service
  service:
    name: logstash
    state: started
    enabled: yes

Nous avons maintenant terminé la configuration de nos rôles. Pour finaliser notre playbook, nous devons créer un fichier main.yaml dans le répertoire ./playbook et appeler les rôles.

Dans le fichier main.yaml, nous devons d'abord définir les variables que nous avons fournies lors des installations d'Elasticsearch et de Kibana.

- name: Deploy Elasticsearch And Kibana
  hosts: all
  become: true
  vars:
    elasticsearch:
      http_port: 9200
    kibana:
      server_port: 5601
      server_host: 0.0.0.0
      publicBaseUrl: "http://192.168.50.10:5601/"

Après avoir défini les variables, nous ajoutons les rôles que nous souhaitons invoquer.

roles:
    - { role: elasticsearch }
    - { role: kibana }
    - { role: logstash }

Enfin, nous devons joués sur la console pour obtenir l’URL de Kibana ainsi que le nom d’utilisateur et le mot de passe Elasticsearch.

post_tasks:
    - name: Kibana Dashboard URL
      debug:
        msg: "Kibana Dashboard URL : {{ kibana.publicBaseUrl }}"
      delegate_to: localhost
    - name: Elasticsearch User And Password
      debug:
        msg: "User : Elastic, Password: {{ elastic_password }}"
      delegate_to: localhost

Notre installation est maintenant terminée. Vous pouvez accéder à Kibana via l'URL fournie.

Installation de la version 8.9 de l'empilement ELK avec Ansible​

1. ÉTAPE SÉLECTION​

2. ANSIBLE​

3. Installation d'une pile ELK avec Ansible​

Configuration kibana​

Nous pouvons procéder à l’installation du dernier rôle, qui est Logstash.​