O Docker é uma plataforma popular de código aberto para desenvolver, enviar e executar aplicativos. Ele encapsula aplicativos e suas dependências em contêineres para promover a consistência em diferentes ambientes. Essa consistência ajuda a evitar problemas relacionados a conflitos de dependência e discrepâncias do tipo “isso funciona no meu computador”.

Com o Docker, você pode definir as dependências e extensões necessárias usando Dockerfiles. Isso significa que seus aplicativos têm todas as bibliotecas e ferramentas necessárias em um ambiente reprodutível e isolado.

A Hospedagem de Aplicativos da Kinsta oferece suporte dinâmico para Dockerfiles personalizados, o que permite que você tenha maior controle do ambiente do seu aplicativo. Com um Dockerfile, você pode usar praticamente qualquer linguagem — e não está restrito às linguagens suportadas por Nixpacks ou Buildpacks.

Este artigo prático orienta você sobre como instalar e usar dependências e extensões PHP no Docker.

Por que usar o Docker para instalar dependências?

Usar o Docker para instalar dependências tem vários benefícios:

  • Consistência de ambiente — o Docker permite que você empacote seu aplicativo, suas dependências e suas configurações em um contêiner. Essa abordagem garante que o ambiente no qual seu aplicativo é executado permaneça consistente em diferentes configurações e sistemas, incluindo ambientes de desenvolvimento, teste e produção.
  • Facilidade de instalação e resolução de dependências — o Docker permite que você configure o ambiente do seu aplicativo em qualquer máquina que o suporte, especificando todas as dependências e configurações necessárias. Como resultado, você evita problemas de compatibilidade e o incômodo de instalar dependências manualmente.
  • Controle de versão e isolamento — os contêineres do Docker encapsulam todas as dependências, inclusive suas versões específicas dentro do contêiner. Isso significa que você pode controlar a versão do seu aplicativo e suas dependências, promovendo a reprodutibilidade e eliminando conflitos entre diferentes versões de dependências.

Além disso, os contêineres do Docker oferecem isolamento, o que ajuda a eliminar conflitos entre dependências de diferentes aplicativos executados no mesmo sistema.

Configure seu aplicativo na Kinsta

A configuração do seu aplicativo na Kinsta é simples. Visite o MyKinsta e siga o processo de registro. Uma vez registrado, você pode acessar um poderoso painel de hospedagem e um conjunto de recursos projetados para otimizar o desempenho e a segurança.

A Hospedagem de Aplicativos da Kinsta suporta uma variedade de linguagens de programação, incluindo PHP, Python, Node.js e Ruby. Esse amplo suporte a linguagens garante a compatibilidade com diversos aplicativos, permitindo que você escolha a linguagem que melhor atenda aos requisitos do seu projeto.

Por exemplo, se você estiver desenvolvendo um aplicativo web dinâmico em PHP, o ambiente de hospedagem otimizado da Kinsta garante alto desempenho e confiabilidade para seus projetos baseados em PHP. Ou, se você estiver criando uma API RESTful com Node.js ou um aplicativo web orientado por dados em Python, a Kinsta fornece a infraestrutura e o suporte necessários para o seu aplicativo.

Para que você tenha uma ideia de como implantar um aplicativo usando um Dockerfile na Kinsta, use este aplicativo, um sistema básico de autenticação baseado em PHP que usa o MariaDB para armazenar dados. Esse aplicativo também aproveita alguns pacotes composer, incluindo respect/validation para validação de entrada e ircmaxell/password-compat para hashing de senha.

Prepare seu ambiente do Docker

Um Dockerfile é um arquivo de texto que contém todos os comandos, organizados na ordem necessária, que você precisa para criar a imagem desejada. Um Dockerfile básico para um aplicativo PHP seria semelhante a este:

FROM php:8.3-cli
COPY . /usr/src/myapp
WORKDIR /usr/src/myapp
CMD [ "php", "./your-script.php" ]

Esse Dockerfile cria um ambiente de contêiner para executar um script PHP a partir de uma interface de linha de comando (CLI). Ele começa usando a imagem oficial do PHP com a variante CLI, garantindo que apenas o runtime do PHP seja incluído no contêiner.

Em seguida, ele copia o conteúdo do diretório local, que contém o Dockerfile, para o diretório /usr/src/myapp dentro do contêiner. Após definir o diretório de trabalho como /usr/src/myapp, ele especifica o script PHP a ser executado, your-script.php, usando o comando php.

A imagem contém muitas extensões PHP pré-compiladas. Portanto, comece verificando se a extensão de que você precisa está instalada executando o comando php -m.

Se a extensão de que você precisa não estiver disponível na imagem de base, o Docker fornece os seguintes scripts auxiliares para ajudá-lo a instalar extensões adicionais com mais facilidade:

  • docker-php-ext-configure
  • docker-php-ext-install
  • docker-php-ext-enable

Por exemplo, o aplicativo de demonstração deste tutorial usa a extensão MySQLi para interagir com o banco de dados MariaDB. Essa extensão não é compilada na imagem por padrão, portanto, instale-a usando o seguinte comando em seu Dockerfile:

RUN docker-php-ext-install mysqli

Para escrever um Dockerfile para o aplicativo de demonstração, crie um novo arquivo chamado Dockerfile na pasta raiz do projeto. Cole o seguinte código no arquivo:

FROM php:8.3-apache

# Install MySQL client, server, and other dependencies
RUN apt-get update && \
	apt-get install -y \
	default-mysql-client \
	default-mysql-server \
	git \
	&& apt-get clean \
	&& rm -rf /var/lib/apt/lists/*

# Install mysqli PHP extension for MySQL support
RUN docker-php-ext-install mysqli

Este código especifica a imagem oficial do PHP — especificamente a versão 8.3 — com o Apache instalado como a imagem de base para o contêiner. Essa imagem fornece um ambiente pré-configurado para a execução de aplicativos PHP com o Apache como servidor web.

Em seguida, instala as dependências adicionais que o aplicativo de demonstração requer, incluindo default-mysql-client e default-mysql-server, que criam e interagem com o banco de dados MariaDB.

Por fim, o snippet acima instala a extensão PHP mysqli usando docker-php-ext-install, que permite que o aplicativo de demonstração estabeleça uma conexão e execute operações no banco de dados MariaDB.

Gerencie dependências com o Docker

O gerenciamento das dependências do PHP com o Docker envolve usar o Composer, um popular gerenciador de dependências para PHP. Ao instalar o Composer em um contêiner do Docker, você pode simplificar o processo de instalação, atualização e gerenciamento das dependências de PHP, facilitando a consistência e a reprodutibilidade em diferentes ambientes.

Siga as etapas abaixo para usar o Composer para o gerenciamento de dependências no aplicativo de demonstração. Adicione o código em cada uma das etapas ao seu Dockerfile.

  1. Instale o Composer na imagem do Docker usando o comando abaixo: 
    # Install Composer
COPY --from=composer/composer:latest-bin /composer /usr/bin/composer

    Esse comando copia um arquivo binário pré-criado do Composer do repositório do Docker Hub para a sua imagem. --from=composer/composer:latest-bin especifica a imagem de origem da qual você copiará os arquivos.

    O caminho /composer na imagem de origem contém os arquivos a serem copiados, enquanto o caminho /usr/bin/composer da sua imagem do Docker é o destino desses arquivos.

  2. Em seguida, defina o diretório de trabalho executando o seguinte: 
    # Set working directory
WORKDIR /var/www/html
  3. Copie os arquivos composer.json e composer.lock para a imagem. 
    # Copy composer.json and composer.lock
COPY composer.json composer.lock ./
  4. Instale as dependências do Composer listadas em composer.json. 
    # Install Composer dependencies
RUN composer install --no-dev --optimize-autoloader

    --no-dev instrui o Composer a ignorar as dependências específicas do desenvolvimento. --optimize-autoloader instrui o Composer a otimizar o carregador automático para melhorar o desempenho.

Você pode atualizar e gerenciar as dependências ao longo do tempo modificando o arquivo composer.json conforme necessário, adicionando novas dependências, atualizando as restrições de versão e removendo as dependências que não são mais necessárias.

Depois de fazer as alterações necessárias, você pode executar composer install ou composer update no contêiner do Docker para instalar ou atualizar as dependências concordemente.

Aplique as configurações finais

Antes de o aplicativo funcionar com o Docker, você deve criar o banco de dados e o usuário do banco de dados, definir variáveis de ambiente e copiar os arquivos do projeto para a imagem do Docker.

Para fazer isso, siga as etapas abaixo e copie cada snippet de código para o seu Dockerfile.

  1. Defina as variáveis de ambiente que o aplicativo PHP usará para se conectar ao banco de dados MariaDB. Você pode substituir DB_USER, DB_PASSWORD e DB_NAME pelas credenciais de sua preferência. 
    # Set environment variables
ENV DB_HOST=localhost \
	DB_USER=kinsta_user \
	DB_PASSWORD=your_password_here \
	DB_NAME=kinsta_docker_auth \
	# Path to the Unix socket file used for connecting to the MariaDB server.
	DB_SOCKET=/var/run/mysqld/mysqld.sock
  2. Copie os arquivos do aplicativo PHP para a imagem do Docker: 
    # Copy PHP application files into the image
COPY . .
  3. Copie o script de inicialização para a imagem: 
    # Copy the startup script
COPY scripts/start.sh /usr/local/bin/start.sh

    Esse script é executado quando o contêiner é iniciado e é responsável por iniciar o servidor de banco de dados, criar um banco de dados, uma tabela e um usuário, e iniciar o servidor Apache. Você criará esse script mais tarde.

  4. Torne o script executável usando o comando chmod: 
    # Make the script executable
RUN chmod +x /usr/local/bin/start.sh
  5. Por fim, execute o script usando o comando abaixo: 
    # Execute the startup script
CMD ["/usr/local/bin/start.sh"]

Agora que o Dockerfile está completo, é hora de criar o script de inicialização discutido anteriormente.

Crie um novo arquivo chamado scripts/start.sh na pasta raiz do projeto e adicione o seguinte código. Certifique-se de usar as credenciais do banco de dados que você definiu no Dockerfile.

#!/bin/bash

# Start MariaDB server
service mariadb start

# Wait for MariaDB to be fully initialized (retry up to 30 times, waiting 1  second between each attempt)
attempt=0
while [ $attempt -lt 30 ]; do
		if mysqladmin ping &>/dev/null; then
    		echo "MariaDB is up and running."
    		break
		else
    		echo "MariaDB is not yet available. Retrying..."
    		attempt=$((attempt+1))
    		sleep 1
		Fi
done

# If MariaDB failed to start within the specified attempts, exit with an error
if [ $attempt -eq 30 ]; then
		echo "Error: MariaDB failed to start within the specified time."
		exit 1
fi

# Set the database name, username, and password
dbname="kinsta_docker_auth"
dbuser="kinsta_user"
dbpassword="your_password_here"

# Create the database if it does not exist
mysql -u root -e "CREATE DATABASE IF NOT EXISTS $dbname;"

# Create a database user and assign privileges to the database
mysql -u root -e "CREATE USER '$dbuser'@'localhost' IDENTIFIED BY '$dbpassword';"
mysql -u root -e "GRANT ALL PRIVILEGES ON $dbname.* TO '$dbuser'@'localhost';"
mysql -u root -e "FLUSH PRIVILEGES;"

# Create users table if it does not exist
mysql -u root -e "USE $dbname; CREATE TABLE IF NOT EXISTS users (
		id INT AUTO_INCREMENT PRIMARY KEY,
		username VARCHAR(20) UNIQUE NOT NULL,
		password_hash VARCHAR(255) NOT NULL
);"

# Start Apache server
apache2ctl -D FOREGROUND

Esse script Bash inicia o servidor MariaDB. Em seguida, quando o servidor é totalmente inicializado, cria um banco de dados, um usuário com os privilégios apropriados e uma tabela no banco de dados. Por fim, inicia o servidor Apache.

Implante na Kinsta

Antes de implantar seu aplicativo na Kinsta, você deve definir algumas configurações para o servidor Apache. O serviço de Hospedagem de Aplicativos da Kinsta tem as portas 80 e 443 abertas, mas recomendamos que você use a porta 8080 se o seu aplicativo expuser alguma porta.

Por padrão, o servidor Apache escuta conexões na porta 80, portanto você deve configurá-lo para escutar conexões na porta 8080. Para fazer isso, siga estas etapas:

  1. Crie uma pasta chamada apache-conf na pasta raiz do projeto.
  2. Na pasta recém-criada, crie um arquivo chamado apache-config.conf. Adicione o código abaixo para configurar o Apache para escutar conexões na porta 8080: 
    <VirtualHost *:8080>
	ServerAdmin webmaster@localhost
	DocumentRoot /var/www/html

	ErrorLog ${APACHE_LOG_DIR}/error.log
	CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
  3. Na pasta apache-conf, crie um novo arquivo chamado apache-ports.conf e adicione o código abaixo. 
    # Change the Listen directive to listen on port 8080
Listen 8080

# Keep the existing configuration for port 443
<IfModule ssl_module>
	Listen 443
</IfModule>

<IfModule mod_gnutls.c>
	Listen 443
</IfModule>

    A diretiva Listen 8080 instrui o Apache a escutar as conexões de entrada na porta 8080.

  4. Agora, você precisa modificar o Dockerfile para aplicar essa configuração ao servidor Apache. No Dockerfile, adicione estes comandos logo após o comando para definir o diretório de trabalho (WORKDIR /var/www/html). Eles são responsáveis por copiar os arquivos de configuração personalizados para os diretórios apropriados. 
    # Set up Apache virtual host
COPY apache-conf/apache-config.conf /etc/apache2/sites-available/000-default.conf

# Set up Apache ports
COPY apache-conf/apache-ports.conf /etc/apache2/ports.conf
  5. Por fim, crie um arquivo .dockerignore na pasta raiz do projeto. Esse arquivo contém uma lista de pastas e arquivos que não devem ser copiados para a imagem do Docker. Adicione vendor para excluir a pasta vendor.

Com todas as configurações feitas, você pode implantar na Kinsta. Carregue os arquivos do seu projeto no provedor Git de sua preferência (Bitbucket, GitHub ou GitLab) e siga as etapas abaixo.

  1. No seu painel MyKinsta, selecione Aplicativos na barra lateral e clique no botão Adicionar aplicativo.
  2. Na página Adicionar aplicativo, selecione o repositório e o branch do Git, forneça um nome de aplicativo, escolha um local de centro de dados e clique em Continuar.
  3. Na página Ambiente de build, selecione Usar Dockerfile para configurar a imagem do contêiner. Forneça “Dockerfile” como o Caminho do Dockerfile e um ponto final (“.”) como o Contexto. Clique em Continuar.

    Seção Ambiente de build no formulário Adicionar aplicativo.
    Seção Ambiente de build no formulário Adicionar aplicativo.

  4. Deixe tudo marcado na página Configurar seus processos e clique em Continuar. Observação: O banco de dados perderá dados quando você reiniciar ou reimplantar o aplicativo. Se você precisar resolver esse problema, confira o armazenamento persistente da Kinsta e aplique-o nesta página. Este guia não analisará a configuração de armazenamento persistente.
  5. Confirme os detalhes do pagamento na página Resumo e clique em Implantar agora.
  6. Quando a implantação estiver concluída, abra o domínio do seu aplicativo para visualizar o site ativo.
    Página de login no site ativo.
    Página de login no site ativo.

    Registre-se para criar uma conta, faça login usando seus detalhes e verifique se você pode acessar a página protegida e se tudo funciona conforme o esperado.

    A página inicial do aplicativo quando você estiver conectado.
    A página inicial do aplicativo quando você estiver conectado.

Monitore e otimize seu aplicativo

Depois que seu aplicativo estiver em funcionamento na Kinsta, é essencial monitorar e otimizar seu desempenho. Isso garante que seu aplicativo possa operar sem problemas e usar os recursos de forma eficiente.

A otimização do desempenho do seu aplicativo é crucial para proporcionar uma experiência de usuário rápida e responsiva.

A Kinsta está sempre trabalhando em maneiras de otimizar o desempenho do seu aplicativo. Oferecemos ferramentas de monitoramento abrangentes para ajudar você a acompanhar várias métricas de desempenho, incluindo largura de banda, tempo total de build, uso de CPU, consumo de memória, tráfego de rede e tempos de resposta. Você pode visualizar todas essas informações navegando até a seção Análises do seu aplicativo no painel da Kinsta.

Se você encontrar um problema ou um comportamento inesperado do aplicativo, poderá navegar até a seção Registros no painel da Kinsta. Essa visão detalhada do desempenho e do comportamento do seu aplicativo inclui registros de erros e acessos.

Analisando meticulosamente esses registros, você obtém informações valiosas sobre o que pode estar causando o problema, como mensagens de erro, rastreamentos de pilha ou padrões de comportamento anormal. Essas informações podem ajudá-lo a diagnosticar a raiz do problema e tomar as medidas adequadas para resolvê-lo.

Além disso, você pode aproveitar as técnicas de otimização de desempenho no ambiente do Docker, como a otimização de imagens do Docker e a implementação de práticas recomendadas para arquitetura de aplicativos e otimização de código.

Resumo

Os contêineres leves e portáteis do Docker facilitam o empacotamento e a implantação de aplicativos com todas as dependências necessárias, independentemente da infraestrutura subjacente. Ao colocar seu aplicativo e suas dependências em contêineres, você promove a consistência em diferentes ambientes, simplifica os processos de configuração e obtém melhor controle de versão.

Ao utilizar o Docker com a Kinsta, você aprimora o processo de implantação do seu aplicativo. Seu suporte para Dockerfiles personalizados e uma ampla gama de linguagens de programação, incluindo PHP, garante compatibilidade e flexibilidade para seus projetos.

Com a infraestrutura da Hospedagem de Aplicativos e a tecnologia de conteinerização do Docker, você obtém implantação simplificada, escalabilidade e confiabilidade para os seus aplicativos.

Você já usou o Docker em seus projetos? Você tem experiência ou insights sobre o Docker? Compartilhe nos comentários abaixo!

Jeremy Holcombe Kinsta

Content & Marketing Editor at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems ;).