Explication détaillée des étapes pour créer un environnement de développement PHP avec Docker

Cette fois, je vais vous apporter une explication détaillée des étapes pour créer un environnement de développement PHP avec Docker Quelles sont les précautions et ce qui suit est un cas pratique, jetons un coup d'œil.

1. Introduction

1.1 Pourquoi utiliser Docker ?

Existe-t-il un scénario dans lequel vous avez un projet et vous devez mettre en place un environnement lorsque vous le développez localement, et vous devez également mettre en place un environnement lorsque vous le mettez en ligne lorsque vous vous rendez dans l'entreprise ? et que vous voulez jouer en secret, vous devez créer un environnement, mais cela ne fonctionne pas encore, car vous avez pas mal de dépendances environnementales. Si vous avez Docker à ce moment-là, il vous suffit d'installer Docker sur la machine, de mettre le fichier Docker écrit et une ligne de commande terminera automatiquement la tâche , ce qui est pratique et efficace, n'est-ce pas. être génial ?

1.2 Préparation

Ensuite, cet article présente comment créer un environnement de développement PHP, en utilisant zPhal-dockerfiles comme exemple. Il s'agit d'un ensemble de fichiers Docker que j'ai préparés pour mon système de blog.

Maintenant, qu'il s'agisse de Windows, Mac ou Linux, Docker peut très bien le prendre en charge, y compris les systèmes Windows sous Win 10, Docker pour Windows est en fait assez bon, mais il consomme plus de mémoire.

Grâce à la ligne de commande Docker, nous pouvons faire beaucoup de choses, extraire des images, exécuter des conteneurs, exécuter des commandes dans le conteneur, etc., mais maintenant, nous devons utiliser une manière plus simple et plus grossière d'écrire Dockerfiles, puis utilisez docker -compose gère ces fichiers et simplifie le processus de fonctionnement.

Qu'est-ce qu'un Dockerfile ?

Dockerfile est un script composé d'une série de commandes et de paramètres. Ces commandes sont appliquées à l'image de base extraite et créent enfin une nouvelle image grâce à Dockerfile, nous pouvons créer une image dont vous avez besoin, qui contient le logiciel dont vous avez besoin. vouloir installer équivaut à personnaliser les extensions à installer, les commandes à exécuter, etc., puis à les exécuter en un seul clic, simplifiant grandement le processus de fonctionnement.

Pour créer un environnement selon cet article, vous avez besoin de :

Tout d'abord, comprendre Docker et certaines opérations de base de Docker, et ce qu'est docker-compose.
Docker et docker-compose doivent ensuite être installés, j'utiliserai docker-compose pour gérer mes Dockerfiles.
Notez que l'écriture d'un Dockerfile est une chose vivante, pas une chose morte. Le Dockerfile écrit par chacun sera différent, en fonction de vos besoins.

La documentation officielle de Docker est très claire, même si elle est en anglais, elle contient essentiellement tout. Si vous avez des questions, il est très judicieux de vous référer au document : Docker Documentation.

2. Commencez à écrire

Ce qui suit prendra les fichiers zPhal-docker comme exemple. Vous pouvez cliquer sur le lien pour voir le fichier complet. Ce qui suit n'est qu'un fragment.

Aperçu 2.1

Tout d'abord, jetons un coup d'œil au projet Dockerfile que j'ai créé. Je l'ai grossièrement divisé dans les répertoires suivants (bien sûr, cela est déterminé par moi-même, et c'est le cas). il n'est pas nécessaire d'être formaté de cette façon pour vous. fichier) :

zPhal-dockerfiles
app/
 index.php
 phpinfo.php
data/
 .gitignore
files/
 mysql/
 conf.d/
  mysql-file.cnf
 Dockerfile
 nginx/
 conf.d/
  default.conf
  zphal.conf
 Dockerfile
 nginx.conf
 php/
 pkg/
  .gitignore
 Dockerfile
 php.ini
 php-dev.ini
 php-fpm.conf
 redis/
 Dockerfile
 docker-compose.yml
logs/
.gitgnore
README.md

Dans ce projet, j'ai utilisé les extensions PHP, MySQL, Nginx, Redis, Composer, Phalcon, etc.

En général, nous avons trois processus pour ce faire : écrire le Dockerfile de chaque logiciel ; écrire le fichier de configuration ; traiter tous les Dockerfiles via docker-compose, y compris le fichier de configuration. jeté dans l’image que le Dockerfile va construire.

2.2 Écriture d'un Dockerfile

2.2.1 PHP

Ce qui suit est le Dockerfile de PHP :

FROM php:7.2-fpm

MAINTAINER goozp "gzp@goozp.com"
Définir le fuseau horaire

ENV TZ=Asia/Shanghai

RUN ln -snf /usr/share/zoneinfo/$TZ /etc/ localtime && echo $TZ > /etc/timezone

Mettre à jour et installer les packages de dépendances et les extensions de base PHP

RUN apt-get update && apt-get install -y \
git \
libfreetype6-dev \
libjpeg62-turbo-dev \
libpng-dev \
&& docker-php-ext-configure gd --with-freetype-dir=/usr/include/ --with-jpeg-dir=/usr/include/ \
&& docker-php-ext-install -j$(nproc) gd \
&& docker-php-ext-install zip \
&& docker-php-ext-install pdo_mysql \
&& docker-php-ext-install opcache \
&& docker-php-ext-install mysqli \
&& rm -r /var/lib/apt/lists/*

Copiez le package d'extension pré-téléchargé à partir de la machine hôte

COPY ./pkg/redis.tgz /home/redis.tgz
COPY ./pkg/cphalcon.tar.gz /home/cphalcon.tar.gz

Installez l'extension PECL, ici nous installons Redis

RUN pecl install /home/redis.tgz && echo "extension=redis.so" > d/redis.ini

Installer les extensions tierces, voici l'extension Phalcon

RUN cd /home \
&& tar -zxvf cphalcon.tar.gz \
&& mv cphalcon-* phalcon \
&& cd phalcon/build \
&& ./install \
&& echo "extension=phalcon.so" > /usr/local/etc/php/conf.d/phalcon.ini

Installer Composer

ENV COMPOSER_HOME /root/composer
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
ENV PATH $COMPOSER_HOME/vendor/bin:$PATH
RUN rm -f /home/redis.tgz \
rm -f /home/cphalcon.tar.gz 
WORKDIR /data
Write Permission
RUN usermod -u 1000 www-data

La première ligne définit l'image de base, ici we Utilisant la version fpm de PHP 7.2, la deuxième ligne définit ici un responsable.

Ensuite, le fuseau horaire est défini. Cette phrase est définie dans chaque Dockerfile, principalement pour synchroniser l'heure de tous les conteneurs avec l'hôte. En fait, nous pouvons la définir comme ceci dans le fichier docker-composer.yml :

services :

php-fpm :

volumes :

- /etc/localtime:/etc/localtime:ro
Mais en non- Systèmes Linux, par exemple, lors de l'exécution sous Windows, nous ne pouvons pas obtenir /etc/localtime Afin d'être plus compatible avec toutes les plates-formes, j'ai écrit la synchronisation de l'heure dans le Dockerfile.

Ensuite, installez quelques extensions. En fait, le processus d'installation des extensions est similaire à la façon dont nous installons les extensions PHP sous Linux à mains nues. J'ai installé Composer directement dans l'image php-fpm. En fait, l'image officielle de Composer est également fournie. Extraire l'image Composer pour l'exécution peut également atteindre l'objectif, car nous utilisons Composer uniquement pour exécuter la commande Composer pour gérer nos packages. Si Composer S'il s'agit d'un conteneur séparé, nous pouvons désactiver le conteneur lorsqu'il n'est pas utilisé ; mais ici, j'ai directement installé Composer dans l'image php-fpm, principalement parce que mon projet a installé des extensions PHP, et après avoir écrit composer.json. Lors de l'écriture du fichier, j'ai défini les dépendances de l'extension, de sorte que lorsque Composer est exécuté, il vérifie si l'environnement a installé ces dépendances. Donc, si j'utilise directement l'image Composer, je dois également installer l'extension que j'utilise. l'image, ce qui est beaucoup plus gênant, donc je l'ai fait directement dans l'image PHP. Il n'y a en fait aucune différence, cela dépend de la façon dont vous l'utilisez.

2.2.2 Nginx

Ce qui suit est le Dockerfile de Nginx :

FROM nginx:1.12
set timezome

ENV TZ=Asia/ Shanghai

RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone

C'est beaucoup plus simple, je règle seulement une heure . Comme je n’ai rien d’autre à installer, je peux utiliser directement l’image officielle.

Bien sûr, nous devons modifier le fichier de configuration. Écrivez simplement le fichier de configuration à l'avance. Enfin, dans le fichier docker-compose.yml, ajoutez le fichier de configuration. Cela sera discuté ci-dessous, y compris le fichier. fichier de configuration de PHP et MySQL Les fichiers de configuration sont tous identiques.

2.2.3 MySQL

Ce qui suit est le Dockerfile de MySQL :

FROM mysql:5.7
set timezome

ENV TZ =Asie /Shanghai

RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone

MySQL n'a rien de spécial soit, utilisez directement l’image officielle.

2.2.4 Redis

Ce qui suit est Redis, et l'image officielle est également utilisée directement :

FROM redis:3.2
set timezome

ENV TZ=Asie/Shanghai

RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > 🎜>2.3 Écriture des fichiers de configuration

Comment traiter les fichiers de configuration ? Je catégorise les fichiers de configuration PHP sont placés dans le répertoire PHP, et les fichiers de configuration Nginx sont placés dans le répertoire Nginx. un nouveau sous-fichier Le dossier dépend de la situation, comme le dossier conf.d.

Ce qui suit prend le fichier de configuration Nginx comme exemple. Tout d'abord, le répertoire Nginx est le suivant :

nginx/

conf.d/

. default.conf

>

zphal.conf

Dockerfile

nginx.conf

En plus de nginx.conf, il existe également un sous-dossier conf.d pour stocker tous les noms de domaine Les fichiers de configuration devraient être familiers à ceux qui ont construit un environnement PHP sous Linux. Ces fichiers de configuration sont les fichiers que nous transférerons vers le conteneur à ce moment-là. Nous n'utiliserons pas ces fichiers sur l'hôte.

La chose la plus importante à noter est donc que le chemin qui apparaît dans le fichier de configuration est le chemin d'accès à l'environnement dans le conteneur, et non le chemin d'accès à l'hôte. Chaque conteneur a un environnement en cours d'exécution, qui est un. micro Pour les petits systèmes, ces chemins sont tous des chemins à l'intérieur du conteneur. Nous pouvons synchroniser les fichiers en montant et en communiquant au sein du conteneur. Le démarrage du conteneur sur la ligne de commande nécessite également de monter le chemin du fichier. Maintenant, nous utilisons également docker-compose pour résoudre cette étape.

Voici un exemple de fichier de configuration :

server {
listen 80 default;
index index.html index.htm;
server_name localhost docker;
root /data/www;
index index.php index.html index.htm;
location / {
 try_files $uri $uri/ /index.html;
}
location ~ \.php {
 include fastcgi_params;
 fastcgi_pass php-fpm:9000;
 fastcgi_index index.php;
 fastcgi_param SCRIPT_FILENAME /data/www/$fastcgi_script_name;
}
}

而root /data/www中，/data/www路径，是到时候Nginx容器的路径，而不是当前在操作的宿主机的路径，所以到时候我们要挂载Web程序放的位置到这个路径。

2.4 编写 docker-compose.yml

在PHP、Nginx等目录的同级，我们创建一个docker-compose.yml，我们在执行docker-compose相关命令时，会自动找到这个文件，并根据里面的内容来执行。

接上面Nginx的例子，我们先谈挂载，因为这是最重要的一步。在docker-compose.yml中，Nginx的部分：

build: ./nginx
depends_on:
 - php-fpm
links:
 - php-fpm:php-fpm
volumes:
 - ../app:/data/www:rw
 - ./nginx/conf.d:/etc/nginx/conf.d:ro
 - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
 - ../logs/nginx:/var/log/nginx
ports:
 - "80:80"
 - "8080:8080"
 - "443:443"
restart: always
command: nginx -g 'daemon off;'

有一个volumes参数，这里就是我们要挂载的目录的相关配置，第一条我们将../app挂载到/data/www之中，也是我们配置文件中定义的默认监听的root，而APP目录是我们宿主机中的一个目录，通过这样挂载我们可以直接将我们的项目文件放到APP中，Docker会帮你传输到容器内的/data/www目录下。

其它的参数：

build定义了你的Dockerfile在哪里，如果没有写Dockerfile可以不用build，可以用images参数定义官方镜像，比如image:mysql:5.7；
depends_on表示将依赖其它镜像，比如Nginx依赖php-fpm，没有它我Nginx没法玩；
links定义连接，比如要连接到php-fpm容器，就是php-fpm:php-fpm，后面是别名；
ports表示端口映射，80:80表示将80端口映射到宿主机的80端口；
restart重启，restart: always表示将自动重启；
command是自动执行的命令；
……
参数很多，更多的可以参考官方文档。

下面是一个完整的 docker-compose.yml 文件：

version: '3.2'
services:
php-fpm:
build: ./php/
ports:
 - "9000:9000"
links:
 - mysql-db:mysql-db
 - redis-db:redis-db
volumes:
 - ../app:/data/www:rw
 - ./php/php-dev.ini:/usr/local/etc/php/php.ini:ro
 - ./php/php-fpm.conf:/usr/local/etc/php-fpm.conf:ro
 - ../logs/php-fpm:/var/log/php-fpm:rw
restart: always
command: php-fpm
nginx:
build: ./nginx
depends_on:
 - php-fpm
links:
 - php-fpm:php-fpm
volumes:
 - ../app:/data/www:rw
 - ./nginx/conf.d:/etc/nginx/conf.d:ro
 - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
 - ../logs/nginx:/var/log/nginx
ports:
 - "80:80"
 - "8080:8080"
 - "443:443"
restart: always
command: nginx -g 'daemon off;'
mysql-db:
 build: ./mysql
 ports:
 - "3306:3306"
 volumes:
 - ../data/mysql:/var/lib/mysql:rw
 - ../logs/mysql:/var/lib/mysql-logs:rw
 - ./mysql/conf.d:/etc/mysql/conf.d:ro
 environment:
 MYSQL_ROOT_PASSWORD: 123456
 MYSQL_DATABASE: zphaldb
 MYSQL_USER: zphal
 MYSQL_PASSWORD: zphal123
 restart: always
 command: "--character-set-server=utf8"
redis-db:
 build: ./redis
 ports:
 - "6379:6379"
 volumes:
 - ../data/redis:/data
 restart: always

3. 使用

这一套编写下来，我们怎么用呢？

3.1 使用搭建好的环境

首先，进入项目Dockerfiles的目录下，这里是files目录：

cd zPhal-dockerfiles/files

wget https://pecl.php.net/get/redis-3.1.6.tgz -O php/pkg/redis.tgz

wget https://codeload.github.com/phalcon/cphalcon/tar.gz/v3.3.1 -O php/pkg/cphalcon.tar.gz
然后下载我们会用到的PHP拓展包。

执行命令：

docker-compose up
Docker会自动通过编写好的docker-compose.yml内容构建镜像，并且启动容器。

如果没问题，下次启动时可以以守护模式启用，所有容器将后台运行：

docker-compose up -d
关闭容器：

可以这样关闭容器并删除服务：

docker-compose down
使用 docker-compose 基本上就这么简单，用stop，start等这些命令来操纵容器服务。而更多的工作是在于编写Dockerfile和docker-compose.yml文件。

3.2 使用Composer

当我们要使用Composer时怎么做呢？ 我们已经在php-fpm里安装了Composer。

用docker-compose进行操作：

docker-compose run --rm -w /data/www/zPhal php-fpm composer update
-w /data/www/zPhal为在php-fpm的工作区域，zPhal项目也是挂载在里面，所有我们可以直接在容器里运行Composer。

或者进入宿主机APP目录下用Docker命令：

cd zPhal-dockerfiles/app

docker run -it --rm -v `pwd`:/data/www/ -w /data/www/zPhal files_php-fpm composer update

4. 注意事项

注意挂载路径。
构建失败时，注意容器内是否报错。
加速镜像。如果过程下载镜像很慢，可以使用国内的加速镜像服务。

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

LaravelS通过Swoole加速Laravel/Lumen步骤详解

php连接MSsql server方式方法总结

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!