Crear y ejecutar un proyecto Symfony

ServBay es un entorno de desarrollo web local diseñado especialmente para macOS y Windows. Integra múltiples runtimes de lenguajes como PHP, Node.js, Python, Go y Java, junto con bases de datos como MySQL, PostgreSQL, MongoDB y Redis, y soporta los servidores web Apache y Caddy. En esta guía aprenderás paso a paso cómo montar y poner en marcha un proyecto Symfony usando ServBay tanto en macOS como en Windows.

¿Qué es Symfony?

Symfony es un framework web PHP de código abierto creado por SensioLabs, cuyo objetivo es ofrecer a los desarrolladores un conjunto de herramientas eficiente, flexible y potente para construir aplicaciones web modernas y APIs. Sigue buenas prácticas estándar del desarrollo web y cuenta con numerosos componentes funcionales, como enrutamiento, motor de plantillas (Twig), gestión de formularios, autenticación e inyección de dependencias, lo que simplifica de manera significativa muchas tareas habituales en el desarrollo web.

Características y ventajas principales de Symfony

• Diseño modular: El núcleo de Symfony es su biblioteca de componentes reutilizables. Los desarrolladores pueden elegir y usar los componentes que necesiten, creando desde aplicaciones ligeras hasta sistemas robustos.
• Alto rendimiento: Gracias a su arquitectura optimizada, mecanismos de caché efectivos y compatibilidad con las últimas características de PHP, Symfony ofrece un rendimiento destacado.
• Gran comunidad: Dispone de una comunidad enorme, abundantes Bundles (plugins) de terceros y documentación detallada, facilitando la resolución de problemas.
• Flexibilidad: Es sencillo integrar librerías y extensiones externas, siendo apto para proyectos de cualquier tamaño y complejidad.
• Estabilidad y fácil mantenimiento: Al seguir buenas prácticas y patrones de diseño, las aplicaciones creadas son fáciles de probar, mantener y evolucionar.

Symfony es ideal para desarrollar desde APIs simples hasta sistemas empresariales de gran escala.

Crear y ejecutar un proyecto Symfony con ServBay

ServBay proporciona todas las herramientas necesarias para proyectos Symfony: versiones compatibles de PHP, Composer, servidores web y servicios de bases de datos y caché. Esta sección te enseña cómo crear un nuevo proyecto Symfony y configurarlo usando las funcionalidades de ServBay.

Requisitos previos

Antes de comenzar, verifica que has realizado lo siguiente:

1. Instalar ServBay: Ya tienes ServBay instalado y funcionando en tu sistema macOS. Si aún no lo tienes, revisa la Guía de instalación de ServBay.
2. ServBay en ejecución: Los servicios principales de ServBay (como Caddy o Apache y las bases de datos requeridas) están activos.
3. Conocimientos básicos: Entiendes los conceptos fundamentales de PHP, Composer y Symfony.

Crear un proyecto Symfony

Se recomienda almacenar tus proyectos web en el directorio /Applications/ServBay/www, facilitando que ServBay los detecte y administre.

1. Verifica que Composer está disponible

   Composer ya viene integrado y configurado en ServBay, por lo tanto no es necesario instalarlo aparte. Para confirmar que está listo, abre una terminal y ejecuta composer --version.

2. Crea el directorio del proyecto

   En la raíz sugerida de los sitios web, crea una nueva carpeta para el proyecto Symfony:

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

3. Crea el proyecto usando Composer

   Accede a la carpeta recién creada y utiliza Composer para generar la estructura base de Symfony utilizando website-skeleton, que incluye dependencias comunes para aplicaciones web tradicionales.

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

   Esto descargará los archivos base de Symfony y sus dependencias en el directorio actual.

Configuración inicial

La configuración principal de Symfony suele hacerse 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 definen parámetros como la conexión a la base de datos, claves secretas, etc. Modifica o agrega configuraciones según tus necesidades.

   Verifica que las siguientes líneas estén correctas y adaptadas 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, para mayor seguridad
   
   # Información de conexión a base de datos (ejemplo usando MySQL, detallado más adelante)
   # DATABASE_URL="mysql://db_user:db_password@127.0.0.1:3306/db_name?serverVersion=8.0&charset=utf8mb4"
   # DATABASE_URL="postgresql://db_user:db_password@127.0.0.1:5432/db_name?serverVersion=13&charset=utf8"
   # DATABASE_URL="sqlite:///%kernel.project_dir%/var/data.db"

   Cambia your_secret_key por una cadena segura y aleatoria. Para la base de datos, el usuario predeterminado en ServBay suele ser root y la contraseña password (te recomendamos cambiarlas en producción). Usaremos servbay_symfony_app como nombre de ejemplo para la base de datos.

Configuración del servidor web (Sitios en ServBay)

Para acceder a tu proyecto Symfony desde el navegador, usa la función “Sitios web” de ServBay para agregar un host virtual local. El directorio raíz web de Symfony es public/.

Abre el panel de control de ServBay y navega a la sección de configuración de “Sitio web” (o “Host” en versiones antiguas) para añadir uno nuevo:

• Nombre: Elige un nombre reconocible, por ejemplo Mi sitio Symfony Dev.
• Dominio: Define un dominio local, como servbay-symfony-test.local. ServBay lo resolverá automáticamente a tu máquina.
• Tipo de sitio web: Selecciona PHP.
• Versión de PHP: Elige una versión de PHP compatible con Symfony, preferentemente la última estable que te ofrezca ServBay, como 8.3.
• Raíz del sitio: Este parámetro es clave. Debe señalar a la carpeta public/ del proyecto: /Applications/ServBay/www/servbay-symfony-app/public.

Guarda y aplica los cambios. ServBay actualizará la configuración del servidor web y, gracias a Caddy o Apache, generará y confiará el certificado SSL para tu dominio local, permitiendo acceso seguro por HTTPS.

Para instrucciones detalladas, revisa Cómo añadir tu primer sitio web en ServBay.

Añadir código de ejemplo básico

Para comprobar que la configuración del sitio web es correcta, agreguemos una ruta y controlador simples que muestren un mensaje al acceder a la raíz del sitio.

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

   Abre el archivo config/routes.yaml y añade lo siguiente para crear la ruta / que apunta al método index de un controlador:

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

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

   Crea el archivo DefaultController.php en la carpeta src/Controller/ y agrega 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 respuesta HTTP sencilla
           return new Response('Hello ServBay and Symfony!');
       }
   }

   Este controlador básico tiene el método index asociado a la raíz / con la anotación @Route("/"). Al visitar esa ruta, se mostrará el texto "Hello ServBay and Symfony!".

Acceso al sitio web

Ahora, abre tu navegador y accede al dominio configurado en ServBay: https://servbay-symfony-test.local. Si todo está bien, deberías ver en pantalla:

Hello ServBay and Symfony!

Eso confirma que el proyecto Symfony funciona correctamente en el servidor web de ServBay. Recuerda que ServBay configura HTTPS por defecto, así que accede usando https://.

Ejemplos de base de datos y caché

Symfony emplea Doctrine ORM para gestionar bases de datos relacionales y el componente Symfony Cache para almacenamientos en caché y bases de datos NoSQL. ServBay te facilita el uso de estas tecnologías, ofreciendo diferentes servicios y extensiones PHP.

Ejemplo con base de datos relacional (Doctrine ORM)

ServBay soporta MySQL y PostgreSQL. Aquí te enseñamos cómo configurarlos y usarlos en Symfony.

1. Configura la conexión

   En el archivo .env de la raíz, descomenta y ajusta la línea DATABASE_URL según la base de datos elegida.

   • Para MySQL: ServBay usa root como usuario por defecto, password como contraseña y el puerto 3306.

     # .env
     DATABASE_URL="mysql://root:password@127.0.0.1:3306/servbay_symfony_app?serverVersion=8.0&charset=utf8mb4"

   • Para PostgreSQL: Usuario por defecto root, contraseña password, puerto 5432.

     # .env
     DATABASE_URL="postgresql://root:password@127.0.0.1:5432/servbay_symfony_app?serverVersion=13&charset=utf8"

   Asegúrate de que el servicio de MySQL o PostgreSQL está activo desde el panel de ServBay.

2. Crea la base de datos

   Si servbay_symfony_app no existe, créala manualmente usando las herramientas de ServBay (phpMyAdmin, pgAdmin) o con este comando:

   php bin/console doctrine:database:create

3. Crea la Entity y la migración

   Doctrine usa Entities para mapear las tablas. Puedes generarlas fácilmente con Maker Bundle.

   • Crea la entidad (por ejemplo, User):

     php bin/console make:entity User

     Añade campos como name (string) y email (string, único).
   • Genera la migración:

     php bin/console make:migration

     Se creará un archivo en src/Migrations con la sentencia SQL para la tabla.

4. Ejecuta la migración

   Aplica los cambios en la base de datos con:

   php bin/console doctrine:migrations:migrate

5. Ejemplo de operaciones con la base de datos

   Edita src/Controller/DefaultController.php para añadir rutas y métodos de ejemplo que lean y escriban datos usando Doctrine. Necesitarás inyectar EntityManagerInterface.

   Primero, ajusta el constructor para recibir 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 EntityManagerInterface
   use App\Entity\User; // Importa la entidad User
   use Symfony\Component\HttpFoundation\JsonResponse; // Para respuestas JSON
   
   class DefaultController
   {
       private $entityManager;
   
       // Inyección de dependencias
       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 ...
   }

   Añade rutas en config/routes.yaml:

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

   Métodos del 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;
   
   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();
           // Ejemplo de datos relacionados con ServBay
           $user->setName('ServBay Demo User');
           $user->setEmail('demo-user@servbay.test');
   
           // Persiste el objeto (lo prepara para guardar)
           $this->entityManager->persist($user);
           // Realiza la operación de guardado
           $this->entityManager->flush();
   
           return new Response('¡Usuario agregado exitosamente!');
       }
   
       /**
        * @Route("/get-users", name="app_get_users")
        */
       public function getUsers(): JsonResponse
       {
           // Obtiene todos los usuarios desde la base de datos
           $users = $this->entityManager->getRepository(User::class)->findAll();
   
           // Convierte el resultado en un array para JsonResponse
           $usersArray = [];
           foreach ($users as $user) {
               $usersArray[] = [
                   'id' => $user->getId(),
                   'name' => $user->getName(),
                   'email' => $user->getEmail(),
               ];
           }
   
           // Devuelve la respuesta en formato JSON
           return new JsonResponse($usersArray);
       }
   }

6. Acceso a los ejemplos

   • Accede a https://servbay-symfony-test.local/add-user para agregar un usuario.
   • Ve a https://servbay-symfony-test.local/get-users para ver la lista de usuarios en formato JSON.

Ejemplo de caché y NoSQL (Symfony Cache)

ServBay incluye servicios Redis y Memcached y sus extensiones PHP correspondientes, para ser usados a través del componente Symfony Cache.

1. Configura la conexión de caché

   En el .env, señala el servicio de caché que deseas usar.

   • Memcached: El puerto por defecto es 11211.

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

     Cerciórate de que Memcached está activo en el panel de ServBay.
   • Redis: El puerto por defecto es 6379.

     # .env
     # ...
     CACHE_DSN=redis://127.0.0.1:6379
     # Si Redis requiere contraseña (por defecto no en ServBay):
     # CACHE_DSN=redis://:your_password@127.0.0.1:6379

     Activa Redis en el panel de ServBay.

2. Ejemplo de uso de caché

   Modifica el constructor de DefaultController para recibir CacheInterface:

   <?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
   
       // Constructor con inyección de caché
       public function __construct(EntityManagerInterface $entityManager, CacheInterface $cache)
       {
           $this->entityManager = $entityManager;
           $this->cache = $cache;
       }
   
       // ... Otros métodos ...
   }

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

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

   Método de ejemplo en el 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;
   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 obtener datos desde el caché
           $cacheItem = $this->cache->get('my_symfony_cache_key', function (ItemInterface $item) {
               // Callback si el caché no existe
               $item->expiresAfter(3600); // Caduca tras una hora
   
               // Simula una operación costosa, como consultar datos complejos
               $data = "Data generated at " . date('Y-m-d H:i:s');
   
               // Retorna el dato a almacenar
               return $data;
           });
   
           // $cacheItem tiene el dato del caché (si existe) o uno recién generado
           $output = "From Cache: " . $cacheItem;
   
           return new Response($output);
       }
   }

3. Prueba el ejemplo

   • Visita https://servbay-symfony-test.local/cache-example. La primera vez se genera el dato y se guarda en el caché; en accesos sucesivos, antes de que caduque, el dato se lee directamente de Memcached o Redis.

Preguntas frecuentes (FAQ)

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

R: Comprueba lo siguiente:

1. ServBay está en ejecución y el servicio correspondiente (Caddy o Apache) está activo.
2. Revisa que el dominio servbay-symfony-test.local está bien configurado y que la “raíz del sitio web” apunta exactamente a /Applications/ServBay/www/servbay-symfony-app/public.
3. Consulta el archivo de log (var/log/dev.log) del proyecto Symfony para detalles del error.
4. Ejecuta composer install en la raíz del proyecto para asegurarte de que las dependencias están instaladas.
5. Verifica que la versión de PHP corresponde con la requerida por tu proyecto Symfony.

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

R: Verifica esto:

1. El servicio de base de datos necesario (MySQL o PostgreSQL) está activo en el panel de ServBay.
2. La cadena DATABASE_URL del .env es correcta: usuario, contraseña, host (127.0.0.1), puerto (MySQL 3306, PostgreSQL 5432) y nombre de base de datos.
3. El usuario y contraseña corresponden a los valores predeterminados o los personalizados en ServBay.
4. La base de datos servbay_symfony_app existe y está creada.

P: ¿No puedo ejecutar el comando php bin/console?

R: Asegúrate de estar en la carpeta correcta /Applications/ServBay/www/servbay-symfony-app y de que PHP de ServBay está en el PATH del sistema (ServBay suele configurarlo automáticamente). Puedes comprobar qué PHP usas con which php.

Resumen

Siguiendo esta guía has creado, configurado y ejecutado un proyecto básico Symfony usando ServBay en macOS. ServBay reúne todos los componentes necesarios para el desarrollo con Symfony (PHP, Composer, servidor web, bases de datos y caché) y simplifica la puesta en marcha del entorno para que puedas centrarte en tu aplicación. Continua explorando más funcionalidades de Symfony y aprovecha todos los servicios y herramientas que ServBay te ofrece para desarrolladores.