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:
- 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.
- ServBay en funcionamiento: Los servicios principales de ServBay (como Caddy o Apache y la base de datos necesaria) deben estar activos.
- 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.
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
.Crear el directorio del proyecto
Crea un nuevo directorio en el directorio raíz recomendado para almacenar tu proyecto Symfony:
bashcd /Applications/ServBay/www mkdir servbay-symfony-app
1
2Crear 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.bashcd /Applications/ServBay/www/servbay-symfony-app composer create-project symfony/website-skeleton .
1
2Tras 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.
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:
dotenv# 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"
1
2
3
4
5
6
7
8Sustituye
your_secret_key
por una cadena aleatoria segura. En cuanto a la base de datos, el usuario por defecto en ServBay suele serroot
y la contraseñapassword
(es fundamental que cambies este dato en entornos de producción). Usaremosservbay_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.
Configurar la ruta (
config/routes.yaml
)Abre
config/routes.yaml
y añade el siguiente contenido para definir una ruta/
que apunte al métodoindex
del controlador:yaml# config/routes.yaml index: path: / controller: App\Controller\DefaultController::index
1
2
3
4Crear el controlador (
src/Controller/DefaultController.php
)Dentro de
src/Controller/
crea el archivoDefaultController.php
y añade este código:php<?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!'); } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18Este ejemplo define la clase
DefaultController
y asocia el métodoindex
, 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.
Configura la conexión a la base de datos
En el
.env
de tu proyecto, descomenta y edita la variableDATABASE_URL
según el sistema de bases de datos seleccionado.- Para MySQL: El usuario predeterminado de MySQL en ServBay es
root
, contraseñapassword
y puerto3306
(ajusta si es necesario).dotenv# .env DATABASE_URL="mysql://root:[email protected]:3306/servbay_symfony_app?serverVersion=8.0&charset=utf8mb4"
1
2 - Para PostgreSQL: El usuario predeterminado de PostgreSQL es
root
, contraseñapassword
y puerto5432
.dotenv# .env DATABASE_URL="postgresql://root:[email protected]:5432/servbay_symfony_app?serverVersion=13&charset=utf8"
1
2
Recuerda iniciar el servicio de base de datos elegido en el panel de ServBay (MySQL o PostgreSQL).
- Para MySQL: El usuario predeterminado de MySQL en ServBay es
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:bashphp bin/console doctrine:database:create
1Crear 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
):bashAñade los campos según la guía interactiva, por ejemplo:php bin/console make:entity User
1name
(string) yemail
(string, unique=yes). - Crear archivos de migración: Según los cambios en la entidad, genera la migración correspondiente:bashEsto creará un nuevo archivo en
php bin/console make:migration
1src/Migrations
con las instrucciones SQL necesarias.
- Crear una entidad (por ejemplo,
Ejecutar las migraciones
Aplica la estructura en la base de datos ejecutando:
bashphp bin/console doctrine:migrations:migrate
1Agregar 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 interfazEntityManagerInterface
.Primero, asegúrate que el constructor del controlador acepte
EntityManagerInterface
:php<?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 ... }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30Luego, añade nuevas rutas en
config/routes.yaml
: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
1
2
3
4
5
6
7
8Crea en
src/Controller/DefaultController.php
los métodos correspondientes: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; // 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); } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67Acceder 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).
- Visita
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.
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
.dotenvAsegúrate que el servicio Memcached está iniciado en el panel ServBay.# .env # ... otras configuraciones ... CACHE_DSN=memcached://127.0.0.1:11211
1
2
3 - Para Redis: Por defecto el puerto es
6379
.dotenvNo olvides asegurar que Redis esté funcionando en ServBay.# .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
1
2
3
4
5
- Para Memcached: El puerto por defecto es
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 interfazCacheInterface
.Primero, añade
CacheInterface
al constructor de tu controlador: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; // 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 ... }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25Añade la nueva ruta en
config/routes.yaml
:yaml# config/routes.yaml # ... otras rutas ... cache_example: path: /cache-example controller: App\Controller\DefaultController::cacheExample
1
2
3
4
5Y el método que lo emplea en
DefaultController.php
: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); } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47Acceder 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.
- Navega a
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:
- Asegúrate de que ServBay está en marcha y que el servidor web (Caddy o Apache) está iniciado.
- 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
. - Consulta los logs de tu proyecto Symfony en
var/log/dev.log
para detalles del error. - En la terminal, ejecuta
composer install
en la raíz de tu proyecto para instalar dependencias. - 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:
- Comprueba que el servicio de base de datos adecuado (MySQL o PostgreSQL) está iniciado en el panel de ServBay.
- 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). - Asegúrate que usuario y contraseña coinciden con las que has definido o que vienen por defecto en ServBay.
- 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.