Iniciadores Rápidos
¿Cómo construir un backend para Python?

41min
Introducción
En este tutorial paso a paso, aprenderás a construir un backend completo para aplicaciones de Python utilizando Back4App.
Recorreremos la integración de características esenciales de Back4App, como la gestión de bases de datos, funciones de Cloud Code, APIs REST y GraphQL, autenticación de usuarios y consultas en tiempo real, para crear un backend seguro, escalable y robusto que se comunique sin problemas con tu código Python.
Python es una opción popular entre los lenguajes de programación para el desarrollo de backend porque ofrece simplicidad y la capacidad de mantener el lado del servidor con facilidad.
Frameworks y bibliotecas como Django, Flask y más han hecho de Python una opción preferida para los procesos de desarrollo web.
Al aprovechar Back4App, un desarrollador de Python puede configurar rápidamente el esquema de la base de datos, garantizar la integridad de los datos e incluso incorporar tareas de aprendizaje automático sin tener que gestionar una infraestructura compleja.
A lo largo del camino, obtendrás experiencia práctica con funcionalidades clave, como características de seguridad avanzadas, programación de tareas con Cloud Jobs y configuración de webhooks para integraciones externas.
Al final de este tutorial, estarás bien preparado para mejorar esta estructura fundamental en una aplicación de backend de Python lista para producción o integrarte fácilmente con otras herramientas como Docker y Kubernetes a medida que tu proyecto crezca.
Esto dará un impulso a tu viaje de desarrollo de backend en Python utilizando una plataforma confiable y bibliotecas robustas de Python.
Requisitos previos
Para completar este tutorial, necesitarás:
Una cuenta de Back4App y un nuevo proyecto de Back4App
Comenzando con Back4App.
Regístrate gratis si aún no lo has hecho y crea un nuevo proyecto.
Python 3.x instalado
Asegúrate de tener Python 3.x configurado en tu máquina. Descargar Python.﻿
El SDK de Parse para Python
Instala a través de pip con pip install parse-rest. Usaremos este SDK para interacciones de datos.
Familiaridad con conceptos básicos de Python
Si eres nuevo en Python, revisa la Documentación oficial de Python. o un tutorial para principiantes.
Tener estos requisitos previos asegurará que puedas seguir mientras exploramos cómo construir un backend para Python en Back4App.
Paso 1 – Configuración del proyecto de Back4App
Crear un nuevo proyecto
El primer paso para construir tu backend de Python en Back4App es crear un nuevo proyecto. Si aún no has creado uno, sigue estos pasos:
Inicia sesión en tu cuenta de Back4App.
Haz clic en el botón “Nueva App” en tu panel de control de Back4App.
Dale un nombre a tu app (por ejemplo, “Python-Backend-Tutorial”).
﻿
Una vez que se crea el proyecto, lo verás listado en tu panel de control de Back4App. Este proyecto será la base para todas las configuraciones de backend discutidas en este tutorial.
Conectar el SDK de Parse
Back4App se basa en la Plataforma Parse para gestionar tus datos, proporcionar características en tiempo real, manejar la autenticación de usuarios, y más.
Para conectar tu código Python a Back4App, debes instalar el SDK de Parse correspondiente e inicializarlo con las credenciales de tu panel de control de Back4App.
Recupera tus Claves de Parse:
En tu panel de control de Back4App, navega a la Configuración de la Aplicación o a la Seguridad y Claves sección para encontrar tu ID de Aplicación y Clave API REST. También encontrarás la URL del Servidor Parse (a menudo https://parseapi.back4app.com).
﻿
Instala el SDK REST de Parse para Python:
Bash
pip install parse-rest
pip install parse-rest
﻿
Inicializa Parse en tu script de Python:
Típicamente, crearías un archivo (por ejemplo, parse_config.py) en tu proyecto:
parse_config.py
# parse_config.py
from parse_rest.connection import register

# Replace the placeholders with your Back4App credentials
APPLICATION_ID = "YOUR_APPLICATION_ID"
REST_API_KEY = "YOUR_REST_API_KEY"
PARSE_SERVER_URL = "https://parseapi.back4app.com"

# The register function initializes the connection
register(APPLICATION_ID, REST_API_KEY, master_key=None)
# parse_config.py
from parse_rest.connection import register

# Replace the placeholders with your Back4App credentials
APPLICATION_ID = "YOUR_APPLICATION_ID"
REST_API_KEY = "YOUR_REST_API_KEY"
PARSE_SERVER_URL = "https://parseapi.back4app.com"

# The register function initializes the connection
register(APPLICATION_ID, REST_API_KEY, master_key=None)
﻿
Este código asegura que cada vez que importes tu parse_config módulo en otra parte de tu aplicación Python, esté preconfigurado para conectarse a tu instancia específica de Back4App. Ahora has establecido una conexión segura entre tu código Python y el backend de Back4App.
Paso 2 – Configuración de la Base de Datos
Un esquema de base de datos robusto es esencial para el desarrollo de backend en Python. Las características de gestión de datos de Back4App te permiten definir tablas (clases), campos y relaciones, asegurando que puedas almacenar y recuperar datos fácilmente en tu marco web de Python o en cualquier otra biblioteca de Python que elijas.
Creando un Modelo de Datos
Back4App crea automáticamente esquemas de clase cuando guardas un objeto desde el código por primera vez, o puedes definir un esquema en el panel de control:
Navega a la sección “Base de datos” en tu panel de control de Back4App.
Crea una nueva clase (por ejemplo, “Todo”) y añade columnas relevantes, como título (String) y isCompleted (Boolean).
Crear nueva clase
﻿
Creando un modelo de datos utilizando el agente de IA
El agente de IA de Back4App puede ayudarte a crear un esquema de base de datos rápidamente:
Abre el agente de IA desde tu panel de control de la aplicación.
Describe tu modelo de datos en lenguaje natural (por ejemplo, “Crea una aplicación ToDo con un esquema de clase completo.”).
Deja que el agente de IA genere tu esquema automáticamente.
﻿
Lectura y escritura de datos utilizando el SDK de Python Parse
Una vez que tu esquema esté listo, guardar y consultar datos es sencillo. Por ejemplo:
models.py
from parse_rest.datatypes import Object
import parse_config  # ensure parse_config is imported

class Todo(Object):
    pass

def create_todo_item(title, is_completed=False):
    new_todo = Todo(title=title, isCompleted=is_completed)
    new_todo.save()
    print("Todo saved successfully:", new_todo.objectId)

def fetch_todos():
    return Todo.Query.all()

# Usage
# create_todo_item("Buy groceries", False)
# results = fetch_todos()
# for todo in results:
#     print(todo.title, todo.isCompleted)
from parse_rest.datatypes import Object
import parse_config  # ensure parse_config is imported

class Todo(Object):
    pass

def create_todo_item(title, is_completed=False):
    new_todo = Todo(title=title, isCompleted=is_completed)
    new_todo.save()
    print("Todo saved successfully:", new_todo.objectId)

def fetch_todos():
    return Todo.Query.all()

# Usage
# create_todo_item("Buy groceries", False)
# results = fetch_todos()
# for todo in results:
#     print(todo.title, todo.isCompleted)
﻿
Lectura y escritura de datos utilizando REST API
Si prefieres interactuar a través de REST, puedes enviar solicitudes directamente:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
Lectura y escritura de datos utilizando GraphQL API
Back4App también proporciona un endpoint de GraphQL para consultar y mutar datos:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
Trabajando con consultas en vivo (opcional)
Las consultas en vivo te permiten recibir actualizaciones en tiempo real cada vez que los datos cambian. Para habilitarlas:
Activar Consultas en Vivo en tu Back4App Configuraciones del Servidor.
Usar un enfoque de WebSocket en Python para suscribirse a cambios. Aunque el SDK de Python para Consultas en Vivo es impulsado por la comunidad, puedes integrar una biblioteca de WebSocket si tu aplicación requiere actualizaciones en tiempo real.
Paso 3 – Aplicando Seguridad con ACLs y CLPs
Resumen Breve
Back4App proporciona Listas de Control de Acceso (ACLs) y Permisos a Nivel de Clase (CLPs) para ayudarte a garantizar la integridad de los datos. Estas características definen cómo los usuarios públicos o los usuarios autenticados pueden acceder o modificar datos.
﻿
Configurando Permisos a Nivel de Clase
Ve a tu Panel de Control de Back4App, selecciona tu aplicación y abre la Base de Datos sección.
Selecciona una clase (por ejemplo, “Todo”).
Ve a Permisos a Nivel de Clase y configura reglas para usuarios públicos o autenticados.
Configurando ACLs en Código
Las ACL son permisos finos establecidos en objetos individuales. Por ejemplo:
Python
from parse_rest.datatypes import Object, ACL
from parse_rest.user import User
import parse_config

class TodoACL(Object):
    pass

def create_private_todo(title, owner):
    todo = TodoACL(title=title)
    # Create ACL that allows only the owner read/write
    acl = ACL()
    acl.set_read_access(owner.objectId, True)
    acl.set_write_access(owner.objectId, True)
    todo.ACL = acl
    todo.save()
    return todo
from parse_rest.datatypes import Object, ACL
from parse_rest.user import User
import parse_config

class TodoACL(Object):
    pass

def create_private_todo(title, owner):
    todo = TodoACL(title=title)
    # Create ACL that allows only the owner read/write
    acl = ACL()
    acl.set_read_access(owner.objectId, True)
    acl.set_write_access(owner.objectId, True)
    todo.ACL = acl
    todo.save()
    return todo
﻿
Con las ACL y CLP, puedes encontrar un equilibrio entre seguridad y conveniencia al construir tus aplicaciones en Python.
Paso 4 – Escribiendo Funciones de Cloud Code
Por qué Cloud Code
Cloud Code te permite descargar lógica empresarial importante al lado del servidor. Esto podría involucrar validaciones, disparadores o tareas sofisticadas como integrar herramientas de aprendizaje automático o APIs externas con tu desarrollo de backend en Python.
Función de Ejemplo
Puedes escribir tus funciones en main.js (Cloud Code basado en JavaScript) en Back4App. Ten en cuenta que, aunque desarrolles tu aplicación en Python, el entorno de Cloud Code en Back4App utiliza Node.js/JavaScript. Puedes llamar a estas funciones desde tu código Python o cualquier otro cliente.
JS
// main.js
Parse.Cloud.define("calculateTextLength", async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error("No text provided");
  }
  return { length: text.length };
});
// main.js
Parse.Cloud.define("calculateTextLength", async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error("No text provided");
  }
  return { length: text.length };
});
﻿
Puedes llamar a esta función utilizando las capacidades REST o GraphQL de Python:
Python
import requests

def get_text_length(text):
    url = "https://parseapi.back4app.com/functions/calculateTextLength"
    headers = {
        "X-Parse-Application-Id": "YOUR_APP_ID",
        "X-Parse-REST-API-Key": "YOUR_REST_API_KEY",
        "Content-Type": "application/json"
    }
    response = requests.post(url, headers=headers, json={"text": text})
    data = response.json()
    return data.get("result", {})

# usage
length_info = get_text_length("Hello Back4App")
print(length_info.get("length"))
import requests

def get_text_length(text):
    url = "https://parseapi.back4app.com/functions/calculateTextLength"
    headers = {
        "X-Parse-Application-Id": "YOUR_APP_ID",
        "X-Parse-REST-API-Key": "YOUR_REST_API_KEY",
        "Content-Type": "application/json"
    }
    response = requests.post(url, headers=headers, json={"text": text})
    data = response.json()
    return data.get("result", {})

# usage
length_info = get_text_length("Hello Back4App")
print(length_info.get("length"))
﻿
Despliegue y NPM
El Cloud Code de Back4App se despliega utilizando el Back4App CLI o a través del panel de control. Puedes instalar paquetes NPM (por ejemplo, para manipulación de datos, llamadas a API externas) y hacer referencia a ellos en tu main.js. Este enfoque mantiene tu código eficiente y seguro en el lado del servidor.
Paso 5 – Configurando la Autenticación
Habilitar o Configurar la Autenticación de Usuarios
Back4App aprovecha la clase Parse User para la autenticación. Esto maneja automáticamente el hash de contraseñas, tokens de sesión y más. Puedes gestionar registros, inicios de sesión o restablecimientos de contraseña con un mínimo de sobrecarga.
Registrarse e Iniciar Sesión desde Python
Python
from parse_rest.user import User
import parse_config

def sign_up_user(username, password, email):
    new_user = User.signup(username, password, email=email)
    print("User signed up successfully:", new_user.objectId)
    return new_user

def log_in_user(username, password):
    logged_user = User.login(username, password)
    print("User logged in:", logged_user.username)
    return logged_user
from parse_rest.user import User
import parse_config

def sign_up_user(username, password, email):
    new_user = User.signup(username, password, email=email)
    print("User signed up successfully:", new_user.objectId)
    return new_user

def log_in_user(username, password):
    logged_user = User.login(username, password)
    print("User logged in:", logged_user.username)
    return logged_user
﻿
Las sesiones son manejadas automáticamente por Parse. Puedes rastrear al usuario conectado y llamar .logout() cuando sea necesario. Para más detalles, consulta la Documentación de la Clase de Usuario.
Inicio de Sesión Social
Puedes integrar proveedores populares (como Facebook o Google) configurando flujos de OAuth o utilizando adaptadores especializados. Consulta la Documentación de Inicio de Sesión Social para más detalles sobre cómo configurar estas características en tu proyecto de Python.
Paso 6 – Manejo del Almacenamiento de Archivos
Configurando el Almacenamiento de Archivos
La plataforma Parse incluye almacenamiento de archivos nativo:
Python
import requests
import parse_config

def upload_file(file_path):
    file_name = file_path.split('/')[-1]
    url = f"https://parseapi.back4app.com/files/{file_name}"
    headers = {
        "X-Parse-Application-Id": "YOUR_APP_ID",
        "X-Parse-REST-API-Key": "YOUR_REST_API_KEY",
        "Content-Type": "image/jpeg" # or other mime type
    }
    with open(file_path, 'rb') as f:
        response = requests.post(url, headers=headers, data=f)
    return response.json().get('url')
import requests
import parse_config

def upload_file(file_path):
    file_name = file_path.split('/')[-1]
    url = f"https://parseapi.back4app.com/files/{file_name}"
    headers = {
        "X-Parse-Application-Id": "YOUR_APP_ID",
        "X-Parse-REST-API-Key": "YOUR_REST_API_KEY",
        "Content-Type": "image/jpeg" # or other mime type
    }
    with open(file_path, 'rb') as f:
        response = requests.post(url, headers=headers, data=f)
    return response.json().get('url')
﻿
Ejemplo
Puedes adjuntar este archivo a un objeto Parse almacenando su URL. Esto mantiene tus datos consistentes mientras tus medios están alojados de forma segura por Back4App.
Consideraciones de Seguridad
Puedes controlar quién puede subir o acceder a archivos configurando la configuración de tu servidor Parse para permitir solo a usuarios autenticados, por ejemplo. Este enfoque asegura que tus aplicaciones de Python en producción permanezcan seguras.
Paso 7 – Verificación de Correo Electrónico y Restablecimiento de Contraseña
Descripción General
La verificación de correo electrónico y los restablecimientos de contraseña son cruciales para la gestión de usuarios. Ayudan a confirmar las identidades de los usuarios y mantener la seguridad de la cuenta.
Configuración del Panel de Control de Back4App
Habilitar Verificación de Correo Electrónico en Configuraciones de la Aplicación > Configuraciones de Correo Electrónico.
Configurar las plantillas de correo electrónico, como la dirección “De”, y las instrucciones para restablecer la contraseña.
Implementación de Código
Desde Python, puedes activar correos electrónicos de restablecimiento de contraseña a través del punto final REST o bibliotecas de parse. Por ejemplo:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]"}' \
  https://parseapi.back4app.com/requestPasswordReset
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"user@example.com"}' \
  https://parseapi.back4app.com/requestPasswordReset
﻿
Esto asegura un flujo sin problemas para los restablecimientos de contraseña directamente desde tu backend de Python o cualquier otra interfaz.
Paso 8 – Programación de Tareas con Cloud Jobs
Qué Hacen los Cloud Jobs
Los Cloud Jobs te permiten automatizar tareas, como limpiar registros antiguos o generar informes periódicos. Estos se ejecutan en la infraestructura de Back4App en intervalos especificados.
Ejemplo
En tu main.js:
JS
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
﻿
Luego puedes programar este trabajo para que se ejecute diariamente o semanalmente utilizando la Sección de Trabajos en Segundo Plano. del panel de control de Back4App.
Programando un Trabajo en la Nube
﻿
Paso 9 – Integrando Webhooks
Definición
Los webhooks permiten que tu aplicación Back4App notifique a servicios externos cuando ocurren ciertos eventos. Esto es útil para integrarse con pasarelas de pago o plataformas de análisis, ampliando tus procesos de desarrollo.
Configuración
Navegar a Webhooks en tu panel de control de Back4App.
Agregar un nuevo webhook endpoint (por ejemplo, https://your-service.com/webhook-endpoint).
Seleccionar los eventos que activan el webhook (por ejemplo, creación de objetos o actualizaciones).
Agregando un Webhook
﻿
También puedes definir webhooks en los triggers de Cloud Code como beforeSave o afterSave para enviar datos a APIs externas.
Webhook BeforeSave
﻿
Paso 10 – Explorando el Panel de Administración de Back4App
Dónde Encontrarlo
La Aplicación de Administración de Back4App es una interfaz de gestión basada en la web. Permite a tu equipo realizar operaciones CRUD, gestionar datos y manejar tareas diarias sin escribir código adicional. Esto puede agilizar tu proceso de desarrollo de backend en Python.
Características
Habilitar la aplicación de administración desde App Dashboard > Más > Aplicación de administración y sigue los pasos:
Habilitar aplicación de administración
﻿
Crea el primer usuario administrador. Un nuevo rol (B4aAdminUser) y clases se añaden automáticamente a tu esquema.
﻿
Elige un subdominio para tu interfaz de administración y finaliza. Luego inicia sesión para acceder a tu nueva aplicación de administración.
﻿
﻿
La aplicación de administración facilita la actualización o eliminación de registros y la gestión de tus datos. Con controles de acceso adecuados, es seguro compartirla con gerentes de proyecto o partes interesadas.
Conclusión
Al seguir esta guía sobre cómo construir un backend para Python, has:
Creado un backend seguro para aplicaciones de Python en Back4App.
Configurado una base de datos con esquemas y relaciones flexibles.
Implementado consultas en tiempo real para actualizaciones instantáneas de datos (opcional con Consultas en Vivo).
Aplicado medidas de seguridad con ACLs y CLPs para proteger los datos.
Escrito Cloud Code en JavaScript para manejar la lógica del lado del servidor, fácilmente llamable desde Python.
Configurado la autenticación de usuarios con verificación de correo electrónico y flujos de restablecimiento de contraseña.
Manejado cargas de archivos en tu código Python con seguridad de archivos opcional.
Programado trabajos recurrentes para tareas automatizadas.
Integrado servicios externos utilizando webhooks.
Explorado el Panel de Administración para la gestión de datos y colaboración.
Con una base de código Python sólida y un backend robusto de Back4App, ahora estás equipado para abordar estructuras de datos avanzadas, incorporar frameworks como Django y Flask, e incluso integrar aprendizaje automático. 
Python ofrece innumerables posibilidades, y combinarlo con Back4App significa que puedes iterar rápidamente mientras te concentras en la lógica empresarial central en lugar de en el mantenimiento del servidor.
Próximos Pasos
Construir una aplicación Python lista para producción refinando tu esquema de base de datos, añadiendo caché y gestionando optimizaciones de rendimiento.
Explorar características avanzadas como control de acceso basado en roles, registro avanzado o conexión de APIs de terceros para análisis.
Revisar la documentación oficial de Back4App para obtener información más profunda sobre seguridad, ajuste de rendimiento y análisis de registros.
Experimentar con herramientas como Docker y Kubernetes para contenerizar y escalar tu aplicación según sea necesario.
Al aprovechar las poderosas bibliotecas de Python y la infraestructura escalable de Back4App, puedes acelerar tu viaje de desarrollo backend con confianza.
Actualizado 23 Jan 2025
¿Esta página le fue útil?
¿Cómo construir un backend para Flask?
¿Cómo construir un backend para Astro?