O jogo de cartas Durak para jogar online com outros jogadores

Download do frasco do Spring Cloud Starter Eureka Server

Se você está desenvolvendo microsserviços com Spring Boot e Spring Cloud, você deve ter ouvido falar Spring Cloud Netflix Eureka. É uma solução de descoberta de serviço que permite que você registre e descubra seus microsserviços sem codificar suas localizações. Neste artigo, mostraremos como baixar e instalar o spring-cloud-starter-eureka-server jar, que é a dependência que você precisa para configurar um Servidor Eureka no seu projecto. Também mostraremos como registrar e descobrir serviços com o Eureka Server e como acessar e monitorar seu painel.

spring-cloud-starter-eureka-server jar download

DOWNLOAD: https://urlca.com/2vSe98

Introdução

O Spring Cloud Netflix Eureka faz parte do projeto Spring Cloud Netflix, que fornece integrações com componentes OSS (software de código aberto) da Netflix. O Eureka é um desses componentes e é responsável pela descoberta de serviços.

A descoberta de serviço é um recurso fundamental em uma arquitetura de microsserviços, na qual você tem vários serviços independentes que precisam se comunicar entre si. Em vez de codificar os nomes de host e portas desses serviços, você pode usar um registro de serviço, onde cada serviço pode se registrar com sua localização e metadados. Em seguida, outros serviços podem consultar o registro para localizar e consumir os serviços registrados.

Eureka Server é o componente de registro de serviço que você pode configurar em seu projeto. Possui as seguintes características e benefícios:

• É fácil de usar e configurar com anotações e propriedades Spring Boot e Spring Cloud.

• Ele oferece suporte ao balanceamento de carga do lado do cliente e do lado do servidor, o que significa que cada cliente pode armazenar em cache as informações do registro localmente e usar um algoritmo de balanceamento de carga para escolher a melhor instância de serviço.

• Ele é resistente a falhas, pois pode lidar com erros de rede, interrupções de serviço e problemas de replicação de registro.

• Ele fornece uma interface da web onde você pode visualizar os serviços registrados e suas instâncias, bem como sua integridade e status.

• Ele se integra bem com outros componentes do Spring Cloud Netflix, como Zuul (um proxy de roteamento e filtragem), Hystrix (um disjuntor e mecanismo de fallback), Ribbon (um balanceador de carga do lado do cliente) e Feign (um cliente REST declarativo).

Como baixar e instalar o Eureka Server Jar

Para configurar um Eureka Server em seu projeto, você precisa baixar e instalar o spring-cloud-starter-eureka-server jar, que é a dependência que contém todas as bibliotecas e configurações necessárias. Aqui estão os passos que você precisa seguir:

Pré-requisitos e dependências

Para usar o Eureka Server, você precisa ter os seguintes pré-requisitos:

• Java 8 ou posterior

• Maven ou Gradle como sua ferramenta de construção

Spring Boot 2.x como sua estrutura de aplicativoPara usar o Eureka Server, você também precisa adicionar a seguinte dependência ao seu pom.xml arquivo se você estiver usando Maven, ou para o seu build.gradle arquivo se você estiver usando o Gradle:

```xml

org.springframework.cloud

spring-cloud-starter-eureka-server

3.0.4

``` ```implementação gradle 'org.springframework.cloud:spring-cloud-starter-eureka-server:3.0.4' ``` Você pode encontrar a versão mais recente da dependência no .

Spring Initializer

Uma maneira conveniente de gerar um modelo de projeto com a dependência do Eureka Server é usar , que é uma ferramenta baseada na Web que permite criar e configurar aplicativos Spring Boot. Você pode seguir estas etapas para usar o Spring Initializr:

• Vou ao e preencha as informações básicas, como nome do projeto, ID do grupo, ID do artefato, empacotamento e versão do Java.

• Selecione Spring Boot 2.x como a versão do Spring Boot.

• Na seção de dependências, procure e selecione Servidor Eureka.

• Clique no Gerar botão para baixar um arquivo zip contendo o modelo do projeto.

• Extraia o arquivo zip e abra o projeto em seu IDE (Integrated Development Environment) de sua preferência.

Configuração do Servidor Eureka

Depois de criar e abrir o projeto, você precisa habilitar e configurar o Eureka Server em seu aplicativo Spring Boot. Você pode fazer isso seguindo estas etapas:

• Na classe principal do seu aplicativo, adicione o @EnableEurekaServer anotação acima da declaração de classe. Esta anotação informa ao Spring Boot que este aplicativo é um Eureka Server e deve iniciar como um.

• ```java import org.springframework.boot.SpringApplication; importar org.springframework.boot.autoconfigure.SpringBootApplication; importar org.springframework.cloud.netflix.eureka.server.EnableEurekaServer; @SpringBootApplication @EnableEurekaServer public class EurekaServerApplication public static void main(String[] args) SpringApplication.run(EurekaServerApplication.class, args); ``` No application.properties arquivo (ou aplicativo.yml se preferir o formato YAML), adicione algumas propriedades para configurar o Eureka Server. Por exemplo, você pode definir a porta do servidor, o nome do aplicativo e se deve se registrar em outros servidores Eureka (se tiver mais de um). Aqui está um exemplo de algumas propriedades básicas:

```properties server.port=8761 spring.application.name=eureka-server eureka.client.register-with-eureka=false eureka.client.fetch-registry=false ``` Você pode encontrar mais propriedades e suas descrições no .

• Salve e execute seu aplicativo. Você deve ver alguns logs indicando que o Eureka Server está funcionando na porta 8761.

Como registrar e descobrir serviços com o Eureka Server

Agora que você configurou um Eureka Server em seu projeto, pode usá-lo para registrar e descobrir seus microsserviços. Para fazer isso, você precisa adicionar o Cliente Eureka dependência aos seus aplicativos de microsserviço e configure-os para se registrar e consultar no Eureka Server.Aqui estão os passos que você precisa seguir:

Dependência e anotação do cliente Eureka

Para usar o Eureka Client em seus aplicativos de microsserviço, você precisa adicionar a seguinte dependência ao seu pom.xml arquivo se você estiver usando Maven, ou para o seu build.gradle arquivo se você estiver usando o Gradle:

```xml

org.springframework.cloud

spring-cloud-starter-eureka-client

3.0.4

``` ```implementação gradle 'org.springframework.cloud:spring-cloud-starter-eureka-client:3.0.4' ``` Você pode encontrar a versão mais recente da dependência no .

Além disso, você precisa adicionar o @EnableEurekaClient acima da classe principal do seu aplicativo de microsserviço. Esta anotação informa ao Spring Boot que este aplicativo é um Eureka Client e deve se comunicar com o Eureka Server.

```java import org.springframework.boot.SpringApplication; importar org.springframework.boot.autoconfigure.SpringBootApplication; importar org.springframework.cloud.netflix.eureka.EnableEurekaClient; @SpringBootApplication @EnableEurekaClient public class MicroserviceApplication public static void main(String[] args) SpringApplication.run(MicroserviceApplication.class, args); ``` Configuração e registro do cliente Eureka

Depois de adicionar a dependência e a anotação do Eureka Client ao seu aplicativo de microsserviço, você precisa configurar algumas propriedades para registrá-lo no Eureka Server. Você pode fazer isso adicionando algumas propriedades ao seu application.properties arquivo (ou aplicativo.yml se preferir o formato YAML). Por exemplo, você pode definir o nome do aplicativo, a URL do Eureka Server e a ID da instância. Aqui está um exemplo de algumas propriedades básicas:

```properties spring.application.name=microservice eureka.client.service-url.defaultZone= eureka.instance.instance-id=$spring.application.name:$random.value ``` Você pode encontrar mais propriedades e suas descrições no .

Salve e execute seu aplicativo de microsserviço. Você deve ver alguns logs indicando que ele foi registrado com sucesso no Eureka Server.

Fingir configuração e consumo do cliente

Para consumir um serviço registrado de outro microsserviço, você pode usar Spring Cloud Netflix Feign Client, que é um cliente REST declarativo que simplifica a comunicação HTTP. Para usar o Feign Client em seu aplicativo de microsserviço, você precisa adicionar a seguinte dependência ao seu pom.xml arquivo se você estiver usando Maven, ou para o seu build.gradle arquivo se você estiver usando o Gradle:

```xml

org.springframework.cloud

spring-cloud-starter-openfeign

3.0.4

``` ```implementação gradle 'org.springframework.cloud:spring-cloud-starter-openfeign:3.0.4' ``` Você pode encontrar a versão mais recente da dependência no .

Além disso, você precisa adicionar o @EnableFeignClients acima da classe principal do seu aplicativo de microsserviço. Esta anotação informa ao Spring Boot que este aplicativo pode usar Feign Clients para consumir serviços registrados.

```java import org.springframework.boot.SpringApplication; importar org.springframework.boot.autoconfigure.SpringBootApplication; importar org.springframework.cloud.netflix.eureka.EnableEurekaClient; importar org.springframework.cloud.openfeign.EnableFeignClients; @SpringBootApplication @EnableEurekaClient @EnableFeignClients public class MicroserviceApplication public static void main(String[] args) SpringApplication.run(MicroserviceApplication.class, args); ``` Para criar um Feign Client para um serviço registrado, você precisa definir uma interface e anotá-la com @FeignClient. A anotação leva o nome do serviço como parâmetro e, opcionalmente, algumas propriedades de configuração. Em seguida, você pode declarar métodos na interface que correspondem aos endpoints REST do serviço e anotá-los com anotações do Spring MVC, como @GetMapping, @PostMapping, etcAqui está um exemplo de um Feign Client para um serviço chamado olá-serviço que tem um ponto de extremidade GET em /olá:

```java import org.springframework.cloud.openfeign.FeignClient; importar org.springframework.web.bind.annotation.GetMapping; @FeignClient(name = "hello-service") public interface HelloServiceClient @GetMapping("/hello") String hello(); ``` Para usar o Feign Client em seu aplicativo de microsserviço, você pode simplesmente injetá-lo como um bean e chamar seus métodos. Por exemplo, você pode criar um controlador REST que usa o Feign Client para consumir o hello-service:

```java import org.springframework.web.bind.annotation.GetMapping; importar org.springframework.web.bind.annotation.RestController; @RestController public class HelloController private final HelloServiceClient helloServiceClient; public HelloController(HelloServiceClient helloServiceClient) this.helloServiceClient = helloServiceClient; @GetMapping("/consume") public String consumir() return helloServiceClient.hello(); ``` Como acessar e monitorar o painel do servidor Eureka

O Eureka Server fornece uma interface web onde você pode visualizar os serviços registrados e suas instâncias, bem como sua integridade e status. Para acessar o painel, você pode simplesmente abrir seu navegador e acessar a URL do seu aplicativo Eureka Server. Por exemplo, se o seu Eureka Server estiver sendo executado na porta 8761 em sua máquina local, você pode ir para Você deve ver uma página como esta:

O painel mostra as seguintes informações:

• O nome do aplicativo e o status do Eureka Server.

• A seção de informações gerais, que exibe a hora atual, ambiente, perfis e porta do servidor.

• As instâncias atualmente registradas na seção Eureka, que lista os nomes e URLs dos serviços registrados e suas instâncias. Você pode clicar em cada instância para ver mais detalhes, como metadados, status e URL de verificação de integridade.

Pontos de extremidade do atuador de inicialização de mola

Para monitorar a integridade e o status de seu aplicativo Eureka Server, você pode usar Atuador de bota de mola, que é um subprojeto do Spring Boot que fornece recursos prontos para produção, como métricas, auditorias e verificações de integridade. Para usar o Spring Boot Actuator em seu aplicativo Eureka Server, você precisa adicionar a seguinte dependência ao seu pom.xml arquivo se você estiver usando Maven, ou para o seu build.gradle arquivo se você estiver usando o Gradle:

```xml

org.springframework.boot

mola-inicializador-acionador-atuador

2.5.6

``` ```implementação gradle 'org.springframework.boot:spring-boot-starter-actuator:2.5.6' ``` Você pode encontrar a versão mais recente da dependência no .

Depois de adicionar a dependência, você pode acessar vários terminais que fornecem informações sobre seu aplicativo Eureka Server. Por exemplo, você pode ir para /atuador/saúde para ver o status de saúde do seu aplicativo, ou para /atuador/info para ver algumas informações básicas sobre seu aplicativo. Você também pode personalizar e configurar os endpoints de acordo com suas necessidades. Você pode encontrar mais detalhes e exemplos no .

Conclusão

Neste artigo, mostramos como baixar e instalar o arquivo jar spring-cloud-starter-eureka-server, que é a dependência necessária para configurar um Eureka Server em seu projeto. Também mostramos como registrar e descobrir serviços com o Eureka Server e como acessar e monitorar seu painel.

O Eureka Server é uma solução de descoberta de serviço que permite que você registre e descubra seus microsserviços sem codificar suas localizações. Possui muitos recursos e benefícios, como fácil configuração, balanceamento de carga, resiliência, interface web e integração com outros componentes do Spring Cloud Netflix.

Se você quiser saber mais sobre o Eureka Server e como usá-lo em sua arquitetura de microsserviços, confira estes links e recursos:

• 
  

• 
  

• 
  

• 
  

perguntas frequentes

Quais são algumas alternativas ao Eureka Server para descoberta de serviço?

Algumas alternativas ao Eureka Server para descoberta de serviço são:

• , que é uma malha de serviço distribuída que fornece descoberta, configuração e coordenação de serviço.

• , que é um serviço centralizado para manutenção de informações de configuração, nomeação e fornecimento de sincronização distribuída.

• , que é um armazenamento de valor-chave distribuído que fornece descoberta de serviço e gerenciamento de configuração.

• , que é um sistema de orquestração de contêineres que fornece descoberta de serviço e balanceamento de carga para microsserviços.

Como habilitar segurança e autenticação para o Eureka Server?

Para ativar a segurança e a autenticação do Eureka Server, você pode usar Spring Security, que é uma estrutura que fornece recursos de segurança abrangentes para aplicativos Spring. Para usar o Spring Security em seu aplicativo Eureka Server, você precisa adicionar a seguinte dependência ao seu pom.xml arquivo se você estiver usando Maven, ou para o seu build.gradle arquivo se você estiver usando o Gradle:

```xml ```xml

org.springframework.boot

spring-boot-starter-security

2.5.6

``` ```implementação gradle 'org.springframework.boot:spring-boot-starter-security:2.5.6' ``` Você pode encontrar a versão mais recente da dependência no .

Depois de adicionar a dependência, você pode configurar algumas propriedades e beans para ativar a autenticação básica para seu aplicativo Eureka Server. Por exemplo, você pode definir o nome de usuário e a senha em seu application.properties arquivo (ou aplicativo.yml se preferir o formato YAML):

```propriedades spring.security.user.name=admin spring.security.user.password=segredo ``` Você também pode criar uma classe de configuração que estende WebSecurityConfigurerAdapter e substitui o configurar método para permitir que os clientes Eureka ignorem a autenticação. Aqui está um exemplo de tal classe:

```java import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer; import org.springframework.context.annotation.Configuration; import org.springframework.core.Ordered; importar org.springframework.core.annotation.Order; importar org.springframework.security.config.annotation.web.builders.HttpSecurity; importar org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; @Configuration @EnableEurekaServer @Order(Ordered.HIGHEST_PRECEDENCE) public class SecurityConfig extends WebSecurityConfigurerAdapter @Override protected void configure(HttpSecurity http) lança exceção http.csrf().disable() .authorizeRequests() .antMatchers("/eureka/").hasRole("ADMIN") .anyRequest().authentica ted() .and() .httpBasic(); ``` Você pode encontrar mais detalhes e exemplos sobre como habilitar segurança e autenticação para Eureka Server no .

Como lidar com falhas e fallbacks com o Eureka Server?

Para lidar com falhas e fallbacks com o Eureka Server, você pode usar Spring Cloud Netflix Hystrix, que é um disjuntor e mecanismo de fallback que fornece resiliência e tolerância a falhas para microsserviços. Para usar o Hystrix em seus aplicativos de microsserviço, você precisa adicionar a seguinte dependência ao seu pom.xml arquivo se você estiver usando Maven, ou para o seu build.gradle arquivo se você estiver usando o Gradle:

```xml

org.springframework.cloud

spring-cloud-starter-netflix-hystrix

2.2.9.LIBERAÇÃO

``` ```implementação gradle 'org.springframework.cloud:spring-cloud-starter-netflix-hystrix:2.2.9.RELEASE' ``` Você pode encontrar a versão mais recente da dependência no .

Depois de adicionar a dependência, você precisa habilitar o Hystrix em seu aplicativo de microsserviço adicionando o @EnableCircuitBreaker anotação acima da classe principal do seu aplicativo. Essa anotação informa ao Spring Boot que esse aplicativo pode usar o Hystrix para lidar com falhas e fallbacks.

```java import org.springframework.boot.SpringApplication; importar org.springframework.boot.autoconfigure.SpringBootApplication; importar org.springframework.cloud.netflix.eureka.EnableEurekaClient; importar org.springframework.cloud.netflix.hystrix.EnableCircuitBreaker; @SpringBootApplication @EnableEurekaClient @EnableCircuitBreaker public class MicroserviceApplication public static void main(String[] args) SpringApplication.run(MicroserviceApplication.class, args); ``` Para usar Hystrix em seu Feign Client, você precisa adicionar o cair pra trás atributo para o @FeignClient anotação e especifique uma classe que implemente a interface Feign Client e forneça métodos de fallback para cada endpoint. Aqui está um exemplo de uma classe de fallback para o hello-service Feign Client:

```java import org.springframework.stereotype.Component; @Component public class HelloServiceFallback implements HelloServiceClient @Override public String hello() return "O serviço Hello está indisponível"; ``` Para usar Hystrix em seu controlador REST, você precisa adicionar o @HystrixCommand para cada método que chama um Feign Client e especifique um método de fallback que retorne um valor padrão ou uma mensagem de erro. Aqui está um exemplo de um controlador REST que usa Hystrix:

```java import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand; importar org.springframework.web.bind.annotation.GetMapping; importar org.springframework.web.bind.annotation.RestController; @RestController public class HelloController private final HelloServiceClient helloServiceClient; public HelloController(HelloServiceClient helloServiceClient) this.helloServiceClient = helloServiceClient; @GetMapping("/consume") @HystrixCommand(fallbackMethod = "consumeFallback") public String consumir() return helloServiceClient.hello(); public String consumaFallback() return "Falha ao consumir o serviço hello"; ``` Você pode encontrar mais detalhes e exemplos sobre como usar o Hystrix com Eureka Server no .

Como dimensionar e agrupar o Eureka Server para alta disponibilidade?

Para dimensionar e agrupar o Eureka Server para alta disponibilidade, você pode executar várias instâncias do Eureka Server e configurá-las para se comunicarem entre si. Dessa forma, se uma instância ficar inativa, as outras instâncias ainda poderão atender às solicitações e manter as informações do registro. Para fazer isso, você precisa seguir estas etapas:

• Crie um arquivo de configuração para cada instância do Eureka Server e dê a eles nomes e portas diferentes. Por exemplo, você pode criar dois arquivos chamados application-peer1.properties e application-peer2.propertiese defina as seguintes propriedades:

```properties # application-peer1.properties server.port=8761 spring.application.name=eureka-server eureka.client.register-with-eureka=true eureka.client.fetch-registry=true eureka.client.service-url.defaultZone= eureka.instance.instance-id=$spring.application.name :$random.value # application-peer2.properties server.port=8762 spring.application.name=eureka-server eureka.client.register-with-eureka=true eureka.client.fetch-registry=true eureka.client.service-url.defaultZone= eureka.instance.instance-id=$spring.application .name:$random.value ``` As propriedades acima informam a cada instância do Eureka Server para se registrar e buscar na outra instância, criando um relacionamento ponto a ponto.

• Execute cada instância do Eureka Server com o arquivo de configuração correspondente. Por exemplo, você pode usar os seguintes comandos:

```bash java -jar eureka-server.jar --spring.profiles.active=peer1 java -jar eureka-server.jar --spring.profiles.active=peer2 ``` Você deve ver alguns logs indicando que cada instância do Eureka Server foi registrada e replicada da outra instância.

• Registre seus aplicativos de microsserviço com ambas as instâncias do Eureka Server adicionando ambas as URLs ao eureka.client.service-url.defaultZone propriedade em seu application.properties arquivo (ou aplicativo.yml se preferir o formato YAML). Por exemplo:

```propriedades eureka.client.service-url.defaultZone= ``` Dessa forma, seus aplicativos de microsserviço podem se registrar e consultar em ambas as instâncias do Eureka Server, garantindo alta disponibilidade.

Como personalizar e estender a funcionalidade do Eureka Server?

Para personalizar e estender a funcionalidade do Eureka Server, você pode usar algumas das seguintes opções:

• Você pode usar Eventos do Servidor Eureka, que são eventos acionados por várias ações no Eureka Server, como atualizações de registro, alterações de status e eventos de replicação. Você pode criar ouvintes para esses eventos e implementar lógica ou comportamento personalizado. Por exemplo, você pode criar um ouvinte que envia uma notificação por e-mail quando um serviço fica inativo. Você pode encontrar mais detalhes e exemplos sobre como usar o Eureka Server Events no .

• Você pode usar Filtros de Servidor Eureka, que são filtros que interceptam as requisições e respostas entre o Eureka Server e seus clientes. Você pode criar filtros personalizados para modificar ou aprimorar o processo de comunicação. Por exemplo, você pode criar um filtro que adiciona cabeçalhos de autenticação às solicitações ou respostas. Você pode encontrar mais detalhes e exemplos sobre como usar Eureka Server Filters no .

• Você pode usar Extensões de Servidor Eureka, que são extensões que fornecem recursos ou integrações adicionais para o Eureka Server. Você pode criar suas próprias extensões ou usar algumas das existentes, como .

Espero que você tenha gostado de ler este artigo e aprendido algo novo sobre o Spring Cloud Starter Eureka 0517a86e26