Criando e Executando um Projeto Symfony

O ServBay é um ambiente local de desenvolvimento web criado especialmente para macOS e Windows, integrando runtimes de várias linguagens como PHP, Node.js, Python, Go e Java, além de bancos de dados como MySQL, PostgreSQL, MongoDB, Redis e servidores web Apache e Caddy. Este guia detalha como usar o ServBay para criar e rodar rapidamente um projeto Symfony nessas plataformas.

O que é Symfony?

Symfony é um framework web PHP open source desenvolvido pela SensioLabs, projetado para oferecer aos desenvolvedores um conjunto eficiente, flexível e poderoso de ferramentas para criar aplicações web modernas e APIs. Seguindo as melhores práticas do mercado, o Symfony traz diversos componentes úteis como roteamento, template engine (Twig), gerenciamento de formulários, autenticação, injeção de dependência e outros, facilitando muitas tarefas comuns de desenvolvimento web.

Principais Características e Benefícios do Symfony

• Design modular: O núcleo do Symfony é a sua biblioteca de componentes reutilizáveis, permitindo ao desenvolvedor escolher aquilo que precisa para construir desde aplicações leves até sistemas robustos.
• Alta performance: Sua arquitetura otimizada, mecanismos de cache e suporte aos recursos mais modernos do PHP garantem ótimo desempenho.
• Grande comunidade: Conta com uma comunidade ativa, vastos bundles (plugins) de terceiros e documentação rica, tornando mais fácil resolver dúvidas e problemas.
• Flexibilidade: Integra facilmente diferentes bibliotecas e extensões, sendo indicado para projetos de todos os tamanhos e níveis de complexidade.
• Estabilidade e manutenção: Segue boas práticas de codificação e padrões de design, facilitando testes, manutenção e evolução das aplicações.

Symfony é ideal para o desenvolvimento de projetos web que vão desde pequenas APIs até grandes sistemas corporativos.

Criando e Executando um Projeto Symfony com ServBay

O ServBay oferece todo o suporte de ambiente para projetos Symfony, incluindo versões de PHP, Composer, servidores web e diversos bancos de dados e serviços de cache. Nesta seção, mostramos como criar um novo projeto Symfony e configurá-lo com o ServBay.

Pré-requisitos

Antes de iniciar, certifique-se de que:

1. ServBay instalado: Você já instalou e iniciou o ServBay no macOS. Se não instalou ainda, consulte o Guia de Instalação do ServBay.
2. Serviços do ServBay ativos: O servidor web principal (Caddy ou Apache) e o banco de dados necessário estão rodando.
3. Conhecimentos básicos: Você tem noções básicas de PHP, Composer e Symfony.

Criando um Projeto Symfony

O ServBay recomenda que seus projetos de sites sejam armazenados na pasta /Applications/ServBay/www, facilitando o reconhecimento e gerenciamento dos projetos pelo ServBay.

1. Verifique o Composer

   O ServBay já traz o Composer pré-instalado e configurado no ambiente, não sendo necessário instalar manualmente. Para verificar, use o comando no terminal: composer --version

2. Crie o diretório do projeto

   Dentro do diretório recomendado, crie uma nova pasta para o seu projeto Symfony:

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

3. Use o Composer para criar o projeto Symfony

   Acesse o diretório criado e utilize o Composer para gerar a estrutura inicial do Symfony baseada no website-skeleton, que já inclui dependências essenciais.

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

   Este comando irá baixar os arquivos do Symfony e suas dependências para o diretório atual.

Configuração Inicial

Normalmente, as configurações centrais do Symfony são gerenciadas por variáveis de ambiente, que ficam no arquivo .env na raiz do projeto.

1. Configure variáveis de ambiente (.env)

   Abra o arquivo .env na raiz do projeto, onde você pode definir configurações como conexão com o banco de dados e chave secreta do app. Ajuste conforme a necessidade:

   Certifique-se de que estas configurações estão corretas conforme seu ambiente ServBay:

   # Exemplo de .env
   APP_ENV=dev # Ambiente de desenvolvimento
   APP_SECRET=your_secret_key # Substitua por uma string aleatória única para segurança
   
   # Informações de conexão com banco de dados (exemplo com MySQL, ver detalhes abaixo)
   # 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"

   Troque your_secret_key por uma string segura aleatória. Para bancos de dados, o usuário padrão do ServBay costuma ser root e a senha password (lembre-se de sempre alterá-los em produção!). Usaremos servbay_symfony_app como exemplo de nome do banco de dados.

Configurando o Servidor Web (Site ServBay)

Para acessar seu projeto Symfony no navegador, utilize o recurso “Sites” do ServBay para configurar seu host virtual local. A pasta public/ do projeto é o diretório web root do Symfony.

Acesse o painel do ServBay, vá em “Sites” (ou “Hosts” em versões antigas) e adicione um novo site:

• Nome: Dê um nome descritivo, por exemplo My Symfony Dev Site.
• Domínio: Defina um domínio local como servbay-symfony-test.local. O ServBay fará o redirecionamento automático.
• Tipo de site: Selecione PHP.
• Versão do PHP: Escolha uma versão compatível (recomendada a mais recente estável, exemplo 8.3).
• Root do site: O ponto mais crucial; para projetos Symfony, defina o root como /Applications/ServBay/www/servbay-symfony-app/public.

Depois de salvar, o ServBay ajusta a configuração do servidor web automaticamente. Ele usa Caddy ou Apache e cria certificados SSL para o domínio local, permitindo acesso direto via HTTPS.

Para um passo a passo detalhado, veja Como adicionar o primeiro site ServBay.

Adicionando Código de Exemplo Básico

Para testar se a configuração está funcionando, adicione uma rota e controlador simples para exibir uma mensagem na raiz do site.

1. Configure a rota (config/routes.yaml)

   No arquivo config/routes.yaml, inclua:

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

2. Crie o controlador (src/Controller/DefaultController.php)

   No diretório src/Controller/, crie DefaultController.php com o seguinte 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
       {
           // Retorna uma resposta HTTP simples
           return new Response('Hello ServBay and Symfony!');
       }
   }

   Esse exemplo cria um controlador chamado DefaultController onde o método index é vinculado à rota / e retorna o texto "Hello ServBay and Symfony!".

Acessando o Site

Abra seu navegador e acesse https://servbay-symfony-test.local. Se tudo estiver correto, verá:

Hello ServBay and Symfony!

Isso confirma que seu projeto Symfony está rodando com o servidor web do ServBay. O acesso recomendado é via HTTPS, já que o SSL é configurado automaticamente.

Exemplos de Banco de Dados e Cache

O Symfony geralmente utiliza Doctrine ORM para bancos de dados relacionais, além do componente Cache para armazenamento de dados e uso com bancos NoSQL. O ServBay traz serviços e extensões PHP para bancos como MySQL, PostgreSQL, Redis e Memcached, fáceis de integrar no Symfony.

Exemplo de Banco de Dados Relacional (Doctrine ORM)

O ServBay suporta MySQL e PostgreSQL. Veja como configurar e usar ambos no Symfony.

1. Configuração da Conexão com o Banco

   No .env, descomente e ajuste a opção correta de DATABASE_URL.

   • Para MySQL: Usuário padrão é root, senha password, porta 3306:

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

   • Para PostgreSQL: Usuário padrão é root, senha password, porta 5432:

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

   Garanta que o serviço correspondente esteja ativado no painel do ServBay.

2. Criando o banco de dados

   Se o banco servbay_symfony_app ainda não existir, crie usando a ferramenta de administração do ServBay (phpMyAdmin ou pgAdmin) ou utilizando o comando do Symfony:

   php bin/console doctrine:database:create

3. Criação de Entity e Migration

   Com o Maker Bundle, você pode gerar facilmente Entities e arquivos de migration.

   • Criar Entity (exemplo: entidade User):

     php bin/console make:entity User

     Defina campos como name (string) e email (string, único).
   • Gerar arquivo de migration:

     php bin/console make:migration

     Isso criará o arquivo de migration (SQL) dentro de src/Migrations.

4. Executando a Migration

   Para aplicar a estrutura no banco de dados:

   php bin/console doctrine:migrations:migrate

5. Exemplo de Operação no Banco

   Edite src/Controller/DefaultController.php para incluir métodos de exemplo usando Doctrine para inserir e consultar dados. É necessário injetar EntityManagerInterface.

   No construtor do DefaultController, injete 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 resposta JSON
   
   class DefaultController
   {
       private $entityManager;
   
       // Injeta EntityManagerInterface via construtor
       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 ...
   }

   Adicione as rotas em config/routes.yaml:

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

   Inclua os métodos no 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();
           // Dados de exemplo relacionados ao ServBay
           $user->setName('ServBay Demo User');
           $user->setEmail('demo-user@servbay.test');
   
           // Persiste o objeto (prepara para inserir)
           $this->entityManager->persist($user);
           // Executa a inserçã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
       {
           // Busca todos os usuários no banco
           $users = $this->entityManager->getRepository(User::class)->findAll();
   
           // Converte o resultado em array para usar no JsonResponse
           $usersArray = [];
           foreach ($users as $user) {
               $usersArray[] = [
                   'id' => $user->getId(),
                   'name' => $user->getName(),
                   'email' => $user->getEmail(),
               ];
           }
   
           // Retorna os dados em JSON
           return new JsonResponse($usersArray);
       }
   }

6. Acesse os exemplos

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

Exemplo de Cache e Banco NoSQL (Symfony Cache)

O ServBay oferece Redis e Memcached nativos, além das extensões PHP necessárias, facilitando o uso do componente Symfony Cache.

1. Configuração da conexão com cache

   No arquivo .env, configure o serviço de cache de acordo com sua escolha.

   • Com Memcached: Porta padrão: 11211

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

     Lembre-se de ativar o serviço Memcached via painel do ServBay.
   • Com Redis: Porta padrão: 6379

     # .env
     # ... outras configurações ...
     CACHE_DSN=redis://127.0.0.1:6379
     # Se precisar de senha (por padrão no ServBay não usa):
     # CACHE_DSN=redis://:sua_senha@127.0.0.1:6379

     Lembre-se de ativar o serviço Redis via painel do ServBay.

2. Exemplo de uso de cache

   Edite src/Controller/DefaultController.php e inclua métodos que demonstram o uso do componente Cache do Symfony (Memcached ou Redis), usando injeção de CacheInterface.

   No construtor do controlador, 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; // Propriedade cache
   
       // Injeta CacheInterface no construtor
       public function __construct(EntityManagerInterface $entityManager, CacheInterface $cache)
       {
           $this->entityManager = $entityManager;
           $this->cache = $cache;
       }
   
       // ... outros métodos ...
   }

   Crie a rota em config/routes.yaml:

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

   Adicione o método no 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;
       }
   
       // ... outros métodos ...
   
       /**
        * @Route("/cache-example", name="app_cache_example")
        */
       public function cacheExample(): Response
       {
           // Tenta recuperar dados do cache
           $cacheItem = $this->cache->get('my_symfony_cache_key', function (ItemInterface $item) {
               // Se não encontrar, executa o callback
               $item->expiresAfter(3600); // Cache válido por 1 hora
   
               // Simula uma operação pesada
               $data = "Dados gerados em " . date('Y-m-d H:i:s');
   
               return $data;
           });
   
           $output = "Do Cache: " . $cacheItem;
   
           return new Response($output);
       }
   }

3. Testando o exemplo

   • Acesse https://servbay-symfony-test.local/cache-example. A primeira visita gera e salva o dado no cache. As próximas usam o dado em cache até expirar.

Perguntas Frequentes (FAQ)

P: Ao acessar https://servbay-symfony-test.local aparece erro 500 ou página não encontrada. O que fazer?

R: Verifique:

1. Se o ServBay está rodando e o serviço web (Caddy ou Apache) está ativo.
2. Se as configurações do site no ServBay estão corretas, com domínio servbay-symfony-test.local e root em /Applications/ServBay/www/servbay-symfony-app/public.
3. O arquivo de log do Symfony está em var/log/dev.log — veja se há detalhes do erro.
4. Rode composer install no diretório do projeto para garantir que todas dependências estão presentes.
5. Confira se a versão do PHP está de acordo com o Symfony.

P: Não consigo conectar ao banco de dados. E agora?

R: Verifique:

1. Se o serviço do banco (MySQL ou PostgreSQL) está rodando no painel do ServBay.
2. Se o DATABASE_URL no .env contém usuário, senha, host (127.0.0.1), porta (3306 para MySQL, 5432 para PostgreSQL) e nome do banco corretos.
3. Usuário e senha do banco devem ser os padrões do ServBay ou os que você tenha alterado.
4. O banco servbay_symfony_app precisa existir.

P: O comando php bin/console não funciona?

R: Certifique-se de estar no diretório /Applications/ServBay/www/servbay-symfony-app no terminal, e que o PHP do ServBay está corretamente no PATH do sistema (normalmente configurado automaticamente pela instalação). Execute which php para conferir se é o PHP do ServBay.

Conclusão

Este guia trouxe o passo a passo para criar, configurar e executar rapidamente um projeto básico Symfony com ServBay no macOS. O ServBay oferece todos os componentes essenciais para o desenvolvimento Symfony (PHP, Composer, servidor web, banco de dados, cache), simplificando a configuração do ambiente e acelerando seu ciclo de desenvolvimento. A partir desse ponto você poderá aprofundar-se nas funcionalidades do Symfony e explorar todos os recursos extras que o ServBay disponibiliza.