Menu Docs
Página inicial do Docs
/ /
Integrações de terceiros
Página inicial do Docs
/ /
Driver de sincronização Java
/
Integrações de terceiros
Página inicial do Docs
/
Bibliotecas do cliente
/
Java
/
Driver de sincronização Java
/
Integrações de terceiros

Tutorial: Criar um Aplicativo de Microsserviços com MongoDB

Visão geral

Este tutorial mostra como criar uma arquitetura de microsserviços usando Spring Boot, Spring nuvem e MongoDB. Especificamente, este tutorial orienta você na criação de vários serviços que funcionam juntos para formar um aplicativo completo.

Você pode encontrar o código fonte completo nos seguintes repositórios do GitHub:

  • aplicativo de microsserviços

  • Repositório de configuração

Bota de primavera

O Spring Boot é um framework criado sobre o Spring Framework. Ele adiciona recursos de configuração automática, padrões e recursos prontos para produção para simplificar a criação de aplicativos Java baseados em Spring, incluindo a integração com o Spring Data MongoDB. Para obter mais informações, consulte a documentação do Spring Boot.

Nuvem de primavera

Spring nuvem é uma coleção de ferramentas para construir sistemas distribuídos e microsserviços. Ele fornece recursos para gerenciamento de configuração, descoberta de serviços e roteamento inteligente. Para mais informações, consulte a documentação do Spring nuvem.

Tutorial

Este tutorial mostra como executar as seguintes ações:

  • Verifique os pré-requisitos

  • Clone os repositórios de exemplo

  • Configurar um servidor de configuração

  • Configurar um registro de serviço

  • Configurar um gateway de API

  • Criar microsserviços MongoDB

  • Teste as APIs REST

1

Verifique os pré-requisitos.

Antes de começar, verifique se você tem o seguinte instalado:

2

Clone os repositórios de exemplo .

Clone o aplicativo de microsserviços e os repositórios de configuração executando os seguintes 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 as instruções no arquivo README.md do repositório microservices-architecture-mongodb para iniciar cada serviço.

3

Configure um servidor de configuração.

Um servidor de configuração armazena todos os arquivos de configuração para seus microsserviços em um único repositório.

A configuração do servidor de configuração é definida no arquivo 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 configuração especifica a localização do repositório Git que armazena sua configuração de microsserviços e a ramificação a ser usada.

O aplicativo do servidor de configuração é definido na seguinte classe Java localizada no diretório microservices-architecture-mongodb/config-server/src/main/java/com/mongodb/configserver/:

ConfigServerApplication.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);
    }
}

Observação

A anotação @EnableConfigServer habilita a funcionalidade do servidor de configuração em seu aplicativo Spring Boot.

4

Configure um registro de serviço.

Um registro de serviço acompanha quais microsserviços estão sendo executados e suas localizações. Outros serviços usam essas informações para se comunicar com os microsserviços de que precisam.

A configuração do registro de serviço é definida no seguinte arquivo de propriedades:

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

As duas últimas propriedades impedem que o registro de serviço se registre em si mesmo.

O aplicativo de registro de serviço é definido na seguinte classe Java localizada no diretório microservices-architecture-mongodb/service-registry/src/main/java/com/mongodb/serviceregistry/ :

ServiceRegistryApplication.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);
    }
}

Observação

A anotação @EnableEurekaServer habilita a funcionalidade de registro de serviço em seu aplicativo Spring Boot.

5

Configure um gateway de API.

Um gateway de API fornece um único ponto de entrada para acessar todos os seus microsserviços. O gateway distribui solicitações entre vários microsserviços e lida com segurança, monitoramento e outras preocupações.

A configuração do gateway da API é definida no arquivo 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 configuração define rotas para os serviços da empresa e do funcionário e registra o gateway no registro de serviço.

6

Crie microsserviços MongoDB.

Este aplicativo inclui dois microsserviços: um serviço para a empresa e um serviço para o funcionário. Cada microsserviço se conecta à sua própria instância do MongoDB para manter a independência.

A configuração do serviço da empresa é definida no arquivo 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

A configuração do serviço do funcionário é definida no arquivo 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

Observação

Para desenvolvimento local, o serviço da empresa se conecta ao MongoDB na porta 27017 e o serviço do funcionário se conecta ao MongoDB na porta 27018. Para produção, utilize clusters MongoDB Atlas separados e configure as cadeias de conexão utilizando as variáveis de ambiente do MONGODB_URI_1 e MONGODB_URI_2.

7

Teste as APIs REST.

Depois de iniciar todos os serviços, verifique se a arquitetura de microsserviços funciona corretamente garantindo que os seguintes serviços estejam em execução:

  • servidor de configuração na porta 8888

  • Registro de serviço na porta 8761

  • Gateway da API na porta 8080

  • Serviço da empresa na porta 8081

  • Serviço de funcionário na porta 8082

Certifique-se também de ter duas instâncias do MongoDB em execução nas portas 27017 e 27018, ou dois clusters do MongoDB Atlas .

Execute o script de teste executando o seguinte comando:

./2_api-tests.sh

O script cria empresas e funcionários e, em seguida, os recupera usando a REST API. A saída retornada pelo script é semelhante à seguinte:

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
    }
]

O serviço de funcionários consulta o serviço da empresa para recuperar os detalhes da empresa. O seguinte código mostra como o serviço do funcionário se comunica com o serviço da empresa por meio do registro de serviço:

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;
}

O URL faz referência ao serviço da empresa por nome e não pelo endereço IP e porta, o que confirma que o registro de serviço funciona corretamente.

Recursos adicionais

Para saber mais sobre como criar microsserviços com Spring e MongoDB, consulte os seguintes recursos:

Voltar

CSFLE de dados da primavera

Próximo

Quarkus com Panache e MongoDB

Nesta página