Como Instalar e Utilizar o Composer no Ubuntu 20.04

Introdução

O Composer é uma ferramenta popular de gerenciamento de dependências para o PHP, criado principalmente para facilitar a instalação e a atualização das dependências do projeto. Ele verificará de quais outros pacotes um projeto específico depende e os instalará para você, usando as versões apropriadas de acordo com os requisitos do projeto. O Composer também é comumente utilizado para inicializar novos projetos baseados em frameworks PHP populares, como o Symfony e o Laravel.

Neste tutorial, você instalará e começará a utilizar o Composer em um sistema Ubuntu 20.04.

Pré-requisitos

Para seguir este guia, você precisará de acesso a um servidor Ubuntu 20.04 como um usuário sudo não-root e um firewall habilitado em seu servidor. Para configurar isto, siga nosso guia Configuração do servidor inicial para o Ubuntu 20.04

Passo 1 — Instalando o PHP e as Dependências Adicionais

Além das dependências que já devem estar incluídas em seu sistema Ubuntu 20.04, como o git e o curl, o Composer exige o php-cli para executar scripts PHP na linha de comando e o unzip para extrair arquivos zipados. Vamos instalar essas dependências agora.

Primeiro, atualize o cache do gerenciador de pacotes executando:

sudo apt update

Em seguida, execute o seguinte comando para instalar os pacotes necessários:

sudo apt install php-cli unzip

Você será solicitado a confirmar a instalação digitando Y e, depois, ENTER.

Assim que os pré-requisitos estiverem instalados, você pode seguir para a instalação do Composer.

Passo 2 — Baixando e Instalando o Composer

O Composer fornece um script installer escrito em PHP. Vamos baixá-lo, verificar se ele não está corrompido e, em seguida, o usaremos para instalar o Composer.

Certifique-se de estar em seu diretório home. Em seguida, baixe o instalador usando o curl:

cd ~
curl -sS https://getcomposer.org/installer -o composer-setup.php

Em seguida, vamos verificar se o instalador baixado corresponde ao hash SHA-384 para o instalador mais recente encontrado na página Composer Public Keys / Signatures. Para facilitar o passo de verificação, você pode utilizar o seguinte comando para obter programaticamente o hash mais recente da página do Composer e armazená-lo em uma variável de shell:

HASH=`curl -sS https://composer.github.io/installer.sig`

Se você quiser verificar o valor obtido, execute:

echo $HASH

Output
e0012edf3e80b6978849f5eff0d4b4e4c79ff1609dd1e613307e16318854d24ae64f26d17af3ef0bf7cfb710ca74755a

Agora, execute o código PHP a seguir, conforme fornecido na página de download do Composer, para verificar se o script de instalação está seguro para ser executado:

php -r "if (hash_file('SHA384', 'composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

Você verá o seguinte resultado:

Installer verified

Se a saída diz Installer corrupt,você precisará baixar o script de instalação novamente e verificar se você está usando o hash correto. Em seguida, repita o processo de verificação. Quando você tiver um instalador verificado, você pode continuar.

Para instalar o composer globalmente, use o seguinte comando que baixará e instalará o Composer como um comando disponível em todo o sistema chamado composer, sob /usr/local/bin:

sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

Você verá um resultado parecido com este:

Output
All settings correct for using Composer
Downloading...

Composer (version 1.10.5) successfully installed to: /usr/local/bin/composer
Use it: php /usr/local/bin/composer

Para testar a sua instalação, execute:

composer

Output
   ______
  / ____/___  ____ ___  ____  ____  ________  _____
 / /   / __ \/ __ `__ \/ __ \/ __ \/ ___/ _ \/ ___/
/ /___/ /_/ / / / / / / /_/ / /_/ (__  )  __/ /
\____/\____/_/ /_/ /_/ .___/\____/____/\___/_/
                    /_/
Composer version 1.10.5 2020-04-10 11:44:22

Usage:
  command [options] [arguments]

Options:
  -h, --help                     Display this help message
  -q, --quiet                    Do not output any message
  -V, --version                  Display this application version
      --ansi                     Force ANSI output
      --no-ansi                  Disable ANSI output
  -n, --no-interaction           Do not ask any interactive question
      --profile                  Display timing and memory usage information
      --no-plugins               Whether to disable plugins.
  -d, --working-dir=WORKING-DIR  If specified, use the given directory as working directory.
      --no-cache                 Prevent use of the cache
  -v|vv|vvv, --verbose           Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug
...

Isso verifica que o Composer foi instalado com sucesso em seu sistema e está disponível em todo o sistema.

Agora vamos dar uma olhada em como utilizar o Composer para gerenciar as dependências.

Passo 3 — Usando o Composer em um Projeto PHP

Os projetos PHP geralmente dependem de bibliotecas externas, e o gerenciamento dessas dependências e suas versões pode ser complicado. O Composer resolve esse problema mantendo o controle de versões e dependências do projeto, enquanto também facilita o processo de descoberta, instalação e atualização de pacotes que são necessários por um projeto.

Para utilizar o Composer em seu projeto, você precisará de um arquivo composer.json. O arquivo composer.json informa ao Composer quais dependências ele precisa baixar para seu projeto e quais versões de cada pacote tem permissão para serem instaladas. Isso é muito importante para manter seu projeto consistente e evitar instalar versões instáveis que podem causar problemas de compatibilidade retroativa.

Você não precisa criar este arquivo manualmente - é comum ocorrerem erros de sintaxe quando fizer isso. O Composer oferece uma maneira interativa de criar um novo arquivo composer.json com base na entrada do usuário, o que é uma boa escolha se você planeja compartilhar seu projeto mais tarde como um pacote público no Packagist. O Composer também gera automaticamente um arquivo básico composer.json quando você executa um comando composer require para incluir uma dependência em um projeto recém-criado.

O processo de utilizar o Composer para instalar um pacote como uma dependência em um projeto envolve os passos a seguir:

• Identifique o tipo de biblioteca que o aplicativo precisa.
• Pesquise uma biblioteca de código aberto adequada no Packagist.org, o repositório oficial de pacotes para o Composer.
• Escolha o pacote de dependência.
• Execute composer require para incluir a dependência no arquivo composer.json e instalar o pacote.

Vamos testar isso com uma aplicação de demonstração.

O objetivo desta aplicação é transformar uma determinada sentença em uma string de URL amigável - um slug. Isso é comumente usado para converter os títulos de página para caminhos de URL (Assim como a parte final da URL para este tutorial).

Vamos começar criando um diretório para o nosso projeto. Vamos chamá-lo de slugify:

cd ~
mkdir slugify
cd slugify

Embora não seja necessário, você pode executar agora um comando composer init para criar um arquivo composer.json detalhado para seu projeto. Como o único objetivo do nosso projeto é demonstrar como instalar dependências com o Composer, usaremos um arquivo composer.json mais simples que será gerado automaticamente quando exigirmos nosso primeiro pacote.

Agora é hora de procurar no Packagist.org por um pacote que pode nos ajudar a gerar slugs. Se você procurar pelo termo “slug” no Packagist, receberá um resultado parecido com este:

Você verá dois números no lado direito de cada pacote na lista. O número no topo representa quantas vezes o pacote foi instalado através do Composer, e o número em baixo mostra quantas vezes um pacote foi estrelado no GitHub. De um modo geral, os pacotes com mais instalações e mais estrelas tendem a ser mais estáveis, pois mais pessoas os utilizam. Também é importante verificar a descrição do pacote para relevância para garantir que ele é o que você precisa.

Precisamos de um conversor string-to-slug A partir dos resultados da pesquisa, o pacote cocur/slugify, que aparece como o primeiro resultado naquela página, parece ser um bom candidato, com uma quantidade razoável de instalações e estrelas.

Os pacotes no Packagist têm um nome de vendor e um nome de package. Cada pacote tem um identificador único (um namespace) no mesmo formato que o GitHub utiliza para seus repositórios: vendor/package. A biblioteca que queremos instalar utiliza o namespace cocur/slugify. Você precisa de um namespace do pacote para exigi-lo em seu projeto.

Agora que você sabe exatamente qual pacote deseja instalar, você pode executar o composer require para incluí-lo como uma dependência e gerar também o arquivo composer.json para seu projeto. Uma coisa importante é observar a exigência de pacotes. O Composer rastreia as dependências no nível da aplicação e do sistema. As dependências no nível do sistema são importantes para indicar de quais módulos PHP um pacote depende. No caso do pacote cocur/slugify, ele exige um módulo PHP que ainda não instalamos.

Quando um pacote necessário depende de uma biblioteca de sistema que não está atualmente instalada em seu servidor, você receberá um erro informando qual requisito está faltando:

composer require cocur/slugify

Output
Using version ^4.0 for cocur/slugify
./composer.json has been updated
Loading composer repositories with package information
Updating dependencies (including require-dev)
Your requirements could not be resolved to an installable set of packages.

  Problem 1
    - Installation request for cocur/slugify ^4.0 -> satisfiable by cocur/slugify[v4.0.0].
    - cocur/slugify v4.0.0 requires ext-mbstring * -> the requested PHP extension mbstring is missing from your system.
...

Para resolver o problema de dependência do sistema, podemos procurar pelo pacote que falta usando o apt search:

apt search mbstring

Output
Sorting... Done
Full Text Search... Done
php-mbstring/focal 2:7.4+75 all
  MBSTRING module for PHP [default]

php-patchwork-utf8/focal 1.3.1-1 all
  UTF-8 strings handling for PHP

php7.4-mbstring/focal 7.4.3-4ubuntu1 amd64
  MBSTRING module for PHP

Após localizar o nome do pacote correto, você pode utilizar o apt novamente para instalar a dependência de sistema:

sudo apt install php-mbstring

Assim que a instalação terminar, você pode executar novamente o comando composer require:

composer require cocur/slugify

Output
Using version ^4.0 for cocur/slugify
./composer.json has been created
Loading composer repositories with package information
Updating dependencies (including require-dev)
Package operations: 1 install, 0 updates, 0 removals
  - Installing cocur/slugify (v4.0.0): Downloading (100%)         
Writing lock file
Generating autoload files

Como você pode ver na saída, o Composer decidiu automaticamente qual versão do pacote utilizar. Se você verificar o diretório do seu projeto agora, ele irá conter dois arquivos novos: composer.json e composer.lock, e um diretório vendor:

ls -l

Output
total 12
-rw-rw-r-- 1 sammy sammy   59 May  4 13:56 composer.json
-rw-rw-r-- 1 sammy sammy 3229 May  4 13:56 composer.lock
drwxrwxr-x 4 sammy sammy 4096 May  4 13:56 vendor

O arquivo composer.lock é usado para armazenar informações sobre quais versões de cada pacote estão instaladas, e garantir que as mesmas versões sejam usadas se outra pessoa clonar seu projeto e instalar suas dependências. O diretório vendor é onde as dependências do projeto estão localizadas. Você não deve fazer commit da pasta vendor no controle de versão - você precisa apenas incluir os arquivos composer.json e composer.lock.

Vamos dar uma olhada rápida em restrições de versão. Se você verificar o conteúdo do seu arquivo composer.json, verá algo parecido com isto:

cat composer.json

Output
{
    "require": {
        "cocur/slugify": "^4.0"
    }
}

Note que há o caractere especial ^ antes do número da versão no composer.json. O Composer suporta várias restrições diferentes e formatos para definir a versão necessária do pacote, para fornecer flexibilidade enquanto também mantém seu projeto estável. O operador circunflexo (^) utilizado pelo arquivo composer.json criado automaticamente é o operador recomendado para a interoperabilidade máxima, seguindo o versionamento semântico. Neste caso, ele define 4.0 como a versão mínima compatível e permite atualizações para qualquer versão futura abaixo de 5.0.

De um modo geral, você não precisará alterar as restrições de versão em seu arquivo composer.json. No entanto, algumas situações podem exigir que você edite manualmente as restrições – por exemplo, quando uma nova versão principal da sua biblioteca requerida é liberada e você deseja atualizar, ou quando a biblioteca que você deseja usar não segue o versionamento semântico.

Aqui estão alguns exemplos para lhe dar um melhor entendimento sobre como as restrições de versão do Composer funcionam:

Para uma visualização mais detalhada das restrições de versão do Composer, consulte a documentação oficial.

A seguir, vamos ver como carregar dependências automaticamente com o Composer.

Passo 4 — Incluindo o Script Autoload

Como o PHP por si só não carrega classes automaticamente, o Composer fornece um script autoload que você pode incluir em seu projeto para obter o carregamento automático para ele. Este arquivo é gerado automaticamente pelo Composer quando você adiciona sua primeira dependência.

A única coisa que você precisa fazer é incluir o arquivo vendor/autoload.php em seus scripts PHP antes de qualquer instância de classe.

Vamos testar isso em nossa aplicação de demonstração. Abra um novo arquivo chamado test.php em seu editor de texto:

nano test.php

Adicione o código a seguir que vem no arquivo vendor/autoload.php, carrega a dependência cocur/slugify, e o utiliza para criar um slug:

<?php
require __DIR__ . '/vendor/autoload.php';

use Cocur\Slugify\Slugify;

$slugify = new Slugify();

echo $slugify->slugify('Hello World, this is a long sentence and I need to make a slug from it!');

Salve o arquivo e saia do seu editor.

Agora, execute o script.

php test.php

Isso produz a saída hello-world-this-is-a-long-sentence-and-i-need-to-make-a-slug-from-it.

As dependências precisam de atualizações quando novas versões são liberadas. Dessa forma, vamos ver como lidar com isso.

Passo 5 — Atualizando as Dependências do Projeto

Sempre que você quiser atualizar suas dependências do projeto para versões mais recentes, execute o comando update:

composer update

Isso irá verificar por versões mais recentes das bibliotecas que você requer em seu projeto. Se uma versão mais recente for encontrada e ela for compatível com a restrição de versão definida no arquivo composer.json, o Composer substituirá a versão anterior instalada. O arquivo composer.lock será atualizado para refletir essas alterações.

Você também pode atualizar uma ou mais bibliotecas específicas, especificando-as desta forma:

composer update vendor/package vendor2/package2

Certifique-se de verificar em seus arquivos composer.json e composer.lock dentro do seu sistema de controle de versão após atualizar suas dependências de modo que outros também possam instalar essas versões mais recentes.

Conclusão

O Composer é uma ferramenta poderosa que facilita o trabalho de gerenciar as dependências em projetos PHP. Ele fornece uma maneira confiável de descobrir, instalar e atualizar pacotes PHP dos quais um projeto depende. Neste guia, vimos como instalar o Composer, como incluir novas dependências em um projeto, e como atualizar essas dependências assim que as novas versões estiverem disponíveis.