Docs Menu
Docs Home
/ /
Integraciones de terceros
Docs Home
/ /
Java Sync Driver
/
Integraciones de terceros
Docs Home
/
Librerías de clientes
/
Java
/
Java Sync Driver
/
Integraciones de terceros

Tutorial: Crea una aplicación de microservicios con MongoDB

Overview

Este tutorial muestra cómo construir una arquitectura de microservicios con Spring Boot, Spring Cloud y MongoDB. En concreto, te guía en la creación de múltiples servicios que interactúan para formar una aplicación completa.

Puede encontrar el código fuente completo en los siguientes repositorios de GitHub:

  • Aplicación de microservicios

  • Repositorio de configuración

Bota de primavera

Spring Boot es un framework desarrollado sobre Spring Framework. Incorpora autoconfiguración, valores predeterminados y funciones listas para producción para simplificar la creación de aplicaciones Java basadas en Spring, incluyendo la integración con Spring Data MongoDB. Para más información, consulte la documentación de Spring Boot.

Nube de primavera

Spring Cloud es una colección de herramientas para crear sistemas distribuidos y microservicios. Ofrece funciones para la gestión de la configuración, el descubrimiento de servicios y el enrutamiento inteligente. Para más información, consulte la documentación de Spring Cloud.

Tutorial

Este tutorial muestra cómo realizar las siguientes acciones:

  • Verificar los prerrequisitos

  • Clonar los repositorios de ejemplo

  • Configurar un servidor de configuración

  • Configurar un registro de servicios

  • Configurar una puerta de enlace API

  • Crear microservicios de MongoDB

  • Probar las API REST

1

Verificar los prerrequisitos.

Antes de comenzar, asegúrese de tener instalado lo siguiente:

  • Kit de desarrollo de Java (JDK) 21 o posterior. Puede descargar el JDK desde el sitio web de Oracle.

  • Git

  • MongoDB (dos implementaciones para desarrollo local). Para aprender a configurar MongoDB localmente, consulte la guía "Crear una implementación local de Atlas con Docker".

2

Clonar los repositorios de ejemplo.

Clone la aplicación de microservicios y los repositorios de configuración ejecutando los siguientes comandos:

git clone git@github.com:mongodb-developer/microservices-architecture-mongodb.git
git clone git@github.com:mongodb-developer/microservices-architecture-mongodb-config-repo.git

Siga las instrucciones del archivo README.md del microservices-architecture-mongodb repositorio para iniciar cada servicio.

3

Configurar un servidor de configuración.

Un servidor de configuración almacena todos los archivos de configuración de sus microservicios dentro de un único repositorio.

La configuración del servidor se define en el archivo microservices-architecture-mongodb/config-server/src/main/resources/application.properties:

spring.application.name=config-server
server.port=8888
spring.cloud.config.server.git.uri=${HOME}/Work/microservices-architecture-mongodb-config-repo
spring.cloud.config.label=main

Esta configuración especifica la ubicación del repositorio Git que almacena la configuración de sus microservicios y la rama a utilizar.

La aplicación del servidor de configuración se define en la siguiente clase Java ubicada en el directorio microservices-architecture-mongodb/config-server/src/main/java/com/mongodb/configserver/:

AplicaciónConfigServer.java
package com.mongodb.configserver;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;
@EnableConfigServer
@SpringBootApplication
public class ConfigServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApplication.class, args);
    }
}

Nota

La anotación @EnableConfigServer habilita la funcionalidad del servidor de configuración en su aplicación Spring Boot.

4

Establecer un registro de servicios.

Un registro de servicios rastrea qué microservicios se están ejecutando y sus ubicaciones. Otros servicios utilizan esta información para comunicarse con los microservicios que necesitan.

La configuración del registro del servicio se define en el siguiente archivo de propiedades:

spring.application.name=service-registry
server.port=8761
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

Las dos últimas propiedades impiden que el registro de servicio se registre a sí mismo.

La aplicación de registro de servicios se define en la siguiente clase Java ubicada en el directorio microservices-architecture-mongodb/service-registry/src/main/java/com/mongodb/serviceregistry/:

Aplicación de registro de servicio.java
package com.mongodb.serviceregistry;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@SpringBootApplication
@EnableEurekaServer
public class ServiceRegistryApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceRegistryApplication.class, args);
    }
}

Nota

La anotación @EnableEurekaServer habilita la funcionalidad de registro de servicio en su aplicación Spring Boot.

5

Configurar una puerta de enlace API.

Una puerta de enlace API proporciona un único punto de entrada para acceder a todos sus microservicios. La puerta de enlace distribuye las solicitudes entre múltiples microservicios y gestiona la seguridad, la monitorización y otras cuestiones.

La configuración de la puerta de enlace API se define en el archivo microservices-architecture-mongodb/api-gateway/src/main/resources/application.yml:

server:
  port: 8080
spring:
  application:
    name: api-gateway
  cloud:
    gateway:
      routes:
        - id: company-service
          uri: lb://company-service
          predicates:
            - Path=/api/company/**,/api/companies
        - id: employee-service
          uri: lb://employee-service
          predicates:
            - Path=/api/employee/**,/api/employees
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:8761/eureka/
  instance:
    hostname: localhost

Esta configuración define rutas para los servicios de la empresa y de los empleados y registra la puerta de enlace en el registro de servicios.

6

Crear microservicios MongoDB.

Esta aplicación incluye dos microservicios: uno para la empresa y otro para los empleados. Cada microservicio se conecta a su propia instancia de MongoDB para mantener su independencia.

La configuración del servicio de la empresa se define en el archivo microservices-architecture-mongodb-config-repo/company-service.properties:

spring.data.mongodb.uri=${MONGODB_URI_1:mongodb://localhost:27017}
spring.threads.virtual.enabled=true
management.endpoints.web.exposure.include=*
management.info.env.enabled=true
info.app.name=Company Microservice
info.app.java.version=21
info.app.type=Spring Boot
server.port=8081
eureka.client.register-with-eureka=true
eureka.client.fetch-registry=true
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/
eureka.instance.hostname=localhost

La configuración del servicio al empleado se define en el archivo microservices-architecture-mongodb-config-repo/employee-service.properties:

spring.data.mongodb.uri=${MONGODB_URI_2:mongodb://localhost:27018}
spring.threads.virtual.enabled=true
management.endpoints.web.exposure.include=*
management.info.env.enabled=true
info.app.name=Employee Microservice
info.app.java.version=21
info.app.type=Spring Boot
server.port=8082
eureka.client.register-with-eureka=true
eureka.client.fetch-registry=true
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/
eureka.instance.hostname=localhost

Nota

Para el desarrollo local, el servicio de la empresa se conecta a MongoDB en el puerto 27017 y el servicio del empleado se conecta a MongoDB en el puerto 27018. Para producción, utilice clústeres de MongoDB Atlas independientes y configure las cadenas de conexión mediante las variables de entorno MONGODB_URI_1 y MONGODB_URI_2.

7

Pruebe las API REST.

Después de iniciar todos los servicios, verifique que su arquitectura de microservicios funcione correctamente asegurándose de que los siguientes servicios se estén ejecutando:

  • Servidor de configuración en el puerto 8888

  • Registro de servicio en el puerto 8761

  • Puerta de enlace API en el puerto 8080

  • Servicio de la empresa en el puerto 8081

  • Servicio de empleados en el puerto 8082

Asegúrese también de tener dos instancias de MongoDB ejecutándose en los puertos 27017 y 27018, o dos clústeres de MongoDB Atlas.

Ejecute el script de prueba ejecutando el siguiente comando:

./2_api-tests.sh

El script crea empresas y empleados, y luego los recupera mediante la API REST. El resultado que devuelve el script es similar al siguiente:

DELETE Companies
2
DELETE Employees
2
POST Company 'MongoDB'
POST Company 'Google'
GET Company 'MongoDB' by 'id'
{
    "id": "661aac7904e1bf066ee8e214",
    "name": "MongoDB",
    "headquarters": "New York",
    "created": "2009-02-11T00:00:00.000+00:00"
}
GET Company 'Google' by 'name'
{
    "id": "661aac7904e1bf066ee8e216",
    "name": "Google",
    "headquarters": "Mountain View",
    "created": "1998-09-04T00:00:00.000+00:00"
}
GET Companies
[
    {
        "id": "661aac7904e1bf066ee8e214",
        "name": "MongoDB",
        "headquarters": "New York",
        "created": "2009-02-11T00:00:00.000+00:00"
    },
    {
        "id": "661aac7904e1bf066ee8e216",
        "name": "Google",
        "headquarters": "Mountain View",
        "created": "1998-09-04T00:00:00.000+00:00"
    }
]
POST Employee Maxime
POST Employee Tim
GET Employee 'Maxime' by 'id'
{
    "id": "661aac79cf04401110c03516",
    "firstName": "Maxime",
    "lastName": "Beugnet",
    "company": "Google",
    "headquarters": "Mountain View",
    "created": "1998-09-04T00:00:00.000+00:00",
    "joined": "2018-02-12T00:00:00.000+00:00",
    "salary": 2468
}
GET Employee 'Tim' by 'id'
{
    "id": "661aac79cf04401110c03518",
    "firstName": "Tim",
    "lastName": "Kelly",
    "company": "MongoDB",
    "headquarters": "New York",
    "created": "2009-02-11T00:00:00.000+00:00",
    "joined": "2023-08-23T00:00:00.000+00:00",
    "salary": 13579
}
GET Employees
[
    {
        "id": "661aac79cf04401110c03516",
        "firstName": "Maxime",
        "lastName": "Beugnet",
        "company": "Google",
        "headquarters": "Mountain View",
        "created": "1998-09-04T00:00:00.000+00:00",
        "joined": "2018-02-12T00:00:00.000+00:00",
        "salary": 2468
    },
    {
        "id": "661aac79cf04401110c03518",
        "firstName": "Tim",
        "lastName": "Kelly",
        "company": "MongoDB",
        "headquarters": "New York",
        "created": "2009-02-11T00:00:00.000+00:00",
        "joined": "2023-08-23T00:00:00.000+00:00",
        "salary": 13579
    }
]

El servicio de empleados consulta al servicio de empresas para obtener los datos de la empresa. El siguiente código muestra cómo se comunica el servicio de empleados con el servicio de empresas a través del registro de servicios:

private CompanyDTO getCompany(String company) {
    String url = "http://company-service/api/company/name/";
    CompanyDTO companyDTO = restTemplate.getForObject(url + company, CompanyDTO.class);
    if (companyDTO == null) {
        throw new EntityNotFoundException("Company not found: ", company);
    }
    return companyDTO;
}

La URL hace referencia al servicio de la empresa por nombre en lugar de por dirección IP y puerto, lo que confirma que el registro del servicio funciona correctamente.

Recursos adicionales

Para obtener más información sobre cómo crear microservicios con Spring y MongoDB, consulte los siguientes recursos:

Volver

Datos de primavera CSFLE

Next

Quarkus con Panache y MongoDB

En esta página