Installation SearXNG avec Ansible

Introduction

SearXNG est un métamoteur de recherche libre ; respectant votre vie privée et qui agrège près de 70 services de recherche. Il ne collecte aucune données, ne trace aucune requêtes et n’affiche aucune publicité dans les résultats. La personnalisation du moteur est assez fine. Vous pouvez aussi lui rajouter l’utilisation d’un proxy ou du réseau TOR.

Il y a 3 types d’installations possible, bien détaillées sur le site officiel :

Docker : L’utilisation d’un container docker : voir Installation avec Docker,
script shell : L’installation s’effectue via la compilation des sources récupérées sur GitHub : voir Installation script ,
Pas à pas : L’installation sur divers distributions linux : voir Installation pas à pas,

Je vais effectuer l’installation ‘pas à pas’ dans un container LXC Proxmox. Je vais par contre pour la première fois utiliser ‘ansible’ pour déployer mon service.

Le serveur sera placé derrière ‘Nginx’ et accessible depuis l’extérieur.

L’application est en python et utilise un environnement virtuel. Nous utiliseraons uwsgi pour lancer automatiquement et gérer le daemon de l’application.

Hypothèse de travail

J’ai créé au préalable un container LXC basé sur une distribution Debian 12 avec 512Mo de Ram.

Je pars du principe que le serveur SSH est configuré coté serveur pour pouvoir exécuter les scripts ‘ansible’.

Ansible est installé sur votre poste client qui effectuera le déploiement du service ‘SearXNG’. Mon répertoire de travail ‘.ansible’ se trouve à la racine du répertoire utilisateur.

Mes fichiers de déploiements ansible seront dans le répertoire :

/home/user/.ansible/roles

Configuration ansible spécifique

Nous aurons besoin pour le déploiement du service ‘SearXNG’ d’activer une option ansible particulière pour pouvoir changer l’utilisateur de l’environnement virtuel contenant les sources python de l’application.

Pour cela, il faut créer un fichier ‘ansible.cfg’ à la racine de votre répertoire ‘.ansible’.

Ce fichier aura une seule option active :

    [defaults]
    allow_world_readable_tmpfiles = true

L’architecture de mes fichiers de configuration ‘ansible’

J’utilise les ‘roles’ pour une structure modulaire et une simplication décritures de mes ‘Playbooks’.

Voici un apercu des fichiers et répertoires nécessaires :

La configuration des pré-requis

Configuration de la tache

Nous allons utilisés un seul fichier de type ‘tasks’ pour décrire les installations à effectuer. Ce fichier est situé dans

pre-requis/tasks/main.yml

Voici son contenu :

    ---

    - name: "Installation : python3-dev,python3-babel,python3-venv,python3-pip"
    apt:
        name: "python3-dev,python3-babel,python3-venv,python3-pip"
        state: "present"

    - name: "Installation : uwsgi,uwsgi-plugin-python3"
    apt:
        name: "uwsgi,uwsgi-plugin-python3"
        state: "present"

    - name: "Installation : git,build-essential,libxslt-dev,zlib1g-dev,libffi-dev,libssl-dev"
    apt:
        name: "git,build-essential,libxslt-dev,zlib1g-dev,libffi-dev,libssl-dev"
        state: "present"

Il est assez simple à comprendre : il ne fait qu’exécuter la commande ‘apt’ sur le serveur pour installer les paquets nécessaire à l’installation des sources ‘SearXNG’.

Configuration du Playbook

L’utilisation des rôles simplifie grandement les fichiers ‘Playbooks’. Je ne fais qu’ici, indiqué le nom du rôle répertoire contenant la tâche à lancer “pre-requis”. J’utilise ici ‘become’ et ‘become_method’ pour exécuter mes tâches avec les privilèges ‘sudo’. Ce fichier peut-être situer où vous voulez.

    ---
    - name: Install pre-requis
    hosts: searxng
    become: yes
    become_method: sudo
    roles:
        - role: "pre-requis"

Remarque : J’utilise le fichier de configuration ‘hosts’ qui se trouve à la racine du répertoire ‘.ansible’. Pour la syntaxe de ce fichier, je vous renvoi à la documentation de Ansible.

La configuration des sources

Configuration des variables globales

Nous allons utilisez un fichier de configuration contenant des variables globale qui seront utilisées dans nos tâches.

Ce fichier est situé dans :

config/commun/defaults/main.yml

    ---

    user_name: "searxng"
    user_passwd: 'motdepasse_crypted'
    user_home: "/usr/local/searxng"
    redis_home: "/usr/local/searxng-redis"
    searxng_url: "https://github.com/searxng/searxng"
    searxng_dst: "{{user_home}}/searxng-src"
    searxng_env: "{{user_home}}/venv"
    searxng_config: "/etc/searxng"
    searxng_settings: "{{searxng_config}}/settings.yml"
    uwsgi_config: "/etc/uwsgi/apps-available/searxng.ini"
    uwsgi_config_enable: "/etc/uwsgi/apps-enabled/searxng.ini"
    ansible_local_uwsgi: "/home/user/.ansible/roles/config/uwsgi/searxng.ini"

Il faudra remplacer dans ce fichier le mot de passe crypté ‘user_passwd’. Pour générer ce mot de passe crypté, taper la commande :

mkpasswd --method=sha-512

Remarque : J’utilise une seule tâche pour déployer le service ‘SearXNG’ mais il est comme même intéressant d’utiliser un fichier de configuration pour les variables ; cela facilite la configuration des chemins et évite de modifier plusieurs lignes dans le fichier de tâche en cas de modifications.

Configuration de la tache

Nous allons utilisés un seul fichier de type ‘tasks’ pour décrire les installations à effectuer. Ce fichier est situé dans

config/searxng/tasks/main.yml

Voici son contenu :

    ---

    - name: Verifie si le repertoire Utilisateur existe
    stat:
        path: "{{ user_home }}"
    register: user_dir

    - name: Creation utilisateur searxng
    ansible.builtin.user:
        name: "{{ user_name }}"
        password: "{{ user_passwd }}"
        state: present
        shell: /bin/bash
        system: yes
        createhome: yes
        home: "{{ user_home }}"
    when: not user_dir.stat.exists

    - name: Creation repertoire searxng
    ansible.builtin.file:
        path: "{{ user_home }}"
        state: directory
        owner: "{{ user_name }}"
        group: "{{ user_name }}"
        mode: 0775
    when: not user_dir.stat.exists

    - name: Verifie si les sources ont deja ete recuperees
    stat:
        path: "{{ searxng_dst }}"
    register: file_source

    - name: Recuperation des sources
    ansible.builtin.git:
        repo: "{{ searxng_url }}"
        version: master
        dest: "{{ searxng_dst }}"
    when: not file_source.stat.exists

    - name: Changement proprietaire source
    command:
        chown -R "{{ user_name }}":"{{ user_name }}" "{{ searxng_dst }}"
    when: not file_source.stat.exists

    - name: Verifie si le virtualenv existe
    stat:
        path: "{{ searxng_env }}"
    register: virtualenv_installed

    - name: Creation environnement virtuel
    file:
        name: "{{ searxng_env }}"
        state: directory
    become: yes
    become_user: "{{ user_name }}"
    when: not virtualenv_installed.stat.exists

    - name: Creation fichier requirements.txt
    file:
        path: "{{ searxng_env }}/requirements.txt"
        state: touch
    when: not virtualenv_installed.stat.exists

    - name: Initialisation environnement virtuel
    pip:
        virtualenv: "{{ searxng_env }}"
        virtualenv_command: '/usr/bin/python3 -m venv'
        requirements: "{{ searxng_env }}/requirements.txt"
    become: yes
    become_user: "{{ user_name }}"
    when: not virtualenv_installed.stat.exists

    - name: Mise a jour PIP
    ansible.builtin.pip:
        name:
        - pip
        - setuptools
        - wheel
        - pyyaml
        virtualenv: "{{ searxng_env }}"
        #virtualenv_site_packages: yes
    become: yes
    become_user: "{{ user_name }}"

    - name: Verifie si la source a deja été installée
    stat:
        path: "{{ searxng_dst }}/searx"
    register: source_installed

    - name: Installation de la source
    args:
        chdir: "{{ searxng_dst }}"
    ansible.builtin.pip:
        name: .
        extra_args: "--use-pep517 --no-build-isolation -e"
        virtualenv: "{{ searxng_env }}"
    become: yes
    become_user: "{{ user_name }}"
    when: not source_installed.stat.exists

    - name: Verifie si le repertoire de configuration existe
    stat:
        path: "{{ searxng_config }}"
    register: config_created

    - name: Creation repertoire config
    ansible.builtin.file:
        path: "{{ searxng_config }}"
        state: directory
        owner: "root"
        group: "root"
        mode: 0755
    when: not config_created.stat.exists

    - name: Copie du fichier settings.yml
    command:
        cp "{{ searxng_dst }}/utils/templates/etc/searxng/settings.yml" "{{ searxng_settings }}"
    when: not config_created.stat.exists

    - name: Genere la clé secrete
    command:
        openssl rand -hex 16
    register: secret_key

    - name: remplace la clé secrete dans la config
    ansible.builtin.replace:
        path: "{{ searxng_settings }}"
        regexp: 'ultrasecretkey'
        replace: "{{ secret_key.stdout }}"

    - name: Verifie si redis est deja installée
    stat:
        path: "{{ redis_home }}"
    register: redis_created

    - name: Affiche message debug
    debug:
        msg: "Vous devez installer Redis manuellement en mode root via la command : [sudo /usr/local/searxng/searxng-src/utils/searxng.sh install redis]"
    when: not redis_created.stat.exists

    - name: Verifie si le fichier de configuration uwsgi existe
    stat:
        path: "{{ uwsgi_config }}"
    register: uwsgi_created

    - name: Copie le fichier de configuration uwsgi
    ansible.builtin.copy:
        src: "{{ ansible_local_uwsgi }}"
        dest: "{{ uwsgi_config }}"
        owner: root
        group: root
        mode: '0644'
    when: not uwsgi_created.stat.exists

    - name: Verifie si le lien dynamique de configuration uwsgi existe
    stat:
        path: "{{ uwsgi_config_enable }}"
    register: uwsgi_ln_created

    - name: Creer lien dynamique fichier configuratioon uwsgi
    command:
        ln -s "{{ uwsgi_config }}" "{{ uwsgi_config_enable }}"
    when: not uwsgi_ln_created.stat.exists

    - name: Lance le service uwsgi
    command:
        sudo -H service uwsgi start searx
    when: uwsgi_ln_created.stat.exists

Le fichier est assez volimineux ; il aurait pu être découper en plusieurs tâches : installation des sources, comfiguration de uwsgi... Le fonctionnement du fichier est tout le temps le même : On vérifie l'existance d'un fichier ou répertoire et on exécute une commande si celui si n'existe pas. Cela permet de relancer plusieurs fois le 'Playbook' et de continuer à l´endroit ou il s'était arrêté (suite à une erreur ou à un abandon).

Configuration du Playbook

    ---
    - name: Install SearXNG
    hosts: searxng
    become: yes
    become_method: sudo
    roles:
        - role: "config/searxng"

Configuration des métadonnées pour le role ‘searxng’

Le fichier de configuration des ‘meta’ permet de faire le lien avec le fichier contenant les variables globales. Il se trouve dans

config/searxng/meta/main.yml

Voici son contenu :

    dependencies:
    -  role: "config/commun"

Lancement des ‘playbooks’

Playbook des pré-requis

La commande à exécuter pour lancer le ‘Playbook’ est celle ci :

ansible-playbook --ask-become-pass -i hosts repertoire_playbook/install_pre_requis.yml

Vous devez indiquez le chemin ou se trouve votre fichier ‘Playbook’en remplacant ‘repertoire_playbook’. Ce fichier peut-être n’importe ou, mais vous pouvez le mettre à la racine de votre dossier ‘.ansible’.

Remarque : J’utilise le fichier de configuration ‘hosts’ qui se trouve à la racine du répertoire ‘.ansible’. L’option ‘–ask-become-pass’ indique qu’il faut demander le mot de passe ‘sudo’ nécessaire à l’éxecution des tâches sur le serveur.

Si tout se passe bien, vous devriez avoir comme résultat :

Playbook principal

La commande à exécuter pour lancer le ‘Playbook’ est celle ci :

ansible-playbook --ask-become-pass -i hosts repertoire_playbook/install_config.yml

Si tout se passe bien, vous devriez avoir comme résultat :

Le daemon uwsgi

Le daemon ‘uwsgi’ est lancé automatiquement à chaque redémarrage de votre serveur. Pour voir le status du daemon, tapez la commande :

sudo -H service uwsgi status searx

Consultation du service depuis votre LAN

Le metamoteur SearXNG est consultable via l’adresse : ip_du_serveur:8888

Configuration de Nginx pour un accès depuis l’extérieur

Le fichier de configuration pour une installation Nginx standard se trouve dans /etc/nginx/sites-available/searxng.conf

Une configuration typique pour Nginx, à adapter à votre installation.

    server {
        listen              80;
        server_name         service.subdomain.domain.tld;
        location / {
            return              301 https://$server_name$request_uri;
        }
    }

    server {
        listen 443 ssl http2;
        server_name service.subdomain.domain.tld;
        client_max_body_size 20M;

        include /etc/nginx/ssl/ciphers-subdomain.domain.tld.conf;
        error_log /var/log/nginx/error.log notice;
        access_log /var/log/nginx/access.log;

        location /searx/static {
                alias /usr/local/searx/searx-src/searx/static;
        }

        location / {
            include /etc/nginx/conf.d/proxy.conf;
            proxy_pass http://ip_du_serveur:8888;
        }
    }

Il faudra par la suite crér un lien symbolique dans le répertoire ‘sites-enabled’ via la commande :

sudo ln -s /etc/nginx/sites-available/searxng.conf searxng

Vous pouvez tester les modifications avant de relancer nginx :

sudo nginx -t

Si aucune erreur n’est retournée, vous pouvez relancer le service :

sudo systemctl restart nginx.service

Vous pourrez maintenant accéder au moteur SearXNG via l’adresse : service.subdomain.domain.tld