Dockerizando a Pilha LEMP com Docker-Compose no Ubuntu

Docker-Compose é uma ferramenta de linha de comando para definir e gerenciar aplicações docker de múltiplos contêineres. O Compose é um script em python, que pode ser instalado facilmente com o comando pip (pip é o comando para instalar software Python do repositório de pacotes python). Com o compose, podemos executar múltiplos contêineres docker com um único comando. Ele permite que você crie um contêiner como um serviço, ótimo para seu ambiente de desenvolvimento, teste e homologação.

Neste tutorial, eu irei guiá-lo passo a passo para usar o docker-compose para criar um ambiente de Pilha LEMP (LEMP = Linux - Nginx - MySQL - PHP). Vamos executar todos os componentes em diferentes contêineres Docker, configuraremos um contêiner Nginx, um contêiner PHP, um contêiner PHPMyAdmin e um contêiner MySQL/MariaDB.

Pré-requisitos

Servidor Ubuntu 16.04 -64bit
Privilégios de root

Passo 1 - Instalar Docker

Neste passo, iremos instalar o Docker. O Docker está disponível no repositório do Ubuntu, basta atualizar seu repositório e então instalá-lo.

Atualize o repositório do ubuntu e faça a atualização:

sudo apt-get update  
sudo apt-get upgrade

Instale a versão mais recente do Docker a partir do repositório do ubuntu.

sudo apt-get install -y docker.io

Inicie o docker e habilite-o para iniciar na inicialização:

systemctl start docker  
systemctl enable docker

Os serviços do Docker estão em execução.

Em seguida, você pode tentar usar o docker com o comando abaixo para testá-lo:

docker run hello-world

Olá mundo do docker.

Hello Docker

Passo 2 - Instalar Docker-Compose

No primeiro passo, já instalamos o Docker. Agora iremos instalar o docker-compose.

Precisamos do python-pip para a instalação do compose, instale python e python-pip com apt:

sudo apt-get install -y python python-pip

Quando a instalação estiver concluída, instale o docker-compose com o comando pip.

pip install docker-compose

Agora verifique a versão do docker-compose:

docker-compose --version

Docker-compose foi instalado.

Passo 3 - Criar e Configurar o Ambiente Docker

Neste passo, iremos construir nosso ambiente docker-compose. Usaremos um usuário não-root, então precisamos criar esse usuário agora.

Adicione um novo usuário chamado ‘ hakase ‘ (escolha seu próprio nome de usuário aqui se desejar):

useradd -m -s /bin/bash hakase  
passwd hakase

Em seguida, adicione o novo usuário ao grupo ‘ docker ‘ e reinicie o docker.

usermod -a -G docker hakase  
sudo systemctl restart docker

Agora o usuário ‘ hakase ‘ pode usar o docker sem sudo.

Em seguida, a partir do usuário root, faça login no usuário ‘hakase’ com su.

su - hakase

Crie um novo diretório para o ambiente compose.

mkdir lemp-compose/  
cd lemp-compose/

Este é nosso ambiente docker-compose, todos os arquivos que devem estar no contêiner Docker devem estar neste diretório. Quando estamos usando docker-compose, precisamos de um arquivo .yml chamado ‘ docker-compose.yml ‘.

No diretório ‘lemp-compose’, crie alguns novos diretórios e um arquivo docker-compose.yml:

touch docker-compose.yml  
mkdir -p {logs,nginx,public,db-data}

logs: Diretório para arquivos de log do Nginx.
nginx: contém a configuração do Nginx como host virtual etc.
public: diretório para arquivos web, index.html e arquivo de informações PHP.
db-data: diretório de dados do MariaDB.

Crie os arquivos de log error.log e access.log no diretório ‘ logs ‘.

touch logs/{error,access}.log

Crie um novo arquivo de configuração de host virtual nginx no diretório ‘ nginx ‘:

vim nginx/app.conf

Cole a configuração abaixo:

upstream php {  
        server phpfpm:9000;  
}  
   
server {  
   
        server_name 193.70.36.50;  
   
        error_log "/opt/bitnami/nginx/logs/myapp-error.log";  
        access_log  "/opt/bitnami/nginx/logs/myapp-access.log";  
   
        root /myapps;  
        index index.php index.html;  
   
        location / {  
   
                try_files $uri $uri/ /index.php?$args;  
        }  
   
        location ~ \.php$ {  
   
                include fastcgi.conf;  
                fastcgi_intercept_errors on;  
                fastcgi_pass php;  
        }  
   
        location ~* \.(js|css|png|jpg|jpeg|gif|ico)$ {  
                expires max;  
                log_not_found off;  
        }  
}

Salve o arquivo e saia do vim.

Crie um novo arquivo index.html e um arquivo de informações PHP no diretório ‘ public ‘.

echo 'LEMP Docker-Compose

hakase-labs' > public/index.html echo '' > public/info.php

Agora você pode ver o diretório do ambiente como mostrado abaixo:

tree

Docker compose project environment

Passo 4 - Configuração do arquivo docker-compose.yml

No passo anterior, criamos os diretórios e arquivos necessários para nossos contêineres. Neste passo, queremos editar o arquivo ‘ docker-compose.yml ‘. No arquivo docker-compose.yml, definiremos nossos serviços para a pilha LEMP, as imagens base para cada contêiner e os volumes do docker.

Faça login no usuário ‘ hakase ‘ e edite o arquivo docker-compose.yml com vim:

su - hakase  
cd lemp-compose/  
vim docker-compose.yml

- Definir serviços Nginx

Cole a configuração do nginx abaixo:

nginx:  
    image: 'bitnami/nginx'  
    ports:  
        - '80:80'  
    links:  
        - phpfpm  
    volumes:  
        - ./logs/access.log:/opt/bitnami/nginx/logs/myapp-access.log  
        - ./logs/error.log:/opt/bitnami/nginx/logs/myapp-error.log  
        - ./nginx/app.conf:/bitnami/nginx/conf/vhosts/app.conf  
        - ./public:/myapps

Nesta configuração, já definimos:

nginx: nome do serviço
image: estamos usando a imagem docker ‘ bitnami/nginx ‘
ports: expõe a porta do contêiner 80 para a porta do host 80
links: vincula o contêiner do serviço ‘ nginx ‘ ao contêiner ‘ phpfpm ‘
volumes: monta diretórios locais no contêiner. Monta o diretório de arquivos de log, monta a configuração do host virtual do Nginx e monta o diretório raiz da web.

- Definir serviços PHP-fpm

Cole a configuração abaixo do bloco Nginx:

phpfpm:  
    image: 'bitnami/php-fpm'  
    ports:  
        - '9000:9000'  
    volumes:  
        - ./public:/myapps

Definimos aqui:

phpfpm: define o nome do serviço.
image: define a imagem base para o serviço phpfpm com a imagem ‘ bitnami/php-fpm ‘.
ports: Estamos executando o PHP-fpm na porta TCP 9000 e expondo a porta 9000 para o host.
volumes: monta o diretório raiz da web ‘ public ‘ para ‘ myapps ‘ no contêiner.

- Definir o serviço MySQL

No terceiro bloco, cole a configuração abaixo para o contêiner de serviço MariaDB:

mysql:  
    image: 'mariadb'  
    ports:  
        - '3306:3306'  
    volumes:  
        - ./db-data:/var/lib/mysql  
    environment:  
        - MYSQL_ROOT_PASSWORD=hakase-labs123

Aqui você pode ver que estamos usando:

mysql: como o nome do serviço.
image: o contêiner é baseado nas imagens docker ‘ mariadb ‘.
ports: contêiner de serviço usando a porta 3306 para conexão MySQL, e expõe para o host na porta 3306.
volumes: diretório db-data mysql
environment: define a variável de ambiente ‘ MYSQL_ROOT_PASSWORD ‘ para a senha root do mysql nas imagens docker, executada ao construir o contêiner.

- Configuração dos serviços PHPMyAdmin

No último bloco, cole a configuração abaixo:

phpmyadmin:  
    image: 'phpmyadmin/phpmyadmin'  
    restart: always  
    ports:  
       - '8080:80'  
    links:  
        - mysql:mysql  
    environment:  
        MYSQL_USERNAME: root  
        MYSQL_ROOT_PASSWORD: hakase-labs123  
        PMA_HOST: mysql

Estamos usando uma imagem docker ‘phpmyadmin’, mapeando a porta do contêiner 80 para 8080 no host, vinculando o contêiner ao contêiner mariadb, definindo reinício sempre e definindo algumas variáveis de ambiente da imagem docker, incluindo definir ‘ PMA_HOST ‘.

Salve o arquivo e saia do vim.

Você pode ver um exemplo completo no github.

Passo 5 - Executar Docker-Compose

Agora estamos prontos para executar o docker-compose. Nota: quando você quiser executar o docker-compose, deve estar no diretório do projeto docker-compose e garantir que há o arquivo yml com a configuração do compose.

Execute o comando abaixo para iniciar a pilha LEMP:

docker-compose up -d

-d: executando como daemon ou em segundo plano

Você verá o resultado de que os novos contêineres foram criados, verifique com o comando abaixo:

docker-compose ps

running docker-compose

Agora temos quatro contêineres executando Nginx, PHP-fpm, MariaDB e PHPMyAdmin.

Passo 6 - Testando

Verificando as portas que estão sendo usadas pelo docker-proxy no host.

netstat -plntu

all docker port mapped to host

Podemos ver a porta 80 para o contêiner Nginx, a porta 3306 para o contêiner MariaDB, a porta 9000 para o contêiner php-fpm e a porta 8080 para o contêiner PHPMyAdmin.

Acesse a porta 80 pelo navegador web, e você verá nosso arquivo index.html.

http://serverip-address/

Certifique-se de que o PHP-fpm está em execução, acesse pelo navegador web.

http://serverip-address/info.php

php-fpm docker container is working

Acesse o contêiner MySQL no shell MySQL.

docker-compose exec mysql bash  
mysql -u root -p  
DIGITE A SENHA MYSQL: hakase-labs123

Agora crie um novo banco de dados:

create database hakase_db;  
exit

O contêiner shell mysql do MariaDB está acessível, e criamos um novo banco de dados ‘ hakase_db ‘.

access mysql shell docker container

Em seguida, acesse o PHPMyAdmin na porta 8080: http://serverip-address:8080/.

Você verá a página de login do PHPMyAdmin, basta digitar o nome de usuário ‘ root ‘ e a senha é ‘ hakase-labs123 ‘.

phpmyadmin docker container

Você será conectado automaticamente ao contêiner mysql que foi definido na variável de ambiente PMA_HOST.

Clique em ‘ Go ‘ e você verá o painel do phpmyadmin que está conectado ao contêiner ‘ mysql ‘.

phpmyadmin and mysql docker container is working

Sucesso! A Pilha LEMP está em execução sob uma configuração docker-compose, consistindo de quatro contêineres.