Neste artigo explicarei um pouco sobre o Docker e demonstrarei na prática como criar um ambiente de desenvolvimento LAMP, stack web que utiliza as tecnologias Apache, PHP e MySQL como base para rodar sua aplicação.
O Docker é uma plataforma que permite automatizar o processo de criação, implantação e execução de aplicativos dentro de contêineres. Ele basicamente simplifica o desenvolvimento e a implantação de aplicativos, fornecendo uma maneira consistente de empacotar o código, bibliotecas e outras dependências necessárias em um contêiner isolado.
Portanto quando você possui um aplicativo configurado em Docker, ele irá funcionar de maneira consistente, independentemente do ambiente em que está sendo executado.
O Docker Compose é uma ferramenta complementar ao Docker que permite definir e executar aplicativos multi-contêiner em um único ambiente e neste artigo iremos utilizar essa ferramenta.
Para você criar um ambiente em Docker utilizando o docker-compose você precisará somente de uma pasta com dois arquivos dentro dela apenas, sendo eles o Dockerfile e docker-compose.yml.
O Dockerfile ele descreve o ambiente de execução do contêiner, incluindo quaisquer dependências, configurações de ambiente e comandos necessários para configurar o ambiente do aplicativo dentro do contêiner e o docker-compose.yml é o arquivo de configuração usado pelo Docker Compose para definir, configurar e gerenciar aplicativos compostos por múltiplos contêineres.
O Docker disponibiliza um hub em nuvem que possível encontrar imagens oficiais e feitas por colaboradores dos aplicativos através desse link: https://hub.docker.com/
Vamos logo ao que interessa, vamos montar nossa stack LAMP utilizando o Docker e Docker-Compose!
Primeiramente você precisa fazer o download e a instalação do Docker em seu ambiente, portando acesse o site oficial e faça o procedimento necessário: https://www.docker.com/products/docker-desktop
Sendo assim, vamos criar uma pasta com o nome docker-lamp e dentro dela criaremos os arquivos Dockerfile e docker-compose.yml inicialmente.
É possível configurar essa stack de diversas maneiras utilizando as imagens e configurando o arquivo docker-compose.yml, mas eu particularmente gosto de de configurar dois containers distintos: sendo o primeiro o ambiente Linux já com o Apache e o PHP configurado com todas as dependências necessárias diretamente na execução do Dockerfile e o segundo é o banco de dados em MySQL através da imagem oficial configurado no docker-compose.yml.
Como bônus também irei criar um terceiro container com o phpMyAdmin utilizando sua imagem oficial que tem a função de gerenciador do banco de dados com uma interface gráfica. Mas ele é completamente desnecessário.
No arquivo Dockerfile simplesmente utilizaremos bash como linguagem, portanto vamos configura-lo da seguinte maneira:
# Utilizaremos Ubuntu como SO
FROM ubuntu:22.04
ARG DEBIAN_FRONTEND=noninteractive
# Update do linux e instalação de dependências
RUN apt-get update && apt-get install -y
RUN apt-get install software-properties-common -y
RUN add-apt-repository ppa:ondrej/php
# Instalação do Apache, PHP, plugins do PHP e softwares necessários
RUN apt-get install -y build-essential \
nano \
unzip \
curl \
locales \
apache2 \
php8.1 \
php8.1-common \
php8.1-mysql \
php8.1-xml \
php8.1-xmlrpc \
php8.1-curl \
php8.1-gd \
php8.1-imagick \
php8.1-cli \
php8.1-dev \
php8.1-imap \
php8.1-mbstring \
php8.1-opcache \
php8.1-soap \
php8.1-zip \
php8.1-intl \
php8.1-bcmath \
php8.1-pgsql \
php8.1-pspell \
libapache2-mod-php8.1 \
&& apt-get clean
RUN locale-gen pt_BR.UTF-8
# Instala o Composer para o PHP
RUN cd /usr/local/lib/ && curl -sS https://getcomposer.org/installer | php && mv composer.phar /usr/local/bin/composer
# Instala o CA Certificates para futura configuração SSL
RUN apt-get install --reinstall ca-certificates -y
# Cria a pasta src, que é a pasta onde ficará sua aplicação
ADD src/ /var/www/html/src
# Seta as permissões da pasta src
RUN chown $USER:www-data -R /var/www/html/src
RUN chmod u=rwX,g=srX,o=rX -R /var/www/html/src
RUN find /var/www/html/src -type d -exec chmod g=rwxs "{}" \;
RUN find /var/www/html/src -type f -exec chmod g=rws "{}" \;
# Ativa Apache mod_rewrite
RUN a2enmod rewrite
RUN a2enmod actions
# Altera AllowOverride de None para All
RUN sed -i '170,174 s/AllowOverride None/AllowOverride All/g' /etc/apache2/apache2.conf
# Inicia o Apache
RUN service apache2 restart
# Expõe as portas necessárias
EXPOSE 80 8080 3306
# Roda o apache fulltime
ENTRYPOINT ["apache2ctl", "-D", "FOREGROUND"]
Agora vamos configurar o arquivo docker-compose.yml para rodar o Dockerfile e adicionar a imagem do banco de dados para rodar um segundo container MySQL e do phpMyAdmin para o rodar o terceiro, vamos lá:
# Configura a versão do compose
version: '3.9'
# Em services definiremos nossos containers
services:
# App é nosso primeiro container que contém o Apache e o PHP confiugrado no Dockerfile
app:
container_name: docker-lamp
build: .
# Porta exposta para o Apache
ports:
- "80:80"
# Facilitando as configurações os volumes são os alias de pastas e arquvivos do Apache e PHP para pasta do docker-compose
volumes:
- ./src:/var/www/html/src
- ./config/php.ini:/etc/php/8.1/apache2/php.ini
- ./config/000-default.conf:/etc/apache2/sites-available/000-default.conf
- ./config/apache2.conf:/etc/apache2/apache2.conf
- ./logs/apache2:/var/log/apache2
# Configuração do uso de recursos da virtualização
deploy:
resources:
limits:
cpus: '2'
memory: 12G
# mysql é nosso segundo container que contém a imagem oficial do Mysql
mysql:
# Imagem do MySQL do Docker Hub
image: mysql:latest
container_name: mysql
# Configurações de acesso e db do mysql
environment:
MYSQL_ROOT_PASSWORD: 'senha-root'
MYSQL_DATABASE: banco-de-dados
MYSQL_USER: user
MYSQL_PASSWORD: 'user-senha'
restart: always
command: --default-authentication-plugin=mysql_native_password
# Porta exposta para o MySQL
ports:
- "3306:3306"
# Facilitando as configurações os volumes são os alias de pastas e arquvivos do MySQL para pasta do docker-compose
volumes:
- ./config/my.cnf:/etc/mysql/conf.d/my.cnf
- ./database:/var/lib/mysql
- ./logs/mysql:/var/log/mysql
# Configuração do uso de recursos da virtualização
deploy:
resources:
limits:
cpus: '2'
memory: 12G
# phpmyadmin é nosso terceiro container que contém a imagem oficial do phpmyadmin
phpmyadmin:
# Imagem do phpMyAdmin do Docker Hub
image: phpmyadmin:latest
container_name: phpmyadmin
# Configurações de link do banco de dados com o phpMyAdmin
links:
- mysql
environment:
PMA_HOST: mysql
PMA_PORT: 3306
PMA_ARBITRARY: 1
UPLOAD_LIMIT: 300M
restart: always
# Porta exposta para o uso phpMyAdmin
ports:
- 8080:80
Vendo os códigos podemos observar que de acordo com as nossas configurações no Dockerfile e docker-compose-yml será necessário criar mais algumas pastas dentro da nossa docker-lamp para finalizar nossa configuração, a estrutura da pasta ficará assim:
De qualquer maneira no final desse artigo vou disponibilizar o repositório desse projeto no GitHub com todos os arquivos.
Pronto! Toda a configuração do nosso ambiente em Docker está devidamente aplicada, agora nós devemos apenas dar um build (complilar) na nossa pasta do docker-lamp e após isso dar um up (start) em nossos containers para ver nossa aplicação rodando.
Para isso basta acessar a nossa pasta docker-lamp abrir seu terminal e rodar os seguintes comandos:
docker-compose build
Com isso ele irá compilar nossos nosso ambiente em docker-compose, esse processo pode demorar alguns minutos, após isso basta rodar o seguinte comando:
docker-compose up -d
Esse comando irá criar os containers e dar start no ambiente colocando nossa aplicação online, a variável -d é para rodar em segundo plano.
Agora basta você colocar sua aplicação na pasta src e acessa-la via web.
Repositório no GitHub: https://github.com/matsesso/docker-lamp
É isso aí! Espero que esse artigo contribua a você.
Top comments (2)
Muito bom o teu tutorial... mas tu te ligou que o ultimo comando está e**ado ?
Abs
Corrigi, muito obrigado!