Wie man eine Node.js-Anwendung mit Docker erstellt

  • 403-Ansichten
  • 15-Minutenlesung
Hadi Bahadori
  • 8. Februar 2024
0 Aktien
0
0
0
0
0
Aktien
0
0
0
0

Einführung

Die Docker-Plattform ermöglicht es Entwicklern, Anwendungen als Container zu verpacken und auszuführen. Ein Container ist ein einzelner Prozess, der auf einem gemeinsam genutzten Betriebssystem läuft und eine ressourcenschonendere Alternative zu virtuellen Maschinen darstellt. Obwohl Container nicht neu sind, bieten sie Vorteile – darunter Prozessisolation und Standardisierung der Umgebung –, die mit zunehmender Verbreitung verteilter Anwendungsarchitekturen immer wichtiger werden.

Beim Erstellen und Skalieren einer Anwendung mit Docker besteht der erste Schritt üblicherweise darin, ein Image für die Anwendung zu erstellen, das anschließend in einem Container ausgeführt werden kann. Dieses Image enthält den Anwendungscode, Bibliotheken, Konfigurationsdateien, Umgebungsvariablen und die Laufzeitumgebung. Durch die Verwendung eines Images wird sichergestellt, dass die Containerumgebung standardisiert ist und nur die Komponenten enthält, die zum Erstellen und Ausführen der Anwendung erforderlich sind.

In diesem Tutorial erstellen Sie ein Anwendungsimage für eine statische Website, die die Frameworks Express und Bootstrap nutzt. Anschließend erstellen Sie mit diesem Image einen Container und laden ihn zur späteren Verwendung in Docker Hub hoch. Abschließend laden Sie das gespeicherte Image aus Ihrem Docker-Hub-Repository herunter und erstellen daraus einen weiteren Container. Dies demonstriert, wie Sie Ihre Anwendung refaktorisieren und skalieren können.

Voraussetzungen

  • Ein Server mit Ubuntu, auf dem ein Benutzer ohne Root-Rechte (sudo) und eine aktivierte Firewall läuft. Anweisungen zur Einrichtung finden Sie in unserer Anleitung zur Serverinstallation. Wählen Sie dazu Ihre Ubuntu-Distribution aus dieser Liste aus.
  • Docker ist auf Ihrem Server installiert.
  • Node.js und npm sind installiert.
  • Ein Docker Hub-Konto.

Schritt 1 – Installieren Sie Ihre Anwendungsabhängigkeiten

Um Ihr Image zu erstellen, müssen Sie zunächst Ihre Anwendungsdateien kompilieren und diese anschließend in Ihren Container kopieren. Diese Dateien enthalten den statischen Inhalt, den Code und die Abhängigkeiten Ihrer Anwendung.

Erstellen Sie zunächst ein Verzeichnis für Ihr Projekt im Home-Verzeichnis Ihres Benutzers (nicht Root). Wir nennen unser Projekt node_project, Sie können den Namen aber gerne ändern:

mkdir node_project

Wechseln Sie in dieses Verzeichnis:

cd node_project

Dies wird das Hauptverzeichnis des Projekts sein.

Erstellen Sie als Nächstes eine package.json-Datei mit den Abhängigkeiten Ihres Projekts und weiteren identifizierenden Informationen. Öffnen Sie die Datei mit nano oder Ihrem bevorzugten Editor:

nano package.json

Fügen Sie die folgenden Informationen zum Projekt hinzu, einschließlich Name, Autor, Lizenz, Einstiegspunkt und Abhängigkeiten. Ersetzen Sie unbedingt die Autoreninformationen durch Ihren Namen und Ihre Kontaktdaten:

{
"name": "nodejs-image-demo",
"version": "1.0.0",
"description": "nodejs image demo",
"author": "Sammy the Shark <[email protected]>",
"license": "MIT",
"main": "app.js",
"keywords": [
"nodejs",
"bootstrap",
"express"
],
"dependencies": {
"express": "^4.16.4"
}
}

Diese Datei enthält den Projektnamen, den Autor und die Lizenz, unter der das Projekt vertrieben wird. Npm empfiehlt, den Projektnamen kurz und aussagekräftig zu halten und Duplikate im NPM-Repository zu vermeiden. Im Abschnitt „Lizenz“ ist die MIT-Lizenz aufgeführt, die die freie Nutzung und Verbreitung des Programmcodes erlaubt. Darüber hinaus enthält die Datei folgende Angaben:

  • “main”: Der Einstiegspunkt der Anwendung, app.js. Diese Datei wird später erstellt.
  • “Abhängigkeiten”: Projektabhängigkeiten – in diesem Fall Express 4.16.4 oder höher.

Obwohl diese Datei kein Repository auflistet, können Sie eines hinzufügen, indem Sie diese Anweisungen zum Hinzufügen eines Repositorys zu Ihrer package.json-Datei befolgen. Dies ist besonders hilfreich, wenn Sie Ihre Anwendung bearbeiten. Speichern und schließen Sie die Datei, sobald Sie alle Änderungen vorgenommen haben.

Um die Abhängigkeiten Ihres Projekts zu installieren, führen Sie folgenden Befehl aus:

npm install

Dadurch werden die in Ihrer package.json-Datei aufgeführten Pakete in Ihr Projektverzeichnis installiert. Jetzt können wir die Anwendungsdateien erstellen.

Schritt 2 – Erstellen der Programmdateien

Wir erstellen eine Website mit Informationen über Haie. Unsere Anwendung besteht aus einer Hauptdatei (app.js) und einem Verzeichnis namens „views“, das die festen Projektdateien enthält. Die Startseite (index.html) bietet grundlegende Informationen und einen Link zu einer Seite mit detaillierteren Haiinformationen (sharks.html). Im Verzeichnis „views“ erstellen wir sowohl die Startseite als auch die Seite „sharks.html“.

Öffnen Sie zunächst die Datei app.js im Hauptprojektverzeichnis, um die Projektpfade zu definieren:

nano app.js

Der erste Teil der Datei erstellt die Express- und Router-Anwendungsobjekte und definiert das Basisverzeichnis und den Port als Konstanten:

const express = require('express');
const app = express();
const router = express.Router();

const path = __dirname + '/views/';
const port = 8080;

Die `require`-Funktion lädt das Express-Modul, mit dem wir anschließend die Anwendungs- und Router-Objekte erstellen. Das Router-Objekt übernimmt das Routing der Anwendung. Sobald wir HTTP-Methodenrouten definieren, fügen wir diese diesem Objekt hinzu, um festzulegen, wie unsere Anwendung Anfragen verarbeitet.

Dieser Abschnitt der Datei enthält außerdem mehrere Konstanten. Weg Und Hafen Sets:

  • Pfad: Definiert das Basisverzeichnis, das sich im aktuellen Projektverzeichnis unter dem Verzeichnis „views“ befinden wird.
  • Port: Weist das Programm an, Port 8080 abzuhören und sich mit diesem zu verbinden.

Als Nächstes werden die Anwendungsrouten mithilfe des Router-Objekts festgelegt:

...
router.use(function (req,res,next) {
console.log('/' + req.method);
next();
});
router.get('/', function(req,res){
res.sendFile(path + 'index.html');
});
router.get('/sharks', function(req,res){
res.sendFile(path + 'sharks.html');
});

Die Funktion `router.use` lädt eine Middleware-Funktion, die Router-Anfragen protokolliert und an die Anwendungsrouten weiterleitet. Diese sind in den folgenden Funktionen definiert, die festlegen, dass eine GET-Anfrage an die Basis-Projekt-URL die Seite `index.html` zurückgeben soll, während eine GET-Anfrage an die Route `/sharks` die Seite `sharks.html` zurückgeben soll.

Zum Schluss binden Sie die Router-Middleware und die statischen Assets der Anwendung ein und weisen die Anwendung an, auf Port 8080 zu lauschen:

...
app.use(express.static(path));
app.use('/', router);
app.listen(port, function () {
console.log('Example app listening on port 8080!')
})

Die fertige app.js-Datei sieht folgendermaßen aus:

const express = require('express');
const app = express();
const router = express.Router();
const path = __dirname + '/views/';
const port = 8080;
router.use(function (req,res,next) {
console.log('/' + req.method);
next();
});
router.get('/', function(req,res){
res.sendFile(path + 'index.html');
});
router.get('/sharks', function(req,res){
res.sendFile(path + 'sharks.html');
});
app.use(express.static(path));
app.use('/', router);
app.listen(port, function () {
console.log('Example app listening on port 8080!')
})

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Als Nächstes fügen wir der Anwendung statische Inhalte hinzu. Beginnen wir mit dem Erstellen des Verzeichnisses „views“:

mkdir views

Öffnen Sie die Landingpage-Datei index.html:

nano views/index.html

Fügen Sie den folgenden Code in die Datei ein, der Bootstrap importiert und eine Jumbotron-Komponente mit einem Link zur Detailinformationsseite sharks.html erstellt:

<!DOCTYPE html>
<html lang="en">
<head>
<title>About Sharks</title>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
<link href="css/styles.css" rel="stylesheet">
<link href="https://fonts.googleapis.com/css?family=Merriweather:400,700" rel="stylesheet" type="text/css">
</head>
<body>
<nav class="navbar navbar-dark bg-dark navbar-static-top navbar-expand-md">
<div class="container">
<button type="button" class="navbar-toggler collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false"> <span class="sr-only">Toggle navigation</span>
</button> <a class="navbar-brand" href="#">Everything Sharks</a>
<div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
<ul class="nav navbar-nav mr-auto">
<li class="active nav-item"><a href="/" class="nav-link">Home</a>
</li>
<li class="nav-item"><a href="/sharks" class="nav-link">Sharks</a>
</li>
</ul>
</div>
</div>
</nav>
<div class="jumbotron">
<div class="container">
<h1>Want to Learn About Sharks?</h1>
<p>Are you ready to learn about sharks?</p>
<br>
<p><a class="btn btn-primary btn-lg" href="/sharks" role="button">Get Shark Info</a>
</p>
</div>
</div>
<div class="container">
<div class="row">
<div class="col-lg-6">
<h3>Not all sharks are alike</h3>
<p>Though some are dangerous, sharks generally do not attack humans. Out of the 500 species known to researchers, only 30 have been known to attack humans.
</p>
</div>
<div class="col-lg-6">
<h3>Sharks are ancient</h3>
<p>There is evidence to suggest that sharks lived up to 400 million years ago.
</p>
</div>
</div>
</div>
</body>
</html>

Die Navigationsleiste auf oberster Ebene ermöglicht es Nutzern, zwischen der Startseite und der Seite „Sharks“ zu wechseln. Innerhalb der Komponente „navbar-nav“ verwenden wir die Bootstrap-Klasse „active“, um dem Nutzer die aktuelle Seite anzuzeigen. Wir haben außerdem Routen für unsere statischen Seiten definiert, die den in app.js definierten Routen entsprechen.

...
<div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
<ul class="nav navbar-nav mr-auto">
<li class="active nav-item"><a href="/" class="nav-link">Home</a>
</li>
<li class="nav-item"><a href="/sharks" class="nav-link">Sharks</a>
</li>
</ul>
</div>
...

Zusätzlich haben wir auf dem Jumbotron-Button einen Link zu unserer Hai-Informationsseite eingefügt:

...
<div class="jumbotron">
<div class="container">
<h1>Want to Learn About Sharks?</h1>
<p>Are you ready to learn about sharks?</p>
<br>
<p><a class="btn btn-primary btn-lg" href="/sharks" role="button">Get Shark Info</a>
</p>
</div>
</div>
...

Im Header befindet sich außerdem ein Link zu einem benutzerdefinierten Stylesheet:

...
<link href="css/styles.css" rel="stylesheet">
...

Am Ende dieses Schritts erstellen wir dieses Stylesheet. Speichern und schließen Sie die Datei anschließend. Durch das Einfügen der App-Startseite können wir unsere Hai-Informationsseite namens sharks.html erstellen, die interessierten Nutzern weitere Informationen über Haie bietet.

Öffnen Sie die Datei:

nano views/sharks.html

Fügen Sie den folgenden Code hinzu, der Bootstrap und ein benutzerdefiniertes Stylesheet importiert und Benutzern detaillierte Informationen über bestimmte Haie bereitstellt:

<!DOCTYPE html>
<html lang="en">
<head>
<title>About Sharks</title>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
<link href="css/styles.css" rel="stylesheet">
<link href="https://fonts.googleapis.com/css?family=Merriweather:400,700" rel="stylesheet" type="text/css">
</head>
<nav class="navbar navbar-dark bg-dark navbar-static-top navbar-expand-md">
<div class="container">
<button type="button" class="navbar-toggler collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false"> <span class="sr-only">Toggle navigation</span>
</button> <a class="navbar-brand" href="/">Everything Sharks</a>
<div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
<ul class="nav navbar-nav mr-auto">
<li class="nav-item"><a href="/" class="nav-link">Home</a>
</li>
<li class="active nav-item"><a href="/sharks" class="nav-link">Sharks</a>
</li>
</ul>
</div>
</div>
</nav>
<div class="jumbotron text-center">
<h1>Shark Info</h1>
</div>
<div class="container">
<div class="row">
<div class="col-lg-6">
<p>
<div class="caption">Some sharks are known to be dangerous to humans, though many more are not. The sawshark, for example, is not considered a threat to humans.
</div>
<img src="https://assets.digitalocean.com/articles/docker_node_image/sawshark.jpg" alt="Sawshark">
</p>
</div>
<div class="col-lg-6">
<p>
<div class="caption">Other sharks are known to be friendly and welcoming!</div>
<img src="https://assets.digitalocean.com/articles/docker_node_image/sammy.png" alt="Sammy the Shark">
</p>
</div>
</div>
</div>
</html>

Beachten Sie, dass wir in dieser Datei erneut die Klasse „active“ verwenden, um die aktuelle Seite anzuzeigen. Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Erstellen Sie abschließend das benutzerdefinierte CSS-Stylesheet, auf das Sie in index.html und sharks.html verlinkt haben, indem Sie zuerst einen Ordner „css“ im Verzeichnis „views“ erstellen:

mkdir views/css

Öffnen Sie das Stylesheet:

nano views/css/styles.css

Fügen Sie folgenden Code hinzu, der die gewünschte Farbe und Schriftart für unsere Seiten festlegt:

.navbar {
margin-bottom: 0;
}
body {
background: #020A1B;
color: #ffffff;
font-family: 'Merriweather', sans-serif;
}
h1,
h2 {
font-weight: bold;
}
p {
font-size: 16px;
color: #ffffff;
}
.jumbotron {
background: #0048CD;
color: white;
text-align: center;
}
.jumbotron p {
color: white;
font-size: 26px;
}
.btn-primary {
color: #fff;
text-color: #000000;
border-color: white;
margin-bottom: 5px;
}
img,
video,
audio {
margin-top: 20px;
max-width: 80%;
}
div.caption: {
float: left;
clear: both;
}

Neben der Festlegung von Schriftart und Farbe begrenzt diese Datei auch die Bildgröße durch eine maximale Breite von 80 %. Dadurch wird sichergestellt, dass die Bilder nicht mehr Platz auf der Seite einnehmen als gewünscht. Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Nachdem die Programmdateien und die Projektabhängigkeiten installiert sind, können Sie das Programm starten.

Wenn Sie die Anleitung zur Ersteinrichtung des Servers unter „Voraussetzungen“ befolgt haben, verfügen Sie über eine aktive Firewall, die nur SSH-Verkehr zulässt. Um den Datenverkehr zu Port 8080 zu ermöglichen:

sudo ufw allow 8080

Um das Programm zu starten, stellen Sie sicher, dass Sie sich im Stammverzeichnis Ihres Projekts befinden:

cd ~/node_project

Starten Sie die Anwendung mit node app.js:

node app.js

Öffnen Sie in Ihrem Browser http://your_server_ip:8080. Die folgende Landingpage wird geladen:


Klicken Sie auf die Schaltfläche „Hai-Informationen abrufen“. Die folgende Informationsseite wird geladen:


Ihre Anwendung ist nun betriebsbereit. Wenn Sie fertig sind, beenden Sie den Server mit Strg+C. Jetzt können wir ein Dockerfile erstellen, mit dem wir die Anwendung nach Bedarf neu erstellen und skalieren können.

Schritt 3 – Schreiben der Dockerfile

Ihre Dockerfile legt fest, was beim Ausführen Ihres Anwendungscontainers enthalten sein soll. Mithilfe einer Dockerfile können Sie Ihre Containerumgebung definieren und Konflikte mit Abhängigkeiten oder Laufzeitversionen vermeiden.

Durch die Einhaltung dieser Richtlinien für die Erstellung optimaler Container gestalten wir unser Image so effizient wie möglich, indem wir die Anzahl der Image-Ebenen minimieren und die Funktionalität des Images auf einen einzigen Zweck beschränken – die Neuerstellung von Anwendungsdateien und statischen Inhalten.

Erstellen Sie im Stammverzeichnis Ihres Projekts eine Dockerfile:

nano Dockerfile

Docker-Images werden aus aufeinander aufbauenden, geschichteten Images erstellt. Im ersten Schritt fügen wir das Basis-Image für unsere Anwendung hinzu, welches den Ausgangspunkt für deren Erstellung bildet.

Wir verwenden das Image node:10-alpine, da es zum Zeitpunkt der Erstellung dieses Dokuments die empfohlene LTS-Version von Node.js ist. Das Alpine-Image stammt aus dem Alpine-Linux-Projekt und hilft uns, die Image-Größe gering zu halten. Weitere Informationen darüber, ob das Alpine-Image für Ihr Projekt geeignet ist, finden Sie in der ausführlichen Beschreibung im Abschnitt „Image-Varianten“ auf der Docker-Hub-Seite für Node-Images.

Fügen Sie die folgende FROM-Direktive hinzu, um das Basis-Image der Anwendung festzulegen:

FROM node:10-alpine

Dieses Image enthält Node.js und npm. Jede Dockerfile muss mit einer FROM-Anweisung beginnen.

Standardmäßig enthält das Docker-Node-Image einen Node-Benutzer ohne Root-Rechte. Mit diesem Benutzer können Sie verhindern, dass Ihr Anwendungscontainer als Root ausgeführt wird. Es empfiehlt sich, die Ausführung von Containern als Root zu vermeiden und die Berechtigungen im Container auf die für die Ausführung seiner Prozesse erforderlichen zu beschränken. Daher verwenden wir das Home-Verzeichnis des Node-Benutzers als Arbeitsverzeichnis für unsere Anwendung und richten ihn als Benutzer im Container ein. Weitere Informationen zu Best Practices für die Arbeit mit dem Docker-Node-Image finden Sie in diesem Leitfaden.

Um die Berechtigungen unseres Anwendungscodes im Container präzise anzupassen, erstellen wir im Verzeichnis `/home/node` neben dem Anwendungsverzeichnis ein Unterverzeichnis `node_modules`. Durch das Erstellen dieser Verzeichnisse wird sichergestellt, dass sie die gewünschten Berechtigungen besitzen. Dies ist wichtig, wenn wir lokale Node-Module im Container mit `npm install` erstellen. Zusätzlich zum Erstellen dieser Verzeichnisse weisen wir ihnen den Besitzer unseres Node-Benutzers zu.

...
RUN mkdir -p /home/node/app/node_modules && chown -R node:node /home/node/app

Weitere Informationen zur Verwendung von integrierten RUN-Anweisungen finden Sie in dieser Diskussion über die Verwaltung von Containerebenen.

Als Nächstes legen Sie das Arbeitsverzeichnis der Anwendung auf /home/node/app fest:

...
WORKDIR /home/node/app

Wenn WORKDIR nicht festgelegt ist, erstellt Docker standardmäßig eines. Daher ist es ratsam, es explizit festzulegen.

Kopieren Sie anschließend die Dateien package.json und package-lock.json (für npm 5+):

...
COPY package*.json ./

Durch Hinzufügen dieser COPY-Anweisung vor dem Ausführen von `npm install` oder dem Kopieren des Anwendungscodes können wir den Caching-Mechanismus von Docker nutzen. In jeder Phase des Build-Prozesses prüft Docker, ob eine Ebene für diese Anweisung zwischengespeichert wurde. Wenn wir die `package.json` ändern, wird diese Ebene neu erstellt. Andernfalls ermöglicht diese Anweisung Docker, die bestehende Image-Ebene zu verwenden und die Neuinstallation unserer Node-Module zu überspringen.

Um sicherzustellen, dass alle Anwendungsdateien dem Nicht-Root-Benutzer von Node gehören, einschließlich des Inhalts des Verzeichnisses node_modules, ändern Sie den Benutzer zu node, bevor Sie npm install ausführen:

...
USER node

Nachdem wir die Projektabhängigkeiten kopiert und den Benutzer gewechselt haben, können wir npm install ausführen:

...
RUN npm install

Kopieren Sie anschließend Ihren Anwendungscode mit den entsprechenden Berechtigungen in das Anwendungsverzeichnis des Containers:

...
COPY --chown=node:node . .

Dadurch wird sichergestellt, dass die Anwendungsdateien dem Benutzer gehören, der kein Root-Benutzer ist.

Zum Schluss legen Sie Port 8080 im Container fest und starten die Anwendung:

...
EXPOSE 8080
CMD [ "node", "app.js" ]

EXPOSE legt den Port nicht offen, sondern dient dazu, die dem Container zur Laufzeit zur Verfügung stehenden Ports zu dokumentieren. CMD führt den Befehl zum Starten der Anwendung aus – in diesem Fall `node app.js`. Beachten Sie, dass pro Dockerfile nur ein CMD-Befehl vorhanden sein sollte. Falls Sie mehrere angeben, wird nur der letzte ausgeführt.

Mit einer Dockerfile lassen sich viele Dinge anstellen. Eine vollständige Liste mit Anweisungen finden Sie in der Dockerfile-Referenzdokumentation von Docker.

Das vollständige Dockerfile sieht folgendermaßen aus:

FROM node:10-alpine
RUN mkdir -p /home/node/app/node_modules && chown -R node:node /home/node/app
WORKDIR /home/node/app
COPY package*.json ./
USER node
RUN npm install
COPY --chown=node:node . .
EXPOSE 8080
CMD [ "node", "app.js" ]

Speichern und schließen Sie die Datei, wenn Sie mit der Bearbeitung fertig sind.

Bevor wir das Anwendungsimage erstellen, fügen wir eine .dockerignore-Datei hinzu. Ähnlich wie eine .gitignore-Datei legt .dockerignore fest, welche Dateien und Verzeichnisse in Ihrem Projektverzeichnis nicht in Ihren Container kopiert werden sollen.

Öffnen Sie die Datei .dockerignore:

nano .dockerignore

Fügen Sie in der Datei die lokalen Node-Module, npm-Logs, die Dockerfile und die .dockerignore-Datei hinzu:

node_modules
npm-debug.log
Dockerfile
.dockerignore

Wenn Sie mit Git arbeiten, sollten Sie auch Ihr .git-Verzeichnis und Ihre .gitignore-Datei hinzufügen.

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Sie können nun Ihr Anwendungs-Image mit dem Befehl `docker build` erstellen. Mit dem Parameter `-t` können Sie dem Image einen aussagekräftigen Namen geben. Da wir das Image auf Docker Hub hochladen werden, fügen wir unseren Docker-Hub-Benutzernamen in den Tag ein. Wir taggen das Image als `nodejs-image-demo`, Sie können aber gerne einen Namen Ihrer Wahl verwenden. Ersetzen Sie außerdem `your_dockerhub_username` durch Ihren Docker-Hub-Benutzernamen.

sudo docker build -t your_dockerhub_username/nodejs-image-demo .

. Gibt an, dass der Kontext für den Build das aktuelle Verzeichnis ist.

Die Erstellung des Bildes dauert ein bis zwei Minuten. Überprüfen Sie anschließend Ihre Bilder:

sudo docker images

Sie erhalten folgende Ausgabe:

Output
REPOSITORY TAG IMAGE ID CREATED SIZE
your_dockerhub_username/nodejs-image-demo latest 1c723fb2ef12 8 seconds ago 73MB
node 10-alpine f09e7c96b6de 3 weeks ago 70.7MB

Jetzt können wir mit `docker run` einen Container mit diesem Image erstellen. Wir fügen diesem Befehl drei Befehle hinzu:

  • -p: Dadurch wird der Port im Container veröffentlicht und einem Port auf dem Host zugeordnet. Wir verwenden Port 80 auf dem Host. Falls dieser Port bereits von einem anderen Prozess belegt ist, sollten Sie ihn gegebenenfalls ändern. Weitere Informationen dazu finden Sie in der Docker-Dokumentation unter dem Stichwort „Portbindung“.
  • -d: Führt diesen Container im Hintergrund aus.
  • --name: Damit können wir dem Container einen einprägsamen Namen geben.

Um den Container zu erstellen, führen Sie folgenden Befehl aus:

sudo docker run --name nodejs-image-demo -p 80:8080 -d your_dockerhub_username/nodejs-image-demo

Sobald Ihr Container läuft, können Sie mit docker ps eine Liste Ihrer laufenden Container abrufen:

sudo docker ps

Sie erhalten folgende Ausgabe:

Output
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
e50ad27074a7 your_dockerhub_username/nodejs-image-demo "node app.js" 8 seconds ago Up 7 seconds 0.0.0.0:80->8080/tcp nodejs-image-demo

Während Ihr Container läuft, können Sie Ihre Anwendung nun aufrufen, indem Sie in Ihrem Browser die Server-IP-Adresse ohne Portangabe eingeben:

http://your_server_ip

Die Startseite Ihrer App wird erneut geladen.


Nachdem Sie nun ein Image für Ihre Anwendung erstellt haben, können Sie es zur späteren Verwendung in Docker Hub hochladen.

Schritt 4 – Verwendung eines Repositorys zur Arbeit mit Bildern

Indem Sie Ihr Anwendungs-Image in eine Registry wie Docker Hub hochladen, stellen Sie es für die spätere Verwendung beim Erstellen und Skalieren von Containern zur Verfügung. Wir zeigen Ihnen, wie das funktioniert, indem wir Ihr Anwendungs-Image in ein Repository hochladen und es anschließend verwenden, um Ihren Container neu zu erstellen.

Der erste Schritt zum Hochladen des Images besteht darin, sich bei dem Docker Hub-Konto anzumelden, das Sie in den Voraussetzungen erstellt haben:

sudo docker login -u your_dockerhub_username

Geben Sie bei Aufforderung Ihr Docker Hub-Kontopasswort ein. Durch diese Anmeldemethode wird in Ihrem Benutzerverzeichnis eine Datei ~/.docker/config.json mit Ihren Docker Hub-Zugangsdaten erstellt.

Sie können das Anwendungsimage nun mit dem zuvor erstellten Tag, Ihr_DockerHub-Benutzername/nodejs-image-demo, auf Docker Hub hochladen:

sudo docker push your_dockerhub_username/nodejs-image-demo

Testen wir das Image-Registry-Tool, indem wir unseren aktuellen Anwendungscontainer und das Image zerstören und sie anschließend mit dem Image aus unserem Repository neu erstellen.

Zuerst listen Sie Ihre laufenden Container auf:

sudo docker ps

Sie erhalten folgende Ausgabe:

Output
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
e50ad27074a7 your_dockerhub_username/nodejs-image-demo "node app.js" 3 minutes ago Up 3 minutes 0.0.0.0:80->8080/tcp nodejs-image-demo

Beenden Sie den laufenden Anwendungscontainer mithilfe der in der Ausgabe aufgeführten CONTAINER-ID. Ersetzen Sie unbedingt die unten hervorgehobene ID durch Ihre eigene CONTAINER-ID:

sudo docker stop e50ad27074a7

Listen Sie alle Ihre Bilder mit -a auf:

docker images -a

Sie erhalten die folgende Ausgabe mit Ihrem Image-Namen, Ihr_DockerHub-Benutzername/nodejs-image-demo, zusammen mit dem Node-Image und anderen Images aus Ihrem Build:

Output
REPOSITORY TAG IMAGE ID CREATED SIZE
your_dockerhub_username/nodejs-image-demo latest 1c723fb2ef12 7 minutes ago 73MB
<none> <none> 2e3267d9ac02 4 minutes ago 72.9MB
<none> <none> 8352b41730b9 4 minutes ago 73MB
<none> <none> 5d58b92823cb 4 minutes ago 73MB
<none> <none> 3f1e35d7062a 4 minutes ago 73MB
<none> <none> 02176311e4d0 4 minutes ago 73MB
<none> <none> 8e84b33edcda 4 minutes ago 70.7MB
<none> <none> 6a5ed70f86f2 4 minutes ago 70.7MB
<none> <none> 776b2637d3c1 4 minutes ago 70.7MB
node 10-alpine f09e7c96b6de 3 weeks ago 70.7MB

Stoppen Sie den Container und entfernen Sie alle Images, einschließlich ungenutzter oder hängender Images, mit folgendem Befehl:

docker system prune -a

Wenn Sie beim Beenden aufgefordert werden, die Entfernung des Containers und der gestoppten Images zu bestätigen, geben Sie „J“ ein. Beachten Sie, dass dadurch auch Ihr Build-Cache gelöscht wird.

Sie haben nun sowohl den Container, der Ihr Anwendungsimage ausführte, als auch das Image selbst gelöscht. Weitere Informationen zum Löschen von Docker-Containern, -Images und -Volumes finden Sie unter „So löschen Sie Docker-Images, -Container und -Volumes“.

Nachdem alle Images und Container entfernt wurden, können Sie nun das Anwendungsimage von Docker Hub abrufen:

docker pull your_dockerhub_username/nodejs-image-demo

Listen Sie Ihre Bilder noch einmal auf:

docker images

Ihre Ausgabe wird ein Bild Ihrer Anwendung enthalten:

Output
REPOSITORY TAG IMAGE ID CREATED SIZE
your_dockerhub_username/nodejs-image-demo latest 1c723fb2ef12 11 minutes ago 73MB

Sie können Ihren Container nun mit dem Befehl aus Schritt 3 neu erstellen:

docker run --name nodejs-image-demo -p 80:8080 -d your_dockerhub_username/nodejs-image-demo

Liste deiner laufenden Container auf:

docker ps
Output
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
f6bc2f50dff6 your_dockerhub_username/nodejs-image-demo "node app.js" 4 seconds ago Up 3 seconds 0.0.0.0:80->8080/tcp nodejs-image-demo

Besuchen Sie http://your_server_ip erneut, um Ihre laufende Anwendung anzuzeigen.

Ergebnis

In diesem Tutorial haben Sie eine statische Webanwendung mit Express und Bootstrap sowie ein Docker-Image dafür erstellt. Mithilfe dieses Images haben Sie einen Container erstellt und diesen auf Docker Hub hochgeladen. Anschließend konnten Sie Image und Container löschen und mithilfe Ihres Docker-Hub-Repositorys neu erstellen.

In diesem Artikel:
,
Beitrag verfasst von:
Folgen
Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Vorheriger Artikel
Nächster Artikel
Das könnte Ihnen auch gefallen