Wdróż aplikację PHP za pomocą Docker-compose

• Konfigurowanie naszego środowiska pracy
• Konfigurowanie kontenera PHP
• Konfigurowanie kontenera Nginx
• Konfigurowanie kontenera MySQL
• Budowanie naszej aplikacji
• Wniosek

Aplikacje PHP zwykle składają się z serwera WWW, systemu relacyjnej bazy danych i samego tłumacza języka. W tym samouczku wykorzystamy pełny stos aplikacji PHP za pomocą okna dokowanego. To jest dogłębny samouczek, w którym zamierzamy budować i koordynować kontenery dla Nginx (serwer WWW), MySQL (system bazy danych) i PHP.

Na potrzeby tego samouczka napiszemy prostą aplikację, która odczyta listę miast z bazy danych i wyświetli ją na stronie internetowej, w ten sposób zademonstrujemy prostą, ale działającą aplikację PHP.

W tym przewodniku założono, że masz już zainstalowany Docker-CE i przynajmniej minimalna praktyczna znajomość dokera. W tym celu możesz przejrzeć następujące samouczki:

• Instalowanie Docker CE na Ubuntu 16.04
• Instalowanie Docker CE na CentOS 7
• Jak korzystać z Docker: Tworzenie pierwszego kontenera Docker

Konfigurowanie naszego środowiska pracy

Rzeczywista aplikacja oparta na dokerze zwykle składa się z kilku kontenerów. Ręczne zarządzanie nimi może stać się dość nieporządne i kłopotliwe. Tam właśnie wkracza kompozycja dokująca. Pomaga zarządzać wieloma kontenerami za pomocą prostego yamlpliku konfiguracyjnego.

Zainstaluj komponent dokujący.

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

Utwórz folder do przechowywania wszystkich niezbędnych plików z tego przykładu, a następnie cddo niego. Od teraz jest to nasz katalog roboczy i każde polecenie będzie wykonywane w tym folderze, a każda ścieżka będzie do niego wskazywana. Do tego folderu można się później odwołać jako WORKING_DIR.

mkdir ~/docker
cd ~/docker

Teraz utwórz jeszcze trzy foldery.

mkdir php nginx app

phpFolder jest gdzie będziemy budować nasz zwyczaj PHP obrazu, nginxfolder będzie posiadać niezbędne pliki na nasz zwyczaj nginx obrazu i appfolder jest gdzie będziemy wprowadzenie kodu źródłowego i konfigurację naszej przykładowej aplikacji.

Konfigurowanie kontenera PHP

W tym przykładzie użyjemy php-fpmdo połączenia z serwerem internetowym Nginx. Będziemy używać oficjalnego podstawowego obrazu PHP. Jednak musimy również zainstalować i włączyć niektóre rozszerzenia, abyśmy mogli uzyskać dostęp do bazy danych. Wewnątrz phpfolderu utwórz plik o nazwie Dockerfilei umieść w nim następującą zawartość.

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

Pamiętaj, że korzystamy z alpejskiej wersji oficjalnego obrazu PHP. Alpine to bardzo niewielka dystrybucja ukierunkowana na kontenery, ponieważ zapewnia znacznie mniejsze ślady. Zwróć też uwagę na użycie polecenia docker-php-ext-install, oficjalny obraz PHP udostępnia to polecenie, aby ułatwić proces instalowania i konfigurowania rozszerzeń PHP.

Teraz zbudujmy ten obraz Dockera, wydając następujące (w naszym WORKING_DIR):

docker build -t vultr-php php/

docker-compose.ymlplik

Jak już wspomniano, docker-composeumożliwia zarządzanie wieloma kontenerami za pomocą prostego pliku konfiguracyjnego. Ten plik konfiguracyjny ma zwykle nazwę docker-compose.yml. Utwórz ten plik w appfolderze.

touch app/docker-compose.yml

Teraz włóż następującą zawartość do tego pliku.

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

Wyjaśnimy tę składnię. Najpierw zwróć uwagę na pierwszą linię.

version: '2'

Określa wersję docker-compose.ymlużywanego pliku konfiguracyjnego. Kolejny wiersz określa usługi lub, innymi słowy, pojemniki, które mają zostać udostępnione.

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

Pamiętaj, że każda usługa ma określony klucz w servicesbloku. Podana tutaj nazwa zostanie później użyta do odwołania się do tego konkretnego kontenera. Pamiętaj również, że w phpkonfiguracji definiujemy obraz używany do uruchomienia kontenera (jest to obraz, który zbudowaliśmy wcześniej). Definiujemy również mapowanie woluminów.

volumes:
  - ./:/app

To mówi docker-composeo zamapowaniu bieżącego katalogu ( ./) na /appkatalog wewnątrz kontenera. Ostatni wiersz ustawia /appfolder wewnątrz kontenera jako katalog roboczy, co oznacza, że ​​jest to folder, z którego domyślnie wykonywane są wszystkie przyszłe polecenia w kontenerze.

Możemy teraz koordynować nasze kontenery.

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

Możesz uruchomić następujące polecenie, aby upewnić się, że kontener PHP został wykonany:

docker ps

Jak wykonywać polecenia w kontenerach

Nadal w appfolderze możemy za pomocą polecenia uruchomić dowolne polecenie w określonym kontenerze usług docker-compose.

docker-compose exec [service] [command]

Symbol [service]zastępczy odnosi się do klucza usługi. W naszym przypadku tak było php. Uruchommy polecenie w kontenerze, aby sprawdzić naszą wersję PHP.

docker-compose exec php php -v

Zobaczysz następujące dane wyjściowe.

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

Konfigurowanie kontenera Nginx

Podobnie jak kontener PHP, musimy stworzyć niestandardowy obraz dla serwera WWW. Ale w tym przypadku musimy tylko podać konfigurację dla naszego virtual host. Upewnij się, że jesteś w naszym WORKING_DIRi utwórz folder Dockerfilewewnątrz nginx:

cd ~/docker
touch nginx/Dockerfile

Teraz włóż w to następującą zawartość Dockerfile:

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

Używamy domyślnego obrazu Nginx opartego na Alpine. W tym pliku Docker po prostu kopiujemy plik konfiguracyjny do naszej konfiguracji aplikacji. Przed zbudowaniem tego obrazu utwórz plik konfiguracyjny.

touch nginx/default.conf

Teraz wypełnij go tą zawartością.

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

Zauważ, że w fastcgi_pass php:9000wierszu odwołujemy się do kontenera PHP według jego nazwy w servicebloku docker-compose.ymlpliku konfiguracyjnego. Wewnętrznie docker-composetworzy sieć i przypisuje nazwę usługi jako nazwę hosta do każdej ze zdefiniowanych usług. Możemy teraz zbudować obraz Nginx.

docker build -t vultr-nginx nginx/

Aktualizacja docker-compose.yml

Teraz zaktualizuj app/docker-compose.ymlplik.

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

Dodaliśmy tylko nową usługę. Konfiguracja jest prawie taka sama, z wyjątkiem poniższych.

depends_on:
  - php
ports:
  - 80:80

Gdy kontener Nginx wymaga pełnej inicjalizacji usługi PHP, wymuszamy to wymaganie w depends_onopcji. portsKlucz konfiguracja mapuje port hosta do portu kontenerowego, tutaj mamy map portu 80w przyjmującym do portu 80w pojemniku.

Teraz utwórz plik o nazwie index.phpwewnątrz appfolderu i umieść w nim następujące elementy.

<?php phpinfo();

Upewnij się, że port 80jest dostępny przez zaporę ogniową i wykonaj następujące czynności.

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

Ponownie sprawdź, czy usługa jest uruchomiona.

docker ps

Otwórz przeglądarkę i uzyskaj dostęp [vultr-instance-ip]. Możesz znaleźć swój adres IP instancji Vultr, uruchamiając następujące polecenie.

hostname -I

Zobaczysz stronę informacyjną PHP.

Konfigurowanie kontenera MySQL

Oficjalny obraz MySQL pozwala skonfigurować kontener za pomocą prostych zmiennych środowiskowych. Można to zrobić za pomocą environmentopcji w definicji bloku serwisowego. Zaktualizuj ~/docker/app/docker-compose.ymlplik do następującego.

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:

Teraz zdefiniowaliśmy nową usługę dla bazy danych. Zwróć uwagę na linię dbdata:/var/lib/mysql. Spowoduje to zamontowanie ścieżki w kontenerze /var/lib/mysqldo trwałego woluminu zarządzanego przez Docker, w ten sposób dane bazy danych pozostaną po usunięciu kontenera. Ten wolumin należy zdefiniować w bloku najwyższego poziomu, jak widać na końcu pliku.

Przed zaaranżowaniem naszej nowej konfiguracji pobierzmy przykładową bazę danych MySQL. Oficjalna dokumentacja MySQL zawiera kilka przykładowych baz danych. Będziemy korzystać ze znanej światowej bazy danych. Ta baza danych zawiera listę krajów i miast. Aby pobrać tę próbkę, wykonaj następujące czynności w naszym folderze aplikacji.

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

Teraz pozwala organizować nasze kontenery.

docker-compose up -d

Jak zapewne zauważyłeś, docker-compose uppolecenie uruchamia tylko te kontenery, które nie zostały jeszcze uruchomione. Sprawdza różnice między docker-compose.ymlplikiem a bieżącą konfiguracją działających kontenerów.

Jeszcze raz sprawdź, czy kontener MySQL został uruchomiony.

docker ps

Teraz zapełnij światową bazę danych.

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

Możesz sprawdzić, czy baza danych została zapełniona, wybierając dane bezpośrednio z bazy danych. Najpierw uzyskaj dostęp do monitu MySQL w kontenerze.

docker-compose exec mysql mysql -uroot -proot world

W wierszu MySQL uruchom następujące polecenie.

select * from city limit 10;

Zobaczysz listę miast. Teraz zamknij monit MySQL.

mysql> exit

Budowanie naszej aplikacji

Teraz, gdy wszystkie niezbędne pojemniki są już uruchomione, możemy skupić się na naszej przykładowej aplikacji. Zaktualizuj app/index.phpplik do następującego.

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

Jeśli uzyskasz dostęp [vultr-instance-ip]w przeglądarce internetowej, zobaczysz listę najbardziej zaludnionych miast na świecie. Gratulacje, wdrożyłeś w pełni działającą aplikację PHP za pomocą dokera.

Wniosek

W tym samouczku pokazałem krok po kroku, jak skonfigurować w pełni działającą aplikację PHP. Zbudowaliśmy niestandardowe obrazy dla PHP i Nginx, a także skonfigurowaliśmy kompozycję dokującą do aranżacji naszych kontenerów. Mimo że jest bardzo prosty i prosty, ta konfiguracja odzwierciedla prawdziwy scenariusz z życia.

W tym przewodniku zbudowaliśmy i oznaczyliśmy nasze obrazy lokalnie. Aby uzyskać bardziej elastyczną konfigurację, możesz przesłać te obrazy do rejestru dokera . Możesz przejść do oficjalnego rejestru dokerów, a nawet skonfigurować własny rejestr dokerów. W każdym razie pozwoli ci to zbudować obrazy na jednym hoście i użyć ich na innym.

Aby uzyskać bardziej szczegółowe informacje na temat korzystania docker-compose, należy zapoznać się z oficjalną dokumentacją .

W zależności od wymagań aplikacji i używanego środowiska PHP możesz chcieć dodać więcej rozszerzeń. Można to łatwo zrobić, modyfikując Dockerfileużywany do budowy naszego niestandardowego obrazu PHP. Jednak niektóre rozszerzenia wymagają dodatkowych zależności do zainstalowania w kontenerze. Należy zapoznać się z listą rozszerzeń w oficjalnej dokumentacji PHP, aby przejrzeć podstawowe wymagania każdego rozszerzenia.