Izvietojiet PHP lietojumprogrammu, izmantojot Docker-compose

PHP lietojumprogrammas parasti veido tīmekļa serveris, relāciju datu bāzes sistēma un pats valodas tulks. Šajā apmācībā mēs izmantosim pilnu PHP lietojumprogrammu kopu, izmantojot docker. Šī ir padziļināta apmācība, kurā mēs gatavojamies izveidot un koordinēt konteinerus Nginx (tīmekļa serverim), MySQL (datu bāzes sistēmai) un PHP.

Šīs apmācības nolūkos mēs uzrakstīsim vienkāršu aplikāciju, kas nolasa pilsētu sarakstu no datu bāzes un parāda to tīmekļa lapā, tādā veidā mēs demonstrēsim pamata, bet strādājošu PHP aplikāciju.

Šajā rokasgrāmatā tiek pieņemts, ka jums jau ir instalēts Docker-CE un jums ir vismaz minimālas darba zināšanas par doku. Šim nolūkam varat pārskatīt šādas apmācības:

• Docker CE instalēšana Ubuntu 16.04
• Docker CE instalēšana operētājsistēmā CentOS 7
• Kā lietot Docker: izveidojiet savu pirmo Docker konteineru

Mūsu darba vides konfigurēšana

Reālās dzīves docker lietojumprogramma parasti sastāv no vairākiem konteineriem. To manuāla pārvaldīšana var viegli kļūt diezgan netīra un apgrūtinoša. Šeit tiek izmantota dokera komponēšana. Tas palīdz pārvaldīt vairākus konteinerus, izmantojot vienkāršu yamlkonfigurācijas failu.

Instalējiet 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

Izveidojiet mapi, kurā glabājiet visus nepieciešamos šī piemēra failus un pēc tam cdtajā. No šī brīža šis ir mūsu darba direktorijs, un katra komanda tiks izpildīta šajā mapē, un katrs ceļš tiks attiecināts uz to. Šo mapi vēlāk var saukt par WORKING_DIR.

mkdir ~/docker
cd ~/docker

Tagad izveidojiet vēl trīs mapes.

mkdir php nginx app

phpMape ir vieta, kur mēs veidot mūsu pasūtījuma PHP tēlu, tad nginxmape rīkos nepieciešamos failus mūsu pasūtījuma Nginx tēla un appmape, kurā mēs liekot pirmkodu un konfigurāciju mūsu parauga pieteikumu.

PHP konteinera konfigurēšana

Šajā piemērā mēs izmantosim, php-fpmlai izveidotu savienojumu ar Nginx tīmekļa serveri. Mēs izmantosim oficiālo PHP bāzes attēlu. Tomēr mums ir arī jāinstalē un jāiespējo daži paplašinājumi, lai mēs varētu piekļūt datu bāzei. Inside phpmapē izveidotu failu ar nosaukumu Dockerfileun nodot šādus saturu tajā.

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

Ņemiet vērā, ka mēs izmantojam oficiālā PHP attēla Alpine versiju. Alpine ir ļoti mazs izplatījums, kas paredzēts konteineriem, nodrošinot daudz mazākus nospiedumus. Ņemiet vērā arī komandas izmantošanu docker-php-ext-install, oficiālais PHP attēls nodrošina šo komandu, lai atvieglotu PHP paplašinājumu instalēšanas un konfigurēšanas procesu.

Tagad izveidosim šo Docker attēlu, izdodot šo (mūsu iekšienē WORKING_DIR):

docker build -t vultr-php php/

docker-compose.ymlfails

Kā jau minēts, tas docker-composeļauj pārvaldīt vairākus konteinerus, izmantojot vienkāršu konfigurācijas failu. Šim konfigurācijas failam parasti ir nosaukums docker-compose.yml. Izveidojiet šo failu appmapē.

touch app/docker-compose.yml

Tagad ievietojiet šajā failā šādu saturu.

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

Mēs izskaidrosim šo sintaksi. Pirmkārt, atzīmējiet pirmo rindiņu.

version: '2'

Tas norāda izmantotā docker-compose.ymlkonfigurācijas faila versiju . Nākamajā rindā ir norādīti pakalpojumi vai, citiem vārdiem sakot, nodrošināmie konteineri.

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

Ņemiet vērā, ka katram pakalpojumam servicesblokā ir noteikta atslēga . Šeit norādītais nosaukums vēlāk tiks izmantots, lai atsauktos uz šo konkrēto konteineru. Ņemiet vērā arī to, ka phpkonfigurācijā mēs definējam attēlu, kas tiek izmantots konteinera palaišanai (šis ir attēls, ko mēs izveidojām iepriekš). Mēs arī definējam apjoma kartēšanu.

volumes:
  - ./:/app

Tas liek docker-composekartēt pašreizējo direktoriju ( ./) ar /appdirektoriju konteinera iekšpusē. Pēdējā rindiņā /appkā darba direktoriju tiek iestatīta mape konteinerā, kas nozīmē, ka šī ir mape, kurā pēc noklusējuma tiek izpildītas visas konteinerā esošās nākamās komandas.

Tagad mēs varam sakārtot savus konteinerus.

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

Varat palaist šādu komandu, lai pārliecinātos, ka PHP konteiners ir izpildīts:

docker ps

Kā izpildīt komandas konteineros

Joprojām appmapē mēs varam palaist jebkuru komandu noteiktā pakalpojuma konteinerā ar docker-composekomandas palīdzību.

docker-compose exec [service] [command]

[service]Vietturis norāda uz servisa atslēgu. Mūsu gadījumā tas bija php. Palaidīsim komandu konteinerā, lai pārbaudītu mūsu PHP versiju.

docker-compose exec php php -v

Jūs redzēsit šādu izvadi.

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 konteinera konfigurēšana

Tāpat kā PHP konteineram, mums ir jāizveido pielāgots attēls tīmekļa serverim. Bet šajā gadījumā mums vienkārši ir jānodrošina mūsu konfigurācija virtual host. Pārliecinieties, ka jums ir iekšā mūsu WORKING_DIRun radīt Dockerfileiekšpusē nginxmapi:

cd ~/docker
touch nginx/Dockerfile

Tagad ievietojiet tajā šādu saturu Dockerfile:

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

Mēs izmantojam noklusējuma Nginx attēlu, kura pamatā ir Alpine. Šajā Docker failā mēs vienkārši kopējam konfigurācijas failu mūsu lietojumprogrammas iestatījumos. Pirms šī attēla izveides izveidojiet konfigurācijas failu.

touch nginx/default.conf

Tagad aizpildiet to ar šo saturu.

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

Ņemiet vērā, ka fastcgi_pass php:9000rindā mēs atsaucamies uz PHP konteineru pēc tā nosaukuma konfigurācijas faila serviceblokā docker-compose.yml. Iekšēji docker-composeizveido tīklu un piešķir pakalpojuma nosaukumu kā resursdatora nosaukumu katram definētajam pakalpojumam. Tagad mēs varam izveidot Nginx attēlu.

docker build -t vultr-nginx nginx/

Atjaunināšana docker-compose.yml

Tagad atjauniniet app/docker-compose.ymlfailu.

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

Esam tikai pievienojuši jaunu pakalpojumu. Konfigurācija ir gandrīz tāda pati, izņemot tālāk norādīto.

depends_on:
  - php
ports:
  - 80:80

Kad Nginx konteineram ir nepieciešams pilnībā inicializēt PHP pakalpojumu, mēs piespiežam šo depends_onopciju. portsKonfigurācijas atslēga kartes resursdatora ostas uz konteineru ostas, šeit mēs kartētu ostas 80uzņēmējā uz ostu 80konteinerā.

Tagad izveidot failu sauc index.phpiekšpusē appmapi un nodot šādus tajā.

<?php phpinfo();

Pārliecinieties, vai portam 80var piekļūt, izmantojot ugunsmūri, un izpildiet tālāk norādītās darbības.

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

Vēlreiz vēlreiz pārbaudiet, vai pakalpojums ir pieejams.

docker ps

Atveriet pārlūkprogrammu un piekļūstiet [vultr-instance-ip]. Varat uzzināt savu Vultr instances IP adresi, izpildot tālāk norādīto.

hostname -I

Jūs redzēsit PHP informācijas lapu.

MySQL konteinera konfigurēšana

Oficiālais MySQL attēls ļauj konfigurēt konteineru, izmantojot vienkāršus vides mainīgos. To var izdarīt, izmantojot environmentopciju pakalpojumu bloka definīcijā. Atjauniniet ~/docker/app/docker-compose.ymlfailu uz tālāk norādīto.

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:

Tagad datubāzei esam definējuši jaunu pakalpojumu. Ievērojiet līniju dbdata:/var/lib/mysql. Tādējādi konteinera ceļš tiek /var/lib/mysqlpievienots pastāvīgam sējumam, ko pārvalda Docker, tādējādi datu bāzes dati saglabājas arī pēc konteinera noņemšanas. Šis apjoms ir jādefinē augstākā līmeņa blokā, kā redzat faila beigās.

Pirms jaunās konfigurācijas organizēšanas lejupielādēsim MySQL datu bāzes paraugu. Oficiālais MySQL dokumentācijā sniedz dažus paraugu datu bāzes. Mēs izmantosim labi zināmo pasaules datu bāzi. Šī datu bāze nodrošina valstu un pilsētu sarakstu. Lai lejupielādētu šo paraugu, mūsu lietotņu mapē izpildiet tālāk norādītās darbības.

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

Tagad organizēsim mūsu konteinerus.

docker-compose up -d

Kā jūs, iespējams, jau pamanījāt, docker-compose upkomanda palaiž tikai tos konteinerus, kas vēl nav startēti. Tas pārbauda atšķirības starp jūsu docker-compose.ymlfailu un pašreizējo darbojošos konteineru konfigurāciju.

Vēlreiz pārbaudiet, vai MySQL konteiners ir palaists.

docker ps

Tagad aizpildiet pasaules datu bāzi.

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

Varat pārbaudīt, vai datu bāze ir aizpildīta, atlasot datus tieši no datu bāzes. Vispirms piekļūstiet MySQL uzvednei konteinerā.

docker-compose exec mysql mysql -uroot -proot world

MySQL uzvednē izpildiet tālāk norādīto.

select * from city limit 10;

Jūs redzēsit pilsētu sarakstu. Tagad aizveriet MySQL uzvedni.

mysql> exit

Mūsu lietojumprogrammas izveide

Tagad, kad visi nepieciešamie konteineri ir izveidoti un darbojas, mēs varam koncentrēties uz mūsu lietojumprogrammas paraugu. Atjauniniet app/index.phpfailu uz tālāk norādīto.

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

Ja piekļūstat [vultr-instance-ip]tīmekļa pārlūkprogrammā, jūs redzēsit pasaules visvairāk apdzīvoto pilsētu sarakstu. Apsveicam, jūs esat izvietojis pilnībā strādājošu PHP lietojumprogrammu, izmantojot docker.

Secinājums

Šajā apmācībā es soli pa solim parādīju, kā konfigurēt pilnībā strādājošu PHP lietojumprogrammu. Mēs izveidojām pielāgotus attēlus PHP un Nginx un konfigurējām docker-compose, lai sakārtotu mūsu konteinerus. Neskatoties uz to, ka šis iestatījums ir ļoti vienkāršs un vienkāršs, tas atspoguļo reālu dzīves scenāriju.

Šajā rokasgrāmatā mēs esam izveidojuši un atzīmējuši savus attēlus lokāli. Lai iestatīšana būtu elastīgāka, varat nosūtīt šos attēlus uz doka reģistru . Varat pārsūtīt uz oficiālo doku reģistru vai pat iestatīt savu doku reģistru. Jebkurā gadījumā tas ļaus jums izveidot attēlus vienā resursdatorā un izmantot tos citā.

Lai iegūtu sīkāku informāciju par lietošanu docker-compose, skatiet oficiālo dokumentāciju .

Atkarībā no lietojumprogrammas prasībām un izmantotā PHP ietvara, iespējams, vēlēsities pievienot citus paplašinājumus. To var viegli izdarīt, mainot Dockerfileizmantoto, lai izveidotu mūsu pielāgoto PHP attēlu. Tomēr dažiem paplašinājumiem ir nepieciešamas papildu atkarības, lai tos instalētu konteinerā. Lai pārskatītu katra paplašinājuma pamatprasības, skatiet PHP oficiālajā dokumentācijā esošo paplašinājumu sarakstu.