Docker ti consente di impacchettare la tua applicazione in un modo che semplifica la collaborazione e la distribuzione. Ma se non conosci Docker e ti stai chiedendo come creare un container Django Docker per la tua applicazione web, sei pronto per una sorpresa!
In questo tutorial imparerai a diventare il maestro di te stesso nella creazione di un'immagine Docker e di un contenitore per la tua applicazione Django.
Preparati e inizia a containerizzare!
Prerequisiti
Questo tutorial sarà una dimostrazione pratica. Se desideri continuare, assicurati di avere quanto segue:
- Docker e Docker Compose installati.
- Una macchina Linux:questo tutorial utilizza Ubuntu 20.04.3 LTS.
- Python installato:questo tutorial utilizza Python 3.8.12.
Creazione di un'API Django e connessione a PostgreSQL
Prima di creare un contenitore di applicazioni Django Docker, è necessario innanzitutto un'applicazione per la containerizzazione. Creerai una ricetta API e la collegherai a PostgreSQL, che viene fornito con Django per impostazione predefinita.
Ma prima devi installare il framework Django e Django REST sul tuo computer locale. Il framework Django REST è essenziale per la creazione di API in Django.
1. Apri il tuo terminale ed esegui il pip comando qui sotto per installare django e djangorestframework sul tuo computer locale.
pip install django djangorestframework2. Quindi, esegui i seguenti comandi per creare una directory denominata ~/django_recipe_api e navigare in quella directory. Questa directory conterrà tutti i file necessari per questo progetto.
mkdir ~/django_recipe_api
cd ~/django_recipe_api
3. Esegui i seguenti comandi per creare un nuovo progetto Django (recipe_api ) e un'app (recipe ) nella directory corrente in cui risiederà l'API.
# 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. Ora apri ~/django_recipe_api/recipe_api/settings.py file nel tuo editor di testo preferito e aggiungi il codice seguente.
Il codice seguente aggiunge il rest_framework all'app (ricetta) che hai creato in precedenza (passaggio tre).
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. Apri ~/django_recipe_api/recipe/models.py file e incolla il codice qui sotto.
Il codice seguente avvia i campi e il tipo di dati che memorizzerai nel database.
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. Crea un altro file chiamato ~/django_recipe_api/recipe/serializers.py e compilare il file con il codice seguente.
Il codice seguente crea un serializzatore per il modello creato in precedenza (passaggio cinque). Il serializzatore aiuta a convertire i dati dall'API in un modulo, come JSON, che può essere utilizzato nel 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. Ora crea un file chiamato ~/django_recipe_api/recipe/views.py e incolla il codice qui sotto.
Il codice seguente crea un viewset per restituire i dati dall'API al frontend e gestire le richieste GET degli utenti.
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. Infine, apri il file nel percorso ~/django_recipe_api/recipe_api/urls.py e sostituisci il codice nel file con il codice qui sotto.
Nel codice seguente, stai configurando gli URL in modo che Django REST Framework possa connettersi correttamente alla tua applicazione. Indichi anche il percorso da utilizzare quando accedi all'API su un browser.
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
]Creazione di un Dockerfile per creare l'API Django
Attualmente, hai solo un'API Django che non è in alcun modo containerizzata. La creazione di contenitori per l'applicazione semplifica la collaborazione e la distribuzione, se necessario.
Crea un file chiamato Dockerfile nella radice del tuo progetto e popola il file con il codice seguente. Un File Docker contiene un elenco di istruzioni utilizzate da Docker per creare l'immagine Docker.
Il codice seguente crea una directory nel tuo container e copia il codice nel tuo computer locale nel 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 userOra crea il requirements.txt file nella radice del tuo progetto e inserisci il testo qui sotto.
Di seguito è riportato un elenco di dipendenze necessarie per eseguire il progetto.
django==3.1.2
djangorestframework==3.13.1
Creazione di un file Docker Compose per eseguire Django e PostgreSQL
Hai appena creato l'immagine Docker della tua applicazione, ma come la esegui? Docker-compose è uno strumento utilizzato per eseguire immagini Docker da macchine locali. Docker-compose ti aiuta a gestire vari servizi nella tua applicazione, come Django e database.
1. Crea un file chiamato docker-compose.yml nella radice del tuo progetto e incolla il codice qui sotto.
Il codice seguente mappa la porta dalla tua macchina locale alla porta della tua immagine ed esegue la tua applicazione.
# 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. Quindi, apri il tuo settings.py file e aggiungi 0.0.0.0 come valore di ALLOWED_HOSTS poiché Docker viene eseguito sull'host (0.0.0.0). Il ALLOWS_HOSTS la variabile contiene un elenco di domini/host che possono accedere alla tua applicazione.
ALLOWED_HOSTS = ['0.0.0.0']3. Esegui i seguenti comandi per generare un database per il tuo modello 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. Ora, esegui ogni comando seguente per creare ed eseguire il tuo contenitore Django.
sudo docker-compose build # Build your Service
sudo docker-compose up # Runs your application5. Infine, apri il tuo browser web preferito e vai a http://0.0.0.0:8000/recipe/ per eseguire la tua API.
Come vedi di seguito, la tua API funziona perfettamente, il che ti consente di aggiungere ricette.
Configurazione di PostgreSQL su W ork con Docker e Django
Al momento stai lavorando con SQLite come database, il che non è l'ideale quando vuoi ridimensionare la tua applicazione. Un'opzione migliore che si connette bene con Django è PostgreSQL, che aggiungerai alla tua applicazione.
Per configurare PostgreSQL in modo che funzioni con Docker e Django:
1. Apri il tuo Dockerfile e aggiungi il codice seguente sopra RUN pip install -r /requirements.txt linea. Queste dipendenze sono necessarie affinché PostgreSQL funzioni correttamente con 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. Quindi, apri requirements.txt file e aggiungi il psycopg2==2.8.6 requisito.
3. Eseguire nuovamente il comando seguente per creare nuovamente l'immagine.
docker-compose build
4. Apri il tuo settings.py file e sostituisci DATABASES blocco con il codice seguente.
Il codice seguente aggiorna il tuo database in Django per utilizzare PostgreSQL.
Il os module è usato nel codice qui sotto, quindi devi aggiungere import os nella parte superiore del tuo ~/django_recipe_api/recipe_api/settings.py contenuto del file.
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. Apri il docker-compose.yml file e sostituisci il contenuto del file con il codice seguente.
Il codice seguente crea un servizio per il database che hai creato (passaggio quattro) e fornisce le credenziali del database a 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. Eseguire i seguenti comandi per applicare le migrazioni per il nuovo database creato (passaggio cinque).
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. Ora esegui il seguente comando per eseguire la tua applicazione Django nel contenitore Docker.
sudo docker-compose up
8. Infine, vai nuovamente a http://0.0.0.0:8000/recipe/ sul tuo browser.
Come vedi di seguito, i dati salvati in precedenza non sono più presenti poiché hai modificato il tuo database. Ora puoi continuare e aggiungere più dati, se lo desideri.
Conclusione
In questo tutorial, hai imparato a configurare un contenitore Docker per l'API Django che utilizza PostgreSQL per l'archiviazione dei dati. Hai anche avviato i container Django utilizzando Dockerfile e docker-compose.yml file.
A questo punto, hai già imparato le basi dell'esecuzione di applicazioni in un contenitore Docker. Quindi quali altre applicazioni da eseguire nel contenitore Docker hai in mente? Forse un contenitore Docker per il contenitore Django e MongoDB?