Dockerizing LEMP Stack mit Docker-Compose auf Ubuntu
Docker-Compose ist ein Befehlszeilenwerkzeug zur Definition und Verwaltung von Multi-Container-Docker-Anwendungen. Compose ist ein Python-Skript, das mit dem pip-Befehl einfach installiert werden kann (pip ist der Befehl zur Installation der Python-Software aus dem python-Paket-Repository). Mit compose können wir mehrere Docker-Container mit einem einzigen Befehl ausführen. Es ermöglicht Ihnen, einen Container als Dienst zu erstellen, der sich ideal für Ihre Entwicklungs-, Test- und Stagingumgebung eignet.
In diesem Tutorial werde ich Sie Schritt für Schritt durch die Verwendung von docker-compose zur Erstellung einer LEMP-Stack-Umgebung (LEMP = Linux – Nginx – MySQL – PHP) führen. Wir werden alle Komponenten in verschiedenen Docker-Containern ausführen, wir richten einen Nginx-Container, PHP-Container, PHPMyAdmin-Container und einen MySQL/MariaDB-Container ein.
Voraussetzungen
- Ubuntu-Server 16.04 -64bit
- Root-Rechte
Schritt 1 – Docker installieren
In diesem Schritt werden wir Docker installieren. Docker ist im Ubuntu-Repository verfügbar, aktualisieren Sie einfach Ihr Repository und installieren Sie es dann.
Aktualisieren Sie das Ubuntu-Repository und das Upgrade:
sudo apt-get update sudo apt-get upgrade
Installieren Sie das neueste Docker aus dem Ubuntu-Repository.
sudo apt-get install -y docker.io
Starten Sie den Docker und aktivieren Sie ihn so, dass er beim Booten startet:
systemctl start docker systemctl enable docker
Die Docker-Dienste werden ausgeführt.
Als nächstes können Sie versuchen, Docker mit dem folgenden Befehl zu verwenden, um es zu testen:
docker run hello-world
Hallo Welt von Docker.
Schritt 2 – Docker-Compose installieren
Im ersten Schritt haben wir Docker bereits installiert. Nun werden wir Docker-Compose installieren.
Wir benötigen python-pip für die Compose-Installation, installieren python und python-pip mit apt:
sudo apt-get install -y python python-pip
Wenn die Installation abgeschlossen ist, installieren Sie das Docker mit dem Befehl pip.
pip install docker-compose
Überprüfen Sie nun die Docker-Compose-Version:
docker-compose --version
Docker-compose wurde installiert.
Schritt 3 – Erstellen und Konfigurieren der Docker-Umgebung
In diesem Schritt werden wir unsere Docker-Compose-Umgebung aufbauen. Wir werden einen Nicht-Root-Benutzer verwenden, also müssen wir diesen Benutzer jetzt anlegen.
Füge einen neuen Benutzer namens‘hakase‚ hinzu (wähle hier deinen eigenen Benutzernamen, wenn du möchtest):
useradd -m -s /bin/bash hakase passwd hakase
Als nächstes fügen Sie den neuen Benutzer zur Gruppe „docker“ hinzu und starten Sie das Docker neu.
usermod -a -G docker hakase sudo systemctl restart docker
Nun kann der Benutzer‘hakase‚ den Docker ohne sudo verwenden.
Als nächstes loggen Sie sich vom Root-Benutzer aus mit su in den ‚hakase‘ Benutzer ein.
su - hakase
Erstellen Sie ein neues Verzeichnis für die Kompositionsumgebung.
mkdir lemp-compose/ cd lemp-compose/
Dies ist unsere Docker-Compose-Umgebung, alle Dateien, die sich im Docker-Container befinden sollen, müssen sich in diesem Verzeichnis befinden. Wenn wir docker-compose verwenden, benötigen wir eine .yml-Datei namens‘docker-compose.yml‚.
Erstellen Sie im Verzeichnis’lemp-compose‘ einige neue Verzeichnisse und eine docker-compose.yml-Datei:
touch docker-compose.yml
mkdir -p {logs,nginx,public,db-data}
- Protokolle: Verzeichnis für Nginx-Protokolldateien.
- nginx: enthält Nginx-Konfiguration wie virtueller Host etc.
- public: Verzeichnis für Webdateien, index.html und PHP-Infodatei.
- db-data: MariaDB Datenverzeichnis Volumen.
Erstellen Sie die Protokolldateien error.log und access.log im Verzeichnis ‚logs‚.
touch logs/{error,access}.log
Erstellen Sie eine neue Konfigurationsdatei für den virtuellen Host von nginx im Verzeichnis „nginx„:
vim nginx/app.conf
Füge die Konfiguration unten ein:
upstream php {
server phpfpm:9000;
}
server {
server_name 193.70.36.50;
error_log "/opt/bitnami/nginx/logs/myapp-error.log";
access_log "/opt/bitnami/nginx/logs/myapp-access.log";
root /myapps;
index index.php index.html;
location / {
try_files $uri $uri/ /index.php?$args;
}
location ~ \.php$ {
include fastcgi.conf;
fastcgi_intercept_errors on;
fastcgi_pass php;
}
location ~* \.(js|css|png|jpg|jpeg|gif|ico)$ {
expires max;
log_not_found off;
}
}
Speichern Sie die Datei und beenden Sie vim.
Erstellen Sie eine neue index.html-Datei und eine PHP-Infodatei im Verzeichnis ‚public‚.
echo '<h1>LEMP Docker-Compose</h1><p><b>hakase-labs</b>' > public/index.html echo '<?php phpinfo(); ?>' > public/info.php
Nun können Sie das Umgebungsverzeichnis wie unten gezeigt sehen:
tree
Schritt 4 – Konfiguration der Datei docker-compose.yml
Im vorherigen Schritt haben wir die Verzeichnisse und Dateien erstellt, die für unsere Container benötigt werden. In diesem Schritt möchten wir die Datei‘docker-compose.yml‚ bearbeiten. In der Datei docker-compose.yml definieren wir unsere Dienste für den LEMP-Stapel, die Basisbilder für jeden Container und die Docker-Volumes.
Melden Sie sich beim Benutzer‘hakase‚ an und bearbeiten Sie die Datei docker-compose.yml mit vim:
su - hakase cd lemp-compose/ vim docker-compose.yml
– Nginx-Dienste definieren
Fügen Sie die untenstehende nginx-Konfiguration ein:
nginx: image: 'bitnami/nginx' ports: - '80:80' links: - phpfpm volumes: - ./logs/access.log:/opt/bitnami/nginx/logs/myapp-access.log - ./logs/error.log:/opt/bitnami/nginx/logs/myapp-error.log - ./nginx/app.conf:/bitnami/nginx/conf/vhosts/app.conf - ./public:/myapps
In dieser Konfiguration haben wir bereits definiert:
- nginx: Name des Dienstes
- Bild: Wir verwenden‘bitnami/nginx‚ Docker-Bilder.
- Ports: Setzen Sie den Container-Port 80 dem Host-Port 80 aus.
- Links: verbindet den Servicecontainer‘nginx‚ mit dem Container‘phpfpm‚.
- Volumes: Mounten Sie lokale Verzeichnisse in den Container. Mounten Sie das Verzeichnis der Protokolldatei, mounten Sie die Konfiguration des virtuellen Nginx-Hosts und mounten Sie das Web-Root-Verzeichnis.
– PHP-fpm-Dienste definieren
Fügen Sie die Konfiguration unter dem Nginx-Block ein:
phpfpm: image: 'bitnami/php-fpm' ports: - '9000:9000' volumes: - ./public:/myapps
Wir haben hier definiert:
- phpfpm: Definiere den Servicenamen.
- Bild: Definieren Sie das Basisbild für den phpfpm-Dienst mit dem Bild’bitnami/php-fpm‚.
- Ports: Wir betreiben PHP-fpm mit TCP-Port 9000 und stellen den Port 9000 dem Host zur Verfügung.
- Volumes: mounten Sie das Web-Root-Verzeichnis ‚public‚ auf ‚myapps‚ auf dem Container.
– MySQL-Dienst definieren
Fügen Sie im dritten Block die untenstehende Konfiguration für den MariaDB-Service-Container ein:
mysql: image: 'mariadb' ports: - '3306:3306' volumes: - ./db-data:/var/lib/mysql environment: - MYSQL_ROOT_PASSWORD=hakase-labs123
Hier können Sie sehen, dass wir verwenden:
- mysql: als Servicename.
- Bild: Der Container basiert auf‘mariadb‚ Docker-Bildern.
- Ports: Service-Container, der Port 3306 für die MySQL-Verbindung verwendet, und stellen Sie ihn dem Host auf Port 3306 zur Verfügung.
- Volumes: db-data Verzeichnis mysql
- Umgebung: Setzen Sie die Umgebungsvariable‘MYSQL_ROOT_PASSWORD‚ für das mysql root-Passwort auf die Docker-Images, die beim Erstellen des Containers ausgeführt werden.
– Konfiguration der PHPMyAdmin-Dienste
Im letzten Block fügen Sie die folgende Konfiguration ein:
phpmyadmin: image: 'phpmyadmin/phpmyadmin' restart: always ports: - '8080:80' links: - mysql:mysql environment: MYSQL_USERNAME: root MYSQL_ROOT_PASSWORD: hakase-labs123 PMA_HOST: mysql
Wir verwenden ein ‚phpmyadmin‘ Docker-Image, mappen den Container-Port 80 bis 8080 auf dem Host, verbinden den Container mit dem mariadb-Container, setzen immer einen Neustart und setzen einige Umgebungsvariablen des Docker-Images, einschließlich des Sets’PMA_HOST‚.
Speichern Sie die Datei und beenden Sie vim.
Du kannst das vollständige Beispiel auf github sehen.
Schritt 5 – Ausführen von Docker-Compose
Jetzt sind wir bereit, Docker-Compose zu starten. Hinweis: Wenn Sie docker-compose ausführen möchten, müssen Sie sich im Projektverzeichnis von docker-compose befinden und sicherstellen, dass es die yml-Datei mit der Compose-Konfiguration gibt.
Führen Sie den folgenden Befehl aus, um den LEMP-Stapel hochzufahren:
docker-compose up -d
–d: läuft als Daemon oder Hintergrund
Sie werden das Ergebnis sehen, dass die neuen Container erstellt wurden, überprüfen Sie es mit dem folgenden Befehl:
docker-compose ps
Jetzt haben wir vier Container mit Nginx, PHP-fpm, MariaDB und PHPMyAdmin.
Schritt 6 – Prüfung
Überprüfen von Ports, die vom Docker-Proxy auf dem Host verwendet werden.
netstat -plntu
Wir sehen Port 80 für den Nginx-Container, Port 3306 für den MariaDB-Container, Port 9000 für den php-fpm-Container und Port 8080 für den PHPMyAdmin-Container.
Greifen Sie über den Webbrowser auf Port 80 zu, und Sie sehen unsere Datei index.html.
http://serverip-address/
Stellen Sie sicher, dass PHP-fpm läuft, greifen Sie über den Webbrowser darauf zu.
http://serverip-address/info.php
Zugriff auf den MySQL-Container in der MySQL-Shell.
docker-compose exec mysql bash mysql -u root -p TYPE MYSQL PASSWORD: hakase-labs123
Erstellen Sie nun eine neue Datenbank:
create database hakase_db; exit
MariaDB mysql shell container ist zugänglich, und wir haben eine neue Datenbank ‚hakase_db‚ erstellt.
Als nächstes greifen Sie auf PHPMyAdmin auf Port 8080 zu: http://serverip-address:8080/.
Du wirst die PHPMyAdmin-Anmeldeseite sehen, gib einfach den Benutzernamen‘root‚ ein und das Passwort lautet‘hakase-labs123‚.
Sie werden automatisch mit dem mysql-Container verbunden, der in der Umgebungsvariablen PMA_HOST definiert wurde.
Klicken Sie auf „Go“ und Sie sehen das phpmyadmin Dashboard, das mit dem Container „mysql“ verbunden ist.
Erfolgreich! Der LEMP Stack läuft unter einem Docker-Compose-Setup, das aus vier Containern besteht.