JBoss Fuse - Guide rapide

Dans ce chapitre, nous commencerons par les éléments essentiels d'Enterprise Service Bus. Vous trouverez ci-dessous une explication détaillée sur ESB ainsi que ses avantages, ses inconvénients et quelques diagrammes pour une compréhension plus facile.

Qu'est-ce que l'ESB?

ESB signifie Enterprise Service Bus. ESB dans sa forme la plus simple est un middleware qui agit comme une autoroute de l'information aidant plusieurs applications à communiquer.

Dans le monde de l'entreprise, nous développons des solutions pour de nombreux domaines. Ces solutions peuvent utiliser différentes technologies et différents formats de données. Il devient fastidieux d'utiliser ces solutions ensemble en raison de la variance de compatibilité de la communication ou du format de données dans ces technologies. Nous avons donc besoin d'une technologie qui permettraloosely coupled integration entre ces différentes solutions.

ESB vise à simplifier ce problème d'intégration en devenant un «HUB» qui se trouve au milieu de toutes vos applications et facilite le routage des messages entre elles. ESB sert de médiateur, agissant comme autoroute de l'information, s'occupant du routage de la transformation des données, laissant le codeur ou le développeur se concentrer sur sa propre logique d'application.

Comprendre ESB devient très simple quand on comprend le problème pour lequel il a été spécialement conçu et que la solution devient facile. Il faut bien comprendre comment activer de nombreux systèmes disparates, écrits dans différentes langues et fonctionnant sur différentes machines utilisant différents formats de données pour partager des informations et former une plate-forme d'entreprise intégrée.

Le problème d'intégration

Dans la plate-forme d'entreprise, il est courant que plusieurs applications collaborent et fournissent des fonctionnalités métier dans leur ensemble, mais l'intégration de ces applications est le problème le plus récurrent. Cela devient encore plus difficile avec le temps à mesure que les applications se développent.

Chaque application peut entrer et sortir des données dans son propre format. Cette approche fonctionne bien si le nombre d'applications est inférieur, mais à mesure que le nombre d'applications augmente, les roues d'intégration doivent également être modifiées avec une meilleure approche. Par exemple, si une application particulière pour une entreprise doit être modifiée, son format de sortie ou de données d'entrée pour toutes les applications dépendant de cette application maître est affecté.

Une telle approche constitue le plus gros obstacle pour l'intégration qui attend une architecture étroitement couplée. C'est là qu'ESB entre en scène. Chaque application n'a pas besoin de communiquer directement avec une autre application; à la place, toutes les applications communiquent avec l'ESB et l'ESB gère le routage des informations et la conversion interne du format des données.

Pourquoi ESB?

Voici quelques points qui expliquent pourquoi Enterprise Service Bus est essentiel.

ESB vise à simplifier le problème de l'intégration avec des applications compatibles avec des variantes.
Il agit comme un middleware, qui sert de médiateur de toutes vos applications et facilite le routage des messages entre elles.
Au lieu que chaque application s'interface avec toutes les autres applications directement, chaque application n'a plus qu'une seule interface avec l'ESB.
L'ESB est responsable de la traduction des messages vers / depuis un format commun et de leur acheminement vers leurs destinations.
L'économie majeure de cette approche est une aubaine si vous devez remplacer l'une de vos applications existantes. Au lieu d'écrire tout un tas de nouvelles interfaces, vous n'avez plus à vous soucier que d'une seule interface (entre votre application et l'ESB).

SOA et ESB?

SOA et ESB sont couramment utilisés de manière interchangeable, mais ils sont complètement différents.

SOA est un modèle de conception qui permet à une application d'exposer ses fonctionnalités en tant que service sur le réseau via des protocoles de communication, tandis que ESB est un modèle qui facilite la communication entre des systèmes disparates, mais ESB peut être utilisé comme un backbone lors de la mise en œuvre de SOA.

JBoss Fuse est une solution ESB Open source de Redhat. Il s'agit d'une solution d'entreprise basée sur un projet communautaire, Apache Servicemix.

Intégration à Fuse

JBoss Fuse est une plate-forme d'intégration légère et flexible qui permet une intégration rapide des applications d'entreprise.

Fuse a été initialement développé par Progressive Software Inc. qui a été acquis par Redhat en 2012. JBoss Fuse 6.1.0.redhat-379 GA est une version stable de Fuse qui peut être téléchargée depuis leur site officiel.

Architecture

Fuse combine diverses technologies en un seul produit.

Composants

Apache CXF

Apache CXF est un cadre de développement de services Web open source qui prend également en charge le développement de services Web SOAP & Rest.

Chameau Apache

Apache Camel est un framework d'intégration basé sur EIP. Les modèles EIP ou d'intégration d'entreprise sont des solutions identifiées aux problèmes récurrents dans l'intégration d'entreprise. Une solution d'intégration complète peut être obtenue de manière fulgurante avec des combinaisons de ces modèles prédéfinis prêts à l'emploi.

Il permet d'écrire la logique de routage dans plusieurs langages spécifiques au domaine comme Java, Spring DSL et Scala, etc.

Apache AMQ

Apache AMQ est un JMS qui fournit un système de messagerie fiable selon les normes JMS. Il prend non seulement en charge la spécification JMS, mais fournit également des fonctionnalités intéressantes et utiles qui ne sont pas incluses dans les spécifications JMS.

Apache Karaf

Apache Karaf est un conteneur OSGi léger qui sert de moteur d'exécution pour les artefacts. Apache Karaf est de nature plus dynamique que JVM. Il permet d'installer ou de désinstaller des modules au moment de l'exécution. Tous les artefacts de Fuse sont déployés à Karaf.

en tissu

Fabric offre un moyen simple de gérer les déploiements d'artefacts dans un environnement étendu et distribué. Il fournit une gestion centralisée de toutes les instances de fusibles multiples.

Installation du fusible

L'installation de Fuse est assez simple. Comme les autres produits JBoss, Fuse se présente sous la forme d'un fichier zip qui peut être extrait et après quelques modifications de configuration mineures, il peut être démarré directement.

L'installation de Fuse est un processus en quatre étapes -

Télécharger

Téléchargez Fuse 6.1.0 GA à partir du lien suivant. http://www.jboss.org/

Décompressez

Comme tous les autres produits JBoss, Fuse est également un zip indépendant de la plateforme.

Décompressez le fichier téléchargé dans le répertoire de destination que vous souhaitez utiliser comme répertoire d'installation de Fuse. Choisissez ce répertoire judicieusement car il doit rester le même pendant toute la durée de vie de l'instance Fuse.

Note - Même si Fuse se décompresse et démarre comme les autres produits JBoss, il n'est pas recommandé de déplacer l'installation de Fuse d'un emplacement à un autre une fois l'installation terminée.

Configurer

Après avoir décompressé Fuse, vous trouverez les répertoires suivants dans le répertoire extrait -

bin
etc
deploy
lib
licenses
extras
quickstarts

Sur lequel nous n'utiliserons que deux répertoires bin & etc.

Pratiquement après l'extraction de Fuse, nous devrions être en mesure de démarrer Fuse directement, mais cela lancera Fuse avec toutes les configurations par défaut, ce qui n'est pas conseillé pour l'environnement de production. Il est fortement recommandé d'effectuer les modifications suivantes avant de démarrer Fuse.

Définir les variables d'environnement

Définissez les variables d'environnement suivantes - JAVA_HOME
La variable doit pointer vers le répertoire d'installation java - M2_HOME
La variable doit pointer vers le répertoire d'installation de Maven - PATH
Définissez la variable de chemin pour inclure les exécutables Java et Maven.

les fenêtres

Sous Windows, les réglages peuvent être effectués en suivant les instructions ci-dessous -

Démarrer → Poste de travail → Clic droit → Propriétés → Paramètres système avancés → Variables d'environnement.

UNIX et clones

Pour chaque utilisateur, il existe un profil bash dans le *nixsystèmes d'exploitation. Nous pouvons ajouter ou modifier la variable système existante en modifiant ce fichier.

$ vi ~/.bash_proflle

Note- Toutes les modifications apportées à ce fichier sont permanentes. Il est fortement recommandé de faire une sauvegarde du fichier existant avant de changer l'original.

Configuration de base

Nous discuterons de la configuration de base de JBoss Fuse et pour cela nous devons commencer par la commande suivante Edit $FUSE_INSTALLATION_DIR/etc/

Dans user.properties

#admin=admin,admin
Cela doit être changé selon le premier administrateur avec le nom d'utilisateur que nous voulons, le deuxième administrateur avec le mot de passe, le troisième peut être conservé tel quel car il indique un rôle et n'oubliez pas de supprimer #
Par exemple - FuseAdmin = FusePAss, admin

Dans System.properties
- karafName = racine
  - Cela indique le nom que vous souhaitez donner à l'instance Karaf.
  - Nous pouvons l'appeler tout ce que nous voulons, comme Cont1.
  - Assurez-vous que ce nom que vous donnez est un nom unique et n'est pas déjà utilisé par une autre instance de Fuse.
Dans org.ops4j.pax.web.cfg
- Org.osgi.service.http.port = 8181
- Cette propriété indique le port à utiliser pour accéder à l'interface basée sur le navigateur HAWTIO fournie par Fuse
- HAWTIO est une interface de navigateur intégrée à Fuse qui est disponible à partir de la version 6.0
Dans org.ops4j.pax.url.mvn.cfg
- org.ops4j.pax.url.mvn.localRepository = D: / référentiel
- Cette propriété indique le chemin vers localRepository de notre Maven à partir duquel Fuse installera ses artefacts.
- org.ops4j.pax.url.mvn.settings = D: /Maven/conf/settings.xml
- Cette propriété indique settings.xml que Fuse doit utiliser pour obtenir des artefacts de Maven.

Configurer Maven

Maven est une condition préalable à l'installation de Fuse. Si vous ne savez pas ce qu'est maven, veuillez vous référer à

Maven est un outil intégré utilisé pour créer des artefacts Fuse. Fuse recherche d'abord dans le référentiel local Maven les artefacts lorsque nous émettons une commande pour installer l'artefact. Nous devons donc indiquer à Fuse où Maven est installé et le chemin du référentiel local de Maven.

Modifiez $ FUSE_INSTALLATION_DIR / etc /org.ops4j.paxurl.mvn.cfg

Mettez à jour les deux propriétés suivantes -

org.ops4j.pax.url.mvn.settings = $ M2_HOME / conf /settings.xml
org.ops4j.pax.url.mvn.localRepository = $ local_repo

Note - Veuillez changer $local_repo avec le chemin réel de votre référentiel local mentionné dans Mavens settings.xml.

Courir

Après avoir effectué les modifications de configuration de base, nous pouvons maintenant démarrer Fuse. Tous les fichiers binaires pour travailler avec Fuse se trouvent dans$FUSE_INSTALLATION_DIR.

Il existe deux façons de démarrer Fuse -

En utilisant ./fuse
- Cela vous permettra de voir toute la progression et les journaux sur la même fenêtre dans laquelle vous avez démarré Fuse.
- Il vous donnera la console Karaf dans le même terminal que celui indiqué ci-dessous.

Note- Cela démarrera le fusible en mode console, ce qui signifie que le processus de fusion sera également arrêté lorsque l'utilisateur se déconnecte de la session ou ferme le terminal, ce qui n'est pas souhaitable dans un scénario de production ou de développement. Ce script ne doit être utilisé que pour le débogage de Fuse.

En utilisant ./start
- Cela n'affichera aucun journal à l'écran, pas même la progression, mais cela démarrera Fuse en arrière-plan et le service Fuse ne sera pas arrêté lorsque l'utilisateur quitte la session ou ferme le terminal.
- Dans l'application du monde réel, ce type de comportement est souhaité. Le fusible doit fonctionner en arrière-plan même si nous fermons le terminal.
- Si vous souhaitez vous connecter à Fuse fonctionnant en arrière-plan, vous pouvez utiliser client script qui se trouve dans le même dossier.
- Vous devriez obtenir l'affichage comme indiqué dans la capture d'écran suivante.
- La sortie du script client n'arrêtera pas le service Fuse. Cela fermera simplement la console Fuse.

HAWTIO

Fuse fournit également un accès GUI complet à celui-ci à l'aide de FMC (Fuse Management Console). Vous pouvez trouver l'interface graphique sur l'URL ci-dessoushttp://localhost:8181.

Tout ce que nous avons fait en exécutant des commandes peut également être fait en accédant à cette interface graphique basée sur un navigateur. Cela devient extrêmement utile lorsque nous avons plusieurs conteneurs et que nous fonctionnons dans un environnement Fabric.

Dans ce chapitre, nous discuterons d'Apache Karaf et de la raison pour laquelle il est appelé comme un conteneur OSGi léger, ainsi que de ses avantages et d'autres fonctionnalités importantes.

Le problème JVM

La machine virtuelle JVM ou Java n'agit pas comme une machine virtuelle réelle. Une machine qui vous permettra d'arrêter, de démarrer ou de redémarrer les composants qui tournent à l'intérieur à la volée. Il peut parfois autoriser des déploiements à chaud au niveau de la classe, mais il est impossible de déployer ou d'annuler le déploiement d'un composant de votre application dans votre machine virtuelle sans la redémarrer.

Pour résoudre ce problème et permettre la modularité de l'application Java, Fuse utilise un environnement d'exécution basé sur OSGi appelé Apache Karaf.

OSGi

La technologie OSGi est un ensemble de spécifications qui définissent un système de composants dynamiques pour java. Ces spécifications permettent un modèle de développement dans lequel les applications sont (dynamiquement) composées de nombreux composants différents (réutilisables).

Avantages d'OSGi

Reduced Complexity - L'application est construite en tant que composants collaboratifs qui cachent leurs détails d'implémentation les uns des autres, ce qui réduit la complexité.
Reusability - De nombreux composants peuvent exploiter le même composant déployé dans un conteneur.
Deployment - OSGi prend en charge le démarrage, l'arrêt et la mise à jour des composants à la volée avec ses API de gestion du cycle de vie sans redémarrage du conteneur.

Fonctionnalités Bundles Vs

Voici la comparaison entre les offres groupées et les fonctionnalités.

Liasses

Les bundles sont équivalents à OSGi ce que les jars sont à JVM. Les bundles sont des artefacts qui peuvent être déployés dans un conteneur OSGi. Les bundles sont des composants qui fonctionnent ensemble ou indépendamment pour former une application.

Ces bundles peuvent être installés, désinstallés, mis à jour, démarrés ou arrêtés au moment de l'exécution sans redémarrer le conteneur.

traits

Les fonctionnalités sont un moyen de déployer plusieurs bundles ensemble. Parfois, il est plus judicieux de déployer des bundles en groupe. Les fonctionnalités nous permettent de déployer un groupe de bundles avec une seule commande.

Pourquoi un autre conteneur?

Apache Karaf est un runtime basé sur OSGi, c'est là que nos bundles d'applications s'exécutent. Fuse utilise Apache Karaf comme environnement d'exécution dans lequel les bundles s'exécutent et collaborent pour fournir des fonctionnalités métier.

Karaf est construit sur Felix et Equinox qui sont des Frameworks OSGi.

Architecture de Karaf

Apache Karaf ajoute les fonctionnalités supplémentaires suivantes au runtime OSGi de base.

Déploiement à chaud

Karaf prend en charge le déploiement à chaud. Il contient un répertoire de déploiement à chaud. Tout ce qui est placé dans ce répertoire est automatiquement déployé et installé dans Karaf sous forme de bundle.

Enregistrement

Karaf fournit une journalisation centralisée en générant des journaux pour tous les bundles dans $Fuse_home/data/log. Nous pouvons modifier la configuration de l'enregistreur dansorg.ops4j.pax.logging.cfg dans $Fuse_home/etc directory.

Console d'administration

Karaf fournit une console d'administration sophistiquée et lucide pour interagir avec l'instance en cours d'exécution de fuse. Il fournit également un ensemble de commandes préinstallées qui peuvent être utilisées pour gérer et surveiller les composants (Bundle) lors de l'exécution. Cette console est extensible, elle nous permet donc d'ajouter de nouvelles commandes à la console en ajoutant de nouveaux bundles à la console.

Accès SSH

Karaf autorise l'accès à distance à cette console d'administration avec SSH. Toute personne disposant d'informations d'identification valides peut se connecter à la console d'administration karaf via le terminal SSH.

Dans ce chapitre, nous aborderons ce qu'est Apache Camel et comment il achemine efficacement les données entre les points de terminaison, avec quelques exemples.

Qu'est-ce qu'Apache Camel?

Apache Camel est un framework d'intégration open source qui a été lancé début 2007.

Il s'agit d'une approche basée sur EIP (Enterprise Integration Pattern) qui fournit plusieurs implémentations de modèles prêts à l'emploi qui peuvent être utilisées pour résoudre les problèmes d'intégration d'entreprise. Les EIP ne sont rien d'autre que des solutions éprouvées aux problèmes bien documentés et récurrents de l'intégration d'entreprise.

Camel est également connu sous le nom de moteur de routage et de médiation car il achemine efficacement les données entre les points de terminaison, tout en prenant une charge lourde comme la transformation des formats de données, la connectivité des points de terminaison et bien d'autres.

Exemple de base

Les prérequis pour utiliser Apache Camel sont:

Java
Maven
Redhat JBoss Fuse 6.1-GA-379

Créer le squelette de base de l'application

mvn:archetype generate 
–DgroupId = com.tutorialpoint.app 
–DartifactId = camel-first-app 
–DarchetypeGroupId = org.apache.camel.archetypes
–DarchetypeArtifactId = camel-archetype-spring 
–DinteractiveMode = false -X

Cela devrait générer la structure de répertoires suivante.

Ceci est un squelette de base de notre application Camel en cours de génération.

Modifier camel-context.xml

Éditer camel-first-app → src → main → resources → META-INF\spring\camel-context.xml pour correspondre comme ci-dessous

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring
   http://camel.apache.org/schema/spring/camel-spring.xsd">

   <camelContext xmlns = "http://camel.apache.org/schema/spring">
      <!-- here is a sample which processes the input file
         (leaving them in place - see the 'noop' flag) 
         then performs content based routing on the message using XPath -->
			
      <route>
         <from uri = "file:///d:/src/data?noop=false"/>
         <choice>
            <when>
               <xpath>/person/city = 'London'</xpath>
               <log message = "UK message"/>
               <to uri = "file:///d:/target/messages/uk"/>
            </when>
				
            <otherwise>
               <log message = "Other message"/>
               <to uri = "file:///d:/target/messages/others"/>
            </otherwise>
				
         </choice>
			
      </route>
   </camelContext>
</beans>

Modifier pom.xml

Ajoutez le code suivant dans <plugins> </plugins>

<plugin>
   <groupId>org.apache.felix</groupId>
   <artifactId>maven-bundle-plugin</artifactId>
   <version>2.3.4</version>
   <extensions>true</extensions>
	
   <configuration>
      <instructions>
         <Bundle-SymbolicName>
            ${project.artifactId}
         </Bundle-SymbolicName>
         <Import-Package>*</Import-Package>
      </instructions>
   </configuration>
	
</plugin>

Changer le type d'emballage de jar → bundle.

<packaging>bundle</packaging>

Générez le projet à l'aide de la commande suivante -

mvn clean install

Installer le projet dans Fuse

Démarrer Fuse en utilisant Fuse.bat/start.bat. Si vous démarrez Fuse en utilisantstart.bat, utilisation client.batpour se connecter à Fuse. Vous devriez obtenir l'interface utilisateur comme indiqué dans la capture d'écran suivante.

Il s'agit de la CLI pour accéder aux commandes Karaf et Fuse.

install –s mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

Testez si votre projet est en cours d'exécution

Maintenant, votre application doit être installée dans Fuse. Copier le répertoire de données à l'intérieurcamel-first-app et placez-le dans D:/src/ et il devrait copier le message ayant city = London dans D:/target/merssages/uk.

Placez le fichier d'entrée dans D:/src/data

Input

Message1.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "james">
   <firstName>James</firstName>
   <lastName>Strachan</lastName>
   <city>London</city>
</person>

Message2.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "hiram">
   <firstName>Hiram</firstName>
   <lastName>Chirino</lastName>
   <city>Tampa</city>
</person>

Output

En D: / target / messages / uk

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "james">
   <firstName>James</firstName>
   <lastName>Strachan</lastName>
   <city>London</city>
</person>

En D: / cible / messages / autres

<?xml version = "1.0" encoding = "UTF-8"?>
<person user = "hiram">
   <firstName>Hiram</firstName>
   <lastName>Chirino</lastName>
   <city>Tampa</city>
</person>

Dans ce chapitre, nous allons comprendre les différents concepts de Camel. Commençons par prendre un exemple de base pour comprendre les concepts de base pour commencer.

ChameauContexte

Chaque application chameau aura au moins un CamelContext. C'est ici que nous ajoutons des itinéraires de chameaux. C'est similaire àApplicationContext du printemps.

Le contexte de chameau peut être pensé comme un conteneur qui maintient toutes choses ensemble. Un contexte de chameau peut avoir plusieurs itinéraires à l'intérieur.

Itinéraires

CamelContext peut contenir une ou plusieurs routes. Les routes sont la logique d'intégration qui définit la manière dont les données circuleront dans un contexte de chameau d'un point de terminaison à un autre.

Point final

Le point final est la fin du canal par lequel le système peut envoyer ou recevoir des messages. C'est ce que nous appelons la destination ou la source en langage de communication.

Composants

Les composants sont des points d'extension dans Camel. Les composants peuvent être une interface avec la technologie, le format de données, les transformateurs, etc. Ils peuvent également agir comme une usine pour les terminaux.

EIP

EIP signifie Enterprise Integration Pattern. Ce sont des solutions identifiées et bien connues à un problème récurrent. Camel prend en charge la plupart des modèles d'intégration d'entreprise.

Routeur basé sur le contenu

Les modèles CBR nous permettent d'acheminer les données selon le contenu du fichier d'entrée.

Ce modèle est utilisé lorsque nous devons acheminer des valeurs en fonction du contenu du corps de l'entrée.

L'exemple suivant lira les données de D:/data/inputannuaire. Après lecture, il vérifiera la balise de valeur à l'intérieur de la balise de données. Si la balise value contientvalue1, il sera envoyé à D:/value1, S'il contient value2, il sera envoyé à D:/value2 et si aucun de ces deux, alors il sera envoyé à d'autres.

<CamelContext xmlns = "http://camel.apache.org/schema/spring">
   <route>
      <from uri = "file:///D:/data/input"/>
      <choice>
         <when>
            <xpath>/data/value = 'value1'</xpath>
            <to uri = "file:///D:/value1"/>
         </when> 
         <when>
            <xpath>/data/value = 'value2'</xpath>
            <to uri = "file:///D:/value2"/>
         </when>  
			
         <otherwise>
            <to uri = "file:///D:/others "/>
         </otherwise>
			
      </choice>
   </route>
</camelContext>

Input

D: /data/input/message1.xml

<data>
   <value>value1</value>
</data>

D: /data/input/message2.xml

<data>
   <value>value2</value>
</data>

Output

D: / valeur1 /

<data>
   <value>value1</value>
</data>

D: / valeur2 /

<data>
   <value>value2</value>
</data>

Splitter

Un modèle de fractionnement est utilisé pour diviser les données d'entrée en plus petits morceaux.

Ce modèle est utilisé la plupart du temps avec d'énormes entrées de données qui doivent être divisées en morceaux, de sorte qu'il devient transformable. Il décompose l'entrée en fragments plus petits en fonction de la chaîne de jeton d'entrée.

<CamelContext xmlns = "http://camel.apache.org/schema/spring">
   <route>
      <from uri = "file:///D:/inbox"/>
      <split streaming = "true">
         <tokenize token = "order" xml = "true"/>
         <to uri = "activemq:queue:order"/>
      </split>
   </route>
</CamelContext>

Input

D: /inbox/message.xml

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

Output

Si vous cochez AMQ, vous trouverez 3 messages postés.

<order>
   <data>
      <value>value4</value>
   </data>
</order>

Liste des destinataires

Un modèle de liste de destinataires est utilisé lorsqu'une liste de destinataires doit être extraite du corps du message lui-même.

Dans l'exemple suivant, un message sera envoyé à tous les destinataires répertoriés dans la balise client sous forme de liste de chaînes séparées par des virgules.

<CamelContext xmlns = "http://camel.apache.org/schema/spring">
   <route>
      <from uri = "jms:xmlOrders" />
      <recipientList>
         <xpath>/order/customer</xpath>
      </recipientList>
   </route>
</camelContext>

Autres EIP

Camel prend en charge presque tous les EIP identifiés. Certains des EIP couramment utilisés sont mentionnés ci-dessous.

Log - Pour enregistrer un message complet ou une partie de celui-ci
Message Filter - Filtrage du contenu des messages
Re-Sequencer - Pour obtenir tous les jetons en séquence
Wiretap - Pour inspecter les messages itinérants

La liste complète des EIP et de leur utilisation se trouve dans la documentation officielle de Camel http://camel.apache.org/eip.html

Manipulation d'exception en chameau

Using Error Handler - C'est le moyen le plus simple de gérer les exceptions chez le chameau.

Pour l'utiliser, nous devons configurer le bean de classe du gestionnaire d'erreur et le fournir comme référence à CamelContext errorHandlerRef attribut.

<bean id = "loggingErrorHandler" class = "org.apache.camel.builder.LoggingErrorHandler">
   <property name = "logName" value = "mylogger.name"/>
   <property name = "level" value = "DEBUG"/>
</bean>

<camelContext errorHandlerRef = ” loggingErrorHandler” >
   …
</camelContext>

Utiliser Try Catch enfin

Camel prend également en charge le style Java Try Catch Finally block pour la gestion des erreurs.

Tout comme Java, il comporte les trois blocs suivants -

doTry block contient du code qui peut générer une exception.
doCatch block contient du code qui doit être exécuté en cas d'exception.
doFinallyblock a un code qui doit être exécuté indépendamment de l'exception. Il sera toujours exécuté, peu importe si une exception a été déclenchée ou non.

Note- Mock est un composant de test et n'est pas recommandé à d'autres fins. C'est le composant de camel utilisé pour les tests, tout comme le composant jMOck dans le développement piloté par les tests.

<route>
   <from uri = "direct:start"/>
   <doTry>
      <process ref = "someProcesorThatmayFail"/>
      <to uri = "mock:result"/>
		
      <doCatch>
         <exception>java.io.IOException</exception>
         <exception>java.lang.IllegalStateException</exception>
         <to uri = "mock:catch"/>
      </doCatch>
		
      <doFinally>
         <to uri = "mock:finally"/>
      </doFinally>
		
   </doTry>
</route>

Dans l'exemple ci-dessus, nous pouvons donner une liste d'exceptions qui doivent être gérées par le bloc catch.

Déploiement du bundle dans Fuse

Démarrer Fuse en utilisant Fuse.bat/start.bat.

Si vous démarrez Fuse à l'aide de start.bat, utilisez client.bat pour vous connecter à Fuse. Vous devriez obtenir l'interface utilisateur comme indiqué dans la capture d'écran suivante.

Il s'agit de la CLI pour accéder aux commandes Karaf et Fuse.

install –s mvn:group.id /artifact.id/version 
e.g. install –s mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

Dans ce chapitre, parlons de ce qu'est Apache CXF et de la manière dont il peut être utile pour développer SOAP et Rest Web Services.

Qu'est-ce qu'Apache CXF?

Apache CXF est un cadre de développement de services Web qui peut être utilisé pour développer des services Web SOAP et Rest. CXF est entièrement conforme àJAX-RS and JAX-Ws la norme.

Il s'agit actuellement du cadre de développement de services Web le plus largement utilisé. CXF a appris et amélioré par rapport à Axis2 qui est maintenant progressivement remplacé par CXF.

CXF contre Axis2

	CXF	Axe2
Améliorations	CXF est le framework le plus utilisé à ce jour. Il a beaucoup d' améliorations par rapport à Axis2	Axis2 est progressivement remplacé par CXf. Il nécessite plus de code par rapport à CXF
Code requis	CXF nécessite moins de code par rapport à Axis2	Axis2 nécessite plus de code comparativement
Conformité standard	CSF est entièrement compatible avec JAX-RS et JAX-WS	Axis2 n'est pas entièrement compatible avec JAX-RS et JAX-WS
Compatible avec Spring	Oui	Non
Séparation des frontaux	Séparation nette du front-end du code JAX-WS	Aucune séparation propre n'est fournie

SAVON

SOAP signifie Simple Object Access Protocol. Il s'agit d'un protocole d'échange d'informations structurées via des services Web entre deux systèmes. Il repose principalement sur XML pour structurer les données et utilise HTTP ou SMTP pour la négociation et la transmission des messages.

Il existe deux approches pour développer des services Web SOAP:

Code first - Dans cette approche, WSDL est généré à partir du code.
Contract first - Dans le contrat d'abord, le code est généré à partir de WSDL.

Développement SOAP à l'aide de CXF

Configurer Maven

Ajoutez le profil suivant à votre settings.xml de Maven.

<profiles>
   <profile>
      <id>Jboss-Fuse</id>
		
      <activation>
         <activeByDefault>true</activeByDefault>
      </activation>
		
      <repositories>
         <repository>
            <id>fusesource</id>
            <url>http://repo.fusesource.com/nexus/content/groups/public/</url>
            <snapshots>
               <enabled>false</enabled>
            </snapshots>
            <releases>
               <enabled>true</enabled>
            </releases>
         </repository>
      </repositories>
		
   </profile>
</profiles>

Créer un squelette

mvn archetype:generate
-DarchetypeGroupId = org.apache.servicemix.tooling 
-DarchetypeArtifactId = servicemix-cxf-code-first-osgi-bundle 
-DarchetypeVersion=2012.01.0.redhat-60024 
-DgroupId = org.fusesource.example 
-DartifactId = cxf-basic 
-Dversion = 1.0-SNAPSHOT

Build Web Service Project.

mvn clean install

Install web-service into Fuse using the following command.

JBossFuse:[email protected]>install -s mvn:org.fusesource.example/cxf-basic/1.0-SNAPSH

Check if bundle has registered SOQP web-service

Ouvrir le lien http://localhost:8181/cxf

Le service Web doit être répertorié comme suit.

Testing Web-Service

mvn -Pclient

INFO - Création du service {http://ws.totorials.com/} PersonService de la classe com.to

torials.ws.Person
Invoking getPerson...
getPerson._getPerson_personId = Guillaume
getPerson._getPerson_ssn = 000-000-0000
getPerson._getPerson_name = Guillaume
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 30.668 s
[INFO] Finished at: 2016-02-15T21:01:20+05:30
[INFO] Final Memory: 10M/37M
[INFO] ------------------------------------------------------------------------

Pour commencer, REST signifie Representational State Transfer. C'est un moyen de développer des services Web basés sur un protocole client-serveur sans état, pouvant être mis en cache, qui est HTTP dans la plupart des cas.

Les services Web REST utilisent des requêtes HTTP pour publier, obtenir et supprimer des données du réseau.

Développement REST à l'aide de CXF

Créer un projet de démarrage rapide Maven simple

mvn archetype:generate 
-DgroupId = com.tuts.abhinav 
-DartifactId = rest-service
-DarchetypeArtifactId = maven-archetype-quickstart 
-DinteractiveMode = false

Ajouter des dépendances

<dependency>
   <groupId>org.apache.servicemix.specs</groupId>
   <artifactId>org.apache.servicemix.specs.jsr311-api-1.1.1</artifactId>
   <version>1.9.0</version>
   <scope>provided</scope>
</dependency>

<dependency>
   <groupId>org.apache.servicemix</groupId>
   <artifactId>servicemix-http</artifactId>
   <version>2013.01</version>
</dependency>

<dependency>
   <groupId>log4j</groupId>
   <artifactId>log4j</artifactId>
   <version>1.2.16</version>
</dependency>

Ajouter une instruction de construction

<build>
   <defaultGoal>install</defaultGoal>
   <plugins>
      <plugin>
         <groupId>org.apache.felix</groupId>
         <artifalctId>maven-bundle-plugin</artifactId>
         <version>2.3.4</version>
         <extensions>true</extensions>
			
         <configuration>
            <instructions>
               <Bundle-SymbolicName>rest-example-database-post-method
                  </Bundle-SymbolicName>
               <Import-Package>* </Import-Package>
            </instructions>
         </configuration>
			
      </plugin>
   </plugins>
</build>

Ajouter des référentiels de plugins Fuse

<pluginRepositories>
   <pluginRepository>
      <id>fusesource.m2</id>
      <name>FuseSource Community Release Repository</name>
      <url>http://repo.fusesource.com/nexus/content/repositories/releases</url>
      <snapshots>
         <enabled>false</enabled>
      </snapshots>
		
      <releases>
         <enabled>true</enabled>
      </releases>
   </pluginRepository>
<pluginRepositories>

Ajouter des référentiels

<repositories>
   <repository>
      <id>fusesource.m2</id>
      <name>FuseSource Community Release Repository</name>
      <url>http://repo.fusesource.com/nexus/content/repositories/releases</url>
      <snapshots>
         <enabled>false</enabled>
      </snapshots>
		
      <releases>
         <enabled>true</enabled>
      </releases>
		
   </repository>
	
   <repository>
      <id>fusesource.ea</id>
      <name>FuseSource Community Early Access Release Repository</name>
      <url>http://repo.fusesource.com/nexus/content/groups/ea</url>
      <snapshots>
         <enabled>false</enabled>
      </snapshots>
      <releases>
         <enabled>true</enabled>
      </releases>
   </repository>
	
</repositories>

Créer une classe de service

Créez la classe UserService.java sous com / tuts /

package com.tuts;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/UserService_1")
public class UserService {
   @GET
   @Path("/get_data")
   @Produces(MediaType.APPLICATION_JSON)
	
   public String getUser() {
      String reponse = "This is standard response from REST";
      return reponse;
   }
}

Créer Blueprint.xml

Créez blueprint.xml sous / src / main / resources / OSGI-INF / blueprint blueprint.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<blueprint xmlns = "http://www.osgi.org/xmlns/blueprint/v1.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:jaxrs = "http://cxf.apache.org/blueprint/jaxrs"
   xsi:schemaLocation = "http://www.osgi.org/xmlns/blueprint/v1.0.0 
   http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd
   http://cxf.apache.org/blueprint/jaxrs 
   http://cxf.apache.org/schemas/blueprint/jaxrs.xsd">
	
   <jaxrs:server id = "service" address = "/users">
      <jaxrs:serviceBeans>
         <ref component-id = "userService" />
      </jaxrs:serviceBeans>
   </jaxrs:server>
	
   <bean id = "userService" class = "com.tuts.UserService" />
</blueprint>

Installer le service Rest dans Fuse

install -s mvn:com.tuts.abhinav/rest-service/1.0-SNAPSHOT

Vérifiez si Bundle a un service Web enregistré

Ouvrir le lien http://localhost:8181/cxf

Tester le service Web

Ouvrir le lien http://localhost:8181/cxf/users12/UserService_1/get_data

Dans ce chapitre, nous découvrirons ActiveMQ et comment il agit en tant que courtier de messages pour permettre aux applications de communiquer entre elles.

Qu'est-ce que l'AMQ?

ActiveMQ est un courtier de messages open source écrit en Java. Il est entièrement conforme aux normes JMS 1.1.

JMS est une spécification qui permet le développement d'un système basé sur les messages. ActiveMQ agit comme un courtier de messages qui se situe entre les applications et leur permet de communiquer de manière asynchrone et fiable.

Types de messagerie

Il existe deux types d'options de messagerie expliquées ci-dessous pour une meilleure compréhension.

Point à point

Dans ce type de communication, le courtier n'envoie des messages qu'à un seul consommateur, tandis que les autres consommateurs attendront de recevoir les messages du courtier. Aucun consommateur ne recevra le même message.

S'il n'y a pas de consommateurs, le courtier conservera les messages jusqu'à ce qu'il obtienne un consommateur. Ce type de communication est également appeléQueue based communicationoù le producteur envoie des messages à une file d'attente et un seul consommateur reçoit un message de la file d'attente. S'il y a plus d'un consommateur, ils peuvent recevoir le message suivant mais ils ne recevront pas le même message que l'autre consommateur.

Publier / S'abonner

Dans ce type de communication, le Broker envoie la même copie des messages à tous les consommateurs actifs. Ce type de communication est également appeléTopic based communicationoù le courtier envoie le même message à tous les consommateurs actifs qui se sont abonnés à un sujet particulier. Ce modèle prend en charge la communication unidirectionnelle où aucune vérification des messages transmis n'est attendue.

Création d'une file d'attente et de sujets

Fuse est livré avec ActiveMQ. Nous pouvons accéder à ActiveMQ à l'aide de la console FMC (l'interface basée sur le navigateur pour travailler avec AMQ).

Connectez-vous à FMC en utilisant localhost:8181 et sélectionnez ActiveMQ languette.

Cliquez sur + Créer
Entrez le nom de la file d'attente / du sujet
Sélectionnez File d'attente / Sujet dans le bouton radio
Cliquez sur Créer une file d'attente / Créer un sujet

Vous devriez maintenant pouvoir voir le TestQ créé sous root → File d'attente →

Pour vérifier le sujet créé, suivez root → Sujet.

Parcourir / supprimer le contenu de la file d'attente

Connectez-vous à FMC en utilisant localhost:8181
Sélectionnez l'onglet ActiveMQ
Racine → File d'attente → TestQ <sélectionnez la file d'attente que vous souhaitez parcourir> → Parcourir

Pour vérifier le contenu de ce message, cliquez sur ce message particulier.

Vous pouvez supprimer un message particulier en cliquant sur le bouton Supprimer affiché dans le coin supérieur droit

Dans ce chapitre, nous allons apprendre les bases du fonctionnement d'ActiveMQ avec Camel.

Configuration du composant ActiveMQ

Avant de pouvoir utiliser la file d'attente ou la rubrique ActiveMQ dans notre code, nous devons configurer ActiveMQComponent. La configuration minimale d'ActiveMQComponent peut être effectuée comme indiqué dans le programme suivant -

<bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
   <property name = "brokerURL" value = "tcp://localhost:61616"/>
   <property name = "userName" value = "admin"/>
   <property name = "password" value = "admin"/>
</bean>

brokerURL - Spécifie l'hôte et le port pour AMQ Broker.
username - Spécifie le nom d'utilisateur à utiliser pour se connecter à AMQ Broker.
password - spécifie le mot de passe pour se connecter à AMQ Broker.

Connexion à la file d'attente

Maintenant que nous avons configuré ActiveMQComponent, nous pouvons l'utiliser dans notre CamelContext comme point de terminaison.

Nous utiliserons le point de terminaison AMQ dans le format suivant -

Activemq:[queue|topic]:[queueName|topicName]

Écrire des messages sur AMQ

<?xml version = "1.0" encoding="UTF-8"?>
<!-- Configures the Camel Context-->
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring
   http://camel.apache.org/schema/spring/camel-spring.xsd">

Après avoir déployé ce bundle dans le conteneur Fuse, vous devriez pouvoir voir les messages publiés sur AMQ qui ont été placés sous forme de fichiers dans D:/src/data.

Input

D: /src/data/input.txt

Test me

Output

Lecture depuis AMQ

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring
   http://camel.apache.org/schema/spring/camel-spring.xsd">
	
   <camelContext xmlns = "http://camel.apache.org/schema/spring">
      <!-- here is a sample which processes the input files
         (leaving them in place - see the 'noop' flag)
          then performs content based routing on the message using XPath -->
			 
      <route>
         <from uri = "activemq:queue:TestQ"/>
         <to uri = "file:///d:/src"/>
      </route>
   </camelContext>
	
   <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
      <property name = "brokerURL" value = "tcp://localhost:61616"/>
      <property name = "userName" value = "admin"/>
      <property name = "password" value = "admin"/>
   </bean>
	
</beans>

Input

Après avoir déployé ce bundle, vous devriez voir un fichier généré dans D: / src et les messages sont consommés. Le consommateur doit également être affiché pour cette file d'attente.

Output

D: / src

Test me

Ecrire au sujet

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring 
   http://camel.apache.org/schema/spring/camel-spring.xsd">
	
   <camelContext xmlns = "http://camel.apache.org/schema/spring">
      <!-- here is a sample which processes the input files
         (leaving them in place - see the 'noop' flag)
          then performs content based routing on the message using XPath -->
			 
      <route>
         <from uri = "file:///d:/src"/>
         <to uri = "activemq:topic:TestTopic” />
      </route>
   </camelContext>
	
   <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
      <property name = "brokerURL" value = "tcp://localhost:61616"/>
      <property name = "userName" value = "admin"/>
      <property name = "password" value = "admin"/>
   </bean>
	
</beans>

Lecture à partir du sujet

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "
   http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://camel.apache.org/schema/spring 
   http://camel.apache.org/schema/spring/camel-spring.xsd">
	
   <camelContext xmlns = "http://camel.apache.org/schema/spring">
      <!-- here is a sample which processes the input files
         (leaving them in place - see the 'noop' flag)
         then performs content based routing on the message using XPath -->
			
      <route>
         <from uri = "activemq:topic:TestTopic"/>
         <to uri = "file:///d:/src2"/>
      </route>
   </camelContext>
	
   <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
      <property name = "brokerURL" value="tcp://localhost:61616"/>
      <property name = "userName" value = "admin"/>
      <property name = "password" value = "admin"/>
   </bean>
	
</beans>

Input

D: /src/file1.xml

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

Output

D: / src /

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

Qu'est-ce que le tissu?

Fabric fournit des fonctionnalités de gestion et d'orchestration pour plusieurs instances Fuse. Fabric nous permet de contrôler toutes les instances Fuse qui lui sont connectées à partir d'un seul point. Un conteneur Fuse normal peut être converti pour agir comme un Fabric. Fabric contient un registre de fabric qui sert de magasin de données contenant toutes les informations concernant les conteneurs qu'il gère.

Pourquoi le tissu?

Fabric possède les capacités spéciales suivantes, ce qui en fait un candidat idéal pour une utilisation dans des environnements distribués.

Surveillance de l'état de tous les conteneurs dans le tissu.
Démarrage et arrêt des conteneurs distants.
Provisionne le conteneur distant pour exécuter une application particulière.
Mise à niveau des applications et déploiement de correctifs dans le système actif.
Démarrage et approvisionnement rapides avec de nouveaux conteneurs, par exemple pour faire face à une charge accrue sur le système.

Configuration du tissu

Créer un tissu

Le conteneur Normal Fuse peut être converti en Fabric à l'aide de la commande suivante

fabric: create --clean --zookeeper-password myZooPass

Connexion d'un autre conteneur à Fabric -

fabric:join --zookeeper-password myZooPass <fabric_host>:2181 Cont1

Note - Veuillez remplacer <fabric_host> par le nom d'hôte réel sur lequel le fabric est en cours d'exécution.

Lorsque vous vous connectez à la Fuse Management Console à partir de votre navigateur en utilisant localhost:8181, vous devriez pouvoir voir deux conteneurs comme indiqué dans la capture d'écran suivante. Le conteneur Fabric est indiqué par un petit symbole de nuage devant lui.

Profils

Un profil contient les informations suivantes -

Bundles à installer
Fonctionnalités à installer
Configurations à appliquer

Un profil fournit un moyen dans l'environnement Fabric d'installer le même ensemble de bundles, de fonctionnalités et de configuration sur plusieurs serveurs.

Si le même profil est appliqué à plusieurs conteneurs et que nous apportons des modifications à ce profil à partir de tout conteneur, des modifications similaires seront déployées automatiquement sur les conteneurs restants auxquels elles sont appliquées.

Créer des profils

Connectez-vous à FMC localhost:8181
Runtime → Gérer
Dans la partie gauche du menu Profil, cliquez sur +

Entrez le nom que vous souhaitez donner au profil et cliquez sur créer.

Après cela, le profil doit être créé.

Application du profil au conteneur

Runtime → Conteneurs → root (sélectionnez le conteneur souhaité)

Cliquez sur Addce qui mènera à une boîte pop-up. Recherchez le profil souhaité, puis cliquez à nouveau surAdd.

Le profil doit être affiché dans la liste comme indiqué dans la capture d'écran suivante.

Déployer un bundle

Pour déployer un bundle, utilisez le chemin suivant:

Runtime → Conteneurs → root (sélectionnez le conteneur souhaité) → First_profile (sélectionnez le profil)

Cliquez sur l'onglet Bundles. Définissez le chemin du bundle au format suivant, puis cliquez sur+.

mvn:group.id/artifact.id/version

Par exemple: mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

Un bundle sera ajouté au profil et sera déployé sur tous les conteneurs auxquels le profil est attribué.

Annuler le déploiement d'un bundle

Pour annuler le déploiement d'un bundle, utilisez le chemin suivant:

Runtime → Conteneurs → root (sélectionnez le conteneur que vous voulez) → First_profile (sélectionnez le profil)

Cliquez sur l'onglet Bundles et recherchez le bundle que vous souhaitez supprimer, puis cliquez sur X. Le Bundle sera supprimé de tous les conteneurs auxquels le profil est appliqué.

Un conteneur enfant est le moyen le plus simple de gérer la charge croissante. Lorsque le système subit une charge soudaine dans le trafic et qu'un seul conteneur n'est pas en mesure de faire face à la charge, nous pouvons facilement créer un ensemble de conteneurs enfants et répartir la charge entre eux, plutôt que de créer un nouveau conteneur complet.

Créer un conteneur enfant

Connectez-vous à FMC en utilisant localhost:8181

Maintenant, suivez le chemin: Runtime → conteneur → + Créer (bouton sur le côté droit)

Entrez des détails tels que le nom de l'enfant, le conteneur parent Nombre d'instances, etc.

Cliquez sur Create And Start Container

Gérer un conteneur enfant

Un conteneur enfant agit uniquement comme un conteneur normal.

Arrêt d'un conteneur enfant

Pour arrêter un conteneur enfant, suivez le chemin: Runtime → Container → Child1

Cliquez sur Arrêter pour arrêter le conteneur enfant.

Démarrage d'un conteneur enfant

Pour démarrer un conteneur enfant, suivez le chemin: Runtime → Container → Child1

Cliquez sur Démarrer pour démarrer le conteneur enfant.

Dans ce chapitre, nous aborderons quelques problèmes connus que vous pourriez rencontrer en travaillant avec Fuse. Nous discuterons également de la manière dont vous pouvez surmonter ces problèmes.

Les changements de code ne sont pas reflétés

Connectez-vous à l'instance Fuse à l'aide d'un script client. Recherchez le bundle pour lequel vous rencontrez un problème à l'aide de la commande suivante.

JBossFuse:[email protected] > list|grep <Bundle Description>
For Example:
JBossFuse:[email protected] > list|grep Camel
[ 255] [Active ] [ ] [ ] [ 60] Fabric8 :: Camel Component (1.0.0.redhat-379)
[ 266] [Active ] [ ] [Started] [ 60] A Camel Spring Route (1.0.0.SNAPSHOT)

Note - ID de bundle pour le bundle à partir de la sortie de la commande ci-dessus et utilisez la commande ci-dessous.

JBossFuse:[email protected] > update <bundle id>
JBossFuse:[email protected] > update 266

Bundle non téléchargé

Cela peut se produire pour les deux raisons suivantes -

Dépôt Maven non spécifié
Bundle non présent dans le référentiel

Référentiel Maven non spécifié

Maven est un outil intégré utilisé pour créer des artefacts Fuse. Fuse recherche d'abord dans le référentiel local Maven des artefacts, lorsque nous émettons une commande pour installer l'artefact. Nous devons donc indiquer à Fuse où Maven est installé et le chemin du référentiel local Mavens.

Modifiez $ FUSE_INSTALLATION_DIR / etc /org.ops4j.paxurl.mvn.cfg

Mettez à jour les deux propriétés suivantes -

org.ops4j.pax.url.mvn.settings = $ M2_HOME / conf /settings.xml
org.ops4j.pax.url.mvn.localRepository = $ local_repo

Note - Veuillez modifier $ local_repo avec le chemin réel de votre dépôt local mentionné dans Mavens settings.xml

Bundle non présent dans le référentiel

Si les paramètres Maven sont en place mais toujours si vous rencontrez des problèmes lors du téléchargement du bundle, assurez-vous que les bundles JAR est présent au bon emplacement dans le référentiel Maven.

Par exemple, si le bundle suivant génère des erreurs lors du téléchargement -

mvn:com.tutorialpoint.app/camel-first-app/1.0-SNAPSHOT

Nous devons vérifier dans $ M2_REPO / com / tutorialpoint / app / camel-first-app / 1.0-SNAPSHOT si le JAR réel est présent.

Note - $ M2_REPO doit être remplacé par le chemin réel du référentiel Maven que Fuse est configuré pour utiliser.

Impossible de se connecter à FMC (interface graphique basée sur le navigateur)

Users not Created - Si vous obtenez l'interface utilisateur suivante mais que vous ne parvenez pas à vous connecter avec un message disant «Échec de la connexion, interdit».

Vérifiez si vous avez ajouté des utilisateurs dans $FUSE_INSTALLATION_HOME/etc/users.properties

Le format correct pour ajouter des utilisateurs est -

Username = Password,Role

Le port HAWTIO est différent

Si vous ne parvenez même pas à obtenir l'interface utilisateur sur localhost: 8181 dans le navigateur, vérifiez si vous avez mentionné le port correct dans l'URL.

$FUSE_INSTALLATION_HOME/etc/org.ops4j.pax.web.cfg

Modifiez la propriété suivante dans le fichier pour utiliser le port auquel vous souhaitez accéder.

org.osgi.service.http.port=8181

AMQ Broker ne fonctionne pas

Assurez-vous que le port 61616 est ouvert et n'est pas actuellement utilisé par un autre port. Si vous souhaitez changer le port 61616 par défaut pour le même, vous pouvez le modifier dans$FUSE_INSTALLATION_HOME/etc/System.properties

activemq.port = 61616

↰ Previous page