Docker vous permet de conditionner votre application de manière à simplifier la collaboration et le déploiement. Mais si vous débutez avec Docker et que vous vous demandez comment créer un conteneur Django Docker pour votre application Web, vous allez vous régaler !
Dans ce didacticiel, vous apprendrez à devenir votre propre maître dans la création d'une image et d'un conteneur Docker pour votre application Django.
Préparez-vous et commencez à conteneuriser !
Prérequis
Ce tutoriel sera une démonstration pratique. Si vous souhaitez suivre, assurez-vous d'avoir les éléments suivants :
- Docker et Docker Compose installés.
- Une machine Linux :ce didacticiel utilise Ubuntu 20.04.3 LTS.
- Python installé :ce didacticiel utilise Python 3.8.12.
Création d'une API Django et connexion à PostgreSQL
Avant de créer un conteneur d'application Django Docker, vous avez d'abord besoin d'une application à conteneuriser. Vous allez créer une API de recette et la connecter à PostgreSQL, qui est fourni avec Django par défaut.
Mais d'abord, vous devrez installer Django et le framework Django REST sur votre machine locale. Le framework Django REST est essentiel pour créer des API dans Django.
1. Ouvrez votre terminal et exécutez le pip commande ci-dessous pour installer django et djangorestframework sur votre ordinateur local.
pip install django djangorestframework2. Ensuite, exécutez les commandes suivantes pour créer un répertoire nommé ~/django_recipe_api et naviguer dans ce répertoire. Ce répertoire contiendra tous les fichiers nécessaires à ce projet.
mkdir ~/django_recipe_api
cd ~/django_recipe_api
3. Exécutez les commandes suivantes pour créer un nouveau projet Django (recipe_api ) et une application (recipe ) dans le répertoire actuel où l'API vivra.
# 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. Ouvrez maintenant le ~/django_recipe_api/recipe_api/settings.py fichier dans votre éditeur de texte préféré et ajoutez le code suivant.
Le code ci-dessous ajoute le rest_framework à l'application (recette) que vous avez créée précédemment (étape 3).
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. Ouvrez le ~/django_recipe_api/recipe/models.py fichier et collez le code ci-dessous.
Le code ci-dessous initie les champs et le type de données que vous stockerez dans la base de données.
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. Créez un autre fichier nommé ~/django_recipe_api/recipe/serializers.py et remplissez le fichier avec le code ci-dessous.
Le code ci-dessous crée un sérialiseur pour le modèle que vous avez créé précédemment (étape cinq). Le sérialiseur aide à convertir les données de l'API en un formulaire, comme JSON, qui peut être utilisé dans le frontend.
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. Créez maintenant un fichier nommé ~/django_recipe_api/recipe/views.py et collez le code ci-dessous.
Le code ci-dessous crée un ensemble de vues pour renvoyer les données de l'API à l'interface et gérer les requêtes GET des utilisateurs.
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. Enfin, ouvrez le fichier dans le chemin ~/django_recipe_api/recipe_api/urls.py et remplacez le code dans le fichier par le code ci-dessous.
Dans le code ci-dessous, vous configurez les URL afin que Django REST Framework puisse se connecter correctement à votre application. Vous indiquez également la route à utiliser lors de l'accès à l'API sur un navigateur.
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
]Création d'un Dockerfile pour construire l'API Django
Actuellement, vous n'avez qu'une API Django qui n'est en aucun cas conteneurisée. La conteneurisation de votre application facilite la collaboration et le déploiement si nécessaire.
Créez un fichier appelé Dockerfile à la racine de votre projet et remplissez le fichier avec le code ci-dessous. Un Dockerfile contient une liste d'instructions que Docker utilise pour créer votre image Docker.
Le code ci-dessous crée un répertoire dans votre conteneur et copie le code de votre machine locale dans le conteneur.
# 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 userMaintenant, créez le requirements.txt fichier à la racine de votre projet et saisissez le texte ci-dessous.
Vous trouverez ci-dessous une liste des dépendances nécessaires pour exécuter votre projet.
django==3.1.2
djangorestframework==3.13.1
Création d'un fichier Docker Compose pour exécuter Django et PostgreSQL
Vous venez de créer l'image Docker de votre application, mais comment l'exécutez-vous ? Docker-compose est un outil utilisé pour exécuter des images Docker à partir de machines locales. Docker-compose vous aide à gérer divers services dans votre application, tels que Django et les bases de données.
1. Créez un fichier appelé docker-compose.yml à la racine de votre projet et collez le code ci-dessous.
Le code ci-dessous mappe le port de votre machine locale au port de votre image et exécute votre application.
# 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. Ensuite, ouvrez votre settings.py fichier et ajoutez 0.0.0.0 comme valeur de ALLOWED_HOSTS puisque Docker s'exécute sur l'hôte (0.0.0.0). Le ALLOWS_HOSTS La variable contient une liste de domaines/hôtes pouvant accéder à votre application.
ALLOWED_HOSTS = ['0.0.0.0']3. Exécutez les commandes suivantes pour générer une base de données pour votre modèle d'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. Maintenant, exécutez chaque commande ci-dessous pour créer et exécuter votre conteneur Django.
sudo docker-compose build # Build your Service
sudo docker-compose up # Runs your application5. Enfin, ouvrez votre navigateur Web préféré et accédez à http://0.0.0.0:8000/recipe/ pour exécuter votre API.
Comme vous le voyez ci-dessous, votre API fonctionne parfaitement, ce qui vous permet d'ajouter des recettes.
Configuration de PostgreSQL sur W Travaillez avec Docker et Django
Vous travaillez actuellement avec SQLite en tant que base de données, ce qui n'est pas idéal lorsque vous souhaitez faire évoluer votre application. Une meilleure option qui se connecte bien à Django est PostgreSQL, que vous ajouterez à votre application.
Pour configurer PostgreSQL pour qu'il fonctionne avec Docker et Django :
1. Ouvrez votre Dockerfile et ajoutez le code ci-dessous au-dessus de RUN pip install -r /requirements.txt doubler. Ces dépendances sont nécessaires pour que PostgreSQL fonctionne correctement avec 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. Ensuite, ouvrez le requirements.txt fichier et ajoutez le psycopg2==2.8.6 exigence.
3. Réexécutez la commande ci-dessous pour reconstruire l'image.
docker-compose build
4. Ouvrez votre settings.py fichier, et remplacez les DATABASES bloquer avec le code suivant.
Le code ci-dessous met à jour votre base de données dans Django pour utiliser PostgreSQL.
Le os module est utilisé dans le code ci-dessous, vous devez donc ajouter import os en haut de votre ~/django_recipe_api/recipe_api/settings.py contenu du fichier.
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. Ouvrez le fichier docker-compose.yml fichier et remplacez le contenu du fichier par le code ci-dessous.
Le code ci-dessous crée un service pour la base de données que vous avez créée (étape quatre) et transmet les informations d'identification de la base de données à 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. Exécutez les commandes suivantes pour appliquer les migrations pour la nouvelle base de données que vous avez créée (étape cinq).
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. Maintenant, exécutez la commande suivante pour exécuter votre application Django dans le conteneur Docker.
sudo docker-compose up
8. Enfin, accédez à nouveau à http://0.0.0.0:8000/recipe/ sur votre navigateur.
Comme vous le voyez ci-dessous, les données précédemment enregistrées ne sont plus là depuis que vous avez changé votre base de données. Vous pouvez maintenant continuer et ajouter plus de données si vous le souhaitez.
Conclusion
Dans ce didacticiel, vous avez appris à configurer un conteneur Docker pour l'API Django qui utilise PostgreSQL pour stocker les données. Vous êtes également passé par le lancement de conteneurs Django à l'aide de Dockerfile et docker-compose.yml fichiers.
À ce stade, vous maîtrisez déjà les bases de l'exécution d'applications dans un conteneur Docker. Alors, quelles autres applications à exécuter dans le conteneur Docker avez-vous en tête ? Peut-être un conteneur Docker pour le conteneur Django et MongoDB ?