TOC

Une introduction au printemps Cloud Zookeeper

1. Introduction

Dans cet article, nous allons nous familiariser avec Zookeeper et son utilisation pour Service Discovery, qui est utilisé comme une connaissance centralisée des services dans le cloud.

Spring Cloud Zookeeper fournit une intégration Apache Zookeeper pour les applications Spring Boot via la configuration automatique et la liaison à l’environnement Spring.

2. Configuration du service découverte

Nous allons créer deux applications:

  • Une application qui fournira un service (appelé dans cet article le

  • Fournisseur de services ** _) _

  • Une application qui utilisera ce service (appelé le ** __Service

Consommateur__** )

Apache Zookeeper agira en tant que coordinateur dans notre configuration de découverte de service. Les instructions d’installation d’Apache Zookeeper sont disponibles à l’adresse link .

3. Enregistrement du fournisseur de services

Nous activerons l’enregistrement du service en ajoutant la dépendance spring-cloud-starter-zookeeper-discovery et en utilisant l’annotation @ EnableDiscoveryClient dans l’application principale.

Ci-dessous, nous allons montrer ce processus étape par étape pour le service qui renvoie le message «Hello World!» Dans une réponse aux demandes GET.

3.1. Dépendances Maven

Premièrement, ajoutons les https://search.maven.org/classic/ search%7Cga%7C1%7Cspring-cloud-stoud-zookeeper-discovery[spring-cloud-stouder-zookeeper-discovery[requises search.maven.org/classic/#search%7Cga%7C1%7Cg%3A%22org.springframework%22%20and%20a%3a%22spring-web%22[spring-web], https://search.maven . org/classic/ search% 7Cga% 7C1% 7Cg% 3A% 22org.springframework.cloud% 22% 20% 20and% 20a% 3A% 22seping-cloud-dependencies% 22[printemps-cloud-dependencies]et https://search.maven.org/classic/#search%7Cga%7C1%7Ca%3A%22spring-boot-starter%22%20AND%20g%3A%22org.springframework.boot%22&spring-boot-starter ]dépend de notre fichier pom.xml : 

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>1.5.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
        <version>4.3.7.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
        <version>1.0.3.RELEASE</version>
     </dependency>
</dependencies>
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Brixton.SR7</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

3.2. Annotations du fournisseur de services

Ensuite, nous annoterons notre classe principale avec @ EnableDiscoveryClient .

Ceci rendra l’application HelloWorld détectable: 

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

Et un contrôleur simple: 

@GetMapping ("/helloworld")
public String helloWorld () {
    retourne "Hello World!";
}

3.3. Configurations YAML

Créons maintenant un fichier YAML Application.yml qui sera utilisé pour configurer le niveau de journalisation de l’application et informer Zookeeper que l’application est activée pour la reconnaissance.

Le nom de l’application avec laquelle est enregistré Zookeeper est le plus important. Plus tard dans l’utilisateur du service, un client feign utilisera ce nom lors de la découverte du service: 

spring:
  application:
    name: HelloWorld
  cloud:
    zookeeper:
      discovery:
        enabled: true
logging:
  level:
    org.apache.zookeeper.ClientCnxn: WARN

L’application de démarrage de printemps recherche zookeeper sur le port par défaut 2181. Si zookeeper est situé ailleurs, la configuration doit être ajoutée: 

spring:
  cloud:
    zookeeper:
      connect-string: localhost:2181

4. Consommateur de service

Nous allons maintenant créer un consommateur de service REST et l’avoir enregistré avec spring Netflix Feign Client .

4.1. Dépendance Maven

Premièrement, ajoutons les https://search.maven.org/classic/ search%7Cga%7C1%7Cspring-cloud-stoud-zookeeper-discovery[spring-cloud-stouder-zookeeper-discovery[requises search.maven.org/classic/#search%7Cga%7C1%7Cg%3A%22org.springframework%22%20and%20a%3a%22spring-web%22[spring-web], https://search.maven . org/classic/ search% 7Cga% 7C1% 7Cg% 3A% 22org.springframework.cloud% 22% 20% 20AND% 20a% 3A% 22A dépendances de cloud% 22[printemps-cloud-dependencies], https://search.maven.org/classic/#search%7Cga%7C1%7Ca%3A%22spring-boot-starter-actuator%22%20and% 20%%%%%%%%%%%%CA%22Springframework.]et spring-cloud-starter-feign dépendances de notre fichier pom.xml : 

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
        <version>1.0.3.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
        <version>1.5.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-feign</artifactId>
        <version>1.2.5.RELEASE</version>
    </dependency>
</dependencies>
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Brixton.SR7</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

4.2. Annotations des consommateurs de services

Comme avec le fournisseur de services, nous annotons la classe principale avec @ EnableDiscoveryClient pour la rendre compatible avec la découverte: 

@SpringBootApplication
@EnableDiscoveryClient
public class GreetingApplication {

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

4.3. Discover Service avec Feign Client

Nous allons utiliser Spring Cloud Feign Integration, un projet de Netflix qui vous permet de définir un client REST déclaratif. Nous déclarons à quoi ressemble l’URL et feign s’occupe de la connexion au service REST.

Le Feign Client est importé via le https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22Asringframework.cloud%22%20a%20a%3A%22spring-cloud-starter- feign% 22[paquet-printemps-nuage-démarreur-feinte] . Nous annotons un @ Configuration avec @ EnableFeignClients pour l’utiliser dans l’application.

Enfin, nous annotons une interface avec @ FeignClient («nom de service») et la connectons automatiquement à notre application pour que nous puissions accéder à ce service par programme.

Dans l’annotation @ FeignClient (name = “HelloWorld”) , nous nous référons au nom service du producteur de service que nous avons créé précédemment. 

@Configuration
@EnableFeignClients
@EnableDiscoveryClient
public class HelloWorldClient {

    @Autowired
    private TheClient theClient;

    @FeignClient(name = "HelloWorld")
    interface TheClient {

        @RequestMapping(path = "/helloworld", method = RequestMethod.GET)
        @ResponseBody
    String helloWorld();
    }
    public String HelloWorld() {
        return theClient.HelloWorld();
    }
}

4.4. Classe de contrôleur

Voici la classe de contrôleur de service simple qui appellera la fonction de fournisseur de service sur notre classe de client feinte pour consommer le service (dont les détails sont résumés via la découverte de service) via l’objet injecté helloWorldClient et l’afficher en réponse: 

@RestController
public class GreetingController {

    @Autowired
    private HelloWorldClient helloWorldClient;

    @GetMapping("/get-greeting")
    public String greeting() {
        return helloWorldClient.helloWorld();
    }
}

4.5. Configurations YAML

Ensuite, nous créons un fichier YAML Application.yml très similaire à celui utilisé auparavant. Cela configure le niveau de journalisation de l’application: 

logging:
  level:
    org.apache.zookeeper.ClientCnxn: WARN

L’application recherche le Zookeeper sur le port par défaut 2181. Si Zookeeper est situé ailleurs, la configuration doit être ajoutée: 

spring:
  cloud:
    zookeeper:
      connect-string: localhost:2181

5. Test de la configuration

Le service HelloWorld REST s’enregistre auprès de Zookeeper lors du déploiement. Ensuite, le service Greeting faisant office de consommateur de service appelle le service HelloWorld à l’aide du client Feign.

Nous pouvons maintenant créer et exécuter ces deux services.

Enfin, nous allons pointer notre navigateur sur http://localhost : 8080/get-greeting[ http://localhost : 8083/get-greeting ], et il devrait afficher: 

Hello World!

6. Conclusion

Dans cet article, nous avons vu comment implémenter la découverte de service à l’aide de Spring Cloud Zookeeper et nous avons enregistré un service appelé HelloWorld dans le serveur Zookeeper, que le service Greeting doit utiliser pour découvrir et utiliser.

GitHub .

Related