Įdiekite PHP programą naudodami „Docker-compose“.

PHP programas paprastai sudaro žiniatinklio serveris, reliacinė duomenų bazių sistema ir pats kalbos vertėjas. Šioje pamokoje mes išnaudosime visą PHP programų paketą naudodami docker. Tai yra nuodugni pamoka, kurioje mes ketiname kurti ir organizuoti konteinerius, skirtus Nginx (žiniatinklio serveriui), MySQL (duomenų bazių sistemai) ir PHP.

Šios pamokos sumetimais parašysime paprastą aplikaciją, kuri nuskaito miestų sąrašą iš duomenų bazės ir parodo jį tinklalapyje, tokiu būdu pademonstruosime pagrindinę, bet veikiančią PHP programą.

Šiame vadove daroma prielaida, kad jau įdiegėte „Docker-CE“ ir turite bent minimalias docker darbo žinias. Šiuo klausimu galite peržiūrėti šias pamokas:

• „Docker CE“ diegimas „Ubuntu 16.04“.
• „Docker CE“ diegimas „CentOS 7“.
• Kaip naudotis „Docker“: sukurkite pirmąjį „Docker“ konteinerį

Mūsų darbo aplinkos konfigūravimas

Realiai veikianti dokerių programa paprastai bus sudaryta iš kelių konteinerių. Jų valdymas rankiniu būdu gali būti gana nepatogus ir sudėtingas. Štai čia ir atsiranda dokeris-komponavimas. Tai padeda valdyti daugybę konteinerių naudojant paprastą yamlkonfigūracijos failą.

Įdiekite 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

Sukurkite aplanką, kuriame būtų visi reikalingi šio pavyzdžio failai, o tada cdį jį. Nuo šiol tai yra mūsų darbo katalogas ir kiekviena komanda bus vykdoma šiame aplanke ir kiekvienas kelias bus susijęs su ja. Šis aplankas vėliau gali būti nurodytas kaip WORKING_DIR.

mkdir ~/docker
cd ~/docker

Dabar sukurkite dar tris aplankus.

mkdir php nginx app

phpAplankas, kuriame statysime mūsų užsakymą PHP vaizdą, nginxaplankas laikys reikiamus failus mūsų užsakymą Nginx įvaizdžio ir appaplankas yra, kur mes bus išleisti kodą ir konfigūraciją mūsų imties taikymo.

PHP konteinerio konfigūravimas

Šiame pavyzdyje mes naudosime php-fpmprisijungti prie Nginx žiniatinklio serverio. Mes naudosime oficialų PHP bazinį vaizdą. Tačiau taip pat turime įdiegti ir įjungti kai kuriuos plėtinius, kad galėtume pasiekti duomenų bazę. Viduje phpaplanke sukurti failą pavadinimu Dockerfileir įdėti šiuos turinį į jį.

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

Atminkite, kad naudojame oficialaus PHP vaizdo Alpine versiją. Alpine yra labai mažas platinimas, skirtas konteineriams, suteikiant daug mažesnius plotus. Taip pat atkreipkite dėmesį į komandos naudojimą docker-php-ext-install, oficialus PHP vaizdas suteikia šią komandą, kad palengvintų PHP plėtinių diegimo ir konfigūravimo procesą.

Dabar sukurkime šį „Docker“ vaizdą, išleisdami šį (mūsų viduje WORKING_DIR):

docker build -t vultr-php php/

docker-compose.ymlfailą

Kaip jau minėta, docker-composeleidžia valdyti daugybę konteinerių naudojant paprastą konfigūracijos failą. Šis konfigūracijos failas paprastai vadinamas docker-compose.yml. Sukurkite šį failą appaplanke.

touch app/docker-compose.yml

Dabar į šį failą įdėkite šį turinį.

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

Mes paaiškinsime šią sintaksę. Pirma, atkreipkite dėmesį į pirmąją eilutę.

version: '2'

Tai nurodo docker-compose.ymlnaudojamo konfigūracijos failo versiją . Kitoje eilutėje nurodomos paslaugos arba, kitaip tariant, teikiami konteineriai.

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

Atminkite, kad kiekviena paslauga turi tam tikrą raktą servicesbloko viduje . Čia nurodytas pavadinimas vėliau bus naudojamas nuorodai į šį konkretų sudėtinį rodinį. Taip pat atkreipkite dėmesį, kad phpkonfigūracijos viduje apibrėžiame vaizdą, naudojamą konteineriui paleisti (tai vaizdas, kurį sukūrėme anksčiau). Taip pat apibrėžiame tūrio atvaizdavimą.

volumes:
  - ./:/app

Tai nurodo docker-composedabartinį katalogą ( ./) susieti /appsu konteinerio viduje esančiu katalogu. Paskutinėje eilutėje /apptalpyklos viduje esantis aplankas nustatomas kaip darbo katalogas, o tai reiškia, kad tai yra aplankas, iš kurio pagal nutylėjimą vykdomos visos būsimos sudėtinio rodinio komandos.

Dabar galime organizuoti savo konteinerius.

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

Norėdami įsitikinti, kad buvo vykdomas PHP konteineris, galite paleisti šią komandą:

docker ps

Kaip vykdyti komandas konteinerių viduje

Vis dar appaplanke galime paleisti bet kurią komandą apibrėžtame paslaugų konteineryje, naudodami docker-composekomandą.

docker-compose exec [service] [command]

Vietos [service]rezervavimo ženklas nurodo paslaugos raktą. Mūsų atveju tai buvo php. Paleiskite komandą konteinerio viduje, kad patikrintume savo PHP versiją.

docker-compose exec php php -v

Pamatysite tokią išvestį.

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

Nginx konteinerio konfigūravimas

Kaip ir PHP konteineryje, turime sukurti tinkintą žiniatinklio serverio vaizdą. Tačiau šiuo atveju tereikia pateikti savo konfigūraciją virtual host. Įsitikinkite, kad esate mūsų viduje WORKING_DIRir sukurti Dockerfileviduje nginxaplanką:

cd ~/docker
touch nginx/Dockerfile

Dabar įdėkite šį turinį Dockerfile:

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

Mes naudojame numatytąjį Nginx vaizdą, pagrįstą Alpine. Šiame „Docker“ faile tiesiog nukopijuojame konfigūracijos failą į programos sąranką. Prieš kurdami šį vaizdą, sukurkite konfigūracijos failą.

touch nginx/default.conf

Dabar užpildykite jį šiuo turiniu.

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

Atminkite, kad fastcgi_pass php:9000eilutėje mes nurodome PHP konteinerį jo pavadinimu konfigūracijos failo servicebloke docker-compose.yml. Viduje docker-composesukuria tinklą ir kiekvienai apibrėžtai paslaugai priskiria paslaugos pavadinimą kaip pagrindinio kompiuterio pavadinimą. Dabar galime sukurti „Nginx“ vaizdą.

docker build -t vultr-nginx nginx/

Atnaujinama docker-compose.yml

Dabar atnaujinkite app/docker-compose.ymlfailą.

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

Pridėjome tik naują paslaugą. Konfigūracija yra beveik tokia pati, išskyrus toliau nurodytus dalykus.

depends_on:
  - php
ports:
  - 80:80

Kai „Nginx“ konteineriui reikia, kad PHP paslauga būtų visiškai inicijuota, šį reikalavimą priverčiame depends_onpasirinkti. portsKonfigūracija raktas žemėlapiai šeimininko uosto konteinerių uostą, čia mes žemėlapį uostą 80priimančiojoje uosto 80į konteinerį.

Dabar sukurkite failą, pavadintą aplanko index.phpviduje, appir įdėkite į jį šiuos dalykus.

<?php phpinfo();

Įsitikinkite, kad prievadas 80pasiekiamas per užkardą, ir atlikite šiuos veiksmus.

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

Dar kartą patikrinkite, ar paslauga veikia.

docker ps

Atidarykite naršyklę ir pasiekite [vultr-instance-ip]. Savo Vultr egzemplioriaus IP adresą galite sužinoti vykdydami toliau nurodytus veiksmus.

hostname -I

Pamatysite PHP informacijos puslapį.

„MySQL“ konteinerio konfigūravimas

Oficialus MySQL vaizdas leidžia sukonfigūruoti konteinerį naudojant paprastus aplinkos kintamuosius. Tai galima padaryti naudojant environmentparinktį paslaugų bloko apibrėžime. Atnaujinkite ~/docker/app/docker-compose.ymlfailą į toliau pateiktą.

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:

Dabar mes apibrėžėme naują duomenų bazės paslaugą. Atkreipkite dėmesį į liniją dbdata:/var/lib/mysql. Taip sujungiamas kelias konteineryje /var/lib/mysqlį nuolatinį „Docker“ valdomą tomą, todėl duomenų bazės duomenys išlieka ir pašalinus konteinerį. Šis tomas turi būti apibrėžtas aukščiausio lygio bloke, kaip matote failo pabaigoje.

Prieš rengdami naują konfigūraciją, atsisiųskite pavyzdinę MySQL duomenų bazę. Oficialus MySQL dokumentacija pateikiama keletas pavyzdžių duomenų bazes. Naudosime gerai žinomą pasaulio duomenų bazę. Šioje duomenų bazėje pateikiamas šalių ir miestų sąrašas. Norėdami atsisiųsti šį pavyzdį, mūsų programos aplanke atlikite šiuos veiksmus.

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

Dabar suorganizuokime savo konteinerius.

docker-compose up -d

Kaip jau galbūt pastebėjote, docker-compose upkomanda paleidžia tik tuos konteinerius, kurie dar nepaleisti. Ji patikrina, ar jūsų docker-compose.ymlfailas skiriasi nuo dabartinės veikiančių sudėtinių rodinių konfigūracijos.

Dar kartą patikrinkite, ar buvo paleistas MySQL konteineris.

docker ps

Dabar užpildykite pasaulio duomenų bazę.

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

Galite patikrinti, ar duomenų bazė buvo užpildyta, pasirinkdami duomenis tiesiai iš duomenų bazės. Pirmiausia pasiekite „MySQL“ raginimą konteinerio viduje.

docker-compose exec mysql mysql -uroot -proot world

„MySQL“ raginime paleiskite šiuos veiksmus.

select * from city limit 10;

Pamatysite miestų sąrašą. Dabar uždarykite MySQL raginimą.

mysql> exit

Mūsų programos kūrimas

Dabar, kai visi reikalingi konteineriai yra sukurti ir veikia, galime sutelkti dėmesį į programos pavyzdį. Atnaujinkite app/index.phpfailą į toliau pateiktą.

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

Jei prisijungsite [vultr-instance-ip]prie interneto naršyklės, pamatysite daugiausiai gyventojų turinčių pasaulio miestų sąrašą. Sveikiname, įdiegėte visiškai veikiančią PHP programą naudodami docker.

Išvada

Šioje pamokoje žingsnis po žingsnio parodžiau, kaip sukonfigūruoti visiškai veikiančią PHP programą. Sukūrėme pasirinktinius PHP ir Nginx vaizdus ir sukonfigūravome docker-compose, kad sutvarkytume mūsų konteinerius. Nepaisant to, kad ši sąranka yra labai paprasta ir paprasta, ji atspindi realų scenarijų.

Šiame vadove sukūrėme ir pažymėjome savo vaizdus vietoje. Kad sąranka būtų lankstesnė, šiuos vaizdus galite perkelti į doko registrą . Galite persikelti į oficialų dokų registrą arba net nustatyti savo dokų registrą. Bet kokiu atveju tai leis jums sukurti vaizdus viename pagrindiniame kompiuteryje ir naudoti juos kitame.

Norėdami sužinoti daugiau apie naudojimą docker-compose, turėtumėte žiūrėti oficialią dokumentaciją .

Atsižvelgiant į taikomosios programos reikalavimus ir naudojamą PHP sistemą, galbūt norėsite pridėti daugiau plėtinių. Tai galima lengvai padaryti pakeitus Dockerfilenaudojamą kuriant mūsų pasirinktinį PHP vaizdą. Tačiau kai kuriems plėtiniams reikia papildomų priklausomybių, kad jie būtų įdiegti konteineryje. Turėtumėte peržiūrėti plėtinių sąrašą oficialioje PHP dokumentacijoje, kad peržiūrėtumėte pagrindinius kiekvieno plėtinio reikalavimus.