微服务，灵活便捷，助力架构平稳升级

见解分享

2023-10-16 06:00:48

微服务架构概述

定义：

微服务架构是一种软件开发和设计方法，将应用程序分解为一组松散耦合、可独立部署和维护的小型服务。每个微服务都有自己独立的进程和端口，负责一个特定的功能。微服务架构允许开发人员快速迭代和部署新功能，并提高应用程序的可扩展性和容错性。

优势：

敏捷开发： 微服务架构允许开发人员并行开发和部署新功能，从而加快开发速度。
可扩展性： 微服务架构可以轻松地进行横向扩展，以满足不断增长的需求。
容错性： 微服务架构中的每个微服务都是独立的，因此单个微服务发生故障不会影响其他微服务。
弹性： 微服务架构可以轻松地添加或删除微服务，以满足不断变化的业务需求。

挑战：

复杂性： 微服务架构的实现比传统架构要复杂，需要更多的开发和运维工作。
协调： 微服务架构中的各个微服务需要协调协作，才能保证应用程序正常运行。
安全： 微服务架构中的每个微服务都有自己的边界，这可能会增加安全风险。

微服务注册中心

定义：

微服务注册中心是一个集中式服务，负责维护所有微服务的列表和元数据。微服务启动时，会向注册中心注册自己的信息，包括服务名称、端口号、IP地址等。微服务客户端在调用服务时，先向注册中心查询服务信息，然后根据查询结果调用相应的微服务。

作用：

服务发现： 微服务注册中心帮助微服务客户端发现可用的微服务实例。
负载均衡： 微服务注册中心可以实现微服务实例的负载均衡，将请求均匀地分配到不同的微服务实例上。
健康检查： 微服务注册中心可以定期检查微服务实例的健康状况，并将不健康的微服务实例从注册列表中移除。

实现方式：

微服务注册中心有两种常见的实现方式：

客户端注册： 在这种方式下，每个微服务客户端负责向注册中心注册自己的信息。
服务端注册： 在这种方式下，每个微服务将自己的信息发送到注册中心，由注册中心负责维护所有微服务的列表。

哈希函数

定义：

哈希函数是一种将任意长度的数据映射到固定长度的字符串的方法。哈希函数具有以下特性：

确定性： 相同的输入数据总是会生成相同的哈希值。
抗冲突性： 不同的输入数据不太可能生成相同的哈希值。
均匀分布： 哈希值在整个哈希空间中均匀分布。

作用：

哈希函数在微服务架构中有以下几种作用：

服务分片： 微服务注册中心可以根据哈希值将微服务实例划分为不同的分片，以便实现负载均衡。
缓存一致性： 微服务可以根据哈希值将数据存储到不同的缓存节点上，以实现缓存一致性。
分布式锁： 微服务可以使用哈希函数来实现分布式锁，以避免并发访问同一资源。

Go语言实现

服务端注册中心实现

package registry

import (
	"fmt"
	"sync"

	"github.com/hashicorp/consul/api"
)

type ConsulRegistry struct {
	client *api.Client
	sync.RWMutex
	services map[string][]string
}

func NewConsulRegistry(addr string) (*ConsulRegistry, error) {
	client, err := api.NewClient(&api.Config{
		Address: addr,
	})
	if err != nil {
		return nil, err
	}

	return &ConsulRegistry{
		client:   client,
		services: make(map[string][]string),
	}, nil
}

func (r *ConsulRegistry) Register(service, instance string) error {
	r.Lock()
	defer r.Unlock()

	services, ok := r.services[service]
	if !ok {
		services = []string{}
	}

	services = append(services, instance)
	r.services[service] = services

	return nil
}

func (r *ConsulRegistry) Deregister(service, instance string) error {
	r.Lock()
	defer r.Unlock()

	services, ok := r.services[service]
	if !ok {
		return fmt.Errorf("service not found: %s", service)
	}

	for i, s := range services {
		if s == instance {
			services = append(services[:i], services[i+1:]...)
			break
		}
	}

	r.services[service] = services

	return nil
}

func (r *ConsulRegistry) GetServices() map[string][]string {
	r.RLock()
	defer r.RUnlock()

	return r.services
}

func (r *ConsulRegistry) GetInstances(service string) ([]string, error) {
	r.RLock()
	defer r.RUnlock()

	services, ok := r.services[service]
	if !ok {
		return nil, fmt.Errorf("service not found: %s", service)
	}

	return services, nil
}

客户端调用实现

package client

import (
	"fmt"
	"hash/crc32"
	"net/http"
	"net/url"

	"github.com/hashicorp/consul/api"
)

type ConsulClient struct {
	client *api.Client
	table  crc32.Table
}

func NewConsulClient(addr string) (*ConsulClient, error) {
	client, err := api.NewClient(&api.Config{
		Address: addr,
	})
	if err != nil {
		return nil, err
	}

	return &ConsulClient{
		client: client,
		table:  crc32.MakeTable(crc32.Castagnoli),
	}, nil
}

func (c *ConsulClient) Call(service string, method string, path string, body []byte) (*http.Response, error) {
	services, err := c.client.Agent().ServicesWithFilter(fmt.Sprintf("Service == \"%s\"", service))
	if err != nil {
		return nil, err
	}

	if len(services) == 0 {
		return nil, fmt.Errorf("service not found: %s", service)
	}

	// 根据哈希值选择一个实例
	hash := crc32.Checksum(body, c.table)
	instance := services[hash%uint32(len(services))]

	// 构建请求地址
	u := url.URL{
		Scheme: "http",
		Host:   instance.Address,
		Path:   path,
	}

	req, err := http.NewRequest(method, u.String(), body)
	if err != nil {
		return nil, err
	}

	// 发送请求
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}

	return resp, nil
}