So erstellen Sie Docker-Images mit einer Docker-Datei unter Ubuntu 16.04 LTS

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 zeige ich Ihnen, wie Sie Ihr eigenes Docker-Image mit einer Docker-Datei erstellen. Ich werde das Dockerfile-Skript im Detail erklären, damit Sie Ihre eigenen Dockerfile-Skripts erstellen können.

Voraussetzung

• Ein Linux-Server – ich werde Ubuntu 16.04 als Host-Maschine und Ubuntu 16.04 als Docker-Basis-Image verwenden.
• Root-Berechtigungen.
• Docker-Befehl verstehen

Einführung in den Dockerfile-Befehl

Ein Dockerfile ist ein Skript, das eine Sammlung von Dockerfile-Befehlen und Betriebssystembefehlen (z. B. Linux-Befehlen) enthält. Bevor wir unser erstes Dockerfile erstellen, sollten Sie sich mit dem Dockerfile-Befehl vertraut machen.

Unten sind einige Dockerfile-Befehle, die Sie kennen müssen:

VON

Das Basisimage zum Erstellen eines neuen Images. Dieser Befehl muss sich über der Docker-Datei befinden.

WARTER

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

LAUFEN

Wird verwendet, um während des Erstellungsprozesses des Docker-Images einen Befehl 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 lädt diese Datei dann in das Zielverzeichnis herunter.

ENV

Definieren Sie eine Umgebungsvariable.

CMD

Wird zum Ausführen von Befehlen verwendet, wenn wir einen neuen Container aus dem Docker-Image erstellen.

Einstiegspunkt

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

ARBEITSVERZ

Dies ist die Anweisung für den auszuführenden CMD-Befehl.

BENUTZER

Legen Sie den Benutzer oder die UID für den mit dem Image erstellten Container fest.

LAUTSTÄRKE

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

Beginnen wir nun damit, unser erstes Dockerfile zu erstellen.

Schritt 1 – Docker installieren

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

ssh [email protected]
apt-get update

Installieren Sie docker.io mit diesem apt-Befehl:

apt-get install docker.io

Wenn die Installation abgeschlossen ist, starten Sie den Docker-Dienst und ermöglichen Sie ihm, beim Booten zu starten:

systemctl start docker
systemctl enable docker

Docker wurde installiert und läuft auf dem System.

Schritt 2 - Dockerfile erstellen

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

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

mkdir ~/myimages 
cd myimages/
touch Dockerfile

Definieren Sie als Nächstes, was wir mit unserem neuen benutzerdefinierten Image machen möchten. In dieser Anleitung installiere ich Nginx und PHP-FPM 7 mit einem Ubuntu 16.04-Docker-Image. Außerdem brauchen wir Supervisord, damit wir Nginx und PHP-FPM 7 beide in einem Befehl starten können.

Bearbeiten Sie das 'Dockerfile' mit vim:

nano Dockerfile

Fügen Sie oben in der Datei eine Zeile mit dem Basis-Image (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 in der Docker-Datei 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 die vorhandene Konfigurationsdatei mit dem Befehl 'sed' bearbeiten.

In diesem Tutorial ersetzen wir die Standardkonfiguration des virtuellen Hosts durch eine neue Konfiguration, indem wir den Dockerfile-Befehl „COPY“ 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 werden die standardmäßige Supervisord-Konfiguration durch eine neue Konfiguration ersetzen, indem wir den Befehl „COPY“ verwenden.

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

KOPIEREN

Erstellen Sie nun ein neues Verzeichnis für die php-fpm-Sock-Datei und ändern Sie den Eigentümer des /var/www/html-Verzeichnisses 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

Definieren Sie als Nächstes das Volume, damit wir die unten aufgeführten 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"]

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

# 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 das komplette Dockerfile 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 „Dockerfile“-Verzeichnis eine neue Konfigurationsdatei für den virtuellen Host namens „default“, eine supervisord-Konfigurationsdatei „supervisord.conf“ und ein Dienstkonfigurationsskript „start.sh“.

vim default

Fügen Sie die Standardkonfiguration 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;
    #}
}

Supervisord-Konfigurationsdatei:

vim supervisord.conf

Konfiguration unten einfügen:

[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

Konfiguration unten einfügen:

#!/bin/sh
 
/usr/bin/supervisord -n -c /etc/supervisor/supervisord.conf

Speichern und beenden

Machen Sie start.sh mit dem chmod-Befehl 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 darauf basierenden neuen Container

Das Dockerfile und alle erforderlichen Konfigurationsdateien wurden erstellt, jetzt können wir ein neues Docker-Image basierend auf Ubuntu 16.04 und unserem Dockerfile mit dem folgenden Docker-Befehl erstellen:

docker build -t nginx_image .

Wenn der Befehl erfolgreich abgeschlossen wurde, können wir das neue Bild „nginx_image“ mit dem folgenden Docker-Befehl überprüfen:

docker images

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

mkdir -p /webroot

Führen Sie nun den neuen Container mit dem folgenden Befehl 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“ ausgeführt wird:

docker ps

Hinweis:

• --name hakase nginx_image =Wir erstellen einen neuen Container mit dem Namen „hakase“, basierend auf dem Docker-Image „nginx_images“.
• -p 80:80 =Hakase-Container, der auf Port 80 auf dem Host-Rechner ausgeführt wird.
• -v /webroot:/var/www/html =/webroot-Verzeichnis auf dem Host-Rechner schreibt das /var/www/html-Verzeichnis auf dem Container um.

Der neue Container basierend auf dem nginx_image läuft ohne Fehler.

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

Versuchen Sie, mit echo:

eine neue index.html-Datei im /webroot-Verzeichnis 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 als Nächstes, ob PHP-FPM 7.0 ausgeführt wird, 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 Hostcomputers ein:

http://192.168.1.248/info.php

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

Das neue Docker-Image „nginx_image“ wurde erfolgreich erstellt, jetzt können wir weitere Container basierend auf diesem Image erstellen.