pindu/cloudset

By pindu

•Updated 2 months ago

Imagen para el despliegue de app con django

Image

Languages & frameworks

Operating systems

10K+

Overview Tags

pindu/cloudset repository overview

⁠Dockerizado de Django para Desplegar Aplicaciones en Python

Referencia Rápida

Mantenido Por: PINDU

⁠Descargo de Responsabilidad:

El código proporcionado se ofrece "tal cual", sin garantía de ningún tipo, expresa o implícita. En ningún caso los autores o titulares de derechos de autor serán responsables de cualquier reclamo, daño u otra responsabilidad.

⁠Donaciones:

Si encuentras útil este proyecto y deseas contribuir a su mantenimiento, considera hacer una donación. Tu apoyo es muy apreciado.

⁠Resumen:

Este artículo presenta una solución basada en Docker para desplegar una imagen de Alpine Linux que ejecuta una aplicación de Django, utilizando Pandas, Redis y PostgreSQL. Se proporciona el Dockerfile⁠ y la configuración de Docker Compose⁠ que demuestran la instalación de paquetes necesarios y la integración con PostgreSQL para la gestión de datos. Las características principales incluyen el uso de Alpine Linux⁠ para minimizar el tamaño de la imagen, la instalación de las bibliotecas de Python necesarias, y la gestión de volúmenes para la persistencia de datos. La solución tiene como objetivo simplificar la implementación y el mantenimiento de aplicaciones con Django eficientes en entornos en la nube, asegurando una fácil integración con bases de datos PostgreSQL para operaciones de análisis de datos.

⁠Palabras Clave: Docker, Alpine Linux, cron jobs

⁠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 conectar Django a la base de datos PostgreSQL
# Para ORACLE el motor es django.db.backends.oracle
# Para POSTGRESQL el motor es django.db.backends.postgresql
DATABASE_ENGINE=django.db.backends.postgresql
DATABASE_HOST=db
DATABASE_PORT=5432
DATABASE_NAME=postgres
PGUSER=postgres

.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:

######################################################################
# .env.backend
# APP store
CLIENT_ID=
CLIENT_SECRET=
API_URL=example.com
#######################################################################
CELERY_BROKER_URL=redis://redis:6379/0
CELERY_RESULT_DBURI=redis://redis:6379/0
#######################################################################
# Bot Discord
IA_API=
IA_MODEL=gemini-1.5-flash
BOT_TOKEN=
#######################################################################
# Este SERVER_NAME es la IP o nombres donde se sirve el backend
SERVER_NAME="127.0.0.1 localhost ${API_URL}"
# Datos para credenciales de Oracle. Ruta a la carpeta
TNS_ADMIN=
LD_LIBRARY_PATH=
# Datos para la configuración de Django
SECRET_KEY=$(python -c "import secrets; print(secrets.token_hex(33))")
PYTHONUNBUFFERED=1
APP_CORS_ALLOW_ALL=True
DEBUG=False
CSRF_TRUSTED_ORIGINS=${SERVER_NAME}
CORS_ORIGIN_WHITELIST="${SERVER_NAME} worker"
ALLOWED_HOSTS=${SERVER_NAME}
# Datos para enviar correos automáticamente usando una cuenta de Gmail
EMAIL_USE_TLS=True
EMAIL_HOST=smtp.gmail.com
EMAIL_HOST_USER=
EMAIL_HOST_PASSWORD=
EMAIL_PORT=587

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/cloudset: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.

⁠Dockerfile

A continuación se muestra el Dockerfile utilizado para construir la imagen:

########################################################################################
# Etapa de base
########################################################################################
FROM python:alpine AS base
ENV PYTHON_VERSION="3.14"
LABEL maintainer="Luciano Parruccia <[email protected]>"
LABEL version="1.0"
LABEL description="Imagen para desplegar una aplicación en Django"
# Example of apk add without version pinning, disabling DL3018 warning
# hadolint ignore=DL3018
RUN apk --no-cache add pango ttf-freefont py3-pip curl \
  && mkdir /code \
  && mkdir /home/pindu \
  && chmod -R 755 /code \
  && addgroup -g 99 -S pindu && adduser -u 99 -S pindu -G pindu \
  && chown -R pindu:pindu /code /home/pindu
WORKDIR /code

########################################################################################
# Etapa de construcción
########################################################################################
FROM base AS builder

# Instalación de dependencias de construcción
# hadolint ignore=DL3018
RUN apk --no-cache add \
  py3-pillow py3-brotli py3-scipy py3-cffi \
  linux-headers autoconf automake libtool gcc cmake python3-dev \
  fortify-headers binutils libffi-dev wget openssl-dev libc-dev \
  g++ make musl-dev pkgconf libpng-dev openblas-dev build-base \
  font-noto terminus-font libffi libpq libpq-dev \
  && rm -rf /var/cache/apk/*

# Copia solo los archivos necesarios para instalar dependencias de Python
COPY ./cloudset/requirements.txt .

# Instalación de dependencias de Python y limpieza de dependencias de build
# hadolint ignore=DL3013
RUN pip install --no-cache-dir --prefer-binary --prefix=/install -r requirements.txt \
  && rm requirements.txt \
  && apk del \
  linux-headers autoconf automake libtool gcc cmake python3-dev \
  fortify-headers binutils libffi-dev openssl-dev libc-dev \
  g++ make musl-dev pkgconf openblas-dev build-base libpq-dev \
  && rm -rf /var/cache/apk/* /tmp/* /var/tmp/*
########################################################################################
# Etapa de producción
########################################################################################
FROM base AS final
# Copia solo los archivos necesarios desde la etapa de construcción
COPY --chown=pindu:pindu --from=builder /install/lib/python$PYTHON_VERSION/site-packages /usr/local/lib/python$PYTHON_VERSION/site-packages
COPY --chown=pindu:pindu --from=builder /install/bin /usr/local/bin
#COPY --chown=pindu:pindu --from=builder /usr/lib/python$PYTHON_VERSION/site-packages /usr/lib/python$PYTHON_VERSION/site-packages
ENV PATH=/usr/local/lib/python$PYTHON_VERSION/site-packages:$PATH
#hadolint ignore=DL3013
# Configuración adicional
RUN ln -s /usr/share/zoneinfo/America/Cordoba /etc/localtime
COPY LICENSE /code/LICENSE
# Establecer el usuario para ejecutar el contenedor
USER pindu
# Exponer el puerto 8000
EXPOSE 8000
CMD ["gunicorn", "--bind", ":8000", "--workers", "2", "app.wsgi"]

Este Dockerfile define cómo se construye la imagen Docker, especificando la imagen base, las dependencias necesarias, los archivos copiados al contenedor y configuraciones adicionales. Cada instrucción en el Dockerfile contribuye a configurar el entorno y las aplicaciones dentro del contenedor, permitiendo una construcción de imagen consistente y reproducible.

Las librerías utilizadas en la creación de la imagen se especifican en el archivo requirements.txt. Este archivo contiene una lista de las dependencias de Python necesarias para ejecutar los scripts ETL. A continuación, se muestra un ejemplo de cómo podría lucir el contenido de requirements.txt:

########################################################################################
# Framework Django
Django
django_redis
djangorestframework
#django-admin-autocomplete-filter
django-autocompletefilter
django-cors-headers
########################################################################################
# PostgreSQL
#psycopg2-binary
#zopfli
#brotli
psycopg[binary]
SQLAlchemy
########################################################################################
# AFIP FE requests==2.31.0
requests
django-afip
########################################################################################
# Lectura xlsx
pandas
xlrd
openpyxl
########################################################################################
# Reporte
reportlab
########################################################################################
# Mapas
folium

celery[redis]
gunicorn

Estas librerías incluyen:

pandas: Utilizado para la manipulación y análisis de datos.
SQLAlchemy: Un ORM (Object-Relational Mapping) que facilita la interacción con bases de datos SQL.
zopfli: Una implementación de compresión compatible con gzip y zlib.
brotli: Un algoritmo de compresión utilizado para la compresión de datos.
psycopg[binary]: Un adaptador de base de datos PostgreSQL para Python, con soporte para conexiones en pool.
requests: Una biblioteca HTTP para Python, fácil de usar y con una sintaxis simple, que permite enviar solicitudes HTTP/1.1 con métodos como GET y POST, manejar cookies, y gestionar sesiones.
xlrd: Una biblioteca para leer datos e información de formato de archivos Excel en el formato histórico .xls. Es útil para extraer datos de archivos Excel antiguos.
openpyxl: Una biblioteca de Python para leer/escribir archivos Excel 2010 xlsx/xlsm/xltx/xltm. Permite crear, modificar y extraer información de archivos Excel de manera programática.
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 AFIP (Administración Federal de Ingresos Públicos) de Argentina.
celery[redis]: Una biblioteca de cola de tareas distribuida que soporta la ejecución de tareas en segundo plano en Django, con soporte para Redis como broker.
python-dotenv: Carga variables de entorno desde un archivo .env. reportlab: Una biblioteca de Python para generar documentos PDF directamente desde el código. Es útil para crear informes, facturas y otros documentos que requieren un formato preciso y profesional.

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.

Tag summary

Recent tags

Content type

Image

Digest

sha256:b8ab1f4f1…

Size

156 MB

Last updated

2 months ago

docker pull pindu/cloudset:test