JBoss Fuse - Szybki przewodnik

W tym rozdziale zaczniemy od podstaw Enterprise Service Bus. Poniżej znajduje się szczegółowe wyjaśnienie ESB wraz z jej zaletami, wadami i kilkoma diagramami dla łatwiejszego zrozumienia.

Co to jest ESB?

ESB oznacza Enterprise Service Bus. ESB w swojej najprostszej postaci to oprogramowanie pośredniczące, które działa jak autostrada informacyjna, wspomagająca komunikację wielu aplikacji.

W świecie przedsiębiorstw opracowujemy rozwiązania do wielu celów. Te rozwiązania mogą wykorzystywać różne technologie i różne formaty danych. Wspólne używanie tych rozwiązań staje się uciążliwe ze względu na różnice w kompatybilności komunikacji lub formatu danych w tych technologiach. Dlatego potrzebujemy technologii, która pozwoliloosely coupled integration między tymi różnymi rozwiązaniami.

ESB ma na celu uproszczenie tego problemu integracji, stając się „HUBEM”, który znajduje się pośrodku wszystkich aplikacji i ułatwia przesyłanie wiadomości między nimi. ESB pełni rolę mediatora, pełniącego rolę autostrady informacyjnej, zajmującego się routingiem transformacji danych, pozostawiając Kodera lub Dewelopera skupienie się na własnej logice aplikacji.

Zrozumienie ESB staje się bardzo proste, gdy zrozumiemy problem, dla którego została specjalnie zaprojektowana, a rozwiązanie staje się łatwe. Należy dobrze rozumieć, jak włączyć wiele odmiennych systemów, napisanych w różnych językach i działających na różnych maszynach przy użyciu różnych formatów danych, w celu udostępniania informacji i tworzenia zintegrowanej platformy biznesowej.

Problem integracji

Na platformie korporacyjnej często wiele aplikacji współpracuje i zapewnia funkcjonalność biznesową jako całość, ale integracja tych aplikacji jest najczęściej powtarzającym się problemem. Wraz z rozwojem aplikacji staje się to nawet trudne.

Każda aplikacja może wprowadzać i wyprowadzać dane w swoim własnym formacie. To podejście działa dobrze, jeśli liczba aplikacji jest mniejsza, ale wraz ze wzrostem liczby aplikacji koła integracji również wymagają lepszego podejścia. Na przykład, jeśli konkretna aplikacja biznesowa wymaga zmiany, ma to wpływ na jej format danych wyjściowych lub wejściowych dla wszystkich aplikacji zależnych od tej aplikacji głównej.

Takie podejście jest największą przeszkodą dla Integracji, która oczekuje ściśle powiązanej architektury. Tutaj pojawia się ESB. Żadna aplikacja nie musi komunikować się bezpośrednio z inną aplikacją; zamiast tego wszystkie aplikacje komunikują się z ESB, a ESB obsługuje routing informacji i wewnętrzną konwersję formatu danych.

Dlaczego ESB?

Poniżej przedstawiono kilka punktów wyjaśniających, dlaczego Enterprise Service Bus jest niezbędny.

ESB ma na celu uproszczenie problemu integracji z różnymi kompatybilnymi aplikacjami.
Działa jako oprogramowanie pośredniczące, które służy jako mediator dla wszystkich aplikacji i ułatwia kierowanie wiadomości między nimi.
Zamiast każdej aplikacji współpracującej bezpośrednio z każdą inną aplikacją, każda aplikacja ma teraz tylko jeden interfejs do ESB.
ESB jest odpowiedzialna za tłumaczenie komunikatów do / ze wspólnego formatu i kierowanie ich do miejsc docelowych.
Duża oszczędność w tym podejściu to dobrodziejstwo, jeśli musisz wymienić którąkolwiek z istniejących aplikacji. Zamiast pisać całą masę nowych interfejsów, masz teraz tylko jeden interfejs, o który należy się martwić (między twoją aplikacją a ESB).

SOA i ESB?

SOA i ESB są powszechnie używane zamiennie, ale są zupełnie inne.

SOA to wzorzec projektowy, który pozwala aplikacji na eksponowanie swoich funkcjonalności jako usługi w sieci za pośrednictwem protokołów komunikacyjnych, podczas gdy ESB to model, który ułatwia komunikację między różnymi systemami, ale ESB może służyć jako szkielet przy implementacji SOA.

JBoss Fuse to rozwiązanie ESB typu open source firmy Redhat. Jest to rozwiązanie dla przedsiębiorstw oparte na projekcie społecznościowym Apache Servicemix.

Integracja z Fuse

JBoss Fuse to lekka i elastyczna platforma integracyjna, która umożliwia szybką integrację aplikacji korporacyjnych.

Fuse został pierwotnie opracowany przez Progressive software Inc., który został przejęty przez Redhat w 2012 roku. JBoss Fuse 6.1.0.redhat-379 GA to stabilna wersja Fuse, którą można pobrać z ich oficjalnej strony internetowej.

Architektura

Fuse łączy różne technologie w jeden produkt.

składniki

Apache CXF

Apache CXF to platforma do tworzenia usług internetowych typu open source, która obsługuje również tworzenie usług sieciowych SOAP & Rest.

Apache Camel

Apache Camel to platforma integracji oparta na protokole EIP. Wzorce EIP lub Enterprise Integration to zidentyfikowane rozwiązania powtarzających się problemów w Enterprise Integration. Kompletne rozwiązanie integracyjne można osiągnąć błyskawicznie dzięki kombinacji tych wstępnie zdefiniowanych, gotowych wzorców.

Pozwala pisać logikę routingu w kilku językach specyficznych dla domeny, takich jak Java, Spring DSL i Scala itp.

Apache AMQ

Apache AMQ to JMS, który zapewnia niezawodny system przesyłania wiadomości zgodnie ze standardami JMS. Obsługuje nie tylko specyfikację JMS, ale także dostarcza ekscytujących i przydatnych funkcji, które nie są zawarte w specyfikacjach JMS.

Apache Karaf

Apache Karaf to lekki kontener OSGi, który działa jako środowisko wykonawcze dla artefaktów. Apache Karaf ma bardziej dynamiczny charakter w porównaniu do JVM. Pozwala zainstalować lub odinstalować moduły w czasie wykonywania. Wszystkie artefakty w Fuse są rozmieszczone w Karaf.

Tkanina

Sieć szkieletowa zapewnia łatwy sposób zarządzania wdrożeniami artefaktów w dużym i rozproszonym środowisku. Zapewnia scentralizowane zarządzanie wszystkimi wieloma instancjami bezpieczników.

Instalowanie bezpiecznika

Instalacja Fuse jest dość prosta. Podobnie jak inne produkty JBoss, Fuse jest dostępny jako plik zip, który można rozpakować, a po drobnych zmianach konfiguracji można go bezpośrednio uruchomić.

Instalacja Fuse to czteroetapowy proces -

Pobieranie

Pobierz Fuse 6.1.0 GA z poniższego linku. http://www.jboss.org/

Rozsunąć suwak

Podobnie jak wszystkie inne produkty JBoss, Fuse jest również niezależnym od platformy zipem.

Rozpakuj pobrany plik do katalogu docelowego, który ma być katalogiem instalacyjnym programu Fuse. Wybierz ten katalog mądrze, ponieważ powinien pozostać taki sam przez cały okres istnienia instancji Fuse.

Note - Mimo że Fuse rozpina i uruchamia się jak inne produkty JBoss, nie zaleca się przenoszenia instalacji Fuse z jednego miejsca do drugiego po zakończeniu instalacji.

Skonfiguruj

Po rozpakowaniu Fuse w wyodrębnionym katalogu znajdziesz następujące katalogi -

bin
etc
deploy
lib
licenses
extras
quickstarts

Z których będziemy używać tylko dwóch katalogów bin & etc.

Praktycznie po wyodrębnieniu Fuse powinniśmy być w stanie uruchomić fuse bezpośrednio, ale spowoduje to uruchomienie Fuse ze wszystkimi domyślnymi konfiguracjami, co nie jest zalecane w środowisku produkcyjnym. Zdecydowanie zaleca się dokonanie poniższych zmian przed uruchomieniem Fuse.

Ustaw zmienne środowiskowe

Ustaw następujące zmienne środowiskowe - JAVA_HOME
Zmienna powinna wskazywać na katalog instalacyjny java - M2_HOME
Zmienna powinna wskazywać na katalog instalacyjny Mavena - PATH
Ustaw zmienną ścieżki, aby zawierała pliki wykonywalne Java i Maven.

Windows

W systemie Windows ustawienia można wykonać, postępując zgodnie z poniższymi instrukcjami -

Start → Mój komputer → Kliknij prawym przyciskiem myszy → Właściwości → Zaawansowane ustawienia systemu → Zmienne środowiskowe.

UNIX i klony

Dla każdego użytkownika istnieje profil bash w pliku *nixsystem operacyjny. Możemy dodać lub edytować istniejącą zmienną systemową, zmieniając ten plik.

$ vi ~/.bash_proflle

Note- Wszelkie zmiany w tym pliku są trwałe. Zdecydowanie zaleca się wykonanie kopii zapasowej istniejącego pliku przed zmianą oryginału.

Podstawowa konfiguracja

Omówimy podstawową konfigurację JBoss Fuse i do tego musimy zacząć od następującego polecenia Edit $FUSE_INSTALLATION_DIR/etc/

W user.properties

#admin=admin,admin
Należy to zmienić zgodnie z pierwszym administratorem z nazwą użytkownika, który chcemy, drugi administrator z hasłem, trzeci może zostać zachowany, ponieważ wskazuje rolę i nie zapomnij usunąć #
Na przykład - FuseAdmin = FusePAss, admin

W System.properties
- karafName = root
  - Wskazuje nazwę, jaką chcesz nadać instancji Karaf.
  - Możemy nazwać to wszystko, co chcemy, jak Cont1.
  - Upewnij się, że ta nazwa jest unikatowa i nie jest już używana przez inną instancję Fuse.
W org.ops4j.pax.web.cfg
- Org.osgi.service.http.port = 8181
- Ta właściwość wskazuje port, który ma być używany do uzyskiwania dostępu do interfejsu HAWTIO opartego na przeglądarce udostępnianego przez Fuse
- HAWTIO to wbudowany interfejs przeglądarki Fuse, który jest dostępny od wersji 6.0
W org.ops4j.pax.url.mvn.cfg
- org.ops4j.pax.url.mvn.localRepository = D: / repository
- Ta właściwość wskazuje ścieżkę do localRepository naszego Mavena, z którego Fuse zainstaluje swoje artefakty.
- org.ops4j.pax.url.mvn.settings = D: /Maven/conf/settings.xml
- Ta właściwość wskazuje settings.xml, którego Fuse powinien używać do pobierania artefaktów z Mavena.

Konfigurowanie Mavena

Maven jest warunkiem koniecznym do zainstalowania Fuse. Jeśli nie wiesz, czym jest maven, zajrzyj dohttp://www.tutorialspoint.com/maven/

Maven to wbudowane narzędzie służące do budowy artefaktów Fuse. Połącz pierwsze wyszukiwania artefaktów w lokalnym repozytorium Maven, gdy wydamy polecenie instalacji artefaktu. Musimy więc powiadomić Fuse, gdzie jest zainstalowany Maven i ścieżkę do lokalnego repozytorium Mavena.

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

Zaktualizuj następujące dwie właściwości -

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

Note - Proszę się zmienić $local_repo rzeczywistą ścieżką do lokalnego repozytorium wymienioną w Mavens settings.xml.

Biegać

Po wykonaniu podstawowych zmian w konfiguracji możemy teraz uruchomić Fuse. Wszystkie pliki binarne do pracy z programem Fuse znajdują się w$FUSE_INSTALLATION_DIR.

Istnieją dwa sposoby uruchomienia Fuse -

Za pomocą ./fuse
- Pozwoli ci to zobaczyć cały postęp i dzienniki w tym samym oknie, w którym uruchomiłeś Fuse.
- To da ci konsolę Karaf w tym samym terminalu, co pokazano poniżej.

Note- Spowoduje to uruchomienie fuse w trybie konsoli, co oznacza, że proces Fuse zostanie również zatrzymany, gdy użytkownik wyloguje się z sesji lub zamknie Terminal, co nie jest pożądane w scenariuszu produkcyjnym lub rozwojowym. Ten skrypt powinien być używany tylko do debugowania Fuse.

Za pomocą ./start
- To nie pokaże żadnych logów na ekranie, nawet postępu, ale spowoduje to uruchomienie Fuse w tle, a usługa Fuse nie zostanie zatrzymana, gdy użytkownik wyjdzie z sesji lub zamknie terminal.
- W rzeczywistej aplikacji tego typu zachowanie jest pożądane. Bezpiecznik powinien działać w tle nawet jeśli zamkniemy terminal.
- Jeśli chcesz połączyć się z Fuse działającym w tle, możesz użyć client skrypt, który znajduje się w tym samym folderze.
- Powinieneś otrzymać wyświetlacz, jak pokazano na poniższym zrzucie ekranu.
- Wyjście ze skryptu klienta nie zatrzyma usługi Fuse. Po prostu zamknie konsolę Fuse.

HAWTIO

Fuse zapewnia również pełny dostęp do interfejsu GUI za pomocą FMC (konsoli zarządzania bezpiecznikami). Możesz znaleźć GUI pod poniższym adresem URLhttp://localhost:8181.

Wszystko, co zrobiliśmy, wykonując polecenia, można również wykonać, uzyskując dostęp do tego graficznego interfejsu użytkownika opartego na przeglądarce. Jest to niezwykle pomocne, gdy mamy więcej niż jeden kontener i pracujemy w środowisku Fabric.

W tym rozdziale omówimy Apache Karaf i dlaczego nazywany jest lekkim kontenerem OSGi wraz z jego zaletami i innymi ważnymi cechami.

Problem JVM

Maszyna wirtualna JVM lub Java nie działa jako rzeczywista maszyna wirtualna. Maszyna, która pozwoli Ci w locie zatrzymać, uruchomić lub ponownie uruchomić komponenty w niej działające. Czasami może zezwalać na gorące wdrożenia na poziomie klasy, ale nie ma możliwości wdrożenia lub cofnięcia wdrożenia komponentu aplikacji na maszynie wirtualnej bez jej ponownego uruchomienia.

Aby rozwiązać ten problem i umożliwić modułowość w aplikacji Java, Fuse używa środowiska uruchomieniowego opartego na OSGi znanego jako Apache Karaf.

OSGi

Technologia OSGi to zestaw specyfikacji definiujących dynamiczny system komponentów dla języka Java. Specyfikacje te pozwalają na model programistyczny, w którym aplikacje są (dynamicznie) złożone z wielu różnych (wielokrotnego użytku) komponentów.

Korzyści z OSGi

Reduced Complexity - Aplikacja jest zbudowana jako współpracujące komponenty, które ukrywają przed sobą szczegóły implementacji, co zmniejsza złożoność.
Reusability - Wiele składników może wykorzystywać ten sam składnik wdrożony w kontenerze.
Deployment - OSGi zapewnia obsługę uruchamiania, zatrzymywania i aktualizowania komponentów w locie dzięki interfejsom API do zarządzania cyklem życia bez ponownego uruchamiania kontenera.

Pakiety kontra funkcje

Poniżej znajduje się porównanie pakietów i funkcji.

Wiązki

Pakiety są odpowiednikiem OSGi, czym słoiki są dla JVM. Pakiety to artefakty, które można wdrożyć w kontenerze OSGi. Pakiety to komponenty, które współpracują ze sobą lub niezależnie, tworząc aplikację.

Pakiety te można instalować, odinstalowywać, aktualizować, uruchamiać lub zatrzymywać w czasie wykonywania bez ponownego uruchamiania kontenera.

funkcje

Funkcje to sposób na jednoczesne wdrażanie wielu pakietów. Czasami bardziej sensowne jest wdrażanie pakietów w grupie. Funkcje pozwalają nam wdrożyć grupę pakietów za pomocą tylko jednego polecenia.

Dlaczego inny pojemnik?

Apache Karaf to środowisko uruchomieniowe oparte na OSGi, w którym działają nasze pakiety aplikacji. Fuse używa Apache Karaf jako środowiska wykonawczego, w którym pakiety działają i współpracują w celu zapewnienia funkcjonalności biznesowej.

Karaf jest zbudowany na Felix i equinox, które są frameworkami OSGi.

Architektura Karaf

Apache Karaf dodaje następujące dodatkowe funkcje do podstawowego środowiska uruchomieniowego OSGi.

Wdrożenie na gorąco

Karaf wspiera wdrażanie na gorąco. Zawiera katalog gorącej instalacji. Wszystko, co jest umieszczone w tym katalogu, jest automatycznie wdrażane i instalowane w Karaf jako pakiet.

Logowanie

Karaf zapewnia scentralizowane rejestrowanie, generując dzienniki dla wszystkich pakietów w $Fuse_home/data/log. Możemy edytować konfigurację loggera worg.ops4j.pax.logging.cfg w $Fuse_home/etc directory.

Konsola administracyjna

Karaf zapewnia wyrafinowaną i przejrzystą konsolę administracyjną do interakcji z uruchomioną instancją fuse. Zawiera również wstępnie zainstalowany zestaw poleceń, których można używać do zarządzania i monitorowania komponentów (pakiet) w czasie wykonywania. Ta konsola jest rozszerzalna, więc pozwala nam dodawać nowe polecenia do konsoli poprzez dodawanie nowych pakietów do konsoli.

Dostęp SSH

Karaf umożliwia zdalny dostęp do tej konsoli administracyjnej przez SSH. Każdy z ważnymi danymi uwierzytelniającymi może połączyć się z konsolą administratora Karaf przez terminal SSH.

W tym rozdziale omówimy, czym jest Apache Camel i jak skutecznie kieruje dane między punktami końcowymi, wraz z kilkoma przykładami.

Co to jest Apache Camel?

Apache Camel to platforma integracji typu open source, która została uruchomiona na początku 2007 roku.

Jest to podejście oparte na EIP (Enterprise Integration Pattern), które zapewnia kilka nieszablonowych implementacji wzorców, które można wykorzystać do rozwiązywania problemów związanych z integracją przedsiębiorstwa. EIP to nic innego jak sprawdzone rozwiązania dobrze udokumentowanych i powtarzających się problemów w integracji przedsiębiorstwa.

Camel jest również znany jako silnik routingu i mediacji, ponieważ skutecznie kieruje dane między punktami końcowymi, przy dużym obciążeniu, takim jak transformacja formatów danych, łączność z punktami końcowymi i wiele innych.

Podstawowy przykład

Wymagania wstępne do korzystania z Apache Camel to -

Java
Maven
Bezpiecznik Redhat JBoss 6.1-GA-379

Utwórz podstawowy szkielet aplikacji

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

Powinno to wygenerować następującą strukturę katalogów.

To jest podstawowy szkielet generowanej aplikacji Camel.

Edytuj plik camel-context.xml

Edytować camel-first-app → src → main → resources → META-INF\spring\camel-context.xml, aby dopasować jak poniżej

<?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>

Edytuj plik pom.xml

Dodaj następujący kod wewnątrz <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>

Zmień typ opakowania z jar → bundle.

<packaging>bundle</packaging>

Zbuduj projekt za pomocą następującego polecenia -

mvn clean install

Zainstaluj projekt w programie Fuse

Uruchom Fuse za pomocą Fuse.bat/start.bat. Jeśli zaczniesz Fuse za pomocąstart.bat, posługiwać się client.batpodłączyć do Fuse. Powinieneś otrzymać interfejs użytkownika, jak pokazano na poniższym zrzucie ekranu.

To jest CLI do uzyskiwania dostępu do poleceń Karaf i Fuse.

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

Sprawdź, czy Twój projekt jest uruchomiony

Teraz Twoja aplikacja powinna być zainstalowana w Fuse. Skopiuj katalog danych do środkacamel-first-app i umieść go w D:/src/ i powinien skopiować wiadomość z city = London do D:/target/merssages/uk.

Umieść plik wejściowy w 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

W D: / target / messages / uk

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

W D: / target / messages / others

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

W tym rozdziale zrozumiemy różne koncepcje wielbłądów. Zacznijmy od podstawowego przykładu, aby na początek zrozumieć podstawowe pojęcia.

CamelContext

Każda aplikacja dla wielbłądów będzie miała co najmniej jeden obiekt CamelContext. To miejsce, w którym dodajemy trasy wielbłądów. To jest podobne doApplicationContext wiosny.

Kontekst wielbłąda można traktować jako pojemnik, który trzyma wszystko razem. Jeden kontekst wielbłąda może mieć w sobie wiele tras.

Trasy

CamelContext może zawierać jedną lub więcej tras. Trasy to logika integracji, która definiuje sposób przepływu danych w kontekście wielbłąda z jednego punktu końcowego do drugiego.

Punkt końcowy

Punkt końcowy to koniec kanału, przez który system może wysyłać lub odbierać wiadomości. To właśnie nazywamy celem lub źródłem w języku komunikacji.

składniki

Komponenty są punktami rozszerzenia w Camel. Komponenty mogą być interfejsem technologii, formatem danych, transformatorami itp. Mogą też pełnić rolę fabryki dla punktów końcowych.

EIP

EIP to skrót od Enterprise Integration Pattern. Są to zidentyfikowane i dobrze znane rozwiązania powtarzającego się problemu. Camel obsługuje większość wzorców integracji przedsiębiorstwa.

Router oparty na zawartości

Wzorce CBR pozwalają nam kierować dane zgodnie z zawartością pliku wejściowego.

Ten wzorzec jest używany, gdy musimy kierować wartości w zależności od zawartości treści danych wejściowych.

Poniższy przykład odczyta dane z D:/data/inputinformator. Po przeczytaniu sprawdzi znacznik wartości wewnątrz znacznika danych. Jeśli tag wartości zawieravalue1, zostanie wysłany do D:/value1, Jeśli zawiera value2, zostanie wysłany do D:/value2 a jeśli żadne z tych obu, zostanie wysłane do innych.

<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: / wartość1 /

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

D: / wartość2 /

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

Rozdzielacz

Wzorzec rozdzielający służy do dzielenia danych wejściowych na mniejsze fragmenty.

Ten wzorzec jest używany przez większość czasu w przypadku ogromnych danych wejściowych, które wymagają podzielenia na fragmenty, dzięki czemu stają się przetwarzalne. Dzieli dane wejściowe na mniejsze fragmenty na podstawie ciągu tokenu wejściowego.

<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

Jeśli zaznaczysz AMQ, znajdziesz 3 wysłane wiadomości.

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

Lista odbiorców

Wzorzec listy adresatów jest używany, gdy lista adresatów musi zostać pobrana z samej treści wiadomości.

W poniższym przykładzie wiadomość zostanie wysłana do wszystkich adresatów wymienionych w tagu klienta jako lista ciągów oddzielonych przecinkami.

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

Inne EIP

Camel wspiera prawie wszystkie zidentyfikowane EIP. Poniżej wymieniono niektóre z powszechnie stosowanych EIP.

Log - Aby zarejestrować całą wiadomość lub jej część
Message Filter - Filtrowanie treści wiadomości
Re-Sequencer - Aby uzyskać wszystkie tokeny w kolejności
Wiretap - Aby sprawdzić wiadomości podróżne

Pełną listę EIP i ich wykorzystania można znaleźć w oficjalnej dokumentacji Camel http://camel.apache.org/eip.html

Obsługa wyjątków w programie Camel

Using Error Handler - To najłatwiejszy sposób postępowania z wyjątkami u wielbłądów.

Aby z tego skorzystać, musimy skonfigurować komponent bean klasy obsługi błędów i podać go jako odniesienie do CamelContext errorHandlerRef atrybut.

<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>

Korzystanie z Try Catch Final

Camel obsługuje również styl Java Try Catch Finally block do obsługi błędów.

Podobnie jak Java ma następujące trzy bloki -

doTry blok zawiera kod, który może generować wyjątek.
doCatch blok zawiera kod, który należy wykonać w przypadku wyjątku.
doFinallyblok zawiera kod, który musi zostać wykonany niezależnie od wyjątku. Będzie zawsze wykonywany bez względu na to, czy wyjątek został zgłoszony, czy nie.

Note- Mock jest elementem testowym i nie jest zalecany do innych celów. Jest to komponent wielbłąda używany do testowania, podobnie jak komponent jMOck w programowaniu sterowanym testami.

<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>

W powyższym przykładzie możemy podać listę wyjątków, które muszą być obsługiwane przez blok catch.

Wdrażanie paczki w Fuse

Uruchom Fuse za pomocą Fuse.bat/start.bat.

Jeśli uruchomisz Fuse za pomocą start.bat, użyj client.bat, aby połączyć się z Fuse. Powinieneś otrzymać interfejs użytkownika, jak pokazano na poniższym zrzucie ekranu.

To jest CLI do uzyskiwania dostępu do poleceń Karaf i Fuse.

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

W tym rozdziale omówimy, czym jest Apache CXF i jak może być pomocny w tworzeniu SOAP i Rest Web Services.

Co to jest Apache CXF?

Apache CXF to platforma do tworzenia usług internetowych, która może być używana do tworzenia usług sieciowych SOAP i Rest. CXF jest w pełni zgodny zJAX-RS and JAX-Ws standard.

Jest to obecnie najczęściej używana platforma do tworzenia usług internetowych. CXF nauczył się i ulepszył Axis2, który jest obecnie stopniowo zastępowany przez CXF.

CXF kontra Axis2

	CXF	Oś 2
Improvements	Obecnie najczęściej używanym frameworkiem jest CXF. Ma wiele ulepszeń w stosunku do Axis2	Axis2 jest stopniowo zastępowany przez CXf. Wymaga więcej kodu w porównaniu do CXF
Wymagany kod	CXF wymaga mniej kodu w porównaniu do Axis2	Oś 2 wymaga stosunkowo więcej kodu
Zgodność ze standardami	CSF jest w pełni zgodny z JAX-RS i JAX-WS	Axis2 nie jest w pełni zgodny z JAX-RS i JAX-WS
Kompatybilny z Spring	tak	Nie
Oddzielenie front-endów	Czyste oddzielenie front-endu od kodu JAX-WS	Nie zapewnia się czystej separacji

MYDŁO

SOAP to skrót od Simple Object Access Protocol. Jest to protokół służący do wymiany ustrukturyzowanych informacji między dwoma systemami za pośrednictwem usług sieciowych. Opiera się głównie na XML do strukturyzacji danych i używa HTTP lub SMTP do negocjacji i transmisji wiadomości.

Istnieją dwa podejścia do tworzenia usług sieciowych SOAP -

Code first - W tym podejściu WSDL jest generowany z kodu.
Contract first - W umowie najpierw kod jest generowany z WSDL.

Rozwój SOAP przy użyciu CXF

Skonfiguruj Mavena

Dodaj następujący profil do swojego settings.xml 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>

Utwórz szkielet

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:karaf@root>install -s mvn:org.fusesource.example/cxf-basic/1.0-SNAPSH

Check if bundle has registered SOQP web-service

Otwórz URL http://localhost:8181/cxf

Usługa internetowa powinna być wymieniona w następujący sposób.

Testing Web-Service

mvn -Pclient

INFO - Tworzenie usługi {http://ws.totorials.com/} PersonService z klasy 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] ------------------------------------------------------------------------

Na początek REST oznacza Representational State Transfer. Jest to sposób tworzenia usług internetowych w oparciu o bezstanowy, buforowalny protokół klient-serwer, którym w większości przypadków jest HTTP.

Usługi sieciowe REST używają żądań HTTP do wysyłania, pobierania i usuwania danych z sieci.

Programowanie REST przy użyciu CXF

Utwórz prosty projekt szybkiego uruchamiania Maven

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

Dodaj zależności

<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>

Dodaj instrukcję budowy

<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>

Dodaj repozytoria wtyczek 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>

Dodaj repozytoria

<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>

Utwórz klasę usług

Utwórz klasę UserService.java w 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;
   }
}

Utwórz plik Blueprint.xml

Utwórz plik blueprint.xml pod / 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>

Zainstaluj usługę Rest w programie Fuse

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

Sprawdź, czy pakiet ma zarejestrowaną usługę internetową

Otwórz URL http://localhost:8181/cxf

Testuj usługę internetową

Otwórz URL http://localhost:8181/cxf/users12/UserService_1/get_data

W tym rozdziale dowiemy się o ActiveMQ oraz o tym, jak działa jako broker komunikatów, umożliwiając aplikacjom komunikowanie się ze sobą.

Co to jest AMQ?

ActiveMQ to broker komunikatów typu open source napisany w języku Java. Jest w pełni zgodny ze standardami JMS 1.1.

JMS to specyfikacja umożliwiająca tworzenie systemu opartego na komunikatach. ActiveMQ działa jako broker komunikatów, który znajduje się pomiędzy aplikacjami i umożliwia im komunikację w sposób asynchroniczny i niezawodny.

Rodzaje wiadomości

Istnieją dwa rodzaje opcji przesyłania wiadomości wyjaśnione poniżej dla lepszego zrozumienia.

Wskaż punkt

W tego typu komunikacji broker wysyła wiadomości tylko do jednego konsumenta, podczas gdy pozostali konsumenci będą czekać, aż otrzymają wiadomości od brokera. Żaden konsument nie otrzyma tej samej wiadomości.

Jeśli nie ma konsumentów, Broker będzie przechowywał wiadomości, dopóki nie dotrze do konsumenta. Ten rodzaj komunikacji jest również nazywany jakoQueue based communicationgdzie producent wysyła komunikaty do kolejki, a tylko jeden konsument otrzymuje jeden komunikat z kolejki. Jeśli jest więcej niż jeden konsument, mogą otrzymać następną wiadomość, ale nie otrzymają tej samej wiadomości, co drugi konsument.

Publikuj / subskrybuj

W tego typu komunikacji Broker wysyła tę samą kopię wiadomości do wszystkich aktywnych konsumentów. Ten rodzaj komunikacji jest również znany jakoTopic based communicationgdzie broker wysyła tę samą wiadomość do wszystkich aktywnych konsumentów, którzy zapisali się na dany temat. Model ten obsługuje komunikację jednokierunkową, w której nie oczekuje się weryfikacji przesyłanych wiadomości.

Tworzenie kolejki i tematów

Fuse jest dostarczany w pakiecie z ActiveMQ. Dostęp do ActiveMQ możemy uzyskać za pomocą konsoli FMC (interfejs oparty na przeglądarce do pracy z AMQ).

Zaloguj się do FMC używając localhost:8181 i wybierz ActiveMQ patka.

Kliknij + Utwórz
Wprowadź nazwę kolejki / tematu
Wybierz kolejkę / temat z przycisku opcji
Kliknij Utwórz kolejkę / Utwórz temat

Teraz powinieneś być w stanie zobaczyć TestQ utworzony w katalogu głównym → Kolejka →

Aby sprawdzić utworzony temat, przejdź do katalogu głównego → Temat.

Przeglądanie / usuwanie zawartości kolejki

Zaloguj się do FMC używając localhost:8181
Wybierz zakładkę ActiveMQ
Root → Queue → TestQ <wybierz kolejkę, którą chcesz przeglądać> → Przeglądaj

Aby sprawdzić zawartość tej wiadomości, kliknij tę wiadomość.

Możesz usunąć konkretną wiadomość, klikając przycisk Usuń widoczny w prawym górnym rogu

W tym rozdziale nauczymy się podstaw działania ActiveMQ z Camel.

Konfiguracja do składnika ActiveMQ

Zanim będziemy mogli użyć kolejki lub tematu ActiveMQ w naszym kodzie, musimy skonfigurować ActiveMQComponent. Minimalną konfigurację ActiveMQComponent można wykonać tak, jak pokazano w poniższym programie -

<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 - Określa hosta i port dla AMQ Broker.
username - Określa nazwę użytkownika, która ma być używana do łączenia się z AMQ Broker.
password - określa hasło do połączenia z AMQ Broker.

Łączenie się z kolejką

Teraz, gdy skonfigurowaliśmy ActiveMQComponent, możemy go użyć w naszym CamelContext jako punkt końcowy.

Będziemy używać punktu końcowego AMQ w następującym formacie -

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

Pisanie wiadomości do 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">

Po wdrożeniu tego pakietu w kontenerze Fuse powinieneś być w stanie zobaczyć wiadomości wysłane do AMQ, które zostały umieszczone jako pliki w D:/src/data.

Input

D: /src/data/input.txt

Test me

Output

Czytanie z 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

Po wdrożeniu tego pakietu powinieneś zobaczyć generowany plik w D: / src, a komunikaty są zużywane. Powinien być również pokazany konsument dla tej kolejki.

Output

D: / src

Test me

Pisanie do tematu

<?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>

Czytanie z tematu

<?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>

Co to jest tkanina?

Sieć szkieletowa zapewnia funkcje zarządzania i orkiestracji dla wielu instancji Fuse. Fabric pozwala nam kontrolować wszystkie instancje Fuse do niego podłączone z jednego punktu. Zwykły pojemnik z bezpiecznikami może zostać przekształcony w materiał. Fabric ma rejestr tkanin, który służy jako magazyn danych zawierający wszystkie informacje dotyczące kontenerów, którymi zarządza.

Dlaczego tkanina?

Tkanina ma następujące specjalne właściwości, co czyni ją idealnym kandydatem do użytku w środowiskach rozproszonych.

Monitorowanie stanu wszystkich pojemników w tkaninie.
Uruchamianie i zatrzymywanie zdalnych kontenerów.
Udostępnia zdalny kontener do uruchamiania określonej aplikacji.
Aktualizowanie aplikacji i wdrażanie poprawek w systemie na żywo.
Szybkie uruchamianie i udostępnianie nowych kontenerów, na przykład w celu radzenia sobie ze zwiększonym obciążeniem systemu.

Konfiguracja tkaniny

Tworzenie tkaniny

Zwykły pojemnik Fuse można przekształcić w Fabric za pomocą następującego polecenia

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

Podłączanie innego pojemnika do tkaniny -

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

Note - Zastąp <fabric_host> rzeczywistą nazwą hosta, na którym działa tkanina.

Gdy logujesz się do Fuse Management Console z przeglądarki za pomocą localhost:8181, powinieneś być w stanie zobaczyć dwa kontenery, jak pokazano na poniższym zrzucie ekranu. Pojemnik z tkaniną jest oznaczony małym symbolem chmurki przed nim.

Profile

Profil zawiera następujące informacje -

Pakiety do zainstalowania
Funkcje do zainstalowania
Konfiguracje do zastosowania

Profil umożliwia w środowisku szkieletowym instalację tego samego zestawu pakietów, funkcji i konfiguracji na wielu serwerach.

Jeśli ten sam profil zostanie zastosowany do wielu kontenerów i dokonamy zmian w tym profilu z dowolnego kontenera, podobne zmiany zostaną wdrożone automatycznie w pozostałych kontenerach, w których jest stosowany.

Tworzenie profili

Zaloguj się do FMC localhost:8181
Środowisko wykonawcze → Zarządzaj
Po lewej stronie w menu Profil kliknij +

Wpisz nazwę, którą chcesz nadać profilowi i kliknij utwórz.

Następnie należy utworzyć profil.

Stosowanie profilu do kontenera

Środowisko uruchomieniowe → Kontenery → root (wybierz żądany kontener)

Kliknij Addco doprowadzi do wyskakującego okienka. Wyszukaj żądany profil, a następnie ponownie kliknijAdd.

Profil powinien być pokazany na liście, jak pokazano na poniższym zrzucie ekranu.

Wdrażanie pakietu

Aby wdrożyć pakiet, użyj następującej ścieżki -

Runtime → Containers → root (wybierz kontener, który chcesz) → First_profile (wybierz profil)

Kliknij kartę Pakiety. Ustaw ścieżkę pakietu w następującym formacie, a następnie kliknij+.

mvn:group.id/artifact.id/version

Na przykład: mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

Paczka zostanie dodana do profilu i zostanie wdrożona na wszystkich kontenerach, do których przypisany jest profil.

Wycofywanie paczki

Aby cofnąć wdrożenie pakietu, użyj następującej ścieżki -

Runtime → Containers → root (wybierz kontener, który chcesz) → First_profile (wybierz profil)

Kliknij kartę Pakiety i wyszukaj pakiet, który chcesz usunąć, a następnie kliknij X. Pakiet zostanie usunięty ze wszystkich kontenerów, do których zastosowano profil.

Kontener podrzędny zapewnia najłatwiejszy sposób zarządzania rosnącym obciążeniem. Gdy system doświadcza gwałtownego obciążenia ruchem i pojedynczy kontener nie jest w stanie sobie z nim poradzić, możemy w prosty sposób stworzyć zestaw kontenerów podrzędnych i rozłożyć ładunek pomiędzy nimi, zamiast tworzyć zupełnie nowy kontener.

Tworzenie kontenera podrzędnego

Zaloguj się do FMC używając localhost:8181

Teraz podążaj ścieżką: Runtime → container → + Create (przycisk po prawej stronie)

Wprowadź szczegóły, takie jak imię i nazwisko dziecka, kontener nadrzędny Liczba instancji itp.

Kliknij Create And Start Container

Zarządzanie kontenerem podrzędnym

Kontener podrzędny działa tylko jak zwykły kontener.

Zatrzymywanie kontenera podrzędnego

Aby zatrzymać kontener podrzędny, postępuj zgodnie ze ścieżką: Runtime → Container → Child1

Kliknij przycisk Zatrzymaj, aby zatrzymać kontener podrzędny.

Uruchamianie kontenera podrzędnego

Aby uruchomić kontener podrzędny, postępuj zgodnie ze ścieżką: Runtime → Container → Child1

Kliknij Start, aby uruchomić kontener podrzędny.

W tym rozdziale omówimy kilka znanych problemów, które mogą wystąpić podczas pracy z programem Fuse. Omówimy również, jak możesz sobie z tym poradzić.

Zmiany kodu nie są odzwierciedlane

Połącz się z instancją Fuse przy użyciu skryptu klienta. Wyszukaj pakiet, dla którego masz problem, używając następującego polecenia.

JBossFuse:karaf@root > list|grep <Bundle Description>
For Example:
JBossFuse:karaf@root > 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 - Identyfikator pakietu dla pakietu z wyjścia powyższego polecenia i użyj poniższego polecenia.

JBossFuse:karaf@root > update <bundle id>
JBossFuse:karaf@root > update 266

Pakiet nie jest pobierany

Może się tak zdarzyć z następujących dwóch powodów -

Nie określono repozytorium Maven
Pakiet nie występuje w repozytorium

Nie określono repozytorium Maven

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

Zaktualizuj następujące dwie właściwości -

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

Note - Zmień $ local_repo na rzeczywistą ścieżkę do lokalnego repozytorium wymienioną w Mavens settings.xml

Pakiet nie jest obecny w repozytorium

Jeśli ustawienia Maven są na miejscu, ale nadal napotykasz problemy podczas pobierania pakietu, upewnij się, że pakiety JAR znajduje się we właściwej lokalizacji w repozytorium Maven.

Na przykład, jeśli następujący pakiet generuje błędy podczas pobierania -

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

Musimy sprawdzić w $ M2_REPO / com / tutorialpoint / app / camel-first-app / 1.0-SNAPSHOT, czy obecny JAR jest obecny.

Note - $ M2_REPO musi zostać zastąpione rzeczywistą ścieżką repozytorium Maven, do użycia którego mamy skonfigurowany Fuse.

Nie można zalogować się do FMC (GUI oparty na przeglądarce)

Users not Created - Jeśli otrzymujesz następujący interfejs użytkownika, ale nie możesz się zalogować z komunikatem „Logowanie nie powiodło się, zabronione”.

Sprawdź, czy dodałeś użytkowników w $FUSE_INSTALLATION_HOME/etc/users.properties

Prawidłowy format dodawania użytkowników to -

Username = Password,Role

Port HAWTIO jest inny

Jeśli nie jesteś nawet w stanie uzyskać interfejsu użytkownika na localhost: 8181 w przeglądarce, sprawdź, czy podałeś poprawny port w adresie URL.

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

Edytuj następującą właściwość w pliku, aby użyć portu, do którego chcesz uzyskać dostęp.

org.osgi.service.http.port=8181

AMQ Broker nie działa

Upewnij się, że port 61616 jest otwarty i nie jest aktualnie używany przez inny port. Jeśli chcesz zmienić domyślny port 61616 na ten sam, możesz go edytować w$FUSE_INSTALLATION_HOME/etc/System.properties

activemq.port = 61616