TOC

So richten Sie einen PageKite-Front-End-Server unter Debian 9 ein

Der Autor hat Open Internet / Free Speech Fund ausgewählt, um eine Spende im Rahmen von https://do.co/w4do-cta zu erhalten [Write for DOnations] program.

Einführung

Private Netzwerke bieten den Hosts im Allgemeinen einen Internetzugang über NAT (Netzwerkadressübersetzung), wobei alle Hosts im privaten Netzwerk eine einzige öffentliche IP-Adresse gemeinsam nutzen. In NAT-Systemen sind die Hosts innerhalb des privaten Netzwerks von außerhalb des Netzwerks nicht sichtbar. Um Dienste, die auf diesen Hosts ausgeführt werden, für das öffentliche Internet verfügbar zu machen, erstellen Sie normalerweise NAT-Regeln im Gateway, die allgemein als Portweiterleitungsregeln bezeichnet werden. In einigen Situationen hätten Sie jedoch keinen Zugriff auf das Gateway, um diese Regeln zu konfigurieren. In solchen Situationen bieten sich Tunneling-Lösungen wie PageKite an.

http://pagekite.net [PageKite] ist eine schnelle und sichere Tunnellösung, mit der ein Dienst in einem privaten Netzwerk für das öffentliche Internet verfügbar gemacht werden kann, ohne dass eine Portweiterleitung erforderlich ist. Zu diesem Zweck wird ein externer Server namens front-end server benötigt, zu dem der Server hinter NAT und die Clients eine Verbindung herstellen, um die Kommunikation zwischen ihnen zu ermöglichen. Standardmäßig verwendet PageKite seinen eigenen kommerziellen Dienst http://pagekite.net [pagekite.net]. Da es sich jedoch um ein vollständig Open-Source-Projekt handelt, können Sie ein privates Frontend auf einem öffentlich zugänglichen Host wie z a DigitalOcean Droplet. Mit diesem Setup können Sie eine herstellerunabhängige Lösung für den Remotezugriff auf Hosts hinter NAT erstellen. Indem Sie die Remote-Hosts mit dem PageKite-Client so konfigurieren, dass sie eine Verbindung zum Frontend herstellen und den SSH-Port freigeben, können Sie über die Befehlszeilenschnittstellenshell mit SSH auf sie zugreifen. Sie können auf eine grafische Benutzeroberfläche auch zugreifen, indem Sie ein Desktopfreigabesystem wie VNC oder RDP ausführen über eine SSH-Verbindung.

In diesem Tutorial installieren und konfigurieren Sie einen PageKite-Front-End-Dienst auf einem Server, auf dem Debian 9 ausgeführt wird. Sie werden auch zwei weitere Debian 9-Server einrichten, um eine lokale und eine entfernte Umgebung zu simulieren. Wenn Sie fertig sind, haben Sie einen Server für mehrere Clients eingerichtet und ihn mit einer praktischen Lösung für den Remotezugriff über SSH und VNC getestet.

Voraussetzungen

Bevor Sie diesem Handbuch folgen, benötigen Sie Folgendes:

  • Ein DigitalOcean account zum Einrichten der Droplets, die im Lernprogramm verwendet werden.

  • Ein Server, auf dem Debian 9 mit einer öffentlichen IP-Adresse als Front-End-Server ausgeführt wird und der gemäß https://www.digitalocean.com/community/tutorials/initial-server-setup-with-debian-9 [eingerichtet wurde. Erstes Server-Setup mit Debian 9]. Ein Standard-DigitalOcean-Droplet mit 1 GB Speicher reicht für Testzwecke oder für Anwendungen mit wenigen Verbindungen. Wir verweisen auf diesen Server mit dem Hostnamen "+ Front-End-Server " und seiner öffentlichen IP-Adresse mit "+".

  • Zwei Hosts unter Debian 9, die die Rolle eines entfernten und lokalen Hosts spielen, der über den PageKite-Dienst eine Verbindung herstellt, werden gemäß https://www.digitalocean.com/community/tutorials/initial-server-setup- eingerichtet. with-debian-9 [Erstes Server-Setup mit Debian 9]. Auf den Remote-Host mit Internetzugang über NAT greift der lokale Host über einen PageKite-Tunnel zu. Auf entfernte und lokale Hosts wird durch die Hostnamen "+ remote-host " und " local-host +" und ihre öffentlichen IP-Adressen durch "" bzw. "" verwiesen. In diesem Lernprogramm werden zwei Standard-DigitalOcean-Droplets mit 1 GB Speicher verwendet, um sie darzustellen. Alternativ könnten zwei lokale oder virtuelle Maschinen verwendet werden, um diese Hosts darzustellen.

  • Ein vollständig registrierter Domainname. In diesem Tutorial wird "++" als Beispiel verwendet. Sie können einen Domain-Namen unter https://namecheap.com [Namecheap] erwerben, einen kostenlosen unter Freenom erhalten oder den Domain-Registrar Ihrer Wahl verwenden .

  • Die beiden folgenden DNS-Einträge wurden für Ihren Server eingerichtet. Unter https://www.digitalocean.com/community/tutorials/an-einführung-zu-digitalocean-dns finden Sie Informationen zum Hinzufügen von DNS.

  • Ein A-Datensatz mit einem "+ pagekit. ", Der auf die IP-Adresse des " Front-End-Servers" verweist.

  • Wir müssen auch DNS einrichten, damit jede Domain, die mit "+ pagekite" endet, auch auf unseren "+ Front-End-Server" verweist. Dies kann mithilfe von Wildcard-DNS-Einträgen eingerichtet werden. Erstellen Sie in diesem Fall einen A-Eintrag für den Platzhalter-DNS-Eintrag "+ *. Pagekite. ", Um auf die gleiche IP-Adresse "+" hinzuweisen. Dies wird verwendet, um die Clients, die eine Verbindung zu unserem Server herstellen, anhand des Domänennamens (z. B. + client-1.pagekite. + Und + client-2.pagekite. +) Zu unterscheiden und die Anforderungen entsprechend zu tunneln.

  • Ein lokaler Computer mit einem installierten VNC-Client, der VNC-Verbindungen über SSH-Tunnel unterstützt.

  • Unter Windows können Sie TightVNC, RealVNC oder UltraVNC verwenden.

  • Unter macOS können Sie das integrierte Programm Screen Sharing oder eine plattformübergreifende App wie diese verwenden RealVNC.

  • Unter Linux können Sie aus vielen Optionen auswählen, darunter https://wiki.gnome.org/Apps/Vinagre [+ vinagre +] und https://kde.org/applications/internet/org.kde.krdc [` + krdc + `], RealVNC oder TightVNC.

Schritt 1 - Einrichten der Server

In diesem Tutorial werden wir drei DigitalOcean Droplets verwenden, um die Rolle des Front-End-Servers, des lokalen Hosts und des Remote-Hosts zu übernehmen. Dazu werden wir zuerst den lokalen Host und den Remote-Host so einstellen, dass sie Zugriff auf die grafische Umgebung haben und das Verhalten eines Remote-Hosts unter NAT nachahmen, so dass PageKite dies kann als Lösung für den Zugriff auf seine Dienste verwendet werden. Außerdem müssen wir die Droplet-Firewall-Regeln für den Front-End-Server konfigurieren, damit er mit PageKite zusammenarbeitet und die Verbindung zwischen dem lokalen Host und dem Remote-Host vermittelt.

Da wir mit mehreren Servern arbeiten, werden wir in den Befehlslisten verschiedene Farben verwenden, um den von uns verwendeten Server wie folgt zu identifizieren:

# Commands and outputs in the front-end-server Droplet
# Commands and outputs in the remote-host Droplet
# Commands and outputs in the local-host Droplet
# Commands and outputs in both the remote-host and local-host Droplets

Führen Sie zunächst die Schritte für die Droplets "+ remote-host " und " local-host +" aus, um die Abhängigkeiten zu installieren und den Zugriff auf die grafische Umgebung mit VNC einzurichten. Danach werden wir die Firewall-Konfiguration in jedem der drei Droplets behandeln, damit der Front-End-Server PageKite ausführen und eine Verbindung mit NAT auf Remote-Host nachahmen kann.

Abhängigkeiten installieren

Wir benötigen Zugriff auf die grafische Oberfläche sowohl auf "+ local-host" als auch auf "+ remote-host" oder "hosts", um diese Demonstration durchführen zu können. Auf "+ local-host " verwenden wir eine VNC-Sitzung, um auf die grafische Oberfläche zuzugreifen und unser Setup mit dem Browser zu testen. Auf " remote-host " richten wir eine VNC-Sitzung ein, auf die wir über " local-host +" zugreifen.

Um VNC einzurichten, müssen zuerst einige Abhängigkeiten von + local-host und` + remote-host` installiert werden. Vor der Installation eines Pakets müssen Sie jedoch die Paketliste der Repositorys aktualisieren, indem Sie auf beiden Servern Folgendes ausführen:

sudo apt-get update

Als Nächstes installieren wir den VNC-Server und eine grafische Benutzerumgebung, die zum Starten einer VNC-Sitzung erforderlich ist. Wir werden den Tight VNC -Server und die Xfce -Desktopumgebung verwenden, die installiert werden kann, indem Folgendes ausgeführt wird:

sudo apt-get install xfce4 xfce4-goodies tightvncserver

Während der Installation der grafischen Umgebung werden wir nach dem Tastaturlayout gefragt, das wir verwenden möchten. Wählen Sie für eine QWERTY US-Tastatur "+ Englisch (US) +".

Zusätzlich benötigen wir auf "+ local-host " einen VNC-Viewer und einen Internetbrowser, um die Verbindung zu " remote-host +" herstellen zu können. In diesem Tutorial werden der Firefox-Webbrowser und der xtightvncviewer installiert. Um sie zu installieren, führen Sie Folgendes aus:

sudo apt-get install firefox-esr xtightvncviewer

Wenn eine grafische Umgebung installiert ist, wird das System standardmäßig im grafischen Modus initialisiert. Über die DigitalOcean-Konsole kann der grafische Anmeldemanager angezeigt werden, es ist jedoch nicht möglich, sich anzumelden oder die Befehlszeilenschnittstelle zu verwenden. In unserem Setup ahmen wir das Netzwerkverhalten so nach, als würden wir NAT verwenden. Dazu müssen wir die DigitalOcean-Konsole verwenden, da wir keine Verbindung über SSH herstellen können. Daher müssen wir die grafische Benutzeroberfläche deaktivieren, damit sie beim Booten nicht automatisch gestartet wird. Dies kann durch Deaktivieren des Anmeldemanagers auf beiden Servern erfolgen:

sudo systemctl disable lightdm.service

Nach dem Deaktivieren des Anmeldemanagers können wir die Droplets neu starten und testen, ob wir uns über die DigitalOcean-Konsole anmelden können. Führen Sie dazu Folgendes aus:

sudo shutdown -r now

Greifen Sie auf die DigitalOcean-Konsole zu, indem Sie in der DigitalOcean-Systemsteuerung zur Droplet-Seite navigieren, Ihr Droplet "+ local-host +" auswählen und auf das Wort "* Console *" in der oberen rechten Ecke neben dem Schalter klicken, um das Droplet zu aktivieren und aus:

image: https://assets.digitalocean.com/articles/cart-64916/DigitalOcean_Control_Panel.png [DigitalOcean Control Panel]

Sobald Sie die Eingabetaste in der Konsole drücken, werden Sie aufgefordert, Ihren Benutzernamen und Ihr Kennwort einzugeben. Geben Sie diese Anmeldeinformationen ein, um die Eingabeaufforderung aufzurufen:

Bild: https://assets.digitalocean.com/articles/cart-64916/DigitalOcean_Droplet_Console.jpg [DigitalOcean Droplet Console]

Wiederholen Sie diesen Vorgang für den "+ local-host on" für den "+ remote-host".

Mit der Konsole für beide Droplets können wir nun den VNC einrichten.

Einrichten von VNC

Hier stellen wir ein grundlegendes VNC-Setup zusammen. Wenn Sie eine ausführlichere Anleitung zur Einrichtung benötigen, lesen Sie unsere https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-vnc-on-debian- 9 [Wie installiert und konfiguriert man VNC unter Debian 9] Tutorial.

Führen Sie zum Starten einer VNC-Sitzung die folgenden Schritte auf den Droplets + local-host und` + remote-host` aus:

vncserver

Bei der ersten Ausführung erstellt das System die Konfigurationsdateien und fragt nach dem Hauptkennwort. Geben Sie Ihr gewünschtes Passwort ein und überprüfen Sie es. Der VNC-Server fragt außerdem nach einem Passwort, das nur zum Anzeigen der VNC-Sitzung eines anderen Benutzers verwendet wird. Da wir keine reine VNC-Sitzung benötigen, geben Sie für diese Eingabeaufforderung "+ n +" ein.

Die Ausgabe sieht ungefähr so ​​aus:

Output@:/home/$ vncserver

You will require a password to access your desktops.

Password:
Verify:
Would you like to enter a view-only password (y/n)? n
xauth:  file /home//.Xauthority does not exist

New 'X' desktop is remote-host:1

Creating default startup script /home//.vnc/xstartup
Starting applications specified in /home//.vnc/xstartup
Log file is /home//.vnc/:1.log

Das ": 1 +" nach dem Hostnamen steht für die Nummer der VNC-Sitzung. Standardmäßig wird die Sitzungsnummer " 1 " an Port " 5901 ", die Sitzungsnummer " 2 " an Port " 5902 " usw. ausgeführt. Nach der vorherigen Ausgabe können wir auf " remote-host " zugreifen, indem wir einen VNC-Client verwenden, um eine Verbindung zu "+" an Port "+ 5901 +" herzustellen.

Ein Problem der vorherigen Konfiguration besteht darin, dass sie nicht dauerhaft ist. Dies bedeutet, dass sie beim Neustart des Droplets nicht standardmäßig gestartet wird. Damit es dauerhaft bleibt, können wir einen Systemd-Dienst erstellen und aktivieren. Dazu erstellen wir die Datei "+ vncserver @ .service " unter " / etc / systemd / system ". Dies kann mit " nano +" geschehen:

sudo nano /etc/systemd/system/[email protected]

Fügen Sie den folgenden Inhalt in die Datei ein und ersetzen Sie "++" durch Ihren Benutzernamen:

/etc/systemd/system/[email protected]

[Unit]
Description=Start TightVNC server at startup
After=syslog.target network.target

[Service]
Type=forking
User=
PAMName=login
PIDFile=/home//.vnc/%H:%i.pid
ExecStartPre=-/usr/bin/vncserver -kill :%i > /dev/null 2>&1
ExecStart=/usr/bin/vncserver -depth 24 -geometry 1280x800 :%i
ExecStop=/usr/bin/vncserver -kill :%i

[Install]
WantedBy=multi-user.target

Diese Datei erstellt eine "+ vncserver " Systemd-Einheit, die mit dem Tool " systemctl " als Systemdienst konfiguriert werden kann. In diesem Fall bricht der Dienst beim Starten die VNC-Sitzung ab, wenn sie bereits ausgeführt wird (Zeile ` ExecStartPre `), und startet eine neue Sitzung mit der Auflösung von ` 1280x800 ` (Zeile ` ExecStart `). Wenn der Dienst beendet wird, bricht er die VNC-Sitzung ab (Zeile ` ExecStop +`).

Speichern Sie die Datei und beenden Sie + nano +. Als Nächstes machen wir das System auf die neue Unit-Datei aufmerksam, indem wir Folgendes ausführen:

sudo systemctl daemon-reload

Aktivieren Sie dann den Dienst, der beim Initialisieren des Servers automatisch gestartet wird, indem Sie Folgendes ausführen:

sudo systemctl enable [email protected]

Wenn wir den Befehl "+ enable " mit " systemctl +" verwenden, werden Symlinks erstellt, damit der Dienst automatisch gestartet wird, wenn das System initialisiert wird, wie aus der Ausgabe des vorherigen Befehls hervorgeht:

OutputCreated symlink /etc/systemd/system/multi-user.target.wants/[email protected] → /etc/systemd/system/[email protected].

Wenn der VNC-Server ordnungsgemäß konfiguriert ist, werden die Droplets möglicherweise neu gestartet, um zu testen, ob der Dienst automatisch gestartet wird:

sudo shutdown -r now

Melden Sie sich nach der Systeminitialisierung mit SSH an und prüfen Sie, ob VNC ausgeführt wird mit:

sudo systemctl status [email protected]

Die Ausgabe zeigt an, dass der Dienst ausgeführt wird:

● [email protected] - Start TightVNC server at startup
  Loaded: loaded (/etc/systemd/system/[email protected]; enabled; vendor preset: enabled)
  Active:  since Thu 2019-08-29 19:21:12 UTC; 1h 22min ago
 Process: 848 ExecStart=/usr/bin/vncserver -depth 24 -geometry 1280x800 :1 (code=exited, status=0/SUCCESS)
 Process: 760 ExecStartPre=/usr/bin/vncserver -kill :1 > /dev/null 2>&1 (code=exited, status=2)
Main PID: 874 (Xtightvnc)
   Tasks: 0 (limit: 4915)
  CGroup: /system.slice/system-vncserver.slice/[email protected]
          ‣ 874 Xtightvnc :1 -desktop X -auth /home/sammy/.Xauthority -geometry 1280x800 -depth 24 -rfbwait

Aug 29 19:21:10 remote-host systemd[1]: Starting Start TightVNC server at startup...
Aug 29 19:21:10 remote-host systemd[760]: pam_unix(login:session): session opened for user sammy by (uid=0)
Aug 29 19:21:11 remote-host systemd[848]: pam_unix(login:session): session opened for user sammy by (uid=0)
Aug 29 19:21:12 remote-host systemd[1]: Started Start TightVNC server at startup.
~

Damit ist die VNC-Konfiguration abgeschlossen. Denken Sie daran, die vorherigen Schritte auf "+ remote-host" und "+ localhost" auszuführen. Betrachten wir nun die Firewall-Konfigurationen für jeden Host.

Firewall konfigurieren

Beginnend mit dem "+ remote-host " konfigurieren wir die Firewall so, dass externe Verbindungen zu den Droplets-Diensten verweigert werden, um das Verhalten hinter NAT nachzuahmen. In diesem Tutorial werden wir den Port " 8000 " für HTTP-Verbindungen, " 22 " für SSH und " 5901 +" für VNC verwenden, sodass die Firewall so konfiguriert wird, dass externe Verbindungen zu diesen Ports verweigert werden.

Wenn Sie dem initial setup for Debian 9 folgen, wird + remote-host + eine Firewall-Regel haben, um Verbindungen zuzulassen zu SSH. Wir können diese Regel überprüfen, indem wir Folgendes ausführen:

sudo ufw status verbose

Die Ausgabe wird wie folgt sein:

OutputStatus: active
Logging: on (low)
Default: deny (incoming), allow (outgoing), disabled (routed)
New profiles: skip

To                         Action      From
--                         ------      ----
22/tcp (OpenSSH)           ALLOW IN    Anywhere
22/tcp (OpenSSH (v6))      ALLOW IN    Anywhere (v6)

Entfernen Sie diese SSH-Regeln, um das Verhalten hinter NAT nachzuahmen.

Um den SSH-Zugriff zu verweigern, verwenden Sie "+ ufw +" und führen Sie Folgendes aus:

sudo ufw delete allow OpenSSH

Wir können überprüfen, ob die SSH-Regeln entfernt wurden, indem wir den Status der Firewall erneut überprüfen:

sudo ufw status verbose

In der Ausgabe werden keine Firewall-Regeln angezeigt, wie im Folgenden dargestellt:

OutputStatus: active
Logging: on (low)
Default: deny (incoming), allow (outgoing), disabled (routed)
New profiles: skip

Obwohl die Firewall konfiguriert ist, wird die neue Konfiguration erst ausgeführt, wenn wir sie aktivieren mit:

sudo ufw enable

Beachten Sie, dass wir nach der Aktivierung nicht mehr über SSH auf "+ remote-host" zugreifen können, wie in der Ausgabe des Befehls angegeben:

OutputCommand may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Melden Sie sich vom "+ remote-host " ab und testen Sie die Konfiguration, indem Sie versuchen, eine SSH- oder VNC-Verbindung herzustellen. Es wird nicht möglich sein. Von nun an können wir ausschließlich über die DigitalOcean-Konsole auf " remote-host +" zugreifen.

Auf + local-host + lassen wir die SSH-Ports offen. Wir benötigen nur eine Firewall-Regel, um den Zugriff auf die VNC-Sitzung zu ermöglichen:

sudo ufw allow 5901

Aktivieren Sie die Firewall-Regeln, nachdem Sie sie geändert haben, indem Sie Folgendes ausführen:

sudo ufw enable

Jetzt können wir die VNC-Verbindung unter Verwendung der https://www.digitalocean.com/community/tutorials/how-to-set-up-a-pagekite-front-end-server-on-a-debian-9#voraussetzungen testen [Voraussetzung für den VNC-Client auf Ihrem lokalen Computer], um über das von Ihnen eingerichtete VNC-Kennwort eine Verbindung zu "+ local-host " an Port " 5901 +" herzustellen.

Öffnen Sie dazu Ihren VNC-Client und stellen Sie eine Verbindung zu +: 5901 + her. Sobald Sie das Passwort eingegeben haben, stellen Sie eine Verbindung zur VNC-Sitzung her.

Beim ersten Start fragt Xfce nach der Ersteinrichtung der Umgebung:

image: https://assets.digitalocean.com/articles/cart-64916/Initial_Xfce_Configuration.png [Xfce-Erstkonfiguration]

Wählen Sie für dieses Tutorial die Option * Use default config *.

Schließlich müssen wir Verbindungen zu Port "+ 80 " auf dem " Front-End-Server" zulassen, der von PageKite verwendet wird. Öffnen Sie ein Terminal auf "+ Front-End-Server +" und verwenden Sie den folgenden Befehl:

sudo ufw allow 80

Erlauben Sie zusätzlich den Datenverkehr auf Port + 443 + für HTTPS:

sudo ufw allow 443

Führen Sie Folgendes aus, um die neue Firewall-Konfiguration zu aktivieren:

sudo ufw enable

Nachdem wir die Droplets eingerichtet haben, konfigurieren wir den PageKite-Front-End-Server.

Schritt 2 - Installieren von PageKite auf dem Front-End-Server

Obwohl es möglich ist, PageKite mit einem Python-Skript zum Einrichten des Front-End-Servers auszuführen, ist es zuverlässiger, es mit einem Systemdienst auszuführen. Dazu müssen wir PageKite auf dem Server installieren.

Der empfohlene Weg, einen Dienst auf einem Debian-Server zu installieren, ist die Verwendung eines distribution package. Auf diese Weise können automatische Updates abgerufen und der Dienst so konfiguriert werden, dass er beim Start gestartet wird.

Zuerst konfigurieren wir das Repository, um PageKite zu installieren. Aktualisieren Sie dazu die Paketliste der Repositorys:

sudo apt-get update

Installieren Sie nach Abschluss der Aktualisierung das Paket https://packages.debian.org/stretch/dirmngr [+ dirmngr +], das für den Schlüsselringimport aus dem PageKite-Repository erforderlich ist, um eine sichere Installation zu gewährleisten:

sudo apt-get install dirmngr

Fügen Sie anschließend das Repository zur Datei "+ /etc/appt/sources.list" hinzu, indem Sie Folgendes ausführen:

echo deb http://pagekite.net/pk/deb/ pagekite main | sudo tee -a /etc/apt/sources.list

Importieren Sie nach dem Einrichten des Repository den PageKite-Paketschlüssel in unseren vertrauenswürdigen Schlüsselsatz, damit wir Pakete aus diesem Repository installieren können. Die Verwaltung der Paketschlüssel erfolgt mit dem Dienstprogramm + apt-key +. In diesem Fall müssen wir den Schlüssel "+ AED248B1C7B2CAC3 " vom Schlüsselserver " keys.gnupg.net +" importieren.

sudo apt-key adv --recv-keys --keyserver keys.gnupg.net AED248B1C7B2CAC3

Aktualisieren Sie als Nächstes die Paketlisten der Repositorys erneut, sodass das Paket + pagekite + indiziert wird:

sudo apt-get update

Zum Schluss installieren Sie es mit:

sudo apt-get install pagekite

Nachdem wir PageKite installiert haben, richten wir den Front-End-Server ein und konfigurieren den Dienst so, dass er beim Booten ausgeführt wird.

Schritt 3 - Konfigurieren des Front-End-Servers

Mit dem soeben installierten PageKite-Paket können Sie eine Verbindung zu einem PageKite-Front-End-Server konfigurieren. Es kann auch verwendet werden, um einen Front-End-Dienst für den Empfang von PageKite-Verbindungen einzurichten, was wir hier tun möchten. Dazu müssen wir die Konfigurationsdateien von PageKite bearbeiten.

PageKite speichert seine Konfigurationsdateien im Verzeichnis "+ / etc / pagekite.d ". Die erste Änderung besteht darin, alle Zeilen in der Datei " / etc / pagekite.d / 10_account.rc " zu deaktivieren, da diese Datei nur verwendet wird, wenn PageKite als Client für die Verbindung mit einem Front-End-Server eingerichtet ist . Wir können die Datei mit ` nano +` bearbeiten:

sudo nano /etc/pagekite.d/10_account.rc

Um die Zeilen zu deaktivieren, fügen Sie ein "+ # +" hinzu, um die aktiven Zeilen der Datei zu deaktivieren:

/etc/pagekite.d/10_account.rc

#################################[ This file is placed in the Public Domain. ]#
# Replace the following with your account details.

kitename   = NAME.pagekite.me
kitesecret = YOURSECRET

# Delete this line!
abort_not_configured

Speichern Sie die Änderungen und beenden Sie "+ nano ". Bearbeiten Sie als nächstes die Datei ` / etc / pagekite.d / 20_frontends.rc +`:

sudo nano /etc/pagekite.d/20_frontends.rc

Fügen Sie der Datei die folgenden hervorgehobenen Zeilen hinzu und kommentieren Sie die Zeile "+ Defaults +" aus. Ersetzen Sie dabei "" durch den von Ihnen verwendeten Domainnamen und "" durch ein Passwort Ihrer Wahl:

/etc/pagekite.d/20_frontends.rc

#################################[ This file is placed in the Public Domain. ]#
# Front-end selection
#
# Front-ends accept incoming requests on your behalf and forward them to
# your PageKite, which in turn forwards them to the actual server.  You
# probably need at least one, the service defaults will choose one for you.

# Use the pagekite.net service defaults.
defaults

# If you want to use your own, use something like:
#     frontend = hostname:port
# or:
#     frontends = COUNT:dnsname:port

Lassen Sie uns diese Zeilen einzeln erklären. Um PageKite als Front-End-Server zu konfigurieren, haben wir zunächst die Zeile "+ isfrontend " hinzugefügt. Um die Ports zu konfigurieren, auf denen der Server empfangsbereit ist, haben wir " ports = 80,443 " hinzugefügt. Wir haben auch die Protokolle konfiguriert, die PageKite als Proxy verwendet. Um HTTP, HTTPS und RAW (das von SSH-Verbindungen verwendet wird) zu verwenden, fügen wir die Zeile ` protos = http, https, raw ` hinzu. Wir deaktivieren auch die Einstellungen " Defaults +", damit für den Server keine Konflikte auftreten.

Außerdem haben wir die Domain konfiguriert, die wir für den + Front-End-Server + verwenden werden. Für jeden Client wird eine Subdomain verwendet. Aus diesem Grund benötigten wir die https://www.digitalocean.com/community/tutorials/how-to-set-up-a-pagekite-front-end-server-on- Voraussetzungen für a-debian-9 # [DNS-Konfigurationen im Abschnitt Voraussetzungen]. Wir haben auch ein Passwort eingerichtet, mit dem die Clients authentifiziert werden. Unter Verwendung des Platzhalterkennworts "+" wurden diese Konfigurationen durchgeführt, indem die Zeile " domain = http, https, raw: *. Pagekite.: " Hinzugefügt wurde. Schließlich haben wir eine zusätzliche Zeile hinzugefügt, um eine Verbindung über SSH herzustellen (die nicht dokumentiert ist, wie unter https://stackoverflow.com/questions/25974680/setting-up-pagekite-with-my-own-frontend-to-access beschrieben) -ssh [hier]): ` rawports = virtual +`.

Speichern Sie die Datei und beenden Sie + nano +. Starten Sie den PageKite-Dienst neu, indem Sie Folgendes ausführen:

sudo systemctl restart pagekite.service

Dann aktivieren Sie es, um beim Booten zu starten mit:

sudo systemctl enable pagekite.service

Nachdem nun der Front-End-Server ausgeführt wird, testen wir ihn, indem wir einen HTTP-Port auf dem Remote-Host freigeben und eine Verbindung über den Local-Host herstellen.

Schritt 4 - Verbindung zum Host hinter NAT herstellen

Um den "+ Front-End-Server " zu testen, starten wir einen HTTP-Dienst auf " Remote-Host " und stellen ihn mit PageKite dem Internet zur Verfügung, damit wir über " Local-Host " eine Verbindung zu ihm herstellen können. Denken Sie daran, dass wir über die DigitalOcean-Konsole eine Verbindung zu " remote-host" herstellen müssen, da wir die Firewall so konfiguriert haben, dass eingehende SSH-Verbindungen verweigert werden.

Um einen HTTP-Server zum Testen zu starten, können wir das Python 3-Modul + http.server + verwenden. Da Python bereits in der minimalen Debian-Installation installiert ist und "+ http.server " Teil der Python-Standardbibliothek ist, führen wir Folgendes aus, um den HTTP-Server über den Port " 8000 " auf " remote-host +" zu starten:

python3 -m http.server 8000 &

Da Debian 9 standardmäßig immer noch Python 2 verwendet, muss Python durch Ausführen von + python3 + aufgerufen werden, um den Server zu starten. Das abschließende Zeichen "+ & +" gibt an, dass der Befehl im Hintergrund ausgeführt werden soll, sodass das Shell-Terminal weiterhin verwendet werden kann. Die Ausgabe zeigt an, dass der Server ausgeführt wird:

Output@remote-host:~$ python3 -m http.server 8000 &
[1]
@remote-host:~$ Serving HTTP on 0.0.0.0 port 8000 ...

Während der HTTP-Server ausgeführt wird, wird möglicherweise der PageKite-Tunnel eingerichtet. Eine schnelle Möglichkeit, dies zu tun, ist die Verwendung des Skripts + pagekite.py +. Wir können es auf + remote-host herunterladen:

wget https://pagekite.net/pk/pagekite.py

Markieren Sie es nach dem Herunterladen als ausführbar, indem Sie Folgendes ausführen:

chmod a+x pagekite.py

Wenn "+ pagekite.py " im aktuellen Verzeichnis verfügbar ist, können wir eine Verbindung zu " Front-End-Server " herstellen und den HTTP-Server in der Domäne " remote-host.pagekite. +" Verfügbar machen, indem wir Folgendes ausführen und "ersetzen" `und` `mit Ihren eigenen Zugangsdaten:

./pagekite.py --clean --frontend=pagekite.:80 --service_on=http:remote-host.pagekite.:localhost:8000:

Sehen wir uns die Argumente in diesem Befehl an:

  • + - clean + wird verwendet, um die Standardkonfiguration zu ignorieren.

  • + - frontend = pagekite.: 80 + gibt die Adresse unseres Frontends an. Beachten Sie, dass wir den Port "+ 80 +" verwenden, da wir in Schritt 3 das Front-End so eingestellt haben, dass es auf diesem Port ausgeführt wird.

  • Im letzten Argument, "+ - service_on = http: remote-host.pagekite.: Localhost: 8000: ", richten wir den Dienst ein, den wir verfügbar machen möchten (" http "), die Domain, die wir besuchen möchten Verwenden Sie (` remote-host.pagekite. `), die lokale Adresse und den Port, an dem der Dienst ausgeführt wird (` localhost: 8000 `, da wir einen Dienst auf demselben Host verfügbar machen, den wir für die Verbindung mit PageKite verwenden). , und das Passwort für die Verbindung zum Frontend (`+`).

Sobald dieser Befehl ausgeführt wird, wird die Meldung "+ Drachen fliegen und alles ist in Ordnung" in der Konsole angezeigt. Danach können wir ein Browserfenster in der + local-host + VNC-Sitzung öffnen und auf den HTTP-Server auf + remote-host + zugreifen, indem wir auf die Adresse + http: //remote-host.pagekite zugreifen. + `. Dies zeigt das Dateisystem für `+ remote-host an:

image: https: //assets.digitalocean.com/articles/cart-64916/local-host_accessing_remote-host_web_page.png [local-host Accessing remote-host Web Page]

Um die Verbindung von PageKite auf "+ remote-host " zu beenden, drücken Sie " STRG + C " in der " remote-host +" - Konsole.

Nachdem wir "+ Front-End-Server " getestet haben, konfigurieren wir " Remote-Host +", um die Verbindung mit PageKite dauerhaft herzustellen und beim Booten zu starten.

Schritt 5 - Hostkonfiguration persistent machen

Die Verbindung zwischen dem in Schritt 4 eingerichteten Remote-Host und dem Front-End-Server ist nicht persistent. Dies bedeutet, dass die Verbindung beim Neustart des Servers nicht wiederhergestellt wird. Dies ist ein Problem, wenn Sie diese Lösung langfristig verwenden möchten. Lassen Sie uns dieses Setup also dauerhaft ausführen.

Es ist möglich, PageKit so einzurichten, dass es als Dienst auf + remote-host ausgeführt wird, sodass es beim Booten gestartet wird. Dazu können wir die gleichen Distributionspakete verwenden, die wir in Schritt 3 für den Front-End-Server verwendet haben. Führen Sie in der Konsole "+ remote-host ", auf die über das DigitalOcean-Bedienfeld zugegriffen wird, den folgenden Befehl aus, um " dirmngr +" zu installieren:

sudo apt-get install dirmngr

Führen Sie dann Folgendes aus, um das PageKite-Repository hinzuzufügen und den GPG-Schlüssel zu importieren:

echo deb http://pagekite.net/pk/deb/ pagekite main | sudo tee -a /etc/apt/sources.list
sudo apt-key adv --recv-keys --keyserver keys.gnupg.net AED248B1C7B2CAC3

Führen Sie Folgendes aus, um die Paketliste zu aktualisieren und PageKite zu installieren:

sudo apt-get update
sudo apt-get install pagekite

Um PageKite als Client einzurichten, konfigurieren wir die Adresse und den Port des Front-End-Servers in der Datei "+ / etc / pagekite.d / 20_frontends.rc ". Wir können es mit ` nano +` bearbeiten:

sudo nano /etc/pagekite.d/20_frontends.rc

Kommentieren Sie in dieser Datei die Zeile mit + Defaults +, um die Verwendung von + pagekite.net + Service Defaults zu vermeiden. Konfigurieren Sie außerdem die Adresse und den Port des Front-End-Servers mit dem Parameter "+ frontend " und fügen Sie die Zeile " frontend = pagekite.: 80 " am Ende der Datei hinzu. Stellen Sie sicher, dass Sie "+" durch die von Ihnen verwendete Domain ersetzen.

Hier ist die vollständige Datei mit den hervorgehobenen bearbeiteten Zeilen:

/etc/pagekite.d/20_frontends.rc

#################################[ This file is placed in the Public Domain. ]#
# Front-end selection
#
# Front-ends accept incoming requests on your behalf and forward them to
# your PageKite, which in turn forwards them to the actual server.  You
# probably need at least one, the service defaults will choose one for you.

# Use the pagekite.net service defaults.
defaults

# If you want to use your own, use something like:

# or:
#     frontends = COUNT:dnsname:port

Nachdem Sie die Änderungen gespeichert und "+ nano " beendet haben, fahren Sie mit der Konfiguration fort, indem Sie die Datei " / etc / pagekite.d / 10_account.rc " bearbeiten und die Anmeldeinformationen für die Verbindung mit " Front-End-Server +" festlegen. Öffnen Sie zuerst die Datei, indem Sie Folgendes ausführen:

sudo nano /etc/pagekite.d/10_account.rc

Um die Domain einzurichten, verwenden wir den Domainnamen und das Passwort, um eine Verbindung zu unserem Front-End-Server herzustellen, und bearbeiten die Parameter "+ kitename " und " kitesecret +". Wir müssen auch die letzte Zeile der Datei auskommentieren, um die Konfiguration zu aktivieren, wie im Folgenden hervorgehoben:

/etc/pagekite.d/10_account.rc

#################################[ This file is placed in the Public Domain. ]#
# Replace the following with your account details.




# Delete this line!

Speichern und beenden Sie den Texteditor.

Wir werden nun unsere Dienste konfigurieren, die dem Internet ausgesetzt werden. Für HTTP- und SSH-Dienste enthält PageKite Beispielkonfigurationsdateien mit den Endungen "+ .sample " im Konfigurationsverzeichnis " / etc / pagekite.d +". Beginnen wir mit dem Kopieren der Beispielkonfigurationsdatei in eine gültige für HTTP:

cd /etc/pagekite.d
sudo cp 80_httpd.rc.sample 80_httpd.rc

Die HTTP-Konfigurationsdatei ist fast eingerichtet. Wir müssen nur den HTTP-Port anpassen, was wir tun können, indem wir die gerade kopierte Datei bearbeiten:

sudo nano /etc/pagekite.d/80_httpd.rc

Der Parameter "+ service_on " definiert die Adresse und den Port des Dienstes, den wir verfügbar machen möchten. Standardmäßig wird " localhost: 80 " angezeigt. Da unser HTTP-Server auf dem Port " 8000 +" ausgeführt wird, müssen wir nur die Portnummer ändern, wie im Folgenden hervorgehoben:

/etc/pagekite.d/80_httpd.rc

#################################[ This file is placed in the Public Domain. ]#
# Expose the local HTTPD

service_on = http:@kitename : localhost: : @kitesecret

# If you have TLS/SSL configured locally, uncomment this to enable end-to-end
# TLS encryption instead of relying on the wild-card certificate at the relay.

#service_on = https:@kitename : localhost:443 : @kitesecret

#
# Uncomment the following to globally DISABLE the request firewall.  Do this
# if you are sure you know what you are doing, for more details please see
#                <http://pagekite.net/support/security/>
#
#insecure
#
# To disable the firewall for one kite at a time, use lines like this::
#
#service_cfg = KITENAME.pagekite.me/80 : insecure : True

Nach dem Speichern der Änderungen an dieser Konfigurationsdatei müssen wir den Dienst neu starten, damit die Änderungen wirksam werden:

sudo systemctl restart pagekite.service

Um den Dienst beim Booten zu starten, aktivieren Sie den Dienst mit:

sudo systemctl enable pagekite.service

Verwenden Sie wie zuvor das Python-Modul "+ http.server +", um unseren HTTP-Server zu emulieren. Es wird bereits ausgeführt, seit wir es in Schritt 4 gestartet haben, um es im Hintergrund auszuführen. Wenn es jedoch aus irgendeinem Grund nicht ausgeführt wird, können wir es erneut starten mit:

python3 -m http.server 8000 &

Nachdem der HTTP-Server und der PageKite-Dienst ausgeführt werden, öffnen Sie ein Browserfenster in der VNC-Sitzung "+ local-host " und verwenden Sie es für den Zugriff auf " remote-host " unter Verwendung der Adresse " http: // remote- host.pagekite. + `. Dies zeigt das Dateisystem von "+ remote-host +" im Browser an.

Wir haben gesehen, wie ein PageKite-Front-End-Server und ein Client so konfiguriert werden, dass ein lokaler HTTP-Server verfügbar gemacht wird. Als Nächstes richten wir "+ remote-host +" ein, um SSH verfügbar zu machen und Remoteverbindungen zuzulassen.

Schritt 6 - SSH mit PageKite verfügbar machen

Mit PageKite können neben HTTP auch andere Dienste wie SSH als Proxy verwendet werden. Dies ist nützlich, um in Umgebungen, in denen Netzwerk- und Routerkonfigurationen nicht geändert werden können, remote auf Hosts hinter NAT zuzugreifen.

In diesem Abschnitt konfigurieren wir "+ remote-host " so, dass sein SSH-Dienst mit PageKite verfügbar gemacht wird, und öffnen dann eine SSH-Sitzung über " local-host +".

Genauso wie wir HTTP mit PageKite konfiguriert haben, kopieren wir für SSH die Beispielkonfigurationsdatei in eine gültige, um den SSH-Dienst auf "+ remote-host +" verfügbar zu machen:

cd /etc/pagekite.d
sudo cp 80_sshd.rc.sample 80_sshd.rc

Diese Datei ist vorkonfiguriert, um den SSH-Dienst verfügbar zu machen, der an Port "+ 22 +" ausgeführt wird. Dies ist die Standardkonfiguration. Werfen wir einen Blick auf den Inhalt:

nano 80_sshd.rc

Dies zeigt Ihnen die Datei:

/etc/pagekite.d/80_sshd.rc

#################################[ This file is placed in the Public Domain. ]#
# Expose the local SSH daemon

service_on = raw/22:@kitename : localhost:22 : @kitesecret

Diese Datei ähnelt der zum Anzeigen von HTTP verwendeten Datei. Die einzigen Unterschiede sind die Portnummer, die für SSH "+ 22 " ist, und das Protokoll, das für die Belichtung von SSH auf " raw +" gesetzt werden muss.

Da wir hier keine Änderungen vornehmen müssen, verlassen Sie die Datei.

Starten Sie den PageKite-Dienst neu:

sudo systemctl restart pagekite.service

Auf "+ localhost" verwenden wir den SSH-Client, um eine Verbindung zu "+ remote-host" herzustellen. PageKite tunnelt die Verbindungen über HTTP, sodass für die Verwendung von SSH über PageKite ein HTTP-Proxy erforderlich ist. Es gibt verschiedene Optionen von HTTP-Proxys, die wir aus den Debian-Repositories verwenden könnten, wie zum Beispiel http://nc110.sourceforge.net/ [Netcat] (+ nc +) und https://github.com/bryanpkc/corkscrew [` + Korkenzieher + `]. Für dieses Tutorial verwenden wir "+ corkscrew ", da es weniger Argumente als " nc +" erfordert.

Um + corkscrew auf` + local-host to` zu installieren, verwenden Sie + apt-get install mit dem gleichnamigen Paket:

sudo apt-get install corkscrew

Generieren Sie als nächstes einen SSH-Schlüssel auf "+ local-host" und hängen Sie den öffentlichen Schlüssel an die Datei "+ .ssh / authorized_keys" von "+ remote-host +" an. Folgen Sie dazu dem Einrichten von SSH-Schlüsseln unter Debian 9. einschließlich des Abschnitts * Manuelles Kopieren des öffentlichen Schlüssels * in Schritt 2.

Um eine Verbindung zu einem SSH-Server über einen Proxy herzustellen, verwenden wir "+ ssh " mit dem Argument " -o ", um " ProxyCommand " einzugeben und " corkscrew " als HTTP-Proxy anzugeben. Auf diese Weise führen wir auf " local-host " den folgenden Befehl aus, um über den PageKite-Tunnel eine Verbindung zu " remote-host +" herzustellen:

ssh @remote-host.pagekite. -i ~/id_rsa -o "ProxyCommand corkscrew %h 80 %h %p"

Beachten Sie, dass wir einige Argumente für "+ Korkenzieher " angegeben haben. Die Zeichen `% h ` und `% p ` werden vom SSH-Client durch den Namen des Remote-Hosts (` remote-host.pagekite. `) Und den Remote-Port (` 22 `) ersetzt, die implizit von `verwendet werden + ssh + `) wenn` + corkscrew + `läuft. Das ` 80 +` bezieht sich auf den Port, auf dem PageKite läuft. Dieser Port bezieht sich auf die Kommunikation zwischen dem PageKite-Client und dem Front-End-Server.

Sobald Sie diesen Befehl auf "+ local-host " ausführen, wird die Eingabeaufforderung für " remote-host +" angezeigt.

Wenn unsere SSH-Verbindung über PageKite funktioniert, legen wir als nächstes eine VNC-Sitzung auf "+ remote_server " fest und greifen über " local-host +" mit VNC über SSH darauf zu.

Schritt 7 - Verwenden von VNC über SSH

Jetzt können wir über eine Shell auf einen Remote-Host zugreifen, wodurch viele Probleme behoben werden, die bei Servern auftreten, die sich hinter NAT verstecken. In einigen Situationen benötigen wir jedoch Zugriff auf die grafische Benutzeroberfläche. SSH bietet eine Möglichkeit zum Tunneln von Diensten in seiner Verbindung, z. B. VNC, die für den grafischen Remotezugriff verwendet werden können.

Wenn "+ remote-host " so konfiguriert ist, dass SSH über unseren Front-End-Server verfügbar gemacht wird, verwenden wir eine SSH-Verbindung, um VNC zu tunneln und auf die grafische Oberfläche " remote-host +" zuzugreifen.

Da wir bereits eine VNC-Sitzung so konfiguriert haben, dass sie auf "+ remote-host " automatisch gestartet wird, verwenden wir " local-host ", um eine Verbindung zu " remote-host " herzustellen, indem wir " ssh " mit dem Argument " -L +" verwenden :

ssh @remote-host.pagekite. -i ~/id_rsa -o "ProxyCommand corkscrew %h 80 %h %p" -L5902:localhost:5901

Das Argument "+ -L +" gibt an, dass Verbindungen zu einem bestimmten lokalen Port an einen Remote-Host und -Port weitergeleitet werden sollen. Zusammen mit diesem Argument haben wir eine Portnummer gefolgt von einem Doppelpunkt, einer IP-Adresse, einer Domäne oder einem Hostnamen gefolgt von einem weiteren Doppelpunkt und einer Portnummer angegeben. Werfen wir einen Blick auf diese Informationen im Detail:

  • Die erste Portnummer bezieht sich auf diejenige, die wir auf dem Host verwenden werden, der die SSH-Verbindung startet (in diesem Fall "+ local-host "), um die getunnelte Verbindung vom Remote-Host zu empfangen. In diesem Fall ist aus Sicht von " local-host " die VNC-Sitzung von " remote-host " lokal an Port " 5902 " verfügbar. Wir konnten den Port " 5901 " nicht verwenden, da er bereits auf " local-host +" für seine eigene VNC-Sitzung verwendet wird.

  • Nach dem ersten Doppelpunkt geben wir den Hostnamen (oder die IP-Adresse) des Geräts an, das die VNC-Sitzung bedient, die getunnelt werden soll. Wenn wir einen Hostnamen angeben, wird dieser vom Host, der SSH bereitstellt, in eine IP-Adresse aufgelöst. In diesem Fall können wir "+ localhost " verwenden, da " remote-host +" die SSH-Verbindung bedient und die VNC-Sitzung auch von diesem Host bedient wird.

  • Nach dem zweiten Doppelpunkt geben wir den Port an, in dem der zu tunnelnde Dienst bereitgestellt wird. Wir verwenden den Port "+ 5901 ", da VNC auf diesem Port auf dem " Remote-Host" läuft.

Nachdem die Verbindung hergestellt wurde, wird uns eine Remote-Shell auf "+ remote-host +" angezeigt.

Jetzt können wir die "+ remote-host " VNC-Sitzung von " local-host " aus erreichen, indem wir uns mit dem Port " 5902 " verbinden. Öffnen Sie dazu in Ihrem VNC-Client eine Shell über die GUI ` local-host +` und führen Sie dann Folgendes aus:

vncviewer localhost:5902

Nach Eingabe des "+ remote-host +" VNC-Passworts können wir auf die grafische Umgebung zugreifen.

Dieses Setup kann für Support-Teams nützlich sein, die Remotezugriff verwenden. Es ist möglich, SSH zu verwenden, um jeden Dienst zu tunneln, der von + remote-host + erreicht werden kann. Auf diese Weise können wir "+ remote-host +" als Gateway zu einem lokalen Netzwerk mit vielen Hosts einrichten, einschließlich einiger unter Windows oder einem anderen Betriebssystem. Solange auf den Hosts ein VNC-Server mit einer VNC-Sitzung eingerichtet ist, ist der Zugriff über eine grafische Benutzeroberfläche über SSH möglich, die von unserem PageKite-Front-End-Server getunnelt wird.

Im letzten Schritt werden wir das PageKite-Frontend so konfigurieren, dass mehr Clients mit unterschiedlichen Passwörtern unterstützt werden.

Schritt 8 - Konfigurieren des Front-End-Servers für viele Clients (optional)

Angenommen, wir werden unseren Front-End-Server verwenden, um vielen Clients den Fernzugriff zu ermöglichen. In diesem Mehrbenutzer-Setup ist es empfehlenswert, sie zu isolieren und für jede Verbindung zu unserem Server einen anderen Domänennamen und ein anderes Kennwort zu verwenden. Eine Möglichkeit besteht darin, mehrere PageKite-Dienste auf unserem Server an verschiedenen Ports auszuführen, die jeweils mit einer eigenen Unterdomäne und einem eigenen Kennwort konfiguriert sind. Dies kann jedoch schwierig zu organisieren sein.

Glücklicherweise unterstützt das PageKite-Frontend die Konfiguration mehrerer Clients selbst, sodass wir denselben Service an einem einzigen Port nutzen können. Dazu konfigurieren wir das Frontend mit den Domainnamen und Passwörtern.

Da wir den Wildcard-DNS-Eintrag "+ *. Pagekite. " Konfiguriert haben, der auf unseren " Front-End-Server" verweist, können auch DNS-Einträge in Subdomains wie "+ remote-host.client-1.pagekite. " Verwendet werden weisen Sie auf unseren Server hin, damit wir Domains verwenden können, die auf " client1.pagekite. " und " client2.pagekite. +" enden, um Hosts verschiedener Clients mit unterschiedlichen Passwörtern zu identifizieren.

Öffnen Sie dazu auf dem Front-End-Server die Datei "+ / etc / pagekite.d / 20_frontends.rc +":

sudo nano /etc/pagekite.d/20_frontends.rc

Fügen Sie die Domänen mit dem Schlüsselwort "+ domain +" hinzu und legen Sie für jede Domäne unterschiedliche Kennwörter fest. Fügen Sie zum Einrichten der genannten Domains Folgendes hinzu:

/etc/pagekite.d/20_frontends.rc

#################################[ This file is placed in the Public Domain. ]#
# Front-end selection
#
# Front-ends accept incoming requests on your behalf and forward them to
# your PageKite, which in turn forwards them to the actual server.  You
# probably need at least one, the service defaults will choose one for you.

# Use the pagekite.net service defaults.
# defaults

# If you want to use your own, use something like:
#     frontend = hostname:port
# or:
#     frontends = COUNT:dnsname:port

isfrontend
ports=80,443

protos=http,https,raw
domain=http,https,raw:*.pagekite.:



rawports=virtual

Speichern und schließen Sie die Datei.

Starten Sie PageKite nach dem Ändern der Konfigurationsdateien neu:

sudo systemctl restart pagekite.service

Konfigurieren Sie auf den Remote-Hosts den PageKite-Client so, dass die Verbindung gemäß den neuen Domänen und Kennwörtern hergestellt wird. Ändern Sie beispielsweise in "+ remote-host " zum Herstellen einer Verbindung mit " client-1.pagekite. " Die Datei " / etc / pagekite.d / 10_account.rc ", in der die Anmeldeinformationen für die Verbindung mit "" angegeben sind Front-End-Server + `werden gespeichert:

sudo nano /etc/pagekite.d/10_account.rc

Ändern Sie "+ kitename " und " kitesecret " in die entsprechenden Anmeldeinformationen. Für die Domain ` remote-host.client-1.pagekite. +` Wäre die Konfiguration:

/etc/pagekite.d/10_account.rc

#################################[ This file is placed in the Public Domain. ]#
# Replace the following with your account details.




# Delete this line!

Speichern und schließen Sie die Datei.

Starten Sie den PageKite-Dienst nach dem Ändern der Datei neu:

sudo systemctl restart pagekite.service

Jetzt können wir uns auf + localhost über SSH mit` + remote-host` verbinden:

ssh @remote-host.client-1.pagekite. -i ~/id_rsa -o "ProxyCommand corkscrew %h 80 %h %p"

Wir könnten die Domain + client-2.pagekite. + Für einen anderen Client verwenden. Auf diese Weise können wir die Dienste isoliert verwalten und das Kennwort eines Clients ändern oder sogar deaktivieren, ohne dass dies Auswirkungen auf den anderen Client hat.

Fazit

In diesem Artikel haben wir einen privaten PageKite-Front-End-Server auf einem Debian 9-Droplet eingerichtet und damit HTTP- und SSH-Dienste auf einem Remote-Host hinter NAT verfügbar gemacht. Wir haben uns dann von einem lokalen Server aus mit diesen Diensten verbunden und die PageKite-Funktionalität überprüft. Wie bereits erwähnt, kann dies eine effektive Einrichtung für RAS-Anwendungen sein, da wir andere Dienste in der SSH-Verbindung wie VNC tunneln können.

Wenn Sie mehr über PageKite erfahren möchten, lesen Sie die PageKite Support Info. Wenn Sie tiefer in die Vernetzung mit Droplets eintauchen möchten, besuchen Sie DigitalOceans Netzwerkdokumentation.

Related