Kubernetes Workshop Teil 3: Wireguard

Nachdem wir in Teil 2 die Server vorbereitet haben, wollen wir nun Wireguard installieren und konfigurieren.

Wie gesagt, sollen die Server und die Kubernetes-Komponenten verschlüsselt über wireguard miteinander kommunizieren. Eine schöne Anleitung dazu gibt es z.B. hier:

https://vitobotta.com/2019/07/17/kubernetes-wireguard-vpn-rancheros/

Im ersten Schritt installieren wir Wireguard. Vorher machen wir uns natürlich zum root.

sudo -s
add-apt-repository ppa:wireguard/wireguard
apt update
apt install wireguard

Es gibt diverse Anleitungen, wie man unter Ubuntu ein Wireguard-Setup aufbauen kann, wie z.B.

https://www.thomas-krenn.com/de/wiki/Ubuntu_18.04_als_WireGuard_VPN_Client_konfigurieren

Die Schritte sind im Prinzip für jeden Server das Gleiche. Wir erzeugen auf jedem Server jeweils einen privaten, einen öffentlichen Schlüssel und einen sogenannten preshared-key. Hier als Beispiel für meinen ersten Server defiant:

sudo -s
cd /etc/wireguard
umask 077
wg genkey > private-key
wg pubkey > public-key < private-key
wg genpsk > defiant.psk

Im Verzeichnis sollten nun die jeweiligen Dateien liegen. Insbesondere auf den privaten Key sollte man gut aufpassen, daher lohnt sich noch ein:

chmod 600 /etc/wireguard/privatekey

Im nächsten Schritt legen wir für jeden Server eine Konfigurationsdatei unter /etc/wireguard/wg0.conf an. Hier ist das Beispiel für den ersten Server defiant. Dieser soll mit allen anderen 3 Servern und meinem Raspberry-Pi reden können. Daher tragen wir die 4 Kommunikationspartner mit in die Datei ein. Das gleiche gilt dann jeweils für die anderen 3 Server auch, nur dass dort der jeweilige private Schlüssel und eine andere IP vergeben werden müssen.

In meinem Setup vergebe ich folgende IPs:

defiant10.0.0.1
discovery10.0.0.2
reliant10.0.0.3
yorktown10.0.0.4
pi10.0.0.10
IP-Addressen der Server

Der Rest der Datei ist selbsterklärend:

[Interface]
ListenPort = 51871
PrivateKey = <privater Schlüssel Server defiant>
Address = 10.0.0.1/32

PostUp = iptables -A FORWARD -i %i -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i %i -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

[Peer]
# pi 
PublicKey = <öffentlicher Schlüssel raspberrypi>
PresharedKey = <preshared key raspberrypi>
AllowedIPs = 10.0.0.10/32, 192.168.0.0/24

[Peer]
# Discovery 
PublicKey = <öffentlicher Schlüssel discovery>
PresharedKey = <preshared key discovery>
AllowedIPs = 10.0.0.2/32
Endpoint = <öffentliche IP discovery>:51871

[Peer]
# reliant 
PublicKey = <öffentlicher Schlüssel reliant>
PresharedKey = <preshared key reliant>
AllowedIPs = 10.0.0.3/32
Endpoint = <öffentliche IP reliant>:51871

[Peer]
#yorktown 
PublicKey = <öffentlicher Schlüssel yorktown>
PresharedKey = <preshared key yorktown>
AllowedIPs = 10.0.0.4/32
Endpoint = <öffentliche IP yorktown>:51871

Zur Erklärung:

  • ListenPort: Port (UDP) auf dem Wireguard hört
  • PrivateKey: privater Schlüssel
  • Adress: Die IP-Adresse des Servers für das wireguard-Interface
  • PostUp: mit den Befehlen aktiviert man das packet-forwarding auf dem wireguard interface
  • PostDown: Damit deaktiviert man es wieder

Für jeden Peer trägt man folgende Dinge ein:

  • PublicKey: Der öffentliche Schlüssel des Peers
  • PresharedKey: der preshared-key, den ihr für den jeweiligen Server erzeugt habt.
  • AllowedIPs: Das ist die IP des Partners
  • Endpoint: Die öffentliche IP-Adresse des Servers, auf der dann wireguard erreichbar ist.

Eine Besonderheit gibt es bei dem Eintrag für den RaspberryPI. Dort lasse ich neben der IP-Adresse 10.0.0.10 auch das Netz 192.168.0.0/24 zu. Dabei handelt es sich um mein Heimnetzwerk. Damit kann ich nachher die Geräte in meinem Heimnetz erreichen und vom Heimnetz aus die Server über Wireguard ansprechen.

Anschließend erlauben wir noch in der ufw-Firewall auf den Servern die Kommunikation über den UDP-Port 51871:

ufw allow 51871/udp

Mit dem Befehl wg-quick kann man wireguard starten.

wg-quick up wg0

Mit wg show sollten nun die Daten zum wireguard-Netzwerk aufgezeigt werden. Ebenfalls kann man mit ping die jeweiligen peers erreichen:

wg show

ping 10.0.0.2
PING 10.0.0.2 (10.0.0.2) 56(84) bytes of data.
64 bytes from 10.0.0.2: icmp_seq=1 ttl=64 time=3.59 ms
64 bytes from 10.0.0.2: icmp_seq=2 ttl=64 time=0.729 ms
64 bytes from 10.0.0.2: icmp_seq=3 ttl=64 time=1.34 ms
64 bytes from 10.0.0.2: icmp_seq=4 ttl=64 time=0.787 ms

Wenn das alles zur Zufriedenheit funktioniert, sollte man den Dienst noch aktivieren, damit wireguard auch nach dem nächsten Serverneustart gestartet wird:

# aktivieren
systemctl enable wg-quick@wg0
# ggf. starten
systemctl start wg-quick@wg0

Ich erlaube in der Firewall noch alles, was über das Interface wg0 reinkommt, also alles aus meinem VPN:

ufw allow in on wg0

Wenn ihr euch sicher seid, dass ihr eure Server von eurem Client aus per SSH durch den wireguard-tunnel erreichen könnt, könnt ihr auch die OpenSSH-Regel aus der Firewall entfernen. Der Port muss ja nicht für das ganze Internet geöffnet sein. Wir prüfen das lokal mit:

ssh ronny@10.0.0.1

und entfernen dann die „alte“ OpenSSH Regel:

ufw delete allow OpenSSH

Nachdem nun die Kommunikation zwischen den Servern funktioniert, wollen wir im nächsten Teil Docker und Rancher installieren.