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:
- &admin_key age1e8p35795htf7twrejyugpzw0qja2v33awcw76y4gp6acnxnkzq0s935t4t # Admin key (Steffen)
- &admin_key age1e8p35795htf7twrejyugpzw0qja2v33awcw76y4gp6acnxnkzq0s935t4t
- &cryodev-main_key age1y6hushuapy0k04mrvvpev0t8lq44w904r596jus44nhkflky0yhqgq2xx6
creation_rules:
- path_regex: hosts/cryodev-main/secrets.yaml$
key_groups:
- age:
- *admin_key
# - *server_key # Add server key here once obtained
- *admin_key
- *cryodev-main_key
- path_regex: hosts/cryodev-pi/secrets.yaml$
key_groups:
- age:
- *admin_key
- *admin_key
# - *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)
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:
- 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
- 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
- Host-Konfiguration in `hosts/<hostname>/` (ohne secrets.yaml)
```
1. Services deaktivieren (die Secrets brauchen)
2. NixOS installieren
3. SSH-Host-Key extrahieren, SOPS konfigurieren, Secrets erstellen
4. Services reaktivieren und deployen
```
## Schritt 1: Host-Konfiguration vorbereiten
> Falls der Host bereits in `hosts/` und `flake.nix` existiert, ueberspringe 1.1-1.3.
### 1.1 Template kopieren
```bash
cp -r templates/generic-server hosts/neuer-server
cp -r templates/generic-server hosts/<hostname>
```
### 1.2 Hostname setzen
`hosts/neuer-server/networking.nix`:
`hosts/<hostname>/networking.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
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
touch hosts/neuer-server/secrets.yaml
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.
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
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
passwd
passwd # Root-Passwort setzen fuer SSH-Zugang
ip a # IP-Adresse ermitteln
```
### 2.3 IP-Adresse ermitteln
Optional per SSH verbinden (bequemer):
```bash
ip a
ssh -o StrictHostKeyChecking=no root@<IP>
```
### 2.4 Per SSH verbinden (optional)
```bash
ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no nixos@<IP>
sudo -i
```
## Schritt 3: Installation durchführen
### 3.1 Repository klonen
### 2.3 Repository klonen und installieren
```bash
nix-shell -p git
git clone <GIT_REPO_URL> /tmp/nixos
cd /tmp/nixos
git clone <REPO_URL> /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
# 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
```
## 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
passwd # Sofort ändern!
```
### 4.2 SSH-Host-Key zu Age-Key konvertieren
Auf dem **neuen Server**:
```bash
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
keys:
- &admin_key age1e8p35795htf7twrejyugpzw0qja2v33awcw76y4gp6acnxnkzq0s935t4t
- &neuer_server_key age1abc123... # Key von oben
- &admin_key age1e8p... # Dein lokaler Admin-Key
- &hostname_key age1abc... # Key von Schritt 3.1
creation_rules:
- path_regex: hosts/neuer-server/secrets.yaml$
- path_regex: hosts/<hostname>/secrets.yaml$
key_groups:
- age:
- *admin_key
- *neuer_server_key
- *admin_key
- *hostname_key
```
### 4.4 Secrets erstellen
### 3.3 Secrets erstellen
Secrets-Datei oeffnen:
```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
# Lokal bauen und per SSH deployen
nixos-rebuild switch --flake .#neuer-server --target-host root@<IP>
nixos-rebuild switch --flake .#<hostname> --target-host root@<IP>
```
## Nächste Schritte
## Schritt 4: Platzhalter-Secrets ersetzen
- [Tailscale einrichten](../services/tailscale.md) - VPN-Verbindung
- [Netdata konfigurieren](../services/netdata.md) - Monitoring
- [CD einrichten](../deployment/cd.md) - Automatisches Deployment
Nachdem der Server mit Headscale und Forgejo laeuft, die Platzhalter durch echte Werte ersetzen:
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 = [
# TODO: Enable after first install when SOPS secrets are configured
# ./forgejo.nix
# ./headplane.nix
# ./mailserver.nix
# ./tailscale.nix
./forgejo.nix
./headplane.nix
./headscale.nix
./mailserver.nix
./netdata.nix
./nginx.nix
./openssh.nix
./sops.nix
./tailscale.nix
];
}

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

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