Swarm hay k3s cho trụ sở: ánh xạ stack BanHang.Api và chuyển không gián đoạn

# ===== kustomization.yaml
# Secret banhang-sql-v1 (khóa connection-string) và bhpay-api-key-v1 (khóa api-key) tạo ngoài Git.
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
  - namespace.yaml
  - deployment.yaml
  - service.yaml
  - pdb.yaml
# ===== namespace.yaml
---
apiVersion: v1
kind: Namespace
metadata:
  name: banhang                        # tên stack của Swarm
# ===== deployment.yaml
---
# BanHang.Api trên k3s HA của trụ sở. Ánh xạ từ banhang-api.stack.yml (service api của stack banhang).
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
  namespace: banhang
  labels:
    app.kubernetes.io/name: banhang-api
spec:
  replicas: 4                          # deploy.replicas
  minReadySeconds: 90                  # update_config.delay và monitor 90 s
  progressDeadlineSeconds: 600         # quá hạn chỉ báo ProgressDeadlineExceeded, không tự rollback
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1                      # parallelism 1, order start-first
      maxUnavailable: 0
  selector:
    matchLabels:
      app.kubernetes.io/name: banhang-api
  template:
    metadata:
      labels:
        app.kubernetes.io/name: banhang-api
    spec:
      automountServiceAccountToken: false   # API không gọi Kubernetes API
      terminationGracePeriodSeconds: 30     # > preStop 5 s + ShutdownTimeout 15 s + 1 s
      topologySpreadConstraints:            # Swarm tự trải 4 replica trên 5 node; Kubernetes phải khai báo
        - maxSkew: 1
          topologyKey: kubernetes.io/hostname
          whenUnsatisfiable: DoNotSchedule
          labelSelector:
            matchLabels:
              app.kubernetes.io/name: banhang-api
      containers:
        - name: api
          image: registry.banhang.local/banhang/api:1.5.0
          ports:
            - name: http
              containerPort: 8080
          env:
            - name: ASPNETCORE_ENVIRONMENT
              value: Production
            - name: BanHang__Node             # Swarm: {{.Node.Hostname}}
              valueFrom:
                fieldRef:
                  fieldPath: spec.nodeName
            - name: BanHang__Task             # Swarm: {{.Task.Name}}
              valueFrom:
                fieldRef:
                  fieldPath: metadata.name
            - name: RutChoGiay                # preStop chờ thay cho 2 s Swarm chờ trước SIGTERM
              value: "0"
          resources:
            requests:
              cpu: 500m                       # reservations.cpus 0.5
              memory: 512Mi                   # reservations.memory 512M
            limits:
              cpu: "2"
              memory: 1Gi                     # limits.memory 1024M
          startupProbe:                       # start_period 60 s, start_interval 1 s
            httpGet:
              path: /healthz/live
              port: http
            periodSeconds: 1
            timeoutSeconds: 2
            failureThreshold: 60
          livenessProbe:                      # healthcheck: interval 5 s, timeout 3 s, retries 3
            httpGet:
              path: /healthz/live
              port: http
            periodSeconds: 5
            timeoutSeconds: 3
            failureThreshold: 3
          readinessProbe:                     # Swarm không có; như bài 4
            httpGet:
              path: /healthz/ready
              port: http
            periodSeconds: 5
            timeoutSeconds: 2
            failureThreshold: 2
          lifecycle:
            preStop:
              sleep:
                seconds: 5
          volumeMounts:
            - name: bi-mat
              mountPath: /run/secrets
              readOnly: true
      volumes:
        - name: bi-mat                        # hai Secret chung một thư mục như /run/secrets của Swarm
          projected:
            sources:
              - secret:
                  name: banhang-sql-v1
                  items:
                    - key: connection-string
                      path: ConnectionStrings__BanHang
              - secret:
                  name: bhpay-api-key-v1
                  items:
                    - key: api-key
                      path: BHPay__ApiKey
# ===== service.yaml
---
# ServiceLB của k3s giữ cổng 8080 trên mọi node, như routing mesh của Swarm.
apiVersion: v1
kind: Service
metadata:
  name: api
  namespace: banhang
  labels:
    app.kubernetes.io/name: banhang-api
spec:
  type: LoadBalancer
  selector:
    app.kubernetes.io/name: banhang-api
  ports:
    - name: http
      protocol: TCP
      port: 8080
      targetPort: http
# ===== pdb.yaml
---
# kubectl drain khi vá máy (docker node update --availability drain ở bài 1): giữ ít nhất 3/4 replica.
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: api
  namespace: banhang
spec:
  minAvailable: 3
  selector:
    matchLabels:
      app.kubernetes.io/name: banhang-api

#:package YamlDotNet@18.1.0
// So từng thiết lập của stack Swarm (kết quả docker stack config) với manifest Kubernetes.
// Mỗi khóa lá của service phải được một luật nhận; luật nói manifest giữ thiết lập đó ra sao.
// dotnet run SoSwarmK3s.cs -- banhang-api.render.yml <manifest.yaml | thư mục manifest>
using System.Globalization;
using System.Text.RegularExpressions;
using YamlDotNet.RepresentationModel;

var swarm = new Dictionary<string, string>();
Phang(DocYaml(args[0])[0], "", swarm);
foreach (var k in swarm.Keys.Where(k => !k.StartsWith("services.") && !k.StartsWith("secrets.")).ToList()) swarm.Remove(k);   // bỏ "version"
var k8s = (Directory.Exists(args[1]) ? Directory.GetFiles(args[1], "*.yaml") : [args[1]]).SelectMany(DocYaml)
    .OfType<YamlMappingNode>().ToList();
var dep = k8s.FirstOrDefault(d => V(d, "kind") == "Deployment");
var pod = N(dep, "spec", "template", "spec");
var c = (N(pod, "containers") as YamlSequenceNode)?.Children.FirstOrDefault();
var svc = k8s.FirstOrDefault(d => V(d, "kind") == "Service");
var pdb = k8s.FirstOrDefault(d => V(d, "kind") == "PodDisruptionBudget");
string S(string p) => swarm.GetValueOrDefault("services.api." + p, "");
const double ShutdownTimeout = 15, KestrelSauAbort = 1, GossipSwarm = 2;   // BanHang.Api.cs, bài 2

// Trạng thái: khớp | đổi dạng (trường khác, cùng tác dụng) | thêm mới (Swarm làm ngầm) |
//             thay bằng quy trình | không tương đương | SAI | THIẾU
var luat = new List<(string Mau, string Ten, Func<(string, string)> Kiem)>
{
    (@"^services\.api\.image$", "image", () => Bang(V(c, "image"), S("image"))),
    (@"^services\.api\.deploy\.(mode|replicas)$", "replicas", () => Bang(V(dep, "spec", "replicas"), S("deploy.replicas"))),
    (@"^services\.api\.deploy\.resources\.limits\.cpus$", "limits.cpus", () => Cpu(V(c, "resources", "limits", "cpu"), S("deploy.resources.limits.cpus"))),
    (@"^services\.api\.deploy\.resources\.limits\.memory$", "limits.memory", () => Ram(V(c, "resources", "limits", "memory"), S("deploy.resources.limits.memory"))),
    (@"^services\.api\.deploy\.resources\.reservations\.cpus$", "reservations.cpus", () => Cpu(V(c, "resources", "requests", "cpu"), S("deploy.resources.reservations.cpus"))),
    (@"^services\.api\.deploy\.resources\.reservations\.memory$", "reservations.memory", () => Ram(V(c, "resources", "requests", "memory"), S("deploy.resources.reservations.memory"))),
    (@"^services\.api\.deploy\.restart_policy\.condition$", "restart_policy.condition", () =>
        V(pod, "restartPolicy") is null or "Always" ? ("khớp", "restartPolicy Always") : ("SAI", V(pod, "restartPolicy")!)),
    (@"^services\.api\.deploy\.restart_policy\.delay$", "restart_policy.delay", () =>
        ("không tương đương", "kubelet tự lùi 10 s, 20 s, 40 s… tối đa 300 s")),
    (@"^services\.api\.environment\.ASPNETCORE_ENVIRONMENT$", "env ASPNETCORE_ENVIRONMENT", () => Bang(V(Env("ASPNETCORE_ENVIRONMENT"), "value"), S("environment.ASPNETCORE_ENVIRONMENT"))),
    (@"^services\.api\.environment\.BanHang__Node$", "env {{.Node.Hostname}}", () => TuPod("BanHang__Node", "spec.nodeName")),
    (@"^services\.api\.environment\.BanHang__Task$", "env {{.Task.Name}}", () => TuPod("BanHang__Task", "metadata.name")),
    (@"^services\.api\.environment\.RutChoGiay$", "rút trước SIGTERM", () =>
    {
        double rut = double.Parse(V(Env("RutChoGiay"), "value") ?? "0", CultureInfo.InvariantCulture), cho = PreStop();
        string k = $"RutChoGiay {rut} + preStop {cho} s";
        return rut + cho >= GossipSwarm ? ("đổi dạng", k) : ("SAI", k + $": SIGTERM tới cùng lúc gỡ endpoint, Swarm chờ {GossipSwarm} s");
    }),
    (@"^services\.api\.ports\[0\]\.target$", "ports.target", () => Bang(V(N(c, "ports") is YamlSequenceNode p ? p.Children[0] : null, "containerPort"), S("ports[0].target"))),
    (@"^services\.api\.ports\[0\]\.(published|mode|protocol)$", "routing mesh :8080", () =>
        svc is null ? ("THIẾU", "không có Service")
        : V(svc, "spec", "type") == "LoadBalancer" && V(N(svc, "spec", "ports") is YamlSequenceNode sp ? sp.Children[0] : null, "port") == S("ports[0].published")
            ? ("đổi dạng", "Service LoadBalancer :8080, ServiceLB trên mọi node")
            : ("SAI", $"Service {V(svc, "spec", "type") ?? "ClusterIP"}: không nhận request từ ngoài cụm")),
    (@"^services\.api\.healthcheck\.test\[\d\]$", "healthcheck.test", () =>
    {
        var lv = N(c, "livenessProbe");
        string url = S("healthcheck.test[2]"), duong = new Uri(url).AbsolutePath;
        if (V(lv, "httpGet", "path") == duong) return ("đổi dạng", $"livenessProbe httpGet {duong}");
        if (N(lv, "exec", "command") is YamlSequenceNode cmd && cmd.Children.Any(x => x.ToString() == url)) return ("khớp", "livenessProbe exec KiemTra");
        return ("THIẾU", "không có livenessProbe");
    }),
    (@"^services\.api\.healthcheck\.interval$", "healthcheck.interval", () => Bang(V(c, "livenessProbe", "periodSeconds"), Giay(S("healthcheck.interval")))),
    (@"^services\.api\.healthcheck\.timeout$", "healthcheck.timeout", () => Bang(V(c, "livenessProbe", "timeoutSeconds"), Giay(S("healthcheck.timeout")))),
    (@"^services\.api\.healthcheck\.retries$", "healthcheck.retries", () => Bang(V(c, "livenessProbe", "failureThreshold"), S("healthcheck.retries"))),
    (@"^services\.api\.healthcheck\.(start_period|start_interval)$", "start_period, start_interval", () =>
    {
        double han = double.Parse(Giay(S("healthcheck.start_period"))), buoc = double.Parse(Giay(S("healthcheck.start_interval")));
        var st = N(c, "startupProbe");
        if (st is not null)
        {
            double p = So(V(st, "periodSeconds"), 10), f = So(V(st, "failureThreshold"), 3);
            return p == buoc && p * f >= han ? ("đổi dạng", $"startupProbe {p} s × {f}") : ("SAI", $"startupProbe {p} s × {f}");
        }
        string? tre = V(c, "livenessProbe", "initialDelaySeconds");
        return tre is null ? ("THIẾU", "không có startupProbe") : ("SAI", $"liveness initialDelaySeconds {tre}: kiểm muộn {tre} s, không có startupProbe");
    }),
    (@"^services\.api\.stop_grace_period$", "stop_grace_period", () =>
    {
        double grace = So(V(pod, "terminationGracePeriodSeconds"), 30), cho = PreStop(), can = cho + ShutdownTimeout + KestrelSauAbort;
        string k = $"terminationGracePeriodSeconds {grace}" + (cho > 0 ? $", tính từ trước preStop {cho} s" : "");
        return grace > can ? (cho > 0 ? "đổi dạng" : "khớp", k) : ("SAI", k + $": cần hơn {can} s");
    }),
    (@"^services\.api\.deploy\.update_config\.(parallelism|order)$", "parallelism, start-first", () =>
    {
        var ru = N(dep, "spec", "strategy", "rollingUpdate");
        string k = $"maxSurge {V(ru, "maxSurge") ?? "25%"}, maxUnavailable {V(ru, "maxUnavailable") ?? "25%"}";
        return V(ru, "maxSurge") == S("deploy.update_config.parallelism") && V(ru, "maxUnavailable") == "0" ? ("đổi dạng", k) : ("SAI", k);
    }),
    (@"^services\.api\.deploy\.update_config\.(delay|monitor)$", "delay, monitor", () =>
    {
        double can = Math.Max(double.Parse(Giay(S("deploy.update_config.delay"))), double.Parse(Giay(S("deploy.update_config.monitor"))));
        string? m = V(dep, "spec", "minReadySeconds");
        return m is null ? ("THIẾU", "không có minReadySeconds: bản treo lên cả 4 pod")
            : So(m, 0) >= can ? ("đổi dạng", $"minReadySeconds {m}") : ("SAI", $"minReadySeconds {m} < {can}");
    }),
    (@"^services\.api\.deploy\.update_config\.failure_action$", "failure_action: rollback", () =>
        V(dep, "spec", "progressDeadlineSeconds") is { } h
            ? ("thay bằng quy trình", $"progressDeadlineSeconds {h} chỉ báo lỗi; quay lại bằng git revert")
            : ("THIẾU", "Deployment không tự rollback, không có hạn báo lỗi")),
    (@"^services\.api\.deploy\.rollback_config\.", "rollback_config", () =>
        ("không tương đương", "rollout undo và git revert dùng lại strategy của Deployment")),
    (@"^services\.api\.secrets\[\d\]\.(source|target)$", "secrets", () => BiMat()),
    (@"^secrets\.", "secret external", () =>
        k8s.Any(d => V(d, "kind") == "Secret") ? ("SAI", "Secret nằm trong manifest") : ("khớp", "Secret tạo ngoài Git")),
};
// Swarm làm ngầm, không có khóa trong stack nhưng bài 1 dựa vào.
var ngam = new List<(string Ten, Func<(string, string)> Kiem)>
{
    ("trải 4 replica trên 5 node", () => N(pod, "topologySpreadConstraints") is YamlSequenceNode t
        && t.Children.Any(x => V(x, "maxSkew") == "1" && V(x, "topologyKey") == "kubernetes.io/hostname" && V(x, "whenUnsatisfiable") == "DoNotSchedule")
        ? ("thêm mới", "topologySpreadConstraints maxSkew 1") : ("THIẾU", "mặc định maxSkew 3, ScheduleAnyway")),
    ("vào mesh khi healthcheck đạt", () => N(c, "readinessProbe") is not null
        ? ("thêm mới", $"readinessProbe {V(c, "readinessProbe", "httpGet", "path")}") : ("THIẾU", "pod nhận request trước khi mở cổng")),
    ("drain giữ 3/4 replica", () => pdb is not null ? ("thêm mới", $"PodDisruptionBudget minAvailable {V(pdb, "spec", "minAvailable")}") : ("THIẾU", "không có PodDisruptionBudget")),
};

var ketQua = new List<(string TrangThai, string Ten, string Swarm, string K8s)>();
var daNhan = new HashSet<string>();
foreach (var (mau, ten, kiem) in luat)
{
    var khoa = swarm.Keys.Where(k => Regex.IsMatch(k, mau)).ToList();
    if (khoa.Count == 0) continue;
    daNhan.UnionWith(khoa);
    var (tt, kv) = kiem();
    ketQua.Add((tt, ten, string.Join(", ", khoa.Select(k => swarm[k]).Distinct()), kv));
}
foreach (var (ten, kiem) in ngam) { var (tt, kv) = kiem(); ketQua.Add((tt, ten, "(ngầm)", kv)); }
var chuaNhan = swarm.Keys.Where(k => !daNhan.Contains(k)).ToList();

foreach (var r in ketQua) Console.WriteLine($"{r.TrangThai,-20}{r.Ten,-30}{Cat(r.Swarm, 28),-30}{r.K8s}");
foreach (var k in chuaNhan) Console.WriteLine($"{"CHƯA ÁNH XẠ",-20}{k}");
Console.WriteLine($"{swarm.Count} khóa lá trong stack, {daNhan.Count} được luật nhận, {ketQua.Count} dòng so: " +
    string.Join(", ", ketQua.GroupBy(r => r.TrangThai).OrderBy(g => g.Key).Select(g => $"{g.Key} {g.Count()}")));
int loi = ketQua.Count(r => r.TrangThai is "SAI" or "THIẾU") + chuaNhan.Count;
return loi;

// ---- đọc YAML ----
static List<YamlNode> DocYaml(string f) { var y = new YamlStream(); using var r = File.OpenText(f); y.Load(r); return y.Documents.Select(d => d.RootNode).ToList(); }
static void Phang(YamlNode n, string duong, Dictionary<string, string> ra)
{
    if (n is YamlMappingNode m) foreach (var (k, v) in m.Children) Phang(v, duong == "" ? k.ToString() : $"{duong}.{k}", ra);
    else if (n is YamlSequenceNode s) for (int i = 0; i < s.Children.Count; i++) Phang(s.Children[i], $"{duong}[{i}]", ra);
    else ra[duong] = n.ToString();
}
static YamlNode? N(YamlNode? n, params string[] duong)
{
    foreach (var d in duong)
        if (n is YamlMappingNode m && m.Children.TryGetValue(new YamlScalarNode(d), out var con)) n = con; else return null;
    return n;
}
static string? V(YamlNode? n, params string[] duong) => N(n, duong) is YamlScalarNode s ? s.Value : null;
YamlNode? Env(string ten) => (N(c, "env") as YamlSequenceNode)?.Children.FirstOrDefault(e => V(e, "name") == ten);
double PreStop() => So(V(c, "lifecycle", "preStop", "sleep", "seconds"), 0);

// ---- so giá trị ----
static (string, string) Bang(string? k, string s) => k is null ? ("THIẾU", "-") : k == s ? ("khớp", k) : ("SAI", k);
(string, string) TuPod(string ten, string truong)
{
    var e = Env(ten);
    if (V(e, "valueFrom", "fieldRef", "fieldPath") == truong) return ("đổi dạng", $"fieldRef {truong}");
    return e is null ? ("THIẾU", "-") : ("SAI", $"chuỗi \"{V(e, "value")}\": Kubernetes không thay mẫu của Swarm");
}
static (string, string) Cpu(string? k, string s) => k is null ? ("THIẾU", "-")
    : SoCpu(k) == double.Parse(s, CultureInfo.InvariantCulture) ? (k == s ? "khớp" : "đổi dạng", k) : ("SAI", k);
static (string, string) Ram(string? k, string s) => k is null ? ("THIẾU", "-")
    : Byte(k) == long.Parse(s) ? (k == s ? "khớp" : "đổi dạng", k) : ("SAI", k);
(string, string) BiMat()
{
    var loi = new List<string>(); var dung = new List<string>();
    foreach (int i in new[] { 0, 1 })
    {
        string nguon = S($"secrets[{i}].source"), dich = S($"secrets[{i}].target"), ten = nguon.Replace('_', '-');
        string? tep = TepBiMat(ten);
        if (tep == $"/run/secrets/{dich}") dung.Add($"{ten} -> {tep}"); else loi.Add($"{ten} -> {tep ?? "không gắn"}");
    }
    return loi.Count == 0 ? ("đổi dạng", string.Join("; ", dung)) : ("SAI", string.Join("; ", loi) + ": KeyPerFile không thấy khóa");
}
// Đường dẫn file mà Secret `ten` hiện ra trong container, theo volumeMounts, items và subPath.
string? TepBiMat(string ten)
{
    foreach (var vol in (N(pod, "volumes") as YamlSequenceNode)?.Children ?? [])
    {
        var nguon = N(vol, "secret") is { } s1 ? new[] { s1 } : (N(vol, "projected", "sources") as YamlSequenceNode)?.Children.Select(x => N(x, "secret")).OfType<YamlNode>().ToArray() ?? [];
        foreach (var s in nguon)
        {
            if ((V(s, "secretName") ?? V(s, "name")) != ten) continue;
            string item = (N(s, "items") as YamlSequenceNode)?.Children.Select(x => V(x, "path")).FirstOrDefault() ?? ten;
            var gan = (N(c, "volumeMounts") as YamlSequenceNode)?.Children.FirstOrDefault(m => V(m, "name") == V(vol, "name"));
            if (gan is null) return null;
            return V(gan, "subPath") is not null ? V(gan, "mountPath") : $"{V(gan, "mountPath")!.TrimEnd('/')}/{item}";
        }
    }
    return null;
}
static double So(string? s, double macDinh) => s is null ? macDinh : double.Parse(s, CultureInfo.InvariantCulture);
static double SoCpu(string s) => s.EndsWith('m') ? double.Parse(s[..^1], CultureInfo.InvariantCulture) / 1000 : double.Parse(s, CultureInfo.InvariantCulture);
static long Byte(string s)
{
    var m = Regex.Match(s, @"^(\d+)(Ki|Mi|Gi|k|M|G)?$");
    long x = long.Parse(m.Groups[1].Value);
    return x * m.Groups[2].Value switch { "Ki" => 1L << 10, "Mi" => 1L << 20, "Gi" => 1L << 30, "k" => 1000, "M" => 1_000_000, "G" => 1_000_000_000, _ => 1 };
}
static string Giay(string s) => Regex.Matches(s, @"([\d.]+)(h|ms|m|s)").Sum(m =>
    double.Parse(m.Groups[1].Value, CultureInfo.InvariantCulture) * m.Groups[2].Value switch { "h" => 3600, "m" => 60, "ms" => 0.001, _ => 1 })
    .ToString(CultureInfo.InvariantCulture);
static string Cat(string s, int n) => s.Length <= n ? s : s[..(n - 1)] + "…";

#:package Microsoft.Data.SqlClient@7.1.1
#:property PublishAot=false
// ThuBoCuc.cs: chạy BanHang.Api thật với hai bố cục /run/secrets và hai cách điền BanHang__Node.
//  - kompose 1.38.0: file mang tên Secret, env giữ nguyên chuỗi mẫu của Swarm.
//  - manifest sửa tay: file mang tên khóa cấu hình, env do kubelet điền từ spec.nodeName.
// dotnet run ThuBoCuc.cs   (BanHang.Api.cs ở ./app; tạo rồi xóa database Kumeo_G2 trên LocalDB). Giá trị bí mật là giả.
using System.Diagnostics;
using Microsoft.Data.SqlClient;

const string Master = @"Server=(localdb)\MSSQLLocalDB;Database=master;Integrated Security=true;Encrypt=False";
const string ChuoiSql = @"Server=(localdb)\MSSQLLocalDB;Database=Kumeo_G2;Integrated Security=true;Encrypt=False";
const string KhoaGia = "bhpay_test_sk_GIA_v1_7Qm2Xc9Lp4";
Process.Start("dotnet", "build app/BanHang.Api.cs -o out/api -v q").WaitForExit();
string exe = Path.GetFullPath(Path.Combine("out/api", OperatingSystem.IsWindows() ? "BanHang.Api.exe" : "BanHang.Api"));
await Sql("IF DB_ID('Kumeo_G2') IS NULL CREATE DATABASE Kumeo_G2");
var http = new HttpClient { Timeout = TimeSpan.FromSeconds(3) };

// Bố cục file trong /run/secrets, đúng như hai manifest gắn Secret vào container.
string ThuMuc(string ten, params (string tep, string giaTri)[] tep)
{
    var d = Path.GetFullPath(Path.Combine("bimat", ten));
    if (Directory.Exists(d)) Directory.Delete(d, true);
    Directory.CreateDirectory(d);
    foreach (var (t, v) in tep) File.WriteAllText(Path.Combine(d, t), v);   // như kubelet: không thêm xuống dòng
    return d;
}
var boCuc = new (string ten, string thuMuc, string node)[]
{
    ("kompose 1.38.0", ThuMuc("kompose", ("banhang-sql-v1", ChuoiSql), ("bhpay-api-key-v1", KhoaGia)), "{{.Node.Hostname}}"),
    ("kompose, sửa riêng secret", ThuMuc("kompose-sua-secret", ("ConnectionStrings__BanHang", ChuoiSql), ("BHPay__ApiKey", KhoaGia)), "{{.Node.Hostname}}"),
    ("sửa tay", ThuMuc("sua-tay", ("ConnectionStrings__BanHang", ChuoiSql), ("BHPay__ApiKey", KhoaGia)), "sw-wkr-1"),
};
int cong = 5281;
foreach (var (ten, thuMuc, node) in boCuc)
{
    string url = $"http://127.0.0.1:{cong++}";
    var psi = new ProcessStartInfo(exe, ["--urls", url, "--ThuMucBiMat", thuMuc, "--SqlChoKhoiDongGiay", "5"])
        { RedirectStandardInput = true, RedirectStandardOutput = true, RedirectStandardError = true };
    psi.Environment["BanHang__Node"] = node;   // kompose: chuỗi mẫu; sửa tay: kubelet điền tên node
    var sw = Stopwatch.StartNew();
    var p = Process.Start(psi)!;
    var loi = new List<string>();
    p.OutputDataReceived += (_, _) => { };
    p.ErrorDataReceived += (_, e) => { if (e.Data != null) lock (loi) loi.Add(e.Data); };
    p.BeginOutputReadLine(); p.BeginErrorReadLine();
    while (!p.HasExited && await Ma(url + "/healthz/ready") != 200) await Task.Delay(50);
    Console.WriteLine($"{ten}: {string.Join(", ", Directory.GetFiles(thuMuc).Select(Path.GetFileName))}");
    if (p.HasExited)
    {
        await Task.Delay(200);
        string dong = loi.FirstOrDefault(d => d.Contains("Exception")) ?? "";
        Console.WriteLine($"  không khởi động được, thoát mã {p.ExitCode}: {dong.Split("Exception: ")[^1].Trim()}");
        continue;
    }
    var may = System.Text.Json.JsonDocument.Parse(await http.GetStringAsync(url + "/api/may"));
    Console.WriteLine($"  ready 200 sau {sw.Elapsed.TotalSeconds:F1} s; /api/may trả node = {may.RootElement.GetProperty("node")}");
    p.StandardInput.WriteLine("term"); await p.WaitForExitAsync();
}
SqlConnection.ClearAllPools();
await Sql("ALTER DATABASE Kumeo_G2 SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE Kumeo_G2");
Console.WriteLine($".NET {Environment.Version}, Kumeo_G2 đã xóa");

async Task<int> Ma(string u) { try { using var r = await http.GetAsync(u); return (int)r.StatusCode; } catch { return 0; } }
static async Task Sql(string lenh) { await using var cn = new SqlConnection(Master); await cn.OpenAsync(); await new SqlCommand(lenh, cn).ExecuteNonQueryAsync(); }