Zum Inhalt springen

Docker/Containerisieren: Unterschied zwischen den Versionen

Aus Foxwiki
Versionsgeschichte interaktiv durchsuchen
VisuellWikitext
Die Seite wurde neu angelegt: „== Containerisieren == ; Containerisieren einer Anwendung Im weiteren Verlauf dieser Anleitung werden Sie mit einem einfachen ToDo-Listen-Manager arbeiten, der auf Node.js läuft. Wenn Sie mit Node.js nicht vertraut sind, machen Sie sich keine Sorgen. Für diese Anleitung sind keine Vorkenntnisse in JavaScript erforderlich === [https://docs.docker.com/get-started/workshop/02_our_app/#prerequisites Voraussetzungen] === * Sie haben die neueste Version von…“
 
DanielZorin (Diskussion | Beiträge)
Bürokraten, Page Ownership admin
335 Bearbeitungen
 
(79 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
== Containerisieren ==
'''{{BASEPAGENAME}}'''
 
== Beschreibung ==
; Containerisieren einer Anwendung
; Containerisieren einer Anwendung
Im weiteren Verlauf dieser Anleitung werden Sie mit einem einfachen ToDo-Listen-Manager arbeiten, der auf Node.js läuft. Wenn Sie mit Node.js nicht vertraut sind, machen Sie sich keine Sorgen. Für diese Anleitung sind keine Vorkenntnisse in JavaScript erforderlich
* Erstellung eines Dockerfiles zur Erstellung eines Images
* Container starten
* Laufende Anwendung prüfen


=== [https://docs.docker.com/get-started/workshop/02_our_app/#prerequisites Voraussetzungen] ===
; Beispiel
* Sie haben die neueste Version von [https://docs.docker.com/get-started/get-docker/ Docker Desktop] installiert
ToDo-Manager der auf Node.js basiert
* Sie haben einen [https://git-scm.com/downloads Git-Client] installiert
* JavaScript-Vorkenntnisse sind hier nicht erforderlich
* Sie verfügen über eine IDE oder einen Texteditor zum Bearbeiten von Dateien. Docker empfiehlt die Verwendung von [https://code.visualstudio.com/ Visual Studio Code]


=== [https://docs.docker.com/get-started/workshop/02_our_app/#get-the-app Holen Sie sich die Anwendung] ===
== Anwendung ==
Bevor Sie die Anwendung ausführen können, müssen Sie den Quellcode der Anwendung auf Ihren Rechner holen.# Klonen Sie das [https://github.com/docker/getting-started-app/tree/main getting-started-app-Repository] mit dem folgenden Befehl:
; Anwendung herunterladen
getting-started-app-Repositorys klonen
<syntaxhighlight lang="bash" highlight="1" line copy>
git clone https://github.com/docker/getting-started-app.git
</syntaxhighlight>


* git clone https://github.com/docker/getting-started-app.git
; Inhalt des geklonten Repositorys
<syntaxhighlight lang="bash" highlight="1" copy line>
tree -L 1 -a getting-started-app
</syntaxhighlight>
└── getting-started-app/
    ├── .dockerignore
    ├── package.json
    ├── README.md
    ├── spec/
    ├── src/
    └── yarn.lock


* Sehen Sie sich den Inhalt des geklonten Repositorys an. Sie sollten die folgenden Dateien und Unterverzeichnisse sehen
== Dockerfile ==
; Dockerfile anlegen
Ein Dockerfile ist einfach eine textbasierte Datei, die ein Skript mit Anweisungen enthält
* Docker verwendet dieses Skript, um ein Container-Image zu erstellen


# ├── getting-started-app/
Erstellen Sie im Verzeichnis ''getting-started-app'' eine Datei namens '''Dockerfile''' mit folgendem Inhalt
<syntaxhighlight lang="dockerfile" highlight="" line copy>
# syntax=docker/dockerfile:1


│ ├── .dockerignore
FROM node:lts-alpine
WORKDIR /app
COPY . .
RUN yarn install --production
CMD ["node", "src/index.js"]
EXPOSE 3000
</syntaxhighlight>


│ ├── package.json
Dieses Dockerfile beginnt mit einem node:lts-alpine-Basis-Image, einem leichtgewichtigen Linux-Image, auf dem Node.js und der Yarn-Paketmanager vorinstalliert sind
* Es kopiert den gesamten Quellcode in das Image, installiert die notwendigen Abhängigkeiten und startet die Anwendung


│ ├── README.md
; Beschreibung
# syntax
# [https://docs.docker.com/reference/dockerfile/#from]
# [https://docs.docker.com/reference/dockerfile/#workdir]
# [https://docs.docker.com/reference/dockerfile/#copy]
# [https://docs.docker.com/reference/dockerfile/#run]
# [https://docs.docker.com/reference/dockerfile/#cmd]
# [https://docs.docker.com/reference/dockerfile/#expose]


│ ├── spec/
== Image ==
; Image erstellen


│ ├── src/


│ └── yarn.lock
<syntaxhighlight lang="bash" highlight="1" line copy>
cd getting-started-app
</syntaxhighlight>


=== [https://docs.docker.com/get-started/workshop/02_our_app/#build-the-apps-image Das Image der Anwendung erstellen] ===
; docker buildx build
Um das Image zu erstellen, müssen Sie ein Dockerfile verwenden. Ein Dockerfile ist einfach eine textbasierte Datei ohne Dateierweiterung, die ein Skript mit Anweisungen enthält. Docker verwendet dieses Skript, um ein Container-Image zu erstellen.# Erstellen Sie im Verzeichnis getting-started-app, demselben Ort wie die Datei package.json, eine Datei namens Dockerfile mit folgendem Inhalt:
<syntaxhighlight lang="bash" highlight="1" line copy>
docker buildx build -t getting-started .
</syntaxhighlight>


* <nowiki># syntax=docker/dockerfile:1</nowiki>
Der Befehl '''''docker buildx build''''' verwendet das Dockerfile, um ein neues Image zu erstellen
* Sie haben vielleicht bemerkt, dass Docker eine Menge "Schichten" heruntergeladen hat
* Das liegt daran, dass Sie dem Builder mitgeteilt haben, dass Sie mit dem node:lts-alpine-Abbild beginnen wollen
* Da Sie dieses aber nicht auf Ihrem Rechner hatten, musste Docker das Abbild herunterladen


[https://docs.docker.com/reference/dockerfile/#from FROM] node:lts-alpine
Nachdem Docker das Image heruntergeladen hat, kopierten die Anweisungen aus der Dockerdatei Ihre Anwendung und installierten mithilfe von Garn die Abhängigkeiten Ihrer Anwendung
* Die CMD-Direktive gibt den Standardbefehl an, der beim Starten eines Containers aus diesem Image ausgeführt werden soll


[https://docs.docker.com/reference/dockerfile/#workdir WORKDIR] /app
Das Flag <code>-t</code> schließlich kennzeichnet Ihr Image
* Stellen Sie sich dies als einen für Menschen lesbaren Namen für das endgültige Image vor
* Da Sie dem Abbild den Namen getting-started gegeben haben, können Sie auf dieses Abbild verweisen, wenn Sie einen Container starten


[https://docs.docker.com/reference/dockerfile/#copy COPY] .
Das <code>.</code> am Ende des Docker-Build-Befehls teilt Docker mit, dass es im aktuellen Verzeichnis nach dem Dockerfile suchen soll


[https://docs.docker.com/reference/dockerfile/#run RUN] yarn install --production
== Container ==
; Container starten
Starten Sie Ihren Container mit dem Befehl docker run und geben Sie den Namen des soeben erstellten Images an


[https://docs.docker.com/reference/dockerfile/#cmd CMD] ["node", "src/index.js"]
<syntaxhighlight lang="bash" highlight="1" line copy>
docker run -d -p 127.0.0.1:3000:3000 getting-started
</syntaxhighlight>


[https://docs.docker.com/reference/dockerfile/#expose EXPOSE] 3000
Mit dem Flag <code>-d</code> (kurz für <code>--detach</code> ) wird der Container im Hintergrund ausgeführt
* Das bedeutet, dass Docker Ihren Container startet und Sie zur Terminal-Eingabeaufforderung zurückkehren
* Außerdem werden keine Protokolle im Terminal angezeigt


Dieses Dockerfile beginnt mit einem node:lts-alpine-Basis-Image, einem leichtgewichtigen Linux-Image, auf dem Node.js und der Yarn-Paketmanager vorinstalliert sind. Es kopiert den gesamten Quellcode in das Image, installiert die notwendigen Abhängigkeiten und startet die Anwendung.* Erstellen Sie das Image mit den folgenden Befehlen:
Das Flag <code>-p</code> (kurz für <code>--publish</code> ) erstellt eine Port-Zuordnung zwischen dem Host und dem Container
* Das Flag <code>-p</code> nimmt einen String-Wert im Format HOST:CONTAINER an, wobei HOST die Adresse des Hosts und CONTAINER der Port des Containers ist
* Der Befehl veröffentlicht den Port 3000 des Containers auf 127.0.0.1:3000 (localhost:3000) auf dem Host
* Ohne die Port-Zuordnung wäre es nicht möglich, vom Host aus auf die Anwendung zuzugreifen.
* Öffnen Sie nach ein paar Sekunden Ihren Webbrowser auf http://localhost:3000
* Sie sollten Ihre Anwendung sehen


Vergewissern Sie sich im Terminal, dass Sie sich im getting-started-app-Verzeichnis befinden. Ersetzen Sie /path/to/getting-started-app durch den Pfad zu Ihrem getting-started-app-Verzeichnis
; Port nach außen veröffentlichen
Um diesen Port nach außen zu veröffentlichen, muss die Syntax <port:port> verwendet werden
<syntaxhighlight lang="bash" highlight="1" line copy>
docker run -d -p 3000:3000 getting-started
</syntaxhighlight>


cd /pfad/bis/getting-started-app
Fügen Sie ein oder zwei Elemente hinzu und prüfen Sie, ob sie wie erwartet funktioniert
* Sie können Elemente als vollständig markieren und entfernen
* Ihr Frontend speichert erfolgreich Elemente im Backend


Erstellen Sie das Image.# docker build -t getting-started
Zu diesem Zeitpunkt haben Sie einen laufenden ToDo-Listen-Manager mit ein paar Einträgen


Der Befehl docker build verwendet das Dockerfile, um ein neues Image zu erstellen. Sie haben vielleicht bemerkt, dass Docker eine Menge "Schichten" heruntergeladen hat. Das liegt daran, dass Sie dem Builder mitgeteilt haben, dass Sie mit dem node:lts-alpine-Abbild beginnen wollen. Da Sie dieses aber nicht auf Ihrem Rechner hatten, musste Docker das Abbild herunterladen
Wenn Sie einen kurzen Blick auf Ihre Container werfen, sollten Sie mindestens einen Container sehen, der das Getting-Started-Image verwendet und auf Port 3000 läuft
* Um Ihre Container zu sehen, können Sie die CLI oder die grafische Oberfläche von Docker Desktop verwenden


Nachdem Docker das Image heruntergeladen hatte, kopierten die Anweisungen aus der Dockerdatei Ihre Anwendung und installierten mit Hilfe von Garn die Abhängigkeiten Ihrer Anwendung. Die CMD-Direktive gibt den Standardbefehl an, der beim Starten eines Containers aus diesem Image ausgeführt werden soll
; Container aufzulisten
<syntaxhighlight lang="bash" highlight="1" line copy>
docker ps
</syntaxhighlight>


Das Flag -t schließlich kennzeichnet Ihr Image. Stellen Sie sich dies als einen für Menschen lesbaren Namen für das endgültige Image vor. Da Sie dem Abbild den Namen getting-started gegeben haben, können Sie auf dieses Abbild verweisen, wenn Sie einen Container starten
Es sollte eine ähnliche Ausgabe wie die folgende erscheinen


Das . am Ende des Docker-Build-Befehls teilt Docker mit, dass es im aktuellen Verzeichnis nach dem Dockerfile suchen soll
<syntaxhighlight lang="bash" highlight="" line>
CONTAINER ID  IMAGE            COMMAND                  CREATED        STATUS        PORTS                      NAMES
df784548666d getting-started "docker-entrypoint.s..." vor 2 Minuten Up 2 Minuten 127.0.0.1:3000->3000/tcp priceless_mcclintock
</syntaxhighlight>


=== [https://docs.docker.com/get-started/workshop/02_our_app/#start-an-app-container Starten eines App-Containers] ===
== Nächste Schritte ==
Jetzt, da Sie ein Image haben, können Sie die Anwendung mit dem Befehl docker run in einem Container ausführen.# Starten Sie Ihren Container mit dem Befehl docker run und geben Sie den Namen des soeben erstellten Images an:
[[Docker/Workshop/Aktualisieren]]
* Änderung an Anwendungen vornehmen
* Laufende Anwendung mit einem neuen Image aktualisieren
* Weitere nützliche Befehle


# docker run -d -p 127.0.0.1:3000:3000 getting-started
<noinclude>


Mit dem Flag -d (kurz für --detach) wird der Container im Hintergrund ausgeführt. Das bedeutet, dass Docker Ihren Container startet und Sie zur Terminal-Eingabeaufforderung zurückkehren. Außerdem werden keine Protokolle im Terminal angezeigt
== Anhang ==
=== Siehe auch ===
<div style="column-count:2">
<categorytree hideroot=on mode="pages">Docker/Workshop</categorytree>
</div>
----
{{Special:PrefixIndex/{{BASEPAGENAME}}/}}


Das Flag -p (kurz für --publish) erstellt eine Port-Zuordnung zwischen dem Host und dem Container. Das Flag -p nimmt einen String-Wert im Format HOST:CONTAINER an, wobei HOST die Adresse des Hosts und CONTAINER der Port des Containers ist. Der Befehl veröffentlicht den Port 3000 des Containers auf 127.0.0.1:3000 (localhost:3000) auf dem Host. Ohne die Portzuordnung wäre es nicht möglich, vom Host aus auf die Anwendung zuzugreifen.# Öffnen Sie nach ein paar Sekunden Ihren Webbrowser auf http://localhost:3000. Sie sollten Ihre Anwendung sehen
=== Dokumentation ===
 
# https://docs.docker.com/reference/cli/docker
# Fügen Sie ein oder zwei Elemente hinzu und prüfen Sie, ob sie wie erwartet funktioniert. Sie können Elemente als vollständig markieren und entfernen. Ihr Frontend speichert erfolgreich Elemente im Backend
<!--
 
; Man-Page
Zu diesem Zeitpunkt haben Sie einen laufenden ToDo-Listen-Manager mit ein paar Einträgen
# [https://manpages.debian.org/stable/procps/pgrep.1.de.html prep(1)]
 
Wenn Sie einen kurzen Blick auf Ihre Container werfen, sollten Sie mindestens einen Container sehen, der das Getting-Started-Image verwendet und auf Port 3000 läuft. Um Ihre Container zu sehen, können Sie die CLI oder die grafische Oberfläche von Docker Desktop verwenden
 
Führen Sie den Befehl docker ps in einem Terminal aus, um Ihre Container aufzulisten
 
docker ps
 
Es sollte eine ähnliche Ausgabe wie die folgende erscheinen
 
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
 
df784548666d getting-started "docker-entrypoint.s..." vor 2 Minuten Up 2 Minuten 127.0.0.1:3000->3000/tcp priceless_mcclintock


=== [https://docs.docker.com/get-started/workshop/02_our_app/#summary Zusammenfassung] ===
; Info-Pages
In diesem Abschnitt haben Sie die Grundlagen über die Erstellung eines Dockerfiles zur Erstellung eines Images gelernt. Nachdem Sie ein Image erstellt haben, haben Sie einen Container gestartet und die laufende Anwendung gesehen
-->


Verwandte Informationen
=== Links ===
* [https://docs.docker.com/reference/dockerfile/ Dockerfile-Referenz]
==== Projekt ====
* [https://docs.docker.com/reference/cli/docker/ Docker-CLI-Referenz]
==== Weblinks ====
# [https://docs.docker.com/reference/dockerfile/ Dockerfile-Referenz]
# [https://docs.docker.com/reference/cli/docker/ Docker-CLI-Referenz]


=== [https://docs.docker.com/get-started/workshop/02_our_app/#next-steps Nächste Schritte] ===
[[Kategorie:Docker]]
Als Nächstes werden Sie eine Änderung an Ihrer Anwendung vornehmen und lernen, wie Sie Ihre laufende Anwendung mit einem neuen Image aktualisieren können. Nebenbei lernen Sie einige weitere nützliche Befehle kennen


[https://docs.docker.com/get-started/workshop/03_updating_app/ Aktualisieren der Anwendung]
</noinclude>

Aktuelle Version vom 3. November 2025, 14:31 Uhr

Docker/Containerisieren

Beschreibung

Containerisieren einer Anwendung
  • Erstellung eines Dockerfiles zur Erstellung eines Images
  • Container starten
  • Laufende Anwendung prüfen
Beispiel

ToDo-Manager der auf Node.js basiert

  • JavaScript-Vorkenntnisse sind hier nicht erforderlich

Anwendung

Anwendung herunterladen

getting-started-app-Repositorys klonen 

git clone https://github.com/docker/getting-started-app.git
Inhalt des geklonten Repositorys
tree -L 1 -a getting-started-app

└── getting-started-app/
    ├── .dockerignore
    ├── package.json
    ├── README.md
    ├── spec/
    ├── src/
    └── yarn.lock

Dockerfile

Dockerfile anlegen

Ein Dockerfile ist einfach eine textbasierte Datei, die ein Skript mit Anweisungen enthält

  • Docker verwendet dieses Skript, um ein Container-Image zu erstellen

Erstellen Sie im Verzeichnis getting-started-app eine Datei namens Dockerfile mit folgendem Inhalt 

# syntax=docker/dockerfile:1

FROM node:lts-alpine
WORKDIR /app
COPY . .
RUN yarn install --production
CMD ["node", "src/index.js"]
EXPOSE 3000

Dieses Dockerfile beginnt mit einem node:lts-alpine-Basis-Image, einem leichtgewichtigen Linux-Image, auf dem Node.js und der Yarn-Paketmanager vorinstalliert sind

  • Es kopiert den gesamten Quellcode in das Image, installiert die notwendigen Abhängigkeiten und startet die Anwendung
Beschreibung
  1. syntax
  2. [1]
  3. [2]
  4. [3]
  5. [4]
  6. [5]
  7. [6]

Image

Image erstellen


cd getting-started-app
docker buildx build
docker buildx build -t getting-started .

Der Befehl docker buildx build verwendet das Dockerfile, um ein neues Image zu erstellen

  • Sie haben vielleicht bemerkt, dass Docker eine Menge "Schichten" heruntergeladen hat
  • Das liegt daran, dass Sie dem Builder mitgeteilt haben, dass Sie mit dem node:lts-alpine-Abbild beginnen wollen
  • Da Sie dieses aber nicht auf Ihrem Rechner hatten, musste Docker das Abbild herunterladen

Nachdem Docker das Image heruntergeladen hat, kopierten die Anweisungen aus der Dockerdatei Ihre Anwendung und installierten mithilfe von Garn die Abhängigkeiten Ihrer Anwendung

  • Die CMD-Direktive gibt den Standardbefehl an, der beim Starten eines Containers aus diesem Image ausgeführt werden soll

Das Flag -t schließlich kennzeichnet Ihr Image

  • Stellen Sie sich dies als einen für Menschen lesbaren Namen für das endgültige Image vor
  • Da Sie dem Abbild den Namen getting-started gegeben haben, können Sie auf dieses Abbild verweisen, wenn Sie einen Container starten

Das . am Ende des Docker-Build-Befehls teilt Docker mit, dass es im aktuellen Verzeichnis nach dem Dockerfile suchen soll

Container

Container starten

Starten Sie Ihren Container mit dem Befehl docker run und geben Sie den Namen des soeben erstellten Images an 

docker run -d -p 127.0.0.1:3000:3000 getting-started

Mit dem Flag -d (kurz für --detach ) wird der Container im Hintergrund ausgeführt

  • Das bedeutet, dass Docker Ihren Container startet und Sie zur Terminal-Eingabeaufforderung zurückkehren
  • Außerdem werden keine Protokolle im Terminal angezeigt

Das Flag -p (kurz für --publish ) erstellt eine Port-Zuordnung zwischen dem Host und dem Container

  • Das Flag -p nimmt einen String-Wert im Format HOST:CONTAINER an, wobei HOST die Adresse des Hosts und CONTAINER der Port des Containers ist
  • Der Befehl veröffentlicht den Port 3000 des Containers auf 127.0.0.1:3000 (localhost:3000) auf dem Host
  • Ohne die Port-Zuordnung wäre es nicht möglich, vom Host aus auf die Anwendung zuzugreifen.
  • Öffnen Sie nach ein paar Sekunden Ihren Webbrowser auf http://localhost:3000
  • Sie sollten Ihre Anwendung sehen
Port nach außen veröffentlichen

Um diesen Port nach außen zu veröffentlichen, muss die Syntax <port:port> verwendet werden 

 docker run -d -p 3000:3000 getting-started

Fügen Sie ein oder zwei Elemente hinzu und prüfen Sie, ob sie wie erwartet funktioniert

  • Sie können Elemente als vollständig markieren und entfernen
  • Ihr Frontend speichert erfolgreich Elemente im Backend

Zu diesem Zeitpunkt haben Sie einen laufenden ToDo-Listen-Manager mit ein paar Einträgen

Wenn Sie einen kurzen Blick auf Ihre Container werfen, sollten Sie mindestens einen Container sehen, der das Getting-Started-Image verwendet und auf Port 3000 läuft

  • Um Ihre Container zu sehen, können Sie die CLI oder die grafische Oberfläche von Docker Desktop verwenden
Container aufzulisten
docker ps

Es sollte eine ähnliche Ausgabe wie die folgende erscheinen 

CONTAINER ID   IMAGE             COMMAND                  CREATED         STATUS        PORTS                      NAMES
df784548666d getting-started "docker-entrypoint.s..." vor 2 Minuten Up 2 Minuten 127.0.0.1:3000->3000/tcp priceless_mcclintock

Nächste Schritte

Docker/Workshop/Aktualisieren

  • Änderung an Anwendungen vornehmen
  • Laufende Anwendung mit einem neuen Image aktualisieren
  • Weitere nützliche Befehle


Anhang

Siehe auch

Kategorie Docker/Workshop wurde nicht gefunden


Dokumentation

  1. https://docs.docker.com/reference/cli/docker

Links

Projekt

Weblinks

  1. Dockerfile-Referenz
  2. Docker-CLI-Referenz


Abgerufen von „https://wiki.foxtom.de/index.php?title=Docker/Containerisieren&oldid=156877“