Criando e Rodando um Projeto Symfony

O ServBay é um ambiente de desenvolvimento web local projetado especialmente para macOS, integrado com diversos runtimes de linguagem como PHP, Node.js, Python, Go e Java, além de bancos de dados como MySQL, PostgreSQL, MongoDB e Redis, e suporte aos servidores web Apache e Caddy. Este guia detalha como configurar e rodar rapidamente um projeto Symfony no macOS utilizando o ServBay.

O que é Symfony?

Symfony é um framework web PHP open source criado pela SensioLabs. Ele fornece um conjunto eficiente, flexível e poderoso de ferramentas para desenvolvedores construírem aplicações web modernas e APIs. O Symfony segue as melhores práticas da web e oferece uma grande variedade de componentes, como roteamento, template engine (Twig), tratamento de formulários, autenticação, injeção de dependências, entre outros, facilitando tarefas comuns no desenvolvimento web.

Principais Características e Vantagens do Symfony

• Design Modular: O núcleo do Symfony é construído sobre uma biblioteca de componentes reutilizáveis; desenvolvedores podem escolher e usar apenas o que precisarem, de aplicações leves a robustas.
• Alto desempenho: Através de uma arquitetura otimizada, mecanismos de cache eficazes e suporte aos recursos mais recentes do PHP, o Symfony oferece excelente performance.
• Comunidade Forte: O Symfony conta com uma grande comunidade de desenvolvedores, inúmeros bundles (plugins) de terceiros e documentação abrangente, tornando fácil encontrar soluções para problemas.
• Flexibilidade: Fácil integração com diversas bibliotecas e extensões de terceiros, sendo adequado para projetos de todos os portes e complexidades.
• Estabilidade e Manutenibilidade: Seguindo boas práticas de codificação e padrões de design, os aplicativos criados com Symfony são fáceis de testar, manter e expandir.

Symfony é indicado para a construção de qualquer tipo de projeto web: desde pequenas APIs até grandes sistemas empresariais.

Criando e Executando Projetos Symfony com ServBay

O ServBay fornece um ambiente completo para rodar projetos Symfony, incluindo a versão necessária do PHP, Composer, servidor web e serviços de banco de dados e cache. Nesta seção, você verá como criar um novo projeto Symfony e realizar sua configuração utilizando o ServBay.

Pré-requisitos

Antes de começar, certifique-se de ter feito o seguinte:

1. Instalação do ServBay: O ServBay está instalado e rodando no seu macOS. Caso não esteja instalado, veja o Guia de Instalação do ServBay.
2. Serviços do ServBay Ativos: Os serviços principais do ServBay (Caddy ou Apache, e bancos de dados que você precisa) estão em funcionamento.
3. Conhecimentos Básicos: Tenha noções básicas de PHP, Composer e Symfony.

Criando um Projeto Symfony

Recomenda-se centralizar seus projetos web no diretório /Applications/ServBay/www, facilitando assim o gerenciamento automático via ServBay.

1. Verifique o Composer

   O Composer já vem integrado no ServBay e está devidamente configurado no ambiente, dispensando instalação separada. Verifique se está disponível com o comando composer --version no terminal.

2. Crie o Diretório do Projeto

   No diretório sugerido, crie uma pasta para seu novo projeto Symfony:

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

3. Crie o Projeto Symfony com o Composer

   Entre na nova pasta e use o Composer para gerar um esqueleto de projeto Symfony baseado no website-skeleton, que contém dependências comuns para aplicações web tradicionais.

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

   Com este comando, o Composer fará o download dos arquivos essenciais do Symfony e suas dependências para o diretório atual.

Configuração Inicial

A configuração central de um projeto Symfony geralmente é feita por variáveis de ambiente armazenadas no arquivo .env na raiz do projeto.

1. Configure as Variáveis de Ambiente (.env)

   Abra o arquivo .env na raiz do projeto. Nele ficam as configurações de ambiente da aplicação, como dados de conexão do banco de dados e chaves secretas. Edite conforme sua necessidade.

   Certifique-se de ajustar as seguintes configurações de acordo com seu ambiente ServBay:

   # Exemplo de arquivo .env
   APP_ENV=dev # Ambiente de desenvolvimento
   APP_SECRET=your_secret_key # Substitua por uma string única e segura para fins de segurança
   
   # Exemplo de conexões de banco de dados (exemplo com MySQL, explicado a seguir)
   # 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"

   Substitua your_secret_key por uma string aleatória segura. O usuário e senha padrão no ServBay geralmente são root e password (lembre-se: em produção nunca use credenciais padrões!). Usaremos servbay_symfony_app como nome do banco de dados de exemplo.

Configurando o Servidor Web (Site do ServBay)

Para acessar seu projeto Symfony via navegador, use o recurso “Site” do ServBay para configurar um virtual host local. O diretório web root do Symfony é a pasta public/.

Abra o painel do ServBay e vá até a aba de configuração de “Site” (ou “Host” em versões antigas) para adicionar um novo site:

• Nome: Dê um nome fácil de reconhecer, como My Symfony Dev Site.
• Domínio: Defina um domínio local de desenvolvimento, como servbay-symfony-test.local. O ServBay cuida da resolução automaticamente.
• Tipo de Site: Selecione PHP.
• Versão PHP: Escolha uma versão compatível com seu projeto Symfony, recomenda-se a mais recente estável do ServBay, como 8.3.
• Diretório Root: Este é o ponto principal. Para Symphony, o root deve ser a pasta public/: /Applications/ServBay/www/servbay-symfony-app/public.

Salve e aplique as mudanças. O ServBay atualizará automaticamente a configuração do servidor web. Ele usa Caddy ou Apache por padrão, gerando automaticamente certificados SSL confiáveis para seu domínio local; assim, você pode acessar via HTTPS de imediato.

Para etapas detalhadas, veja Adicionando seu primeiro site no ServBay.

Adicionando Código de Exemplo Básico

Para testar se a configuração do site está ok, vamos criar uma rota e um controller simples, exibindo um texto ao acessar a raiz.

1. Configuração de Rota (config/routes.yaml)

   Edite o arquivo config/routes.yaml e adicione:

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

2. Criando o Controller (src/Controller/DefaultController.php)

   Crie o arquivo DefaultController.php em src/Controller/, com o conteúdo:

   <?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
       {
           // Retorna uma resposta HTTP simples
           return new Response('Hello ServBay and Symfony!');
       }
   }

   O controller acima associa o método index à rota /, retornando a mensagem "Hello ServBay and Symfony!" em resposta HTTP.

Acessando o Site

Abra o navegador e acesse o domínio configurado no ServBay: https://servbay-symfony-test.local. Se tudo estiver correto, você verá:

Hello ServBay and Symfony!

Isso indica que o projeto Symfony está rodando no ServBay com sucesso. Dica: use sempre o prefixo https://, pois o ServBay configura SSL local automaticamente.

Exemplos de Banco de Dados e Cache

O Symfony normalmente utiliza Doctrine ORM para bancos relacionais e o componente Symfony Cache para cache e bancos NoSQL. O ServBay já oferece serviços de bancos de dados e extensões PHP prontos para uso em projetos Symfony.

Banco de Dados Relacional (Doctrine ORM)

O ServBay suporta MySQL e PostgreSQL. A seguir, veja como configurar e usar cada um.

1. Configuração da Conexão do Banco de Dados

   No .env, descomente e edite a linha DATABASE_URL conforme o banco utilizado.

   • Usando MySQL: Os padrões do ServBay são usuário root, senha password, porta 3306. Ajuste se necessário.

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

   • Usando PostgreSQL: Padrão do ServBay: usuário root, senha password, porta 5432.

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

   Certifique-se de que o banco correspondente está ativo no painel do ServBay.

2. Crie o Banco de Dados

   Se não existir, crie o banco via a interface do ServBay (phpMyAdmin, pgAdmin) ou pelo console do Symfony:

   php bin/console doctrine:database:create

3. Crie uma Entity e o Arquivo de Migration

   As entidades correspondem a tabelas do banco. Com o Maker Bundle, gere uma Entity e um arquivo de migration.

   • Criar Entity (ex: entidade User):

     php bin/console make:entity User

     Siga os prompts (ex: campos name e email, com email único).
   • Gerar arquivos de migration:

     php bin/console make:migration

     Um arquivo de migration será criado em src/Migrations, com os comandos SQL para a tabela users.

4. Executar a Migration

   Aplique as alterações no banco:

   php bin/console doctrine:migrations:migrate

5. Adicionar Exemplo de Operação com o Banco de Dados

   Edite src/Controller/DefaultController.php para adicionar rotas e métodos de teste usando o Doctrine. Você vai precisar do EntityManagerInterface via injeção.

   No construtor do DefaultController, injete o 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 a entidade User
   use Symfony\Component\HttpFoundation\JsonResponse; // Para respostas JSON
   
   class DefaultController
   {
       private $entityManager;
   
       // Injeção de dependência do EntityManagerInterface
       public function __construct(EntityManagerInterface $entityManager)
       {
           $this->entityManager = $entityManager;
       }
   
       /**
        * @Route("/", name="app_index")
        */
       public function index(): Response
       {
           return new Response('Hello ServBay and Symfony!');
       }
   
       // ... outros métodos ...
   }

   No config/routes.yaml, adicione as novas rotas:

   # config/routes.yaml
   # ... outras rotas ...
   mysql_add_user:
       path: /mysql-add-user # ou /pgsql-add-user, conforme o banco
       controller: App\Controller\DefaultController::addUser
   mysql_get_users:
       path: /mysql-users # ou /pgsql-users
       controller: App\Controller\DefaultController::getUsers

   E então, os métodos correspondentes no controller:

   <?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();
           // Dados de exemplo com a marca ServBay
           $user->setName('ServBay Demo User');
           $user->setEmail('[email protected]');
   
           // Persistir a entidade (preparar para salvar)
           $this->entityManager->persist($user);
           // Executar a gravação no banco
           $this->entityManager->flush();
   
           return new Response('Usuário adicionado com sucesso!');
       }
   
       /**
        * @Route("/get-users", name="app_get_users")
        */
       public function getUsers(): JsonResponse
       {
           // Buscar todos os users no banco
           $users = $this->entityManager->getRepository(User::class)->findAll();
   
           // Converter resultado para array para o JsonResponse
           $usersArray = [];
           foreach ($users as $user) {
               $usersArray[] = [
                   'id' => $user->getId(),
                   'name' => $user->getName(),
                   'email' => $user->getEmail(),
               ];
           }
   
           // Retornar resposta em JSON
           return new JsonResponse($usersArray);
       }
   }

6. Acessando exemplos

   • Acesse https://servbay-symfony-test.local/add-user para adicionar um usuário.
   • Acesse https://servbay-symfony-test.local/get-users para listar os usuários cadastrados (em JSON).

Exemplo de Cache e Banco de Dados NoSQL (Symfony Cache)

O ServBay disponibiliza Redis e Memcached (mais extensões PHP), prontos para uso com o componente Cache do Symfony.

1. Configuração de conexão de cache

   No .env, configure conforme o serviço desejado:

   • Memcached (padrão na porta 11211):

     # .env
     # ... outras configurações ...
     CACHE_DSN=memcached://127.0.0.1:11211

     Certifique-se de que o Memcached está ativo no ServBay.
   • Redis (padrão na porta 6379):

     # .env
     # ... outras configurações ...
     CACHE_DSN=redis://127.0.0.1:6379
     # Caso necessite senha (padrão ServBay sem senha), ficaria:
     # CACHE_DSN=redis://:[email protected]:6379

     Certifique-se de que o Redis está ativo no ServBay.

2. Adicionando exemplo de uso do cache

   Edite src/Controller/DefaultController.php e adicione roteamento e métodos demonstrando o uso do Symfony Cache. Injete o CacheInterface.

   No construtor do controller, injete 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; // Adiciona cache property
   
       // Injeção do CacheInterface
       public function __construct(EntityManagerInterface $entityManager, CacheInterface $cache)
       {
           $this->entityManager = $entityManager;
           $this->cache = $cache; // Atribui o cache
       }
   
       // ... outros métodos ...
   }

   Em config/routes.yaml, adicione uma rota nova:

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

   No controller, adicione o método de exemplo:

   <?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;
       }
   
       // ... outros métodos ...
   
       /**
        * @Route("/cache-example", name="app_cache_example")
        */
       public function cacheExample(): Response
       {
           // Busca dados do cache (ou gera se não existir)
           $cacheItem = $this->cache->get('my_symfony_cache_key', function (ItemInterface $item) {
               // Se não existir, salva novo valor no cache por 1 hora
               $item->expiresAfter(3600);
   
               // Simula operação lenta (consulta pesada, etc)
               $data = "Data generated at " . date('Y-m-d H:i:s');
   
               // Retorna o dado para o cache
               return $data;
           });
   
           // $cacheItem já é o resultado do cache ou recém-gerado
           $output = "From Cache: " . $cacheItem;
   
           return new Response($output);
       }
   }

3. Acessando o exemplo

   • Acesse https://servbay-symfony-test.local/cache-example. A primeira visita executa o callback gerando o valor e armazenando no cache. As seguintes buscam direto do Memcached ou Redis, se o cache não tiver expirado.

Perguntas Frequentes (FAQ)

P: Estou recebendo erro de página não encontrada ou erro 500 ao acessar https://servbay-symfony-test.local. E agora?

R: Verifique:

1. O ServBay está rodando e o servidor do site (Caddy ou Apache) está ativo?
2. Na configuração do site no ServBay, o domínio servbay-symfony-test.local está certo e o “diretório root” está exatamente em /Applications/ServBay/www/servbay-symfony-app/public?
3. Consulte o arquivo de log do Symfony (var/log/dev.log) para detalhes do erro.
4. Rode composer install na raiz do projeto para garantir que todas dependências estejam instaladas.
5. Confirme que a versão do PHP é compatível com o projeto Symfony.

P: Falha na conexão com o banco de dados, o que fazer?

R: Revise:

1. O serviço desejado (MySQL ou PostgreSQL) está rodando no painel do ServBay?
2. O valor DATABASE_URL em .env está certo (usuário, senha, host 127.0.0.1, porta – MySQL 3306, PostgreSQL 5432 – e database)?
3. Usuário e senha realmente conferem com os valores atuais do ServBay?
4. O banco de dados servbay_symfony_app realmente existe?

P: Não consigo rodar comandos php bin/console?

R: Certifique-se de estar no diretório /Applications/ServBay/www/servbay-symfony-app no terminal, e que o PHP do ServBay está no PATH (o instalador do ServBay normalmente já faz isso). Confira com which php se está usando o PHP do ServBay.

Resumo

Com este guia, você criou, configurou e rodou um projeto Symfony básico no macOS via ServBay. O ServBay entrega todos os componentes necessários para o ciclo de desenvolvimento Symfony (PHP, Composer, servidor web, banco de dados, cache) e simplifica o setup, permitindo que você se concentre no desenvolvimento do seu app. Aprofunde-se na documentação Symfony e aproveite todo o ecossistema adicional de pacotes e serviços do ServBay!