Implementați o aplicație PHP folosind Docker-compose

• Configurarea mediului nostru de lucru
• Configurarea containerului PHP
• Configurarea containerului Nginx
• Configurarea containerului MySQL
• Construirea aplicației noastre
• Concluzie

Aplicațiile PHP sunt de obicei compuse dintr-un server web, un sistem relațional de baze de date și însuși interpretul limbii. În acest tutorial vom folosi un stack complet de aplicații PHP folosind docker. Acesta este un tutorial aprofundat în care urmează să construim și să orchestrăm containere pentru Nginx (webserver), MySQL (sistemul de baze de date) și PHP.

De dragul acestui tutorial, vom scrie o aplicație simplă care citește o listă de orașe dintr-o bază de date și o va afișa pe o pagină web, astfel vom demonstra o aplicație PHP de bază, dar funcțională.

Acest ghid presupune că aveți Docker-CE deja instalat și cel puțin o cunoștință de lucru minimă despre docker. Pentru această problemă, puteți consulta următoarele instrucțiuni:

• Instalarea Docker CE pe Ubuntu 16.04
• Instalarea Docker CE pe CentOS 7
• Cum să utilizați Docker: Crearea primului dvs. container Docker

Configurarea mediului nostru de lucru

O aplicație bazată pe docker viață reală va fi de obicei compusă din mai multe containere. Gestionarea lor manuală poate deveni cu ușurință destul de dezordonată și greoaie. Acolo intră în joc docker-compose. Vă ajută să gestionați un număr de containere printr-un yamlfișier simplu de configurare.

Instalați docker-compose.

curl -L https://github.com/docker/compose/releases/download/1.19.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

Creați un folder care să conțină toate fișierele necesare din acest exemplu și apoi cdîn el. De acum încolo, acesta este directorul nostru de lucru și fiecare comandă va fi executată în acest folder și fiecare cale va fi trimisă în raport cu acesta. Acest folder poate fi referit ulterior WORKING_DIR.

mkdir ~/docker
cd ~/docker

Acum creați alte trei dosare.

mkdir php nginx app

phpDosarul este în cazul în care vom construi imaginea noastră PHP, nginxdosarul va organiza fișierele necesare pentru imaginea noastră personalizată Nginx și appdosarul este în cazul în care vom pune codul sursă și configurația aplicației noastre de probă.

Configurarea containerului PHP

În acest exemplu, vom folosi php-fpmpentru a ne conecta la serverul web Nginx. Vom folosi imaginea de bază oficială PHP. Cu toate acestea, trebuie să instalăm și să activăm unele extensii pentru a putea accesa baza de date. În interiorul phpfolderului creați un fișier numit Dockerfileși puneți în el următorul conținut.

FROM php:7.1-fpm-alpine3.4
RUN apk update --no-cache \
    && apk add --no-cache $PHPIZE_DEPS \
    && apk add --no-cache mysql-dev \
    && docker-php-ext-install pdo pdo_mysql

Rețineți că folosim versiunea alpină a imaginii oficiale PHP. Alpine este o distribuție foarte mică, orientată către containere, oferind urme mult mai mici. De asemenea, rețineți utilizarea comenzii docker-php-ext-install, imaginea PHP oficială oferă această comandă pentru a ușura procesul de instalare și configurare a extensiilor PHP.

Acum, haideți să construim această imagine Docker publicând următoarele (în interiorul nostru WORKING_DIR):

docker build -t vultr-php php/

docker-compose.ymlfişierul

După cum am menționat deja, docker-composevă permite să gestionați un număr de containere printr-un simplu fișier de configurare. Acest fișier de configurare este de obicei numit docker-compose.yml. Creați acest fișier în appfolderul.

touch app/docker-compose.yml

Acum introduceți următorul conținut în acest fișier.

version: '2'
services:
  php:
    image: vultr-php
    volumes:
      - ./:/app
    working_dir: /app

Vom explica această sintaxă. În primul rând, notează prima linie.

version: '2'

Aceasta specifică versiunea docker-compose.ymlfișierului de configurare utilizat. Următoarea linie specifică serviciile sau, cu alte cuvinte, containerele care urmează să fie aprovizionate.

services:
  php:
    image: vultr-php
    volumes:
      - ./:/app
    working_dir: /app

Rețineți că fiecare serviciu are o cheie specifică în interiorul servicesblocului. Numele specificat aici va fi folosit pentru a face referire la acest container specific ulterior. Rețineți, de asemenea, că în interiorul phpconfigurației, definim imaginea folosită pentru a rula containerul (aceasta este imaginea pe care am construit-o anterior). De asemenea, definim o mapare a volumului.

volumes:
  - ./:/app

Acest lucru indică docker-composesă mapăm directorul curent ( ./) cu /appdirectorul din interiorul containerului. Ultima linie stabilește /appfolderul din interiorul containerului ca director de lucru, ceea ce înseamnă că acesta este folderul din care sunt executate în mod implicit toate comenzile viitoare din interiorul unui container.

Acum putem orchestră containerele noastre.

cd ~/docker/app
docker-compose up -d

Puteți rula următoarea comandă pentru a vă asigura că a fost executat containerul PHP:

docker ps

Cum se execută comenzi în interiorul containerelor

Tot în interiorul appfolderului, putem rula orice comandă într-un container de serviciu definit cu ajutorul docker-composecomenzii.

docker-compose exec [service] [command]

Locul de [service]amplasare se referă la cheia serviciului. În cazul nostru, acesta a fost php. Să rulăm o comandă în interiorul containerului pentru a verifica versiunea PHP.

docker-compose exec php php -v

Veți vedea următoarea ieșire.

PHP 7.1.14 (cli) (built: Feb  7 2018 00:40:45) ( NTS )
Copyright (c) 1997-2018 The PHP Group
Zend Engine v3.1.0, Copyright (c) 1998-2018 Zend Technologies

Configurarea containerului Nginx

La fel ca containerul PHP, trebuie să creăm o imagine personalizată pentru webserver. Dar în acest caz, trebuie doar să oferim o configurație pentru a noastră virtual host. Asigurați-vă că vă aflați în interiorul nostru WORKING_DIRși creați un folder Dockerfileîn interior nginx:

cd ~/docker
touch nginx/Dockerfile

Acum introduceți următorul conținut în acest lucru Dockerfile:

FROM nginx:1.13.8-alpine
COPY ./default.conf /etc/nginx/conf.d/default.conf

Folosim imaginea Nginx implicită bazată pe Alpine. În acest fișier Docker pur și simplu copiem un fișier de configurare în configurarea aplicației noastre. Înainte de a construi această imagine, creați un fișier de configurare.

touch nginx/default.conf

Acum populează-l cu acest conținut.

server {
    listen 80 default_server;
    listen [::]:80 default_server ipv6only=on;

    root /app;
    index index.php;

    #server_name server_domain_or_IP;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        try_files $uri /index.php =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass php:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
}

Rețineți că la fastcgi_pass php:9000linia facem referire la containerul PHP după numele acestuia din serviceblocul docker-compose.ymlfișierului de configurare. docker-composeCreează intern o rețea și atribuie numele serviciului ca nume de gazdă fiecăruia dintre serviciile definite. Acum putem construi imaginea Nginx.

docker build -t vultr-nginx nginx/

actualizarea docker-compose.yml

Acum actualizați app/docker-compose.ymlfișierul.

version: '2'
services:
  php:
    image: vultr-php
    volumes:
      - ./:/app
    working_dir: /app
  web:
    image: vultr-nginx
    volumes:
      - ./:/app
    depends_on:
      - php
    ports:
      - 80:80

Am adăugat doar un nou serviciu. Configurația este aproape aceeași, cu excepția următoarelor.

depends_on:
  - php
ports:
  - 80:80

Odată ce containerul Nginx are nevoie de serviciul PHP pentru a fi inițializat complet, forțăm această cerință în depends_onopțiune. portsCheie de configurare hărți un port gazdă la un port container, aici harta portul 80în gazdă la portul 80în container.

Acum creați un fișier numit index.phpîn interiorul appfolderului și puneți în el următoarele.

<?php phpinfo();

Asigurați-vă că portul 80este accesibil prin firewall și executați următoarele.

cd ~/docker/app
docker-compose up -d

Încă o dată, verificați de două ori dacă serviciul este pe deplin.

docker ps

Deschideți un browser și accesați [vultr-instance-ip]. Puteți afla adresa IP a instanței dvs. Vultr rulând următoarele.

hostname -I

Veți vedea pagina de informații PHP.

Configurarea containerului MySQL

Imaginea oficială MySQL vă permite să configurați containerul prin variabile simple de mediu. Aceasta se poate face cu o environmentopțiune din definiția blocului de servicii. Actualizați ~/docker/app/docker-compose.ymlfișierul la următoarele.

version: '2'
services:
  php:
    image: vultr-php
    volumes:
      - ./:/app
    working_dir: /app
  web:
    image: vultr-nginx
    volumes:
      - ./:/app
    depends_on:
      - php
    ports:
      - 80:80
  mysql:
    image: mysql:5.7.21
    volumes:
      - ./:/app
      - dbdata:/var/lib/mysql
    environment:
      - MYSQL_DATABASE=world
      - MYSQL_ROOT_PASSWORD=root
    working_dir: /app
volumes:
  dbdata:

Acum am definit un nou serviciu pentru baza de date. Observați linia dbdata:/var/lib/mysql. Aceasta montează calea de pe container /var/lib/mysqlla un volum persistent gestionat de Docker, în acest fel datele bazei de date persistă după eliminarea containerului. Acest volum trebuie definit într-un bloc de nivel superior așa cum puteți vedea în finalul fișierului.

Înainte de a orchestra noua noastră configurație, haideți să descărcăm o bază de date MySQL. Documentația oficială MySQL furnizează câteva exemple de baze de date. Vom folosi bine-cunoscuta bază de date mondială. Această bază de date oferă o listă de țări și orașe. Pentru a descărca acest eșantion, executați următoarele în folderul aplicației noastre.

curl -L http://downloads.mysql.com/docs/world.sql.gz -o world.sql.gz
gunzip world.sql.gz

Acum permiteți să ne orchestrăm containerele noastre.

docker-compose up -d

După cum ați observat deja, docker-compose upcomanda pornește doar containerele care nu sunt deja pornite. Verifică diferențele dintre docker-compose.ymlfișierul dvs. și configurația curentă a containerelor rulante.

Încă o dată, verificați dacă a fost pornit containerul MySQL.

docker ps

Acum populează baza de date mondială.

docker-compose exec -T mysql mysql -uroot -proot world < world.sql

Puteți verifica dacă baza de date a fost completată selectând date direct din baza de date. Mai întâi accesați promptul MySQL în interiorul containerului.

docker-compose exec mysql mysql -uroot -proot world

În promptul MySQL, executați următoarele.

select * from city limit 10;

Veți vedea o listă de orașe. Acum, renunțați la promptul MySQL.

mysql> exit

Construirea aplicației noastre

Acum că toate recipientele necesare funcționează, ne putem concentra asupra aplicației noastre de probă. Actualizați app/index.phpfișierul la următoarele.

<?php

$pdo = new PDO('mysql:host=mysql;dbname=world;charset=utf8', 'root', 'root');

$stmt = $pdo->prepare("
    select city.Name, city.District, country.Name as Country, city.Population
    from city
    left join country on city.CountryCode = country.Code
    order by Population desc
    limit 10
");
$stmt->execute();
$cities = $stmt->fetchAll(PDO::FETCH_ASSOC);

?>

<!doctype html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Vultr Rocks!</title>
</head>
<body>
    <h2>Most Populous Cities In The World</h2>
    <table>
    <thead>
        <tr>
            <th>Name</th>
            <th>Country</th>
            <th>District</th>
            <th>Population</th>
        </tr>
    </thead>
    <tbody>
        <?php foreach($cities as $city): ?>
            <tr>
                <td><?=$city['Name']?></td>
                <td><?=$city['Country']?></td>
                <td><?=$city['District']?></td>
                <td><?=number_format($city['Population'], 0)?></td>
            </tr>
        <?php endforeach ?>
    </tbody>
    </table>
</body>
</html>

Dacă accesați [vultr-instance-ip]într-un browser web, veți vedea o listă cu cele mai populate orașe din lume. Felicitări, ați implementat o aplicație PHP care funcționează complet folosind docker.

Concluzie

În acest tutorial, am demonstrat pas cu pas modul de configurare a unei aplicații PHP care funcționează complet. Am creat imagini personalizate pentru PHP și Nginx, și am configurat documentele pentru documente pentru a orchestră containerele noastre. În ciuda faptului că este foarte de bază și simplă, această configurare reflectă un scenariu din viața reală.

În acest ghid, am construit și etichetat imaginile noastre la nivel local. Pentru o configurare mai flexibilă, puteți împinge aceste imagini într-un registru de docker . Puteți apăsa în registrul oficial de docker sau chiar configurați propriul registru de docker. În orice caz, acest lucru vă va permite să vă construiți imaginile pe o gazdă și să le utilizați pe alta.

Pentru o utilizare mai detaliată a acesteia docker-compose, trebuie să vă referiți la documentația oficială .

În funcție de cerințele aplicației și de cadrul PHP pe care îl utilizați, poate doriți să adăugați mai multe extensii. Acest lucru se poate realiza cu ușurință prin modificarea Dockerfileutilizată pentru a construi imaginea PHP personalizată. Cu toate acestea, unele extensii au nevoie de dependențe suplimentare pentru a fi instalate în container. Ar trebui să vă referiți la lista de extensii din documentația oficială PHP pentru a examina cerințele de bază ale fiecărei extensii.