Installazione software · 15 min read · Oct 22, 2025

Come installare NetBox Network Documentation e Management Tool su Ubuntu 22.04

NetBox è un’applicazione web open-source per la gestione degli indirizzi IP (IPAM) e dell’infrastruttura del datacenter (DCIM) utilizzata per gestire e documentare reti informatiche e indirizzi IP. È stata concepita inizialmente dal team di ingegneria di rete di DigitalOcean. È scritta 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

  • Un server che esegue Ubuntu 22.04.
  • Un utente non root con privilegi sudo.
  • Un nome di dominio completamente qualificato (FQDN) come netbox.example.com.
  • Assicurati che tutto sia aggiornato. $ sudo apt update $ sudo apt upgrade
  • Alcuni pacchetti di cui il tuo sistema ha bisogno. $ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y Alcuni di questi pacchetti potrebbero già essere installati sul tuo sistema.

Passo 1 - Configura il Firewall

Il primo passo è configurare il firewall. Ubuntu viene fornito di default con ufw (Uncomplicated Firewall).

Controlla se il firewall è attivo.

$ sudo ufw status

Dovresti ottenere il seguente output.

Status: inactive

Consenti la porta SSH in modo che il firewall non interrompa la connessione attuale quando viene abilitato.

$ sudo ufw allow OpenSSH

Consenti anche le porte HTTP e HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Abilita il Firewall

$ sudo ufw enable
Il comando può interrompere le connessioni ssh esistenti. Procedere con l'operazione (y|n)? y
Il firewall è attivo e abilitato all'avvio del sistema

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)

Passo 2 - Installa e configura PostgreSQL

NetBox funziona con PostgreSQL 11 e versioni successive. Ubuntu 22.04 viene fornito di default con PostgreSQL 14. Utilizzeremo PostgreSQL 15 per il nostro tutorial.

Esegui il seguente comando per aggiungere la chiave GPG di 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 alla tua lista di sorgenti.

$ 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 utilizzando il comando sottostante.

$ sudo apt install postgresql postgresql-contrib

Il pacchetto postgresql-contrib contiene alcune utility 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 di PostgreSQL.

$ sudo -i -u postgres psql

Crea il database NetBox.

postgres=# CREATE DATABASE netbox;

Crea l’utente NetBox e scegli una password forte.

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

Cambia il proprietario del database in utente NetBox.

postgres-# ALTER DATABASE netbox OWNER TO netbox;

Esci dalla shell.

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

Esci dalla shell digitando \q.

Passo 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 ufficiale di Redis.

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

Aggiungi il repository APT alla tua lista di sorgenti.

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 la lista dei repository di sistema.

$ sudo apt update

Esegui 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 al servizio utilizzando il seguente comando.

$ redis-cli

Verrai spostato nella shell di Redis.

Il primo passo è impostare la password per l’utente predefinito di Redis. Sostituisci Your_Redis_Password con una password forte a tua scelta.

127.0.0.1:6379> acl setuser default >Your_Redis_Password

Testa l’autenticazione di Redis.

127.0.0.1:6379> AUTH Your_Redis_Password
OK

Ping il servizio.

127.0.0.1:6379> ping
PONG

Esci dal servizio digitando exit.

Passo 4 - Scarica NetBox

NetBox richiede Python Django per funzionare. Il primo passo per installare NetBox è installare i pacchetti Python richiesti. Esegui il seguente comando 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 directory.

$ cd /opt/netbox

Clona il branch master 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 desideri scaricare l’intera cronologia dei commit, puoi omettere il flag.

Controlla l’ultima versione di NetBox dalla pagina delle release e controllala utilizzando Git. Al momento della scrittura 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 controllarla, devi aggiungere la directory all’elenco delle directory sicure di Git. Questa è una nuova funzionalità di sicurezza disponibile nelle recenti versioni di Git.

Il passo successivo è creare un utente e un gruppo di sistema per NetBox.

$ sudo adduser --system --group netbox

Dai all’utente i permessi sulla directory media 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 effettivo.

$ sudo cp configuration_example.py configuration.py

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

$ python3 ../generate_secret_key.py
dSSWi$Ar2cVvu1)V!B82sY1tJAQK9r)vzM8ReQRF7@C^+$=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 dei nomi host e degli indirizzi IP validi tramite i quali questo server può essere raggiunto.

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

Il passo successivo è modificare i dettagli del database. Configura i dettagli del database come segue.

DATABASE = {
    'NAME': 'netbox',              # Nome del database
    'USER': 'netbox',              # Nome utente PostgreSQL
    'PASSWORD': 'Your_Password',   # Password PostgreSQL
    'HOST': 'localhost',           # Server del database
    'PORT': '',                    # Porta del database (lascia vuoto per il predefinito)
    'CONN_MAX_AGE': 300,           # Età massima della connessione al database
}

Configura la configurazione di Redis come mostrato. Inserisci la password di Redis che hai impostato nel passo 3.

REDIS = {
    'tasks': {
        'HOST': 'localhost',
        'PORT': 6379,
        # Commenta le righe `HOST` e `PORT` e decommenta le seguenti se utilizzi Redis Sentinel
        # 'SENTINELS': [('mysentinel.redis.example.com', 6379)],
        # 'SENTINEL_SERVICE': 'netbox',
        'PASSWORD': 'Your_Redis_Password',
        'DATABASE': 0,
        'SSL': False,
        # Imposta questo su True per saltare la verifica del certificato TLS
        # Questo può esporre la connessione ad attacchi, fai attenzione
        # 'INSECURE_SKIP_TLS_VERIFY': False,
    },
    'caching': {
        'HOST': 'localhost',
        'PORT': 6379,
        # Commenta le righe `HOST` e `PORT` e decommenta le seguenti se utilizzi Redis Sentinel
        # 'SENTINELS': [('mysentinel.redis.example.com', 6379)],
        # 'SENTINEL_SERVICE': 'netbox',
        'PASSWORD': 'Your_Redis_Password',
        'DATABASE': 1,
        'SSL': False,
        # Imposta questo su True per saltare la verifica del certificato TLS
        # Questo può esporre la connessione ad attacchi, fai attenzione
        # 'INSECURE_SKIP_TLS_VERIFY': False,
    }
}

Aggiungi il valore della chiave segreta alla variabile.

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

Per impostazione predefinita, NetBox utilizza il filesystem locale per memorizzare i file caricati. Puoi memorizzare i file su un filesystem remoto installando la libreria django-storages. Esegui il seguente comando per aggiungere il pacchetto django-storages al requirements.txt di NetBox, che verrà quindi installato in un passaggio successivo. Dobbiamo anche configurare i parametri di archiviazione. Decommenta la sezione di archiviazione del file di configurazione e procedi 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',
}

Altri tipi di archiviazione sono supportati, inclusi FTP, SFTP, Dropbox e altri fornitori S3. Per sapere come configurarli, puoi leggere la pagina di aiuto di django-storages.

Salva il file premendo Ctrl + X e inserendo 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 operazioni.

  • Crea un ambiente virtuale Python
  • Installa tutti i pacchetti Python richiesti
  • Esegue le migrazioni dello schema del database
  • Costruisce la documentazione localmente (per uso offline)
  • Aggrega i file di risorse statiche su disco

Attiva l’ambiente virtuale creato dallo script di aggiornamento.

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

Il passo successivo è 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

Riceverai il seguente output.

Username (lascia vuoto per usare 'navjot'):
Email address: [email protected]
Password:
Password (di nuovo):
Superuser creato con successo.

NetBox include un comando di gestione housekeeping che gestisce attività di pulizia ricorrenti, come la rimozione di sessioni obsolete e registrazioni di cambiamento scadute. Puoi eseguire il comando manualmente o utilizzare cron per eseguirlo a intervalli regolari. NetBox fornisce uno script shell per eseguire le attività di housekeeping. Esegui il seguente comando per creare un collegamento simbolico per lo script nella directory Cron giornaliera. Questo garantirà che il comando venga eseguito quotidianamente.

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

L’ultimo passo è testare se l’applicazione NetBox funziona. Ma prima, dobbiamo aprire la porta 8000 per il test. Puoi usare 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

Se ha successo, riceverai 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/. Riceverai la seguente schermata.

Homepage di NetBox

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

Pagina di accesso di NetBox

Verrai riportato al dashboard di NetBox.

Premi il tasto Ctrl + C per fermare il server. Disattiva l’ambiente virtuale Python.

(venv) $ deactivate

Passo 7 - Configura Gunicorn e crea un file di servizio

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

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

$ 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 cambiare l’hostname, il numero di porta o apportare miglioramenti delle prestazioni modificando i thread, i worker e il numero di richieste.

Il passo successivo è copiare entrambi i file di servizio di 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

Riceverai un output 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 ascolta sulla porta 8001 per impostazione predefinita. Queste informazioni saranno utili quando configurerai Nginx come server proxy inverso.

Passo 8 - Installa Nginx

Ubuntu 22.04 viene fornito con una versione più vecchia di Nginx. Per installare l’ultima versione, devi scaricare il repository ufficiale di Nginx.

Importa la chiave di firma di Nginx.

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

Aggiorna i repository di sistema.

$ sudo apt update

Installa Nginx.

$ sudo apt install nginx

Verifica l’installazione.

$ nginx -v
nginx version: nginx/1.22.1

Avvia il server Nginx.

$ sudo systemctl start nginx

Passo 9 - Installa SSL

Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot utilizzando il repository di Ubuntu o scaricare l’ultima versione utilizzando lo strumento Snapd. Utilizzeremo la versione Snapd.

Ubuntu 22.04 viene fornito con Snapd installato di default. 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 Certbot.

$ sudo snap install --classic certbot

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

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

Esegui il seguente comando per generare un certificato SSL.

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

Il comando sopra 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 controllare se il rinnovo SSL funziona correttamente, esegui un tentativo di prova del processo.

$ sudo certbot renew --dry-run

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

Passo 10 - Configura Nginx

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

$ sudo nano /etc/nginx/nginx.conf

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

server_names_hash_bucket_size  64;

Salva il file premendo Ctrl + X e inserendo 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 {
  # Reindirizza tutte le richieste http a 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;

  # Configurazione 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 ---
  # recupera i record OCSP dall'URL nel ssl_certificate e memorizzali nella cache
  ssl_stapling on;
  ssl_stapling_verify on;
  ssl_dhparam /etc/ssl/certs/dhparam.pem;

  client_max_body_size 25m;

  # Proxy tutto al server 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;
  }
}

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

Verifica la sintassi del file di configurazione di Nginx.

$ sudo nginx -t
nginx: il file di configurazione /etc/nginx/nginx.conf ha una sintassi corretta
nginx: il test del file di configurazione /etc/nginx/nginx.conf è riuscito

Riavvia il servizio Nginx.

$ sudo systemctl restart nginx

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

Passo 11 - Aggiorna NetBox

Aggiornare NetBox è piuttosto semplice. I passaggi prevedono di controllare il branch master del repository Git, estrarre gli ultimi commit e quindi controllare la nuova versione stabile.

Passa alla directory di NetBox.

$ cd /opt/netbox

Controlla il branch master.

$ sudo git checkout master

Estrai gli ultimi commit dal repository.

$ sudo git pull origin master

Controlla la nuova versione. Se 3.4.2 è la versione più recente, puoi controllarla.

$ sudo git checkout v3.4.2

Esegui 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 eventuali migrazioni del database incluse nella release
  • Costruisce la documentazione localmente (per uso offline)
  • Raccoglie tutti i file statici da servire dal servizio HTTP
  • Elimina i tipi di contenuto obsoleti 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 su come installare NetBox Network Documentation e Management Tool su un server Ubuntu 22.04 insieme a NGinx come server proxy inverso. Se hai domande, pubblicale nei commenti qui sotto.

Share: X/Twitter LinkedIn
#Installazione software

Ricevi i nuovi post nella tua casella di posta.

Nessuno spam. Disiscriviti in qualsiasi momento.