Docker-Instanz aus Dockerdatei ausführen

Isaac Tony 23 August 2022
Docker-Instanz aus Dockerdatei ausführen

Docker-Container sind zweifellos zur Standardeinheit geworden, wenn es um die Verwaltung von Software und Abhängigkeiten in verschiedenen Umgebungen geht. Wenn Sie mit echten Anwendungen arbeiten, müssen Sie eine Docker-Datei erstellen, bevor Sie das Container-Image Ihrer Anwendung erstellen.

Eine Dockerfile ist einfach ein schreibgeschütztes Textdokument mit Anweisungen, die beim Zusammenstellen eines Docker-Image festgelegt werden. Andererseits ist ein Docker-Image eine Reihe von Anweisungen, Anwendungscode, Abhängigkeiten, Tools und Bibliotheken, die zum Erstellen eines Docker-Containers verwendet werden.

Daher ist ein Container eine ausführbare Instanz des Docker-Images, das aus einer Docker-Datei zusammengesetzt wird.

Dieser Artikel führt Sie durch die Schritte zum Erstellen einer Docker-Datei und zum Ausführen einer Docker-Instanz aus dieser Datei.

Schritte zum Ausführen einer Docker-Instanz aus Dockerfile

Wir müssen die folgenden Schritte ausführen, um eine Docker-Instanz aus der Dockerfile auszuführen.

Eine Dockerdatei erstellen

Um ein Dockerfile zu erstellen, müssen wir seine Komponenten verstehen. Einige der häufigsten Befehle sind:

  • FROM: Erstellt eine Ebene des verwendeten Eltern-/Basisbildes.
  • WORKDIR: erlaubt uns, das Arbeitsverzeichnis festzulegen.
  • COPY: ermöglicht uns, aktuelle Verzeichnisinhalte in ein Verzeichnis im Container zu kopieren.
  • PULL: fügt Dateien aus Ihrem Docker-Repository hinzu.
  • RUN: wird ausgeführt, wenn wir das Image erstellen wollen.
  • CMD: gibt an, welcher Befehl ausgeführt werden soll, wenn der Container startet.
  • ENV: definiert Umgebungsvariablen, die während des Builds verwendet werden.
  • ENTRYPOINT: bestimmt, welcher Befehl ausgeführt werden soll, wenn der Container startet.
  • MAINTAINER: gibt den Urheber des Bildes an.

Um ein Dockerfile zu erstellen, erstellen wir zunächst das Hauptverzeichnis, das neben anderen Dateien das Dockerfile hosten wird. Wir werden eine einfache Flask-Anwendung erstellen, die eine Nachricht auf der Konsole ausgibt.

mkdir my-app

Nun wechseln wir in dieses Verzeichnis und erstellen die Hauptdatei Ihrer Anwendung als app.py. Diese Datei enthält den Anwendungscode für das Programm.

from flask import Flask

app = Flask(__name__)


def hello():

    print("Hello, this is a simple Flask application")


hello()

Wir können jetzt damit fortfahren, unser Dockerfile zu erstellen und es mit den erforderlichen Befehlen zu füllen, um ein Docker-Image zu erstellen.

touch Dockerfile

Wir haben auch eine requirements.txt-Datei erstellt, die die notwendige Datei enthält, die zum Ausführen dieser Anwendung installiert werden muss. Die Anforderungen sind unten aufgeführt.

click==8.0.4
Flask==2.0.3
gunicorn==20.1.0
itsdangerous==2.1.0
Jinja2==3.0.3
MarkupSafe==2.1.0
Werkzeug==2.0.3

Wir werden die Dockerfile bearbeiten und die folgenden Befehle hinzufügen, um Docker-Images mit dem Befehl docker build zu erstellen. In diesem Fall ist Python das Basisimage.

Wir haben auch das Arbeitsverzeichnis festgelegt und die notwendigen Dateien aus dem aktuellen Verzeichnis in das Verzeichnis im Docker-Container kopiert.

#  base image
FROM python

# Set your working directory
WORKDIR /var/www/
# Copy the necessary files
COPY ./app.py /var/www/app.py
COPY ./requirements.txt /var/www/requirements.txt

# Install the necessary packages
RUN pip install -r /var/www/requirements.txt
# Run the app
CMD ["echo", "Hello, Developer"]

Erstellen Sie ein Docker-Image

Wir fahren fort, ein Docker-Image mit dem Befehl docker build zu erstellen. Wir müssen diesen Befehl jedoch im selben Verzeichnis ausführen.

Syntax:

$ docker build [OPTIONS] PATH | URL | -

Innerhalb des Verzeichnisses my-app führen wir den folgenden Befehl aus. Das Flag -t ermöglicht es uns, den Namen des Bildes zu markieren und anzuzeigen, dass sich die Dockerfile in demselben Verzeichnis befindet, in dem wir diesen Befehl ausführen.

~/my-app$ docker build -t new_image .

Ausgabe:

[+] Building 184.4s (10/10) FINISHED
 => [internal] load build definition from Dockerfile                                                                                       1.5s
 => => transferring dockerfile: 38B                                                                                                        0.0s
 => [internal] load .dockerignore                                                                                                          1.9s
 => => transferring context: 2B                                                                                                            0.0s
 => [internal] load metadata for docker.io/library/python:latest                                                                          50.8s
 => [1/5] FROM docker.io/library/python@sha256:3204faabc2f0b5e0939bdb8b29079a2a330c38dee92a22482a9ed449c5649a55                           30.4s
 => => resolve docker.io/library/python@sha256:3204faabc2f0b5e0939bdb8b29079a2a330c38dee92a22482a9ed449c5649a55                            0.4s
 => => sha256:3204faabc2f0b5e0939bdb8b29079a2a330c38dee92a22482a9ed449c5649a55 2.14kB / 2.14kB                                             0.0s
 => => sha256:17e2d81e5757980ee40742d77dd5d3e1a69ad0d6dacb13064e1b018a6664ec72 2.22kB / 2.22kB                                             0.0s
 => => sha256:178dcaa62b393b539abc8b866c39be81e8ade01786880dc5d17ce3fe02426dbb 8.55kB / 8.55kB                                             0.0s
 => => sha256:38121472aa0128f87b31fde5c07080418cc17b4a8ee224767b59e24c592ff7d3 2.34MB / 2.34MB                                            10.4s
 => => extracting sha256:38121472aa0128f87b31fde5c07080418cc17b4a8ee224767b59e24c592ff7d3                                                 14.6s
 => [internal] load build context                                                                                                          1.1s
 => => transferring context: 195B                                                                                                          0.0s
 => [2/5] WORKDIR /var/www/                                                                                                                3.2s
 => [3/5] COPY ./app.py /var/www/app.py                                                                                                    1.9s
 => [4/5] COPY ./requirements.txt /var/www/requirements.txt                                                                                2.6s
 => [5/5] RUN pip install -r /var/www/requirements.txt                                                                                    82.3s
 => exporting to image                                                                                                                     8.1s
 => => exporting layers                                                                                                                    6.0s
 => => writing image sha256:5811f24b498ae784af32935318a5fddba536e2be27233b19bf08cad81438d114                                               0.2s
 => => naming to docker.io/library/new_image

Wir können jetzt die Docker-Images mit dem Befehl docker images unten auflisten.

~/my-app$ docker images

Ausgabe:

REPOSITORY           TAG       IMAGE ID       CREATED         SIZE
new_image            latest    5811f24b498a   2 minutes ago   929MB

Führen Sie die Instanz aus der Docker-Datei aus

Um aus diesem Docker-Image eine lauffähige Instanz zu erstellen, verwenden wir den Befehl docker run, um eine beschreibbare Ebene über dem zuvor erstellten Image zu erstellen.

Syntax:

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

Schließlich können wir jetzt mit dem obigen Befehl eine lauffähige Instanz erstellen.

~/my-app$ docker run -it new_image
Hello, Developer
Autor: Isaac Tony
Isaac Tony avatar Isaac Tony avatar

Isaac Tony is a professional software developer and technical writer fascinated by Tech and productivity. He helps large technical organizations communicate their message clearly through writing.

LinkedIn