Come installare Django con Postgres, Nginx e Gunicorn su Rocky Linux 9

Su questa pagina

Prerequisiti
Passaggio 1: configurazione del firewall
Passaggio 2 - Installa PostgreSQL e le utility
Passaggio 3 - Configurare PostgreSQL
Passaggio 4 - Installa Django
1. Installa usando pip
2. Installa la versione di sviluppo
1. Esegui il server Django persistente utilizzando nohup
2. Installa Gunicorn
Django è un framework Python utilizzato per lo sviluppo di siti Web e applicazioni dinamici. Segue l'architettura MVC (Model-View-Controller). L'uso di Django accelera il processo di sviluppo delle applicazioni poiché la maggior parte delle attività sottostanti sono gestite da esso.
In questo tutorial imparerai come installare il framework Django su un server Rocky Linux 9. Creerai anche un progetto demo e lo testerai.
Prerequisiti
- A server running Rocky Linux 9.
- A non-root user with sudo privileges.
- A fully qualified domain name (FQDN) pointing to your server. For our purposes, we will use django.example.com as the domain name.
- Make sure everything is updated.
```
$ sudo dnf update
```
- Install basic utility packages. Some of them may already be installed.
```
$ sudo dnf install wget curl nano unzip yum-utils -y
```
- SELinux è disabilitato.
Passaggio 1: configurare il firewall
Il primo passo è configurare il firewall. Rocky Linux utilizza Firewalld Firewall. Controlla lo stato dei firewall.
```
$ sudo firewall-cmd --state
running
```
Il firewall funziona con zone diverse e la zona pubblica è quella predefinita che utilizzeremo. Elenca tutti i servizi e le porte attive sul firewall.
```
$ sudo firewall-cmd --permanent --list-services
```
Dovrebbe mostrare il seguente output.
```
cockpit dhcpv6-client ssh
```
Django ha bisogno delle porte HTTP e HTTPS per funzionare. Aprili.
```
$ sudo firewall-cmd --add-service=http --permanent
$ sudo firewall-cmd --add-service=https --permanent
```
Ricarica il firewall per applicare le modifiche.
```
$ sudo firewall-cmd --reload
```
Passaggio 2: installa PostgreSQL e le utilità

Rocky Linux 9 viene fornito con una versione precedente di PostgreSQL. Installeremo Postgres 14 per il nostro tutorial.
Installa l'RPM del repository per PostgreSQL.
```
$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm
```
Installa il server PostgreSQL 14.
```
$ sudo dnf install -y postgresql14-server postgresql14-contrib postgresql14-devel python3-psycopg2
```
Inizializzare il database.
```
$ sudo /usr/pgsql-14/bin/postgresql-14-setup initdb
```
Abilita e avvia il servizio PostgreSQL.
```
$ sudo systemctl enable postgresql-14 --now
```
Controlla lo stato del servizio.
```
$ sudo systemctl status postgresql-14
? postgresql-14.service - PostgreSQL 14 database server
     Loaded: loaded (/usr/lib/systemd/system/postgresql-14.service; enabled; vendor preset: disabled)
     Active: active (running) since Mon 2022-09-12 01:17:24 UTC; 2s ago
       Docs: https://www.postgresql.org/docs/14/static/
    Process: 87995 ExecStartPre=/usr/pgsql-14/bin/postgresql-14-check-db-dir ${PGDATA} (code=exited, status=0/SUCCESS)
   Main PID: 88000 (postmaster)
      Tasks: 8 (limit: 5915)
     Memory: 16.5M
        CPU: 60ms
     CGroup: /system.slice/postgresql-14.service
             ??88000 /usr/pgsql-14/bin/postmaster -D /var/lib/pgsql/14/data/
             ??88001 "postgres: logger "
             ??88003 "postgres: checkpointer "
             ??88004 "postgres: background writer "
             ??88005 "postgres: walwriter "
             ??88006 "postgres: autovacuum launcher "
             ??88007 "postgres: stats collector "
             ??88008 "postgres: logical replication launcher "

Sep 12 01:17:24 board.example.com systemd[1]: Starting PostgreSQL 14 database server...
```
Installiamo alcune utilità aggiuntive di cui avremo bisogno per far funzionare Django.
```
$ sudo dnf install -y python3 python3-devel python3-pip gcc
```
Per risolvere eventuali errori futuri relativi a pg_config non trovato, è necessario aggiungere il percorso alla cartella bin di PostgreSQL. Apri il file .bashrc per la modifica.
```
$ nano ~/.bashrc
```
Aggiungere la riga seguente alla fine del file.
```
export PATH=$PATH:/usr/pgsql-14/bin	
```
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Passaggio 3: configurare PostgreSQL

Accedi alla shell PostgreSQL.
```
$ sudo -i -u postgres psql
```
Crea un nuovo database per Django.
```
postgres=# CREATE DATABASE djangoapp;
```
Crea un nuovo utente del database con una password complessa.
```
postgres=# CREATE USER djangouser WITH ENCRYPTED PASSWORD 'dbpassword';
```
Concedere all'utente i diritti per l'utilizzo del database.
```
postgres=# GRANT ALL PRIVILEGES ON DATABASE djangoapp TO djangouser;
```
Uscire dalla shell di Postgres.
```
postgres=# \q
```
Passo 4 - Installa Django
Esistono diversi metodi con cui è possibile installare Django. Decidere quale funziona meglio per te dipende da come vuoi configurare il tuo ambiente di sviluppo e dalle tue esigenze. Ogni metodo ha il proprio set di pro e contro. Esaminiamo tutti questi metodi.
Installa usando pip
Questo è il modo più comune per installare Django. Il modo consigliato per farlo è creare un ambiente Python virtuale. Ciò consente di installare i pacchetti Python senza influire sul sistema.
Creiamo una directory del progetto demo.
```
$ mkdir ~/sampleproject
$ cd ~/sampleproject
```
Crea un ambiente virtuale utilizzando il seguente comando. Sostituisci sample_env con il nome che vuoi chiamare il tuo ambiente virtuale.
```
$ python3 -m venv sample_env
```
Questo installa una versione portatile di Python, pip all'interno della directory del tuo progetto. Per installare eventuali pacchetti nel progetto, è necessario attivare l'ambiente utilizzando il seguente comando.
```
$ source sample_env/bin/activate
```
Il prompt della shell cambierà per riflettere l'ambiente virtuale.
```
(sample_env) :~/sampleproject$
```
Ora che l'ambiente virtuale è attivato, usa pip per installare Django. Esegui il seguente comando per installare Django.
```
(sample_env) $ pip install django
```
Verificare l'installazione.
```
(sample_env) $ django-admin --version
4.1.2
```
A seconda dei requisiti del tuo progetto, puoi installare una versione diversa di Django nel modo seguente.
```
(sample_env) $ pip install django==3.2.1
```
Verificare l'installazione.
```
(sample_env) $ django-admin --version
3.2.1
```
Come puoi vedere, questo metodo installa una versione più recente di Django rispetto alla versione ottenuta dal repository Rocky Linux.
Per uscire dall'ambiente virtuale, eseguire il seguente comando.
```
(sample_env) $ deactivate
```
Installa la versione di sviluppo
Puoi anche usare pip per installare la versione di sviluppo di Django. Per questo, prenderemo la versione di sviluppo dal repository Github di Djangos.
Clona il repository nella directory ~/django-dev usando il seguente comando.
```
$ git clone https://github.com/django/django ~/django-dev
```
Passa alla directory appena creata.
```
$ cd ~/django-dev
```
Creare l'ambiente virtuale.
```
$ python3 -m venv dev_django_env
```
Attiva l'ambiente.
```
$ source dev_django_env/bin/activate
```
Installa Django usando pip. Il flag -e lo installa in una modalità modificabile che è richiesta se stai installando dal controllo di versione.
```
(dev_django_dev) $ pip install -e ~/django-dev
```
Verificare l'installazione.
```
(dev_django_dev) $ django-admin --version
4.2.dev20221012095013
```
Come puoi vedere, la versione qui è l'ultima versione di sviluppo. La versione di sviluppo di Django non è utile per gli ambienti di produzione.
Passaggio 5: creare un progetto di esempio
Costruiamo un esempio di progetto Django. Creare una directory per il progetto di esempio.
```
$ mkdir ~/dj-sample
$ cd ~/dj-sample
```
Crea un ambiente virtuale Python.
```
$ python3 -m venv sample_proj
```
Attiva l'ambiente.
```
$ source sample_proj/bin/activate
```
Installa il pacchetto Wheel.
```
(sample_proj) $ pip install wheel
```
Installa Django e i pacchetti richiesti.
```
(sample_proj) $ pip install django psycopg2 psycopg2-binary
```
Per costruire il progetto, dobbiamo usare il comando startproject. Questo comando crea un'altra directory che include:
- Uno script di gestione, manage.py, utilizzato per amministrare compiti specifici di Django.
- Una directory con lo stesso nome del progetto che include il codice del progetto.
Creeremo la directory del progetto nella nostra attuale directory di lavoro. Per fare ciò, usa il carattere punto (.) alla fine del seguente comando.
```
(sample_proj) $ django-admin startproject demoproject .
```
Django utilizza la variabile SECRET_KEY per fornire la firma crittografica. Genera un valore predefinito durante l'installazione. Dovresti sostituirlo con un valore sicuro. Eseguire il seguente comando per generare la chiave e copiarla per dopo.
```
(sample_proj) $ python3 -c 'from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())'
```
Otterrai il seguente output con una chiave.
```
wm#dzb^ymuo3s3tza=f5cx^kan!$4sch1!b-q=v%)=d0pb(jqf
```
Il primo passo è regolare le impostazioni del progetto. Apri il file delle impostazioni per la modifica.
```
(sample_proj) $ nano demoproject/settings.py
```
Sostituisci il valore corrente della variabile SECRET_KEY con la chiave che hai generato.
```
SECRET_KEY = 's)3m=4s&!a=p#$8(z6e+u8(^tkpw28qyj0t#8ku2'
```
Modifica le impostazioni per la sezione DATABASES come segue.
```
DATABASES = {
    'default': {
		'ENGINE': 'django.db.backends.postgresql_psycopg2',
		'NAME': 'DATABASE_DB',
		'USER': 'DATABASE_USER',
		'PASSWORD': 'DATABASE_PASSWORD',
		'HOST': 'DATABASE_HOST',
		'PORT': 'DATABASE_PORT',
	},
}
```
Successivamente, spostati in fondo al file e aggiungi un'impostazione per la posizione dei file statici. Questo è importante affinché Nginx funzioni e gestisca le richieste per questi file. Aggiungi la riga seguente sopra la variabile STATIC_URL.
```
STATIC_ROOT = os.path.join(BASE_DIR, "static/")
```
Poiché la variabile STATIC_ROOT utilizza il modulo os, dobbiamo importarla poiché non è importata per impostazione predefinita. Aggiungi la riga seguente sopra la riga from pathlib import Path.
```
import os
```
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Verificare le impostazioni del database.
```
(sample_proj) $ python manage.py check --database default
```
Dovresti ottenere il seguente output.
```
System check identified no issues (0 silenced).
```
Successivamente, dobbiamo migrare il database usando il comando migrate. Le migrazioni in Django propagano le modifiche apportate ai modelli nello schema del database.
```
(sample_proj) $ python manage.py makemigrations
(sample_proj) $ python manage.py migrate
```
Otterrai il seguente output.
```
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying auth.0009_alter_user_last_name_max_length... OK
  Applying auth.0010_alter_group_name_max_length... OK
  Applying auth.0011_update_proxy_permissions... OK
  Applying auth.0012_alter_user_first_name_max_length... OK
  Applying sessions.0001_initial... OK
```
Successivamente, crea un utente amministrativo per accedere all'interfaccia di amministrazione di Djangos.
```
(sample_proj) $ python manage.py createsuperuser
```
Ti verrà richiesto un nome utente, un'e-mail e una password.
```
Username (leave blank to use 'navjot'):
Email address: 
Password:
Password (again):
Superuser created successfully.
```
Copia i file statici nella directory statica. Inserisci yes quando richiesto.
```
(sample_proj) $ python manage.py collectstatic
130 static files copied to '/home/navjot/dj-sample/static'.
```
Passaggio 6: testare il server di sviluppo
È giunto il momento di testare l'applicazione. Per questo, devi modificare la direttiva ALLOWED_HOSTS nelle impostazioni di Django. Questa direttiva definisce l'elenco di indirizzi IP e nomi di dominio a cui viene concesso l'accesso all'applicazione Django.
Apri il file delle impostazioni usando il seguente comando.
```
(sample_proj) $ nano demoproject/settings.py
```
Trova la seguente voce.
```
ALLOWED_HOSTS = []
```
Inserisci l'indirizzo IP del tuo server tra parentesi quadre. Ogni voce deve essere racchiusa tra virgolette e più voci devono essere separate da virgole. L'immissione di www.example.com verrà abbinata esattamente. Tuttavia, .example.com corrisponderà a example.com e www.example.com e qualsiasi altro sottodominio di example.com. Pertanto, si consiglia di utilizzare il simbolo del punto come prefisso di un nome di dominio in modo che corrisponda a esso e ai relativi sottodomini.
```
ALLOWED_HOSTS = ['<yourserver_ip_address>']
```
Abbiamo utilizzato l'indirizzo IP per abbinare il nostro server. Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Prima di testare il server di sviluppo, devi configurare il firewall per consentire a Django di funzionare. Django utilizza la porta 8000 per impostazione predefinita. Apri la porta utilizzando Uncomplicated Firewall (UFW).
```
(sample_proj) $ sudo firewall-cmd --add-port=8000/tcp --permanent
(sample_proj) $ sudo firewall-cmd --reload
```
Avvia il server di sviluppo.
```
(sample_proj) $ python manage.py runserver 0.0.0.0:8000
```
Avvia l'URL http://:8000 nel tuo browser e otterrai la seguente schermata.
Puoi accedere all'interfaccia di amministrazione seguendo l'URL http://:8000/admin/ e vedrai la seguente schermata di accesso.
Inserisci le credenziali create in precedenza per accedere al pannello di amministrazione mostrato di seguito.
Una volta che hai finito con il tuo progetto demo, puoi chiudere il server premendo Ctrl + C nel tuo terminale.
Passaggio 7: installare e testare Gunicorn
Esegui il server Django persistente usando nohup
Finora, il servizio Djangos non è persistente. Per rendere il servizio persistente, ci sono due metodi. Il primo metodo prevede l'utilizzo dell'utility nohup. Il nohup è un comando POSIX che significa non riagganciare. Viene utilizzato per eseguire comandi in un modo che non si interrompe nemmeno quando un utente si disconnette.
Assicurati di essere uscito dal server dal terminale premendo Ctrl + C.
Eseguire il seguente comando per eseguire il server di sviluppo Djangos.
```
(sample_proj) $ nohup python manage.py runserver 0.0.0.0:8000 &
```
Ora, il tuo server Django continuerà a funzionare fino a quando non lo ucciderai manualmente. Il comando ti darà l'ID del processo e produrrà un altro comando.
```
[1] 42595
(sample_proj) $ nohup: ignoring input and appending output to 'nohup.out'
^C
```
Premi Ctrl + C per uscire. Il server Django originale continuerà a funzionare. Puoi verificare aprendo l'URL nel tuo browser.
Una volta che hai finito, devi terminare il processo. Il comando nohup fornisce un ID processo. Ma in realtà, sono in corso due processi. Per trovare gli ID per entrambi i processi, eseguire il comando seguente.
```
(sample_proj) $ ps aux | grep manage.py
navjot    153474  1.6  3.9  46264 39016 pts/0    S    04:15   0:00 python manage.py runserver 0.0.0.0:8000
navjot    153475  3.0  4.4 196060 43500 pts/0    Sl   04:15   0:00 /home/navjot/dj-sample/sample_proj/bin/python manage.py runserver 0.0.0.0:8000
navjot    153483  0.0  0.2   6420  2248 pts/0    S+   04:15   0:00 grep --color=auto manage.py
```
Come puoi vedere, vengono eseguiti due processi, uno con ID 153474 e l'altro con ID 153475.
Eseguire il seguente comando per chiudere il server utilizzando gli ID di processo ottenuti in precedenza.
```
(sample_proj) $ sudo kill -9 153474 153475
```
Installa Gunicorn
Il secondo metodo per eseguire un server Django persistente richiede l'installazione dei server Web Gunicorn e Nginx. Gunicorn è un server HTTP WSGI Python. Si interfaccerà con l'applicazione Django e quindi Nginx fungerà da proxy inverso per Gunicorn. Questo metodo ha l'ulteriore vantaggio di fornire la sicurezza e le prestazioni che derivano dall'utilizzo di Nginx.
Installa Gunicorn.
```
(sample_proj) $ pip install gunicorn
```
Prima di procedere, dobbiamo testare la capacità di Gunicorn di servire il progetto. Eseguire il seguente comando per eseguire Gunicorn.
```
(sample_proj) $ gunicorn --bind 0.0.0.0:8000 demoproject.wsgi:application
```
Questo avvierà Gunicorn sulla stessa interfaccia su cui era in esecuzione Django. Per verificare, apri l'URL http://:8000 nel tuo browser e otterrai la stessa home page di Django. Ciò significa che Gunicorn funziona perfettamente.
Al termine del test, premi Ctrl + C sul terminale per uscire da Gunicorn.
Disattiva l'ambiente virtuale per tornare alla normale shell.
```
(sample_proj) $ deactivate
```
Passaggio 8: creare un file Socket e Service per Gunicorn
Il primo passo è creare un file socket Gunicorn. Il socket Gunicorn verrà creato al momento dell'avvio e ascolterà le connessioni. Quando si verifica una connessione, systemd avvierà automaticamente il processo Gunicorn per gestirla.
Crea e apri il file socket Gunicorn per la modifica.
```
$ sudo nano /etc/systemd/system/gunicorn.socket
```
Incolla il seguente codice al suo interno.
```
[Unit]
Description=gunicorn socket

[Socket]
ListenStream=/run/gunicorn.sock

[Install]
WantedBy=sockets.target
```
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Successivamente, crea e apri il file di servizio Gunicorn per la modifica.
```
$ sudo nano /etc/systemd/system/gunicorn.service
```
Incolla il seguente codice al suo interno.
```
[Unit]
Description=django gunicorn daemon
Requires=gunicorn.socket
After=network.target

[Service]
User=navjot
Group=nginx
WorkingDirectory=/home/navjot/dj-sample
ExecStart=/home/navjot/dj-sample/sample_proj/bin/gunicorn \
          -t 3000 \
          --access-logfile - \
          --workers 3 \
          --bind unix:/run/gunicorn.sock \
          demoproject.wsgi:application -w 2

[Install]
WantedBy=multi-user.target
```
Salva il file premendo Ctrl + X e immettendo Y quando richiesto. Sostituisci navjot con il tuo nome utente di sistema. Il gruppo nginx consentirà al server Nginx di comunicare con Django.
Ricarica il demone di sistema per aggiornare i file systemd.
```
$ sudo systemctl daemon-reload
```
Abilita e avvia il file socket Gunicorn.
```
$ sudo systemctl start gunicorn.socket
$ sudo systemctl enable gunicorn.socket
```
Controlla lo stato della presa Gunicorn.
```
$ sudo systemctl status gunicorn.socket
```
Riceverai un output simile.
```
? gunicorn.socket - gunicorn socket
     Loaded: loaded (/etc/systemd/system/gunicorn.socket; enabled; vendor preset: disabled)
     Active: active (listening) since Thu 2022-10-13 04:19:28 UTC; 14s ago
      Until: Thu 2022-10-13 04:19:28 UTC; 14s ago
   Triggers: ? gunicorn.service
     Listen: /run/gunicorn.sock (Stream)
     CGroup: /system.slice/gunicorn.socket

Oct 13 04:19:28 django.nspeaks.xyz systemd[1]: Listening on gunicorn socket.
```
Il servizio Gunicorn non è ancora in esecuzione, come puoi verificare.
```
$ sudo systemctl status gunicorn.service
? gunicorn.service - django gunicorn daemon
     Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: enabled)
     Active: inactive (dead)
TriggeredBy: ? gunicorn.socket
```
Per testare il meccanismo di attivazione del socket, eseguire il comando seguente.
```
$ curl --unix-socket /run/gunicorn.sock localhost
```
Riceverai l'output HTML della home page di Django nel tuo terminale. Questo avvia anche Gunicorn per servire l'applicazione. Controlla di nuovo lo stato del servizio e vedrai che ora è in esecuzione.
```
$ sudo systemctl status gunicorn.service
? gunicorn.service - django gunicorn daemon
     Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: disabled)
     Active: active (running) since Thu 2022-10-13 06:13:55 UTC; 1min 34s ago
TriggeredBy: ? gunicorn.socket
   Main PID: 157742 (gunicorn)
      Tasks: 4 (limit: 5915)
     Memory: 96.2M
        CPU: 1.198s
     CGroup: /system.slice/gunicorn.service
             ??157742 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application -w 2
             ??157746 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application -w 2
             ??157747 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application -w 2
             ??157748 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application -w 2
.......
```
Passaggio 9: installa Nginx
L'ultimo passaggio consiste nell'installare e configurare Nginx. Rocky Linux viene fornito con una versione precedente di Nginx. Devi scaricare il repository Nginx ufficiale per installare l'ultima versione.
Crea e apri il file /etc/yum.repos.d/nginx.repo per creare il repository Nginx ufficiale.
```
$ sudo nano /etc/yum.repos.d/nginx.repo
```
Incolla il seguente codice al suo interno.
```
[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true
```
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Installa il server Nginx.
```
$ sudo dnf install nginx -y
```
Verificare l'installazione.
```
$ nginx -v
nginx version: nginx/1.22.1
```
Abilita e avvia il server Nginx.
```
$ sudo systemctl enable nginx --now
```
Controlla lo stato del server.
```
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
     Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; vendor preset: disabled)
     Active: active (running) since Thu 2022-10-13 06:17:24 UTC; 1s ago
       Docs: http://nginx.org/en/docs/
    Process: 157900 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
   Main PID: 157901 (nginx)
      Tasks: 2 (limit: 5915)
     Memory: 1.9M
        CPU: 18ms
     CGroup: /system.slice/nginx.service
             ??157901 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??157902 "nginx: worker process"

Oct 13 06:17:24 django.example.com systemd[1]: Starting nginx - high performance web server...
```
Passaggio 10: installa SSL
Finora, la tua applicazione Django viene servita su una connessione HTTP in chiaro. Si consiglia vivamente di proteggerlo tramite un certificato SSL. Per questo, usa lo strumento Certbot usando lo strumento Snapd. Richiede il repository EPEL per funzionare.
```
$ sudo dnf install epel-release
```
Useremo Snapd per installare Certbot. Installa Snapd.
```
$ sudo dnf install snapd
```
Abilita e avvia il servizio Snap.
```
$ sudo systemctl enable snapd.socket --now
```
Crea i collegamenti necessari affinché Snapd funzioni.
```
$ sudo ln -s /var/lib/snapd/snap /snap
$ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh
```
Installa il repository principale di Snapd.
```
$ sudo snap install core
$ sudo snap refresh core
```
Installa Cerbot.
```
$ sudo snap install --classic certbot
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
```
Genera il certificato. Il seguente comando configurerà automaticamente anche Nginx.
```
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m  -d django.example.com
```
Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/django.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 11: configurare Nginx
Crea e apri il file /etc/nginx/conf.d/django-gunicorn.conf per la modifica.
```
$ sudo nano /etc/nginx/conf.d/django-gunicorn.conf
```
Incolla il seguente codice al suo interno.
```
# enforce HTTPS
server {
  listen 80 default_server;
  server_name django.example.com;
  return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name django.example.com;

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

    http2_push_preload on; # Enable HTTP/2 Server Push

    ssl_certificate /etc/letsencrypt/live/django.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/django.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/django.example.com/chain.pem;
    ssl_session_timeout 1d;

    # Enable TLS versions (TLSv1.3 is required upcoming HTTP/3 QUIC).
    ssl_protocols TLSv1.2 TLSv1.3;

    # Enable TLSv1.3's 0-RTT. Use $ssl_early_data when reverse proxying to
    # prevent replay attacks.
    #
    # @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
    ssl_early_data on;

    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;

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

    add_header X-Early-Data $tls1_3_early_data;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /home/navjot/dj-sample;
    }

    location / {
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_pass http://unix:/run/gunicorn.sock;
    }
}

# This block is useful for debugging TLS v1.3. Please feel free to remove this
# and use the `$ssl_early_data` variable exposed by NGINX directly should you
# wish to do so.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}
```
Sostituisci la posizione root nel file precedente con la directory sul tuo server.
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
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.
Verifica la configurazione di Nginx.
```
$ sudo nginx -t
```
Se non vedi errori, significa che sei a posto.
Dovrai anche aggiungere il nome di dominio alla tua direttiva ALLOWED_HOSTS. Apri il file settings.py.
```
$ nano ~/dj-sample/demoproject/settings.py
```
Cambia il valore per la variabile ALLOWED_HOSTS.
```
ALLOWED_HOSTS = ['<yourserver_ip_address>','django.example.com']
```
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Riavvia Gunicorn Socket e Service.
```
$ sudo systemctl restart gunicorn.socket
$ sudo systemctl restart gunicorn.service
```
Ricarica il server Nginx.
```
$ sudo systemctl reload nginx
```
Apri la porta HTTP. Puoi anche eliminare la porta 8000 se non la utilizzerai più.
```
$ sudo firewall-cmd --remove-port=8000/tcp --permanent
$ sudo firewall-cmd --reload
```
Verifica aprendo l'URL http://django.example.com e la home page di Django verrà caricata.
Conclusione
Questo conclude il nostro tutorial in cui hai imparato come installare Django insieme a Gunicorn e Nginx su un server Rocky Linux 9. Hai anche installato un certificato SSL per migliorare la sicurezza del tuo progetto Django. Se hai domande, pubblicale nei commenti qui sotto.

Come installare Django con Postgres, Nginx e Gunicorn su Rocky Linux 9

Su questa pagina

Prerequisiti

Passaggio 1: configurare il firewall

Passaggio 2: installa PostgreSQL e le utilità

Passaggio 3: configurare PostgreSQL

Passo 4 - Installa Django

Installa usando pip

Installa la versione di sviluppo

Passaggio 5: creare un progetto di esempio

Passaggio 6: testare il server di sviluppo

Passaggio 7: installare e testare Gunicorn

Esegui il server Django persistente usando nohup

Installa Gunicorn

Passaggio 8: creare un file Socket e Service per Gunicorn

Passaggio 9: installa Nginx

Passaggio 10: installa SSL

Passaggio 11: configurare Nginx

Conclusione