Django è un framework di sviluppo web gratuito e open source scritto in Python. Viene utilizzato per lo sviluppo di applicazioni Python complesse e basate su database. Viene fornito con una serie di script Python per la creazione di progetti Python. Può essere eseguito su qualsiasi sistema operativo in grado di eseguire Python, inclusi Windows, macOS, Linux/Unix e Solaris. Aiuta gli sviluppatori a scrivere meno codice e creare un nuovo sito Web in un breve lasso di tempo.
In questo tutorial, spiegherò come configurare Django in ambiente virtuale Python utilizzando il database PostgreSQL su Debian 11. Quindi installeremo e configureremo Nginx come proxy inverso per Django.
Prerequisiti
- Un server che esegue Debian 11.
- Un nome di dominio valido puntato all'IP del tuo server.
- Sul server è configurata una password di root.
Per iniziare
Prima di iniziare, è una buona idea aggiornare i pacchetti di sistema all'ultima versione. Puoi farlo usando il seguente comando:
apt-get update -y
Una volta aggiornati tutti i pacchetti, installa altri strumenti Python e il pacchetto Nginx con il seguente comando:
apt-get install python3-pip python3-dev libpq-dev curl nginx -y
Una volta installati tutti i pacchetti richiesti, puoi procedere al passaggio successivo.
Installa il server di database PostgreSQL
Qui useremo PostgreSQL come database back-end. Quindi installiamolo usando il seguente comando:
apt-get install postgresql postgresql-contrib -y
Una volta installato PostgreSQL, connettiti alla shell PostgreSQL con il seguente comando:
su - postgres
psql
Quindi, crea un database e un utente per Django con il seguente comando:
CREATE DATABASE django;
CREATE USER django WITH PASSWORD 'password';
Quindi, concedi alcuni ruoli richiesti con il seguente comando:
ALTER ROLE django SET client_encoding TO 'utf8';
ALTER ROLE django SET default_transaction_isolation TO 'read committed';
ALTER ROLE django SET timezone TO 'UTC';
GRANT ALL PRIVILEGES ON DATABASE django TO django;
Quindi, esci dalla shell di PostgreSQL usando il seguente comando:
\q
exit
A questo punto, il database PostgreSQL è pronto per Django. Ora puoi procedere al passaggio successivo.
Crea un ambiente virtuale Python
Successivamente, dovrai creare un ambiente virtuale Python per creare un progetto Django.
Innanzitutto, aggiorna il pacchetto PIP all'ultima versione utilizzando il comando seguente:
pip3 install --upgrade pip
Successivamente, verifica la versione PIP utilizzando il comando seguente:
pip --version
Esempio di output:
pip 21.2.4 from /usr/local/lib/python3.9/dist-packages/pip (python 3.9)
Quindi, installa il pacchetto dell'ambiente virtuale usando il seguente comando:
pip3 install virtualenv
Quindi, crea una directory per il progetto Django e crea un ambiente virtuale Django:
mkdir ~/djangoapp
cd ~/djangoapp
virtualenv djangoenv
Successivamente, attiva l'ambiente virtuale Django utilizzando il comando seguente:
source djangoenv/bin/activate
Quindi, installa Django, Gunicorn e altri pacchetti usando il seguente comando:
pip install django gunicorn psycopg2-binary
A questo punto, Django è installato nell'ambiente virtuale Python. Ora puoi procedere al passaggio successivo.
Installa e configura Django
Django fornisce un django-admin.py script per creare un progetto. Puoi eseguire il seguente comando per creare un progetto Django:
django-admin.py startproject djangoapp ~/djangoapp
Successivamente, dovrai modificare settings.py e definire le impostazioni del database:
nano ~/djangoapp/djangoapp/settings.py
Modifica la seguente riga con il tuo nome di dominio:
ALLOWED_HOSTS = ['django.example.com', 'localhost']
Decommenta il backend del database predefinito e aggiungi le impostazioni del database PostgreSQL:
#DATABASES = {
# 'default': {
# 'ENGINE': 'django.db.backends.sqlite3',
# 'NAME': BASE_DIR / 'db.sqlite3',
# }
#}
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'django',
'USER': 'django',
'PASSWORD': 'password',
'HOST': 'localhost',
'PORT': '',
}
}
Aggiungi le seguenti righe alla fine del file:
STATIC_URL = '/static/' import os STATIC_ROOT = os.path.join(BASE_DIR, 'static/')
Salva e chiudi il file, quindi migra lo schema del database iniziale nel database PostgreSQL:
./manage.py makemigrations
./manage.py migrate
Esempio di outputL:
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
Quindi, crea un account superutente per Django con il seguente comando:
./manage.py createsuperuser
Imposta il nome utente e la password dell'amministratore come mostrato di seguito:
Username (leave blank to use 'root'): dadmin Email address: [email protected] Password: Password (again): Superuser created successfully.
Quindi, raccogli tutto il contenuto statico nella directory:
./manage.py collectstatic
Esegui Django Development Server
A questo punto, Django è installato e configurato. Ora puoi avviare il server di sviluppo Django usando il seguente comando:
./manage.py runserver 0.0.0.0:8000
Se tutto va bene, dovresti ottenere il seguente output:
Watching for file changes with StatReloader Performing system checks... System check identified no issues (0 silenced). August 27, 2021 - 10:02:05 Django version 3.2.6, using settings 'djangoapp.settings' Starting development server at http://0.0.0.0:8000/ Quit the server with CONTROL-C.
Ora apri il tuo browser web e accedi al tuo progetto Django utilizzando l'URL http://django.example.com:8000/admin/ . Verrai reindirizzato alla pagina di accesso di Django:
Fornisci il nome utente e la password dell'amministratore e fai clic su Accedi . Dovresti vedere la dashboard di Django nella pagina seguente:
Ora torna al tuo terminale e premi CTRL + C per fermare il server di sviluppo Django.
Verifica Django con Gunicorn
Successivamente, dovrai anche verificare se il Gunicorn può servire o meno il Django. Puoi avviare Django usando il server Gunicorn con il seguente comando:
gunicorn --bind 0.0.0.0:8000 djangoapp.wsgi
Se tutto va bene, dovresti ottenere il seguente output:
[2021-08-27 10:04:22 +0000] [47383] [INFO] Starting gunicorn 20.1.0 [2021-08-27 10:04:22 +0000] [47383] [INFO] Listening at: http://0.0.0.0:8000 (47383) [2021-08-27 10:04:22 +0000] [47383] [INFO] Using worker: sync [2021-08-27 10:04:22 +0000] [47384] [INFO] Booting worker with pid: 47384
Premi CTRL + C per fermare il server Gunicorn.
Successivamente, disattiva dall'ambiente virtuale Python con il seguente comando:
deactivate
Crea un file di servizio Systemd per Gunicorn
Successivamente, dovrai creare un file di servizio systemd affinché Gunicorn avvii e arresti il server delle applicazioni Django.
Puoi creare un Gunicorn con il seguente comando:
nano /etc/systemd/system/gunicorn.socket
Aggiungi le seguenti righe:
[Unit] Description=gunicorn socket [Socket] ListenStream=/run/gunicorn.sock [Install] WantedBy=sockets.target
Salva e chiudi il file, quindi crea un file di servizio per Gunicorn:
nano /etc/systemd/system/gunicorn.service
Aggiungi le seguenti righe che corrispondono al percorso del tuo progetto Django:
[Unit] Description=gunicorn daemon Requires=gunicorn.socket After=network.target [Service] User=root Group=www-data WorkingDirectory=/root/djangoapp ExecStart=/root/djangoapp/djangoenv/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock djangoapp.wsgi:application [Install] WantedBy=multi-user.target
Salva e chiudi il file, quindi imposta le autorizzazioni appropriate per la directory del progetto Django:
chown -R www-data:root ~/djangoapp
Quindi, ricarica il demone systemd con il seguente comando:
systemctl daemon-reload
Quindi, avvia il servizio Gunicorn e abilitalo per l'avvio al riavvio del sistema:
systemctl start gunicorn.socket
systemctl enable gunicorn.socket
Quindi, controlla lo stato del Gunicorn usando il comando seguente:
systemctl status gunicorn.socket
Dovresti ottenere il seguente output:
? gunicorn.socket - gunicorn socket
Loaded: loaded (/etc/systemd/system/gunicorn.socket; disabled; vendor preset: enabled)
Active: active (listening) since Fri 2021-08-27 10:05:46 UTC; 6s ago
Triggers: ? gunicorn.service
Listen: /run/gunicorn.sock (Stream)
CGroup: /system.slice/gunicorn.socket
Aug 27 10:05:46 debian11 systemd[1]: Listening on gunicorn socket.
Configura Nginx come proxy inverso per Django
Successivamente, dovrai configurare Nginx come proxy inverso per servire Django.
Per farlo, crea un file di configurazione Nginx:
nano /etc/nginx/conf.d/django.conf
Aggiungi le seguenti righe:
server {
listen 80;
server_name django.example.com;
location = /favicon.ico { access_log off; log_not_found off; }
location /static/ {
root /root/djangoapp;
}
location / {
include proxy_params;
proxy_pass http://unix:/run/gunicorn.sock;
}
}
Salva e chiudi il file, quindi verifica Nginx per eventuali errori di configurazione:
nginx -t
Output:
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok nginx: configuration file /etc/nginx/nginx.conf test is successful
Infine, riavvia il servizio Nginx per applicare le modifiche:
systemctl restart nginx
Per controllare lo stato di Nginx, esegui:
systemctl status nginx
Esempio di output:
? nginx.service - A high performance web server and a reverse proxy server
Loaded: loaded (/lib/systemd/system/nginx.service; enabled; vendor preset: enabled)
Active: active (running) since Fri 2021-08-27 10:06:59 UTC; 6s ago
Docs: man:nginx(8)
Process: 47494 ExecStartPre=/usr/sbin/nginx -t -q -g daemon on; master_process on; (code=exited, status=0/SUCCESS)
Process: 47495 ExecStart=/usr/sbin/nginx -g daemon on; master_process on; (code=exited, status=0/SUCCESS)
Main PID: 47496 (nginx)
Tasks: 2 (limit: 2341)
Memory: 2.5M
CPU: 49ms
CGroup: /system.slice/nginx.service
??47496 nginx: master process /usr/sbin/nginx -g daemon on; master_process on;
??47497 nginx: worker process
Aug 27 10:06:59 debian11 systemd[1]: Starting A high performance web server and a reverse proxy server...
Aug 27 10:06:59 debian11 systemd[1]: nginx.service: Failed to parse PID from file /run/nginx.pid: Invalid argument
Aug 27 10:06:59 debian11 systemd[1]: Started A high performance web server and a reverse proxy server.
Ora puoi accedere all'applicazione Django utilizzando l'URL http://django.example.com/admin . Puoi anche accedere all'applicazione Django utilizzando l'URL http://django.example.com/ .
Conclusione
Congratulazioni! hai installato con successo un'applicazione Django con Gunicorn e Nginx come proxy inverso. Ora puoi iniziare a distribuire la tua applicazione Python utilizzando il framework Django.