Nasaďte aplikaci PHP pomocí Docker-compose

PHP aplikace jsou obvykle tvořeny webovým serverem, relačním databázovým systémem a samotným jazykovým interpretem. V tomto tutoriálu budeme využívat celý zásobník aplikací PHP pomocí dockeru. Toto je podrobný tutoriál, ve kterém budeme vytvářet a organizovat kontejnery pro Nginx (webový server), MySQL (databázový systém) a PHP.

Pro tento tutoriál si napíšeme jednoduchou aplikaci, která načte seznam měst z databáze a zobrazí jej na webové stránce, předvedeme si tak základní, ale fungující PHP aplikaci.

Tato příručka předpokládá, že máte již nainstalovaný Docker-CE a alespoň minimální pracovní znalosti dockeru. V tomto případě si můžete prohlédnout následující tutoriály:

• Instalace Docker CE na Ubuntu 16.04
• Instalace Docker CE na CentOS 7
• Jak používat Docker: Vytvoření prvního kontejneru Docker

Konfigurace našeho pracovního prostředí

Aplikace založená na dockeru v reálném životě se bude obvykle skládat z několika kontejnerů. Manuální správa se může snadno stát docela chaotický a těžkopádný. Zde přichází na řadu docker-compose. Pomáhá vám spravovat řadu kontejnerů prostřednictvím jednoduchého yamlkonfiguračního souboru.

Nainstalujte 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

Vytvořte složku pro uložení všech potřebných souborů z tohoto příkladu a poté cddo ní. Od nynějška je toto náš pracovní adresář a každý příkaz bude proveden v této složce a každá cesta bude vzhledem k ní odkazována. Tato složka může být později označena jako WORKING_DIR.

mkdir ~/docker
cd ~/docker

Nyní vytvořte další tři složky.

mkdir php nginx app

phpSložka je místo, kde budeme stavět náš zvyk PHP obraz se nginxbude složka mít k dispozici potřebné soubory pro náš zvyk Nginx obrazu a appsložka je místo, kde budeme dávat zdrojový kód a konfiguraci naší ukázkové aplikace.

Konfigurace kontejneru PHP

V tomto příkladu použijeme php-fpmpřipojení k webovému serveru Nginx. Budeme používat oficiální základní obrázek PHP. Musíme však také nainstalovat a povolit některá rozšíření, abychom měli přístup k databázi. Uvnitř phpsložky vytvořte soubor s názvem Dockerfilea vložte do něj následující 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šimněte si, že používáme alpskou verzi oficiálního obrazu PHP. Alpine je velmi malá distribuce zaměřená na kontejnery tím, že poskytuje mnohem menší stopy. Všimněte si také použití příkazu docker-php-ext-install, oficiální obrázek PHP poskytuje tento příkaz pro usnadnění procesu instalace a konfigurace rozšíření PHP.

Nyní vytvoříme tento obrázek Docker vydáním následujícího (uvnitř našeho WORKING_DIR):

docker build -t vultr-php php/

docker-compose.ymlsoubor

Jak již bylo zmíněno, docker-composeumožňuje spravovat řadu kontejnerů prostřednictvím jednoduchého konfiguračního souboru. Tento konfigurační soubor se obvykle jmenuje docker-compose.yml. Vytvořte tento soubor ve appsložce.

touch app/docker-compose.yml

Nyní do tohoto souboru vložte následující obsah.

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

Vysvětlíme si tuto syntaxi. Nejprve si všimněte prvního řádku.

version: '2'

Toto určuje verzi použitého docker-compose.ymlkonfiguračního souboru. Další řádek specifikuje služby nebo jinými slovy kontejnery, které mají být poskytovány.

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

Všimněte si, že každá služba má v servicesbloku specifický klíč . Zde zadaný název bude později použit jako odkaz na tento konkrétní kontejner. Všimněte si také, že uvnitř phpkonfigurace definujeme obrázek použitý ke spuštění kontejneru (toto je obrázek, který jsme vytvořili dříve). Definujeme také mapování objemu.

volumes:
  - ./:/app

To říká, docker-composeže je třeba namapovat aktuální adresář ( ./) na /appadresář uvnitř kontejneru. Poslední řádek nastavuje /appsložku uvnitř kontejneru jako pracovní adresář, což znamená, že toto je složka, ze které jsou standardně spouštěny všechny budoucí příkazy v kontejneru.

Nyní můžeme zorganizovat naše kontejnery.

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

Můžete spustit následující příkaz, abyste se ujistili, že byl kontejner PHP spuštěn:

docker ps

Jak provádět příkazy uvnitř kontejnerů

Stále uvnitř appsložky můžeme pomocí příkazu spustit libovolný příkaz uvnitř definovaného servisního kontejneru docker-compose.

docker-compose exec [service] [command]

[service]Zástupný odkazuje na klíč služby. V našem případě to bylo php. Spusťte příkaz uvnitř kontejneru pro kontrolu naší verze PHP.

docker-compose exec php php -v

Uvidíte následující 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

Konfigurace kontejneru Nginx

Stejně jako kontejner PHP musíme vytvořit vlastní obrázek pro webový server. Ale v tomto případě nám stačí poskytnout konfiguraci pro náš virtual host. Ujistěte se, že jste v naší WORKING_DIRa vytvořte Dockerfileuvnitř nginxsložky:

cd ~/docker
touch nginx/Dockerfile

Nyní do toho vložte následující obsah Dockerfile:

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

Používáme výchozí obrázek Nginx založený na Alpine. Na tento soubor Docker jednoduše zkopírujeme konfigurační soubor do nastavení naší aplikace. Před vytvořením tohoto obrazu vytvořte konfigurační soubor.

touch nginx/default.conf

Nyní jej naplňte tímto obsahem.

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šimněte si, že na fastcgi_pass php:9000řádku odkazujeme na kontejner PHP podle jeho názvu v servicebloku docker-compose.ymlkonfiguračního souboru. Interně docker-composevytvoří síť a přiřadí název služby jako název hostitele každé z definovaných služeb. Nyní můžeme vytvořit obraz Nginx.

docker build -t vultr-nginx nginx/

Aktualizace docker-compose.yml

Nyní aktualizujte app/docker-compose.ymlsoubor.

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

Přidali jsme pouze novou službu. Konfigurace je téměř stejná, až na následující.

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

Oficiální obraz MySQL vám umožňuje konfigurovat kontejner pomocí jednoduchých proměnných prostředí. To lze provést pomocí environmentvolby uvnitř definice servisního bloku. Aktualizujte ~/docker/app/docker-compose.ymlsoubor na následující.

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:

Nyní jsme definovali novou službu pro databázi. Všimněte si čáry dbdata:/var/lib/mysql. Tím se cesta v kontejneru připojí /var/lib/mysqlk trvalému svazku spravovanému Dockerem, takže data databáze zůstanou zachována i po odstranění kontejneru. Tento svazek musí být definován v bloku nejvyšší úrovně, jak můžete vidět na konci souboru.

Před orchestrací naší nové konfigurace si stáhněte ukázkovou databázi MySQL. Oficiální MySQL dokumentace obsahuje několik ukázkových databází. Budeme používat známou světovou databázi. Tato databáze poskytuje seznam zemí a měst. Chcete-li stáhnout tuto ukázku, proveďte v naší složce aplikace následující.

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

Nyní pojďme zorganizovat naše kontejnery.

docker-compose up -d

Jak jste si již možná všimli, docker-compose uppříkaz spustí pouze kontejnery, které ještě nejsou spuštěny. Zkontroluje rozdíly mezi vaším docker-compose.ymlsouborem a aktuální konfigurací běžících kontejnerů.

Ještě jednou zkontrolujte, zda byl spuštěn kontejner MySQL.

docker ps

Nyní naplňte světovou databázi.

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

Výběrem dat přímo z databáze můžete ověřit, zda byla databáze naplněna. Nejprve otevřete výzvu MySQL uvnitř kontejneru.

docker-compose exec mysql mysql -uroot -proot world

V příkazovém řádku MySQL spusťte následující.

select * from city limit 10;

Zobrazí se seznam měst. Nyní ukončete výzvu MySQL.

mysql> exit

Vytváření naší aplikace

Nyní, když jsou všechny potřebné kontejnery připraveny a spuštěny, se můžeme soustředit na naši ukázkovou aplikaci. Aktualizujte app/index.phpsoubor na následující.

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

Pokud přistoupíte [vultr-instance-ip]ve webovém prohlížeči, uvidíte seznam nejlidnatějších měst světa. Gratulujeme, nasadili jste plně funkční PHP aplikaci pomocí dockeru.

Závěr

V tomto tutoriálu jsem krok za krokem ukázal, jak nakonfigurovat plně funkční PHP aplikaci. Vytvořili jsme vlastní obrázky pro PHP a Nginx a nakonfigurovali docker-compose pro orchestraci našich kontejnerů. Přestože je toto nastavení velmi jednoduché a jednoduché, odráží skutečný životní scénář.

V této příručce jsme vytvořili a označili naše obrázky lokálně. Pro flexibilnější nastavení můžete tyto obrázky odeslat do registru dockeru . Můžete odeslat do oficiálního registru dockerů nebo dokonce nastavit svůj vlastní registr dockerů. V každém případě vám to umožní vytvářet obrázky na jednom hostiteli a používat je na jiném.

Pro podrobnější použití docker-composebyste se měli podívat na oficiální dokumentaci .

V závislosti na požadavcích vaší aplikace a frameworku PHP, který používáte, možná budete chtít přidat další rozšíření. To lze snadno provést úpravou souboru Dockerfilepoužitého k vytvoření vlastního obrazu PHP. Některá rozšíření však vyžadují další závislosti, které se mají nainstalovat do kontejneru. Základní požadavky každého rozšíření byste si měli prohlédnout v seznamu rozšíření v oficiální dokumentaci PHP .