Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- it-wiki:docker:docker_createcontainerimages [2021/10/17 15:46] – angelegt marko
+++ it-wiki:docker:docker_createcontainerimages [2021/10/18 06:50] (aktuell) – [6. Dein neues Docker-Image starten. Wohooo!] marko
@@ Zeile 23: / Zeile 23: @@
 Dockerfile's sind einfache Textdateien, die pro Zeile einen Befehl enthalten. Damit du ein Base-Image definieren kannst, benutzt du folgenden Befehl:
+<code bash>
+FROM <image-name>:<tag>
+</code>
+Da wir Nginx benötigen, sollte unsere erste Zeile im Dockerfile wie folgt aussehen:
+<code bash>
+FROM nginx:1.11-alpine
+</code>
+Schreibe diese Zeile in dein Dockerfile und speichere die Datei.
+**Hinweis zur Versionierung von Images:**
+Es ist so schön einfach :latest-Tag zu verwenden, um die aktuelle Image-Version zu erhalten. Jedoch ist hier vorsicht geboten. Nicht immer bekommst du die Version des Image, die auf deine Anwendung abgestimmt ist. Ich empfehle dir daher immer die spezifische Versionsnummer als Tag anzugeben.
+Sobald du eine Aktualisierung vorgenommen hast, solltest du dein Dockerfile auf die entsprechend Versionsnummer abändern.
+Ja, das ist mehr Aufwand, aber es schützt auch vor Kopfschmerzen durch inkompatible Versionen!
+===== 2. Befehle ausführen =====
+Wenn du das Base-Image angegeben hast, musst du weitere Befehle definieren, um dein Image zu konfigurieren. Hier gibt es mehrere Befehle, die dir dabei helfen z.B. RUN und COPY.
+Hier eine kurze Erklärung zu RUN und COPY:
+=== RUN <Befehl> ===
+Der RUN-Befehl erlaubt es dir, jeden Befehl wie in der Kommandozeile auszuführen. Damit kannst du bspw. verschiedene Anwendungspakete installieren oder einen Build-Befehl ausführen.
+Die Ergebnisse des RUN-Befehls werden im Image gespeichert, daher ist es wichtig, keine unnötigen oder temporären Dateien (z.B. Cache-Dateien) zu hinterlassen, da diese sonst in das Image eingebunden werden.
+=== COPY <Quelle> <Ziel> ===
+Mit COPY kannst du Dateien aus dem Verzeichnis, in dem sich dein Dockerfile befindet, in das Image des Containers kopieren. Das ist besonders nützlich für Quellcode und Assets, die du in deinem Container bereitstellen möchtest.
+**Hier eine einfache Übung zum COPY-Befehl:**
+Um etwas Praxis-Erfahrung zu bekommen führe Folgendes aus.
+  - Erstelle eine .html Datei z.B. index.html und fülle sie mit etwas Inhalt. Diese Datei wollen wir im Anschluss in unserem Container bereitstellen.
+  - Benutze in der nächsten Zeile den Befehl COPY Befehl, um die index.html in das Nginx-Verzeichnis /usr/share/nginx/html zu kopieren.
+Hast du das gemacht? Gut! Dann geht es jetzt weiter mit der Freischaltung der Ports.
+===== 3. Ports freigeben (öffnen) =====
+Wenn die Dateien in unser Image kopiert wurden und die Dependencies heruntergeladen sind, musst du noch den Port definieren. Genauer gesagt musst du spezifizieren, auf welchem Port die Anwendung zugänglich sein wird.
+Dafür benutzt du den Befehl //EXPOSE <port>// . Wir teilen Docker mit, welche Ports offen sein sollen und an welche Ports Docker gebunden werden kann. Es ist auch möglich gleich mehrere Ports einem einzigen Befehl zu definieren.
+**Docker-Beispiel, um mehrere Ports freizugeben:**
+<code bash>
+EXPOSE 80 433
+EXPOSE 7000-8000
+</code>
+Wenn du diesen Schritt nachmachen möchtest, dann gib mit dem obigen Befehl den Port 80 frei. Der Port 80 muss geöffnet sein, damit unser Webserver (Nginx) verfügbar ist. Füge die Zeile (EXPOSE 80) deinem Dockerfile hinzu, um diesen Schritt auszuführen und speichere deine Datei.
+===== 4. Anwendung per Befehl starten =====
+Fassen wir kurz zusammen was bis hierhin passiert ist. Du hast ein Docker-Image konfiguriert und festgelegt, auf welchen Port deine Anwendung zugreifen muss. Jetzt ist es an der Zeit den Befehl zu definieren, der deine Anwendung startet.
+Der CMD-Befehl in einem Dockerfile definiert den Standardbefehl, der ausgeführt wird sobald dein Container gestartet wird. Wenn der Befehl zusätzliche Argumente benötigt, solltest du dafür ein Array verwenden.
+**CMD Befehl mit Argumenten als Array:**
+["cmd", "-a", "arga value", "-b", "argb-value"]
+Die obige Zeile würde dann den Befehl **"cmd -a "arga value" -b argb-value"** ausführen.
+Jetzt bist du wieder gefragt: Der Befehl zum Ausführen von NGINX lautet nginx -g daemon off;.
+Setze diesen Befehl als Standardbefehl in deinem Dockerfile.
+===== 5. Das Container-Image erstellen =====
+Nachdem du dein Dockerfile definiert hast, musst du es mit docker build in ein Image umwandeln. Der Befehl build nimmt ein Verzeichnis mit dem Dockerfile auf, führt die Schritte aus und speichert das Image in deiner lokalen Docker Engine. Wenn einer der Schritte aufgrund eines Fehlers fehlschlägt, wird die Container-Erstellung abgebrochen.
+**Willst du diesen Schritt nachmachen?**
+Benutze den Befehl **docker build**, um das Image zu bauen. Du kannst dem Image einen lesbaren Namen geben, indem du das Argument -t <name> verwendest z.B.
+<code bash>
+docker build -t mein-image
+</code>
+Tipp: Mit dem Befehl docker images siehst du eine Liste deiner Images. Damit kannst du prüfen, ob der Build-Vorgang erfolgreich beendet wurde.
+===== 6. Dein neues Docker-Image starten. Wohooo! =====
+Wenn das Image erfolgreich erstellt wurde, kannst du den Container nun auf die gleiche Weise starten, wie du es schon aus vorherigen Tutorials kennst. Solltest du noch nicht wissen, wie du ein Image startest, findest du nachfolgend den Befehl dafür.
+**Du möchtest diesen Schritt nachmachen?** Starte eine Instanz deines brandneuen Images, indem du die ID des Build oder den Shortname (Nice-Name) verwendest, den du im letzten Schritt zugewiesen hast.
+Der Webserver Nginx ist so konzipiert, dass er als Hintergrund-Prozess läuft. Du solltest daher die Option -d verwenden. Beim Ausführen solltest du als Argument ebenso den Port 80 an deinen Container binden (p 80:80).
+Klingt kompliziert?
+**Hier der fertige docker run Befehl:**
+<code bash>
+docker run -d -p 80:80 <Image ID oder Shortname>
+</code>
+Da ich mein Image im letzten Schritt "mein-image" genannt habe würde der Befehl so aussehen:
+<code bash>
+docker run -d -p 80:80 mein-image
+</code>
+Du kannst überprüfen, ob dein Container läuft, indem du folgenden Befehl benutzt: docker ps