pindu/base repository overview

⁠Dockerizado de Django para Desplegar Aplicaciones en Python

Referencia Rápida

• Docker⁠: Herramienta para crear, implementar y ejecutar aplicaciones en contenedores.
• Alpine Linux⁠: Distribución de Linux ligera y segura.
• Debian Linux⁠: Sistema operativo universal basado en Linux.
• Python⁠: Lenguaje de programación de alto nivel.
• PostgreSQL⁠: Sistema de gestión de bases de datos relacional avanzado.
• Django⁠: Framework web de alto nivel para Python.
• Django REST Framework⁠: Herramienta para construir APIs web en Django.
• Gunicorn⁠: Servidor WSGI para aplicaciones Python.
• Docker Compose⁠: Herramienta para definir y ejecutar aplicaciones multi-contenedor.

Mantenido Por: PINDU

⁠Descargo de Responsabilidad

Este proyecto se proporciona "tal cual", sin garantías de ningún tipo, ya sean expresas o implícitas, incluidas, entre otras, las garantías de comerciabilidad, idoneidad para un propósito particular y no infracción. El uso del código es bajo tu propio riesgo. Ni los autores ni los titulares de derechos de autor serán responsables de ningún daño directo, indirecto, incidental, especial, ejemplar o consecuente que surja del uso de este software.

⁠Donaciones

Si este proyecto te resulta útil y deseas apoyar su desarrollo continuo, considera realizar una donación. Tu contribución ayuda a mantener y mejorar este proyecto, permitiendo que más personas se beneficien de él. ¡Gracias por tu apoyo!

⁠Resumen

Este proyecto presenta una solución integral para desplegar aplicaciones Django utilizando Docker. La configuración incluye una imagen basada en Alpine Linux, optimizada para ser ligera y eficiente, que ejecuta una aplicación Django con soporte para PostgreSQL.

Se proporciona un Dockerfile⁠ y un archivo de configuración Docker Compose⁠ que facilitan la instalación de dependencias, la integración con bases de datos PostgreSQL y la gestión de volúmenes para la persistencia de datos.

Las principales características incluyen:

• Uso de Alpine Linux para minimizar el tamaño de la imagen.
• Instalación de bibliotecas esenciales de Python para desarrollo web.
• Configuración de servicios como PostgreSQL para la gestión de datos.
• Orquestación simplificada para entornos en la nube.

Esta solución está diseñada para desarrolladores que buscan una implementación eficiente, escalable y fácil de mantener de aplicaciones Django en entornos modernos. Además, asegura una integración fluida con bases de datos relacionales y herramientas de análisis de datos, optimizando el flujo de trabajo y la productividad.

⁠Palabras Clave:

Docker, Alpine Linux, PostgreSQL, Django, Python, Redis, Gunicorn, Docker Compose, APIs, Django REST Framework, Contenedores, Orquestación, Desarrollo Web, Backend, Escalabilidad, Persistencia de Datos, Cloud Computing, Microservicios, CI/CD, Automatización, Infraestructura como Código, Seguridad, Optimización, Análisis de Datos, Integración Continua, Despliegue Continuo, Sistemas Distribuidos, Arquitectura de Software, Desarrollo Ágil, DevOps, Virtualización, Gestión de Dependencias, Configuración de Entornos, Mejores Prácticas.

⁠Variables de Entorno

Para configurar tu entorno de docker-compose, necesitas crear dos archivos de variables de entorno con la siguiente información:

.env.db: Este archivo debe contener las variables de entorno específicas para la base de datos, como credenciales de acceso y configuraciones relacionadas. Ejemplo de contenido:

#######################################################################
# .env.db
# Datos para la conexion desde django a la base de datos de postgres
# Para ORACLE el engine es django.db.backends.oracle
# Para POSTGRESQL el engine es django.db.backends.postgresql
DATABASE_ENGINE=django.db.backends.postgresql
POSTGRES_HOST=db
POSTGRES_PORT=5432
POSTGRES_DB=postgres
POSTGRES_USER=postgres
PGUSER=${POSTGRES_USER}
#POSTGRES_PASSWORD=postgres
LANG=es_AR.utf8
#TZ=America/Argentina/Cordoba
POSTGRES_INITDB_ARGS="--locale-provider=icu --icu-locale=es-AR --auth-local=trust"
POSTGRES_HOST_AUTH_METHOD=scram-sha-256
POSTGRES_PASSWORD_FILE=/run/secrets/db-password

.env.backend: Este archivo debe contener las variables de entorno para el backend de tu aplicación. Incluye configuraciones como URLs de API, claves secretas y otras variables necesarias para el funcionamiento del backend. Ejemplo de contenido:

#######################################################################
# variables definidas en /etc/environment
SERVER_NAME=
#######################################################################
# Datos para la configuracion de Django
# este SERVER_NAME es los IP o nombres donde se atiende el backend
SERVER_NAMES="${SERVER_NAME} 127.0.0.1 localhost"
SECRET_KEY=$(python -c "import secrets; print(secrets.token_hex(33))")
PYTHONUNBUFFERED=1
APP_CORS_ALLOW_ALL=True
DEBUG=True
CSRF_TRUSTED_ORIGINS=${SERVER_NAMES}
CORS_ORIGIN_WHITELIST=${SERVER_NAMES}
# direcciones que sirven la app
ALLOWED_HOSTS=${SERVER_NAMES}
# Datos para el envio de mails automaticamente usando cuenta de gmail
EMAIL_USE_TLS=True
EMAIL_HOST=
EMAIL_HOST_USER=
EMAIL_HOST_PASSWORD=
EMAIL_PORT=587
#######################################################################
#Títulos
SITE_HEADER="Administración"
SITE_TITLE="Administración"
INDEX_TITLE="Panel de control"
SITE_URL="/"

Estos archivos deben estar en el mismo directorio que tu archivo docker-compose.yml. Docker Compose cargará automáticamente las variables definidas en estos archivos al construir y ejecutar los contenedores, asegurando que tu aplicación esté correctamente configurada según el entorno de ejecución.

⁠Orquestación

Para definir y gestionar tus servicios Docker, necesitas crear un archivo docker-compose.yml. Este archivo especifica la configuración de los contenedores, redes y volúmenes necesarios para tu aplicación.

A continuación, se muestra un ejemplo básico de un archivo docker-compose.yml:

services:
  db:
    image: postgres:alpine
    env_file:
      - .env.db
    secrets:
      - db-user
      - db-password
    environment:
      - POSTGRES_INITDB_ARGS=--auth-host=md5 --auth-local=trust
      - POSTGRES_PASSWORD_FILE=/run/secrets/db-password
    healthcheck:
      test: [ "CMD-SHELL", "pg_isready" ]
      interval: 10s
      timeout: 2s
      retries: 5
    volumes:
      - db:/var/lib/postgresql/data

  backend:
    image: pindu/base:latest
    entrypoint: python3 manage.py
    command: /bin/sh -c "gunicorn --bind :8000 --workers 2 app.wsgi"
    env_file:
      - .env.db
      - .env.backend
    healthcheck:
      test: [ "CMD", "curl", "-f", "http://localhost:8000" ]
      timeout: 2s
      retries: 5
    ports:
      - 8000:8000
    volumes:
      - ./src:/code
    depends_on:
      db:
        condition: service_healthy
    secrets:
      - db-user
      - db-password

volumes:
  db:
    external: false

secrets:
  db-password:
    file: secrets/db_password.txt
  db-user:
    file: secrets/db_user.txt

Para configurar la conexión a la base de datos, necesitas crear los siguientes archivos en el directorio de secretos:

• secrets/db_password.txt: Este archivo debe contener la contraseña para la base de datos.
• secrets/db_user.txt: Este archivo debe contener el nombre de usuario para la base de datos.

Asegúrate de que estos archivos contengan solo la información necesaria (sin espacios adicionales) y estén ubicados en la ruta especificada. La correcta configuración de estos archivos es crucial para establecer una conexión segura y exitosa con la base de datos.

Las librerías utilizadas en la creación de la imagen son:

Django
django_redis
djangorestframework
django-autocompletefilter
django-cors-headers
psycopg[binary]
django-afip

Estas librerías incluyen:

• psycopg[binary]: Un adaptador de base de datos PostgreSQL para Python, con soporte para conexiones en pool.
• django: Un framework web de alto nivel que fomenta el desarrollo rápido y el diseño limpio y pragmático.
• django_redis: Un backend de caché para Django que utiliza Redis.
• djangorestframework: Un poderoso y flexible kit de herramientas para construir APIs web en Django.
• django-autocompletefilter: Un filtro de autocompletar para el administrador de Django.
• django-cors-headers: Un middleware para manejar CORS en Django.
• django-afip: Una biblioteca para interactuar con los servicios web de la ARCA (Agencia de Recaudación y Control Aduanero) de Argentina.

Estas librerías son esenciales para la funcionalidad avanzada de la aplicación, como la generación de contenido automatizado y el reconocimiento de voz, mejorando la interacción y la experiencia del usuario.

Para verificar la calidad y adherencia a las mejores prácticas de tu Dockerfile, puedes usar Hadolint, una herramienta de linting para Dockerfiles. Ejecuta el siguiente comando para validar tu Dockerfile:

docker run --rm -i hadolint/hadolint < Dockerfile

Este comando utiliza un contenedor Docker para ejecutar Hadolint, que analizará el Dockerfile y mostrará recomendaciones y advertencias basadas en las mejores prácticas. Asegúrate de reemplazar Dockerfile con la ruta a tu Dockerfile si está en un directorio diferente.