Como criar 容器包含 PHP、MySQL 和 NGINX utilizando 或 Docker Compose
Nesse 发布了一个子容器，包括 PHP 7.3、MySQL 5.7 和 Nginx utilizando，以及 Docker Compose 和子操作系统环境，包括格式、目标和 padronizada。
O que é Docker?
Docker 是 Go 的开源平台，是 Google 开发的语言程序，可以对环境隔离进行管理和管理，并投资于完整的系统操作，并且可以与虚拟化环境一起使用传统的。
使用 Docker 有何优势？
Docker 允许在容器中提供服务或内部环境，因此可以在安装 Docker 的情况下使用外部环境的端口。
可以降低环境或应用程序的部署速度，不需要调整环境参数以实现应用程序的相关功能，环境环境和应用程序的部署速度，可以通过配置来实现。复制量子韦泽斯奎瑟。
Mas eo Docker Compose？
Docker Compose 是一种使用 Docker Compose 的工具，可以在 Dockerfile 中使用 docker-compose，在 YAML 中使用“YAML Ain't Markup Language”（葡萄牙语，“YAML não é linguagem de”）。马卡桑”）。
步骤 1：在 Windows 和 Linux 上安装和配置
Em Windows：
想要了解 Docker 的相关信息，请输入 docker.com 的 ID 并获取授权：
https://hub.docker.com/editions/community/docker-ce-desktop-windows
打开 docker，然后完成安装过程，然后按照常用术语进行操作，自动安装并安装 Docker 程序，最后单击“Finish”。
这是因为“Docker”是 Windows 环境中的一个障碍，它是 Docker for Windows 执行的两个小团体的一部分。
很快，码头工人就开始使用计算机和容器来装载容器了。
Em Linux：
在 Linux 上安装 Docker com Docker Compose，然后在没有终端的情况下执行 seu Linux：
sudo apt install docker docker-compose -y
步骤 2：配置服务器 Web
最初的过程和定义有关项目的指示或指示，请不要在“项目”指示中指示 trabalho 和指示：
视窗：
Linux：
使用 docker-compose.yml 来配置我们的服务器网络，然后将其作为后续链接：
services:
web:
image: nginx:latest
container_name: nginx
restart: always
ports:
- "80:80"
- Linha 1:是一个服务名称，是一个服务，是一个网络服务。
- Linha 2：使用 vamos 的图像，因此，vamos 使用 Nginx 的图像来进行其他操作。
- Linha 3： Definimos um nome para nosso 容器，nesse caso，vamos chamá-lo de “nginx”。
- 第 4 条：由于 Docker 的重新政策是“不”，所以，在现代阿尔古玛中，没有重新定义容器，因此改变了“始终”的政策，而 Docker 重新定义容器是必要的。
- Linhas 5 和 6： Nessas duas linhas 被定义为使用自己的服务器网络的端口，首先是在没有容器的情况下使用的端口，并且是在没有容器的情况下使用服务器网络的端口。
定义配置后，就可以使用 Docker Compose 的主要容器，然后在项目目录中使用终端命令：
docker-compose up -d
Lembrando：没有 Linux，您需要使用 sudo no início。
如果执行此项目的命令，请执行以下操作，然后在没有终端的“Creating nginx…done”下执行后续操作。
容器的 Podemos ver os 是 estão rodando 和 portas utilizadas com 或comando pelos 相关容器 com 或 seguinte comando：
docker-compose ps
Lembrando：没有 Linux，您需要使用 sudo no início。
定义端口 80 为容器，该容器映射到 80 端口，可访问服务器网络，通过http://localhost进行导航并输入密码，然后访问服务器，并显示 Nginx 的服务。
在 web 上的服务程序 Rodando 上，vamos 映射到您的计算机上的面食，并为您的服务提供服务，并为您的服务提供配置，然后将 vamos 插入到 docker-compose.yml 前面的链接中：
volumes:
- ./www:/www
- ./site.conf:/etc/nginx/conf.d/site.conf
- Linha 1： Declaração de que vamos mapear rows nas linhas abaixo。
- Linha 2： Nessa linha 声明将面食放入容器中。
- Linha 3: Nessa linha declaramos que o arquivo site.conf vai ser passar a mapear o caminho /etc/nginx/conf.d/site.conf dentro do nosso 容器。
Agora no mesmo nível do docker-compose.yml, vamos criar um diretório chamado www.
Ainda no diretório do nosso projeto, Vamos criar or arquivo chamado site.conf que vai possuir toda a configuração do host docker.localhost de nosso servidor Nginx, nesse arquivo inclua as seguintes linhas:
server {
index index.html index.php;
server_name docker.localhost;
error_log /var/log/nginx/error.log;
access_log /var/log/nginx/access{% raw %}`.log;
root /www;
}
```
- **Linha 1:** Tag de abertura da configuração do servidor Nginx.
- **Linha 2:** Nessa linha definimos os arquivos iniciais de nosso host.
- **Linha 3:** Definimos qual host vai utilizar essa configuração, nesse exemplo vamos utilizar o host docker.localhost.
- **Linha 4:** Aqui definimos o caminho onde serão salvos os logs de erro.
- **Linha 5:** Aqui definimos o caminho onde serão salvos os logs de acesso ao host.
- **Linha 6:** Nessa linha definimos o diretório raiz do nosso host, nesse caso, definimos o diretório www que foi mapeado para o diretório www do diretório de nosso projeto.
**Lembrando:** Por padrão a imagem do Nginx já possui um default.conf que ira configurar o acesso para o endereço http://localhost, por isso não podemos criar uma nova conf para esse mesmo endereço, caso deseje substituir essa configuração padrão para subir a sua aplicação em http://localhost basta criar o arquivo chamado default.conf ao invés do site.conf e montar um volume apontando para /etc/nginx/conf.d/default.conf como feito com site.conf.
Precisamos agora acessar o diretório www, nesse diretório vamos criar uma página bem básica para testar se a configuração do servidor web está funcionando corretamente, para isso, basta criar um arquivo chamado index.html e incluir as seguintes linhas:
```HTML
<html>
<head>
<title>Ola</title>
</head>
<body>
<h2>Ola Docker!<h2>
</body>
</html>
```
Tudo pronto, agora vamos reiniciar o nosso container com os seguintes comandos:
**docker-compose down**
**docker-compose up -d**
**Lembrando:** No Linux é necessário rodar o comando com sudo no início.
**No Windows:**
Abra o Bloco de Notas como administrador, agora com Bloco de Notas aberto clique em Arquivo > Abrir, na sequência, vá até a seguinte pasta: C: > Windows > System32 > Drivers > etc. Ali, no lado do campo Nome, mude a opção Documentos de texto (*.txt) para Todos os arquivos (*.*), o arquivo hosts aparecerá, clique nele, com o arquivo aberto no Bloco de Notas vá até o final do arquivo e inclua a seguinte linha:
127.0.0.1 docker.localhost
Após basta salvar o arquivo indo em Arquivo > Salvar.
No Linux:
Abra o terminal do seu Linux e digite o comando abaixo:
**sudo nano /etc/hosts**
Com arquivo aberto em seu terminal, vá até o final do arquivo e inclua a seguinte linha:
127.0.0.1 docker.localhost
Após isso basta salvar a alteração teclando Ctrl + O e depois Enter, para sair da edição do arquivo pressione Ctrl + X.
Pronto, finalmente podemos testar o acesso ao endereço http://docker.localhost, caso tudo esteja correto, será apresentado um “Ola Docker!”.
**Passo 3: Configurando o PHP-FPM em nosso servidor Nginx**
Agora que nosso servidor web já está funcionando, vamos configurar o PHP-FPM e fazer a ligação com o serviço web, para isso, vamos abrir novamente o arquivo docker-compose.yml e incluir as seguintes linhas:
```YML
links:
- php
php:
image: php:7.3-fpm
container_name: php-fpm
volumes:
- ./www:/www
```
- **Linha 1 e 2:** Nessas linhas criamos um link do php para o serviço web tenha acesso a ele.
- **Linha 3:** Definimos o nome do nosso serviço.
- **Linha 4:** Nome da imagem e versão que iremos utilizar.
- **Linha 5:** Definimos o nome do nosso container.
- **Linha 6 e 7:** Mapeamos o diretório www de nosso projeto também no container do PHP-FPM para que o mesmo também tenha acesso aos arquivos.
Após incluir a configuração do PHP-FPM e linkar o serviço PHP no serviço web, vamos incluir as seguintes linhas no site.conf, dentro da tag server:
```
location ~ \.php$ {
try_files $uri =404;
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass php:9000;
fastcgi_index index.php;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_path_info;
}
```
Vamos agora acessar o diretório www e renomear a index.html para index.php e substituir seu conteúdo por:
```PHP
<?php
echo phpinfo();
```
Antes de testar vamos rodar os comandos abaixo para encerrar todos containers que estão rodando e subi-los novamente, incluindo o do serviço php.
**docker-compose down**
**docker-compose up –d**
**Lembrando:** No Linux é necessário rodar os comandos com sudo no início.
Pronto, finalmente podemos testar o acesso ao endereço http://docker.localhost.
Agora que temos o servidor rodando com PHP, vamos configurar o MySQL 5.7, para isso, vamos retornar ao arquivo docker-compose.yml e incluir as seguintes linhas no final do arquivo:
```YML
links:
- db
db:
image: mysql:5.7
container_name: mysql
ports:
- "3306:3306"
command: --default-authentication-plugin=mysql_native_password
restart: always
environment:
MYSQL_ROOT_PASSWORD: root
MYSQL_DATABASE: teste
```
- Linha 1 e 2: Nessas linhas criamos um link do serviço de Banco de Dados para que o PHP tenha acesso a ele.
- Linha 3: Aqui definimos o nome do nosso serviço.
- Linha 4: Nome da imagem e versão que vamos utilizar.
- Linha 5: Definimos o nome do nosso container.
- Linha 6 e 7: Nessas duas linhas definimos as portas que vão ser utilizadas pelo nosso servidor MySQL, primeiro a porta que queremos ouvir em nossa máquina e depois a porta que o servidor MySQL está ouvindo no container.
- Linha 8: Nessa linha definimos que vamos utilizar o método nativo de autenticação do MySQL.
- Linha 9: Definimos a política de restart do Docker para “Always” para que o Docker reinicie o container sempre que necessário.
- Linha 10: Nessa linha dizemos que abaixo vamos definir algumas variáveis de ambiente.
- Linha 11: Definimos a senha do root como “root”.
- Linha 12: Nessa linha definimos que vamos utilizar uma base chamada teste, quando subirmos o container a base em questão vai ser criada automaticamente.
Após isso, vamos rodar os comandos abaixo para encerrar todos containers e subi-los novamente:
**docker-compose down**
**docker-compose up –d**
**Lembrando:** No Linux é necessário rodar os comandos com sudo no início.
Para verificar se o servidor MySQL está rodando corretamente e possui a base “teste” criada, vamos acessar esse container via bash com o seguinte comando:
**docker-compose exec db bash**
**Lembrando:** No Linux é necessário rodar o comando com sudo no início.
Após rodar esse comando você está no bash do container onde o MySQL está rodando, agora vamos acessar o MySQL com usuário root e senha root que definimos no arquivo docker-compose.yml com o seguinte comando:
**mysql -u root –proot**
Após rodar esse comando você vai estar logado no MySQL com usuário root e pode ver as bases criadas, para isso basta executar o seguinte comando:
**show databases;**
Com isso, será mostrada todas as bases criadas, entre elas deve existir a base chamada teste.
Perfeito, agora temos o servidor Nginx rodando com PHP e o MySQL, já podemos criar um script em PHP para se conectar a base teste e verificar se está tudo funcionando corretamente.
Para testar a conexão, primeiro precisamos instalar a extensão PDO para MySQL no PHP pois essa não vem configurado por padrão, é possível definir a instalação dessa extensão no arquivo Dockerfile para que seja instalada já no primeiro build do serviço, como nesse post não iremos abordar o arquivo Dockerfile, vamos realizar essa instalação de forma manual com um comando, para isso vamos executar o seguinte comando no diretório de nosso projeto:
**docker exec -it php-fpm docker-php-ext-install pdo pdo_mysql**
**docker-compose restart**
**Lembrando:** No Linux é necessário rodar os comandos com sudo no início.
Agora que já temos o driver de conexão ao MySQL instalado e configurado no PHP, vamos criar um arquivo chamado db.php dentro do diretório www com o seguinte código:
```PHP
<?php
$host = "db";
$username = "root";
$password = "root";
$db = "teste";
try {
$conn = new PDO("mysql:host=$host;dbname=$db", $username,
$password);
$conn->setAttribute(PDO::ATTR_ERRMODE,
PDO::ERRMODE_EXCEPTION);
echo '<h2>Conectado com sucesso.<h2>';
} catch (PDOException $e) {
echo 'ERROR: ' . $e->getMessage();
}
?>
```
Por fim, podemos acessar http://docker.localhost/db.php para testar a conexão do PHP ao nosso servidor MySQL, caso tudo funcione como esperado, você vai ver a mensagem “Conectado com sucesso.” no seu navegador.
Agora você tem um ambiente que pode ser replicado facilmente para qualquer outra máquina que possua o Docker instalado, para isso basta apenas copiar o arquivo docker-compose.yml.
**Conclusão**
Há muito mais sobre o Docker Compose do que o que foi mostrado nesse post, mas acredito que isso deve ser suficiente para começar a utilizar e aproveitar toda facilidade que o Docker Compose proporciona para realizar o deploy dos seus ambientes de desenvolvimento, teste, produção, etc.
**Meus contatos:**
E-mail: nunesjr1993@gmail.com
Linkedin: https://www.linkedin.com/in/jrnunes1993/
**Endereço do repositório do projeto no Github:**
https://github.com/jrnunes1993/Docker
**Links interessantes para estudo e usados na construção deste post:**
https://docs.docker.com/
https://nginx.org/en/docs/
https://pt.wikipedia.org/wiki/YAML
https://pt.wikipedia.org/wiki/Docker_(software)