So installierst du das NetBox Netzwerkdokumentations- und Management-Tool unter Ubuntu 22.04

NetBox ist eine Open-Source-Webanwendung zur Verwaltung von IP-Adressen (IPAM) und Rechenzentrumsinfrastruktur (DCIM), mit der Computernetzwerke und IP-Adressen verwaltet und dokumentiert werden können. Das Netzwerktechnikteam von DigitalOcean hat sie ursprünglich entwickelt. Sie wurde mit dem Django-Python-Framework geschrieben und nutzt die PostgreSQL-Datenbank zur Datenspeicherung. Außerdem nutzt es die Redis-Datenbank für das Caching von Abfragen.

In diesem Lernprogramm lernst du, wie du das NetBox-Tool auf einem Ubuntu 22.04-Server und Nginx als Reverse-Proxy-Server installierst.

Voraussetzungen

  • Ein Server, auf dem Ubuntu 22.04 läuft.
  • Ein Nicht-Root-Benutzer mit sudo-Rechten.
  • Ein vollständig qualifizierter Domainname (FQDN) wie netbox.example.com.
  • Stelle sicher, dass alles auf dem neuesten Stand ist.
    $ sudo apt update
    $ sudo apt upgrade
    
  • Einige wenige Pakete, die dein System benötigt.
    $ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y
    

    Einige dieser Pakete sind vielleicht schon auf deinem System installiert.

Schritt 1 – Firewall konfigurieren

Der erste Schritt besteht darin, die Firewall zu konfigurieren. Ubuntu wird standardmäßig mit ufw (Uncomplicated Firewall) ausgeliefert.

Überprüfe, ob die Firewall läuft.

$ sudo ufw status

Du solltest die folgende Ausgabe erhalten.

Status: inactive

Erlaube den SSH-Port, damit die Firewall die aktuelle Verbindung nicht unterbricht, wenn du sie aktivierst.

$ sudo ufw allow OpenSSH

Lasse auch HTTP- und HTTPS-Ports zu.

$ sudo ufw allow http
$ sudo ufw allow https

Aktiviere die Firewall

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Überprüfe den Status der Firewall erneut.

$ sudo ufw status

Du solltest eine ähnliche Ausgabe sehen.

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)

Schritt 2 – PostgreSQL installieren und konfigurieren

NetBox funktioniert mit PostgreSQL 11 und höher. Ubuntu 22.04 wird standardmäßig mit PostgreSQL 14 ausgeliefert. Wir werden PostgreSQL 15 für unser Tutorial verwenden.

Führe den folgenden Befehl aus, um den PostgreSQL GPG-Schlüssel hinzuzufügen.

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

Füge das APT-Repository zu deiner Quellenliste hinzu.

$ 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'

Aktualisiere das System-Repository.

$ sudo apt update

Jetzt kannst du PostgreSQL mit folgendem Befehl installieren.

$ sudo apt install postgresql postgresql-contrib

Das Paket postgresql-contrib enthält einige zusätzliche Hilfsprogramme.

Überprüfe den Status des PostgreSQL-Dienstes.

$ 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.

Du kannst sehen, dass der Dienst aktiviert ist und standardmäßig läuft.

Starte die PostgreSQL-Shell.

$ sudo -i -u postgres psql

Erstelle die NetBox-Datenbank.

postgres=# CREATE DATABASE netbox;

Erstelle den NetBox-Benutzer und wähle ein sicheres Passwort.

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

Ändere den Eigentümer der Datenbank in NetBox-Benutzer.

postgres-# ALTER DATABASE netbox OWNER TO netbox;

Beende die Shell.

postgres-# \q

Überprüfe, ob deine Anmeldedaten funktionieren.

$ psql --username netbox --password --host localhost netbox
Password for user 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=>

Beende die Shell, indem du \q eingibst.

Schritt 3 – Redis installieren und konfigurieren

Ubuntu wird mit Redis 6.0.16 ausgeliefert. Für unser Tutorial werden wir die neueste Version aus dem offiziellen Repository installieren.

Importiere den offiziellen Redis-GPG-Schlüssel.

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

Füge das APT-Repository zu deiner Quellenliste hinzu.

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

Aktualisiere die Liste der System-Repositorys.

$ sudo apt update

Gib den folgenden Befehl ein, um den Redis-Server zu installieren.

$ sudo apt install redis

Bestätige die Redis-Version.

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

Überprüfe die Verbindung zum Dienst mit dem folgenden Befehl.

$ redis-cli

Du wirst auf die Redis-Shell umgeschaltet.

Der erste Schritt besteht darin, das Passwort für den Redis-Standardbenutzer festzulegen. Ersetze Your_Redis_Password durch ein sicheres Passwort deiner Wahl.

127.0.0.1:6379> acl setuser default >Your_Redis_Password

Teste die Redis-Authentifizierung.

127.0.0.1:6379> AUTH Your_Redis_Password
OK

Pinge den Dienst an.

127.0.0.1:6379> ping
PONG

Beende den Dienst, indem du exit eingibst.

Schritt 4 – NetBox herunterladen

NetBox benötigt Python Django, um zu funktionieren. Der erste Schritt bei der Installation von NetBox besteht darin, die erforderlichen Python-Pakete zu installieren. Führe den folgenden Befehl aus, um die erforderlichen Python-Pakete zu installieren.

$ 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

Überprüfe die Python-Version.

$ python3 -V
Python 3.10.6

Erstelle das Basisverzeichnis für die NetBox-Installation.

$ sudo mkdir -p /opt/netbox/

Wechsle in das Verzeichnis.

$ cd /opt/netbox

Klone den Master-Zweig des GitHub-Repositorys der NetBox in das aktuelle Verzeichnis.

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

Das --depth 1 Flag ruft nur den letzten Commit des Repositorys ab. Wenn du den gesamten Commit-Verlauf herunterladen möchtest, kannst du das Flag weglassen.

Schau dir die neueste Version von NetBox auf der Versionsseite an und checke sie mit Git aus. Zum Zeitpunkt der Erstellung dieses Tutorials ist die Version 3.4.1 die neueste verfügbare Version.

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

Bevor du sie auscheckst, musst du das Verzeichnis zur Liste der sicheren Verzeichnisse von Git hinzufügen. Das ist eine neue Sicherheitsfunktion, die in den letzten Git-Versionen verfügbar ist.

Im nächsten Schritt musst du einen Systembenutzer und eine Gruppe für die NetBox erstellen.

$ sudo adduser --system --group netbox

Gib dem Benutzer das Recht auf das Medienverzeichnis der NetBox.

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

Schritt 5 – NetBox konfigurieren

Wechsle in das NetBox-Konfigurationsverzeichnis.

$ cd /opt/netbox/netbox/netbox/

Kopiere die Beispielkonfigurationsdatei, um die eigentliche Datei zu erstellen.

$ sudo cp configuration_example.py configuration.py

Bevor wir mit der Konfiguration fortfahren, müssen wir einen geheimen Schlüssel für die NetBox erstellen. Notiere dir den Schlüssel, denn wir brauchen ihn für die Konfiguration.

$ python3 ../generate_secret_key.py
dSSWi$Ar2cVvu1)V!B82sY1tJAQK9r)[email protected]^+$=1+(

Öffne die Konfigurationsdatei zum Bearbeiten.

$ sudo nano configuration.py

Suche die Variable ALLOWED_HOSTS und setze ihre Werte wie folgt. Diese Variable enthält eine Liste der gültigen Hostnamen und IP-Adressen, über die dieser Server erreicht werden kann.

ALLOWED_HOSTS = ['netbox.example.com', '<yourserverIP>']

Der nächste Schritt ist die Bearbeitung der Datenbankdetails. Konfiguriere die Datenbankdetails wie folgt.

DATABASE = {
    'NAME': 'netbox',              # Database name
    'USER': 'netbox',              # PostgreSQL username
    'PASSWORD': 'Your_Password',   # PostgreSQL password
    'HOST': 'localhost',           # Database server
    'PORT': '',                    # Database port (leave blank for default)
    'CONN_MAX_AGE': 300,           # Max database connection age
}

Konfiguriere die Redis-Konfiguration wie abgebildet. Gib das Redis-Passwort ein, das du in Schritt 3 festgelegt hast.

REDIS = {
    'tasks': {
        'HOST': 'localhost',
        'PORT': 6379,
        # Comment out `HOST` and `PORT` lines and uncomment the following if using Redis Sentinel
        # 'SENTINELS': [('mysentinel.redis.example.com', 6379)],
        # 'SENTINEL_SERVICE': 'netbox',
        'PASSWORD': 'Your_Redis_Password',
        'DATABASE': 0,
        'SSL': False,
        # Set this to True to skip TLS certificate verification
        # This can expose the connection to attacks, be careful
        # 'INSECURE_SKIP_TLS_VERIFY': False,
    },
    'caching': {
        'HOST': 'localhost',
        'PORT': 6379,
        # Comment out `HOST` and `PORT` lines and uncomment the following if using Redis Sentinel
        # 'SENTINELS': [('mysentinel.redis.example.com', 6379)],
        # 'SENTINEL_SERVICE': 'netbox',
        'PASSWORD': 'Your_Redis_Password',
        'DATABASE': 1,
        'SSL': False,
        # Set this to True to skip TLS certificate verification
        # This can expose the connection to attacks, be careful
        # 'INSECURE_SKIP_TLS_VERIFY': False,
    }
}

Füge den Wert des geheimen Schlüssels zu der Variablen hinzu.

SECRET_KEY = 'dSSWi$Ar2cVvu1)V!B82sY1tJAQK9r)[email protected]^+$=1+('

Standardmäßig verwendet die NetBox das lokale Dateisystem, um hochgeladene Dateien zu speichern. Du kannst Dateien auf einem entfernten Dateisystem speichern, indem du die django-storages Bibliothek installierst. Führe den folgenden Befehl aus, um das Paket django-storages zu requirements.txt der NetBox hinzuzufügen, das dann in einem späteren Schritt installiert wird. Wir müssen auch die Speicherparameter konfigurieren. Entferne das Kommentarzeichen im Abschnitt „Storage“ in der Konfigurationsdatei und gehe wie folgt vor.

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',
}

Es werden auch andere Speichertypen wie FTP, SFTP, Dropbox und andere S3-Anbieter unterstützt. Wie du sie konfigurierst, kannst du auf der Hilfeseitedjango-storages nachlesen.

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Schritt 6 – NetBox installieren

Führe das NetBox-Upgrade-Skript aus.

$ sudo /opt/netbox/upgrade.sh

Das Upgrade-Skript führt die folgenden Aufgaben aus.

  • Es erstellt eine virtuelle Python-Umgebung
  • Installiert alle erforderlichen Python-Pakete
  • Führt Datenbankschema-Migrationen durch
  • Erstellt die Dokumentation lokal (für die Offline-Nutzung)
  • Aggregiert statische Ressourcendateien auf der Festplatte

Aktiviere die virtuelle Umgebung, die durch das Upgrade-Skript erstellt wurde.

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

Der nächste Schritt besteht darin, einen Superuser für den Zugriff auf die NetBox zu erstellen. Wechsle aber zuerst in das gewünschte Verzeichnis.

(venv) $ cd /opt/netbox/netbox

Erstelle den Superuser.

(venv) $ python3 manage.py createsuperuser

Du erhältst die folgende Ausgabe.

Username (leave blank to use 'navjot'):
Email address: [email protected]
Password:
Password (again):
Superuser created successfully.

NetBox enthält einen housekeeping Verwaltungsbefehl, der sich um wiederkehrende Aufräumarbeiten kümmert, z. B. um das Löschen alter Sitzungen und abgelaufener Änderungseinträge. Du kannst den Befehl entweder manuell ausführen oder ihn mit cron in regelmäßigen Abständen ausführen lassen. NetBox stellt ein Shell-Skript zur Verfügung, das die Aufräumarbeiten ausführt. Führe den folgenden Befehl aus, um einen Softlink für das Skript im Verzeichnis Cron daily zu erstellen. Dadurch wird sichergestellt, dass der Befehl täglich ausgeführt wird.

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

Der letzte Schritt ist zu testen, ob die NetBox-Anwendung funktioniert. Aber zuerst müssen wir den Port 8000 für den Test öffnen. Du kannst aber auch jeden anderen Port verwenden.

(venv) $ sudo ufw allow 8000

Starte eine Entwicklungsinstanz von NetBox.

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

Wenn der Test erfolgreich war, erhältst du die folgende Ausgabe.

Performing system checks...

System check identified no issues (0 silenced).
December 27, 2022 - 09:27:37
Django version 4.1.4, using settings 'netbox.settings'
Starting development server at http://0.0.0.0:8000/
Quit the server with CONTROL-C.

Du solltest in der Lage sein, NetBox über die URL http://<yourserverIP>:8000/ aufzurufen. Du erhältst den folgenden Bildschirm.

NetBox Homepage

Klicke auf die Schaltfläche Anmelden, um die Anmeldeseite zu öffnen und gib die zuvor erstellten Superuser-Anmeldedaten ein.

NetBox Anmeldeseite

Du gelangst zurück zum NetBox Dashboard.

Drücke die Tasten Strg + C, um den Server anzuhalten. Deaktiviere die virtuelle Python-Umgebung.

(venv) $ deactivate

Schritt 7 – Gunicorn konfigurieren und eine Servicedatei erstellen

NetBox läuft als WSGI-Anwendung hinter einem HTTP-Server. NetBox installiert automatisch den Gunicorn-Server. In diesem Schritt konfigurieren wir Gunicorn und erstellen eine Servicedatei für NetBox, damit die Anwendung im Hintergrund und über Systemneustarts hinweg ausgeführt werden kann.

NetBox wird mit einer Standard-Gunicorn-Konfigurationsdatei geliefert. Erstelle eine Kopie davon.

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

Die Standardkonfiguration sollte für unsere Zwecke ausreichen. Je nach deinen Bedürfnissen kannst du die Datei bearbeiten, um den Hostnamen und die Portnummer zu ändern oder die Leistung zu verbessern, indem du Threads, Worker und die Anzahl der Anfragen änderst.

Im nächsten Schritt kopierst du die Servicedateien von NetBox und Gunicorn in das Verzeichnis /etc/systemd/system.

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

Starte den Service Daemon neu.

$ sudo systemctl daemon-reload

Starte und aktiviere die Dienste netbox und netbox-rq.

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

Überprüfe den Status des WSGI-Dienstes.

$ sudo systemctl status netbox

Du wirst eine ähnliche Ausgabe erhalten.

? 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

Wie du sehen kannst, lauscht Gunicorn standardmäßig auf Port 8001. Diese Information ist nützlich, wenn du Nginx als Reverse-Proxy-Server konfigurierst.

Schritt 8 – Nginx installieren

Ubuntu 22.04 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.

Importiere den Signierschlüssel von Nginx.

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

Füge das Repository für die stabile Version von Nginx hinzu.

$ 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

Aktualisiere die System-Repositories.

$ sudo apt update

Installiere Nginx.

$ sudo apt install nginx

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.22.1

Starte den Nginx-Server.

$ sudo systemctl start nginx

Schritt 9 – SSL installieren

Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Repository von Ubuntu installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.

Bei Ubuntu 22.04 ist Snapd standardmäßig installiert. Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist. Vergewissere dich, dass deine Version von Snapd auf dem neuesten Stand ist.

$ sudo snap install core
$ sudo snap refresh core

Installiere Certbot.

$ sudo snap install --classic certbot

Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt wird, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.

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

Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.

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

Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/netbox.example.com auf deinem Server heruntergeladen.

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

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

Um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert, führe einen Probelauf des Prozesses durch.

$ sudo certbot renew --dry-run

Wenn du keine Fehler siehst, ist alles in Ordnung. Dein Zertifikat wird automatisch erneuert.

Schritt 10 – Nginx konfigurieren

Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.

$ sudo nano /etc/nginx/nginx.conf

Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.

server_names_hash_bucket_size  64;

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Erstelle und öffne die Datei /etc/nginx/conf.d/netbox.conf zum Bearbeiten.

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

Füge den folgenden Code in die Datei ein.

server {
  # Redirect any http requests to 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;

  # TLS configuration
  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 ---
  # fetch OCSP records from URL in ssl_certificate and cache them
  ssl_stapling on;
  ssl_stapling_verify on;
  ssl_dhparam /etc/ssl/certs/dhparam.pem;

  client_max_body_size 25m;

  # Proxy everything over to the netbox server
  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;
  }
}

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Überprüfe die Syntax der Nginx-Konfigurationsdatei.

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Starte den Nginx-Dienst neu.

$ sudo systemctl restart nginx

Du kannst jetzt über die URL https://netbox.example.com auf das NetBox Dashboard zugreifen.

Schritt 11 – NetBox aktualisieren

Das Upgrade von NetBox ist ganz einfach. Die Schritte umfassen das Auschecken des Master-Zweigs des Git-Repositorys, das Ziehen der letzten Commits und das Auschecken der neuen stabilen Version.

Wechsle in das NetBox-Verzeichnis.

$ cd /opt/netbox

Checke den Master-Zweig aus.

$ sudo git checkout master

Ziehe die letzten Commits aus dem Repository.

$ sudo git pull origin master

Checke die neue Version aus. Wenn 3.4.2 die neuere Version ist, kannst du diese auschecken.

$ sudo git checkout v3.4.2

Führe das Upgrade-Skript aus.

$ sudo ./upgrade.sh

Für den Upgrade-Prozess führt das Skript die folgenden Funktionen aus.

  • Zerstört die virtuelle Python-Umgebung und baut sie neu auf
  • Installiert alle erforderlichen Python-Pakete (aufgelistet unter requirements.txt)
  • Installiert alle zusätzlichen Pakete von local_requirements.txt
  • Wendet alle Datenbankmigrationen an, die in der Version enthalten waren
  • Erstellt die Dokumentation lokal (für die Offline-Nutzung)
  • Sammelt alle statischen Dateien, die vom HTTP-Dienst bereitgestellt werden sollen
  • Löscht veraltete Inhaltstypen aus der Datenbank
  • Löscht alle abgelaufenen Benutzersitzungen aus der Datenbank

Startet den Gunicorn- und NetBox-Dienst neu.

$ sudo systemctl restart netbox netbox-rq

Fazit

Damit ist unsere Anleitung zur Installation von NetBox Network Documentation and Management Tool auf einem Ubuntu 22.04 Server zusammen mit NGinx als Reverse Proxy Server abgeschlossen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.

Das könnte dich auch interessieren …