通过 Python+Nacos实现微服务，细解微服务架构`shigen`是一名擅长多种编程语言的博主，致力于分享技术成长

shigen坚持更新文章的博客写手，擅长Java、python、vue、shell等编程语言和各种应用程序、脚本的开发。记录成长，分享认知，留住感动。 个人IP：shigen

背景

一直以来的想法比较多，然后就用Python编写各种代码脚本。很多的脚本都是通过Python的Flask框架实现，如[file-server]，然后部署到云服务器。但是这样只提供一个端口就可以通过http访问，无异于在互联网上裸奔。而且这样的服务有很多个，一直在想如何实现一个统一认证然后就可以访问这么多的服务。在Java领域最常见的设计就是使用微服务架构，把每个服务拆分出来，然后通过网关统一拦截、验证、分发流量。蹭了一张架构图（发现飞书的模板已经很好了）：

微服务架构设计

那我的Python服务为什么不能设计成微服务架构呢，当然，还没听说过谁家的Python服务是微服务架构的，姑且一试。

代码实现

考虑到大家的技术栈就是Java，以下的python代码将省略部分细节。

有了之前python flask如何注册到nacos踩坑的经验，这次明显顺利的多了。现在本地搭建nacos环境，并支持http访问，推荐docker-compose的方式搭建：shigen/spring-cloud-platform

因为我的Nacos版本是2.0+的，官方的nacos-sdk-python是这样描述的：

Supported Python version：

Python 2.7 Python 3.6 Python 3.7

Supported Nacos version

Nacos 0.8.0 ~ 1.3.2

于是就使用的是官方的API：Open API 指南

我的服务模块是这样细分的：

 microservices-demo/
 ├── nacos/
 ├── api-gateway/
 │   └── app.py
 ├── user-service/
 │   └── app.py
 ├── auth-service/
 │   └── app.py
 └── document-service/
     └── app.py

也就是分成了四个模块：网关、用户中心、鉴权中心、文档中心。接下来就是服务的注册和调用。我们以最简单的auth-service为例：

 NACOS_URL = os.getenv(
     "NACOS_URL", "http://localhost:8848/nacos/v1/ns/instance")
 SERVICE_NAME = "auth-service"
 SERVICE_IP = socket.gethostbyname(socket.gethostname())
 SERVICE_PORT = 5002
 NAMESPACE = "python"
 
 # 发送到Nacos服务注册接口
 def register_service():
     payload = {
         "serviceName": SERVICE_NAME,
         "ip": SERVICE_IP,
         "port": SERVICE_PORT,
         "namespaceId": NAMESPACE,
     }
     response = requests.post(f"{NACOS_URL}", params=payload)
 
 # 每5秒发送一次心跳
 def send_heartbeat():
     while True:
         payload = {
             "serviceName": SERVICE_NAME,
             "ip": SERVICE_IP,
             "port": SERVICE_PORT,
             "namespaceId": NAMESPACE,
         }
         response = requests.put(f"{NACOS_URL}/beat", params=payload)
         time.sleep(5)
 
 # 密码验证，获得token
 @app.route('/auth', methods=['POST'])
 def authenticate():
     pass
 
 # 验证token
 @app.route('/verify', methods=['POST'])
 def verify_token():
     pass
 
 # 服务启动类
 if __name__ == '__main__':
     register_service()
     heartbeat_thread = threading.Thread(target=send_heartbeat)
     heartbeat_thread.daemon = True
     heartbeat_thread.start()
     app.run(port=SERVICE_PORT)

不用尝试读懂代码，很简单：在服务启动的时候注册到nacos，完了就是定时的向nacos发送心跳。@app.route('/auth', methods=['POST'])表示提供一个POST请求方式的/auth接口，然后启动服务：

服务启动

服务启动成功之后，可以看到控制台打印的日志信息。同时提供http访问接口。测试的方式如下：

 curl --location 'http://127.0.0.1:5002/auth' \
 --header 'Content-Type: application/json' \
 --data '{
     "username": "user",
     "password": "pass"
 }'

其他的几个服务也如法炮制。最终Nacos服务注册表如下：

Nacos服务列表

在网关这一块可能稍微有一点区别，复习前面提到的网关的作用：流量的拦截和转发、认证拦截、负载均衡......这里我的网关服务设计如下：

 NACOS_URL = os.getenv(
     "NACOS_URL", "http://localhost:8848/nacos/v1/ns/instance")
 NAMESPACE = "python"
 
 
 def get_service_url(service_name):
     try:
         response = requests.get(
             f"{NACOS_URL}/list?serviceName={service_name}&namespaceId={NAMESPACE}")
         data = response.json()
         if data and data['hosts']:
             service = data['hosts'][0]
             # return f"http://{service['ip']}:{service['port']}"
             # 这里是本机调用测试
             return f"http://localhost:{service['port']}"
     except Exception as e:
         print(f"Error getting service URL: {e}")
     return None
 
 
 @app.route('/<service_name>/<path:path>', methods=['GET', 'POST', 'PUT', 'DELETE'])
 def proxy(service_name, path):
     service_url = get_service_url(service_name)
     if not service_url:
         return jsonify({"error": "Service not found"}), 404
 
     # 认证逻辑
     if service_name != "auth-service":
         token = request.headers.get("Authorization")
         if not token:
             return jsonify({"error": "Missing token"}), 401
 
         auth_url = get_service_url("auth-service")
         if not auth_url:
             return jsonify({"error": "Auth service not found"}), 500
 
         verify_response = requests.post(
             f"{auth_url}/verify", json={"token": token})
         if verify_response.status_code != 200:
             return jsonify({"error": "Invalid token"}), 401
 
     url = f"{service_url}/{path}"
     response = requests.request(
         method=request.method,
         url=url,
         headers={key: value for key,
                  value in request.headers if key != 'Host'},
         data=request.get_data(),
         cookies=request.cookies,
         allow_redirects=False
     )
 
     return (response.content, response.status_code, response.headers.items())
 
 
 if __name__ == '__main__':
     app.run(port=8080)

这里其实就是请求来了之后，从nacos上拉取服务列表。这个服务列表就是服务名称和对应的服务所在机器的IP（service-name和对应的IP集合）。然后选取对应服务所在的机器之一作为目标机器（这里选用的是第一台机器），从请求头中获得token，进行验证和调用。token校验失败则打给认证服务，重新进行登录验证。为此，我还对比了一下Spring Cloud + Nacos的设计：

Nacos注册发现实现

Nacos的API实现的是springframework.cloud.client.discovery的接口，意味着统一的标准：

 package com.alibaba.cloud.nacos.discovery;
 
 public class NacosDiscoveryClient implements DiscoveryClient {
 
         private static final Logger log = LoggerFactory.getLogger(NacosDiscoveryClient.class);
 
         /**
          * Nacos Discovery Client Description.
          */
         public static final String DESCRIPTION = "Spring Cloud Nacos Discovery Client";
 
         private NacosServiceDiscovery serviceDiscovery;
 
         public NacosDiscoveryClient(NacosServiceDiscovery nacosServiceDiscovery) {
                 this.serviceDiscovery = nacosServiceDiscovery;
         }
 
         @Override
         public String description() {
                 return DESCRIPTION;
         }
 
         @Override
         public List<ServiceInstance> getInstances(String serviceId) {
                 try {
                         return serviceDiscovery.getInstances(serviceId);
                 }
                 catch (Exception e) {
                         throw new RuntimeException(
                                         "Can not get hosts from nacos server. serviceId: " + serviceId, e);
                 }
         }
 
         @Override
         public List<String> getServices() {
                 try {
                         return serviceDiscovery.getServices();
                 }
                 catch (Exception e) {
                         log.error("get service name from nacos server fail,", e);
                         return Collections.emptyList();
                 }
         }
 
 }

其中的serviceName和serviceId其实是同一概念，意味着我们可以通过服务名获得全部的部署服务的实例信息，实现自定义的负载均衡调用。这里的原理和我直接从Nacos的API中获得服务列表，默认选取第一台机器进行调用的设计如出一辙。

对于以上的Python代码段，可能文字描述有不详细或者不当之处，借助魔法进行进一步的完善：

这段代码实现了一个反向代理服务器，其主要功能是根据服务名称将请求转发到不同的服务，并在转发前进行认证。具体功能如下：

服务发现：代码通过访问 NACOS（一个服务发现和配置管理平台）来获取目标服务的 URL。NACOS 提供了服务注册和发现的功能，代码中通过 get_service_url(service_name) 函数实现这一功能。

请求转发：当接收到一个请求时，根据 URL 中的 service_name 和 path，代码会将请求转发到相应的目标服务。转发时，保留了原始请求的 HTTP 方法、头信息、数据和 cookies。

认证检查：对于非 auth-service 的请求，代码会检查请求头中是否包含 Authorization token。如果没有 token 或 token 无效，则会返回错误响应。具体步骤如下：

检查请求头中是否包含 Authorization token。

如果没有 token，返回 401 错误（未授权）。

如果有 token，向认证服务（auth-service）发送请求，验证 token 的有效性。

如果 token 无效，返回 401 错误。

错误处理：代码包含了基本的错误处理逻辑，例如当服务 URL 无法获取或认证服务不可用时，返回相应的错误响应。

通过这些功能，该反向代理服务器能够在微服务架构中充当中间层，路由请求并提供统一的认证机制。

这样下来，我们调用服务只需要直接走网关了，其它的服务端口也不用放行，极大程度上保证了数据的安全。此时，我们需要这样调用服务：

服务调用

 curl --location 'http://127.0.0.1:8080/document-service/documents' \
 --header 'Authorization: xxx'

总结

之前微服务的开发中，可能我们借助Spring Cloud部分组件、Nacos，在项目中加上依赖配置，稍微改一下配置文件，服务就可以正常的调用了。其中依赖的SDK如何的工作，可能只是停留在理论上，缺少实操。这次的这个案例很好的展示Python+Nacos如何实现微服务，并从中细解微服务结构和服务之间的调用原理。是不是觉得Nacos其实也不过如此哈，没什么牛掰、独特之处，其实都是草台班子。

与shigen一起，每天不一样！