Como instalar o WordPress usando o Composer: guia de instalação passo a passo

Publicados: 2023-02-28

Introdução: Por que o WordPress é baseado no Composer?

Como qualquer outro aplicativo, seu site WordPress é mais seguro quando você pode garantir compilações repetíveis e atualizações confirmáveis ​​para seu código e suas dependências. Sua infraestrutura é confirmada por meio de um conjunto de arquivos de configuração que especificam qual versão do PHP e do MariaDB você deseja usar. Esta é a melhor maneira de garantir que seu projeto permaneça reproduzível ao desenvolver novos recursos.

O núcleo do WordPress, além de seus temas e plugins, deveria funcionar idealmente da mesma maneira, mas muitas vezes não é o caso. O painel de administração do WordPress fornece botões de um clique para atualizar todos esses componentes quando eles estiverem desatualizados ou, caso contrário, esperar para gravar o acesso ao sistema de arquivos para fazer alterações de configuração em tempo de execução. No entanto, desenvolver-se dessa forma tem suas consequências.

Primeiro, nem sempre você terá acesso de gravação ao sistema de arquivos em tempo de execução. Portanto, depender desse mecanismo para atualizações e alterações de configuração é totalmente restrito para muitas soluções de hospedagem. Por outro lado, se você tiver acesso de gravação no tempo de execução onde está hospedando no momento, a instalação de um novo módulo ou tema apresenta um risco de segurança não trivial (quando a fonte é desconhecida).

Mas, talvez o mais importante, a atualização do WordPress em tempo de execução separa o estado do seu site do código em seu repositório. Um colega trabalhando em um novo recurso em seu clone local do projeto pode muito bem ser uma versão completa por trás do site ativo. Como resultado desse fluxo de trabalho, você pode introduzir bugs com consequências desconhecidas (e não testadas).

Vantagens de usar o Composer

Dados os fatos acima, gerenciar seu site WordPress com o Composer tem vantagens claras. Primeiro, ele permite que você defina explicitamente suas dependências em um arquivo confirmado (composer.lock). Esse arquivo de bloqueio é gerado a partir de uma lista mais descritiva de restrições de dependência (composer.json) quando suas dependências são instaladas e se torna parte do histórico de confirmação do seu projeto. A partir de então, qualquer nova ramificação funcionará a partir da coleção idêntica de dependências até o hash de confirmação exato. Nesse ponto, não importa quem contribui para o projeto ou mesmo onde ele é implantado – é o mesmo código para todos em todos os lugares.

O Composer também elimina a necessidade de enviar muitos códigos externos para o seu repositório. No caso do WordPress, não usar o Composer geralmente exige que você confirme todo o código de um tema, e até mesmo do núcleo do WordPress e dos próprios plugins, em seu próprio projeto. Além de tornar o repositório desnecessariamente grande e lento para clonar, atualizar essas cópias torna-se um ato de malabarismo com o qual ninguém precisa lidar.

Com o Composer, você pode adicionar e atualizar dependências ao seu projeto e, em seguida, bloquear suas versões exatas para que cada nova ramificação obtenha a mesma atualização. Se a atualização tivesse sido executada no site implantado em tempo de execução, você teria que se lembrar de git pull primeiro.

Instalando o núcleo do WordPress com o Composer

Da mesma forma, usar o Composer torna desnecessário enviar todo o WordPress para o seu repositório, pois você pode adicioná-lo como uma dependência. Existem várias maneiras de fazer isso (como o Bedrock), dependendo de quantas suposições você deseja fazer para sua configuração e estrutura do projeto. O mais simples usa o fork John Bloch Composer para adicionar um instalador às suas compilações para WordPress:

 $ composer requer johnpbloch/wordpress-core-installer
$ composer requer johnpbloch/wordpress-core

O comando acima criará um arquivo composer.json e instalará o núcleo do WordPress no diretório do WordPress. O composer.json ficará assim

 {
    "exigir": {
        "johnpbloch/wordpress-core-installer": "^2.0",
        "johnpbloch/wordpress-core": "^6.1"
    },
    "configuração": {
        "permitir plug-ins": {
            "johnpbloch/wordpress-core-installer": verdadeiro
        }
    }
}

Temos o núcleo do WordPress na pasta WordPress. Mas precisamos copiar index.php fora do diretório do WordPress para que possamos apontar o servidor web para o diretório raiz.

Para gerenciar totalmente o WordPress com o Composer , precisamos usar um diretório diferente para wp-content em vez do padrão, WordPress/wp-content.

Vamos criar um novo diretório na raiz do projeto chamado wp-content.

Uma vez copie o index.php da pasta WordPress. Precisamos alterar a localização do arquivo wp-blog-header.php onde nosso diretório WordPress está localizado.

Após a alteração, o index.php ficará assim

 <?php 
define('WP_USE_THEMES', verdadeiro);
require(dirname( __FILE__ ) . '/wordpress/wp-blog-header.php' );

Precisamos criar um arquivo .htaccess no diretório raiz com o seguinte conteúdo:

 # COMEÇAR WordPress
<IfModule mod_rewrite.c>
Reescrever Motor Ligado
RewriteBase /
RewriteRule ^index.php$ - [L]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /index.php [L]
</IfModule>
# FIM WordPress

Vamos copiar o arquivo wp-config.php de amostra e adicionar o seguinte código:

 $dominio = 'meudominio.com;
define('WP_SITEURL', "https://{$domain}/wordpress");
define('WP_HOME',"https://{$domain}");
$httpHost = isset($_SERVER['HTTPS_HOST']) ? $_SERVER['HTTPS_HOST'] : $domínio;
define( 'WP_CONTENT_DIR', dirname( __FILE__ ). '/wp-content' );
define( 'WP_CONTENT_URL', 'https://' . $httpHost . '/wp-content' );
/** Caminho absoluto para o diretório do WordPress. */
if (!definido('ABSPATH')) {
    define('ABSPATH', dirname(__FILE__) . '/wordpress');
}

Adicionamos o WordPress em ABSPATH, pois o núcleo do WordPress está em /WordPress
Como o arquivo wp-config.php contém dados confidenciais; não o enviaremos ao nosso repositório criando um arquivo .gitignore:

 /wp-config.php
/wordpress/
/wp-content/
/fornecedor/

Os diretórios WordPress, wp-content e vendor também precisam ser ignorados para que possamos adicioná-los ao arquivo .gitignore também.

Nota: Você precisa alterar o diretório wp-content caso queira adicionar uma convenção de nomenclatura diferente para seu wp-content.

Nosso diretório raiz do projeto deve ser semelhante a este

 .git
.gitignore
composer.lock
composer.json
fornecedor
wp-config.php
index.php
wordpress

Você precisa criar um banco de dados e alterar os detalhes em wp-config.php. Seu site WordPress será chamado de “mydomain.com” e o back-end do WordPress será acessível por mydomain.com/wordpress/wp-admin

Adicionando Plugins e Temas do Repositório WordPress

Por padrão, o Composer examinará apenas o repositório packagist.org. Mas não contém plugins e temas do WordPress.

Para poder extrair plugins e temas do WordPress, você precisa apontar o Composer para o repositório wpackagist.org. Você faz isso adicionando este pedaço de configuração em seu arquivo composer.json:

 "repositórios": [
  {
    "tipo": "compositor",
    "url": "https://wpackagist.org",
    "apenas": [
      "wpackagist-plugin/*",
      "wpackagist-theme/*"
    ]
  }
],

Também precisamos informar ao Composer onde colocar plugins e temas. Isso envolve adicionar um pouco mais de configuração ao composer.json:

 "extra": {
        "caminhos do instalador": {
            "wp-content/mu-plugins/{$name}/": [
                "tipo:wordpress-muplugin"
            ],
           "wp-content/plugins/{$name}/": [
                "tipo:plugin-wordpress"
            ],
           "wp-content/themes/{$name}/": [
                "type:wordpress-theme"
            ]
        }
    }

Com isso instalado, agora você pode instalar qualquer plugin ou tema dos repositórios oficiais usando o comando composer require, como fizemos para instalar o WordPress.

# Para instalar um plugin, use este formato:

 composer requer "wpackagist-plugin/:"

# Para instalar um tema, use este formato:

 composer requer "wpackagist-theme/:"

As restrições de versão são complicadas, mas provavelmente a forma mais simples de lembrar é usar um curinga *. Para instalar a versão gratuita do nosso plugin WP Migrate, usando a versão 2.x, você deve executar:

composer require "wpackagist-plugin/wp-migrate-db:2.*"

Se você sempre quis que suas atualizações trouxessem a versão mais recente, você pode usar um * como a restrição de versão:

composer require "wpackagist-plugin/wp-migrate-db:*"

Na primeira vez que você executar um comando como este, poderá ser perguntado se deseja “confiar em “compositor/instaladores” para executar o código”. Isso é seguro, mas esteja ciente de que isso permite que o Composer execute o código em seu computador.

Se tudo estiver bem, você deve instalar o plug-in (mas não ativá-lo). Eu também recomendaria confirmar suas alterações no Git neste momento.

Adicionar plugins e temas personalizados ou de terceiros

Tudo bem se você quiser plugins e temas do repositório. Mas e se você quiser adicionar plug-ins de terceiros que não estão no repositório wordpress.org ou em seu próprio código personalizado? O diretório do WordPress não está no Git, então como você controla a versão de suas próprias coisas?

Alguns autores de temas e plugins oferecem suporte a repositórios personalizados para seus plugins.

E alguns temas e plugins não podem usar nenhum repositório para seus plugins, por exemplo, plugins pagos.

Mas se isso não se aplicar, o truque aqui é ignorar seletivamente diretórios específicos usando o arquivo .gitignore e adicionar esses plugins e temas personalizados em composer.json.

Também podemos colocar esses plugins em outro diretório para instalá-los a partir do composer.json.

Como estamos ignorando a pasta plugins no .gitignore, precisamos criar outra pasta chamada dist,

No dist, podemos ter plugins pagos e personalizados e podemos instalá-los a partir do Composer.

  • dist/
    • plugins/
    • temas/
    • mu-plugins/

Precisamos copiar nossos plugins e temas personalizados para a pasta apropriada.

E precisamos criar composer.json para cada plugin adicionado no dist/plugins.

Atualmente, temos advanced-custom-fields-pro, que é pago. Também queremos adicionar esse plug-in por meio do compositor para instalação com um clique e automatizar implantações.

Temos que baixar esse plug-in do portal do site do autor e extraí-lo na pasta dist/plugins/advanced-custom-fields-pro. E crie composer.json na mesma pasta com o seguinte conteúdo,

 {
   "nome": "plug-ins personalizados/acf-pro",

   "descrição": "Campos personalizados avançados PRO",

   "versão": "5.12.2",

   "tipo": "plug-in wordpress",

   "exigir": {

       "compositor/instaladores": "^1.0",
       "johnpbloch/wordpress-core": ">=5.4"
   }


}

Podemos adicionar a versão e o nome com prefixos personalizados aqui. E adicione algum código no arquivo composer.json raiz para chamar este plugin enquanto fazemos a instalação.

Na seção “repositories”: adicione o seguinte código na última,

 "repositórios": [
{
     "tipo": "caminho",

     "url": "dist/plugins/*",

     "opções": {

       "link simbólico": falso

     }

Você também tem outras entradas na seção de repositórios. Para instalar este plugin, temos duas maneiras, primeiro adicionar o nome do plugin com a versão no

 "exigir": {
     "custom-plugins/acf-pro": ">=5.12.2"
}

Ou execute o comando a seguir, ele instalará o plugin e adicionará a entrada acima no composer.json.

 $ composer requer custom-plugins/acf-pro

Da mesma forma, podemos instalar temas e plugins mu.

Para o tema, precisamos adicionar o local da pasta do tema,

 "repositórios": [
{
     "tipo": "caminho",

     "url": "dist/temas/*",

     "opções": {

       "link simbólico": falso

     }

Você deve adicionar composer.json em seu tema personalizado com detalhes de nome e versão. Usando esse nome, podemos instalar o tema usando o comando composer require.

Para concluir

Usar o Composer é a abordagem mais eficaz para garantir que seu WordPress permaneça seguro, atualizado e reproduzível. O Composer permite que os desenvolvedores adicionem e atualizem facilmente dependências em seus projetos e bloqueiem suas versões exatas para garantir que cada nova ramificação funcione com o mesmo código.

Com essas vantagens, o Composer é uma ótima opção para gerenciar projetos WordPress, garantindo compilações repetíveis e atualizações commitáveis.

Entendemos que começar a usar o Composer pode ser um pouco complicado. Se você tiver alguma dúvida, não hesite em entrar em contato conosco. Estamos aqui para ajudá-lo a aproveitar ao máximo sua experiência no WordPress.

Referências:

    • https://docs.platform.sh/guides/wordpress/composer.html
    • https://deliciousbrains.com/storing-wordpress-in-git/
    • https://time2hack.com/composer-wordpress-deployment/