Introducción
Django es un poderoso marco web para Python que permite a los desarrolladores crear aplicaciones web complejas de manera organizada. Proporciona muchas funciones que aceleran el proceso de desarrollo, como un motor de plantillas, un mapeador relacional de objetos y un sistema de autenticación. También contiene muchas herramientas integradas, como un admin interfaz, almacenamiento en caché, alimentación RSS y Atom, etc. Con Django, los desarrolladores pueden crear potentes aplicaciones web con facilidad y rapidez con un mínimo esfuerzo. Incluye un servidor web para pruebas y desarrollo, pero para implementarlo en producción, debe usar otras soluciones como Gunicorn.
Este artículo muestra los pasos para usar Vultr Object Storage para alojar los archivos estáticos, configurar Vultr Managed PostgreSQL Database como el backend de la base de datos, contener la aplicación Django e implementar la aplicación Django en Vultr Kubernetes Engine.
requisitos previos
Antes de comenzar, debe:
Implemente un clúster de Vultr Kubernetes Engine.
Implemente una base de datos administrada Vultr para el clúster de PostgreSQL.
Implemente un recurso de almacenamiento de objetos.
Tener acceso a la configuración de DNS de un nombre de dominio. Este artículo utilizadjango.ejemplo.compara demostración
Implemente un servidor Ubuntu 22.04 para usarlo como estación de trabajo de administración. En la estación de trabajo de gestión:
instalarKubectl.
Descargue su configuración de VKE y configure Kubectl.
Asegúrese de aprovisionar todos los servicios en la misma región para una latencia baja entre los servicios.
Inicializar el proyecto Django
Un proyecto Django contiene toda la lógica de un solo proyecto dividida en fragmentos parciales llamados aplicaciones Django. Esta sección demuestra los pasos para inicializar un nuevo proyecto Django usando eldjango-admindominio. Puede omitir estos pasos y pasar a los siguientes mientras trabaja en un proyecto existente.
Crear un nuevo directorio llamadodjango-demo.
# mkdir ~/django-demo
# cd ~/django-demo
Instala elvirtualenvpaquete.
# pip install virtualenv
El comando anterior instaló elvirtualenvpaquete. Es una biblioteca de Python que le permite crear entornos aislados para sus proyectos de Python. Se usa comúnmente para administrar dependencias de paquetes y evitar dependencias conflictivas entre diferentes proyectos.
Crear un nuevo entorno virtual.
# virtualenv venv
El comando anterior crea un nuevo directorio llamadovenven el directorio de trabajo que contiene todos los archivos del entorno virtual de Python.
Activar el entorno virtual.
# source venv/bin/activate
El comando anterior ejecuta elactivatearchivo binario que manipula el$PATHvariable para que lapythonypipLos comandos se refieren a archivos binarios de entorno virtual en lugar de archivos binarios globales.
Instala eldjangopaquete.
(venv) # pip install django
Cree un nuevo proyecto Django.
(venv) # django-admin startproject PROJECT_NAME
Añada los anfitriones en elALLOWED_HOSTSlista.
(venv) # cd PROJECT_NAME
(venv) # nano PROJECT_NAME/settings.py
Encuentre la variable y agregue sus hosts a la lista.
ALLOWED_HOSTS = ['PUBLIC_IP', 'django.example.com']
La declaración anterior le indica a Django que permita conexiones en elPUBLIC_IPy eldjango.example.comsubdominio
Guarde el archivo y close el editor de archivos usando CTRL+X y luego ENTER.
Inicialice la base de datos.
(venv) # python manage.py migrate
(venv) # python manage.py createsuperuser
Deshabilite el cortafuegos.
(venv) # ufw disable
El comando anterior deshabilita el firewall para permitir conexiones de red entrantes en cualquier puerto.
Inicie en el servidor Django.
(venv) # cd PROJECT_NAME
(venv) # python manage.py runserver 0.0.0.0:8000
Los comandos anteriores generan una instancia del servidor web Django incorporado que escucha en el puerto8000. Puede abrir la interfaz en su navegador web abriendohttps://PUBLIC_IP:8000. Después de confirmar el acceso, detenga el servidor usando CTRL+C para continuar con los siguientes pasos.
Configurar el almacenamiento de objetos Vultr como servidor de archivos estáticos
Django no sirve archivos estáticos sin el modo de depuración, lo que requiere que los alojes por separado. Puede utilizar un servicio de almacenamiento de objetos para alojar los archivos estáticos como solución alternativa. Esta sección demuestra los pasos para configurar el servicio de almacenamiento de objetos Vultr como backend para alojar y servir los archivos estáticos.
Instale los paquetes de Python necesarios.
(venv) # pip install django-storages boto3
El comando anterior instala eldjango-storagesy elboto3paquetes en el entorno virtual, lo que le permite integrar el almacenamiento de objetos Vultr con su proyecto Django.
Editar elsettings.pyhora de oficina.
(venv) # nano PROJECT_NAME/settings.py
Agregue la siguiente línea en el encabezado del archivo.
import os
La declaración anterior importa laosbiblioteca, una biblioteca integrada que proporciona una forma de utilizar la funcionalidad dependiente del sistema operativo.
Agregue los siguientes contenidos bajo las variables de archivo estático.
DEFAULT_FILE_STORAGE = "storages.backends.s3boto3.S3Boto3Storage"
STATICFILES_STORAGE = "storages.backends.s3boto3.S3StaticStorage"
AWS_S3_REGION_NAME = os.environ.get("OBJECT_STORAGE_REGION")
AWS_S3_ENDPOINT_URL = f"https://{AWS_S3_REGION_NAME}.vultrobjects.com"
AWS_S3_USE_SSL = True
AWS_STORAGE_BUCKET_NAME = os.environ.get("OBJECT_STORAGE_BUCKET_NAME")
AWS_ACCESS_KEY_ID = os.environ.get("OBJECT_STORAGE_ACCESS_KEY")
AWS_SECRET_ACCESS_KEY = os.environ.get("OBJECT_STORAGE_SECRET_KEY")
AWS_DEFAULT_ACL="public-read"
Las declaraciones anteriores definen la configuración para el servidor de archivos estáticos y utilizan elos.environ()función para obtener las credenciales de las variables de entorno. Guarde el archivo y close el editor de archivos usando CTRL+X y luego ENTER.
Crear un nuevo archivo llamado.env.
(venv) # nano .env
Agregue los siguientes contenidos al archivo.
OBJECT_STORAGE_REGION=
OBJECT_STORAGE_BUCKET_NAME=
OBJECT_STORAGE_SECRET_KEY=
OBJECT_STORAGE_ACCESS_KEY=
Rellene los valores utilizando la información de la página de recursos. Guarde el archivo y close el editor de archivos usando CTRL+X y luego ENTER.
Exporte las variables de entorno.
(venv) # export $(xargs < .env)
El comando anterior lee el.envarchivo y lo exporta a las variables de entorno de la máquina host.
Aplicar la configuración.
(venv) # python manage.py collectstatic
El comando anterior recopila todos los archivos estáticos y los carga en el depósito de almacenamiento de objetos Vultr especificado. losdjango-storagesEl paquete asegura que su proyecto Django use las URL de almacenamiento de objetos para servir los archivos estáticos.
Verifique los cambios.
(venv) # python manage.py runserver 0.0.0.0:8000
El comando anterior genera un servidor web Django. Puede verificar los cambios abriendohttps://PUBLIC_IP:8000/adminen su navegador web y viendo el código fuente para verificar las URL de los recursos. Detenga el servidor usando CTRL+C para continuar con los siguientes pasos.
Configurar la base de datos administrada por Vultr como backend de la base de datos
De forma predeterminada, Django usa una base de datos SQL Lite para almacenar todos los modelos y datos. Esta sección demuestra los pasos para cambiar el motor de la base de datos a PostgreSQL y usar el clúster PostgreSQL de la base de datos administrada por Vultr como backend de la base de datos. Debe realizar estos cambios incluso si su proyecto Django ya usa PostgreSQL, ya que necesita usar variables de entorno para obtener las credenciales de la base de datos.
Instale los paquetes de Python necesarios.
(venv) # pip install psycopg2-binary
El comando anterior instala elpsycopg2-binarypaquete en el entorno virtual, lo que le permite integrar el clúster de la base de datos PostgreSQL administrada por Vultr con su proyecto Django.
Editar elsettings.pyhora de oficina.
(venv) # nano PROJECT_NAME/settings.py
Reemplace laDATABASESvariable con el siguiente contenido.
DATABASES = {
"default": {
'ENGINE': 'django.db.backends.postgresql',
'NAME': os.environ.get("DATABASE_NAME"),
'USER': os.environ.get("DATABASE_USER"),
'PASSWORD': os.environ.get("DATABASE_PASS"),
'HOST': os.environ.get("DATABASE_HOST"),
'PORT': os.environ.get("DATABASE_PORT"),
'OPTIONS': {'sslmode': 'require'}
}
}
Las declaraciones anteriores definen la configuración para el backend de la base de datos y utilizan elos.environ()función para obtener las credenciales de las variables de entorno. Guarde el archivo y close el editor de archivos usando CTRL+X y luego ENTER.
Actualizar el.envhora de oficina.
(venv) # nano .env
Agregue los siguientes contenidos al archivo.
DATABASE_HOST=
DATABASE_PORT=
DATABASE_USER=
DATABASE_PASS=
DATABASE_NAME=
Rellene los valores utilizando la información de la página de recursos. Guarde el archivo y close el editor de archivos usando CTRL+X y luego ENTER.
Exporte las variables de entorno.
(venv) # export $(xargs < .env)
El comando anterior lee el.envarchivo y lo exporta a las variables de entorno de la máquina host.
Aplicar la configuración.
(venv) # python manage.py makemigrations
(venv) # python manage.py migrate
(venv) # python manage.py createsuperuser
Los comandos anteriores leen todos los modelos definidos en el proyecto Django para inicializar la base de datos PostgreSQL especificada. Puede usar diferentes credenciales para la cuenta de superusuario para verificar el cambio de base de datos.
Verifique los cambios.
(venv) # python manage.py runserver 0.0.0.0:8000
El comando anterior genera un servidor web Django. Puede verificar los cambios abriendohttps://PUBLIC_IP:8000/adminen su navegador web e intentando iniciar sesión con las nuevas credenciales de superusuario. Detenga el servidor usando CTRL+C para continuar con los siguientes pasos.
Poner en contenedor el proyecto Django
Necesita contenerizar el proyecto Django para crear un KubernetesDeploymentrecurso para manejar las solicitudes de Django. Esta sección muestra los pasos para contener el proyecto Django para que pueda crear una imagen para usar en el clúster de Kubernetes.
Elimine el antiguo archivo de base de datos de SQL Lite.
(venv) # rm -f db.sqlite3
Deshabilite el depurador de Django.
(venv) # nano PROJECT_NAME/settings.py
Busque y reemplace el siguiente valor en el archivo.
DEBUG = False
La declaración anterior deshabilita el depurador de Django para ocultar los errores en el entorno de producción que podrían llevar a revelar la base de código sensible.
Instale el paquete de Python necesario.
(venv) # pip install gunicorn
El comando anterior instala elgunicornpaquete en el entorno virtual. Gunicorn es un servidor web de producción para ejecutar aplicaciones web de Python. Lo usará para servir al proyecto Django aprovechando un mejor rendimiento, confiabilidad y escalabilidad.
Crear un nuevo archivo llamadorequirements.txt.
(venv) # pip freeze > requirements.txt
El comando anterior obtiene todos los paquetes requeridos y los agrega alrequirements.txthora de oficina.
Desactivar el entorno virtual.
(venv) # deactivate
Cree un nuevo Dockerfile.
# nano Dockerfile
Agregue los siguientes contenidos al archivo.
FROM python:3.8
WORKDIR /app
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1
RUN pip install --upgrade pip
COPY ./requirements.txt /app
RUN pip install -r requirements.txt
COPY . /app
EXPOSE 8000
CMD ["gunicorn", "PROJECT_NAME.wsgi","-b", "0.0.0.0:8000"]
La configuración anterior hereda la imagen acoplable oficial de Python y utiliza elrequirements.txtpara cumplir con todos los requisitos. Ejecuta elgunicorn PROJECT_NAME.wsgi -b 0.0.0.0:8000Comando para generar un servidor web Gunicorn dentro del contenedor para servir al proyecto Django.
Cree un nuevo repositorio privado en DockerHub.
Ve a laSitio web de DockerHube inicie sesión en su cuenta.
Navega a la pestaña “Repositorios” en el menú superior.
Haga clic en el botón “Crear repositorio”.
Enter un nombre para su repositorio y seleccione “Privado” de las opciones de visibilidad.
Haga clic en el botón “Crear” para crear su nuevo repositorio privado.
Inicie sesión en la cuenta de DockerHub.
# docker login
El comando anterior le solicita que ingrese sus credenciales de DockerHub para compilar y enviar la imagen en DockerHub.
Construye y empuja la imagen.
# docker build -t DOCKERHUB_USERNAME/REPO_NAME:latest .
# docker push DOCKERHUB_USERNAME/REPO_NAME:latest
Los comandos anteriores compilan y envían la imagen a DockerHub, que usará en el manifiesto de Kubernetes en los pasos posteriores.
Preparar el clúster de Kubernetes
Debe preparar el clúster de Kubernetes para la implementación de Django instalando los complementos necesarios y creando algunos recursos. Esta sección muestra los pasos para instalar elnginx-ingresscontrolador, instale elcert-managercomplemento, crea unClusterIssuerrecurso para emitir certificados de Let’s Encrypt y crear un recurso secreto para las credenciales de DockerHub.
Instala elnginx-ingresscontrolador y elcert-managerenchufar.
# kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.10.0/cert-manager.yaml
# kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.5.1/deploy/static/provider/cloud/deploy.yaml
Los comandos anteriores instalan elnginx-ingresscontrolador y elcert-managercomplemento en el clúster de Kubernetes utilizando los archivos de manifiesto oficiales. losnginx-ingressEl controlador aprovisiona un complemento de balanceador de carga para manejar las solicitudes HTTP entrantes en elIngressrecursos.
Obtenga la dirección IP del balanceador de carga.
# kubectl get services/ingress-nginx-controller -n ingress-nginx
Debes apuntar elAgrabar para django.example.com a la dirección IP del balanceador de carga.
Crear unClusterIssuerfunción para Let's Encrypt CA.
# nano ~/le_clusterissuer.yaml
Agregue los siguientes contenidos al archivo.
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
name: letsencrypt-prod
spec:
acme:
server: https://acme-v02.api.letsencrypt.org/directory
email: "YOUR_EMAIL"
privateKeySecretRef:
name: letsencrypt-prod
solvers:
- http01:
ingress:
class: nginx
El manifiesto anterior crea unClusterIssuerrecurso para emitir certificados de Let’s Encrypt. utiliza elHTTP01solucionador de desafíos para verificar la propiedad.
Aplicar la configuración.
# kubectl apply -f ~/le_clusterissuer.yaml
Cree el recurso secreto para las credenciales de DockerHub.
# kubectl create secret docker-registry regcred --docker-username=DOCKERHUB_USER --docker-password=DOCKERHUB_PASS --docker-email=DOCKERHUB_EMAIL
El comando anterior crea un nuevo recurso secreto con sus credenciales de DockerHub, que utilizará en la siguiente sección para descargar la imagen que creó en la sección anterior.
Implementar el proyecto Django
Realizó los pasos necesarios en las secciones anteriores para crear y configurar un proyecto de Django y un clúster de Kubernetes. Esta sección lo guiará a través de los pasos para implementar el proyecto Django en el clúster de Kubernetes. Implica crear los objetos de servicio e implementación necesarios dentro del clúster y configurarlos para alojar y ejecutar el proyecto Django.
Crear un nuevo archivo llamadodjango.yaml.
# nano ~/django.yaml
Agregue los siguientes contenidos al archivo.
apiVersion: apps/v1
kind: Deployment
metadata:
name: django-deployment
spec:
replicas: 3
selector:
matchLabels:
name: django-app
template:
metadata:
labels:
name: django-app
spec:
imagePullSecrets:
- name: regcred
containers:
- name: django
image: DOCKERHUB_USERNAME/REPO_NAME:latest
imagePullPolicy: Always
ports:
- containerPort: 8000
envFrom:
- secretRef:
name: django-secrets
---
apiVersion: v1
kind: Service
metadata:
name: django-service
spec:
ports:
- name: http
port: 80
protocol: TCP
targetPort: 8000
selector:
name: django-app
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: django-ingress
annotations:
kubernetes.io/ingress.class: nginx
cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
tls:
- secretName: django-tls
hosts:
- django.example.com
rules:
- host: django.example.com
https:
paths:
- path: /
pathType: Prefix
backend:
service:
name: django-service
port:
number: 80
El manifiesto anterior crea tres recursos. losDeploymentresource usa la imagen que envió a DockerHub. losServiceEl recurso expone las conexiones con elDeploymentrecurso dentro del clúster. losIngressrecurso expone elServicerecurso a nivel mundial y utiliza laClusterIssuerfunción para emitir un certificado Let's Encrypt.
Cree el recurso secreto para las variables de entorno.
# kubectl create secret generic django-secrets --from-env-file=.env
Aplicar el archivo de manifiesto.
# kubectl apply -f ~/django.yaml
El comando anterior aplica eldjango.yamlmanifiesto en el clúster. Después de unos minutos, puede verificar la implementación abriendohttps://django.example.comen su navegador web. Debe tener un certificado SSL y la respuesta debe permanecer sin cambios.
Conclusión
Este artículo demostró los pasos para usar Vultr Object Storage para alojar los archivos estáticos, configurar Vultr Managed PostgreSQL Database como el backend de la base de datos, contener la aplicación Django e implementar la aplicación Django en Vultr Kubernetes Engine. Puede seguir estos pasos para implementar su aplicación Django existente en Vultr Cloud Infraestructura.
Más información
Título del artículo Nombre (opcional) Correo electrónico (opcional) Descripción
Enviar sugerencia
