Docker ist eine Virtualisierung auf Betriebssystemebene, die hauptsächlich für Entwickler und Systemadministratoren gedacht ist. Docker erleichtert das Erstellen und Bereitstellen von Anwendungen in einer isolierten Umgebung.
Ein Dockerfile ist ein Skript, das Sammlungen von Befehlen und Anweisungen enthält, die automatisch nacheinander in der Docker-Umgebung ausgeführt werden, um ein neues Docker-Image zu erstellen.
In diesem Tutorial zeigen wir Ihnen, wie Sie Ihr eigenes Docker-Image mit einem Dockerfile erstellen. Wir erklären Details im Zusammenhang mit der Docker-Datei, damit Sie Ihr eigenes Docker-Image erstellen können.
Voraussetzungen
Für diese Anleitung verwenden wir Ubuntu 18.04 mit 1 GB RAM, 25 GB freiem Speicherplatz und 2 CPUs. Außerdem verwenden wir Ubuntu 18.04 als Basis-Image, um das benutzerdefinierte Docker-Image zu erstellen.
Einführung in den Dockerfile-Befehl
Ein Dockerfile ist ein Skript, das alle Befehle zum Erstellen eines Docker-Images enthält. Das Dockerfile enthält alle Anweisungen, die verwendet werden, um das Docker-Image mit dem Befehl „docker build“ zu erstellen.
Bevor Sie Ihr erstes Dockerfile erstellen, sollten Sie sich mit der Dockerfile-Anweisung vertraut machen. Nachfolgend einige Dockerfile-Anweisungen, die Sie kennen müssen.
VON
Legen Sie das Basis-Image für das neue Image fest, das Sie erstellen möchten. Die FROM-Anweisung initialisiert die neue Build-Stage und muss sich ganz oben in der Docker-Datei befinden.
LABEL
Mit dieser Anweisung können Sie zusätzliche Informationen zu Ihrem Docker-Image hinzufügen, z. B. Version, Beschreibung, Betreuer usw. Die LABEL-Anweisung ist ein Schlüssel-Wert-Paar, mit dem Sie mehrere Labels und mehrzeilige Werte hinzufügen können.
LAUFEN
Diese Anweisung wird zum Ausführen des Befehls während des Build-Prozesses des Docker-Images verwendet. Sie können zusätzliche Pakete installieren, die für Ihre Docker-Images benötigt werden.
HINZUFÜGEN
Die ADD-Anweisung wird verwendet, um Dateien, Verzeichnisse oder Remote-Dateien von der URL in Ihre Docker-Images zu kopieren, von „src“ in den absoluten Pfad „dest“. Außerdem können Sie den Standardbesitz Ihrer Datei festlegen.
ENV
Die ENV-Anweisung wird verwendet, um eine Umgebungsvariable zu definieren, die während der Build-Phase verwendet und in vielen auch inline ersetzt werden kann.
CMD
Die CMD-Anweisung wird verwendet, um den Standardbefehl zu definieren, der beim Ausführen des Containers ausgeführt werden soll. Und das Dockerfile darf nur eine CMD-Anweisung enthalten, und wenn es mehrere CMD-Anweisungen gibt, wird die letzte CMD-Anweisung ausgeführt.
AUSSETZEN
Diese Anweisung wird verwendet, um den Containerport zur Laufzeit auf den spezifischen Netzwerkports verfügbar zu machen. Das verfügbare Standardprotokoll ist TCP, aber Sie können angeben, ob TCP oder UDP.
ARG
Die ARG-Anweisung wird verwendet, um eine Variable zu definieren, die der Benutzer zur eingebauten Zeit übergeben kann. Sie können diese Anweisung im „Build-Befehl“ des Dockers während der Build-Zeit mit der Option „--build-arg variable=value“ verwenden und durch die Docker-Datei übertragen werden. Außerdem können Sie mehrere ARGs im Dockerfile verwenden.
Einstiegspunkt
Die ENTRYPOINT-Anweisung wird verwendet, um den ersten und Standardbefehl zu definieren, der ausgeführt wird, wenn der Container läuft. Definieren Sie den Befehl zum Starten Ihrer Anwendung mit der ENTRYPOINT-Anweisung.
ARBEITSVERZ
Die Anweisung WORKDIR wird verwendet, um das Standardarbeitsverzeichnis Ihres Docker-Images zu definieren. Die Anweisungen RUN, CMD, ENTRYPOINT und ADD folgen der Anweisung WORKDIR. Sie können Ihrer Docker-Datei mehrere WORKDIR-Anweisungen hinzufügen, und wenn keine vorhanden ist, wird sie automatisch erstellt.
BENUTZER
Die USER-Anweisung wird verwendet, um den Standardbenutzer oder die GID zu definieren, wenn das Image ausgeführt wird. RUN, CMD und ENTRYPOINT folgen der USER-Anweisung in der Dockerfile.
LAUTSTÄRKE
Die VOLUME-Anweisungsanzeige, die zum Aktivieren des Zugriffs/verknüpften Verzeichnisses zwischen dem Container und dem Hostcomputer verwendet wird.
Beginnen wir nun damit, das erste Dockerfile zu erstellen.
Schritt 1 – Installieren Sie Docker CE (Community Edition)
Bevor wir ein Dockerfile erstellen, installieren wir Docker CE auf unserem Ubuntu 18.04-System.
Aktualisieren Sie den Ubuntu-Paketindex und installieren Sie einige Pakete mit dem folgenden apt-Befehl.
sudo apt update
sudo apt install \
apt-transport-https \
ca-certificates \
curl \
gnupg-agent \
software-properties-common
Fügen Sie als Nächstes den GPG-Schlüssel des offiziellen Docker-Repositorys hinzu.
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
Fügen Sie als Nächstes das Docker CE Community Edition-Repository mit dem folgenden Befehl hinzu.
sudo add-apt-repository \
"deb [arch=amd64] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) \
stable"
Der Befehl aktualisiert den Paketindex automatisch erneut.
Installieren Sie als Nächstes die Docker CE-Pakete mit dem folgenden apt-Befehl.
sudo apt install docker-ce docker-ce-cli containerd.io
Sobald die gesamte Installation abgeschlossen ist, starten Sie den Docker-Dienst und fügen Sie ihn zum Systemstart hinzu.
systemctl start docker
systemctl enable docker
Der Docker-Dienst ist eingerichtet und wird ausgeführt. Führen Sie nun den folgenden Docker-Befehl aus, um sicherzustellen, dass die Installation korrekt ist.
docker run hello-world
Unten sehen Sie das Ergebnis, das Sie erhalten.
Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
(amd64)
3. The Docker daemon created a new container from that image which runs the
executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
to your terminal.
To try something more ambitious, you can run an Ubuntu container with:
$ docker run -it ubuntu bash
Share images, automate workflows, and more with a free Docker ID:
https://hub.docker.com/
For more examples and ideas, visit:
https://docs.docker.com/get-started/
Wie zu sehen ist, erhalten Sie von Docker die Hallo-Welt-Nachricht, und die Installation von Docker CE wurde erfolgreich abgeschlossen.
Schritt 2 – Dockerfile und andere Konfigurationen erstellen
In diesem Schritt zeigen wir Ihnen, wie Sie mithilfe der Dockerfile ein benutzerdefiniertes Docker-Image für Ihre Anwendung erstellen. Wir erstellen ein neues benutzerdefiniertes Docker-Image basierend auf dem Ubuntu 18.04-Image für die PHP-FPM- und Nginx-Dienste und führen dann den neuen Container mit einem einfachen phpinfo-Skript aus.
Erstellen Sie zunächst ein neues Projektverzeichnis und erstellen Sie ein leeres Dockerfile.
mkdir -p nginx-image; cd nginx-image/
touch Dockerfile
Bearbeiten Sie nun das 'Dockerfile'-Skript mit Ihrem eigenen Editor (für dieses Beispiel verwenden wir vim).
vim Dockerfile
Fügen Sie oben in der Zeile das Basis-Image Ubuntu 18.04-Image hinzu, indem Sie die FROM-Anweisung wie unten verwenden.
#Download base image ubuntu 18.04
FROM ubuntu:18.04
Fügen Sie nun mit der LABEL-Anweisung detaillierte Informationen über das benutzerdefinierte Bild hinzu.
# LABEL about the custom image
LABEL maintainer="[email protected]"
LABEL version="0.1"
LABEL description="This is custom Docker Image for \
the PHP-FPM and Nginx Services."
Für die Installation der apt-Pakete werden wir alle interaktiven Schritte nach der Installation überspringen, indem wir die Umgebungsvariable 'DEBIAN_FRONTEND=noninteractive' verwenden.
# Disable Prompt During Packages Installation
ARG DEBIAN_FRONTEND=noninteractive
Führen Sie als Nächstes den Befehl „apt update“ aus, bevor Sie Pakete installieren.
# Update Ubuntu Software repository
RUN apt update
Installieren Sie nun die Pakete Nginx, PHP-FPM und Supervisor. Sobald die gesamte Installation abgeschlossen ist, entfernen Sie den Cache aller Pakete, um die Größe des benutzerdefinierten Images zu reduzieren.
# Install nginx, php-fpm and supervisord from ubuntu repository
RUN apt install -y nginx php-fpm supervisor && \
rm -rf /var/lib/apt/lists/* && \
apt clean
Definieren Sie eine neue Umgebungsvariable, die an das benutzerdefinierte Bild übergeben werden kann.
#Define the ENV variable
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/7.2/fpm/php.ini
ENV nginx_conf /etc/nginx/nginx.conf
ENV supervisor_conf /etc/supervisor/supervisord.conf
Kopieren Sie nun die Nginx-Standardkonfiguration in die Variable ‚nginx_vhost‘, ersetzen Sie die PHP-Konfiguration ‚cgi.fix_pathinfo=1‘ durch ‚cgi.fix_pathinfo=0‘ in der Konfigurationsdatei php.ini und fügen Sie dann die Option ‚daemon off‘ zu der hinzu Standardvariable 'nginx_conf'.
# Enable PHP-fpm on nginx virtualhost configuration
COPY default ${nginx_vhost}
RUN sed -i -e 's/;cgi.fix_pathinfo=1/cgi.fix_pathinfo=0/g' ${php_conf} && \
echo "\ndaemon off;" >> ${nginx_conf}
Kopieren Sie die benutzerdefinierte Supervisord-Konfiguration in die Variable „supervisor_conf“.
#Copy supervisor configurationKOPIEREN
COPY supervisord.conf ${supervisor_conf}
Erstellen Sie ein neues Verzeichnis für die PHP-FPM-Sock-Datei, ändern Sie den Besitz des Web-Root-Verzeichnisses „/var/www/html“ und des PHP-FPM-Verzeichnisses „/run/php“ auf den Standardbenutzer „www-data“.
RUN mkdir -p /run/php && \
chown -R www-data:www-data /var/www/html && \
chown -R www-data:www-data /run/php
Definieren Sie das Volume für das benutzerdefinierte Image, damit wir alle diese Verzeichnisse auf dem Hostcomputer einhängen können.
# Volume configuration
VOLUME ["/etc/nginx/sites-enabled", "/etc/nginx/certs", "/etc/nginx/conf.d", "/var/log/nginx", "/var/www/html"]
Fügen Sie nun das Skript „start.sh“ hinzu und definieren Sie den Standard-Containerbefehl mithilfe der CMD-Anweisung wie unten beschrieben.
# Copy start.sh script and define default command for the container
COPY start.sh /start.sh
CMD ["./start.sh"]
Und zuletzt öffnen Sie die Standard-HTTP- und -HTTPS-Ports auf dem Container mit der EXPOSE-Anweisung.
# Expose Port for the Application
EXPOSE 80 443
Speichern und schließen.
Unten ist das vollständige Dockerfile-Skript, das wir gerade erstellt haben.
# Download base image ubuntu 18.04
FROM ubuntu:18.04
# LABEL about the custom image
LABEL maintainer="[email protected]"
LABEL version="0.1"
LABEL description="This is custom Docker Image for \
the PHP-FPM and Nginx Services."
# Disable Prompt During Packages Installation
ARG DEBIAN_FRONTEND=noninteractive
# Update Ubuntu Software repository
RUN apt update
# Install nginx, php-fpm and supervisord from ubuntu repository
RUN apt install -y nginx php-fpm supervisor && \
rm -rf /var/lib/apt/lists/* && \
apt clean
# Define the ENV variable
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/7.2/fpm/php.ini
ENV nginx_conf /etc/nginx/nginx.conf
ENV supervisor_conf /etc/supervisor/supervisord.conf
# Enable PHP-fpm on nginx virtualhost configuration
COPY default ${nginx_vhost}
RUN sed -i -e 's/;cgi.fix_pathinfo=1/cgi.fix_pathinfo=0/g' ${php_conf} && \
echo "\ndaemon off;" >> ${nginx_conf}
# Copy supervisor configuration
COPY supervisord.conf ${supervisor_conf}
RUN mkdir -p /run/php && \
chown -R www-data:www-data /var/www/html && \
chown -R www-data:www-data /run/php
# Volume configuration
VOLUME ["/etc/nginx/sites-enabled", "/etc/nginx/certs", "/etc/nginx/conf.d", "/var/log/nginx", "/var/www/html"]
# Copy start.sh script and define default command for the container
COPY start.sh /start.sh
CMD ["./start.sh"]
# Expose Port for the Application
EXPOSE 80 443
Als Nächstes erstellen wir eine neue zusätzliche Konfiguration für Nginx, Supervisord und das Skript start.sh.
Die „standardmäßige“ Nginx-Virtualhost-Konfiguration enthält den Abschnitt für das PHP-FPM. Tatsächlich können Sie das PHP-Skript mit dem benutzerdefinierten Image ohne Änderungen ausführen.
Erstellen Sie mit Ihrem Editor eine neue „standardmäßige“ virtuelle Nginx-Hostkonfiguration.
vim default
Fügen Sie die folgende Konfiguration ein.
server {
listen 80 default_server;
root /var/www/html;
index index.html index.htm index.nginx-debian.html;
server_name _;
location / {
try_files $uri $uri/ =404;
}
location ~ \.php$ {
include snippets/fastcgi-php.conf;
fastcgi_pass unix:/run/php/php7.2-fpm.sock;
}
} Speichern und schließen.
Als Nächstes erstellen wir die Konfiguration „supervisrod.conf“, die sowohl Nginx als auch das PHP-FPM-Programm enthält, das automatisch ausgeführt wird.
Erstellen Sie die Datei „supervisrod.conf“ mit Ihrem Editor.
vim supervisord.conf
Fügen Sie die folgende Konfiguration ein.
[unix_http_server]
file=/dev/shm/supervisor.sock ; (the path to the socket file)
[supervisord]
logfile=/var/log/supervisord.log ; (main log file;default $CWD/supervisord.log)
logfile_maxbytes=50MB ; (max main logfile bytes b4 rotation;default 50MB)
logfile_backups=10 ; (num of main logfile rotation backups;default 10)
loglevel=info ; (log level;default info; others: debug,warn,trace)
pidfile=/tmp/supervisord.pid ; (supervisord pidfile;default supervisord.pid)
nodaemon=false ; (start in foreground if true;default false)
minfds=1024 ; (min. avail startup file descriptors;default 1024)
minprocs=200 ; (min. avail process descriptors;default 200)
user=root ;
[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
[supervisorctl]
serverurl=unix:///dev/shm/supervisor.sock ; use a unix:// URL for a unix socket
[include]
files = /etc/supervisor/conf.d/*.conf
[program:php-fpm7.2]
command=/usr/sbin/php-fpm7.2 -F
numprocs=1
autostart=true
autorestart=true
[program:nginx]
command=/usr/sbin/nginx
numprocs=1
autostart=true
autorestart=true
Speichern und schließen.
Erstellen Sie nun das Skript „start.sh“ mit t=Ihrem Editor, es enthält den Supervisord-Befehl zum Starten.
vim start.sh
Fügen Sie die folgende Konfiguration ein.
#!/bin/sh
/usr/bin/supervisord -n -c /etc/supervisor/supervisord.conf
Speichern und schließen.
Machen Sie das Skript „start.sh“ ausführbar.
chmod +x start.sh
Als Ergebnis wurde die gesamte Konfiguration für unser benutzerdefiniertes Docker-Image erstellt. Nachfolgend sind alle Konfigurationen aufgeführt, die wir erstellt haben.
tree .
Jetzt können wir basierend auf diesen Konfigurationen ein neues benutzerdefiniertes Image erstellen.
Schritt 3 – Neuen benutzerdefinierten Container erstellen und neuen Container ausführen
Um das benutzerdefinierte Docker-Image zu erstellen, gehen Sie in das Projektverzeichnis „nginx-image“ und führen Sie den Befehl „docker build“ wie unten beschrieben aus.
docker build -t nginx-image .
Der Befehl lädt das Basis-Image Ubuntu 18.04 herunter und erstellt ein neues benutzerdefiniertes Image mit dem Namen „nginx-image.
Überprüfen Sie nach Abschluss des gesamten Prozesses die Liste der verfügbaren Docker-Images auf Ihrem System mit dem folgenden Befehl.
docker image ls
Unten sehen Sie das Ergebnis, das Sie erhalten.
Wie zu sehen ist, wurde das neue benutzerdefinierte Docker-Image „nginx-image“ erstellt.
Als nächstes führen wir den neuen Docker-Container basierend auf dem „nginx-image“ aus.
Erstellen Sie auf Ihrem lokalen Rechner ein neues Verzeichnis mit dem Namen „webroot“, das zum Speichern aller Webdateien verwendet wird.
mkdir -p /webroot
Erstellen Sie nun einen neuen Container mit dem Namen test-container, indem Sie den Docker-Run-Befehl unten verwenden.
docker run -d -v /webroot:/var/www/html -p 8080:80 --name test-container nginx-image
Hinweis:
- --name test-container nginx-image =Wir erstellen einen neuen Container mit dem Namen „test-container“, basierend auf dem Docker-Image „nginx-image“.
- -p 8080:80 =test-container container läuft auf Port 8080 auf dem Host-Rechner.
- -v /webroot:/var/www/html =Verzeichnis /webroot auf dem Host-Rechner schreibt das Verzeichnis /var/www/html auf dem Container um.
Überprüfen Sie danach alle laufenden Container auf Ihrem System mit dem folgenden Befehl.
docker ps
Unten sehen Sie das Ergebnis, das Sie erhalten.
Als Ergebnis ist der neue Container mit dem Namen „test-container“, der auf dem „nginx-image“ basiert, verfügbar und der Port 8080 verfügbar.
Schritt 4 – Testen
Um sicherzustellen, dass der Container ordnungsgemäß ausgeführt wird, erstellen wir eine neue index.html- und phpinfo-Datei im Stammverzeichnis „/webroot“ auf dem Hostcomputer. Weil das '/webroot'-Verzeichnis in das Container-Verzeichnis '/var/www/html' gemountet wird.
Erstellen Sie die Datei index.html im Verzeichnis „/webroot“ mit dem folgenden Befehl.
echo '<h1>Nginx and PHP-FPM 7.2 inside Docker Container with Ubuntu 18.04 Base Image</h1>' > /webroot/index.html
Testen Sie nun den Zugriff auf Ihren Container mit dem Curl-Befehl auf Port 8080.
curl server-ip:8080
curl -I server-ip:8080
Als Ergebnis erhalten Sie die soeben erstellte index.html-Standardseite.
Erstellen Sie als Nächstes eine neue PHP-Datei „info.php“ im Verzeichnis „/webroot“, um sicherzustellen, dass der PHP-FPM-Dienst ausgeführt wird.
Erstellen Sie die Datei „info.php“ mit dem folgenden Befehl.
echo '<?php phpinfo(); ?>' > /webroot/info.php
Öffnen Sie als Nächstes Ihren Webbrowser und geben Sie Ihre Server-IP-Adresse mit Port „8080“ ein, gefolgt vom Pfad der Datei „info.php“.
http://server-ip:8080/info.php
Jetzt erhalten Sie die untenstehende phpinfo-Seite.
Wie zu sehen ist, wurde der 'Test-Container' erfolgreich vom PHP-Skript geladen.
Als Ergebnis haben wir erfolgreich ein neues benutzerdefiniertes Docker-Image erstellt und den darauf basierenden neuen Container ohne Fehler ausgeführt.