Dockerisierung des LEMP-Stacks mit Docker-Compose auf Ubuntu

Docker-Compose ist ein Befehlszeilenwerkzeug zum Definieren und Verwalten von Docker-Anwendungen mit mehreren Containern. Compose ist ein Python-Skript, das einfach mit dem pip-Befehl 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, was großartig für Ihre Entwicklungs-, Test- und Staging-Umgebung ist.

In diesem Tutorial werde ich Sie Schritt für Schritt anleiten, wie Sie Docker-Compose verwenden, um eine LEMP-Stack-Umgebung zu erstellen (LEMP = Linux - Nginx - MySQL - PHP). Wir werden alle Komponenten in verschiedenen Docker-Containern ausführen, wir richten einen Nginx-Container, einen PHP-Container, einen 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 führen Sie ein Upgrade durch:

sudo apt-get update  
sudo apt-get upgrade

Installieren Sie die neueste Docker-Version aus dem Ubuntu-Repository.

sudo apt-get install -y docker.io

Starten Sie Docker und aktivieren Sie es, damit es beim Booten gestartet wird:

systemctl start docker  
systemctl enable docker

Die Docker-Dienste laufen.

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.

Hallo Docker

Schritt 2 - Docker-Compose installieren

Im ersten Schritt haben wir bereits Docker installiert. Jetzt werden wir Docker-Compose installieren.

Wir benötigen python-pip für die Installation von Compose, installieren Sie 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 pip-Befehl.

pip install docker-compose

Überprüfen Sie jetzt 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 erstellen.

Fügen Sie einen neuen Benutzer mit dem Namen ‘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 zur Gruppe ‘docker‘ hinzu und starten Sie Docker neu.

usermod -a -G docker hakase  
sudo systemctl restart docker

Jetzt kann der Benutzer ‘hakase‘ Docker ohne sudo verwenden.

Als Nächstes melden Sie sich als 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 sich im Docker-Container befinden sollen, müssen sich in diesem Verzeichnis befinden. 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}

logs: Verzeichnis für Nginx-Protokolldateien.
nginx: enthält Nginx-Konfigurationen wie virtuelle Hosts usw.
public: Verzeichnis für Webdateien, index.html und PHP-Info-Datei.
db-data: MariaDB-Datenverzeichnis-Volume.

Erstellen Sie die Protokolldateien error.log und access.log im Verzeichnis ‘logs‘.

touch logs/{error,access}.log

Erstellen Sie eine neue Nginx-virtuelle Host-Konfigurationsdatei im Verzeichnis ‘nginx‘:

vim nginx/app.conf

Fügen Sie die folgende Konfiguration 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-Info-Datei im Verzeichnis ‘public‘.

echo 'LEMP Docker-Compose

hakase-labs' > public/index.html echo '' > public/info.php

Jetzt können Sie das Umgebungsverzeichnis wie unten gezeigt sehen:

tree

Docker-Compose-Projektumgebung

Schritt 4 - Konfiguration der docker-compose.yml-Datei

Im vorherigen Schritt haben wir die benötigten Verzeichnisse und Dateien für unsere Container erstellt. In diesem Schritt möchten wir die Datei ‘docker-compose.yml‘ bearbeiten. In der docker-compose.yml-Datei definieren wir unsere Dienste für den LEMP-Stack, die Basisbilder für jeden Container und die Docker-Volumes.

Melden Sie sich beim Benutzer ‘hakase‘ an 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 definiert:

nginx: Dienstname
image: Wir verwenden ‘ bitnami/nginx ‘ Docker-Images
ports: Exponieren Sie den Containerport 80 auf den Hostport 80
links: Verknüpfen Sie den Dienstcontainer ‘ nginx ‘ mit dem Container ‘ phpfpm ‘
volumes: Mounten Sie lokale Verzeichnisse in den Container. Mounten Sie das Protokolldateiverzeichnis, mounten Sie die Nginx-virtuelle Hostkonfiguration und mounten Sie das Webstammverzeichnis.

- 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

Hier haben wir definiert:

phpfpm: Definieren Sie den Dienstnamen.
image: Definieren Sie das Basisbild für den PHP-fpm-Dienst mit dem Bild ‘ bitnami/php-fpm ‘.
ports: Wir führen PHP-fpm mit TCP-Port 9000 aus und exponieren den Port 9000 auf den Host.
volumes: Mounten Sie das Webstammverzeichnis ‘ public ‘ auf ‘ myapps ‘ im Container.

- Den MySQL-Dienst definieren

Im dritten Block fügen Sie die Konfiguration für den MariaDB-Dienstcontainer unten ein:

mysql:  
    image: 'mariadb'  
    ports:  
        - '3306:3306'  
    volumes:  
        - ./db-data:/var/lib/mysql  
    environment:  
        - MYSQL_ROOT_PASSWORD=hakase-labs123

Hier sehen Sie, dass wir verwenden:

mysql: als Dienstnamen.
image: Der Container basiert auf ‘ mariadb ‘ Docker-Images.
ports: Der Dienstcontainer verwendet Port 3306 für die MySQL-Verbindung und exponiert ihn auf dem Host auf Port 3306.
volumes: db-data Verzeichnis MySQL
environment: 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.

- PHPMyAdmin-Dienste konfigurieren

Im letzten Block fügen Sie die Konfiguration unten 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 Containerport 80 auf 8080 auf dem Host abbildet, den Container mit dem mariadb-Container verknüpft, immer neu startet und einige Umgebungsvariablen des Docker-Images festlegt, einschließlich der Festlegung von ‘ PMA_HOST ‘.

Speichern Sie die Datei und beenden Sie vim.

Sie können ein vollständiges Beispiel auf GitHub sehen.

Schritt 5 - Docker-Compose ausführen

Jetzt sind wir bereit, Docker-Compose auszuführen. Hinweis: Wenn Sie Docker-Compose ausführen möchten, müssen Sie sich im Docker-Compose-Projektverzeichnis befinden und sicherstellen, dass sich die yml-Datei mit der Compose-Konfiguration dort befindet.

Führen Sie den folgenden Befehl aus, um den LEMP-Stack zu starten:

docker-compose up -d

-d: im Hintergrund oder als Daemon ausführen

Sie werden das Ergebnis sehen, dass die neuen Container erstellt wurden, überprüfen Sie dies mit dem folgenden Befehl:

docker-compose ps

Docker-Compose läuft

Jetzt haben wir vier Container, die Nginx, PHP-fpm, MariaDB und PHPMyAdmin ausführen.

Schritt 6 - Testen

Überprüfen Sie die Ports, die vom Docker-Proxy auf dem Host verwendet werden.

netstat -plntu

Alle Docker-Ports auf den Host abgebildet

Wir können den Port 80 für den Nginx-Container, den Port 3306 für den MariaDB-Container, den Port 9000 für den PHP-fpm-Container und den Port 8080 für den PHPMyAdmin-Container sehen.

Greifen Sie über den Webbrowser auf Port 80 zu, und Sie sehen unsere index.html-Datei.

http://serverip-address/

Stellen Sie sicher, dass PHP-fpm läuft, greifen Sie über den Webbrowser darauf zu.

http://serverip-address/info.php

PHP-fpm Docker-Container funktioniert

Greifen Sie auf den MySQL-Container in der MySQL-Shell zu.

docker-compose exec mysql bash  
mysql -u root -p  
TYPE MYSQL PASSWORD: hakase-labs123

Jetzt erstellen Sie eine neue Datenbank:

create database hakase_db;  
exit

Der MariaDB MySQL-Shell-Container ist zugänglich, und wir haben eine neue Datenbank ‘hakase_db‘ erstellt.

Zugriff auf MySQL-Shell-Docker-Container

Als Nächstes greifen Sie über Port 8080 auf PHPMyAdmin zu: http://serverip-address:8080/.

Sie sehen die Anmeldeseite von PHPMyAdmin, geben Sie einfach den Benutzernamen ‘root‘ und das Passwort ‘hakase-labs123‘ ein.

PHPMyAdmin Docker-Container

Sie werden automatisch mit dem MySQL-Container verbunden, der in der Umgebungsvariable PMA_HOST definiert ist.

Klicken Sie auf ‘Go‘, und Sie sehen das Dashboard von PHPMyAdmin, das mit dem Container ‘mysql‘ verbunden ist.

PHPMyAdmin und MySQL Docker-Container funktionieren

Erfolg! Der LEMP-Stack läuft unter einer Docker-Compose-Konfiguration, die aus vier Containern besteht.