Ir para o conteúdo1
Fechar menu lateral
Logo da Universidade Federal de Juiz de Fora

Professor Rodrigo Alves Dias

PHP Websites usando Docker Containers com PHP Apache e MySQL

Seguindo o tutorial postado no Link: https://www.section.io/engineering-education/dockerized-php-apache-and-mysql-container-development-environment/

 

Os arquivos do projeto final estão disponiveis em meu canal do Github:

https://github.com/diasrodri/dockerphp

 

Este guia mostrará como podemos usar o ambiente de desenvolvimento Docker para:

  • Configure e execute uma instância local do servidor PHP Apache.
  • Sirva um site dinâmico baseado em PHP.
  • Configure um banco de dados MySQL para executar scripts SQL, buscar registros e imprimi-los em um site baseado em PHP.
  • Usaremos as imagens do hub do Docker para configurar um ambiente de desenvolvimento PHP em contêiner.

 

Pré-requisitos

 

  1. Certifique-se de que os aplicativos do Docker estejam instalados em seu computador. Link1 ,  Link2
  2. Conhecimento básico de consultas PHP e SQL.
  3. Compreensão fundamental de como criar e executar imagens de hub do Docker a partir de um arquivo do Docker.
  4. Entenda como os contêineres funcionam.
  5. Conhecimento básico sobre como executar comandos Docker e docker-compose.

 

 

Configurando e testando se o Docker está em execução
Depois de baixar e instalar o demônio do Docker, abra o mecanismo do Docker e verifique se o mecanismo está funcionando.

Abra uma linha de comando e execute o seguinte comando para verificar se o Docker está instalado corretamente em seu computador.

 

docker version

Isso registrará os resultados quase semelhantes a esses registros de linha de comando.

 

Colocando o arquivo YML docker-compose
O Docker-compose permite definir os parâmetros das imagens necessárias que você deseja executar em seu aplicativo. No nosso caso, usaremos imagens oficiais do hub Docker, como PHP Apache e MySQL. Escreveremos seus parâmetros em um arquivo .yml. Um .yaml também funcionará.

Vá em frente e crie uma pasta de projeto e crie um arquivo .yml dentro dessa pasta.

Por exemplo, docker-compose.yml.

Para definir um docker-compose, você precisa primeiro selecionar a versão do Docker que deseja usar, os serviços que deseja fornecer e os contêineres que deseja executar.

version: '3.8'
services:
  php-apache-environment:
    container_name:

 

Configurar e executar uma instância local do servidor PHP Apache
Para configurar um contêiner PHP Apache, você precisa especificar os seguintes ambientes,

O nome do contêiner – este é apenas um nome aleatório que você gostaria de nomear seu contêiner PHP.
Por exemplo container_name: php-apache.

A imagem do contêiner – esta é a imagem oficial do PHP, a versão do PHP Apache que você deseja usar. Nesse caso, estamos extraindo a imagem: php:8.0-apache do hub do Docker.

O volume – isso configurará seu diretório src de trabalho atual para seus arquivos de código/fonte. Se você fosse executar um script PHP, esse arquivo teria que estar nesse diretório.

Tal como:

volumes:
  - ./php/src:/var/www/html/

 

  • The port numbers. This defines the ports where the script will run from. It will set up an Apache server port mapping to the port on your local computer.

For example:

 

ports:
 - 8000:80

 

 

Isso significa que estamos configurando um servidor Apache para expor a porta 80. A porta 8000 acessa os scripts PHP e os executa em um navegador a partir de contêineres Docker.

É assim que seu docker-compose.yml deve se parecer.

 

 

version: '3.8'
services:
  php-apache-environment:
    container_name: php-apache
    image: php:8.0-apache
    volumes:
      - ./php/src:/var/www/html/
    ports:
      - 8000:80

 

Vamos testar.

Crie uma pasta dockerphp e dentro da pasta digite 

 
vim docker-compose.yml

 

Dentro do arquivo cole o texto acima e execute o comando,

 

docker-compose up

Isso vai extrair todas as informações, baixar o servidor Apache, criar a imagem e executar o contêiner.

Para instalar o docker-desktop veja o link.

 

Se você abrir o docker-desktop, o contêiner deverá estar funcionando.

Contêiner do mecanismo Docker em execução

 

Para garantir que o contêiner esteja configurado para executar os scripts PHP, abra sua postagem de host local definida no navegador, ou seja, 

http://localhost:8000/

 

 

 

 

 

 

 

Isso mostra que o contêiner está configurado para executar algum código baseado em PHP.

 

Servir um site dinâmico baseado em PHP

 

Vamos agora executar algum código PHP e obter a saída no navegador. Você executará os scripts do diretório que definiu nos volumes do seu arquivo docker-compose.

Neste caso, estamos usando ./php/src.

Vá para o diretório do seu projeto ➙ ./php/src, crie um arquivo index.php e comece a escrever seus scripts PHP.

 

 

 

 

 

 

 

 

Um script index.php simples.

 

<?php
echo "Hello there, this is a PHP Apache container";
?>

 

 

Atualize em seu navegador (http://localhost:8000/) e os resultados deste simples site da unidade PHP devem estar visíveis.

 

 

 

 

 

 

 

 

Parabéns! Agora você tem um site PHP em contêiner.

 

Configurar um contêiner de banco de dados MySQL

 

 

Você provavelmente gostaria de configurar um banco de dados para interagir com seu site. Criaremos outro serviço para fornecer suporte ao MySQL dentro do contêiner PHP.

Vamos adicionar o serviço MySQL ao arquivo docker-compose.yml. Para configurar o MySQL, precisamos customizar algum ambiente, como:

Autenticação de senha. Para usar e acessar um servidor MySQL, você precisa definir ambientes de autenticação que permitirão acessar o servidor MySQL definido e seus serviços, como um banco de dados.

Usaremos

MYSQL_USER: MYSQL_USER e

MYSQL_PASSWORD: MYSQL_PASSWORD

para conectar ao MySQL e acessar o

MYSQL_DATABASE: MYSQL_DATABASE.

Uma política de reinicialização restart: always: Isso reinicia o serviço sempre que qualquer configuração definida é alterada.

db:
    container_name: db
    image: mysql
    restart: always
    environment:
        MYSQL_ROOT_PASSWORD: MYSQL_ROOT_PASSWORD
        MYSQL_DATABASE: MY_DATABASE
        MYSQL_USER: MYSQL_USER
        MYSQL_PASSWORD: MYSQL_PASSWORD
    ports:
        - "9906:3306"

 

Precisamos adicionar algumas ferramentas de suporte ao MySQL dentro do container PHP para que os dois serviços (db e php-apache) funcionem corretamente. Esta ferramenta inclui mysqli.

Dentro do diretório do seu projeto, vá para a pasta /php, crie um arquivo Docker, nomeie-o Dockerfile e adicione as seguintes configurações do PHP.

 

FROM php:8.0-apache
RUN docker-php-ext-install mysqli && docker-php-ext-enable mysqli
RUN apt-get update && apt-get upgrade -y

 

Aqui criamos uma imagem PHP Apache personalizada e um ambiente que instalará o mysqli, uma extensão PHP que conectará o PHP Apache ao servidor MySQL.

Agora precisamos construir esta imagem personalizada dentro do serviço php-apache no arquivo docker-compose.yml. O PHP Apache também depende do serviço db para se conectar ao MySQL. Precisamos configurá-lo especificando um depende_on: ambiente.

É assim que seu arquivo docker-compose.yml deve ficar.

 

 

 

version: '3.8'
services:
    php-apache-environment:
        container_name: php-apache
        build:
            context: ./php
            dockerfile: Dockerfile
        depends_on:
            - db
        volumes:
            - ./php/src:/var/www/html/
        ports:
            - 8000:80
    db:
        container_name: db
        image: mysql
        restart: always
        environment:
            MYSQL_ROOT_PASSWORD: MYSQL_ROOT_PASSWORD
            MYSQL_DATABASE: MYSQL_DATABASE
            MYSQL_USER: MYSQL_USER
            MYSQL_PASSWORD: MYSQL_PASSWORD
        ports:
            - "9906:3306"

 

Execute docker-compose up para extrair e configurar o ambiente MySQL. O MySQL será adicionado ao contêiner.

Captura de tela 2023-01-18 222222

 

 

 

 

 

 

 

 

Executar consulta SQL usando scripts PHP

 

Vamos testar se o container está funcionando conforme o esperado. Vá para o arquivo index.php e o seguinte código de conexão PHP MySQL.

 

<?php
//These are the defined authentication environment in the db service

// The MySQL service named in the docker-compose.yml.
$host = 'db';

// Database use name
$user = 'MYSQL_USER';

//database user password
$pass = 'MYSQL_PASSWORD';

// check the MySQL connection status
$conn = new mysqli($host, $user, $pass);
if ($conn->connect_error) {
    die("Connection failed: " . $conn->connect_error);
} else {
    echo "Connected to MySQL server successfully!";
}
?>

Salve o arquivo e atualize seu endereço da web http://localhost:8000/.

 

Estrondo. Aí está. Os ambientes PHP Apache e MySQL agora estão configurados e você pode começar a desenvolver seu aplicativo baseado em PHP e se comunicar com o servidor MySQL.

 

Configurando o PHPMyAdmin

 

A conexão MySQL agora está correta. Vamos ver como podemos buscar alguns dados de um banco de dados MySQL e exibi-los em uma página da Web usando scripts PHP.

Suponha que seu aplicativo interaja com um banco de dados; você provavelmente gostaria de uma interface para interagir com seus dados. Adicionaremos serviços PHPMyAdmin para nos fornecer uma interface para interagir com o banco de dados MySQL.

Vamos adicionar um serviço PHPMyAdmin conforme mostrado abaixo.

 

 

phpmyadmin:
    image: phpmyadmin/phpmyadmin
    ports:
        - '8080:80'
    restart: always
    environment:
        PMA_HOST: db
    depends_on:
        - db

 

Abra http://localhost:8080/ no navegador para acessar o PHPMyAdmin.

 

 

 

 

 

 

 

 

 

Para acessar o painel do Phpmyadmin, use o nome de usuário como root e a senha como MYSQL_ROOT_PASSWORD. A senha já foi definida nas variáveis de ambiente MySQL (MYSQL_ROOT_PASSWORD: MYSQL_ROOT_PASSWORD)

 

Buscar registros e imprimi-los em um site baseado em PHP

Crie uma tabela de banco de dados e preencha alguns registros. Selecione o banco de dados e execute a consulta a seguir.

drop table if exists `users`;
create table `users` (
    id int not null auto_increment,
    username text not null,
    password text not null,
    primary key (id)
);
insert into `users` (username, password) values
    ("admin","password"),
    ("Alice","this is my password"),
    ("Job","12345678");

 

 

 

 

 

 

 

Vá em frente e escreva uma consulta SQL selecionada com PHP.

 

<?php
//These are the defined authentication environment in the db service

// The MySQL service named in the docker-compose.yml.
$host = 'db';

// Database use name
$user = 'MYSQL_USER';

//database user password
$pass = 'MYSQL_PASSWORD';

// database name
$mydatabase = 'MYSQL_DATABASE';
// check the mysql connection status

$conn = new mysqli($host, $user, $pass, $mydatabase);

// select query
$sql = 'SELECT * FROM users';

if ($result = $conn->query($sql)) {
    while ($data = $result->fetch_object()) {
        $users[] = $data;
    }
}

foreach ($users as $user) {
    echo "<br>";
    echo $user->username . " " . $user->password;
    echo "<br>";
}
?>

 

Atualize http://localhost:8000/ para visualizar os resultados.

 

 

 

 

 

 

Usamos apenas a operação Read para demonstrar isso. Vá em frente e tente outras operações CRUD com o aplicativo PHP dockerizado.

 

Outra maneira de iniciar dados no banco de dados sem entrar no PHPmyAdmin é o seguinte.

Crie dentro da pasta php um pasta chamada db e entre na pasta db.

cd php && mkdir db && cd db

Dentro da pasta crie um arquivo com nome user.sql

vim user.sql

 

e cole o sequinte texto dentro do arquivo.

drop table if exists `users`;
create table `users` (
    id int not null auto_increment,
    username text not null,
    password text not null,
    primary key (id)
);
insert into `users` (username, password) values
    ("admin","password"),
    ("Alice","this is my password"),
    ("Job","12345678"),
    ("admin","password"),
    ("Alice","this is my password"),
    ("Job","12345678");

M0difique o arquivo Docker-compose.yml para,

 

version: '3.8'
services:
    php-apache-environment:
        container_name: php-apache
        build:
            context: ./php
            dockerfile: Dockerfile
        depends_on:
            - db
        volumes:
            - ./php/src:/var/www/html/
        ports:
            - 8000:80
    db:
        container_name: db
        image: mysql
        restart: always
        environment:
            MYSQL_ROOT_PASSWORD: MYSQL_ROOT_PASSWORD
            MYSQL_DATABASE: MYSQL_DATABASE
            MYSQL_USER: MYSQL_USER
            MYSQL_PASSWORD: MYSQL_PASSWORD
        ports:
            - "9906:3306"
        volumes:
            - ./php/db:/docker-entrypoint-initdb.d
    
    phpmyadmin:
         image: phpmyadmin/phpmyadmin
         ports:
            - '8080:80'
         restart: always
         environment:
            PMA_HOST: db
         depends_on:
            - db

 

 

Conclusão

Espero que este tutorial tenha ajudado você a configurar um ambiente de desenvolvimento PHP e MySQL usando contêineres Docker.

O Docker é uma tecnologia de contêiner inspiradora com benefícios fascinantes.

Se você ainda não começou a aprender Docker, confira está no hora de começar.