Jak vytvořit kontejner aplikace Django Docker

Docker vám umožňuje zabalit vaši aplikaci způsobem, který zjednoduší spolupráci a nasazení. Ale pokud jste v Dockeru noví a přemýšlíte, jak vytvořit kontejner Django Docker pro vaši webovou aplikaci, máte se na co těšit!

V tomto tutoriálu se naučíte, jak se stát svým vlastním mistrem ve vytváření image a kontejneru Dockeru pro vaši aplikaci Django.

Připravte se a začněte kontejnerizovat!

Předpoklady

Tento tutoriál bude praktickou ukázkou. Pokud je chcete sledovat, ujistěte se, že máte následující:

• Docker a Docker Compose jsou nainstalovány.

• Počítač se systémem Linux – Tento výukový program používá Ubuntu 20.04.3 LTS.

• Nainstalovaný Python – Tento výukový program používá Python 3.8.12.

Vytvoření Django API a připojení k PostgreSQL

Před vytvořením kontejneru aplikace Django Docker nejprve potřebujete aplikaci ke kontejnerizaci. Vytvoříte si API receptur a připojíte ho k PostgreSQL, který je standardně dodáván s Django.

Nejprve však budete muset nainstalovat Django a Django REST framework na místní počítač. Rámec Django REST je nezbytný pro vytváření rozhraní API v Django.

1. Otevřete svůj terminál a spusťte pip příkaz níže k instalaci django a djangorestframework na vašem místním počítači.

pip install django djangorestframework

2. Dále spusťte následující příkazy a vytvořte adresář s názvem ~/django_recipe_api a přejděte do tohoto adresáře. Tento adresář bude obsahovat všechny soubory požadované pro tento projekt.

mkdir ~/django_recipe_api
cd ~/django_recipe_api

3. Spuštěním následujících příkazů vytvořte nový projekt Django (recipe_api ) a aplikaci (recipe ) v aktuálním adresáři, kde bude rozhraní API sídlit.

# Create a new Django project named "recipe_api" in the current directory.
django-admin startproject recipe_api .
# Create an app named "recipe" in the current directory where the API will live.
python manage.py startapp recipe

4. Nyní otevřete ~/django_recipe_api/recipe_api/settings.py soubor ve vašem preferovaném textovém editoru a přidejte následující kód.

Níže uvedený kód přidá rest_framework do aplikace (receptu), kterou jste dříve vytvořili (krok tři).

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
		'rest_framework' # for Django REST Framework to work
    'recipe', # newly created app
]

5. Otevřete ~/django_recipe_api/recipe/models.py soubor a vložte níže uvedený kód.

Níže uvedený kód inicializuje pole a druh dat, která budete ukládat do databáze.

from django.db import models

class Recipe(models.Model):
    """Recipe object"""
    title = models.CharField(max_length=255)
    time_minutes = models.IntegerField()
    ingredients = models.CharField(max_length=255)
   # display an instance of the model when necessary
    def __str__(self):
        return self.title

6. Vytvořte další soubor s názvem ~/django_recipe_api/recipe/serializers.py a naplňte soubor níže uvedeným kódem.

Níže uvedený kód vytvoří serializátor pro model, který jste dříve vytvořili (krok 5). Serializátor pomáhá převádět data z API do formy, jako je JSON, kterou lze použít v rozhraní.

from dataclasses import fields
from rest_framework import serializers
from .models import Recipe
 
# create a serializer
class RecipeSerializer(serializers.Serializer):
    # initialize model and fields you want to serialize
    class Meta:
        model = Recipe
        fields = ('title', 'time_minutes', 'ingredients')

7. Nyní vytvořte soubor s názvem ~/django_recipe_api/recipe/views.py a vložte kód níže.

Níže uvedený kód vytvoří sadu zobrazení, která vrátí data z rozhraní API do frontendu a zpracuje požadavky GET od uživatelů.

from rest_framework import viewsets
from .serializers import RecipeSerializer #impor the serializer we just created
from .models import Recipe
 

class recipe_view_set(viewsets.ModelViewSet):
    # define queryset
    queryset = Recipe.objects.all()
    serializer_class = RecipeSerializer

8. Nakonec otevřete soubor v cestě ~/django_recipe_api/recipe_api/urls.py a nahraďte kód v souboru níže uvedeným kódem.

V níže uvedeném kódu nastavujete adresy URL, aby se Django REST Framework mohl správně připojit k vaší aplikaci. Uvádíte také cestu, která se má použít při přístupu k rozhraní API v prohlížeči.

from django.contrib import admin
from django.urls import path, include
from recipe.views import recipe_view_set
from rest_framework import routers

# define the router
router = routers.DefaultRouter()
router.register(r'recipe', recipe_view_set) #the route tha will be used to access your API on the browser

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include(router.urls)),
    path('api-auth/', include('rest_framework.urls')) # Adds 'Login' link in the top right of the page

]

Vytvoření souboru Dockerfile pro sestavení Django API

V současné době máte pouze Django API, které není žádným způsobem kontejnerizováno. Kontejnerování vaší aplikace usnadňuje spolupráci a nasazení v případě potřeby.

Vytvořte soubor s názvem Dockerfile v kořenovém adresáři vašeho projektu a naplňte soubor níže uvedeným kódem. Dockerfile obsahuje seznam pokynů, které Docker používá k vytvoření vašeho obrazu Docker.

Níže uvedený kód vytvoří adresář ve vašem kontejneru a zkopíruje kód z vašeho místního počítače do kontejneru.

# The image you are going to inherit your Dockerfile from
FROM python:3.7-alpine
# Necessary, so Docker doesn't buffer the output and that you can see the output 
# of your application (e.g., Django logs) in real-time.
ENV PYTHONUNBUFFERED 1
# Make a directory in your Docker image, which you can use to store your source code
RUN mkdir /django_recipe_api
# Set the /django_recipe_api directory as the working directory
WORKDIR /django_recipe_api
# Copies from your local machine's current directory to the django_recipe_api folder 
# in the Docker image
COPY . .
# Copy the requirements.txt file adjacent to the Dockerfile 
# to your Docker image
COPY ./requirements.txt /requirements.txt
# Install the requirements.txt file in Docker image
RUN pip install -r /requirements.txt
# Create a user that can run your container
RUN adduser -D user
USER user

Nyní vytvořte requirements.txt soubor v kořenovém adresáři vašeho projektu a zadejte text níže.

Níže je uveden seznam závislostí potřebných ke spuštění vašeho projektu.

django==3.1.2
djangorestframework==3.13.1

Vytvoření souboru Docker Compose pro spuštění Django a PostgreSQL

Právě jste vytvořili obrázek Docker vaší aplikace, ale jak jej spustit? Docker-compose je nástroj používaný ke spouštění obrazů Dockeru z místních počítačů. Docker-compose vám pomáhá spravovat různé služby ve vaší aplikaci, jako je Django a databáze.

1. Vytvořte soubor s názvem docker-compose.yml v kořenovém adresáři vašeho projektu a vložte níže uvedený kód.

Níže uvedený kód mapuje port z vašeho místního počítače na port vašeho obrázku a spustí vaši aplikaci.

# Verion of docker-compose to use 
version: "3"

services:
  django_recipe_api:
    build:
      context: . #Sets the directory for docker-compose to build.

    # Maps port on the local machine to port on Docker image
    ports:
      - "8000:8000"
      
    volumes: 
    # Copy changes made to the project to your image in real-time.
      - .:/django_recipe_api
    # Handles the command used to run the project in the Docker container.
    command: sh -c "python manage.py runserver 0.0.0.0:8000" 

2. Dále otevřete soubor settings.py soubor a přidejte 0.0.0.0 jako hodnotu ALLOWED_HOSTS protože Docker běží na hostiteli (0.0.0.0). ALLOWS_HOSTS proměnná obsahuje seznam domén/hostitelů, kteří mají přístup k vaší aplikaci.

ALLOWED_HOSTS = ['0.0.0.0']

3. Spuštěním následujících příkazů vygenerujte databázi pro váš model API.

# Generates the SQL code for yuou models.
sudo docker-compose run django_recipe_api sh -c "python manage.py makemigrations" 
# Runs the SQL commands that you generated.
sudo docker-compose run django_recipe_api sh -c "python manage.py migrate" 

4. Nyní spusťte každý níže uvedený příkaz k vytvoření a spuštění vašeho kontejneru Django.

sudo docker-compose build # Build your Service
sudo docker-compose up # Runs your application

5. Nakonec otevřete preferovaný webový prohlížeč a přejděte na http://0.0.0.0:8000/recipe/, kde spustíte své API.

Jak vidíte níže, vaše API funguje perfektně, což vám umožňuje přidávat recepty.

Konfigurace PostgreSQL na W ork s Dockerem a Django

V tuto chvíli pracujete s SQLite jako s databází, což není ideální, když chcete škálovat svou aplikaci. Lepší možností, která se dobře spojí s Django, je PostgreSQL, kterou přidáte do své aplikace.

Konfigurace PostgreSQL pro práci s Dockerem a Django:

1. Otevřete svůj Dockerfile a přidejte níže uvedený kód nad RUN pip install -r /requirements.txt čára. Tyto závislosti jsou vyžadovány, aby PostgreSQL správně fungoval s Django.

RUN apk add --update postgresql-client jpeg-dev
RUN apk add --update --virtual .tmp-build-deps \
      gcc libc-dev linux-headers postgresql-dev musl-dev zlib zlib-dev

2. Dále otevřete soubor requirements.txt a přidejte psycopg2==2.8.6 požadavek.

3. Znovu spusťte níže uvedený příkaz a vytvořte obraz znovu.

docker-compose build

4. Otevřete soubor settings.py a nahraďte DATABASES blok s následujícím kódem.

Níže uvedený kód aktualizuje vaši databázi v Django, aby používala PostgreSQL.

os Modul se používá v kódu níže, takže musíte přidat import os v horní části vašeho ~/django_recipe_api/recipe_api/settings.py obsah souboru.

DATABASES = {
  'default': {
    'ENGINE': 'django.db.backends.postgresql',
    'HOST': os.environ.get('DB_HOST'),
    'NAME': os.environ.get('DB_NAME'),
    'USER': os.environ.get('DB_USER'),
    'PASSWORD': os.environ.get('DB_PASS'),
  }
}

5. Otevřete soubor docker-compose.yml soubor a nahraďte obsah souboru níže uvedeným kódem.

Níže uvedený kód vytvoří službu pro databázi, kterou jste vytvořili (krok čtyři), a předá přihlašovací údaje k databázi Django.

# Verion of docker-compose to use 
version: "3"

services:
  django_recipe_api:
    build:
      context: . # Sets the directory for docker-compose to build.

    # Maps port on the local machine to port on Docker image
    ports:
      - "8000:8000"
      
    volumes: 
    # Copy changes made to the project to your image in real-time.
      - .:/django_recipe_api
    # Handles the command used to run the project in the Docker container.  
    command: sh -c "python manage.py runserver 0.0.0.0:8000" 
    
    environment:
			# The environment variable credetials that is needed 
      # in the settings for Postgres.
      - DB_HOST=db
      - DB_NAME=recipe
      - DB_USER=postgres
      - DB_PASS=supersecretpassword
    depends_on:
      - db

  db:
    image: postgres:10-alpine
    environment:
			# credentials required by postgres:10-alpine
      - POSTGRES_DB=recipe
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=supersecretpassword

6. Spuštěním následujících příkazů použijte migraci pro novou databázi, kterou jste vytvořili (krok 5).

sudo docker-compose build
sudo docker-compose run django_recipe_api sh -c "python manage.py makemigrations"
sudo docker-compose run django_recipe_api sh -c "python manage.py migrate"

7. Nyní spusťte následující příkaz ke spuštění aplikace Django v kontejneru Docker.

sudo docker-compose up

8. Nakonec znovu přejděte v prohlížeči na adresu http://0.0.0.0:8000/recipe/.

Jak vidíte níže, dříve uložená data zde již nejsou, protože jste svou databázi změnili. Nyní můžete pokračovat a přidat další data, pokud chcete.

Závěr

V tomto tutoriálu jste se naučili nastavit Docker kontejner pro Django API, který používá PostgreSQL pro ukládání dat. Také jste prošli spouštěním kontejnerů Django pomocí Dockerfile a docker-compose.yml soubory.

V tuto chvíli jste již zvládli základy spouštění aplikací v kontejneru Docker. Jaké další aplikace spustit v kontejneru Docker máte tedy na mysli? Možná kontejner Docker pro kontejner Django a MongoDB?