12 - Registry - Consumer

I. Registration Center

1.1 service registration and discovery

After using microservices, calls become calls between services.

Inter service calls need to know IP, port and other information.

Before there is no micro service, our call information is usually written in the caller's configuration file (some companies write this information to the database and other public places for maintenance).

Due to the complexity of the business, each service may depend on N other services. If the IP, port and other information of a service changes, the configuration files of all services that depend on the service need to be modified, which is obviously too troublesome.

Some services have multiple instances for load, and the number of instances may be adjusted at any time. If you have to modify the configuration of other services and restart each time you adjust the number of instances, it's too troublesome.

In order to solve this problem, there is a registration center

Suppose we have A service A that needs to call service B, and A service registration discovery component R. The overall process will become three steps:

  1. When service B starts, register capital with the registry
  2. Service A pulls the information of service B from the registry
  3. Service A invokes service B

With the service registration and discovery component, you don't have to modify other related services when modifying service A information

1.2 distributed consistency algorithm

Consistency is the consistency of data. In a distributed system, it can be understood that the values of data in multiple nodes are consistent

Consistency protocol algorithms mainly include Paxos, Raft, ZAB and mission

Specific reference: https://zhuanlan.zhihu.com/p/130332285

Paxos algorithm is a consistency algorithm based on message passing proposed by Leslie Lamport in 1990. It is very difficult to understand. The biggest difference between data synchronization based on Paxos protocol and traditional active and standby methods is that Paxos can ensure the continuous availability of services without data loss by only requiring more than half of the replicas to be online and communicate with each other normally.

Raft is a consistency algorithm designed by Diego Ongaro and John Ousterhout of Stanford University for the purpose of easy understanding. There have been more than a dozen languages of raft algorithm implementation framework, the more famous one is etcd, and Kubernetes of Google also uses etcd as his service discovery framework.

Raft is a simplified version of Paxos. Compared with Paxos, raft emphasizes that it is easy to understand and implement. Like Paxos, raft can provide services as long as more than half of the nodes are normal. This article "ETCD tutorial - 2.Raft Protocol" explains the principle of raft in detail, which is very interesting. Interested students can have a look.

ZooKeeper atomic broadcast (ZAB) is the core algorithm for ZooKeeper to realize distributed data consistency. ZAB draws lessons from Paxos algorithm, but unlike Paxos algorithm, it is a general distributed consistency algorithm. It is an atomic broadcast protocol specially designed for ZooKeeper to support crash recovery

1.3 selection of Registration Center

Five common registries are Zookeeper, Eureka, Nacos, Consul and ETCD

Specific reference: https://blog.csdn.net/lml200701158/article/details/123153513

II. Consul

2.1 introduction

Consul is an open source tool launched by HashiCorp, which is used to realize service discovery and configuration of distributed systems. Compared with other distributed service registration and discovery schemes, consul's scheme is more "one-stop", with built-in service registration and discovery framework, distributed consistency protocol implementation, health check, Key/Value storage and multi data center scheme. It no longer needs to rely on other tools (such as ZooKeeper).

Consul is also relatively simple to use and written in Go language, so it has natural portability (supporting Linux, windows and Mac OS X); The installation package contains only one executable file, which is convenient for deployment and can work seamlessly with lightweight containers such as Docker
Main features of Consul

2.2 consumer features

CP Model, using Raft Algorithm to ensure strong consistency, not availability;

Support service registration and discovery, health examination KV Store Function.

Supporting multiple data centers can avoid single point of failure of a single data center, and its deployment needs to consider network delay, Segmentation, etc.

Support secure service communication, Consul Services can be generated and distributed TLS Certificates to establish mutual TLS connect.

support http and dns Protocol interface;

Officially provided web Management interface

2.3 installation

General installation

Download address: https://www.consul.io/downloads

win

//1 download
//2 add environment variables
//3 execution
consul agent -dev

mac

//1 download
//2 add environment variables
//3 execution
consul agent -dev

docker installation

//1. Use docker to download consumer
//Synchronization time: ntpdate CN pool. ntp. org
docker pull docker.io/library/consul

//2. Modify the consumer tag
docker tag docker.io/library/consul consul

//3 start
docker run -d -p 8500:8500 -p 8300:8300 -p 8301:8301 -p 8302:8302 -p 8600:8600/udp   consul consul agent -dev -client=0.0.0.0

//4 accessing web pages in a browser
// 8500 port: http port. We register the service and find that we use HTTP port
// 8600 port: dns port

//5 dig command to resolve the address and port through the domain name
//The dns address of dig command is 10.0.0.102,
//Port: 8600,
//Domain name: the name of the service service. Automatically generate consumption
//The query type is specified as srv
dig @10.0.0.102 -p 8600 consul.service.consul SRV

III. common API s

3.1 service registration

Reference documents: https://www.consul.io/commands/services/register

// put request
// Address: / v1/agent/service/register
// Service Registration Flags
	-name:The name of the service to register-->Service name
	-id:The ID of the service. This will default to -name if not set-->id Do not set and name agreement
	-tag value - Associate a tag with the service instance. This flag can be specified multiples times.-->Label of the service
	-address - The address of the service. If this isn't specified, it will default to the address registered with the local agent.
	-port - The port of the service.

Registering a presentation using postman

// towards http://10.0.0.102:8500/v1/agent/service/register Send put request
// body data is
{
    "Name":"lqz",
    "ID":"ddd",
    "Tags":["lqz","web"],
    "Address":"127.0.0.1",
    "Port":8080

}

Go language registration

package main

import "fmt"
import consulapi "github.com/hashicorp/consul/api"

const (
	consulAddress = "10.0.0.102:8500"
)

func RegisterConsul(localIP string, localPort int, name string,id string, tags []string) error {
	// Create connection consumer service configuration
	config := consulapi.DefaultConfig()
	config.Address = consulAddress
	client, err := consulapi.NewClient(config)
	if err != nil {
		fmt.Println("consul client error : ", err)
	}

	// Create a service registered to consumer
	registration := new(consulapi.AgentServiceRegistration)
	registration.ID = id
	registration.Name = name //Find this service by this name
	registration.Port = localPort
	//registration.Tags = []string{"lqz", "web"} / / this is a tag. You can find this service according to this, which is equivalent to v1.0 1 this
	registration.Tags = tags //This is a tag. You can find this service according to this, which is equivalent to V1 1 this
	registration.Address = localIP

	// Add consumer health check callback function
	check := new(consulapi.AgentServiceCheck)
	check.HTTP = fmt.Sprintf("http://%s:%d/health", registration.Address, registration.Port)
	check.Timeout = "5s"                         //overtime
	check.Interval = "5s"                        //Health examination frequency
	check.DeregisterCriticalServiceAfter = "30s" // Consumer will automatically delete the registration service 30 seconds after the failure check
	registration.Check = check
	// Register service to consumer
	err = client.Agent().ServiceRegister(registration)
	if err != nil {
		return err
	}
	return nil

}

func main() {
	// 1 registration
	RegisterConsul("192.168.1.1",8080,"lqz_web","lqz_web",[]string{"lqz","web"})

}

3.2 service deletion

reference resources: https://www.consul.io/commands/services/deregister

Registering a presentation using postman

// To http://10.0.0.102:8500/v1/agent/service/deregister/ddd Send put request

go code

func DeleteService() error {
	// Create connection consumer service configuration
	config := consulapi.DefaultConfig()
	config.Address = consulAddress
	client, err := consulapi.NewClient(config)
	if err != nil {
		fmt.Println("consul client error : ", err)
	}

	err = client.Agent().ServiceDeregister("qqq")
	if err != nil {
		return err
	}
	return nil

}

3.3 set up health check

reference resources: https://www.consul.io/api-docs/agent/check#register-check

3.4 access to services

reference resources: https://www.consul.io/api-docs/agent/service#sample-request

Get all

func GetAllService() (map[string]*consulapi.AgentService, error) {
	// Create connection consumer service configuration
	config := consulapi.DefaultConfig()
	config.Address = consulAddress
	client, err := consulapi.NewClient(config)
	if err != nil {
		fmt.Println("consul client error : ", err)
	}
	res, err := client.Agent().Services()
	if err != nil {
		return nil, err
	}
	return res, nil
}

Filtering service

func FilterService() (map[string]*consulapi.AgentService, error) {
	// Create connection consumer service configuration
	config := consulapi.DefaultConfig()
	config.Address = consulAddress
	client, err := consulapi.NewClient(config)
	if err != nil {
		fmt.Println("consul client error : ", err)
	}
	//res, err := client.Agent().ServicesWithFilter(`Service=="lqz-web03" `) / / filter by service name
	res, err := client.Agent().ServicesWithFilter(`Port==8087`) // Filter by port
	if err != nil {
		return nil, err
	}
	return res, nil

}

3.5 multiple registrations of the same service

The same name and different id will put the same name together

Posted by baw on Sun, 22 May 2022 00:48:28 +0300