Utilisation d’un démarreur Spring Cloud App

Utilisation d'un démarreur Spring Cloud App

1. introduction

Dans cet article, nous allons montrer comment utiliser les démarreurs Spring Cloud App - qui fournissent des applications bootstrap et prêtes à l'emploi - qui peuvent servir de point de départ pour le développement futur.

En bref, les applications Task App Starters sont dédiées à des cas d'utilisation tels que la migration de bases de données et les tests distribués, et Stream App Starters fournit des intégrations avec des systèmes externes.

Dans l'ensemble, il y a plus de 55 partants; consultez la documentation officiellehere ethere pour plus d'informations sur ces deux.

Ensuite, nous allons créer une petite application Twitter distribuée qui diffusera les publications Twitter dans un système de fichiers distribué Hadoop.

2. Obtenir la configuration

Nous utiliserons lesconsumer-key etaccess-token pour créer une application Twitter simple.

Ensuite, nous configurerons Hadoop afin que nous puissions conserver notre flux Twitter à des fins futures de Big Data.

Enfin, nous avons la possibilité d'utiliser les référentiels Spring GitHub fournis pour compiler et assembler les composants autonomes du modèle d'architecturesources -processors-sinks à l'aide de Maven ou combinersources,processors etsinks via leurs interfaces de liaison Spring Stream.

Nous allons examiner les deux façons de procéder.

Il convient de noter qu'autrefois, tous les démarreurs d'applications Stream étaient regroupés dans un seul grand dépôt àgithub.com/spring-cloud/spring-cloud-stream-app-starters. Chaque démarreur a été simplifié et isolé.

3. Identifiants Twitter

Commençons par configurer nos identifiants de développeur Twitter. Pour obtenir les informations d'identification de développeur Twitter, suivez les étapes pour configurer une application et créer un jeton d'accèsfrom the official Twitter developer documentation.

Plus précisément, nous aurons besoin de:

La clé du consommateur
Secret de la clé du consommateur
Clé d'accès secret
Jeton d'accès

Assurez-vous de garder cette fenêtre ouverte ou notez-les, car nous utiliserons celles ci-dessous!

4. Installer Hadoop

Ensuite, installons Hadoop! Nous pouvons soit suivrethe official documentation, soit simplement utiliser Docker:

$ sudo docker run -p 50070:50070 sequenceiq/hadoop-docker:2.4.1

5. Compiler nos démarreurs d'applications

Pour utiliser des composants entièrement indépendants et indépendants, nous pouvons télécharger et compiler les démarreurs d’application Spring Cloud Stream souhaités individuellement à partir de leurs référentiels GitHub.

5.1. Démarreur de l'application Twitter Spring Cloud Stream

Ajoutons le Twitter Spring Cloud Stream App Starter (org.springframework.cloud.stream.app.twitterstream.source) à notre projet:

git clone https://github.com/spring-cloud-stream-app-starters/twitter.git

Ensuite, nous lançons Maven:

./mvnw clean install -PgenerateApps

L’application de démarrage compilée qui en résulte sera disponible dans «/ target» de la racine du projet local.

Ensuite, nous pouvons exécuter ce fichier .jar compilé et transmettre les propriétés d’application pertinentes comme suit:

java -jar twitter_stream_source.jar --consumerKey= --consumerSecret= \
    --accessToken= --accessTokenSecret=

Nous pouvons également transmettre nos informations d'identification en utilisant les Springapplication.properties: familiers

twitter.credentials.access-token=...
twitter.credentials.access-token-secret=...
twitter.credentials.consumer-key=...
twitter.credentials.consumer-secret=...

5.2. Démarreur de l'application HDFS Spring Cloud Stream

Maintenant (avec Hadoop déjà configuré), ajoutons la dépendance HDFS Spring Cloud Stream App Starter (org.springframework.cloud.stream.app.hdfs.sink) à notre projet.

Tout d’abord, clonez le rapport correspondant:

git clone https://github.com/spring-cloud-stream-app-starters/hdfs.git

Ensuite, exécutez le travail Maven:

./mvnw clean install -PgenerateApps

L’application de démarrage compilée qui en résulte sera disponible dans «/ target» de la racine du projet local. Nous pouvons ensuite exécuter ce fichier .jar compilé et transmettre les propriétés d’application pertinentes:

java -jar hdfs-sink.jar --fsUri=hdfs://127.0.0.1:50010/

«hdfs://127.0.0.1:50010/» est la valeur par défaut pour Hadoop, mais votre port HDFS par défaut peut varier en fonction de la façon dont vous avez configuré votre instance.

Nous pouvons voir la liste des nœuds de données (et leurs ports actuels) à «http://0.0.0.0:50070» compte tenu de la configuration que nous avons passée précédemment.

Nous pouvons également transmettre nos informations d'identification en utilisant les Springapplication.properties familiers avant la compilation - nous n'avons donc pas à toujours les transmettre via CLI.

Configurons nosapplication.properties pour utiliser le port Hadoop par défaut:

hdfs.fs-uri=hdfs://127.0.0.1:50010/

6. Utilisation deAggregateApplicationBuilder

Alternativement, nous pouvons combiner nosSource etSink Spring Stream via lesorg.springframework.cloud.stream.aggregate.AggregateApplicationBuilder dans une simple application Spring Boot!

Tout d'abord, nous allons ajouter les deux démarreurs d'application Stream à nospom.xml:


    
        org.springframework.cloud.stream.app
        spring-cloud-starter-stream-source-twitterstream
        1.3.1.BUILD-SNAPSHOT
    
    
        org.springframework.cloud.stream.app
        spring-cloud-starter-stream-sink-hdfs
        1.3.1.BUILD-SNAPSHOT

Nous commencerons ensuite à combiner nos deux dépendances Stream App Starter en les encapsulant dans leurs sous-applications respectives.

6.1. Construire nos composants d'application

NotreSourceApp spécifie lesSource à transformer ou consommer:

@SpringBootApplication
@EnableBinding(Source.class)
@Import(TwitterstreamSourceConfiguration.class)
public class SourceApp {
    @InboundChannelAdapter(Source.OUTPUT)
    public String timerMessageSource() {
        return new SimpleDateFormat().format(new Date());
    }
}

Notez que nous lions nosSourceApp àorg.springframework.cloud.stream.messaging.Source et injectons la classe de configuration appropriée pour récupérer les paramètres nécessaires à partir de nos propriétés environnementales.

Ensuite, nous mettons en place une simple liaisonorg.springframework.cloud.stream.messaging.Processor:

@SpringBootApplication
@EnableBinding(Processor.class)
public class ProcessorApp {
    @Transformer(inputChannel = Processor.INPUT, outputChannel = Processor.OUTPUT)
    public String processMessage(String payload) {
        log.info("Payload received!");
        return payload;
    }
}

Ensuite, nous créons notre consommateur (Sink):

@SpringBootApplication
@EnableBinding(Sink.class)
@Import(HdfsSinkConfiguration.class)
public class SinkApp {
    @ServiceActivator(inputChannel= Sink.INPUT)
    public void loggerSink(Object payload) {
        log.info("Received: " + payload);
    }
}

Ici, nous lions nosSinkApp àorg.springframework.cloud.stream.messaging.Sink et injectons à nouveau la classe de configuration correcte pour utiliser nos paramètres Hadoop spécifiés.

Enfin, nous combinons nosSourceApp,ProcessorApp et nosSinkApp en utilisant lesAggregateApplicationBuilder dans notre méthode principaleAggregateApp:

@SpringBootApplication
public class AggregateApp {
    public static void main(String[] args) {
        new AggregateApplicationBuilder()
          .from(SourceApp.class).args("--fixedDelay=5000")
          .via(ProcessorApp.class)
          .to(SinkApp.class).args("--debug=true")
          .run(args);
    }
}

Comme pour toute application Spring Boot, nous pouvons injecter des paramètres spécifiés en tant que propriétés environnementales viaapplication.properties or par programme.

Puisque nous utilisons le framework Spring Stream, nous pouvons également passer nos arguments dans le constructeurAggregateApplicationBuilder.

6.2. Exécution de l'application terminée

Nous pouvons ensuite compiler et exécuter notre application en utilisant les instructions en ligne de commande suivantes:

    $ mvn install
    $ java -jar twitterhdfs.jar

N'oubliez pas de conserver chaque classe@SpringBootApplication dans un package séparé (sinon, plusieurs exceptions de liaison différentes seront levées)! Pour plus d'informations sur l'utilisation desAggregateApplicationBuilder, jetez un œil auxofficial docs.

Après avoir compilé et exécuté notre application, nous devrions voir quelque chose comme ce qui suit dans notre console (naturellement, le contenu varie en fonction du Tweet):

2018-01-15 04:38:32.255  INFO 28778 --- [itterSource-1-1]
c.b.twitterhdfs.processor.ProcessorApp   : Payload received!
2018-01-15 04:38:32.255  INFO 28778 --- [itterSource-1-1]
com.example.twitterhdfs.sink.SinkApp    : Received: {"created_at":
"Mon Jan 15 04:38:32 +0000 2018","id":952761898239385601,"id_str":
"952761898239385601","text":"RT @mighty_jimin: 180114 ...

Ceux-ci démontrent le fonctionnement correct de nosProcessor etSink lors de la réception de données desSource! Dans cet exemple, nous n'avons pas configuré notre récepteur HDFS pour faire grand-chose - il affichera simplement le message «Charge utile reçue!»

7. Conclusion

Dans ce didacticiel, nous avons appris à combiner deux superbes démarreurs d'application Spring Stream en un seul exemple de Spring Boot!

Voici quelques autres excellents articles officiels surSpring Boot Starters et comment créer uncustomized starter!

Comme toujours, le code utilisé dans l'article se trouveover on GitHub.

TOC

Utilisation d’un démarreur Spring Cloud App