Skip to content
Baunach Infrastruktur

Hetzner Server einrichten

In dieser Anleitung wird Schritt für Schritt erklärt, wie wir einen neuen Cloud oder Root Server bei Hetzner vollumfänglich einrichten.

Vorbereitungen

Bevor es ans eingemachte gehen kann, müssen noch verschiedene Vorbereitungen getroffen werden, um den Server später nahtlos und ohne Verzögerung konfigurieren zu können.

Infrastruktur Repository

Die Konfiguration zur Verwaltung eines Servers muss in einem dafür dediziert genutzten Git-Repository gespeichert werden.

Repositories erstellen

  1. Github: Repository in Github anlegen
    • Organisation: Baunach-IT
    • Name: infrastructure-{NAME}
    • Sichtbarkeit : PRIVAT
  2. Gitea: Repository in Gitea anlegen
    • Organisation: Infrastructure
    • Name: infrastructure-{NAME}
    • Sichtbarkeit : PRIVAT
  3. Gitea: Renovate einrichten (Benachrichtigung über neue Versionen)
    • Einstellungen des Repositories öffnen
    • bot-renovate als Mitarbeiter/Collaborator hinzufügen
  4. Gitea: Spiegelung nach Github einrichten
    • Einstellungen des Repositories öffnen
    • unter Mirror-Einstellungen die Spiegelung konfigurieren
      • URL: https://github.com/baunach-it/infrastructure-{NAME}.git
      • Benutzer (Authentifizierung): baunach-admin
      • Passwort (Authentifizierung): Github PAT für Gitea aus dem Passwordmanager
      • Option “Synchronisieren, wenn Commits gepusht werden” aktivieren
      • Mirror Intervall: 0

Infrastruktur Konfiguration erstellen (Lokal)

An dieser Stelle kann sich einfach an all den anderen Infrastruktur Server Repositories orientiert werden.

  1. Repositories klonen und Spiegelung konfigurieren

    Terminal window
    git clone https://gitea.baunach.work/Infrastructure/infrastructure-{NAME}.git
    git remote add github https://github.com/baunach-it/infrastructure-{NAME}.git

  2. README.md anlegen mit kurzer Beschreibung des Servers & den bereitgestellten Diensten

    README.md
    # Infrastruktur des IdP Servers
    

    ## Applikationen
    Der Produktions Server enthält folgende Produktions-Applikationen:
    - Gitea als IdP (https://id.baunach.work)

  3. .gitignore anlegen

    .gitignore
    .env

  4. Cloudflare Tunnels konfigurieren für SSH und eigene Dienste

    docker-compose.yml
    services:
        cloudflared-tunnel-ssh:
            container_name: cloudflared-tunnel-ssh
            image: cloudflare/cloudflared:2024.12.1
            restart: always
            command: tunnel run
            environment:
                - TUNNEL_TOKEN=${cloudflare_tunnel_ssh_token}
            network_mode: "host"
    

        cloudflared-tunnel:
            container_name: cloudflared-tunnel
            image: cloudflare/cloudflared:2024.12.1
            restart: always
            command: tunnel run
            environment:
                - TUNNEL_TOKEN=${cloudflare_tunnel_token}
            networks:
                cloudflare-tunnel-network:
    networks:
        cloudflare-tunnel-network:
            name: cloudflare-tunnel-network
            driver: bridge
        internal-network:
            name: internal-network
            driver: bridge
    • .env.example anlegen und ergänzen
    .env.example
    cloudflare_tunnel_token=
    cloudflare_tunnel_ssh_token=

  5. Traefik Reverse Proxy konfigurieren

    • Traefik Service hinzufügen
    docker-compose.yml
    services:
        ....
        traefik:
            image: traefik:2.11.15
            container_name: traefik
            restart: always
            networks:
                cloudflare-tunnel-network:
                internal-network:
            volumes:
                - /var/run/docker.sock:/var/run/docker.sock:ro
                - .local/traefik/traefik.yaml:/traefik.yaml:ro
                - .local/traefik/certificates.yaml:/certificates.yaml:ro
                - .local/traefik/certs/cloudflare/:/certs/cloudflare:ro
                - .local/traefik/certs/letsencrypt/:/certs/letsencrypt:rw
        ....
    • Dateienstruktur für Traefik Konfiguration anlegen
    • Directory.local
      • Directorytraefik
        • Directorycerts
          • Directorycloudflare
            • .gitignore
            • README.md
          • Directoryletsencrypt
            • .gitignore
            • README.md
      • certificates.yaml
      • traefik.yaml
    • traefik.yaml erstellen
    traefik.yaml
    log:
        level: DEBUG
    

    entryPoints:
        web:
            address: ":80"
            http:
                redirections:
                    entrypoint:
                        to: "websecure"
                        scheme: "https"
        websecure:
            address: ":443"
    

    certificatesResolvers:
        le:
            acme:
                tlschallenge: true
                email: it-entwicklung@baunach.net
                storage: /certs/letsencrypt/acme.json
    

    providers:
        docker:
            endpoint: "unix:///var/run/docker.sock"
            exposedByDefault: false
            network: internal-network
        file:
            filename: certificates.yaml
    • certificates.yaml erstellen
    certificates.yaml
    tls:
        stores:
            default:
                defaultCertificate:
                    certFile: /certs/cloudflare/baunach.work.pem
                    keyFile: /certs/cloudflare/baunach.work.key
    

        certificates:
            - certFile: /certs/cloudflare/baunach.work.pem
              keyFile: /certs/cloudflare/baunach.work.key
    • certs/cloudflare/.gitignore konfigurieren
    certs/cloudflare/.gitignore
    *.key
    *.pem
    !README.md
    • certs/letsencrypt/.gitignore konfigurieren
    certs/letsencrypt/.gitignore
    *.json
    !README.md

  6. die bisherigen Änderungen commiten und pushen

SSH Key für Serverzugriff generieren (persönliche)

  1. neuen SSH Key in Passwordmanager generieren

    • im Passwordmanager speichern unter: Baunach [NAME] - SSH Key Hetzner (Personal)
    • öffentlichen Schlüssel lokal exportieren und ablegen in ~/.ssh/id_ed25519_{NAME}.pub
    • privaten Schlüssel lokal exportieren (mit Passphrase) und ablegen in ~/.ssh/id_ed25519_{NAME}

  2. SSH Config analog anpassen

    • [NAME]: Name des Servers, z.B. idp
    • [SERVER_IPV4]: IPv4 Adresse des Servers
    • [SERVER_IPV4]: IPv4 Adresse des Servers
    • [VORNAME.NACHNAME]: Benutzername des persönlichen Nutzers auf dem Server, hier vorname.nachname
    config
    Host [NAME]-1p [SERVER IPv4]
        User [VORNAME.NACHNAME]
        Hostname [SERVER IPv4]
        IdentitiesOnly yes
        PreferredAuthentications publickey
        IdentityFile ~/.ssh/id_ed25519_[NAME].pub
    

    Host [NAME]
        ProxyCommand /usr/local/bin/cloudflared access ssh --hostname ssh-[NAME].baunach.work
        User [VORNAME.NACHNAME]
        IdentityFile ~/.ssh/id_ed25519_[NAME]

  3. SSH Keys & Config für WSL bereitstellen und Berechtigungen setzen

    Terminal window
    cp /mnt/c/Users/[USERNAME]/.ssh/* ~/.ssh/ && chmod 600 ~/.ssh/id_*

Hetzner Server & Abhängigkeiten erstellen

  1. Object Storage Credentials erstellen

    Hetzner S3 Zugangsdaten erstellen

  2. Firewall erstellen

    Hetzner Firewall erstellen

  3. Cloud Server erstellen

    Hetzner Cloud Server erstellen

Server Installation und Konfiguration

Nun können wir uns über den nicht getunnelten Zugriff (Port 22) auf den Server per SSH aufschalten

ssh [NAME]-1p

Nach erfolgreicher Verbindung sollten wir nun mit unserem Benutzer auf dem Server angemeldet sein

Terminal window
Linux idp-server 6.1.0-28-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.119-1 (2024-11-22) x86_64


The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.


Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Thu Dec 19 08:24:30 2024 from ::1
aleksandar.damjanovic@idp-server:~$

Für alle weiteren Schritte müssen wir uns als Root-User mit dem zuvor gespeicherten Root-Passwort authentifizieren

su root

Standardprogramme installieren

Wir nutzen ein Set an Standardprogrammen, die wir auf jedem Server installieren.

  1. Docker installieren (Offizielle Anleitung)
    • Repositories aktualisieren
    Terminal window
    # Add Docker's official GPG key:
    sudo apt-get update
    sudo apt-get install ca-certificates curl
    sudo install -m 0755 -d /etc/apt/keyrings
    sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
    sudo chmod a+r /etc/apt/keyrings/docker.asc
    

    # Add the repository to Apt sources:
    echo \
    "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
    $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
    sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
    sudo apt-get update
    • Dockerdienste installieren
    Terminal window
    sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
  2. ctop installieren zum verwalten von Docker 
    sudo wget https://github.com/bcicen/ctop/releases/download/v0.7.7/ctop-0.7.7-linux-amd64 -O /usr/local/bin/ctop && sudo chmod +x /usr/local/bin/ctop
  3. minio/mc installieren zum verwalten des Hetzner Object Storage (S3)
    • Installation
    sudo wget https://dl.min.io/client/mc/release/linux-amd64/mc -O /usr/local/bin/mc && sudo chmod +x /usr/local/bin/mc
    • Hetzner S3 Alias hinzufügen mit zuvor erstellen Zugangsdaten für diesen Server
    mc alias set s3h https://nbg1.your-objectstorage.com accesskey secretkey --api "s3v4" --path "off"
  4. autorestic installieren zum verwalten der Backups 
    wget -qO - https://raw.githubusercontent.com/cupcakearmy/autorestic/master/install.sh | bash
  5. netdata agent installieren
    • Netdata Skript über Oberfläche (Add Nodes) generieren lassen
    wget -O /tmp/netdata-kickstart.sh https://get.netdata.cloud/kickstart.sh && sh /tmp/netdata-kickstart.sh --nightly-channel \
    --claim-token ..... \
    --claim-rooms 870d462b-be33-411d-b41b-b5856f1cbf48 \
    --claim-url https://app.netdata.cloud

Infrastruktur Repository klonen

  1. Passphrase in Passwordmanager erstellen lassen

    • Name: Baunach [NAME] - SSH Passphrase

  2. SSH Key mit Passphrase erstellen

    ssh-keygen -t ed25519 -C "[NAME]@baunach.work"
    • SSH Key NICHT in Passwortmanager speichern

  3. zu Github Account hinzufügen

    • öffentlichen Schlüssel im baunach-admin Github Account als SSH key hinterlegen

  4. Infrastruktur-Repository klonen (srv/infrastructure)

    git clone git@github.com:baunach-it/infrastructure-[NAME].git /srv/infrastructure

  5. .env aus .env.example erstellen

    cp /srv/infrastructure/.env.example /srv/infrastructure/.env

Cloudflare Tunnel & Access konfigurieren

Jetzt können wir die benötigten Cloudflare Tunnel erstellen, um die beiden cloudflared Docker Container mit den jeweiligen Credentials zu versorgen.

  1. Cloudflare SSH Tunnel erstellen

    Cloudflare Tunnel erstellen (SSH)

  2. Cloudflare Dienste Tunnel erstellen

    Cloudflare Tunnel erstellen (Proxy)

  3. Cloudflare Tunnel Tokens in .env Datei ergänzen

    cloudflare_tunnel_token=eyKejkejre...
    cloudflare_tunnel_ssh_token=eyOeriuer...

  4. Cloudflare Access konfigurieren und Zugriffe begrenzen

    Cloudflare Access (SSH) Cloudflare Access (Dienst)

  5. Docker container starten

    docker compose -f /srv/infrastructure/docker-compose.yml up -d

  6. SSH Tunnel über Cloudflare testen (WSL)

    ssh [NAME]

  7. Wenn alles passt, eingehenden Port 22 in Hetzner Firewall wieder schließen/entfernen

Backups mit autorestic konfigurieren

Wie eventuell benötigte Backups konfiguriert werden, kann der folgenden Anleitung entnommen werden

Autorestic Backups konfigurieren

seblstgehostete Dienste hinzufügen und veröffentlichen

Wie weitere selbsgehostete Dienste zur aktuellen Infrastruktur hinzugefügt werden können, kann der folgenden Anleitung entnommen werden

Dienst bereitstellen (selfhosted)