Spring Cloud - Bootstrapping
1. Visão geral
O Spring Cloud é uma estrutura para criar aplicativos de nuvem robustos. A estrutura facilita o desenvolvimento de aplicativos, fornecendo soluções para muitos dos problemas comuns enfrentados ao mudar para um ambiente distribuído.
Os aplicativos executados com a arquitetura de microsserviços visam simplificar o desenvolvimento, a implantação e a manutenção. A natureza decomposta do aplicativo permite que os desenvolvedores se concentrem em um problema de cada vez. As melhorias podem ser introduzidas sem afetar outras partes de um sistema.
Por outro lado, surgem diferentes desafios quando adotamos uma abordagem de microsserviço:
-
Externalizando a configuração para que seja flexível e não exija a reconstrução do serviço na mudança
-
Descoberta de serviço *Ocultando a complexidade dos serviços implantados em diferentes hosts
Neste artigo, criaremos cinco microsserviços: um servidor de configuração, um servidor de descoberta, um servidor de gateway, um serviço de livro e, finalmente, um serviço de classificação. Esses cinco microsserviços formam um aplicativo básico sólido para iniciar o desenvolvimento da nuvem e enfrentar os desafios mencionados acima.
===* 2. Servidor de configuração *
Ao desenvolver um aplicativo em nuvem, um problema é manter e distribuir a configuração para nossos serviços. Realmente não queremos perder tempo configurando cada ambiente antes de dimensionar horizontalmente nosso serviço ou arriscar violações de segurança inserindo nossa configuração em nosso aplicativo.
Para resolver isso, consolidaremos toda a nossa configuração em um único repositório Git e a conectaremos a um aplicativo que gerencia uma configuração para todos os nossos aplicativos. Vamos configurar uma implementação muito simples.
Para saber mais detalhes e ver um exemplo mais complexo, consulte o link:/spring-cloud-configuration [Spring Cloud Configuration] artigo.
====* 2.1 Configuração *
Navegue para https://start.spring.io [start.spring.io] e selecione Maven e Spring Boot 1.4.x.
Defina o artefato como "config" _. Na seção de dependências, procure por "_config server" _ e adicione esse módulo. Em seguida, pressione o botão _generate e você poderá baixar um arquivo zip com um projeto pré-configurado por dentro e pronto para usar.
Como alternativa, podemos gerar um projeto Spring Boot e adicionar algumas dependências ao arquivo POM manualmente.
Essas dependências serão compartilhadas entre todos os projetos:
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.4.0.RELEASE</version>
<relativePath/>
</parent>
<dependencies>
<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>Brixton.SR5</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>Vamos adicionar uma dependência para o servidor de configuração:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-config-server</artifactId>
</dependency>Para referência: você pode encontrar a versão mais recente em Maven Central (https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a%3A% 22spring-cloud-dependencies% 22 [dependências da nuvem da primavera], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.boot%22%20AND%20a% 3A% 22spring-boot-starter-test% 22 [test], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a% 3A% 22spring-cloud-config-server% 22 [config-server]).
====* 2.2 Configuração da Primavera *
Para habilitar o servidor de configuração, devemos adicionar algumas anotações à classe principal do aplicativo:
@SpringBootApplication
@EnableConfigServer
public class ConfigApplication {...}_ @ EnableConfigServer_ transformará nosso aplicativo em um servidor de configuração.
====* 2.3 Propriedades *
Vamos adicionar o application.properties em src/main/resources:
server.port=8081
spring.application.name=config
spring.cloud.config.server.git.uri=file://${user.home}/application-configA configuração mais significativa para o servidor de configuração é o parâmetro git.uri. No momento, ele está definido como um caminho de arquivo relativo que geralmente é resolvido para c: \ Users \\ {nome do usuário} \ _ no Windows ou _/Users/\ {nome do usuário}/ no* nix. Essa propriedade aponta para um repositório Git onde os arquivos de propriedades para todos os outros aplicativos são armazenados. Pode ser definido como um caminho de arquivo absoluto, se necessário.
*Dica* : em uma máquina Windows, anteceda o valor com ‘file:///', em *nix, use‘ file://'.
====* 2.4. Repositório Git *
Navegue até a pasta definida por spring.cloud.config.server.git.uri e adicione a pasta ‘application-config '. CD nessa pasta e digite git init. Isso inicializará um repositório Git onde podemos armazenar arquivos e rastrear suas alterações.
====* 2.5 Run *
Vamos executar o servidor de configuração e verificar se está funcionando. Na linha de comando, digite mvn spring-boot: run. Isso iniciará o servidor. Você deve ver esta saída indicando que o servidor está em execução:
Tomcat started on port(s): 8081 (http)====* 2.6 Configuração de inicialização *
Em nossos servidores subseqüentes, queremos que suas propriedades de aplicativos sejam gerenciadas por este servidor de configuração. Para fazer isso, na verdade, precisamos fazer um pouco de galinha e ovo:* Configure propriedades em cada aplicativo que sabem como responder a esse servidor. *
É um processo de inicialização e* cada um desses aplicativos terá um arquivo chamado bootstrap.properties _. *Ele conterá propriedades como _application.properties, mas com um toque:
Um Spring pai ApplicationContext* carrega o bootstrap.properties primeiro. * Isso é essencial para que o Config Server possa começar a gerenciar as propriedades em application.properties. É esse ApplicationContext especial que também descriptografa todas as propriedades criptografadas do aplicativo.
*É inteligente manter esses arquivos de propriedades distintos.* _Bootstrap.properties_ é para preparar o servidor de configuração e _application.properties_ é para propriedades específicas de nosso aplicativo. Tecnicamente, porém, é possível colocar propriedades do aplicativo em _bootstrap.properties_.
Por fim, como o Config Server está gerenciando nossas propriedades de aplicativo, pode-se perguntar por que um application.properties é de todo? A resposta é que eles ainda são úteis como valores padrão que talvez o Config Server não possua.
*3. Descoberta *
Agora que resolvemos a configuração, precisamos de uma maneira de todos os nossos servidores poderem se encontrar. Resolveremos esse problema configurando o servidor de descoberta Eureka. Como nossos aplicativos podem estar em execução em qualquer combinação de ip/porta, precisamos de um registro de endereço central que possa servir como uma pesquisa de endereço de aplicativo.
Quando um novo servidor é provisionado, ele se comunica com o servidor de descoberta e registra seu endereço para que outras pessoas possam se comunicar com ele. Dessa forma, outros aplicativos podem consumir essas informações à medida que fazem solicitações.
Para saber mais detalhes e ver uma implementação de descoberta mais complexa, consulte o link:/spring-cloud-netflix-eureka [artigo da Spring Cloud Eureka].
====* 3.1 Configuração *
Novamente, vamos navegar para start.spring.io. Defina o artefato como 'descoberta'. Procure por "eureka server" e adicione essa dependência. Procure por "config client" e adicione essa dependência. Gere o projeto.
Como alternativa, podemos criar um projeto Spring Boot, copiar o conteúdo do POM do servidor de configuração e trocar nessas dependências:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka-server</artifactId>
</dependency>Para referência: você encontrará os pacotes configuráveis no Maven Central (https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a%3A%22spring -cloud-starter-config% 22 [config-client], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a%3A % 22spring-cloud-starter-eureka-server% 22 [eureka-server]).
====* 3.2 Configuração da Primavera *
Vamos adicionar a configuração Java à classe principal:
@SpringBootApplication
@EnableEurekaServer
public class DiscoveryApplication {...}_ @ EnableEurekaServer_ configurará este servidor como um servidor de descoberta usando o Netflix Eureka. Spring Boot detectará automaticamente a dependência da configuração no caminho de classe e pesquisará a configuração no servidor de configuração.
====* 3.3 Propriedades *
Agora vamos adicionar dois arquivos de propriedades:
bootstrap.properties em src/main/resources
spring.cloud.config.name=discovery
spring.cloud.config.uri=http://localhost:8081Essas propriedades permitirão que o servidor de descoberta consulte o servidor de configuração na inicialização.
discovery.properties em nosso repositório Git
spring.application.name=discovery
server.port=8082
eureka.instance.hostname=localhost
eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=falseO nome do arquivo deve corresponder à propriedade spring.application.name.
Além disso, informamos a este servidor que ele está operando na zona padrão, que corresponde à configuração de região do cliente de configuração. Também estamos dizendo ao servidor para não se registrar em outra instância de descoberta.
Na produção, você teria mais de um deles para fornecer redundância em caso de falha e essa configuração seria verdadeira.
Vamos confirmar o arquivo no repositório Git. Caso contrário, o arquivo não será detectado.
====* 3.4 Adicionar dependência ao servidor de configuração *
Adicione esta dependência ao arquivo POM do servidor de configuração:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>Para referência* *: * *você encontrará o pacote no Maven Central (https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a % 3A% 22spring-cloud-starter-eureka% 22 [eureka-client]).
Adicione essas propriedades ao arquivo application.properties em src/main/resources do servidor de configuração:
eureka.client.region = default
eureka.client.registryFetchIntervalSeconds = 5
eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/====* 3.5 Run *
Inicie o servidor de descoberta usando o mesmo comando, mvn spring-boot: run. A saída da linha de comando deve incluir:
Fetching config from server at: http://localhost:8081
...
Tomcat started on port(s): 8082 (http)Pare e execute novamente o serviço de configuração. Se tudo estiver bom, a saída deve se parecer com:
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: 204===* 4. Porta de entrada *
Agora que resolvemos nossos problemas de configuração e descoberta, ainda temos um problema com os clientes acessando todos os nossos aplicativos.
Se deixarmos tudo em um sistema distribuído, teremos que gerenciar cabeçalhos CORS complexos para permitir solicitações de origem cruzada nos clientes. Podemos resolver isso criando um servidor Gateway. Isso atuará como uma solicitação de transferência de proxy reverso dos clientes para nossos servidores de back-end.
Um servidor de gateway é um excelente aplicativo na arquitetura de microsserviço, pois permite que todas as respostas sejam originadas de um único host. Isso eliminará a necessidade do CORS e nos proporcionará um local conveniente para lidar com problemas comuns, como autenticação.
====* 4.1 Configuração *
Até agora já sabemos o que fazer. Navegue para start.spring.io. Defina o artefato como gate gateway ‘. Procure por "zuul" e adicione essa dependência. Procure por "_config client" _ e adicione essa dependência. Pesquise "_eureka discovery" _ e adicione essa dependência. Gere esse projeto.
Como alternativa, poderíamos criar um aplicativo Spring Boot com estas dependências:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-zuul</artifactId>
</dependency>Para referência: você encontrará o pacote no Maven Central (https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a%3A%22spring -cloud-starter-config% 22 [config-client], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a%3A % 22spring-cloud-starter-eureka% 22 [eureka-client], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a % 3A% 22spring-cloud-starter-zuul% 22 [zuul]).
====* 4.2 Configuração da Primavera *
Vamos adicionar a configuração à classe principal:
@SpringBootApplication
@EnableZuulProxy
@EnableEurekaClient
public class GatewayApplication {...}====* 4.3 Propriedades *
Agora vamos adicionar dois arquivos de propriedades:
bootstrap.properties em 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=http://localhost:8082/eureka/gateway.properties em nosso repositório Git
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=http://localhost:8082
hystrix.command.discovery.execution.isolation.thread.timeoutInMilliseconds=600000A propriedade zuul.routes nos permite definir um aplicativo para rotear determinadas solicitações com base em um correspondente de URL ant. Nossa propriedade diz ao Zuul para rotear qualquer solicitação que venha em ‘/book-service/* *'para um aplicativo com o spring.application.name do‘ book-service'. Zuul pesquisará o host do servidor de descoberta usando o nome do aplicativo e encaminhará a solicitação para esse servidor.
Lembre-se de confirmar as alterações no repositório!
====* 4.4 Run *
Execute os aplicativos de configuração e descoberta e aguarde até que o aplicativo de configuração seja registrado no servidor de descoberta. Se eles já estiverem em execução, você não precisará reiniciá-los. Quando isso estiver concluído, execute o servidor de gateway. O servidor de gateway deve iniciar na porta 8080 e se registrar no servidor de descoberta. A saída do console deve conter:
Fetching config from server at: http://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)Um erro fácil de cometer é iniciar o servidor antes que o servidor de configuração seja registrado com Eureka. Nesse caso, você verá um log com esta saída:
Fetching config from server at: http://localhost:8888Este é o URL e a porta padrão para um servidor de configuração e indica que nosso serviço de descoberta não tinha um endereço quando a solicitação de configuração foi feita. Aguarde alguns segundos e tente novamente. Depois que o servidor de configuração estiver registrado no Eureka, o problema será resolvido.
===* 5. Serviço de Reservas *
Na arquitetura de microsserviço, somos livres para criar tantos aplicativos para atender a um objetivo comercial. Geralmente, os engenheiros dividem seus serviços por domínio. Seguiremos esse padrão e criaremos um serviço de livros para lidar com todas as operações de livros em nosso aplicativo.
====* 5.1. Configuração *
Mais uma vez. Navegue para start.spring.io. Defina o artefato como 'serviço de livro'. Procure por "web" e adicione essa dependência. Procure por "config client" e adicione essa dependência. Procure _ “eureka discovery” _ e adicione essa dependência. Gere esse projeto.
Como alternativa, adicione essas dependências a um projeto:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>Para referência: você encontrará o pacote no Maven Central (https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a%3A%22spring -cloud-starter-config% 22 [config-client], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a%3A % 22spring-cloud-starter-eureka% 22 [cliente da eureka], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.boot%22%20AND%20a % 3A% 22spring-boot-starter-web% 22 [web]).
====* 5.2 Configuração da Primavera *
Vamos modificar nossa classe principal:
@SpringBootApplication
@EnableEurekaClient
@RestController
@RequestMapping("/books")
public class BookServiceApplication {
public static void main(String[] args) {
SpringApplication.run(BookServiceApplication.class, args);
}
private List<Book> 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<Book> findAllBooks() {
return bookList;
}
@GetMapping("/{bookId}")
public Book findBook(@PathVariable Long bookId) {
return bookList.stream().filter(b -> b.getId().equals(bookId)).findFirst().orElse(null);
}
}Também adicionamos um controlador REST e um campo definido pelo nosso arquivo de propriedades para retornar um valor que definiremos durante a configuração.
Vamos agora adicionar o livro POJO:
public class Book {
private Long id;
private String author;
private String title;
//standard getters and setters
}====* 5.3. Propriedades *
Agora só precisamos adicionar nossos dois arquivos de propriedades:
bootstrap.properties em 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=http://localhost:8082/eureka/book-service.properties em nosso repositório Git:
spring.application.name=book-service
server.port=8083
eureka.client.region = default
eureka.client.registryFetchIntervalSeconds = 5
eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/Vamos confirmar as alterações no repositório.
====* 5.4 Run *
Após o início de todos os outros aplicativos, podemos iniciar o serviço de livro. A saída do console deve se parecer com:
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)Uma vez instalado, podemos usar nosso navegador para acessar o terminal que acabamos de criar. Navegue para http://localhost: 8080/book-service/books e retornamos um objeto JSON com dois livros que adicionamos no controlador. Observe que não estamos acessando o serviço de livro diretamente na porta 8083, mas estamos passando pelo servidor de gateway.
===* 6. Serviço de classificação *
Como nosso serviço de livros, nosso serviço de classificação será um serviço orientado a domínio que lidará com operações relacionadas a classificações.
====* 6.1 Configuração *
Mais uma vez. Navegue para start.spring.io. Defina o artefato como 'serviço de classificação'. Procure por "web" e adicione essa dependência. Procure por "config client" e adicione essa dependência. Procure _ “eureka discovery” _ e adicione essa dependência. Gere esse projeto.
Como alternativa, adicione essas dependências a um projeto:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>Para referência: você encontrará o pacote no Maven Central (https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a%3A%22spring -cloud-starter-config% 22 [config-client], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.cloud%22%20AND%20a%3A % 22spring-cloud-starter-eureka% 22 [cliente da eureka], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.boot%22%20AND%20a % 3A% 22spring-boot-starter-web% 22 [web]).
====* 6.2 Configuração da Primavera *
Vamos modificar nossa classe principal:
@SpringBootApplication
@EnableEurekaClient
@RestController
@RequestMapping("/ratings")
public class RatingServiceApplication {
public static void main(String[] args) {
SpringApplication.run(RatingServiceApplication.class, args);
}
private List<Rating> 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<Rating> findRatingsByBookId(@RequestParam Long bookId) {
return bookId == null || bookId.equals(0L) ? Collections.EMPTY_LIST : ratingList.stream().filter(r -> r.getBookId().equals(bookId)).collect(Collectors.toList());
}
@GetMapping("/all")
public List<Rating> findAllRatings() {
return ratingList;
}
}Também adicionamos um controlador REST e um campo definido pelo nosso arquivo de propriedades para retornar um valor que definiremos durante a configuração.
Vamos adicionar a classificação POJO:
public class Rating {
private Long id;
private Long bookId;
private int stars;
//standard getters and setters
}====* 6.3. Propriedades *
Agora só precisamos adicionar nossos dois arquivos de propriedades:
bootstrap.properties em 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=http://localhost:8082/eureka/rating-service.properties em nosso repositório Git:
spring.application.name=rating-service
server.port=8084
eureka.client.region = default
eureka.client.registryFetchIntervalSeconds = 5
eureka.client.serviceUrl.defaultZone=http://localhost:8082/eureka/Vamos confirmar as alterações no repositório.
====* 6.4. Run *
Uma vez iniciadas todas as outras aplicações, podemos iniciar o serviço de classificação. A saída do console deve se parecer com:
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)Uma vez instalado, podemos usar nosso navegador para acessar o terminal que acabamos de criar. Navegue para http://localhost: 8080/rating-service/ratings/all e retornamos JSON contendo todas as nossas classificações. Observe que não estamos acessando o serviço de classificação diretamente na porta 8084, mas estamos passando pelo servidor de gateway.
===* 7. Conclusão*
Agora, podemos conectar as várias partes do Spring Cloud a um aplicativo de microsserviço em funcionamento. Isso forma uma base que podemos usar para começar a criar aplicativos mais complexos.
Como sempre, você pode encontrar esse código fonte no Github.