steffen/cryodev
1
0
Fork 0
Code Issues Pull requests Projects Releases 2 Packages Wiki Activity Actions

updated pubkey for server, reenabled services, updated docs

Browse source
This commit is contained in:
steffen 2026-03-14 11:19:48 +01:00
parent 304afdc0d4
commit 728edd0036
4 changed files with 210 additions and 104 deletions
Download patch file Download diff file Expand all files Collapse all files

9
.sops.yaml
View file

@ -1,13 +1,14 @@
keys: keys:
- &admin_key age1e8p35795htf7twrejyugpzw0qja2v33awcw76y4gp6acnxnkzq0s935t4t # Admin key (Steffen) - &admin_key age1e8p35795htf7twrejyugpzw0qja2v33awcw76y4gp6acnxnkzq0s935t4t
- &cryodev-main_key age1y6hushuapy0k04mrvvpev0t8lq44w904r596jus44nhkflky0yhqgq2xx6
creation_rules: creation_rules:
- path_regex: hosts/cryodev-main/secrets.yaml$ - path_regex: hosts/cryodev-main/secrets.yaml$
key_groups: key_groups:
- age: - age:
- *admin_key - *admin_key
# - *server_key # Add server key here once obtained - *cryodev-main_key
- path_regex: hosts/cryodev-pi/secrets.yaml$ - path_regex: hosts/cryodev-pi/secrets.yaml$
key_groups: key_groups:
- age: - age:
- *admin_key - *admin_key
# - *pi_key # Add pi key here once obtained # - *pi_key # Add pi key here once obtained

285
docs/getting-started/first-install.md
View file

@ -1,37 +1,43 @@
# Erstinstallation (x86_64 Server) # Erstinstallation (x86_64 Server)
Diese Anleitung beschreibt die **manuelle Installation** eines neuen x86_64 Servers (z.B. cryodev-main). Diese Anleitung beschreibt die **Erstinstallation** eines neuen x86_64 Servers (z.B. cryodev-main).
> **Für Raspberry Pi:** Siehe [Neuen Raspberry Pi hinzufügen](new-client.md) - dort wird ein SD-Image automatisch gebaut. > **Fuer Raspberry Pi:** Siehe [SD-Image erstellen](sd-image.md).
## Übersicht ## Uebersicht
Bei der Erstinstallation gibt es ein Henne-Ei-Problem: Bei der Erstinstallation gibt es ein Henne-Ei-Problem:
- SOPS-Secrets werden mit dem SSH-Host-Key verschlüsselt - SOPS-Secrets werden mit dem SSH-Host-Key verschluesselt
- Der SSH-Host-Key wird erst bei der Installation generiert - Der SSH-Host-Key wird erst bei der Installation generiert
- Daher: Erst installieren, dann Secrets konfigurieren - Daher: **Erst ohne Secrets installieren, dann Secrets konfigurieren**
## Voraussetzungen ### Ablauf
- Bootbares NixOS ISO ([Minimal ISO](https://nixos.org/download/#nixos-iso)) ```
- Netzwerkverbindung 1. Services deaktivieren (die Secrets brauchen)
- Host-Konfiguration in `hosts/<hostname>/` (ohne secrets.yaml) 2. NixOS installieren
3. SSH-Host-Key extrahieren, SOPS konfigurieren, Secrets erstellen
4. Services reaktivieren und deployen
```
## Schritt 1: Host-Konfiguration vorbereiten ## Schritt 1: Host-Konfiguration vorbereiten
> Falls der Host bereits in `hosts/` und `flake.nix` existiert, ueberspringe 1.1-1.3.
### 1.1 Template kopieren ### 1.1 Template kopieren
```bash ```bash
cp -r templates/generic-server hosts/neuer-server cp -r templates/generic-server hosts/<hostname>
``` ```
### 1.2 Hostname setzen ### 1.2 Hostname setzen
`hosts/neuer-server/networking.nix`: `hosts/<hostname>/networking.nix`:
```nix ```nix
{ {
networking.hostName = "neuer-server"; networking.hostName = "<hostname>";
networking.domain = "cryodev.xyz";
} }
``` ```
@ -39,141 +45,244 @@ cp -r templates/generic-server hosts/neuer-server
```nix ```nix
nixosConfigurations = { nixosConfigurations = {
neuer-server = mkNixosConfiguration "x86_64-linux" [ ./hosts/neuer-server ]; <hostname> = mkNixosConfiguration "x86_64-linux" [ ./hosts/<hostname> ];
}; };
``` ```
### 1.4 Placeholder secrets.yaml erstellen ### 1.4 Services temporaer deaktivieren
```bash Alle Services, die SOPS-Secrets referenzieren, muessen fuer die Erstinstallation deaktiviert werden. Andernfalls schlaegt die Installation fehl, weil die Secrets noch nicht entschluesselt werden koennen.
touch hosts/neuer-server/secrets.yaml
In `hosts/<hostname>/services/default.nix` die entsprechenden Imports auskommentieren:
```nix
{
imports = [
# Deaktiviert bis SOPS-Secrets konfiguriert sind:
# ./forgejo.nix # braucht: forgejo-runner/token, forgejo/mail-pw
# ./headplane.nix # braucht: headplane/cookie_secret, headplane/agent_pre_authkey
# ./mailserver.nix # braucht: mailserver/accounts/*
# ./tailscale.nix # braucht: tailscale/auth-key
# Diese Services brauchen keine Secrets:
./headscale.nix
./netdata.nix
./nginx.nix
./openssh.nix
./sops.nix
];
}
``` ```
### 1.5 SOPS-Secrets temporär deaktivieren Zusaetzlich in `hosts/<hostname>/services/sops.nix` die Secrets-Definitionen auskommentieren:
In `hosts/neuer-server/default.nix` alle `sops.secrets.*` Referenzen auskommentieren oder mit `lib.mkIf false` umgeben, bis die echten Secrets existieren. ```nix
sops = {
defaultSopsFile = ../secrets.yaml;
# secrets = {
# "forgejo-runner/token" = { };
# "tailscale/auth-key" = { };
# };
};
```
## Schritt 2: Zielmaschine vorbereiten ### 1.5 Konfiguration testen
```bash
nix eval .#nixosConfigurations.<hostname>.config.system.build.toplevel.name
```
## Schritt 2: Installation durchfuehren
### 2.1 NixOS ISO booten ### 2.1 NixOS ISO booten
Von USB/CD booten. Vom [NixOS Minimal ISO](https://nixos.org/download/#nixos-iso) booten (USB/CD).
### 2.2 Root-Passwort setzen (für SSH) ### 2.2 Netzwerk und SSH einrichten
```bash ```bash
passwd passwd # Root-Passwort setzen fuer SSH-Zugang
ip a # IP-Adresse ermitteln
``` ```
### 2.3 IP-Adresse ermitteln Optional per SSH verbinden (bequemer):
```bash ```bash
ip a ssh -o StrictHostKeyChecking=no root@<IP>
``` ```
### 2.4 Per SSH verbinden (optional) ### 2.3 Repository klonen und installieren
```bash
ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no nixos@<IP>
sudo -i
```
## Schritt 3: Installation durchführen
### 3.1 Repository klonen
```bash ```bash
nix-shell -p git nix-shell -p git
git clone <GIT_REPO_URL> /tmp/nixos git clone <REPO_URL> /tmp/nixos
cd /tmp/nixos bash /tmp/nixos/scripts/install.sh -n <hostname>
``` ```
### 3.2 Disk-Konfiguration anpassen > **Hinweis:** Die Disk-ID in `hosts/<hostname>/disks.sh` muss zur Hardware passen.
> Pruefen mit `ls -la /dev/disk/by-id/`.
**Wichtig:** Die Disk-ID muss zur Hardware passen! Das Script partitioniert die Disk, generiert `hardware.nix` (falls noetig) und installiert NixOS.
### 2.4 Reboot
```bash ```bash
# Verfügbare Disks anzeigen
lsblk -o NAME,SIZE,MODEL,SERIAL
ls -la /dev/disk/by-id/
```
In `hosts/neuer-server/disks.sh` oder `disks.nix` die richtige Disk-ID eintragen.
### 3.3 Install-Script ausführen
```bash
bash scripts/install.sh -n neuer-server
```
Das Script:
1. Partitioniert die Disk (via disko oder disks.sh)
2. Generiert hardware.nix (falls nicht vorhanden)
3. Installiert NixOS
### 3.4 Reboot
```bash
umount -Rl /mnt
reboot reboot
``` ```
## Schritt 4: Nach dem ersten Boot ## Schritt 3: SOPS-Secrets konfigurieren
### 4.1 Einloggen Nach dem ersten Boot einloggen (Passwort: `changeme`, sofort aendern mit `passwd`).
Standard-Passwort: `changeme` ### 3.1 SSH-Host-Key zu Age-Key konvertieren
```bash Auf dem **neuen Server**:
passwd # Sofort ändern!
```
### 4.2 SSH-Host-Key zu Age-Key konvertieren
```bash ```bash
nix-shell -p ssh-to-age --run 'cat /etc/ssh/ssh_host_ed25519_key.pub | ssh-to-age' nix-shell -p ssh-to-age --run 'cat /etc/ssh/ssh_host_ed25519_key.pub | ssh-to-age'
``` ```
**Ausgabe notieren!** (z.B. `age1abc123...`) Ausgabe notieren (z.B. `age1abc123...`).
### 4.3 Auf Entwicklungsrechner: SOPS konfigurieren Alternativ remote:
`.sops.yaml` bearbeiten: ```bash
nix-shell -p ssh-to-age --run 'ssh-keyscan -p 2299 -t ed25519 <IP> | ssh-to-age'
```
### 3.2 .sops.yaml aktualisieren
Auf dem **Entwicklungsrechner** den neuen Host-Key in `.sops.yaml` eintragen:
```yaml ```yaml
keys: keys:
- &admin_key age1e8p35795htf7twrejyugpzw0qja2v33awcw76y4gp6acnxnkzq0s935t4t - &admin_key age1e8p... # Dein lokaler Admin-Key
- &neuer_server_key age1abc123... # Key von oben - &hostname_key age1abc... # Key von Schritt 3.1
creation_rules: creation_rules:
- path_regex: hosts/neuer-server/secrets.yaml$ - path_regex: hosts/<hostname>/secrets.yaml$
key_groups: key_groups:
- age: - age:
- *admin_key - *admin_key
- *neuer_server_key - *hostname_key
``` ```
### 4.4 Secrets erstellen ### 3.3 Secrets erstellen
Secrets-Datei oeffnen:
```bash ```bash
sops hosts/neuer-server/secrets.yaml sops hosts/<hostname>/secrets.yaml
``` ```
Mindestens den Tailscale Auth-Key eintragen (siehe nächster Schritt). Die folgende Tabelle zeigt alle Secrets fuer **cryodev-main** und wie sie generiert werden:
### 4.5 SOPS-Referenzen wieder aktivieren #### Sofort erstellbare Secrets
Die in Schritt 1.5 auskommentierten `sops.secrets.*` Referenzen wieder aktivieren. Diese Secrets haben keine Abhaengigkeiten und koennen direkt generiert werden:
### 4.6 Konfiguration deployen | Secret | Befehl |
|--------|--------|
| `headplane/cookie_secret` | `openssl rand -hex 16` |
| `mailserver/accounts/admin` | `mkpasswd -sm bcrypt` (Passwort merken!) |
| `mailserver/accounts/forgejo` | `mkpasswd -sm bcrypt` (Passwort merken!) |
| `forgejo/mail-pw` | Klartext-Passwort das zum bcrypt-Hash von `mailserver/accounts/forgejo` passt |
#### Secrets die laufende Services brauchen
Diese Secrets koennen erst erstellt werden, nachdem die entsprechenden Services laufen. Bis dahin **Platzhalter** eintragen (z.B. `placeholder`):
| Secret | Befehl | Voraussetzung |
|--------|--------|---------------|
| `tailscale/auth-key` | `sudo headscale preauthkeys create --expiration 99y --reusable --user default` | Headscale laeuft |
| `headplane/agent_pre_authkey` | `sudo headscale users create headplane-agent && sudo headscale preauthkeys create --expiration 99y --user headplane-agent` | Headscale laeuft |
| `forgejo-runner/token` | Forgejo Admin Panel > Actions > Runners > Create Runner | Forgejo laeuft |
#### Beispiel secrets.yaml (Klartext vor Verschluesselung)
```yaml
tailscale:
auth-key: "placeholder"
forgejo-runner:
token: "placeholder"
headplane:
cookie_secret: "a1b2c3d4e5f6..."
agent_pre_authkey: "placeholder"
mailserver:
accounts:
admin: "$2b$05$..."
forgejo: "$2b$05$..."
forgejo:
mail-pw: "das-klartext-passwort"
```
### 3.4 Services reaktivieren
Auf dem **Entwicklungsrechner** die in Schritt 1.4 auskommentierten Imports in `hosts/<hostname>/services/default.nix` wieder aktivieren:
```nix
{
imports = [
./forgejo.nix
./headplane.nix
./headscale.nix
./mailserver.nix
./netdata.nix
./nginx.nix
./openssh.nix
./sops.nix
./tailscale.nix
];
}
```
Ebenso in `hosts/<hostname>/services/sops.nix` die Secrets-Definitionen wieder einkommentieren.
### 3.5 Deployen
```bash ```bash
# Lokal bauen und per SSH deployen nixos-rebuild switch --flake .#<hostname> --target-host root@<IP>
nixos-rebuild switch --flake .#neuer-server --target-host root@<IP>
``` ```
## Nächste Schritte ## Schritt 4: Platzhalter-Secrets ersetzen
- [Tailscale einrichten](../services/tailscale.md) - VPN-Verbindung Nachdem der Server mit Headscale und Forgejo laeuft, die Platzhalter durch echte Werte ersetzen:
- [Netdata konfigurieren](../services/netdata.md) - Monitoring
- [CD einrichten](../deployment/cd.md) - Automatisches Deployment 1. **Headscale-User anlegen** (auf dem Server):
```bash
sudo headscale users create default
sudo headscale users create headplane-agent
```
2. **Preauth-Keys generieren**:
```bash
# Fuer Tailscale
sudo headscale preauthkeys create --expiration 99y --reusable --user default
# Fuer Headplane Agent
sudo headscale preauthkeys create --expiration 99y --user headplane-agent
```
3. **Forgejo-Runner-Token** ueber das Forgejo Admin Panel erstellen:
Administration > Actions > Runners > Create new Runner
4. **Secrets aktualisieren**:
```bash
sops hosts/<hostname>/secrets.yaml
# Platzhalter durch echte Werte ersetzen
```
5. **Erneut deployen**:
```bash
nixos-rebuild switch --flake .#<hostname> --target-host root@<IP>
```
## Naechste Schritte
- [SOPS-Referenz](../services/sops.md) -- Detail-Dokumentation zur Secret-Verwaltung
- [SD-Image erstellen](sd-image.md) -- Raspberry Pi installieren
- [CD einrichten](../deployment/cd.md) -- Automatisches Deployment

10
hosts/cryodev-main/services/default.nix
View file

@ -1,15 +1,13 @@
{ {
imports = [ imports = [
# TODO: Enable after first install when SOPS secrets are configured ./forgejo.nix
# ./forgejo.nix ./headplane.nix
# ./headplane.nix
# ./mailserver.nix
# ./tailscale.nix
./headscale.nix ./headscale.nix
./mailserver.nix
./netdata.nix ./netdata.nix
./nginx.nix ./nginx.nix
./openssh.nix ./openssh.nix
./sops.nix ./sops.nix
./tailscale.nix
]; ];
} }

10
hosts/cryodev-main/services/sops.nix
View file

@ -13,11 +13,9 @@
sops = { sops = {
defaultSopsFile = ../secrets.yaml; defaultSopsFile = ../secrets.yaml;
# age.keyFile is not set, sops-nix defaults to using /etc/ssh/ssh_host_ed25519_key # age.keyFile is not set, sops-nix defaults to using /etc/ssh/ssh_host_ed25519_key
secrets = {
# TODO: Enable after first install when SOPS secrets are configured "forgejo-runner/token" = { };
# secrets = { "tailscale/auth-key" = { };
# "forgejo-runner/token" = { }; };
# "tailscale/auth-key" = { };
# };
}; };
} }