Docker-Compose ist ein Befehlszeilentool zum Definieren und Verwalten von Docker-Anwendungen mit mehreren Containern. Compose ist ein Python-Skript, das einfach mit dem Befehl pip installiert werden kann (pip ist der Befehl zum Installieren von 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 hervorragend für Ihre Entwicklungs-, Test- und Staging-Umgebung eignet.
In dieser Anleitung führe ich Sie Schritt für Schritt durch die Verwendung von docker-compose zum Erstellen einer LEMP-Stack-Umgebung (LEMP =Linux – Nginx – MySQL – PHP). 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 -64 Bit
- Root-Rechte
Schritt 1 – Docker installieren
In diesem Schritt installieren wir Docker. Docker ist im Ubuntu-Repository verfügbar, aktualisieren Sie einfach Ihr Repository und installieren Sie es dann.
Ubuntu-Repository aktualisieren und upgraden:
sudo apt-get update
sudo apt-get upgrade
Installieren Sie den neuesten Docker aus dem Ubuntu-Repository.
sudo apt-get install -y docker.io
Docker starten und beim Booten starten lassen:
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 testen:
docker run hello-world
Hallo Welt von Docker.
Schritt 2 – Docker-Compose installieren
Im ersten Schritt haben wir Docker bereits installiert. Jetzt installieren wir docker-compose.
Wir brauchen python-pip für die Compose-Installation, installiere python und python-pip mit apt:
sudo apt-get install -y python python-pip
Wenn die Installation abgeschlossen ist, installieren Sie docker-compose 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 – Docker-Umgebung erstellen und konfigurieren
In diesem Schritt erstellen wir unsere Docker-Compose-Umgebung. Wir werden einen Nicht-Root-Benutzer verwenden, also müssen wir diesen Benutzer jetzt erstellen.
Fügen Sie einen neuen Benutzer namens „hakase“ hinzu ' (wählen Sie hier Ihren eigenen Benutzernamen, wenn Sie möchten):
useradd -m -s /bin/bash hakase
passwd hakase
Fügen Sie als Nächstes den neuen Benutzer zum 'Docker hinzu ' gruppieren und Docker neu starten.
usermod -a -G docker hakase
sudo systemctl restart docker
Jetzt wird der Benutzer 'hakase ' kann Docker ohne sudo verwenden.
Melden Sie sich als Nächstes vom Root-Benutzer mit su beim Benutzer „hakase“ an.
su - hakase
Erstellen Sie ein neues Verzeichnis für die Compose-Umgebung.
mkdir lemp-compose/
cd lemp-compose/
Dies ist unsere Docker-Compose-Umgebung, alle Dateien, die im Docker-Container sein sollen, müssen in diesem Verzeichnis liegen. Wenn wir docker-compose verwenden, benötigen wir eine .yml-Datei mit dem Namen „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 usw.
- öffentlich :Verzeichnis für Webdateien, index.html und PHP-Infodatei.
- DB-Daten :Volume des MariaDB-Datenverzeichnisses.
Erstellen Sie die Protokolldateien error.log und access.log in den 'logs ' Verzeichnis.
touch logs/{error,access}.log Erstellen Sie eine neue Konfigurationsdatei für den virtuellen nginx-Host in der Datei „nginx ' Verzeichnis:
vim nginx/app.conf
Konfiguration unten einfügen:
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-Info-Datei im Verzeichnis „public ' Verzeichnis.
echo '<h1>LEMP Docker-Compose</h1><p><b>hakase-labs</b>' > public/index.html
echo '<?php phpinfo(); ?>' > public/info.php
Jetzt können Sie das Umgebungsverzeichnis wie unten gezeigt sehen:
tree
Schritt 4 - Konfiguration der docker-compose.yml-Datei
Im vorherigen Schritt haben wir die Verzeichnisse und Dateien erstellt, die für unsere Container benötigt werden. In diesem Schritt wollen wir die Datei 'docker-compose.yml bearbeiten '. In der Datei docker-compose.yml definieren wir unsere Dienste für den LEMP-Stack, die Basis-Images für jeden Container und die Docker-Volumes.
Melden Sie sich bei 'hakase an ' Benutzer und bearbeiten Sie die docker-compose.yml Datei mit vim:
su - hakase
cd lemp-compose/
vim docker-compose.yml
- Nginx-Dienste definieren
Fügen Sie die nginx-Konfiguration unten 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 Folgendes definiert:
- nginx :Dienstname
- Bild :Wir verwenden 'bitnami/nginx ' Docker-Bilder
- Ports :Container-Port 80 verfügbar machen an den Host-Port 80
- Links :verlinkt 'nginx ' Dienstcontainer in 'phpfpm ' Behälter
- Volumen :Hängen Sie lokale Verzeichnisse in den Container ein. Mounten Sie das Protokolldateiverzeichnis, mounten Sie die virtuelle Nginx-Hostkonfiguration 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 :Dienstnamen definieren.
- Bild :Definieren Sie das Basis-Image für den phpfpm-Dienst mit "bitnami/php-fpm". ' Bild.
- Ports :Wir führen PHP-fpm mit TCP-Port 9000 aus und den Port 9000 freigeben an den Gastgeber.
- Volumen :Mounten Sie das Web-Root-Verzeichnis 'public ' zu 'meineapps ' auf dem Behälter.
- Definieren Sie den MySQL-Dienst
Fügen Sie im dritten Block die folgende Konfiguration für den MariaDB-Dienstcontainer 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 Folgendes verwenden:
- mysql :als Dienstname.
- Bild :Der Container basiert auf 'mariadb ' Docker-Bilder.
- Ports :Dienstcontainer mit Port 3306 für eine MySQL-Verbindung und stellen Sie sie dem Host auf Port 3306 zur Verfügung .
- Volumen :DB-Daten Verzeichnis mysql
- Umgebung :Setzen Sie die Umgebungsvariable 'MYSQL_ROOT_PASSWORD ' für das MySQL-Root-Passwort für die Docker-Images, das beim Erstellen des Containers ausgeführt wird.
- Konfiguration der PHPMyAdmin-Dienste
Fügen Sie im letzten Block 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, das den Container-Port 80 abbildet bis 8080 Verknüpfen Sie auf dem Host den Container mit der mariadb container, setze restart always und setze einige Umgebungsvariablen des Docker-Images, einschließlich set 'PMA_HOST '.
Speichern Sie die Datei und beenden Sie vim.
Sie können das vollständige Beispiel auf GitHub sehen.
Schritt 5 – Docker-Compose ausführen
Jetzt können wir docker-compose ausführen. Hinweis:Wenn Sie Docker-Compose ausführen möchten, müssen Sie sich im Docker-Compose-Projektverzeichnis befinden und sicherstellen, dass dort die yml-Datei mit der Compose-Konfiguration vorhanden ist.
Führen Sie den folgenden Befehl aus, um den LEMP-Stack 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, auf denen Nginx, PHP-fpm, MariaDB und PHPMyAdmin ausgeführt werden.
Schritt 6 – Testen
Ü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 index.html-Datei.
http://Server-IP-Adresse/
Stellen Sie sicher, dass PHP-fpm läuft, greifen Sie über den Webbrowser darauf zu.
http://serverip-adresse/info.php
Greifen Sie in der MySQL-Shell auf den MySQL-Container zu.
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
Auf den MariaDB-Mysql-Shell-Container kann zugegriffen werden, und wir haben eine neue Datenbank „hakase_db“ erstellt '.
Als nächstes greifen Sie auf PHPMyAdmin auf Port 8080 zu:http://serverip-address:8080/.
Sie sehen die Anmeldeseite von PHPMyAdmin, geben Sie einfach den Benutzernamen „root“ ein ' und das Passwort ist 'hakase-labs123 '.
Sie werden automatisch mit dem mysql-Container verbunden, der im PMA_HOST definiert wurde Umgebungsvariable.
Klicken Sie auf "Los". ' und Sie sehen das phpmyadmin-Dashboard, das mit 'mysql verbunden ist ' Container.
Erfolg! Der LEMP-Stack wird unter einem Docker-Compose-Setup ausgeführt, das aus vier Containern besteht.
Referenz
https://hub.docker.com/r/bitnami/nginx/
https://hub.docker.com/r/bitnami/php-fpm/
https://hub.docker.com/_/mariadb/
https://hub.docker.com/r/phpmyadmin/phpmyadmin/
https://docs.docker.com/compose/
https://github.com/yuzukiseo/hakase-labs/tree/master/lemp-compose