Ricerca nel sito web

Come installare la documentazione e lo strumento di gestione della rete NetBox su Ubuntu 22.04


Su questa pagina

  1. Prerequisiti
  2. Passaggio 1: configurazione del firewall
  3. Passaggio 2 - Installa e configura PostgreSQL
  4. Passaggio 3: installa e configura Redis
  5. Passaggio 4 - Scarica NetBox
  6. Passaggio 5 - Configura NetBox
  7. Passaggio 6 - Installa NetBox
  8. Passaggio 7 - Configura Gunicorn e crea un file di servizio
  9. Passaggio 8 - Installa Nginx
  10. Passaggio 9 - Installa SSL
  11. Passaggio 10 - Configura Nginx
  12. Passaggio 11 - Aggiorna NetBox
  13. Conclusione

NetBox è un indirizzo IP (IPAM) e un'applicazione web open source per la gestione dell'infrastruttura del data center (DCIM) utilizzata per gestire e documentare reti di computer e indirizzi IP. Il team di ingegneri di rete di DigitalOcean lo ha inizialmente concepito. È scritto utilizzando il framework Django Python e utilizza il database PostgreSQL per l'archiviazione dei dati. Utilizza anche il database Redis per la memorizzazione nella cache delle query.

Questo tutorial ti insegnerà come installare lo strumento NetBox su un server Ubuntu 22.04 e Nginx come server proxy inverso.

Prerequisiti

  • A server running Ubuntu 22.04.

  • A non-root user with sudo privileges.

  • A fully qualified domain name (FQDN) like netbox.example.com.

  • Make sure everything is updated.

    $ sudo apt update
    $ sudo apt upgrade
    
  • Few packages that your system needs.

    $ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y
    

    Some of these packages may already be installed on your system.

Passaggio 1: configurare il firewall

Il primo passo è configurare il firewall. Ubuntu viene fornito con ufw (Uncomplicated Firewall) per impostazione predefinita.

Controlla se il firewall è in esecuzione.

$ sudo ufw status

Dovresti ottenere il seguente output.

Status: inactive

Consenti porta SSH in modo che il firewall non interrompa la connessione corrente attivandola.

$ sudo ufw allow OpenSSH

Consenti anche porte HTTP e HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Abilita il firewall

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

Controlla di nuovo lo stato del firewall.

$ sudo ufw status

Dovresti vedere un output simile.

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)

Passaggio 2: installa e configura PostgreSQL

NetBox funziona con PostgreSQL 11 e versioni successive. Ubuntu 22.04 viene fornito con PostgreSQL 14 per impostazione predefinita. Useremo PostgreSQL 15 per il nostro tutorial.

Eseguire il comando seguente per aggiungere la chiave GPG PostgreSQL.

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

Aggiungi il repository APT all'elenco delle fonti.

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

Aggiorna il repository di sistema.

$ sudo apt update

Ora puoi installare PostgreSQL usando il comando seguente.

$ sudo apt install postgresql postgresql-contrib

Il pacchetto postgresql-contrib contiene alcune utilità extra.

Controlla lo stato del servizio 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.

Puoi vedere che il servizio è abilitato e in esecuzione per impostazione predefinita.

Avvia la shell PostgreSQL.

$ sudo -i -u postgres psql

Crea il database NetBox.

postgres=# CREATE DATABASE netbox;

Crea l'utente NetBox e scegli una password complessa.

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

Modificare il proprietario del database in utente NetBox.

postgres-# ALTER DATABASE netbox OWNER TO netbox;

Esci dal guscio.

postgres-# \q

Verifica che le tue credenziali funzionino.

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

Uscire dalla shell digitando \q.

Passaggio 3: installa e configura Redis

Ubuntu viene fornito con Redis 6.0.16. Per il nostro tutorial, installeremo l'ultima versione dal repository ufficiale.

Importa la chiave GPG Redis ufficiale.

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

Aggiungi il repository APT all'elenco delle fonti.

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

Aggiorna l'elenco dei repository di sistema.

$ sudo apt update

Immetti il seguente comando per installare il server Redis.

$ sudo apt install redis

Conferma la versione di Redis.

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

Verifichiamo la connessione del servizio utilizzando il seguente comando.

$ redis-cli

Verrai trasferito alla shell Redis.

Il primo passaggio consiste nell'impostare la password per l'utente predefinito di Redis. Sostituisci Your_Redis_Password con una password complessa di tua scelta.

127.0.0.1:6379> acl setuser default >Your_Redis_Password

Testare l'autenticazione Redis.

127.0.0.1:6379> AUTH Your_Redis_Password
OK

Eseguire il ping del servizio.

127.0.0.1:6379> ping
PONG

Uscire dal servizio digitando exit.

Passo 4 - Scarica NetBox

NetBox richiede Python Django per funzionare. Il primo passaggio nell'installazione di NetBox consiste nell'installare i pacchetti Python richiesti. Eseguire il comando seguente per installare i pacchetti Python richiesti.

$ 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

Controlla la versione di Python.

$ python3 -V
Python 3.10.6

Crea la directory di base per l'installazione di NetBox.

$ sudo mkdir -p /opt/netbox/

Passa alla rubrica.

$ cd /opt/netbox

Clona il ramo principale del repository GitHub di NetBox nella directory corrente.

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

Il flag --depth 1 recupera solo il commit più recente del repository. Se vuoi scaricare l'intera cronologia dei commit, puoi omettere il flag.

Controlla l'ultima versione di NetBox dalla pagina dei rilasci e dai un'occhiata usando Git. Al momento della stesura del tutorial, 3.4.1 è l'ultima versione disponibile.

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

Prima di verificarlo, è necessario aggiungere la directory all'elenco delle directory sicure di Git. Questa è una nuova funzionalità di sicurezza disponibile nelle recenti versioni di Git.

Il passaggio successivo consiste nel creare un utente e un gruppo di sistema per NetBox.

$ sudo adduser --system --group netbox

Concedere all'utente l'autorizzazione sulla directory multimediale di NetBox.

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

Passo 5 - Configura NetBox

Passa alla directory di configurazione di NetBox.

$ cd /opt/netbox/netbox/netbox/

Copia il file di configurazione di esempio per creare il file vero e proprio.

$ sudo cp configuration_example.py configuration.py

Prima di procedere con la configurazione, dobbiamo creare una chiave segreta per NetBox. Annotare la chiave perché ne abbiamo bisogno per la configurazione.

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

Apri il file di configurazione per la modifica.

$ sudo nano configuration.py

Trova la variabile ALLOWED_HOSTS e imposta i suoi valori come segue. Questa variabile contiene un elenco di nomi host e indirizzi IP validi tramite i quali è possibile raggiungere questo server.

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

Il prossimo passo è modificare i dettagli del database. Configurare i dettagli del database come segue.

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
}

Configurare la configurazione Redis come mostrato. Inserisci la password Redis che hai impostato al passaggio 3.

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

Aggiungi il valore delle chiavi segrete alla variabile.

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

Per impostazione predefinita, NetBox utilizza il file system locale per archiviare i file caricati. Puoi archiviare i file su un filesystem remoto installando la libreria django-storages. Esegui il seguente comando per aggiungere il pacchetto django-storages al NetBox requirements.txt che verrà quindi installato in un passaggio successivo. Abbiamo anche bisogno di configurare i parametri di archiviazione. Rimuovere il commento dalla sezione di archiviazione del file di configurazione e procedere come segue.

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

Sono supportati anche altri tipi di archiviazione, tra cui FTP, SFTP, Dropbox e altri provider S3. Per sapere come configurarli, puoi leggere la pagina di aiuto di django-storages.

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Passo 6 - Installa NetBox

Esegui lo script di aggiornamento di NetBox.

$ sudo /opt/netbox/upgrade.sh

Lo script di aggiornamento esegue le seguenti attività.

  • Crea un ambiente virtuale Python
  • Installa tutti i pacchetti Python richiesti
  • Esegui migrazioni dello schema del database
  • Crea la documentazione in locale (per l'utilizzo offline)
  • Aggrega file di risorse statiche su disco

Attiva l'ambiente virtuale creato dallo script di aggiornamento.

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

Il prossimo passo è creare un superutente per accedere a NetBox. Ma prima, passa alla directory richiesta.

(venv) $ cd /opt/netbox/netbox

Crea il superutente.

(venv) $ python3 manage.py createsuperuser

Otterrai il seguente output.

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

NetBox include un comando di gestione housekeeping che gestisce le attività di pulizia ricorrenti, come la cancellazione di vecchie sessioni e record di modifiche scaduti. Puoi eseguire il comando manualmente o utilizzare cron per eseguirlo a intervalli regolari. NetBox fornisce uno script di shell per eseguire le attività di pulizia. Esegui il seguente comando per creare un soft link per lo script nella directory giornaliera di Cron. Ciò assicurerà che il comando venga eseguito quotidianamente.

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

Il passaggio finale consiste nel verificare se l'applicazione NetBox funziona. Ma prima dobbiamo aprire la porta 8000 per il test. Puoi comunque utilizzare qualsiasi porta.

(venv) $ sudo ufw allow 8000

Avvia un'istanza di sviluppo di NetBox.

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

In caso di successo, otterrai il seguente output.

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.

Dovresti essere in grado di accedere a NetBox tramite l'URL http://:8000/. Otterrai la seguente schermata.

Fare clic sul pulsante Accedi per aprire la pagina di accesso e inserire le credenziali di superutente create in precedenza.

Verrai riportato alla dashboard di NetBox.

Premere il tasto Ctrl + C per arrestare il server. Disattivare l'ambiente virtuale Python.

(venv) $ deactivate

Passaggio 7: configurare Gunicorn e creare un file di servizio

NetBox funziona come un'applicazione WSGI dietro un server HTTP. NetBox installa automaticamente il server Gunicorn. In questo passaggio, configureremo Gunicorn e creeremo un file di servizio per NetBox in modo che possa essere eseguito in background e durante i riavvii del sistema.

NetBox viene fornito con un file di configurazione Gunicorn predefinito. Creane una copia.

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

La configurazione predefinita dovrebbe essere sufficiente per i nostri scopi. A seconda delle tue esigenze, puoi modificare il file per modificare il nome host e il numero di porta o migliorare le prestazioni modificando thread, worker e il numero di richieste.

Il passaggio successivo consiste nel copiare i file del servizio NetBox e Gunicorn nella directory /etc/systemd/system.

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

Ricarica il demone del servizio.

$ sudo systemctl daemon-reload

Avvia e abilita i servizi netbox e netbox-rq.

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

Controlla lo stato del servizio WSGI.

$ sudo systemctl status netbox

Otterrai un risultato simile.

? 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

Come puoi vedere, Gunicorn è in ascolto sulla porta 8001 per impostazione predefinita. Queste informazioni saranno utili durante la configurazione di Nginx come server proxy inverso.

Passaggio 8: installa Nginx

Ubuntu 22.04 viene fornito con una versione precedente di Nginx. Per installare l'ultima versione, devi scaricare il repository Nginx ufficiale.

Importa la chiave di firma Nginxs.

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

Aggiungi il repository per la versione stabile di Nginxs.

$ 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

Aggiorna i repository di sistema.

$ sudo apt update

Installa Nginx.

$ sudo apt install nginx

Verificare l'installazione.

$ nginx -v
nginx version: nginx/1.22.1

Avvia il server Nginx.

$ sudo systemctl start nginx

Passaggio 9: installa SSL

Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot usando il repository Ubuntus o prendere l'ultima versione usando lo strumento Snapd. Useremo la versione Snapd.

Ubuntu 22.04 viene fornito con Snapd installato per impostazione predefinita. Esegui i seguenti comandi per assicurarti che la tua versione di Snapd sia aggiornata. Assicurati che la tua versione di Snapd sia aggiornata.

$ sudo snap install core
$ sudo snap refresh core

Installa Cerbot.

$ sudo snap install --classic certbot

Utilizzare il seguente comando per assicurarsi che il comando Certbot venga eseguito creando un collegamento simbolico alla directory /usr/bin.

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

Eseguire il seguente comando per generare un certificato SSL.

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

Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/netbox.example.com sul tuo server.

Genera un certificato di gruppo Diffie-Hellman.

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

Per verificare se il rinnovo SSL funziona correttamente, eseguire un'esecuzione a secco del processo.

$ sudo certbot renew --dry-run

Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.

Passaggio 10: configurare Nginx

Apri il file /etc/nginx/nginx.conf per la modifica.

$ sudo nano /etc/nginx/nginx.conf

Aggiungere la riga seguente prima della riga include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Crea e apri il file /etc/nginx/conf.d/netbox.conf per la modifica.

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

Incolla il seguente codice al suo interno.

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;
  }
}

Salva il file premendo Ctrl + X e inserendo Y quando richiesto una volta terminato.

Verificare la sintassi del file di configurazione Nginx.

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

Riavvia il servizio Nginx.

$ sudo systemctl restart nginx

Ora puoi accedere alla dashboard di NetBox tramite l'URL https://netbox.example.com.

Passaggio 11: aggiorna NetBox

L'aggiornamento di NetBox è abbastanza semplice. I passaggi prevedono il check-out del ramo principale del repository Git, l'estrazione degli ultimi commit e quindi il check-out della nuova versione stabile.

Passa alla directory NetBox.

$ cd /opt/netbox

Controlla il ramo principale.

$ sudo git checkout master

Estrai gli ultimi commit dal repository.

$ sudo git pull origin master

Scopri la nuova versione. Se 3.4.2 è la versione più recente, puoi verificarlo.

$ sudo git checkout v3.4.2

Eseguire lo script di aggiornamento.

$ sudo ./upgrade.sh

Per il processo di aggiornamento, lo script esegue le seguenti funzioni.

  • Distrugge e ricostruisce l'ambiente virtuale Python
  • Installa tutti i pacchetti Python richiesti (elencati in requirements.txt)
  • Installa eventuali pacchetti aggiuntivi da local_requirements.txt
  • Applica tutte le migrazioni del database incluse nella versione
  • Crea la documentazione in locale (per l'utilizzo offline)
  • Raccoglie tutti i file statici che devono essere serviti dal servizio HTTP
  • Elimina i tipi di contenuto non aggiornati dal database
  • Elimina tutte le sessioni utente scadute dal database

Riavvia il servizio Gunicorn e NetBox.

$ sudo systemctl restart netbox netbox-rq

Conclusione

Questo conclude il nostro tutorial sull'installazione di NetBox Network Documentation and Management Tool su un server Ubuntu 22.04 insieme a NGinx come server proxy inverso. Se hai domande, pubblicale nei commenti qui sotto.