Lộ Trình .NET: Giới thiệu về .NET Aspire và Dapr cho Phát triển Ứng dụng Cloud-Native

Một hệ tám service trên máy bạn: bốn container hạ tầng, ba API, một worker. docker compose up chạy được, nhưng khi một request chậm bạn phải mở bốn cửa sổ log để đoán nó kẹt ở đâu. .NET Aspire sinh ra để trả lời câu đó trong lúc phát triển; Dapr trả lời câu tương tự ở runtime, bằng sidecar và API chuẩn. Hai công cụ giải hai bài khác nhau, và biết chúng không thay thế nhau là phần quan trọng nhất của bài này.

Cập nhật 2026

  • Aspire 13.x (13.1 là bản vá hiện hành) đi cùng .NET 10. Điểm khác biệt lớn so với bản 8/9: CLI aspire là đường vào chính (aspire new, aspire run, aspire add), và aspire publish/aspire deploy là bước chuyển từ AppHost sang môi trường thật.
  • Dapr 1.19 (SDK Dapr.AspNetCore 1.19) đã ổn định các building block cũ và bổ sung workflow, jobs, distributed lock — những thứ trước đây phải tự viết.
  • Tích hợp Aspire.Hosting.Dapr cho phép AppHost khởi động sidecar và cấu hình component Dapr trong cùng một mô hình tài nguyên.
  • Observability không còn là phần thêm: ServiceDefaults bật OpenTelemetry và dashboard nhận OTLP ngay từ template.

Aspire: mô hình tài nguyên, không phải docker-compose bằng C#

AppHost là một console app tham chiếu tới mọi project và hạ tầng của bạn. Nó không deploy gì cả; nó mô tả quan hệ và khởi động đúng thứ tự khi bạn chạy. Đây là điểm khác biệt căn bản với Compose: Compose mô tả container, Aspire mô tả tài nguyên — project, container, database, endpoint — và biết cách truyền connection string, địa chỉ, health check giữa chúng.

// File: Shop.AppHost/Program.cs
var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddRedis("cache");
var db = builder.AddPostgres("pg").WithDataVolume().AddDatabase("shopdb");

var api = builder.AddProject<Projects.Shop_Api>("api")
    .WithReference(db)
    .WithReference(cache)
    .WithHttpHealthCheck("/health");

var worker = builder.AddProject<Projects.Shop_Worker>("worker")
    .WithReference(db)
    .WaitFor(api);

builder.Build().Run();

WithReference làm hai việc: inject biến môi trường (ví dụ ConnectionStrings__shopdb) và đăng ký địa chỉ để service discovery tìm thấy. WaitFor giữ worker chờ API sẵn sàng — thứ mà depends_on của Compose không làm được vì nó chỉ biết container đã start, chưa biết app đã ready.

Chạy aspire run (hoặc dotnet run --project Shop.AppHost) và dashboard mở ra: danh sách tài nguyên, trạng thái, log, trace, metrics, và biến môi trường đã inject. Trace là thứ đáng giá nhất — một request từ frontend qua API tới Postgres hiện thành một cây, không phải bốn dòng log rời rạc.

ServiceDefaults: phần mặc định mà bạn nên giữ

Template sinh ra project Shop.ServiceDefaults với ba thứ: OpenTelemetry (traces, metrics, logs qua OTLP), health check chuẩn, và cấu hình HttpClient có service discovery + resilience. Mọi service gọi builder.AddServiceDefaults(); API gọi thêm app.MapDefaultEndpoints().

// File: Shop.Api/Program.cs
var builder = WebApplication.CreateBuilder(args);
builder.AddServiceDefaults();   // OTel, health checks, service discovery, resilience

builder.Services.AddHttpClient<CatalogClient>(c => c.BaseAddress = new Uri("https://catalog"));

var app = builder.Build();
app.MapDefaultEndpoints();      // /health và /alive (template chỉ map ngoài Development)
app.MapGet("/orders/{id}", async (string id, CatalogClient catalog) =>
    await catalog.GetItemAsync(id));

Lợi ích thực tế: HttpClient trỏ tới https://catalog hoạt động ở local vì service discovery dịch tên service thành địa chỉ thật, và vẫn hoạt động trên Kubernetes vì DNS ở đó cũng phân giải tên Service. Đó là lý do đừng hard-code http://localhost:5001 — nó phá vỡ cả hai môi trường.

AddStandardResilienceHandler đã bật retry, timeout, circuit breaker theo chuẩn Polly 8. Đừng bọc thêm một lớp retry nữa; retry chồng retry là cách tạo ra bão request khi backend chậm.

Observability mặc định: OTel, không phải log đẹp hơn

ServiceDefaults cấu hình OpenTelemetry với exporter OTLP và đọc endpoint từ biến môi trường chuẩn. Nghĩa là cùng một service chạy trong dashboard local và trong cluster có collector đều gửi telemetry qua cùng một đường; bạn không phải viết lại instrumentation khi đổi môi trường. Resource và span name lấy từ tên tài nguyên, nên trace hiện đúng service nào gọi service nào.

Dashboard Aspire không chỉ phục vụ AppHost: có thể chạy như một dashboard độc lập và trỏ bất kỳ app nào phát OTLP vào đó. Với team chưa có Jaeger/Tempo, đây là cách rẻ nhất để có trace phân tán trong lúc phát triển — nhưng vẫn không thay được backend lưu trữ tập trung cho production.

Kiểm thử với AppHost

Điểm ít người dùng nhưng hữu ích: Aspire.Hosting.Testing cho phép integration test khởi động cả AppHost trong test run, rồi lấy HttpClient trỏ vào một service cụ thể. Bạn test được luồng thật (API + Postgres + Redis) mà không cần docker-compose riêng cho test, và không cần giả lập connection string.

Giới hạn: test này chậm hơn unit test và cần Docker trên máy CI. Giữ chúng ở một project riêng, chạy theo nhóm, đừng trộn vào bộ unit test chạy mỗi lần lưu file.

Dapr: building block qua sidecar

Dapr chạy như một process phụ (sidecar) cạnh app. App gọi sidecar qua HTTP hoặc gRPC; sidecar nói chuyện với Redis, Kafka, PostgreSQL, Key Vault. Điểm mấu chốt: app không cần biết backend là gì, và đổi backend là đổi file component, không đổi code.

Các building block chính ở Dapr 1.19:

  • Service invocation: gọi service khác theo app-id, có retry, mTLS, và name resolution — không cần biết Pod IP.
  • State management: key/value có ETag để optimistic concurrency, backend tuỳ chọn (Redis, Postgres, SQL Server, Cosmos DB).
  • Pub/sub: publish/subscribe qua broker, có at-least-once và dead-letter.
  • Bindings: input (cron, queue, HTTP) và output (gọi hệ ngoài) theo cùng một mô hình.
  • Actors: mô hình single-threaded per actor id, hợp cho trạng thái cần tuần tự hoá; ít dùng trong app CRUD thông thường.
  • Secrets, configuration, distributed lock, workflow, jobs: những thứ trước đây là thư viện tự viết, nay là API chuẩn.
// File: Shop.Api/Program.cs
builder.Services.AddDaprClient();

var app = builder.Build();
app.UseCloudEvents();
app.MapSubscribeHandler();

app.MapPost("/orders", async (Order order, DaprClient dapr) =>
{
    var (existing, etag) = await dapr.GetStateAndETagAsync<Order>("statestore", order.Id);
    if (existing is not null) return Results.Conflict();

    var saved = await dapr.TrySaveStateAsync("statestore", order.Id, order, etag);
    if (!saved) return Results.Conflict();   // ETag cũ: có writer khác chen vào

    await dapr.PublishEventAsync("pubsub", "order-created", order);
    return Results.Accepted();
});

[Topic("pubsub", "order-created")]
public static Task OnOrderCreated(CloudEvent<Order> e, DaprClient dapr)
    => dapr.SaveStateAsync("statestore", "last-order", e.Data);

TrySaveStateAsync với ETag là optimistic concurrency thật, không phải lock phân tán tự chế. Còn PublishEventAsync không nằm trong transaction với state — nếu cần “lưu state và publish cùng thành công”, bạn vẫn phải tự lo outbox. Dapr không biến bài toán đó thành miễn phí.

Sidecar có giá: mỗi lời gọi thêm một hop mạng. Ở mức vài nghìn request/giây, hop đó hiện trong p99. Nếu service của bạn chỉ gọi database trực tiếp và không cần portability giữa cloud, Dapr là thêm một thành phần vận hành mà lợi ích chưa chắc bù.

Dapr trên Kubernetes và cấu hình khai báo

Local: dapr init dựng Redis và Zipkin trong container; dapr run --app-id orders --app-port 8080 -- dotnet run khởi động sidecar cùng app. Cluster: dapr init -k cài control plane, sidecar được inject vào Pod qua annotation dapr.io/enabled, dapr.io/app-id, dapr.io/app-port.

Retry, timeout, circuit breaker của Dapr khai báo trong resiliency.yaml, không nằm trong code. Đây là điểm cộng cho vận hành (đội SRE sửa được policy mà không cần build lại), và cũng là điểm trừ cho debugging (hành vi nằm ở file cấu hình mà lập trình viên ít đọc).

Aspire và Dapr cùng lúc

// File: Shop.AppHost/Program.cs
var builder = DistributedApplication.CreateBuilder(args);

var stateStore = builder.AddDaprStateStore("statestore");
var pubsub = builder.AddDaprPubSub("pubsub");

builder.AddProject<Projects.Shop_Api>("api")
    .WithDaprSidecar()
    .WithReference(stateStore)
    .WithReference(pubsub);

builder.Build().Run();

Gói cần thêm là Aspire.Hosting.Dapr. Với cấu hình này, aspire run khởi động sidecar cho từng service, tạo component YAML, và đưa telemetry của Dapr vào cùng dashboard. Bạn không phải nhớ thứ tự dapr run cho từng service — đây là lợi ích cụ thể nhất của việc dùng cả hai.

Điều Aspire không làm: nó không thay Dapr ở runtime. Trên production, Aspire không chạy; sidecar vẫn do Dapr control plane quản lý. Ngược lại, Dapr không giúp gì cho vòng lặp code của bạn. Hai công cụ, hai giai đoạn.

aspire publish/deploy và giới hạn

aspire publish đọc mô hình tài nguyên và sinh artifact triển khai — manifest Compose hoặc Kubernetes tuỳ publisher bạn dùng. aspire deploy đi thêm một bước cho target được hỗ trợ (ví dụ Azure). Đọc artifact trước khi dùng: nó là điểm khởi đầu đúng về quan hệ và biến môi trường, nhưng không thay được quyết định về probe, resource limit, secret, hay chiến lược rolling update.

Ba giới hạn cần nhớ:

  • AppHost là công cụ phát triển. Dashboard không có auth phù hợp cho production, và không ai muốn nó là single point of failure của môi trường thật.
  • Aspire là .NET-first. Service không phải .NET chỉ tham gia được dưới dạng container hoặc executable — bạn mất phần lớn giá trị của mô hình tài nguyên.
  • Publish ra manifest là “đúng cấu trúc”, không phải “đúng vận hành”. Chart production vẫn cần người viết.

Chọn công cụ nào

Nhu cầu Công cụ Vì sao
Dev local vài service .NET + hạ tầng Aspire AppHost Dashboard, trace, inject cấu hình, không cần viết YAML
Dev local, team đa ngôn ngữ Compose Mọi người đọc được YAML; không phụ thuộc .NET
Prod 1 VM Compose Ít thành phần, dễ vận hành
Prod nhiều replica, autoscale Kubernetes + Helm Rolling update, HPA, PDB
Cần portability runtime giữa cloud Dapr API chuẩn cho state, pub/sub, invocation

Một tổ hợp hợp lý: Aspire cho inner loop, Dapr cho các building block cần portability, Helm cho triển khai. Tổ hợp không hợp lý: dùng Aspire như orchestrator production, hoặc thêm Dapr vào một monolith chỉ có một database.

Cạm bẫy

  • Hard-code địa chỉ service trong app — phá service discovery, và bắt bạn sửa code khi đổi môi trường.
  • Đặt business logic trong AppHost: AppHost là nơi mô tả hạ tầng; logic ở đó không test được và không deploy được.
  • Bật Dapr cho mọi service: mỗi sidecar là một container, một bộ metrics, một thứ có thể hỏng.
  • Dùng Dapr state như database chính: nó là key/value có ETag, không có query, không có transaction đa key.
  • Đóng gói image từ AppHost: image production build từ project service, không từ AppHost.
  • Bỏ ServiceDefaults để “gọn”: mất OTel, mất health endpoint, mất resilience mặc định — ba thứ đắt nhất khi phải thêm lại sau.

Nhìn tới 2027

.NET 11 GA tháng 11/2026 kéo Aspire lên một major mới cùng chu kỳ; hướng đi rõ ràng là publish/deploy mở rộng target và dashboard tích hợp sâu hơn với OTel. Với Dapr, các building block cấp cao (workflow, jobs) sẽ là phần được dùng nhiều nhất, trong khi service invocation và state vẫn là nền. Điều không đổi: sidecar và AppHost đều là hạ tầng thêm — chỉ đáng khi bài toán phân tán của bạn thật.

Checklist

  • AppHost chỉ mô tả tài nguyên; logic nằm trong service.
  • Mọi service gọi AddServiceDefaults; API gọi MapDefaultEndpoints.
  • Không hard-code URL nội bộ; dùng tên tài nguyên.
  • Có integration test chạy trên AppHost cho luồng chính.
  • Dapr chỉ bật cho service thật sự dùng building block.
  • Đọc artifact của aspire publish trước khi đưa vào pipeline deploy.

Đọc tiếp trong series: