Zum Inhalt springen

Deployments ohne Ausfall für Node-Apps mit Docker Compose · Teil 5 von 11 der Serie

Teil 5: Ein eigener Server

Miete einen kleinen Server und mach ihn bereit: ein eigener Benutzer, eine verschlossene Tür, Docker ohne Root, eine Domain, die auf ihn zeigt, und ein Schlüssel, der deine Images lesen kann und sonst nichts.

Quest-Ziele

  • Dich auf einem frischen Server anmelden und einen normalen Benutzer für die Deployments anlegen
  • Anmeldungen nur mit Schlüssel erlauben und jeden Port schließen, der nicht gebraucht wird
  • Docker ohne Root betreiben, das mit der Maschine startet
  • Eine Domain auf den Server zeigen lassen
  • Dem Server ein Token geben, das die Registry nur lesen kann, und das Image holen

Das Image wartet in der Registry. Jetzt braucht es einen Ort zum Laufen, der Tag und Nacht eingeschaltet und von überall erreichbar ist: einen Server. Dieser Teil nimmt einen frisch gemieteten und macht ihn bereit. Am Ende läuft noch keine App, aber alles, was die App brauchen wird, ist da.

Was du brauchst

  • Einen kleinen virtuellen Server, oft VPS genannt: ein Rechner in einem Rechenzentrum, den du monatsweise mietest, für ein paar Euro. Jeder Anbieter ist recht. Wähl Debian 13 oder Ubuntu 24.04 als System. Ein oder zwei Gigabyte Arbeitsspeicher reichen für das Gästebuch völlig.

  • Deinen SSH-Schlüssel darauf. Wenn du den Server anlegst, fragt der Anbieter, wie du dich anmelden willst: Wähl „SSH-Schlüssel“ und gib ihm deinen öffentlichen Schlüssel, denselben, den du in Teil 1 bei GitHub oder GitLab hinterlegt hast. Dann reist nie ein Passwort für den Server per Mail.

  • Eine Domain oder eine Subdomain davon, die du auf den Server zeigen lassen kannst. Die Serie benutzt guestbook.example.com.

Der Anbieter zeigt dir die Adresse des Servers, eine Zahl wie 203.0.113.10. Setz überall, wo diese hier steht, deine ein.

Anmelden und einen Benutzer anlegen

Ein neuer Server hat ein einziges Konto, root, das alles darf. Melde dich von deinem Rechner aus damit an, dieses eine Mal:

~
$ ssh root@203.0.113.10

Jeden Tag als root zu arbeiten ist ein Risiko: ein falscher Befehl, und nichts hält ihn auf. Das Erste ist deshalb ein normaler Benutzer für alles, was folgt. Die Serie nennt ihn deploy:

root@guestbook: ~
$ adduser deploy$ usermod --append --groups sudo deploy$ rsync --archive --chown=deploy:deploy ~/.ssh /home/deploy
  • adduser legt den Benutzer an und fragt nach einem Passwort und ein paar Angaben, die du leer lassen kannst. Wähl ein gutes Passwort und heb es auf: Der Server fragt danach, wann immer deploy etwas als Administrator tut.

  • usermod nimmt den Benutzer in die Gruppe sudo auf. Ihre Mitglieder dürfen einzelne Befehle als Administrator ausführen, indem sie sudo davorschreiben.

  • rsync gibt dem neuen Benutzer eine Kopie von roots Ordner .ssh, in dem dein öffentlicher Schlüssel liegt. Damit öffnet dein Schlüssel auch dieses Konto.

Verlass den Server mit exit und komm als der neue Benutzer zurück. So meldest du dich von jetzt an an, nie mehr als root:

~
$ ssh deploy@203.0.113.10

Die Tür abschließen

Jeder Server im Internet wird den ganzen Tag von Fremden ausprobiert: von Programmen, die von Adresse zu Adresse gehen und Passwörter raten. Zwei kleine Einstellungen nehmen dir diese Sorge. Sie sagen dem SSH-Dienst des Servers, dass er nur Schlüssel annimmt und gar keine Anmeldung als root:

deploy@guestbook: ~
$ echo "PasswordAuthentication no" | sudo tee /etc/ssh/sshd_config.d/10-keys-only.conf$ echo "PermitRootLogin no" | sudo tee --append /etc/ssh/sshd_config.d/10-keys-only.conf$ sudo systemctl reload ssh
  • PasswordAuthentication no: Niemand kommt mit einem Passwort herein, so gut er auch rät. Nur ein Schlüssel, den der Server kennt, öffnet die Tür.

  • PermitRootLogin no: In das Konto, das alles darf, kann man sich von außen nicht einloggen. Verwaltet wird über deploy und sudo.

Die ersten zwei Befehle schreiben diese Zeilen in eine eigene kleine Einstellungsdatei, und der dritte sagt dem SSH-Dienst, dass er seine Einstellungen neu lesen soll.

Das zweite Schloss ist eine Firewall. Sie entscheidet, welche Ports des Servers von außen erreichbar sind. Ein Port ist eine nummerierte Tür, durch die ein Dienst spricht, und das Gästebuch braucht drei davon:

deploy@guestbook: ~
$ sudo apt update && sudo apt install --yes ufw$ sudo ufw allow OpenSSH$ sudo ufw allow 80/tcp$ sudo ufw allow 443$ sudo ufw enable

OpenSSH ist die Tür, durch die du gerade angemeldet bist. Erlaub sie zuerst, sonst sperrt dich die Firewall aus. Port 80 ist das Web ohne Verschlüsselung: Er wird kurz gebraucht, wenn ein Zertifikat geholt wird, und um Besucher auf die sichere Adresse weiterzuschicken. Port 443 ist HTTPS. Die letzte Regel nennt keine Art von Verkehr und öffnet 443 deshalb für beide Arten, die es gibt, TCP und UDP, und die neueste Version des Web-Protokolls, HTTP/3, benutzt UDP. ufw enable fragt, ob du sicher bist, schaltet die Firewall ein und lässt sie auch nach einem Neustart an. Alles andere ist jetzt zu, auch der Port der Datenbank.

Docker ohne Root

Docker läuft normalerweise als root, und damit auch alles, was aus einem Container ausbricht. Auf einem Server, der am Internet hängt, ist das ein Risiko, das du nicht eingehen musst. Im Rootless-Modus läuft Docker als der Benutzer deploy, und ein Container, der ausbricht, ist dieser Benutzer und nicht mehr.

Genau dafür gibt es auf dieser Website ein Tutorial. Folge jetzt Rootless Docker: Docker ohne Root unter Linux, von Anfang bis Ende, angemeldet als deploy. Es dauert etwa 25 Minuten. Diese Serie braucht drei Dinge daraus:

  • Den Rootless-Modus selbst, aus den Abschnitten „Dockers Pakete installieren“ bis „Den Rootless-Modus einrichten“.

  • Lingering, aus „Docker mit dem Rechner starten“. Es lässt die Dienste des Benutzers laufen, wenn niemand angemeldet ist, und nach einem Neustart wieder starten. Docker braucht das, und der Timer in Teil 8 auch.

  • Die niedrigen Ports, aus „Was anders funktioniert“. Ein normaler Benutzer darf keine Ports unter 1024 öffnen, und das Web wohnt auf 80 und 443. Die eine Einstellung, die dort gezeigt wird, erlaubt es ab Port 80.

Wenn du fertig bist, prüf alle drei:

deploy@guestbook: ~
$ docker info --format '{{.SecurityOptions}}'[name=seccomp,profile=builtin name=rootless name=cgroupns]$ loginctl show-user $(whoami) --property=LingerLinger=yes$ sysctl net.ipv4.ip_unprivileged_port_startnet.ipv4.ip_unprivileged_port_start = 80

Die erste Antwort muss rootless enthalten, die zweite yes sagen und die dritte 80. Weicht eine davon ab, geh zu diesem Abschnitt des Tutorials zurück, bevor du weitermachst.

Die Domain auf den Server zeigen lassen

Bisher hat der Server nur seine Zahl. Dort, wo du deine Domain verwaltest, meist bei der Firma, bei der du sie gekauft hast, legst du einen A-Record an: einen Eintrag, der sagt, zu welcher Adresse ein Name gehört. Sein Name ist guestbook (der Teil vor deiner Domain), und sein Wert ist die Adresse des Servers. Es kann ein paar Minuten dauern, bis das ganze Internet ihn kennt. Prüf es von deinem Rechner aus:

~
$ dig +short guestbook.example.com203.0.113.10

Wenn die Antwort die Adresse deines Servers ist, funktioniert der Name, und du kannst ihn statt der Zahl zum Anmelden benutzen. Hat dein Rechner kein dig, sagt dir nslookup guestbook.example.com dasselbe. Der nächste Teil braucht den Namen: ohne ihn kein Zertifikat, und ohne Zertifikat kein HTTPS.

Den Server die Registry lesen lassen

Deine Images sind privat, also muss der Server einen Schlüssel vorzeigen, wenn er eins holt. Er bekommt einen Schlüssel, der zu seiner Aufgabe passt, ein Token, das Images lesen kann und sonst nichts. Sollte jemals jemand in den Server einbrechen, ist das alles, was er damit anfangen könnte.

Ich arbeite mit

GitHub

Öffne auf GitHub deine eigenen Einstellungen (nicht die des Repositorys) und geh auf Developer settings → Personal access tokens → Tokens (classic). Leg dort ein neues klassisches Token an, gib ihm einen Namen wie guestbook-server und ein Ablaufdatum und kreuz einen einzigen Scope an: read:packages. GitHub hat auch neuere, fein einstellbare Tokens, aber seine Registry nimmt nur die klassischen an. Kopier das Token und melde dich dann auf dem Server mit deinem GitHub-Namen an. Wo Docker nach einem Passwort fragt, füg das Token ein. Beim Einfügen wird nichts angezeigt:

deploy@guestbook: ~
$ docker login ghcr.io --username your-namePassword:Login Succeeded$ docker pull ghcr.io/your-name/guestbook:production

GitLab

Öffne auf GitLab dein Projekt und geh auf Settings → Repository → Deploy tokens. Füg ein Token hinzu, trag guestbook-server als Namen und noch einmal im Feld für den Benutzernamen ein, und kreuz einen einzigen Scope an: read_registry. GitLab zeigt den Wert des Tokens ein einziges Mal, kopier ihn also sofort. Melde dich dann auf dem Server mit dem Benutzernamen des Tokens an. Zeigt GitLab einen anderen Benutzernamen als guestbook-server, nimm den, den es zeigt. Wo Docker nach einem Passwort fragt, füg das Token ein. Beim Einfügen wird nichts angezeigt:

deploy@guestbook: ~
$ docker login registry.gitlab.com --username guestbook-serverPassword:Login Succeeded$ docker pull registry.gitlab.com/your-name/guestbook:production

Das docker pull am Ende ist der Beweis: Der Server hat das Image geholt, das die Pipeline gebaut hat. Den Weg von deinem Push bis zum Server gibt es jetzt, auch wenn ihn noch jemand von Hand gehen muss.

Was du jetzt hast

Einen Server mit einem eigenen Benutzer, einer Tür, die sich nur für deinen Schlüssel öffnet, einer Firewall mit drei Türen, Docker, das ohne Root läuft und mit der Maschine startet, einem Namen, der zu ihm führt, und einem Schlüssel für die Registry. Im nächsten Teil zieht das Gästebuch ein: hinter Caddy, einem Webserver, der das HTTPS-Zertifikat selbst holt, und du siehst, was ein gewöhnliches Update deine Besucher kostet.

Kommentare

Die Kommentare sind GitHub Discussions: Zum Schreiben mit GitHub anmelden.

Die Kommentare kommen über giscus von GitHub. Beim Laden gehen deine IP-Adresse an giscus.app und GitHub.