1. Información general
Spring Cloud es un marco para crear aplicaciones robustas en la nube. El marco facilita el desarrollo de aplicaciones al proporcionar soluciones a muchos de los problemas comunes que se enfrentan al pasar a un entorno distribuido.
Las aplicaciones que se ejecutan con arquitectura de microservicios tienen como objetivo simplificar el desarrollo, la implementación y el mantenimiento. La naturaleza descompuesta de la aplicación permite a los desarrolladores concentrarse en un problema a la vez. Se pueden introducir mejoras sin afectar a otras partes de un sistema.
Por otro lado, surgen diferentes desafíos cuando adoptamos un enfoque de microservicio:
- Externalizar la configuración para que sea flexible y no requiera la reconstrucción del servicio al cambiar
- Descubrimiento de servicios
- Ocultar la complejidad de los servicios implementados en diferentes hosts
En este artículo, crearemos cinco microservicios: un servidor de configuración, un servidor de descubrimiento, un servidor de puerta de enlace, un servicio de libros y finalmente un servicio de clasificación. Estos cinco microservicios forman una aplicación de base sólida para comenzar el desarrollo de la nube y abordar los desafíos antes mencionados.
2. Servidor de configuración
Al desarrollar una aplicación en la nube, un problema es mantener y distribuir la configuración de nuestros servicios. Realmente no queremos perder tiempo configurando cada entorno antes de escalar nuestro servicio horizontalmente o arriesgarnos a infracciones de seguridad integrando nuestra configuración en nuestra aplicación.
Para resolver esto, consolidaremos toda nuestra configuración en un solo repositorio de Git y lo conectaremos a una aplicación que administra una configuración para todas nuestras aplicaciones. Vamos a configurar una implementación muy simple.
Para obtener más detalles y ver un ejemplo más complejo, consulte nuestro artículo Configuración de Spring Cloud.
2.1. Preparar
Navegue a //start.spring.io y seleccione Maven y Spring Boot 2.2.x.
Establezca el artefacto en "config " . En la sección de dependencias, busque "servidor de configuración" y agregue ese módulo. Luego presione el botón Generar y podremos descargar un archivo zip con un proyecto preconfigurado adentro y listo para usar.
Alternativamente, podemos generar un proyecto Spring Boot y agregar algunas dependencias al archivo POM manualmente.
Estas dependencias se compartirán entre todos los proyectos:
org.springframework.boot spring-boot-starter-parent 2.2.6.RELEASE org.springframework.boot spring-boot-starter-test test org.springframework.cloud spring-cloud-dependencies Hoxton.SR4 pom import org.springframework.boot spring-boot-maven-plugin Agreguemos una dependencia para el servidor de configuración:
org.springframework.cloud spring-cloud-config-server Como referencia, podemos encontrar la última versión en Maven Central ( spring-cloud-dependencies, test, config-server ).
2.2. Configuración de primavera
Para habilitar el servidor de configuración debemos agregar algunas anotaciones a la clase de aplicación principal:
@SpringBootApplication @EnableConfigServer public class ConfigApplication {...}@EnableConfigServer convertirá nuestra aplicación en un servidor de configuración.
2.3. Propiedades
Agreguemos application.properties en src / main / resources :
server.port=8081 spring.application.name=config spring.cloud.config.server.git.uri=file://${user.home}/application-configLa configuración más significativa para el servidor de configuración es el parámetro git.uri . Actualmente, se establece en una ruta de archivo relativa que generalmente se resuelve en c: \ Users \ {username} \ en Windows o / Users / {username} / en * nix. Esta propiedad apunta a un repositorio de Git donde se almacenan los archivos de propiedades para todas las demás aplicaciones. Se puede establecer en una ruta de archivo absoluta si es necesario.
Sugerencia : En una máquina con Windows, anteponga el valor con “file: ///”, en * nix luego use “file: //”.
2.4. Repositorio de Git
Navegue a la carpeta definida por spring.cloud.config.server.git.uri y agregue la carpeta application-config . CD en esa carpeta y escriba git init . Esto inicializará un repositorio de Git donde podemos almacenar archivos y rastrear sus cambios.
2.5. correr
Ejecutemos el servidor de configuración y asegurémonos de que funciona. Desde la línea de comando, escriba mvn spring-boot: run . Esto iniciará el servidor.
Deberíamos ver esta salida que indica que el servidor se está ejecutando:
Tomcat started on port(s): 8081 (http)2.6. Configuración de bootstrapping
En nuestros servidores posteriores, vamos a querer que las propiedades de su aplicación sean administradas por este servidor de configuración. Para hacer eso, en realidad necesitaremos hacer un poco de huevo y gallina: configurar propiedades en cada aplicación que sepan cómo responder a este servidor.
Es un proceso de arranque, y cada una de estas aplicaciones tendrá un archivo llamado bootstrap.properties . Contendrá propiedades como application.properties pero con un giro:
Un Spring ApplicationContext principal carga primero bootstrap.properties . Esto es fundamental para que Config Server pueda comenzar a administrar las propiedades en application.properties . Es este ApplicationContext especial el que también descifrará las propiedades de la aplicación cifrada.
Es inteligente mantener distintos estos archivos de propiedades. bootstrap.properties es para preparar el servidor de configuración, y application.properties es para propiedades específicas de nuestra aplicación. Sin embargo, técnicamente es posible colocar las propiedades de la aplicación en bootstrap.properties .
Por último, dado que Config Server administra las propiedades de nuestra aplicación, uno podría preguntarse por qué tener un application.properties en absoluto. La respuesta es que estos siguen siendo útiles como valores predeterminados que quizás Config Server no tenga.
3. Descubrimiento
Now that we have configuration taken care of, we need a way for all of our servers to be able to find each other. We will solve this problem by setting the Eureka discovery server up. Since our applications could be running on any ip/port combination we need a central address registry that can serve as an application address lookup.
When a new server is provisioned it will communicate with the discovery server and register its address so that others can communicate with it. This way other applications can consume this information as they make requests.
To learn more details and see a more complex discovery implementation take a look at Spring Cloud Eureka article.
3.1. Setup
Again we'll navigate to start.spring.io. Set the artifact to “discovery”. Search for “eureka server” and add that dependency. Search for “config client” and add that dependency. Finally, generate the project.
Alternatively, we can create a Spring Boot project, copy the contents of the POM from config server and swap in these dependencies:
org.springframework.cloud spring-cloud-starter-config org.springframework.cloud spring-cloud-starter-eureka-server For reference, we'll find the bundles on Maven Central (config-client, eureka-server).
3.2. Spring Config
Let's add Java config to the main class:
@SpringBootApplication @EnableEurekaServer public class DiscoveryApplication {...}@EnableEurekaServer will configure this server as a discovery server using Netflix Eureka. Spring Boot will automatically detect the configuration dependency on the classpath and lookup the configuration from the config server.
3.3. Properties
Now we will add two properties files:
First, we add bootstrap.properties into src/main/resources:
spring.cloud.config.name=discovery spring.cloud.config.uri=//localhost:8081These properties will let discovery server query the config server at startup.
And second, we add discovery.properties to our Git repository
spring.application.name=discovery server.port=8082 eureka.instance.hostname=localhost eureka.client.serviceUrl.defaultZone=//localhost:8082/eureka/ eureka.client.register-with-eureka=false eureka.client.fetch-registry=falseThe filename must match the spring.application.name property.
In addition, we are telling this server that it is operating in the default zone, this matches the config client's region setting. We are also telling the server not to register with another discovery instance.
In production, we'd have more than one of these to provide redundancy in the event of failure and that setting would be true.
Let's commit the file to the Git repository. Otherwise, the file will not be detected.
3.4. Add Dependency to the Config Server
Add this dependency to the config server POM file:
org.springframework.cloud spring-cloud-starter-eureka For reference, we can find the bundle on Maven Central (eureka-client).
Add these properties to the application.properties file in src/main/resources of the config server:
eureka.client.region = default eureka.client.registryFetchIntervalSeconds = 5 eureka.client.serviceUrl.defaultZone=//localhost:8082/eureka/3.5. Run
Start the discovery server using the same command, mvn spring-boot:run. The output from the command line should include:
Fetching config from server at: //localhost:8081 ... Tomcat started on port(s): 8082 (http)Stop and rerun the config service. If all is good output should look like:
DiscoveryClient_CONFIG/10.1.10.235:config:8081: registering service... Tomcat started on port(s): 8081 (http) DiscoveryClient_CONFIG/10.1.10.235:config:8081 - registration status: 2044. Gateway
Now that we have our configuration and discovery issues resolved we still have a problem with clients accessing all of our applications.
If we leave everything in a distributed system, then we will have to manage complex CORS headers to allow cross-origin requests on clients. We can resolve this by creating a gateway server. This will act as a reverse proxy shuttling requests from clients to our back end servers.
A gateway server is an excellent application in microservice architecture as it allows all responses to originate from a single host. This will eliminate the need for CORS and give us a convenient place to handle common problems like authentication.
4.1. Setup
By now we know the drill. Navigate to //start.spring.io. Set the artifact to “gateway”. Search for “zuul” and add that dependency. Search for “config client” and add that dependency. Search for “eureka discovery” and add that dependency. Lastly, generate that project.
Alternatively, we could create a Spring Boot app with these dependencies:
org.springframework.cloud spring-cloud-starter-config org.springframework.cloud spring-cloud-starter-eureka org.springframework.cloud spring-cloud-starter-zuul For reference, we can find the bundle on Maven Central (config-client, eureka-client, zuul).
4.2. Spring Config
Let's add the configuration to the main class:
@SpringBootApplication @EnableZuulProxy @EnableEurekaClient public class GatewayApplication {...}4.3. Properties
Now we will add two properties files:
bootstrap.properties in src/main/resources:
spring.cloud.config.name=gateway spring.cloud.config.discovery.service-id=config spring.cloud.config.discovery.enabled=true eureka.client.serviceUrl.defaultZone=//localhost:8082/eureka/gateway.properties in our Git repository
spring.application.name=gateway server.port=8080 eureka.client.region = default eureka.client.registryFetchIntervalSeconds = 5 zuul.routes.book-service.path=/book-service/** zuul.routes.book-service.sensitive-headers=Set-Cookie,Authorization hystrix.command.book-service.execution.isolation.thread.timeoutInMilliseconds=600000 zuul.routes.rating-service.path=/rating-service/** zuul.routes.rating-service.sensitive-headers=Set-Cookie,Authorization hystrix.command.rating-service.execution.isolation.thread.timeoutInMilliseconds=600000 zuul.routes.discovery.path=/discovery/** zuul.routes.discovery.sensitive-headers=Set-Cookie,Authorization zuul.routes.discovery.url=//localhost:8082 hystrix.command.discovery.execution.isolation.thread.timeoutInMilliseconds=600000The zuul.routes property allows us to define an application to route certain requests based on an ant URL matcher. Our property tells Zuul to route any request that comes in on /book-service/** to an application with the spring.application.name of book-service. Zuul will then lookup the host from discovery server using the application name and forward the request to that server.
Remember to commit the changes in the repository!
4.4. Run
Run the config and discovery applications and wait until the config application has registered with the discovery server. If they are already running, we don't have to restart them. Once that is complete, run the gateway server. The gateway server should start on port 8080 and register itself with the discovery server. The output from the console should contain:
Fetching config from server at: //10.1.10.235:8081/ ... DiscoveryClient_GATEWAY/10.1.10.235:gateway:8080: registering service... DiscoveryClient_GATEWAY/10.1.10.235:gateway:8080 - registration status: 204 Tomcat started on port(s): 8080 (http)One mistake that is easy to make is to start the server before config server has registered with Eureka. In this case, we'll see a log with this output:
Fetching config from server at: //localhost:8888This is the default URL and port for a config server and indicates our discovery service did not have an address when the configuration request was made. Just wait a few seconds and try again, once the config server has registered with Eureka, the problem will resolve.
5. Book Service
In microservice architecture, we are free to make as many applications to meet a business objective. Often engineers will divide their services by domain. We will follow this pattern and create a book service to handle all the operations for books in our application.
5.1. Setup
One more time. Navigate to //start.spring.io. Set the artifact to “book-service”. Search for “web” and add that dependency. Search for “config client” and add that dependency. Search for “eureka discovery” and add that dependency. Generate that project.
Alternatively, add these dependencies to a project:
org.springframework.cloud spring-cloud-starter-config org.springframework.cloud spring-cloud-starter-eureka org.springframework.boot spring-boot-starter-web For reference, we can find the bundle on Maven Central (config-client, eureka-client, web).
5.2. Spring Config
Let's modify our main class:
@SpringBootApplication @EnableEurekaClient @RestController @RequestMapping("/books") public class BookServiceApplication { public static void main(String[] args) { SpringApplication.run(BookServiceApplication.class, args); } private List bookList = Arrays.asList( new Book(1L, "Baeldung goes to the market", "Tim Schimandle"), new Book(2L, "Baeldung goes to the park", "Slavisa") ); @GetMapping("") public List findAllBooks() { return bookList; } @GetMapping("/{bookId}") public Book findBook(@PathVariable Long bookId) { return bookList.stream().filter(b -> b.getId().equals(bookId)).findFirst().orElse(null); } }We also added a REST controller and a field set by our properties file to return a value we will set during configuration.
Let's now add the book POJO:
public class Book { private Long id; private String author; private String title; // standard getters and setters }5.3. Properties
Now we just need to add our two properties files:
bootstrap.properties in src/main/resources:
spring.cloud.config.name=book-service spring.cloud.config.discovery.service-id=config spring.cloud.config.discovery.enabled=true eureka.client.serviceUrl.defaultZone=//localhost:8082/eureka/book-service.properties in our Git repository:
spring.application.name=book-service server.port=8083 eureka.client.region = default eureka.client.registryFetchIntervalSeconds = 5 eureka.client.serviceUrl.defaultZone=//localhost:8082/eureka/Let's commit the changes to the repository.
5.4. Run
Once all the other applications have started we can start the book service. The console output should look like:
DiscoveryClient_BOOK-SERVICE/10.1.10.235:book-service:8083: registering service... DiscoveryClient_BOOK-SERVICE/10.1.10.235:book-service:8083 - registration status: 204 Tomcat started on port(s): 8083 (http)Once it is up we can use our browser to access the endpoint we just created. Navigate to //localhost:8080/book-service/books and we get back a JSON object with two books we added in out controller. Notice that we are not accessing book service directly on port 8083 but we are going through the gateway server.
6. Rating Service
Like our book service, our rating service will be a domain driven service that will handle operations related to ratings.
6.1. Setup
One more time. Navigate to //start.spring.io. Set the artifact to “rating-service”. Search for “web” and add that dependency. Search for “config client” and add that dependency. Search for “eureka discovery“ and add that dependency. Then, generate that project.
Alternatively, add these dependencies to a project:
org.springframework.cloud spring-cloud-starter-config org.springframework.cloud spring-cloud-starter-eureka org.springframework.boot spring-boot-starter-web For reference, we can find the bundle on Maven Central (config-client, eureka-client, web).
6.2. Spring Config
Let's modify our main class:
@SpringBootApplication @EnableEurekaClient @RestController @RequestMapping("/ratings") public class RatingServiceApplication { public static void main(String[] args) { SpringApplication.run(RatingServiceApplication.class, args); } private List ratingList = Arrays.asList( new Rating(1L, 1L, 2), new Rating(2L, 1L, 3), new Rating(3L, 2L, 4), new Rating(4L, 2L, 5) ); @GetMapping("") public List findRatingsByBookId(@RequestParam Long bookId) bookId.equals(0L) ? Collections.EMPTY_LIST : ratingList.stream().filter(r -> r.getBookId().equals(bookId)).collect(Collectors.toList()); @GetMapping("/all") public List findAllRatings() { return ratingList; } }We also added a REST controller and a field set by our properties file to return a value we will set during configuration.
Let's add the rating POJO:
public class Rating { private Long id; private Long bookId; private int stars; //standard getters and setters }6.3. Properties
Now we just need to add our two properties files:
bootstrap.properties in src/main/resources:
spring.cloud.config.name=rating-service spring.cloud.config.discovery.service-id=config spring.cloud.config.discovery.enabled=true eureka.client.serviceUrl.defaultZone=//localhost:8082/eureka/rating-service.properties in our Git repository:
spring.application.name=rating-service server.port=8084 eureka.client.region = default eureka.client.registryFetchIntervalSeconds = 5 eureka.client.serviceUrl.defaultZone=//localhost:8082/eureka/Let's commit the changes to the repository.
6.4. Run
Once all the other applications have started we can start the rating service. The console output should look like:
DiscoveryClient_RATING-SERVICE/10.1.10.235:rating-service:8083: registering service... DiscoveryClient_RATING-SERVICE/10.1.10.235:rating-service:8083 - registration status: 204 Tomcat started on port(s): 8084 (http)Once it is up we can use our browser to access the endpoint we just created. Navigate to //localhost:8080/rating-service/ratings/all and we get back JSON containing all our ratings. Notice that we are not accessing the rating service directly on port 8084 but we are going through the gateway server.
7. Conclusion
Ahora podemos conectar las distintas piezas de Spring Cloud en una aplicación de microservicio en funcionamiento. Esto forma una base que podemos usar para comenzar a construir aplicaciones más complejas.
Como siempre, podemos encontrar este código fuente en GitHub.