Как создать первый микросервис на C# с ASP.NET Core, step by step

ProductMicroservice/
├── Controllers/
│   └── WeatherForecastController.cs
├── Properties/
│   └── launchSettings.json
├── appsettings.json
├── appsettings.Development.json
├── Program.cs
├── Dockerfile (если вы выбрали поддержку Docker)
└── ProductMicroservice.csproj

var builder = WebApplication.CreateBuilder(args);
 
// Добавляем контроллеры и настраиваем JSON сериализацию
builder.Services.AddControllers().AddJsonOptions(options =>
{
    options.JsonSerializerOptions.PropertyNamingPolicy = null;
    options.JsonSerializerOptions.WriteIndented = true;
});
 
// Настраиваем Swagger
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo
    {
        Title = "Product Microservice API",
        Version = "v1",
        Description = "Микросервис для управления продуктами"
    });
});
 
// Здесь позже добавим регистрацию DbContext и репозитория
 
var app = builder.Build();
 
// Настраиваем middleware
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
    app.UseDeveloperExceptionPage();
}
 
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
 
app.Run();

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
 
namespace ProductMicroservice.Models
{
    public class Product
    {
        [Key]
        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public int Id { get; set; }
        
        [Required]
        [StringLength(100)]
        public string Name { get; set; }
        
        [StringLength(500)]
        public string Description { get; set; }
        
        [Required]
        [Column(TypeName = "decimal(18,2)")]
        public decimal Price { get; set; }
        
        public int CategoryId { get; set; }
        
        [ForeignKey("CategoryId")]
        public virtual Category Category { get; set; }
    }
}

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
 
namespace ProductMicroservice.Models
{
    public class Category
    {
        [Key]
        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public int Id { get; set; }
        
        [Required]
        [StringLength(50)]
        public string Name { get; set; }
        
        [StringLength(250)]
        public string Description { get; set; }
        
        public virtual ICollection<Product> Products { get; set; }
    }
}

using Microsoft.EntityFrameworkCore;
using ProductMicroservice.Models;
 
namespace ProductMicroservice.DBContexts
{
    public class ProductContext : DbContext
    {
        public ProductContext(DbContextOptions<ProductContext> options) : base(options)
        {
        }
        
        public DbSet<Product> Products { get; set; }
        public DbSet<Category> Categories { get; set; }
        
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            // Настраиваем связи между моделями
            modelBuilder.Entity<Product>()
                .HasOne(p => p.Category)
                .WithMany(c => c.Products)
                .HasForeignKey(p => p.CategoryId);
                
            // Добавляем начальные данные
            modelBuilder.Entity<Category>().HasData(
                new Category
                {
                    Id = 1,
                    Name = "Электроника",
                    Description = "Электронные устройства"
                },
                new Category
                {
                    Id = 2,
                    Name = "Одежда",
                    Description = "Предметы одежды"
                },
                new Category
                {
                    Id = 3,
                    Name = "Продукты",
                    Description = "Продукты питания"
                }
            );
        }
    }
}

// Регистрируем контекст базы данных
builder.Services.AddDbContext<ProductContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("ProductDB")));

using ProductMicroservice.Models;
using System.Collections.Generic;
 
namespace ProductMicroservice.Repository
{
    public interface IProductRepository
    {
        IEnumerable<Product> GetProducts();
        Product GetProductById(int productId);
        void InsertProduct(Product product);
        void DeleteProduct(int productId);
        void UpdateProduct(Product product);
        void Save();
    }
}

using Microsoft.EntityFrameworkCore;
using ProductMicroservice.DBContexts;
using ProductMicroservice.Models;
using System.Collections.Generic;
using System.Linq;
 
namespace ProductMicroservice.Repository
{
    public class ProductRepository : IProductRepository
    {
        private readonly ProductContext _dbContext;
        
        public ProductRepository(ProductContext dbContext)
        {
            _dbContext = dbContext;
        }
        
        public IEnumerable<Product> GetProducts()
        {
            return _dbContext.Products.Include(p => p.Category).ToList();
        }
        
        public Product GetProductById(int productId)
        {
            return _dbContext.Products
                .Include(p => p.Category)
                .FirstOrDefault(p => p.Id == productId);
        }
        
        public void InsertProduct(Product product)
        {
            _dbContext.Products.Add(product);
        }
        
        public void DeleteProduct(int productId)
        {
            var product = _dbContext.Products.Find(productId);
            if (product != null)
            {
                _dbContext.Products.Remove(product);
            }
        }
        
        public void UpdateProduct(Product product)
        {
            _dbContext.Entry(product).State = EntityState.Modified;
        }
        
        public void Save()
        {
            _dbContext.SaveChanges();
        }
    }
}

// Регистрируем репозиторий
builder.Services.AddScoped<IProductRepository, ProductRepository>();

using Microsoft.AspNetCore.Mvc;
using ProductMicroservice.Models;
using ProductMicroservice.Repository;
using System;
using System.Collections.Generic;
using System.Transactions;
 
namespace ProductMicroservice.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ProductController : ControllerBase
    {
        private readonly IProductRepository _productRepository;
 
        public ProductController(IProductRepository productRepository)
        {
            _productRepository = productRepository;
        }
 
        // GET: api/Product
        [HttpGet]
        public IActionResult Get()
        {
            var products = _productRepository.GetProducts();
            return new OkObjectResult(products);
        }
 
        // GET: api/Product/5
        [HttpGet("{id}", Name = "Get")]
        public IActionResult Get(int id)
        {
            var product = _productRepository.GetProductById(id);
            if (product == null)
            {
                return NotFound();
            }
            return new OkObjectResult(product);
        }
 
        // POST: api/Product
        [HttpPost]
        public IActionResult Post([FromBody] Product product)
        {
            if (product == null)
            {
                return BadRequest("Продукт не может быть пустым");
            }
 
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
 
            using (var scope = new TransactionScope())
            {
                _productRepository.InsertProduct(product);
                _productRepository.Save();
                scope.Complete();
                return CreatedAtAction(nameof(Get), new { id = product.Id }, product);
            }
        }
 
        // PUT: api/Product/5
        [HttpPut("{id}")]
        public IActionResult Put(int id, [FromBody] Product product)
        {
            if (product == null || id != product.Id)
            {
                return BadRequest("Некорректные данные");
            }
 
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
 
            var existingProduct = _productRepository.GetProductById(id);
            if (existingProduct == null)
            {
                return NotFound();
            }
 
            using (var scope = new TransactionScope())
            {
                _productRepository.UpdateProduct(product);
                _productRepository.Save();
                scope.Complete();
                return new OkResult();
            }
        }
 
        // DELETE: api/Product/5
        [HttpDelete("{id}")]
        public IActionResult Delete(int id)
        {
            var product = _productRepository.GetProductById(id);
            if (product == null)
            {
                return NotFound();
            }
 
            using (var scope = new TransactionScope())
            {
                _productRepository.DeleteProduct(id);
                _productRepository.Save();
                scope.Complete();
                return new OkResult();
            }
        }
    }
}

// GET: api/Product
[HttpGet]
public async Task<IActionResult> GetAsync()
{
    var products = await _productRepository.GetProductsAsync();
    return new OkObjectResult(products);
}

public async Task<IEnumerable<Product>> GetProductsAsync()
{
    return await _dbContext.Products.Include(p => p.Category).ToListAsync();
}

[HttpGet]
public async Task<IActionResult> GetAsync([FromQuery] int pageNumber = 1, [FromQuery] int pageSize = 10)
{
    var products = await _productRepository.GetProductsAsync(pageNumber, pageSize);
    
    // Добавляем заголовок с общим количеством элементов
    var totalCount = await _productRepository.GetProductsCountAsync();
    Response.Headers.Add("X-Total-Count", totalCount.ToString());
    
    return new OkObjectResult(products);
}

[HttpGet]
public async Task<IActionResult> GetAsync(
    [FromQuery] int pageNumber = 1,
    [FromQuery] int pageSize = 10,
    [FromQuery] string sortBy = "Id",
    [FromQuery] string filter = "")
{
    var products = await _productRepository.GetProductsAsync(
        pageNumber, pageSize, sortBy, filter);
    
    return new OkObjectResult(products);
}

builder.Logging.ClearProviders();
builder.Logging.AddConsole();
builder.Logging.AddDebug();
builder.Logging.AddEventSourceLogger();
 
// Для продакшн среды можно добавить более продвинутые провайдеры
if (!builder.Environment.IsDevelopment())
{
    builder.Logging.AddJsonConsole(options =>
    {
        options.IncludeScopes = true;
        options.TimestampFormat = "yyyy-MM-dd HH:mm:ss ";
    });
    
    // Можно добавить логирование в файл или внешнюю систему
    // builder.Logging.AddFile("logs/product-service-{Date}.log");
}

private readonly ILogger<ProductController> _logger;
 
public ProductController(IProductRepository productRepository, ILogger<ProductController> logger)
{
    _productRepository = productRepository;
    _logger = logger;
}
 
[HttpGet]
public async Task<IActionResult> GetAsync(...)
{
    _logger.LogInformation("Получение списка продуктов с параметрами: pageNumber={PageNumber}, pageSize={PageSize}", 
        pageNumber, pageSize);
    
    // Остальной код метода
}

public class ErrorHandlingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<ErrorHandlingMiddleware> _logger;
 
    public ErrorHandlingMiddleware(RequestDelegate next, ILogger<ErrorHandlingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Необработанное исключение");
            await HandleExceptionAsync(context, ex);
        }
    }
 
    private static async Task HandleExceptionAsync(HttpContext context, Exception exception)
    {
        context.Response.ContentType = "application/json";
        
        var response = new { error = exception.Message };
        
        switch (exception)
        {
            case KeyNotFoundException:
                context.Response.StatusCode = StatusCodes.Status404NotFound;
                break;
            case ArgumentException:
            case InvalidOperationException:
                context.Response.StatusCode = StatusCodes.Status400BadRequest;
                break;
            default:
                context.Response.StatusCode = StatusCodes.Status500InternalServerError;
                response = new { error = "Произошла внутренняя ошибка сервера." };
                break;
        }
 
        var jsonResponse = JsonSerializer.Serialize(response);
        await context.Response.WriteAsync(jsonResponse);
    }
}

// Добавляем обработчик ошибок в начало пайплайна
app.UseMiddleware<ErrorHandlingMiddleware>();

// Добавляем сервис CORS
builder.Services.AddCors(options =>
{
    options.AddPolicy("AllowSpecificOrigins",
        builder =>
        {
            builder.WithOrigins("http://localhost:3000", "https://yourapplication.com")
                  .AllowAnyHeader()
                  .AllowAnyMethod();
        });
});
 
// И регистрируем его в пайплайне
app.UseCors("AllowSpecificOrigins");

// Добавляем секретный ключ в конфигурацию
var jwtSettings = builder.Configuration.GetSection("JwtSettings");
var secretKey = jwtSettings["Secret"] ?? 
    throw new InvalidOperationException("JWT Secret is not configured");
 
// Настраиваем аутентификацию
builder.Services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
    options.TokenValidationParameters = new TokenValidationParameters
    {
        ValidateIssuer = true,
        ValidateAudience = true,
        ValidateLifetime = true,
        ValidateIssuerSigningKey = true,
        ValidIssuer = jwtSettings["Issuer"],
        ValidAudience = jwtSettings["Audience"],
        IssuerSigningKey = new SymmetricSecurityKey(
            Encoding.UTF8.GetBytes(secretKey))
    };
});

app.UseAuthentication();
app.UseAuthorization();

[Authorize]
[HttpDelete("{id}")]
public async Task<IActionResult> DeleteAsync(int id)
{
    // Метод доступен только аутентифицированным пользователям
}

// Transient - для независимых сервисов
builder.Services.AddTransient<IProductValidator, ProductValidator>();
 
// Scoped - для репозиториев и контекстов БД
builder.Services.AddScoped<IProductRepository, ProductRepository>();
 
// Singleton - для клиентов и кэшей
builder.Services.AddSingleton<HttpClient>();
builder.Services.AddSingleton<IMemoryCache, MemoryCache>();

# .dockerignore
[B]/bin/
[/B]/obj/
[B]/node_modules/
[/B]/.git/
[B]/.vs/
[/B]/Dockerfile*
**/*.user

# Вместо этого
FROM mcr.microsoft.com/dotnet/aspnet:6.0
# Можно использовать более легкий образ
FROM mcr.microsoft.com/dotnet/aspnet:6.0-alpine

// Program.cs - настройка логирования в консоль
builder.Logging.ClearProviders();
builder.Logging.AddConsole();

builder.Logging.AddSeq(builder.Configuration.GetValue<string>("SEQ_URL") ?? "http://localhost:5341");

// Регистрируем метрики Prometheus
app.UseRouting();
 
// Другие middleware...
 
// Добавляем эндпоинт для сбора метрик
app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
    endpoints.MapMetrics(); // Prometheus метрики будут доступны по /metrics
});

private static readonly Counter ProductsCreated = Metrics.CreateCounter(
    "products_created_total", "Number of products created in the system");
 
[HttpPost]
public async Task<IActionResult> Post([FromBody] Product product)
{
    // Основной код...
    
    // Инкрементируем счетчик при создании продукта
    ProductsCreated.Inc();
    
    return CreatedAtAction(nameof(Get), new { id = product.Id }, product);
}

// Добавляем сервис для проверки здоровья
builder.Services.AddHealthChecks()
    .AddDbContextCheck<ProductContext>()
    .AddCheck("self", () => HealthCheckResult.Healthy());
 
// Затем регистрируем эндпоинты
app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
    endpoints.MapHealthChecks("/health", new HealthCheckOptions
    {
        ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
    });
    endpoints.MapMetrics();
});

builder.Services.AddOpenTelemetryTracing(builder => builder
    .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("ProductService"))
    .AddAspNetCoreInstrumentation()
    .AddHttpClientInstrumentation()
    .AddEntityFrameworkCoreInstrumentation()
    .AddJaegerExporter(o =>
    {
        o.AgentHost = builder.Configuration.GetValue<string>("Jaeger:Host") ?? "localhost";
        o.AgentPort = builder.Configuration.GetValue<int>("Jaeger:Port", 6831);
    }));

// Program.cs
// После app.Build() и перед app.Run()
using (var scope = app.Services.CreateScope())
{
    var services = scope.ServiceProvider;
    var context = services.GetRequiredService<ProductContext>();
    
    if (context.Database.GetPendingMigrations().Any())
    {
        context.Database.Migrate();
    }
}