Implementeer een PHP-applicatie met Docker-compose

• Onze werkomgeving configureren
• De PHP-container configureren
• De Nginx-container configureren
• De MySQL-container configureren
• Onze applicatie bouwen
• Gevolgtrekking

PHP-applicaties worden meestal samengesteld door een webserver, een relationeel databasesysteem en de tolk zelf. In deze zelfstudie maken we gebruik van een volledige PHP-applicatiestapel met behulp van docker. Dit is een diepgaande tutorial waarin we containers gaan bouwen en orkestreren voor Nginx (de webserver), MySQL (het databasesysteem) en PHP.

Omwille van deze tutorial zullen we een eenvoudige applicatie schrijven die een lijst met steden uit een database leest en deze op een webpagina weergeeft, op deze manier zullen we een eenvoudige maar werkende PHP-applicatie demonstreren.

In deze handleiding wordt ervan uitgegaan dat Docker-CE al is geïnstalleerd en op zijn minst een minimale kennis van docker. Overigens kunt u de volgende tutorials doornemen:

• Docker CE installeren op Ubuntu 16.04
• Docker CE installeren op CentOS 7
• Hoe Docker te gebruiken: uw eerste Docker-container maken

Onze werkomgeving configureren

Een echte docker-gebaseerde applicatie zal doorgaans uit meerdere containers bestaan. Het handmatig beheren hiervan kan gemakkelijk behoorlijk rommelig en omslachtig worden. Dat is waar docker-compose een rol speelt. Het helpt u om een ​​aantal containers te beheren via een eenvoudig yamlconfiguratiebestand.

Installeer 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

Maak een map om alle benodigde bestanden van dit voorbeeld cdin op te slaan. Vanaf nu is dit onze werkdirectory en elke opdracht zal in deze map worden uitgevoerd en naar elk pad zal relatief worden verwezen. Naar deze map kan later worden verwezen als WORKING_DIR.

mkdir ~/docker
cd ~/docker

Maak nu nog drie mappen.

mkdir php nginx app

De phpmap is waar we onze aangepaste PHP-afbeelding zullen bouwen, de nginxmap bevat de benodigde bestanden voor onze aangepaste nginx-afbeelding en de appmap is waar we de broncode en configuratie van onze voorbeeldtoepassing zullen plaatsen.

De PHP-container configureren

In dit voorbeeld gaan we gebruiken php-fpmom verbinding te maken met de Nginx-webserver. We zullen de officiële PHP-basisafbeelding gebruiken. We moeten echter ook enkele extensies installeren en inschakelen, zodat we toegang hebben tot de database. phpMaak in de map een bestand met de naam Dockerfileen plaats de volgende inhoud erin.

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

Merk op dat we de Alpine-versie van de officiële PHP-afbeelding gebruiken. Alpine is een zeer kleine distributie gericht op containers door een veel kleinere voetafdruk te bieden. Let ook op het gebruik van de opdracht docker-php-ext-install, de officiële PHP-afbeelding biedt deze opdracht om het proces van het installeren en configureren van PHP-extensies te vergemakkelijken.

Laten we nu deze Docker-image bouwen door het volgende uit te geven (binnen onze WORKING_DIR):

docker build -t vultr-php php/

Het docker-compose.ymlbestand

Zoals eerder vermeld, docker-composekunt u een aantal containers beheren via een eenvoudig configuratiebestand. Dit configuratiebestand wordt doorgaans genoemd docker-compose.yml. Maak dit bestand in de appmap.

touch app/docker-compose.yml

Zet nu de volgende inhoud in dit bestand.

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

We zullen deze syntaxis uitleggen. Let eerst op de eerste regel.

version: '2'

Dit specificeert de versie van het gebruikte docker-compose.ymlconfiguratiebestand. De volgende regel specificeert de services, of met andere woorden, de te leveren containers.

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

Merk op dat elke dienst een specifieke sleutel in het servicesblok heeft. De hier opgegeven naam zal later worden gebruikt om naar deze specifieke container te verwijzen. Merk ook op dat we binnen de phpconfiguratie de afbeelding definiëren die wordt gebruikt om de container uit te voeren (dit is de afbeelding die we eerder hebben gebouwd). We definiëren ook een volumetoewijzing.

volumes:
  - ./:/app

Dit vertelt docker-composeom de huidige directory ( ./) toe te /appwijzen aan de directory in de container. De laatste regel stelt de /appmap in de container in als de werkmap, wat betekent dat dit de map is waar alle toekomstige opdrachten in een container standaard vanaf worden uitgevoerd.

We kunnen nu onze containers orkestreren.

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

U kunt de volgende opdracht uitvoeren om ervoor te zorgen dat de PHP-container is uitgevoerd:

docker ps

Hoe opdrachten in de containers uit te voeren

Nog steeds in de appmap kunnen we elke opdracht binnen een gedefinieerde servicecontainer uitvoeren met behulp van de docker-composeopdracht.

docker-compose exec [service] [command]

De [service]tijdelijke aanduiding verwijst naar de servicesleutel. In ons geval was dit zo php. Laten we een commando in de container uitvoeren om onze PHP-versie te controleren.

docker-compose exec php php -v

Je ziet de volgende output.

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

De Nginx-container configureren

Net als de PHP-container, moeten we een aangepaste afbeelding voor de webserver maken. Maar in dit geval hoeven we alleen een configuratie voor ons op te geven virtual host. Zorg ervoor dat je in de onze zit WORKING_DIRen maak een Dockerfilebinnen de nginxmap:

cd ~/docker
touch nginx/Dockerfile

Zet hier nu de volgende inhoud in Dockerfile:

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

We gebruiken de standaard Nginx-afbeelding op basis van Alpine. Op dit Docker-bestand kopiëren we eenvoudig een configuratiebestand naar onze applicatie-setup. Maak een configuratiebestand voordat u deze afbeelding bouwt.

touch nginx/default.conf

Vul het nu met deze inhoud.

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

Merk op dat we op de fastcgi_pass php:9000regel verwijzen naar de PHP-container met zijn naam in het serviceblok van het docker-compose.ymlconfiguratiebestand. docker-composeCreëert intern een netwerk en wijst de servicenaam als hostnaam toe aan elk van de gedefinieerde services. We kunnen nu de Nginx-afbeelding bouwen.

docker build -t vultr-nginx nginx/

Updaten docker-compose.yml

Werk nu het app/docker-compose.ymlbestand bij.

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

We hebben alleen een nieuwe service toegevoegd. De configuratie is bijna hetzelfde, behalve het volgende.

depends_on:
  - php
ports:
  - 80:80

Zodra de Nginx-container de PHP-service volledig moet initialiseren, dwingen we deze vereiste in de depends_onoptie. De portsconfiguratiesleutel wijst een hostpoort toe aan een containerpoort, hier wijzen we de poort 80in de host toe aan de poort 80in de container.

Maak nu een bestand met de naam index.phpin de appmap en plaats het volgende erin.

<?php phpinfo();

Zorg ervoor dat de poort 80toegankelijk is via uw firewall en voer het volgende uit.

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

Controleer nogmaals of de service actief is.

docker ps

Open een browser en open [vultr-instance-ip]. U kunt het IP-adres van uw Vultr-instantie achterhalen door het volgende uit te voeren.

hostname -I

U ziet de PHP-infopagina.

De MySQL-container configureren

Met de officiële MySQL-image kunt u de container configureren via eenvoudige omgevingsvariabelen. Dit kan worden gedaan met een environmentoptie binnen de definitie van het serviceblok. Werk het ~/docker/app/docker-compose.ymlbestand bij naar het volgende.

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:

Nu hebben we een nieuwe service voor de database gedefinieerd. Let op de lijn dbdata:/var/lib/mysql. Hierdoor wordt het pad op de container gekoppeld /var/lib/mysqlaan een permanent volume dat wordt beheerd door Docker, op deze manier blijven de databasegegevens behouden nadat de container is verwijderd. Dit volume moet worden gedefinieerd in een blok op het hoogste niveau, zoals u aan het einde van het bestand kunt zien.

Laten we, voordat we onze nieuwe configuratie orkestreren, een voorbeeld MySQL-database downloaden. De officiële MySQL-documentatie biedt enkele voorbeelddatabases. We gaan de bekende werelddatabase gebruiken. Deze database biedt een lijst met landen en steden. Om dit voorbeeld te downloaden, voert u het volgende uit in onze app-map.

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

Laten we nu onze containers orkestreren.

docker-compose up -d

Zoals je misschien al hebt gemerkt, docker-compose upstart de opdracht alleen de containers die nog niet zijn gestart. Het controleert op de verschillen tussen uw docker-compose.ymlbestand en de huidige configuratie van actieve containers.

Controleer nog een keer of de MySQL-container is gestart.

docker ps

Vul nu de werelddatabase in.

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

U kunt controleren of de database is gevuld door gegevens rechtstreeks uit de database te selecteren. Open eerst de MySQL-prompt in de container.

docker-compose exec mysql mysql -uroot -proot world

Voer in de MySQL-prompt het volgende uit.

select * from city limit 10;

Je ziet een lijst met steden. Sluit nu de MySQL-prompt af.

mysql> exit

Onze applicatie bouwen

Nu alle benodigde containers actief zijn, kunnen we ons concentreren op onze voorbeeldtoepassing. Werk het app/index.phpbestand bij naar het volgende.

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

Als u toegang krijgt [vultr-instance-ip]in een webbrowser, ziet u een lijst met de meest bevolkte steden ter wereld. Gefeliciteerd, je hebt een volledig werkende PHP-applicatie geïmplementeerd met behulp van docker.

Gevolgtrekking

In deze tutorial heb ik stap voor stap gedemonstreerd hoe je een volledig werkende PHP-applicatie configureert. We hebben aangepaste images gemaakt voor PHP en Nginx en docker-compose geconfigureerd om onze containers te orkestreren. Ondanks dat het erg eenvoudig en eenvoudig is, weerspiegelt deze opstelling een realistisch scenario.

In deze gids hebben we onze afbeeldingen lokaal gebouwd en getagd. Voor een meer flexibele installatie kunt u deze afbeeldingen naar een docker-register pushen . U kunt pushen naar het officiële docker-register of zelfs uw eigen docker-register instellen. Hiermee kunt u in ieder geval uw afbeeldingen op de ene host bouwen en op een andere gebruiken.

Voor een meer gedetailleerd gebruik van docker-compose, moet u de officiële documentatie raadplegen .

Afhankelijk van uw toepassingsvereisten en het PHP-framework dat u gebruikt, wilt u misschien meer extensies toevoegen. Dit kan eenvoudig worden gedaan door de Dockerfilegebruikte te wijzigen om onze aangepaste PHP-afbeelding te bouwen. Sommige extensies hebben echter extra afhankelijkheden nodig om in de container te worden geïnstalleerd. Raadpleeg de lijst met extensies in de officiële PHP-documentatie om de basisvereisten van elke extensie te bekijken.