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

29min
Introducción
En este tutorial, aprenderás cómo construir un backend para Symfony utilizando Back4App. 
Te mostraremos cómo utilizar las robustas características de Back4App—incluyendo gestión de bases de datos, Cloud Code, REST y APIs de GraphQL—para crear un backend seguro, escalable y eficiente que funcione sin problemas con tu aplicación Symfony. 
También descubrirás cómo manejar la autenticación de usuarios, el almacenamiento de archivos y las actualizaciones en tiempo real a través de Consultas en Vivo (si es aplicable para tu arquitectura).
Al aprovechar la rápida configuración y la plataforma intuitiva de Back4App, ahorrarás tiempo y esfuerzo en comparación con el manejo manual de servidores y bases de datos. 
Obtendrás experiencia práctica en seguridad avanzada, programación de tareas con Cloud Jobs, configuración de webhooks y otras características esenciales para un desarrollo de backend confiable.
Después de completar este tutorial, puedes expandir o personalizar con confianza tu backend de Symfony para producción, integrar APIs externas y agregar lógica empresarial compleja según sea necesario.
Requisitos previos
Una cuenta de Back4app
Regístrate gratis aquí.
Un nuevo proyecto de Back4app
Comenzando con Back4app.
Configuración específica de Symfony
Asegúrate de tener Symfony instalado localmente. Confirma que tienes PHP y Composer listos.
Conocimientos básicos de Symfony
La familiaridad con controladores, servicios y plantillas es beneficiosa. Documentación oficial de Symfony.
Node.js (opcional, para ciertas herramientas de construcción)
Si planeas usar herramientas basadas en Node para tareas de front-end, instala Node.js.
Asegúrate de que tu entorno de Symfony y tu proyecto de Back4App estén configurados antes de comenzar. Esto te ayudará a seguir los pasos sin problemas.
Paso 1 – Crear un nuevo proyecto en Back4App y conectar
Crear un proyecto de Back4App:
Inicia sesión en tu cuenta de Back4App.
Haz clic en “Nueva App” en el panel de control.
Nómbrala (por ejemplo, “Symfony-Backend-Tutorial”).
﻿
Una vez creado, aparece en tu panel de control de Back4App. Este proyecto es tu base de backend.
Conéctate con REST o GraphQL:
En la “Configuración de la App” o “Seguridad y Claves” de tu app, encuentra tu ID de Aplicación y Clave API REST (y el endpoint de GraphQL si planeas usar GraphQL).
Anota tu URL del Servidor Parse (por ejemplo, https://parseapi.back4app.com).
Dado que Symfony no tiene un SDK nativo de Parse, dependerás del cliente HTTP de Symfony o de una biblioteca como Guzzle para comunicarte con las APIs REST o GraphQL de Back4App.
﻿
A continuación se muestra un ejemplo utilizando el Symfony HttpClient:
PHP
// src/Service/Back4AppClient.php

namespace App\Service;

use Symfony\Component\HttpClient\HttpClient;

class Back4AppClient
{
    private $appId;
    private $restKey;
    private $baseUrl;

    public function __construct(string $appId, string $restKey, string $baseUrl)
    {
        $this->appId = $appId;
        $this->restKey = $restKey;
        $this->baseUrl = $baseUrl;
    }

    public function createObject(string $className, array $data)
    {
        $client = HttpClient::create();
        $response = $client->request('POST', $this->baseUrl.'/classes/'.$className, [
            'headers' => [
                'X-Parse-Application-Id' => $this->appId,
                'X-Parse-REST-API-Key'   => $this->restKey,
                'Content-Type'          => 'application/json'
            ],
            'json' => $data,
        ]);
        return $response->toArray();
    }
}
// src/Service/Back4AppClient.php

namespace App\Service;

use Symfony\Component\HttpClient\HttpClient;

class Back4AppClient
{
    private $appId;
    private $restKey;
    private $baseUrl;

    public function __construct(string $appId, string $restKey, string $baseUrl)
    {
        $this->appId = $appId;
        $this->restKey = $restKey;
        $this->baseUrl = $baseUrl;
    }

    public function createObject(string $className, array $data)
    {
        $client = HttpClient::create();
        $response = $client->request('POST', $this->baseUrl.'/classes/'.$className, [
            'headers' => [
                'X-Parse-Application-Id' => $this->appId,
                'X-Parse-REST-API-Key'   => $this->restKey,
                'Content-Type'          => 'application/json'
            ],
            'json' => $data,
        ]);
        return $response->toArray();
    }
}
﻿
Este servicio te ayudará a hacer solicitudes a tu backend de Back4App desde dentro de Symfony.
Paso 2 – Configuración de la Base de Datos
Creando un Modelo de Datos
En Back4App, definirás clases (tablas) que almacenan tus datos. Supongamos que quieres una Todo clase para contener tareas:
Navegar a la Base de Datos en tu panel de Back4App.
Crear una nueva clase “Todo” y agregar campos como título (String) y isCompleted (Boolean).
Crear Nueva Clase
﻿
Alternativamente, deja que Back4App AI Agent cree tu modelo de datos:
Abrir el AI Agent en el panel de tu proyecto.
Describir tu modelo de datos (por ejemplo, “Crear una clase Todo con campos de título y isCompleted.”).
Generar el esquema automáticamente.
﻿
Lectura y Escritura de Datos usando REST
Para crear un nuevo Todo desde un controlador Symfony, puedes hacer:
PHP
use App\Service\Back4AppClient;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Routing\Annotation\Route;

class TodoController extends AbstractController
{
    #[Route('/todo/new', name: 'new_todo')]
    public function new(Back4AppClient $client)
    {
        $data = [
            'title' => 'Buy groceries',
            'isCompleted' => false
        ];
        $result = $client->createObject('Todo', $data);
        
        return $this->json($result);
    }
}
use App\Service\Back4AppClient;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Routing\Annotation\Route;

class TodoController extends AbstractController
{
    #[Route('/todo/new', name: 'new_todo')]
    public function new(Back4AppClient $client)
    {
        $data = [
            'title' => 'Buy groceries',
            'isCompleted' => false
        ];
        $result = $client->createObject('Todo', $data);
        
        return $this->json($result);
    }
}
﻿
Para consultas, usa una solicitud GET con tus credenciales:
Bash
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  https://parseapi.back4app.com/classes/Todo
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  https://parseapi.back4app.com/classes/Todo
﻿
Lectura y Escritura de Datos usando GraphQL
También puedes integrar GraphQL en Symfony utilizando una biblioteca de cliente GraphQL. Un ejemplo de mutación para crear un Todo es:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the kitchen"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the kitchen"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
Trabajando con Consultas en Vivo (Opcional)
Si tu aplicación Symfony necesita datos en tiempo real, podrías incorporar Consultas en Vivo en un contexto más de microservicio en tiempo real o front-end. Configura las Consultas en Vivo en los Ajustes del Servidor en Back4App, luego conecta un cliente WebSocket. Symfony puede responder o transmitir estas actualizaciones a través de una capa de tiempo real separada si es necesario.
Paso 3 – Aplicando Seguridad con ACLs y CLPs
ACLs (Listas de Control de Acceso)
Las ACLs te permiten controlar quién puede leer o escribir un objeto. Por ejemplo, puedes aplicar una ACL en el código al crear datos con la API REST añadiendo campos _ACL en tu JSON. Por ejemplo:
JSON
{
  "title": "Private Task",
  "isCompleted": false,
  "_ACL": {
    "UserObjectIdHere": {
      "read": true,
      "write": true
    }
  }
}
{
  "title": "Private Task",
  "isCompleted": false,
  "_ACL": {
    "UserObjectIdHere": {
      "read": true,
      "write": true
    }
  }
}
﻿
CLPs (Permisos a Nivel de Clase)
Los Permisos a Nivel de Clase te permiten establecer reglas de acceso amplias para toda una clase:
Abre la Base de Datos en el panel de control de Back4App.
Selecciona tu clase (por ejemplo, “Todo”).
Ve a la pestaña de Permisos y configura el acceso de lectura/escritura.
﻿
Para más información, visita las Directrices de Seguridad de la Aplicación.
Paso 4 – Escribiendo Funciones de Cloud Code
Cloud Code te permite ejecutar JavaScript seguro del lado del servidor sin gestionar infraestructura. Mientras Symfony está en PHP, aún puedes delegar ciertas tareas a Cloud Code en Back4App para lógica avanzada, disparadores y validaciones.
Ejemplo: Validar un Todo Antes de Guardar
JS
// main.js

Parse.Cloud.beforeSave('Todo', (request) => {
  const todo = request.object;
  if (!todo.get('title')) {
    throw new Error('Todo must have a title');
  }
});
// main.js

Parse.Cloud.beforeSave('Todo', (request) => {
  const todo = request.object;
  if (!todo.get('title')) {
    throw new Error('Todo must have a title');
  }
});
﻿
Despliegue
Usa el CLI de Back4App o el panel de control para desplegar main.js.
Invoca tus Funciones de Cloud a través de REST o GraphQL desde tus servicios de Symfony.
﻿
Paso 5 – Configurando la Autenticación
La gestión de usuarios en Back4App se basa en la clase Parse User. Con Symfony, puedes manejar registros de usuarios, inicios de sesión y restablecimientos de contraseña a través de llamadas REST o GraphQL.
Registrarse / Iniciar sesión a través de REST
Bash
# Sign Up
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 '{"username": "alex", "password": "symfony123", "email": "[email protected]"}' \
  https://parseapi.back4app.com/users

# Log In
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  --data-urlencode 'username=alex' \
  --data-urlencode 'password=symfony123' \
  https://parseapi.back4app.com/login
# Sign Up
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 '{"username": "alex", "password": "symfony123", "email": "alex@example.com"}' \
  https://parseapi.back4app.com/users

# Log In
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  --data-urlencode 'username=alex' \
  --data-urlencode 'password=symfony123' \
  https://parseapi.back4app.com/login
﻿
Utiliza un servicio de Symfony para envolver estas llamadas si necesitas flujos de usuario programáticos.
Inicio de sesión social
Si planeas integrar el inicio de sesión de Google o Apple, consulta la documentación de inicio de sesión social de Back4App. Configurarás tus aplicaciones OAuth y realizarás llamadas REST específicas para completar la autenticación.
Paso 6 – Manejo del almacenamiento de archivos
Carga de archivos con REST
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: image/png" \
  --data-binary '@localImage.png' \
  https://parseapi.back4app.com/files/localImage.png
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: image/png" \
  --data-binary '@localImage.png' \
  https://parseapi.back4app.com/files/localImage.png
﻿
Después de cargar, recibirás una URL de archivo. Puedes almacenar ese enlace en cualquier clase (por ejemplo, Todo) como una referencia a ese archivo.
Paso 7 – Verificación de correo electrónico y restablecimiento de contraseña
Configurando el correo electrónico
Ir a la configuración de correo electrónico en Back4App.
Habilitar la verificación de correo electrónico y las plantillas de restablecimiento de contraseña.
Personalizar las líneas “De” y “Asunto” según sea necesario.
Esto asegura que todos los registros requieran confirmaciones de correo electrónico válidas.
Paso 8 – Programación de tareas con trabajos en la nube
Ejemplo de trabajo en la nube
JS
// main.js
Parse.Cloud.job('cleanupOldTodos', async () => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  query.lessThan('createdAt', new Date(now - THIRTY_DAYS));

  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
// main.js
Parse.Cloud.job('cleanupOldTodos', async () => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  query.lessThan('createdAt', new Date(now - THIRTY_DAYS));

  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
﻿
Programa este cleanupOldTodos trabajo en tu panel de Back4App para que se ejecute diariamente, mejorando la gestión de tus datos.
Paso 9 – Integración de Webhooks
Webhooks permiten que Back4App envíe solicitudes HTTP a servicios externos. Por ejemplo, puedes enviar un ping a un endpoint de Slack cada vez que se crea un nuevo Todo :
Ir a Más > WebHooks en tu panel de Back4App.
Agregar un Webhook especificando tu endpoint externo.
Activar el evento en la creación de objetos en la clase Todo.
Agregando un Webhook
﻿
Paso 10 – Explorando el panel de administración de Back4App
Utiliza la Back4App Admin App para una interfaz de gestión de datos fácil de usar:
Habilitar la Admin App desde App Dashboard > Más > Admin App.
Crear un usuario administrador con un nombre de usuario y contraseña seguros.
Asignar un subdominio personalizado para un acceso fácil.
Habilitar la Admin App
﻿
Esta función ayuda a los miembros del equipo no técnicos a ver y gestionar registros sin profundizar en el código.
Conclusión
Has aprendido cómo construir un backend para Symfony utilizando Back4App. Esto incluyó:
Creando un nuevo proyecto en Back4App como base.
Configurando la base de datos con clases, campos y relaciones.
Asegurando los datos con ACLs y CLPs.
Aprovechando Cloud Code para la lógica del lado del servidor.
Gestionando la autenticación de usuarios (registro, inicio de sesión, restablecimiento de contraseña).
Manejando el almacenamiento de archivos con la API REST.
Configurando Cloud Jobs para tareas periódicas.
Integrando webhooks para conectar servicios externos.
Navegando por el Panel de Administración de Back4App para una fácil gestión de datos.
Estos pasos te brindan un marco sólido para construir y escalar tu aplicación Symfony. Amplía esta arquitectura para manejar lógica más compleja, integrar pasarelas de pago o agregar características de seguridad avanzadas. Con Back4App, ahorras tiempo y esfuerzo en hosting e infraestructura, para que puedas concentrarte en ofrecer la mejor experiencia de usuario posible.
Próximos Pasos
Construir una aplicación Symfony lista para producción personalizando tu backend de Back4App para un mayor tráfico y necesidades de rendimiento avanzadas.
Integrar características avanzadas como acceso basado en roles, análisis o APIs de terceros para pagos.
Explorar la documentación oficial de Back4App para obtener información más profunda sobre seguridad, registros y monitoreo.
Revisar más tutoriales para combinar este backend con servicios en tiempo real o para crear sitios web dinámicos con actualizaciones en vivo.
Al seguir estas estrategias, tu proyecto Symfony obtiene un backend poderoso y eficiente. Abraza Back4App para facilitar el mantenimiento y evolucionar rápidamente las capacidades de tu aplicación. ¡Buena suerte construyendo tu próxima obra maestra de Symfony!
Actualizado 23 Jan 2025
¿Esta página le fue útil?
¿Cómo construir un backend para Golang?
¿Cómo construir un backend para Ionic?