Shulou(Shulou.com)06/01 Report--

This article will explain in detail how to implement the basic deployment of Service Mesh micro-service architecture. The content of the article is of high quality, so the editor will share it with you for reference. I hope you will have some understanding of the relevant knowledge after reading this article.

At present, a large number of companies have completed the migration from single architecture to micro-service architecture, and when they are tired of dealing with a large number of communication problems between micro-services, they begin to consider using Service Mesh micro-service architecture as a transparent management framework for direct communication between services, and implement the advanced management functions required by various businesses in a plug-in way.

On the other hand, open source PaaS Rainbond provides an out-of-the-box Service Mesh micro-service architecture, and the applications deployed on Rainbond are Service Mesh micro-service architecture applications.

Next, we will take Rainbond v3.7.0 as the basic platform and take the open source mall project sockshop as an example to demonstrate how to transform the project into a highly reliable e-commerce business system with the capabilities of service registration and discovery, distributed tracking, Amax B testing, grayscale release, current limit, circuit breaker, performance analysis, high availability, log analysis and so on.

Sockshop is a typical case of micro-service architecture, with user management, commodity management, shopping cart, order process, address management and other perfect e-commerce related functions. Sockshop is mainly developed by Spring boot, Golang, Nodejs and other languages, and uses a variety of databases such as MySQL and MongoDB. The original scheme adopts the deployment mode in a stand-alone environment and lacks service governance and distributed capabilities.

Overview of the Topology Diagram after sockshop deployment

Preview of sockshop Mall's home page

Sockshop architecture diagram

More information

Source code address

Sample weavesocksdemo

Sockshop deployment process in Rainbond STEP1 service creation

Rainbond supports application deployment in various ways, such as source code, image, application market, and so on. Here, we create all the services contained in sockshop in batches by creating DockerCompose configuration files.

Docker-compose creation

It should be noted that in the process of detection and creation, it will take some time to obtain a large number of images. Please wait patiently for completion.

Docker-compose source code: download

Version: '2'services: front-end: image: weaveworksdemos/front-end:0.3.12 hostname: front-end restart: always cap_drop:-all ports:-"8079 carts 8079"-"9001 carts 9001" depends_on:-catalogue-carts-payment-user-orders edge-router: image: weaveworksdemos/edge-router:0.1. 1 ports: -'80 CHOWN 80' cap_drop:-all cap_add:-NET_BIND_SERVICE-CHOWN-SETGID-SETUID-DAC_OVERRIDE tmpfs:-/ var/run:rw Noexec Nosuid hostname: edge-router restart: always depends_on:-front-end catalogue: image: weaveworksdemos/catalogue:0.3.5 hostname: catalogue restart: always cap_drop:-all cap_add:-NET_BIND_SERVICE depends_on:-catalogue-db-zipkin catalogue-db: image: rilweic/catalog-db hostname: catalogue-db restart: always environment:-MYSQL_ROOT _ PASSWORD=$ {MYSQL_ROOT_PASSWORD}-MYSQL_ALLOW_EMPTY_PASSWORD=true-MYSQL_DATABASE=socksdb carts: image: weaveworksdemos/carts:0.4.8 hostname: carts restart: always cap_drop:-all cap_add:-NET_BIND_SERVICE tmpfs:-/ tmp:rw Noexec Nosuid environment:-JAVA_OPTS=-Xms64m-Xmx128m-XX:+UseG1GC-Djava.security.egd=file:/dev/urandom-Dspring.zipkin.enabled=false ports:-"80:80" depends_on:-carts-db-zipkin carts-db: image: mongo:3.4 hostname: carts-db restart: always cap_drop:-all cap_add:-CHOWN-SETGID-SETUID Tmpfs:-/ tmp:rw Noexec,nosuid orders: image: rilweic/orders hostname: orders restart: always cap_drop:-all cap_add:-NET_BIND_SERVICE tmpfs:-/ tmp:rw,noexec Nosuid environment:-JAVA_OPTS=-Xms64m-Xmx128m-XX:+UseG1GC-Djava.security.egd=file:/dev/urandom-Dspring.zipkin.enabled=false ports:-"8848 XX:+UseG1GC 8848" depends_on:-orders-db-zipkin-shipping-carts-payment-user orders-db: image: mongo:3.4 hostname: orders-db restart: always cap_drop:-all Cap_add:-CHOWN-SETGID-SETUID tmpfs:-/ tmp:rw Noexec,nosuid shipping: image: Rainbond/shipping:0.4.8 hostname: shipping restart: always cap_drop:-all cap_add:-NET_BIND_SERVICE tmpfs:-/ tmp:rw,noexec Nosuid environment:-JAVA_OPTS=-Xms64m-Xmx128m-XX:+UseG1GC-Djava.security.egd=file:/dev/urandom-Dspring.zipkin.enabled=false ports:-"8080 Xmx128m 8080" depends_on:-rabbitmq-zipkin queue-master: image: weaveworksdemos/queue-master:0.3.1 hostname: queue-master restart: always cap_drop:-all cap_add:-NET_BIND_SERVICE tmpfs:-/ tmp:rw Noexec Nosuid depends_on:-rabbitmq rabbitmq: image: rabbitmq:3.6.8 hostname: rabbitmq restart: always cap_drop:-all cap_add:-CHOWN-SETGID-SETUID-DAC_OVERRIDE payment: image: weaveworksdemos/payment:0.4.3 hostname: payment restart: always cap_drop:-all cap_add:-NET_BIND_SERVICE depends_on :-zipkin user: image: weaveworksdemos/user:0.4.4 hostname: user restart: always cap_drop:-all cap_add:-NET_BIND_SERVICE environment:-MONGO_HOST=user-db:27017 depends_on:-user-db-zipkin user-db: image: weaveworksdemos/user-db:0.4.0 hostname: user-db restart: always cap_drop: -all cap_add:-CHOWN-SETGID-SETUID tmpfs:-/ tmp:rw Noexec,nosuid zipkin: image: openzipkin/zipkin hostname: zipkin restart: always cap_drop:-all cap_add:-CHOWN-SETGID-SETUID tmpfs:-/ tmp:rw,noexec,nosuid environment:-reschedule=on-node-failure ports:-"9411 openzipkin/zipkin hostname 9411"

For other creation methods such as source code, application market, etc., please refer to the Rainbond document: create an application

After the service creation is completed, we need to register the batch created services and adjust the deployment memory. According to the invocation relationship between the services, analyze which services are provided as internal services for other service invocations and which services provide access to users, and perform the following operations:

STEP2 service registration

On the Rainbond platform, we can register the service by opening the port in the service's port page. For more information on service registration, please refer to Rainbond platform Service Registration.

The corresponding port and deployment memory size for each service are as follows:

Note that you must make sure that the service registration information and resource allocation information for each service component are set correctly.

STEP3 service discovery

Sockshop invokes the service through the internal domain name, that is, after completing the registration of the service, the calling service needs to discover the called service.

On the Rainbond platform, we can achieve this through service dependency (see documentation service discovery for details).

For more information on the dependencies of each service, please refer to the overview of the mall on the Rainbond platform above.

If you create an application using the docker-compose file above, there is no need to manually add dependencies. When creating the application, the system has automatically configured service discovery according to the contents of the docker-compose file.

STEP4 Services Mesh Governance

In the sockshop case, front-end is the nodejs project, and the service invokes the other five services to get the data, as shown in the figure:

When calling other services, front-end will use the domain name + port method (all calls for this project are in this way). For example, when front-end calls orders, the internal access address is http://orders/xxx..

When calling a service, the Rainbond platform will resolve the top-level domain name to 127.0.0.1 by default. If the corresponding ports of the called service do not conflict, there will be no problem. In this case, the port of the other five services invoked by front-end is 80. So the first governance function is needed here: Port reuse.

Without installing the layer 7 network governance plug-in, the platform uses the layer 4 network governance plug-in by default, which cannot provide a mechanism for port reuse. Therefore, we install the network governance plug-ins for the service front-end orders respectively.

STEP5 installs the network governance plug-in

Select the service network governance plug-in in my plug-in to install.

Pay special attention to

The Mesh plug-in working on layer 7 occupies port 80 by default, so the service that needs to install this plug-in itself cannot occupy port 80. Therefore, we recommend that the service try to listen to non-80 ports. Plug-in memory usage needs to be adjusted according to traffic.

STEP6 application installation plug-in

Select the plug-in tab on the application details page, and then activate the specified plug-in.

The service network governance plug-in provided by Rainbond by default is based on Envoy, and the Rainbond ServiceMesh architecture provides standard operation support for Envoy. Restart the application to take effect after installing the plug-in.

STEP7 Mesh plug-in configuration

Configure domain name routing to achieve port reuse. In order for the front-end service to select the corresponding service provider according to the domain name call already in the code, we need to configure it according to the domain name it calls. After relying on the application, the service network governance plug-in can automatically identify the application on which it depends. We only need to configure the domain name in the domain name entry of the plug-in configuration. As shown below:

Detailed configuration

Update the configuration related to the plug-in and save it and restart the related application. For the time being, only the domain name-based routing configuration is used here. For more information about the network governance plug-in, please see Service routing, Grayscale release, and Adeband B Test.

Performance Analysis of STEP8 Service

Micro-service is a distributed architecture model, which has always had some problems of its own. When the running state of an application is abnormal, it is very necessary for operators and developers to find the abnormal state of the application immediately and solve it. We can measure the service through monitoring means, or do a data support.

The Rainbond platform provides us with service monitoring and performance monitoring, which can simply and intuitively understand the current status and information of the service.

Applications that support HTTP and mysql protocols at present

Install the plug-in

Application installation plug-in

Install the network governance plug-in for the same application as above

Effect drawing of completion of installation

After installing the performance analysis plug-in, you can view the average response time and throughput of the application on the application overview page where the plug-in is installed.

In addition, we can also see the access of the application in the group overview of this group of applications.

Performance testing tool service on a case

The sockshop Mall case comes with a performance testing service, but the project does not run continuously, but the program will exit after a run. Here, we made a little modification according to the source code. The main thing is to change the program to run without exiting. Source code address

We can create a project through source code--

After the creation is completed, we need to create a user whose account is user and password is password in sockshop Mall. The load test needs to use this user name and password to simulate the request.

After completing the above steps, let's deal with the distributed trace of sockshop.

Brief introduction of microservice distributed tracking zipkin

As the business becomes more and more complex, the system is split, especially with the rise of micro-service architecture and container technology, a seemingly simple application may be supported by dozens or even hundreds of services in the background; a front-end request may require multiple service calls before it can be completed When the request becomes slow or unavailable, we can not know which background service caused it, so we need to solve how to quickly locate the fault point of the service. Zipkin distributed tracking system can solve this problem very well.

Zipkin distributed tracking system; it can help collect time data and solve latency problems under microservice architecture; it manages the collection and search of these data; the design of Zipkin is based on Google's Google Dapper paper. Each application reports timing data to Zipkin, and Zipkin UI presents a dependency chart to show how many trace requests have passed through each application; if you want to solve the delay problem, you can filter or sort all trace requests, and you can view each trace request as a percentage of total trace time.

Zipkin architecture

A service equipped with a zipkin tracker can defer each call of the service (which can be http or rpc or database call, etc.) to the zipkin service via Transport (currently there are four total send modes, http,kafka,scribe,rabbitmq).

Zipkin mainly contains four modules.

Collector: receives or collects data transmitted by each application. Storage: stores data received or collected. Memory,MySQL,Cassandra,ElasticSearch is currently supported, and it is stored in memory by default. API (Query): responsible for querying the data stored in Storage, providing simple JSON API to obtain data, mainly for web UI to use Web: providing a simple web interface

Zipkin service tracking process

From the figure above, it can be simply summarized as a request call. Zipkin will add the trace header information and corresponding comments to the request, record the time of the call and return the data to collector, the collector of zipkin.

Zipkin installation

On the Rinbond platform, we can run zipkin directly through docker run.

Pay attention to opening the external access port and adjusting the application memory size

At this point, the data of the created zipkin exists in memory, and the data of service shutdown or restart will be lost. So in a production environment, we need to store the data in storage.

Zipkin supports three types of MySQL,Cassandra,ElasticSearch storage. Let's take Mysql as an example. The current mysql versions of zipkin are version 5.6 and version 5.7.

Create a version 5.7 mysql application in the Rainbond platform application market, as shown in the figure.

After the mysql is created, we need to initialize the database. Zipkin needs to use the zipkin data and the corresponding table structure, and we need to create it ourselves.

On the details page of the application, we can choose to manage the container and enter the container to operate, as shown in the figure.

After entering the container, log in to the mysql command line using the command.

Mysql-uusername-ppassword

The user and password of mysql can be seen in the application dependency as shown in the figure.

After entering the mysql command line, create the database zipkin

CREATE DATABASE zipkin

Create zipkin-related tables: download

CREATE TABLE IF NOT EXISTS zipkin_spans (`trace_id_ high` BIGINT NOT NULL DEFAULT 0 COMMENT'If non zero, this means the trace uses 128 bit traceIds instead of 64 bit', `trace_ id` BIGINT NOT NULL, `id` BIGINT NOT NULL, `name` VARCHAR (255) NOT NULL, `parent_ id` BIGINT, `debug` BIT (1), `start_ ts` BIGINT COMMENT 'Span.timestamp (): epoch micros used for endTs query and to implement TTL' `duration`BIGINT COMMENT 'Span.duration (): micros used for minDuration and maxDuration query') ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci ALTER TABLE zipkin_spans ADD UNIQUE KEY (`COMMENT high`, `trace_ id`, `id`) COMMENT 'ignore insert on duplicate';ALTER TABLE zipkin_spans ADD INDEX (`trace_id_ high`, `trace_ id`, `id`) COMMENT' for joining with zipkin_annotations';ALTER TABLE zipkin_spans ADD INDEX (`trace_id_ high`, `trace_ id`) COMMENT 'for getTracesByIds';ALTER TABLE zipkin_spans ADD INDEX (`name`) COMMENT' for getTraces and getSpanNames';ALTER TABLE zipkin_spans ADD INDEX (`start_ ts`) COMMENT 'for getTraces ordering and range' CREATE TABLE IF NOT EXISTS zipkin_annotations (`trace_ high` BIGINT NOT NULL DEFAULT 0 COMMENT'If non zero, this means the trace uses 128bit traceIds instead of 64 bit', `trace_ id`BIGINT NOT NULL COMMENT 'coincides with zipkin_spans.trace_id', `span_ id` BIGINT NOT NULL COMMENT' coincides with zipkin_spans.id', `akey` VARCHAR = =-1Qing, `avalue`BLOB COMMENT 'BinaryAnnotation.value (), which must be smaller than 64KB' `atype`INT NOT NULL COMMENT 'BinaryAnnotation.type () or-1 if Annotation', `a_ timestamp` BIGINT COMMENT' Used to implement TTL Annotation.timestamp or zipkin_spans.timestamp', `endpoint_ ipv4` INT COMMENT 'Null when Binary/Annotation.endpoint is null', `endpoint_ ipv6` BINARY (16) COMMENT' Null when Binary/Annotation.endpoint is null, or no IPv6 address', `endpoint_ port`SMALLINT COMMENT 'Null when Binary/Annotation.endpoint is null', `endpoint_service_ name` VARCHAR (255) COMMENT' Null when Binary/Annotation.endpoint is null') ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci ALTER TABLE zipkin_annotations ADD UNIQUE KEY (`trace_id_ high`, `trace_ id`, `span_ id`, `a_ key`, `a_ timestamp`) COMMENT 'Ignore insert on duplicate';ALTER TABLE zipkin_annotations ADD INDEX (`trace_id_ high`, `trace_ id`, `span_ id`) COMMENT' for joining with zipkin_spans';ALTER TABLE zipkin_annotations ADD INDEX (`trace_id_ high`, `trace_ id`) COMMENT 'for getTraces/ByIds';ALTER TABLE zipkin_annotations ADD INDEX (`endpoint_service_ name`) COMMENT' for getTraces and getServiceNames' ALTER TABLE zipkin_annotations ADD INDEX (`atype`) COMMENT 'for getTraces';ALTER TABLE zipkin_annotations ADD INDEX (`akey`) COMMENT' for getTraces';ALTER TABLE zipkin_annotations ADD INDEX (`day`, `span_ id`, `akey`) COMMENT 'for dependencies job';CREATE TABLE IF NOT EXISTS zipkin_dependencies (`day` DATE NOT NULL, `parent` VARCHAR (255) NOT NULL, `child`VARCHAR (255) NOT NULL, `call_ count` BIGINT, `error_ count` BIGINT) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci ALTER TABLE zipkin_dependencies ADD UNIQUE KEY (`day`, `parent`, `child`)

Add the environment variable STORAGE_TYPE to mysql in the zipkin service, which marks the storage method used by zipkin. Optional values are mysql,elasticsearch, cassandra

After establishing a dependency between zipkin and mysql, the zipkin service is installed.

Zipkin calls the environment variables MYSQL_USER (user name), MYSQL_PASS (password), MYSQL_HOST (connection address) and MYSQL_PORT (port) by default. It happens to be the same as the variables set by default for the Rainbond platform, so no changes are required.

For other services, if the connected variables are not consistent with those provided by the Rainbond platform by default, we can add corresponding environment variables to the settings of the application to achieve the purpose of access.

Zipkin cases in sockshop

The sockshop case integrates zipkin for distributed tracking. The integrated components are users, carts, orders, payment, catalogue, shipping.

Where carts, orders and shipping are spring-boot projects, just change the-Dspring.zipkin.enabled of the environment variable JAVA_OPTS to true in the setting.

As shown in the picture

Payment, catalogue and users are golang projects. The project has integrated zipkin components internally. We need to add the environment variable ZIPKIN to http://zipkin:9411/api/v1/spans to specify the address of the service call zipkin.

As shown in the picture

After the setting is completed, you can directly access the access address provided by the zipkin application. Details of the visit are shown in the figure

We can see the delay details of each service invocation in this figure.

At this point, we have completed the basic deployment, we can see the complete business topology diagram, and sockshop is working properly.

This is the end of the basic deployment of how to practice the Service Mesh micro-service architecture. I hope the above content can be of some help and learn more knowledge. If you think the article is good, you can share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.