Implantar um aplicativo PHP usando o Docker-compone

• Configurando nosso ambiente de trabalho
• Configurando o Contêiner PHP
• Configurando o contêiner Nginx
• Configurando o Contêiner MySQL
• Construindo nosso aplicativo
• Conclusão

Os aplicativos PHP geralmente são compostos por um servidor da web, um sistema de banco de dados relacional e o próprio interpretador de linguagem. Neste tutorial, aproveitaremos uma pilha completa de aplicativos PHP usando o docker. Este é um tutorial detalhado no qual vamos construir e orquestrar contêineres para Nginx (o servidor da web), MySQL (o sistema de banco de dados) e PHP.

Para fins deste tutorial, escreveremos um aplicativo simples que lê uma lista de cidades de um banco de dados e a exibe em uma página da Web, desta forma demonstraremos um aplicativo PHP básico, mas funcional.

Este guia pressupõe que você já tenha o Docker-CE instalado e, pelo menos, um conhecimento mínimo sobre o docker. Para esse assunto, você pode revisar os seguintes tutoriais:

• Instalando o Docker CE no Ubuntu 16.04
• Instalando o Docker CE no CentOS 7
• Como usar o Docker: Criando seu primeiro contêiner Docker

Configurando nosso ambiente de trabalho

Um aplicativo baseado no docker da vida real normalmente será composto de vários contêineres. Gerenciar esses manualmente pode facilmente tornar-se bastante confuso e complicado. É aí que o docker-compose entra em cena. Ajuda você a gerenciar vários contêineres por meio de um yamlarquivo de configuração simples .

Instale a janela de encaixe-compor.

curl -L https://github.com/docker/compose/releases/download/1.19.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

Crie uma pasta para armazenar todos os arquivos necessários deste exemplo e depois cddentro dele. A partir de agora, este é o nosso diretório de trabalho e todos os comandos serão executados dentro desta pasta e todos os caminhos serão referenciados em relação a ela. Esta pasta pode ser referenciada posteriormente como WORKING_DIR.

mkdir ~/docker
cd ~/docker

Agora crie mais três pastas.

mkdir php nginx app

A phppasta é onde criaremos nossa imagem PHP personalizada, a nginxpasta conterá os arquivos necessários para nossa imagem nginx personalizada e a apppasta é onde colocaremos o código fonte e a configuração do nosso aplicativo de amostra.

Configurando o Contêiner PHP

Neste exemplo, vamos usar php-fpma conexão com o servidor da web Nginx. Usaremos a imagem base oficial do PHP. No entanto, também precisamos instalar e ativar algumas extensões para que possamos acessar o banco de dados. Dentro da phppasta, crie um arquivo nomeado Dockerfilee coloque o seguinte conteúdo nele.

FROM php:7.1-fpm-alpine3.4
RUN apk update --no-cache \
    && apk add --no-cache $PHPIZE_DEPS \
    && apk add --no-cache mysql-dev \
    && docker-php-ext-install pdo pdo_mysql

Observe que estamos usando a versão alpina da imagem oficial do PHP. Alpine é uma distribuição muito pequena direcionada para contêineres, fornecendo pegadas muito menores. Além disso, observe o uso do comando docker-php-ext-install, a imagem oficial do PHP fornece esse comando para facilitar o processo de instalação e configuração de extensões PHP.

Agora, vamos criar esta imagem do Docker emitindo o seguinte (dentro da nossa WORKING_DIR):

docker build -t vultr-php php/

O docker-compose.ymlarquivo

Como já mencionado, docker-composepermite gerenciar vários contêineres por meio de um arquivo de configuração simples. Esse arquivo de configuração geralmente é nomeado docker-compose.yml. Crie este arquivo dentro da apppasta.

touch app/docker-compose.yml

Agora coloque o seguinte conteúdo neste arquivo.

version: '2'
services:
  php:
    image: vultr-php
    volumes:
      - ./:/app
    working_dir: /app

Vamos explicar essa sintaxe. Primeiro, observe a primeira linha.

version: '2'

Isso especifica a versão do docker-compose.ymlarquivo de configuração usado. A próxima linha especifica os serviços ou, em outras palavras, os contêineres a serem provisionados.

services:
  php:
    image: vultr-php
    volumes:
      - ./:/app
    working_dir: /app

Observe que todo serviço tem uma chave específica dentro do servicesbloco. O nome especificado aqui será usado para referenciar esse contêiner específico posteriormente. Observe também que, dentro da phpconfiguração, definimos a imagem usada para executar o contêiner (esta é a imagem que criamos anteriormente). Também definimos um mapeamento de volume.

volumes:
  - ./:/app

Isso indica docker-composepara mapear o diretório atual ( ./) para o /appdiretório dentro do contêiner. A última linha define a /apppasta dentro do contêiner como o diretório de trabalho, o que significa que é nessa pasta que todos os comandos futuros dentro de um contêiner são executados por padrão.

Agora podemos orquestrar nossos contêineres.

cd ~/docker/app
docker-compose up -d

Você pode executar o seguinte comando para garantir que o contêiner PHP foi executado:

docker ps

Como executar comandos dentro dos contêineres

Ainda dentro da apppasta, podemos executar qualquer comando dentro de um contêiner de serviço definido com a ajuda do docker-composecomando.

docker-compose exec [service] [command]

O [service]espaço reservado refere-se à chave de serviço. No nosso caso, isso foi php. Vamos executar um comando dentro do contêiner para verificar nossa versão do PHP.

docker-compose exec php php -v

Você verá a seguinte saída.

PHP 7.1.14 (cli) (built: Feb  7 2018 00:40:45) ( NTS )
Copyright (c) 1997-2018 The PHP Group
Zend Engine v3.1.0, Copyright (c) 1998-2018 Zend Technologies

Configurando o contêiner Nginx

Assim como o contêiner PHP, precisamos criar uma imagem personalizada para o servidor da web. Mas, neste caso, só precisamos fornecer uma configuração para o nosso virtual host. Verifique se você está dentro do nosso WORKING_DIRe crie um Dockerfiledentro da nginxpasta:

cd ~/docker
touch nginx/Dockerfile

Agora coloque o seguinte conteúdo nisso Dockerfile:

FROM nginx:1.13.8-alpine
COPY ./default.conf /etc/nginx/conf.d/default.conf

Estamos usando a imagem padrão do Nginx com base no Alpine. Nesse arquivo do Docker, simplesmente copiamos um arquivo de configuração na configuração do aplicativo. Antes de criar esta imagem, crie um arquivo de configuração.

touch nginx/default.conf

Agora preencha-o com este conteúdo.

server {
    listen 80 default_server;
    listen [::]:80 default_server ipv6only=on;

    root /app;
    index index.php;

    #server_name server_domain_or_IP;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        try_files $uri /index.php =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass php:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
}

Observe que na fastcgi_pass php:9000linha estamos referenciando o contêiner PHP por seu nome dentro do servicebloco do docker-compose.ymlarquivo de configuração. docker-composeCria internamente uma rede e atribui o nome do serviço como o nome do host a cada um dos serviços definidos. Agora podemos construir a imagem do Nginx.

docker build -t vultr-nginx nginx/

Atualizando docker-compose.yml

Agora atualize o app/docker-compose.ymlarquivo.

version: '2'
services:
  php:
    image: vultr-php
    volumes:
      - ./:/app
    working_dir: /app
  web:
    image: vultr-nginx
    volumes:
      - ./:/app
    depends_on:
      - php
    ports:
      - 80:80

Adicionamos apenas um novo serviço. A configuração é quase a mesma, exceto pelo seguinte.

depends_on:
  - php
ports:
  - 80:80

Depois que o contêiner Nginx precisar que o serviço PHP seja totalmente inicializado, forçamos esse requisito na depends_onopção A portschave de configuração mapeia uma porta de host para uma porta de contêiner, aqui mapeamos a porta 80do host para a porta 80do contêiner.

Agora crie um arquivo chamado index.phpdentro da apppasta e coloque o seguinte.

<?php phpinfo();

Verifique se a porta 80está acessível através do firewall e execute o seguinte.

cd ~/docker/app
docker-compose up -d

Mais uma vez, verifique se o serviço está ativo.

docker ps

Abra um navegador e acesse [vultr-instance-ip]. Você pode descobrir o endereço IP da instância do Vultr executando o seguinte.

hostname -I

Você verá a página de informações do PHP.

Configurando o Contêiner MySQL

A imagem oficial do MySQL permite configurar o contêiner por meio de variáveis ​​de ambiente simples. Isso pode ser feito com uma environmentopção dentro da definição do bloco de serviço. Atualize o ~/docker/app/docker-compose.ymlarquivo para o seguinte.

version: '2'
services:
  php:
    image: vultr-php
    volumes:
      - ./:/app
    working_dir: /app
  web:
    image: vultr-nginx
    volumes:
      - ./:/app
    depends_on:
      - php
    ports:
      - 80:80
  mysql:
    image: mysql:5.7.21
    volumes:
      - ./:/app
      - dbdata:/var/lib/mysql
    environment:
      - MYSQL_DATABASE=world
      - MYSQL_ROOT_PASSWORD=root
    working_dir: /app
volumes:
  dbdata:

Agora, definimos um novo serviço para o banco de dados. Observe a linha dbdata:/var/lib/mysql. Isso monta o caminho no contêiner /var/lib/mysqlpara um volume persistente gerenciado pelo Docker, assim os dados do banco de dados persistem após a remoção do contêiner. Esse volume precisa ser definido em um bloco de nível superior, como você pode ver no final do arquivo.

Antes de orquestrar nossa nova configuração, vamos baixar um banco de dados MySQL de amostra. A documentação oficial do MySQL fornece alguns bancos de dados de amostra. Usaremos o conhecido banco de dados mundial. Este banco de dados fornece uma lista de países e cidades. Para baixar este exemplo, execute o seguinte em nossa pasta de aplicativos.

curl -L http://downloads.mysql.com/docs/world.sql.gz -o world.sql.gz
gunzip world.sql.gz

Agora vamos orquestrar nossos contêineres.

docker-compose up -d

Como você já deve ter notado, o docker-compose upcomando inicia apenas os contêineres que ainda não foram iniciados. Ele verifica as diferenças entre seu docker-compose.ymlarquivo e a configuração atual dos contêineres em execução.

Mais uma vez, verifique se o contêiner do MySQL foi iniciado.

docker ps

Agora preencha o banco de dados mundial.

docker-compose exec -T mysql mysql -uroot -proot world < world.sql

Você pode verificar se o banco de dados foi preenchido selecionando dados diretamente do banco de dados. Primeiro acesse o prompt do MySQL dentro do contêiner.

docker-compose exec mysql mysql -uroot -proot world

No prompt do MySQL, execute o seguinte.

select * from city limit 10;

Você verá uma lista de cidades. Agora saia do prompt do MySQL.

mysql> exit

Construindo nosso aplicativo

Agora que todos os contêineres necessários estão em funcionamento, podemos nos concentrar em nosso aplicativo de amostra. Atualize o app/index.phparquivo para o seguinte.

<?php

$pdo = new PDO('mysql:host=mysql;dbname=world;charset=utf8', 'root', 'root');

$stmt = $pdo->prepare("
    select city.Name, city.District, country.Name as Country, city.Population
    from city
    left join country on city.CountryCode = country.Code
    order by Population desc
    limit 10
");
$stmt->execute();
$cities = $stmt->fetchAll(PDO::FETCH_ASSOC);

?>

<!doctype html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Vultr Rocks!</title>
</head>
<body>
    <h2>Most Populous Cities In The World</h2>
    <table>
    <thead>
        <tr>
            <th>Name</th>
            <th>Country</th>
            <th>District</th>
            <th>Population</th>
        </tr>
    </thead>
    <tbody>
        <?php foreach($cities as $city): ?>
            <tr>
                <td><?=$city['Name']?></td>
                <td><?=$city['Country']?></td>
                <td><?=$city['District']?></td>
                <td><?=number_format($city['Population'], 0)?></td>
            </tr>
        <?php endforeach ?>
    </tbody>
    </table>
</body>
</html>

Se você acessar [vultr-instance-ip]em um navegador da web, verá uma lista das cidades mais populosas do mundo. Parabéns, você implantou um aplicativo PHP totalmente funcional usando o docker.

Conclusão

Neste tutorial, demonstrei passo a passo como configurar um aplicativo PHP totalmente funcional. Criamos imagens personalizadas para PHP e Nginx e configuramos o docker-compose para orquestrar nossos contêineres. Apesar de ser muito básica e simples, essa configuração reflete um cenário da vida real.

Neste guia, criamos e marcamos nossas imagens localmente. Para uma configuração mais flexível, você pode enviar essas imagens para um registro da janela de encaixe . Você pode enviar para o registro oficial do docker ou até mesmo configurar seu próprio registro. De qualquer forma, isso permitirá que você construa suas imagens em um host e use-as em outro.

Para um uso mais detalhado docker-compose, consulte a documentação oficial .

Dependendo dos requisitos de seu aplicativo e da estrutura PHP usada, convém adicionar mais extensões. Isso pode ser feito facilmente, modificando o Dockerfileusado para criar nossa imagem PHP personalizada. No entanto, algumas extensões precisam de dependências extras para serem instaladas no contêiner. Você deve consultar a lista de extensões na documentação oficial do PHP para revisar os requisitos básicos de cada extensão.