Enseñarle a construir un proyecto SpringCloud (3) Integrar el centro de registro de servicios de Eureka

Continúe actualizando, ¡bienvenido a darle me gusta y seguir!
Conozcamos Eureka primero: presentación oficial

1. Comprender Eureka

1. ¿Qué es la gobernanza del servicio?

Springcloud encapsula el módulo Eureka desarrollado por Netflix para implementar la gobernanza del servicio. En la llamada remota RPC tradicional, administrar las dependencias entre cada servicio y servicio es complicado, y la administración es complicada, por lo que se necesita la gobernanza del servicio para administrar las dependencias entre servicios y servicios, lo que puede realizar llamadas de servicio, equilibrio de carga, tolerancia a fallas, etc. Descubrimiento y registro de servicios.

2. ¿Qué es el registro y descubrimiento de servicios?

Eureka adopta la arquitectura de diseño de CS, y el servidor Eureka Server sirve como servidor de la función de registro de servicios, que es el centro de registro de servicios. Para otros microservicios en el sistema, use el cliente Eureka Client para conectarse al servidor Eureka Server y mantener una conexión de latido, de modo que los mantenedores del sistema puedan usar el servidor ureka para monitorear si cada microservicio en el sistema se ejecuta normalmente.

En el servicio de registro y descubrimiento, hay un registro. Cuando se inicie el servidor, registrará la información del servidor actual, como: dirección de servicio, comunicación, etc., en el centro de registro en forma de alias, y la otra parte (consumidor | productor) la obtendrá de el centro de registro en forma de alias La dirección de comunicación del servicio real, y luego realizar la idea de diseño central de la llamada RPC local y el marco de llamada remota RPC. El enfoque aquí es el registro, porque el registro administra las dependencias entre cada servicio y servicio. En cualquier marco RPC, habrá un centro de registro que almacena información relacionada con la dirección del servicio, es decir, la dirección de la interfaz.

La siguiente figura muestra el diagrama de arquitectura de Eureka:
inserte la descripción de la imagen aquí

2. Cree el servicio de servidor Eureka

Crea un nuevo módulo, que es el servicio de Eureka. Los pasos son los mismos que antes de crear un nuevo módulo, el nombre del módulo: cloud-eureka-server. Consulte los dos artículos anteriores. Aquí comenzamos a pegar el código modificando el archivo pom. Nota: Lo principal es agregar dependencias del servidor eureka.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>com.study.springcloud</groupId>
        <artifactId>mcroservice</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
 
    <artifactId>cloud-eureka-server</artifactId>
    <dependencies>
        <!--eureka-server-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
        <dependency>
            <groupId>com.study.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!--boot web actuator-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--一般通用配置-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>
 
</project>

Configurar el archivo yml

server:
  port: 7001
eureka:
  instance:
    hostname: eureka7001.com #eureka服务端的实例名称
  client:
    register-with-eureka: false     #false表示不向注册中心注册自己。
    fetch-registry: false     #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url:
      #设置与eureka  server交互的地址和注册服务都需要依赖这个地址
      defaultZone: http://eureka7001.com:7001/eureka/  #单机就是指向自己

La clase principal de inicio: debido a que es el servidor de Eureka, se debe agregar la anotación @EnableEurekaServer

package com.buba.springcloud.eureka;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
 
 
@SpringBootApplication
@EnableEurekaServer
public class EurekaMain {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(EurekaMain.class,args);
    }
}

Para iniciar el proyecto accedemos directamente a la dirección http://localhost:7001/ , el puerto 7001 es el puerto del servicio modificado, y aparece la siguiente interfaz indicando que el inicio es exitoso.
inserte la descripción de la imagen aquí

Ahora que el servidor de Erueka se ha iniciado con éxito, registraremos a nuestros productores y consumidores de pedidos en nuestro centro de registro de Erueka.

3. Dar de alta al productor en el servicio Erueka

Primero modificamos el archivo pom en el servicio de pago en la nube. Solo necesita agregar la dependencia eureka-client.

<!--   添加eureka客户端的依赖     -->
 <dependency>
      <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
 </dependency>

El siguiente paso es modificar el archivo yml y agregar la siguiente configuración en el archivo yml.

#eureka配置
eureka:
  client:
    #表示是否将自己注册进eureka  默认为true
    register-with-eureka: true
    #是否从EurekaServer中抓取已有的注册信息，默认为true，单点无所谓，集群必须设置true才能和ribbon使用负载均衡
    fetch-registry: true
    service-url:
      #单机配置
      defaultZone: http://localhost:7001/eureka

Luego modifique la clase de inicio principal para agregar esta anotación@EnableEurekaClient

@SpringBootApplication
@EnableEurekaClient
public class PayMentMain {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(PayMentMain.class,args);
    }
}

Finalmente, primero debemos iniciar el servicio en el servidor Eureka y luego iniciar el productor. Luego visite: http://localhost:7001/ , aparecerá la siguiente interfaz, podemos ver el servicio mcroservice-pago en la lista de servicios
inserte la descripción de la imagen aquí

El nombre del servicio mcroservice-pago en la lista de servicios se configura en el archivo yml del servicio mcroservice-pago, como se muestra en la siguiente figura:
inserte la descripción de la imagen aquí

Visitemos la interfaz anterior para ver si el acceso es exitoso. Ingrese http://localhost:8001/payment/get/1 y podrá acceder a él con éxito, como se muestra en la figura a continuación.

inserte la descripción de la imagen aquí

4. Dar de alta el servicio de consumo al servicio de Erueka

Los pasos de modificación específicos son similares a los de nuestro servicio anterior. En el proyecto de microservicio de pedidos de consumidores en la nube, solo es necesario agregar la dependencia eureka-client.

<!--   添加eureka客户端的依赖     -->
 <dependency>
      <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
 </dependency>

El siguiente paso es modificar el archivo yml y agregar la siguiente configuración en el archivo yml.

#eureka配置
eureka:
  client:
    #表示是否将自己注册进eureka  默认为true
    register-with-eureka: true
    #是否从EurekaServer中抓取已有的注册信息，默认为true，单点无所谓，集群必须设置true才能和ribbon使用负载均衡
    fetch-registry: true
    service-url:
      #单机配置
      defaultZone: http://localhost:7001/eureka

Luego modifique la clase de inicio principal para agregar esta anotación@EnableEurekaClient

@SpringBootApplication
@EnableEurekaClient
public class OrderMain {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(OrderMain.class,args);
    }

Finalmente, primero debemos iniciar el servicio del servidor Eureka y luego iniciar el servicio del consumidor. Luego visite: http://localhost:7001/ , aparecerá la siguiente interfaz, podemos ver que además del servicio mcroservice-pago, el servicio mcroservice-order se agrega en la lista de servicios.

inserte la descripción de la imagen aquí

Ahora que tanto el servicio del productor como el servicio del consumidor se han registrado con éxito en nuestro centro de registro de Eureka, probemos si se puede acceder correctamente al servicio del consumidor. Ingrese http://localhost/consumer/payment/get/1 , el acceso es exitoso, como se muestra a continuación:

inserte la descripción de la imagen aquí

Hemos registrado con éxito a productores y consumidores en el centro de registro, y también podemos obtener información a través de la interfaz. tan fácil.

inserte la descripción de la imagen aquí

En el próximo artículo, siga construyendo una versión de clúster de Eureka, siga prestando atención y disfrute. Seguimos actualizando.