Введение в Dapr для разработчиков .NET

// Традиционный подход — прямые зависимости от инфраструктуры
builder.Services.AddStackExchangeRedisCache(options => { 
    options.Configuration = "redis:6379"; 
});
 
builder.Services.AddSingleton<IMessageBroker>(provider => 
    new KafkaMessageBroker("kafka:9092"));
 
builder.Services.AddSingleton<ISecretManager>(provider =>
    new AzureKeyVaultClient(new Uri("https://myvault.vault.azure.net")));

// Подход с Dapr — простые, согласованные API
builder.Services.AddDaprClient();
 
// Пример использования в коде:
// Управление состоянием (может быть Redis, Cosmos DB и т.д.)
await daprClient.SaveStateAsync("statestore", "customer-123", customerData);
 
// Обмен сообщениями (может быть Kafka, RabbitMQ и т.д.)
await daprClient.PublishEventAsync("pubsub", "orders", orderData);
 
// Секреты (может быть Azure Key Vault, HashiCorp Vault и т.д.)
var secret = await daprClient.GetSecretAsync("secretstore", "api-keys");

┌────────────────┐  ┌────────────────┐  ┌────────────────┐
│  Микросервис A │  │  Микросервис B │  │  Микросервис C │
└───────┬────────┘  └───────┬────────┘  └───────┬────────┘
        │                   │                   │
        ▼                   ▼                   ▼
┌────────────────┐  ┌────────────────┐  ┌────────────────┐
│  Dapr Сайдкар  │  │  Dapr Сайдкар  │  │  Dapr Сайдкар  │
└───────┬────────┘  └───────┬────────┘  └───────┬────────┘
        │                   │                   │
        ▼                   ▼                   ▼
┌─────────────────────────────────────────────────────────┐
│      Инфраструктурные сервисы (Redis, Kafka, и т.д.)    │
└─────────────────────────────────────────────────────────┘

// Клиентское приложение делает запрос
using Dapr.Client;
 
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDaprClient();
 
var app = builder.Build();
 
app.MapGet("/checkout/{itemId}", async (int itemId, DaprClient daprClient) =>
{
    // Создание данных заказа
    var orderData = new OrderData(itemId, DateTime.UtcNow);
 
    // Вызов сервиса обработки заказов
    var result = await daprClient.InvokeMethodAsync<OrderData, string>(
        "order-processor",
        "process-order",
        orderData);
 
    return Results.Ok(new { Message = $"Заказ {itemId} обработан: {result}" });
});
 
await app.RunAsync();
 
public record OrderData(int ItemId, DateTime OrderedAt);

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
 
app.MapPost("/process-order", (OrderData order) =>
{
    Console.WriteLine($"Обработка заказа {order.ItemId} от {order.OrderedAt}");
    return $"Подтверждение заказа {order.ItemId}: #{Guid.NewGuid().ToString()[..8]}";
});
 
await app.RunAsync();
 
public record OrderData(int ItemId, DateTime OrderedAt);

// Сервис-издатель
using Dapr.Client;
 
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDaprClient();
 
var app = builder.Build();
 
app.MapPost("/create-order", async (OrderRequest request, DaprClient daprClient) =>
{
    var orderEvent = new OrderCreatedEvent(
        request.OrderId,
        request.CustomerId,
        request.Items,
        DateTime.UtcNow
    );
 
    // Публикация события в топик "orders"
    await daprClient.PublishEventAsync("order-events", "orders", orderEvent);
 
    return Results.Accepted();
});
 
await app.RunAsync();
 
public record OrderRequest(Guid OrderId, string CustomerId, List<string> Items);
public record OrderCreatedEvent(Guid OrderId, string CustomerId, List<string> Items, DateTime CreatedAt);

// Сервис-подписчик
using Dapr;
 
var builder = WebApplication.CreateBuilder(args);
 
// Добавление обработки событий Dapr
builder.Services.AddDapr();
builder.Services.AddControllers();
 
var app = builder.Build();
 
// Обязательно для Dapr pub/sub
app.UseCloudEvents();
app.MapSubscribeHandler();
 
// Подписка на топик "orders"
app.MapPost("/events/orders", [Topic("order-events", "orders")] async (OrderCreatedEvent orderEvent) =>
{
    Console.WriteLine($"Обработка заказа {orderEvent.OrderId} для клиента {orderEvent.CustomerId}");
    await ProcessOrderAsync(orderEvent);
    return Results.Ok();
});
 
await app.RunAsync();
 
async Task ProcessOrderAsync(OrderCreatedEvent orderEvent)
{
    // Обработка заказа
    await Task.Delay(100); // Имитация работы
}
 
public record OrderCreatedEvent(Guid OrderId, string CustomerId, List<string> Items, DateTime CreatedAt);

var builder = WebApplication.CreateBuilder(args);
 
// Регистрация DaprClient в DI-контейнере
builder.Services.AddDaprClient();
 
// Для приложений, которые будут получать события Pub/Sub
builder.Services.AddControllers().AddDapr();
 
var app = builder.Build();
 
// Настройка middleware для Pub/Sub
app.UseCloudEvents();
app.MapSubscribeHandler();
 
// Остальная конфигурация приложения
app.MapControllers();
// или
app.MapGet("/...", ...);
 
app.Run();

app.MapGet("/customers/{id}", async (string id, DaprClient daprClient) =>
{
    // Получение состояния из хранилища Dapr
    var customer = await daprClient.GetStateAsync<Customer>("statestore", id);
    if (customer == null)
        return Results.NotFound();
        
    return Results.Ok(customer);
});

using CommunityToolkit.Aspire.Hosting.Dapr;
 
// Program.cs в проекте Aspire AppHost
var builder = DistributedApplication.CreateBuilder(args);
 
// Добавление сервиса Aspire и настройка Dapr
var orderService = builder.AddProject<Projects.OrderService>("orderservice")
.WithDaprSidecar(new DaprSidecarOptions
{
    AppId = "order-api",
    Config = "./dapr/config.yaml",
    ResourcesPaths = ["./dapr/components"]
});
 
// Добавление еще одного сервиса, который будет взаимодействовать с order-service через Dapr
var checkoutService = builder.AddProject<Projects.CheckoutService>("checkoutservice")
.WithDaprSidecar(new DaprSidecarOptions
{
    AppId = "checkout-api",
    Config = "./dapr/config.yaml",
    ResourcesPaths = ["./dapr/components"]
})
// Ссылка на order-service по его Dapr app ID
.WithReference(orderService);
 
builder.Build().Run();

public class Product
{
    public string Id { get; set; } = Guid.NewGuid().ToString();
    public string Name { get; set; }
    public string Description { get; set; }
    public decimal Price { get; set; }
    public int StockLevel { get; set; }
    public DateTime LastUpdated { get; set; } = DateTime.UtcNow;
}

using Dapr.Client;
using Microsoft.AspNetCore.Mvc;
 
[ApiController]
[Route("[controller]")]
public class ProductsController : ControllerBase
{
    private readonly DaprClient _daprClient;
    private readonly ILogger<ProductsController> _logger;
    private const string StateStoreName = "statestore";
    private const string PubSubName = "shopevents";
 
    public ProductsController(DaprClient daprClient, ILogger<ProductsController> logger)
    {
        _daprClient = daprClient;
        _logger = logger;
    }
 
    [HttpGet]
    public async Task<IActionResult> GetAll()
    {
        try
        {
            var products = new List<Product>();
            // В реальной системе здесь был бы запрос к базе данных
            // Для демо добавим пару товаров
            products.Add(new Product 
            { 
                Id = "p1", 
                Name = "Смартфон XYZ", 
                Description = "Флагманская модель 2025 года",
                Price = 79999,
                StockLevel = 15
            });
            
            products.Add(new Product 
            { 
                Id = "p2", 
                Name = "Ноутбук ABC", 
                Description = "Мощный ноутбук для работы и игр",
                Price = 129999,
                StockLevel = 8
            });
            
            return Ok(products);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении списка товаров");
            return StatusCode(500, "Внутренняя ошибка сервера");
        }
    }
 
    [HttpGet("{id}")]
    public async Task<IActionResult> GetById(string id)
    {
        try
        {
            // В реальном приложении получаем из базы данных
            // Для демо используем Dapr state store
            var product = await _daprClient.GetStateAsync<Product>(StateStoreName, $"product-{id}");
            
            if (product == null)
                return NotFound();
                
            return Ok(product);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении товара {ProductId}", id);
            return StatusCode(500, "Внутренняя ошибка сервера");
        }
    }
 
    [HttpPost]
    public async Task<IActionResult> Create(Product product)
    {
        try
        {
            if (string.IsNullOrEmpty(product.Id))
                product.Id = Guid.NewGuid().ToString();
                
            product.LastUpdated = DateTime.UtcNow;
            
            // Сохраняем товар в хранилище состояния Dapr
            await _daprClient.SaveStateAsync(StateStoreName, $"product-{product.Id}", product);
            
            // Публикуем событие о создании нового товара
            await _daprClient.PublishEventAsync(PubSubName, "product-created", product);
            
            return CreatedAtAction(nameof(GetById), new { id = product.Id }, product);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при создании товара");
            return StatusCode(500, "Внутренняя ошибка сервера");
        }
    }
 
    [HttpPut("{id}")]
    public async Task<IActionResult> Update(string id, Product product)
    {
        try
        {
            var existingProduct = await _daprClient.GetStateAsync<Product>(StateStoreName, $"product-{id}");
            
            if (existingProduct == null)
                return NotFound();
                
            product.Id = id;
            product.LastUpdated = DateTime.UtcNow;
            
            await _daprClient.SaveStateAsync(StateStoreName, $"product-{id}", product);
            
            // Публикуем событие об обновлении товара
            await _daprClient.PublishEventAsync(PubSubName, "product-updated", product);
            
            return Ok(product);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при обновлении товара {ProductId}", id);
            return StatusCode(500, "Внутренняя ошибка сервера");
        }
    }
}

var builder = WebApplication.CreateBuilder(args);
 
// Добавляем контроллеры и Dapr
builder.Services.AddControllers().AddDapr();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
 
// Регистрируем DaprClient
builder.Services.AddDaprClient();
 
var app = builder.Build();
 
// Настраиваем промежуточное ПО
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}
 
app.UseHttpsRedirection();
app.UseAuthorization();
 
// Добавляем промежуточное ПО Dapr
app.UseCloudEvents();
app.MapControllers();
app.MapSubscribeHandler();
 
app.Run();

public class OrderItem
{
    public string ProductId { get; set; }
    public string ProductName { get; set; }
    public decimal UnitPrice { get; set; }
    public int Quantity { get; set; }
}
 
public class Order
{
    public string Id { get; set; } = Guid.NewGuid().ToString();
    public string CustomerId { get; set; }
    public List<OrderItem> Items { get; set; } = new List<OrderItem>();
    public decimal TotalAmount => Items.Sum(i => i.UnitPrice * i.Quantity);
    public string Status { get; set; } = "Created";
    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
    public DateTime? CompletedAt { get; set; }
}

using Dapr;
using Dapr.Client;
using Microsoft.AspNetCore.Mvc;
 
[ApiController]
[Route("[controller]")]
public class OrdersController : ControllerBase
{
    private readonly DaprClient _daprClient;
    private readonly ILogger<OrdersController> _logger;
    private const string StateStoreName = "statestore";
    private const string PubSubName = "shopevents";
 
    public OrdersController(DaprClient daprClient, ILogger<OrdersController> logger)
    {
        _daprClient = daprClient;
        _logger = logger;
    }
 
    [HttpPost]
    public async Task<IActionResult> CreateOrder(Order order)
    {
        try
        {
            if (string.IsNullOrEmpty(order.CustomerId))
                return BadRequest("CustomerId is required");
 
            // Проверяем наличие товаров через вызов сервиса каталога
            foreach (var item in order.Items)
            {
                try
                {
                    // Используем Dapr для вызова сервиса каталога
                    var product = await _daprClient.InvokeMethodAsync<object>(
                        HttpMethod.Get,
                        "catalog-service",
                        $"products/{item.ProductId}");
                        
                    if (product == null)
                        return BadRequest($"Product {item.ProductId} not found");
                }
                catch (Exception ex)
                {
                    _logger.LogWarning(ex, "Не удалось проверить наличие товара {ProductId}", item.ProductId);
                    // В реальном приложении здесь был бы механизм Circuit Breaker
                }
            }
 
            // Сохраняем заказ в хранилище состояния
            await _daprClient.SaveStateAsync(StateStoreName, $"order-{order.Id}", order);
            
            // Публикуем событие о создании заказа
            await _daprClient.PublishEventAsync(PubSubName, "order-created", order);
            
            // В реальном приложении здесь бы запускался процесс обработки заказа
            
            return CreatedAtAction(nameof(GetOrder), new { id = order.Id }, order);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при создании заказа");
            return StatusCode(500, "Внутренняя ошибка сервера");
        }
    }
 
    [HttpGet("{id}")]
    public async Task<IActionResult> GetOrder(string id)
    {
        try
        {
            var order = await _daprClient.GetStateAsync<Order>(StateStoreName, $"order-{id}");
            
            if (order == null)
                return NotFound();
                
            return Ok(order);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении заказа {OrderId}", id);
            return StatusCode(500, "Внутренняя ошибка сервера");
        }
    }
    
    [Topic(PubSubName, "product-updated")]
    [HttpPost("product-updated")]
    public async Task<IActionResult> HandleProductUpdate(Product product)
    {
        _logger.LogInformation("Получено уведомление об обновлении товара: {ProductId}", product.Id);
        // Здесь можно обновить информацию о товаре в активных заказах
        return Ok();
    }
}

public class Product
{
    public string Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public decimal Price { get; set; }
    public int StockLevel { get; set; }
    public DateTime LastUpdated { get; set; }
}

var builder = WebApplication.CreateBuilder(args);
 
builder.Services.AddControllers().AddDapr();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
 
// Регистрируем DaprClient
builder.Services.AddDaprClient();
 
var app = builder.Build();
 
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}
 
app.UseHttpsRedirection();
app.UseAuthorization();
 
// Настраиваем Dapr
app.UseCloudEvents();
app.MapControllers();
app.MapSubscribeHandler();
 
app.Run();

public class OrdersController : ControllerBase
{
    // Существующие поля...
    
    // Добавим политику Circuit Breaker
    private static readonly AsyncCircuitBreakerPolicy _circuitBreakerPolicy = 
        Policy.Handle<Exception>()
              .CircuitBreakerAsync(
                  exceptionsAllowedBeforeBreaking: 3,
                  durationOfBreak: TimeSpan.FromSeconds(30),
                  onBreak: (ex, timespan) => {
                      // Лог о размыкании цепи
                      Console.WriteLine($"Circuit broken for {timespan.TotalSeconds}s due to: {ex.Message}");
                  },
                  onReset: () => {
                      Console.WriteLine("Circuit reset");
                  });
    
    // Модифицируем метод создания заказа
    [HttpPost]
    public async Task<IActionResult> CreateOrder(Order order)
    {
        try
        {
            if (string.IsNullOrEmpty(order.CustomerId))
                return BadRequest("CustomerId is required");
 
            // Проверяем наличие товаров с использованием Circuit Breaker
            foreach (var item in order.Items)
            {
                try
                {
                    // Оборачиваем вызов в политику Circuit Breaker
                    await _circuitBreakerPolicy.ExecuteAsync(async () => {
                        var product = await _daprClient.InvokeMethodAsync<object>(
                            HttpMethod.Get,
                            "catalog-service",
                            $"products/{item.ProductId}");
                            
                        if (product == null)
                            throw new Exception($"Product {item.ProductId} not found");
                    });
                }
                catch (BrokenCircuitException)
                {
                    _logger.LogWarning("Circuit is open, using fallback for product {ProductId}", item.ProductId);
                    // Используем резервные данные или кешированную информацию
                    // В реальном приложении здесь могла бы быть логика получения данных из кеша
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Error checking product {ProductId}", item.ProductId);
                    return BadRequest($"Failed to validate product {item.ProductId}");
                }
            }
 
            // Остальная логика создания заказа...
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error creating order");
            return StatusCode(500, "Internal server error");
        }
    }
    
    // Остальные методы...
}

[ApiController]
[Route("[controller]")]
public class OrderProcessingController : ControllerBase
{
    private readonly DaprClient _daprClient;
    private readonly ILogger<OrderProcessingController> _logger;
 
    public OrderProcessingController(DaprClient daprClient, ILogger<OrderProcessingController> logger)
    {
        _daprClient = daprClient;
        _logger = logger;
    }
 
    [Topic("shopevents", "order-created")]
    [HttpPost("handle-new-order")]
    public async Task<IActionResult> HandleNewOrder(Order order)
    {
        _logger.LogInformation("Received new order: {OrderId}", order.Id);
        
        try {
            // Начинаем процесс обработки заказа
            // В реальном приложении здесь мог бы быть запуск Dapr Workflow
            
            // Имитация обработки платежа
            await ProcessPayment(order);
            
            // Резервирование товаров на складе
            await ReserveInventory(order);
            
            // Подготовка к отправке
            await PrepareForShipment(order);
            
            // Обновляем статус заказа
            order.Status = "Processed";
            order.CompletedAt = DateTime.UtcNow;
            
            await _daprClient.SaveStateAsync("statestore", $"order-{order.Id}", order);
            
            // Публикуем событие о завершении обработки
            await _daprClient.PublishEventAsync("shopevents", "order-processed", order);
            
            return Ok();
        }
        catch (Exception ex) {
            _logger.LogError(ex, "Error processing order {OrderId}", order.Id);
            
            // Обновляем статус заказа в случае ошибки
            order.Status = "Processing Failed";
            await _daprClient.SaveStateAsync("statestore", $"order-{order.Id}", order);
            
            return StatusCode(500, "Order processing failed");
        }
    }
    
    private async Task ProcessPayment(Order order)
    {
        _logger.LogInformation("Processing payment for order {OrderId}", order.Id);
        // Имитация задержки обработки платежа
        await Task.Delay(500);
    }
    
    private async Task ReserveInventory(Order order)
    {
        _logger.LogInformation("Reserving inventory for order {OrderId}", order.Id);
        
        // Для каждого товара в заказе обновляем его запас в каталоге
        foreach (var item in order.Items)
        {
            // Используем Dapr резильентное API для вызова сервиса каталога
            try
            {
                await _daprClient.InvokeMethodAsync(
                    HttpMethod.Put,
                    "catalog-service",
                    $"products/{item.ProductId}/reserve",
                    new { Quantity = item.Quantity });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to reserve inventory for product {ProductId}", item.ProductId);
                throw; // Пробрасываем ошибку для отмены всего процесса
            }
        }
    }
    
    private async Task PrepareForShipment(Order order)
    {
        _logger.LogInformation("Preparing order {OrderId} for shipment", order.Id);
        // Имитация подготовки к отправке
        await Task.Delay(700);
    }
}

var builder = WebApplication.CreateBuilder(args);
 
// Существующая настройка...
 
// Настраиваем логирование
builder.Logging.AddConsole();
 
// Включаем трассировку Dapr
builder.Services.AddOpenTelemetryTracing(builder => builder
    .AddAspNetCoreInstrumentation()
    .AddHttpClientInstrumentation()
    .AddZipkinExporter(options =>
    {
        options.Endpoint = new Uri("http://localhost:9411/api/v2/spans");
    }));
 
// Остальная настройка...

[HttpPost]
public async Task<IActionResult> CreateOrder(Order order)
{
    try
    {
        if (string.IsNullOrEmpty(order.CustomerId))
            return BadRequest("CustomerId is required");
 
        // Начинаем распределенную транзакцию
        var transactionId = Guid.NewGuid().ToString();
        
        _logger.LogInformation("Starting transaction {TransactionId} for order creation", transactionId);
        
        // Проверяем и резервируем товары в рамках транзакции
        foreach (var item in order.Items)
        {
            try
            {
                // Добавляем транзакционный контекст к вызову
                var metadata = new Dictionary<string, string>
                {
                    ["Transaction-Id"] = transactionId
                };
                
                var product = await _daprClient.InvokeMethodAsync<Product>(
                    HttpMethod.Get,
                    "catalog-service",
                    $"products/{item.ProductId}",
                    null,
                    metadata);
                    
                if (product == null)
                    return BadRequest($"Product {item.ProductId} not found");
                    
                // Обновляем информацию о товаре в заказе
                item.ProductName = product.Name;
                item.UnitPrice = product.Price;
                
                // Резервируем товар (уменьшаем доступное количество)
                await _daprClient.InvokeMethodAsync(
                    HttpMethod.Put,
                    "catalog-service",
                    $"products/{item.ProductId}/reserve",
                    new { Quantity = item.Quantity },
                    metadata);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error in transaction {TransactionId} for product {ProductId}", 
                                transactionId, item.ProductId);
                                
                // В случае ошибки, отменяем транзакцию
                await AbortTransaction(transactionId, order);
                return BadRequest($"Failed to process product {item.ProductId}: {ex.Message}");
            }
        }
        
        // Если все прошло успешно, создаем заказ
        await _daprClient.SaveStateAsync("statestore", $"order-{order.Id}", order);
        
        // Публикуем событие с указанием транзакции
        var metadata = new Dictionary<string, string>
        {
            ["Transaction-Id"] = transactionId
        };
        
        await _daprClient.PublishEventAsync("shopevents", "order-created", order, metadata);
        
        _logger.LogInformation("Completed transaction {TransactionId} for order {OrderId}", 
                              transactionId, order.Id);
        
        return CreatedAtAction(nameof(GetOrder), new { id = order.Id }, order);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Unexpected error creating order");
        return StatusCode(500, "Internal server error");
    }
}
 
private async Task AbortTransaction(string transactionId, Order order)
{
    _logger.LogWarning("Aborting transaction {TransactionId} for order {OrderId}", 
                      transactionId, order.Id);
    
    // Публикуем событие отмены транзакции
    var metadata = new Dictionary<string, string>
    {
        ["Transaction-Id"] = transactionId
    };
    
    await _daprClient.PublishEventAsync("shopevents", "transaction-aborted", 
                                      new { TransactionId = transactionId, Order = order }, 
                                      metadata);
}

[Topic("shopevents", "transaction-aborted")]
[HttpPost("handle-transaction-abort")]
public async Task<IActionResult> HandleTransactionAbort([FromBody] TransactionAbortEvent abortEvent)
{
    _logger.LogWarning("Processing transaction abort: {TransactionId}", abortEvent.TransactionId);
    
    // В реальной системе здесь был бы код для освобождения зарезервированных ресурсов
    
    return Ok();
}
 
public class TransactionAbortEvent
{
    public string TransactionId { get; set; }
    public object Order { get; set; }
}