florian.wildeandClaude Opus 5.5
ca9d6de446
Brach das Warten auf Klonen oder Anlegen ab, legte Proxmox den Gast trotzdem fertig an – und „Aufräumen“ wusste nichts von ihm (CT 114 im Feldtest). Refs #020 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
444 lines
18 KiB
TypeScript
444 lines
18 KiB
TypeScript
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(",");
|
||
const upid = 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(", ") || "–"}`,
|
||
});
|
||
// Sofort merken, nicht erst nach dem Warten: bricht das Warten ab, legt Proxmox den
|
||
// Container trotzdem fertig an – „Aufräumen“ muss ihn dann kennen.
|
||
await e.angelegt({ vmid: stand.vmid });
|
||
await aufgabeAbwarten(client, upid, { zeitlimitMs: 15 * 60 * 1000 });
|
||
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;
|
||
}
|
||
}
|
||
}
|