¿Cómo construir e implementar una aplicación de Python?

Python es un lenguaje de programación gratuito y de código abierto que tiene muchas aplicaciones. Fue creado por Guido Van Rossum en 1991 y desde entonces se ha convertido en uno de los lenguajes de programación más populares.

En este artículo, hablaremos sobre Python, sus ventajas, desventajas, casos de uso y opciones de implementación. Además de eso, demostraremos cómo compilar, dockerizar e implementar una aplicación de Python simple en los contenedores de Back4app.

Siga leyendo para obtener más información sobre cómo compilar e implementar un proyecto de Python.

Descripción general de Python

Python es un lenguaje de programación de propósito general de alto nivel. Se interpreta, se escribe dinámicamente y se puede utilizar tanto para secuencias de comandos como para programación. Los desarrolladores suelen describir Python como un lenguaje con “baterías incluidas” debido a su extensa biblioteca estándar.

El lenguaje apareció por primera vez en 1991 y desde entonces se ha convertido en uno de los lenguajes de programación más populares y amados debido a su sintaxis simple y legible. Los principales principios de diseño de Python están cubiertos en The Zen of Python escrito por Tim Peters.

Python tiene una gran comunidad de desarrolladores y paquetes listos para usar. En estos días, Python se usa prácticamente en cualquier lugar: en la administración de servidores, computación científica, aprendizaje automático, creación de API RESTful, etc. Python podría considerarse una de las habilidades esenciales de un desarrollador moderno.

Ventajas de Python

Fácil de usar

Python es uno de los lenguajes más fáciles de usar y aprender. Su curva de aprendizaje es casi inexistente porque su principal filosofía de diseño enfatiza la simplicidad y la legibilidad del código. Python también se ve favorecido en la educación porque es una gran herramienta para aprender conceptos básicos de programación.

Desarrollo rápido

Otra gran ventaja de Python es que permite un desarrollo rápido. Es un gran lenguaje para crear prototipos y hacer el trabajo rápido. Al usar Python, no tiene que preocuparse por la sintaxis compleja, la asignación de memoria, etc., sino que puede concentrarse en su aplicación.

Versátil

Python es uno de los lenguajes de programación más versátiles. Se utiliza en una amplia gama de industrias y campos. Algunos de los campos en los que se usa Python incluyen contabilidad, investigación científica, ciencia de datos, desarrollo web, desarrollo de juegos y automatización.

Portátil

Python es un lenguaje portátil ya que se interpreta (como Java) y no se compila (como C++). Esto significa que el código escrito en una plataforma se puede transferir fácilmente a otra plataforma. Eso hace que Python sea una opción popular para los desarrolladores que necesitan admitir múltiples plataformas, incluidas Windows, macOS, Linux y Android.

Bibliotecas Extensas

El lenguaje de programación Python está respaldado por una gran comunidad de desarrolladores. Hay una biblioteca para casi cualquier cosa que pueda imaginar. Algunas de las bibliotecas más populares incluyen:

• Desarrollo Web (Django, Flask, FastAPI)
• Aprendizaje automático y ciencia de datos (TensorFlow, PyTorch)
• Visión artificial (OpenCV, Pillow, Scikit-image)
• Computación científica (NumPy, SciPy)
• Interfaz gráfica de usuario (Qt , GTK)

Y eso apenas araña la superficie. Si desea ver una lista completa de los increíbles paquetes de Python, eche un vistazo a awesome-python en GitHub.

Escrito dinámicamente

Python es un lenguaje de tipo dinámico, lo que significa que no es necesario declarar el tipo de datos al crear variables. El tipo de variable solo se asigna cuando se está ejecutando el código.

Por muy bueno que sea, los lenguajes dinámicamente tipados a veces pueden ser una espada de doble filo. Por lo general, son más propensos a errores y tienen un nivel más bajo de control de memoria en comparación con los lenguajes escritos estáticamente.

Extensible

Si los requisitos de su proyecto incluyen tareas de cómputo pesado, puede escribirlas en lenguajes más rápidos como C o C++ y luego invocarlas desde su código Python.

Para obtener más información sobre cómo invocar C/C++ desde Python, consulte este excelente artículo.

Limitaciones de Python

Mal desempeño

Python es relativamente lento en comparación con otros lenguajes de programación. Los dos factores que más dificultan su rendimiento son que Python es un lenguaje interpretado y tipificado dinámicamente. Si los requisitos de su proyecto incluyen computación pesada o subprocesos múltiples, es posible que Python no sea la herramienta más adecuada. Estará mucho mejor usando C, C++ o algún otro lenguaje compilado.

Memoria intensiva

Los programas de Python, en comparación con los programas escritos en lenguajes de tipo estático, suelen consumir más memoria y proporcionan un menor nivel de control sobre la memoria. Esto puede ser un poco problemático si sus aplicaciones necesitan tener un uso eficiente de la memoria.

Propenso a errores de tiempo de ejecución

Python, al ser un lenguaje interpretado, es más propenso a errores de tiempo de ejecución. Dado que no hay errores en el proceso de compilación, no se pueden descubrir en tiempo de compilación. Además de eso, Python se escribe dinámicamente, lo que significa que los desarrolladores pueden cambiar el tipo de una variable en cualquier momento. Esto a veces puede conducir a errores y requiere que los desarrolladores tengan en cuenta los tipos de variables.

Bloqueo de intérprete global (GIL)

El bloqueo de intérprete global (GIL, del inglés “Global Interpreter Lock”) en Python es un mecanismo que garantiza que solo un subproceso ejecute el código de bytes de Python a la vez. Si bien esto simplifica la implementación del lenguaje y brinda algunos beneficios de rendimiento para ciertos tipos de programas, también limita la capacidad de utilizar completamente los procesadores multinúcleo en aplicaciones vinculadas a la CPU.

No optimizado para el acceso a la base de datos

Trabajar con bases de datos en aplicaciones de Python puede ser más desafiante debido a la falta de interfaces potentes y fáciles de usar como Java Database Connectivity (JDBC). Si bien Python todavía se puede usar para operaciones de bases de datos que involucran tareas simples de lectura y escritura, puede que no sea la opción más adecuada para aplicaciones que necesitan trabajar con bases de datos grandes y complejas.

Opciones de implementación de Python

Las aplicaciones de Python se pueden implementar en varias plataformas en la nube. En general, podemos dividirlos en las siguientes tres categorías:

• Infraestructura como servicio (IaaS)
• Plataforma como servicio (PaaS)
• Contenedores como servicio (CaaS)

IaaS es el menos abstracto y CaaS es el más abstracto. También existe el alojamiento convencional, pero estoy bastante seguro de que ya está familiarizado con eso.

Infraestructura como servicio (IaaS)

La infraestructura como servicio o IaaS es un modelo de computación en la nube en el que un proveedor externo ofrece recursos informáticos virtualizados, como servidores, almacenamiento, sistemas operativos y redes a través de Internet. Los recursos proporcionados se pueden administrar a través de paneles avanzados o API de alto nivel, lo que brinda a los clientes un control total sobre toda su infraestructura.

Los principales beneficios de IaaS son la escalabilidad, el ahorro de costos, mayor soporte, rendimiento y seguridad. La estructura de pago adoptada por la mayoría de los proveedores de IaaS se basa en un sistema de pago por uso, en el que solo incurre en cargos por los recursos que utiliza.

IaaS es el modelo de computación en la nube más flexible y sigue siendo la opción más popular desde su lanzamiento a principios de la década de 2010. El mayor inconveniente es que el cliente es totalmente responsable de sus aplicaciones, sistemas operativos y datos.

Los ejemplos de IaaS más populares son:

• Microsoft Azure
• Amazon Web Services (AWS)
• Google Cloud Platform (GCP)
• Oracle Cloud Infrastructure (OCI)
• DigitalOcean

Plataforma como servicio (PaaS)

Platform as a Service (PaaS) es un servicio de computación en la nube que brinda a los usuarios un entorno en la nube para crear, administrar y entregar aplicaciones. PaaS ofrece herramientas prediseñadas para el desarrollo, la personalización y las pruebas de aplicaciones. Con PaaS, los usuarios pueden concentrarse en su aplicación, ya que el proveedor de servicios se encarga de la infraestructura subyacente, incluidos los servidores, los sistemas operativos, el software, las copias de seguridad y más.

Los beneficios de PaaS incluyen una mayor velocidad de comercialización, mayor seguridad, rentabilidad, escalabilidad, alta disponibilidad y, en general, requiere menos código. Sin embargo, hay algunas desventajas. Las tres desventajas principales son la falta de flexibilidad, la falta de control y el riesgo de bloqueo del proveedor. No obstante, PaaS aún permite a los usuarios crear aplicaciones más rápidamente y con menos gastos generales de administración.

Los proveedores de PaaS incluyen:

• Heroku
• Fly.io
• Render
• DigitalOcean App Platform
• Microsoft Azure App Service

Contenedores como servicio (CaaS)

Containers as a Service (CaaS) es un modelo de computación en la nube que permite a las organizaciones cargar, ejecutar, escalar y administrar sus contenedores mediante el uso de tecnología de virtualización de contenedores. Los proveedores de CaaS abstraen gran parte del trabajo requerido, como la infraestructura, los sistemas operativos, el software, los motores de contenedores y más.

Lo bueno de los contenedores es que una vez que su aplicación está en un contenedor, puede implementarla prácticamente en cualquier lugar y se garantiza que se comportará de la misma manera. Si surge la necesidad, puede pasar de un proveedor de CaaS a otro. A los clientes de CaaS normalmente se les factura por contenedor (según las especificaciones del contenedor).

CaaS es generalmente más costoso en comparación con IaaS y PaaS, ofrece un nivel más bajo de flexibilidad y control y requiere un trabajo inicial, por ejemplo. acoplar la aplicación, etc. Sin embargo, es uno de los modelos de computación en la nube más fáciles de usar una vez que su aplicación está en un contenedor.

Algunos de los mejores proveedores de CaaS incluyen:

• Back4app Containers
• Amazon Elastic Container Service (ECS)
• Google Kubernetes Engine (GKE)
• Red Hat OpenShift
• Rancher

Para obtener más información sobre los contenedores, consulte ¿Qué son los contenedores en la computación en la nube?

Proceso de implementación de Python

En esta sección del tutorial, demostraremos cómo crear e implementar una aplicación de Python simple paso a paso. La aplicación web se implementará utilizando el marco Flask y se implementará en Back4app Containers.

Requisitos previos

• Experiencia con Python y Flask
• Comprensión básica de Docker
• Python versión 3.8 o posterior y Docker Desktop instalado

¿Qué es Back4app Containers?

Back4app Containers es una plataforma gratuita y de código abierto que le permite implementar y escalar aplicaciones utilizando contenedores distribuidos globalmente. Con Back4app Containers, puede concentrarse en crear su software y enviarlo rápidamente, sin tener que preocuparse por DevOps.

La plataforma está estrechamente integrada con GitHub y viene equipada con un sistema CI/CD integrado. Al usar los contenedores de Back4app, podrá tener su aplicación en línea en cuestión de minutos.

¿Por qué usar Back4app Containers?

• Se integra bien con GitHub
• Implementaciones escalables y sin tiempo de inactividad
• Extremadamente fácil de usar
• Excelente atención al cliente

Introducción al proyecto

En este artículo, crearemos e implementaremos una API RESTful simple que servirá como una lista de COSAS PARA HACER. La API web permitirá a los usuarios realizar operaciones CRUD básicas, como agregar tareas, eliminar tareas, marcarlas como completadas, etc. Primero trabajaremos en el código fuente y luego lo implementaremos en Back4app Containers. La aplicación web se implementará utilizando el marco web Flask.

Siéntase libre de omitir la sección “Aplicación de código” y seguir junto con su propio proyecto de Python.

Aplicación de código

Proyecto inicial

Comience por crear un directorio dedicado para la aplicación Flask y navegue hasta él:

$ mkdir flask-todo
$ cd flask-todo

Cree un entorno virtual y actívelo:

$ python3 -m venv venv && source venv/bin/activate

A continuación, instale Flask a través de pip:

$ (venv) pip install Flask==2.2.2

Para asegurarnos de que todo funcione, reemplacemos el contenido de app.py con lo siguiente:

# app.py

from flask import Flask

app = Flask(__name__)


@app.route('/')
def index_view():
    return {
        'detail': 'Hello world'
    }

Este código inicializa Flask y crea un punto final simple que devuelve un mensaje.

Inicie el servidor con:

$ (venv) flask run

Por último, navegue a http://localhost:5000/ en su navegador favorito. Debería ver un mensaje diciendo Hola mundo.

Base de datos

Avanzando, ocupémonos de la base de datos.

En lugar de ejecutar SQL sin procesar, usaremos Flask-SQLAlchemy, un ORM de Flask simple. Para instalarlo ejecute:

$ (venv) pip install Flask-SQLAlchemy

A continuación, reemplace el contenido de app.py con lo siguiente:

# app.py

from datetime import datetime

from flask import Flask, jsonify, request
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()
app = Flask(__name__)
app.config['SECRET_KEY'] = '5b3ef5s80gl3b217c20fb37044fe4k33'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///default.db"
db.init_app(app)


class Task(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(128), nullable=False)
    description = db.Column(db.String(256), nullable=False)

    is_done = db.Column(db.Boolean, default=False)
    created_at = db.Column(db.DateTime, default=datetime.now(), nullable=True)
    updated_at = db.Column(db.DateTime, default=None, nullable=True)

    def as_dict(self):
        return {c.name: getattr(self, c.name) for c in self.__table__.columns}

    def __repr__(self):
        return f'<Task {self.title}>'


@app.route('/')
def index_view():
    return {
        'name': 'flask-todo',
        'description': 'a simple todo app written in flask',
        'version': 1,
    }

Este código configura Flask y define un nuevo modelo llamado Task. El modelo de tareas tiene un name, description, is_done y algunas otras variables, como created_at y updated_at, que actualizaremos dinámicamente.

A continuación, cree un script de Python llamado init_db.py que inicialice y complete la base de datos SQLite:

# init_db.py

from app import db, app
from app import Task

with app.app_context():
    db.create_all()

    if Task.query.count() == 0:
        tasks = [
            Task(name='Backup the database', description='Make sure to backup the database with all the tables.'),
            Task(name='Setup 2FA', description='Setup the two factor authentication to secure your account.'),
            Task(name='Malware scan', description='Perform a malware scan.'),
        ]

        for task in tasks:
            db.session.add(task)

        db.session.commit()

Ejecute el script desde la línea de comando:

$ (venv) python init_db.py

Notará que se ha creado un nuevo directorio llamado instancia. Dentro del directorio, habrá default.db, que es la base de datos predeterminada.

API

La aplicación Flask tendrá las siguientes URL:

1. /api/ devuelve la lista de todas las tareas
2. /api/<task_id>/ muestra o elimina una tarea específica
3. /api/create/ crea una nueva tarea
4. /api/toggle/<task_id>/alterna la propiedad is_done de una tarea específica

Para implementarlos, agregue lo siguiente al final de app.py:

# app.py

@app.route('/api/')
def list_view():
    json = [task.as_dict() for task in Task.query.all()]
    return jsonify(json)


@app.route('/api/<int:task_id>/', methods=['GET', 'DELETE'])
def detail_view(task_id):
    task = db.get_or_404(Task, task_id)

    if request.method == 'DELETE':
        db.session.delete(task)
        db.session.commit()

        return {
            'detail': 'Task has been successfully deleted.'
        }
    else:
        return task.as_dict()


@app.route('/api/create/', methods=['POST'])
def create_view():
    name = request.form.get('name')
    description = request.form.get('name')

    if name is None or description is None:
        return {
            'detail': 'Please provide the name and the description.'
        }, 400

    task = Task(name=name, description=description)
    db.session.add(task)
    db.session.commit()

    return task.as_dict()


@app.route('/api/toggle/<int:task_id>/')
def toggle_view(task_id):
    task = db.get_or_404(Task, task_id)

    if task.is_done:
        task.is_done = False
    else:
        task.is_done = True

    task.updated_at = datetime.now()
    db.session.commit()

    return task.as_dict()

Este código es bastante auto explicativo. Definimos las rutas requeridas e implementamos la lógica requerida. Cada vez que queramos hacer cambios en la base de datos tenemos que hacer commit() de ellos.

Genial, eso es todo para la aplicación Flask. En las siguientes secciones, prepararemos nuestro proyecto para su implementación.

Gunicorn

El servidor web de Flask no se recomienda en producción, ya que está diseñado para manejar una solicitud a la vez y es posible que no pueda manejar grandes cantidades de tráfico. Debido a eso, intercambiémoslo con Gunicorn, un servidor Python WSGI listo para producción.

Primero, instálelo a través de pip:

$ (venv) pip install gunicorn==20.1.0

Después de la instalación exitosa, puede iniciar el servidor de la siguiente manera:

$ (venv) gunicorn -w 2 -b 0.0.0.0:5000 app:app

[INFO] Starting gunicorn 20.1.0
[INFO] Listening at: http://0.0.0.0:5000 (1)
[INFO] Using worker: sync
[INFO] Booting worker with pid: 3
[INFO] Booting worker with pid: 4

Tenga en cuenta que este comando solo funciona en sistemas operativos basados en UNIX.

Esto iniciará dos trabajadores de Gunicorn y expondrá su aplicación en el puerto 5000. Para acceder a su aplicación, abra su navegador web favorito y vaya a http://localhost:5000.

requirements.txt

Lo último que debemos hacer antes de dockerizar nuestra aplicación es crear un archivo requisitos.txt. El archivo requirements.txt se utiliza para especificar las dependencias del proyecto.

Genere ejecutando el siguiente comando:

$ (venv) pip freeze > requirements.txt

Otros (incluidos los contenedores de Docker) pueden utilizar el archivo requirements.txt de la siguiente manera:

$ (venv) pip install -r requirements.txt

Dockerizando la aplicación 

Para dockerizar la aplicación, usaremos un Dockerfile. Los Dockerfiles se utilizan para definir las instrucciones para crear imágenes de Docker. Le permiten configurar la imagen base, el directorio de trabajo, las variables de entorno, ejecutar comandos y más.

.dockerignore

Antes de trabajar en el Dockerfile, creemos un archivo .dockerignore. Se usa un archivo .dockerignore para especificar qué carpetas y archivos deben omitirse de la imagen.

.git/
.idea/
instance/
__pycache__/

Asegúrese de modificar .dockerignore según sus necesidades.

Dockerfile

Cree un nuevo archivo en la raíz del proyecto denominado Dockerfile con el siguiente contenido:

# syntax=docker/dockerfile:1.4
FROM --platform=$BUILDPLATFORM python:3.10-alpine

WORKDIR /app

# set environment variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# install the requirements
COPY requirements.txt /app
RUN --mount=type=cache,target=/root/.cache/pip \
    pip3 install -r requirements.txt

COPY . .

# initialize the database (create DB, tables, populate)
RUN python init_db.py

EXPOSE 5000/tcp

CMD ["gunicorn", "-w", "2", "-b", "0.0.0.0:5000", "app:app"]

Este Dockerfile utiliza python:3.10-alpine como imagen base. Luego establece el directorio de trabajo, instala los requisitos, copia el proyecto, inicializa la base de datos y, por último, inicia el servidor Gunicorn en el puerto 5000.

Para obtener más información sobre Dockerfiles, consulte la referencia de Dockerfile.

Prueba

Para asegurarnos de que Dockerfile funciona, podemos compilarlo y ejecutarlo localmente. Para construir la imagen ejecuta:

$ docker build -t flask-todo:1.0 .

Si enumera las imágenes, debería ver una nueva imagen:

$ docker images

REPOSITORY        TAG       IMAGE ID       CREATED       SIZE
flask-todo        1.0       7ege66240eb1   3 hours ago   109MB

Por último, use la imagen para activar un nuevo contenedor Docker:

$ docker run -it -p 5000:5000 flask-todo:1.0

[2023-02-02 20:08:57 +0000] [1] [INFO] Starting gunicorn 20.1.0
[2023-02-02 20:08:57 +0000] [1] [INFO] Listening at: http://0.0.0.0:5000 (1)
[2023-02-02 20:08:57 +0000] [1] [INFO] Using worker: sync
[2023-02-02 20:08:57 +0000] [7] [INFO] Booting worker with pid: 3
[2023-02-02 20:08:57 +0000] [8] [INFO] Booting worker with pid: 4

Puede usar -d para iniciar el contenedor Docker en modo separado. Lo que significa que el contenedor se ejecuta en el fondo de su terminal y no recibe entrada ni muestra salida.

Genial, su aplicación ahora se ejecuta en un contenedor. Navegue a http://localhost:5000 en su navegador web favorito para ver su aplicación web en acción.

{
    "name": "flask-todo",
    "description": "a simple todo app written in flask",
    "version": 1
}

Subir a GitHub

Los siguientes pasos requerirán que tenga una cuenta de GitHub. Si aún no tiene una, continúe y regístrese, de lo contrario, inicie sesión. Además, asegúrese de tener Git instalado y configurado.

Una vez que haya iniciado sesión en GitHub, use el botón “más” en la parte superior derecha de la pantalla para abrir el menú desplegable. A continuación, seleccione “Nuevo repositorio”:

Elija un nombre personalizado para su repositorio. Yo usaré “flask-todo”, luego haré clic en “Crear repositorio”:

Una vez que haya creado su repositorio, tome nota de la URL remota:

Ahora, regresemos a nuestro proyecto local y subamos el código.

Dado que tenemos algunos archivos que no queremos enviar a Git, cree un archivo .gitignore en la raíz del proyecto. Le agregaré lo siguiente, pero siéntase libre de modificarlo de acuerdo a sus necesidades:

instance/*
!instance/.gitignore
.webassets-cache
.env

__pycache__/
*.py[cod]
*$py.class

A continuación, abra la línea de comando y ejecute los siguientes comandos:

$ git init
$ git remote add origin <your_remote_url>
$ git add .
$ git commit -m "init"
$ git push origin master

Esto inicializará un nuevo repositorio de Git, agregará el origen remoto, VCS todos los archivos y creará la confirmación inicial. Por último, enviará el código fuente al repositorio de GitHub.

Genial, eso debería ser todo. Si ahora navega a su repositorio en su navegador, debería poder ver que todos los archivos fueron confirmados.

Implementar aplicación

Los siguientes pasos requerirán que tengas una cuenta Back4app. Si ya tiene una, inicie sesión, de lo contrario, continúe y regístrese para obtener la cuenta gratuita.

Una vez que inicie sesión, será redirigido al panel de control de su aplicación. Haga clic en el botón “Crear nueva aplicación” para iniciar el proceso de creación de la aplicación.

Back4app le permite crear e implementar dos tipos de aplicaciones, backend como servicio (BaaS) y contenedores como servicio (CaaS). Como queremos implementar una aplicación dockerizada, elegiremos “Contenedor como servicio”.

A continuación, continúe y conecte su GitHub con su cuenta Back4app. Asegúrese de dar permisos a Back4app para el repositorio que hemos creado en el paso anterior. Luego haga clic en el botón verde “Seleccionar” para seleccionarlo.

Back4app Containers le permite configurar el proceso de implementación. Puede establecer la rama predeterminada, el directorio raíz, habilitar/deshabilitar la implementación automática y establecer variables de entorno. No necesitamos nada de eso, así que simplemente nombremos nuestra aplicación y hagamos clic en “Crear aplicación”.

Back4app se tomará unos minutos para construir el contenedor, cargarlo en el registro del contenedor y ejecutar el contenedor. Una vez que su contenedor esté listo, el estado cambiará a “Listo” y podrá ver una URL verde en el lado izquierdo de la pantalla.

Al hacer clic en la URL, se abrirá la aplicación web en su navegador. Notará que Back4app emitió automáticamente un certificado SSL para su aplicación y le permite alojar una aplicación de Python de forma gratuita.

Conclusión

En este artículo, ha aprendido sobre Python, sus ventajas, desventajas y opciones de implementación. También implementó con éxito una API RESTful de Python simple. Ahora debería poder crear sus API simples e implementarlas en los contenedores Back4app.

El código fuente final se puede encontrar en GitHub.

Pasos futuros

• Por el momento, todos los datos se borran con cada reimplementación. Esto se debe a que la base de datos está incluida en la imagen de Docker. Considere cambiar a una instancia de base de datos administrada.
• Busque compilaciones de varias etapas para acelerar el proceso de implementación.

Preguntas frecuentes