Spring Boot - Servidor proxy Zuul y enrutamiento

Zuul Server es una aplicación de puerta de enlace que maneja todas las solicitudes y realiza el enrutamiento dinámico de las aplicaciones de microservicio. El servidor Zuul también se conoce como servidor perimetral.

Por ejemplo, /api/user se asigna al servicio del usuario y / api / products se asigna al servicio del producto y Zuul Server enruta dinámicamente las solicitudes a la aplicación backend correspondiente.

En este capítulo, veremos en detalle cómo crear la aplicación Zuul Server en Spring Boot.

Creación de la aplicación de servidor Zuul

El servidor Zuul está incluido con la dependencia de Spring Cloud. Puede descargar el proyecto Spring Boot desde la página Spring Initializerhttps://start.spring.io/ y elija la dependencia del servidor Zuul.

Agregue la anotación @EnableZuulProxy en su aplicación principal Spring Boot. La anotación @EnableZuulProxy se utiliza para hacer que su aplicación Spring Boot actúe como un servidor proxy Zuul.

package com.tutorialspoint.zuulserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

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

Tendrá que agregar la dependencia Spring Cloud Starter Zuul en nuestro archivo de configuración de compilación.

Los usuarios de Maven deberán agregar la siguiente dependencia en su pom.xml archivo -

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-zuul</artifactId>
</dependency>

Para los usuarios de Gradle, agregue la siguiente dependencia en su archivo build.gradle

compile('org.springframework.cloud:spring-cloud-starter-zuul')

Para el enrutamiento de Zuul, agregue las siguientes propiedades en su archivo application.properties o en el archivo application.yml.

spring.application.name = zuulserver
zuul.routes.products.path = /api/demo/**
zuul.routes.products.url = http://localhost:8080/
server.port = 8111

Esto significa que http llama a /api/demo/ser reenviado al servicio de productos. Por ejemplo,/api/demo/products se reenvía a /products.

Los usuarios del archivo yaml pueden usar el archivo application.yml que se muestra a continuación:

server:
   port: 8111
spring:
   application:  
      name: zuulserver
zuul:

routes:
   products:
      path: /api/demo/**
      url: http://localhost:8080/

Note - el http://localhost:8080/ La aplicación ya debería estar ejecutándose antes de enrutar a través de Zuul Proxy.

El archivo de configuración de compilación completo se proporciona a continuación.

Los usuarios de Maven pueden usar el archivo pom.xml que se muestra a continuación:

<?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">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>zuulserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>zuulserver</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-zuul</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

Los usuarios de Gradle pueden usar el archivo build.gradle que se muestra a continuación:

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-zuul')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Puede crear un archivo JAR ejecutable y ejecutar la aplicación Spring Boot utilizando los comandos de Maven o Gradle que se indican a continuación:

Para Maven, puede usar el comando que se proporciona a continuación:

mvn clean install

Después de "BUILD SUCCESS", puede encontrar el archivo JAR en el directorio de destino.

Para Gradle, puede usar el comando que se proporciona a continuación:

gradle clean build

Después de "BUILD SUCCESSFUL", puede encontrar el archivo JAR en el directorio build / libs.

Ahora, ejecute el archivo JAR usando el comando que se muestra a continuación:

java –jar <JARFILE>

Puede encontrar que la aplicación se ha iniciado en el puerto 8111 de Tomcat como se muestra aquí.

Ahora, presiona la URL http://localhost:8111/api/demo/products en su navegador web y puede ver la salida de /products REST Endpoint como se muestra a continuación -

↰ Previous page Next page ↱