Docker ist eine beliebte Open-Source-Plattform für die Entwicklung, den Versand und den Betrieb von Anwendungen. Sie kapselt Anwendungen und ihre Abhängigkeiten in Containern, um die Konsistenz zwischen verschiedenen Umgebungen zu fördern. Diese Konsistenz hilft, Probleme im Zusammenhang mit Abhängigkeitskonflikten und Unstimmigkeiten nach dem Motto „Das funktioniert auf meinem Rechner“ zu vermeiden.

Mit Docker kannst du die notwendigen Abhängigkeiten und Erweiterungen mithilfe von Dockerdateien definieren. Das bedeutet, dass deine Anwendungen über alle erforderlichen Bibliotheken und Werkzeuge in einer reproduzierbaren, isolierten Umgebung verfügen.

Kinstas Anwendungs-Hosting bietet dynamische Unterstützung für benutzerdefinierte Dockerfiles, mit denen du eine größere Kontrolle über die Umgebung deiner Anwendung hast. Mit einem Dockerfile kannst du fast jede Sprache verwenden – du bist nicht auf die Sprachen beschränkt, die von Nixpacks oder Buildpacks unterstützt werden.

In diesem praktischen Artikel erfährst du, wie du PHP-Abhängigkeiten und -Erweiterungen in Docker installieren und nutzen kannst.

Warum Docker für die Installation von Abhängigkeiten verwenden?

Die Verwendung von Docker für die Installation von Abhängigkeiten hat mehrere Vorteile:

  • Konsistenz der Umgebung – Mit Docker kannst du deine Anwendung, ihre Abhängigkeiten und ihre Konfigurationen in einen Container packen. Dieser Ansatz stellt sicher, dass die Umgebung, in der deine Anwendung läuft, über verschiedene Konfigurationen und Systeme hinweg konsistent bleibt, einschließlich Entwicklungs-, Test- und Produktionsumgebungen.
  • Einfaches Einrichten und Auflösen von Abhängigkeiten – Mit Docker kannst du die Umgebung deiner Anwendung auf jedem Rechner einrichten, der sie unterstützt, indem du alle erforderlichen Abhängigkeiten und Konfigurationen angibst. Auf diese Weise vermeidest du Kompatibilitätsprobleme und den Aufwand, Abhängigkeiten manuell zu installieren.
  • Versionskontrolle und Isolierung – Docker-Container kapseln alle Abhängigkeiten, einschließlich ihrer spezifischen Versionen, im Container. Das bedeutet, dass du deine Anwendung und ihre Abhängigkeiten versionskontrollieren kannst, was die Reproduzierbarkeit fördert und Konflikte zwischen verschiedenen Abhängigkeitsversionen vermeidet.

Außerdem bieten Docker-Container eine Isolierung, die Konflikte zwischen den Abhängigkeiten verschiedener Anwendungen, die auf demselben System laufen, verhindert.

Einrichten deiner Anwendung auf Kinsta

Das Einrichten deiner Anwendung auf Kinsta ist ganz einfach. Besuche MyKinsta und folge dem Anmeldeprozess. Nach der Registrierung hast du Zugriff auf ein leistungsstarkes Hosting-Dashboard und eine Reihe von Funktionen zur Optimierung von Leistung und Sicherheit.

Das Anwendungs-Hosting von Kinsta unterstützt eine Reihe von Programmiersprachen, darunter PHP, Python, Node.js und Ruby. Diese umfangreiche Sprachunterstützung gewährleistet die Kompatibilität mit verschiedenen Anwendungen und gibt dir die Möglichkeit, die Sprache zu wählen, die am besten zu deinen Projektanforderungen passt.

Wenn du zum Beispiel eine dynamische Webanwendung mit PHP entwickelst, sorgt die optimierte Hosting-Umgebung von Kinsta für hohe Leistung und Zuverlässigkeit deiner PHP-basierten Projekte. Wenn du eine RESTful API mit Node.js oder eine datengesteuerte Webanwendung mit Python entwickelst, bietet Kinsta die nötige Infrastruktur und Unterstützung für deine Anwendung.

Um zu erfahren, wie du eine Anwendung mit einem Dockerfile auf Kinsta bereitstellst, verwende diese Anwendung, ein einfaches PHP-basiertes Authentifizierungssystem, das MariaDB zum Speichern von Daten verwendet. Diese Anwendung nutzt auch einige Composer-Pakete, darunter respect/validation für die Eingabevalidierung und ircmaxell/password-compat für die Passwortverschlüsselung.

Bereite deine Docker-Umgebung vor

Ein Dockerfile ist eine Textdatei, die alle Befehle in der erforderlichen Reihenfolge enthält, die du brauchst, um das gewünschte Image zu erstellen. Ein einfaches Dockerfile für eine PHP-Anwendung sieht wie folgt aus:

FROM php:8.3-cli
COPY . /usr/src/myapp
WORKDIR /usr/src/myapp
CMD [ "php", "./your-script.php" ]

Dieses Dockerfile erstellt eine Containerumgebung, in der ein PHP-Skript über eine Befehlszeilenschnittstelle (CLI) ausgeführt wird. Es beginnt mit der Verwendung des offiziellen PHP-Images mit der CLI-Variante und stellt sicher, dass nur die PHP-Laufzeit in den Container aufgenommen wird.

Anschließend wird der Inhalt des lokalen Verzeichnisses – das die Dockerdatei enthält – in das Verzeichnis /usr/src/myapp im Container kopiert. Nachdem er das Arbeitsverzeichnis auf /usr/src/myapp gesetzt hat, gibt er das auszuführende PHP-Skript, your-script.php, mit dem Befehl php an.

Das Image enthält viele vorkompilierte PHP-Erweiterungen. Überprüfe also zunächst, ob die von dir benötigte Erweiterung installiert ist, indem du den Befehl php -m ausführst.

Wenn die von dir benötigte Erweiterung nicht im Basis-Image enthalten ist, stellt Docker die folgenden Hilfsskripte zur Verfügung, mit denen du zusätzliche Erweiterungen leichter installieren kannst:

  • docker-php-ext-configure
  • docker-php-ext-install
  • docker-php-ext-enable

Die Demoanwendung für diesen Lehrgang verwendet zum Beispiel die MySQLi-Erweiterung, um mit der MariaDB-Datenbank zu interagieren. Diese Erweiterung ist nicht standardmäßig in das Image einkompiliert, also installiere sie mit dem folgenden Befehl in deinem Dockerfile:

RUN docker-php-ext-install mysqli

Um ein Dockerfile für die Demoanwendung zu schreiben, erstelle eine neue Datei namens Dockerfile im Stammverzeichnis des Projekts. Füge den folgenden Code in die Datei ein:

FROM php:8.3-apache

# Install MySQL client, server, and other dependencies
RUN apt-get update && \
	apt-get install -y \
	default-mysql-client \
	default-mysql-server \
	git \
	&& apt-get clean \
	&& rm -rf /var/lib/apt/lists/*

# Install mysqli PHP extension for MySQL support
RUN docker-php-ext-install mysqli

Dieser Code legt das offizielle PHP-Image – genauer gesagt Version 8.3 – mit installiertem Apache als Basis-Image für den Container fest. Dieses Image bietet eine vorkonfigurierte Umgebung für die Ausführung von PHP-Anwendungen mit Apache als Webserver.

Es installiert dann die zusätzlichen Abhängigkeiten, die die Demoanwendung benötigt, einschließlich default-mysql-client und default-mysql-server, die die MariaDB-Datenbank erstellen und mit ihr interagieren.

Schließlich installiert das obige Snippet die PHP-Erweiterung mysqli mit docker-php-ext-install, mit der die Demoanwendung eine Verbindung zur MariaDB-Datenbank herstellen und Operationen durchführen kann.

Verwalten von Abhängigkeiten mit Docker

Zur Verwaltung von PHP-Abhängigkeiten mit Docker wird Composer, ein beliebter Abhängigkeitsmanager für PHP, verwendet. Wenn du Composer in einem Docker-Container installierst, kannst du den Prozess der Installation, Aktualisierung und Verwaltung von PHP-Abhängigkeiten rationalisieren und gleichzeitig die Konsistenz und Reproduzierbarkeit in verschiedenen Umgebungen erleichtern.

Befolge die folgenden Schritte, um Composer für die Verwaltung von Abhängigkeiten in der Demoanwendung zu verwenden. Füge den Code in jedem der Schritte zu deinem Dockerfile hinzu.

  1. Installiere Composer mit dem unten stehenden Befehl im Docker-Image: 
    # Install Composer
COPY --from=composer/composer:latest-bin /composer /usr/bin/composer

    Dieser Befehl kopiert eine vorgefertigte Composer-Binärdatei aus dem Docker Hub Repository in dein Image. --from=composer/composer:latest-bin gibt das Quellimage an, aus dem die Dateien kopiert werden sollen.

    Der Pfad /composer im Quell-Image enthält die zu kopierenden Dateien, während der Pfad /usr/bin/composer deines Docker-Images das Ziel für diese Dateien ist.

  2. Als Nächstes legst du das Arbeitsverzeichnis fest, indem du Folgendes ausführst: 
    # Set working directory
WORKDIR /var/www/html
  3. Kopiere die Dateien composer.json und composer.lock in das Image. 
    # Copy composer.json and composer.lock
COPY composer.json composer.lock ./
  4. Installiere die Composer-Abhängigkeiten, die in composer.json aufgeführt sind. 
    # Install Composer dependencies
RUN composer install --no-dev --optimize-autoloader

    --no-dev weist Composer an, die entwicklungsspezifischen Abhängigkeiten zu überspringen. --optimize-autoloader weist Composer an, den Autoloader für eine bessere Leistung zu optimieren.

Du kannst die Abhängigkeiten im Laufe der Zeit aktualisieren und verwalten, indem du die Datei composer.json nach Bedarf änderst, neue Abhängigkeiten hinzufügst, Versionseinschränkungen aktualisierst und Abhängigkeiten entfernst, die nicht mehr benötigt werden.

Nachdem du die notwendigen Änderungen vorgenommen hast, führst du composer install oder composer update innerhalb des Docker-Containers aus, um die Abhängigkeiten entsprechend zu installieren oder zu aktualisieren.

Endgültige Konfigurationen anwenden

Bevor die Anwendung mit Docker funktioniert, musst du die Datenbank und den Datenbankbenutzer anlegen, Umgebungsvariablen setzen und die Projektdateien in das Docker-Image kopieren.

Dazu befolgst du die folgenden Schritte und kopierst jeden Codeschnipsel in deine Dockerdatei.

  1. Setze die Umgebungsvariablen, mit denen sich die PHP-Anwendung mit der MariaDB-Datenbank verbinden wird. Du kannst die Variablen DB_USER, DB_PASSWORD und DB_NAME durch deine bevorzugten Zugangsdaten ersetzen. 
    # Set environment variables
ENV DB_HOST=localhost \
	DB_USER=kinsta_user \
	DB_PASSWORD=your_password_here \
	DB_NAME=kinsta_docker_auth \
	# Path to the Unix socket file used for connecting to the MariaDB server.
	DB_SOCKET=/var/run/mysqld/mysqld.sock
  2. Kopiere die PHP-Anwendungsdateien in das Docker-Image: 
    # Copy PHP application files into the image
COPY . .
  3. Kopiere das Startscript in das Image: 
    # Copy the startup script
COPY scripts/start.sh /usr/local/bin/start.sh

    Dieses Skript wird beim Start des Containers ausgeführt und ist für den Start des Datenbankservers, die Erstellung einer Datenbank, einer Tabelle und eines Benutzers sowie den Start des Apache-Servers verantwortlich. Du wirst dieses Skript später erstellen.

  4. Führe das Skript mit dem chmod Befehl: 
    # Make the script executable
RUN chmod +x /usr/local/bin/start.sh
  5. Zum Schluss führst du das Skript mit dem folgenden Befehl aus: 
    # Execute the startup script
CMD ["/usr/local/bin/start.sh"]

Jetzt, wo das Dockerfile vollständig ist, erstellst du das zuvor besprochene Startskript.

Erstelle eine neue Datei namens scripts/start.sh im Stammordner des Projekts und füge den folgenden Code hinzu. Vergewissere dich, dass du die im Dockerfile definierten Anmeldedaten für die Datenbank verwendest.

#!/bin/bash

# Start MariaDB server
service mariadb start

# Wait for MariaDB to be fully initialized (retry up to 30 times, waiting 1  second between each attempt)
attempt=0
while [ $attempt -lt 30 ]; do
		if mysqladmin ping &>/dev/null; then
    		echo "MariaDB is up and running."
    		break
		else
    		echo "MariaDB is not yet available. Retrying..."
    		attempt=$((attempt+1))
    		sleep 1
		Fi
done

# If MariaDB failed to start within the specified attempts, exit with an error
if [ $attempt -eq 30 ]; then
		echo "Error: MariaDB failed to start within the specified time."
		exit 1
fi

# Set the database name, username, and password
dbname="kinsta_docker_auth"
dbuser="kinsta_user"
dbpassword="your_password_here"

# Create the database if it does not exist
mysql -u root -e "CREATE DATABASE IF NOT EXISTS $dbname;"

# Create a database user and assign privileges to the database
mysql -u root -e "CREATE USER '$dbuser'@'localhost' IDENTIFIED BY '$dbpassword';"
mysql -u root -e "GRANT ALL PRIVILEGES ON $dbname.* TO '$dbuser'@'localhost';"
mysql -u root -e "FLUSH PRIVILEGES;"

# Create users table if it does not exist
mysql -u root -e "USE $dbname; CREATE TABLE IF NOT EXISTS users (
		id INT AUTO_INCREMENT PRIMARY KEY,
		username VARCHAR(20) UNIQUE NOT NULL,
		password_hash VARCHAR(255) NOT NULL
);"

# Start Apache server
apache2ctl -D FOREGROUND

Dieses Bash-Skript startet den MariaDB-Server. Wenn der Server vollständig initialisiert ist, erstellt es eine Datenbank, einen Benutzer mit entsprechenden Rechten und eine Tabelle in der Datenbank. Zum Schluss startet es den Apache-Server.

Bereitstellen auf Kinsta

Bevor du deine Anwendung auf Kinsta bereitstellst, musst du einige Konfigurationen für den Apache-Server vornehmen. Der Anwendungs-Hosting Dienst von Kinsta hat die Ports 80 und 443 geöffnet, aber wir empfehlen, den Port 8080 zu verwenden, wenn deine Anwendung irgendwelche Ports freigibt.

Standardmäßig wartet der Apache-Server auf Verbindungen an Port 80. Du musst ihn daher so konfigurieren, dass er auf Verbindungen an Port 8080 wartet. Befolge dazu die folgenden Schritte:

  1. Erstelle einen Ordner namens apache-conf im Stammordner des Projekts.
  2. Erstelle in dem neu erstellten Ordner eine Datei namens apache-config.conf. Füge den folgenden Code ein, um den Apache so zu konfigurieren, dass er auf Verbindungen an Port 8080 hört: 
    <VirtualHost *:8080>
	ServerAdmin webmaster@localhost
	DocumentRoot /var/www/html

	ErrorLog ${APACHE_LOG_DIR}/error.log
	CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
  3. Erstelle im Ordner apache-conf eine neue Datei namens apache-ports.conf und füge den folgenden Code hinzu. 
    # Change the Listen directive to listen on port 8080
Listen 8080

# Keep the existing configuration for port 443
<IfModule ssl_module>
	Listen 443
</IfModule>

<IfModule mod_gnutls.c>
	Listen 443
</IfModule>

    Die Direktive Listen 8080 weist den Apache an, auf dem Port 8080 auf eingehende Verbindungen zu warten.

  4. Nun musst du das Dockerfile ändern, um diese Konfiguration auf den Apache-Server anzuwenden. Füge in der Dockerdatei diese Befehle direkt nach dem Befehl zum Festlegen des Arbeitsverzeichnisses ein (WORKDIR /var/www/html). Sie sind dafür verantwortlich, dass die benutzerdefinierten Konfigurationsdateien in die entsprechenden Verzeichnisse kopiert werden. 
    # Set up Apache virtual host
COPY apache-conf/apache-config.conf /etc/apache2/sites-available/000-default.conf

# Set up Apache ports
COPY apache-conf/apache-ports.conf /etc/apache2/ports.conf
  5. Zum Schluss erstellst du eine .dockerignore-Datei im Stammverzeichnis des Projekts. Diese Datei enthält eine Liste von Ordnern und Dateien, die nicht in das Docker-Image kopiert werden sollen. Füge vendor hinzu, um den Ordner vendor auszuschließen.

Wenn du alle Konfigurationen vorgenommen hast, kannst du das Projekt auf Kinsta bereitstellen. Lade deine Projektdateien zu deinem bevorzugten Git-Anbieter (Bitbucket, GitHub oder GitLab) hoch und befolge dann die folgenden Schritte.

  1. In deinem MyKinsta-Dashboard wählst du in der Seitenleiste Anwendungen aus und klickst auf die Schaltfläche Anwendung hinzufügen.
  2. Auf der Seite Anwendung hinzufügen wählst du dein Git-Repository und deinen Zweig aus, gibst einen Anwendungsnamen an, wählst den Standort des Rechenzentrums und klickst auf Weiter.
  3. Wähle auf der Seite Build Environment die Option Use Dockerfile to set up container image. Gib „Dockerfile“ als Dockerfile-Pfad und einen Punkt („.“) als Context an. Klicke auf Fortfahren.

    In den Build-Umgebungsoptionen wählst du die Option Dockerfile und gibst den Dateipfad an
    Abschnitt „Umgebung erstellen“ des Anwendung- hinzufügen-Formulars

  4. Belasse alles auf der Seite Prozesse ein richten und klicke auf Weiter. Hinweis: Die Datenbank verliert Daten, wenn du die Anwendung neu startest oder neu bereitstellst. Wenn du dieses Problem lösen musst, schau dir den persistenten Speicher von Kinsta an und wende ihn auf dieser Seite an. In diesem Leitfaden wird die Einrichtung des persistenten Speichers nicht behandelt.
  5. Bestätige die Zahlungsdetails auf der Seite Zusammenfassung und klicke auf Jetzt bereitstellen.
  6. Sobald die Bereitstellung abgeschlossen ist, öffne die Domain deiner Anwendung, um die Live-Website zu sehen.
    Die Login-Seite der Live-Site mit Feldern für Benutzernamen und Passwort
    Login-Seite auf der Live-Website

    Registriere dich für ein Konto, melde dich mit deinen Daten an und überprüfe, ob du auf die geschützte Seite zugreifen kannst und ob alles wie erwartet funktioniert.

    Die Startseite der Anwendung des angemeldeten Benutzers öffnet sich mit einer personalisierten Willkommensnachricht
    Die Startseite der Anwendung nach dem Einloggen

Überwache und optimiere deine Anwendung

Sobald deine Anwendung auf Kinsta läuft, ist es wichtig, ihre Leistung zu überwachen und zu optimieren. So wird sichergestellt, dass deine Anwendung reibungslos funktioniert und die Ressourcen effizient genutzt werden.

Die Optimierung der Leistung deiner Anwendung ist entscheidend für ein schnelles und reaktionsschnelles Nutzererlebnis.

Kinsta arbeitet ständig an Möglichkeiten, die Leistung deiner Anwendung zu optimieren. Wir bieten umfassende Monitoring-Tools, mit denen du verschiedene Leistungskennzahlen wie Bandbreite, Gesamtaufbauzeit, CPU-Nutzung, Speicherverbrauch, Netzwerkverkehr und Antwortzeiten verfolgen kannst. Du kannst all diese Informationen einsehen, indem du im Kinsta-Dashboard in den Bereich Analytics deiner Anwendung navigierst.

Wenn du auf ein Problem oder ein unerwartetes Verhalten deiner Anwendung stößt, kannst du im Kinsta-Dashboard den Bereich Logs aufrufen. Dort findest du einen detaillierten Überblick über die Leistung und das Verhalten deiner Anwendung sowie Fehler- und Zugriffsprotokolle.

Wenn du diese Protokolle sorgfältig durchgehst, erhältst du wertvolle Einblicke in die mögliche Ursache des Problems, wie z. B. Fehlermeldungen, Stack Traces oder abnormale Verhaltensmuster. Diese Informationen können dir dabei helfen, die Ursache des Problems zu diagnostizieren und geeignete Maßnahmen zu ergreifen, um es zu beheben.

Außerdem kannst du in deiner Docker-Umgebung Techniken zur Leistungsoptimierung einsetzen, z. B. durch die Optimierung von Docker-Images und die Implementierung von Best Practices für die Anwendungsarchitektur und die Code-Optimierung.

Zusammenfassung

Mit den leichtgewichtigen und portablen Containern von Docker ist es einfach, Anwendungen mit allen erforderlichen Abhängigkeiten zu verpacken und bereitzustellen, unabhängig von der zugrunde liegenden Infrastruktur. Durch die Containerisierung deiner Anwendung und ihrer Abhängigkeiten förderst du die Konsistenz in verschiedenen Umgebungen, optimierst die Einrichtungsprozesse und erhältst eine bessere Versionskontrolle.

Durch die Nutzung von Docker mit Kinsta wird der Bereitstellungsprozess deiner Anwendung verbessert. Die Unterstützung für benutzerdefinierte Dockerdateien und eine breite Palette von Programmiersprachen, einschließlich PHP, gewährleistet Kompatibilität und Flexibilität für deine Projekte.

Mit der Infrastruktur von Anwendungs-Hosting und der Containerisierungstechnologie von Docker kannst du eine optimierte Bereitstellung, Skalierbarkeit und Zuverlässigkeit deiner Anwendungen erreichen.

Hast du Docker bereits für dein Projekt genutzt? Hast du Erfahrungen oder Erkenntnisse über Docker? Teile sie unten in den Kommentaren mit!

Jeremy Holcombe Kinsta

Content & Marketing Editor at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems ;).