Docker-basierte PHP-Entwicklungsumgebung

Nachdruck von: http://dockone.io/article/117

[Anmerkung des Herausgebers] Der Autor dieses Artikels ist Geoffrey, er ist ein PHP-Webentwickler, der DevOps und Docker mag. In diesem Artikel wird hauptsächlich die Verwendung von Docker zum Erstellen einer PHP-Entwicklungsumgebung vorgestellt. Der Autor erläutert auch, ob ein einzelner Container oder mehrere Container zum Erstellen einer auf Docker basierenden Entwicklungsumgebung verwendet werden sollen und welche Vor- und Nachteile die einzelnen Container haben. Empfohlen für PHP-Entwickler zur Lektüre.
Viele Entwickler verwenden mittlerweile Vagrant, um ihre Entwicklungsumgebung für virtuelle Maschinen zu verwalten. Vagrant ist wirklich cool, weist aber auch viele Mängel auf (der Hauptgrund ist, dass es zu viele Ressourcen beansprucht). Nach dem Aufkommen der Container-Technologie, Docker und weiterer Docker-ähnlicher Technologien ist die Lösung dieses Problems einfach geworden.
Haftungsausschluss
Aufgrund der Funktionsweise von boot2docker funktionieren die in diesem Artikel beschriebenen Methoden möglicherweise nicht ordnungsgemäß in Ihrer Umgebung. Wenn Sie einen Ordner für einen Docker-Container in einer Nicht-Linux-Umgebung freigeben müssen, müssen Sie auf weitere zusätzliche Details achten. Ich werde einen Folgeartikel schreiben, der speziell auf die tatsächlich aufgetretenen Probleme eingeht.
Was ist eine gute Entwicklungsumgebung?
Zuerst müssen wir wissen, was eine gute Entwicklungsumgebung ist. Für mich muss eine gute Entwicklungsumgebung die folgenden Eigenschaften haben:
Sie kann verwendet werden Wille. Ich muss in der Lage sein, Umgebungen nach Belieben zu löschen und neue zu erstellen.
Schnellstart. Wenn ich damit arbeiten möchte, funktioniert es sofort.
Einfach zu aktualisieren. Die Dinge bewegen und ändern sich in unserer Branche sehr schnell und es muss für mich einfach sein, meine Entwicklungsumgebung auf neue Softwareversionen zu aktualisieren.
Docker unterstützt alle oben genannten Funktionen und noch mehr. Sie können Container fast sofort zerstören und neu erstellen, und für die Aktualisierung Ihrer Umgebung ist nur die Neuerstellung des Images erforderlich, das Sie gerade verwenden.
Was ist eine PHP-Entwicklungsumgebung?
Heutzutage sind Webanwendungen komplex und eine PHP-Entwicklungsumgebung erfordert viele Dinge. Um die Einfachheit der Umgebung sicherzustellen, müssen verschiedene Einschränkungen vorgenommen werden.
Dieses Mal verwenden wir Nginx, PHP5-FPM und MySQL, um das Synmfony-Projekt auszuführen. Da die Ausführung der Befehlszeile in einem Container komplizierter sein wird, überlasse ich diesen Aspekt dem nächsten Blog.
Haustier und Vieh
Ein weiterer wichtiger Punkt, den wir besprechen möchten, ist: Sollten wir die Entwicklungsumgebung in mehreren Containern oder in einem einzelnen Container bereitstellen? Beide Methoden haben ihre eigenen Vorteile:
Ein einziger Behälter ist einfach zu verteilen und zu warten. Da sie unabhängig sind, läuft alles im selben Container, der einer virtuellen Maschine ähnelt. Das bedeutet aber auch, dass Sie den gesamten Container neu erstellen müssen, wenn Sie etwas darin aktualisieren möchten (z. B. eine neue Version von PHP).
Mehrere Container sorgen für eine bessere Modularität beim Hinzufügen von Komponenten. Da jeder Container einen Teil des Stacks enthält: Web, PHP, MySQL usw., kann jeder Dienst unabhängig skaliert oder hinzugefügt werden, ohne dass alles neu erstellt werden muss.
Da ich faul bin und etwas anderes auf mein Notizbuch schreiben muss, stellen wir hier nur die Einzelcontainer-Methode vor.
Initialisieren Sie das Projekt
Als Erstes müssen Sie ein neues Symfony-Projekt initialisieren. Die empfohlene Methode ist die Verwendung des Composer-Befehls „create-project“. Es wäre möglich gewesen, Composer auf der Workstation zu installieren, aber das wäre zu einfach gewesen. Dieses Mal verwenden wir es über Docker.
Ich habe zuvor einen Artikel über Docker-Befehle gepostet: Docker-Befehle erstellen (ok, ich habe gelogen, ich habe es ursprünglich in diesem Artikel geschrieben und dachte dann, es wäre besser, es zu trennen).
Wie auch immer, Sie können es lesen. Wenn noch kein Composer-Befehl vorhanden ist, können Sie als Nächstes Ihren eigenen Composer-Alias ​​erstellen.
$ alias Composer="docker run -i -t -v $PWD:/srv ubermuda/composer"
Jetzt können Sie das Symfony-Projekt initialisieren:
$ Composer Create-Project Symfony/Framwork-Standard- Edition SomeProject
Super! Jetzt kommt die richtige Arbeit. (Ich lasse ein paar Balabla weg, mit denen sich der Blogger amüsiert hat ... Originaltext: Großartig. Gönnen Sie sich einen High-Five, holen Sie sich eine Tasse Kaffee oder was auch immer Ihre Lieblingsdroge ist, und machen Sie sich bereit für die eigentliche Arbeit. )
Container
Es ist ganz einfach, einen autarken Container zu erstellen, der ein Standard-Symfony-Projekt ausführt. Sie müssen nur das häufig verwendete Nginx, PHP5-FPM und MySQL-Server installieren und dann die Voreinstellungen installieren. Bereiten Sie den virtuellen Nginx-Host vor. Werfen Sie die Konfigurationsdatei ein, kopieren Sie einige Konfigurationsdateien und fertig.
Der Quellcode dieses Containers befindet sich im ubermuda/docker-symfony-Repository auf GitHub. Dockerfile ist die Konfigurationsdatei, die Docker zum Erstellen von Images verwendet:
FROM debian:wheezy
ENV DEBIAN_FRONTEND noninteractive
RUN apt-get update -y
RUN apt-get install -y nginx php5-fpm php5-mysqlnd php5-cli mysql-server supervisor
RUN sed -e 's/;daemonize = yes/daemonize = no/' -i /etc/php5/fpm/php-fpm.conf
RUN sed -e 's/;listen.owner/listen.owner/' -i /etc/php5/fpm/pool.d/www.conf
RUN sed -e 's/;listen.group/listen .group/' -i /etc/php5/fpm/pool.d/www.conf
RUN echo "ndaemon off;" /etc/nginx/nginx.conf
ADD vhost.conf / etc/nginx/sites-available/default
ADD supervisor.conf /etc/supervisor/conf.d/supervisor.conf
ADD init.sh /init.sh
EXPOSE 80 3306
VOLUME [ "/srv"]
WORKDIR /srv
CMD ["/usr/bin/supervisord"]
Wir beginnen mit der Erweiterung des debian:wheezy-Basisimages und konfigurieren dann Nginx und PHP5-FPM.
RUN sed -e 's/;daemonize = yes/daemonize = no/' -i /etc/php5/fpm/php-fpm.conf
RUN sed -e 's/;listen.owner/listen .owner/' -i /etc/php5/fpm/pool.d/www.conf
RUN sed -e 's/;listen.group/listen.group/' -i /etc/php5/fpm/pool .d/www.conf
RUN echo "ndaemon off;" >> /etc/nginx/nginx.conf
Wir müssen hier zwei Dinge tun. Konfigurieren Sie zunächst PHP5-FPM und Nginx so, dass sie im Vordergrund laufen, damit der Supervisor sie verfolgen kann.
Konfigurieren Sie dann PHP5-FPM so, dass der Webserver als angegebener Benutzer ausgeführt wird und Dateiberechtigungen verwaltet werden.
Als nächstes müssen Sie eine Reihe von Konfigurationsdateien installieren. Die erste ist die Nginx-Konfigurationsdatei für den virtuellen Host vhost.conf:
server {
listen 80;
server_name _;
access_log /. var/log/ nginx/access.log;
error_log /var/log/nginx/error.log;
root /srv/web;
index app_dev.php;
location / {
try_files $uri $uri/ /app_dev.php?$query_string;
}
location ~ [^/].php(/|$) {
fastcgi_pass unix:/var/run/php5-fpm .sock; Include Fastcgi_params;}
}
Da wir keinen Domänennamen benötigen, setzen wir den Servernamen auf Für /svr/web stellen wir die Anwendung unter /srv bereit und Der Rest ist die Standard-Mginx-PHP5-FPM-Konfiguration
Da ein Container jeweils nur eine Anwendung ausführen kann, benötigen wir Supervisord (oder einen anderen Prozessmanager, aber ich bevorzuge Supervisord). Glücklicherweise wird dieser Prozessmanager alle Prozesse hervorbringen, die wir brauchen! Das Folgende ist ein kurzer Abschnitt der Supervisord-Konfiguration:
[supervisord]
nodaemon=true
[program:nginx]
command=/usr/sbin/nginx
[program:php5-fpm ]
command=/usr/sbin/php5-fpm
[program:mysql]
command=/usr/bin/mysqld_safe
[program:init]
command=/init.sh
autorestart=false
redirect_stderr=true
redirect_stdout=/srv/app/logs/init.log
Was wir hier tun müssen, ist alle Dienste zu definieren und ein spezielles Programm hinzuzufügen: Init-Prozess, Dies ist kein tatsächlicher Dienst, sondern eine originelle Art, ein Startskript auszuführen.
Das Problem bei diesem Startskript besteht darin, dass es normalerweise erfordert, dass einige Dienste zuerst gestartet werden. Beispielsweise möchten Sie möglicherweise einige Datenbanktabellen initialisieren, jedoch nur, wenn Sie zuerst MySQL ausführen. Eine mögliche Lösung besteht darin, MySQL im Startskript zu starten und dann die Tabellen zu initialisieren, um zu verhindern, dass dies Auswirkungen auf die Prozessverwaltung hat. Sie müssen MySQL stoppen und schließlich Supervisord starten.
Ein solches Skript sieht etwa wie folgt aus:
/etc/init.d/mysql start
app/console doctrine:schema:update --force
/etc/init.d/mysql stop
exec /usr/bin/supervisord
Es sieht hässlich aus. Ändern wir die Methode und lassen Sie sie vom Supervisor ausführen und nie neu starten.
Das eigentliche init.sh-Skript lautet wie folgt:
#!/bin/bash
RET=1
while [[ RET -ne 0 ]]; do
sleep 1;
mysql -e 'exit' > /dev/null 2>&1; RET=$?
done
DB_NAME=${DB_NAME:-symfony}
mysqladmin -u root create $DB_NAME
if [ -n "$INIT" ]; then
/srv/$INIT
fi
Das Skript wartet zunächst auf den Start von MySQL und erstellt dann eine Datenbank entsprechend der Umgebungsvariablen DB_NAME, die standardmäßig symfony ist und sucht dann nach dem gewünschten Wert in der INIT-Umgebungsvariablen. Führen Sie das Skript aus und versuchen Sie, es auszuführen. Am Ende dieses Artikels wird erläutert, wie diese Umgebungsvariablen verwendet werden.
Erstellen Sie das Image und führen Sie es aus
Alles ist bereit, alles was Sie brauchen ist der Ostwind. Wir müssen auch das Symfony-Docker-Image mit dem Docker-Build-Befehl erstellen:
$ cd docker-symfony
$ docker build -t symfony .
Jetzt können Sie es verwenden, um Ihr Symfony-Projekt auszuführen:
$ cd SomeProject
$ docker run -i -t -P -v $PWD:/srv symfony
Sehen wir uns an, was diese Reihe von Optionen bewirkt:
-i Interaktiv starten (interaktiv) Der STDIO-Modus (Standard-Eingang und -Ausgang) ist mit Ihrem aktuellen Terminal verbunden. Dies ist nützlich, wenn Sie Protokolle empfangen oder Signale an einen Prozess senden möchten.
-t erstellt ein virtuelles TTY für den Container. Es ist ein guter Freund von -i und wird normalerweise zusammen verwendet.
-P weist den Docker-Daemon an, alle angegebenen Ports zu veröffentlichen, in diesem Fall Port 80.
-v $PWD:/srv Mounten Sie das aktuelle Verzeichnis im /srv-Verzeichnis des Containers. Durch das Mounten eines Verzeichnisses wird der Inhalt des Verzeichnisses für den Ziel-Mountpunkt verfügbar gemacht.
Jetzt erinnern Sie sich noch an die zuvor erwähnten Umgebungsvariablen DB_NAME und INIT. Warum werden sie verwendet: um Ihre Umgebung anzupassen. Grundsätzlich können Sie Umgebungsvariablen im Container über die Option -e von Docker Run festlegen. Wenn Ihre Datenbank also some_project_dev heißt, können Sie den Container wie folgt ausführen:
$ docker run - i -t -P -v $PWD:/srv -e DB_NAME=some_project_dev Die Umgebungsvariable symfony
INIT ist noch leistungsfähiger und ermöglicht es Ihnen, ein bestimmtes Skript beim Start auszuführen.Sie verfügen beispielsweise über ein bin/setup-Skript, das den Composer-Installationsbefehl ausführt und das Datenbankschema festlegt:
#!/bin/bash
composer install
app/console doctrine:schema:update --force
Verwenden Sie -e, um es auszuführen:
$ docker run -i -t -P
-v $PWD:/srv
-e DB_NAME=some_project_dev
-e INIT=bin/setup
Hinweis: Die Option -e kann in docer run mehrmals verwendet werden, was ziemlich cool aussieht. Darüber hinaus benötigt Ihr Startskript ausführbare Berechtigungen (chmod x).
Jetzt senden wir per Curl eine Anfrage an den Container, um zu prüfen, ob alles wie erwartet funktioniert. Zuerst müssen wir den öffentlichen Port von Docker dem Port 80 des Containers zuordnen und den Docker-Port-Befehl verwenden:
$ docker port $(docker ps -aql 1) 80
0.0.0.0:49153
docker ps -aql 1 ist ein nützlicher Befehl, der die ID des letzten Containers einfach abrufen kann. In unserem Beispiel ordnet Docker den Port 80 des Containers dem Port 49153 zu. Lassen Sie es uns zusammenrollen und einen Blick darauf werfen.
$ curl http://localhost:49153
Sie dürfen nicht auf diese Datei zugreifen, um weitere Informationen zu erhalten.
Wenn wir nicht über localhost darauf zugreifen (Anmerkung des Übersetzers: localhost des Container) Dev-Controller, erhalten Sie die Standardfehlermeldung von Symfony. Das ist völlig normal. Da wir die Curl-Anfrage nicht aus dem Container heraus senden, können Sie diese Zeilen bedenkenlos aus der Datei web/app_dev.php entfernen.
// Diese Prüfung verhindert den Zugriff auf Debug-Front-Controller, die versehentlich auf Produktionsservern bereitgestellt werden.
// Sie können dies jederzeit entfernen, erweitern oder etwas komplexeres erstellen.
if (isset($ _SERVER['HTTP_CLIENT_IP'])
||. isset($_SERVER['HTTP_X_FORWARDED_FOR'])
!(in_array(@$_SERVER['REMOTE_ADDR'], array('127.0.0.1', 'fe80 ::1', '::1')) ||. php_sapi_name() === 'cli-server')
) {
header('HTTP/1.0 403 Forbidden');
exit( 'Sie sind nicht berechtigt, auf diese Datei zuzugreifen. Überprüfen Sie '.basename(__FILE__).'
Jetzt kann es normal funktionieren, wenn Sie es aufrollen oder einen Browser verwenden, um auf http://localhost:49153/ zuzugreifen:
result.png
Es ist ganz einfach! Jetzt können wir die Umgebung schnell starten und aktualisieren, aber es gibt noch viele Bereiche, die verbessert werden müssen.
Ursprünglicher Link: Eine PHP-Entwicklungsumgebung mit Docker (Übersetzer: He Linchong Rezensent: Guo Lei)