Docker Swarm ba manager: khởi động lại từng máy mà API trụ sở vẫn bán

#:sdk Microsoft.NET.Sdk.Web
#:package Microsoft.Data.SqlClient@7.1.1
#:property PublishAot=false
// dotnet run BanHang.Api.cs -- --urls http://127.0.0.1:8080 --ThuMucBiMat /duong/dan/tuyet/doi
using Microsoft.AspNetCore.Diagnostics.HealthChecks;
using Microsoft.Data.SqlClient;
using Microsoft.Extensions.Diagnostics.HealthChecks;

var builder = WebApplication.CreateBuilder(args);
// Bài 3: mỗi file trong /run/secrets là một khóa cấu hình, "__" đổi thành ":".
// Thêm sau biến môi trường nên secret thắng nếu trùng khóa.
builder.Configuration.AddKeyPerFile(builder.Configuration["ThuMucBiMat"] ?? "/run/secrets", optional: true);
string chuoiKetNoi = builder.Configuration.GetConnectionString("BanHang")
    ?? throw new InvalidOperationException("Thiếu ConnectionStrings:BanHang (secret ConnectionStrings__BanHang)");
string khoaBhPay = builder.Configuration["BHPay:ApiKey"]
    ?? throw new InvalidOperationException("Thiếu BHPay:ApiKey (secret BHPay__ApiKey)");
if (khoaBhPay.Any(char.IsWhiteSpace))   // không in giá trị, chỉ báo lỗi
    throw new InvalidOperationException($"BHPay:ApiKey có ký tự trắng (dài {khoaBhPay.Length}); tạo secret bằng printf, không để xuống dòng cuối");
builder.Services.AddHttpClient("BHPay", c =>
{
    c.BaseAddress = new Uri(builder.Configuration["BHPay:BaseUrl"] ?? "https://bhpay.banhang.local/");
    c.DefaultRequestHeaders.Add("X-Api-Key", khoaBhPay);
    c.Timeout = TimeSpan.FromSeconds(10);
});

// Bài 2: Swarm gửi SIGTERM rồi chờ stop_grace_period; giữ ShutdownTimeout nhỏ hơn.
builder.Services.Configure<HostOptions>(o => o.ShutdownTimeout = TimeSpan.FromSeconds(15));
var rutCho = TimeSpan.FromSeconds(builder.Configuration.GetValue("RutChoGiay", 0));
var dangDung = false;
builder.Services.AddHealthChecks()
    .AddCheck("dang-dung", () => dangDung ? HealthCheckResult.Unhealthy("đang dừng") : HealthCheckResult.Healthy(), tags: ["ready"])
    .AddAsyncCheck("sql", async ct => await SqlTraLoi(chuoiKetNoi, ct)
        ? HealthCheckResult.Healthy() : HealthCheckResult.Unhealthy("không mở được SQL"), tags: ["ready"]);
var app = builder.Build();

// Bài 1: live không kiểm phụ thuộc nào; ready kiểm SQL và trạng thái dừng.
app.MapHealthChecks("/healthz/live", new HealthCheckOptions { Predicate = _ => false });
app.MapHealthChecks("/healthz/ready", new HealthCheckOptions { Predicate = c => c.Tags.Contains("ready") });
app.Lifetime.ApplicationStopping.Register(() => { dangDung = true; Thread.Sleep(rutCho); });

app.MapGet("/api/may", (IConfiguration c) => new
{
    node = c["BanHang:Node"] ?? Environment.MachineName,   // Swarm điền {{.Node.Hostname}}
    task = c["BanHang:Task"],
    netVersion = Environment.Version.ToString()
});
app.MapPost("/api/thanh-toan/{maLenh}", async (string maLenh, int choMs) =>
{
    await Task.Delay(choMs);                     // thay cho lời gọi BHPay, tối đa 10 s + SQL
    return Results.Text($"da-xu-ly {maLenh}");
});
app.MapGet("/api/bhpay/ping", async (IHttpClientFactory f) =>
    (int)(await f.CreateClient("BHPay").GetAsync("v1/ping")).StatusCode);

// Bài 1: kiểm SQL một lần trước khi mở cổng. Chuỗi kết nối sai thì tiến trình thoát mã 1,
// Swarm thấy task hỏng; còn SQL chập chờn lúc đang chạy thì live vẫn 200, không task nào bị giết.
var han = DateTime.UtcNow.AddSeconds(builder.Configuration.GetValue("SqlChoKhoiDongGiay", 30));
while (!await SqlTraLoi(chuoiKetNoi, CancellationToken.None))
{
    if (DateTime.UtcNow > han) { Console.Error.WriteLine("SQL không trả lời, dừng khởi động"); return 1; }
    await Task.Delay(1000);
}
_ = Task.Run(() =>       // máy thử chạy Windows: "term" qua stdin thay cho SIGTERM; trong container stdin đóng ngay
{
    while (Console.ReadLine() is { } lenh)
        if (lenh == "term") app.Lifetime.StopApplication();   // SIGTERM trên Linux đi vào đúng lời gọi này
});
await app.RunAsync();
return 0;

static async Task<bool> SqlTraLoi(string chuoi, CancellationToken ct)
{
    try
    {
        using var han = CancellationTokenSource.CreateLinkedTokenSource(ct);
        han.CancelAfter(TimeSpan.FromSeconds(2));
        // kiểm nhanh: không tự thử lại khi mở kết nối, quá 2 s là hỏng
        var b = new SqlConnectionStringBuilder(chuoi) { ConnectTimeout = 2, ConnectRetryCount = 0 };
        await using var cn = new SqlConnection(b.ConnectionString);
        await cn.OpenAsync(han.Token);
        await using var cmd = new SqlCommand("SELECT 1", cn);
        return (int)(await cmd.ExecuteScalarAsync(han.Token) ?? 0) == 1;
    }
    catch (Exception e) when (e is SqlException or OperationCanceledException or InvalidOperationException) { return false; }
}

# Image registry.banhang.local/banhang/api. Chưa build trong bài vì không chạy Docker.
FROM mcr.microsoft.com/dotnet/sdk:10.0-noble-aot AS build
WORKDIR /src
COPY BanHang.Api.cs KiemTra.cs ./
RUN dotnet publish BanHang.Api.cs -o /out/api \
 && dotnet publish KiemTra.cs -o /out/kiemtra

FROM mcr.microsoft.com/dotnet/aspnet:10.0
WORKDIR /app
COPY --from=build /out/api ./
COPY --from=build /out/kiemtra/KiemTra /kiemtra/KiemTra
USER $APP_UID
ENTRYPOINT ["dotnet", "BanHang.Api.dll"]

# Stack BanHang.Api trên cụm Swarm trụ sở: sw-mgr-1..3 (manager), sw-wkr-1..2 (worker).
# Triển khai từ một manager: docker stack deploy -c banhang-api.stack.yml banhang
services:
  api:
    image: registry.banhang.local/banhang/api:1.5.0
    environment:
      ASPNETCORE_ENVIRONMENT: Production
      BanHang__Node: "{{.Node.Hostname}}"   # Swarm thay bằng tên node lúc tạo task
      BanHang__Task: "{{.Task.Name}}"
      RutChoGiay: "0"                       # Swarm đã rút task khỏi mesh 2 s trước SIGTERM
    ports:
      - target: 8080                        # cổng mặc định của image ASP.NET Core từ .NET 8
        published: 8080
        protocol: tcp
        mode: ingress                       # routing mesh: node nào cũng nhận cổng 8080
    healthcheck:
      test: ["CMD", "/kiemtra/KiemTra", "http://127.0.0.1:8080/healthz/live"]
      interval: 5s
      timeout: 3s
      retries: 3
      start_period: 60s
      start_interval: 1s
    stop_grace_period: 20s                  # > ShutdownTimeout 15 s + 1 s của Kestrel
    secrets:
      - source: banhang_sql_v1
        target: ConnectionStrings__BanHang  # KeyPerFile đọc thành ConnectionStrings:BanHang
      - source: bhpay_api_key_v1
        target: BHPay__ApiKey
    deploy:
      mode: replicated
      replicas: 4
      resources:
        limits: { cpus: "2", memory: 1024M }
        reservations: { cpus: "0.5", memory: 512M }
      restart_policy:
        condition: any
        delay: 5s
      update_config:
        parallelism: 1
        delay: 90s                          # >= thời gian phát hiện task treo, bài 2
        order: start-first
        failure_action: rollback
        monitor: 90s
        max_failure_ratio: 0
      rollback_config:
        parallelism: 1
        delay: 0s
        order: start-first
        failure_action: pause
        monitor: 30s

secrets:
  banhang_sql_v1:
    external: true                          # tạo trước bằng docker secret create
  bhpay_api_key_v1:
    external: true

// MoHinhCum.cs: mô hình, không phải cụm thật. dotnet run MoHinhCum.cs -- [ms tới live]
// Phần 1: quorum Raft, majority = M/2 + 1 (docs.docker.com, Raft consensus in swarm mode).
// Phần 2: replica còn chạy và còn dời được khi node hỏng; scheduler chọn node ít task của service nhất,
//         hòa thì node ít task tổng nhất (swarmkit manager/scheduler/scheduler.go, nodeLess).
// Phần 3: dòng thời gian của một slot khi drain và khi mất node, theo hằng số trong mã nguồn swarmkit/moby.
double khoiDong = args.Length > 0 ? double.Parse(args[0]) / 1000 : 1.8;   // giây tới live 200, đo ở DoKhoiDong.cs
string[] node = ["sw-mgr-1", "sw-mgr-2", "sw-mgr-3", "sw-wkr-1", "sw-wkr-2"];
const int Replica = 4;
var thietKe = new (string ten, int manager)[] { ("Compose 1 máy", 0), ("Swarm 1 manager", 1), ("Swarm 2 manager", 2), ("Swarm 3 manager", 3), ("Swarm 5 manager", 5) };

// Mọi tập node hỏng có k phần tử
IEnumerable<int[]> ToHop(int n, int k, int tu = 0)
{
    if (k == 0) { yield return []; yield break; }
    for (int i = tu; i <= n - k; i++)
        foreach (var r in ToHop(n, k - 1, i + 1)) yield return [i, .. r];
}

Console.WriteLine("Phần 1-2: 5 node, 4 replica; node trống ban đầu lấy cả 5 khả năng, báo trường hợp xấu nhất");
Console.WriteLine($"{"thiết kế",-17}{"k",3}{"tình huống",11}{"còn quorum",11}{"API còn chạy",13}{"replica ngay",13}{"replica sau dời",16}");
foreach (var (ten, m) in thietKe)
    for (int k = 1; k <= 2; k++)
    {
        int tong = 0, quorum = 0, conChay = 0, xauNgay = int.MaxValue, xauSau = int.MaxValue;
        foreach (var hong in ToHop(node.Length, k))
        {
            tong++;
            bool coQuorum = m == 0 ? !hong.Contains(0) : (m - hong.Count(i => i < m)) >= m / 2 + 1;
            if (coQuorum) quorum++;
            int ngayMin = int.MaxValue, sauMin = int.MaxValue;
            if (m == 0)   // Compose: một container trên sw-mgr-1, không có gì để dời
                ngayMin = sauMin = hong.Contains(0) ? 0 : 1;
            else
                for (int trong = 0; trong < node.Length; trong++)   // node không có replica lúc đầu
                {
                    var soTask = Enumerable.Range(0, node.Length).Select(i => i == trong ? 0 : 1).ToArray();
                    int ngay = Enumerable.Range(0, node.Length).Where(i => !hong.Contains(i)).Sum(i => soTask[i]);
                    // Còn quorum thì manager tạo task thay thế trên node còn sống; mất quorum thì không ai dời.
                    int sau = coQuorum && hong.Length < node.Length ? Replica : ngay;
                    ngayMin = Math.Min(ngayMin, ngay); sauMin = Math.Min(sauMin, sau);
                }
            if (ngayMin > 0) conChay++;
            xauNgay = Math.Min(xauNgay, ngayMin); xauSau = Math.Min(xauSau, sauMin);
        }
        int toiDa = m == 0 ? 1 : Replica;
        Console.WriteLine($"{ten,-17}{k,3}{tong,11}{quorum,11}{conChay,13}{$"{xauNgay}/{toiDa}",13}{$"{xauSau}/{toiDa}",16}");
    }

// Phần 3: một node rời cụm. Hằng số: heartbeat 5 s ± 0,5 s, node DOWN sau 3 chu kỳ (dispatcher.go, period.go);
// restart delay 5 s, không áp cho node drain (restart.go); drain: task cũ dừng xong mới chạy task mới (waitStop);
// task cũ: gỡ khỏi mesh, chờ 2 s rồi SIGTERM (moby controller.go, defaultGossipConvergeDelay);
// có healthcheck: vào mesh khi lần kiểm đầu tiên thành công, start_interval 1 s; không có: vào mesh ngay khi container chạy.
const double Gossip = 2, DungNet = 0.06, ChayContainer = 1, StartInterval = 1, TaiReqGiay = 300;   // DungNet đo ở bài 2
double ChoKiem(double t) => Math.Ceiling(t / StartInterval) * StartInterval;   // lần kiểm thành công đầu tiên sau khi mở cổng
double drainHc = Gossip + DungNet + ChayContainer + ChoKiem(khoiDong);
double drainKhong = Gossip + DungNet + ChayContainer;   // vào mesh ngay khi container chạy, cổng chưa mở
double matNode = 5.5 * 3 + 5 + ChayContainer + ChoKiem(khoiDong);
Console.WriteLine();
Console.WriteLine($"Phần 3: khởi động tới live 200 = {khoiDong:F2} s, tải {TaiReqGiay} request/s chia đều cho task trong mesh");
Console.WriteLine($"  drain, có healthcheck:   3/4 replica trong {drainHc:F1} s, request vào task chưa mở cổng: 0");
Console.WriteLine($"  drain, không healthcheck: 3/4 replica trong {drainKhong:F1} s, rồi task mới nhận 1/4 tải {khoiDong:F2} s khi chưa mở cổng: " +
                  $"{TaiReqGiay / Replica * khoiDong:F0} request bị từ chối");
Console.WriteLine($"  mất node (không drain):  3/4 replica tối đa {matNode:F1} s (16,5 s phát hiện + 5 s restart delay + khởi động)");
Console.WriteLine($"  vá cả 5 node lần lượt bằng drain (4–5 lần dời task): có healthcheck 0, không healthcheck " +
                  $"{4 * TaiReqGiay / Replica * khoiDong:F0}–{5 * TaiReqGiay / Replica * khoiDong:F0} request bị từ chối");

#:package Microsoft.Data.SqlClient@7.1.1
#:property PublishAot=false
// dotnet run DoKhoiDong.cs -- [số lần]   (BanHang.Api.cs và KiemTra.cs ở ../app, bản build ra ../out)
// Bản NativeAOT của KiemTra: dotnet publish ../app/KiemTra.cs -o ../out/kiemtra-aot
using System.Diagnostics;
using Microsoft.Data.SqlClient;

int soLan = args.Length > 0 ? int.Parse(args[0]) : 10;
string app = Path.GetFullPath("../app"), outDir = Path.GetFullPath("../out");
string exe = OperatingSystem.IsWindows() ? ".exe" : "";
Process.Start("dotnet", $"build \"{app}/BanHang.Api.cs\" -o \"{outDir}/api\" -v q").WaitForExit();
Process.Start("dotnet", $"build \"{app}/KiemTra.cs\" -o \"{outDir}/kiemtra\" -v q").WaitForExit();
string apiExe = Path.Combine(outDir, "api", "BanHang.Api" + exe);
// Hai cách chạy KiemTra: qua dotnet (framework-dependent) và bản NativeAOT (dotnet publish KiemTra.cs)
var cachKiem = new List<(string ten, string file, string[] dau)> { ("dotnet KiemTra.dll", "dotnet", [Path.Combine(outDir, "kiemtra", "KiemTra.dll")]) };
string aot = Path.Combine(outDir, "kiemtra-aot", "KiemTra" + exe);
if (File.Exists(aot)) cachKiem.Add(("KiemTra NativeAOT", aot, []));
const string Master = @"Server=(localdb)\MSSQLLocalDB;Database=master;Integrated Security=true;Encrypt=False";
const string Url = "http://127.0.0.1:5181";

// Thư mục giả lập /run/secrets: tên file là khóa cấu hình, ghi không có xuống dòng cuối như printf.
string biMat = Path.GetFullPath("bimat");   // AddKeyPerFile cần đường dẫn tuyệt đối
Directory.CreateDirectory(biMat);
File.WriteAllText(Path.Combine(biMat, "ConnectionStrings__BanHang"),
    @"Server=(localdb)\MSSQLLocalDB;Database=Kumeo_S;Integrated Security=true;Encrypt=False;Application Name=BanHang.Api");
File.WriteAllText(Path.Combine(biMat, "BHPay__ApiKey"), "bhpay_test_sk_GIA_v1_7Qm2Xc9Lp4");
var http = new HttpClient { Timeout = TimeSpan.FromSeconds(3) };

async Task<(int ma, double ms)> Hoi(string duong)
{
    var sw = Stopwatch.StartNew();
    try { using var r = await http.GetAsync(Url + duong); return ((int)r.StatusCode, sw.Elapsed.TotalMilliseconds); }
    catch { return (0, sw.Elapsed.TotalMilliseconds); }   // 0: chưa mở cổng hoặc quá 3 s
}
Process ChayApi(params string[] them)
{
    var psi = new ProcessStartInfo(apiExe, ["--urls", Url, "--ThuMucBiMat", biMat, .. them])
        { RedirectStandardInput = true, RedirectStandardOutput = true, RedirectStandardError = true };
    var p = Process.Start(psi)!;
    p.OutputDataReceived += (_, _) => { };
    p.ErrorDataReceived += (_, e) => { if (e.Data != null) Console.WriteLine("    api: " + e.Data); };
    p.BeginOutputReadLine(); p.BeginErrorReadLine();
    return p;
}
async Task ChoReady(Process p) { while ((await Hoi("/healthz/ready")).ma != 200) { if (p.HasExited) throw new Exception($"API thoát mã {p.ExitCode}"); await Task.Delay(20); } }
async Task Dung(Process p) { p.StandardInput.WriteLine("term"); await p.WaitForExitAsync(); }
async Task SqlMaster(string lenh) { await using var cn = new SqlConnection(Master); await cn.OpenAsync(); await new SqlCommand(lenh, cn).ExecuteNonQueryAsync(); }
async Task<(int ma, double ms, double cpu)> KiemTra((string ten, string file, string[] dau) c, string duong)
{
    var sw = Stopwatch.StartNew();
    var p = Process.Start(new ProcessStartInfo(c.file, [.. c.dau, Url + duong]) { RedirectStandardOutput = true })!;
    await p.WaitForExitAsync();
    return (p.ExitCode, sw.Elapsed.TotalMilliseconds, p.TotalProcessorTime.TotalMilliseconds);
}
string Tk(IEnumerable<double> x) { var s = x.Order().ToArray(); return $"trung vị {s[s.Length / 2]:F0} ms ({s[0]:F0}–{s[^1]:F0})"; }

// 1. Thời gian khởi động tới live 200 và ready 200
await SqlMaster("ALTER DATABASE Kumeo_S SET ONLINE");
var live = new List<double>(); var ready = new List<double>();
for (int lan = 1; lan <= soLan; lan++)
{
    var sw = Stopwatch.StartNew();
    var p = ChayApi();
    double tLive = -1;
    while (true)
    {
        if (p.HasExited) throw new Exception($"API thoát mã {p.ExitCode}");
        if (tLive < 0 && (await Hoi("/healthz/live")).ma == 200) tLive = sw.Elapsed.TotalMilliseconds;
        if (tLive >= 0 && (await Hoi("/healthz/ready")).ma == 200) break;
        await Task.Delay(20);
    }
    live.Add(tLive); ready.Add(sw.Elapsed.TotalMilliseconds);
    await Dung(p);
}
Console.WriteLine($".NET {Environment.Version}, {soLan} lần khởi động");
Console.WriteLine($"  tới live 200:  {Tk(live)}");
Console.WriteLine($"  tới ready 200: {Tk(ready)}");

// 2. Giá một lần chạy KiemTra khi API đang khỏe: thời gian và CPU của tiến trình kiểm
var api = ChayApi();
await ChoReady(api);
foreach (var c in cachKiem)
{
    var kq = new List<(int ma, double ms, double cpu)>();
    for (int i = 0; i < 20; i++) kq.Add(await KiemTra(c, "/healthz/live"));
    Console.WriteLine($"  {c.ten}: mã {string.Join("", kq.Select(k => k.ma).Distinct())}, thời gian {Tk(kq.Select(k => k.ms))}, CPU {Tk(kq.Select(k => k.cpu))}");
}

// 3. Database offline trong lúc chạy: live và ready trả gì, KiemTra trả mã nào
await SqlMaster("ALTER DATABASE Kumeo_S SET OFFLINE WITH ROLLBACK IMMEDIATE");
var l = await Hoi("/healthz/live"); var r = await Hoi("/healthz/ready");
Console.WriteLine($"database offline: live {l.ma} ({l.ms:F0} ms), ready {r.ma} ({r.ms:F0} ms), " +
    $"KiemTra(live) mã {(await KiemTra(cachKiem[^1], "/healthz/live")).ma}, KiemTra(ready) mã {(await KiemTra(cachKiem[^1], "/healthz/ready")).ma}");
await SqlMaster("ALTER DATABASE Kumeo_S SET ONLINE");
var t0 = Stopwatch.StartNew();
await ChoReady(api);
Console.WriteLine($"database online lại: ready 200 sau {t0.Elapsed.TotalMilliseconds:F0} ms; live suốt thời gian đó: {(await Hoi("/healthz/live")).ma}");
await Dung(api);

// 4. Khởi động khi database offline: tiến trình phải thoát mã khác 0, live không bao giờ 200
await SqlMaster("ALTER DATABASE Kumeo_S SET OFFLINE WITH ROLLBACK IMMEDIATE");
t0.Restart();
var hong = ChayApi("--SqlChoKhoiDongGiay", "10");
bool tungLive = false;
while (!hong.HasExited) { tungLive |= (await Hoi("/healthz/live")).ma == 200; await Task.Delay(100); }
Console.WriteLine($"khởi động khi offline: thoát mã {hong.ExitCode} sau {t0.Elapsed.TotalSeconds:F1} s, live từng 200: {(tungLive ? "có" : "không")}");
await SqlMaster("ALTER DATABASE Kumeo_S SET ONLINE");