构建 .NET Core 微服务：现代分布式系统的开发实践

前言

随着应用程序规模的不断扩大和用户需求的多样化，微服务架构成为现代系统开发的热门选择。微服务通过将单体应用拆分成多个独立的服务，每个服务聚焦于单一职责，从而实现灵活、可扩展和易于维护的系统架构。

.NET Core 作为微软推出的跨平台开发框架，具备了构建高性能和可扩展微服务的优势。在本文中，我们将详细介绍如何使用 .NET Core 开发微服务，涵盖关键的设计理念、开发流程和实践。

1. 微服务架构简介

微服务是一种架构风格，它将应用程序划分为多个小型的、独立的服务。每个微服务负责一个特定的业务功能，通常通过 HTTP 或消息队列等通信方式相互交互。

微服务的优点：

• 独立部署： 每个微服务可以独立部署和更新，不会影响其他服务。
• 技术异构性： 每个微服务可以使用不同的技术栈，根据业务需求选择最佳的技术。
• 可扩展性： 各个服务可以根据负载需求单独扩展。

2. 使用 .NET Core 构建微服务

2.1 创建微服务项目

在 .NET Core 中，创建微服务与创建普通的 Web API 项目类似。我们可以使用 dotnet CLI 创建微服务项目：

dotnet new webapi -n MyMicroservice
cd MyMicroservice

这将生成一个基础的 Web API 项目，包含控制器和路由。我们将基于这个项目进行微服务的开发。

2.2 控制器和路由

在微服务中，控制器处理客户端请求，并通过路由将请求分配到特定的操作上。控制器可以通过依赖注入使用服务层逻辑，保证业务逻辑的封装和代码的可维护性。

例如，定义一个简单的 ProductController：

using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;

namespace MyMicroservice.Controllers
{
    // [ApiController] 特性用于标记该类为一个 API 控制器
    [ApiController]
    // [Route] 定义了控制器的路由，"{controller}" 会被替换为控制器类名（这里是 "Product"）
    [Route("api/[controller]")]
    public class ProductController : ControllerBase
    {
        // 注入服务接口，使用依赖注入方式管理业务逻辑
        private readonly IProductService _productService;

        // 构造函数中注入 IProductService，确保控制器拥有业务逻辑服务的引用
        public ProductController(IProductService productService)
        {
            _productService = productService;
        }

        // [HttpGet] 标记该方法为 GET 请求，接收路径中的 id 参数
        [HttpGet("{id}")]
        public async Task<IActionResult> GetProduct(int id)
        {
            // 调用服务方法，异步获取产品信息
            var product = await _productService.GetProductByIdAsync(id);

            // 如果产品不存在，返回 404 NotFound 响应
            if (product == null)
            {
                return NotFound();
            }

            // 如果找到产品，返回 200 OK 响应以及产品数据
            return Ok(product);
        }
    }
}

2.3 使用依赖注入 (DI)

在 .NET Core 中，依赖注入是内置的功能。我们可以在 Startup.cs 文件中配置服务的注册。在微服务架构中，依赖注入可以帮助我们管理服务的生命周期，使得代码更加松耦合。

// 配置服务容器
public void ConfigureServices(IServiceCollection services)
{
    	// 启用控制器服务
        services.AddControllers();

        // 注册 IProductService 和其实现类 ProductService，生命周期为 Scoped（每个请求独立的实例）
        services.AddScoped<IProductService, ProductService>();
}

2.4 数据库访问 - 使用 Entity Framework Core

微服务通常需要与数据库进行交互。在 .NET Core 微服务中，我们可以使用 Entity Framework Core 来处理数据访问。

首先，我们需要安装 Microsoft.EntityFrameworkCore.SqlServer 包：

dotnet add package Microsoft.EntityFrameworkCore.SqlServer

接着在 Startup.cs 中配置数据库上下文：

public void ConfigureServices(IServiceCollection services)
{
    // 注册数据库上下文，使用 SQL Server 作为数据库
    services.AddDbContext<AppDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
}

通过数据库上下文进行数据的 CRUD 操作：

	// 假设这是 ProductService 的实现类
    public class ProductService : IProductService
    {
        // 注入数据上下文类 AppDbContext
        private readonly AppDbContext _context;

        public ProductService(AppDbContext context)
        {
            _context = context;
        }

        // 实现接口中的方法，从数据库中根据产品 ID 获取产品信息
        public async Task<Product> GetProductByIdAsync(int id)
        {
            // 使用 EF Core 的 FindAsync 方法异步查找产品
            return await _context.Products.FindAsync(id);
        }
    }

2.5 API 网关与服务发现

在微服务架构中，通常需要一个 API 网关来统一管理客户端请求，并将请求转发到相应的微服务。可以使用 Ocelot 作为 .NET Core 的 API 网关解决方案。

安装 Ocelot 包：

dotnet add package Ocelot

配置 Ocelot.json 文件来定义路由：

{
  // ReRoutes 定义了一组路由规则，Ocelot 会根据这些规则将上游请求转发到下游服务
  "ReRoutes": [
    {
      // DownstreamPathTemplate 表示下游服务的路径模板，
      // 即当请求被转发到下游服务时，使用该路径
      "DownstreamPathTemplate": "/api/products/{id}",

      // UpstreamPathTemplate 表示上游请求路径模板，
      // 即客户端请求的路径，它会匹配该路径并进行转发
      "UpstreamPathTemplate": "/products/{id}",

      // DownstreamScheme 表示下游服务的协议，
      // 这里使用 http，也可以配置为 https
      "DownstreamScheme": "http",

      // DownstreamHostAndPorts 定义了下游服务的主机地址和端口号，
      // 即请求被转发的目标服务的位置
      "DownstreamHostAndPorts": [
        {
          // Host 是下游服务的主机名，这里是本地服务器
          "Host": "localhost",
          // Port 是下游服务监听的端口号，这里是 5001 端口
          "Port": 5001
        }
      ]
    }
  ]
}

然后在 Startup.cs 中配置 Ocelot：

public void Configure(IApplicationBuilder app)
{
    // 调用 UseOcelot 方法启用 Ocelot 网关中间件，处理传入的请求并根据配置转发到下游服务
    // .Wait() 用于同步等待 Ocelot 启动完成，因为 UseOcelot 返回的是一个异步任务
    app.UseOcelot().Wait();
}

2.6 容器化与部署

微服务的一个重要特性是能够轻松地进行容器化和部署。通过 Docker，我们可以将每个微服务打包为一个独立的容器，方便在不同环境中运行。

创建 Dockerfile：

# 使用微软提供的 ASP.NET Core 基础镜像作为运行时环境
FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
WORKDIR /app

# 将应用程序代码复制到容器中
COPY . .

# 设置容器启动时的入口点，运行应用程序
ENTRYPOINT ["dotnet", "MyMicroservice.dll"]

构建和运行 Docker 镜像：

docker build -t mymicroservice .
docker run -d -p 8080:80 mymicroservice

3. 微服务中的通信方式

3.1 HTTP REST 通信

大多数微服务通过 HTTP 协议和 REST 风格的 API 进行通信，这种方式简单直观，适用于大多数场景。

3.2 消息队列通信

在复杂的微服务架构中，使用消息队列（如 RabbitMQ、Kafka）来实现异步通信和解耦是一种常见的做法。这种模式适用于高并发、事件驱动的场景。

4. 服务监控与日志

为了确保微服务系统的稳定性，监控和日志记录是必不可少的。可以使用 Serilog 和 Prometheus 等工具来记录日志和监控服务的健康状态。

public void ConfigureServices(IServiceCollection services)
{
    // 使用 AddLogging 方法将日志服务添加到服务容器中
    // builder => builder.AddSerilog() 是配置日志服务的回调函数
    // 通过这个回调函数，我们可以配置 Serilog 作为应用程序的日志提供程序
    services.AddLogging(builder => builder.AddSerilog());
}

结论

使用 .NET Core 开发微服务为构建现代分布式系统提供了强大的支持。通过微服务架构，开发者可以灵活地应对复杂的业务需求，提升系统的可扩展性和可靠性。