(Docker) Criando um ambiente LAMP utilizando Docker Compose
Tags: docker, php, mysql, apache
Published: 2024-03-19 01:19:40

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 <u>e neste artigo iremos utilizar essa ferramenta.</u>

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:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/s3aajukmc14pu8ek4vt6.png)

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
```

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/c7x0p2lpjt5h0lj1npjc.png)

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-composer up -d
```

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wn5dkrkwsoka3b483xsc.png)

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ê.