Despliegue de una aplicación Python en un hosting con cPanel

A continuación, se detalla cómo desplegar una aplicación Python básica en cPanel. Se configurará un servidor sencillo usando el framework HTTP Django, que gestionará peticiones y respuestas HTTP básicas, además de servir archivos estáticos. Después explicaremos cómo desplegar la aplicación que hemos desarrollado en cPanel.

Creación de un proyecto básico Python + Django

Lo primero, vamos a crear un proyecto de Python desde cero, los requisitos mínimos para poder crear nuestro setup de desarrollo para nuestra aplicación Python, es contar con el runtime de Python y Pip (El gestor de paquetes de Python) y cualquier IDE o editor de código, en este caso utilizaremos Visual Studio Code.

Puedes encontrar los enlaces para descargar e instalar todo el software necesario a continuación:

Python y Pip: https://www.python.org/downloads/

Visual Studio Code: https://code.visualstudio.com/

Opcionalmente, para seguir el ejemplo “Cómo crear una página que usa recursos de frontend” instalar Node JS y NPM: https://docs.npmjs.com/downloading-and-installing-node-js-and-npm

Una vez instalado todo lo necesario, vamos a crear un proyecto de Python desde cero. Para ello, abrimos una terminal en nuestra máquina local y crearemos una carpeta con el nombre del proyecto y vamos a levantar un entorno virtual de Python para inicializar el proyecto.

• Creamos una nueva carpeta con mkdir [nombre_carpeta].

• Nos movemos a dicha carpeta con cd [nombre_carpeta].

• Inicializamos el virtual environment de python con python3 -m venv .venv para Linux y MacOS o py -m venv .venv en Windows.

$ mkdir django-basic-app
$ cd django-basic-app
[Linux o MacOs] $ python3 -m venv .venv
[Windows] $ py -m venv .venv

Si abrimos el proyecto en Visual Studio Code seleccionando el directorio que acabamos de crear, deberíamos ver que contiene la carpeta .venv, esta contiene todo lo necesario para encapsular las dependencias y el software de Python para nuestro proyecto aislado del contexto global de la instalación de Python y de las dependencias globales instaladas. Esto es beneficioso para manejar las dependencias de cada proyecto Python de manera independiente.

Ahora vamos a crear nuestro fichero requirements.txt. Este fichero es el que define las dependencias específicas que requiere nuestro proyecto para su instalación. Así que creamos el fichero en la raíz de nuestro proyecto y vamos a añadir las dependencias necesarias para la aplicación Django añadiendo el siguiente contenido:

Django==4.2.20
python-webpack-boilerplate==1.0.4

Estamos definiendo las dependencias del framework Django y un paquete para integrar Django con la herramienta de Webpack para hacer más adelante building y bundler de recursos del front-end como assets , código CSS y JavaScript.

En este caso estoy especificando unas versiones concretas de las dependencias, como lo es la versión 4.2.20 de Django, pero utilicé las versiones de su conveniencia, siempre teniendo en cuenta la compatibilidad entre la versión de Python que utiliza y las versiones de las demás dependencias del proyecto.

Para instalar las dependencias en nuestro virtual environment, debemos ejecutar el binario pip que está ubicado en nuestra carpeta .venv. Específicamente, en el directorio .venv/bin/ tenemos todos los binarios que necesitamos para ejecutar tanto el instalador de paquetes pip, como el intérprete de Python.

En este caso, para instalar las dependencias definidas en nuestro fichero requirements.txt debemos de ejecutar el siguiente comando:

$ .venv/bin/pip install -r requirements.txt

Ahora que tenemos las dependencias necesarias instaladas en nuestro entorno virtual de Python, podemos generar la estructura de ficheros de Django en la raíz de nuestro proyecto.

Para esto utilizaremos el comando startproject de nuestro proyecto, en el cual pondremos como segundo argumento, el nombre de nuestro proyecto y como tercer argumento el path, donde queremos generar la estructura de ficheros de Django, en nuestro caso en . debido a que queremos generarla en el mismo directorio en el que nos encontramos.

$ .venv/bin/python -m django startproject django_basic_app .

Podemos observar que la ejecución del comando anterior, ha generado la estructura de ficheros del proyecto, con el fichero `manage.py` (que sirve para ejecutar comandos de Django en nuestro proyecto) y una carpeta con el nombre del proyecto, que hemos definido en la ejecución del comando, esta contiene los ficheros de código Python.

Para utilizar funcionalidades de Django como el sistema de administración, el auth o las sesiones de usuario, debemos de ejecutar las migraciones de base de datos para habilitar una de ellas. Por defecto, esta es una base de datos SQLite que se creará en la raíz del proyecto, pero puedes modificar la configuración del proyecto en el fichero `settings.py` para establecer la base de datos de tu preferencia. En nuestro caso, con la configuración de base de datos por defecto será más que suficiente.

Ejecutaremos el siguiente comando para migrar la base de datos:

$ .venv/bin/python manage.py migrate

Podemos observar que se ha creado un fichero llamado db.squlite3 en nuestro proyecto. Esta es la base de datos que ya contiene todas las tablas y datos de Django por defecto que necesita el framework para funcionar.

Con esto ya tenemos la estructura básica de nuestro proyecto lista y las migraciones ejecutadas; ahora ya podemos probar creando una ruta que devuelva una respuesta básica. Para ello debemos dirigirnos al fichero `urls.py`. En él podremos definir las rutas de la aplicación.

Para englobar todas las rutas de nuestra aplicación bajo un mismo path, podemos definirlo de esta manera con la función path(), en este caso, estamos englobando todas las rutas bajo el path /django-basic-app/. Esto nos permitirá manejar la aplicación Django como se requiere en cPanel. El hecho de definir toda la aplicación bajo un mismo path es un requisito fundamental para más adelante poder desplegarla en cPanel. En caso de que no vayas a desplegar tu aplicación en un cPanel, no tendrías por qué hacerlo, podrías dejar toda la aplicación bajo el path raíz /.

from django.contrib import admin
from django.urls import path, include
from controllers.home import home

urlpatterns = [
   path(
       "django-basic-app/",
       include(
           [
               path("admin/", admin.site.urls),
               path("", home, name="home"),
           ]
       ),
   ),
]

Podemos observar que he dejado declaradas las rutas del panel de administración de Django bajo la ruta `/django-basic-app/admin` y he declarado otra ruta nueva vacía para manejar las peticiones de la ruta `/django-basic-app` dejando el path vacío en la definición de la ruta. Esta última ruta la estoy apuntando a un controlador definido en el directorio `controllers/home.py` que he creado en mi proyecto para ubicar los ficheros del controlador.

Como se puede observar, esta función de controlador es muy sencilla; solamente retorna una cadena de texto como respuesta.

from django.http import HttpResponse

def home(request):

   return HttpResponse(
       "El servidor Python + Django está funcionando correctamente en cPanel"
   )

Para probar en nuestra máquina local que la aplicación Django funciona, podemos ejecutar el comando:

$ .venv/bin/python manage.py runserver

Lo que ejecutará es un pequeño servidor HTTP en local que maneja nuestra aplicación, y este se servirá en http://127.0.0.1:8000/. Ahora podrás acceder desde tu navegador a esta URL para probar las rutas definidas en tu proyecto. Para apagar el servidor, puedes posicionarte en la terminal y pulsar Control + C.

En este caso, estoy accediendo a la ruta que hemos definido anteriormente y podemos observar que el servidor responde lo que hemos definido en la función homede nuestro controlador, lo que indica que todo está funcionando correctamente.

¿Cómo crear una página que usa recursos de frontend, JavaScript, CSS y ficheros estáticos?

La mayoría de aplicaciones web, necesitan servir ficheros estáticos como assets, imágenes o documentos o recursos de código para el front-end como código JavaScript o CSS. Para conseguir servir estos ficheros existen muchas formas de hacerlo dependiendo del framework o la herramienta de bundler que se use en cada proyecto para buildear el código del frontend y los assets de la aplicación.

Existen muchas herramientas de este estilo como Vite o Webpack y en cada caso la integración con Django para servir los recursos y ficheros estáticos puede variar. En nuestro caso, vamos a utilizar Webpack. Para esto, definimos al principio la dependencia ´python-webpack-boilerplate´ en el requirements.txt de nuestro proyecto. Este es el paquete que nos va a permitir hacer la integración entre Django y Webpack de manera sencilla.

Como ya incluimos el paquete en nuestras dependencias inicialmente, debemos instalarlo en nuestra aplicación. Para ello, nos dirigiremos el fichero de configuración `settings.py` a la constante definida como `INSTALLED_APPS` y definiremos un nuevo elemento en el array de esta manera:

INSTALLED_APPS = [
   "django.contrib.admin",
   "django.contrib.auth",
   "django.contrib.contenttypes",
   "django.contrib.sessions",
   "django.contrib.messages",
   "django.contrib.staticfiles",
   "webpack_boilerplate",
]

Esto lo hacemos para indicarle a Django que debe tener en cuenta el paquete de Webpack boilerplate. Una vez hecho esto, ya tendremos a nuestra disposición los comandos del paquete para ejecutar en el `manage.py` de Django.

También tendremos que añadir en el fichero de configuración la siguiente constante:

WEBPACK_LOADER = {
   "MANIFEST_FILE": f"{BASE_DIR}/frontend/build/manifest.json",
}

Para indicarle a Django dónde está el fichero manifest.json de las builds que genere Webpack.

Ahora vamos a ejecutar el comando de instalación del paquete de esta manera:

$ .venv/bin/python manage.py webpack_init

Cuando ejecutes el comando, te pedirá tomar 3 decisiones:

1. El nombre del directorio donde quieres que se almacenen los ficheros del frontend y de webpack. Por defecto, creará el directorio “frontend” si damos directamente a ente o podremos definir el de nuestra preferencia.

2. Nos preguntará sobre dónde queremos instalar las dependencias de Node con NPM, por defecto lo hará en la raíz del proyecto, si escogemos la opción por defecto pulsando enter. Esta suele ser la opción más conveniente y no definir un path concreto.

3. Solicitará qué tecnología o framework de CSS queremos utilizar, no dará las opciones de Tailwind, Bootstrap o SCSS. Por simplificar, en mi caso utilizaré SCSS, ya que es una aplicación sencilla, pero esta decisión depende totalmente de tu caso y la tecnología con la que quieras trabajar.

Como vemos, una vez terminada la ejecución del comando webpack_init, se han creado muchos ficheros y directorios nuevos. Lo principal es que se ha hecho una instalación de NPM en nuestro proyecto, por eso han aparecido los ficheros package.jsony package-lock.json. También hay otros ficheros de configuraciones específicas como de Postcss, o del linter de JavaScript Eslint, pero estos ficheros son funcionalidades concretas que no me meteré a explicar, ya que no es necesario para un ejemplo básico.

Ahora debemos instalar las dependencias de Node que se han declarado ejecutando el comando:

$ npm install

Como sucede en muchos frameworks y herramientas, la instalación de Webpack boilerplate ya viene con un ejemplo funcional. En nuestro caso, vamos a eliminar los ficheros innecesarios del ejemplo del paquete que no nos son de utilidad.

Podemos eliminar la carpeta `frontend/vendors’ y el fichero `frontend/src/components/jumbotron.js’.

También tenemos que hacer algunas modificaciones en otros ficheros para dejarlos limpios.

El fichero frontend/src/application/app.js debemos dejarlo vacío, solamente con la importación del fichero scss.

import "../styles/index.scss";

El fichero frontend/src/styles/index.scss debemos dejarlo vacío, eliminando la clase .jumbotron que se ha autogenerado.

Y en el fichero frontend/webpack/webpack.common.js debemos eliminar la siguiente línea, para dejar de tener en cuenta la carpeta vendors que hemos borrado.

Ahora que ya tenemos la instalación del frontend sin el ejemplo de Webpack por defecto.Está lista para empezar a construir nuestra aplicación de ejemplo.

Para buildear todos los recursos frontend de nuestra aplicación y que se sirvan correctamente, debemos ejecutar el comando:

$ npm run build

Mientras desarrollamos, para no tener que estar ejecutando el comando build cada vez que cambiamos algún código JS o CSS, podemos ejecutar el comando watch que nos permitirá refrescar automáticamente nuestra build cuando se detecten cambios en nuestro código, lo que facilita mucho el proceso de desarrollo del frontend:

$ npm run watch

Para crear una página, vamos a utilizar un template de Django, que ubicaremos en un nuevo directorio llamado “templates” en la raíz de nuestro proyecto.

Esta contendrá un template de renderizado básico, donde dispondremos el siguiente código de template de Django:

{% load webpack_loader static %}

<!DOCTYPE html>
<html>

<head>
   <title>Ejemplo Python + Django</title>
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   {% stylesheet_pack 'app' %}
</head>
    <body>
        <div>
            <h1>Aplicación Python + Django</h1>
            <img src="{% static 'image.webp' %}" />
            <p id="description"></p>
        </div>
        {% javascript_pack 'app' %}
    </body>
</html>

En este template definimos un HTML básico cargando los recursos Javascript y CSS de Webpack que tenemos en nuestro directorio “frontend” y definiendo en el body los elementos de un título, una imagen y un párrafo vacío.

Para configurar nuestro nuevo directorio de templates en Django, debemos dirigirnos a la configuración en el fichero `settings.py` y buscar la constante TEMPLATES y añadir la siguiente línea:

TEMPLATES = [
   {
       "BACKEND": "django.template.backends.django.DjangoTemplates",
       "DIRS": [f"{BASE_DIR}/templates"],
       "APP_DIRS": True,
       "OPTIONS": {
           "context_processors": [
               "django.template.context_processors.debug",
               "django.template.context_processors.request",
               "django.contrib.auth.context_processors.auth",
               "django.contrib.messages.context_processors.messages",
           ],
       },
   },
]

Nuestro fichero de código SCSS ubicado en frontend/src/styles/index.scss se transpilará a código CSS presente en nuestros recursos declarados en el template. Para dar estilo al título de la etiqueta <h1> del HTML, añadiremos el siguiente código:

h1 {
 color: #dc1b1b;
 text-shadow: 2px 2px 4px #00000080;
}

En nuestro código Javascript ubicado en frontend/src/application/app.js, escribiremos el siguiente código que cogerá el elemento <p> con el id description e insertará texto:

// This is the style entry file

import "../styles/index.scss";

window.onload = () => {
 const description = document.getElementById("description");
 description.innerText = "Este texto fue insertado desde el Javascript de nuestra aplicación";
};

Para insertar la imagen, tendremos que añadir el fichero de la imagen en un directorio de ficheros estáticos que crearemos. En mi caso, he creado la carpeta de ficheros estáticos en frontend/statics/ y ahí he añadido la imagen que quiero servir. Este mismo proceso se puede aplicar para servir cualquier fichero estático que queramos desde nuestra aplicación Django.

Una vez creada nuestra carpeta de ficheros estáticos, tenemos que declararla en la configuración de Django y en nuestras rutas.

Para declarar las rutas de ficheros estáticos en nuestro proyecto, debemos añadir lo siguiente en nuestro fichero `urls.py`:

from django.contrib import admin
from django.urls import path, include
from django_basic_app.controllers.home import home
from django.contrib.staticfiles.urls import staticfiles_urlpatterns # Importar esta función

urlpatterns = [
   path(
       "django-basic-app/",
       include(
           [
               path("admin/", admin.site.urls),
               path("", home, name="home"),
           ]
       ),
   ),
]

urlpatterns += staticfiles_urlpatterns() # Concatenar las rutas de ficheros estáticos

Para servir los estáticos, debemos añadir lo siguiente en nuestro fichero `settings.py`:

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/4.2/howto/static-files/

STATICFILES_DIRS = [
   f"{BASE_DIR}/frontend/statics",
   f"{BASE_DIR}/frontend/build",
]
STATIC_ROOT = f"{BASE_DIR}/staticfiles"

STATIC_URL = "django-basic-app/static/"

Estas tres constantes de configuración sirven para:

• STATICFILES_DIRS: Define un array con los paths de los directorios en los que tenemos ficheros estáticos. En nuestro caso, está la carpeta frontend/static que acabamos de crear y la carpeta frontend/build que es donde se generarán los ficheros JS y CSS de la build de Webpack una vez ejecutado el comando npm run build.

• STATIC_ROOT: Define un directorio en el que Django reunirá una copia de nuestros ficheros estáticos para tenerlos todos centralizados en un solo sitio una vez ejecutemos el comando de Django collectstatic. Esta es la forma de trabajar los ficheros estáticos del framework.

• STATIC_URL: Esta es la URL desde la que queremos servir los ficheros estáticos, en este caso la establecemos desde el mismo path en el que servimos toda la aplicación, seguido del path “static”.

Una vez tenemos definida esta configuración, podemos ejecutar el comando de collectstatic de Django:

$ .venv/bin/python manage.py collectstatic

Una vez ejecutado, debemos observar que se ha creado la carpeta que hayamos definido en STATIC_ROOT, en este caso la carpeta llamada “staticfiles” en la raíz del proyecto. Esta debe contener una copia de todos los archivos estáticos de nuestra app.

Ahora que ya hemos preparado todos los recursos JavaScript, CSS y ficheros estáticos que necesitamos en nuestro template, vamos a definir cómo renderizarlo desde nuestro controlador `controllers/home.py`.

from django.shortcuts import render

def home(request):

   return render(request, "home.html")

Aquí estamos definiendo que en la ruta raíz de nuestra app /django-basic-app/ , que está controlada por nuestra función home, debemos de renderizar el template que acabamos de crear. En esta función podríamos hacer operaciones como pasar variables o realizar cualquier cálculo o acción del backend que necesitemos, en este caso solamente renderizo el template.

Si todo ha salido correctamente, podemos ejecutar los comandos:

$ npm run build
$ .venv/bin/python manage.py runserver

Así construiremos la build del frontend y ejecutaremos el servidor local de Django para probar la aplicación. Si accedemos a la URL http://127.0.0.1:8000/django-basic-app/ en nuestro navegador, podremos observar que todo funciona correctamente, el título se estiliza según hemos definido en el CSS de nuestra aplicación, la imagen se sirve desde los ficheros estáticos correctamente y el párrafo se rellena desde el código JavaScript.

Si no sucede correctamente alguna de estas cuestiones, revisa ese punto en concreto en esta guía o busca tu error concreto en un buscador como Google o ¡Pregunta a una inteligencia artificial sobre tu problema!

¿Cómo desplegar la aplicación en cPanel?

Ahora en Raiola Networks ofrecemos en nuestros hostings cPanel, una herramienta especialmente diseñada para desplegar aplicaciones Python de forma fácil e intuitiva.

Lo primero que debemos hacer para poder desplegar nuestra aplicación Django, es adaptar la aplicación al protocolo WSGI (Web Server Gateway Interface), este protocolo sirve para que aplicaciones de servidor web como las hechas con Django o Flask se puedan comunicar con programas de servidor como Apache o Nginx.

En esencia el WSGI de nuestra aplicación, va a ser un fichero de código Python que creará un objeto de Python con una interfaz concreta de métodos que servirá para que el programa de servidor que se use pueda bootear nuestra aplicación y comunicarse con ella por medio de este objeto de WSGI para mandarle las peticiones y que este genere las respuestas HTTP.

Para adaptar el WSGI y que trabaje correctamente con cPanel, debemos de modificar el fichero `wsgi.py` de nuestra aplicación y dejarlo de esta manera:

"""
WSGI config for django_basic_app project.


It exposes the WSGI callable as a module-level variable named ``application``.


For more information on this file, see
https://docs.djangoproject.com/en/4.2/howto/deployment/wsgi/
"""


import os
import sys
from django.core.wsgi import get_wsgi_application
import django.core.handlers.wsgi


SCRIPT_NAME = os.getcwd()


sys.path.append(SCRIPT_NAME)


# ¡IMPORTANTE! En este punto debes igualar esta variable de entorno
# al valor [Nombre de la carpeta donde se encuentran los ficheros
# Python de tu aplicación].settings
# En mi caso este directorio se llama django_basic_app, por lo que
# el valor que debo poner es "django_basic_app.settings"
os.environ["DJANGO_SETTINGS_MODULE"] = "django_basic_app.settings"


class PassengerPathInfoFix(object):
   """
   Sets PATH_INFO from REQUEST_URI because Passenger doesn't provide it.
   """


   def __init__(self, app):
       self.app = app


   def __call__(self, environ, start_response):
       from urllib.parse import unquote


       environ["SCRIPT_NAME"] = SCRIPT_NAME
       request_uri = unquote(environ["REQUEST_URI"])
       script_name = unquote(environ.get("SCRIPT_NAME", ""))
       offset = (
           request_uri.startswith(script_name) and len(environ["SCRIPT_NAME"]) or 0
       )
       environ["PATH_INFO"] = request_uri[offset:].split("?", 1)[0]
       return self.app(environ, start_response)




application = get_wsgi_application()
application = PassengerPathInfoFix(application)

Es importante que iguales la variable de entorno DJANGO_SETTINGS_MODULE de la siguiente manera:

os.environ["DJANGO_SETTINGS_MODULE"] = "[Nombre de la carpeta donde se encuentran los ficheros Python de tu aplicación].settings"

En mi caso, la carpeta donde se encuentran los ficheros .py de mi aplicación, se llama django_basic_app, entonces debo igualar la variable de entorno DJANGO_SETTINGS_MODULE al valor django_basic_app.settings, pero en tu caso debes adaptarla a cómo se llame tu directorio principal de Django. Esta variable de entorno sirve para indicar al WSGI dónde se encuentra tu fichero de settings de Django y es un paso imprescindible para que pueda funcionar correctamente.

También es imprescindible indicar a Django en su configuración que permita funcionar la aplicación montada sobre un nombre de tu host o dominio concreto. En este caso será el dominio de mi servidor cPanel.

ALLOWED_HOSTS = ["enriquesv.webcloud.es"]

Como consideración extra para la configuración de Django, podemos fijarnos en la constante DEBUG. Esta constante, por defecto, tiene asignado el valor True, pero cuando estés utilizando tu aplicación en producción, deberías ponerla en False. Esta variable maneja el debugger web de Django, el cual muestra información sobre los errores de tu aplicación cuando suceden en las respuestas HTTP. Esto está bien para desarrollar en local o para probar inicialmente tu aplicación en producción, pero una vez te asegures de que todo funciona correctamente, deberías de negar esta constante para desactivar el debugger, ya que de lo contrario podrías exponer información sensible y, potencialmente, permitir vulnerabilidades en tu aplicación.

DEBUG = False

Para desplegar nuestra aplicación Python, debemos comprimir nuestro proyecto en un fichero .zip para subirlo a nuestro hosting cPanel. Para esto podemos utilizar herramientas gratuitas como WinRar o 7-Zip para Windows o en el caso de macOS, hacemos clic derecho sobre la carpeta de nuestro proyecto y la opción de “Comprimir” . En caso de Linux, podemos utilizar el comando `zip -r archive.zip dir_to_zip`.

Para subir el proyecto comprimido, nos tenemos que dirigir a la herramienta de “Administrador de archivos” en el menú de herramientas de cPanel. O subir el archivo por SSH o FTP si tenemos estos protocolos habilitados en nuestro hosting cPanel.

Para el ejemplo, utilizaremos la opción del “Administrador de archivos” de la sección “Archivos”. Una vez dentro del administrador, pulsaremos la opción de “Cargar”.

Ahí cargaremos nuestro fichero comprimido .zip y esperaremos a que se complete la subida.

Una vez subido, podremos verlo en nuestra carpeta de usuario de cPanel. Podría tardar unos segundos en aparecer, sé paciente.

Ahora tendremos que descomprimir el proyecto en la carpeta de nuestro usuario, haciendo clic derecho sobre la carpeta y eligiendo la opción de “Extract” o seleccionando el fichero y eligiendo la misma opción en el menú de operaciones de la parte superior.

Aparecerá un menú modal para indicar en qué ruta de nuestro hosting queremos extraer el proyecto. Simplemente, podemos dejar la opción vacía para indicar que lo queremos en la carpeta de nuestro usuario (es en la misma que nos encontramos posicionados) o podemos indicar la ruta de nuestra preferencia. Haz clic en “Extract Files” y espera a que se descomprima el proyecto.

Una vez descomprimido, deberíamos ver la nueva carpeta entre los archivos de nuestra carpeta de usuario.

Si hemos descomprimido correctamente la aplicación, deberíamos ver la carpeta de nuestro proyecto, en mi caso se llama django-basic-app.

Ahora que ya tenemos nuestro proyecto descomprimido en nuestra carpeta de usuario, vamos a desplegar la aplicación. Para ello, tenemos que llegar a la herramienta de despliegue de aplicaciones Python. En el menú de herramientas de nuestro cPanel, vamos a dirigirnos a la sección de “Software” y ahí buscaremos la opción “Setup Python App”.

Una vez dentro, buscaremos el botón “Create Application”.

Cuando entremos al menú para crear la aplicación, veremos lo siguiente:

Tenemos el campo “Python version”, donde debemos seleccionar la versión de Python de nuestra conveniencia, normalmente la misma versión en la que hemos desarrollado nuestra aplicación en local. En mi caso, seleccionaré la 3.9.21. Tú selecciona la que te convenga, osea, la versión con la que hayas desarrollado la aplicación en local.

En el campo “Application root” deberemos indicar la ruta del directorio donde hemos posicionado nuestra aplicación, siempre partiendo desde el path de nuestro usuario de cPanel. En mi caso, el path completo con mi directorio de usuario es enriquesv/django-basic-app, pero en este campo indico solamente el directorio a partir de la carpeta de mi usuario, osea, solamente django-basic-app.

En el campo “Application URL” debemos indicar cuál es la ruta en la que queremos que se sirva nuestra aplicación en nuestro hosting cPanel. Es muy importante que esta ruta coincida con las rutas que hemos declarado en Django en nuestra aplicación. Siempre debemos de configurar nuestras rutas de Django a partir de una misma ruta raíz para desplegar sobre el mismo path que en cPanel. En mi caso, esta ruta es /django-basic-app.

En el campo “Application startup file” tenemos que indicar cuál es el fichero en el que se debe de arrancar nuestra aplicación, siempre va a ser el fichero `wsgi.py` .

En el campo “Application Entry point” debemos especificar el nombre del objeto Python que hemos creado en el fichero `wsgi.py` , en nuestro caso este tiene la referencia `application` .

También tenemos la posibilidad de añadir o sobrescribir variables de entorno de Python en la sección “Environment variables” para el contexto de ejecución de nuestra aplicación. En nuestro caso no necesitamos trabajar con las variables de entorno.

Una vez tengamos todo correctamente establecido, hacemos clic en el botón “Create”. Y cuando se haya creado la aplicación, aparecerá de esta manera:

Tenemos las opciones de parar la ejecución de nuestra aplicación con el botón “Stop App” o de reiniciarla, con el botón “Restart”.

Podemos modificar las mismas opciones que en la creación, por si nos hemos confundido al definir algún campo y reiniciar la aplicación para que se apliquen los cambios.

Para instalar las dependencias de pip de nuestro proyecto, debemos dirigirnos a la parte “Configuration files”, donde añadiremos el fichero requirements.txt de nuestro proyecto, que es el que define las dependencias de Python. Escribimos el nombre del fichero en la caja de texto y pulsamos sobre el botón “Add” para añadir este fichero.

Una vez añadido, podremos pulsar sobre el botón “Run Pip Install” y seleccionar el fichero que acabamos de añadir. Esto ejecutará el comando de instalación de pip sobre el requirements.txt de nuestro proyecto e instalará las dependencias.

Una vez instaladas correctamente, deberíamos ver el siguiente mensaje.

Dependiendo de la versión de Python seleccionada, si no estás posicionado en la versión correcta o en la misma en la que has desarrollado tu aplicación en local, podrías encontrarte con un mensaje de incompatibilidad de las versiones de las dependencias que intentas instalar. Si esto sucede, deberías revisar las versiones de las dependencias compatibles con la versión de Python con la que estás desplegando la aplicación. Para aplicar los cambios necesitas pulsar el botón “Restart” para reiniciar la aplicación.

Una vez instaladas las dependencias, podríamos tener la necesidad de ejecutar comandos de Django sobre el proyecto, para recopilar los ficheros estáticos, para migrar la base de datos o cualquier otra operación que se pueda ejecutar en Django con el `manage.py` . Para eso está la sección “Execute python script”.

Por ejemplo, podríamos ejecutar el comando para recolectar los ficheros estáticos de nuestra aplicación de la siguiente manera:

En el caso de nuestra aplicación, como ya habíamos recolectado los ficheros estáticos y migrado la base de datos SQLlite antes de subir la aplicación a cPanel, no haría falta hacerlo, pero puede que en tu caso, si que necesites ejecutar cualquier comando de Django.

No existe actualmente un acceso directo en la herramienta para reinstalar las dependencias de Node, por lo que tenemos que subir la aplicación con la build de Webpack ya realizada. Si lo haces de esta manera, no deberías necesitar ejecutar comandos de NPM para instalar dependencias Node y hacer la build a posteriori.

Si todo ha salido correctamente, accediendo a la ruta definida de nuestro hosting, deberíamos ver que la aplicación responde correctamente.

Espero que esta guía te haya podido servir como punto de partida para aprender a desplegar aplicaciones Python en cPanel y entender los conceptos y posibles problemas que pueden surgir en el proceso.

Si necesitas ayuda para poner a funcionar tu hosting con Python en Raiola Networks, puedes contactar con nuestro departamento de soporte técnico desde nuestra área de clientes o mediante teléfono.