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.

Hallo 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.

Docker Compose auf Ubuntu installieren

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

Docker komponiert Projektumgebung

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

running docker-compose

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

alle Docker-Ports sind dem Host zugeordnet.

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/

nginx docker container ist arbeit

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

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.

zugriff mysql shell docker container

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‚.

phpmyadmin docker container

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.

phpmyadmin und mysql docker container funktioniert.

Erfolgreich! Der LEMP Stack läuft unter einem Docker-Compose-Setup, das aus vier Containern besteht.

Referenz

Das könnte Dich auch interessieren …