El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Spring Boot i microserveis

Següent ►
►

En aquest tema, explorarem com utilitzar Spring Boot per crear i gestionar microserveis. Els microserveis són una arquitectura de programari que estructura una aplicació com un conjunt de serveis petits i independents, cadascun executant en el seu propi procés i comunicant-se amb mecanismes lleugers, sovint una API HTTP.

Continguts

  1. Introducció als microserveis
  2. Creant un microservei amb Spring Boot
  3. Comunicació entre microserveis
  4. Gestió de configuració centralitzada
  5. Monitorització i traçabilitat
  6. Exercicis pràctics

Introducció als microserveis

Els microserveis ofereixen diversos avantatges:

  • Escalabilitat independent: Cada servei es pot escalar de manera independent segons les necessitats.
  • Desplegament independent: Els serveis es poden desplegar de manera independent, permetent actualitzacions més ràpides.
  • Resiliència: Un error en un servei no afecta tota l'aplicació.
  • Flexibilitat tecnològica: Cada servei pot utilitzar diferents tecnologies i llenguatges de programació.

Creant un microservei amb Spring Boot

Pas 1: Configuració del projecte

  1. Crea un nou projecte Spring Boot utilitzant Spring Initializr (https://start.spring.io/).
  2. Selecciona les dependències següents:
    • Spring Web
    • Spring Boot Actuator
    • Spring Data JPA (opcional, si necessites accés a dades)
    • H2 Database (opcional, per a proves)

Pas 2: Estructura del projecte

L'estructura del projecte serà similar a la següent:

src
└── main
    ├── java
    │   └── com
    │       └── exemple
    │           └── microservei
    │               ├── MicroserveiApplication.java
    │               ├── controlador
    │               │   └── SalutacioControlador.java
    │               └── servei
    │                   └── SalutacioServei.java
    └── resources
        ├── application.properties
        └── data.sql (opcional)

Pas 3: Implementació del microservei

MicroserveiApplication.java

package com.exemple.microservei;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

SalutacioControlador.java

package com.exemple.microservei.controlador;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SalutacioControlador {

    @GetMapping("/salutacio")
    public String salutacio() {
        return "Hola, món!";
    }
}

Pas 4: Executar el microservei

Executa la classe MicroserveiApplication per iniciar el microservei. Pots accedir a l'endpoint http://localhost:8080/salutacio per veure la resposta "Hola, món!".

Comunicació entre microserveis

Utilitzant RestTemplate

Spring Boot proporciona RestTemplate per a la comunicació sincrònica entre microserveis.

Exemple d'ús de RestTemplate

package com.exemple.microservei.servei;

import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class SalutacioServei {

    private final RestTemplate restTemplate;

    public SalutacioServei(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public String obtenirSalutacio() {
        return restTemplate.getForObject("http://altre-microservei/salutacio", String.class);
    }
}

Utilitzant Feign Client

Feign és una eina declarativa per crear clients HTTP.

Configuració de Feign Client

  1. Afegeix la dependència de Feign al teu pom.xml:
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
  1. Habilita Feign Client a la classe principal:
@SpringBootApplication
@EnableFeignClients
public class MicroserveiApplication {
    // ...
}
  1. Crea una interfície Feign Client:
package com.exemple.microservei.client;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

@FeignClient(name = "altre-microservei")
public interface SalutacioClient {

    @GetMapping("/salutacio")
    String obtenirSalutacio();
}

Gestió de configuració centralitzada

Spring Cloud Config proporciona una solució per gestionar la configuració de manera centralitzada.

Configuració del servidor de configuració

  1. Crea un nou projecte Spring Boot amb la dependència spring-cloud-config-server.
  2. Habilita el servidor de configuració:
@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApplication.class, args);
    }
}
  1. Configura el repositori de configuració a application.properties:
spring.cloud.config.server.git.uri=https://github.com/usuari/repo-configuracio

Configuració del client de configuració

  1. Afegeix la dependència de Config Client al pom.xml del microservei:
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>
  1. Configura el client a bootstrap.properties:
spring.application.name=microservei
spring.cloud.config.uri=http://localhost:8888

Monitorització i traçabilitat

Utilitzant Spring Boot Actuator

Spring Boot Actuator proporciona endpoints per monitoritzar i gestionar l'aplicació.

  1. Afegeix la dependència d'Actuator al pom.xml:
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
  1. Configura Actuator a application.properties:
management.endpoints.web.exposure.include=*

Utilitzant Zipkin per a traçabilitat distribuïda

  1. Afegeix la dependència de Zipkin al pom.xml:
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>
  1. Configura Zipkin a application.properties:
spring.zipkin.base-url=http://localhost:9411
spring.sleuth.sampler.probability=1.0

Exercicis pràctics

Exercici 1: Crear un microservei senzill

  1. Crea un nou projecte Spring Boot.
  2. Implementa un controlador que retorni un missatge de salutació.
  3. Executa el microservei i verifica que l'endpoint funcioni correctament.

Exercici 2: Comunicació entre microserveis

  1. Crea dos microserveis: microservei-a i microservei-b.
  2. Implementa un endpoint a microservei-b que retorni un missatge.
  3. Utilitza RestTemplate o Feign Client a microservei-a per cridar l'endpoint de microservei-b.

Exercici 3: Configuració centralitzada

  1. Configura un servidor de configuració amb Spring Cloud Config.
  2. Configura un client de configuració en un microservei.
  3. Verifica que el microservei obtingui la configuració del servidor de configuració.

Conclusió

En aquest tema, hem après com crear i gestionar microserveis amb Spring Boot. Hem explorat la comunicació entre microserveis, la gestió de configuració centralitzada i la monitorització i traçabilitat. Els exercicis pràctics proporcionats t'ajudaran a consolidar els coneixements adquirits. En el següent tema, explorarem com desplegar aplicacions Spring Boot en diferents entorns.

◄ Anterior
◄
Següent ►
►

Curs de Spring Boot

Mòdul 1: Introducció a Spring Boot

Mòdul 2: Conceptes bàsics de Spring Boot

Mòdul 3: Construint serveis web RESTful

Mòdul 4: Accés a dades amb Spring Boot

Mòdul 5: Seguretat a Spring Boot

Mòdul 6: Proves a Spring Boot

Mòdul 7: Funcions avançades de Spring Boot

Mòdul 8: Desplegant aplicacions Spring Boot

Mòdul 9: Rendiment i monitorització

Mòdul 10: Millors pràctiques i consells

El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats