.NET Aspire и cloud-native приложения C#

var builder = WebApplication.CreateBuilder(args);
 
builder.AddServiceDefaults();
// ... остальной код
var app = builder.Build();
 
app.MapDefaultEndpoints();
// ... остальной код
app.Run();

var postgres = builder.AddPostgres("contentplatform-db");
builder.AddProject<Projects.ContentPlatform_Api>("contentplatform-api")
  .WithReference(postgres);

builder.Services.AddDbContext<ApplicationDbContext>(o =>
  o.UseNpgsql(builder.Configuration.GetConnectionString("contentplatform-db")));

var builder = DistributedApplication.CreateBuilder(args);
 
var redis = builder.AddRedis("cache");
var rabbitMq = builder.AddRabbitMQ("messaging");
var postgres = builder.AddPostgres("database");
 
builder.AddProject<Projects.OrderService>("order-service")
  .WithReference(postgres)
  .WithReference(rabbitMq);
 
builder.AddProject<Projects.CatalogService>("catalog-service")
  .WithReference(postgres)
  .WithReference(redis);
 
builder.AddProject<Projects.WebFrontend>("web-frontend")
  .WithReference("order-service")
  .WithReference("catalog-service");
 
builder.Build().Run();

var postgres = builder.AddPostgres("myapp-db")
    .WithUsername("postgres")
    .WithPassword("secretpassword")
    .WithPgAdmin(); // добавляет веб-интерфейс для управления БД

var redis = builder.AddRedis("myapp-cache");

var rabbitMq = builder.AddRabbitMQ("myapp-queue")
    .WithManagementPlugin(); // добавляет веб-консоль управления

builder.AddProject<Projects.ApiService>("api-service")
    .WithReference(postgres)
    .WithReference(rabbitMq);

var builder = DistributedApplication.CreateBuilder(args);
 
// Внешние сервисы
var postgres = builder.AddPostgres("eshop-db");
var redis = builder.AddRedis("eshop-cache");
var rabbitmq = builder.AddRabbitMQ("eshop-queue");
 
// Наши микросервисы
builder.AddProject<Projects.OrderApi>("order-api")
    .WithReference(postgres)
    .WithReference(rabbitmq);
 
builder.AddProject<Projects.CatalogApi>("catalog-api")
    .WithReference(postgres)
    .WithReference(redis);
 
builder.AddProject<Projects.BlazorFrontend>("frontend")
    .WithReference("order-api")
    .WithReference("catalog-api");
 
builder.Build().Run();

builder.AddContainer("order-api", "order-api:latest")
    .WithReference(postgres)
    .WithReference(rabbitmq);

builder.AddServiceDefaults();

builder.Services.AddHttpClient<ICatalogClient, CatalogClient>(client =>
{
    client.BaseAddress = new Uri("http://catalog-api");
})
.AddStandardResilienceHandler(); // Добавляет политики отказоустойчивости

builder.Services.AddHttpClient<ICatalogClient, CatalogClient>(client =>
{
    client.BaseAddress = new Uri("http://catalog-api");
})
.AddResilienceHandler("CatalogClientPolicy", (builder, context) =>
{
    builder.AddRetry(new HttpRetryStrategyOptions
    {
        MaxRetryAttempts = 5,
        BackoffType = DelayBackoffType.Exponential,
        UseJitter = true
    });
    
    builder.AddCircuitBreaker(new HttpCircuitBreakerStrategyOptions
    {
        FailureRatio = 0.5, // 50% ошибок активируют circuit breaker
        SamplingDuration = TimeSpan.FromSeconds(30),
        BreakDuration = TimeSpan.FromSeconds(60)
    });
});

// Настраиваем RabbitMQ в AppHost
var rabbitmq = builder.AddRabbitMQ("ecommerce-queue");
 
// Подключаем к сервисам
builder.AddProject<Projects.OrderService>("order-service")
  .WithReference(rabbitmq);
builder.AddProject<Projects.InventoryService>("inventory-service")
  .WithReference(rabbitmq);
builder.AddProject<Projects.PaymentService>("payment-service")
  .WithReference(rabbitmq);

public class OrderSaga : MassTransitStateMachine<OrderState>
{
    public OrderSaga()
    {
        Event(() => OrderSubmitted, x => x.CorrelateById(m => m.Message.OrderId));
        Event(() => InventoryReserved, x => x.CorrelateById(m => m.Message.OrderId));
        Event(() => PaymentProcessed, x => x.CorrelateById(m => m.Message.OrderId));
        Event(() => InventoryReservationFailed, x => x.CorrelateById(m => m.Message.OrderId));
        Event(() => PaymentFailed, x => x.CorrelateById(m => m.Message.OrderId));
 
        Initially(
            When(OrderSubmitted)
                .Then(context => {
                    // Логика обработки нового заказа
                    context.Saga.OrderId = context.Message.OrderId;
                    context.Saga.CustomerInfo = context.Message.CustomerInfo;
                })
                .PublishAsync(context => context.Init<ReserveInventory>(new {
                    OrderId = context.Saga.OrderId,
                    Items = context.Message.Items
                }))
                .TransitionTo(AwaitingInventoryReservation)
        );
 
        During(AwaitingInventoryReservation,
            When(InventoryReserved)
                .PublishAsync(context => context.Init<ProcessPayment>(new {
                    OrderId = context.Saga.OrderId,
                    Amount = context.Message.TotalAmount
                }))
                .TransitionTo(AwaitingPaymentConfirmation),
            When(InventoryReservationFailed)
                .PublishAsync(context => context.Init<CancelOrder>(new {
                    OrderId = context.Saga.OrderId,
                    Reason = "Нет в наличии"
                }))
                .TransitionTo(Cancelled)
        );
 
        // ... остальные состояния и переходы
    }
 
    public State AwaitingInventoryReservation { get; private set; }
    public State AwaitingPaymentConfirmation { get; private set; }
    public State Completed { get; private set; }
    public State Cancelled { get; private set; }
 
    public Event<OrderSubmitted> OrderSubmitted { get; private set; }
    public Event<InventoryReserved> InventoryReserved { get; private set; }
    // ... другие события
}

| Конфигурация    | Запросов/сек | Ср. латентность | 95% перцентиль |
|-----------------|--------------|-----------------|----------------|
| Docker Compose  | 953          | 52 мс           | 87 мс          |
| .NET Aspire     | 942          | 54 мс           | 89 мс          |

var builder = WebApplication.CreateBuilder(args);
builder.AddServiceDefaults(); // Магия здесь!
 
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
 
var app = builder.Build();
app.MapDefaultEndpoints();
 
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}
 
app.MapPost("/endpoint", (SomeRequest req) =>
{
    // Логика обработки
    return Results.Ok(new { result = "OK" });
});
 
app.Run();

// EShop.AppHost/Program.cs
var builder = DistributedApplication.CreateBuilder(args);
 
// Инфраструктурные сервисы
var postgres = builder.AddPostgres("ecommerce-db")
    .WithPgAdmin()
    .WithEnvironment("POSTGRES_PASSWORD", "mysecretpassword");
 
var redis = builder.AddRedis("ecommerce-cache");
 
var rabbitmq = builder.AddRabbitMQ("ecommerce-mq")
    .WithManagementPlugin()
    .WithEnvironment("RABBITMQ_DEFAULT_USER", "guest")
    .WithEnvironment("RABBITMQ_DEFAULT_PASS", "guest");
 
// Микросервисы
var catalogApi = builder.AddProject<Projects.Catalog_API>("catalog-api")
    .WithReference(postgres)
    .WithReference(redis);
 
var ordersApi = builder.AddProject<Projects.Orders_API>("orders-api")
    .WithReference(postgres)
    .WithReference(rabbitmq);
    
var paymentApi = builder.AddProject<Projects.Payment_API>("payment-api")
    .WithReference(rabbitmq);
    
var notificationsApi = builder.AddProject<Projects.Notifications_API>("notifications-api")
    .WithReference(rabbitmq);
 
// Клиентское приложение
builder.AddProject<Projects.ShopUI_Blazor>("shop-ui")
    .WithReference(catalogApi)
    .WithReference(ordersApi);
 
builder.Build().Run();

// EShop.ServiceDefaults/Extensions.cs
public static class Extensions
{
    public static IHostApplicationBuilder AddServiceDefaults(this IHostApplicationBuilder builder)
    {
        // Добавляем логирование, трейсинг и метрики
        builder.AddDefaultOpenTelemetry();
        
        // Настраиваем обнаружение сервисов
        builder.Services.AddServiceDiscovery();
        
        // Настраиваем политики отказоустойчивости
        builder.Services.ConfigureHttpClientDefaults(http =>
        {
            http.AddStandardResilienceHandler();
            http.AddServiceDiscovery();
        });
        
        // Добавляем проверки работоспособности
        builder.Services.AddHealthChecks();
        
        return builder;
    }
 
    public static WebApplication MapDefaultEndpoints(this WebApplication app)
    {
        // Добавляем эндпоинты для проверки работоспособности
        app.MapHealthChecks("/healthz");
        app.MapHealthChecks("/ready", new HealthCheckOptions
        {
            Predicate = check => check.Tags.Contains("ready")
        });
        
        return app;
    }
}

// Orders.API/Domain/Order.cs
public class Order : AggregateRoot
{
    private readonly List<OrderItem> _items = new();
    
    public Guid Id { get; private set; }
    public string CustomerId { get; private set; }
    public OrderStatus Status { get; private set; }
    public DateTime CreatedAt { get; private set; }
    public IReadOnlyCollection<OrderItem> Items => _items.AsReadOnly();
    
    private Order() { } // Для ORM
    
    public static Order Create(string customerId, IEnumerable<OrderItem> items)
    {
        var order = new Order
        {
            Id = Guid.NewGuid(),
            CustomerId = customerId,
            Status = OrderStatus.Created,
            CreatedAt = DateTime.UtcNow
        };
        
        order._items.AddRange(items);
        
        order.AddDomainEvent(new OrderCreatedEvent(order.Id, order.CustomerId));
        
        return order;
    }
    
    public void MarkAsPaid()
    {
        if (Status != OrderStatus.Created)
            throw new InvalidOperationException("Cannot mark as paid an order that is not in Created status");
            
        Status = OrderStatus.Paid;
        
        AddDomainEvent(new OrderPaidEvent(Id));
    }
    
    public void Cancel(string reason)
    {
        if (Status == OrderStatus.Delivered || Status == OrderStatus.Cancelled)
            throw new InvalidOperationException("Cannot cancel an order that is already delivered or cancelled");
            
        Status = OrderStatus.Cancelled;
        
        AddDomainEvent(new OrderCancelledEvent(Id, reason));
    }
}

// Orders.API/Application/Commands/CreateOrderCommand.cs
public record CreateOrderCommand(string CustomerId, List<OrderItemDto> Items) : IRequest<Guid>;
 
public class CreateOrderCommandHandler : IRequestHandler<CreateOrderCommand, Guid>
{
    private readonly IOrderRepository _orderRepository;
    private readonly IUnitOfWork _unitOfWork;
    
    public CreateOrderCommandHandler(IOrderRepository orderRepository, IUnitOfWork unitOfWork)
    {
        _orderRepository = orderRepository;
        _unitOfWork = unitOfWork;
    }
    
    public async Task<Guid> Handle(CreateOrderCommand request, CancellationToken cancellationToken)
    {
        var items = request.Items.Select(i => new OrderItem(i.ProductId, i.ProductName, i.Quantity, i.UnitPrice));
        
        var order = Order.Create(request.CustomerId, items);
        
        _orderRepository.Add(order);
        
        await _unitOfWork.SaveChangesAsync(cancellationToken);
        
        return order.Id;
    }
}
 
// Orders.API/Application/Queries/GetOrderByIdQuery.cs
public record GetOrderByIdQuery(Guid OrderId) : IRequest<OrderDto>;
 
public class GetOrderByIdQueryHandler : IRequestHandler<GetOrderByIdQuery, OrderDto>
{
    private readonly IOrderReadRepository _orderReadRepository;
    
    public GetOrderByIdQueryHandler(IOrderReadRepository orderReadRepository)
    {
        _orderReadRepository = orderReadRepository;
    }
    
    public async Task<OrderDto> Handle(GetOrderByIdQuery request, CancellationToken cancellationToken)
    {
        return await _orderReadRepository.GetByIdAsync(request.OrderId, cancellationToken);
    }
}

// Orders.API/Infrastructure/EventStore.cs
public class EventStore : IEventStore
{
    private readonly OrdersDbContext _context;
    
    public EventStore(OrdersDbContext context)
    {
        _context = context;
    }
    
    public async Task SaveEventsAsync(Guid aggregateId, IEnumerable<DomainEvent> events, int expectedVersion, CancellationToken cancellationToken = default)
    {
        var eventEntities = events.Select(e => new EventEntity
        {
            Id = Guid.NewGuid(),
            AggregateId = aggregateId,
            Type = e.GetType().Name,
            Data = JsonSerializer.Serialize(e),
            Timestamp = DateTime.UtcNow,
            Version = ++expectedVersion
        });
        
        await _context.Events.AddRangeAsync(eventEntities, cancellationToken);
        await _context.SaveChangesAsync(cancellationToken);
    }
    
    public async Task<List<DomainEvent>> GetEventsForAggregateAsync(Guid aggregateId, CancellationToken cancellationToken = default)
    {
        var eventEntities = await _context.Events
            .Where(e => e.AggregateId == aggregateId)
            .OrderBy(e => e.Version)
            .ToListAsync(cancellationToken);
            
        return eventEntities.Select(e => 
        {
            var type = Type.GetType($"EShop.Orders.Domain.Events.{e.Type}");
            return (DomainEvent)JsonSerializer.Deserialize(e.Data, type);
        }).ToList();
    }
}

// Orders.API/Controllers/OrdersController.cs
[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
    private readonly IMediator _mediator;
    
    public OrdersController(IMediator mediator)
    {
        _mediator = mediator;
    }
    
    [HttpGet("{id}")]
    [ProducesResponseType(typeof(OrderDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> GetById(Guid id, CancellationToken cancellationToken)
    {
        var order = await _mediator.Send(new GetOrderByIdQuery(id), cancellationToken);
        
        if (order == null)
            return NotFound();
            
        return Ok(order);
    }
    
    [HttpPost]
    [ProducesResponseType(StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    public async Task<IActionResult> Create(CreateOrderRequest request, CancellationToken cancellationToken)
    {
        var orderId = await _mediator.Send(
            new CreateOrderCommand(request.CustomerId, request.Items), 
            cancellationToken);
            
        return CreatedAtAction(nameof(GetById), new { id = orderId }, null);
    }
    
    [HttpPost("{id}/cancel")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> Cancel(Guid id, CancelOrderRequest request, CancellationToken cancellationToken)
    {
        await _mediator.Send(new CancelOrderCommand(id, request.Reason), cancellationToken);
        return NoContent();
    }
}

// Orders.API/Infrastructure/EventPublisher.cs
public class EventPublisher : IEventPublisher
{
    private readonly ILogger<EventPublisher> _logger;
    private readonly IBus _bus;
    
    public EventPublisher(IBus bus, ILogger<EventPublisher> logger)
    {
        _bus = bus;
        _logger = logger;
    }
    
    public async Task PublishAsync<T>(T @event, CancellationToken cancellationToken = default) where T : DomainEvent
    {
        _logger.LogInformation("Publishing event {EventType} with ID {EventId}", 
            typeof(T).Name, @event.Id);
            
        await _bus.PubSub.PublishAsync(@event, cancellationToken);
    }
}

// Orders.API/Program.cs
var builder = WebApplication.CreateBuilder(args);
 
// Добавляем общие настройки Aspire
builder.AddServiceDefaults();
 
// Регистрируем контекст базы данных
builder.Services.AddDbContext<OrdersDbContext>(options =>
    options.UseNpgsql(builder.Configuration.GetConnectionString("ecommerce-db")));
 
// Настраиваем MassTransit с RabbitMQ
builder.Services.AddMassTransit(config =>
{
    config.AddConsumers(Assembly.GetExecutingAssembly());
    
    config.UsingRabbitMq((context, cfg) =>
    {
        cfg.Host(builder.Configuration.GetConnectionString("ecommerce-mq"));
        
        cfg.ConfigureEndpoints(context);
        
        // Настраиваем наблюдаемость
        cfg.UseInstrumentation(serviceName: "orders-api");
    });
});
 
// Регистрируем MediatR
builder.Services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()));
 
// Регистрируем репозитории и сервисы
builder.Services.AddScoped<IOrderRepository, OrderRepository>();
builder.Services.AddScoped<IOrderReadRepository, OrderReadRepository>();
builder.Services.AddScoped<IEventStore, EventStore>();
builder.Services.AddScoped<IEventPublisher, EventPublisher>();
builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
 
var app = builder.Build();
 
// Настраиваем эндпоинты мониторинга
app.MapDefaultEndpoints();
 
app.MapControllers();
 
app.Run();

// Catalog.API/Services/CatalogService.cs
public class CatalogService : ICatalogService
{
    private readonly CatalogDbContext _dbContext;
    private readonly IDistributedCache _cache;
    private readonly ILogger<CatalogService> _logger;
    
    public CatalogService(
        CatalogDbContext dbContext, 
        IDistributedCache cache,
        ILogger<CatalogService> logger)
    {
        _dbContext = dbContext;
        _cache = cache;
        _logger = logger;
    }
    
    public async Task<ProductDto> GetProductByIdAsync(Guid id, CancellationToken cancellationToken)
    {
        // Пробуем получить из кэша
        var cacheKey = $"product:{id}";
        var productJson = await _cache.GetStringAsync(cacheKey, cancellationToken);
        
        if (!string.IsNullOrEmpty(productJson))
        {
            _logger.LogInformation("Cache hit for product {ProductId}", id);
            return JsonSerializer.Deserialize<ProductDto>(productJson);
        }
        
        _logger.LogInformation("Cache miss for product {ProductId}", id);
        
        // Если нет в кэше, получаем из БД
        var product = await _dbContext.Products
            .AsNoTracking()
            .FirstOrDefaultAsync(p => p.Id == id, cancellationToken);
            
        if (product == null)
            return null;
            
        var dto = new ProductDto
        {
            Id = product.Id,
            Name = product.Name,
            Description = product.Description,
            Price = product.Price,
            Stock = product.StockQuantity
        };
        
        // Сохраняем в кэш
        var options = new DistributedCacheEntryOptions
        {
            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)
        };
        
        await _cache.SetStringAsync(
            cacheKey, 
            JsonSerializer.Serialize(dto), 
            options, 
            cancellationToken);
            
        return dto;
    }
}

// Payment.API/Consumers/ProcessPaymentConsumer.cs
public class ProcessPaymentConsumer : IConsumer<ProcessPayment>
{
    private readonly IPaymentProcessor _paymentProcessor;
    private readonly ILogger<ProcessPaymentConsumer> _logger;
    private readonly IBus _bus;
    
    public ProcessPaymentConsumer(
        IPaymentProcessor paymentProcessor,
        ILogger<ProcessPaymentConsumer> logger,
        IBus bus)
    {
        _paymentProcessor = paymentProcessor;
        _logger = logger;
        _bus = bus;
    }
    
    public async Task Consume(ConsumeContext<ProcessPayment> context)
    {
        _logger.LogInformation("Processing payment for order {OrderId}", context.Message.OrderId);
        
        try
        {
            var result = await _paymentProcessor.ProcessAsync(
                context.Message.OrderId,
                context.Message.Amount,
                context.Message.PaymentDetails,
                context.CancellationToken);
                
            if (result.Success)
            {
                _logger.LogInformation("Payment successful for order {OrderId}", context.Message.OrderId);
                
                await _bus.Publish(new PaymentSucceeded
                {
                    OrderId = context.Message.OrderId,
                    TransactionId = result.TransactionId
                }, context.CancellationToken);
            }
            else
            {
                _logger.LogWarning("Payment failed for order {OrderId}: {ErrorMessage}", 
                    context.Message.OrderId, result.ErrorMessage);
                    
                await _bus.Publish(new PaymentFailed
                {
                    OrderId = context.Message.OrderId,
                    Reason = result.ErrorMessage
                }, context.CancellationToken);
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error processing payment for order {OrderId}", context.Message.OrderId);
            
            await _bus.Publish(new PaymentFailed
            {
                OrderId = context.Message.OrderId,
                Reason = "Internal error during payment processing"
            }, context.CancellationToken);
        }
    }
}

var redis = builder.AddRedis("ecommerce-cache");
 
builder.AddProject<Projects.CatalogApi>("catalog-api")
  .WithReference(redis);

// CatalogHub.cs
public class CatalogHub : Hub
{
    public async Task JoinProductGroup(string productId)
    {
        await Groups.AddToGroupAsync(Context.ConnectionId, $"product:{productId}");
    }
}
 
// CatalogService.cs
public class CatalogService
{
    private readonly IDistributedCache _cache;
    private readonly IHubContext<CatalogHub> _hubContext;
    
    // ... конструктор опущен для краткости
    
    public async Task UpdateProductPriceAsync(Guid productId, decimal newPrice)
    {
        // Обновляем в БД
        var product = await _dbContext.Products.FindAsync(productId);
        product.Price = newPrice;
        await _dbContext.SaveChangesAsync();
        
        // Инвалидируем кэш
        await _cache.RemoveAsync($"product:{productId}");
        
        // Уведомляем клиентов в реальном времени
        await _hubContext.Clients.Group($"product:{productId}")
            .SendAsync("ProductUpdated", new { Id = productId, Price = newPrice });
    }
}

builder.Services.AddSignalR()
    .AddStackExchangeRedis(builder.Configuration.GetConnectionString("ecommerce-cache"), options =>
    {
        options.Configuration.ChannelPrefix = "catalog";
    });

private HubConnection _hubConnection;
 
protected override async Task OnInitializedAsync()
{
    _hubConnection = new HubConnectionBuilder()
        .WithUrl(NavigationManager.ToAbsoluteUri("/cataloghub"))
        .WithAutomaticReconnect()
        .Build();
        
    _hubConnection.On<ProductUpdateDto>("ProductUpdated", OnProductUpdated);
    
    await _hubConnection.StartAsync();
    await _hubConnection.SendAsync("JoinProductGroup", ProductId);
}
 
private void OnProductUpdated(ProductUpdateDto update)
{
    // Обновляем UI без перезагрузки страницы
    Product.Price = update.Price;
    StateHasChanged();
}