Docker ermöglicht es Ihnen, Ihre Anwendung so zu verpacken, dass die Zusammenarbeit und Bereitstellung vereinfacht wird. Aber wenn Sie neu bei Docker sind und sich fragen, wie Sie einen Django-Docker-Container für Ihre Webanwendung erstellen können, werden Sie sich freuen!
In diesem Tutorial lernen Sie, wie Sie Ihr eigener Meister beim Erstellen eines Docker-Images und -Containers für Ihre Django-Anwendung werden.
Machen Sie sich bereit und beginnen Sie mit der Containerisierung!
Voraussetzungen
Dieses Tutorial wird eine praktische Demonstration sein. Wenn Sie mitmachen möchten, stellen Sie sicher, dass Sie Folgendes haben:
- Docker und Docker Compose installiert.
- Ein Linux-Computer – Diese Anleitung verwendet Ubuntu 20.04.3 LTS.
- Python installiert – Dieses Tutorial verwendet Python 3.8.12.
Erstellen einer Django-API und Verbinden mit PostgreSQL
Bevor Sie einen Django-Docker-Anwendungscontainer erstellen, benötigen Sie zunächst eine Anwendung zum Containerisieren. Sie erstellen eine Rezept-API und verbinden sie mit PostgreSQL, das standardmäßig mit Django geliefert wird.
Aber zuerst müssen Sie Django und das Django-REST-Framework auf Ihrem lokalen Computer installieren. Das Django-REST-Framework ist für die Erstellung von APIs in Django unerlässlich.
1. Öffnen Sie Ihr Terminal und führen Sie pip aus Befehl unten, um django zu installieren und djangorestframework auf Ihrem lokalen Rechner.
pip install django djangorestframework2. Führen Sie als Nächstes die folgenden Befehle aus, um ein Verzeichnis namens ~/django_recipe_api zu erstellen und navigieren Sie in dieses Verzeichnis. Dieses Verzeichnis enthält alle für dieses Projekt erforderlichen Dateien.
mkdir ~/django_recipe_api
cd ~/django_recipe_api
3. Führen Sie die folgenden Befehle aus, um ein neues Django-Projekt zu erstellen (recipe_api ) und eine App (recipe ) im aktuellen Verzeichnis, in dem sich die API befinden wird.
# 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 recipe4. Öffnen Sie nun die ~/django_recipe_api/recipe_api/settings.py Datei in Ihrem bevorzugten Texteditor und fügen Sie den folgenden Code hinzu.
Der folgende Code fügt das rest_framework hinzu zu der App (Rezept), die Sie zuvor erstellt haben (Schritt drei).
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. Öffnen Sie die ~/django_recipe_api/recipe/models.py Datei und fügen Sie den folgenden Code ein.
Der folgende Code initiiert die Felder und die Art der Daten, die Sie in der Datenbank speichern.
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.title6. Erstellen Sie eine weitere Datei namens ~/django_recipe_api/recipe/serializers.py und füllen Sie die Datei mit dem folgenden Code.
Der folgende Code erstellt einen Serializer für das zuvor erstellte Modell (Schritt 5). Der Serializer hilft dabei, die Daten von der API in ein Format wie JSON umzuwandeln, das im Frontend verwendet werden kann.
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. Erstellen Sie nun eine Datei namens ~/django_recipe_api/recipe/views.py und fügen Sie den folgenden Code ein.
Der folgende Code erstellt ein Viewset, um die Daten von der API an das Frontend zurückzugeben und GET-Anforderungen von Benutzern zu verarbeiten.
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 = RecipeSerializer8. Öffnen Sie abschließend die Datei im Pfad ~/django_recipe_api/recipe_api/urls.py und ersetzen Sie den Code in der Datei durch den folgenden Code.
Im folgenden Code richten Sie die URLs ein, damit Django REST Framework ordnungsgemäß eine Verbindung zu Ihrer Anwendung herstellen kann. Sie geben auch die zu verwendende Route an, wenn Sie über einen Browser auf die API zugreifen.
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
]Erstellen einer Dockerdatei zum Erstellen der Django-API
Derzeit haben Sie nur eine Django-API, die in keiner Weise containerisiert ist. Die Containerisierung Ihrer Anwendung erleichtert bei Bedarf die Zusammenarbeit und Bereitstellung.
Erstellen Sie eine Datei namens Dockerfile im Stammverzeichnis Ihres Projekts und füllen Sie die Datei mit dem folgenden Code. Ein Dockerfile enthält eine Liste mit Anweisungen, die Docker verwendet, um Ihr Docker-Image zu erstellen.
Der folgende Code erstellt ein Verzeichnis in Ihrem Container und kopiert den Code auf Ihrem lokalen Computer in den Container.
# 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 userErstellen Sie nun die requirements.txt Datei im Stammverzeichnis Ihres Projekts und geben Sie den folgenden Text ein.
Nachfolgend finden Sie eine Liste der Abhängigkeiten, die zum Ausführen Ihres Projekts erforderlich sind.
django==3.1.2
djangorestframework==3.13.1
Erstellen einer Docker-Compose-Datei zum Ausführen von Django und PostgreSQL
Sie haben gerade das Docker-Image Ihrer Anwendung erstellt, aber wie führen Sie es aus? Docker-compose ist ein Tool zum Ausführen von Docker-Images auf lokalen Computern. Docker-compose unterstützt Sie bei der Verwaltung verschiedener Dienste in Ihrer Anwendung, z. B. Django und Datenbanken.
1. Erstellen Sie eine Datei namens docker-compose.yml im Stammverzeichnis Ihres Projekts und fügen Sie den folgenden Code ein.
Der folgende Code ordnet den Port Ihres lokalen Computers dem Port Ihres Images zu und führt Ihre Anwendung aus.
# 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. Öffnen Sie als Nächstes Ihre settings.py Datei und fügen Sie 0.0.0.0 hinzu als Wert von ALLOWED_HOSTS da Docker auf dem Host (0.0.0.0) läuft. Die ALLOWS_HOSTS Variable enthält eine Liste von Domains/Hosts, die auf Ihre Anwendung zugreifen können.
ALLOWED_HOSTS = ['0.0.0.0']3. Führen Sie die folgenden Befehle aus, um eine Datenbank für Ihr API-Modell zu generieren.
# 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. Führen Sie nun jeden der folgenden Befehle aus, um Ihren Django-Container zu erstellen und auszuführen.
sudo docker-compose build # Build your Service
sudo docker-compose up # Runs your application5. Öffnen Sie schließlich Ihren bevorzugten Webbrowser und navigieren Sie zu http://0.0.0.0:8000/recipe/, um Ihre API auszuführen.
Wie Sie unten sehen, läuft Ihre API perfekt, sodass Sie Rezepte hinzufügen können.
Konfigurieren von PostgreSQL für W Arbeiten Sie mit Docker und Django
Sie arbeiten derzeit mit SQLite als Datenbank, was nicht ideal ist, wenn Sie Ihre Anwendung skalieren möchten. Eine bessere Option, die sich gut mit Django verbindet, ist PostgreSQL, das Sie Ihrer Anwendung hinzufügen.
So konfigurieren Sie PostgreSQL für die Arbeit mit Docker und Django:
1. Öffnen Sie Ihr Dockerfile und fügen Sie den folgenden Code über RUN pip install -r /requirements.txt hinzu Linie. Diese Abhängigkeiten sind erforderlich, damit PostgreSQL ordnungsgemäß mit Django funktioniert.
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. Als nächstes öffnen Sie die requirements.txt Datei und fügen Sie psycopg2==2.8.6 hinzu Anforderung.
3. Führen Sie den folgenden Befehl erneut aus, um das Image erneut zu erstellen.
docker-compose build
4. Öffnen Sie Ihre settings.py Datei und ersetzen Sie die DATABASES mit folgendem Code blockieren.
Der folgende Code aktualisiert Ihre Datenbank in Django für die Verwendung von PostgreSQL.
Das os module wird im Code unten verwendet, also müssen Sie import os hinzufügen oben in Ihrer ~/django_recipe_api/recipe_api/settings.py Dateiinhalt.
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. Öffnen Sie die docker-compose.yml Datei und ersetzen Sie den Inhalt der Datei durch den folgenden Code.
Der folgende Code erstellt einen Dienst für die von Ihnen erstellte Datenbank (Schritt 4) und übermittelt die Datenbankanmeldeinformationen an 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=supersecretpassword6. Führen Sie die folgenden Befehle aus, um Migrationen für die neu erstellte Datenbank anzuwenden (Schritt 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. Führen Sie nun den folgenden Befehl aus, um Ihre Django-Anwendung im Docker-Container auszuführen.
sudo docker-compose up
8. Navigieren Sie schließlich in Ihrem Browser erneut zu http://0.0.0.0:8000/recipe/.
Wie Sie unten sehen, sind die zuvor gespeicherten Daten nicht mehr vorhanden, da Sie Ihre Datenbank geändert haben. Jetzt können Sie fortfahren und weitere Daten hinzufügen, wenn Sie möchten.
Schlussfolgerung
In diesem Tutorial haben Sie gelernt, einen Docker-Container für die Django-API einzurichten, der PostgreSQL zum Speichern von Daten verwendet. Sie haben auch das Starten von Django-Containern mit Dockerfile durchlaufen und docker-compose.yml Dateien.
An diesem Punkt beherrschen Sie bereits die Grundlagen zum Ausführen von Anwendungen in einem Docker-Container. Welche anderen Anwendungen, die im Docker-Container ausgeführt werden sollen, haben Sie im Sinn? Vielleicht ein Docker-Container für Django und MongoDB-Container?