Docker le permite empaquetar su aplicación de una manera que simplifica la colaboración y la implementación. Pero si es nuevo en Docker y se pregunta cómo crear un contenedor Django Docker para su aplicación web, ¡está de enhorabuena!
En este tutorial, aprenderá a convertirse en su propio maestro en la creación de una imagen y un contenedor Docker para su aplicación Django.
¡Prepárese y comience a transportar en contenedores!
Requisitos
Este tutorial será una demostración práctica. Si desea seguirnos, asegúrese de tener lo siguiente:
- Docker y Docker Compose instalados.
- Una máquina Linux:este tutorial usa Ubuntu 20.04.3 LTS.
- Python instalado:este tutorial utiliza Python 3.8.12.
Creación de una API de Django y conexión a PostgreSQL
Antes de crear un contenedor de aplicaciones Django Docker, primero necesita una aplicación para contener. Creará una API de recetas y la conectará a PostgreSQL, que viene con Django de forma predeterminada.
Pero primero, deberá instalar Django y Django REST framework en su máquina local. El marco REST de Django es esencial para crear API en Django.
1. Abre tu terminal y ejecuta el pip comando a continuación para instalar django y djangorestframework en su máquina local.
pip install django djangorestframework2. A continuación, ejecute los siguientes comandos para crear un directorio llamado ~/django_recipe_api y navegue a ese directorio. Este directorio contendrá todos los archivos necesarios para este proyecto.
mkdir ~/django_recipe_api
cd ~/django_recipe_api
3. Ejecute los siguientes comandos para crear un nuevo proyecto Django (recipe_api ) y una aplicación (recipe ) en el directorio actual donde residirá la 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. Ahora abre ~/django_recipe_api/recipe_api/settings.py archivo en su editor de texto preferido y agregue el siguiente código.
El siguiente código agrega el rest_framework a la aplicación (receta) que creó anteriormente (paso tres).
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. Abra ~/django_recipe_api/recipe/models.py archivo y pegue el código a continuación.
El siguiente código inicia los campos y el tipo de datos que almacenará en la base de datos.
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. Cree otro archivo llamado ~/django_recipe_api/recipe/serializers.py y complete el archivo con el siguiente código.
El siguiente código crea un serializador para el modelo que creó anteriormente (paso cinco). El serializador ayuda a convertir los datos de la API en un formulario, como JSON, que se puede usar en la interfaz.
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. Ahora crea un archivo llamado ~/django_recipe_api/recipe/views.py y pegue el código a continuación.
El siguiente código crea un conjunto de vistas para devolver los datos de la API a la interfaz y manejar las solicitudes GET de los usuarios.
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. Finalmente, abra el archivo en la ruta ~/django_recipe_api/recipe_api/urls.py y reemplace el código en el archivo con el siguiente código.
En el siguiente código, está configurando las URL para que Django REST Framework pueda conectarse a su aplicación correctamente. También indica la ruta a utilizar al acceder a la API en un navegador.
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
]Creación de un Dockerfile para compilar la API de Django
Actualmente, solo tiene una API de Django que no está en contenedores de ninguna manera. Contenerizar su aplicación facilita la colaboración y la implementación si es necesario.
Cree un archivo llamado Dockerfile en la raíz de su proyecto y complete el archivo con el código a continuación. Un Dockerfile contiene una lista de instrucciones que utiliza Docker para crear su imagen de Docker.
El siguiente código crea un directorio en su contenedor y copia el código de su máquina local en el contenedor.
# 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 userAhora, cree el requirements.txt archivo en la raíz de su proyecto e ingrese el texto a continuación.
A continuación se muestra una lista de las dependencias necesarias para ejecutar su proyecto.
django==3.1.2
djangorestframework==3.13.1
Creando Docker Compose File para ejecutar Django y PostgreSQL
Acaba de crear la imagen Docker de su aplicación, pero ¿cómo la ejecuta? Docker-compose es una herramienta que se utiliza para ejecutar imágenes de Docker desde máquinas locales. Docker-compose lo ayuda a administrar varios servicios en su aplicación, como Django y bases de datos.
1. Cree un archivo llamado docker-compose.yml en la raíz de su proyecto y pegue el código a continuación.
El siguiente código asigna el puerto de su máquina local al puerto de su imagen y ejecuta su aplicación.
# 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. A continuación, abra su settings.py archivo y agregue 0.0.0.0 como valor de ALLOWED_HOSTS ya que Docker se ejecuta en el host (0.0.0.0). El ALLOWS_HOSTS La variable contiene una lista de dominios/hosts que pueden acceder a su aplicación.
ALLOWED_HOSTS = ['0.0.0.0']3. Ejecute los siguientes comandos para generar una base de datos para su modelo de 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. Ahora, ejecute cada comando a continuación para compilar y ejecutar su contenedor Django.
sudo docker-compose build # Build your Service
sudo docker-compose up # Runs your application5. Finalmente, abra su navegador web preferido y vaya a http://0.0.0.0:8000/recipe/ para ejecutar su API.
Como puede ver a continuación, su API funciona perfectamente, lo que le permite agregar recetas.
Configurando PostgreSQL para W trabajar con Docker y Django
Está trabajando con SQLite como base de datos en este momento, lo cual no es ideal cuando desea escalar su aplicación. Una mejor opción que se conecta bien con Django es PostgreSQL, que agregará a su aplicación.
Para configurar PostgreSQL para trabajar con Docker y Django:
1. Abra su Dockerfile y agregue el siguiente código sobre RUN pip install -r /requirements.txt línea. Estas dependencias son necesarias para que PostgreSQL funcione correctamente 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. A continuación, abra requirements.txt archivo y agregue el psycopg2==2.8.6 requisito.
3. Vuelva a ejecutar el siguiente comando para generar la imagen nuevamente.
docker-compose build
4. Abra su settings.py y reemplace el archivo DATABASES bloque con el siguiente código.
El siguiente código actualiza su base de datos en Django para usar PostgreSQL.
El os El módulo se usa en el código a continuación, por lo que debe agregar import os en la parte superior de tu ~/django_recipe_api/recipe_api/settings.py contenido del archivo.
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. Abra docker-compose.yml archivo y reemplace el contenido del archivo con el siguiente código.
El siguiente código crea un servicio para la base de datos que creó (paso cuatro) y alimenta las credenciales de la base de datos 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. Ejecute los siguientes comandos para aplicar migraciones para la nueva base de datos que creó (paso cinco).
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. Ahora, ejecute el siguiente comando para ejecutar su aplicación Django en el contenedor Docker.
sudo docker-compose up
8. Finalmente, navegue a http://0.0.0.0:8000/recipe/ en su navegador nuevamente.
Como puede ver a continuación, los datos guardados anteriormente ya no están allí porque cambió su base de datos. Ahora puede continuar y agregar más datos si lo desea.
Conclusión
En este tutorial, aprendió a configurar un contenedor Docker para la API de Django que usa PostgreSQL para almacenar datos. También ha pasado por el lanzamiento de contenedores Django usando Dockerfile y docker-compose.yml archivos.
En este punto, ya domina los conceptos básicos de la ejecución de aplicaciones en un contenedor Docker. Entonces, ¿qué otras aplicaciones tiene en mente para ejecutar en el contenedor Docker? ¿Quizás un contenedor Docker para el contenedor Django y MongoDB?