One place for hosting & domains

      Verwenden von ViewChild in Angular für den Zugriff auf eine untergeordnete Komponente, Anweisung oder ein DOM-Element


      Einführung

      Dieser Artikel stellt Ihnen den Dekorateur ViewChild von Angular vor.

      Es kann Situationen geben, in denen Sie aus einer übergeordneten Komponentenklasse auf eine Anweisung, eine untergeordnete Komponente oder ein DOM-Element zugreifen möchten. Der ViewChild -Decorator gibt das erste Element zurück, das einer bestimmten Anweisung, einer Komponente oder einem Auswahlelement für die Vorlagenreferenz entspricht.

      Verwenden von ViewChild mit Anweisungen

      ViewChild ermöglicht es, auf Anweisungen zuzugreifen.

      Nehmen wir an, wir haben eine SharkDirective.

      Im Idealfall verwenden Sie @angular/cli, um Ihre Anweisung zu generieren:

      • ng generate directive shark

      Andernfalls müssen Sie sie gegebenenfalls manuell zu app.module.ts hinzufügen:

      app.module.ts

      import { SharkDirective } from './shark.directive';
      ...
      @NgModule({
        declarations: [
          AppComponent,
          SharkDirective
        ],
        ...
      })
      

      Unsere Anweisung sucht nach Elementen mit dem Attribut appShark und gibt den Text im Element mit dem Wort Shark vor:

      shark.directive.ts

      import {
        Directive,
        ElementRef,
        Renderer2
      } from '@angular/core';
      
      @Directive(
        { selector: '[appShark]' }
      )
      export class SharkDirective {
        creature="Dolphin";
      
        constructor(elem: ElementRef, renderer: Renderer2) {
          let shark = renderer.createText('Shark ');
          renderer.appendChild(elem.nativeElement, shark);
        }
      }
      

      Als Nächstes fügen wir Shark zu Fin hinzu, indem wir es in der Komponentenvorlage verwenden:

      app.component.html

      <span appShark>Fin!</span>
      

      Bei der Anzeige der Anweung in einem Browser wird es dargestellt als:

      Output

      Shark Fin!

      Jetzt können wir auf die Instanzvariable creature von SharkDirective zugreifen und eine Instanzvariable extraCreature mit ihrem Wert festlegen:

      app.component.ts

      import {
        Component,
        ViewChild,
        AfterViewInit
      } from '@angular/core';
      import { SharkDirective } from './shark.directive';
      
      @Component({
        selector: 'app-root',
        templateUrl: './app.component.html',
        styleUrls: ['./app.component.css']
      })
      export class AppComponent implements AfterViewInit {
        extraCreature: string;
      
        @ViewChild(SharkDirective)
        set appShark(directive: SharkDirective) {
          this.extraCreature = directive.creature;
        };
      
        ngAfterViewInit() {
          console.log(this.extraCreature); // Dolphin
        }
      }
      

      Wir haben hier einen Setter verwendet, um die Variable extraCreature festzulegen. Beachten Sie, dass wir warten, bis der AfterViewInit-Lifecycle-Hook auf unsere Variable zugreift, da dann untergeordnete Komponenten und Anweisungen verfügbar werden.

      Wenn wir die Anwendung in einem Browser anzeigen, sehen wir immer noch das "Shark Fin!" („es hat funktioniert!“ ). Im Konsolenprotokoll wird es jedoch folgendermaßen angezeigt:

      Output

      Dolphin

      Die übergeordnete Komponente konnte aus der Anweisung auf den Wert zugreifen.

      Verwenden von ViewChild mit DOM-Elementen

      ViewChild ermöglicht es Ihnen, auf native DOM-Elemente zuzugreifen, die eine Vorlagenreferenzvariable haben.

      Nehmen wir an, wir haben ein <input> unserer Vorlage mit der Referenzvariable #someInput:

      app.component.html

      <input #someInput placeholder="Your favorite sea creature">
      

      Jetzt können wir mit ViewChild auf das <input> zugreifen und den Wert festlegen:

      app.component.ts

      import {
        Component,
        ViewChild,
        AfterViewInit,
        ElementRef
      } from '@angular/core';
      
      @Component({
        selector: 'app-root',
        templateUrl: './app.component.html',
        styleUrls: ['./app.component.css']
      })
      export class AppComponent implements AfterViewInit {
        @ViewChild('someInput') someInput: ElementRef;
        ngAfterViewInit() {
          this.someInput.nativeElement.value="Whale!";
        }
      }
      

      Wenn ngAfterViewInit ausgelöst wird, wird der Wert unseres <input> auf Folgendes gesetzt:

      Output

      Whale!

      Die übergeordnete Komponente konnte den Wert des untergeordneten DOM-Elements festlegen.

      Verwenden von ViewChild mit untergeordneten Komponenten

      ViewChild ermöglicht den Zugriff auf eine untergeordnete Komponente und den Aufruf von Methoden oder den Zugriff auf Instanzvariablen, die dem untergeordneten Element zur Verfügung stehen.

      Nehmen wir an, wir haben eine ChildComponent. Im Idealfall verwenden Sie @angular/cli, um Ihre Komponente zu generieren:

      • ng generate component child --flat

      Andernfalls müssen Sie child.component.css und child.component.html-Dateien erstellen und manuell zu app.module.ts hinzufügen:

      app.module.ts

      import { ChildComponent } from './child.component';
      ...
      @NgModule({
        declarations: [
          AppComponent,
          ChildComponent
        ],
        ...
      })
      

      Wir fügen die whoAml-Methode zur ChildComponent hinzu, die eine Nachricht zurückgibt:

      child.component.ts

      whoAmI() {
        return 'I am a child component!';
      }
      

      Nächstes referieren wir die Komponente in unserer App-Vorlage:

      app.component.html

      <app-child>child works!</app-child>
      

      Jetzt können wir die whoAmI-Methode aus unserer übergeordneten Komponenten-Klasse mit ViewChild wie folgt aufrufen:

      app.component.ts

      import {
        Component,
        ViewChild,
        AfterViewInit
      } from '@angular/core';
      import { ChildComponent } from './child.component';
      
      @Component({
        selector: 'app-root',
        templateUrl: './app.component.html',
        styleUrls: ['./app.component.css'],
      })
      export class AppComponent implements AfterViewInit {
        @ViewChild(ChildComponent) child: ChildComponent;
        ngAfterViewInit() {
          console.log(this.child.whoAmI()); // I am a child component!
        }
      }
      

      Bei der Betrachtung der Anwendung in einem Browser wird das Konsolenprotokoll angezeigt:

      Output

      I am a child component!

      Die übergeordnete Komponente konnte whoAmI-Methode der untergeordneten Komponente aufrufen.

      Zusammenfassung

      Sie haben gelernt, ViewChild für den Zugriff auf eine Anweisung, eine untergeordnete Komponente und ein DOM-Element aus einer übergeordneten Komponenten-Klasse zu verwenden.

      Wenn sich die Referenz dynamisch in ein neues Element ändert, aktualisiert ViewChild automatisch ihre Referenz.

      In Fällen, in denen Sie auf mehrere untergeordnete Komponenten zugreifen möchten, verwenden Sie stattdessen ViewChild.

      Wenn Sie mehr über Angular erfahren möchten, lesen Sie unsere Seite Angular für Übungen und Programmierprojekte.



      Source link

      Aktivieren des serverseitige Rendern für eine React-App


      Einführung

      Serverseitiges Rendern (SSR) ist eine beliebte Technik zum Rendern einer Client-seitigen Einzelseitenanwendung (SPA) auf dem Server und zum anschließenden Senden einer vollständig gerenderten Seite an den Client. Dadurch werden dynamische Komponenten als statisches HTML-Markup bereitgestellt.

      Dieser Ansatz kann für die Suchmaschinenoptimierung (SEO) hilfreich sein, wenn die Indizierung JavaScript nicht richtig verarbeitet. Dies kann auch in Situationen von Vorteil sein, in denen das Herunterladen eines großen JavaScript-Bundles durch ein langsames Netzwerk beeinträchtigt wird.

      In diesem Tutorial initialisieren Sie eine React-App mit Create React App und ändern das Projekt, um das serverseitige Rendern zu aktivieren.

      Am Ende dieses Tutorials haben Sie ein Arbeitsprojekt mit einer Client-seitigen React-Anwendung und einer serverseitigen Express-Anwendung.

      Hinweis: Alternativ bietet Next.js einen modernen Ansatz zum Erstellen statischer und vom Server gerenderter Anwendungen, die mit React erstellt wurden.

      Voraussetzungen

      Um diesem Tutorial zu folgen, benötigen Sie:

      Dieses Tutorial wurde mit Node v14.40 und npm v6.14.5 verifiziert.

      Schritt 1 — Erstellen der React-Anwendung und Ändern der App-Komponente

      Zuerst verwenden wir npx, um eine neue React-Anwendung mit der neuesten Version der Create React App zu starten.

      Rufen wir unsere App my-ssr-app auf:

      • npx create-react-app@3.4.1 my-ssr-app

      Dann nehmen wir cd in die neue Anweisung auf:

      cd my-ssr-app
      

      Schließlich starten wir unsere neue Client-seitige App, um die Installation zu verifizieren:

      Sie sollten eine Beispiel-React-App-Anzeige in Ihrem Browser-Fenster sehen.

      Lassen Sie uns nun eine <Home>-Komponente erstellen:

      Fügen Sie als Nächstes den folgenden Code in die Datei Home.js ein:

      src/Home.js

      import React from 'react';
      
      export default props => {
        return <h1>Hello {props.name}!</h1>;
      };
      

      Dadurch wird eine <h1>-Überschrift mit einer "Hello"-Nachricht erstellt, die an einen Namen geleitet wird.

      Als Nächstes rendern wir das <Home> in der <App>-Komponente. Öffnen Sie die Datei App.js:

      Ersetzen Sie dann die vorhandenen Codezeilen durch diese neuen Codezeilen:

      src/App.js

      import React from 'react';
      import Home from './Home';
      
      export default () => {
        return <Home name="Sammy" />;
      };
      

      Dadurch wird ein Name an die <Home>-Komponente übergeben, sodass die Nachricht, die wir erwarten, "Hello Sammy!" lautet.

      In der Datei index.js unserer App verwenden wir die ReactDOM-Hydratmethode anstelle des Renderns, um dem DOM-Renderer anzuzeigen, dass wir die App nach einem serverseitigen Rendern rehydrieren.

      Öffnen wir die Datei index.js:

      Ersetzen Sie dann den Inhalt der Datei index.js durch den folgenden Code:

      index.js

      import React from 'react';
      import ReactDOM from 'react-dom';
      import App from './App';
      
      ReactDOM.hydrate(<App />, document.getElementById('root'));
      

      Damit wird die Einrichtung der Client-Seite abgeschlossen, wir können mit der Einrichtung der Server-Seite fortfahren.

      Schritt 2 — Erstellen eines Express-Servers und Rendern der App-Komponente

      Nachdem wir nun unsere Anwendung eingerichtet haben, richten wir einen Server ein, der eine gerenderte Version übergeben wird. Wir verwenden Express für unseren Server. Fügen wir es dem Projekt hinzu, indem wir den folgenden Befehl in Ihrem Terminalfenster eingeben:

      • npm install express@4.17.1

      Oder mit yarn:

      Erstellen Sie als Nächstes ein Server-Verzeichnis neben dem Verzeichnis src der App:

      Erstellen Sie dann eine neue Datei index.js, die den Express-Servercode enthält:

      Fügen Sie die Importe hinzu, die einige Konstanten benötigen, und definieren Sie diese auch:

      server/index.js

      import path from 'path';
      import fs from 'fs';
      
      import React from 'react';
      import express from 'express';
      import ReactDOMServer from 'react-dom/server';
      
      import App from '../src/App';
      
      const PORT = process.env.PORT || 3006;
      const app = express();
      

      Fügen Sie als Nächstes den Servercode mit einer Fehlerbehandlung hinzu:

      server/index.js

      // ...
      
      app.get('/', (req, res) => {
        const app = ReactDOMServer.renderToString(<App />);
      
        const indexFile = path.resolve('./build/index.html');
        fs.readFile(indexFile, 'utf8', (err, data) => {
          if (err) {
            console.error('Something went wrong:', err);
            return res.status(500).send('Oops, better luck next time!');
          }
      
          return res.send(
            data.replace('<div id="root"></div>', `<div id="root">${app}</div>`)
          );
        });
      });
      
      app.use(express.static('./build'));
      
      app.listen(PORT, () => {
        console.log(`Server is listening on port ${PORT}`);
      });
      

      Wie Sie möglicherweise sehen, können wir unsere <App>-Komponente aus der Client-App direkt vom Server importieren.

      Hier finden drei wichtige Dinge statt:

      • Wir weisen Express an, Inhalte aus dem Verzeichnis build als statische Dateien zu verwenden.
      • Wir verwenden eine Methode von ReactDOMServer, renderToString, um unsere App zu einer statischen HTML-Zeichenfolge zu rendern.
      • Dann lesen wir die statische Datei index.html aus der integrierten Client-App, injizieren den statischen Inhalt unserer App im <div> mit einer ID von "root", und senden dies als Antwort auf die Anfrage.

      Schritt 3 — Konfigurieren von webpack, Babel und npm Scripts

      Damit unser Servercode funktioniert, müssen wir ihn mit webpack und Babel bündeln und transpilieren. Dazu fügen wir dem Projekt die Abhängigkeiten dev hinzu, indem wir den folgenden Befehl in Ihrem Terminalfenster eingeben:

      • npm install webpack@4.42.0 webpack-cli@3.3.12 webpack-node-externals@1.7.2 @babel/core@7.10.4 babel-loader@8.1.0 @babel/preset-env@7.10.4 @babel/preset-react@7.10.4 --save-dev

      Oder mit yarn:

      • yarn add webpack@4.42.0 webpack-cli@3.3.12 webpack-node-externals@1.7.2 @babel/core@7.10.4 babel-loader@8.1.0 @babel/preset-env@7.10.4 @babel/preset-react@7.10.4 --dev

      Hinweis: Eine frühere Version dieses Tutorials installierte babel-core, babel-preset-env und babel-preset-react-app. Diese Pakete wurden seitdem archiviert, und die mono-repo-Versionen werden stattdessen verwendet.

      Erstellen Sie als Nächstes eine Babel-Konfigurationsdatei:

      Fügen Sie dann die Voreinstellungen env und react-app hinzu:

      .babelrc.json

      {
        "presets": [
          "@babel/preset-env",
          "@babel/preset-react"
        ]
      }
      

      Anmerkung: Eine frühere Version dieses Tutorials verwendete eine .babelrc-Datei (keine .json-Dateierweiterung). Dies war eine Konfigurationsdatei für Babel 6, aber dies ist für Babel 7 nicht mehr der Fall.

      Jetzt erstellen wir eine webpack-Konfiguration für den Server, der Babel Loader verwendet, um den Code zu transpilieren. Beginnen Sie mit der Erstellung der Datei:

      Fügen Sie dann die folgenden Konfigurationen in die webpack.server.js-Datei ein:

      webpack.server.js

      const path = require('path');
      const nodeExternals = require('webpack-node-externals');
      
      module.exports = {
        entry: './server/index.js',
      
        target: 'node',
      
        externals: [nodeExternals()],
      
        output: {
          path: path.resolve('server-build'),
          filename: 'index.js'
        },
      
        module: {
          rules: [
            {
              test: /.js$/,
              use: 'babel-loader'
            }
          ]
        }
      };
      

      Mit dieser Konfiguration wird unser transpiliertes Serverbundle an den Ordner server-build in einer Datei namens index.js ausgegeben.

      Beachten Sie die Verwendung von target: 'node' und externals: [nodeExternals()] aus webpack-node-externals, wodurch die Dateien aus node_modules im Bundle versagt werden; der Server kann direkt auf diese Dateien zugreifen.

      Dadurch wird die Abhängigkeit von der Installation und der webpack- und Babel-Konfiguration abgeschlossen.

      Jetzt besuchen wir erneut package.json, um Helfer-npm-Scripts hinzuzufügen:

      Wir fügen der Datei package.json die Scripts dev:build-server, dev:start und dev hinzu, um unsere SSR-Anwendung leicht zu erstellen und zu bedienen:

      package.json

      "scripts": {
        "dev:build-server": "NODE_ENV=development webpack --config webpack.server.js --mode=development -w",
        "dev:start": "nodemon ./server-build/index.js",
        "dev": "npm-run-all --parallel build dev:*",
        ...
      },
      

      Wir verwenden nodemon, um den Server neu zu starten, wenn wir Änderungen daran durchführen. Und wir verwenden npm-run-all, um mehrere Befehle parallel auszuführen.

      Installieren wir diese Pakete nun durch Eingabe der folgenden Befehle in Ihrem Terminalfenster

      • npm install nodemon@2.0.4 npm-run-all@4.1.5 --save-dev

      Oder mit yarn:

      • yarn add nodemon@2.0.4 npm-run-all@4.1.5 --dev

      Damit können Sie Folgendes ausführen, um die Client-seitige App zu erstellen, den Servercode zu bündeln und zu transpilieren, und den Server unter :3006 zu starten:

      Oder mit yarn:

      Unsere Server-Webpack-Konfiguration wir auf Änderungen achten und unser Server wird bei Änderungen neu starten. Für die Client-Anwendung müssen wir sie jedoch derzeit immer noch jedes Mal erstellen, wenn wir Änderungen vornehmen. Dafür gibt es hier ein offenes Problem.

      Öffnen Sie nun http://localhost:3006/ in Ihrem Webbrowser und Sie sehen Ihre App auf der Serverseite gerendered.

      Zuvor hat der Quellcode enthüllt:

      Output

      <div id="root"></div>

      Mit den Änderungen, die Sie vorgenommen haben, enthüllt der Quellcode nun aber:

      Output

      <div id="root"><h1 data-reactroot="">Hello <!-- -->Sammy<!-- -->!</h1></div>

      Das serverseitige Rendering hat die <App>-Komponente erfolgreich in HTML konvertiert.

      Zusammenfassung

      In diesem Tutorial haben Sie eine React-Anwendung initialisiert und das serverseitige Rendering aktiviert.

      In diesem Beitrag haben wir erst einen Bruchteil des Möglichen besprochen. Die Dinge werden etwas komplizierter, wenn Routing, Datenabruf oder Redux ebenfalls Teil einer serverseitig gerenderten App sein müssen.

      Ein Hauptvorteil der Verwendung von SSR besteht darin, dass eine App für ihren Inhalt gecrawlt werden kann, selbst für Crawler, die keinen JavaScript-Code ausführen. Dies kann bei der Suchmaschinenoptimierung (SEO) und der Bereitstellung von Metadaten für Social-Media-Kanäle hilfreich sein.

      SSR kann auch häufig zur Leistungssteigerung beitragen, da bei der ersten Anforderung eine vollständig geladene App vom Server gesendet wird. Bei nicht trivialen Apps kann Ihr Kilometerstand variieren, da für SSR ein Setup erforderlich ist, das etwas kompliziert werden kann und den Server stärker belastet. Ob Sie serverseitiges Rendering für Ihre React-App verwenden, hängt von Ihren spezifischen Anforderungen ab und davon, welche Kompromisse für Ihren Anwendungsfall am sinnvollsten sind.

      Wenn Sie mehr über React erfahren möchten, sehen Sie sich unsere Reihe Codieren in React.js an oder besuchen Sie unsere React-Themenseite für Übungen und Programmierprojekte.



      Source link

      Konfigurieren des Remotezugriffs für MongoDB unter Ubuntu 20.04


      Eine frühere Version dieses Tutorials wurde von Melissa Anderson verfasst.

      Einführung

      MongoDB, auch als Mongo bekannt, ist eine Open-Source-Dokumentendatenbank, die für gewöhnlich in modernen Webanwendungen verwendet wird. Standardmäßig erlaubt sie nur Verbindungen, die von demselben Server stammen, auf dem sie installiert ist. Wenn Sie MongoDB aus der Ferne verwalten oder die Datenbank mit einem separaten Anwendungsserver verbinden möchten, müssen Sie einige Änderungen an der Standardkonfiguration vornehmen.

      In diesem Tutorial konfigurieren Sie eine MongoDB-Installation so, dass der Zugriff von einem vertrauenswürdigen Remotecomputer aus sicher möglich ist. Dazu aktualisieren Sie Ihre Firewall-Regeln, um dem Remotecomputer Zugriff auf den Port zu gewähren, auf dem MongoDB auf Verbindungen lauscht, und aktualisieren dann ihre Konfigurationsdatei, um ihre IP-Bindungseinstellung zu ändern. Als letzten Schritt testen Sie dann, dass Ihr Remotecomputer die Verbindung zu Ihrer Datenbank erfolgreich herstellen kann.

      Voraussetzungen

      Um dieses Tutorial zu absolvieren, benötigen Sie:

      • Einen Server, auf dem Ubuntu 20.04 ausgeführt wird. Dieser Server sollte über einen administrativen non-root user und eine mit UFW konfigurierte Firewall verfügen. Sie können dies einrichten, indem Sie unserem Leitfaden zur Ersteinrichtung des Servers mit Ubuntu 20.04 folgen.
      • MongoDB, das auf Ihrem Server installiert ist. Dieses Tutorial geht davon aus, dass Sie MongoDB 4.4 oder eine neuere Version installiert haben. Sie können diese Version installieren, indem Sie unserem Leitfaden zum Installieren von MongoDB unter Ubuntu 20.04 folgen.
      • Einen zweiten Computer, von dem Sie auf Ihre MongoDB-Instanz zugreifen. Aus Gründen der Einfachheit geht dieses Tutorial davon aus, dass es sich bei diesem Computer um einen weiteren Ubuntu 20.04-Server handelt, der mit einem administrativen non-root user und einer UFW-Firewall gemäß unserem Leitfaden zur Ersteinrichtung des Servers mit Ubuntu 20.04 konfiguriert ist. Schritt 1 und 2, die das eigentliche Verfahren zur Aktivierung des Remote-Zugriffs auf den Datenbankserver beschreiben, funktionieren jedoch unabhängig davon, unter welchem Betriebssystem der Remotecomputer ausgeführt wird.

      Auch wenn es zum Abschließen dieses Tutorials nicht erforderlich ist, empfehlen wir außerdem dringend, dass Sie Ihre MongoDB-Installation sichern, indem Sie ein administratives Benutzerkonto für die Datenbank erstellen und die Authentifizierung aktivieren. Folgen Sie dazu unserem Leitfaden Sichern von MongoDB unter Ubuntu 20.04.

      Schritt 1 — Anpassen der Firewall

      Unter der Annahme, dass Sie dem Leitfaden zur Ersteinrichtung des Servers aus den Voraussetzungen gefolgt sind und eine UFW-Firewall auf Ihrem Server aktiviert haben, ist Ihre MongoDB-Installation vom Internet nicht zugänglich. Wenn Sie MongoDB nur lokal mit Anwendungen verwenden möchten, die auf dem gleichen Server ausgeführt werden, ist dies die empfohlene und sichere Einstellung. Wenn Sie jedoch eine Verbindung mit Ihrem MongoDB-Server von einem entfernten Ort herstellen möchten, müssen Sie eingehende Verbindungen zu dem Port zulassen, auf dem die Datenbank lauscht, indem Sie eine neue UFW-Regel hinzufügen.

      Überprüfen Sie zunächst mit dem Befehl lsof, auf welchem Port Ihre MongoDB-Installation lauscht. Dieser Befehl gibt normalerweise eine Liste mit jeder offenen Datei in einem System aus. Wenn er jedoch mit der Option -i kombiniert wird, listet er nur netzwerkbezogene Dateien oder Datenströme auf.

      Der folgende Befehl leitet die von lsof -i erstellte Ausgabe an einen grep-Befehl weiter, der nach einer Zeichenfolge namens mongo sucht:

      • sudo lsof -i | grep mongo

      Diese Beispielausgabe zeigt, dass MongoDB den Verbindungen auf ihrem Standard-Port 27017 lauscht:

      Output

      mongod 82221 mongodb 11u IPv4 913411 0t0 TCP localhost:27017 (LISTEN)

      In den meisten Fällen sollte nur von bestimmten vertrauenswürdigen Orten auf MongoDB zugegriffen werden, wie z. B. von einem anderen Server, der eine Anwendung hostet. Um dies zu konfigurieren, besteht unter anderem die Möglichkeit, den folgenden Befehl auf Ihrem MongoDB-Server auszuführen. Dieser erlaubt den Zugriff auf den Standardport von MongoDB, lässt dabei jedoch nur die IP-Adresse des anderen vertrauenswürdigen Servers zu.

      Führen Sie den folgenden Befehl aus und ersetzen Sie hierbei trusted_server_ip mit der IP-Adresse des vertrauenswürdigen Remotecomputers, den Sie für den Zugriff auf Ihre MongoDB-Instanz nutzen möchten:

      Anmerkung: Wenn die Ausgabe des vorherigen Befehls gezeigt hat, dass Ihre Installation von MongoDB auf einem nicht standardmäßigen Port lauscht, verwenden Sie in diesem Befehl diese Portnummer anstelle von 27017.

      • sudo ufw allow from trusted_server_ip to any port 27017

      Wenn Sie in Zukunft von einem anderen Computer auf MongoDB zugreifen möchten, führen Sie diesen Befehl erneut mit der IP-Adresse des neuen Computers anstelle von trusted_server_ip aus.

      Sie können die Änderung der Firewall-Einstellungen mit ufw überprüfen:

      Die Ausgabe zeigt an, dass der Datenverkehr zum Port 27017 vom Remoteserver nun zugelassen wird:

      Output

      Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 27017 ALLOW trusted_server_ip OpenSSH (v6) ALLOW Anywhere (v6)

      Weitere erweiterte Firewall-Einstellungen zum Einschränken des Zugriffs auf Dienste finden Sie in UFW-Grundlagen: gebräuchliche Firewall-Regeln und -Befehle.

      Als Nächstes binden Sie MongoDB an die öffentliche IP-Adresse des Servers, damit Sie von Ihrem Remotecomputer darauf zugreifen können.

      Schritt 2 — Konfigurieren einer öffentlichen bindIP

      Obwohl der Port geöffnet ist, ist MongoDB derzeit an 127.0.0.1 gebunden, die lokale Loopback-Netzwerkschnittstelle. Das bedeutet, dass MongoDB nur Verbindungen akzeptieren kann, die von dem Server stammen, auf dem die Datenbank installiert ist.

      Um Remoteverbindungen zu ermöglichen, müssen Sie die Konfigurationsdatei von MongoDB — /etc/mongod.conf — bearbeiten, um MongoDB zusätzlich an die öffentlich routbare IP-Adresse Ihres Servers zu binden. Auf diese Weise kann Ihre MongoDB-Installation auf Verbindungen zu Ihrem MongoDB-Server von Remotecomputern lauschen.

      Öffnen Sie die MongoDB-Konfigurationsdatei in Ihrem bevorzugten Editor. Das folgende Beispiel verwendet nano:

      • sudo nano /etc/mongod.conf

      Finden Sie den Abschnitt network interfaces und dann den bindIp-Wert:

      /etc/mongod.conf

      . . .
      # network interfaces
      net:
        port: 27017
        bindIp: 127.0.0.1
      
      . . .
      

      Hängen Sie dieser Zeile ein Komma an, gefolgt von der öffentlichen IP-Adresse Ihres MongoDB-Servers:

      /etc/mongod.conf

      . . .
      # network interfaces
      net:
        port: 27017
        bindIp: 127.0.0.1,mongodb_server_ip
      
      . . .
      

      Speichern und schließen Sie die Datei. Wenn Sie nano verwendet haben, drücken Sie STRG+X, Y, dann die EINGABETASTE.

      Starten Sie dann MongoDB neu, um diese Änderung umzusetzen:

      • sudo systemctl restart mongod

      Danach kann Ihre MongoDB-Installation Remoteverbindungen von allen Computern akzeptieren, denen Sie Zugriff auf Port 27017 gewährt haben. Als abschließenden Schritt können Sie testen, ob der vertrauenswürdige Remoteserver, den Sie in Schritt 1 über die Firewall erlauben, die MongoDB-Instanz auf Ihrem Server erreichen kann.

      Schritt 3 — Testen der Remotekonnektivität

      Nachdem Sie Ihre MongoDB-Installation so konfiguriert haben, dass sie auf Verbindungen lauscht, die von ihrer öffentlich routbaren IP-Adresse stammen, und Ihrem Remotecomputer Zugriff über die Firewall Ihres Servers auf den Standardport von Mongo gewährt haben, können Sie testen, ob der Remotecomputer in der Lage ist, sich zu verbinden.

      Anmerkung: Wie im Abschnitt Voraussetzungen erwähnt, geht dieses Tutorial davon aus, dass Ihr Remotecomputer ein anderer Server ist, auf dem Ubuntu 20.04 ausgeführt wird. Das in den Schritten 1 und 2 beschriebene Verfahren zur Aktivierung von Remoteverbindungen sollte unabhängig davon funktionieren, welches Betriebssystem auf Ihrem Remotecomputer ausgeführt wird. Die in diesem Schritt beschriebenen Testmethoden funktionieren jedoch nicht universell bei allen Betriebssystemen.

      Eine Möglichkeit, zu testen, dass Ihr vertrauenswürdiger Remoteserver eine Verbindung mit der MongoDB-Instanz herstellen kann, besteht in der Verwendung des nc-Befehls. nc, kurz für netcat, ist ein Dienstprogramm, das zum Erstellen von Netzwerkverbindungen mit TCP oder UDP verwendet wird. Er ist für Tests in Fällen wie diesen nützlich, da Sie sowohl eine IP-Adresse als auch eine Portnummer angeben können.

      Melden Sie sich zunächst mit SSH bei Ihrem vertrauenswürdigen Server an:

      • ssh sammy@trusted_server_ip

      Führen Sie dann den folgenden nc-Befehl aus, der die Option -z enthält. Dadurch wird nc darauf beschränkt, nur nach einem lauschenden Daemon auf dem Zielserver zu suchen, ohne diesem Daten zu senden. Erinnern Sie sich aus der Installationsanleitung in den Voraussetzungen, dass MongoDB als Dienst-Daemon ausgeführt wird. Daher ist diese Option nützlich zum Testen der Konnektivität. Außerdem enthält er die Option v, der die Ausführlichkeit des Befehls erhöht und bewirkt, dass netcat eine Ausgabe ausgibt, was sonst nicht geschehen würde.

      Führen Sie den folgenden nc-Befehl von Ihrem vertrauenswürdigen Remoteserver aus und stellen Sie sicher, mongodb_server_ip durch die IP-Adresse des Servers, auf dem Sie MongoDB installiert haben, zu ersetzen:

      • nc -zv mongodb_server_ip 27017

      Wenn der vertrauenswürdige Server auf den MongoDB-Daemon zugreifen kann, wird seine Ausgabe angeben, dass die Verbindung erfolgreich war:

      Output

      Connection to mongodb_server_ip 27017 port [tcp/*] succeeded!

      Wenn Sie eine kompatible Version der mongo-Shell auf Ihrem Remoteserver installiert haben, können Sie sich nun direkt mit der auf dem Hostserver installierten MongoDB-Instanz verbinden.

      Eine Möglichkeit zur Verbindung bietet eine URI-Verbindungszeichenfolge wie diese:

      • mongo "mongodb://mongo_server_ip:27017"

      Anmerkung: Wenn Sie dem empfohlenen Leitfaden Sichern von MongoDB unter Ubuntu 20.04 gefolgt sind, haben Sie den Zugriff auf Ihre Datenbank für nicht authentifizierte Benutzer geschlossen. In diesem Fall müssen Sie eine URI verwenden, die so wie die folgende einen gültigen Benutzernamen angibt:

      • mongo "mongodb://username@mongo_server_ip:27017"

      Die Shell wird Sie automatisch dazu auffordern, das Passwort des Benutzers einzugeben.

      Damit haben Sie bestätigt, dass Ihr MongoDB-Server Verbindungen vom vertrauenswürdigen Server akzeptieren kann.

      Zusammenfassung

      Sie können nun von einem Remoteserver auf Ihre MongoDB-Installation zugreifen. Jetzt können Sie Ihre Mongo-Datenbank von dem vertrauenswürdigen Server aus der Ferne verwalten. Alternativ können Sie eine Anwendung so konfigurieren, dass sie auf dem vertrauenswürdigen Server ausgeführt wird und die Datenbank aus der Ferne verwendet.

      Wenn Sie keinen administrativen Benutzer konfiguriert und die Authentifizierung nicht aktiviert haben, kann jeder, der Zugriff auf Ihren Remoteserver hat, auch auf Ihre MongoDB-Installation zugreifen. Sollten Sie es bisher nicht getan haben, empfehlen wir Ihnen dringend, unserem Leitfaden Sichern von MongoDB unter Ubuntu 20.04 zu folgen, und für eine erhöhte Absicherung einen administrativen Benutzer hinzuzufügen.



      Source link