TOC

Erstellen und Bereitstellen eines GraphQL-Servers mit Node.js und MongoDB unter Ubuntu 18.04

Der Autor hat das Programm Wikimedia Foundation ausgewählt, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten .

Einführung

GraphQL wurde 2015 von Facebook als Abfragesprache für APIs veröffentlicht, mit der Daten aus verschiedenen Datensammlungen einfach abgefragt und mutiert werden können. Von einem einzelnen Endpunkt aus können Sie mit einer einzelnen POST-Anforderung mehrere Datenquellen abfragen und mutieren. GraphQL behebt einige der häufig auftretenden Konstruktionsfehler in REST-API-Architekturen, z. B. Situationen, in denen der Endpunkt mehr Informationen zurückgibt, als Sie tatsächlich benötigen. Wenn Sie REST-APIs verwenden, müssen Sie möglicherweise Anforderungen an mehrere REST-Endpunkte senden, um alle erforderlichen Informationen zu erfassen - eine Situation, die als n + 1-Problem bezeichnet wird. Ein Beispiel hierfür wäre, wenn Sie die Informationen eines Benutzers anzeigen möchten, aber Daten wie persönliche Daten und Adressen von verschiedenen Endpunkten sammeln müssen.

Diese Probleme treten bei GraphQL nicht auf, da es nur einen Endpunkt hat, der Daten aus mehreren Sammlungen zurückgeben kann. Die zurückgegebenen Daten hängen von der Anfrage ab, die Sie an diesen Endpunkt senden. In dieser Abfrage definieren Sie die Struktur der Daten, die Sie empfangen möchten, einschließlich aller verschachtelten Datensammlungen. Zusätzlich zu einer Abfrage können Sie auch eine mutation verwenden, um Daten auf einem GraphQL-Server zu ändern, und ein subscription, um nach Änderungen in den Daten zu suchen. Weitere Informationen zu GraphQL und seinen Konzepten finden Sie auf der offiziellen Website unter documentation.

Da GraphQL eine Abfragesprache mit viel Flexibilität ist, lässt es sich besonders gut mit dokumentbasierten Datenbanken wie MongoDB kombinieren. Beide Technologien basieren auf hierarchischen, typisierten Schemata und sind in der JavaScript-Community beliebt. Außerdem werden die Daten von MongoDB als JSON-Objekte gespeichert, sodass auf dem GraphQL-Server kein zusätzliches Parsen erforderlich ist.

In diesem Lernprogramm erstellen und implementieren Sie einen GraphQL-Server mit Node.js, mit dem Daten aus einer MongoDB-Datenbank, die unter Ubuntu 18.04 ausgeführt wird, abgefragt und geändert werden können. Am Ende dieses Lernprogramms können Sie über einen einzelnen Endpunkt auf Daten in Ihrer Datenbank zugreifen, indem Sie Anforderungen direkt über das Terminal an den Server senden und die vorgefertigte GraphiQL-Benutzeroberfläche verwenden. Mit diesem Spielplatz können Sie den Inhalt des GraphQL-Servers erkunden, indem Sie Abfragen, Mutationen und Abonnements senden. Außerdem finden Sie visuelle Darstellungen der für diesen Server definierten Schemas.

Am Ende dieses Tutorials verwenden Sie den GraphiQL-Spielplatz, um schnell eine Verbindung mit Ihrem GraphQL-Server herzustellen:

image: https://assets.digitalocean.com/articles/cart_64864/GraphiQL_1.png [Der GraphiQL-Spielplatz in Aktion]

Voraussetzungen

Bevor Sie mit diesem Handbuch beginnen, benötigen Sie Folgendes:

Schritt 1 - Einrichten der MongoDB-Datenbank

Stellen Sie vor dem Erstellen des GraphQL-Servers sicher, dass Ihre Datenbank richtig konfiguriert, die Authentifizierung aktiviert und mit Beispieldaten gefüllt ist. Dazu müssen Sie über Ihre Eingabeaufforderung eine Verbindung zum Ubuntu 18.04-Server herstellen, auf dem die MongoDB-Datenbank ausgeführt wird. Alle Schritte in diesem Tutorial werden auf diesem Server ausgeführt.

Führen Sie nach dem Herstellen der Verbindung den folgenden Befehl aus, um zu überprüfen, ob MongoDB aktiv ist und auf Ihrem Server ausgeführt wird:

sudo systemctl status mongodb

In Ihrem Terminal wird die folgende Ausgabe angezeigt, die darauf hinweist, dass die MongoDB-Datenbank aktiv ausgeführt wird:

Output● mongodb.service - An object/document-oriented database
  Loaded: loaded (/lib/systemd/system/mongodb.service; enabled; vendor preset: enabled)
   since Sat 2019-02-23 12:23:03 UTC; 1 months 13 days ago
    Docs: man:mongod(1)
Main PID: 2388 (mongod)
   Tasks: 25 (limit: 1152)
  CGroup: /system.slice/mongodb.service
          └─2388 /usr/bin/mongod --unixSocketPrefix=/run/mongodb --config /etc/mongodb.conf

Bevor Sie die Datenbank erstellen, in der Sie die Beispieldaten speichern, müssen Sie zuerst einen * admin * -Benutzer erstellen, da reguläre Benutzer auf eine bestimmte Datenbank festgelegt sind. Sie können dies tun, indem Sie den folgenden Befehl ausführen, der die MongoDB-Shell öffnet:

mongo

Mit der MongoDB-Shell erhalten Sie direkten Zugriff auf die MongoDB-Datenbank und können Benutzer oder Datenbanken erstellen und Daten abfragen. Führen Sie in dieser Shell den folgenden Befehl aus, der einen neuen Benutzer * admin * zu MongoDB hinzufügt. Sie können die hervorgehobenen Keywords durch Ihre eigene Kombination aus Benutzername und Passwort ersetzen. Vergessen Sie jedoch nicht, sie irgendwo aufzuschreiben.

use admin
db.createUser({
   user: "",
   pwd: "",
   roles: [{ role: "root", db: "admin"}]
})

In der ersten Zeile des vorhergehenden Befehls wird die Datenbank "+ admin " ausgewählt, in der alle Administratorrollen gespeichert sind. Mit der Methode ` db.createUser () +` können Sie den eigentlichen Benutzer anlegen und dessen Benutzernamen, Passwort und Rollen definieren.

Wenn Sie diesen Befehl ausführen, wird Folgendes zurückgegeben:

OutputSuccessfully added user: {
   "user" : "",
   "roles" : [
       {
           "role" : "root",
           "db" : "admin"
       }
   ]
}

Sie können die MongoDB-Shell jetzt schließen, indem Sie "+ exit +" eingeben.

Melden Sie sich als Nächstes erneut bei der MongoDB-Shell an, diesmal jedoch mit dem neu erstellten Benutzer * admin *:

mongo -u "" -p "" --authenticationDatabase "admin"

Dieser Befehl öffnet die MongoDB-Shell als bestimmten Benutzer, wobei das Flag "+ -u " den Benutzernamen und das Flag " -p " das Kennwort dieses Benutzers angibt. Das zusätzliche Flag " - authenticationDatabase +" gibt an, dass Sie sich als * admin * anmelden möchten.

Als Nächstes wechseln Sie zu einer neuen Datenbank und erstellen mit der Methode "+ db.createUser () +" einen neuen Benutzer mit Berechtigungen zum Ändern dieser Datenbank. Ersetzen Sie die markierten Abschnitte durch Ihre eigenen Informationen, und notieren Sie sich diese Anmeldeinformationen.

Führen Sie den folgenden Befehl in der MongoDB-Shell aus:

use
db.createUser({
   user: "",
   pwd: "",
   roles: ["readWrite"]
})

Dies gibt Folgendes zurück:

OutputSuccessfully added user: { "user" : "", "roles" : ["readWrite"] }

Füllen Sie diese Datenbank nach dem Erstellen der Datenbank und des Benutzers mit Beispieldaten, die später in diesem Lernprogramm vom GraphQL-Server abgefragt werden können. Hierzu können Sie das Beispiel bios collection von der MongoDB-Website verwenden. Durch Ausführen der Befehle im folgenden Codefragment fügen Sie eine kleinere Version dieses "+ Bios " - Sammlungsdatensatzes in Ihre Datenbank ein. Sie können die hervorgehobenen Abschnitte durch Ihre eigenen Informationen ersetzen. Für die Zwecke dieses Lernprogramms geben Sie der Sammlung jedoch den Namen "+":

db..insertMany([
  {
      "_id" : 1,
      "name" : {
          "first" : "John",
          "last" : "Backus"
      },
      "birth" : ISODate("1924-12-03T05:00:00Z"),
      "death" : ISODate("2007-03-17T04:00:00Z"),
      "contribs" : [
          "Fortran",
          "ALGOL",
          "Backus-Naur Form",
          "FP"
      ],
      "awards" : [
          {
              "award" : "W.W. McDowell Award",
              "year" : 1967,
              "by" : "IEEE Computer Society"
          },
          {
              "award" : "National Medal of Science",
              "year" : 1975,
              "by" : "National Science Foundation"
          },
          {
              "award" : "Turing Award",
              "year" : 1977,
              "by" : "ACM"
          },
          {
              "award" : "Draper Prize",
              "year" : 1993,
              "by" : "National Academy of Engineering"
          }
      ]
  },
  {
      "_id" : ObjectId("51df07b094c6acd67e492f41"),
      "name" : {
          "first" : "John",
          "last" : "McCarthy"
      },
      "birth" : ISODate("1927-09-04T04:00:00Z"),
      "death" : ISODate("2011-12-24T05:00:00Z"),
      "contribs" : [
          "Lisp",
          "Artificial Intelligence",
          "ALGOL"
      ],
      "awards" : [
          {
              "award" : "Turing Award",
              "year" : 1971,
              "by" : "ACM"
          },
          {
              "award" : "Kyoto Prize",
              "year" : 1988,
              "by" : "Inamori Foundation"
          },
          {
              "award" : "National Medal of Science",
              "year" : 1990,
              "by" : "National Science Foundation"
          }
      ]
  }
]);

Dieser Codeblock ist ein Array, das aus mehreren Objekten besteht, die Informationen über erfolgreiche Wissenschaftler aus der Vergangenheit enthalten. Nachdem Sie diese Befehle ausgeführt haben, um diese Sammlung in Ihre Datenbank einzutragen, wird die folgende Meldung angezeigt, die angibt, dass die Daten hinzugefügt wurden:

Output{
   "acknowledged" : true,
   "insertedIds" : [
       1,
       ObjectId("51df07b094c6acd67e492f41")
   ]
}

Nachdem die Erfolgsmeldung angezeigt wurde, können Sie die MongoDB-Shell schließen, indem Sie "+ exit +" eingeben. Konfigurieren Sie als Nächstes die MongoDB-Installation so, dass die Autorisierung aktiviert ist, sodass nur authentifizierte Benutzer auf die Daten zugreifen können. Um die Konfiguration der MongoDB-Installation zu bearbeiten, öffnen Sie die Datei mit den Einstellungen für diese Installation:

sudo nano /etc/mongodb.conf

Kommentieren Sie die hervorgehobene Zeile im folgenden Code aus, um die Autorisierung zu aktivieren:

/etc/mongodb.conf

...
# Turn on/off security.  Off is currently the default
#noauth = true

...

Um diese Änderungen zu aktivieren, starten Sie MongoDB neu, indem Sie Folgendes ausführen:

sudo systemctl restart mongodb

Stellen Sie sicher, dass die Datenbank erneut ausgeführt wird, indem Sie den folgenden Befehl ausführen:

sudo systemctl status mongodb

Dies ergibt eine Ausgabe ähnlich der folgenden:

Output● mongodb.service - An object/document-oriented database
  Loaded: loaded (/lib/systemd/system/mongodb.service; enabled; vendor preset: enabled)
   since Sat 2019-02-23 12:23:03 UTC; 1 months 13 days ago
    Docs: man:mongod(1)
Main PID: 2388 (mongod)
   Tasks: 25 (limit: 1152)
  CGroup: /system.slice/mongodb.service
          └─2388 /usr/bin/mongod --unixSocketPrefix=/run/mongodb --config /etc/mongodb.conf

Um sicherzustellen, dass Ihr Benutzer eine Verbindung zu der soeben erstellten Datenbank herstellen kann, öffnen Sie die MongoDB-Shell als authentifizierter Benutzer mit dem folgenden Befehl:

mongo -u "" -p "" --authenticationDatabase ""

Dies verwendet die gleichen Flags wie zuvor, nur dass diesmal "+ - authenticationDatabase +" auf die Datenbank gesetzt wird, die Sie erstellt und mit den Beispieldaten gefüllt haben.

Jetzt haben Sie erfolgreich einen * admin * -Benutzer und einen anderen Benutzer hinzugefügt, der Lese- / Schreibzugriff auf die Datenbank mit den Beispieldaten hat. Für die Datenbank ist die Autorisierung aktiviert, dh Sie benötigen einen Benutzernamen und ein Kennwort, um darauf zuzugreifen. Im nächsten Schritt erstellen Sie den GraphQL-Server, der später im Lernprogramm mit dieser Datenbank verbunden wird.

Schritt 2 - GraphQL Server erstellen

Nachdem die Datenbank konfiguriert und mit Beispieldaten gefüllt wurde, ist es an der Zeit, einen GraphQL-Server zu erstellen, der diese Daten abfragen und ändern kann. Dazu verwenden Sie Express und https://graphql.org/graphql-js/express-graphql/ [+ express-graphql +], die beide auf Node.js ausführen. Express ist ein leichtes Framework zum schnellen Erstellen von Node.js HTTP-Servern, und + express-graphql + bietet Middleware, mit der sich GraphQL-Server schnell erstellen lassen.

Der erste Schritt besteht darin, sicherzustellen, dass Ihre Maschine auf dem neuesten Stand ist:

sudo apt update

Installieren Sie als Nächstes Node.js auf Ihrem Server, indem Sie die folgenden Befehle ausführen. Zusammen mit Node.js installieren Sie auch npm, einen Paketmanager für JavaScript, der auf Node.js ausgeführt wird.

sudo apt install nodejs npm

Überprüfen Sie nach Abschluss des Installationsvorgangs, ob die soeben installierte Version von Node.js "+ v8.10.0 +" oder höher ist:

node -v

Dies gibt Folgendes zurück:

Output

Führen Sie zum Initialisieren eines neuen JavaScript-Projekts die folgenden Befehle auf dem Server als "+ sudo +" - Benutzer aus und ersetzen Sie die hervorgehobenen Schlüsselwörter durch einen Namen für Ihr Projekt.

Wechseln Sie zuerst in das Stammverzeichnis Ihres Servers:

cd

Erstellen Sie dort ein neues Verzeichnis, das nach Ihrem Projekt benannt ist:

mkdir

In dieses Verzeichnis verschieben:

cd

Initialisieren Sie abschließend ein neues npm-Paket mit dem folgenden Befehl:

sudo npm init -y

Nach dem Ausführen von "+ npm init -y " erhalten Sie eine Erfolgsmeldung, dass die folgende " package.json +" - Datei erstellt wurde:

OutputWrote to /home///package.json:

{
 "name": "",
 "version": "1.0.0",
 "description": "",
 "main": "index.js",
 "scripts": {
   "test": "echo \"Error: no test specified\" && exit 1"
 },
 "keywords": [],
 "author": "",
 "license": "ISC"
}

Nachdem Sie das Projekt initialisiert haben, installieren Sie die Pakete, die Sie zum Einrichten des GraphQL-Servers benötigen:

sudo npm install --save express express-graphql graphql

Erstellen Sie eine neue Datei mit dem Namen "+ index.js +" und öffnen Sie anschließend diese Datei, indem Sie Folgendes ausführen:

sudo nano index.js

Fügen Sie als Nächstes den folgenden Codeblock in die neu erstellte Datei ein, um den GraphQL-Server einzurichten:

index.js

const express = require('express');
const graphqlHTTP = require('express-graphql');
const { buildSchema } = require('graphql');

// Construct a schema, using GraphQL schema language
const schema = buildSchema(`
 type Query {
   hello: String
 }
`);

// Provide resolver functions for your schema fields
const resolvers = {
 hello: () => 'Hello world!'
};

const app = express();
app.use('/graphql', graphqlHTTP({
 schema,
 rootValue: resolvers
}));
app.listen(4000);

console.log(`🚀 Server ready at http://localhost:4000/graphql`);

Dieser Codeblock besteht aus mehreren Teilen, die alle wichtig sind. Zunächst beschreiben Sie das Schema der Daten, die von der GraphQL-API zurückgegeben werden:

index.js

...
// Construct a schema, using GraphQL schema language
const schema = buildSchema(`
 type Query {
   hello: String
 }
`);
...

Der Typ "+ Abfrage" definiert, welche Abfragen ausgeführt werden können und in welchem ​​Format das Ergebnis zurückgegeben wird. Wie Sie sehen, ist die einzige definierte Abfrage "+ hallo ", die Daten im Format " string +" zurückgibt.

Im nächsten Abschnitt wird der resolvers festgelegt, in dem die Daten mit den abfragbaren Schemata abgeglichen werden:

index.js

...
// Provide resolver functions for your schema fields
const resolvers = {
 hello: () => 'Hello world!'
};
...

Diese Resolver sind direkt mit Schemas verknüpft und geben die Daten zurück, die diesen Schemas entsprechen.

Der letzte Teil dieses Codeblocks initialisiert den GraphQL-Server, erstellt den API-Endpunkt mit Express und beschreibt den Port, auf dem der GraphQL-Endpunkt ausgeführt wird:

index.js

...
const app = express();
app.use('/graphql', graphqlHTTP({
 schema,
 rootValue: resolvers
}));
app.listen(4000);

console.log(`🚀 Server ready at http://localhost:4000/graphql`);

Nachdem Sie diese Zeilen hinzugefügt haben, speichern Sie und beenden Sie "+ index.js".

Um den GraphQL-Server tatsächlich auszuführen, müssen Sie die Datei "+ index.js" mit "Node.js" ausführen. Dies kann manuell über die Befehlszeile erfolgen. Es ist jedoch üblich, die Datei "+ package.json +" für Sie einzurichten.

Öffnen Sie die Datei "+ package.json":

sudo nano package.json

Fügen Sie dieser Datei die folgende hervorgehobene Zeile hinzu:

package.json

{
 "name": "project_name",
 "version": "1.0.0",
 "description": "",
 "main": "index.js",
 "scripts": {
   ,
   "test": "echo \"Error: no test specified\" && exit 1"
 },
 "keywords": [],
 "author": "",
 "license": "ISC"
}

Speichern und schließen Sie die Datei.

Führen Sie den folgenden Befehl im Terminal aus, um den GraphQL-Server zu starten:

npm start

Sobald Sie dies ausführen, verschwindet die Terminal-Eingabeaufforderung und es wird eine Meldung angezeigt, die bestätigt, dass der GraphQL-Server ausgeführt wird:

Output🚀 Server ready at http://localhost:4000/graphql

Wenn Sie jetzt eine andere Terminalsitzung öffnen, können Sie testen, ob der GraphQL-Server ausgeführt wird, indem Sie den folgenden Befehl ausführen. Dies sendet eine "+ curl" "+ POST" -Anforderung mit einem JSON-Body nach dem "+ - data +" -Flag, das Ihre GraphQL-Abfrage enthält, an den lokalen Endpunkt:

curl -X POST -H "Content-Type: application/json" --data '{ "query": "{ hello }" }' http://localhost:4000/graphql

Dadurch wird die Abfrage wie im GraphQL-Schema in Ihrem Code beschrieben ausgeführt und es werden Daten in einem vorhersagbaren JSON-Format zurückgegeben, das den Daten entspricht, die in den Resolvern zurückgegeben wurden:

Output{ "data": { "hello": "Hello world!" } }

In diesem Schritt haben Sie die erste Version des GraphQL-Servers erstellt, die jetzt auf einem lokalen Endpunkt ausgeführt wird, auf den Sie auf Ihrem Server zugreifen können. Als Nächstes verbinden Sie Ihre Resolver mit der MongoDB-Datenbank.

Schritt 3 - Verbindung zur MongoDB-Datenbank herstellen

Wenn der GraphQL-Server in Ordnung ist, können Sie jetzt die Verbindung mit der MongoDB-Datenbank einrichten, die Sie zuvor konfiguriert und mit Daten gefüllt haben, und ein neues Schema erstellen, das diesen Daten entspricht.

Um vom GraphQL-Server aus eine Verbindung zu MongoDB herstellen zu können, installieren Sie das JavaScript-Paket für MongoDB von npm aus:

sudo npm install --save mongodb

Nachdem dies installiert wurde, öffne + index.js in deinem Texteditor:

sudo nano index.js

Fügen Sie als Nächstes den folgenden hervorgehobenen Code direkt nach den importierten Abhängigkeiten zu "+ index.js " hinzu und füllen Sie die hervorgehobenen Werte mit Ihren eigenen Verbindungsdetails zur lokalen MongoDB-Datenbank. Die Zeichen " username ", " password _" und "+ database_name _" wurden im ersten Schritt dieses Lernprogramms erstellt.

index.js

const express = require('express');
const graphqlHTTP = require('express-graphql');
const { buildSchema } = require('graphql');



...

Diese Zeilen fügen die Verbindung zur lokalen MongoDB-Datenbank zu einer Funktion mit dem Namen context hinzu. Diese Kontextfunktion steht jedem Resolver zur Verfügung. Deshalb verwenden Sie diese Funktion, um Datenbankverbindungen einzurichten.

Fügen Sie als Nächstes in Ihrer Datei + index.js die Kontextfunktion zur Initialisierung des GraphQL-Servers hinzu, indem Sie die folgenden hervorgehobenen Zeilen einfügen:

index.js

...
const app = express();
app.use('/graphql', graphqlHTTP({
 schema,
 rootValue: resolvers

}));
app.listen(4000);

console.log(`🚀 Server ready at http://localhost:4000/graphql`);

Jetzt können Sie diese Kontextfunktion von Ihren Resolvern aus aufrufen und damit Variablen aus der MongoDB-Datenbank lesen. Wenn Sie auf den ersten Schritt dieses Lernprogramms zurückblicken, können Sie sehen, welche Werte in der Datenbank vorhanden sind. Definieren Sie von hier aus ein neues GraphQL-Schema, das dieser Datenstruktur entspricht. Überschreiben Sie den vorherigen Wert für die Konstante "+ Schema +" mit den folgenden hervorgehobenen Zeilen:

index.js

...
// Construct a schema, using GrahQL schema language





















...

Der Typ "+ Query " hat sich geändert und gibt nun eine Sammlung des neuen Typs " Bio " zurück. Dieser neue Typ besteht aus mehreren Typen, darunter zwei weitere nicht skalare Typen: " Name " und " Awards ". Dies bedeutet, dass diese Typen keinem vordefinierten Format wie " String " oder " Float +" entsprechen. Weitere Informationen zum Definieren von GraphQL-Schemas finden Sie unter documentation für GraphQL.

Da die Auflöser die Daten aus der Datenbank an das Schema binden, müssen Sie den Code für die Auflöser aktualisieren, wenn Sie Änderungen am Schema vornehmen. Erstellen Sie einen neuen Resolver mit dem Namen "+ bios ", der der " Query" entspricht, die im Schema und dem Namen der Sammlung in der Datenbank enthalten ist. Beachten Sie, dass in diesem Fall der Name der Sammlung in + db.collection ('bios') + + bios + lautet. Dies würde sich jedoch ändern, wenn Sie Ihrer Sammlung einen anderen Namen zugewiesen hätten.

Fügen Sie die folgende hervorgehobene Zeile zu + index.js hinzu:

index.js

...
// Provide resolver functions for your schema fields
const resolvers = {

};
...

Diese Funktion verwendet die Kontextfunktion, mit der Sie Variablen aus der MongoDB-Datenbank abrufen können. Sobald Sie diese Änderungen am Code vorgenommen haben, speichern und beenden Sie "+ index.js".

Um diese Änderungen zu aktivieren, müssen Sie den GraphQL-Server neu starten. Sie können den aktuellen Prozess mit der Tastenkombination "+ STRG " + " C +" anhalten und den GraphQL-Server mit folgendem Befehl starten:

npm start

Jetzt können Sie das aktualisierte Schema verwenden und die Daten in der Datenbank abfragen. Wenn Sie sich das Schema ansehen, werden Sie feststellen, dass die "+ Query" für "+ Bios" den Typ "+ Bio " zurückgibt. Dieser Typ könnte auch den Typ " Name +" zurückgeben.

Senden Sie die folgende Anforderung an den GraphQL-Server in einem neuen Terminal-Fenster, um alle Vor- und Nachnamen für alle BIOS in der Datenbank zurückzugeben:

curl -X POST -H "Content-Type: application/json" --data '{ "query": "{ bios { name { first, last } } }" }' http://localhost:4000/graphql

Dies gibt wiederum ein JSON-Objekt zurück, das der Struktur des Schemas entspricht:

Output{"data":{"bios":[{"name":{"first":"John","last":"Backus"}},{"name":{"first":"John","last":"McCarthy"}}]}}

Sie können problemlos weitere Variablen aus dem BIOS abrufen, indem Sie die Abfrage mit einem der Typen erweitern, die im Abschnitt "+ Bio +" beschrieben sind.

Sie können eine Biografie auch abrufen, indem Sie ein "+ id " angeben. Dazu müssen Sie dem Typ " Query" einen weiteren Typ hinzufügen und die Resolver erweitern. Öffnen Sie dazu + index.js in Ihrem Texteditor:

sudo nano index.js

Fügen Sie die folgenden markierten Codezeilen hinzu:

index.js

...
// Construct a schema, using GrahQL schema language
const schema = buildSchema(`
 type Query {
   bios: [Bio]

 }

 ...

 // Provide resolver functions for your schema fields
 const resolvers = {
   bios: (args, context) => context().then(db => db.collection('bios').find().toArray())

 };
 ...

Speichern und schließen Sie die Datei.

Drücken Sie auf dem Terminal, auf dem Ihr GraphQL-Server ausgeführt wird, die Tastenkombination STRG + + + + C +, um die Ausführung zu beenden, und führen Sie die folgenden Schritte aus, um den Computer neu zu starten:

npm start

Führen Sie in einem anderen Terminalfenster die folgende GraphQL-Anforderung aus:

curl -X POST -H "Content-Type: application/json" --data '{ "query": "{ bio(id: 1) { name { first, last } } }" }' http://localhost:4000/graphql

Dies gibt den Eintrag für die Bio zurück, die eine "+ id " gleich " 1 +" hat:

Output{ "data": { "bio": { "name": { "first": "John", "last": "Backus" } } } }

Die Abfrage von Daten aus einer Datenbank ist nicht die einzige Funktion von GraphQL. Sie können auch die Daten in der Datenbank ändern. Öffnen Sie dazu + index.js:

sudo nano index.js

Neben dem Typ "+ Abfrage " können Sie auch den Typ " Mutation +" verwenden, mit dem Sie die Datenbank mutieren können. Um diesen Typ zu verwenden, fügen Sie ihn dem Schema hinzu und erstellen Sie Eingabetypen, indem Sie die folgenden hervorgehobenen Zeilen einfügen:

index.js

...
// Construct a schema, using GraphQL schema language
const schema = buildSchema(`
 type Query {
   bios: [Bio]
   bio(id: Int): Bio
 }













...

Diese Eingabetypen definieren, welche Variablen als Eingaben verwendet werden können, auf die Sie in den Resolvern zugreifen und mit denen Sie ein neues Dokument in die Datenbank einfügen können. Fügen Sie dazu die folgenden Zeilen zu + index.js hinzu:

index.js

...
// Provide resolver functions for your schema fields
const resolvers = {
 bios: (args, context) => context().then(db => db.collection('bios').find().toArray()),
 bio: (args, context) => context().then(db => db.collection('bios').findOne({ _id: args.id }))

};
...

Genau wie bei den Resolvern für reguläre Abfragen müssen Sie einen Wert aus dem Resolver in + index.js + zurückgeben. Im Fall einer "+ Mutation ", bei der der Typ " Bio +" mutiert ist, würden Sie den Wert der mutierten Bio zurückgeben.

Zu diesem Zeitpunkt enthält Ihre Datei + index.js + die folgenden Zeilen:

index.js

iconst express = require('express');
const graphqlHTTP = require('express-graphql');
const { buildSchema } = require('graphql');
const { MongoClient } = require('mongodb');

const context = () => MongoClient.connect('mongodb://:@localhost:27017/', { useNewUrlParser: true })
 .then(client => client.db('GraphQL_Test'));

// Construct a schema, using GraphQL schema language
const schema = buildSchema(`
 type Query {
   bios: [Bio]
   bio(id: Int): Bio
 }
 type Mutation {
   addBio(input: BioInput) : Bio
 }
 input BioInput {
   name: NameInput
   title: String
   birth: String
   death: String
 }
 input NameInput {
   first: String
   last: String
 }
 type Bio {
   name: Name,
   title: String,
   birth: String,
   death: String,
   awards: [Award]
 }
 type Name {
   first: String,
   last: String
 },
 type Award {
   award: String,
   year: Float,
   by: String
 }
`);

// Provide resolver functions for your schema fields
const resolvers = {
 bios: (args, context) =>context().then(db => db.collection('Sample_Data').find().toArray()),
 bio: (args, context) =>context().then(db => db.collection('Sample_Data').findOne({ _id: args.id })),
 addBio: (args, context) => context().then(db => db.collection('Sample_Data').insertOne({ name: args.input.name, title: args.input.title, death: args.input.death, birth: args.input.birth})).then(response => response.ops[0])
};

const app = express();
app.use('/graphql', graphqlHTTP({
 schema,
 rootValue: resolvers,
 context
}));
app.listen(4000);

console.log(`🚀 Server ready at http://localhost:4000/graphql`);

Speichern und beenden Sie + index.js.

Um zu überprüfen, ob Ihre neue Mutation funktioniert, starten Sie den GraphQL-Server neu, indem Sie auf dem Terminal, auf dem Ihr GraphQL-Server ausgeführt wird, die Tastenkombination STRG + + + + c + und + npm start + ausführen. Öffnen Sie anschließend eine weitere Terminalsitzung, um Folgendes auszuführen + curl + Anfrage. Genau wie bei der Anforderung von "+ curl " für Abfragen wird der Text im Flag " - data +" an den GraphQL-Server gesendet. Die markierten Teile werden der Datenbank hinzugefügt:

curl -X POST -H "Content-Type: application/json" --data '{ "query": "mutation { addBio(input: { name: { first: \"\", last: \"\" } }) { name { first, last } } }" }' http://localhost:4000/graphql

Dies gibt das folgende Ergebnis zurück, was bedeutet, dass Sie gerade eine neue Biografie in die Datenbank eingefügt haben:

Output{ "data": { "addBio": { "name": { "first": "", "last": "" } } } }

In diesem Schritt haben Sie die Verbindung mit MongoDB und dem GraphQL-Server hergestellt, sodass Sie Daten aus dieser Datenbank abrufen und ändern können, indem Sie GraphQL-Abfragen ausführen. Als Nächstes machen Sie diesen GraphQL-Server für den Remotezugriff verfügbar.

Schritt 4 - Remotezugriff zulassen

Nachdem Sie die Datenbank und den GraphQL-Server eingerichtet haben, können Sie den GraphQL-Server jetzt für den Remotezugriff konfigurieren. Dazu verwenden Sie Nginx, das Sie im vorausgesetzten Tutorial How to eingerichtet haben installiere Nginx unter Ubuntu 18.04. Diese Nginx-Konfiguration finden Sie in der Datei "+ / etc / nginx / sites-available / ", wobei " example.com +" der Servername ist, den Sie im vorausgesetzten Lernprogramm hinzugefügt haben.

Öffnen Sie diese Datei zum Bearbeiten und ersetzen Sie Ihren Domainnamen durch "++":

sudo nano /etc/nginx/sites-available/

In dieser Datei finden Sie einen Serverblock, der den Port "+ 80 " abhört, für den Sie im vorausgesetzten Lernprogramm bereits einen Wert für " Servername " festgelegt haben. Ändern Sie in diesem Serverblock den Wert für " root " in das Verzeichnis, in dem Sie den Code für den GraphQL-Server erstellt haben, und fügen Sie " index.js " als Index hinzu. Setzen Sie außerdem innerhalb des Adressblocks ein " proxy_pass +", damit Sie die IP Ihres Servers oder einen benutzerdefinierten Domänennamen verwenden können, um auf den GraphQL-Server zu verweisen:

/etc/nginx/sites-available/example.com

server {
 listen 80;
 listen [::]:80;

 ;
 ;

 server_name ;

 location / {

 }
}

Stellen Sie sicher, dass diese Konfigurationsdatei keine Nginx-Syntaxfehler enthält, indem Sie Folgendes ausführen:

sudo nginx -t

Sie erhalten folgende Ausgabe:

Outputnginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Wenn für die Konfigurationsdatei keine Fehler gefunden wurden, starten Sie Nginx neu:

sudo systemctl restart nginx

Jetzt können Sie von jeder Registerkarte einer Terminalsitzung aus auf Ihren GraphQL-Server zugreifen, indem Sie "++" ausführen und durch die IP-Adresse Ihres Servers oder Ihren benutzerdefinierten Domänennamen ersetzen:

curl -X POST -H "Content-Type: application/json" --data '{ "query": "{ bios { name { first, last } } }" }' http://

Dadurch wird dasselbe JSON-Objekt wie im vorherigen Schritt zurückgegeben, einschließlich aller zusätzlichen Daten, die Sie möglicherweise mithilfe einer Mutation hinzugefügt haben:

Output{"data":{"bios":[{"name":{"first":"John","last":"Backus"}},{"name":{"first":"John","last":"McCarthy"}},{"name":{"first":"test","last":"user"}}]}}

Nachdem Sie Ihren GraphQL-Server remote verfügbar gemacht haben, stellen Sie sicher, dass Ihr GraphQL-Server nicht herunterfährt, wenn Sie das Terminal schließen oder den Server neu starten. Auf diese Weise können Sie jederzeit über den GraphQL-Server auf Ihre MongoDB-Datenbank zugreifen.

Verwenden Sie dazu das npm-Paket https://www.npmjs.com/package/forever [+ forever +], ein CLI-Tool, mit dem sichergestellt wird, dass Ihre Befehlszeilenskripts kontinuierlich ausgeführt werden, oder starten Sie es bei einem Fehler neu.

Installiere + forever + mit npm:

sudo npm install forever -g

Sobald die Installation abgeschlossen ist, fügen Sie sie der Datei "+ package.json" hinzu:

package.json

{
 "name": "project_name",
 "version": "1.0.0",
 "description": "",
 "main": "index.js",
 "scripts": {
   "start": "node index.js",

   "test": "echo \"Error: no test specified\" && exit 1"
 },
 ...

Führen Sie den folgenden Befehl aus, um den GraphQL-Server mit aktiviertem "+ forever +" zu starten:

npm run deploy

Dadurch wird die Datei "+ index.js ", die den GraphQL-Server enthält, mit " forever +" gestartet, und es wird sichergestellt, dass sie zwischen jedem Neustart im Falle eines Fehlers mit einer Mindestverfügbarkeit von 2000 Millisekunden und 5 Millisekunden weiter ausgeführt wird. Der GraphQL-Server wird nun kontinuierlich im Hintergrund ausgeführt, sodass Sie keinen neuen Tab mehr öffnen müssen, wenn Sie eine Anfrage an den Server senden möchten.

Sie haben jetzt einen GraphQL-Server erstellt, der MongoDB zum Speichern von Daten verwendet und für den Zugriff von einem Remoteserver eingerichtet ist. Im nächsten Schritt aktivieren Sie den GraphiQL-Bereich, wodurch Sie den GraphQL-Server leichter überprüfen können.

Schritt 5 - GraphiQL Playground aktivieren

Die Möglichkeit, cURL-Anforderungen an den GraphQL-Server zu senden, ist großartig, aber es wäre schneller, eine Benutzeroberfläche zu haben, die GraphQL-Anforderungen sofort ausführen kann, insbesondere während der Entwicklung. Hierfür können Sie GraphiQL verwenden, eine Schnittstelle, die vom Paket + express-graphql + unterstützt wird.

Um GraphQL zu aktivieren, bearbeiten Sie die Datei + index.js:

sudo nano index.js

Fügen Sie die folgenden hervorgehobenen Zeilen hinzu:

index.js

const app = express();
app.use('/graphql', graphqlHTTP({
 schema,
 rootValue: resolvers,
 context

}));
app.listen(4000);

console.log(`🚀 Server ready at http://localhost:4000/graphql`);

Speichern und schließen Sie die Datei.

Damit diese Änderungen sichtbar werden, stellen Sie sicher, dass Sie "+ forever +" anhalten, indem Sie Folgendes ausführen:

forever stop index.js

Starten Sie danach "+ forever +" erneut, damit die neueste Version Ihres GraphQL-Servers ausgeführt wird:

npm run deploy

Öffnen Sie einen Browser unter der URL "+ http: // " und ersetzen Sie "+" durch Ihren Domainnamen oder Ihre Server-IP. Sie sehen den GraphiQL-Bereich, in dem Sie GraphQL-Anforderungen eingeben können.

image: https://assets.digitalocean.com/articles/cart_64864/GraphiQL_2.png [Der Einstiegsbildschirm für den GraphiQL-Spielplatz]

Auf der linken Seite dieses Spielplatzes können Sie die GraphQL-Abfragen und -Mutationen eingeben, während die Ausgabe auf der rechten Seite des Spielplatzes angezeigt wird. Um zu testen, ob dies funktioniert, geben Sie die folgende Abfrage auf der linken Seite ein:

query {
 bios {
   name {
     first
     last
   }
 }
}

Dies gibt dasselbe Ergebnis auf der rechten Seite des Spielplatzes wieder im JSON-Format aus:

image: https://assets.digitalocean.com/articles/cart_64864/GraphiQL_3.png [Der GraphiQL-Spielplatz in Aktion]

Jetzt können Sie GraphQL-Anfragen über das Terminal und den GraphiQL-Spielplatz senden.

Fazit

In diesem Lernprogramm haben Sie eine MongoDB-Datenbank eingerichtet und mithilfe von GraphQL, Node.js und Express für den Server Daten aus dieser Datenbank abgerufen und geändert. Darüber hinaus haben Sie Nginx so konfiguriert, dass Remotezugriff auf diesen Server möglich ist. Sie können nicht nur Anfragen direkt an diesen GraphQL-Server senden, sondern GraphiQL auch als visuelle GraphQL-Oberfläche im Browser verwenden.

Wenn Sie mehr über GraphQL erfahren möchten, können Sie sich unter recording meine Präsentation auf GraphQL unter NDC \ {ansehen. London} oder besuchen Sie die Website https://howtographql.com [howtographql.com] für Tutorials zu GraphQL. Informationen zur Interaktion von GraphQL mit anderen Technologien finden Sie im Tutorial unter https://www.digitalocean.com/community/tutorials/how-to-manual-set-up-a-prisma-server-on-ubuntu-18-. 04 [So richten Sie einen Prisma-Server unter Ubuntu 18.04 manuell ein] und weitere Informationen zum Erstellen von Anwendungen mit MongoDB finden Sie unter https://www.digitalocean.com/community/tutorials/how-to-build-a-blog- with-nest-js-mongodb-and-vue-js [Erstellen eines Blogs mit Nest.js, MongoDB und Vue.js].

Related