Blog de Alkahan

Edit du 25/05/2026: ajout de logger dans le script de service pour envoyer les logs dans le service syslog du système. On peut désormais les consulter depuis l’interface web.

J’utilise un réseau nebula pour administrer les machines, que ce soit des serveurs sous Linux ou Windows ou les postes utilisateurs sous Windows ou MacOS. Avec la mise en place de mes pare-feu sous OPNSense, je souhaite pouvoir y accéder aussi à travers le réseau Nebula. Le système gère plusieurs types de VPN mais pas ce dernier. Voyons comment le mettre en place.

Je ne traiterais pas de la configuration de nebula en lui-même seulement de la partie installation et ce que j’ai mis en place pour qu’il se lance au démarrage.

Mise en œuvre

Par chance nebula fournit un binaire pour freebsd.

# On télécharge l'archive
fetch https://github.com/slackhq/nebula/releases/download/v1.10.3/nebula-freebsd-amd64.tar.gz
# On décompresse
tar xf nebula-freebsd-amd64.tar.gz

On doit avoir deux binaires dans notre répertoire:

root@fw:~/tmp # ll
total 8821
-rwxr-xr-x  1 1001 1001 20907546 Feb  6 19:36 nebula*
-rwxr-xr-x  1 1001 1001  8629420 Feb  6 19:36 nebula-cert*

On place les binaires dans /usr/local/bin

mv nebula nebula-cert /usr/local/bin

Ensuite on crée le répertoire /usr/local/etc/nebula qui va accueillir notre fichier de configuration ainsi que nos certificats et notre clé privé

mkdir /usr/local/etc/nebula

Placez vos fichiers à l’intérieur. On doit obtenir ce résultat:

root@fw:~/tmp # ll /usr/local/etc/nebula/
total 22
-rw-r--r--  1 root wheel   239 May  6 15:53 ca.crt
-rw-r--r--  1 root wheel 11707 May  6 16:23 config.yml
-rw-r--r--  1 root wheel   320 May  6 16:12 host.crt
-rw-r--r--  1 root wheel   127 May  6 15:57 host.key

On peut déjà lancer nebula manuellement pour voir si les certificats et la configuration sont corrects.

/usr/local/bin/nebula -config /usr/local/etc/nebula/config.yml

Il reste maintenant à faire en sorte que le service soit lancé au démarrage. Pour cela on a besoin de créer deux fichiers, un script rc et un fichier

Le script rc /usr/local/etc/rc.d/nebula

#!/bin/sh

# PROVIDE: nebula
# REQUIRE: NETWORKING syslog
# KEYWORD: shutdown

# Add the following lines to /etc/rc.conf to enable nebula:
# nebula_enable="YES"
# nebula_config="/usr/local/etc/nebula/config.yml"
# nebula_user="nebula" (optional, default: root)
# nebula_group="nebula" (optional, default: wheel)
# nebula_pidfile="/var/run/nebula.pid" (optional)

. /etc/rc.subr

name="nebula"
start_cmd="${name}_start"
stop_cmd="${name}_stop"
status_cmd="${name}_status"
pidfile="${nebula_pidfile:-/var/run/${name}.pid}"
command="/usr/local/bin/nebula"
command_args="-config ${nebula_config}"

: ${nebula_enable:="NO"}
: ${nebula_config:="/usr/local/etc/nebula/config.yml"}
: ${nebula_user:="root"}
: ${nebula_group:="wheel"}

nebula_start() {
    if [ ! -f "${nebula_config}" ]; then
        echo "Configuration file ${nebula_config} not found."
        return 1
    fi

    # Ensure PID directory exists
    pid_dir=$(dirname "${pidfile}")
    if [ ! -d "${pid_dir}" ]; then
        install -d -o ${nebula_user} -g ${nebula_group} -m 755 "${pid_dir}"
    fi

    # Start nebula
    echo "Starting ${name}."
    ${command} -config ${nebula_config} 2>&1 | logger -t nebula &
    echo $! > ${pidfile}
}

nebula_stop() {
    if [ -f "${pidfile}" ]; then
        pid=$(cat ${pidfile})
        echo "Stopping ${name} (pid ${pid})."
        kill ${pid} && rm -f ${pidfile}
        return 0
    fi
    echo "${name} is not running."
    return 1
}

nebula_status() {
    if [ -f "${pidfile}" ]; then
        pid=$(cat ${pidfile})
        if ps -p ${pid} > /dev/null 2>&1; then
            echo "${name} is running as pid ${pid}."
            return 0
        else
            echo "${name} is not running (stale pidfile)."
            rm -f ${pidfile}
            return 1
        fi
    fi
    echo "${name} is not running."
    return 1
}

load_rc_config $name
run_rc_command "$1"

On s’assure qu’il possède les permissions d’exécution :

chmodso +x /usr/local/etc/rc.d/nebula

Ensuite on crée un hook de démarrage /usr/local/etc/rc.syshook.d/start/90-nebula

#!/bin/sh
# /usr/local/etc/rc.syshook.d/start/90-nebula

echo -n "Starting Nebula "
service nebula start

Là encore on donne les permissions d’exécution :

chmod +x /usr/local/etc/rc.syshook.d/start/90-nebula

Remarques

Bien vérifier dans le fichier de configuration que les chemins vers les certificats sont correctes.

Nebula embarque sont parefeu interne, on doit donc ajouter les règles pour autoriser le trafic à l’intérieur. Dans mon cas le SSH et HTTPS. Habituellement cela suffit, mais ici le pare feu de OPNSense bloque le trafic il faut donc également l’autoriser au niveau du système. L’interface réseau nebula1 (ou quel que soit le nom que vous lui avez donné dans votre fichier de configuration) est disponible comme device pour le référencer comme interface dans le parefeu (page Interfaces: Assignments de l’interface web). On crée ensuite les règles nécessaires comme pour le WAN ou le LAN.

Dans ma configuration, nebula envoi les logs vers la sortie standard. Avec ces scripts, les logs de nebula apparaissent donc sur l’écran lors du démarrage du système. Ce n’est pas très propre, mais pas gênant non plus.