One place for hosting & domains

      eines

      Erstellen eines Discord-Bots mit Node.js


      Der Autor wählte den Free and Open Source Fund, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Discord ist eine Chat-Anwendung, die Millionen von Benutzern auf der ganzen Welt für Messaging und Voice Chat nutzen – in Communities, die Gilden oder Server genannt werden. Außerdem bietet Discord eine umfangreiche API, die Entwickler zum Einrichten leistungsfähiger Discord-Bots verwenden können. Bots können verschiedene Aktionen wie das Senden von Nachrichten an Server, das Ausführen von DM-Befehlen für Benutzer, das Moderieren von Servern und das Abspielen von Audio in Voice Chats erledigen. So können Entwickler leistungsstarke Bots entwickeln, die erweiterte, anspruchsvolle Merkmale wie Moderationstools oder auch Spiele umfassen. Der Utility-Bot Dyno zum Beispiel stellt Millionen von Gilden bereit und bietet nützliche Merkmale wie Spamschutz, einen Musikplayer und andere Dienstprogrammfunktionen. Wenn Sie wissen, wie man Discord-Bots erstellt, können Sie viele Möglichkeiten implementieren, mit denen Tausende von Menschen täglich interagieren können.

      In diesem Tutorial erstellen Sie von Grund auf einen Discord-Bot mit Node.js und der Discord.js-Bibliothek, sodass Benutzer direkt mit der Discord-API interagieren können. Sie werden ein Profil für einen Discord-Bot einrichten, Authentifizierungstoken für den Bot erhalten und den Bot mit der Fähigkeit zur Verarbeitung von Befehlen mit Argumenten von Benutzern programmieren.

      Voraussetzungen

      Bevor Sie beginnen, benötigen Sie Folgendes:

      Schritt 1 — Einrichten eines Discord-Bots

      In diesem Schritt verwenden Sie die Entwickler-GUI von Discord, um einen Discord-Bot einzurichten und das Token des Bots zu empfangen, das Sie an Ihr Programm übergeben werden.

      Um einen Bot in der Discord-Plattform zu registrieren, verwenden Sie das Dashboard der Discord-Anwendung. Hier können Entwickler Discord-Anwendungen einschließlich Discord-Bots erstellen.

      Abbildung des Dashboards der Discord-Anwendung nach dem ersten Besuch von https://discord.com/developers/applications

      Um zu beginnen, klicken Sie auf Neue Anwendung. Discord wird Sie bitten, einen Namen für Ihre neue Anwendung einzugeben. Klicken Sie dann auf Erstellen, um die Anwendung zu erstellen.

      Abbildung der Eingabeaufforderung für die Erstellung einer Anwendung, mit „Test Node.js Bot“ als Name der Anwendung

      Anmerkung: Der Name Ihrer Anwendung ist unabhängig vom Namen des Bots und der Bot muss nicht den gleichen Namen tragen wie die Anwendung.

      Öffnen Sie nun Ihr Anwendungs-Dashboard. Um der Anwendung einen Bot hinzuzufügen, navigieren Sie links in der Navigationsleiste zur Registerkarte Bot.

      Abbildung der Registerkarte Bot des Anwendungs-Dashboards

      Klicken Sie auf die Schaltfläche Bot hinzufügen, um der Anwendung einen Bot hinzuzufügen. Klicken Sie auf die Schaltfläche Ja, los!, wenn sie Sie zur Bestätigung aufgefordert werden. Nun befinden Sie sich in einem Dashboard, das Details wie den Namen des Bots, das Authentifizierungstoken und das Profilbild enthält.

      Dashboard mit Details Ihres Bots

      Sie können den Namen oder das Profilbild Ihres Bots hier im Dashboard ändern. Außerdem müssen Sie das Authentifizierungstoken des Bots kopieren, indem Sie auf Klicken, um Token anzuzeigen klicken und das angezeigte Token kopieren.

      Achtung: Teilen oder laden Sie Ihr Bot-Token niemals hoch, damit sich andere Personen nicht bei Ihrem Bot anmelden können.

      Jetzt müssen Sie eine Einladung erstellen, mit der Sie die Discord-Gilden des Bots hinzufügen, in denen Sie den Bot testen können. Navigieren Sie zunächst zum Tab OAuth2 des Anwendungs-Dashboards. Um eine Einladung zu erstellen, scrollen Sie nach unten und wählen Sie unter Bereiche Bot aus. Außerdem müssen Sie Berechtigungen festlegen, um zu kontrollieren, welche Aktionen Ihr Bot in Gilden ausführen darf. Wählen Sie für die Zwecke dieses Tutorials Administrator, wodurch Ihr Bot die Berechtigung erhält, fast alle Aktionen in Gilden auszuführen. Kopieren Sie den Link mit der Schaltfläche Kopieren.

      OAuth2-Registerkarte, mit dem Bereich auf „bot“ und Berechtigungen auf „administator“ gesetzt

      Als Nächstes fügen Sie den Bot einem Server hinzu. Folgen Sie dem gerade erstellten Einladungs-Link. Sie können den Bot jedem Server hinzufügen, den Sie besitzen oder für den Sie über Administratorberechtigungen verfügen (über das Dropdownmenü).

      Seite nach dem Folgen des Einladungs-Links, über die Benutzer den Bot Servern hinzufügen können

      Klicken Sie nun auf Weiter. Stellen Sie sicher, dass Sie das Kontrollkästchen neben Administrator aktiviert haben – dadurch erhält der Bot Administratorberechtigungen. Klicken Sie dann auf Autorisieren. Discord wird Sie bitten, eine CAPTCHA zu lösen, bevor der Bot dem Server beitritt. Sie werden den Discord-Bot nun auf der Mitgliederliste in dem Server sehen, dem Sie den Bot unter offline hinzugefügt haben.

      Mitgliederliste eines Discord-Servers mit dem neu erstellten Bot unter dem Abschnitt „offline“ der Mitgliederliste

      Sie haben erfolgreich einen Discord-Bot erstellt und einem Server hinzugefügt. Als Nächstes schreiben Sie ein Programm, um sich bei dem Bot anzumelden.

      Schritt 2 — Erstellen Ihres Projekts

      In diesem Schritt richten Sie die grundlegende Codierungsumgebung ein, in der Sie Ihren Bot erstellen und sich programmatisch beim Bot anmelden werden.

      Zuerst müssen Sie einen Projektordner und die erforderlichen Projektdateien für den Bot einrichten.

      Erstellen Sie Ihren Projektordner:

      Wechseln Sie in den gerade erstellten Projektordner:

      Als Nächstes verwenden Sie Ihren Texteditor, um eine Datei namens config.json zu erstellen und das Authentifizierungstoken Ihres Bots zu speichern:

      Fügen Sie dann den folgenden Code der config-Datei hinzu und ersetzen Sie den hervorgehobenen Text durch das Authentifizierungstoken Ihres Bots:

      config.json

      {
          "BOT_TOKEN": "YOUR BOT TOKEN"
      }
      

      Speichern und schließen Sie die Datei.

      Als Nächstes erstellen Sie eine package.json-Datei, in der Details Ihres Projekts und Informationen über die Abhängigkeiten gespeichert werden, die Sie für das Projekt verwenden werden. Sie erstellen eine package.json-Datei, indem Sie den folgenden npm-Befehl ausführen:

      npm wird Sie nach verschiedenen Details zu Ihrem Projekt fragen. Wenn Sie eine Anleitung für diese Eingabeaufforderungen wünschen, konsultieren Sie Verwenden von Node.js-Modulen mit npm und package.json.

      Sie installieren nun das discord.js-Paket, das Sie zur Interaktion mit der Discord-API verwenden werden. Sie können discord.js über npm mit dem folgenden Befehl installieren:

      Nachdem Sie die Konfigurationsdatei eingerichtet und die erforderliche Abhängigkeit installiert haben, können Sie nun mit der Einrichtung Ihres Bots beginnen. In einer realen Anwendung würde ein großer Bot auf viele Dateien verteilt, aber für die Zwecke dieses Tutorials wird sich der Code Ihres Bots in einer Datei befinden.

      Erstellen Sie zunächst für den Code eine Datei mit dem Namen index.js im Ordner discord-bot:

      Beginnen Sie mit dem Codieren des Bots, indem Sie die discord.js-Abhängigkeit und die Konfigurationsdatei mit dem Token des Bots vorschreiben:

      index.js

      const Discord = require("discord.js");
      const config = require("./config.json");
      

      Fügen Sie danach die folgenden zwei Codezeilen hinzu:

      index.js

      ...
      const client = new Discord.Client();
      
      client.login(config.BOT_TOKEN);
      

      Speichern und schließen Sie Ihre Datei.

      Die erste Zeile des Codes erstellt einen neuen Discord.Client und weist ihn der Konstanten client zu. Dieser Client ist ein Teil davon, wie Sie mit der Discord-API interagieren werden und wie Discord Sie bei Ereignissen wie neuen Meldungen benachrichtigen wird. Der Client ist in Wirklichkeit der Discord-Bot.

      Die zweite Zeile des Codes verwendet die login-Methode für den Client, um sich bei dem von Ihnen erstellten Discord-Bot anzumelden, wobei das Token in der Datei config.json als Passwort verwendet wird. Mit dem Token erfährt die Discord-API, an welches Programm sich der Bot richtet und dass Sie für die Nutzung des Bots authentifiziert sind.

      Führen Sie nun mit Node die Datei index.js aus:

      Der Status Ihres Bots wird sich auf dem Discord-Server, dem er hinzugefügt wurde, in „online“ ändern.

      Abbildung des Bots im Online-Zustand

      Sie haben erfolgreich eine Codierungsumgebung eingerichtet und den grundlegenden Code für die Anmeldung bei einem Discord-Bot erstellt. Im nächsten Schritt werden Sie Benutzerbefehle verwalten und Ihren Bot zur Durchführung von Aktionen veranlassen, wie z. B. zum Senden von Nachrichten.

      Schritt 3 — Verwendung Ihres ersten Benutzerbefehls

      In diesem Schritt erstellen Sie einen Bot, der Benutzerbefehle handhaben kann. Sie werden Ihren ersten Befehl (ping) implementieren, der mit "pong" und der Zeit antworten wird, die zum Antworten auf den Befehl benötigt wurde.

      Zunächst müssen Sie alle Nachrichten erkennen und empfangen, die Benutzer senden, damit Sie Befehle verarbeiten können. Mit der Methode on auf dem Discord-Client wird Ihnen Discord eine Benachrichtigung zu neuen Ereignissen senden. Die Methode on hat zwei Argumente: den Namen eines Ereignisses, auf das gewartet wird, und eine Funktion, die jedes Mal ausgeführt wird, wenn das Ereignis eintritt. Bei dieser Methode können Sie auf das Ereignis message warten – es wird jedes Mal eintreten, wenn eine Nachricht an eine Gilde gesendet wird, in der der Bot die Berechtigung zum Anzeigen von Nachrichten hat. Lassen Sie uns daher eine Funktion erstellen, die bei jeder Übermittlung einer Nachricht ausgeführt wird, um Befehle zu verarbeiten.

      Öffnen Sie zunächst Ihre Datei:

      Fügen Sie den folgenden Code zur Datei hinzu:

      index.js

      ...
      const client = new Discord.Client();
      
      
      client.on("message", function(message) { 
                                               
      });                                      
      
      client.login(config.BOT_TOKEN);
      

      Diese Funktion, die beim Ereignis message ausgeführt wird, nutzt message als Parameter. message wird den Wert einer Discord.js message-Instanz haben, die Informationen über die gesendete Nachricht und Methoden enthält, um dem Bot beim Antworten zu helfen.

      Fügen Sie nun Ihrer Befehlsverarbeitungsfunktion die folgende Codezeile hinzu:

      index.js

      ...
      client.on("message", function(message) {
        if (message.author.bot) return;
      });
      ...
      

      Diese Zeile prüft, ob der Autor der Nachricht ein Bot ist; wenn ja, wird die Verarbeitung des Befehls gestoppt. Dies ist wichtig, da Sie Nachrichten von Bots im Allgemeinen weder bearbeiten noch beantworten möchten. Bots müssen oder wollen unseren Bot in der Regel nicht verwenden, sodass ein Ignorieren ihrer Nachrichten Rechenleistung spart und unbeabsichtigte Antworten verhindert.

      Jetzt schreiben Sie einen Befehlshandler. Um das zu erreichen, ist es hilfreich, das übliche Format eines Discord-Befehls zu verstehen. In der Regel enthält die Struktur eines Discord-Befehls drei Teile in der folgenden Reihenfolge: ein Präfix, einen Befehlsnamen und (manchmal) Befehlsargumente.

      Abbildung eines typischen Discord-Befehls, der

      • Präfix: Das Präfix kann alles sein, ist aber in der Regel eine Interpunktion oder abstrakte Phrase, die normalerweise nicht am Anfang einer Nachricht stehen würde. Das bedeutet, dass bei Eingabe des Präfix am Anfang der Nachricht der Bot weiß, dass der Befehl von einem Bot verarbeitet werden soll.

      • Befehlsname: Der Name des Befehls, den der Benutzer verwenden möchte. Das bedeutet, dass der Bot mehrere Befehle mit unterschiedlicher Funktionalität unterstützen kann und Benutzer durch Angabe eines anderen Befehlsnamens zwischen ihnen wählen können.

      • Argumente: Wenn der Befehl ggf. zusätzliche Informationen vom Benutzer benötigt oder verwendet, kann der Benutzer nach dem Befehlsnamen Argumente angeben, wobei jedes Argument durch ein Leerzeichen getrennt wird.

      Anmerkung: Es gibt keine zwingende Befehlsstruktur; Bots können Befehle verarbeiten, wie sie wollen. Die hier dargestellte Struktur ist jedoch eine effiziente Struktur, die eine überwiegende Mehrheit der Bots verwendet.

      Um mit der Erstellung eines Befehlsparsers zu beginnen, der dieses Format handhabt, fügen Sie der Nachrichtenverarbeitungsfunktion folgende Codezeilen hinzu:

      index.js

      ...
      const prefix = "!";
      
      client.on("message", function(message) {
        if (message.author.bot) return;
        if (!message.content.startsWith(prefix)) return;
      });
      ...
      

      Sie fügen die erste Codezeile hinzu, um den Wert "!" der Konstanten prefix zuzuweisen, die Sie als Präfix des Bots nutzen werden.

      Die zweite Codezeile, die Sie hinzufügen, prüft, ob der Inhalt der Nachricht, die der Bot verarbeitet, mit dem von Ihnen festgelegten Präfix beginnt; wenn nicht, wird die Weiterverarbeitung der Nachricht gestoppt.

      Jetzt müssen Sie den Rest der Nachricht in einen Befehlsnamen und jegliche Argumente konvertieren, die in der Nachricht vorhanden sind. Fügen Sie die folgenden hervorgehobenen Zeilen hinzu:

      index.js

      ...
      client.on("message", function(message) {
        if (message.author.bot) return;
        if (!message.content.startsWith(prefix)) return;
      
        const commandBody = message.content.slice(prefix.length);
        const args = commandBody.split(' ');
        const command = args.shift().toLowerCase();
      });
      ...
      

      Sie verwenden hier die erste Zeile, um das Präfix aus dem Nachrichteninhalt zu entfernen und das Ergebnis der Konstanten commandBody zuzuweisen. Dies ist notwendig, da Sie das Präfix nicht in den analysierten Befehlsnamen einfügen möchten.

      Die zweite Zeile nimmt die Nachricht mit dem entfernten Präfix und wendet die split-Methode darauf an, wobei ein Leerzeichen als Trennzeichen dient. Dadurch wird eine Aufspaltung in eine Gruppe von untergeordneten Zeichenfolgen vorgenommen, wobei bei jedem Leerzeichen eine Trennung vorgenommen wird. So entsteht ein Array, das den Befehlsnamen und dann (wenn in der Nachricht enthalten) Argumente beinhaltet. Sie weisen dieses Array der Konstanten args zu.

      Die dritte Zeile entfernt das erste Element aus dem Array args (was der bereitgestellte Befehlsname sein wird), konvertiert es in Kleinbuchstaben und weist es dann der Konstanten command zu. Dadurch können Sie den Befehlsnamen isolieren und nur Argumente im Array belassen. Außerdem verwenden Sie die Methode toLowerCase, da bei Befehlen in Discord-Bots typischerweise nicht zwischen Groß-/Kleinschreibung unterschieden wird.

      Sie haben die Erstellung eines Befehlsparsers, die Implementierung eines erforderlichen Präfix und das Erhalten des Befehlsnamens und der Argumente von Nachrichten abgeschlossen. Sie werden nun den Code für die spezifischen Befehle implementieren und erstellen.

      Fügen Sie folgenden Code hinzu, um den ping-Befehl zu implementieren:

      index.js

      ...
        const args = commandBody.split(' ');
        const command = args.shift().toLowerCase();
      
        if (command === "ping") {
                                 
        }                        
      });
      ...
      

      Diese if-Anweisung prüft, ob der analysierte Befehlsname (der der Konstanten command zugewiesen ist) mit "ping" übereinstimmt. Wenn ja, heißt das, dass der Benutzer den Befehl "ping" verwenden möchte. Sie werden den Code für den spezifischen Befehl im if-Anweisungsblock verschachteln. Sie werden dieses Muster für andere Befehle, die Sie implementieren möchten, wiederholen.

      Jetzt können Sie den Code für den Befehl "ping" implementieren:

      index.js

      ...
        if (command === "ping") {
          const timeTaken = Date.now() - message.createdTimestamp;
          message.reply(`Pong! This message had a latency of ${timeTaken}ms.`);
        }
      ...
      

      Speichern und schließen Sie Ihre Datei.

      Sie fügen den Befehlsblock "ping" hinzu, der die Differenz zwischen der aktuellen Zeit (ermittelt durch Anwendung der Methode now auf das Objekt Date) und dem Zeitstempel, als die Nachricht erstellt wurde, berechnet (in Millisekunden). Dadurch wird berechnet, wie lang die Verarbeitung der Nachricht und das "ping" des Bots benötigt haben.

      Die zweite Zeile reagiert auf den Befehl des Benutzers mit der reply-Methode in der Konstanten message. Die reply-Methode pingt (wodurch der Benutzer benachrichtigt und die Nachricht für den angegebenen Benutzer hervorgehoben wird) den Benutzer an, der den Befehl aufgerufen hat, gefolgt von dem Inhalt, der als erstes Argument der Methode angegeben wurde. Sie stellen ein template literal bereit, das eine Nachricht und den errechneten Ping als Antwort enthält, die die reply-Methode verwenden wird.

      Damit ist die Implementierung des Befehls "ping" abgeschlossen.

      Führen Sie Ihren Bot mit dem folgenden Befehl aus (im selben Ordner wie index.js):

      Sie können nun den Befehl "! ping" in jedem Kanal nutzen, den der Bot anzeigen und in dem der Bot Nachrichten senden kann; dabei kommt es zu einer Antwort.

      Abbildung von Bot, der in Discord auf

      Sie haben nun erfolgreich einen Bot erstellt, der Benutzerbefehle handhaben kann, und Ihren ersten Befehl implementiert. Im nächsten Schritt werden Sie Ihren Bot weiterentwickeln, indem Sie einen sum-Befehl implementieren.

      Schritt 4 — Implementieren des sum-Befehls

      Jetzt werden Sie Ihr Programm durch Implementieren des "! sum"-Befehls erweitern. Der Befehl nimmt eine beliebige Anzahl von Argumenten an und fügt sie zusammen, bevor die Summe aller Argumente an den Benutzer zurückgegegen wird.

      Wenn Ihr Discord-Bot noch ausgeführt wird, können Sie den Prozess mit Strg+C anhalten.

      Öffnen Sie erneut Ihre index.js-Datei:

      Um mit der Implementierung des "! sum"-Befehls zu beginnen, werden Sie einen else-if-Block verwenden. Nach der Prüfung des ping-Befehlsnamens wird geprüft, ob der Befehlsname gleich "sum" ist. Wir verwenden einen else-if-Block, da nur ein Befehl auf einmal verarbeitet wird; wenn das Programm dem Befehlsnamen "ping" entspricht, muss also nicht auf den Befehl "sum" geprüft werden. Fügen Sie in Ihrer Datei die folgenden hervorgehobenen Zeilen hinzu:

      index.js

      ...
        if (command === "ping") {
          const timeTaken = Date.now() - message.createdTimestamp;
          message.reply(`Ping! This message had a latency of ${timeTaken}ms.`);
        }
      
        else if (command === "sum") {
                                     
        }                            
      });
      ...
      

      Sie können mit der Implementierung des Codes für den "sum"-Befehl beginnen. Der Code für den Befehl "sum" wird in den gerade erstellten else-if-Block eingebunden. Fügen Sie nun folgenden Code hinzu:

      index.js

      ...
        else if (command === "sum") {
          const numArgs = args.map(x => parseFloat(x));
          const sum = numArgs.reduce((counter, x) => counter += x);
          message.reply(`The sum of all the arguments you provided is ${sum}!`);
        }
      ...
      

      Sie verwenden die map-Methode in der Argumentenliste, um eine neue Liste zu erstellen, indem Sie die Funktion parseFloat auf jedes Element im Array args anwenden. Dadurch ensteht ein neues Array (das der Konstanten numArgs zugewiesen ist), in dem alle Elemente Zahlen anstelle von Zeichenfolgen sind. Das bedeutet, dass Sie durch Addieren die Summe der Zahlen ermitteln können.

      Die zweite Zeile wendet die reduce-Methode auf die Konstante numArgs an; so ist eine Funktion verfügbar, die die Summe aller Elemente in der Liste errechnet. Sie weisen die Summe aller Elemente in numArgs der Konstanten sum zu.

      Dann wenden Sie die reply-Methode auf das Nachrichtenobjekt an, um auf den Befehl des Benutzers mit einem template literal zu antworten, das die Summe aller Argumente enthält, die der Benutzer an den Bot sendet.

      Damit ist die Implementierung des Befehls "sum" abgeschlossen. Führen Sie Ihren Bot nun mit dem folgenden Befehl aus (im selben Ordner wie index.js):

      Sie können den Befehl "! sum" jetzt in jedem Kanal verwenden, den der Bot anzeigen und in dem er Nachrichten senden kann.

      Abbildung von Bot, der mit „Die Summe aller von Ihnen angegebenen Argumente ist 6!“ auf

      Im Folgenden finden Sie eine fertige Version des index.js-Bot-Skripts:

      index.js

      const Discord = require("discord.js");
      const config = require("./config.json");
      
      const client = new Discord.Client();
      
      const prefix = "!";
      
      client.on("message", function(message) {
        if (message.author.bot) return;
        if (!message.content.startsWith(prefix)) return;
      
        const commandBody = message.content.slice(prefix.length);
        const args = commandBody.split(' ');
        const command = args.shift().toLowerCase();
      
        if (command === "ping") {
          const timeTaken = Date.now() - message.createdTimestamp;
          message.reply(`Pong! This message had a latency of ${timeTaken}ms.`);
        }
      
        else if (command === "sum") {
          const numArgs = args.map(x => parseFloat(x));
          const sum = numArgs.reduce((counter, x) => counter += x);
          message.reply(`The sum of all the arguments you provided is ${sum}!`);
        }
      });
      
      client.login(config.BOT_TOKEN);
      

      In diesem Schritt haben Sie Ihren Discord-Bot durch Implementieren des sum-Befehls weiterentwickelt.

      Zusammenfassung

      Sie haben einen Discord-Bot implementiert, der verschiedene Benutzerbefehle und Befehlsargumente handhaben kann. Wenn Sie Ihren Bot erweitern möchten, können Sie ggf. weitere Befehle implementieren oder weitere Bestandteile der Discord-API zur Erstellung eines leistungsfähigen Discord-Bots testen. Konsultieren Sie die Discord.js-Dokumentation oder Discord-API-Dokumentation, um mehr über die Discord-API zu erfahren.

      Bei der Erstellung von Discord-Bots müssen Sie stets die allgemeinen Geschäftsbedingungen der Discord-API im Auge behalten; darin wird umrissen, wie Entwickler die Discord-API verwenden müssen. Außerdem können Sie diesen Satz an Leitfäden lesen, um einen Discord-Bot optimal zu implementieren und Tipps zur Gestaltung von Discord-Bots zu erhalten. Wenn Sie mehr über Node.js erfahren möchten, lesen Sie unsere Serie zum Codieren in Node.js.



      Source link

      Installieren eines ERPNext-Stacks unter Ubuntu 18.04


      Der Autor hat Software in the Public Interest dazu ausgewählt, im Rahmen des Programms Write for DOnations eine Spende zu erhalten.

      Einführung

      ERPNext ist eine Suite für Enterprise Resource Planning (ERP), die die Leistung und Flexibilität von Open-Source-Technologien nutzt. Sie eignet sich bestens zur Verwaltung von wichtigen Geschäftsprozessen wie Finanzen, Vertrieb, Personalverwaltung, Herstellung, Einkauf, Dienstleistungen, Helpdesk und vielem mehr. Zu den Vorteilen der Implementierung eines Systems wie ERPNext gehören:

      • Höhere Produktivität durch Automatisieren wiederholter Geschäftsprozesse
      • Verbesserte IT-Effizienz durch Freigabe einer Datenbank für alle Abteilungen innerhalb des Unternehmens
      • Bessere Entscheidungsprozesse dank einer integrierten Übersicht darüber, wie Geschäftseinheiten miteinander verbunden sind

      ERPNext basiert auf Frappe, einem Full-Stack-Webanwendungsframework, das in Python geschrieben wurde. Es nutzt umfassend die Node-/JavaScript-Laufzeitumgebung und verwendet MariaDB als Datenbank-Backend. Einer der vielen Vorteile von Frappe-basierten Anwendungen wie ERPNext ist das Befehlszeilentool bench. Die bench-CLI speichert Administratoren Zeit, indem sie Aufgaben wie Installation, Aktualisierung, Konfiguration und Verwaltung verschiedener Frappe-/ERPNext-Sites automatisiert.

      In diesem Tutorial installieren und konfigurieren Sie einen ERPNext-Stack auf einem Server, auf dem Ubuntu 18.04 ausgeführt wird. Dadurch können Sie Ihren Stack je nach Bedarf für verschiedene Entwicklungs- oder Produktionsumgebungen konfigurieren. So erhalten Sie die Möglichkeit, eine komplexere und fehlertolerantere Architektur einzurichten.

      Voraussetzungen

      Anmerkung: Bei der Auswahl der Spezifikationen Ihres Servers sollten Sie daran denken, dass ERP-Systeme ressourcenintensiv sind. Dieser Leitfaden erfordert einen Server mit 4 GB RAM, was für grundlegende Anwendungsfälle ausreicht. Die spezifischen Hardwareanforderungen können jedoch je nach Anzahl der Benutzer sowie der Unternehmensgröße variieren.

      • Ein vollständig registrierter Domänenname mit einem A-Eintrag, der auf Ihren Server verweist. Wenn Sie ein DigitalOcean-Droplet verwenden, können Sie diesem Leitfaden folgen, um Ihr DNS richtig einzurichten. In diesem Tutorial wird überall your_domain verwendet.

      Schritt 1 — Konfigurieren der Firewall

      Zwar ist die Konfiguration einer Firewall für Entwicklungsumgebungen optional, für die Produktion ist sie jedoch eine obligatorische Sicherheitsmaßnahme.

      Sie müssen auf Ihrem ERPNext-Server die folgenden Ports öffnen:

      • 80/tcp und 443/tcp für HTTP bzw. HTTPS
      • 3306/tcp für die MariaDB-Verbindung (nur empfohlen, wenn Sie Remotezugriff auf die Datenbank benötigen)
      • 143/tcp und 25/tcp für IMAP bzw. STMP
      • 22/tcp für SSH (wenn Sie OpenSSH nicht bereits aktiviert haben)
      • 8000/tcp für Entwicklungstests, bevor Sie Ihre Site bereitstellen

      Zum Öffnen verschiedener Ports auf einmal können Sie folgenden Befehl verwenden:

      • sudo ufw allow 22,25,143,80,443,3306,8000/tcp

      Alternativ können Sie Verbindungen von bestimmten IP-Adressen zu bestimmten Ports mit diesem Befehl zulassen:

      • sudo ufw allow from server_IP to any port port_number

      Nach dem Öffnen aller erforderlichen Ports aktivieren Sie die Firewall:

      Nach Aktivierung der Firewall prüfen Sie den Status Ihrer offenen Ports:

      Weitere Informationen zum Firewall-Setup finden Sie in unserem Leitfaden Einrichten einer Firewall mit UFW unter Ubuntu 18.04.

      Das Einrichten einer ordnungsgemäß funktionierenden Firewall ist der erste von zwei Vorbereitungsschritten. Jetzt konfigurieren Sie die Tastenbelegung und Zeichencodierung auf Ihrem Server.

      Schritt 2 — Konfigurieren von Gebietsschemas

      Es wird dringend empfohlen, die Tastenbelegung für die Konsole sowie die Sprache und die Zeichencodierung auf Ihrem Host zu konfigurieren. Dies ist notwendig, um mögliche Probleme bei der ERPNext 12-Installation zu verhindern. Beachten Sie, dass diese Konfiguration nichts mit der UI-Sprache in Ihrer eigentlichen ERPNext-Plattform zu tun hat, sondern mit der Systemkonfiguration des Gebietsschemas.

      Aktualisieren Sie zunächst Ihren Server:

      Konfigurieren Sie nun die Tastenbelegung, Sprache und Zeichencodierung:

      • sudo localectl set-keymap us && sudo localectl set-locale LANG=en_US.utf8

      Das Dienstprogramm localectl wird von Ubuntu 18.04 und anderen Linux-Distributionen verwendet, um systemweite Einstellungen für das Gebietsschema und die Tastaturbelegung zu steuern und zu ändern, bevor der Benutzer sich anmeldet. Das ist genau das, was ERPNext 12 benötigt.

      Sie müssen Ihrer Datei /etc/environment außerdem die folgenden Zeilen hinzufügen. Verwenden Sie nano oder Ihren bevorzugten Texteditor, um die Datei zu öffnen:

      • sudo nano /etc/environment

      Fügen Sie jetzt den folgenden Inhalt hinzu.

      /etc/environment

      LC_ALL=en_US.UTF-8
      LC_CTYPE=en_US.UTF-8
      LANG=en_US.UTF-8
      

      Speichern und schließen Sie die Datei.

      Starten Sie Ihren Server neu, um alle Änderungen anzuwenden:

      Geben Sie Ihrem Server einige Minuten zum Neustart und stellen Sie dann erneut eine SSH-Verbindung her. Sie sind nun bereit, Ihre Datenbank zu installieren.

      Schritt 3 — Installieren von MariaDB 10.04

      Jetzt fügen Sie MariaDB Ihrem Server-Stack hinzu. ERPNext 12 erfordert MariaDB 10.2 oder höher; die im offiziellen Repository von Ubuntu 18.04 enthaltene Version lautet jedoch 10.1, was bedeutet, dass Sie eine höhere Version installieren müssen. Für die Zwecke dieses Leitfadens verwenden Sie die neueste stabile Version von MariaDB, zum Zeitpunkt der Verfassung dieses Textes Version 10.4.

      Um MariaDB 10.4 unter Ubuntu 18.04 zu installieren, müssen Sie den entsprechenden Signaturschlüssel und das Repository hinzufügen. Diese Informationen finden Sie im Repository-Assistenten der MariaDB Foundation. Besuchen Sie diese URL in Ihrem Webbrowser. Klicken Sie nun unter 1. Choose a Distro (1. Distro wählen) auf Ubuntu. Eine zweite Spalte mit dem Titel 2. Choose a Release (2. Release wählen) wird angezeigt. Klicken Sie unter diesem Titel auf 18.04 LTS “bionic”. Dann wird eine dritte Spalte mit dem Titel 3. Choose a Version (3. Version wählen) angezeigt. Klicken Sie darunter auf 10.4 stable. Eine dritte Spalte mit dem Titel 4. Choose a Mirror (4. Spiegelung wählen) wird angezeigt. Wählen Sie eine auf Ihrem Standort basierende Spiegelung aus; dann wird MariaDB die entsprechenden Befehle für Ihre benutzerdefinierte Installation eingeben.

      Repository-Assistent von MariaDB

      Führen Sie die drei eingegebenen Befehle aus, wodurch das MariaDB-Repository und der Schlüssel ordnungsgemäß hinzugefügt werden. Ihre eigenen Befehle werden etwa wie folgt aussehen:

      • sudo apt-get install software-properties-common && sudo apt-key adv --fetch-keys 'https://mariadb.org/mariadb_release_signing_key.asc' && sudo add-apt-repository 'deb [arch=amd64,arm64,ppc64el] http://mirror.klaus-uwe.me/mariadb/repo/10.4/ubuntu bionic main'

      Sobald Sie das Repository hinzugefügt haben, installieren Sie MariaDB:

      • sudo apt install mariadb-server

      Installieren Sie nach der Installation von mariadb-server die folgenden Pakete:

      • sudo apt install libmysqlclient-dev python3-mysqldb

      ERPNext 12 ist eine Python-Anwendung und benötigt daher die Bibliothek python3-mysqldb für das Datenbankmanagement. Bezüglich libmysqlclient-dev, mariadb-client und libmariadbclient18: Über diese Pakete können Benutzer mit dem MariaDB-Dienst kommunizieren. ntpdate und libdate-manip-perl werden von ERPNext zur Synchronisierung der Serverzeit verwendet.

      Fügen Sie dem MariaDB-Server als Nächstes eine grundlegende Sicherheitsschicht hinzu, indem Sie das Skript mysql_secure_installation ausführen:

      • sudo mysql_secure_installation

      Das Skript mysql_secure_installation wird Ihnen mehrere Fragen stellen:

      • Die erste Eingabeaufforderung wird Sie nach dem root-Passwort fragen. Da jedoch noch kein Passwort konfiguriert ist, drücken Sie die Eingabetaste.
      • Als Nächstes müssen Sie entscheiden, ob Sie Unix-Authentifizierung verwenden möchten oder nicht. Antworten Sie mit Y (J), um diese Authentifizierungsmethode zu akzeptieren.
      • Antworten Sie mit N, wenn Sie dazu aufgefordert werden, dasroot-Passwort für MariaDB zu ändern. Eine Verwendung des Standardpassworts zusammen mit Unix-Authentifizierung ist das empfohlene Verfahren für Ubuntu-basierte Systeme, da das root-Konto eng mit automatisierten Systemwartungsaufgaben verbunden ist.
      • Die übrigen Fragen haben mit dem Entfernen des anonymen Datenbankbenutzers tun, wobei das root-Konto so beschränkt wird, dass es sich remote bei localhost anmeldet, die Testdatenbank entfernt wird und Berechtigungstabellen neu geladen werden. Sie können alle diese Fragen mit Y beantworten.

      Nach Abschluss des Skripts mysql_secure_installation wird MariaDB mit ihrer Standardkonfiguration gestartet. Die standardmäßige ERPNext-Installation verwendet für alle Datenbankoperationen den root user von MariaDB. Zwar mag dieser Ansatz für einzelne Serverkonfigurationen praktisch sein, doch gilt er nicht als besonders sicher. Im nächsten Abschnitt erfahren Sie daher, wie Sie das Problem vermeiden können, indem Sie einen neuen Benutzer mit speziellen Berechtigungen erstellen.

      Erstellen eines MariaDB Super Admin-Benutzers

      ERPNext erwartet, dass zur Verwaltung von Datenbankverbindungen der root user von MariaDB verwendet wird. Dies ist jedoch nicht immer ideal. Um diese Einschränkung zu umgehen und MariaDB von einem Nicht-root-Benutzer verwalten zu lassen, müssen Sie nun manuell eine Datenbank erstellen, die nach diesem Benutzer benannt ist. Dann können Sie dem neuen Benutzer spezielle Berechtigungen zuweisen, um ihm ERPNext-Datenbankoperationen zu ermöglichen.

      Öffnen Sie die Eingabeaufforderung von MariaDB:

      Erstellen Sie nun eine neue Datenbank, die nach dem Benutzer benannt ist, den Sie für MariaDB-Verbindungen zuweisen möchten. In diesem Tutorial wird sammy verwendet, Sie können jedoch einen Namen Ihrer Wahl nutzen:

      Prüfen Sie mit dieser SQL-Anweisung, ob die Datenbank erstellt wurde:

      Sie sehen eine Ausgabe, die dieser ähnelt:

      Output

      +--------------------+ | Database | +--------------------+ | information_schema | | mysql | | performance_schema | | sammy | +--------------------+

      Erstellen Sie nun den MariaDB-Benutzer sammy mit Berechtigungen, die denen von root ähneln, und weisen Sie dem Benutzer ein starkes Passwort Ihrer Wahl zu. Bewahren Sie das Passwort an einem sicheren Ort auf; Sie werden es später benötigen:

      • GRANT ALL PRIVILEGES ON *.* TO 'sammy'@'%' IDENTIFIED BY 'mariadb_password' WITH GRANT OPTION;

      Prüfen Sie nun sowohl die Erstellung des Benutzers als auch die Berechtigungen des neuen Benutzers:

      • SELECT host, user, Super_priv FROM mysql.user;

      Sie werden eine Ausgabe wie diese sehen:

      Output

      +-----------+-------+------------+ | Host | User | Super_priv | +-----------+-------+------------+ | localhost | root | Y | | localhost | mysql | Y | | % | sammy | Y | +-----------+-------+------------+ 3 rows in set (0.001 sec)

      Bereinigen Sie nun Berechtigungen, um alle Änderungen anzuwenden:

      Abschließend beenden Sie die Sitzung:

      Nachdem Sie einen Datenbankbenutzer erstellt haben, müssen Sie nun nur noch MariaDB optimieren, um einen ordnungsgemäßen Betrieb von ERPNext 12 sicherzustellen. Das ERPNext-Team verfügt zum Glück über eine ausgezeichnete Konfigurationsvorlage, die Sie als Ausgangspunkt für Ihre Implementierung verwenden werden. Im nächsten Abschnitt erfahren Sie, wie Sie die MariaDB-Datenbank mit dieser Vorlage richtig konfigurieren.

      Schritt 4 — Konfigurieren von MariaDB für ERPNext

      Nach dem Installieren und Schützen von MariaDB ist es nun an der Zeit für die Optimierung der ERPNext-Verbindungen.

      Halten Sie zunächst mariadb.service an:

      • sudo systemctl stop mariadb

      Verwenden Sie nun nano oder Ihren bevorzugten Texteditor, um eine MariaDB-Konfigurationsdatei namens settings.cnf zu erstellen:

      • sudo nano /etc/mysql/conf.d/settings.cnf

      Fügen Sie nun die Konfigurationsvorlage von ERPNext hinzu:

      /etc/mysql/conf.d/settings.cnf

      [mysqld]
      
      # GENERAL #
      user                           = mysql
      default-storage-engine         = InnoDB
      socket                         = /var/lib/mysql/mysql.sock
      pid-file                       = /var/lib/mysql/mysql.pid
      
      # MyISAM #
      key-buffer-size                = 32M
      myisam-recover                 = FORCE,BACKUP
      
      # SAFETY #
      max-allowed-packet             = 256M
      max-connect-errors             = 1000000
      innodb                         = FORCE
      
      # DATA STORAGE #
      datadir                        = /var/lib/mysql/
      
      # BINARY LOGGING #
      log-bin                        = /var/lib/mysql/mysql-bin
      expire-logs-days               = 14
      sync-binlog                    = 1
      
      # REPLICATION #
      server-id                      = 1
      
      # CACHES AND LIMITS #
      tmp-table-size                 = 32M
      max-heap-table-size            = 32M
      query-cache-type               = 0
      query-cache-size               = 0
      max-connections                = 500
      thread-cache-size              = 50
      open-files-limit               = 65535
      table-definition-cache         = 4096
      table-open-cache               = 10240
      
      # INNODB #
      innodb-flush-method            = O_DIRECT
      innodb-log-files-in-group      = 2
      innodb-log-file-size           = 512M
      innodb-flush-log-at-trx-commit = 1
      innodb-file-per-table          = 1
      innodb-buffer-pool-size        = 5462M
      innodb-file-format             = barracuda
      innodb-large-prefix            = 1
      collation-server               = utf8mb4_unicode_ci
      character-set-server           = utf8mb4
      character-set-client-handshake = FALSE
      max_allowed_packet             = 256M
      
      # LOGGING #
      log-error                      = /var/lib/mysql/mysql-error.log
      log-queries-not-using-indexes  = 0
      slow-query-log                 = 1
      slow-query-log-file            = /var/lib/mysql/mysql-slow.log
      
      [mysql]
      default-character-set = utf8mb4
      
      [mysqldump]
      max_allowed_packet=256M
      
      !includedir /etc/mysql/mariadb.conf.d/
      

      Speichern und schließen Sie die Datei. Weitere Informationen zu diesen Konfigurationen finden Sie in dieser Vorlagendatei im Github-Repository von ERPNext. Dies ist ein nützlicher Ausgangspunkt für die Erkundung der Optionen.

      Erstellen Sie als Nächstes eine weitere Datei namens erpnext.cnf:

      • sudo nano /etc/mysql/mariadb.conf.d/erpnext.cnf

      Fügen Sie der Datei folgenden Inhalt hinzu:

      /etc/mysql/mariadb.conf.d/erpnext.cnf

      [mysqld]
      pid-file        = /var/run/mysqld/mysqld.pid
      socket          = /var/run/mysqld/mysqld.sock
      bind-address    = 0.0.0.0
      

      Die erste Datei /etc/mysql/conf.d/settings.cnf ergänzt und überschreibt auch einige Werte, die in der Standardkonfiguration von MariaDB unter /etc/mysql/my.cnf enthalten sind. Diese Datei dient Ihnen als kuratierte Vorlage, die die Datenbankleistung für ERPNext erheblich verbessert. Beachten Sie, dass diese Vorlage zwar ein guter Ausgangspunkt ist, Sie die Leistung von MariaDB jedoch noch weiter verbessern können, indem Sie die Parameter an Ihre Bedürfnisse anpassen.

      Die zweite Datei /etc/mysql/mariadb.conf.d/erpnext.cnf überschreibt ebenfalls einige Werte, indem bestimmte Informationen zu Ihrer Datenbankverbindung hinzugefügt werden.

      Testen der MariaDB-Verbindung

      Da ERPNext bei fast allen internen Operationen auf die Datenbankverbindung angewiesen ist, ist es sinnvoll, die Verbindung vor dem Fortfahren zu testen.

      Starten Sie mariadb.service:

      • sudo systemctl start mariadb

      Zum Testen der Verbindung können Sie folgenden Befehl verwenden. Denken Sie daran, sammy und mariadb_password durch Ihre eigenen Anmeldedaten zu ersetzen:

      • mysql --user sammy --password mariadb_password --host=localhost --protocol=tcp --port=3306 test

      Sie erhalten eine Ausgabe mit dem grundlegenden Hilfeinhalt von MariaDB und mehreren Parametern. Das bedeutet, dass Ihre Verbindung erfolgreich hergestellt wurde:

      Output

      mysql Ver 15.1 Distrib 10.4.13-MariaDB, for debian-linux-gnu (x86_64) using readline 5.2 Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others. Usage: mysql [OPTIONS] [database] Default options are read from the following files in the given order: /etc/my.cnf /etc/mysql/my.cnf ~/.my.cnf ... --ssl-verify-server-cert Verify server's "Common Name" in its cert against hostname used when connecting. This option is disabled by default. -t, --table Output in table format. --tee=name Append everything into outfile. See interactive help (h) also. Does not work in batch mode. Disable with --disable-tee. This option is disabled by default. -u, --user=name User for login if not current user. -U, --safe-updates Only allow UPDATE and DELETE that uses keys. -U, --i-am-a-dummy Synonym for option --safe-updates, -U. -v, --verbose Write more. (-v -v -v gives the table output format). ... max-join-size 1000000 secure-auth FALSE show-warnings FALSE plugin-dir (No default value) default-auth (No default value) binary-mode FALSE connect-expired-password FALSE

      Wenn Sie Änderungen an den Einstellungen von MariaDB vornehmen oder Fehler beheben müssen, können Sie den Dienst mit dem folgenden Befehl neu laden:

      • sudo systemctl restart mariadb

      Aktivieren Sie anschließend MariaDB:

      • sudo systemctl enable mariadb

      Nachdem Sie die Datenbankverbindung getestet haben, können Sie nun mit der Installation Ihrer ERPNext-Anwendung fortfahren.

      Schritt 5 — Einrichten von ERPNext 12

      Nachdem Ihr Datenbank-Backend bereit ist, können Sie nun mit der Einrichtung Ihrer ERPNext-Webanwendung fortfahren. In diesem Abschnitt erfahren Sie, wie Sie alle von ERPNext 12 benötigten Komponenten installieren und konfigurieren und dann die Anwendung selbst installieren.

      Bereiten Sie zunächst mit allen Systempaketen, die ERPNext 12 benötigt, den Server vor. Installieren Sie systemweite Abhängigkeiten mit dem folgenden Befehl:

      • sudo DEBIAN_FRONTEND=noninteractive apt install -y curl build-essential mariadb-client python3-setuptools python3-dev libffi-dev python3-pip libcurl4 dnsmasq fontconfig git htop libcrypto++-dev libfreetype6-dev liblcms2-dev libwebp-dev libxext6 libxrender1 libxslt1-dev libxslt1.1 libffi-dev ntpdate postfix python3-dev python-tk screen vim xfonts-75dpi xfonts-base zlib1g-dev apt-transport-https libsasl2-dev libldap2-dev libcups2-dev pv libjpeg8-dev libtiff5-dev tcl8.6-dev tk8.6-dev libssl1.0-dev python3-mysqldb libdate-manip-perl logwatch

      Die Variable DEBIAN_FRONTEND=noninteractive wurde an den Installationsbefehl übergeben, um Postfix-Eingabeaufforderungen zu vermeiden. Detaillierte Informationen zur Postfix-Konfiguration finden Sie in unserem Leitfaden zum Installieren und Konfigurieren von Postfix unter Ubuntu 18.04.

      Aktualisieren Sie nun pip3 und installieren Sie dann die neuesten Versionen von drei zusätzlichen Python-Modulen, die ERPNext benötigt:

      • sudo -H python3 -m pip install --upgrade setuptools cryptography psutil

      Nachdem Sie alle erforderlichen globalen Abhängigkeiten installiert haben, installieren Sie nun sämtliche Dienste und Bibliotheken, die ERPNext 12 benötigt.

      Einrichten von Node.js und Yarn

      ERPNext 12 kann mit Version 8 der Node.js-Serverumgebung und höher zusammenarbeiten. Zum Zeitpunkt der Verfassung dieses Dokuments verwendet das offizielle ERPNext easy_install-Skript Node 8. Aus Sicherheitsgründen ist es jedoch ratsam, eine neuere Version zu installieren, da Node 8 2020 sein Lebensende (End of Life, EOL) erreicht hat und somit keine Sicherheitspatches mehr erhalten wird. Für die Zwecke dieses Leitfadens wird Node.js-Version 12 LTS zusammen mit den entsprechenden Paketmanagern npm und yarn installiert. Bitte beachten Sie, dass das Frappe-Framework yarn zum Installieren von Abhängigkeiten verwendet. Wenn Sie sich dazu entscheiden, eine alternative Installationsmethode zu nutzen, stellen Sie sicher, dass am Ende Version 1.12 von yarn oder höher in Ihrem System ausgeführt wird.

      Fügen Sie das NodeSource-Repository zu Ihrem System hinzu:

      • curl -sL https://deb.nodesource.com/setup_12.x -o nodesource_setup.sh

      Sie können nun den Inhalt des heruntergeladenen Skripts überprüfen:

      • sudo nano nodesurce_setup.sh

      Sobald Sie zufrieden sind, können Sie das Skript ausführen:

      • sudo bash nodesource_setup.sh

      Dieses Skript aktualisiert automatisch die Liste apt. Sie können nodejs nun auf Ihrem Server installieren:

      Installieren Sie als Nächstes yarn global mit dem enthaltenen npm-Paket:

      Nachdem Sie Node installiert haben, können Sie nun mit der Konfiguration von wkhtmltopdf für Ihre Plattform fortfahren.

      ERPNext verwendet das Open-Source-Tool wkhtmltopdf, um HTML-Inhalte mit der Qt WebKit-Rendering-Engine in PDF zu konvertieren. Diese Funktion dient hauptsächlich zum Drucken von Rechnungen, Angeboten und anderen Berichten. Für ERPNext 12 wird eine spezifische Version von wkhtmltopdf (0.12.5) mit gepatchtem Qt benötigt.

      Wechseln Sie zum Installieren von wkhtmltopdf zunächst in ein geeignetes Verzeichnis, in das Sie das Paket herunterladen möchten, in diesem Fall /tmp:

      Laden Sie die entsprechende wkhtmltopdf-Version und das Paket für Ubuntu 18.04 von der Projektseite herunter:

      • wget https://github.com/wkhtmltopdf/wkhtmltopdf/releases/download/0.12.5/wkhtmltox_0.12.5-1.bionic_amd64.deb

      Installieren Sie das Paket nun mit dem Tool dpkg:

      • sudo dpkg -i wkhtmltox_0.12.5-1.bionic_amd64.deb

      Kopieren Sie als Nächstes alle relevanten ausführbaren Dateien in Ihr Verzeichnis /usr/bin:

      • sudo cp /usr/local/bin/wkhtmlto* /usr/bin/

      Ändern Sie anschließend ihre Berechtigungen, um sie ausführbar zu machen:

      • sudo chmod a+x /usr/bin/wk*

      Nachdem wkhtmltopdf richtig installiert ist, fügen wir nun Redis unserem Datenbank-Stack hinzu.

      Installieren von Redis

      ERPNext 12 verwendet Redis, um die Leistung von MariaDB zu verbessern. Insbesondere hilft Redis beim Caching.

      Installieren Sie zunächst Redis aus dem offiziellen Ubuntu 18.04-Repository:

      • sudo apt install redis-server

      Aktivieren Sie anschließend Redis beim Start:

      • sudo systemctl enable redis-server

      Nachdem Sie Redis Ihrem Stack hinzugefügt haben, können wir uns nun einen Moment Zeit nehmen, um zusammenzufassen, was Sie bisher erreicht haben. Bisher haben Sie alle wichtigen Komponenten installiert, die ERPNext 12 benötigt, darunter folgende Komponenten:

      • Ein MariaDB-Datenbank-Backend
      • Die Node.js-JavaScript-Serverumgebung
      • Den Yarn-Paketmanager
      • Einen Redis-Datenbankcache
      • Den wkhtmltopdf-Generator für PDF-Dokumente

      Egal, ob Sie das ERP-System für die Entwicklung oder Produktion installieren, sind Sie nun bereit für den nächsten Schritt, bei dem das Frappe-Full-Stack-Framework und die eigentliche ERPNext-12-Webanwendung installiert werden.

      Schritt 6 — Installieren der Frappe Bench-CLI

      Nachdem Sie alle Stack-Voraussetzungen für ERPNext installiert haben, können Sie nun die Flexibilität des Befehlzeilentools bench von Frappe nutzen. Die bench-CLI wurde mit dem Ziel entwickelt, Benutzer beim Installieren, Einrichten und Verwalten von Anwendungen wie ERPNext, die auf dem Frappe-Framework basieren, zu unterstützen. In den kommenden Abschnitten installieren Sie die bench-CLI und verwenden diese dann zum Abschließen der Einrichtung von ERPNext 12.

      Stellen Sie sicher, dass der Frappe-Benutzer (in diesem Fall sammy) über die richtigen Berechtigungen für das Verzeichnis home verfügt:

      • sudo chown sammy -R /home/sammy

      Klonen Sie nun das frappe/bench-Repository in Ihr Stammverzeichnis. Denken Sie daran, sammy durch Ihren Systembenutzernamen zu ersetzen:

      • git clone https://github.com/frappe/bench /home/sammy/.bench --depth 1 --branch master

      Installieren Sie die bench-CLI:

      • sudo pip3 install -e /home/sammy/.bench

      Dieser Leitfaden geht davon aus, dass Sie ERPNext 12 für Test- bzw. Produktionsszenarien installieren und daher die Verzweigung master verwenden. Wenn Sie jedoch Anwendungen oder benutzerdefinierte ERPNext-Module entwickeln möchten, kann die Verzweigung develop eine bessere Option sein. In jedem Fall sind Sie nun bereit, das Frappe-Framework zu installieren. Dies ist der letzte Schritt vor der Installation von ERPNext selbst.

      Einrichten der Frappe-Framework-Umgebung

      In diesem Abschnitt erstellen Sie eine Frappe-Umgebung mithilfe der bench-CLI.

      Bei der Installation von Frappe überschreiten Sie ggf. das File-Watch-Limit von Ubuntu, das standardmäßig auf 8192 festgelegt ist. Legen Sie mit dem folgenden Befehl ein höheres Limit fest, um das zu verhindern:

      • echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p

      Initialisieren Sie als Nächstes Frappe Framework 12. Ersetzen Sie Sammy durch Ihren Systembenutzernamen:

      • bench init /home/sammy/frappe-bench --frappe-path https://github.com/frappe/frappe --frappe-branch version-12 --python python3

      Bei der Ausführung werden möglicherweise ein Fehler zu Ihrem Pfad sowie mehrere Warnungen angezeigt. Lassen Sie den Prozess bis zum Ende fortlaufen. Nach seinem Abschluss sehen Sie eine Ausgabe, die der folgenden ähnelt; das bedeutet, dass Ihre Umgebung erfolgreich erstellt wurde:

      Output

      ... Done in 82.23s. INFO:bench.utils:setting up backups no crontab for sammy SUCCESS: Bench /home/sammy/frappe-bench initialized

      Anmerkung: Der Prozess bench init kann angehalten werden, wenn ein Fehler vom Typ spawn ENOMEM auftritt. Dieser Fehler wird ausgelöst, wenn Ihr System nicht mehr genügend Arbeitsspeicher hat. Sie müssen das Problem vor dem Fortfahren beheben, entweder durch Installieren von mehr physischem Arbeitsspeicher oder durch Zuweisen eines Auslagerungsbereichs.

      Sehen wir uns den Befehl genauer an, mit dem die Umgebung erstellt wird:

      • /home/sammy/frappe-bench ist der Pfad, in dem das Frappe-Framework, die Websites und zugehörige Anwendungen installiert werden. Es wird ein neues Verzeichnis (in diesem Beispiel namens frappe-bench) erstellt, um alle erforderlichen Dateien zu unterbringen.
      • --frappe-path verweist auf das Frappe-Repository, das in diesem Fall das offizielle Github-Repository ist.
      • --frappe-branch ist die zu installierende Frappe-Version. Da Sie ERPNext 12 installieren möchten, ist die gewählte Version Frappe 12.
      • --python ist die zu verwendende Python-Version. ERPNext 12 erfordert Python 3.6 oder höher. Frühere Versionen nutzen jedoch immer noch Python 2.7.

      Weitere Informationen zu bench-CLI-Befehlen finden Sie im Spickzettel mit Bench-Befehlen.

      Die Flexibilität, die das Frappe-Framework bietet, geht weit über die Verwendung isolierter Umgebungen hinaus. Sie können auch verschiedene Websites erstellen und Anwendungen in ihnen installieren.

      Schritt 7 — Installieren der ERPNext 12-Webanwendung

      In diesem Abschnitt richten Sie eine auf Frappe basierende Site ein und installieren dann darin die ERPNext 12-Anwendung.

      Wechseln Sie zu dem Verzeichnis, in dem Frappe initialisiert wurde.

      • cd /home/sammy/frappe-bench

      Laden Sie nun mit der bench-CLI ERPNext 12 aus dem Repository herunter:

      • bench get-app erpnext https://github.com/frappe/erpnext --branch version-12

      Erstellen Sie als Nächstes die neue Site und ersetzen Sie your_domain durch die Domäne, die Sie mit der IP-Adresse dieses Servers verknüpft haben:

      • bench new-site your_domain --admin-password 'erpnext_admin_password' --mariadb-root-username sammy --mariadb-root-password 'mariadb_password'

      Nehmen wir uns einen Moment Zeit, um die im obigen Befehl verwendeten Optionen zu betrachten:

      • bench new-site erstellt eine neue Site basierend auf dem Frappe-Framework.
      • your_domain ist der Name für die neue Site. Stellen Sie sicher, dass das DNS Ihrer Domäne über einen A-Eintrag verfügt, der auf die IP-Adresse Ihres Servers verweist.
      • erpnext_admin_password ist das gewünschte Passwort für den ERPNext-Benutzer Administrator. Bewahren Sie dieses Passwort an einem sicheren Ort auf; Sie werden es in Kürze benötigen.
      • mariadb_password ist das Passwort, das Sie am Anfang des Leitfadens für den MariaDB-Benutzer sammy erstellt haben.

      Installieren Sie anschließend die ERPNext-Anwendung in der Site:

      • bench --site your_domain install-app erpnext

      Nach Abschluss der Installation verfügen Sie über eine funktionierende ERPNext 12-Anwendung. Testen wir dies nun mit einem bench-Befehl:

      Mit dem oben genannten Schritt wird eine Konsole zur Echtzeitüberwachung gestartet, die Ihnen verschiedene Nachrichten zum Webserver und anderen Diensten anzeigt. Öffnen Sie einen Webbrowser und navigieren Sie zu localhost:8000 (bei lokalen Installationen) oder your_domain:8000 (wenn Sie einen Remoteserver verwenden). Sie sehen den ERPNext-Anmeldebildschirm (wir werden in einem späteren Schritt mit der Anmeldung und Einrichtung fortfahren, wenn unsere Site produktionsfertig ist).

      Kehren Sie nach dem Besuch Ihrer Testbereitstellung zu Ihrem Terminal zurück und drücken Sie Strg+C. Dadurch wird ERPNext angehalten und die Überwachungskonsole beendet.

      Wenn Ihr Hauptziel darin besteht, Module zu erstellen oder ERPNext 12 zu modifizieren, können Sie an diesem Punkt aufhören. Für Entwicklungszwecke sind keine Komponenten mehr erforderlich. Wenn Sie jedoch ein produktionsfähiges System benötigen, das keine manuelle Initialisierung voraussetzt, müssen Sie noch einige zusätzliche Komponenten installieren und konfigurieren. Dies ist Ihr nächster Schritt.

      Schritt 8 — Einrichten von ERPNext 12 für die Produktion

      Zwar ist die ERPNext 12-Anwendung bereit, doch ist das System insgesamt noch nicht ganz fertig für die Produktion. Um die Zuverlässigkeit und Sicherheit von ERPNext zu gewährleisten, müssen Sie einige zusätzliche Dienste aktivieren:

      • Fail2ban bietet eine zusätzliche Schutzschicht vor Brute-Force-Angriffen durch bösartige Benutzer und Bots.
      • Nginx dient hauptsächlich als Webproxy, der den gesamten Datenverkehr von Port 8000 an Port 80 (HTTP) oder Port 443 (HTTPS) weiterleitet.
      • Supervisor: Dieser Dienst sorgt dafür, dass die wichtigsten Prozesse von ERPNext kontinuierlich ausgeführt und bei Bedarf neu gestartet werden.

      Bisher haben Sie ERPNext 12 manuell installiert und konfiguriert, sodass Sie den Prozess an einem bestimmten Anwendungsfall anpassen konnten. Für den Rest der Produktionseinrichtung können Sie jedoch aus Gründen der Einfachheit die bench-CLI nutzen und die Installation und Konfiguration der verbleibenden Dienste automatisch erledigen lassen.

      Stellen Sie sicher, dass Sie sich im Arbeitsverzeichnis Frappe befinden:

      • cd /home/sammy/frappe-bench

      Verwenden Sie nun folgenden Befehl, um die Einrichtung von ERPNext 12 für die Produktion abzuschließen:

      • sudo bench setup production sammy --yes

      Dadurch werden Nginx, Supervisor und Fail2Ban installiert und konfiguriert und wird sammy als Eigentümer der Produktionsumgebung festgelegt.

      Die Konfigurationsdateien, die mit dem Befehl created werden, sind:

      • Zwei Nginx-Konfigurationsdateien, die sich unter /etc/nginx/nginx.conf und /etc/nginx/conf.d/frappe-bench.conf befinden
      • Ein Fail2Ban-Proxy-Jail unter /etc/fail2ban/jail.d/nginx-proxy.conf und ein Filter unter /etc/fail2ban/filter.d/nginx-proxy.conf

      Diese Standardkonfigurationen reichen für dieses Tutorial aus; Sie sollten diese Dateien jedoch erkunden und an Ihre eigenen Anforderungen anpassen. Sie können alle Dienste anhalten, indem Sie Folgendes ausführen:

      • sudo supervisorctl stop all

      Und wenn Sie bereit dazu sind, können Sie Ihre Dienste neu starten:

      • sudo supervisorctl start all

      Sie sind nun in der Lage, Ihre Installation zu testen.

      Testen Ihrer ERPNext 12-Installation

      Überprüfen Sie zunächst mit dem folgenden Befehl systemctl, ob die wichtigsten Produktionsdienste ausgeführt werden, und leiten Sie dann an grep weiter:

      • systemctl list-unit-files | grep 'fail2ban|nginx|supervisor'

      Sie werden eine Ausgabe wie diese sehen:

      Output

      fail2ban.service enabled nginx.service enabled supervisor.service enabled

      Nachdem Sie sich vergewissert haben, dass alles wie erwartet funktioniert, können Sie ERPNext 12 auf Ihrem Server live testen. Öffnen Sie Ihren bevorzugten Browser und navigieren Sie zu der Domäne, wo Sie Ihre ERPNext 12-Anwendung hosten.

      Nach wenigen Sekunden sollten Sie den Anmeldebildschirm von ERPNext 12 sehen. Verwenden Sie Administrator als Benutzernamen und das zuvor für das Passwort erstellte erpnext_admin_password.

      Anmeldefenster von ERPNext

      Im nächsten Bildschirm sehen Sie ein Dropdownmenü, in dem Sie die Sprache der Benutzeroberfläche für die Anwendung auswählen können:

      Sprachauswahl

      Nach der Sprachauswahl wird Sie ERPNext zur Eingabe Ihres Lands, Ihrer Zeitzone und der Währung auffordern:

      Wählen Sie Ihre Region aus

      Nachdem Sie die Regionsinformationen festgelegt haben, können Sie den ersten ERPNext-Benutzer erstellen. Die von Ihnen angegebenen Informationen werden als Anmeldedaten des Benutzers verwendet.

      Erster ERPNext-Benutzer

      Im nächsten Bildschirm werden Sie nach etwas gefragt, das ERPNext Domänen nennt. Wenn Sie sich nicht sicher sind, wie Ihre Domäne lautet, wählen Sie als Nächstes Distribution und klicken Sie auf die Schaltfläche Weiter.

      Wählen Sie Ihre Domänen aus

      Als Nächstes müssen Sie einen Firmennamen und eine Abkürzung angeben.

      Firmenname

      Im letzten Bildschirm fragt Sie ERPNext nach dem, was Ihre Firma tut, nach dem Namen ihrer Bank, nach der Art der Kontenpläne und nach der Geschäftsjahresperiode. Sie können später weitere Banken eingeben. Füllen Sie vorerst alle Felder wie gewünscht aus und klicken Sie dann auf die Schaltfläche Complete Setup (Einrichtung abschließen).

      Finanzdaten

      Als Nächstes sehen Sie eine Fortschrittsleiste.

      Einrichten von ERPNext

      Nach Abschluss der Einrichtung wird das Haupt-Dashboard von ERPNext 12 angezeigt.

      ERPNext 12-Dashboard

      Sie haben nun eine ERPNext 12-Anwendung vollständig installiert und konfiguriert.

      Zusammenfassung

      Nachdem Sie Ihre ERPNext 12-Anwendung richtig installiert haben, können Sie nun mit der Anpassung des Systems an Ihre geschäftlichen Bedürfnisse beginnen. Ein guter Ausgangspunkt ist ein Klick auf die Schaltfläche Getting Started (Erste Schritte) im ERPNext-Dashboard. ERPNext hilft Ihnen dann bei der Konfiguration der Plattform für alle Ihre geschäftlichen und E-Commerce-Anforderungen.

      Erste Schritte

      Vielleicht möchten Sie auch die Geschwindigkeit von ERPNext erhöhen. In diesem Fall können Sie Leistungsoptimierung bei ERPNext lesen; hier erhalten Sie Informationen über bewährte Praktiken und die Behebung von Leistungsproblemen.



      Source link

      Einrichten eines IKEv2-VPN-Servers mit StrongSwan unter Ubuntu 20.04


      Eine frühere Version dieses Tutorials wurde von Justin Ellingwood und Namo verfasst

      Einführung

      Ein virtuelles privates Netzwerk oder VPN ermöglicht Ihnen die sichere Verschlüsselung des Datenverkehrs auf dem Weg durch nicht vertrauenswürdige Netzwerke, wie z. B. im Café, bei einer Konferenz oder auf einem Flughafen.

      Internet Key Exchange v2 oder IKEv2 ist ein Protokoll, das ein direktes IPSec-Tunneling zwischen Server und Client ermöglicht. In IKEv2-VPN-Implementierungen bietet IPSec eine Verschlüsselung für den Netzwerkverkehr. IKEv2 wird auf einigen Plattformen (OS X 10.11+, iOS 9.1+ und Windows 10) nativ unterstützt, ohne dass zusätzliche Anwendungen erforderlich sind und Client-Hickups werden reibungslos verwaltet.

      In diesem Tutorial richten Sie einen IKEv2-VPN-Server mit StrongSwan auf einem Ubuntu-20.04-Server ein. Anschließend lernen Sie, wie mit Windows-, macOS-, Ubuntu-, iOS- und Android-Clients eine Verbindung zu diesem Server herstellen können.

      Voraussetzungen

      Um diesem Tutorial zu folgen, benötigen Sie:

      Schritt 1 — Installieren von StrongSwan

      Zuerst installieren wir StrongSwan, einen Open-Source-IPSec-Daemon, den wir als unseren VPN-Server konfigurieren werden. Außerdem installieren wir die Komponente „Public Key Infrastructure“ (PKI), sodass wir eine Zertifizierungsstelle (Certificate Authority, CA) erstellen können, die die Anmeldedaten für unsere Infrastruktur bereitstellt.

      Beginnen Sie mit der Aktualisierung des lokalen Paket-Caches:

      Installieren Sie dann die Software durch folgende Eingabe:

      • sudo apt install strongswan strongswan-pki libcharon-extra-plugins libcharon-extauth-plugins

      Das zusätzliche Paket libcharon-extauth-plugins wird verwendet, um sicherzustellen, dass verschiedene Clients sich bei Ihrem Server mit einem gemeinsamen Benutzernamen und einer gemeinsamen Passphrase authentifizieren können.

      Nachdem nun alles installiert ist, fahren wir mit der Erstellung unserer Zertifikate fort.

      Schritt 2 — Erstellen einer Zertifizierungsstelle

      Ein IKEv2-Server erfordert ein Zertifikat, um sich gegenüber Clients zu identifizieren. Um bei der Erstellung des erforderlichen Zertifikats zu helfen, enthält das Paket strongswan-pki ein Dienstprogramm namens pki zur Generierung einer Zertifizierungsstelle und von Serverzertifikaten.

      Zu Beginn erstellen wir einige Verzeichnisse zum Speichern aller Assets, an denen wir arbeiten möchten. Die Verzeichnisstruktur entspricht einigen der Verzeichnisse in /etc/ipsec.d, wohin wir schließlich alle von uns erstellten Objekte verschieben werden:

      • mkdir -p ~/pki/{cacerts,certs,private}

      Dann sperren wir die Berechtigungen, sodass unsere privaten Dateien von anderen Benutzern nicht gesehen werden können:

      Nachdem wir nun über eine Verzeichnisstruktur verfügen, um alles zu speichern, können wir einen Stammschlüssel generieren. Dies wird ein 4096-Bit-RSA-Schlüssel sein, der zum Signieren unserer Stammzertifizierungsstelle verwendet wird.

      Führen Sie diese Befehle zur Generierung des Schlüssels aus:

      • pki --gen --type rsa --size 4096 --outform pem > ~/pki/private/ca-key.pem

      Danach können wir zur Erstellung unserer Stammzertifizierungsstelle übergehen und den gerade generierten Schlüssel zum Signieren des Stammzertifikats verwenden:

      • pki --self --ca --lifetime 3650 --in ~/pki/private/ca-key.pem
      • --type rsa --dn "CN=VPN root CA" --outform pem > ~/pki/cacerts/ca-cert.pem

      Das Flag --lifetime 3650 wird verwendet, um sicherzustellen, dass das Stammzertifikat der Zertifizierungsstelle für 10 Jahre gültig ist. Das Stammzertifikat einer Stelle ändert sich in der Regel nicht, da es an alle Server und Clients, die darauf angewiesen sind, neu verteilt werden müsste. 10 Jahre ist als ein sicherer Standardwert für die Gültigkeitsdauer.

      Sie können den Wert für den unterscheidenden Namen (Distinguished name, DN) in etwas anderes ändern, wenn Sie möchten. Der gewöhnliche Name (Common Name) (CN-Feld) ist hier nur der Indikator, sodass er mit nichts in Ihrer Infrastruktur übereinstimmen muss.

      Nachdem wir nun unsere Stammzertifizierungsstelle eingerichtet haben, können wir ein Zertifikat erstellen, das der VPN-Server verwenden wird.

      Schritt 3 — Erstellen eines Zertifikats für den VPN-Server

      Wir erstellen nun ein Zertifikat und einen Schlüssel für den VPN-Server. Dieses Zertifikat ermöglicht es dem Client, die Authentifizierung des Servers mit dem gerade generierten CA-Zertifikat zu überprüfen.

      Erstellen Sie zunächst einen privaten Schlüssel für den VPN-Server mit dem folgenden Befehl:

      • pki --gen --type rsa --size 4096 --outform pem > ~/pki/private/server-key.pem

      Erstellen und signieren Sie nun das VPN-Serverzertifikat mit dem Schlüssel der Zertifizierungsstelle, den Sie im vorherigen Schritt erstellt haben. Führen Sie den folgenden Befehl aus, ändern Sie jedoch den Common Name (CN) und das Feld Subject Alternate Name (SAN) in den DNS-Namen oder die IP-Adresse Ihres VPN-Servers:

      • pki --pub --in ~/pki/private/server-key.pem --type rsa
      • | pki --issue --lifetime 1825
      • --cacert ~/pki/cacerts/ca-cert.pem
      • --cakey ~/pki/private/ca-key.pem
      • --dn "CN=server_domain_or_IP" --san server_domain_or_IP
      • --flag serverAuth --flag ikeIntermediate --outform pem
      • > ~/pki/certs/server-cert.pem

      Anmerkung: Wenn Sie anstelle eines DNS-Namens eine IP-Adresse verwenden, müssen mehrere --san Einträge angegeben werden. Die Zeile im vorherigen Befehlsblock, in dem Sie den Distinguished Name (--dn ...) angeben, muss mit dem zusätzlichen Eintrag wie die folgende Auszugszeile modifiziert werden:

      --dn "CN=IP address --san @IP_address --san IP_address 
      

      Der Grund für diesen zusätzlichen Eintrag --san @IP_address ist, dass einige Clients prüfen, ob das TLS-Zertifikat sowohl über einen DNS-Eintrag als auch einen IP-Adressen-Eintrag für einen Server verfügt, wenn sie seine Identität überprüfen.

      Die Option –--flag serverAuth wird verwendet, um anzugeben, dass das Zertifikat explizit für die Serverauthentifizierung verwendet wird, bevor der verschlüsselte Tunnel hergestellt wird. Die Option --flag ikeIntermediate wird zur Unterstützung älterere MacOS-Clients verwendet.

      Nachdem wir nun alle TLS/SSL-Dateien erzeugt haben, die StrongSwan benötigt, können wir die Dateien in das Verzeichnis /etc/ipsec.d verschieben, indem wir Folgendes eingeben:

      • sudo cp -r ~/pki/* /etc/ipsec.d/

      In diesem Schritt haben wir ein Zertifikatpaar erstellt, das zur Sicherung der Kommunikation zwischen dem Client und dem Server verwendet wird. Wir haben die Zertifikate auch mit dem CA-Schlüssel signiert, sodass der Client die Authentifizierung des VPN-Servers mit dem CA-Zertifikat überprüfen kann. Nachdem nun alle diese Zertifikate fertig sind, gehen wir zur Konfiguration der Software über.

      Schritt 4 — Konfigurieren von StrongSwan

      StrongSwan hat eine Standardkonfigurationsdatei mit einigen Beispielen, aber wir werden die Konfiguration größtenteils selbst vornehmen müssen. Lassen Sie uns die Datei als Referenz sichern, bevor wir von Grund auf starten:

      • sudo mv /etc/ipsec.conf{,.original}

      Erstellen und öffnen Sie eine neue leere Konfigurationsdatei mit Ihrem bevorzugten Texteditor. Wir verwenden hier nano:

      • sudo nano /etc/ipsec.conf

      Anmerkung: Während Sie diesen Abschnitt zur Konfiguration des Serverteils Ihres VPNs durcharbeiten, werden Sie auf Einstellungen stoßen, die sich auf die linke und die rechte Seite einer Verbindung beziehen. Bei der Arbeit mit IPSec bezieht sich die linke Seite per Konvention auf das lokale System, das Sie konfigurieren, in diesem Fall den Server. Die Anweisungen der rechten Seite in diesen Einstellungen beziehen sich auf entfernte Clients wie Telefone und andere Computer.

      Wenn Sie später in diesem Tutorial mit der Konfiguration von Clients fortfahren, beziehen sich die Client-Konfigurationsdateien mit verschiedenen linken Anweisungen auf sich selbst, und der Server wird mit der Terminologie der rechten Seite bezeichnet.

      Zuerst weisen wir StrongSwan an, den Daemon-Status zur Fehlersuche zu protokollieren und doppelte Verbindungen zulassen. Fügen Sie der Datei diese Zeilen hinzu:

      /etc/ipsec.conf

      config setup
          charondebug="ike 1, knl 1, cfg 0"
          uniqueids=no
      

      Dann erstellen wir einen Konfigurationsabschnitt für unser VPN. Außerdem weisen wir StrongSwan an, IKEv2 VPN-Tunnel zu erstellen und diesen Konfigurationsabschnitt automatisch beim Starten zu laden. Fügen Sie der Datei folgende Zeilen an:

      /etc/ipsec.conf

      . . .
      conn ikev2-vpn
          auto=add
          compress=no
          type=tunnel
          keyexchange=ikev2
          fragmentation=yes
          forceencaps=yes
      

      Wir konfigurieren ebenfalls die Dead-Peer-Erkennung, um alle „unreferenzierten“ Verbindungen zu löschen, falls der Client die Verbindung unerwartet trennt. Fügen Sie diese Zeilen hinzu:

      /etc/ipsec.conf

      . . .
      conn ikev2-vpn
          . . .
          dpdaction=clear
          dpddelay=300s
          rekey=no
      

      Als Nächstes konfigurieren wir die IPSec-Parameter der „linken“ Seite des Servers. Jede der folgenden Parameter stellt sicher, dass der Server für die Annahme von Verbindungen von Clients und für seine korrekte Identifizierung konfiguriert ist. Sie fügen jede dieser Einstellungen der Datei /etc/ipsec.conf hinzu, sobald Sie sich damit vertraut gemacht haben, was sie sind und warum sie verwendet werden:

      • left =%any Der Wert %any stellt sicher, dass der Server die Netzwerkschnittstelle, an der er eingehende Verbindungen empfängt, für die nachfolgende Kommunikation mit Clients verwendet. Wenn Sie beispielsweise einen Client über ein privates Netzwerk verbinden, verwendet der Server für den Rest der Verbindung die private IP-Adresse, an der er den Datenverkehr empfängt.
      • leftid=@server_domain_or_IP Diese Option steuert den Namen, den der Server den Clients präsentiert. In Kombination mit der nächsten Option leftcert, stellt die Option leftid sicher, dass der konfigurierte Name des Servers und der im öffentlichen Zertifikat enthaltene Dinstinguished Name (DN) übereinstimmen.
      • leftcert=server-cert.pem Diese Option ist der Pfad zum öffentlichen Zertifikat für den Server, den Sie in Schritt 3 konfiguriert haben. Ohne ihn kann sich der Server nicht bei Clients authentifizieren und die Aushandlung der IKEv2-Einrichtung nicht beenden.
      • leftsendcert=always Der Wert always stellt sicher, dass jeder Client, der sich mit dem Server verbindet, als Teil des anfänglichen Verbindungsaufbaus immer eine Kopie des öffentlichen Zertifikats des Servers erhält.
      • leftsubnet=0.0.0.0/0 Die letzte Option der „linken“ Seite, die Sie hinzufügen werden, informiert Clients über die Subnetze, die hinter dem Server erreichbar sind. In diesem Fall wird 0.0.0.0/0 verwendet, um den gesamten Satz der IPv4-Adressen zu repräsentieren, was bedeutet, dass der Server Clients standardmäßig anweist, ihren gesamten Datenverkehr über das VPN zu senden.

      Nachdem Sie nun mit jeder der entsprechenden Optionen der „linken“ Seite vertraut sind, fügen Sie sie alle wie folgt zur Datei hinzu:

      /etc/ipsec.conf

      . . .
      conn ikev2-vpn
          . . .
          left=%any
          leftid=@server_domain_or_IP
          leftcert=server-cert.pem
          leftsendcert=always
          leftsubnet=0.0.0.0/0
      

      Anmerkung: Geben Sie bei der Konfiguration der Server-ID (leftid) das @-Zeichen nur dann an, wenn Ihr VPN-Server durch einen Domänennamen identifiziert werden soll:

      /etc/ipsec.conf

          . . .    leftid=@vpn.example.com
          . . .
      

      Wenn der Server durch seine IP-Adresse identifiziert werden soll, geben Sie einfach die IP-Adresse ein:

      /etc/ipsec.conf

          . . .
          leftid=your_server_ip
          . . .
      

      Als Nächstes können wir die IPSec-Parameter der „rechten“ Seite des Clients konfigurieren. Jede der folgenden Parameter teilt dem Server mit, wie Verbindungen von Clients akzeptiert werden sollen, wie sich Clients beim Server authentifizieren sollen und welche privaten IP-Adressbereiche und DNS-Server diese Clients verwenden werden. Fügen Sie jede dieser Einstellungen der Datei /etc/ipsec.conf hinzu, sobald Sie sich damit vertraut gemacht haben, was sie sind und warum sie verwendet werden:

      • right=%any Die Option %any für die rechte Seite der Verbindung weist den Server an, eingehende Verbindungen von jedem Remote-Client anzunehmen.
      • rightid=%any Diese Option stellt sicher, dass der Server keine Verbindungen von Clients ablehnt, die eine Identität angeben, bevor der verschlüsselte Tunnel hergestellt ist.
      • rightauth=eap-mschapv2 Diese Option konfiguriert die Authentifizierungsmethode, die Clients zur Authentifizierung gegenüber dem Server verwenden werden. eap-mschapv2 wird hier für eine breite Kompatibilität verwendet, um Clients wie Windows-, MacOS- und Android-Geräte zu unterstützen.
      • rightsourceip=10.10.10.0/24 Diese Option weist den Server an, Clients private IP-Adressen aus dem angegebenen IP-Pool 10.10.10.0/24 zuzuweisen.
      • rightdns=8.8.8.8,8.8.4.4 Diese IP-Adressen sind die öffentlichen DNS-Auflöser von Google. Sie können geändert werden, um andere öffentliche Auflöser, die Auflösung des VPN-Servers oder einen anderen Auflöser zu verwenden, den die Clients erreichen können.
      • rightsendcert=never Diese Option weist den Server an, dass Clients kein Zertifikat senden müssen, um sich selbst zu authentifizieren.

      Nachdem Sie nun mit den erforderlichen Optionen der „rechten“ Seite vertraut sind, fügen Sie die folgenden Zeilen in /etc/ipsec.conf ein:

      /etc/ipsec.conf

      . . .
      conn ikev2-vpn
          . . .
          right=%any
          rightid=%any
          rightauth=eap-mschapv2
          rightsourceip=10.10.10.0/24
          rightdns=8.8.8.8,8.8.4.4
          rightsendcert=never
      

      Nun werden wir StrongSwan anweisen, den Client beim Verbindungsaufbau nach den Anmeldedaten der Benutzer zu fragen:

      /etc/ipsec.conf

      . . .
      conn ikev2-vpn
          . . .
          eap_identity=%identity
      

      Zum Schluss fügen Sie die folgenden Zeilen hinzu, um Linux-, Windows-, macOS-, iOS- und Android-Clients zu unterstützen. Diese Zeilen spezifizieren die verschiedenen Schlüsselaustausch-, Hashing-, Authentifizierungs- und Verschlüsselungsalgorithmen (allgemein als Cipher Suites bezeichnet), die StrongSwan den verschiedenen Clients zur Verfügung stellt:

      /etc/ipsec.conf

      . . .
      conn ikev2-vpn
          . . .
          ike=chacha20poly1305-sha512-curve25519-prfsha512,aes256gcm16-sha384-prfsha384-ecp384,aes256-sha1-modp1024,aes128-sha1-modp1024,3des-sha1-modp1024!
          esp=chacha20poly1305-sha512,aes256gcm16-ecp384,aes256-sha256,aes256-sha1,3des-sha1!
      

      Jede unterstützte Cipher Suite wird durch ein Komma von den anderen abgegrenzt. Beispielsweise ist chacha20poly1305-sha512-curve25519-prfsha512 eine Suite, und aes256gcm16-sha384-prfsha384-ecp384 ist eine andere. Die hier aufgelisteten Cipher Suits sind so ausgewählt, dass sie die größtmögliche Kompatibilität zwischen Windows-, macOS-, iOS-, Android- und Linux-Clients gewährleisten.

      Die vollständige Konfigurationsdatei sollte wie folgt aussehen:

      /etc/ipsec.conf

      config setup
          charondebug="ike 1, knl 1, cfg 0"
          uniqueids=no
      
      conn ikev2-vpn
          auto=add
          compress=no
          type=tunnel
          keyexchange=ikev2
          fragmentation=yes
          forceencaps=yes
          dpdaction=clear
          dpddelay=300s
          rekey=no
          left=%any
          leftid=@server_domain_or_IP
          leftcert=server-cert.pem
          leftsendcert=always
          leftsubnet=0.0.0.0/0
          right=%any
          rightid=%any
          rightauth=eap-mschapv2
          rightsourceip=10.10.10.0/24
          rightdns=8.8.8.8,8.8.4.4
          rightsendcert=never
          eap_identity=%identity
          ike=chacha20poly1305-sha512-curve25519-prfsha512,aes256gcm16-sha384-prfsha384-ecp384,aes256-sha1-modp1024,aes128-sha1-modp1024,3des-sha1-modp1024!
          esp=chacha20poly1305-sha512,aes256gcm16-ecp384,aes256-sha256,aes256-sha1,3des-sha1!
      

      Speichern und schließen Sie die Datei, nachdem Sie überprüft haben, dass Sie jede Zeile korrekt hinzugefügt haben. Wenn Sie nano verwendet haben, drücken Sie STRG+X, Y, dann die EINGABETASTE.

      Nachdem wir nun die VPN-Parameter konfiguriert haben, gehen wir zur Erstellung eines Kontos über, damit unsere Benutzer eine Verbindung zum Server herstellen können.

      Schritt 5 — Konfigurieren der VPN-Authentifizierung

      Unser VPN-Server ist nun so konfiguriert, dass er Client-Verbindungen akzeptiert, aber wir haben noch keine Anmeldedaten konfiguriert. Wir müssen einige Dinge in einer speziellen Konfigurationsdatei namens ipsec.secrets konfigurieren:

      • Wir müssen StrongSwan mitteilen, wo der private Schlüssel für unser Serverzertifikat zu finden ist, damit sich der Server gegenüber den Clients authentifizieren kann.
      • Außerdem müssen wir eine Liste von Benutzern erstellen, die eine Verbindung mit dem VPN herstellen dürfen.

      Öffnen wie die Datei „Secrets“ zum Bearbeiten:

      • sudo nano /etc/ipsec.secrets

      Zuerst teilen wir StrongSwan mit, wo unser privater Schlüssel zu finden ist:

      /etc/ipsec.secrets

      : RSA "server-key.pem"
      

      Dann definieren wir die Anmeldedaten des Benutzers. Sie können jede beliebige Kombination von Benutzername und Passwort zusammenstellen, die Ihnen gefällt:

      /etc/ipsec.secrets

      your_username : EAP "your_password"
      

      Speichern und schließen Sie die Datei. Nachdem wir die Arbeit mit den VPN-Parametern beendet haben, starten wir den VPN-Dienst neu, damit unsere Konfiguration übernommen wird:

      • sudo systemctl restart strongswan-starter

      Nachdem der VPN-Server nun sowohl mit den Serveroptionen als auch mit den Anmeldedaten der Benutzer vollständig konfiguriert ist, ist es an der Zeit, mit der Konfiguration des wichtigsten Teils fortzufahren: der Firewall.

      Schritt 6 — Konfigurieren der Firewall & Kernel-IP-Weiterleitung

      Nachdem die Konfiguration von StrongSwan abgeschlossen ist, müssen wir die Firewall so konfigurieren, dass sie VPN-Verkehr durchlässt und weiterleitet.

      Wenn Sie dem Tutorial zur Ersteinrichtung des Servers gefolgt sind, sollten Sie eine UFW-Firewall aktiviert haben. Wenn Sie UFW noch nicht konfiguriert haben, sollten Sie zunächst mit dem Hinzufügen einer Regel beginnen, um SSH-Verbindungen durch die Firewall zuzulassen, damit Ihre aktuelle nicht geschlossen wird, wenn Sie UFW aktivieren:

      Aktivieren Sie dann die Firewall durch folgende Eingabe:

      Fügen Sie dann eine Regel hinzu, um den UDP-Verkehr zu den IPSec-Standardports 500 und 4500 zulassen:

      • sudo ufw allow 500,4500/udp

      Als Nächstes öffnen wir eine der Konfigurationsdateien von UFW, um einige niedrigstufige Richtlinien für das Routing und die Weiterleitung von IPSec-Paketen hinzuzufügen. Zuvor müssen wir jedoch herausfinden, welche Netzwerkschnittstelle auf unserem Server für den Internetzugang verwendet wird. Finden Sie diese Schnittstelle, indem Sie das mit der Standardroute verknüpfte Gerät abfragen:

      Ihre öffentliche Schnittstelle sollte dem Wort „dev“ folgen. Dieses Ergebnis zeigt beispielsweise die im folgenden Beispiel hervorgehobene Schnittstelle eth0 an:

      Output

      default via your_server_ip dev eth0 proto static

      Wenn Sie Ihre öffentliche Netzwerkschnittstelle haben, öffnen Sie die Datei /etc/ufw/before.rules in Ihrem Texteditor. Die Regeln in dieser Datei werden der Firewall vor den übrigen üblichen Eingabe- und Ausgaberegeln hinzugefügt. Sie werden verwendet, um die Netzwerkadressübersetzung (Network Address Translation, NAT) zu konfigurieren, damit der Server Verbindungen zu und von Clients und dem Internet korrekt weiterleiten kann.

      • sudo nano /etc/ufw/before.rules

      Fügen Sie am Anfang der Datei (vor der Zeile *filter) den folgenden Konfigurationsblock hinzu. Ändern Sie jede Instanz von eth0 in der obigen Konfiguration so, dass sie mit dem Schnittstellennamen übereinstimmt, den Sie mit ip route gefunden haben. Die Zeilen *nat erstellen Regeln, damit die Firewall den Datenverkehr zwischen den VPN-Clients und dem Internet korrekt weiterleiten und manipulieren kann. Die Zeile *mangle passt die maximale Paketsegmentgröße an, um potenzielle Probleme mit bestimmten VPN-Clients zu verhindern:

      /etc/ufw/before.rules

      *nat
      -A POSTROUTING -s 10.10.10.0/24 -o eth0 -m policy --pol ipsec --dir out -j ACCEPT
      -A POSTROUTING -s 10.10.10.0/24 -o eth0 -j MASQUERADE
      COMMIT
      
      *mangle
      -A FORWARD --match policy --pol ipsec --dir in -s 10.10.10.0/24 -o eth0 -p tcp -m tcp --tcp-flags SYN,RST SYN -m tcpmss --mss 1361:1536 -j TCPMSS --set-mss 1360
      COMMIT
      
      *filter
      :ufw-before-input - [0:0]
      :ufw-before-output - [0:0]
      :ufw-before-forward - [0:0]
      :ufw-not-local - [0:0]
      . . .
      

      Fügen Sie als Nächstes nach den Zeilen *filter und Kettendefinitionen einen weiteren Konfigurationsblock hinzu:

      /etc/ufw/before.rules

      . . .
      *filter
      :ufw-before-input - [0:0]
      :ufw-before-output - [0:0]
      :ufw-before-forward - [0:0]
      :ufw-not-local - [0:0]
      
      -A ufw-before-forward --match policy --pol ipsec --dir in --proto esp -s 10.10.10.0/24 -j ACCEPT
      -A ufw-before-forward --match policy --pol ipsec --dir out --proto esp -d 10.10.10.0/24 -j ACCEPT
      

      Diese Zeilen weisen die Firewall an, den ESP-Datenverkehr (Encapsulating Security Payload-Datenverkehr) weiterzuleiten, sodass die VPN-Clients eine Verbindung herstellen können. ESP bietet für unsere VPN-Pakete zusätzliche Sicherheit, da sie nicht vertrauenswürdige Netzwerke durchqueren.

      Wenn Sie fertig sind, speichern und schließen Sie die Datei, nachdem Sie überprüft haben, dass Sie jede Zeile korrekt hinzugefügt haben. Wenn Sie nano verwendet haben, drücken Sie STRG+X, Y, dann die EINGABETASTE.

      Vor dem Neustart der Firewall werden wir einige Netzwerk-Kernel-Parameter ändern, um die Weiterleitung von einer Schnittstelle zu einer anderen zu ermöglichen. Die Datei, die diese Einstellungen steuert, heißt /etc/ufw/sysctl.conf. In dieser Datei müssen wir einige Dinge konfigurieren.

      Zuerst muss die IPv4-Paketweiterleitung eingeschaltet werden, damit der Datenverkehr zwischen dem VPN und den öffentlich zugänglichen Netzwerkschnittstellen auf dem Server ausgetauscht werden kann. Als Nächstes deaktivieren wir die Path-MTU-Erkennung, um Probleme mit der Paketfragmentierung zu verhindern. Abschließend werden wir weder ICMP-Weiterleitungen akzeptieren noch ICMP-Weierleitungen senden, um Man-in-the-Middle-Angriffe zu verhindern.

      Öffnen Sie die Konfigurationsdatei der UFW-Kernel-Parameter in nano oder Ihrem bevorzugten Texteditor:

      • sudo nano /etc/ufw/sysctl.conf

      Fügen Sie nun am Ende der Datei die folgende Einstellung net/ipv4/ip_forward=1 hinzu, um die Weiterleitung von Paketen zwischen Schnittstellen zu ermöglichen:

      /etc/ufw/sysctl.conf

      . . .
      net/ipv4/ip_forward=1
      

      Blockieren Sie als Nächstes das Senden und Empfangen von ICMP-Umleitungspaketen, indem Sie die folgenden Zeilen am Ende der Datei hinzufügen:

      /etc/ufw/sysctl.conf

      . . .
      net/ipv4/conf/all/accept_redirects=0
      net/ipv4/conf/all/send_redirects=0
      

      Deaktivieren Sie abschließend die Path-MTU-Erkennung, indem Sie diese Zeile am Ende der Datei hinzufügen:

      /etc/ufw/sysctl.conf

      . . .
      net/ipv4/ip_no_pmtu_disc=1
      

      Speichern Sie die Datei, wenn Sie fertig sind. Jetzt können wir alle unsere Änderungen durch Deaktivieren und erneutes Aktivieren der Firewall aktivieren, da UFW diese Einstellungen bei jedem Neustart anwendet:

      • sudo ufw disable
      • sudo ufw enable

      Sie werden dazu aufgefordert, den Vorgang zu bestätigen. Geben Sie Y ein, um UFW mit den neuen Einstellungen erneut zu aktivieren.

      Schritt 7 — Testen der VPN-Verbindung unter Windows, macOS, Ubuntu, iOS und Android

      Nachdem nun alles eingerichtet ist, ist es Zeit, es auszuprobieren. Zuerst müssen Sie das von Ihnen erstellte CA-Zertifikat kopieren und auf Ihrem/Ihren Client-Gerät(en) installieren, das/die sich mit Ihrem Server verbindet/verbinden. Am einfachsten geht das, indem Sie sich bei Ihrem Server anmelden und den Inhalt der Zertifikatsdatei ausgeben:

      • cat /etc/ipsec.d/cacerts/ca-cert.pem

      Sie sehen eine Ausgabe, die dieser ähnelt:

      Output

      -----BEGIN CERTIFICATE----- MIIFNDCCAxygAwIBAgIIHCsidG5mXzgwDQYJKoZIhvcNAQEMBQAwODELMAkGA1UE . . . H2YUdz8XNHrJHvMQKWFpi0rlEcMs+MSXPFWE3Q7UbaZJ/h8wpSldSUbQRUlphExJ dJ4PX+MUJO/vjG1/ie6Kh25xbBAc3qNq8siiJZDwrg6vjEK7eiZ1rA== -----END CERTIFICATE-----

      Kopieren Sie diese Ausgabe auf Ihren Computer, einschließlich der Zeilen --BEGIN CERTIFICATE---- und --END CERTIFICATE--, und speichern Sie sie in einer Datei mit einem erkennbaren Namen wie ca-cert.pem. Stellen Sie sicher, dass die von Ihnen erstellte Datei die Erweiterung .pem hat.

      Alternativ können Sie SFTP verwenden, um die Datei auf Ihren Computer zu übertragen.

      Sobald die Datei ca-cert.pem auf Ihren Computer heruntergeladen haben, können Sie die Verbindung zum VPN einrichten.

      Herstellen der Verbindung von Windows

      Es gibt mehrere Möglichkeiten, das Stammzertifikat zu importieren und Windows für die Verbindung mit einem VPN zu konfigurieren. Die erste Methode verwendet grafische Tools für jeden Schritt. Die zweite Methode verwendet PowerShell-Befehle, die in Skripts geschrieben und an Ihre VPN-Konfiguration angepasst werden können.

      Anmerkung: Diese Anweisungen wurden in Windows 10-Installationen getestet, die die Versionen 1903 und 1909 ausführen.

      Konfigurieren von Windows mit grafischen Tools

      Importieren Sie zunächst das Stammzertifikat, indem Sie die folgenden Schritte ausführen:

      1. Drücken Sie WINDOWS+R, um das Dialogfeld Ausführen aufzurufen, und geben Sie mmc.exe zum Starten der Windows Managementkonsole ein.
      2. Navigieren Sie im Menü Datei zu Snap-In hinzufügen oder entfernen, wählen Sie aus der Liste der verfügbaren Snap-Ins Zertifikate aus und klicken Sie auf Hinzufügen.
      3. Wir wollen, dass das VPN mit jedem Benutzer funktioniert, daher wählen wir Computerkonto und klicken auf Weiter.
      4. Wir konfigurieren Dinge auf dem lokalen Computer, daher wählen wir Lokaler Computer und klicken auf Fertigstellen.
      5. Erweitern Sie unter dem Knoten Konsolenstamm den Eintrag Zertifikate (Lokaler Computer), erweitern Sie Vertrauenswürdige Stammzertifizierungsstellen und wählen Sie dann den Eintrag** Zertifikate**: Zertifikatsansicht.

      6. Wählen Sie im Menü Aktion Alle Aufgaben aus und klicken Sie auf Improtieren, um den Assistenten für den Zertifikatimport anzuzeigen. Klicken Sie auf Weiter, um die Einführung zu überspringen.

      7. Klicken Sie auf dem Bildschirm Zu importierende Datei die Schaltfläche Durchsuchen, stellen Sie sicher, dass Sie den Dateityp von „X.509-Zertifikat (.cer;.crt)“ in „Alle Dateien (.)“ ändern und wählen Sie die Datei ca-cert.pem, die Sie gespeichert haben. Klicken Sie dann auf Weiter.

      8. Stellen Sie sicher, dass der Zertifikatspeicher auf Vertrauenswürdige Stammzertifizierungsstellen eingestellt ist und klicken Sie auf Weiter.

      9. Klicken Sie auf Fertigstellen, um das Zertifikat zu importieren.

      Konfigurieren Sie das VPN dann mit diesen Schritten:

      1. Starten Sie die Systemsteuerung, navigieren Sie dann zum Netzwerk- und Freigabecenter.
      2. Klicken Sie auf Einrichten einer neuen Verbindung oder eines neuen Netzwerks und wählen Sie Mit einem Arbeitsplatz verbinden.
      3. Wählen Sie Meine Internetverbindung (VPN) verwenden.
      4. Geben Sie die Details des VPN-Servers ein. Geben Sie den Domänennamen oder die IP-Adresse des Servers in das Feld Internetadresse ein und geben Sie dann den Zielnamen mit einer Beschreibung Ihrer VPN-Verbindung ein. Klicken Sie dann auf Fertig.

      Konfigurieren von Windows mit PowerShell

      Um das Stamm-CA-Zertifikat mit PowerShell zu importieren, öffnen Sie zunächst eine PowerShell-Eingabeaufforderung mit Administratorberechtigungen. Klicken Sie dazu mit der rechten Maustaste auf das Symbol im Startmenü und wählen Sie Windows PowerShell (Admin). Sie können auch eine Eingabeaufforderung als Administrator öffnen und powershell eingeben.

      Als Nächstes importieren wir das Zertifikat mit dem Powershell cmdlet Import-Certificate. Im folgenden Befehl wird mit dem ersten Argument -CertStoreLocation sichergestellt, dass das Zertifikat in dem Speicher der Vertrauenswürdigen Stammzertifizierungsstelle des Computers importiert wird, damit alle Programme und Benutzer das Zertifikat des VPN-Servers überprüfen können. Das Argument -FilePath sollte auf den Speicherort verweisen, in den Sie das Zertifikat kopiert haben. Im folgenden Beispiel lautet der Pfad C:UserssammyDocumentsca-cert.pem. Stellen Sie sicher, dass Sie den Befehl so bearbeiten, dass er mit dem von Ihnen verwendeten Speicherort übereinstimmt.

      • Import-Certificate `
      • -CertStoreLocation cert:LocalMachineRoot `
      • -FilePath C:userssammyDocumentsca-cert.pem

      Der Befehl gibt etwas wie das Folgende aus:

      Output

      PSParentPath: Microsoft.PowerShell.SecurityCertificate::LocalMachineRoot Thumbprint Subject ---------- ------- DB00813B4087E9367861E8463A60CEA0ADC5F002 CN=VPN root CA

      Um nun das VPN mit PowerShell zu konfigurieren, führen Sie den folgenden Befehl aus. Ersetzen Sie den DNS-Namen oder die IP-Adresse Ihres Servers in der Zeile -Serveraddress. Die verschiedenen Flags stellen sicher, dass Windows korrekt mit den entsprechenden Sicherheitsparametern konfiguriert wird, die den Optionen entsprechen, die Sie in /etc/ipsec.conf festgelegt haben.

      • Add-VpnConnection -Name "VPN Connection" `
      • -ServerAddress "server_domain_or_IP" `
      • -TunnelType "IKEv2" `
      • -AuthenticationMethod "EAP" `
      • -EncryptionLevel "Maximum" `
      • -RememberCredential `

      Wenn der Befehl erfolgreich ist, gibt es keine Ausgabe. Um zu bestätigen, dass das VPN richtig konfiguriert ist, verwenden Sie das cmdlet Get-VPNConnection:

      • Get-VpnConnection -Name "VPN Connection"

      Sie erhalten eine Ausgabe wie die folgende:

      Output

      Name : VPN Connection ServerAddress : your_server_ip AllUserConnection : False Guid : {B055A1AB-175C-4028-B4A8-D34309A2B20E} TunnelType : Ikev2 AuthenticationMethod : {Eap} EncryptionLevel : Maximum L2tpIPsecAuth : UseWinlogonCredential : False EapConfigXmlStream : #document ConnectionStatus : Disconnected RememberCredential : True SplitTunneling : False DnsSuffix : IdleDisconnectSeconds : 0

      Standardmäßig wählt Windows ältere und langsamere Algorithmen. Führen Sie das cmdlet Set-VpnConnectionIPsecConfiguration aus, um die Verschlüsselungsparameter zu aktualisieren, die Windows für den IKEv2-Schlüsselaustausch verwendet und um Pakete zu verschlüsseln:

      • Set-VpnConnectionIPsecConfiguration -Name "VPN Connection" `
      • -AuthenticationTransformConstants GCMAES256 `
      • -CipherTransformConstants GCMAES256 `
      • -DHGroup ECP384 `
      • -IntegrityCheckMethod SHA384 `
      • -PfsGroup ECP384 `
      • -EncryptionMethod GCMAES256

      Anmerkung: Wenn Sie die VPN-Verbindung löschen und mit verschiedenen Optionen neu konfigurieren möchten, können Sie das cmdlet Remove-VpnConnection ausführen.

      • Remove-VpnConnection -Name "VPN Connection" -Force

      Das Flag -Force wird übersprungen und Sie werden aufgefordert, das Entfernen zu bestätigen. Wenn Sie versuchen, die VPN-Verbindung mit diesem Befehl zu entfernen, müssen Sie vom VPN getrennt sein.

      Herstellen einer Verbindung mit dem VPN

      Sobald Sie das Zertifikat importiert und das VPN mit einer der beiden Methoden konfiguriert haben, wird Ihre neue VPN-Verbindung unter der Liste der Netzwerke sichtbar. Wählen Sie das VPN und klicken Sie auf Verbinden. Sie werden zur Eingabe Ihres Benutzernamens und Ihres Passworts aufgefordert. Geben Sie sie ein, klicken Sie auf OK, und Sie werden verbunden.

      Herstellen einer Verbindung von macOS

      Folgen Sie diesen Schritten, um das Zertifikat zu importieren:

      1. Doppelklicken Sie auf die Zertifikatsdatei. Keychain Access wird mit einem Dialogfeld eingeblendet, in dem es heißt „Keychain Access is trying to modify the system keychain. Enter your password to allow this.“ (Keychain Access versucht die System-Keychain zu ändern. Geben Sie Ihr Passwort ein, um dies zuzulassen).
      2. Geben Sie Ihr Passwort ein, klicken Sie dann auf Modify Keychain (Keychain ändern)
      3. Doppelklicken Sie auf das neu importierte VPN-Zertifikat. Dadurch wird ein kleines Eigenschaftenfenster eingeblendet, in dem Sie die Vertrauensstufen angeben können. Setzen Sie IP Security (IPSec) auf Always Trust (Immer vertrauen) und Sie werden erneut zur Eingabe Ihres Passworts aufgefordert. Diese Einstellung wird nach der Eingabe des Passworts automatisch gespeichert.

      Nachdem das Zertifikat importiert und vertrauenswürdig ist, konfigurieren Sie die VPN-Verbindung nun mit diesen Schritten:

      1. Gehen Sie zu Systemeinstellungen und wählen Sie Netzwerk.
      2. Klicken Sie auf die kleine „Plus“-Schaltfläche unten links in der Liste der Netzwerke.
      3. Stellen Sie in dem angezeigten Popup-Fenster Schnittstelle auf VPN, setzen Sie den VPN-Typ auf IKEv2 und geben Sie der Verbindung einen Namen.
      4. Geben Sie im Feld Server und Remote ID den Domänennamen oder die IP-Adresse des Servers ein. Lassen Sie Lokale ID leer.
      5. Klicken Sie auf Authentifizierungseinstellungen, wählen Sie Bentuzername und geben Sie Ihren Benutzernamen und Ihr Passwort ein, das Sie für Ihren VPN-Benutzer konfiguriert haben. Klicken Sie dann auf OK.

      Klicken Sie abschließend auf Verbinden, um sich mit dem VPN zu verbinden. Sie sollten nun mit dem VPN verbunden sein.

      Herstellen einer Verbindung von Ubuntu

      Um eine Verbindung von einem Ubuntu-Rechner herzustellen, können Sie StrongSwan als Dienst einrichten und verwalten oder bei jeder gewünschten Verbindung einen einmaligen Befehl verwenden. Für beides stehen Anweisungen zur Verfügung.

      Verwalten von StrongSwan als Dienst

      Um StrongSwan als Dienst zu verwalten, müssen Sie die folgenden Konfigurationsschritte durchführen.

      Aktualisieren Sie zunächst Ihren lokalen Paket-Cache mit apt

      Installieren Sie als Nächstes StrongSwan und die erforderlichen Plugins für die Authentifizierung:

      • sudo apt install strongswan libcharon-extra-plugins

      Jetzt benötigen Sie im Verzeichnis /etc/ipsec.d/cacerts eine Kopie des CA-Zertifikats, damit Ihr Client die Identität des Servers überprüfen kann. Führen Sie den folgenden Befehl aus, um die Datei ca-cert.pem in den richtigen Speicherort zu kopieren:

      • sudo cp /tmp/ca-cert.pem /etc/ipsec.d/cacerts

      Um sicherzustellen, dass das VPN nur bei Bedarf ausgeführt wird, deaktivieren Sie mit systemctl die automatische Ausführung von StrongSwan:

      • sudo systemctl disable --now strongswan-starter

      Konfigurieren Sie als Nächstes den Benutzernamen und das Passwort, das Sie zur Authentifizierung auf dem VPN-Server verwenden werden. Bearbeiten Sie /etc/ipsec.secrets mit nano oder Ihrem bevorzugten Editor:

      • sudo nano /etc/ipsec.conf

      Fügen Sie die folgende Zeile hinzu und bearbeiten Sie die hervorgehobenen Werte für Benutzername und Passwort, damit sie mit denen übereinstimmen, die Sie auf dem Server konfiguriert haben:

      /etc/ipsec.conf

      your_username : EAP "your_password"
      

      Bearbeiten Sie abschließend die Datei /etc/ipsec.conf, um Ihren Client so zu konfigurieren, dass er mit der Konfiguration des Servers übereinstimmt:

      /etc/ipsec.conf

      config setup
      
      conn ikev2-rw
          right=server_domain_or_IP
          # This should match the `leftid` value on your server's configuration
          rightid=server_domain_or_IP
          rightsubnet=0.0.0.0/0
          rightauth=pubkey
          leftsourceip=%config
          leftid=username
          leftauth=eap-mschapv2
          eap_identity=%identity
          auto=start
      

      Um sich mit dem VPN zu verbinden, geben Sie Folgendes ein:

      • sudo systemctl start strongswan-starter

      Um sich wieder zu trennen, geben Sie Folgendes ein:

      • sudo systemctl stop strongswan-starter

      Verwenden des Clients charon-cmd für einmalige Verbindungen

      Um StrongSwan als Dienst zu verwalten, müssen Sie die folgenden Konfigurationsschritte durchführen.

      Aktualisieren Sie zunächst Ihren lokalen Paket-Cache mit apt

      Installieren Sie als Nächstes StrongSwan und die erforderlichen Plugins für die Authentifizierung:

      • sudo apt install strongswan libcharon-extra-plugins

      Jetzt benötigen Sie im Verzeichnis /etc/ipsec.d/cacerts eine Kopie des CA-Zertifikats, damit Ihr Client die Identität des Servers überprüfen kann. Führen Sie den folgenden Befehl aus, um die Datei ca-cert.pem in den richtigen Speicherort zu kopieren:

      • sudo cp /tmp/ca-cert.pem /etc/ipsec.d/cacerts

      Zu diesem Zeitpunkt können Sie sich mit charon-cmd unter Verwendung des CA-Zertifikats des Servers, der IP-Adresse des VPN-Servers und des von Ihnen konfigurierten Benutzernamens mit dem VPN-Server verbinden.

      Führen Sie den folgenden Befehl aus, wann immer Sie eine Verbindung mit dem VPN herstellen möchten:

      • sudo charon-cmd --cert ca-cert.pem --host vpn_domain_or_IP --identity your_username

      Geben Sie, wenn Sie dazu aufgefordert werden, das Passwort des VPN-Benutzers ein und Sie werden mit dem VPN verbunden. Um die Verbindung zu trennen, drücken Sie im Terminal Strg+C und warten Sie, bis die Verbindung geschlossen wird.

      Herstellen einer Verbindung von iOS

      Führen Sie die folgenden Schritte aus, um die VPN-Verbindung auf einem iOS-Gerät zu konfigurieren:

      1. Senden Sie sich selbst eine E-Mail mit dem Stammzertifikat im Anhang.
      2. Öffnen Sie die E-Mail auf Ihrem iOS-Gerät und tippen Sie auf die angehängte Zertifikatdatei, tippen Sie dann auf Installieren und geben Sie Ihren Passcode ein. Sobald diese installiert ist, tippen Sie auf Fertig.
      3. Gehen Sie zu Einstellungen, Allgemein, VPN und tippen Sie auf VPN-Konfiguration hinzufügen. Daraufhin wird der Bildschirm zur Konfiguration der VPN-Verbindung angezeigt.
      4. Tippen Sie auf Typ und wählen Sie IKEv2.
      5. Geben Sie im Feld Beschreibung einen kurzen Namen für die VPN-Verbindung ein. Dieser Name kann beliebig sein.
      6. Geben Sie im Feld Server und Remote ID den Domänennamen oder die IP-Adresse des Servers ein. Das Feld Lokale ID kann leer gelassen werden.
      7. Geben Sie Ihren Benutzernamen und Ihr Passwort in den Abschnitt Authentifizierung ein, und tippen Sie dann auf Fertig.
      8. Wählen Sie die gerade erstellte VPN-Verbindung, tippen Sie auf die Schaltfläche oben auf der Seite und schon sind Sie verbunden.

      Herstellen einer Verbindung von Android

      Folgen Sie diesen Schritten, um das Zertifikat zu importieren:

      1. Senden Sie sich selbst eine E-Mail mit dem CA-Zertifikat im Anhang. Speichern Sie das CA-Zertifikat in Ihrem Download-Ordner.
      2. Laden Sie den StrongSwan VPN-Client aus dem Play-Store herunter.
      3. Öffnen Sie die App. Tippen Sie auf das Symbol “Mehr” () in der rechten oberen Ecke und wählen Sie CA-Zertifikate.
      4. Tippen Sie erneut auf das Symbol “Mehr” () in der rechten oberen Ecke. Wählen Sie Zertifikat importieren.
      5. Navigieren Sie zu der CA-Zertifikatsdatei in Ihrem Donwload-Ordner und wählen Sie sie aus, um sie in die Anwendung zu importieren.

      Nachdem das Zertifikat nun in die StrongSwan-Anwendung importiert wurde, können Sie die VPN-Verbindung mit diesen Schritten konfigurieren:

      1. Tippen Sie oben in der App auf VPN-PROFIL HINZUFÜGEN.
      2. Geben Sie bei Server den Domänennamen oder die öffentliche IP-Adresse Ihres VPN-Servers ein.
      3. Stellen Sie sicher, dass IKEv2 EAP (Benutzername/Passwort) als VPN-Typ ausgewählt ist.
      4. Geben Sie bei Benutzername und Passwort die Anmeldedaten ein, die Sie auf dem Server definiert haben.
      5. Deaktivieren Sie Automatisch auswählen im Abschnitt CA-Zertifikat und klicken Sie auf CA-Zertifikat auswählen.
      6. Tippen Sie auf die Registerkarte IMPORTIERT oben auf dem Bildschirm und wählen Sie die von Ihnen importierte CA (sie heißt „VPN root CA“ wenn Sie den „DN“ nicht zuvor geändert haben).
      7. Wenn Sie möchten, können Sie den Profilnamen (optional) mit einem aussagekräftigeren Namen ausfüllen.

      Wenn Sie eine Verbindung mit dem VPN herstellen möchten, klicken Sie auf das Profil, das Sie gerade in der Anwendung StrongSwan erstellt haben.

      Fehlerbehebung bei Verbindungen

      Wenn Sie das Zertifikat nicht importieren können, stellen Sie sicher, dass die Datei die Erweiterung .pem und nicht .pem.txt hat.

      Wenn Sie keine Verbindung mit dem VPN herstellen können, überprüfen Sie den von Ihnen verwendeten Servernamen oder die IP-Adresse. Der Domänenname oder die IP-Adresse des Servers muss mit dem übereinstimmen, was Sie bei der Erstellung des Zertifikats als Common Name (CN) konfiguriert haben. Wenn sie nicht übereinstimmen, funktioniert die VPN-Verbindung nicht. Wenn Sie beispielsweise ein Zertifikat mit dem CN von vpn.example.com einrichten, müssen Sie vpn.example.com verwenden, wenn Sie die VPN-Serverdetails eingeben. Überprüfen Sie den Befehl, den Sie zum Generieren des Zertifikats verwendet haben, und die Werte, die Sie bei der Erstellung Ihrer VPN-Verbindung verwendet haben.

      Abschließend überprüfen Sie die VPN-Konfiguration, um sicherzustellen, dass der Wert leftid mit dem Symbol @ konfiguriert ist, wenn Sie einen Domänennamen verwenden:

      /etc/ipsec.conf

          leftid=@vpn.example.com
      

      Wenn Sie eine IP-Adresse verwenden, stellen Sie sicher, dass das Symbol @ ausgelassen ist. Stellen Sie außerdem sicher, dass Sie beim Generieren der Datei server-cert.pem die beiden Flags --san @IP_address und --san IP_address eingefügt haben.

      Zusammenfassung

      In diesem Tutorial haben Sie einen VPN-Server erstellt, der das IKEv2-Protokoll verwendet. Sie haben sich mit den Anweisungen vertraut gemacht, die die linke und die rechte Seite einer Verbindung sowohl auf dem Server als auch auf den Clients steuern. Außerdem haben Sie einen Windows-, macOS-, iOS-, Android- oder Linux-Client für die Verbindung mit dem VPN konfiguriert.

      Um Benutzer hinzuzufügen oder zu entfernen, führen Sie erneut Schritt 5 aus. Jede Zeile in /etc/ipsec.secrets ist für einen Benutzer, sodass das Hinzufügen oder Entfernen von Benutzern oder das Ändern von Passwörtern nur die Bearbeitung der Datei erfordert.

      Jetzt können Sie sicher sein, dass Ihre Online-Aktivitäten überall und mit jedem Gerät, das Sie für den Zugang zum Internet benutzen, geschützt bleiben.



      Source link