Dockerisieren Sie Ihre Node.js-REST-API mit der Containerisierungstechnologie von Docker, die den Bereitstellungs- und Verwaltungsprozess vereinfacht.

Der Prozess der Bereitstellung und Ausführung von Anwendungen in verschiedenen Umgebungen kann mühsam sein, da eine Reihe von Faktoren zu berücksichtigen sind wie das Einrichten der Umgebungsvariablen bis hin zum Konfigurieren der erforderlichen Abhängigkeiten und spezifischen Versionen verschiedener Softwarepakete.

Durch die Nutzung der Containerisierungstechnologie von Docker können Sie jedoch Anwendungen mit minimalem Aufwand in verschiedenen Umgebungen mit allen erforderlichen Abhängigkeiten im Docker-Image bereitstellen. Das heißt, Sie müssen sich keine Gedanken über die Konfiguration machen. Dadurch wird das Bereitstellen und Ausführen von Anwendungen in verschiedenen Umgebungen zum Kinderspiel.

Was ist Docker?

Docker ist eine Entwicklungsplattform, die die Tools und die Umgebung bereitstellt, um Anwendungen als portable Images zu verpacken, die als eigenständige ausführbare Komponenten in Containern ausgeführt werden können.

instagram viewer

Diese Container stellen den Code der Anwendung und die erforderlichen Abhängigkeiten dar, damit die Anwendung ohne Probleme erfolgreich auf verschiedenen Laufzeitumgebungen ausgeführt werden kann.

Bevor Sie beginnen, installieren Sie Docker auf Ihrem lokalen Computer. Überprüfen Sie die plattformspezifischen Voraussetzungen und Installationsanweisungen aus der offiziellen Dokumentation.

Erstellen Sie eine Node.js-REST-API

Um loszulegen, Erstellen Sie einen Node.js-Webserver.

Sie finden den Code dieser Anwendung in seiner GitHub-Repository.

Installieren Sie als Nächstes die erforderlichen Pakete für dieses Projekt.

npm installiert morgan pg knex

Der S -Paket wird verwendet, um eine Verbindung mit einer PostgreSQL-Datenbank herzustellen. Knie, bietet andererseits eine einfache API für die Interaktion mit PostgreSQL – Sie werden es verwenden, um SQL-Abfragen zu schreiben.

Schließlich werden Sie verwenden Morgan, eine Middleware, die HTTP-Anforderungen und -Antworten auf der Konsole protokolliert, um Ihre in einem Docker-Container ausgeführte Anwendung zu debuggen und zu überwachen.

Öffnen Sie abschließend die index.js Datei, und fügen Sie den Code darunter hinzu implementiert eine einfache REST-API mit drei Strecken.

konst ausdrücken = erfordern("äußern")
konst Morgan = erfordern("morgan")
konst app = ausdrücken()
konst db = erfordern('./db')
konst PORT = process.env. HAFEN || 5000
app.use (morgan('Entwickler'))
app.use (express.json())
app.use (express.urlencoded({ erweitert: WAHR }))


app.get('/', (req, res) => res.send('Hallo Welt!' ))


app.get('/Benutzer', asynchron (req, res) => {
konst Benutzer = erwarten db.select().from('Benutzer')
 res.json (Benutzer)
})


app.post('/Benutzer', asynchron (req, res) => {
konst Benutzer = erwarten db('Benutzer').Einfügung({ Name: req.body.name }).returning('*')
 res.json (Benutzer)
})
app.listen (PORT, () => Konsole.Protokoll(`Server auf PORT:${PORT}`))

Konfigurieren Sie die Datenbankverbindung

Die REST-API interagiert mit der PostgreSQL-Instanz von Docker, Sie müssen jedoch zuerst die Datenbankverbindung in Ihrer Anwendung konfigurieren. Erstellen Sie im Stammverzeichnis Ihres Projektordners eine db.js Datei und fügen Sie den folgenden Code hinzu.

konst Knie = erfordern('knex')
Modul.exports = knex({
 Klient: 'postgres',
 Verbindung: {
 Gastgeber: 'db',
 Benutzer: 'testBenutzer',
 Passwort: 'meinpasswort123',
 Datenbank: 'testBenutzer',

 },
})

Richten Sie die Dateien „migrate.js“ und „seed.js“ ein

Diese beiden Dateien ermöglichen es, eine Tabelle in der Datenbank zu erstellen und sie über die API mit Testdaten zu füllen. Einen neuen Ordner erstellen, Skripte, im Stammverzeichnis Ihres Projekts und fügen Sie zwei Dateien hinzu: migrieren.js Und Seed.js.

Im migrieren.js Datei, fügen Sie den folgenden Code hinzu:

konst db = erfordern('../db');
(asynchron () => {
versuchen {
erwarten db.schema.dropTableIfExists('Benutzer')
erwarten db.schema.withSchema('öffentlich').Tabelle erstellen('Benutzer', (Tabelle) => {
 Tabelle.inkremente ()
 tabelle.string('Name')
 })
Konsole.Protokoll('Benutzertabelle erstellt!')
 Prozess.exit(0)
 } fangen (irren) {
Konsole.log (fehler)
 Prozess.exit(1)
 }
})()

Dieser Code erstellt eine Benutzer Tabelle mit einer automatisch inkrementierenden ID-Spalte und a Name Spalte in der Datenbank.

Als nächstes im Seed.js Datei, fügen Sie den folgenden Code hinzu:

konst db = erfordern('../db');
(asynchron () => {
versuchen {
erwarten db('Benutzer').Einfügung({ Name: 'Benutzer1 testen' })
erwarten db('Benutzer').Einfügung({ Name: 'Benutzer2 testen' })
Konsole.Protokoll('Dummy-Benutzer hinzugefügt!')
 Prozess.exit(0)
 } fangen (irren) {
Konsole.log (fehler)
 Prozess.exit(1)
 }
})()

Dieser Code implementiert eine asynchrone Funktion, die zwei Benutzer in die PostgreSQL-Datenbank einfügt.

Fügen Sie schließlich diese Befehle zu Ihrer hinzu Paket.json Datei.

"Skripte": {
"Start": "Knotenindex.js",
"Wandern": "Knotenskripte/migrate.js",
"Samen": "Knotenskripte/seed.js"
 },

Da Sie keinen Client konfiguriert haben, müssen Sie zum Testen der API die beiden Dateien als Skripte neben der ausführen npm ausführen Befehl.

Richten Sie eine Dockerdatei ein

Ein Dockerfile definiert die Anweisungen, die von der Docker-Engine benötigt werden, um ein Docker-Image zu erstellen. Erstellen Sie im Stammverzeichnis Ihres Projekts eine neue Datei und benennen Sie sie, Dockerfile. Fügen Sie dann die folgenden Anweisungen hinzu, um ein Docker-Image für die Node.js-Anwendung zu erstellen.

AUS Knoten:16.3.0-alpin3.13
ARBEITSVERZ /app
KOPIEREN Paket*.json ./
LAUFEN npm installieren
KOPIEREN. .
EXPONIEREN8000
CMD [ "Knoten", "index.js" ]

Lassen Sie es uns aufschlüsseln:

  • AUS – Diese Anweisung legt das Basis-Image für die Anwendung fest, bei dem es sich um das Node.js-Alpine-Image handelt, eine einfache Version des Node.js-Images, das in der Docker-Registrierung zu finden ist.
  • ARBEITSVERZ - setzt /app Verzeichnis als Arbeitsverzeichnis.
  • KOPIEREN Paket*.json./ - Weist Docker an, alle Dateien mit diesem Dateinamenformat aus dem aktuellen Verzeichnis in die zu kopieren /app Ordner.
  • LAUFEN - führt das Bild aus und baut es auf.
  • KOPIEREN.. - kopiert die Quelldateien in die /app Ordner.
  • EXPONIEREN - Dies weist Docker an, einen Port innerhalb des Containers für die externe Umgebung verfügbar zu machen, in diesem Fall für den Hostcomputer.
  • CMD - gibt den Befehl an, der ausgeführt werden soll, wenn der Docker-Container aus dem Image erstellt wird.

Erstellen Sie die Docker Compose-Datei

Damit die Node.js-Anwendung mit der PostgreSQL-Instanz von Docker interagieren kann, müssen die beiden Anwendungen in Docker-Containern innerhalb derselben Netzwerkumgebung ausgeführt werden.

Aus diesem Grund müssen Sie sowohl das Image der Anwendung als auch die PostgreSQL-Instanz mithilfe von definieren und erstellen Docker Compose — ein Tool, mit dem Sie mehrere Docker-Container erstellen und verwalten können.

Einfach ausgedrückt: Mit Docker Compose können Sie die Dienste, aus denen Ihre Anwendung besteht, als eine Einheit definieren, in diesem Fall die Node.js-REST-API und die PostgreSQL-Datenbank.

Erstellen Sie eine neue Datei, docker-compose.yml, im Stammverzeichnis und fügen Sie den folgenden Code hinzu:

Ausführung:'3.9'
Dienstleistungen:
Server:
bauen:.
Häfen:
-'5000:5000'
kommt drauf an:
-db
dB:
Bild:'postgres'
Häfen:
-'4321:5432'
Umfeld:
POSTGRES_PASSWORT:'meinpasswort123'
POSTGRES_USER:'testBenutzer'
Volumen:
-Daten:/var/lib/postgresql/data
Volumen:
Daten:

Dieser Code erstellt und führt zwei Docker-Container aus. Der erste Behälter, Serververwendet Docker Compose das Dockerfile, um das Image für diesen Container zu erstellen.

Es gibt auch an, dass der Servercontainer von der abhängt db Container. Bedeutung, die Server Container muss nach dem gestartet werden db Container damit zu verbinden.

Der zweite Container ist ein PostgreSQL-Datenbankcontainer. Sie müssen für diesen Container kein Dockerfile angeben, da es aus dem PostgreSQL-Image in der Image-Registrierung von Docker erstellt wird.

Erstellen Sie die Docker-Images

Verwenden Sie den Befehl Docker Compose, um die Images zu erstellen und die beiden Container zu starten.

docker-compose up -d

Sie sollten eine ähnliche Antwort sehen, nachdem der Vorgang erfolgreich abgeschlossen wurde.

Testen Sie die REST-API

Führen Sie den folgenden Befehl aus, um die im Docker-Container ausgeführte REST-API zu testen. Es sollte eine Tabelle in der PostgreSQL-Datenbank erstellen.

docker exec docker_node-server-1 npm migrieren ausführen

Sie sollten eine ähnliche Antwort sehen.

Teilen der Docker-Images

Der letzte Schritt besteht darin, das Docker-Image für Ihre Node.js-Anwendung an Docker Hub zu übertragen. Dies ähnelt dem Pushen Ihrer Projekte an GitHub.

  • Geh 'rüber zu Docker-Hub und registrieren Sie sich für ein Konto und melden Sie sich beim Benutzer-Dashboard an.
  • Klicken Sie anschließend auf Erstellen Sie ein Repository. Geben Sie den Namen Ihres Repositorys an und stellen Sie seine Sichtbarkeit auf beides ein Öffentlich oder Privatgelände und dann klicken Erstellen.
  • Um das Docker-Image Ihrer Anwendung per Push an Docker Hub zu übertragen, müssen Sie sich zunächst über das Terminal bei Ihrem Konto anmelden und dann Ihren Benutzernamen und Ihr Kennwort angeben. 
Docker-Anmeldung
  • Aktualisieren Sie als Nächstes den Namen Ihres Docker-Images so, dass er diesem Format entspricht: /. Führen Sie den folgenden Befehl aus, um diese Änderung vorzunehmen: 
 Docker-Tag /
  • Pushen Sie schließlich Ihr Docker-Image. 
 Docker-Push /< Repository-Name>

Verwendung von Docker in der Entwicklung

Dieser Leitfaden hat nur einen Bruchteil des Potenzials angesprochen, das Docker bieten kann. Sie können jetzt jedoch die Containerisierungstechnologie von Docker verwenden, um jede Anwendung und alle ihre Abhängigkeiten als zu verpacken Images, die in verschiedenen Entwicklungs- und Produktionsumgebungen wie der Cloud ohne jegliches bereitgestellt werden können Schluckauf.