PHP-alkalmazás üzembe helyezése a Docker-compose használatával

A PHP-alkalmazások általában egy webszerverből, egy relációs adatbázis-rendszerből és magából a nyelvi értelmezőből állnak. Ebben az oktatóanyagban egy teljes PHP-alkalmazáskészletet fogunk kihasználni a docker segítségével. Ez egy mélyreható oktatóanyag, amelyben konténereket fogunk építeni és hangszerelni az Nginx (a webszerver), a MySQL (az adatbázisrendszer) és a PHP számára.

Az oktatóanyag kedvéért írunk egy egyszerű alkalmazást, amely beolvassa a városok listáját egy adatbázisból és megjeleníti egy weboldalon, így bemutatunk egy alapvető, de működő PHP alkalmazást.

Ez az útmutató feltételezi, hogy a Docker-CE már telepítve van, és legalább minimális munkaismerettel rendelkezik a dockerrel kapcsolatban. Ezzel kapcsolatban áttekintheti a következő oktatóanyagokat:

• A Docker CE telepítése Ubuntu 16.04-re
• A Docker CE telepítése CentOS 7 rendszerre
• A Docker használata: Az első Docker-tároló létrehozása

Munkakörnyezetünk konfigurálása

Egy valós docker-alapú alkalmazás általában több tárolóból áll. Ezek manuális kezelése könnyen zavarossá és nehézkessé válhat. Itt jön képbe a docker-compose. Segít számos tároló kezelésében egy egyszerű yamlkonfigurációs fájlon keresztül.

Telepítse a docker-compose-t.

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

Hozzon létre egy mappát a példa összes szükséges fájljának tárolására, majd cdhelyezze el. Mostantól ez a mi munkakönyvtárunk, és minden parancs ebben a mappában fog végrehajtásra kerülni, és minden elérési út ehhez képest lesz hivatkozva. Erre a mappára később mint WORKING_DIR.

mkdir ~/docker
cd ~/docker

Most hozzon létre három további mappát.

mkdir php nginx app

Ebben a phpmappában fogjuk elkészíteni az egyéni PHP-képet, a nginxmappában tároljuk az egyéni nginx-képünkhöz szükséges fájlokat, és a appmappába helyezzük el a példaalkalmazásunk forráskódját és konfigurációját.

A PHP tároló beállítása

Ebben a példában php-fpmaz Nginx webszerverhez való csatlakozáshoz használjuk . A hivatalos PHP alapképet fogjuk használni. Azonban néhány bővítményt is telepítenünk és engedélyeznünk kell, hogy hozzáférhessünk az adatbázishoz. A phpmappán belül hozzon létre egy nevű fájlt, Dockerfileés tegye bele a következő tartalmat.

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

Ne feledje, hogy a hivatalos PHP kép alpesi verzióját használjuk. Az Alpine egy nagyon apró disztribúció, amely a konténereket célozza meg, mivel sokkal kisebb helyet biztosít. Vegye figyelembe a parancs használatát is docker-php-ext-install, a hivatalos PHP-kép ezt a parancsot biztosítja, hogy megkönnyítse a PHP-bővítmények telepítését és konfigurálását.

Most készítsük el ezt a Docker-képet a következő kiadásával (a mi ben WORKING_DIR):

docker build -t vultr-php php/

A docker-compose.ymlfájl

Mint már említettük, docker-composelehetővé teszi számos tároló kezelését egy egyszerű konfigurációs fájlon keresztül. Ennek a konfigurációs fájlnak általában a neve docker-compose.yml. Hozd létre ezt a fájlt a appmappában.

touch app/docker-compose.yml

Most tegye a következő tartalmat ebbe a fájlba.

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

Elmagyarázzuk ezt a szintaxist. Először is vegye figyelembe az első sort.

version: '2'

Ez adja meg a docker-compose.ymlhasznált konfigurációs fájl verzióját . A következő sor megadja a szolgáltatásokat, vagy más szóval a kiépítendő tárolókat.

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

Vegye figyelembe, hogy minden szolgáltatásnak van egy adott kulcsa a servicesblokkon belül . Az itt megadott név a későbbiekben erre a konkrét tárolóra fog hivatkozni. Vegye figyelembe azt is, hogy a phpkonfiguráción belül meghatározzuk a tároló futtatásához használt képet (ez az a kép, amelyet korábban készítettünk). Meghatározunk egy térfogat-leképezést is.

volumes:
  - ./:/app

Ez azt mondja, docker-composehogy az aktuális könyvtárat ( ./) le kell /appképezni a tárolón belüli könyvtárra. Az utolsó sor /appa tárolón belüli mappát állítja be munkakönyvtárnak, ami azt jelenti, hogy ez az a mappa, ahonnan a tárolón belüli összes jövőbeli parancs alapértelmezés szerint végrehajtásra kerül.

Most már hangszerelhetjük konténereinket.

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

A következő parancs futtatásával megbizonyosodhat arról, hogy a PHP-tároló végrehajtásra került:

docker ps

A tárolókon belüli parancsok végrehajtása

Még mindig a appmappán belül, a parancs segítségével bármilyen parancsot futtathatunk egy meghatározott szolgáltatástárolón belül docker-compose.

docker-compose exec [service] [command]

A [service]helyőrző a szervizkulcsra utal. A mi esetünkben ez volt php. Futtassunk egy parancsot a tárolón belül a PHP verziónk ellenőrzéséhez.

docker-compose exec php php -v

A következő kimenetet fogja látni.

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

Az Nginx tároló konfigurálása

Csakúgy, mint a PHP-tárolóhoz, létre kell hoznunk egy egyedi képet a webszerverhez. De ebben az esetben csak egy konfigurációt kell biztosítanunk a virtual host. Győződjön meg róla, hogy a mi mappánkban van, WORKING_DIRés hozzon létre egy Dockerfilebelső nginxmappát:

cd ~/docker
touch nginx/Dockerfile

Most tedd bele a következő tartalmat Dockerfile:

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

Az alapértelmezett Nginx képet használjuk az Alpine alapján. Ezen a Docker-fájlon egyszerűen bemásolunk egy konfigurációs fájlt az alkalmazásbeállításunkba. A kép elkészítése előtt hozzon létre egy konfigurációs fájlt.

touch nginx/default.conf

Most töltse fel ezzel a tartalommal.

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

Ne feledje, hogy a fastcgi_pass php:9000sorban a PHP-tárolóra hivatkozunk servicea docker-compose.ymlkonfigurációs fájl blokkjában található nevével . Belsőleg docker-composelétrehoz egy hálózatot, és a szolgáltatásnevet állomásnévként rendeli hozzá minden meghatározott szolgáltatáshoz. Most már elkészíthetjük az Nginx képet.

docker build -t vultr-nginx nginx/

Frissítés docker-compose.yml

Most frissítse a app/docker-compose.ymlfájlt.

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

Csak egy új szolgáltatást adtunk hozzá. A konfiguráció majdnem ugyanaz, kivéve a következőket.

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.

Az új konfigurációnk összehangolása előtt töltsünk le egy MySQL-minta adatbázist. A hivatalos MySQL dokumentáció néhány mintaadatbázist tartalmaz. A jól ismert világadatbázist fogjuk használni. Ez az adatbázis országok és városok listáját tartalmazza. A minta letöltéséhez hajtsa végre a következőt az alkalmazásmappánkban.

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

Most hangszereljük konténereinket.

docker-compose up -d

Amint azt már észrevette, a docker-compose upparancs csak azokat a tárolókat indítja el, amelyek még nincsenek elindítva. Ellenőrzi a különbségeket a docker-compose.ymlfájl és a futó tárolók jelenlegi konfigurációja között.

Még egyszer ellenőrizze, hogy a MySQL-tároló elindult-e.

docker ps

Most töltse fel a világadatbázist.

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

Az adatbázis feltöltését közvetlenül az adatbázisból történő adatok kiválasztásával ellenőrizheti. Először nyissa meg a MySQL promptot a tárolóban.

docker-compose exec mysql mysql -uroot -proot world

A MySQL parancssorban futtassa a következőt.

select * from city limit 10;

Látni fogja a városok listáját. Most lépjen ki a MySQL promptból.

mysql> exit

Alkalmazásunk felépítése

Most, hogy az összes szükséges konténer elkészült és fut, koncentrálhatunk a példaalkalmazásunkra. Frissítse a app/index.phpfájlt a következőre.

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

Ha [vultr-instance-ip]webböngészőben éri el, látni fogja a világ legnépesebb városainak listáját. Gratulálunk, egy teljesen működő PHP-alkalmazást telepített a docker segítségével.

Következtetés

Ebben az oktatóanyagban lépésről lépésre bemutattam egy teljesen működő PHP-alkalmazás konfigurálását. Egyedi képeket készítettünk PHP-hez és Nginx-hez, és konfiguráltuk a docker-compose-t a konténereink hangszereléséhez. Annak ellenére, hogy nagyon egyszerű és egyszerű, ez a beállítás egy valós forgatókönyvet tükröz.

Ebben az útmutatóban képeinket helyben készítettük el és címkéztük fel. A rugalmasabb beállítás érdekében ezeket a képeket átküldheti egy docker-nyilvántartásba . Leküldheti a hivatalos docker-nyilvántartást, vagy akár beállíthatja saját docker-nyilvántartását. Mindenesetre ez lehetővé teszi, hogy a képeket az egyik gazdagépen építse fel, és használja őket egy másikon.

A részletesebb használathoz docker-composetekintse meg a hivatalos dokumentációt .

Az alkalmazás követelményeitől és a használt PHP keretrendszertől függően érdemes lehet további bővítményeket hozzáadni. Ez egyszerűen megtehető, ha módosítja a Dockerfilehasznált fájlt az egyéni PHP kép elkészítéséhez. Néhány bővítménynek azonban további függőségekre van szüksége a tárolóba való telepítéshez. Tekintse meg a PHP hivatalos dokumentációjában található kiterjesztések listáját, hogy áttekintse az egyes bővítmények alapvető követelményeit.