Webbplatssökning

Hur man dockeriserar en Django-applikation på Linux

I den här guiden kommer jag att visa dig hur du ställer in en Docker-miljö för ditt Django-projekt när det fortfarande är i utvecklingsfasen. Även om jag använder Ubuntu 18.04, är stegen desamma oavsett vilken Linux-distribution du använder, med undantag för installationen av Docker och docker-compose.

I ett vanligt mjukvaruutvecklingsprojekt har vi vanligtvis en utvecklingsprocess som oftast börjar från utvecklarens miljö till VCS och sedan till produktion. Vi kommer att försöka följa reglerna så att du förstår var varje DevOps-verktyg kommer in.

DevOps handlar helt om att eliminera det gamla uttrycket; „Men det fungerar på min laptop!“. Docker-containerisering skapar produktionsmiljön för din applikation så att den kan distribueras var som helst, utveckla en gång, distribuera var som helst!

1) Installera Docker Engine

Du behöver ha en Docker-runtime installerad på din server/dator. Våra installationsguider för Docker bör vara till stor hjälp.

Hur man installerar Docker på CentOS/Debian/Ubuntu

2) Miljöinställning

Jag har skapat ett GitHub-repo för det här projektet som heter django-docker-dev-app. Känn dig fri att fork:a det eller klona/ladda ner det.

Först, skapa mappen för att hålla ditt projekt. Min arbetsmapp heter django-docker-dev-app. Gå in i mappen och öppna den sedan i din IDE.

Dockerfil

I en containeriserad miljö lever alla applikationer i en container. Själva containrarna består av flera bilder. Du kan skapa din egen bild eller använda andra bilder från Docker Hub. En Dockerfile är ett Docker-textdokument som Docker läser för att automatiskt skapa/bygga en bild. Vår Dockerfile kommer att lista alla beroenden som krävs av vårt projekt.

Skapa en fil med namnet Dockerfile.

nano Dockerfile

Skriv följande i filen:

#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

Skapa filen requirements.txt och lägg till ditt projekts krav.

Django
djangorestframework

Skapa mappen app som kommer att hålla källkoden. Nu är vi redo att bygga vår bild!

mkdir app

Öppna en terminal i ditt projekt och skriv följande kommando för att bygga vår bild:

 docker build .

I slutet säger det till Docker att leta efter Dockerfile i samma katalog. Om du hade filen på en annan plats skulle vi ha skrivit sökvägen till den filen. Docker kommer sedan att hämta de nödvändiga bilderna från Docker Hub för att skapa din bild.

Använda Docker Compose

Från Docker-dokumentation; Compose är ett verktyg för att definiera och köra multi-container Docker-applikationer. Med Compose använder du en YAML-fil för att konfigurera din applikations tjänster. Sedan, med ett enda kommando, skapar och startar du alla tjänster från din konfiguration.

  • Installera Docker Compose på Linux

Eftersom vårt projekt kommer att kräva många tjänster i framtiden är det bättre att skapa en miljö med flera containrar för det. Till exempel kan vi behöva en container för att hosta vårt frontend, en annan för att hosta en databas och ytterligare en för att hosta backend när vi övergår till en mikrotjänstarkitektur. Vi kommer att skapa en docker-compose-fil som definierar de olika tjänster och containrar som vårt projekt kommer att behöva.

Skapa en fil med namnet 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"

Observera YAML-filformatet!!! Vi har en tjänst som heter ddda (Django Docker Dev App).

Vi är nu redo att bygga vår tjänst:

docker-compose build

Efter en lyckad bygg ser du: Successfully tagged djangodockerdevapp_ddda:latest

Det betyder att vår bild heter djangodockerdevapp_ddda:latest och vår tjänst heter ddda

Observera nu att vi ännu inte har skapat vårt Django-projekt! Om du har följt ovanstående procedur framgångsrikt, grattis, du har ställt in Docker-miljön för ditt projekt! Nästa steg är att börja din utveckling genom att göra följande:

Skapa Django-projektet:

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

För att köra din behållare:

docker-compose up

Besök sedan http://localhost:8000/

Skapa migrationer

$ docker-compose exec ddda python manage.py migrate

Från och med nu kommer du att köra Django-kommandon som kommandot ovan, genom att lägga till ditt kommando efter servicens namn ddda.

Det var allt för nu. Jag vet att det är enkelt och att det finns många funktioner vi inte har gått igenom, som en databas, men detta är en början!

Projektet finns på GitHub här.

Mer om Docker:

  • Exportera och importera Docker-bilder/behållare
  • Installera Harbor Docker Image Registry på CentOS/Debian/Ubuntu
  • Hur man kör lokala Kubernetes-kluster i Docker