Zoeken op website

Hoe een Django-applicatie op Linux te dockerizen

In deze tutorial laat ik je zien hoe je een Docker-omgeving opzet voor je Django-project terwijl je nog in de ontwikkelingsfase zit. Hoewel ik Ubuntu 18.04 gebruik, blijven de stappen hetzelfde voor welke Linux-distributie je ook gebruikt, met uitzondering van de installatie van Docker en docker-compose.

In een typisch softwareontwikkelingsproject hebben we meestal een ontwikkelingsproces dat gewoonlijk begint bij het ontwikkelaarsvoorstel tot versiebeheersysteem (VCS) en vervolgens naar productie. We zullen proberen ons aan de regels te houden zodat je begrijpt waar elk DevOps-hulpmiddel inkomt.

DevOps gaat erom de uitdrukking van vroeger te elimineren: "Maar het werkt op mijn laptop!". Docker-containerisatie creëert de productieomgeving voor je applicatie, zodat deze overal kan worden ingezet. Ontwikkel één keer, zet overal in!

1) Installeer Docker Engine

Je hebt een Docker-runtime-engine op je server/desktop nodig. Onze Docker-installatiegidsen zouden je goed moeten helpen.

Hoe Docker te installeren op CentOS/Debian/Ubuntu

2) Omgevingsconfiguratie

Ik heb een GitHub-repository opgezet voor dit project genaamd django-docker-dev-app. Voel je vrij om het te forken of te klonen/downloaden.

Maak eerst de map aan om je project in te bewaren. Mijn werkmap heet django-docker-dev-app. Ga naar de map en open deze vervolgens in je IDE.

Dockerbestand

In een gecontaineriseerde omgeving leven alle applicaties in een container. Containers zelf bestaan uit meerdere images. Je kunt je eigen image maken of andere images van Docker Hub gebruiken. Een Dockerfile is een Docker-tekstdocument dat Docker leest om automatisch een image te maken/bouwen. Onze Dockerfile zal alle afhankelijkheden vermelden die ons project nodig heeft.

Maak een bestand genaamd Dockerfile.

nano Dockerfile

Typ het volgende in het bestand:

#base image
FROM python:3.9-alpine

#maintainer
LABEL Author="CodeGenes"

# The enviroment variable ensures that the python output is set straight
# to the terminal with out buffering it first
ENV PYTHONBUFFERED 1

#copy requirements file to image 
COPY ./requirements.txt /requirements.txt

#let pip install required packages
RUN pip install -r requirements.txt

#directory to store app source code
RUN mkdir /app

#switch to /app directory so that everything runs from here
WORKDIR /app

#copy the app code to image working directory
COPY ./app /app

#create user to run the app(it is not recommended to use root)
#we create user called user with -D -> meaning no need for home directory
RUN adduser -D user

#switch from root to user to run our app
USER user

Maak het requirements.txt-bestand aan en voeg de vereisten van je project toe.

Django
djangorestframework

Maak de app-map aan die de broncode zal bevatten. Nu zijn we klaar om onze image te bouwen!

mkdir app

Open een terminal in je project en typ het volgende commando om onze image te bouwen:

 docker build .

Aan het einde vertelt het Docker om te controleren op een Dockerfile in dezelfde map. Als je het bestand op een andere locatie had, zouden we het pad naar dat bestand hebben geschreven. Docker zal dan de benodigde afbeeldingen van Docker Hub ophalen om je afbeelding te maken.

Docker Compose gebruiken

Uit de Docker-documentatie; Compose is een hulpmiddel om multi-container Docker-toepassingen te definiëren en uit te voeren. Met Compose gebruik je een YAML-bestand om de services van je toepassing te configureren. Vervolgens kun je met één commando alle services uit je configuratie creëren en starten.

  • Installeer Docker Compose op Linux

Omdat ons project in de toekomst veel services zal vereisen, is het beter om een multi-containeromgeving ervoor te creëren. We hebben bijvoorbeeld mogelijk een container nodig om onze front-end te hosten, een andere om een database te hosten en weer een andere om een backend te hosten wanneer we overschakelen naar een microservices-architectuur. We zullen een docker-compose-bestand maken dat de verschillende services en containers definieert die ons project zal vereisen.

Maak een bestand met de naam docker-compose.yml

version: "3"
services:
  ddda:
    build:
      context: .
    ports:
      - "8000:8000"
    volumes:
      - ./app:/app
    command: >
      sh -c "python manage.py runserver 0.0.0.0:8000"

Let op het YAML-bestandsformaat!!! We hebben één service genaamd ddda (Django Docker Dev App).

We zijn nu klaar om onze service te bouwen:

docker-compose build

Na een succesvolle build zie je: Succesvol getagd djangodockerdevapp_ddda:latest

Het betekent dat onze image djangodockerdevapp_ddda:latest wordt genoemd en onze service ddda heet.

Merk op dat we ons Django-project nog niet hebben aangemaakt! Als je de bovenstaande procedure succesvol hebt gevolgd, gefeliciteerd, je hebt de Docker-omgeving voor je project ingesteld! Begin nu met je ontwikkeling door het volgende te doen:

Maak het Django-project aan:

 docker-compose run ddda sh -c “django-admin.py startproject app .”

Om je container uit te voeren:

docker-compose up

Bezoek dan http://localhost:8000/

Migraties uitvoeren

$ docker-compose exec ddda python manage.py migrate

Vanaf nu zul je Django-commando's uitvoeren zoals het bovenstaande commando, waarbij je je eigen commando toevoegt na de servicenaam ddda.

Dat is het voor nu. Ik weet dat het eenvoudig is en dat er veel functies zijn die we nog niet hebben behandeld, zoals een database, maar dit is een begin!

Het project is hier beschikbaar op GitHub.

Meer over Docker:

  • Docker-images/containers exporteren en importeren
  • Installeer Harbor Docker Image Registry op CentOS/Debian/Ubuntu
  • Hoe lokale Kubernetes-clusters in Docker te draaien