Guida Docker:Dockerizzazione dell'applicazione Python Django

Docker è un progetto open source che fornisce una piattaforma aperta a sviluppatori e amministratori di sistema per creare, impacchettare ed eseguire applicazioni ovunque come un contenitore leggero. Docker automatizza la distribuzione delle applicazioni all'interno di contenitori software.

Django è un framework di applicazioni web scritto in Python che segue l'architettura MVC (Model-View-Controller). È disponibile gratuitamente e rilasciato con una licenza open source. È veloce e progettato per aiutare gli sviluppatori a mettere online la loro applicazione il più rapidamente possibile.

In questo tutorial, ti mostrerò passo dopo passo come creare un'immagine docker per un progetto di applicazione Django esistente in Ubuntu 16.04. Impareremo come dockerizzare un'applicazione Django python e quindi distribuire l'applicazione come contenitore nell'ambiente docker utilizzando uno script docker-compose.

Per distribuire la nostra applicazione python Django, abbiamo bisogno di immagini docker aggiuntive. Abbiamo bisogno di un'immagine docker nginx per il server web e di un'immagine PostgreSQL per il database.

Cosa faremo?

1. Installa Docker-ce
2. Installa Docker-componi
3. Configura l'ambiente di progetto
4. Costruisci ed esegui
5. Test

Passaggio 1:installa Docker-ce

In questo tutorial, installeremo l'edizione community docker-ce dal repository docker. Installeremo docker-ce community edition e docker-compose che supportano la composizione del file versione 3.

Prima di installare docker-ce, installa le dipendenze docker necessarie usando il comando apt.

sudo apt install -y \
    apt-transport-https \
    ca-certificates \
    curl \
    software-properties-common

Ora aggiungi la chiave mobile e il repository eseguendo i comandi seguenti.

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"

Aggiorna il repository e installa docker-ce.

sudo apt update
sudo apt install -y docker-ce

Al termine dell'installazione, avvia il servizio Docker e abilitalo per l'avvio ogni volta all'avvio del sistema.

systemctl start docker
systemctl enable docker

Successivamente, aggiungeremo un nuovo utente chiamato 'omar' e lo aggiungeremo al gruppo Docker.

useradd -m -s /bin/bash omar
usermod -a -G docker omar

Accedi come utente omar ed esegui il comando docker come mostrato di seguito.

su - omar
docker run hello-world

Assicurati di ricevere il messaggio di benvenuto da Docker.

L'installazione di Docker-ce è stata completata.

Passaggio 2:installa Docker-compose

In questo tutorial, utilizzeremo l'ultimo supporto di composizione mobile per la composizione del file versione 3. Installeremo manualmente la composizione mobile.

Scarica l'ultima versione di docker-compose usando il comando curl nella directory '/usr/local/bin' e rendila eseguibile usando chmod.

Esegui i comandi seguenti.

sudo curl -L https://github.com/docker/compose/releases/download/1.21.0/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Ora controlla la versione di composizione mobile.

docker-compose version

E assicurati di avere l'ultima versione di docker-compose 1.21.

È stata installata l'ultima versione di docker-compose che supporta la versione 3 del file di composizione.

Fase 3 - Configura l'ambiente del progetto

In questo passaggio, configureremo l'ambiente del progetto python Django. Creeremo una nuova directory 'guide01' e la renderemo la directory principale per i nostri file di progetto, come un Dockerfile, un progetto Django, un file di configurazione di nginx ecc.

Accedi all'utente 'omar'.

su - omar

Crea una nuova directory 'guide01' e vai alla directory.

mkdir -p guide01
cd guide01/

Ora all'interno della directory 'guide01', crea le nuove directory 'project' e 'config'.

mkdir project/ config/

Nota:

• Directory 'progetto':tutti i nostri file di progetto Django python verranno inseriti in quella directory.
• Directory 'config':Directory per i file di configurazione del progetto, incluso il file di configurazione di nginx, il file dei requisiti di python pip ecc.

Crea un nuovo file Requirements.txt

Quindi, crea il nuovo file 'requirements.txt' all'interno della directory 'config' usando il comando vim.

vim config/requirements.txt

Incolla la configurazione qui sotto.

Django==2.0.4  
 gunicorn==19.7.0  
 psycopg2==2.7.4

Salva ed esci.

Crea il file host virtuale Nginx django.conf

Nella directory config, crea la directory di configurazione 'nginx' e aggiungi il file di configurazione dell'host virtuale django.conf.

mkdir -p config/nginx/
vim config/nginx/django.conf

Incolla lì la seguente configurazione.

upstream web {
   ip_hash;
   server web:8000;
 }
 
 # portal
 server {
   location / {
         proxy_pass http://web/;
     }
   listen 8000;
   server_name localhost;
 
   location /static {    
     autoindex on;    
     alias /src/static/;    
   }
 }

Salva ed esci.

Crea il Dockerfile

Crea un nuovo 'Dockerfile' all'interno della directory 'guide01'.

Esegui il comando seguente.

vim Dockerfile

Ora incolla lo script Dockerfile di seguito.

FROM python:3.5-alpine
 ENV PYTHONUNBUFFERED 1  
 
 RUN apk update && \
     apk add --virtual build-deps gcc python-dev musl-dev && \
     apk add postgresql-dev bash
 
 RUN mkdir /config  
 ADD /config/requirements.txt /config/  
 RUN pip install -r /config/requirements.txt
 RUN mkdir /src
 WORKDIR /src

Salva ed esci.

Nota:

Vogliamo costruire le immagini Docker per il nostro progetto Django basato su Alpine Linux, la dimensione più piccola di Linux. Il nostro progetto Django eseguirà Alpine Linux con Python 3.5 installato su di esso e aggiungerà il pacchetto postgresql-dev per il supporto del database PostgreSQL. E poi installeremo tutti i pacchetti python elencati nel file 'requirements.txt' usando il comando python pip e creeremo un nuovo '/src' per il nostro progetto.

Crea script di composizione Docker

Crea il file 'docker-compose.yml' nella directory 'guide01' usando il comando vim di seguito.

vim docker-compose.yml

Incolla lì la seguente configurazione.

version: '3'
 services:
   db:
     image: postgres:10.3-alpine
     container_name: postgres01
   nginx:
     image: nginx:1.13-alpine
     container_name: nginx01
     ports:
       - "8000:8000"
     volumes:
       - ./project:/src
       - ./config/nginx:/etc/nginx/conf.d
     depends_on:
       - web
   web:
     build: .
     container_name: django01
     command: bash -c "python manage.py makemigrations && python manage.py migrate && python manage.py collectstatic --noinput && gunicorn hello_django.wsgi -b 0.0.0.0:8000"
     depends_on:
       - db
     volumes:
       - ./project:/src
     expose:
       - "8000"
     restart: always

Salva ed esci.

Nota:

Con questo script di composizione del file docker creeremo tre servizi. Crea il servizio di database denominato 'db' utilizzando PostgreSQL alpine Linux, crea il servizio 'nginx' utilizzando nuovamente Nginx alpine Linux e crea il nostro contenitore python Django utilizzando le immagini docker personalizzate generate dal nostro Dockerfile.

Configura il progetto Django

Copia i file del tuo progetto Django nella directory 'progetto'.

cd ~/django
cp -r * ~/guide01/project/

Vai alla directory 'progetto' e modifica l'impostazione dell'applicazione 'settings.py'.

cd ~/guide01/project/
vim hello_django/settings.py

Nota:

Distribuiremo una semplice applicazione Django chiamata app 'hello_django'.

Nella riga 'ALLOW_HOSTS', aggiungi il nome del servizio 'web'.

ALLOW_HOSTS = ['web']

Ora cambia le impostazioni del database. Utilizzeremo il database PostgreSQL che viene eseguito come servizio denominato 'db' con utente e password predefiniti.

DATABASES = {  
     'default': {
         'ENGINE': 'django.db.backends.postgresql_psycopg2',
         'NAME': 'postgres',
         'USER': 'postgres',
         'HOST': 'db',
         'PORT': 5432,
     }
 }

E per la directory di configurazione 'STATIC_ROOT', aggiungi questa riga alla fine della riga del file.

STATIC_ROOT = os.path.join(BASE_DIR, 'static/')

Salva ed esci.

Ora siamo pronti per creare ed eseguire il progetto Django nel contenitore Docker.

Passaggio 4:crea ed esegui l'immagine Docker

In questo passaggio, vogliamo creare un'immagine Docker per il nostro progetto Django utilizzando la configurazione nella directory 'guide01'.

Vai alla directory 'guide01'.

cd ~/guide01/

Ora costruisci le immagini della finestra mobile usando il comando docker-compose.

docker-compose build

Avvia tutti i servizi all'interno dello script di composizione mobile.

docker-compose up -d

Attendi qualche minuto affinché Docker crei la nostra immagine Python e scarichi le immagini della finestra mobile nginx e postgresql.

E quando è completo, controlla il contenitore in esecuzione e elenca le immagini della finestra mobile sul sistema utilizzando i seguenti comandi.

docker-compose ps
docker-compose images

E ora otterrai tre contenitori in esecuzione e un elenco di immagini Docker sul sistema come mostrato di seguito.

La nostra applicazione Python Django è ora in esecuzione all'interno del contenitore docker e sono state create immagini docker per il nostro servizio.

Fase 5 - Test

Apri il tuo browser web e digita l'indirizzo del server con la porta 8000, il mio è: http://ovh01:8000/

Ora otterrai la home page predefinita di Django.

Quindi, verifica la pagina di amministrazione aggiungendo il percorso '/admin' sull'URL.

http://ovh01:8000/admin/

E vedrai la pagina di accesso dell'amministratore di Django.

L'applicazione Dockerizing Python Django è stata completata con successo.