Symfony

Conheça os principais projetos do Doctrine

Ao falar em Doctrine é normal pensarmos diretamente no ORM, porém o Doctrine é um conjunto de projetos em PHP voltados para trabalhar com banco de dados e outros recursos.

Projetos do Doctrine

O objetivo do doctrine inicialmente era construir um projeto único para garantir o acesso a dados de forma eficiente assim como em outras linguagens de programação, também no PHP. Com o tempo o projeto foi sendo melhorado e nesses processos os desenvolvedores começaram a observar que poderia separar o projeto em pequenos projetos que pudessem ser reutilizados, tanto dentro do próprio Doctrine quanto em outros projetos PHP, mesmo que a aplicação não utilize o Doctrine ORM em si.

Baseado nessa filosofia hoje o Doctrine conta com mais de 15 projetos. Os principais são:

DBAL

É uma camada de abstração de acesso a dados construída sobre o PDO. Conta com recursos importantes que permitem executar queries parametrizadas, construir consultas através do query builder, além de ferramentas para ler e alterar a estrutura do banco de dados.

ORM

O Doctrine ORM é um Object Relational Mapper que implementa o padrão Data Mapper. Seu principal objetivo é facilitar o mapeamento entre o banco de dados relacional e o modelo orientado a objetos, diminuindo a complexidade do acesso aos dados.

Commom

Agrupa recursos em comum que são compartilhados por diferentes projetos do Doctrine. O objetivo principal dele é evitar que trechos de códigos com recursos comuns tenham de ser duplicados dentro dos diversos projetos do Doctrine.

Migrations

Permite a definição da estrutura do banco de dados através de arquivos dentro da aplicação, facilitando a criação do banco de dados em novos ambientes e também o versionamento da estrutura do banco.

Annotations

No PHP é comum usarmos um padrão chamado DocBlock para documentarmos nossas aplicações. As annotations nada mais são do que informações que definimos dentro desses blocos de comentários, mas que são lidas pela aplicação, ao invés de ignoradas como os demais comentários. O projeto annotation consistem em um parser (leitor) que consegue obter essas informações de forma simples.

Collections

Projeto consiste em uma biblioteca que adiciona funcionalidades bastante úteis para o tratamento de conjuntos de informações. Podemos pensar de forma muito simplista nas collections como sendo funcionalidades adicionais sobre os arrays nativos do PHP.

Cache

Projeto muito utilizado na comunidade PHP para realização de cache. Por padrão possui drivers que permitem utilizá-lo com diferentes meios de armazenamento, como, redis, memcache e outros.

Event Manager

É um gerenciador de eventos usado em vários projetos do próprio Doctrine e também da comunidade em geral.

MongoDB Abstraction Layer

O projeto consiste em uma camada adicional de abstração que adiciona funcionalidades a extensão PHP Mongo disponível no PECL.

Mongo ODM

O Mongo ODM (Object Document Mapper) é um projeto da mesma categoria que o ORM, com a diferença que ele faz o mapeamento entre o modelo de documentos do banco de dados NoSQL Mongo para o modelo de orientado a objetos.

Outros projetos

O Doctrine ainda conta com outros projetos fora os especificados neste post. A lista completa pode ser acessada no site do Doctrine: https://www.doctrine-project.org/projects.html

Considerações finais

O doctrine conta com projetos de alta qualidade que podem ser usados em qualquer aplicação PHP, mesmo que não utilize os projetos principais como DBAL e ORM. Assim como conhecer os principais componentes do Symfony pode te ajudar na hora da escolha das bibliotecas, os projetos do Doctrine também são extremamente importantes para seu repertório.

Docker Desktop no Windows rodando com WSL 2

Com a inclusão de um kernel Linux completo dentro do Windows graças ao Windows Subsystem for Linux (WSL) 2, ferramentas que antes não podiam ser utilizadas no WSL por questões de compatibilidade agora podem ser executadas sem problemas. Uma dessas ferramentas muito utilizadas pelos desenvolvedores é o Docker.

No Windows 10 é possível utilizar o Docker Desktop para ter uma experiência integrada com o Docker, se aproximando muito de um sistema Linux. Entretanto, existem algumas limitações que com a atual versão que serão tratadas com a nova integração entre o Docker Desktop com o WSL 2.

Docker Desktop

O Docker Desktop é uma solução para executar containers Linux nos sistemas Windows e macOS. Ele permite que você tenha uma experiência semelhante a uma distribuição Linux, integrando o sistema de arquivos do sistemas e a rede com a máquina virtual que executa o Docker.

Essa máquina virtual é gerenciada pelo Docker Desktop através do hypervisor de virtualização do sistema, no caso do Windows o Hyper-V e do macOS o hyperkit. A execução dos containers em si acontece nessa máquina virtual, como podemos ver no diagrama abaixo:

Arquitetura do Docker Desktop

O Docker Desktop está disponível faz alguns anos, sendo a forma recomendada de executar Docker nos sistemas Windows e macOS, sendo possível com ele até executar um cluster de Kubernetes na sua máquina local.

Restrições do Docker Desktop

Apesar de ser a forma recomendada de executar o Docker nesses sistemas, um grande fator que impacta no seu uso é a performance em operações de leitura e escrita. Por executar dentro de uma máquina virtual, existe um delay para sincronizar os arquivos que estão no sistema operacional com a máquina virtual.

Isso pode ser um problema para aplicações que exigem constante leitura em disco, como é o caso de linguagens interpretadas, como o PHP. Além disso, mais especificamente com o Docker Desktop for Windows, é preciso ter o Hyper-V habilitado, que só é incluído com o Windows 10 Pro.

Então se você utiliza o Windows 10 Home ou trabalha com uma linguagem interpretada, sua experiência com o Docker no Windows pode não ser a melhor possível. Felizmente, isso vai mudar com o Docker com WSL 2.

Docker com WSL 2

O WSL 2 traz para o Windows o kernel completo do Linux através de uma máquina virtual moderna e com uma performance de disco próxima a uma máquina rodando Linux. Você pode ler mais sobre o WSL 2 nesse artigo aqui.

Com esse anúncio, o WSL 2 se tornou uma opção mais interessante para executar o Docker nos sistemas Windows. Além do ganho de performance, o WSL 2 será compatível com o Windows 10 Home, tornando o Docker Desktop disponível para um maior número de usuários.

O suporte do Docker Desktop utilizando o WSL 2 ainda está em preview, mas você já pode testá-lo se tiver executando o Windows 10 Insider. A previsão de lançamento do WSL 2 será no release 2003, e se espera que o suporte na versão estável do Docker chegue nessa época também.

O Docker Desktop irá incluir o suporte ao WSL 2 e utilizá-lo sempre que possível, mantendo o comportamento atual de usar uma máquina virtual no Hyper-V como um fallback para versões do Windows 10 que ainda não suportam WSL 2. Com isso, teremos todas as vantagens presentes no Docker Desktop, mas com uma melhor performance e suporte para o Windows 10 Home (o que hoje não é possível por requerer o Hyper-V).

Internamente, o Docker Desktop provisiona duas distribuições Linux na sua máquina, uma contendo o daemon do Docker e outra é utilizada para armazenar dados como os containers e as imagens que você utilizará. A comunicação entre essas distribuições acontece através de sockets, tanto entre o Windows como com a distribuição que você utiliza com o WSL 2 no seu dia-a-dia. Mais detalhes dessa implementação podem ser encontrados nesse post do blog de engenharia do Docker.

Arquitetura do Docker com WSL 2

Mas será que tudo isso vale a pena? Além do tempo de carregamento para iniciar o Docker Desktop, que reduziu para poucos segundos, a performance com o disco melhorou bastante. Podemos comparar esses números com o benchmark abaixo.

Teste de performance com disco

Para esse teste, vamos comparar a diferença entre o Docker Desktop utilizando Hyper-V e o WSL 2. Ambos os testes foram executados no mesmo ambiente, com a mesma máquina e quantidade de recursos disponíveis.

Para esse teste utilizei a aplicação de demonstração do Symfony junto com uma configuração de containers para Symfony mantida por um de seus core contributor. O código desses dois projetos juntos se encontra no GitHub da TreinaWeb também.

Depois de clonar o projeto e ter instalado o Docker, basta executar o comando docker-compose up para iniciar o projeto. O tempo a ser medido como comparação é para o primeiro carregamento da página inicial do projeto. Graças ao Symfony Profiler temos diretamente no navegador utilitários que auxiliam o desenvolvimento da nossa aplicação, incluindo o tempo de carregamento da mesma.

No primeiro teste, abri a página inicial do projeto utilizando o Docker Desktop com Hyper-V e essa página levou 2681ms para ser carregada:

Tempo de carregamento Docker Hyper-V

Com Docker Desktop usando WSL 2, a mesma página levou apenas 249ms!

Tempo de carregamento Docker WSL 2

Tudo isso considerando o primeiro carregamento do projeto. Foi preciso baixar todas as dependências do Composer, o container do PHP não tinha nenhum OpCache, o Symfony não chegou a fazer nenhum tipo de otimização, como compilar as views do Twig, ler as rotas da aplicação presentes nas anotations. Se considerarmos essas otimizações que farão efeito nas requests subsequentes, esse tempo cai para 20ms, comparado com um Linux rodando nativamente:

Tempo de carregamento Docker WSL 2 - carregamento subsequente

Como começar a utilizar

O Docker Desktop com WSL 2 está disponível na versão edge do Docker Desktop e pode ser baixada aqui. Por enquanto é preciso utilizar a versão insider do Windows 10 para habilitar o acesso ao WSL 2 caso você queira testar hoje mesmo.

Como vimos na comparação, o Docker Desktop com WSL 2 vai trazer um grande salto na performance para aplicações que usam muito processamento em disco. Para mim, que de vez em quando trabalho com projetos em PHP vai ser uma mão na roda! 😀

E para você? Pretende testar o Docker com WSL 2 no seu projeto? Conte pra gente o que você achou!

Symfony Componentes: o que são e qual sua importância para o ecossistema PHP

Recentemente apresentei uma palestra no PHP Community Summit falando sobre o Ecossistema Symfony. A principal motivação para o conteúdo dessa palestra e também deste post é a importância que o Symfony possui para o ecossistema macro do PHP como um todo. Muito desta relevância do Symfony vem dos seus componentes, então vamos falar um pouco sobre eles.

O que são os componentes Symfony

A maioria das pessoas quando ouve falar a palavra Symfony logo pensa em um framework PHP. Na verdade, o Symfony é bem mais que isso, veja a definição oficial do site do Symfony:

O Symfony é um conjunto de componentes, um framework, uma filosofia e uma comunidade.

Antes mesmo de falar que Symfony é um framework existe uma ênfase nos componentes, mas o que são esses componentes. Se formos olhar novamente na definição oficial, mas agora sobre os componentes, teremos:

Componentes são pacotes reutilizáveis e desacoplados com objetivos específicos e que podem ser utilizados em qualquer aplicação PHP.

Exatamente nesse ponto entra a importância do Symfony para o PHP. Os componentes não estão acoplados e funcionam exclusivamente dentro do Symfony Framework, é possível usar os componentes em qualquer aplicação PHP.

Symfony - Fundamentos
Curso de Symfony - Fundamentos
CONHEÇA O CURSO

Quem utiliza os componentes do Symfony?

A maioria dos grandes projetos escritos em PHP utilizam algum dos diversos componentes do Symfony. Veja uma lista abaixo dos principais:

  • Laravel Framework
  • Drupal
  • Magento
  • Joomla
  • Yii Framework
  • API Platform
  • SDK PHP do facebook
  • SDK PHP do Google
  • PHPStan
  • Behat
  • Composer

A lista é muito grande! Na página do Symfony é possível verificar os projetos e quais componentes cada um utiliza. Uma coisa é certa, basicamente qualquer projeto PHP que vamos trabalhar utiliza algum tipo de componente do Symfony.

Porque tanta gente utiliza os componentes do Symfony

Nesse ponto deve estar se perguntando o que esses componentes fazem de especial para serem utilizados em tantos projetos importantes na linguagem PHP e aqui entram dois pontos bem importantes.

O primeiro ponto que leva muitos projetos a utilizarem os componentes do Symfony é a confiabilidade. Os componentes são testados e utilizados em milhares de projetos, além de possuírem uma comunidade por trás que realiza manutenções de segurança e melhorias regularmente.

O segundo ponto é a produtividade, ao invés de reinventar a roda e correr o risco que ela não fique tão redonda quanto o necessário, o que acaba sendo menos produtivo e mais arriscado, porque não utilizar a roda que já está pronta e testada.

O que esses componentes fazem

O Symfony possui componentes para diversos tipos de ações. Existem componentes que ajudam na estruturação de uma aplicação, por exemplo a estruturação de um framework. Existem componentes que ajudam em tarefas comuns a maioria das aplicações, por exemplo enviar email. E também existem componentes que são Polyfill para extensões e versões do PHP, por exemplo, vamos supor que sua aplicação necessite do PHP 7.3, porém não pode instalar essa versão em seu servidor, nesse caso pode instalar um componente que entregará as funções da versão sem realmente possuir.

Alguns exemplos de componentes para estruturação de uma aplicação:

  • HTTP Kernel – Responsável por ajudar na estruturação desde o processo de request até o retorno da Response;
  • HTTP Foundation – Permite acesso a uma implementação orientada a objetos do protocolo HTTP;
  • Routing – Facilita o trabalho de roteamento da aplicação;
  • DependencyInjection – Implementa o container e recursos de injeção de dependência
  • Config – Facilita o acesso às configurações;
  • Dotenv – Permite o acesso às variáveis de ambiente;

Alguns componentes que realizam tarefas comuns a maioria das aplicações:

  • Mailer – Envio de email usando diversos serviços de forma extremamente simples;
  • HTTP Client – Permite realizar requisições HTTP a outras aplicações;
  • Form – Facilita a criação e a recuperação dos dados enviados via formulário;
  • Validation – Permite a validação de dados usando regras predefinidas ou através da criação de novas regras;
  • Security – Facilita o trabalho de autenticação e autorização na aplicação;
  • Cache – Facilita a utilização de cache com diversos meios de armazenamento;
  • DomCrawler – Possui mecanismos que permite navegar em documentos HTML e XML.

Temos também os componentes de polyfill:

  • Polyfill PHP 5.4 até 7.3
  • Polyfill XML
  • Polyfill Intl
  • Polyfill Mbstring
  • Polyfill Ctype

Sempre que for usar componentes de polyfill é necessário consultar a documentação para verificar quais funções o componente realmente implementa, pois nem todas podem estar disponíveis.

Porque não utilizar os componentes do Symfony

Nem tudo são rosas, como a maioria das coisas também existem pontos negativos ao usar componentes prontos.

Podemos citar primeiramente a falta de liberdade. Se sua aplicação necessita de uma nova função que não possui no componente. Caso queira implementar no componente oficial terá que convencer a equipe mantenedora que sua nova funcionalidade é importante para a maioria das pessoas que utilizam o componente, além de ter que seguir todas as regras para contribuir no projeto.

Outro ponto é a dependência do componente. A aplicação pode ficar dependente de um componente de tal forma que se ele for descontinuado ela esteja em risco. Por outro lado, isso pode ser contornado com a arquitetura correta da sua aplicação, se ao invés de depender diretamente do componente, depender de contratos, será possível trocar de componente com o mínimo de esforço.

Conclusão

O Symfony possui mais de 50 componentes para os mais diversos propósitos. Aconselho acessar a lista de componentes e ler o que cada um deles realiza. Desse modo sempre que tiver uma situação onde é necessário implementar uma nova funcionalidade na sua aplicação, poderá considerar um componente Symfony analisando as vantagens e desvantagens discutidas aqui.

Como criar recipes do Symfony Flex e enviar para o repositório

O Symfony Flex facilita a instalação de dependências na aplicação. Ele faz isso usando uma “receita” ou em inglês recipe que indica quais ações ele deve realizar no projeto. Essa receita fica armazenada dentro dos repositórios do Symfony Flex que pode ser o repositório oficial, da própria comunidade chamado repositório contrib ou repositórios privados.

Antes de iniciar a criação do recipe aconselho realizar a leitura do post Como criar repositórios privados do Symfony Flex, pois alguns conceitos são explicados nele.

Nesse post vamos aprender como criar recipes dos nossos próprios bundles, validar e enviar para o repositório, seja ele o repositório disponível para comunidade (contrib) ou um repositório privado, já que o processo basicamente é o mesmo.

Symfony - Fundamentos
Curso de Symfony - Fundamentos
CONHEÇA O CURSO

Ações possíveis

O Symfony Flex possui um conjunto de ações que podemos inserir na receita para que ele possa executar no projeto onde a dependência foi instalada:

  • bundles configurator – configura entradas no arquivo de bundles da aplicação
  • container configurator – configura entradas no container da aplicação
  • copy-from-package configurator – copia pastas e arquivos do repositório para a aplicação
  • copy-from-recipe configurator – copia pastas e arquivos do recipe para a aplicação
  • env configurator – Adiciona entradas no arquivo de configuração de ambiente .env
  • composer-scripts configurator – registra scripts no arquivo composer.json
  • gitignore configurator – Adiciona entradas no arquivo de configuração .gitignore
  • post-install-output configurator – Permite definir informações que serão exibidas no console ao final do processo de configuração do Flex

Essas ações são definidas dentro de um arquivo JSON que será lido pelo Flex.

Estrutura de pastas de um recipe

A primeira coisa que precisamos nos preocupar quando vamos criar um recipe é a estrutura de pastas. A leitura do recipe pelo Flex depende que ele possua um padrão de pastas envolvendo o nome do fornecedor, bundle e versão mínima. Essas informações são retiradas do packagist.org, veja o exemplo abaixo:

Se formos criar um recipe para o bundle acima precisamos definir a seguinte estrutura de pastas:

elton-fonseca/empty-symfony-bundle/1.0

No caso acima, estamos informando que esse recipe deve ser usado da versão 1.0.0 em diante do nosso bundle.

Criando o primeiro recipe

Vamos agora criar nosso primeiro recipe. Crie a seguinte estrutura de pastas dentro de um local qualquer do seu computador:

Agora precisamos criar um arquivo chamado manifest.json onde devemos colocar todas as ações que o Flex deve fazer.

Vamos testar algumas das ações possíveis quando estamos trabalhando com Flex. No arquivo criado anteriormente insira o seguinte conteúdo:

{
    "env": {
        "TREINAWEB": "cursos"
    },
    "copy-from-package": {
        "Treinaweb.php": "%SRC_DIR%/Treinaweb.php"
    },
    "copy-from-recipe": {
        "config/": "%CONFIG_DIR%/"
    },
    "aliases": ["treinaweb", "treinaweb-recipe"]
}

É importante deixar uma quebra de linha no final do arquivo, caso contrário o validador do Flex da erro na hora de enviar

Primeiro declaramos que o flex deve adicionar uma nova entrada no arquivo .env do projeto com chave TREINAWEB e valor cursos.

"env": {
    "TREINAWEB": "cursos"
},

Em seguida falamos para o flex copiar um arquivo que está dentro do bundle para a pasta SRC do projeto que está instalando a dependência:

"copy-from-package": {
    "Treinaweb.php": "%SRC_DIR%/Treinaweb.php"
},

Na última ação pedimos para ele copiar uma pasta chamada config do recipe para a pasta do projeto:

"copy-from-recipe": {
    "config/": "%CONFIG_DIR%/"
},

Crie dentro da mesma pasta onde está o arquivo manifest.json uma pasta chamada config com um arquivo de exemplo chamado treinaweb.yaml. Dentro do arquivo coloque apenas um comentário:

#arquivo de teste

É importante deixar uma quebra de linha no final do arquivo, caso contrário o validador do Flex da erro na hora de enviar

Conforme vimos anteriormente além das ações mostradas neste exemplo é possível realizar outras. Você pode consultar todas as ações possíveis no repositório oficial da equipe do Symfony.

Clonando o repositório na máquina local

Independente se enviará seu recipe para um repositório privado ou público, a primeira coisa que precisa fazer é clonar o repositório. Vamos usar como exemplo o repositório privado criado no post sobre esse assunto citado no início do artigo:

Para clonar o repositório vamos usar a linha de comandos. Se estiver usando Windows aconselho o Power Shell, se estiver usando Linux ou MacOS pode usar o terminal padrão sem problemas. Execute o comando para clonar:

git clone https://github.com/elton-fonseca/flex-private-repository.git

Entre na pasta flex-private-repository com o comando:

cd flex-private-repository

Agora precisamos criar uma nova branch no repositório que clonamos. Através dessa branch podemos criar um pedido para que nosso recipe seja validado e integrado ao repositório. Execute o comando:

git checkout -b new-recipe
Symfony - Gerenciando aplicações com Symfony Flex
Curso de Symfony - Gerenciando aplicações com Symfony Flex
CONHEÇA O CURSO

Enviando o recipe para o repositório

Agora dentro da pasta onde clonou o repositório faça a cópia da pasta do recipe que criamos, representada pelo nome do fornecedor do pacote.

Precisamos enviar essas alterações para o servidor do Github. Execute os comandos:

git add .

git commit -m "adicionar um novo recipe"

git push origin new-recipe

Precisamos dizer ao Github que desejamos que as alterações realizadas no branch novo sejam adicionadas ao branch principal. Ao acessar o repositório no Github automaticamente ele te dirá que enviou um branch se deseja unir a outro:

No nosso caso precisamos unir o novo branch ao master, clique no botão conforme abaixo para realizar esse pedido:

Uma vez que envia o pedido automaticamente, o robô do Symfony Flex faz a validação do conteúdo do seu recipe. Se tudo for aprovado basta clicar Merge Pull Request:

Ao voltar na página inicial do repositório verá que a pasta do recipe já está no branch master:

Testando o recipe

Acesse uma aplicação gerenciada pelo Symfony Flex com código de projeto inserido no repositório, caso seja um repositório privado, e execute o comando para instalação do nosso bundle:

composer install elton-fonseca/empty-symfony-bundle

Ao instalar o pacote no seu projeto automaticamente serão executadas as ações do recipe:

Ao verificar as diferenças no projeto depois da execução verá que as ações foram executadas corretamente:

  • Copiou o arquivo do recipe para a pasta de configuração
  • Copiou o arquivo do bundle para a pasta SRC
  • Adicionou um novo valor no arquivo de env

Isso indica que nosso recipe foi criado corretamente.

Como criar repositórios privados do Symfony Flex

O Symfony Flex possui 2 repositórios públicos onde ele busca os recipes. O primeiro é o repositório oficial onde ficam as recipes da própria equipe do Symfony. O segundo é o repositório contrib onde o pessoal da comunidade envia as recipes que são usadas para bundles públicos que não são oficiais.

Quando precisamos criar recipes para automatizar tarefas em bundles que serão usados apenas em projetos privados, os dois repositórios anteriores não são aplicáveis. Nesses casos podemos criar os nossos próprios repositórios privados para armazenar nossas recipes.

Symfony - Gerenciando aplicações com Symfony Flex
Curso de Symfony - Gerenciando aplicações com Symfony Flex
CONHEÇA O CURSO

Como criar o repositório privado

O repositório privado do Symfony Flex, na verdade, é um repositório comum Git hospedado no GitHub e integrado ao robô de verificação da equipe do Symfony. O repositório no GitHub pode ser público ou privado, em ambos os casos o recipe será reconhecido, porém já que estamos criando um repositório privado do Flex faz mais sentido o repositório do GitHub também ser privado.

No início de 2019 o GitHub passou a permitir a criação de repositórios privados ilimitados nas contas pessoais gratuitamente, mais informações https://github.blog/2019-01-07-new-year-new-github/

Vamos criar um novo repositório privado no GitHub. Uma vez logado acesse o endereço https://github.com/new e preencha as informações conforme abaixo:

Integrando o repositório do GitHub com o Flex

Agora precisamos indicar ao Symfony Flex que ele deve validar e ler os recipes que colocamos dentro do repositório que acabamos de criar. Isso é feito através de uma integração com o GitHub, acesse o endereço https://github.com/apps/symfony-flex-server/installations/new e selecione a conta que está o repositório que criamos no passo anterior:

Ele vai confirmar sua senha do GitHub e perguntar se você deseja adicionar todos os repositórios da sua conta como repositório do Flex ou apenas 1. Aconselho indicar somente os repositórios que realmente serão usados como repositórios do Symfony Flex:

Depois de clicar em instalar ele apresentará uma tela de congratulations, vamos falar dos passos explicados nessa tela mais adiante.

Desenvolvedor Symfony Full-Stack
Formação: Desenvolvedor Symfony Full-Stack
Nesta formação você aprenderá desenvolver aplicações PHP usando o framework Symfony com desenvoltura. Ao final desta formação, terá condições de trabalhar em grandes aplicações web ou APIs integradas com diversos serviços, tudo isso usando as melhores práticas do mercado.
CONHEÇA A FORMAÇÃO

Como liberar os projetos que podem acessar o repositório

Como nós temos um repositório privado é importante que apenas os projetos autorizados consigam utilizar nossos recipes. Para isso nós geramos um identificador único de cada projeto e configuramos dentro do nosso repositório.

Na aplicação Symfony que utiliza o Flex para gerenciamento, execute o comando abaixo:

composer symfony:generate-id

Esse comando não retorna nenhuma mensagem no console. Ele realiza a criação de um identificador do seu projeto dentro do arquivo composer.json na sessão extra.symfony.id:

"extra": {
    "symfony": {
        "allow-contrib": false,
        "require": "4.3.*",
        "id": "01DFEFJHVTGS3PAR3J1K2HB60T"
    }
}

Agora precisamos configurar esse id no repositório junto com todos outros projetos que terão acesso aos recipes. Esse conteúdo é definido dentro do arquivo config.json na raiz do projeto com o seguinte padrão:

{
  "projects": {
    "id1": "descriçao do projeto 1",
    "id2": "descriçao do projeto 2",
    "id3": "descriçao do projeto 3"
  }
}

Crie o arquivo na raiz do repositório:

Como enviar os recipes

Precisamos enviar os recipes que vamos usar em nossos projetos para o repositório. O processo para criação e envio do recipe é o mesmo usado para o repositório de contrib do Symfony.

Vamos ver como criar um recipe e como enviar para o repositório no próximo post.

O que é o Symfony Flex e como ele funciona

O Symfony é um dos frameworks mais utilizados na linguagem PHP. Ele possui grande importância no ecossistema, pois além da utilização direta do framework, diversas outras ferrramentas e até frameworks utilizam seus componentes como base de desenvolvimento. Mesmo com tanta relevância o Symfony não era tão falado na comunidade brasileira, porém com as novidades apresentadas nos últimos tempos ele voltou a ganhar bastante destaque. Inclusive, prova disso é o evento oficial da Symfony que aconteceu em São Paulo.

Desenvolvedor Symfony Full-Stack
Formação: Desenvolvedor Symfony Full-Stack
Nesta formação você aprenderá desenvolver aplicações PHP usando o framework Symfony com desenvoltura. Ao final desta formação, terá condições de trabalhar em grandes aplicações web ou APIs integradas com diversos serviços, tudo isso usando as melhores práticas do mercado.
CONHEÇA A FORMAÇÃO

Um dos recursos mais interessantes aprensentados pela equipe do Symfony é o Flex. Ele automatiza o processo de configuração das dependências no momento da instalação. Isso possibilita ao desenvolvedor começar o projeto com o mínimo possível de dependencias, algo parecido com um micro framework, e adicionar novas dependencias de forma muito fluida até chegar a uma estrutura parecida com um framework full stack.

O que é Symfony Flex

O Symfony Flex é um plugin para composer. Ele automatiza os principais processos na hora da criação do projeto e instalação das dependências. Pode ser usado a partir da versão 3.4 do Symfony e passou a ser usado por padrão a partir da versão 4. O Flex altera o comportamento padrão de alguns dos comandos do Composer para permitir a automatização das tarefas de gerenciamento do projeto.

Quando realizamos a instalação de um novo pacote do composer, o Symfony Flex verifica dentro de um repositório próprio se existe alguma automatização correspondente a essa dependência, se existir ele executa as ações definidas.

O que são Recipes

Recipe (receita) é o nome dado ao conjunto de arquivos responsável pela automatização do processo de instalação de uma dependência específica. As instruções são definidas dentro de um arquivo chamado manifest.json que fica dentro do repositório do Flex, veja um exemplo abaixo:

{
    "bundles": {
        "Symfony\Bundle\DebugBundle\DebugBundle": ["dev", "test"]
    },
    "copy-from-recipe": {
        "config/": "%CONFIG_DIR%/"
    }
}

O recipe acima está pedindo para adicionar um novo bundle no arquivo de configuração e copiar a pasta config de dentro do repositório do Symfony Flex para o projeto. Esse arquivo faz parte do recipe de debug https://github.com/symfony/recipes/blob/master/symfony/debug-bundle/4.1/manifest.json

Ao executar essas tarefas, o Flex evita que o desenvolvedor necessite executar manualmente, diminuindo a chance de erro e a complexidade de instalação de novos pacotes.

Symfony - Gerenciando aplicações com Symfony Flex
Curso de Symfony - Gerenciando aplicações com Symfony Flex
CONHEÇA O CURSO

Repositório de recipes

O Symfony Flex possui 2 repositórios de recipes. O primeiro é o repositório oficial onde somente projetos da equipe do Symfony são colocados:

O segundo é o repositório contrib onde qualquer pessoa pode submeter um recipe para automatizar as configurações do seu bundle.

Ainda é possível criar repositórios privados onde podemos colocar as recipes do Flex que serão usadas somente dentro dos nossos projetos.

Como o Flex cria a estrutura da aplicação Symfony na instalação

Symfony - Fundamentos
Curso de Symfony - Fundamentos
CONHEÇA O CURSO

Como instalar novas dependências no projeto

Uma vez que temos uma aplicação que utiliza o Flex podemos facilmente instalar novas dependências e se beneficiar das automatizações. O Symfony possui uma página onde podemos consultar todos os recipes tanto oficiais quanto do repositório de contrib https://flex.symfony.com, vamos procurar por twig:

Note que temos vários recipes relacionados ao twig. Vamos instalar o pacote symfony/twig-bundle.

composer require symfony/twig-bundle

Se tudo der certo o resultado final será parecido com esse:

Note que após instalar o pacote do composer no projeto ele executou o recipe. Ao fazer isso o Flex configurou todos os detalhes necessários para o Twig funcionar no seu projeto. Podemos ver isso na prática se olharmos no Git as alterações realizadas:

Apelidos para os pacotes do Flex

Alguns pacotes possuem Aliases (apelidos). Se notar o pacote que instalamos verá que ele possui alguns nomes definidos:

O principal objetivo do alias é facilitar na hora de instalação, podemos fazer simplesmente:

composer require twig

Ou

composer require template

Se estiver dentro de uma aplicação que não utiliza o Flex, o composer não vai encontrar esses pacotes, pois o padrão para identificação de pacotes do composer é nome-vendor/nome-pacote. Usar apelidos só é possível graças ao Symfony Flex e em pacotes que possuem Recipes.

Symfony -  Formulários e Validações
Curso de Symfony - Formulários e Validações
CONHEÇA O CURSO

Prefetch e download simultâneo

Quando usamos o Flex ele adiciona 2 funções muito interessantes ao composer:

  • Prefetch – Ele baixa todos os pacotes necessários antes de iniciar a instalação
  • Download Simultâneo – O composer por padrão baixa uma dependência por vez, com uso do Flex ele passar a realizar o download ao mesmo tempo de vários pacotes, tornando mais rápido o processo.

O interessante é que se instalarmos o Flex globalmente no sistema operacional esses 2 recursos passam a ser usados em qualquer projeto, mesmo que não utilize o Symfony. Para instalar o Flex global basta executar:

composer global require symfony/flex 

Conclusão

O Flex torna o gerenciamento das dependências de uma aplicação muito mais simples, rápido e seguro. Uma vez que remove a necessidade de configuração manual por parte do desenvolvedor. Além disso ele ainda conta com uma série de recursos avançados que facilitam o trabalho diário de manutenção de aplicações Symfony.

Principais comandos do Symfony CLI

Quando criamos uma aplicação Symfony automaticamente podemos executar uma série de comandos a partir do arquivo bin/console. Esses comandos são muito úteis no desenvolvimento do nosso projeto, porém ele está limitado ao contexto da aplicação. Baseado nessa dificuldade e outras limitações foi criado um programa de linha de comando que pode ser instalado globalmente na máquina. Ele facilita desde a criação do projeto até tarefas diárias no desenvolvimento.

O utilitário também conta com uma série de recursos para deploy e configuração de aplicações que utilizam o Symfony Cloud, um serviço de nuvem que apresenta uma série de facilidade para a hospedagem de aplicações que utilizam o framework.

Instalando o comando Symfony

A instalação é extremamente simples, independente do sistema operacional que está usando na sua máquina.

Windows: Basta baixar o instalador e executar com todas as opções padrão. Ele fará o download do utilitário e colocará o caminho na variável PATH, permitindo que execute o comando symfony a partir do prompt.

Linux: Ao executar no terminal wget https://get.symfony.com/cli/installer -O - | bash ele fará o download e a instalação. Em seguida precisamos tornar o comando global, para isso podemos mover o arquivo para a pasta de executáveis com o seguinte comando mv $HOME/.symfony/bin/symfony /usr/local/bin/symfony

MacOS: Executar no terminal curl -sS https://get.symfony.com/cli/installer | bash e em seguida mover o arquivo para a pasta de executáveis com o comando mv $HOME/.symfony/bin/symfony /usr/local/bin/symfony

Verificando a instalação

Depois de instalado podemos executar o comando symfony em qualquer terminal que ele exibirá os comandos disponíveis:

Caso queira explorar todos os comandos de forma detalhada execute Symfony --help. Conforme falamos anteriormente, o comando symfony possui uma série de ferramentas específicas para trabalhar com Symfony Cloud, porém no escopo desse artigo vamos explorar apenas os comandos voltados para aplicação local.

Criando o projeto

A primeira coisa que podemos fazer é criar a estrutura do nosso projeto através do comando symfony, ele possui uma sintaxe bem mais simples que a do composer. Para criar a aplicação com estrutura mínima usamos:

symfony new my_project

Se quisermos a aplicação com a estrutura completa web executamos:

symfony new --full my_project

Caso não saiba a diferença entre os 2 tipos de aplicação e a sintaxe de criação de projetos a partir do composer veja: Como criar projeto no Symfony e seu primeiro CRUD.

Symfony - Fundamentos
Curso de Symfony - Fundamentos
CONHEÇA O CURSO

Servidor de desenvolvimento

A recomendação do Symfony é utilizar o servidor disponível no utilitário de linha de comandos symfony para desenvolvimento. Esse servidor possui suporte a HTTP2, HTTPS, domínio local e outros.

Dentro da pasta da aplicação execute:

symfony server:start

Caso tenha várias versões do PHP na máquina ele pode apresentar um erro ao iniciar o servidor, dependendo das versões instaladas. Nesse caso você pode executar o comando symfony local:php:list ele mostrará qual versão está usando, se precisar mudar basta criar um arquivo chamado .php-version com a versão do PHP desejada.

Caso queira usar certificado local para HTTPS, precisa executar uma única vez o comando:

symfony server:ca:install

Comandos da aplicação

Podemos ainda rodar os comandos da aplicação diretamente pelo utilitário symfony, ao invés de executar o comando php bin/console conseguimos chamar symfony console.

Veja o exemplo abaixo:

symfony console make:form clientType

Esse comando realiza a criação de uma classe específica para trabalhar com componente de formulários. Poderia ser qualquer outro comando disponível no framework.

Verificação de segurança das dependências

Sempre que instalamos dependências em nosso projeto estamos sujeitos a adicionar código com algum tipo de vulnerabilidade. Existem algumas bases de dados que indicam quais dependências e versões dela possuem problemas de segurança. O symfony possui um comando para realizar essa verificação:

symfony security:check

Ele faz a leitura do composer.lock que guarda a versão de todos os itens instalados no seu projeto e te avisa caso algum deles possui falha conhecida.

Executando demais utilitários

O comando symfony ainda nos permite executar outros recursos através dele: composer, php, pecl, pear, php-fpm, php-cgi, php-config e phpdbg.

No caso do composer a principal vantagem é executar o gerenciador de dependências sem limite de memória. Por exemplo:

symfony composer require symfony/maker-bundle --dev

E para os comandos do php a principal vantagem é a execução já na versão do php usada no projeto, versão que pode ser indicada no arquivo .php-version na raiz do projeto.

Symfony - Fundamentos
Curso de Symfony - Fundamentos
CONHEÇA O CURSO

Conclusão

O comando symfony é uma ferramenta indispensável no ambiente de desenvolvimento. Ela contém um poderoso servidor de desenvolvimento, utilitários que ajudam no dia a dia, além de comandos específicos para trabalhar com Symfony Cloud.

Iniciando com Symfony: Como criar o projeto e seu primeiro CRUD

Caso nunca tenha tido contato com Symfony, antes de iniciar esse artigo aconselho a leitura: O que é o Symfony Framework, nele falamos sobre o padrão estrutural MVC, componentes, ciclo de atualização e suporte, além de outras características.

Uma das principais novidades que o Symfony trouxe a partir da versão 4 é o Flex, que vamos falar em nosso próximo artigo. Ele é um plugin para composer que faz a criação de toda a estrutura do nosso projeto, além facilitar a instalação de novos pacotes. A partir do seu uso é possível de forma muito simples começar com um pequeno projeto e ir “plugando” novos recursos quando necessário. O Flex permitiu ao Symfony unir as características de microframework e framework full stack em um único lugar.

Baseado nessa característica é possível escolher quando vamos criar o projeto entre duas opções. A primeira é a estrutura mínima, com poucas dependências, muito utilizada para APIs e pequenos projetos. A segunda estrutura chamada de website, é uma estrutura mais completa que contém a maioria das dependências necessárias para aplicações web clássicas.

Symfony - Fundamentos
Curso de Symfony - Fundamentos
CONHEÇA O CURSO

Criando o projeto com estrutura mínima

Quando vamos trabalhar com API, micro serviço ou uma aplicação muito pequena geralmente não precisamos de todos os recursos de uma aplicação web. Nesses casos ao invés de usar um microframework como Slim ou Lumen, podemos usar o Symfony com sua estrutura de base simplificada.

Para realizarmos a criação do projeto precisamos apenas do PHP e do composer instalados na máquina. Ao executarmos o comando abaixo ele fará a criação do projeto:

composer create-project symfony/skeleton nome-do-projeto

Ao abrir o projeto verá que ele possui uma estrutura bem enxuta. E poucas dependências declaradas no composer.json:

"require": {
    "php": "^7.1.3",
    "ext-ctype": "*",
    "ext-iconv": "*",
    "symfony/console": "4.3.*",
    "symfony/dotenv": "4.3.*",
    "symfony/flex": "^1.1",
    "symfony/framework-bundle": "4.3.*",
    "symfony/yaml": "4.3.*"
},

Podemos começar desenvolver nossa aplicação e instalar os pacotes conforme necessário.

Criando o projeto com estrutura website

Quando vamos criar uma aplicação web normalmente precisamos de uma série de recursos específicos, como por exemplo, template engine, forms, gerenciador de assets e outros. Nesse caso podemos usar o projeto que possui todos esses elementos já instalados e pré-configurado por padrão.

Basta executar o comando abaixo:

composer create-project symfony/website-skeleton nome-projeto2

Depois de criado faça uma comparação entre a estrutura dele e o primeiro. Além da própria estrutura, a quantidade de pacotes instalados também é bem maior:

"require": {
    "php": "^7.1.3",
    "ext-ctype": "*",
    "ext-iconv": "*",
    "sensio/framework-extra-bundle": "^5.1",
    "symfony/asset": "4.3.*",
    "symfony/console": "4.3.*",
    "symfony/dotenv": "4.3.*",
    "symfony/expression-language": "4.3.*",
    "symfony/flex": "^1.1",
    "symfony/form": "4.3.*",
    "symfony/framework-bundle": "4.3.*",
    "symfony/http-client": "4.3.*",
    "symfony/intl": "4.3.*",
    "symfony/monolog-bundle": "^3.1",
    "symfony/orm-pack": "*",
    "symfony/process": "4.3.*",
    "symfony/security-bundle": "4.3.*",
    "symfony/serializer-pack": "*",
    "symfony/swiftmailer-bundle": "^3.1",
    "symfony/translation": "4.3.*",
    "symfony/twig-bundle": "4.3.*",
    "symfony/validator": "4.3.*",
    "symfony/web-link": "4.3.*",
    "symfony/yaml": "4.3.*"
},
"require-dev": {
    "symfony/debug-pack": "*",
    "symfony/maker-bundle": "^1.0",
    "symfony/profiler-pack": "*",
    "symfony/test-pack": "*",
    "symfony/web-server-bundle": "4.3.*"
},

Rodando o projeto

Depois de terminar a criação do projeto podemos testar, basta iniciar o servidor embutido do PHP dentro da pasta public:

php -S 127.0.0.1:8080

Já é possível ver a página de boas-vindas do Symphony no endereço http://127.0.0.1:8080

O mais aconselhável é usar o servidor de desenvolvimento através do comando symfony, porém como estamos apenas trabalhando em uma aplicação de exemplo vamos manter assim.

Criando um CRUD de forma prática

O Symfony conta com uma aplicação console que nos ajuda executar as tarefas de desenvolvimento de forma fácil e segura. A partir dela podemos gerar uma série de arquivos na nossa aplicação e até mesmo cadastros completos. No vídeo abaixo, veja como é possível criar um CRUD com as 4 operações básicas do banco de dados usando apenas comandos. Essa ferramenta é muito útil para quem está começando a aprender o Symfony, mas também para automatizar a tarefa em sistemas que possuem muitos cadastros.

O que é Symfony?

Software livre sobre a licença MIT, o Symfony é um Framework web escrito em PHP, lançado em 2005.

Sua comunidade conta com mais de 600.000 desenvolvedores de mais de 120 países, tornando a implementação de novas funcionalidades ao Framework um processo rápido.

É um Framework amplamente conhecido por ter sido um dos primeiros a trabalhar com componentes, possibilitando o reuso do seu código em diversos projetos open sources. Os principais pontos em sua filosofia são:

  • A utilização de melhores práticas de desenvolvimento;
  • A criação de aplicações profissionais, e;
  • A interoperabilidade de aplicações.
Symfony - Fundamentos
Curso de Symfony - Fundamentos
CONHEÇA O CURSO

Padrão MVC

Utiliza o padrão de projeto MVC, que é basicamente:

  • Model: Parte lógica da aplicação que gerencia o comportamento dos dados. A camada de model apenas tem o necessário para que tudo aconteça, mas não sabe quando irá executar.

  • View: Gerencia a saída gráfica e textual da aplicação ao usuário final, não possuindo a responsabilidade de saber quando vai exibir os dados, apenas como irá exibi-los.

  • Controller: Essa é a camada que sabe quem chamar e quando chamar para executar determinada ação, comandando a visão e o modelo para se alterarem de forma apropriada.

Basicamente, o MVC funciona da seguinte forma:

Ao receber uma requisição, o Controller solicita ao Model as informações necessárias (que provavelmente virão do banco de dados), que as obtém e retorna ao Controller. De posse dessas informações, o Controller as envia para a View que irá renderizá-las.

Vantagens do Symfony

  • Orientado a objetos;
  • Possui ferramentas de depuração;
  • Suporte para ambientes de implantação;
  • Recursos avançados de segurança;
  • Documentação completa e bem explicada;
  • ORM: Fácil integração com Doctrine;
  • Integração com PHPUnit;
  • Versões mantidas por um longo período.

Componentes

Os componentes são um conjunto de bibliotecas PHP desacopladas e reutilizáveis, permitindo que sejam utilizadas em qualquer projeto PHP independentemente do Symfony Framework.

Dentre os vários componentes do Symfony, podemos citar:

  • DependencyInjection – Permite padronizar e centralizar a maneira como os objetos são construídos em sua aplicação;
  • Debug – Fornece ferramentas para facilitar a depuração de código PHP;
  • Form – Fornece ferramentas para facilitar a criação, processamento e reutilização de formulários HTML;
  • Mailer – Ajuda a implementar o envio de e-mails e fornece integração com os principais serviços.

Muitos outros componentes podem ser utilizados para te auxiliar na realização de suas aplicações. A lista de todos os componentes do Symfony você pode acessar neste link.

Os componentes do Symfony são usados nos principais projetos PHP. Alguns projetos importantes que fazem o uso são:

  • Laravel Framework
  • Yii Framework
  • Drupal
  • Joomla
  • Magento

É possível ver a lista completa de projetos que usam componentes do Symfony aqui.

Framework ou Micro-Framework?

A partir da versão 4 o Symfony possui uma ferramenta chamada Flex. Ela realiza a instalação e configuração de pacotes de uma maneira extremamente simples e automática. Isso permite ao desenvolvedor iniciar um projeto com o mínimo de dependências e “plugar” novas funcionalidades quando necessário. Baseado nesse recurso quando vamos instalar o Symfony podemos escolher entre uma aplicação mínima com características de micro-framework ou uma aplicação completa, com características de framework.

Quando usamos a estrutura completa do Symfony temos as principais características de um framework:

  • Completo;
  • Integrado;
  • Padronizado;
  • Fácil de deployar.

Quando usamos a estrutura mínima, podemos citar as seguintes características:

  • Leve;
  • Altamente customizável;
  • “Rápido”;
  • Ideal para cenários com micro-serviços.

Ou seja, desta forma, o Symfony traz o melhor dos dois mundos onde atenderá desde aplicações menores a aplicações mais robustas.

Caso ainda não tenha ficado claro a diferença entre Framework e Micro-Framework, temos aqui no blog dois artigos bem legais sobre o assunto. Basta clicar sobre os links. 🙂

Atualizações e Suporte

O Symfony possui cronogramas muito bem definido de manutenção de correções e suporte para cada uma das versões lançadas. Isso garante uma segurança maior, principalmente para projetos corporativos.

As versões comuns contam com 6 meses de suporte a correções e 1 ano de suporte de segurança, enquanto as versões LTS (long term support) 3 anos de suporte para correção e 4 anos de suporte para segurança, sendo a segunda a versão mais indicada para uso em produção.

A cada 6 meses uma nova versão minor é lançada, conforme o cronograma acima. Atualmente estamos na versão 4.3, a versão LTS atual é a 3.4 e a próxima versão LTS é a 4.4 que será lançada em novembro.

Concluindo

O Symfony é um ótimo framework para a criação de aplicações, independente do seu tamanho. Neste artigo vimos algumas de suas principais características.