Crear y ejecutar un proyecto Symfony

ServBay es un entorno de desarrollo web local diseñado especialmente para macOS. Integra diversos runtimes de lenguajes como PHP, Node.js, Python, Go y Java, además de bases de datos como MySQL, PostgreSQL, MongoDB y Redis. También es compatible con los servidores web Apache y Caddy. Esta guía explica detalladamente cómo montar y ejecutar rápidamente un proyecto Symfony en macOS utilizando ServBay.

¿Qué es Symfony?

Symfony es un framework web PHP de código abierto creado por SensioLabs, diseñado para proporcionar a los desarrolladores un conjunto eficiente, flexible y potente de herramientas para la construcción de aplicaciones web modernas y APIs. Sigue las mejores prácticas estándar de desarrollo web e incluye numerosos componentes como enrutamiento, motor de plantillas (Twig), manejo de formularios, autenticación e inyección de dependencias, simplificando considerablemente las tareas comunes de desarrollo web.

Principales características y ventajas de Symfony

• Diseño modular: El núcleo de Symfony es su biblioteca reutilizable de componentes. Los desarrolladores pueden seleccionar y usar sólo los componentes que necesiten, para crear desde aplicaciones ligeras hasta proyectos complejos.
• Alto rendimiento: Gracias a su arquitectura optimizada, mecanismos de caché eficientes y compatibilidad con las últimas características de PHP, Symfony ofrece un excelente desempeño.
• Gran comunidad y soporte: Una comunidad amplia de desarrolladores, una gran variedad de Bundles (plugins) de terceros y documentación completa facilitan encontrar soluciones a problemas comunes.
• Flexibilidad: Fácil integración de librerías y extensiones de terceros, adaptándose a proyectos de cualquier tamaño o complejidad.
• Estabilidad y mantenibilidad: Sigue buenas prácticas de codificación y patrones de diseño que garantizan que las aplicaciones sean fáciles de probar, mantener y ampliar.

Symfony es ideal tanto para crear pequeñas APIs como sistemas empresariales a gran escala.

Crear y ejecutar un proyecto Symfony utilizando ServBay

ServBay proporciona un entorno completo para ejecutar proyectos Symfony, incluyendo la versión necesaria de PHP, Composer, el servidor web y diversas soluciones para bases de datos y sistemas de caché. En esta sección aprenderás a crear y configurar desde cero un proyecto Symfony con ServBay.

Requisitos previos

Antes de comenzar, asegúrate de haber realizado lo siguiente:

1. Instalar ServBay: Debes tener ServBay instalado y funcionando en tu macOS. Si aún no lo has hecho, consulta la Guía de instalación de ServBay.
2. ServBay en funcionamiento: Los servicios principales de ServBay (como Caddy o Apache y la base de datos necesaria) deben estar activos.
3. Conocimientos básicos: Debes poseer conocimientos elementales de PHP, Composer y Symfony.

Crear un proyecto Symfony

Se recomienda almacenar todos tus proyectos web en el directorio /Applications/ServBay/www. De este modo, ServBay podrá reconocer y gestionar fácilmente tus proyectos.

1. Verificar la disponibilidad de Composer

   Composer viene integrado en ServBay y su variable de entorno ya está configurada, así que no es necesario instalarlo por separado. Puedes verificar su disponibilidad desde la terminal con el comando composer --version.

2. Crear el directorio del proyecto

   Crea un nuevo directorio en el directorio raíz recomendado para almacenar tu proyecto Symfony:

   cd /Applications/ServBay/www
   mkdir servbay-symfony-app

3. Crear el proyecto Symfony usando Composer

   Accede al directorio que acabas de crear y utiliza Composer para generar la estructura base de Symfony usando website-skeleton. Este esqueleto contiene las dependencias más habituales para proyectos web tradicionales.

   cd /Applications/ServBay/www/servbay-symfony-app
   composer create-project symfony/website-skeleton .

   Tras ejecutar este comando, Composer descargará los archivos principales de Symfony y sus dependencias en el directorio actual.

Configuración inicial

La configuración central de un proyecto Symfony suele gestionarse mediante variables de entorno almacenadas en el archivo .env de la raíz del proyecto.

1. Configura las variables de entorno (.env)

   Abre el archivo .env en la raíz del proyecto. Aquí se encuentran configuraciones de entorno como los datos de acceso a la base de datos, claves de la aplicación, etc. Modifica o agrega valores según tus necesidades.

   Asegúrate de que tienes correctamente ajustados los siguientes elementos, o adapta los valores a tu entorno ServBay:

   # Ejemplo de archivo .env
   APP_ENV=dev # Entorno de desarrollo
   APP_SECRET=your_secret_key # Sustituye por una cadena aleatoria única, usada con fines de seguridad
   
   # Datos de conexión a la base de datos (usando MySQL como ejemplo, se explica más abajo)
   # DATABASE_URL="mysql://db_user:[email protected]:3306/db_name?serverVersion=8.0&charset=utf8mb4"
   # DATABASE_URL="postgresql://db_user:[email protected]:5432/db_name?serverVersion=13&charset=utf8"
   # DATABASE_URL="sqlite:///%kernel.project_dir%/var/data.db"

   Sustituye your_secret_key por una cadena aleatoria segura. En cuanto a la base de datos, el usuario por defecto en ServBay suele ser root y la contraseña password (es fundamental que cambies este dato en entornos de producción). Usaremos servbay_symfony_app como nombre de base de datos de ejemplo.

Configurar el servidor web (Sitios en ServBay)

Para poder acceder a tu proyecto Symfony en el navegador, debes configurar un host virtual local usando la función de “Sitios” de ServBay. El directorio raíz web de Symfony es la carpeta public/ dentro de tu proyecto.

Abre el panel de control de ServBay, dirígete a la sección de configuración de sitios (o "Host" en versiones anteriores) y añade un nuevo sitio:

• Nombre: Ponle un nombre identificativo, por ejemplo, My Symfony Dev Site.
• Dominio: Indica un dominio local, por ejemplo, servbay-symfony-test.local. ServBay lo resolverá automáticamente como local.
• Tipo de sitio: Elige PHP.
• Versión de PHP: Selecciona una versión compatible con tu proyecto Symfony; se recomienda la última versión estable incluida en ServBay, como 8.3.
• Directorio raíz del sitio: Este dato es fundamental. En Symfony, el directorio raíz web es public/ dentro de tu proyecto, por lo que asigna /Applications/ServBay/www/servbay-symfony-app/public.

Guarda y aplica los cambios. ServBay actualizará automáticamente la configuración del servidor web, generando y confiando el certificado SSL para tu dominio local, lo que te permitirá acceder directamente mediante HTTPS.

Consulta los pasos detallados en Añadir tu primer sitio con ServBay.

Agregar un ejemplo base de código

Para verificar que la configuración es correcta, vamos a añadir una ruta y un controlador simple para que al visitar el dominio se muestre un mensaje.

1. Configurar la ruta (config/routes.yaml)

   Abre config/routes.yaml y añade el siguiente contenido para definir una ruta / que apunte al método index del controlador:

   # config/routes.yaml
   index:
       path: /
       controller: App\Controller\DefaultController::index

2. Crear el controlador (src/Controller/DefaultController.php)

   Dentro de src/Controller/ crea el archivo DefaultController.php y añade este código:

   <?php
   // src/Controller/DefaultController.php
   namespace App\Controller;
   
   use Symfony\Component\HttpFoundation\Response;
   use Symfony\Component\Routing\Annotation\Route;
   
   class DefaultController
   {
       /**
        * @Route("/", name="index")
        */
       public function index(): Response
       {
           // Devuelve una sencilla respuesta HTTP
           return new Response('Hello ServBay and Symfony!');
       }
   }

   Este ejemplo define la clase DefaultController y asocia el método index, mediante la anotación @Route("/"), con la ruta raíz del sitio. Al visitarla, devuelve el mensaje "Hello ServBay and Symfony!".

Acceder al sitio web

Ahora abre tu navegador y visita el dominio configurado: https://servbay-symfony-test.local. Si la configuración es correcta, deberías ver:

Hello ServBay and Symfony!

Esto indica que tu proyecto Symfony está funcionando correctamente a través del servidor web de ServBay. Recuerda que puedes y debes acceder usando https:// ya que ServBay configura el SSL automáticamente.

Ejemplos de bases de datos y caché

Symfony suele utilizar Doctrine ORM para bases de datos relacionales y el componente Cache para cachés y bases NoSQL. ServBay incluye múltiples servicios de bases de datos y las extensiones PHP necesarias, lo que facilita integrarlas en tus aplicaciones Symfony.

Ejemplo de base de datos relacional (Doctrine ORM)

ServBay soporta MySQL y PostgreSQL. A continuación, verás cómo configurar y utilizar ambos sistemas con Symfony.

1. Configura la conexión a la base de datos

   En el .env de tu proyecto, descomenta y edita la variable DATABASE_URL según el sistema de bases de datos seleccionado.

   • Para MySQL: El usuario predeterminado de MySQL en ServBay es root, contraseña password y puerto 3306 (ajusta si es necesario).

     # .env
     DATABASE_URL="mysql://root:[email protected]:3306/servbay_symfony_app?serverVersion=8.0&charset=utf8mb4"

   • Para PostgreSQL: El usuario predeterminado de PostgreSQL es root, contraseña password y puerto 5432.

     # .env
     DATABASE_URL="postgresql://root:[email protected]:5432/servbay_symfony_app?serverVersion=13&charset=utf8"

   Recuerda iniciar el servicio de base de datos elegido en el panel de ServBay (MySQL o PostgreSQL).

2. Crear la base de datos

   Si servbay_symfony_app no existe, créala manualmente usando la herramienta de administración de bases de datos integrada (phpMyAdmin o pgAdmin desde el panel de ServBay), o bien mediante Symfony:

   php bin/console doctrine:database:create

3. Crear entidades y archivos de migración

   En Symfony, las entidades Doctrine representan tablas. Usa Maker Bundle para generarlas y crear archivos de migración.

   • Crear una entidad (por ejemplo, User):

     php bin/console make:entity User

     Añade los campos según la guía interactiva, por ejemplo: name (string) y email (string, unique=yes).
   • Crear archivos de migración: Según los cambios en la entidad, genera la migración correspondiente:

     php bin/console make:migration

     Esto creará un nuevo archivo en src/Migrations con las instrucciones SQL necesarias.

4. Ejecutar las migraciones

   Aplica la estructura en la base de datos ejecutando:

   php bin/console doctrine:migrations:migrate

5. Agregar un ejemplo de operaciones sobre la base de datos

   Modifica src/Controller/DefaultController.php para agregar rutas y métodos de ejemplo que permitan usar Doctrine para escribir y leer datos. Deberás inyectar la interfaz EntityManagerInterface.

   Primero, asegúrate que el constructor del controlador acepte EntityManagerInterface:

   <?php
   // src/Controller/DefaultController.php
   namespace App\Controller;
   
   use Symfony\Component\HttpFoundation\Response;
   use Symfony\Component\Routing\Annotation\Route;
   use Doctrine\ORM\EntityManagerInterface; // Importa la interfaz
   use App\Entity\User; // Importa la entidad User
   use Symfony\Component\HttpFoundation\JsonResponse; // Para retornar JSON
   
   class DefaultController
   {
       private $entityManager;
   
       // Inyección de dependencias para obtener EntityManagerInterface
       public function __construct(EntityManagerInterface $entityManager)
       {
           $this->entityManager = $entityManager;
       }
   
       /**
        * @Route("/", name="app_index")
        */
       public function index(): Response
       {
           return new Response('Hello ServBay and Symfony!');
       }
   
       // ... otros métodos ...
   }

   Luego, añade nuevas rutas en config/routes.yaml:

   # config/routes.yaml
   # ... otras rutas ...
   mysql_add_user:
       path: /mysql-add-user # O /pgsql-add-user según la base de datos
       controller: App\Controller\DefaultController::addUser
   mysql_get_users:
       path: /mysql-users # O /pgsql-users
       controller: App\Controller\DefaultController::getUsers

   Crea en src/Controller/DefaultController.php los métodos correspondientes:

   <?php
   // src/Controller/DefaultController.php
   namespace App\Controller;
   
   use Symfony\Component\HttpFoundation\Response;
   use Symfony\Component\Routing\Annotation\Route;
   use Doctrine\ORM\EntityManagerInterface;
   use App\Entity\User;
   use Symfony\Component\HttpFoundation\JsonResponse; // Importa JsonResponse
   
   class DefaultController
   {
       private $entityManager;
   
       public function __construct(EntityManagerInterface $entityManager)
       {
           $this->entityManager = $entityManager;
       }
   
       /**
        * @Route("/", name="app_index")
        */
       public function index(): Response
       {
           return new Response('Hello ServBay and Symfony!');
       }
   
       /**
        * @Route("/add-user", name="app_add_user")
        */
       public function addUser(): Response
       {
           $user = new User();
           // Inserta datos de ejemplo relacionados con ServBay
           $user->setName('ServBay Demo User');
           $user->setEmail('[email protected]');
   
           // Prepara para guardar el objeto
           $this->entityManager->persist($user);
           // Ejecuta la inserción en la base de datos
           $this->entityManager->flush();
   
           return new Response('¡Usuario añadido con éxito!');
       }
   
       /**
        * @Route("/get-users", name="app_get_users")
        */
       public function getUsers(): JsonResponse
       {
           // Obtiene todas las entidades User desde la base de datos
           $users = $this->entityManager->getRepository(User::class)->findAll();
   
           // Convierte a array para JsonResponse
           $usersArray = [];
           foreach ($users as $user) {
               $usersArray[] = [
                   'id' => $user->getId(),
                   'name' => $user->getName(),
                   'email' => $user->getEmail(),
               ];
           }
   
           // Retorna la respuesta en formato JSON
           return new JsonResponse($usersArray);
       }
   }

6. Acceder a los ejemplos

   • Visita https://servbay-symfony-test.local/add-user para agregar un usuario.
   • Visita https://servbay-symfony-test.local/get-users para ver la lista de usuarios agregados (formato JSON).

Ejemplo de caché y bases de datos NoSQL (Symfony Cache)

ServBay trae Redis y Memcached junto con las extensiones PHP requeridas, por lo que puedes usar directamente el componente Cache de Symfony para aprovechar estos servicios.

1. Configurar la conexión de caché

   Añade en tu archivo .env la configuración para el servicio de caché que prefieras.

   • Para Memcached: El puerto por defecto es 11211.

     # .env
     # ... otras configuraciones ...
     CACHE_DSN=memcached://127.0.0.1:11211

     Asegúrate que el servicio Memcached está iniciado en el panel ServBay.
   • Para Redis: Por defecto el puerto es 6379.

     # .env
     # ... otras configuraciones ...
     CACHE_DSN=redis://127.0.0.1:6379
     # Si Redis requiere contraseña (por defecto no en ServBay):
     # CACHE_DSN=redis://:[email protected]:6379

     No olvides asegurar que Redis esté funcionando en ServBay.

2. Agregar ejemplo de uso de caché

   Modifica src/Controller/DefaultController.php para agregar rutas y métodos que demuestren cómo usar el componente Cache de Symfony con Memcached o Redis. Deberás inyectar la interfaz CacheInterface.

   Primero, añade CacheInterface al constructor de tu controlador:

   <?php
   // src/Controller/DefaultController.php
   namespace App\Controller;
   
   use Symfony\Component\HttpFoundation\Response;
   use Symfony\Component\Routing\Annotation\Route;
   use Doctrine\ORM\EntityManagerInterface;
   use App\Entity\User;
   use Symfony\Component\HttpFoundation\JsonResponse;
   use Symfony\Contracts\Cache\CacheInterface; // Importa CacheInterface
   
   class DefaultController
   {
       private $entityManager;
       private $cache; // Nuevo atributo
   
       // Inyección del caché
       public function __construct(EntityManagerInterface $entityManager, CacheInterface $cache)
       {
           $this->entityManager = $entityManager;
           $this->cache = $cache;
       }
   
       // ... otros métodos ...
   }

   Añade la nueva ruta en config/routes.yaml:

   # config/routes.yaml
   # ... otras rutas ...
   cache_example:
       path: /cache-example
       controller: App\Controller\DefaultController::cacheExample

   Y el método que lo emplea en DefaultController.php:

   <?php
   // src/Controller/DefaultController.php
   namespace App\Controller;
   
   use Symfony\Component\HttpFoundation\Response;
   use Symfony\Component\Routing\Annotation\Route;
   use Doctrine\ORM\EntityManagerInterface;
   use App\Entity\User;
   use Symfony\Component\HttpFoundation\JsonResponse;
   use Symfony\Contracts\Cache\CacheInterface;
   use Symfony\Component\Cache\Item\ItemInterface; // Importa ItemInterface
   
   class DefaultController
   {
       private $entityManager;
       private $cache;
   
       public function __construct(EntityManagerInterface $entityManager, CacheInterface $cache)
       {
           $this->entityManager = $entityManager;
           $this->cache = $cache;
       }
   
       // ... otros métodos ...
   
       /**
        * @Route("/cache-example", name="app_cache_example")
        */
       public function cacheExample(): Response
       {
           // Intenta leer el dato desde la caché
           $cacheItem = $this->cache->get('my_symfony_cache_key', function (ItemInterface $item) {
               // Si no existe en caché, se ejecuta este callback
               $item->expiresAfter(3600); // 1 hora de validez
   
               // Simula operación costosa, como una consulta compleja
               $data = "Data generated at " . date('Y-m-d H:i:s');
   
               // El dato que se cachea
               return $data;
           });
   
           $output = "From Cache: " . $cacheItem;
   
           return new Response($output);
       }
   }

3. Acceder al ejemplo

   • Navega a https://servbay-symfony-test.local/cache-example. La primera vez el callback generará y almacenará el dato en memoria. Las siguientes, mientras no expire, se obtendrá directamente desde la caché de Memcached o Redis.

Preguntas frecuentes (FAQ)

P: Al acceder a https://servbay-symfony-test.local aparece una página de error 404 o 500, ¿qué hago?

R: Revisa lo siguiente:

1. Asegúrate de que ServBay está en marcha y que el servidor web (Caddy o Apache) está iniciado.
2. Verifica que el dominio servbay-symfony-test.local está correctamente configurado y que la raíz del sitio apunte exactamente a /Applications/ServBay/www/servbay-symfony-app/public.
3. Consulta los logs de tu proyecto Symfony en var/log/dev.log para detalles del error.
4. En la terminal, ejecuta composer install en la raíz de tu proyecto para instalar dependencias.
5. Comprueba que tu versión de PHP es compatible con Symfony.

P: ¿Qué hago si falla la conexión a la base de datos?

R: Revisa estos puntos:

1. Comprueba que el servicio de base de datos adecuado (MySQL o PostgreSQL) está iniciado en el panel de ServBay.
2. Revisa que la variable DATABASE_URL en el .env esté correcta (usuario, contraseña, host - 127.0.0.1, puerto - MySQL 3306, PostgreSQL 5432 y nombre de la base).
3. Asegúrate que usuario y contraseña coinciden con las que has definido o que vienen por defecto en ServBay.
4. Verifica que la base servbay_symfony_app existe.

P: ¿Por qué no funciona el comando php bin/console?

R: Asegúrate de estar en la carpeta /Applications/ServBay/www/servbay-symfony-app en tu terminal y que la versión de PHP de ServBay esté correctamente añadida al PATH del sistema (esto suele configurarse automáticamente al instalar ServBay). Prueba ejecutando which php para comprobar que usas el PHP que provee ServBay.

Resumen

Siguiendo esta guía, habrás creado, configurado y ejecutado satisfactoriamente un proyecto Symfony básico en macOS usando ServBay. ServBay proporciona todos los componentes esenciales para desarrollo con Symfony (PHP, Composer, servidor web, bases de datos, caché) y simplifica al máximo la configuración del entorno para que puedas centrarte en desarrollar tu aplicación. Ahora puedes continuar profundizando en las funcionalidades de Symfony y aprovechar otros servicios y paquetes que ofrece ServBay.