Como Instalar e Usar o Composer no Ubuntu

Introdução

O Composer é uma ferramenta popular de gerenciamento de dependências para PHP, criada principalmente para facilitar a instalação e a atualização das dependências de um projeto. Ele verifica quais outros pacotes um projeto específico necessita e os instala para você, utilizando as versões apropriadas de acordo com os requisitos do projeto. O Composer também é comumente usado para iniciar novos projetos baseados em frameworks PHP populares, como Symfony e Laravel. Se você planeja trabalhar com Laravel, talvez também queira conferir nosso guia sobre Como Instalar e Configurar o Laravel com Docker Compose no Ubuntu 20.04.

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

Principais Conclusões

• O Composer automatiza o gerenciamento de dependências PHP ao lidar com a instalação de bibliotecas, controle de versão e atualizações, eliminando tarefas manuais de gerenciamento de pacotes.
• A instalação global fornece acesso aos comandos do Composer em todo o sistema a partir de qualquer diretório, enquanto a instalação local oferece controle específico do projeto e isolamento de versões.
• A verificação de hash é essencial para a segurança ao baixar o instalador do Composer, protegendo contra scripts de instalação adulterados ou corrompidos.
• O arquivo composer.lock garante consistência ao bloquear versões exatas de dependências nos ambientes de desenvolvimento, teste e produção.
• Composer é o padrão para o desenvolvimento moderno em PHP, com integração perfeita em frameworks como Laravel e Symfony, e suporte de mais de 400.000 pacotes no Packagist.

Pré-requisitos

Para seguir este guia, você precisará de acesso a um servidor Ubuntu (20.04 LTS, 22.04 LTS ou 24.04 LTS) como um usuário sudo não root, e um firewall ativado no seu servidor. Para configurar isso, você pode seguir nosso guia de configuração inicial de servidor para Ubuntu ou o guia correspondente para sua versão do Ubuntu.

Se você está procurando uma referência rápida, consulte nosso guia rápido Como Instalar o Composer no Ubuntu. Para tutoriais e recursos adicionais sobre o Composer, confira nossa coleção de tutoriais do Composer.

Passo 1 — Instalando PHP e Dependências Adicionais

Além das dependências que já devem estar incluídas no seu sistema Ubuntu, como git e curl, o Composer requer o php-cli para executar scripts PHP na linha de comando e o unzip para extrair arquivos compactados. O pacote php-cli instalará a versão padrão do PHP para a sua versão do Ubuntu (PHP 7.4 no Ubuntu 20.04, PHP 8.1 no Ubuntu 22.04 ou PHP 8.3 no Ubuntu 24.04). Se você precisar configurar seu servidor Ubuntu primeiro, consulte nosso guia de configuração inicial do servidor para Ubuntu. 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, em seguida, ENTER.

Uma vez que os pré-requisitos estejam instalados, você pode prosseguir com a instalação do Composer.

Passo 2 — Baixando e Instalando o Composer

O Composer fornece um script de instalação escrito em PHP. Vamos baixá-lo, verificar se não está corrompido e então usá-lo para instalar o Composer.

Certifique-se de que você está no seu diretório home e então recupere o instalador usando curl:

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

Em seguida, verificaremos se o instalador baixado corresponde ao hash SHA-384 do instalador mais recente encontrado na página de Chaves Públicas/Assinaturas do Composer. Para facilitar a etapa de verificação, você pode usar 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, pode executar:

echo $HASH

e0012edf3e80b6978849f5eff0d4b4e4c79ff1609dd1e613307e16318854d24ae64f26d17af3ef0bf7cfb710ca74755a

Agora execute o seguinte código PHP, conforme fornecido na página de download do Composer, para verificar se o script de instalação é seguro de executar:

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

Você verá a seguinte saída:

Installer verified

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

Para instalar o composer globalmente, use o seguinte comando que irá baixar e instalar o Composer como um comando de sistema chamado composer, em /usr/local/bin:

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

Você verá uma saída semelhante a esta:

All settings correct for using Composer
Downloading...

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

Para testar sua instalação, execute:

composer

   ______
  / ____/___  ____ ___  ____  ____  ________  _____
 / /   / __ \/ __ `__ \/ __ \/ __ \/ ___/ _ \/ ___/
/ /___/ /_/ / / / / / / /_/ / /_/ (__  )  __/ /
\____/\____/_/ /_/ /_/ .___/\____/____/\___/_/
                    /_/
Composer version Composer version 2.2.9 2022-03-15 22:13:37
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 no seu sistema e está disponível em todo o sistema.

Agora vamos ver como usar o Composer para gerenciar dependências.

Passo 3 — Usando o Composer em um Projeto PHP

Projetos PHP muitas vezes dependem de bibliotecas externas, e gerenciar essas dependências e suas versões pode ser complicado. O Composer resolve esse problema ao acompanhar as versões e dependências do projeto, além de facilitar o processo de encontrar, instalar e atualizar pacotes necessários para um projeto.

Para usar 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 o seu projeto e quais versões de cada pacote podem ser instaladas. Isso é extremamente importante para manter seu projeto consistente e evitar a instalação de versões instáveis que poderiam potencialmente causar problemas de compatibilidade retroativa.

Você não precisa criar este arquivo manualmente - é comum encontrar erros de sintaxe ao fazê-lo. O Composer oferece uma forma interativa de criar um novo arquivo composer.json com base nas entradas 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 composer.json básico quando você executa o comando composer require para incluir uma dependência em um projeto recém-criado.

O processo de usar o Composer para instalar um pacote como dependência em um projeto envolve os seguintes passos:

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

Vamos testar isso com um aplicativo de demonstração.

O objetivo deste aplicativo é transformar uma frase dada em uma string amigável para URL - um slug. Isso é comumente usado para converter títulos de páginas em caminhos de URL (como a parte final do URL deste 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 obrigatório, você poderia agora executar o comando composer init para criar um arquivo composer.json detalhado para o 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 um pacote que possa nos ajudar a gerar slugs. Se você procurar pelo termo “slug” no Packagist, você encontrará um resultado semelhante a 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 via Composer, e o número embaixo mostra quantas vezes um pacote recebeu estrela no GitHub. De modo geral, pacotes com mais instalações e mais estrelas tendem a ser mais estáveis, já que muitas pessoas os estão usando. Também é importante verificar a descrição do pacote para garantir que ele é relevante e atende às suas necessidades.

Precisamos de um conversor de string-para-slug. Pelos resultados de busca, o pacote cocur/slugify, que aparece como o primeiro resultado naquela página, parece ser uma boa opção, com uma quantidade razoável de instalações e estrelas.

Pacotes no Packagist têm um nome de fornecedor e um nome de pacote. Cada pacote possui um identificador único (um namespace) no mesmo formato que o GitHub usa para seus repositórios: fornecedor/pacote. A biblioteca que queremos instalar usa o namespace cocur/slugify. Você precisa do namespace de um pacote para adicioná-lo ao seu projeto.

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

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

composer require cocur/slugify

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 está faltando usando apt search:

apt search mbstring

Sorting... Done
Full Text Search... Done
php-mbstring/jammy 2:8.1+92ubuntu1 all
  MBSTRING module for PHP [default]

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

php8.1-mbstring/jammy 8.1.2-1ubuntu2.14 amd64
  MBSTRING module for PHP

Depois de localizar o nome correto do pacote, você pode usar o apt mais uma vez para instalar a dependência do sistema:

sudo apt install php-mbstring

Uma vez que a instalação esteja concluída, você pode executar novamente o comando composer require:

composer require cocur/slugify

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 no resultado, o Composer decidiu automaticamente qual versão do pacote usar. Se você verificar o diretório do seu projeto agora, ele conterá dois novos arquivos: composer.json e composer.lock, e um diretório vendor:

ls -l

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 alguém clonar seu projeto e instalar suas dependências. Este arquivo bloqueia as versões exatas de todas as dependências e suas subdependências, proporcionando consistência em diferentes ambientes e membros da equipe. O diretório vendor é onde estão localizadas as dependências do projeto. A pasta vendor não deve ser incluída no controle de versão – você só precisa incluir os arquivos composer.json e composer.lock. Quando outros clonarem seu projeto, eles podem executar composer install para recriar exatamente a árvore de dependências com base no arquivo de lock.

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

cat composer.json

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

Você pode notar o caractere especial ^ antes do número da versão em composer.json. O Composer suporta várias restrições e formatos diferentes para definir a versão necessária de um pacote, a fim de fornecer flexibilidade, mantendo seu projeto estável. O operador caret (^) usado pelo arquivo composer.json gerado automaticamente é o operador recomendado para máxima interoperabilidade, 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 modo geral, você não precisará mexer nas restrições de versão no 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 biblioteca que você precisa é lançada e você deseja atualizar, ou quando a biblioteca que você quer usar não segue versionamento semântico.

Aqui estão alguns exemplos para te dar uma melhor compreensão de como funcionam as restrições de versão do Composer:

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

Em seguida, vamos ver como carregar dependências automaticamente com o Composer.

Passo 4 — Incluindo o Script de Autocarregamento

Como o próprio PHP não carrega classes automaticamente, o Composer fornece um script de autoload que você pode incluir em seu projeto para fazer o autoload funcionar. Esse 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 nos seus scripts PHP antes de qualquer instanciação de classe.

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

nano test.php

Adicione o seguinte código que inclui o arquivo vendor/autoload.php, carrega a dependência cocur/slugify e a 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 lançadas, então vamos ver como lidar com isso.

Etapa 5 — Atualizando as Dependências do Projeto

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

composer update

Isso verificará se há versões mais recentes das bibliotecas que você requisitou em seu projeto. Se uma versão mais nova for encontrada e 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 mudanças.

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

composer update vendor/package vendor2/package2

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

Perguntas Frequentes

1. Para que o Composer é usado no PHP?

O Composer é um gerenciador de dependências para PHP que automatiza o processo de encontrar, instalar e atualizar bibliotecas e pacotes dos quais seus projetos PHP dependem. Em vez de baixar e gerenciar dependências manualmente, o Composer lê um arquivo composer.json que lista os requisitos do seu projeto e gerencia tudo automaticamente. Isso garante que você obtenha as versões corretas dos pacotes e suas dependências, tornando o desenvolvimento PHP mais eficiente e confiável.

2. Como faço para instalar o Composer globalmente no Ubuntu?

Para instalar o Composer globalmente no Ubuntu, baixe o script de instalação, verifique sua integridade usando o hash SHA-384 e, em seguida, execute o instalador com as opções --install-dir e --filename apontando para /usr/local/bin. Isso torna o Composer disponível em todo o sistema como o comando composer. O processo de instalação é idêntico nas versões Ubuntu 20.04, 22.04 e 24.04. Os passos detalhados estão cobertos no Passo 2 deste tutorial.

3. Como posso verificar se o instalador do Composer é seguro?

Você pode verificar a segurança do instalador do Composer comparando seu hash SHA-384 com o hash oficial publicado na página de Chaves Públicas/Assinaturas do Composer. Use o comando php -r "if (hash_file('SHA384', '/tmp/composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; }" onde $HASH contém o hash mais recente da página oficial do Composer. Esta etapa de verificação é crucial para a segurança e é demonstrada no Passo 2.

4. Qual é a diferença entre uma instalação global e uma instalação local do Composer?

Uma instalação global coloca o Composer em um diretório do sistema como /usr/local/bin, tornando-o acessível a partir de qualquer diretório do seu sistema. Isso é conveniente para gerenciar múltiplos projetos. Uma instalação local cria um arquivo composer.phar em um diretório específico do projeto, o que é útil quando você não tem permissões para instalação em todo o sistema ou deseja versões do Composer específicas para o projeto. Você pode executar uma instalação local com php /tmp/composer-setup.php no diretório do seu projeto.

5. Como faço para atualizar o Composer para a versão mais recente?

Para atualizar o Composer para a versão mais recente, execute composer self-update. Esse comando baixa e instala a versão mais nova do Composer, substituindo a sua instalação atual. Para instalações globais, pode ser necessário usar sudo composer self-update dependendo das suas permissões.

6. Por que o Composer está dando erros de limite de memória no Ubuntu?

Erros de limite de memória geralmente ocorrem quando o Composer tenta processar árvores de dependência grandes ou quando o limite de memória do seu PHP é muito baixo. Você pode resolver isso aumentando temporariamente o limite de memória do PHP para os comandos do Composer usando php -d memory_limit=512M /usr/local/bin/composer install ou editando seu arquivo php.ini para aumentar a configuração memory_limit. Para a maioria dos projetos, 512MB ou 1GB devem ser suficientes.

7. Como desinstalar o Composer no Ubuntu?

Para desinstalar um Composer instalado globalmente, basta remover o arquivo executável: sudo rm /usr/local/bin/composer. Para instalações locais, exclua o arquivo composer.phar do diretório do seu projeto. Note que isso não remove o diretório vendor nem os arquivos composer.json dos seus projetos, que você pode excluir separadamente, se necessário.

8. Preciso de sudo para rodar o Composer?

Você não precisa de sudo para executar comandos do Composer para gerenciar dependências do projeto. No entanto, pode ser necessário usar sudo ao instalar ou atualizar o Composer globalmente, já que isso exige escrever em diretórios do sistema, como /usr/local/bin. Uma vez instalado, operações regulares do Composer, como composer install, composer require e composer update, funcionam sem privilégios elevados.

Conclusão

O Composer é uma ferramenta poderosa que pode facilitar muito o trabalho de gerenciamento de dependências em projetos PHP. Ele fornece uma forma 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 quando novas versões estiverem disponíveis.

Próximos Passos

Agora que você instalou e configurou o Composer em seu sistema Ubuntu, você pode começar a criar aplicações PHP com dependências gerenciadas. Aqui estão alguns próximos passos recomendados:

• Implante aplicações PHP com Composer: Aprenda como implantar projetos baseados em Composer usando a Plataforma de Aplicativos Linux-Console.net, que detecta e instala automaticamente as dependências do Composer durante a implantação.

• Configure o Laravel com Docker: Se você está trabalhando com Laravel, confira nosso guia sobre Como Instalar e Configurar o Laravel com Docker Compose no Ubuntu para containerizar seu ambiente de desenvolvimento.

• Aprenda Docker Compose: Para gerenciar aplicações com múltiplos containers, confira nosso tutorial sobre Como Instalar e Usar o Docker Compose no Ubuntu.

• Explore o desenvolvimento em PHP: Navegue pela nossa coleção de tutoriais de PHP para aprender mais sobre as melhores práticas de desenvolvimento em PHP, configuração de frameworks e estratégias de implantação.

Pronto para implantar sua aplicação PHP? Comece com a Plataforma de Apps Linux-Console.net e implante seus projetos baseados em Composer em minutos com gerenciamento automático de dependências e escalabilidade.

Recursos Adicionais

• Referência Rápida: Para uma versão condensada deste guia, veja nosso guia de Início Rápido de Como Instalar o Composer no Ubuntu 20.04.
• Tutoriais de Composer: Explore nossa coleção completa de tutoriais de Composer para padrões de uso mais avançados e melhores práticas.
• Integração com Docker: Aprenda como containerizar suas aplicações PHP com nosso guia sobre Como Instalar e Usar o Docker Compose no Ubuntu 20.04 ou o guia correspondente para sua versão do Ubuntu.
• Desenvolvimento em PHP: Navegue pela nossa coleção completa de tutoriais de PHP, abrangendo frameworks, estratégias de implementação e otimização de desempenho.

Quer hospedar suas aplicações PHP? Faça o deploy com a Plataforma de Aplicativos do Linux-Console.net para escalonamento automático, bancos de dados gerenciados e integração perfeita com o Composer, ou crie um Droplet para ter controle total do servidor.

Obrigado por aprender com a comunidade Linux-Console.net.