Docker Gids: Dockeriseren van Python Django Applicatie

Docker is een open-source project dat een open platform biedt voor ontwikkelaars en sysadmins om overal toepassingen te bouwen, te verpakken en te draaien als een lichtgewicht container. Docker automatiseert het inzetten van toepassingen binnen softwarecontainers.

Django is een in python geschreven raamwerk voor webapplicaties dat de MVC (Model-View-Controller) architectuur volgt. Het is gratis beschikbaar en uitgebracht onder een open bron licentie. Het is snel en ontworpen om ontwikkelaars te helpen hun toepassing zo snel mogelijk online te krijgen.

In deze zelfstudie laat ik je stap-voor-stap zien hoe je een docker image kunt maken voor een bestaand Django applicatieproject in Ubuntu 16.04. We leren over het docker maken van een python Django toepassing, en zetten dan de toepassing als een container in de docker omgeving uit met een docker-compose script.

Om onze python Django toepassing te kunnen inzetten, hebben we extra docker images nodig. We hebben een nginx docker image nodig voor de webserver en een PostgreSQL image voor de databank.

Wat zullen we doen?

1. Installeer Docker-ce
2. Installeer Docker-compose
3. Configureer de projectomgeving
4. Bouwen en uitvoeren
5. Testen van

Stap 1 – Installeer Docker-ce

In deze tutorial installeren we docker-ce community editie uit de docker repository. We zullen docker-ce community editie en docker-compose installeren die compose file versie 3 ondersteunen.

Voordat je docker-ce installeert, installeer je de benodigde docker afhankelijkheden met het apt commando.

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

Voeg nu de docker sleutel en repository toe door onderstaande commando’s uit te voeren.

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"

Werk de repository bij en installeer docker-ce.

sudo apt update
sudo apt install -y docker-ce

Nadat de installatie voltooid is, start je de docker service en schakel je hem in om telkens bij het opstarten van het systeem te starten.

systemctl start docker
systemctl enable docker

Vervolgens voegen we een nieuwe gebruiker toe met de naam ‘omar’ en voegen die toe aan de docker groep.

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

Log in als de omar gebruiker en voer het docker commando uit zoals hieronder.

su - omar
docker run hello-world

Zorg ervoor dat je de hello-world boodschap van Docker krijgt.

De installatie van Docker-ce is voltooid.

Stap 2 – Installeer Docker-compose

In deze tutorial gebruiken we de nieuwste docker-compose ondersteuning voor compose bestand versie 3. We zullen docker-compose handmatig installeren.

Download de nieuwste versie van docker-compose met het commando curl naar de map ‘/usr/local/bin’ en maak hem uitvoerbaar met chmod.

Voer onderstaande commando’s uit.

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

Controleer nu de versie van docker-compose.

docker-compose version

En zorg ervoor dat je de nieuwste versie van de docker-compose 1.21 krijgt.

De docker-compose nieuwste versie die compose file versie 3 ondersteunt is geïnstalleerd.

Stap 3 – Configureer de projectomgeving

In deze stap configureren we de omgeving van het python Django project. We maken een nieuwe directory ‘guide01’ en maken die tot hoofddirectory voor onze projectbestanden, zoals een Dockerfile, Django project, nginx configuratiebestand enz.

Meld je aan als gebruiker ‘omar’.

su - omar

Maak een nieuwe map ‘guide01’ en ga naar de map.

mkdir -p guide01
cd guide01/

Maak nu binnen de ‘guide01’ directory nieuwe directories ‘project’ en ‘config’.

mkdir project/ config/

Opmerking:

• De directory ‘project’: Al onze python Django project bestanden komen in die directory te staan.
• Directory ‘config’: Directory voor de project configuratie bestanden, waaronder nginx configuratie bestand, python pip eisen bestand enz.

Maak een nieuw requirements.txt bestand

Maak vervolgens een nieuw bestand ‘requirements.txt’ binnen de ‘config’ directory met het vim commando.

vim config/requirements.txt

Plak er de onderstaande configuratie in.

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

Bewaar en sluit af.

Maak het Nginx virtuele host bestand django.conf

Maak onder de config directory de ‘nginx’ configuratiemap en voeg het virtuele host configuratiebestand django.conf toe.

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

Plak er de volgende configuratie in.

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

Sla op en sluit af.

Maak het Dockerbestand

Maak een nieuw ‘Dockerfile’ binnen de map ‘guide01’.

Voer het onderstaande commando uit.

vim Dockerfile

Plak nu het onderstaande Dockerfile script.

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

Sla op en sluit af.

Opmerking:

We willen de Docker images voor ons Django project bouwen op basis van Alpine Linux, de kleinste maat van Linux. Ons Django project zal Alpine Linux draaien met daarop python 3.5 geïnstalleerd en het postgresql-dev pakket toevoegen voor de PostgreSQL database ondersteuning. En dan installeren we alle python pakketten die in het ‘requirements.txt’ bestand vermeld staan met python pip commando, en maken een nieuwe ‘/src’ voor ons project.

Docker-compose script maken

Maak het ‘docker-compose.yml’ bestand onder de ‘guide01’ directory met onderstaand vim commando.

vim docker-compose.yml

Plak er de volgende configuratie in.

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

Sla op en sluit af.

Opmerking:

Met dit docker-compose bestandsscript zullen we drie diensten aanmaken. Maak de databank dienst met de naam ‘db’ met behulp van de PostgreSQL alpine Linux, maak de ‘nginx’ dienst met weer de Nginx alpine Linux, en maak onze python Django container met behulp van de aangepaste docker images die uit ons Dockerfile gegenereerd worden.

Configureer Django project

Kopieer je Django project bestanden naar de ‘project’ map.

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

Ga naar de ‘project’ directory en bewerk de applicatie-instelling ‘settings.py’.

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

Opmerking:

We zullen eenvoudige Django applicatie genaamd ‘hello_django’ app inzetten.

Voeg op de regel ‘ALLOW_HOSTS’ de dienstnaam ‘web’ toe.

ALLOW_HOSTS = ['web']

Verander nu de instellingen voor de databank. We zullen de PostgreSQL databank gebruiken die draait als een dienst met de naam ‘db’ met standaard gebruiker en wachtwoord.

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

En voeg voor de ‘STATIC_ROOT’ configuratiedirectory deze regel toe aan het eind van de regel van het bestand.

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

Sla op en sluit af.

Nu zijn we klaar om het Django project onder de docker container te bouwen en te draaien.

Stap 4 – Bouw en draai het Docker image

In deze stap willen we een Docker image bouwen voor ons Django project met behulp van de configuratie op de ‘guide01’ directory.

Ga naar de ‘guide01’ map.

cd ~/guide01/

Bouw nu de docker images met het docker-compose commando.

docker-compose build

Start alle diensten binnen het docker-compose script.

docker-compose up -d

Wacht enkele minuten tot Docker ons Python image bouwt en de nginx en postgresql docker images downloadt.

En als dat klaar is, controleer dan draaiende container en lijst docker images op het systeem met de volgende commando’s.

docker-compose ps
docker-compose images

En nu krijg je drie draaiende containers en lijst van Docker images op het systeem zoals hieronder te zien is.

Onze Python Django Applicatie draait nu binnen de docker container, en docker images voor onze dienst zijn aangemaakt.

Stap 5 – Testen

Open je webbrowser en typ het serveradres met poort 8000, het mijne is:http://ovh01:8000/

Nu krijg je de standaard Django startpagina.

Test vervolgens de admin pagina door het ‘/admin’ pad aan de URL toe te voegen.

http://ovh01:8000/admin/

En je ziet de Django admin inlogpagina.

Het Dockeriseren van Python Django Applicatie is met succes voltooid.

Referentie

• https://docs.docker.com/