Installation NetBox · 16 min read · Oct 22, 2025

Comment installer l'outil de documentation et de gestion de réseau NetBox sur Ubuntu 22.04

NetBox est une application web open-source de gestion d’adresses IP (IPAM) et d’infrastructure de datacenter (DCIM) utilisée pour gérer et documenter les réseaux informatiques et les adresses IP. L’équipe d’ingénierie réseau de DigitalOcean l’a initialement conçue. Elle est écrite en utilisant le framework Django Python et utilise la base de données PostgreSQL pour le stockage des données. Elle utilise également la base de données Redis pour mettre en cache les requêtes.

Ce tutoriel vous apprendra à installer l’outil NetBox sur un serveur Ubuntu 22.04 et Nginx en tant que serveur proxy inverse.

Prérequis

  • Un serveur exécutant Ubuntu 22.04.
  • Un utilisateur non-root avec des privilèges sudo.
  • Un nom de domaine entièrement qualifié (FQDN) comme netbox.example.com.
  • Assurez-vous que tout est à jour. $ sudo apt update $ sudo apt upgrade
  • Quelques paquets dont votre système a besoin. $ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y Certains de ces paquets peuvent déjà être installés sur votre système.

Étape 1 - Configurer le pare-feu

La première étape consiste à configurer le pare-feu. Ubuntu est livré avec ufw (Uncomplicated Firewall) par défaut.

Vérifiez si le pare-feu est en cours d’exécution.

$ sudo ufw status

Vous devriez obtenir la sortie suivante.

Status: inactive

Autorisez le port SSH afin que le pare-feu ne rompe pas la connexion actuelle lors de son activation.

$ sudo ufw allow OpenSSH

Autorisez également les ports HTTP et HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Activez le pare-feu

$ sudo ufw enable
La commande peut perturber les connexions ssh existantes. Poursuivre l'opération (y|n)? y
Le pare-feu est actif et activé au démarrage du système

Vérifiez à nouveau l’état du pare-feu.

$ sudo ufw status

Vous devriez voir une sortie similaire.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Étape 2 - Installer et configurer PostgreSQL

NetBox fonctionne avec PostgreSQL 11 et supérieur. Ubuntu 22.04 est livré avec PostgreSQL 14 par défaut. Nous allons utiliser PostgreSQL 15 pour notre tutoriel.

Exécutez la commande suivante pour ajouter la clé GPG de PostgreSQL.

$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/postgresql-key.gpg >/dev/null

Ajoutez le dépôt APT à votre liste de sources.

$ sudo sh -c 'echo "deb [signed-by=/usr/share/keyrings/postgresql-key.gpg arch=amd64] http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'

Mettez à jour le dépôt système.

$ sudo apt update

Maintenant, vous pouvez installer PostgreSQL en utilisant la commande ci-dessous.

$ sudo apt install postgresql postgresql-contrib

Le paquet postgresql-contrib contient quelques utilitaires supplémentaires.

Vérifiez l’état du service PostgreSQL.

$ sudo systemctl status postgresql
? postgresql.service - PostgreSQL RDBMS
     Loaded: loaded (/lib/systemd/system/postgresql.service; enabled; vendor preset: enabled)
     Active: active (exited) since Tue 2022-11-27 9:10:35 UTC; 5s ago
    Process: 30544 ExecStart=/bin/true (code=exited, status=0/SUCCESS)
   Main PID: 30544 (code=exited, status=0/SUCCESS)
        CPU: 2ms

Dec 27 9:10:35 netbox systemd[1]: Starting PostgreSQL RDBMS...
Dec 27 9:10:35 netbox systemd[1]: Finished PostgreSQL RDBMS.

Vous pouvez voir que le service est activé et en cours d’exécution par défaut.

Lancez le shell PostgreSQL.

$ sudo -i -u postgres psql

Créez la base de données NetBox.

postgres=# CREATE DATABASE netbox;

Créez l’utilisateur NetBox et choisissez un mot de passe fort.

postgres-# CREATE USER netbox WITH PASSWORD 'Your_Password';

Changez le propriétaire de la base de données à l’utilisateur NetBox.

postgres-# ALTER DATABASE netbox OWNER TO netbox;

Quittez le shell.

postgres-# \q

Vérifiez que vos identifiants fonctionnent.

$ psql --username netbox --password --host localhost netbox
Mot de passe pour l'utilisateur netbox:
psql (15.1 (Ubuntu 15.1-1.pgdg22.04+1))
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, bits: 256, compression: off)
Type "help" for help.

netbox=>

Quittez le shell en tapant \q.

Étape 3 - Installer et configurer Redis

Ubuntu est livré avec Redis 6.0.16. Pour notre tutoriel, nous allons installer la dernière version à partir du dépôt officiel.

Importez la clé GPG officielle de Redis.

$ curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg

Ajoutez le dépôt APT à votre liste de sources.

echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list

Mettez à jour la liste des dépôts système.

$ sudo apt update

Exécutez la commande suivante pour installer le serveur Redis.

$ sudo apt install redis

Confirmez la version de Redis.

$ redis-server -v
Redis server v=7.0.7 sha=00000000:0 malloc=jemalloc-5.2.1 bits=64 build=2260280010e18db8

Vérifions la connexion au service en utilisant la commande suivante.

$ redis-cli

Vous serez transféré dans le shell Redis.

La première étape consiste à définir le mot de passe pour l’utilisateur par défaut de Redis. Remplacez Your_Redis_Password par un mot de passe fort de votre choix.

127.0.0.1:6379> acl setuser default >Your_Redis_Password

Testez l’authentification Redis.

127.0.0.1:6379> AUTH Your_Redis_Password
OK

Ping le service.

127.0.0.1:6379> ping
PONG

Quittez le service en tapant exit.

Étape 4 - Télécharger NetBox

NetBox nécessite Python Django pour fonctionner. La première étape de l’installation de NetBox consiste à installer les paquets Python requis. Exécutez la commande suivante pour installer les paquets Python requis.

$ sudo apt install -y python3 python3-pip python3-venv python3-dev build-essential libxml2-dev libxslt1-dev libffi-dev libpq-dev libssl-dev zlib1g-dev

Vérifiez la version de Python.

$ python3 -V
Python 3.10.6

Créez le répertoire de base pour l’installation de NetBox.

$ sudo mkdir -p /opt/netbox/

Passez au répertoire.

$ cd /opt/netbox

Clonez la branche principale du dépôt GitHub de NetBox dans le répertoire courant.

$ sudo git clone -b master --depth 1 https://github.com/netbox-community/netbox.git .

Le drapeau --depth 1 récupère uniquement le commit le plus récent du dépôt. Si vous souhaitez télécharger l’historique complet des commits, vous pouvez omettre le drapeau.

Vérifiez la dernière version de NetBox sur la page des versions et vérifiez-la à l’aide de Git. Au moment de la rédaction de ce tutoriel, 3.4.1 est la dernière version disponible.

$ git config --global --add safe.directory /opt/netbox
$ sudo git checkout v3.4.1

Avant de la vérifier, vous devez ajouter le répertoire à la liste des répertoires sûrs de Git. C’est une nouvelle fonctionnalité de sécurité disponible dans les versions récentes de Git.

L’étape suivante consiste à créer un utilisateur et un groupe système pour NetBox.

$ sudo adduser --system --group netbox

Donnez à l’utilisateur la permission sur le répertoire média de NetBox.

$ sudo chown --recursive netbox /opt/netbox/netbox/media/

Étape 5 - Configurer NetBox

Passez au répertoire de configuration de NetBox.

$ cd /opt/netbox/netbox/netbox/

Copiez le fichier de configuration exemple pour créer le fichier réel.

$ sudo cp configuration_example.py configuration.py

Avant de procéder à la configuration, nous devons créer une clé secrète pour NetBox. Notez la clé car nous en aurons besoin pour la configuration.

$ python3 ../generate_secret_key.py
dSSWi$Ar2cVvu1)V!B82sY1tJAQK9r)vzM8ReQRF7@C^+$=1+(

Ouvrez le fichier de configuration pour l’éditer.

$ sudo nano configuration.py

Trouvez la variable ALLOWED_HOSTS et définissez ses valeurs comme suit. Cette variable contient une liste des noms d’hôtes et des adresses IP valides par lesquels ce serveur peut être atteint.

ALLOWED_HOSTS = ['netbox.example.com', '']

L’étape suivante consiste à modifier les détails de la base de données. Configurez les détails de la base de données comme suit.

DATABASE = {
    'NAME': 'netbox',              # Nom de la base de données
    'USER': 'netbox',              # Nom d'utilisateur PostgreSQL
    'PASSWORD': 'Your_Password',   # Mot de passe PostgreSQL
    'HOST': 'localhost',           # Serveur de base de données
    'PORT': '',                    # Port de la base de données (laisser vide pour par défaut)
    'CONN_MAX_AGE': 300,           # Âge max de la connexion à la base de données
}

Configurez la configuration Redis comme indiqué. Entrez le mot de passe Redis que vous avez défini à l’étape 3.

REDIS = {
    'tasks': {
        'HOST': 'localhost',
        'PORT': 6379,
        # Commenter les lignes `HOST` et `PORT` et décommenter ce qui suit si vous utilisez Redis Sentinel
        # 'SENTINELS': [('mysentinel.redis.example.com', 6379)],
        # 'SENTINEL_SERVICE': 'netbox',
        'PASSWORD': 'Your_Redis_Password',
        'DATABASE': 0,
        'SSL': False,
        # Définissez ceci sur True pour ignorer la vérification du certificat TLS
        # Cela peut exposer la connexion à des attaques, soyez prudent
        # 'INSECURE_SKIP_TLS_VERIFY': False,
    },
    'caching': {
        'HOST': 'localhost',
        'PORT': 6379,
        # Commenter les lignes `HOST` et `PORT` et décommenter ce qui suit si vous utilisez Redis Sentinel
        # 'SENTINELS': [('mysentinel.redis.example.com', 6379)],
        # 'SENTINEL_SERVICE': 'netbox',
        'PASSWORD': 'Your_Redis_Password',
        'DATABASE': 1,
        'SSL': False,
        # Définissez ceci sur True pour ignorer la vérification du certificat TLS
        # Cela peut exposer la connexion à des attaques, soyez prudent
        # 'INSECURE_SKIP_TLS_VERIFY': False,
    }
}

Ajoutez la valeur de la clé secrète à la variable.

SECRET_KEY = 'dSSWi$Ar2cVvu1)V!B82sY1tJAQK9r)vzM8ReQRF7@C^+$=1+('

Par défaut, NetBox utilise le système de fichiers local pour stocker les fichiers téléchargés. Vous pouvez stocker des fichiers sur un système de fichiers distant en installant la bibliothèque django-storages. Exécutez la commande suivante pour ajouter le paquet django-storages au requirements.txt de NetBox, qui sera ensuite installé dans une étape ultérieure. Nous devons également configurer les paramètres de stockage. Décommentez la section de stockage du fichier de configuration et procédez comme suit.

STORAGE_BACKEND = 'storages.backends.s3boto3.S3Boto3Storage'
STORAGE_CONFIG = {
    'AWS_ACCESS_KEY_ID': 'Key ID',
    'AWS_SECRET_ACCESS_KEY': 'Secret',
    'AWS_STORAGE_BUCKET_NAME': 'netbox',
    'AWS_S3_REGION_NAME': 'eu-west-1',
}

D’autres types de stockage sont également pris en charge, y compris FTP, SFTP, Dropbox et d’autres fournisseurs S3. Pour apprendre à les configurer, vous pouvez consulter la page d’aide de django-storages.

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Étape 6 - Installer NetBox

Exécutez le script de mise à niveau de NetBox.

$ sudo /opt/netbox/upgrade.sh

Le script de mise à niveau effectue les tâches suivantes.

  • Crée un environnement virtuel Python
  • Installe tous les paquets Python requis
  • Exécute les migrations de schéma de base de données
  • Construit la documentation localement (pour une utilisation hors ligne)
  • Agrège les fichiers de ressources statiques sur le disque

Activez l’environnement virtuel créé par le script de mise à niveau.

$ source /opt/netbox/venv/bin/activate

L’étape suivante consiste à créer un superutilisateur pour accéder à NetBox. Mais d’abord, passez au répertoire requis.

(venv) $ cd /opt/netbox/netbox

Créez le superutilisateur.

(venv) $ python3 manage.py createsuperuser

Vous obtiendrez la sortie suivante.

Nom d'utilisateur (laisser vide pour utiliser 'navjot'):
Adresse e-mail: [email protected]
Mot de passe:
Mot de passe (à nouveau):
Superutilisateur créé avec succès.

NetBox inclut une commande de gestion housekeeping qui gère les tâches de nettoyage récurrentes, telles que la suppression des anciennes sessions et des enregistrements de changement expirés. Vous pouvez soit exécuter la commande manuellement, soit utiliser cron pour l’exécuter à intervalles réguliers. NetBox fournit un script shell pour exécuter les tâches de nettoyage. Exécutez la commande suivante pour créer un lien symbolique pour le script dans le répertoire Cron quotidien. Cela garantira que la commande s’exécute quotidiennement.

(venv) $ sudo ln -s /opt/netbox/contrib/netbox-housekeeping.sh /etc/cron.daily/netbox-housekeeping

L’étape finale consiste à tester si l’application NetBox fonctionne. Mais d’abord, nous devons ouvrir le port 8000 pour les tests. Vous pouvez utiliser n’importe quel port.

(venv) $ sudo ufw allow 8000

Démarrez une instance de développement de NetBox.

(venv) $ python3 manage.py runserver 0.0.0.0:8000 --insecure

Si cela réussit, vous obtiendrez la sortie suivante.

Effectuer des vérifications système...

La vérification du système n'a identifié aucun problème (0 silencieux).
27 décembre 2022 - 09:27:37
Version de Django 4.1.4, utilisant les paramètres 'netbox.settings'
Démarrage du serveur de développement à http://0.0.0.0:8000/
Quittez le serveur avec CONTROL-C.

Vous devriez pouvoir accéder à NetBox via l’URL http://:8000/. Vous obtiendrez l’écran suivant.

Page d'accueil de NetBox

Cliquez sur le bouton Se connecter pour ouvrir la page de connexion et entrez les identifiants du superutilisateur créés précédemment.

Page de connexion de NetBox

Vous serez ramené au tableau de bord de NetBox.

Appuyez sur la touche Ctrl + C pour arrêter le serveur. Désactivez l’environnement virtuel Python.

(venv) $ deactivate

Étape 7 - Configurer Gunicorn et créer un fichier de service

NetBox fonctionne comme une application WSGI derrière un serveur HTTP. NetBox installe automatiquement le serveur Gunicorn. Dans cette étape, nous allons configurer Gunicorn et créer un fichier de service pour NetBox afin qu’il puisse être exécuté en arrière-plan et à travers les redémarrages du système.

NetBox est livré avec un fichier de configuration Gunicorn par défaut. Créez une copie de celui-ci.

$ sudo cp /opt/netbox/contrib/gunicorn.py /opt/netbox/gunicorn.py

La configuration par défaut devrait suffire à nos besoins. Selon vos besoins, vous pouvez modifier le fichier pour changer le nom d’hôte, le numéro de port ou apporter des améliorations de performance en modifiant les threads, les travailleurs et le nombre de requêtes.

L’étape suivante consiste à copier les fichiers de service NetBox et Gunicorn dans le répertoire /etc/systemd/system.

$ sudo cp -v /opt/netbox/contrib/*.service /etc/systemd/system/

Rechargez le démon de service.

$ sudo systemctl daemon-reload

Démarrez et activez les services netbox et netbox-rq.

$ sudo systemctl start netbox netbox-rq
$ sudo systemctl enable netbox netbox-rq

Vérifiez l’état du service WSGI.

$ sudo systemctl status netbox

Vous obtiendrez une sortie similaire.

? netbox.service - NetBox WSGI Service
     Loaded: loaded (/etc/systemd/system/netbox.service; enabled; vendor preset: enabled)
     Active: active (running) since Tue 2022-12-27 09:28:23 UTC; 17s ago
       Docs: https://docs.netbox.dev/
   Main PID: 4180 (gunicorn)
      Tasks: 6 (limit: 1030)
     Memory: 357.9M
        CPU: 7.747s
     CGroup: /system.slice/netbox.service
             ??4180 /opt/netbox/venv/bin/python3 /opt/netbox/venv/bin/gunicorn --pid /var/tmp/netbox.pid --pythonpath /opt/netbox/netbox --config /opt/netbox/gunicorn.py netbox.wsgi
             ??4181 /opt/netbox/venv/bin/python3 /opt/netbox/venv/bin/gunicorn --pid /var/tmp/netbox.pid --pythonpath /opt/netbox/netbox --config /opt/netbox/gunicorn.py netbox.wsgi
             ??4182 /opt/netbox/venv/bin/python3 /opt/netbox/venv/bin/gunicorn --pid /var/tmp/netbox.pid --pythonpath /opt/netbox/netbox --config /opt/netbox/gunicorn.py netbox.wsgi
             ??4183 /opt/netbox/venv/bin/python3 /opt/netbox/venv/bin/gunicorn --pid /var/tmp/netbox.pid --pythonpath /opt/netbox/netbox --config /opt/netbox/gunicorn.py netbox.wsgi
             ??4184 /opt/netbox/venv/bin/python3 /opt/netbox/venv/bin/gunicorn --pid /var/tmp/netbox.pid --pythonpath /opt/netbox/netbox --config /opt/netbox/gunicorn.py netbox.wsgi
             ??4185 /opt/netbox/venv/bin/python3 /opt/netbox/venv/bin/gunicorn --pid /var/tmp/netbox.pid --pythonpath /opt/netbox/netbox --config /opt/netbox/gunicorn.py netbox.wsgi

Dec 27 09:28:23 netbox systemd[1]: Started NetBox WSGI Service.
Dec 27 09:28:24 netbox gunicorn[4180]: [2022-12-27 09:28:24 +0000] [4180] [INFO] Starting gunicorn 20.1.0
Dec 27 09:28:24 netbox gunicorn[4180]: [2022-12-27 09:28:24 +0000] [4180] [INFO] Listening at: http://127.0.0.1:8001 (4180)
Dec 27 09:28:24 netbox gunicorn[4180]: [2022-12-27 09:28:24 +0000] [4180] [INFO] Using worker: gthread
Dec 27 09:28:24 netbox gunicorn[4181]: [2022-12-27 09:28:24 +0000] [4181] [INFO] Booting worker with pid: 4181
Dec 27 09:28:24 netbox gunicorn[4182]: [2022-12-27 09:28:24 +0000] [4182] [INFO] Booting worker with pid: 4182
Dec 27 09:28:24 netbox gunicorn[4183]: [2022-12-27 09:28:24 +0000] [4183] [INFO] Booting worker with pid: 4183
Dec 27 09:28:24 netbox gunicorn[4184]: [2022-12-27 09:28:24 +0000] [4184] [INFO] Booting worker with pid: 4184
Dec 27 09:28:24 netbox gunicorn[4185]: [2022-12-27 09:28:24 +0000] [4185] [INFO] Booting worker with pid: 4185

Comme vous pouvez le voir, Gunicorn écoute sur le port 8001 par défaut. Cette information sera utile lors de la configuration de Nginx en tant que serveur proxy inverse.

Étape 8 - Installer Nginx

Ubuntu 22.04 est livré avec une version plus ancienne de Nginx. Pour installer la dernière version, vous devez télécharger le dépôt officiel de Nginx.

Importez la clé de signature de Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
    | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Ajoutez le dépôt pour la version stable de Nginx.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
    | sudo tee /etc/apt/sources.list.d/nginx.list

Mettez à jour les dépôts système.

$ sudo apt update

Installez Nginx.

$ sudo apt install nginx

Vérifiez l’installation.

$ nginx -v
nginx version: nginx/1.22.1

Démarrez le serveur Nginx.

$ sudo systemctl start nginx

Étape 9 - Installer SSL

Nous devons installer Certbot pour générer le certificat SSL. Vous pouvez soit installer Certbot en utilisant le dépôt d’Ubuntu, soit obtenir la dernière version en utilisant l’outil Snapd. Nous allons utiliser la version Snapd.

Ubuntu 22.04 est livré avec Snapd installé par défaut. Exécutez les commandes suivantes pour vous assurer que votre version de Snapd est à jour. Assurez-vous que votre version de Snapd est à jour.

$ sudo snap install core
$ sudo snap refresh core

Installez Certbot.

$ sudo snap install --classic certbot

Utilisez la commande suivante pour vous assurer que la commande Certbot s’exécute en créant un lien symbolique vers le répertoire /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Exécutez la commande suivante pour générer un certificat SSL.

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d netbox.example.com

La commande ci-dessus téléchargera un certificat dans le répertoire /etc/letsencrypt/live/netbox.example.com sur votre serveur.

Générez un certificat de groupe Diffie-Hellman.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Pour vérifier si le renouvellement SSL fonctionne correctement, effectuez un essai à sec du processus.

$ sudo certbot renew --dry-run

Si vous ne voyez aucune erreur, vous êtes prêt. Votre certificat se renouvellera automatiquement.

Étape 10 - Configurer Nginx

Ouvrez le fichier /etc/nginx/nginx.conf pour l’éditer.

$ sudo nano /etc/nginx/nginx.conf

Ajoutez la ligne suivante avant la ligne include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Créez et ouvrez le fichier /etc/nginx/conf.d/netbox.conf pour l’éditer.

$ sudo nano /etc/nginx/conf.d/netbox.conf

Collez le code suivant dedans.

server {
  # Redirigez toutes les requêtes http vers https
  listen         80;
  listen         [::]:80;
  server_name    netbox.example.com;
  return 301     https://$host$request_uri;
}

server {
  listen                    443 ssl http2;
  listen                    [::]:443 ssl http2;
  server_name               netbox.example.com;

  access_log                /var/log/nginx/netbox.access.log;
  error_log                 /var/log/nginx/netbox.error.log;

  # Configuration TLS
  ssl_certificate           /etc/letsencrypt/live/netbox.example.com/fullchain.pem;
  ssl_certificate_key       /etc/letsencrypt/live/netbox.example.com/privkey.pem;
  ssl_trusted_certificate   /etc/letsencrypt/live/netbox.example.com/chain.pem;
  ssl_protocols             TLSv1.2 TLSv1.3;

  ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
  ssl_prefer_server_ciphers on;
  ssl_session_cache         shared:SSL:50m;
  ssl_session_timeout       1d;

  # OCSP Stapling ---
  # récupérez les enregistrements OCSP à partir de l'URL dans ssl_certificate et mettez-les en cache
  ssl_stapling on;
  ssl_stapling_verify on;
  ssl_dhparam /etc/ssl/certs/dhparam.pem;

  client_max_body_size 25m;

  # Proxy tout vers le serveur netbox
  location /static/ {
    alias /opt/netbox/netbox/static/;
  }

  location / {
    proxy_set_header        X-Real-IP $remote_addr;
    proxy_set_header        X-Forwarded-Proto $scheme;
    proxy_set_header        X-Forwarded-Host $http_host;
    proxy_pass              http://127.0.0.1:8001;
  }
}

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité une fois terminé.

Vérifiez la syntaxe du fichier de configuration de Nginx.

$ sudo nginx -t
nginx: le fichier de configuration /etc/nginx/nginx.conf syntaxe est ok
nginx: test du fichier de configuration /etc/nginx/nginx.conf réussi

Redémarrez le service Nginx.

$ sudo systemctl restart nginx

Vous pouvez maintenant accéder au tableau de bord de NetBox via l’URL https://netbox.example.com.

Étape 11 - Mettre à niveau NetBox

La mise à niveau de NetBox est assez facile. Les étapes consistent à vérifier la branche principale du dépôt Git, à tirer les derniers commits, puis à vérifier la nouvelle version stable.

Passez au répertoire de NetBox.

$ cd /opt/netbox

Vérifiez la branche principale.

$ sudo git checkout master

Tirez les derniers commits du dépôt.

$ sudo git pull origin master

Vérifiez la nouvelle version. Si 3.4.2 est la version la plus récente, vous pouvez la vérifier.

$ sudo git checkout v3.4.2

Exécutez le script de mise à niveau.

$ sudo ./upgrade.sh

Pour le processus de mise à niveau, le script effectue les fonctions suivantes.

  • Détruit et reconstruit l’environnement virtuel Python
  • Installe tous les paquets Python requis (énumérés dans requirements.txt)
  • Installe tous les paquets supplémentaires de local_requirements.txt
  • Applique toutes les migrations de base de données qui ont été incluses dans la version
  • Construit la documentation localement (pour une utilisation hors ligne)
  • Collecte tous les fichiers statiques à servir par le service HTTP
  • Supprime les types de contenu obsolètes de la base de données
  • Supprime toutes les sessions utilisateur expirées de la base de données

Redémarrez le service Gunicorn et NetBox.

$ sudo systemctl restart netbox netbox-rq

Conclusion

Cela conclut notre tutoriel sur l’installation de l’outil de documentation et de gestion de réseau NetBox sur un serveur Ubuntu 22.04 avec Nginx en tant que serveur proxy inverse. Si vous avez des questions, postez-les dans les commentaires ci-dessous.

Share: X/Twitter LinkedIn
#Installation NetBox

Recevez de nouveaux articles dans votre boîte de réception.

Aucun spam. Désabonnez-vous à tout moment.