通过 Python+Nacos实现微服务,细解微服务架构

简介: `shigen`是一名擅长多种编程语言的博主,致力于分享技术成长和认知。他尝试将Python服务构建为微服务架构,模仿Java领域的微服务设计。通过Nacos服务发现和注册,实现了Python Flask应用的微服务化,包括网关、用户中心、鉴权和文档服务。代码示例展示了服务注册、心跳维持、HTTP接口以及网关的代理和认证逻辑。此实现促进了服务安全调用,增强了对数据的保护。通过这种方式,`shigen`揭示了Python+Nacos实现微服务的细节,鼓励读者深入理解微服务工作原理。

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服务注册表如下:

服务列表-20240610094917590.(null))

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

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的设计:
image.png

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代码段,可能文字描述有不详细或者不当之处,借助魔法进行进一步的完善:

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

  1. 服务发现:代码通过访问 NACOS(一个服务发现和配置管理平台)来获取目标服务的 URL。NACOS 提供了服务注册和发现的功能,代码中通过 get_service_url(service_name) 函数实现这一功能。
  2. 请求转发:当接收到一个请求时,根据 URL 中的 service_name 和 path,代码会将请求转发到相应的目标服务。转发时,保留了原始请求的 HTTP 方法、头信息、数据和 cookies。
  3. 认证检查:对于非 auth-service 的请求,代码会检查请求头中是否包含 Authorization token。如果没有 token 或 token 无效,则会返回错误响应。具体步骤如下:
    1. 检查请求头中是否包含 Authorization token。
    2. 如果没有 token,返回 401 错误(未授权)。
    3. 如果有 token,向认证服务(auth-service)发送请求,验证 token 的有效性。
    4. 如果 token 无效,返回 401 错误。
  4. 错误处理:代码包含了基本的错误处理逻辑,例如当服务 URL 无法获取或认证服务不可用时,返回相应的错误响应。

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

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

登录

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

服务调用

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

总结

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

与shigen一起,每天不一样!

目录
相关文章
|
1天前
|
Kubernetes API 开发者
探索现代后端开发中的微服务架构
【7月更文挑战第17天】本文深入探讨了微服务架构在现代后端开发中的应用,分析了其设计原则、优势以及面临的挑战。通过具体实例,展示了如何有效实施微服务架构,并讨论了相关技术栈的选择。文章旨在为后端开发者提供微服务实施的指导和最佳实践。
|
2天前
|
运维 监控 API
探索微服务架构:从理论到实践
【7月更文挑战第16天】本文旨在深入探讨微服务架构的核心概念、设计原则以及在实际应用中所面临的挑战与解决策略。通过对微服务的定义和优势进行阐述,分析其在现代软件开发中的重要性,并结合具体案例,展示如何将微服务理念应用于实际项目中,以提升系统的可维护性、可扩展性和敏捷性。
14 6
|
2天前
|
消息中间件 负载均衡 网络协议
探索微服务架构中的服务通信模式
【7月更文挑战第16天】在微服务架构的海洋中,服务间的通信宛如细丝相连,维系着整个系统的协同与和谐。本文将深入探讨微服务之间如何通过同步与异步通信模式进行交互,并剖析这些模式背后的技术原理及其对系统性能和可扩展性的影响。我们将从理论到实践,一探究竟。
16 6
|
1天前
|
安全 数据安全/隐私保护 UED
优化用户体验:前后端分离架构下Python WebSocket实时通信的性能考量
【7月更文挑战第17天】前后端分离趋势下,WebSocket成为实时通信的关键,Python有`websockets`等库支持WebSocket服务。与HTTP轮询相比,WebSocket减少延迟,提高响应。连接管理、消息传输效率、并发处理及安全性是性能考量重点。使用WebSocket能优化用户体验,尤其适合社交、游戏等实时场景。开发应考虑场景需求,充分利用WebSocket优势。
10 3
|
2天前
|
缓存 负载均衡 监控
探索微服务架构中的API网关模式
【7月更文挑战第16天】在微服务架构的复杂网络中,API网关扮演着交通枢纽的角色,它不仅简化了客户端与众多微服务间的交互,还提升了整个系统的可扩展性与安全性。本文将深入探讨API网关的核心概念、设计模式以及在实际应用中的考量因素,为开发者提供实现高效、稳定微服务系统的实用指南。
14 4
|
22小时前
|
消息中间件 运维 API
探索后端开发中的微服务架构实践
本文将深入探讨微服务架构在后端开发中的应用,包括其设计原则、优势与挑战。通过对具体案例的分析,我们将了解如何在实际项目中有效实施微服务,以及如何克服实施过程中的常见问题。文章旨在为后端开发人员提供一套微服务架构的实践指南,帮助他们构建更加灵活、可扩展的系统。
8 1
|
2天前
|
测试技术 调度 微服务
微服务架构下的两类测试
【7月更文挑战第16天】微服务架构下的两类测试:流量录制回放测试和仿真环境测试
|
21小时前
|
存储 监控 持续交付
微服务架构的演进与挑战
随着软件工程领域的快速发展和云计算技术的广泛应用,微服务架构作为现代软件开发的一种重要范式,已经引起了业界的广泛关注。本文将探讨微服务架构的演进过程、面临的主要挑战以及应对策略,旨在为软件开发人员提供深入理解和实践微服务架构的参考。
|
21小时前
|
负载均衡 安全 API
探索微服务架构中的API网关模式
在微服务架构的海洋中,API网关犹如一座灯塔,为迷失方向的请求指引道路。本文将深入探讨API网关的设计哲学、核心功能及其在系统架构中的关键作用。我们将从流量控制、安全防护到服务聚合等多个维度剖析API网关的重要性,并结合实例分析其在实际项目中的运用。
|
1天前
|
运维 负载均衡 前端开发
深度解析:Python Web前后端分离架构中WebSocket的选型与实现策略
【7月更文挑战第16天】Python Web开发中,前后端分离常见于实时通信场景,WebSocket作为全双工协议,常用于此类应用。选型时考虑性能、功能、易用性、社区支持和成本。Flask-SocketIO是实现WebSocket的一个选项,它简化了与Flask的集成。案例展示了如何用Flask-SocketIO创建一个实时聊天室:后端处理消息广播,前端通过Socket.IO库连接并显示消息。此实现策略演示了在Python中实现实时通信的基本步骤。
11 0