Nasaďte aplikáciu PHP pomocou Docker-compose

PHP aplikácie sa zvyčajne skladajú z webového servera, relačného databázového systému a samotného jazykového tlmočníka. V tomto návode budeme využívať celý zásobník PHP aplikácií pomocou dockeru. Toto je podrobný návod, v ktorom budeme zostavovať a organizovať kontajnery pre Nginx (webový server), MySQL (databázový systém) a PHP.

Pre tento tutoriál si napíšeme jednoduchú aplikáciu, ktorá načíta zoznam miest z databázy a zobrazí ho na webovej stránke, takto si ukážeme základnú, no fungujúcu PHP aplikáciu.

Táto príručka predpokladá, že už máte nainštalovaný Docker-CE a aspoň minimálne pracovné znalosti dockeru. V tomto prípade si môžete prečítať nasledujúce návody:

• Inštalácia Docker CE na Ubuntu 16.04
• Inštalácia Docker CE na CentOS 7
• Ako používať Docker: Vytvorenie prvého kontajnera Docker

Konfigurácia nášho pracovného prostredia

Aplikácia založená na dockeroch v reálnom živote bude zvyčajne pozostávať z niekoľkých kontajnerov. Manuálne spravovanie môže byť veľmi komplikované a ťažkopádne. Tu vstupuje do hry docker-compose. Pomáha vám spravovať množstvo kontajnerov prostredníctvom jednoduchého yamlkonfiguračného súboru.

Nainštalujte 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

Vytvorte priečinok, do ktorého budú uložené všetky potrebné súbory z tohto príkladu, a potom cddo neho. Odteraz je toto náš pracovný adresár a každý príkaz bude vykonaný v tomto priečinku a každá cesta bude k nemu odkazovaná. Tento priečinok môže byť neskôr označený ako WORKING_DIR.

mkdir ~/docker
cd ~/docker

Teraz vytvorte ďalšie tri priečinky.

mkdir php nginx app

phpZložka je miesto, kde budeme stavať náš zvyk PHP obraz sa nginxbude zložka mať k dispozícii potrebné súbory pre náš zvyk Nginx obrazu a appzložka je miesto, kde budeme dávať zdrojový kód a konfiguráciu našej ukážkové aplikácie.

Konfigurácia kontajnera PHP

V tomto príklade sa použijeme php-fpmna pripojenie k webovému serveru Nginx. Budeme používať oficiálny základný obrázok PHP. Musíme však tiež nainštalovať a povoliť niektoré rozšírenia, aby sme mali prístup k databáze. V phppriečinku vytvorte súbor s názvom Dockerfilea vložte doň nasledujúci obsah.

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

Všimnite si, že používame alpskú verziu oficiálneho obrazu PHP. Alpine je veľmi malá distribúcia zameraná na kontajnery tým, že poskytuje oveľa menšie stopy. Všimnite si tiež použitie príkazu docker-php-ext-install, oficiálny obrázok PHP poskytuje tento príkaz na uľahčenie procesu inštalácie a konfigurácie rozšírení PHP.

Teraz poďme vytvoriť tento obrázok Docker vydaním nasledujúceho (v našom WORKING_DIR):

docker build -t vultr-php php/

docker-compose.ymlsúbor

Ako už bolo spomenuté, docker-composeumožňuje vám spravovať množstvo kontajnerov prostredníctvom jednoduchého konfiguračného súboru. Tento konfiguračný súbor má zvyčajne názov docker-compose.yml. Vytvorte tento súbor v apppriečinku.

touch app/docker-compose.yml

Teraz do tohto súboru vložte nasledujúci obsah.

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

Vysvetlíme si túto syntax. Najprv si všimnite prvý riadok.

version: '2'

Toto určuje verziu použitého docker-compose.ymlkonfiguračného súboru. Ďalší riadok špecifikuje služby alebo inými slovami kontajnery, ktoré sa majú poskytovať.

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

Všimnite si, že každá služba má v servicesbloku špecifický kľúč . Tu zadaný názov sa neskôr použije na odkazovanie na tento konkrétny kontajner. Všimnite si tiež, že v rámci phpkonfigurácie definujeme obrázok použitý na spustenie kontajnera (toto je obrázok, ktorý sme vytvorili predtým). Definujeme tiež mapovanie objemu.

volumes:
  - ./:/app

Toto hovorí, docker-composeže je potrebné namapovať aktuálny adresár ( ./) na /appadresár v kontajneri. Posledný riadok nastavuje /apppriečinok v kontajneri ako pracovný adresár, čo znamená, že toto je priečinok, z ktorého sa štandardne vykonávajú všetky budúce príkazy v kontajneri.

Teraz môžeme organizovať naše kontajnery.

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

Môžete spustiť nasledujúci príkaz, aby ste sa uistili, že kontajner PHP bol spustený:

docker ps

Ako vykonávať príkazy v kontajneroch

Stále v apppriečinku môžeme pomocou príkazu spustiť ľubovoľný príkaz v definovanom servisnom kontajneri docker-compose.

docker-compose exec [service] [command]

[service]Zástupný odkazuje na kľúč služby. V našom prípade to bolo php. Spustite príkaz vo vnútri kontajnera na kontrolu našej verzie PHP.

docker-compose exec php php -v

Uvidíte nasledujúci výstup.

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

Konfigurácia kontajnera Nginx

Rovnako ako kontajner PHP, musíme vytvoriť vlastný obrázok pre webový server. V tomto prípade však musíme poskytnúť konfiguráciu pre náš virtual host. Uistite sa, že ste v našom WORKING_DIRa vytvorte si Dockerfilev nginxpriečinku:

cd ~/docker
touch nginx/Dockerfile

Teraz do toho vložte nasledujúci obsah Dockerfile:

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

Používame predvolený obrázok Nginx založený na Alpine. V tomto súbore Docker jednoducho skopírujeme konfiguračný súbor do nášho nastavenia aplikácie. Pred vytvorením tohto obrazu vytvorte konfiguračný súbor.

touch nginx/default.conf

Teraz ju naplňte týmto obsahom.

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;
    }
}

Všimnite si, že v fastcgi_pass php:9000riadku odkazujeme na kontajner PHP jeho názvom v servicebloku docker-compose.ymlkonfiguračného súboru. Interne docker-composevytvorí sieť a priradí názov služby ako názov hostiteľa každej z definovaných služieb. Teraz môžeme vytvoriť obraz Nginx.

docker build -t vultr-nginx nginx/

Aktualizuje sa docker-compose.yml

Teraz aktualizujte app/docker-compose.ymlsúbor.

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

Pridali sme len novú službu. Konfigurácia je takmer rovnaká, s výnimkou nasledujúcich.

depends_on:
  - php
ports:
  - 80:80

Once the Nginx container needs the PHP service to be fully initialized, we force this requirement in the depends_on option. The ports configuration key maps a host port to a container port, here we map the port 80 in the host to the port 80 in the container.

Now create a file called index.php inside the app folder and put the following in it.

<?php phpinfo();

Make sure the port 80 is accessible through your firewall and execute the following.

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

Once again, double check that the service is up.

docker ps

Open a browser and access [vultr-instance-ip]. You may find out your Vultr instance IP address by running the following.

hostname -I

You will see the PHP info page.

Configuring the MySQL container

The official MySQL image allows you to configure the container through simple environment variables. This can be done with an environment option inside the service block definition. Update the ~/docker/app/docker-compose.yml file to the following.

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:

Now we've defined a new service for the database. Notice the line dbdata:/var/lib/mysql. This mounts the path on the container /var/lib/mysql to a persistent volume managed by Docker, this way the database data persists after the container is removed. This volume needs to be defined in a top-level block as you can see in the end of the file.

Before orchestrating our new configuration, let's download a sample MySQL database. The official MySQL documentation provides some sample databases. We will be using the well-known world database. This database provides a listing of countries and cities. To download this sample, execute the following inside our app folder.

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

Now lets orchestrate our containers.

docker-compose up -d

As you may have already noticed, the docker-compose up command starts only the containers that are not already started. It checks for the differences between your docker-compose.yml file and the current configuration of running containers.

One more time, check that the MySQL container was started.

docker ps

Now populate the world database.

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

Výberom údajov priamo z databázy môžete overiť, či bola databáza naplnená. Najprv otvorte výzvu MySQL v kontajneri.

docker-compose exec mysql mysql -uroot -proot world

Vo výzve MySQL spustite nasledovné.

select * from city limit 10;

Zobrazí sa zoznam miest. Teraz ukončite výzvu MySQL.

mysql> exit

Vytváranie našej aplikácie

Teraz, keď sú všetky potrebné kontajnery pripravené a spustené, sa môžeme sústrediť na našu vzorovú aplikáciu. Aktualizujte app/index.phpsúbor na nasledujúci.

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

Ak pristúpite [vultr-instance-ip]vo webovom prehliadači, zobrazí sa vám zoznam najľudnatejších miest sveta. Gratulujeme, nasadili ste plne funkčnú aplikáciu PHP pomocou dockeru.

Záver

V tomto návode som krok za krokom ukázal, ako nakonfigurovať plne funkčnú PHP aplikáciu. Vytvorili sme vlastné obrázky pre PHP a Nginx a nakonfigurovali docker-compose na organizáciu našich kontajnerov. Napriek tomu, že je veľmi jednoduché a jednoduché, toto nastavenie odráža skutočný životný scenár.

V tejto príručke sme vytvorili a označili naše obrázky lokálne. Pre flexibilnejšie nastavenie môžete tieto obrázky vložiť do dokovacieho registra . Môžete tlačiť do oficiálneho registra dockerov alebo dokonca nastaviť svoj vlastný register dockerov. V každom prípade vám to umožní vytvárať obrázky na jednom hostiteľovi a používať ich na inom.

Podrobnejšie informácie o použití docker-composenájdete v oficiálnej dokumentácii .

V závislosti od požiadaviek vašej aplikácie a rámca PHP, ktorý používate, možno budete chcieť pridať ďalšie rozšírenia. To sa dá ľahko dosiahnuť úpravou súboru Dockerfilepoužitého na vytvorenie vlastného obrazu PHP. Niektoré rozšírenia však vyžadujú ďalšie závislosti, ktoré sa majú nainštalovať do kontajnera. Mali by ste si pozrieť zoznam rozšírení v oficiálnej dokumentácii PHP, aby ste si prečítali základné požiadavky každého rozšírenia.