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:
- 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.
- ServBay en ejecución: Los servicios principales de ServBay (como Caddy o Apache y las bases de datos requeridas) están activos.
- 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.
- 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.
- Crea el directorio del proyecto - En la raíz sugerida de los sitios web, crea una nueva carpeta para el proyecto Symfony: bash- cd /Applications/ServBay/www mkdir servbay-symfony-app1
 2
- 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.bash- cd /Applications/ServBay/www/servbay-symfony-app composer create-project symfony/website-skeleton .1
 2- 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.
- Configura las variables de entorno ( - .env)- Abre el archivo - .enven 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: dotenv- # 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"1
 2
 3
 4
 5
 6
 7
 8- Cambia - your_secret_keypor una cadena segura y aleatoria. Para la base de datos, el usuario predeterminado en ServBay suele ser- rooty la contraseña- password(te recomendamos cambiarlas en producción). Usaremos- servbay_symfony_appcomo 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.
- Configura la ruta ( - config/routes.yaml)- Abre el archivo - config/routes.yamly añade lo siguiente para crear la ruta- /que apunta al método- indexde un controlador:yaml- # config/routes.yaml index: path: / controller: App\Controller\DefaultController::index1
 2
 3
 4
- Crea el controlador ( - src/Controller/DefaultController.php)- Crea el archivo - DefaultController.phpen la carpeta- src/Controller/y agrega 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 respuesta HTTP sencilla return new Response('Hello ServBay and Symfony!'); } }1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18- Este controlador básico tiene el método - indexasociado 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!1
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.
- Configura la conexión - En el archivo - .envde la raíz, descomenta y ajusta la línea- DATABASE_URLsegún la base de datos elegida.- Para MySQL: ServBay usa rootcomo usuario por defecto,passwordcomo contraseña y el puerto3306.dotenv# .env DATABASE_URL="mysql://root:password@127.0.0.1:3306/servbay_symfony_app?serverVersion=8.0&charset=utf8mb4"1
 2
- Para PostgreSQL: Usuario por defecto root, contraseñapassword, puerto5432.dotenv# .env DATABASE_URL="postgresql://root:password@127.0.0.1:5432/servbay_symfony_app?serverVersion=13&charset=utf8"1
 2
 - Asegúrate de que el servicio de MySQL o PostgreSQL está activo desde el panel de ServBay. 
- Para MySQL: ServBay usa 
- Crea la base de datos - Si - servbay_symfony_appno existe, créala manualmente usando las herramientas de ServBay (phpMyAdmin, pgAdmin) o con este comando:bash- php bin/console doctrine:database:create1
- 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):bashAñade campos comophp bin/console make:entity User1name(string) yemail(string, único).
- Genera la migración:bashSe creará un archivo enphp bin/console make:migration1src/Migrationscon la sentencia SQL para la tabla.
 
- Crea la entidad (por ejemplo, 
- Ejecuta la migración - Aplica los cambios en la base de datos con: bash- php bin/console doctrine:migrations:migrate1
- Ejemplo de operaciones con la base de datos - Edita - src/Controller/DefaultController.phppara 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- <?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 ... }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- Añade rutas en - config/routes.yaml: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::getUsers1
 2
 3
 4
 5
 6
 7
 8- Métodos del 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; 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); } }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
 67
- Acceso a los ejemplos - Accede a https://servbay-symfony-test.local/add-userpara agregar un usuario.
- Ve a https://servbay-symfony-test.local/get-userspara ver la lista de usuarios en formato JSON.
 
- Accede a 
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.
- 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.dotenvCerciórate de que Memcached está activo en el panel de ServBay.# .env # ... CACHE_DSN=memcached://127.0.0.1:112111
 2
 3
- Redis: El puerto por defecto es 6379.dotenvActiva Redis en el panel de ServBay.# .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:63791
 2
 3
 4
 5
 
- Memcached: El puerto por defecto es 
- Ejemplo de uso de caché - Modifica el constructor de - DefaultControllerpara recibir- CacheInterface: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 // Constructor con inyección de 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
 25- Añade la ruta en - config/routes.yaml:yaml- # config/routes.yaml # ... demás rutas ... cache_example: path: /cache-example controller: App\Controller\DefaultController::cacheExample1
 2
 3
 4
 5- Método de ejemplo en el 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; 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); } }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
- 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.
 
- Visita 
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:
- ServBay está en ejecución y el servicio correspondiente (Caddy o Apache) está activo.
- Revisa que el dominio servbay-symfony-test.localestá bien configurado y que la “raíz del sitio web” apunta exactamente a/Applications/ServBay/www/servbay-symfony-app/public.
- Consulta el archivo de log (var/log/dev.log) del proyecto Symfony para detalles del error.
- Ejecuta composer installen la raíz del proyecto para asegurarte de que las dependencias están instaladas.
- 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:
- El servicio de base de datos necesario (MySQL o PostgreSQL) está activo en el panel de ServBay.
- La cadena DATABASE_URLdel.enves correcta: usuario, contraseña, host (127.0.0.1), puerto (MySQL 3306, PostgreSQL 5432) y nombre de base de datos.
- El usuario y contraseña corresponden a los valores predeterminados o los personalizados en ServBay.
- La base de datos servbay_symfony_appexiste 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.
