feat(lxc): LXC-Container ausrollen, mit oder ohne Node-SSH
Container aus dem Proxmox-Template (neueste passende Version aus aplinfo), unprivilegiert, nesting automatisch für docker. Weil Proxmox keine Exec-API für Container hat, läuft die Provisionierung per SSH: bevorzugt pct exec über den Node, sonst direkt in den Container mit einem Bereitstellungsschlüssel, der am Ende wieder entfernt wird. Auf pve-demo beide Wege geprüft: Debian 13 mit docker per pct exec (hello-world läuft mit nesting allein) und Ubuntu 24.04 per SSH in den Container. Dabei gefunden: chrony scheitert ohne CAP_SYS_TIME (jetzt if: vm), sshd -t auf Ubuntu 24.04 ohne /run/sshd. Closes #009 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 5.5
@@ -465,7 +465,6 @@ export function Assistent({ daten, vorauswahl }: { daten: AssistentDaten; voraus
|
||||
className={clsx(
|
||||
"border-linie flex cursor-pointer flex-col gap-1 rounded-lg border p-4",
|
||||
werte.typ === wert && "border-akzent",
|
||||
wert === "lxc" && "cursor-not-allowed opacity-50",
|
||||
)}
|
||||
>
|
||||
<span className="flex items-center gap-2 font-semibold">
|
||||
@@ -555,7 +554,7 @@ export function Assistent({ daten, vorauswahl }: { daten: AssistentDaten; voraus
|
||||
autoFocus
|
||||
/>
|
||||
</Feld>
|
||||
<Feld id="vmid" label="VMID" hilfe="Leer = nächste freie">
|
||||
<Feld id="vmid" label={werte.typ === "lxc" ? "CTID" : "VMID"} hilfe="Leer = nächste freie">
|
||||
<input
|
||||
id="vmid"
|
||||
inputMode="numeric"
|
||||
@@ -631,6 +630,40 @@ export function Assistent({ daten, vorauswahl }: { daten: AssistentDaten; voraus
|
||||
</select>
|
||||
</Feld>
|
||||
</div>
|
||||
{werte.typ === "lxc" ? (
|
||||
<div className="mt-5 grid gap-4 sm:grid-cols-3">
|
||||
<Feld id="swap" label="Swap (MB)">
|
||||
<input
|
||||
id="swap"
|
||||
type="number"
|
||||
min={0}
|
||||
step={256}
|
||||
className={EINGABE_KLASSE}
|
||||
value={werte.swapMb}
|
||||
onChange={(e) => setze({ swapMb: e.target.value })}
|
||||
/>
|
||||
</Feld>
|
||||
<Schalter
|
||||
id="unprivilegiert"
|
||||
label="Unprivilegiert"
|
||||
hilfe="Standard und empfohlen. Privilegierte Container braucht es selten."
|
||||
checked={werte.unprivilegiert}
|
||||
onChange={(an) => setze({ unprivilegiert: an })}
|
||||
/>
|
||||
<Schalter
|
||||
id="nesting"
|
||||
label="nesting"
|
||||
hilfe={
|
||||
werte.profile.includes("docker")
|
||||
? "Das Profil docker schaltet es ohnehin ein."
|
||||
: "Für Docker oder systemd-Dienste mit eigenem Namensraum."
|
||||
}
|
||||
checked={werte.nesting || werte.profile.includes("docker")}
|
||||
disabled={werte.profile.includes("docker")}
|
||||
onChange={(an) => setze({ nesting: an })}
|
||||
/>
|
||||
</div>
|
||||
) : null}
|
||||
</Karte>
|
||||
) : null}
|
||||
|
||||
|
||||
@@ -0,0 +1,444 @@
|
||||
import { AblaufFehler } from "@/engine/ablauf/fehler";
|
||||
import type { PhasenKontext, PhasenSchritt } from "@/engine/ablauf/ablauf";
|
||||
import { adapterFuer } from "@/engine/adapter";
|
||||
import { templateWaehlen } from "@/engine/katalog/lxc-template";
|
||||
import type { Distribution } from "@/engine/katalog/schema";
|
||||
import type { AufgeloestesProfil } from "@/engine/profile/aufloesen";
|
||||
import { MARKE, profileRendern } from "@/engine/profile/rendern";
|
||||
import { aufgabeAbwarten } from "@/engine/proxmox/aufgaben";
|
||||
import { pfad, type ProxmoxClient } from "@/engine/proxmox/client";
|
||||
import { q } from "@/engine/shell";
|
||||
import { SshFehler, sshAusfuehren } from "@/engine/ssh/verbindung";
|
||||
import type { AusrollAnfrage } from "@/lib/schemas/ausrollen";
|
||||
import type { NodeBefehl } from "./template-bau";
|
||||
|
||||
/**
|
||||
* Einen LXC-Container ausrollen. Anlegen, Netz und Start gehen per API; Befehle im Container
|
||||
* nicht – Proxmox hat dafür keine API (geprüft gegen das Schema von PVE 9.2). Provisioniert wird
|
||||
* deshalb per SSH, auf einem von zwei Wegen:
|
||||
*
|
||||
* - **Node**: `pct exec <ctid> -- bash -s` über SSH zum Node. Braucht keinen Netzweg zum Container.
|
||||
* - **Gast**: SSH als root direkt in den Container mit dem ProxDeploy-Bereitstellungsschlüssel, den
|
||||
* das Anlegen per `ssh-public-keys` hinterlegt; am Ende wird er wieder entfernt.
|
||||
*/
|
||||
export type Bereitstellungsschluessel = { privat: string; oeffentlich: string };
|
||||
|
||||
export type LxcAusrollEingabe = {
|
||||
client: ProxmoxClient;
|
||||
anfrage: AusrollAnfrage;
|
||||
distribution: Distribution;
|
||||
profile: AufgeloestesProfil[];
|
||||
/** Container-Features, die Profile verlangen (z. B. docker → nesting). */
|
||||
profilFeatures: { nesting: boolean; keyctl: boolean };
|
||||
vmidReservieren: (belegt: Set<number>, wunsch?: number) => Promise<number>;
|
||||
sshFuer: (knoten: string) => NodeBefehl | null;
|
||||
bereitstellung: () => Promise<Bereitstellungsschluessel>;
|
||||
angelegt: (eintrag: Record<string, unknown>) => Promise<void>;
|
||||
auftragKurzId: string;
|
||||
warten?: (ms: number) => Promise<void>;
|
||||
netzMs?: number;
|
||||
/** Nur für Tests: SSH in den Gast ersetzen. */
|
||||
gastSsh?: (
|
||||
ziel: { host: string; schluessel: Bereitstellungsschluessel },
|
||||
skript: string,
|
||||
beiAusgabe: (t: string) => void,
|
||||
warten: (ms: number) => Promise<void>,
|
||||
) => Promise<number | null>;
|
||||
};
|
||||
|
||||
export type LxcAusrollStand = {
|
||||
knoten?: string;
|
||||
vmid?: number;
|
||||
ostemplate?: string;
|
||||
vztmplStorage?: string;
|
||||
ip?: string;
|
||||
weg?: "node" | "gast";
|
||||
};
|
||||
|
||||
type Ressource = {
|
||||
vmid?: number;
|
||||
node?: string;
|
||||
type?: string;
|
||||
status?: string;
|
||||
maxmem?: number;
|
||||
mem?: number;
|
||||
};
|
||||
type StorageEintrag = { storage: string; content: string; active?: number; enabled?: number };
|
||||
type Aplinfo = { template: string; section?: string; package?: string };
|
||||
|
||||
const schlafen = (ms: number) => new Promise<void>((erfuellen) => setTimeout(erfuellen, ms));
|
||||
|
||||
/** Markenzeilen der Provisionierung in Detail und Log übersetzen – für beide Wege gleich. */
|
||||
export function ausgabeVerfolgen(k: PhasenKontext) {
|
||||
let rest = "";
|
||||
let profil = "";
|
||||
const beginn = Date.now();
|
||||
return {
|
||||
get profil() {
|
||||
return profil;
|
||||
},
|
||||
weiter(text: string) {
|
||||
rest += text;
|
||||
const zeilen = rest.split("\n");
|
||||
rest = zeilen.pop() ?? "";
|
||||
for (const zeile of zeilen) {
|
||||
const marke = new RegExp(`^${MARKE} profil (.+)$`).exec(zeile);
|
||||
if (marke) {
|
||||
profil = marke[1]!;
|
||||
const s = Math.round((Date.now() - beginn) / 1000);
|
||||
void k.detail(
|
||||
`Profil ${profil} läuft … ${Math.floor(s / 60)}m ${String(s % 60).padStart(2, "0")}s`,
|
||||
);
|
||||
}
|
||||
void k.log(zeile, zeile.startsWith(MARKE) ? "info" : "debug");
|
||||
}
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
export function lxcNetz(netz: AusrollAnfrage["netz"]): string {
|
||||
return [
|
||||
"name=eth0",
|
||||
`bridge=${netz.bridge}`,
|
||||
...(netz.vlan ? [`tag=${netz.vlan}`] : []),
|
||||
netz.modus === "dhcp" ? "ip=dhcp" : `ip=${netz.ip}`,
|
||||
...(netz.modus === "statisch" && netz.gateway ? [`gw=${netz.gateway}`] : []),
|
||||
"type=veth",
|
||||
].join(",");
|
||||
}
|
||||
|
||||
export function lxcAusrollSchritte(e: LxcAusrollEingabe, stand: LxcAusrollStand = {}): PhasenSchritt[] {
|
||||
const { client, anfrage: a, distribution: d } = e;
|
||||
const warten = e.warten ?? schlafen;
|
||||
const lxc = d.lxc;
|
||||
const ctPfad = () => pfad`/nodes/${stand.knoten!}/lxc/${stand.vmid!}`;
|
||||
const features = {
|
||||
nesting: a.features.nesting || e.profilFeatures.nesting,
|
||||
keyctl: a.features.keyctl || e.profilFeatures.keyctl,
|
||||
};
|
||||
let bereitstellung: Bereitstellungsschluessel | undefined;
|
||||
|
||||
return [
|
||||
{
|
||||
schluessel: "pruefungen",
|
||||
titel: "Prüfungen",
|
||||
ausfuehren: async () => {
|
||||
if (!lxc)
|
||||
throw new AblaufFehler(
|
||||
`${d.name} gibt es nicht als LXC-Container.`,
|
||||
"Eine andere Distribution wählen.",
|
||||
);
|
||||
const ressourcen = await client.get<Ressource[]>("/cluster/resources");
|
||||
const nodes = ressourcen.filter((r) => r.type === "node" && r.status === "online");
|
||||
stand.knoten =
|
||||
a.knoten ??
|
||||
[...nodes].sort((x, y) => (y.maxmem ?? 0) - (y.mem ?? 0) - ((x.maxmem ?? 0) - (x.mem ?? 0)))[0]
|
||||
?.node;
|
||||
if (!stand.knoten || !nodes.some((n) => n.node === stand.knoten)) {
|
||||
throw new AblaufFehler(`Node ${stand.knoten ?? "?"} ist nicht online.`, "Anderen Node wählen.");
|
||||
}
|
||||
const storages = await client.get<StorageEintrag[]>(pfad`/nodes/${stand.knoten}/storage`);
|
||||
const aktiv = (s: StorageEintrag) => s.active === 1 && s.enabled !== 0;
|
||||
const ziel = storages.find((s) => s.storage === a.storage);
|
||||
if (!ziel || !aktiv(ziel) || !ziel.content.split(",").includes("rootdir")) {
|
||||
throw new AblaufFehler(
|
||||
`Storage ${a.storage} nimmt auf ${stand.knoten} keine Container auf.`,
|
||||
`Geeignet sind: ${
|
||||
storages
|
||||
.filter((s) => aktiv(s) && s.content.includes("rootdir"))
|
||||
.map((s) => s.storage)
|
||||
.join(", ") || "keiner"
|
||||
}.`,
|
||||
);
|
||||
}
|
||||
stand.vztmplStorage = storages.find(
|
||||
(s) => aktiv(s) && s.content.split(",").includes("vztmpl"),
|
||||
)?.storage;
|
||||
if (!stand.vztmplStorage)
|
||||
throw new AblaufFehler(
|
||||
"Kein Storage mit Inhaltstyp „Container-Templates“.",
|
||||
"Einem Dir-Storage den Inhaltstyp vztmpl geben.",
|
||||
);
|
||||
|
||||
const netze = await client.get<Array<{ iface: string; type: string; bridge_vlan_aware?: number }>>(
|
||||
pfad`/nodes/${stand.knoten}/network`,
|
||||
);
|
||||
const bridge = netze.find(
|
||||
(n) => n.iface === a.netz.bridge && (n.type === "bridge" || n.type === "OVSBridge"),
|
||||
);
|
||||
if (!bridge)
|
||||
throw new AblaufFehler(
|
||||
`Bridge ${a.netz.bridge} gibt es auf ${stand.knoten} nicht.`,
|
||||
"Andere Bridge wählen.",
|
||||
);
|
||||
if (a.netz.vlan && bridge.type === "bridge" && bridge.bridge_vlan_aware !== 1) {
|
||||
throw new AblaufFehler(
|
||||
`Bridge ${a.netz.bridge} ist nicht VLAN-fähig.`,
|
||||
"„VLAN aware“ an der Bridge einschalten oder ohne VLAN ausrollen.",
|
||||
);
|
||||
}
|
||||
|
||||
// Provisionierung braucht SSH: lieber zum Node (kein Netzweg zum Container nötig).
|
||||
stand.weg = e.sshFuer(stand.knoten) ? "node" : "gast";
|
||||
if (features.keyctl && stand.weg !== "node") {
|
||||
throw new AblaufFehler(
|
||||
"Das Feature keyctl darf per API-Token nicht gesetzt werden.",
|
||||
"SSH zum Node einrichten (dann setzt ProxDeploy es per pct set) oder ohne keyctl ausrollen.",
|
||||
);
|
||||
}
|
||||
const belegt = new Set(
|
||||
ressourcen.map((r) => r.vmid).filter((v): v is number => typeof v === "number"),
|
||||
);
|
||||
stand.vmid = await e.vmidReservieren(belegt, a.vmid);
|
||||
await e.angelegt({ knoten: stand.knoten, typ: "LXC" });
|
||||
return {
|
||||
detail: `CTID ${stand.vmid} frei · ${a.storage} · ${a.netz.bridge}${a.netz.vlan ? ` VLAN ${a.netz.vlan}` : ""} · Provisionierung über ${stand.weg === "node" ? "pct exec" : "SSH in den Container"}`,
|
||||
};
|
||||
},
|
||||
},
|
||||
{
|
||||
schluessel: "lxc-template",
|
||||
titel: "LXC-Template",
|
||||
ausfuehren: async () => {
|
||||
const vorhanden = await client.get<Array<{ volid: string }>>(
|
||||
pfad`/nodes/${stand.knoten!}/storage/${stand.vztmplStorage!}/content`,
|
||||
{
|
||||
content: "vztmpl",
|
||||
},
|
||||
);
|
||||
const dateien = vorhanden.map((v) => v.volid.split("/").pop()!);
|
||||
const lokal = templateWaehlen(lxc!.template_pattern, dateien);
|
||||
// Was es zum Herunterladen gibt – ist dort eine neuere Version, wird sie geladen.
|
||||
const verfuegbar = (await client.get<Aplinfo[]>(pfad`/nodes/${stand.knoten!}/aplinfo`)).map(
|
||||
(x) => x.template,
|
||||
);
|
||||
const neueste = templateWaehlen(lxc!.template_pattern, verfuegbar);
|
||||
if (lokal && (!neueste || lokal === neueste)) {
|
||||
stand.ostemplate = `${stand.vztmplStorage}:vztmpl/${lokal}`;
|
||||
return { uebersprungen: true, detail: `${lokal} vorhanden` };
|
||||
}
|
||||
if (!neueste) {
|
||||
if (lokal) {
|
||||
stand.ostemplate = `${stand.vztmplStorage}:vztmpl/${lokal}`;
|
||||
return { uebersprungen: true, detail: `${lokal} vorhanden` };
|
||||
}
|
||||
throw new AblaufFehler(
|
||||
`Kein Container-Template passt zu „${lxc!.template_pattern}“.`,
|
||||
"Mit „pveam update“ die Liste auf dem Node auffrischen oder das Muster im Katalog prüfen.",
|
||||
);
|
||||
}
|
||||
await aufgabeAbwarten(
|
||||
client,
|
||||
await client.post<string>(pfad`/nodes/${stand.knoten!}/aplinfo`, {
|
||||
storage: stand.vztmplStorage!,
|
||||
template: neueste,
|
||||
}),
|
||||
{ zeitlimitMs: 30 * 60 * 1000 },
|
||||
);
|
||||
stand.ostemplate = `${stand.vztmplStorage}:vztmpl/${neueste}`;
|
||||
return { detail: `${neueste} geladen` };
|
||||
},
|
||||
},
|
||||
{
|
||||
schluessel: "anlegen",
|
||||
titel: "Anlegen",
|
||||
ausfuehren: async () => {
|
||||
if (stand.weg === "gast") bereitstellung = await e.bereitstellung();
|
||||
const featureListe = [features.nesting ? "nesting=1" : null].filter(Boolean).join(",");
|
||||
await aufgabeAbwarten(
|
||||
client,
|
||||
await client.post<string>(pfad`/nodes/${stand.knoten!}/lxc`, {
|
||||
vmid: stand.vmid!,
|
||||
hostname: a.name,
|
||||
ostemplate: stand.ostemplate!,
|
||||
ostype: lxc!.ostype,
|
||||
rootfs: `${a.storage}:${a.diskGb}`,
|
||||
cores: a.cores,
|
||||
memory: a.speicherMb,
|
||||
swap: a.swapMb,
|
||||
unprivileged: a.unprivilegiert,
|
||||
...(featureListe ? { features: featureListe } : {}),
|
||||
net0: lxcNetz(a.netz),
|
||||
...(a.netz.dns.length > 0 ? { nameserver: a.netz.dns.join(" ") } : {}),
|
||||
...(a.netz.suchdomain ? { searchdomain: a.netz.suchdomain } : {}),
|
||||
// Nur der Bereitstellungsschlüssel kommt an root – der Benutzer bekommt seine eigenen Schlüssel.
|
||||
...(bereitstellung ? { "ssh-public-keys": bereitstellung.oeffentlich } : {}),
|
||||
onboot: a.startBeiBoot,
|
||||
tags: ["proxdeploy", d.id, ...a.tags].join(";"),
|
||||
description: `Ausgerollt mit ProxDeploy (Auftrag ${e.auftragKurzId})\nDistribution: ${d.name}\nProfile: ${e.profile.map((p) => p.profil.id).join(", ") || "–"}`,
|
||||
}),
|
||||
{ zeitlimitMs: 15 * 60 * 1000 },
|
||||
);
|
||||
await e.angelegt({ vmid: stand.vmid });
|
||||
if (features.keyctl) {
|
||||
const ssh = e.sshFuer(stand.knoten!)!;
|
||||
if (!client.trocken) {
|
||||
const ergebnis = await ssh(
|
||||
`pct set ${stand.vmid} --features ${q(`nesting=${features.nesting ? 1 : 0},keyctl=1`)}`,
|
||||
);
|
||||
if (ergebnis.code !== 0)
|
||||
throw new AblaufFehler(
|
||||
`keyctl ließ sich nicht setzen: ${ergebnis.stderr.trim()}`,
|
||||
"Rechte des SSH-Benutzers prüfen.",
|
||||
);
|
||||
}
|
||||
}
|
||||
return {
|
||||
detail: `${a.unprivilegiert ? "unprivilegiert" : "privilegiert"} · ${a.cores} CPU · ${a.speicherMb} MB · ${a.diskGb}G${
|
||||
features.nesting || features.keyctl
|
||||
? ` · ${[features.nesting && "nesting", features.keyctl && "keyctl"].filter(Boolean).join(", ")}`
|
||||
: ""
|
||||
}`,
|
||||
};
|
||||
},
|
||||
},
|
||||
{
|
||||
schluessel: "start",
|
||||
titel: "Start",
|
||||
ausfuehren: async () => {
|
||||
await aufgabeAbwarten(client, await client.post<string>(`${ctPfad()}/status/start`), {
|
||||
zeitlimitMs: 5 * 60 * 1000,
|
||||
});
|
||||
return { detail: `CT ${stand.vmid} läuft` };
|
||||
},
|
||||
},
|
||||
{
|
||||
schluessel: "netzwerk",
|
||||
titel: "Netzwerk",
|
||||
ausfuehren: async (k) => {
|
||||
if (a.netz.modus === "statisch") {
|
||||
stand.ip = a.netz.ip!.split("/")[0];
|
||||
return { detail: `IP ${stand.ip}` };
|
||||
}
|
||||
if (client.trocken) return { detail: "IP per DHCP" };
|
||||
const beginn = Date.now();
|
||||
const grenze = e.netzMs ?? 2 * 60 * 1000;
|
||||
while (!stand.ip) {
|
||||
await k.pruefeAbbruch();
|
||||
const schnittstellen = await client.get<Array<{ name: string; inet?: string }>>(
|
||||
`${ctPfad()}/interfaces`,
|
||||
);
|
||||
stand.ip = schnittstellen.find((s) => s.name === "eth0" && s.inet)?.inet?.split("/")[0];
|
||||
if (stand.ip) break;
|
||||
if (Date.now() - beginn > grenze) {
|
||||
throw new AblaufFehler(
|
||||
"Der Container hat per DHCP keine Adresse bekommen.",
|
||||
"DHCP auf der Bridge bzw. im VLAN prüfen oder eine statische Adresse wählen.",
|
||||
);
|
||||
}
|
||||
await k.detail(`wartet auf DHCP … ${Math.round((Date.now() - beginn) / 1000)}s`);
|
||||
await warten(2000);
|
||||
}
|
||||
return { detail: `IP ${stand.ip} per DHCP` };
|
||||
},
|
||||
},
|
||||
{
|
||||
schluessel: "provisionierung",
|
||||
titel: "Provisionierung",
|
||||
ausfuehren: async (k) => {
|
||||
const adapter = adapterFuer(d.family);
|
||||
if (!adapter)
|
||||
throw new AblaufFehler(
|
||||
`Für die Familie „${d.family}“ gibt es keinen Adapter.`,
|
||||
"Adapter ergänzen (docs/katalog.md).",
|
||||
);
|
||||
const nachspann =
|
||||
stand.weg === "gast"
|
||||
? [
|
||||
`echo '${MARKE} bereitstellung-entfernen'\nsed -i '/proxdeploy-bereitstellung/d' /root/.ssh/authorized_keys\n`,
|
||||
]
|
||||
: [];
|
||||
const { skript } = profileRendern(
|
||||
e.profile,
|
||||
adapter,
|
||||
{ os: d.os, gast: { name: a.name, benutzer: a.zugang.benutzer, typ: "lxc" } },
|
||||
[
|
||||
adapter.benutzerAnlegen({
|
||||
name: a.zugang.benutzer,
|
||||
sshSchluessel: a.zugang.sshSchluessel,
|
||||
sudo: true,
|
||||
}),
|
||||
],
|
||||
);
|
||||
const gesamt = skript + nachspann.join("");
|
||||
if (client.trocken) {
|
||||
await k.log(gesamt, "info");
|
||||
return {
|
||||
detail: `über ${stand.weg === "node" ? "pct exec" : "SSH"}${e.profile.length > 0 ? ` · Profile ${e.profile.map((p) => p.profil.id).join(", ")}` : ""}`,
|
||||
};
|
||||
}
|
||||
const verfolgen = ausgabeVerfolgen(k);
|
||||
let code: number | null;
|
||||
if (stand.weg === "node") {
|
||||
const ssh = e.sshFuer(stand.knoten!)!;
|
||||
code = (
|
||||
await ssh(`pct exec ${stand.vmid} -- bash -s`, {
|
||||
eingabe: gesamt,
|
||||
zeitlimitMs: 60 * 60 * 1000,
|
||||
beiAusgabe: (t) => verfolgen.weiter(t),
|
||||
})
|
||||
).code;
|
||||
} else {
|
||||
const ziel = { host: stand.ip!, schluessel: bereitstellung! };
|
||||
code = await (e.gastSsh ?? gastSshStandard)(ziel, gesamt, (t) => verfolgen.weiter(t), warten);
|
||||
}
|
||||
verfolgen.weiter("\n");
|
||||
if (code !== 0) {
|
||||
throw new AblaufFehler(
|
||||
`Provisionierung ${verfolgen.profil ? `im Profil ${verfolgen.profil} ` : ""}mit Code ${code} abgebrochen.`,
|
||||
"Detail-Log ansehen.",
|
||||
);
|
||||
}
|
||||
return {
|
||||
detail:
|
||||
e.profile.length > 0
|
||||
? `Profile ${e.profile.map((p) => p.profil.id).join(", ")} angewendet`
|
||||
: "Benutzer eingerichtet",
|
||||
};
|
||||
},
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* SSH als root in den frischen Container. Seinen Host-Key kann ProxDeploy vorher nicht kennen –
|
||||
* er entsteht beim ersten Start. Vertraut wird deshalb dem ersten Schlüssel (TOFU), und das nur für
|
||||
* diese eine Verbindung; der Bereitstellungsschlüssel wird am Ende des Skripts wieder entfernt.
|
||||
*/
|
||||
async function gastSshStandard(
|
||||
ziel: { host: string; schluessel: Bereitstellungsschluessel },
|
||||
skript: string,
|
||||
beiAusgabe: (t: string) => void,
|
||||
warten: (ms: number) => Promise<void> = schlafen,
|
||||
): Promise<number | null> {
|
||||
const beginn = Date.now();
|
||||
for (;;) {
|
||||
try {
|
||||
const ergebnis = await sshAusfuehren(
|
||||
{
|
||||
host: ziel.host,
|
||||
port: 22,
|
||||
benutzer: "root",
|
||||
privatSchluessel: ziel.schluessel.privat,
|
||||
hostSchluessel: null,
|
||||
},
|
||||
"bash -s",
|
||||
{ erkunden: true, eingabe: skript, zeitlimitMs: 60 * 60 * 1000, beiAusgabe },
|
||||
);
|
||||
return ergebnis.code;
|
||||
} catch (fehler) {
|
||||
// sshd braucht nach dem Start ein paar Sekunden.
|
||||
if (fehler instanceof SshFehler && fehler.art === "verbindung" && Date.now() - beginn < 90_000) {
|
||||
await warten(3000);
|
||||
continue;
|
||||
}
|
||||
if (fehler instanceof SshFehler) {
|
||||
throw new AblaufFehler(
|
||||
`SSH in den Container ${ziel.host} fehlgeschlagen: ${fehler.ursache}`,
|
||||
"Ist der Container aus dem Netz von ProxDeploy erreichbar? Sonst SSH zum Node einrichten (pct exec).",
|
||||
);
|
||||
}
|
||||
throw fehler;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -24,7 +24,7 @@ import { q } from "@/engine/shell";
|
||||
/** Führt einen Befehl als root auf einem Node aus (ssh2, gepinnter Host-Key). */
|
||||
export type NodeBefehl = (
|
||||
befehl: string,
|
||||
optionen?: { eingabe?: string; zeitlimitMs?: number },
|
||||
optionen?: { eingabe?: string; zeitlimitMs?: number; beiAusgabe?: (text: string) => void },
|
||||
) => Promise<{ code: number | null; stdout: string; stderr: string }>;
|
||||
|
||||
export type TemplateBauEingabe = {
|
||||
|
||||
@@ -369,7 +369,7 @@ export function vmAusrollSchritte(e: VmAusrollEingabe, stand: VmAusrollStand = {
|
||||
const { skript } = profileRendern(
|
||||
e.profile,
|
||||
adapter,
|
||||
{ os: d.os, gast: { name: a.name, benutzer: a.zugang.benutzer } },
|
||||
{ os: d.os, gast: { name: a.name, benutzer: a.zugang.benutzer, typ: "vm" } },
|
||||
[
|
||||
adapter.benutzerAnlegen({
|
||||
name: a.zugang.benutzer,
|
||||
|
||||
@@ -147,6 +147,8 @@ KbdInteractiveAuthentication ${h.passwortAnmeldung ? "yes" : "no"}
|
||||
PermitRootLogin ${h.rootAnmeldung ? "prohibit-password" : "no"}
|
||||
PROXDEPLOY_SSH
|
||||
if command -v sshd >/dev/null 2>&1; then
|
||||
# Ubuntu 24.04 startet sshd per Socket – bis zur ersten Verbindung fehlt /run/sshd, und sshd -t bricht ab.
|
||||
install -d -m 0755 /run/sshd
|
||||
sshd -t
|
||||
systemctl reload ssh 2>/dev/null || systemctl reload sshd 2>/dev/null || true
|
||||
fi
|
||||
|
||||
@@ -56,7 +56,10 @@ export type Distribution = z.infer<typeof DistributionSchema>;
|
||||
|
||||
export const VariableSchema = z
|
||||
.object({
|
||||
name: z.string().regex(/^[a-z][a-z0-9_]*$/, "Variablennamen: klein, mit Unterstrich."),
|
||||
name: z
|
||||
.string()
|
||||
.regex(/^[a-z][a-z0-9_]*$/, "Variablennamen: klein, mit Unterstrich.")
|
||||
.refine((n) => n !== "vm" && n !== "lxc", "vm und lxc sind feste Bedingungen, keine Variablennamen."),
|
||||
label: z.string().min(1),
|
||||
type: z.enum(["string", "number", "boolean", "select"]).default("string"),
|
||||
required: z.boolean().default(false),
|
||||
|
||||
@@ -14,17 +14,26 @@ export const MARKE = "::proxdeploy::";
|
||||
|
||||
export type RenderKontext = {
|
||||
os: { id: string; version_id: string; codename?: string };
|
||||
gast: { name: string; benutzer: string };
|
||||
gast: { name: string; benutzer: string; typ?: "vm" | "lxc" };
|
||||
};
|
||||
|
||||
/** Feste Bedingungen neben den Profil-Variablen: `if: vm` / `if: lxc` (bzw. `!vm`, `!lxc`). */
|
||||
export const FESTE_BEDINGUNGEN = ["vm", "lxc"] as const;
|
||||
|
||||
export type Abschnitt = { profil: string; skript: string };
|
||||
|
||||
export type Gerendert = { skript: string; abschnitte: Abschnitt[] };
|
||||
|
||||
function bedingungErfuellt(schritt: ProfilSchritt, werte: Record<string, unknown>): boolean {
|
||||
function bedingungErfuellt(
|
||||
schritt: ProfilSchritt,
|
||||
werte: Record<string, unknown>,
|
||||
typ: "vm" | "lxc" | undefined,
|
||||
): boolean {
|
||||
if (!schritt.if) return true;
|
||||
const verneint = schritt.if.startsWith("!");
|
||||
const wert = Boolean(werte[schritt.if.replace(/^!/, "")]);
|
||||
const name = schritt.if.replace(/^!/, "");
|
||||
// Ohne bekannten Typ (Rendern zum Ansehen) laufen typabhängige Schritte mit.
|
||||
const wert = name === "vm" || name === "lxc" ? (typ ? typ === name : !verneint) : Boolean(werte[name]);
|
||||
return verneint ? !wert : wert;
|
||||
}
|
||||
|
||||
@@ -87,7 +96,7 @@ export function profileRendern(
|
||||
};
|
||||
const teile: string[] = [];
|
||||
for (const schritt of profil.families[adapter.familie] ?? []) {
|
||||
if (!bedingungErfuellt(schritt, werte)) continue;
|
||||
if (!bedingungErfuellt(schritt, werte, kontext.gast.typ)) continue;
|
||||
const text = schrittRendern(schritt, adapter, vorlagenKontext);
|
||||
if ("ssh_harden" in schritt) zumSchluss.push(text);
|
||||
else teile.push(text);
|
||||
|
||||
@@ -40,7 +40,13 @@ export function hostSchluesselFingerabdruck(schluessel: Buffer): string {
|
||||
export function sshAusfuehren(
|
||||
ziel: SshZiel,
|
||||
befehl: string,
|
||||
optionen: { zeitlimitMs?: number; eingabe?: string; erkunden?: boolean } = {},
|
||||
optionen: {
|
||||
zeitlimitMs?: number;
|
||||
eingabe?: string;
|
||||
erkunden?: boolean;
|
||||
/** Laufende Ausgabe (stdout und stderr), z. B. für Live-Fortschritt einer Provisionierung. */
|
||||
beiAusgabe?: (text: string) => void;
|
||||
} = {},
|
||||
): Promise<SshErgebnis> {
|
||||
if (!ziel.hostSchluessel && !optionen.erkunden) {
|
||||
return Promise.reject(
|
||||
@@ -95,8 +101,16 @@ export function sshAusfuehren(
|
||||
let stdout = "";
|
||||
let stderr = "";
|
||||
let code: number | null = null;
|
||||
kanal.on("data", (teil: Buffer) => (stdout += teil.toString("utf8")));
|
||||
kanal.stderr.on("data", (teil: Buffer) => (stderr += teil.toString("utf8")));
|
||||
kanal.on("data", (teil: Buffer) => {
|
||||
const text = teil.toString("utf8");
|
||||
stdout += text;
|
||||
optionen.beiAusgabe?.(text);
|
||||
});
|
||||
kanal.stderr.on("data", (teil: Buffer) => {
|
||||
const text = teil.toString("utf8");
|
||||
stderr += text;
|
||||
optionen.beiAusgabe?.(text);
|
||||
});
|
||||
kanal.on("exit", (exitCode: number | null) => (code = exitCode));
|
||||
kanal.on("close", () => ende(null, { code, stdout, stderr, hostSchluessel: gesehen }));
|
||||
if (optionen.eingabe !== undefined) kanal.end(optionen.eingabe);
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
import type { Server } from "@/generated/prisma/client";
|
||||
import { phasenAusfuehren, type EreignisSenke } from "@/engine/ablauf/ablauf";
|
||||
import { lxcAusrollSchritte, type LxcAusrollStand } from "@/engine/ablaeufe/lxc-ausrollen";
|
||||
import { vmAusrollSchritte, type VmAusrollStand } from "@/engine/ablaeufe/vm-ausrollen";
|
||||
import type { PhasenSchritt } from "@/engine/ablauf/ablauf";
|
||||
import type { Distribution, Profil } from "@/engine/katalog/schema";
|
||||
import { profileAufloesen, type AufgeloestesProfil } from "@/engine/profile/aufloesen";
|
||||
import { ProxmoxClient, type Aufruf } from "@/engine/proxmox/client";
|
||||
@@ -11,6 +13,7 @@ import { AnwendungsFehler } from "@/server/fehler";
|
||||
import { auftragAnlegen } from "@/server/services/auftraege";
|
||||
import { serverHolen, verbindungAus } from "@/server/services/server";
|
||||
import { nodeBefehlFuer } from "@/server/services/ssh-zugang";
|
||||
import { bereitstellungsschluessel } from "@/server/services/bereitstellung";
|
||||
import { vmidVorschlagen } from "@/server/services/vmid";
|
||||
|
||||
/**
|
||||
@@ -44,14 +47,6 @@ export async function ausrollenVorbereiten(roh: unknown): Promise<Vorbereitet> {
|
||||
`${distribution.name} gibt es nicht als ${anfrage.typ === "vm" ? "VM" : "LXC-Container"}.`,
|
||||
);
|
||||
}
|
||||
if (anfrage.typ === "lxc") {
|
||||
throw new AnwendungsFehler(
|
||||
400,
|
||||
"nicht_umgesetzt",
|
||||
"LXC-Container folgen mit #009.",
|
||||
"Vorerst als VM ausrollen.",
|
||||
);
|
||||
}
|
||||
const verfuegbar = new Map(
|
||||
(await prisma.profil.findMany({ where: { aktiv: true, entferntAm: null } })).map((p) => [
|
||||
p.id,
|
||||
@@ -92,6 +87,66 @@ export async function ausrollenStarten(roh: unknown, aufrufer: Aufrufer, ip: str
|
||||
);
|
||||
}
|
||||
|
||||
export type AusrollStand = VmAusrollStand & LxcAusrollStand;
|
||||
|
||||
/** Container-Features, die die gewählten Profile verlangen (z. B. docker → nesting). */
|
||||
export function profilFeatures(profile: AufgeloestesProfil[]): { nesting: boolean; keyctl: boolean } {
|
||||
return {
|
||||
nesting: profile.some((p) => p.profil.lxc.features?.nesting),
|
||||
keyctl: profile.some((p) => p.profil.lxc.features?.keyctl),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Die Phasen für VM oder LXC – dieselben im Trockenlauf und im worker. Was sich unterscheidet
|
||||
* (reservieren oder nur vorschlagen, Auftrags-ID), kommt von außen.
|
||||
*/
|
||||
export function ausrollSchritte(
|
||||
v: Vorbereitet,
|
||||
o: {
|
||||
client: ProxmoxClient;
|
||||
vmidReservieren: (belegt: Set<number>, wunsch?: number) => Promise<number>;
|
||||
templateVmidReservieren: (belegt: Set<number>) => Promise<number>;
|
||||
angelegt: (eintrag: Record<string, unknown>) => Promise<void>;
|
||||
auftragKurzId: string;
|
||||
},
|
||||
stand: AusrollStand,
|
||||
): PhasenSchritt[] {
|
||||
const sshFuer = (knoten: string) => nodeBefehlFuer(v.server, knoten);
|
||||
if (v.anfrage.typ === "lxc") {
|
||||
return lxcAusrollSchritte(
|
||||
{
|
||||
client: o.client,
|
||||
anfrage: v.anfrage,
|
||||
distribution: v.distribution,
|
||||
profile: v.profile,
|
||||
profilFeatures: profilFeatures(v.profile),
|
||||
vmidReservieren: o.vmidReservieren,
|
||||
sshFuer,
|
||||
bereitstellung: bereitstellungsschluessel,
|
||||
angelegt: o.angelegt,
|
||||
auftragKurzId: o.auftragKurzId,
|
||||
},
|
||||
stand,
|
||||
);
|
||||
}
|
||||
return vmAusrollSchritte(
|
||||
{
|
||||
client: o.client,
|
||||
anfrage: v.anfrage,
|
||||
distribution: v.distribution,
|
||||
profile: v.profile,
|
||||
vmidReservieren: o.vmidReservieren,
|
||||
templateBau: v.anfrage.templateBauen
|
||||
? { sshFuer, auftragKurzId: o.auftragKurzId, vmidReservieren: o.templateVmidReservieren }
|
||||
: undefined,
|
||||
angelegt: o.angelegt,
|
||||
auftragKurzId: o.auftragKurzId,
|
||||
},
|
||||
stand,
|
||||
);
|
||||
}
|
||||
|
||||
export type Plan = {
|
||||
kopf: string;
|
||||
phasen: Array<{
|
||||
@@ -138,25 +193,17 @@ export async function ausrollenPlanen(roh: unknown): Promise<Plan> {
|
||||
if (angaben?.phase === "provisionierung" && nachricht.startsWith("#!/bin/bash")) skript = nachricht;
|
||||
},
|
||||
};
|
||||
const stand: VmAusrollStand = {};
|
||||
const stand: AusrollStand = {};
|
||||
try {
|
||||
const ergebnis = await phasenAusfuehren(
|
||||
vmAusrollSchritte(
|
||||
ausrollSchritte(
|
||||
v,
|
||||
{
|
||||
client,
|
||||
anfrage: v.anfrage,
|
||||
distribution: v.distribution,
|
||||
profile: v.profile,
|
||||
vmidReservieren: (belegt, wunsch) =>
|
||||
vmidVorschlagen({ serverId: v.server.id, belegt, von: v.server.gastVmidVon, wunsch }),
|
||||
templateBau: v.anfrage.templateBauen
|
||||
? {
|
||||
sshFuer: (knoten) => nodeBefehlFuer(v.server, knoten),
|
||||
auftragKurzId: "dry-run",
|
||||
vmidReservieren: (belegt) =>
|
||||
vmidVorschlagen({ serverId: v.server.id, belegt, von: v.server.templateVmidVon }),
|
||||
}
|
||||
: undefined,
|
||||
templateVmidReservieren: (belegt) =>
|
||||
vmidVorschlagen({ serverId: v.server.id, belegt, von: v.server.templateVmidVon }),
|
||||
angelegt: async () => {},
|
||||
auftragKurzId: "dry-run",
|
||||
},
|
||||
@@ -178,11 +225,16 @@ export async function ausrollenPlanen(roh: unknown): Promise<Plan> {
|
||||
}
|
||||
}
|
||||
|
||||
export function kopfzeile(v: Pick<Vorbereitet, "server" | "distribution">, stand: VmAusrollStand): string {
|
||||
export function kopfzeile(
|
||||
v: Pick<Vorbereitet, "server" | "distribution" | "anfrage">,
|
||||
stand: AusrollStand,
|
||||
): string {
|
||||
return [
|
||||
`Server ${v.server.name}`,
|
||||
stand.knoten ? `Node ${stand.knoten}` : null,
|
||||
`${v.distribution.name}${stand.template ? ` (Template ${stand.template.vmid})` : ""}`,
|
||||
v.anfrage.typ === "lxc"
|
||||
? `${v.distribution.name} (LXC)`
|
||||
: `${v.distribution.name}${stand.template ? ` (Template ${stand.template.vmid})` : ""}`,
|
||||
]
|
||||
.filter(Boolean)
|
||||
.join(" · ");
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
import ssh2 from "ssh2";
|
||||
import type { Bereitstellungsschluessel } from "@/engine/ablaeufe/lxc-ausrollen";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { entschluesseln, verschluesseln } from "@/lib/geheimnisse";
|
||||
|
||||
/**
|
||||
* Der Bereitstellungsschlüssel: damit meldet sich ProxDeploy als root in frisch angelegten
|
||||
* Containern an, wenn es keinen SSH-Zugang zum Node hat. Er steht nur während der
|
||||
* Provisionierung in /root/.ssh/authorized_keys und wird am Ende des Skripts entfernt (am
|
||||
* Kommentar `proxdeploy-bereitstellung` erkennbar). Einmal erzeugt, privat nur verschlüsselt.
|
||||
*/
|
||||
const SCHLUESSEL = "bereitstellungsschluessel";
|
||||
export const KOMMENTAR = "proxdeploy-bereitstellung";
|
||||
|
||||
export async function bereitstellungsschluessel(): Promise<Bereitstellungsschluessel> {
|
||||
const vorhanden = await prisma.einstellung.findUnique({ where: { schluessel: SCHLUESSEL } });
|
||||
if (vorhanden) {
|
||||
const wert = vorhanden.wert as { privat: string; oeffentlich: string };
|
||||
return { privat: entschluesseln(wert.privat), oeffentlich: wert.oeffentlich };
|
||||
}
|
||||
const paar = ssh2.utils.generateKeyPairSync("ed25519", { comment: KOMMENTAR });
|
||||
const neu = { privat: verschluesseln(paar.private), oeffentlich: paar.public.trim() };
|
||||
// Zwei gleichzeitige Aufträge: der erste gewinnt, der zweite liest dessen Schlüssel.
|
||||
await prisma.einstellung.upsert({
|
||||
where: { schluessel: SCHLUESSEL },
|
||||
create: { schluessel: SCHLUESSEL, wert: neu },
|
||||
update: {},
|
||||
});
|
||||
return await bereitstellungsschluessel();
|
||||
}
|
||||
@@ -29,6 +29,6 @@ export function nodeBefehlFuer(server: Server, knoten: string): NodeBefehl | nul
|
||||
hostSchluessel: pin,
|
||||
},
|
||||
befehl,
|
||||
{ eingabe: optionen.eingabe, zeitlimitMs: optionen.zeitlimitMs },
|
||||
{ eingabe: optionen.eingabe, zeitlimitMs: optionen.zeitlimitMs, beiAusgabe: optionen.beiAusgabe },
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1,11 +1,15 @@
|
||||
import { phasenAusfuehren } from "@/engine/ablauf/ablauf";
|
||||
import { sshBefehl, vmAusrollSchritte, type VmAusrollStand } from "@/engine/ablaeufe/vm-ausrollen";
|
||||
import { sshBefehl } from "@/engine/ablaeufe/vm-ausrollen";
|
||||
import { ProxmoxClient } from "@/engine/proxmox/client";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { melden } from "@/server/ereignisse/senke";
|
||||
import { ausrollenVorbereiten, kopfzeile } from "@/server/services/ausrollen";
|
||||
import {
|
||||
ausrollenVorbereiten,
|
||||
ausrollSchritte,
|
||||
kopfzeile,
|
||||
type AusrollStand,
|
||||
} from "@/server/services/ausrollen";
|
||||
import { verbindungAus } from "@/server/services/server";
|
||||
import { nodeBefehlFuer } from "@/server/services/ssh-zugang";
|
||||
import { vmidReservieren } from "@/server/services/vmid";
|
||||
import { ablaufRegistrieren } from "../ausfuehren";
|
||||
import { aufrufLogger } from "../aufruf-log";
|
||||
@@ -13,7 +17,7 @@ import { aufrufLogger } from "../aufruf-log";
|
||||
ablaufRegistrieren("AUSROLLEN", async ({ auftrag, senke, abbruchGewuenscht, angelegt }) => {
|
||||
// Dieselbe Vorbereitung wie beim Anlegen – der Katalog könnte sich seitdem geändert haben.
|
||||
const v = await ausrollenVorbereiten(auftrag.anfrage);
|
||||
const stand: VmAusrollStand = {};
|
||||
const stand: AusrollStand = {};
|
||||
const kopfSetzen = async () => {
|
||||
await prisma.auftrag.update({
|
||||
where: { id: auftrag.id },
|
||||
@@ -26,12 +30,10 @@ ablaufRegistrieren("AUSROLLEN", async ({ auftrag, senke, abbruchGewuenscht, ange
|
||||
const client = new ProxmoxClient(verbindungAus(v.server), { beobachter: aufrufLogger(senke) });
|
||||
try {
|
||||
const ergebnis = await phasenAusfuehren(
|
||||
vmAusrollSchritte(
|
||||
ausrollSchritte(
|
||||
v,
|
||||
{
|
||||
client,
|
||||
anfrage: v.anfrage,
|
||||
distribution: v.distribution,
|
||||
profile: v.profile,
|
||||
vmidReservieren: async (belegt, wunsch) => {
|
||||
const vmid = await vmidReservieren({
|
||||
serverId: v.server.id,
|
||||
@@ -44,20 +46,14 @@ ablaufRegistrieren("AUSROLLEN", async ({ auftrag, senke, abbruchGewuenscht, ange
|
||||
await kopfSetzen();
|
||||
return vmid;
|
||||
},
|
||||
templateBau: v.anfrage.templateBauen
|
||||
? {
|
||||
sshFuer: (knoten) => nodeBefehlFuer(v.server, knoten),
|
||||
auftragKurzId: auftrag.kurzId,
|
||||
vmidReservieren: (belegt) =>
|
||||
vmidReservieren({
|
||||
serverId: v.server.id,
|
||||
auftragId: auftrag.id,
|
||||
belegt,
|
||||
von: v.server.templateVmidVon,
|
||||
bis: v.server.templateVmidBis,
|
||||
}),
|
||||
}
|
||||
: undefined,
|
||||
templateVmidReservieren: (belegt) =>
|
||||
vmidReservieren({
|
||||
serverId: v.server.id,
|
||||
auftragId: auftrag.id,
|
||||
belegt,
|
||||
von: v.server.templateVmidVon,
|
||||
bis: v.server.templateVmidBis,
|
||||
}),
|
||||
angelegt,
|
||||
auftragKurzId: auftrag.kurzId,
|
||||
},
|
||||
|
||||
Reference in New Issue
Block a user