Wie man Docker Images mit einer Dockerdatei erstellt

Docker ist eine Virtualisierung auf Betriebssystemebene, die hauptsächlich für Entwickler und Sysadmins gedacht ist. Docker erleichtert die Erstellung und Bereitstellung von Anwendungen in einer isolierten Umgebung. Eine Dockerdatei ist ein Skript, das eine Sammlung von Befehlen und Anweisungen enthält, die automatisch nacheinander in der Dockerumgebung ausgeführt werden, um ein neues Docker-Image zu erstellen.

In diesem Tutorial werde ich Ihnen zeigen, wie Sie Ihr eigenes Docker-Image mit einer Dockerdatei erstellen können. Ich werde das Dockerfile-Skript im Detail erklären, damit du deine eigenen Dockerfile-Skripte erstellen kannst.

Voraussetzung

  • Ein Linux-Server – Ich werde Ubuntu 16.04 als Host-Computer und Ubuntu 16.04 als Docker-Basis-Image verwenden.
  • Root-Privilegien.
  • Den Docker-Befehl verstehen

Einführung in den Befehl Dockerfile Command

Eine Dockerdatei ist ein Skript, das eine Sammlung von Dockerdateibefehlen und Betriebssystembefehlen (z.B. Linux-Befehle) enthält. Bevor wir unsere erste Dockerdatei erstellen, sollten Sie sich mit dem Befehl dockerfile vertraut machen.

Nachfolgend finden Sie einige Befehle für Dockerdateien, die Sie kennen müssen:

VON

Das Basisbild für den Aufbau eines neuen Bildes. Dieser Befehl muss sich oben auf der Dockerdatei befinden.

MAINTAINER

Optional enthält es den Namen des Betreuers des Images.

LAUF

Wird verwendet, um einen Befehl während des Erstellungsprozesses des Docker-Images auszuführen.

HINZUFÜGEN

Kopieren Sie eine Datei vom Hostcomputer in das neue Docker-Image. Es gibt eine Option, eine URL für die Datei zu verwenden, Docker wird diese Datei dann in das Zielverzeichnis herunterladen.

ENV

Definieren Sie eine Umgebungsvariable.

CMD

Wird für die Ausführung von Befehlen verwendet, wenn wir einen neuen Container aus dem Docker-Image erstellen.

EINTRAGSPUNKT

Definieren Sie den Standardbefehl, der ausgeführt wird, wenn der Container läuft.

WORKDIR

Dies ist eine Anweisung zur Ausführung des CMD-Befehls.

BENUTZER

Setzt den Benutzer oder die UID für den Container, der mit dem Image erstellt wurde.

VOLUMEN

Zugriff/verknüpftes Verzeichnis zwischen dem Container und dem Hostcomputer aktivieren.

Nun lassen Sie uns stattdessen unsere erste Dockerdatei erstellen.

Schritt 1 – Docker installieren

Melden Sie sich bei Ihrem Server an und aktualisieren Sie das Software-Repository.

ssh root@192.168.1.248
apt-get update

Installiere docker.io mit diesem apt-Befehl:

apt-get install docker.io

Wenn die Installation abgeschlossen ist, starten Sie den Docker-Dienst und aktivieren Sie ihn zum Startzeitpunkt:

systemctl start docker
systemctl enable docker

Docker wurde installiert und läuft auf dem System.

Schritt 2 – Dockerdatei erstellen

In diesem Schritt erstellen wir ein neues Verzeichnis für die Dockerdatei und definieren, was wir mit dieser Dockerdatei machen wollen.

Erstellen Sie ein neues Verzeichnis und eine neue und leere Dockerdatei in diesem Verzeichnis.

mkdir ~/myimages 
cd myimages/
touch Dockerfile

Als nächstes definieren Sie, was wir mit unserem neuen benutzerdefinierten Bild machen wollen. In diesem Tutorial werde ich Nginx und PHP-FPM 7 mit einem Ubuntu 16.04 Docker Image installieren. Zusätzlich benötigen wir Supervisord, damit wir Nginx und PHP-FPM 7 beide in einem Befehl starten können.

Bearbeiten Sie die’Dockerdatei‘ mit vim:

vim Dockerfile

Fügen Sie oben in der Datei eine Zeile mit dem Basisbild (Ubuntu 16.04) hinzu, das wir verwenden möchten.

#Download base image ubuntu 16.04
FROM ubuntu:16.04

Aktualisieren Sie das Ubuntu-Software-Repository innerhalb der Dockerdatei mit dem Befehl’RUN‘.

# Update Ubuntu Software repository
RUN apt-get update

Installieren Sie dann die Anwendungen, die wir für das benutzerdefinierte Image benötigen. Installieren Sie Nginx, PHP-FPM und Supervisord aus dem Ubuntu-Repository mit apt. Fügen Sie die RUN-Befehle für die Installation von Nginx und PHP-FPM hinzu.

# Install nginx, php-fpm and supervisord from ubuntu repository
RUN apt-get install -y nginx php7.0-fpm supervisor && \
    rm -rf /var/lib/apt/lists/*

In diesem Stadium sind alle Anwendungen installiert und wir müssen sie konfigurieren. Wir werden Nginx für die Handhabung von PHP-Anwendungen konfigurieren, indem wir die Standardkonfiguration des virtuellen Hosts bearbeiten. Wir können sie durch unsere neue Konfigurationsdatei ersetzen, oder wir können die bestehende Konfigurationsdatei mit dem Befehl’sed‘ bearbeiten.

In diesem Tutorial ersetzen wir die standardmäßige virtuelle Host-Konfiguration durch eine neue Konfiguration, indem wir den Befehl’COPY‘ dockerfile verwenden.

#Define the ENV variable
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/7.0/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}

Als nächstes konfigurieren Sie Supervisord für Nginx und PHP-FPM. Wir ersetzen die standardmäßige Supervisord-Konfiguration durch eine neue Konfiguration, indem wir den Befehl’COPY‘ verwenden.

#Copy supervisor configuration
COPY supervisord.conf ${supervisor_conf}

Erstellen Sie nun ein neues Verzeichnis für die php-fpm sock-Datei und ändern Sie den Besitzer des Verzeichnisses /var/wwww/html und des PHP-Verzeichnisses in www-data.

RUN mkdir -p /run/php && \
    chown -R www-data:www-data /var/www/html && \
    chown -R www-data:www-data /run/php

Als nächstes definieren Sie das Volume, damit wir die unten aufgeführten Verzeichnisse auf dem Hostcomputer einbinden können.

# Volume configuration
VOLUME ["/etc/nginx/sites-enabled", "/etc/nginx/certs", "/etc/nginx/conf.d", "/var/log/nginx", "/var/www/html"]

Richten Sie abschließend den Standard-Container-Befehl’CMD‘ ein und öffnen Sie den Port für HTTP und HTTPS. Wir werden eine neue start.sh-Datei für den Standardbefehl’CMD‘ erstellen, wenn der Container gestartet wird. Die Datei enthält den Befehl’supervisord‘, und wir werden die Datei mit dem Befehl’COPY‘ dockerfile in das neue Image kopieren.

# Configure Services and Port
COPY start.sh /start.sh
CMD ["./start.sh"]

EXPOSE 80 443

Speichern Sie die Datei und beenden Sie sie.

Hier ist die komplette Dockerdatei in einem Stück:

#Download base image ubuntu 16.04
FROM ubuntu:16.04

# Update Software repository
RUN apt-get update

# Install nginx, php-fpm and supervisord from ubuntu repository
RUN apt-get install -y nginx php7.0-fpm supervisor && \
rm -rf /var/lib/apt/lists/*

#Define the ENV variable
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/7.0/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“]

# Configure Services and Port
COPY start.sh /start.sh
CMD [„./start.sh“]

EXPOSE 80 443

Erstellen Sie nun in unserem Verzeichnis’Dockerfile‘ eine neue Konfigurationsdatei für den virtuellen Host namens’default‘, eine Supervisor-Konfigurationsdatei’supervisord.conf‘ und ein Dienstkonfigurations-Skript’start.sh‘.

vim default

Fügen Sie die standardmäßige Konfiguration des virtuellen Hosts unten ein:

server {
    listen 80 default_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.0-fpm.sock;
}

# deny access to .htaccess files, if Apache’s document root
# concurs with nginx’s one
#
#location ~ /\.ht {
#    deny all;
#}
}

Supervisor-Konfigurationsdatei:

vim supervisord.conf

Füge die Konfiguration unten 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             ;

; the below section must remain in the config file for RPC
; (supervisorctl/web interface) to work, additional interfaces may be
; added by defining them in separate rpcinterface: sections
[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

; The [include] section can just contain the „files“ setting.  This
; setting can list multiple files (separated by whitespace or
; newlines).  It can also contain wildcards.  The filenames are
; interpreted as relative to this file.  Included files *cannot*
; include files themselves.

[include]
files = /etc/supervisor/conf.d/*.conf

[program:php-fpm7.0]
command=/usr/sbin/php-fpm7.0 -F
numprocs=1
autostart=true
autorestart=true

[program:nginx]
command=/usr/sbin/nginx
numprocs=1
autostart=true
autorestart=true

Start.sh-Datei.

vim start.sh

Füge die Konfiguration unten ein:

#!/bin/sh

/usr/bin/supervisord -n -c /etc/supervisor/supervisord.conf

Speichern und beenden

Machen Sie start.sh mit dem Befehl chmod ausführbar:

chmod +x start.sh

Speichern Sie die Datei und beenden Sie sie.

Schritt 3 – Erstellen Sie ein neues Docker-Image und erstellen Sie einen neuen Container basierend auf diesem.

Die Dockerdatei und alle erforderlichen Konfigurationsdateien wurden erstellt, jetzt können wir ein neues Docker-Image basierend auf Ubuntu 16.04 und unserer Dockerdatei mit dem Dockerbefehl unten erstellen:

docker build -t nginx_image .

Wenn der Befehl erfolgreich abgeschlossen wurde, können wir das neue Bild’nginx_image‘ mit dem Docker-Befehl unten überprüfen:

docker images

Docker-Image erstellen

Dann können wir versuchen, einen neuen Container basierend auf nginx_images zu erstellen. Und bevor wir einen neuen Container erstellen, können wir ein neues Verzeichnis auf dem Hostcomputer für die Webroot-Daten erstellen.

mkdir -p /webroot

Führen Sie nun den neuen Container mit dem Befehl unten aus:

docker run -d -v /webroot:/var/www/html -p 80:80 --name hakase nginx_image

Dann können wir überprüfen, ob der neue Container mit dem Namen hakase basierend auf’nginx_image‘ läuft:

docker ps

Überprüfen Sie, ob unser Docker-Container läuft.

Hinweis:

  • Name hakase nginx_image = Wir erstellen einen neuen Container mit dem Namen’hakase‘, basierend auf dem Dockerbild’nginx_images‘.
  • p 80:80 = hakase container, der auf Port 80 des Host-Rechners läuft.
  • -v /webroot:/var/wwww/html = /webroot Verzeichnis auf dem Hostcomputer schreibt das Verzeichnis /var/www/html auf dem Container neu.

Der neue Container auf Basis des nginx_image läuft fehlerfrei.

Schritt 4 – Testen von Nginx und PHP-FPM im Container

Versuchen Sie, eine neue index.html-Datei im Verzeichnis /webroot mit echo zu erstellen:

echo '<h1>Nginx and PHP-FPM 7 inside Docker Container</h1>' > /webroot/index.html

Testen mit dem Curl-Befehl durch Zugriff auf die IP-Adresse des Host-Computers.

curl 192.168.1.250
curl -I 192.168.1.250

Wir werden die Ergebnisse unten sehen.

Testen Sie, ob nginx innerhalb des Docker-Containers erreichbar ist.

Als nächstes testen Sie, ob PHP-FPM 7.0 läuft, indem Sie eine neue phpinfo-Datei im Verzeichnis /webroot auf dem Hostcomputer erstellen.

echo '<?php phpinfo(); ?>' > /webroot/info.php

Öffnen Sie den Webbrowser und geben Sie die IP-Adresse des Host-Computers ein:

http://192.168.1.248/info.php

Jetzt können Sie die Ausgabe der phpinfo-Datei sehen.

PHP-FPM funktioniert einwandfrei.

das neue Docker-Image’nginx_image‘ wurde erfolgreich erstellt, jetzt können wir mehr Container basierend auf diesem Image erstellen.

Referenz

Das könnte Dich auch interessieren …