JBoss Fuse - Panduan Cepat

Dalam bab ini, kita akan mulai dengan hal-hal penting dari Enterprise Service Bus. Diberikan di bawah ini adalah penjelasan rinci tentang ESB beserta kelebihan, kekurangannya dan beberapa diagram untuk memudahkan pemahaman.

Apa itu ESB?

ESB adalah singkatan dari Enterprise Service Bus. ESB dalam bentuk yang paling sederhana adalah middleware yang bertindak sebagai jalan raya informasi yang membantu banyak aplikasi untuk berkomunikasi.

Dalam dunia perusahaan, kami mengembangkan solusi untuk banyak hal. Solusi ini mungkin menggunakan teknologi yang berbeda dan format data yang berbeda. Menjadi rumit untuk menggunakan solusi ini bersama karena varians kompatibilitas format komunikasi atau data dalam teknologi ini. Oleh karena itu diperlukan suatu teknologi yang memungkinkanloosely coupled integration di antara solusi yang berbeda ini.

ESB bertujuan untuk menyederhanakan masalah integrasi ini dengan menjadi 'HUB' yang berada di tengah-tengah semua aplikasi Anda dan memfasilitasi perutean pesan di antara mereka. ESB berfungsi sebagai mediator, bertindak sebagai jalan raya informasi, mengurus perutean transformasi data, membiarkan Coder atau Pengembang fokus pada logika aplikasinya sendiri.

Memahami ESB menjadi sangat sederhana ketika kita memahami masalah yang dirancang khusus dan solusinya menjadi mudah. Seseorang harus memiliki pemahaman yang jelas tentang bagaimana mengaktifkan banyak sistem yang berbeda, yang ditulis dalam bahasa berbeda dan berjalan pada mesin yang berbeda menggunakan format data yang berbeda untuk berbagi informasi dan membentuk platform bisnis yang terintegrasi.

Masalah Integrasi

Dalam platform perusahaan, beberapa aplikasi biasa berkolaborasi dan menyediakan fungsionalitas bisnis secara keseluruhan, tetapi integrasi aplikasi ini adalah masalah yang paling berulang. Ini menjadi semakin sulit seiring waktu seiring berkembangnya aplikasi.

Setiap aplikasi dapat memasukkan dan mengeluarkan data dalam formatnya masing-masing. Pendekatan ini berfungsi dengan baik jika jumlah aplikasi lebih sedikit, tetapi seiring dengan bertambahnya jumlah aplikasi, roda integrasi juga perlu diaduk dengan pendekatan yang lebih baik. Misalnya, jika aplikasi tertentu untuk bisnis perlu diubah, format data keluaran atau masukan untuk semua aplikasi yang memiliki ketergantungan pada aplikasi Master tersebut akan terpengaruh.

Pendekatan seperti itu berfungsi sebagai rintangan terbesar untuk Integrasi yang mengharapkan arsitektur yang digabungkan erat. Di sinilah ESB berperan. Setiap aplikasi tidak perlu berkomunikasi langsung dengan aplikasi lain; sebaliknya, semua aplikasi berkomunikasi dengan ESB dan ESB menangani perutean informasi dan konversi format data internal.

Mengapa ESB?

Berikut adalah beberapa poin yang menjelaskan mengapa Enterprise Service Bus penting.

  • ESB bertujuan untuk menyederhanakan masalah integrasi dengan aplikasi yang kompatibel dengan varian.

  • Ini bertindak sebagai Middleware, yang berfungsi sebagai mediator dari semua aplikasi Anda dan memfasilitasi perutean pesan di antara mereka.

  • Alih-alih setiap aplikasi berinteraksi dengan setiap aplikasi lain secara langsung, setiap aplikasi sekarang hanya memiliki satu antarmuka ke ESB.

  • ESB bertanggung jawab untuk menerjemahkan pesan ke / dari format umum dan merutekannya ke tujuannya.

  • Penghematan besar dalam pendekatan ini datang sebagai keuntungan jika Anda harus mengganti aplikasi yang sudah ada. Alih-alih menulis sejumlah besar antarmuka baru, Anda sekarang hanya memiliki satu antarmuka yang perlu diperhatikan (antara aplikasi Anda dan ESB).

SOA & ESB?

SOA dan ESB biasanya digunakan secara bergantian, tetapi keduanya sama sekali berbeda.

SOA adalah pola desain yang memungkinkan aplikasi untuk mengekspos fungsionalitasnya sebagai layanan melalui jaringan melalui protokol komunikasi, sedangkan ESB adalah model yang memfasilitasi komunikasi antar sistem yang berbeda, tetapi ESB dapat digunakan sebagai tulang punggung saat mengimplementasikan SOA.

JBoss Fuse adalah solusi ESB open source oleh Redhat. Ini adalah solusi perusahaan berdasarkan proyek komunitas, Apache Servicemix.

Integrasi ke Fuse

JBoss Fuse adalah platform integrasi ringan dan fleksibel yang memungkinkan integrasi cepat aplikasi perusahaan.

Fuse awalnya dikembangkan oleh Progressive software Inc. yang diakuisisi oleh Redhat pada tahun 2012. JBoss Fuse 6.1.0.redhat-379 GA adalah versi stabil dari Fuse yang dapat diunduh dari situs resminya.

Arsitektur

Fuse menggabungkan berbagai teknologi menjadi satu produk.

Komponen

Apache CXF

Apache CXF adalah framework pengembangan layanan web open source yang juga mendukung pengembangan layanan web SOAP & Rest.

Apache Camel

Apache Camel adalah kerangka kerja integrasi berbasis EIP. Pola EIP atau Integrasi Perusahaan adalah solusi yang teridentifikasi untuk masalah yang berulang dalam Integrasi Perusahaan. Solusi integrasi lengkap dapat dicapai secara meteorik dengan kombinasi pola out of the box yang telah ditentukan sebelumnya.

Ini memungkinkan untuk menulis logika perutean dalam beberapa Bahasa Khusus Domain seperti Java, Spring DSL, dan Scala dll.

Apache AMQ

Apache AMQ adalah JMS yang menyediakan sistem pesan yang andal sesuai standar JMS. Ini tidak hanya mendukung spesifikasi JMS tetapi juga menyediakan beberapa fitur menarik dan berguna yang tidak termasuk dalam spesifikasi JMS.

Apache Karaf

Apache Karaf adalah wadah OSGi ringan yang bertindak sebagai runtime untuk artefak. Apache Karaf lebih dinamis dibandingkan dengan JVM. Ini memungkinkan untuk menginstal atau menghapus modul saat runtime. Semua artefak di Fuse dikerahkan di Karaf.

Kain

Fabric menyediakan cara mudah untuk mengelola penerapan artefak di lingkungan yang luas dan terdistribusi. Ini menyediakan manajemen terpusat untuk semua beberapa contoh sekering.

Memasang Fuse

Menginstal Fuse cukup sederhana. Seperti produk JBoss lainnya, Fuse hadir sebagai file zip yang dapat diekstrak dan setelah beberapa perubahan konfigurasi kecil, Fuse dapat langsung dijalankan.

Memasang Sekring adalah proses empat langkah -

Unduh

Unduh Fuse 6.1.0 GA dari tautan berikut. http://www.jboss.org/

Buka zip

Seperti semua produk JBoss lainnya, Fuse juga merupakan ritsleting platform independen.

Buka zip file yang diunduh ke direktori tujuan yang Anda inginkan sebagai direktori instalasi Fuse. Pilih direktori ini dengan bijak karena ini harus tetap sama selama masa pakai instance Fuse.

Note - Meskipun Fuse membuka ritsleting dan mulai seperti produk JBoss lainnya, tidak disarankan untuk memindahkan instalasi Fuse dari satu lokasi ke lokasi lain setelah instalasi selesai.

Konfigurasi

Setelah Anda mengekstrak Fuse, Anda akan menemukan direktori berikut di dalam Direktori yang diekstrak -

  • bin
  • etc
  • deploy
  • lib
  • licenses
  • extras
  • quickstarts

Dari situ kita hanya akan menggunakan dua direktori bin & etc.

Sebenarnya setelah mengekstraksi Fuse, kita dapat memulai sekring secara langsung, tetapi ini akan memulai Fuse dengan semua konfigurasi default yang tidak disarankan untuk lingkungan produksi. Sangat disarankan untuk melakukan perubahan berikut sebelum memulai Fuse.

Tetapkan variabel Lingkungan

  • Tetapkan variabel Lingkungan berikut - JAVA_HOME

  • Variabel harus mengarah ke direktori instalasi java - M2_HOME

  • Variabel harus mengarah ke direktori instalasi Maven - PATH

  • Setel variabel jalur untuk menyertakan file executable Java & Maven.

Windows

Pada windows, pengaturan dapat dilakukan dengan mengikuti instruksi yang diberikan di bawah ini -

Mulai → Komputer Saya → Klik Kanan → Properti → Pengaturan Sistem Lanjutan → Variabel lingkungan.

UNIX & Klon

Untuk setiap pengguna, ada profil bash di *nixsistem operasi. Kita dapat menambah atau mengedit variabel sistem yang ada dengan mengubah file ini.

$ vi ~/.bash_proflle

Note- Setiap perubahan dalam file ini bersifat permanen. Sangat disarankan untuk membuat cadangan dari file yang ada sebelum mengubah aslinya.

Konfigurasi Dasar

Kita akan membahas tentang konfigurasi dasar JBoss Fuse dan untuk itu kita harus mulai dengan perintah berikut Edit $FUSE_INSTALLATION_DIR/etc/

  • Di user.properties

    • #admin=admin,admin

    • Ini perlu diubah sesuai dengan admin pertama dengan nama pengguna yang kita inginkan, admin kedua dengan kata sandi, yang ketiga mungkin tetap seperti itu karena menunjukkan peran dan jangan lupa untuk menghapus #

    • Misalnya - FuseAdmin = FusePAss, admin

    • Di System.properties

      • karafName = root

        • Ini menunjukkan nama yang ingin Anda berikan kepada Karaf instance.

        • Kita bisa menamainya apapun yang kita mau seperti Cont1.

        • Pastikan nama yang Anda berikan adalah nama yang unik dan belum digunakan oleh Fuse lainnya.

    • Di org.ops4j.pax.web.cfg

      • Org.osgi.service.http.port = 8181

      • Properti ini menunjukkan port yang akan digunakan untuk mengakses antarmuka berbasis browser HAWTIO yang disediakan oleh Fuse

      • HAWTIO adalah antarmuka browser bawaan untuk Fuse yang tersedia mulai 6.0 dan seterusnya

    • Di org.ops4j.pax.url.mvn.cfg

      • org.ops4j.pax.url.mvn.localRepository = D: / repositori

      • Properti ini menunjukkan jalur ke localRepository Maven kita dari mana Fuse akan menginstal artefaknya.

      • org.ops4j.pax.url.mvn.settings = D: /Maven/conf/settings.xml

      • Properti ini menunjukkan settings.xml yang harus digunakan Fuse untuk mendapatkan artefak dari Maven.

    Mengonfigurasi Maven

    Maven adalah prasyarat untuk memasang Fuse. Jika Anda tidak tahu apa itu maven, silakan lihathttp://www.tutorialspoint.com/maven/

    Maven adalah alat yang digunakan untuk membangun artefak Fuse. Fuse pencarian pertama di repositori lokal Maven untuk artefak ketika kita mengeluarkan perintah untuk menginstal artefak. Jadi, kita harus memberi tahu Fuse di mana Maven diinstal dan jalur repositori lokal Maven.

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

    Perbarui dua properti berikut -

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

    Note - Tolong ganti $local_repo dengan jalur sebenarnya dari repositori lokal Anda yang disebutkan di Mavens settings.xml.

    Lari

    Setelah melakukan perubahan konfigurasi dasar, sekarang kita dapat memulai Fuse. Semua file biner untuk bekerja dengan Fuse berada di$FUSE_INSTALLATION_DIR.

    Ada dua cara untuk memulai Fuse -

    • Menggunakan ./fuse

      • Ini akan memungkinkan Anda untuk melihat semua kemajuan dan log di jendela yang sama tempat Anda memulai Fuse.

      • Ini akan memberi Anda konsol Karaf di terminal yang sama seperti yang ditunjukkan di bawah ini.

    Note- Ini akan memulai sekering dalam mode konsol yang berarti proses sekering juga akan dihentikan saat pengguna keluar dari sesi atau menutup Terminal yang tidak diinginkan dalam skenario produksi atau pengembangan. Skrip ini harus digunakan hanya untuk debugging Fuse.

    • Menggunakan ./start

      • Ini tidak akan menampilkan log apa pun di layar bahkan tidak kemajuannya tetapi ini akan memulai Fuse di latar belakang dan layanan Fuse tidak akan dihentikan saat pengguna keluar dari sesi atau menutup terminal.

      • Dalam Penerapan dunia nyata, jenis perilaku ini diinginkan. Sekring harus berjalan di latar belakang meskipun kita menutup terminal.

      • Jika Anda ingin menghubungkan ke Fuse yang berjalan di latar belakang, Anda dapat menggunakan client skrip yang terletak di folder yang sama.

      • Anda harus mendapatkan tampilan seperti yang ditunjukkan pada tangkapan layar berikut.

      • Keluar dari skrip klien tidak akan menghentikan layanan Fuse. Ini hanya akan menutup konsol Fuse.

    HAWTIO

    Fuse juga menyediakan akses GUI lengkap menggunakan FMC (Fuse management console). Anda dapat menemukan GUI di bawah URLhttp://localhost:8181.

    Semua yang kami lakukan dengan menjalankan perintah juga dapat dilakukan dengan mengakses GUI berbasis browser ini. Ini menjadi sangat membantu ketika kita memiliki lebih dari satu wadah dan kita menjalankannya di lingkungan Fabric.

    Pada bab ini, kita akan membahas tentang Apache Karaf dan mengapa disebut sebagai Container OSGi yang ringan beserta manfaat dan fitur penting lainnya.

    Masalah JVM

    JVM atau Mesin virtual Java tidak bertindak sebagai mesin virtual yang sebenarnya. Mesin yang memungkinkan Anda menghentikan, memulai, atau memulai ulang komponen yang berjalan di dalamnya dengan cepat. Terkadang memungkinkan penerapan panas di tingkat kelas tetapi tidak ada cara Anda dapat menerapkan atau membatalkan penerapan komponen aplikasi Anda di mesin virtual tanpa memulai ulang.

    Untuk mengatasi masalah ini dan memungkinkan modularitas dalam aplikasi Java, Fuse menggunakan runtime berbasis OSGi yang dikenal sebagai Apache Karaf.

    OSGi

    Teknologi OSGi adalah sekumpulan spesifikasi yang mendefinisikan sistem komponen dinamis untuk java. Spesifikasi ini memungkinkan model pengembangan di mana aplikasi (secara dinamis) terdiri dari banyak komponen berbeda (dapat digunakan kembali).

    Manfaat OSGi

    • Reduced Complexity - Aplikasi dibangun sebagai komponen kolaborasi yang menyembunyikan detail implementasinya satu sama lain sehingga mengurangi kompleksitas.

    • Reusability - Banyak komponen yang dapat memanfaatkan komponen yang sama yang digunakan dalam wadah.

    • Deployment - OSGi menyediakan dukungan untuk memulai, menghentikan, dan memperbarui komponen dengan cepat dengan API manajemen siklus hidupnya tanpa memulai ulang kontainer.

    Bundel Vs Fitur

    Berikut adalah perbandingan antara Bundel dan Fitur.

    bundel

    Paket setara dengan OSGi, apa toples untuk JVM. Paket adalah artefak yang dapat diterapkan dalam penampung OSGi. Bundel adalah komponen yang bekerja bersama atau sendiri-sendiri untuk membentuk suatu aplikasi.

    Paket ini dapat dipasang, dicopot, diperbarui, dimulai atau dihentikan saat runtime tanpa memulai ulang penampung.

    fitur

    Fitur adalah cara untuk menerapkan beberapa bundel bersama-sama. Terkadang lebih masuk akal untuk menerapkan bundel dalam grup. Fitur memungkinkan kami untuk menerapkan sekelompok bundel hanya dengan satu perintah.

    Mengapa Container lain?

    Apache Karaf adalah runtime berbasis OSGi, di situlah bundel Aplikasi kami berjalan. Fuse menggunakan Apache Karaf sebagai runtime-nya yang menjalankan bundel dan berkolaborasi untuk menyediakan fungsionalitas bisnis.

    Karaf dibangun di atas Felix dan equinox yang merupakan OSGi Frameworks.

    Arsitektur Karaf

    Apache Karaf menambahkan fungsi tambahan berikut ke runtime OSGi dasar.

    Penerapan Panas

    Karaf mendukung penyebaran panas. Ini berisi direktori penyebaran panas. Apa pun yang ditempatkan di direktori ini secara otomatis disebarkan dan dipasang di Karaf sebagai bundel.

    Logging

    Karaf menyediakan logging terpusat dengan menghasilkan log untuk semua bundel di $Fuse_home/data/log. Kita dapat mengedit konfigurasi logger diorg.ops4j.pax.logging.cfg di $Fuse_home/etc directory.

    Konsol Admin

    Karaf menyediakan konsol Admin yang canggih dan jelas untuk berinteraksi dengan sekering yang sedang berjalan. Ini juga menyediakan seperangkat perintah pra-instal yang dapat digunakan untuk mengelola dan memantau komponen (Bundle) saat runtime. Konsol ini dapat diperluas sehingga memungkinkan kita untuk menambahkan perintah baru ke konsol dengan menambahkan bundel baru ke konsol.

    Akses SSH

    Karaf mengizinkan akses jarak jauh ke konsol Admin ini dengan SSH. Siapapun dengan kredensial yang valid dapat terhubung ke konsol admin karaf melalui terminal SSH.

    Dalam bab ini, kita akan membahas apa itu Apache Camel dan bagaimana cara efektif merutekan data antar titik akhir, bersama dengan beberapa contoh.

    Apa Apache Camel?

    Apache Camel adalah kerangka kerja integrasi sumber terbuka yang dimulai pada awal 2007.

    Ini adalah pendekatan berbasis EIP (Enterprise Integration Pattern) yang menyediakan beberapa implementasi pola out of the box yang dapat digunakan untuk memecahkan masalah integrasi perusahaan. EIP hanyalah solusi yang terbukti untuk masalah yang terdokumentasi dengan baik dan berulang dalam integrasi perusahaan.

    Camel juga dikenal sebagai mesin perutean dan mediasi karena secara efektif merutekan data antar titik akhir, sambil mengambil beban berat seperti transformasi format data, konektivitas titik akhir, dan banyak lagi.

    Contoh Dasar

    Prasyarat untuk menggunakan Apache Camel adalah -

    • Java
    • Maven
    • Redhat JBoss Fuse 6.1-GA-379

    Buat kerangka dasar Aplikasi

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

    Ini harus menghasilkan struktur direktori berikut.

    Ini adalah kerangka dasar dari aplikasi Unta kami yang sedang dibuat.

    Edit unta-konteks.xml

    Edit camel-first-app → src → main → resources → META-INF\spring\camel-context.xml agar cocok seperti di bawah ini

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

    Edit pom.xml

    Tambahkan kode berikut di dalam <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>

    Ubah jenis kemasan dari jar → bundle.

    <packaging>bundle</packaging>

    Bangun proyek menggunakan perintah berikut -

    mvn clean install

    Pasang Proyek ke Fuse

    Mulai Fuse menggunakan Fuse.bat/start.bat. Jika Anda memulai Fuse menggunakanstart.bat, gunakan client.batuntuk terhubung ke Fuse. Anda harus mendapatkan UI seperti yang ditunjukkan pada tangkapan layar berikut.

    Ini adalah CLI untuk mengakses perintah Karaf dan Fuse.

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

    Uji apakah Proyek Anda sedang Berjalan

    Sekarang aplikasi Anda harus diinstal di Fuse. Salin direktori data di dalamnyacamel-first-app dan letakkan di D:/src/ dan harus menyalin pesan yang memiliki city = London D:/target/merssages/uk.

    Tempatkan file input di 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

    Di D: / target / messages / uk

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

    Di D: / target / messages / others

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

    Dalam bab ini, kita akan memahami berbagai Konsep Unta. Mari kita mulai dengan mengambil contoh dasar untuk memahami konsep inti sebagai permulaan.

    CamelContext

    Setiap aplikasi unta memiliki setidaknya satu CamelContext. Ini adalah tempat kami menambahkan rute unta. Ini mirip denganApplicationContext Musim Semi.

    Konteks unta dapat diartikan sebagai wadah yang menyatukan semua hal. Satu konteks unta dapat memiliki banyak rute di dalamnya.

    Rute

    CamelContext mungkin berisi satu atau lebih rute. Rute adalah logika integrasi yang menentukan bagaimana data akan mengalir dalam konteks unta dari satu titik akhir ke titik lainnya.

    Titik akhir

    Endpoint adalah akhir saluran di mana sistem dapat mengirim atau menerima pesan. Inilah yang kita sebut sebagai tujuan atau sumber dalam bahasa komunikasi.

    Komponen

    Komponen adalah titik perluasan di Camel. Komponen dapat menjadi antarmuka ke teknologi, format data, transformator, dll. Mereka juga dapat bertindak sebagai pabrik untuk titik akhir.

    EIP

    EIP adalah singkatan dari Enterprise Integration Pattern. Ini diidentifikasi dan solusi terkenal untuk masalah yang berulang. Camel mendukung sebagian besar Pola Integrasi Perusahaan.

    Router Berbasis Konten

    Pola CBR memungkinkan kita untuk merutekan data sesuai dengan konten file input.

    Pola ini digunakan ketika kita harus merutekan nilai tergantung pada isi dari input.

    Contoh berikut akan membaca data dari D:/data/inputdirektori. Setelah membaca, itu akan memeriksa tag nilai di dalam tag data. Jika tag nilai berisivalue1, itu akan dikirim ke D:/value1, Jika berisi value2, itu akan dikirim ke D:/value2 dan jika tidak satupun dari keduanya, maka akan dikirimkan ke orang lain.

    <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: / nilai1 /

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

    D: / nilai2 /

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

    Pembelah

    Pola pemisah digunakan untuk membagi data masukan menjadi beberapa bagian yang lebih kecil.

    Pola ini digunakan sebagian besar waktu dengan input data yang sangat besar yang perlu dipecah menjadi beberapa bagian, sehingga dapat diproses. Ini memecah input menjadi fragmen yang lebih kecil berdasarkan string token input.

    <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

    Jika Anda memeriksa AMQ, Anda akan menemukan 3 pesan yang diposting.

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

    Daftar Penerima

    Pola daftar penerima digunakan ketika daftar penerima perlu diambil dari badan pesan itu sendiri.

    Dalam contoh berikut, pesan akan dikirim ke semua penerima yang terdaftar di tag pelanggan sebagai daftar string yang dipisahkan koma.

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

    EIP lainnya

    Camel memberikan dukungan kepada hampir semua EIP yang diidentifikasi. Beberapa EIP yang umum digunakan adalah seperti yang disebutkan di bawah ini.

    • Log - Untuk mencatat pesan lengkap atau sebagian darinya

    • Message Filter - Memfilter konten pesan

    • Re-Sequencer - Untuk mendapatkan semua token secara berurutan

    • Wiretap - Untuk memeriksa pesan perjalanan

    Daftar lengkap EIP dan penggunaannya dapat ditemukan di dokumentasi resmi Camel http://camel.apache.org/eip.html

    Penanganan Pengecualian pada Unta

    Using Error Handler - Ini adalah cara termudah untuk menangani pengecualian pada unta.

    Untuk menggunakan ini, kita harus mengkonfigurasi kacang kelas penanganan Kesalahan dan menyediakannya sebagai referensi CamelContext errorHandlerRef atribut.

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

    Menggunakan Try Catch Akhirnya

    Unta juga mendukung gaya Java Try Catch Finally block untuk penanganan kesalahan.

    Sama seperti Java, ia memiliki tiga blok berikut -

    • doTry blok berisi kode yang dapat menghasilkan pengecualian.

    • doCatch blok berisi kode yang perlu dijalankan jika ada pengecualian.

    • doFinallyblok memiliki kode yang harus dijalankan terlepas dari pengecualian. Itu akan selalu dijalankan tidak peduli apakah pengecualian dimunculkan atau tidak.

    Note- Mock adalah komponen pengujian dan tidak direkomendasikan untuk tujuan lain. Ini adalah komponen dalam unta yang digunakan untuk pengujian seperti komponen jMOck dalam pengembangan yang digerakkan oleh Uji.

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

    Dalam contoh di atas, kita bisa memberikan daftar pengecualian yang perlu ditangani oleh blok catch.

    Menerapkan Bundel di Fuse

    Mulai Fuse menggunakan Fuse.bat/start.bat.

    Jika Anda memulai Fuse menggunakan start.bat, gunakan client.bat untuk menyambung ke Fuse. Anda harus mendapatkan UI seperti yang ditunjukkan pada tangkapan layar berikut.

    Ini adalah CLI untuk mengakses perintah Karaf dan Fuse.

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

    Dalam bab ini, mari kita bahas tentang apa itu Apache CXF dan bagaimana hal itu dapat membantu dalam mengembangkan SOAP dan Layanan Web Lainnya.

    Apa itu Apache CXF?

    Apache CXF adalah kerangka pengembangan layanan web yang dapat digunakan untuk mengembangkan layanan web SOAP dan Rest. CXF sepenuhnya sesuai denganJAX-RS and JAX-Ws standar.

    Ini adalah kerangka pengembangan layanan web yang paling banyak digunakan sekarang. CXF telah belajar dan meningkatkan Axis2 yang sekarang secara bertahap digantikan oleh CXF.

    CXF vs Sumbu2

    CXF Sumbu2
    Perbaikan

    CXF adalah kerangka kerja yang paling banyak digunakan sampai sekarang.

    Ini memiliki banyak peningkatan dibandingkan Axis2

    Axis2 secara bertahap digantikan oleh CXf.

    Ini membutuhkan lebih banyak kode dibandingkan dengan CXF
    Kode diperlukan

    CXF membutuhkan lebih sedikit kode dibandingkan dengan Axis2

    Axis2 membutuhkan lebih banyak kode secara komparatif
    Kepatuhan Standar

    CSF sepenuhnya sesuai dengan JAX-RS dan JAX-WS

    Axis2 tidak sepenuhnya sesuai dengan JAX-RS dan JAX-WS
    Kompatibel dengan Spring

    Iya

    Tidak
    Pemisahan ujung depan

    Pemisahan bersih front-end dari kode JAX-WS

    Tidak ada pemisahan yang bersih

    SABUN MANDI

    SOAP adalah singkatan dari Simple Object Access Protocol. Ini adalah protokol untuk bertukar informasi terstruktur melalui layanan web antara dua sistem. Ini sebagian besar bergantung pada XML untuk menyusun data dan menggunakan HTTP atau SMTP untuk negosiasi dan transmisi pesan.

    Ada dua pendekatan untuk mengembangkan layanan web SOAP -

    • Code first - Dalam pendekatan ini, WSDL dihasilkan dari kode.

    • Contract first - Dalam kontrak pertama, kode dihasilkan dari WSDL.

    Pengembangan SOAP Menggunakan CXF

    Konfigurasi Maven

    Tambahkan profil berikut ke settings.xml Anda di 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>

    Buat Kerangka

    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

    Buka URL http://localhost:8181/cxf

    Layanan web harus terdaftar sebagai berikut.

    Testing Web-Service

    mvn -Pclient

    INFO - Membuat Layanan {http://ws.totorials.com/} PersonService dari kelas 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] ------------------------------------------------------------------------

    Pertama-tama, REST adalah singkatan dari Representational State Transfer. Ini adalah cara mengembangkan layanan web berdasarkan protokol server-klien tanpa status, dapat disimpan dalam cache, yang dalam banyak kasus merupakan HTTP.

    Layanan web REST menggunakan permintaan HTTP untuk memposting, mendapatkan, menghapus data dari jaringan.

    Pengembangan REST menggunakan CXF

    Buat proyek mulai cepat Maven sederhana

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

    Tambahkan dependensi

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

    Tambahkan Instruksi Bangun

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

    Tambahkan Repositori Plugin 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>

    Tambahkan Repositori

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

    Buat Kelas Layanan

    Buat kelas UserService.java di bawah 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;
   }
}

    Buat Blueprint.xml

    Buat cetak biru.xml di bawah / 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>

    Instal layanan Istirahat di Fuse

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

    Periksa apakah Bundle memiliki Layanan Web Terdaftar

    Buka URL http://localhost:8181/cxf

    Uji Layanan Web

    Buka URL http://localhost:8181/cxf/users12/UserService_1/get_data

    Dalam bab ini, kita akan mengetahui tentang ActiveMQ dan bagaimana ia bertindak sebagai perantara pesan untuk memungkinkan aplikasi berkomunikasi satu sama lain.

    Apakah AMQ itu?

    ActiveMQ adalah broker pesan open source yang ditulis di Java. Ini sepenuhnya sesuai dengan standar JMS 1.1.

    JMS adalah spesifikasi yang memungkinkan pengembangan sistem berbasis pesan. ActiveMQ bertindak sebagai perantara pesan yang berada di antara aplikasi dan memungkinkan mereka untuk berkomunikasi secara asynchronous dan dapat diandalkan.

    Jenis Pesan

    Ada dua jenis opsi perpesanan yang dijelaskan di bawah untuk pemahaman yang lebih baik.

    Poin ke poin

    Dalam jenis komunikasi ini, broker mengirimkan pesan hanya ke satu konsumen, sedangkan konsumen lain akan menunggu sampai mereka mendapatkan pesan dari broker. Tidak ada konsumen yang akan mendapatkan pesan yang sama.

    Jika tidak ada konsumen, Broker akan menyimpan pesan-pesan tersebut sampai mendapatkan konsumen. Jenis komunikasi ini juga disebut sebagaiQueue based communicationdi mana Produser mengirim pesan ke antrian dan hanya satu konsumen yang mendapat satu pesan dari antrian. Jika ada lebih dari satu konsumen, mereka mungkin mendapatkan pesan berikutnya tetapi mereka tidak akan mendapatkan pesan yang sama dengan konsumen lainnya.

    Publikasikan / Berlangganan

    Dalam jenis komunikasi ini, Pialang mengirimkan salinan pesan yang sama ke semua konsumen aktif. Jenis komunikasi ini juga dikenal sebagaiTopic based communicationdimana broker mengirimkan pesan yang sama kepada semua konsumen aktif yang telah berlangganan Topik tertentu. Model ini mendukung komunikasi satu arah di mana tidak ada verifikasi pesan yang ditransmisikan.

    Membuat Antrian dan Topik

    Fuse dibundel dengan ActiveMQ. Kita dapat mengakses ActiveMQ menggunakan konsol FMC (antarmuka berbasis browser untuk bekerja dengan AMQ).

    Masuk ke FMC menggunakan localhost:8181 dan pilih ActiveMQ tab.

    • Klik + Buat
    • Masukkan Nama Antrian / Topik
    • Pilih Queue / Topic dari radio button
    • Klik Buat Antrian / Buat topik

    Sekarang Anda dapat melihat file TestQ dibuat di bawah root → Queue →

    Untuk memeriksa topik yang dibuat ikuti root → Topik.

    Menjelajah / Menghapus Isi Antrian

    • Masuk ke FMC menggunakan localhost:8181

    • Pilih tab ActiveMQ

    • Root → Queue → TestQ <pilih antrian yang ingin Anda telusuri> → Browse

    • Untuk memeriksa isi pesan ini, klik pada pesan itu.

    • Anda dapat menghapus pesan tertentu dengan mengklik tombol Hapus yang ditampilkan di sudut kanan atas

    Dalam bab ini, kita akan mempelajari dasar-dasar bagaimana ActiveMQ bekerja dengan Camel.

    Konfigurasi ke Komponen ActiveMQ

    Sebelum kita dapat menggunakan antrian atau topik ActiveMQ dalam kode kita, kita harus mengkonfigurasi ActiveMQComponent. Konfigurasi minimal ActiveMQComponent dapat dilakukan seperti yang ditunjukkan pada program berikut -

    <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 - Menentukan host dan port untuk AMQ Broker.

    • username - Menentukan nama pengguna yang akan digunakan untuk menghubungkan ke AMQ Broker.

    • password - menentukan kata sandi untuk menghubungkan ke AMQ Broker.

    Menghubungkan ke Antrian

    Sekarang kita telah mengkonfigurasi ActiveMQComponent, kita dapat menggunakannya di CamelContext sebagai titik akhir.

    Kami akan menggunakan titik akhir AMQ dalam format berikut -

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

    Menulis Pesan ke 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">

    Setelah menerapkan bundel ini dalam wadah Fuse, Anda seharusnya dapat melihat pesan yang diposting ke AMQ yang ditempatkan sebagai file di D:/src/data.

    Input

    D: /src/data/input.txt

    Test me

    Output

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

    Setelah menerapkan bundel ini, Anda akan melihat file sedang dibuat di D: / src dan pesan dikonsumsi. Juga Konsumen harus ditunjukkan untuk Antrian itu.

    Output

    D: / src

    Test me

    Menulis ke Topik

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

Membaca dari Topik

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

Apa itu Fabric?

Fabric menyediakan kemampuan manajemen dan orkestrasi untuk beberapa instans Fuse. Fabric memungkinkan kita untuk mengontrol semua instance Fuse yang terhubung dengannya dari satu titik. Wadah Fuse normal dapat diubah menjadi Fabric. Fabric memiliki registry fabric di dalamnya yang berfungsi sebagai penyimpanan data yang berisi semua informasi tentang container, yang dikelolanya.

Mengapa Fabric?

Kain memiliki kemampuan khusus berikut yang menjadikannya kandidat ideal untuk digunakan di lingkungan terdistribusi.

  • Memantau status semua wadah di kain.
  • Memulai dan menghentikan kontainer jarak jauh.
  • Penyediaan remote container untuk menjalankan aplikasi tertentu.
  • Mengupgrade aplikasi dan meluncurkan tambalan di sistem langsung.
  • Memulai dan menyediakan kontainer baru dengan cepat misalnya untuk mengatasi beban yang meningkat pada sistem.

Penyiapan Kain

Membuat Kain

Wadah Sekring Normal dapat diubah menjadi Fabric dengan menggunakan perintah berikut

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

Menghubungkan wadah lain ke Fabric -

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

Note - Harap ganti <fabric_host> dengan nama host sebenarnya tempat fabric berjalan.

Saat Anda login ke Fuse Management Console dari browser Anda menggunakan localhost:8181, Anda seharusnya dapat melihat dua wadah seperti yang ditunjukkan pada gambar layar berikut. Wadah Fabric ditandai dengan simbol awan kecil di depannya.

Profil

Profil berisi informasi berikut -

  • Bundel untuk dipasang
  • Fitur yang akan diinstal
  • Konfigurasi yang akan diterapkan

Profil menyediakan cara di lingkungan fabric untuk menginstal kumpulan bundel, fitur, dan konfigurasi yang sama di beberapa server.

Jika profil yang sama diterapkan ke beberapa penampung dan kami melakukan perubahan pada profil itu dari penampung apa pun, perubahan serupa akan diterapkan secara otomatis ke penampung yang tersisa tempat ia diterapkan.

Membuat Profil

  • Masuk ke FMC localhost:8181

  • Runtime → Kelola

  • Di sisi kiri di bawah menu Profil klik +

Masukkan nama yang ingin Anda berikan ke profil dan klik buat.

Setelah ini, profil harus dibuat.

Menerapkan Profil ke Penampung

Runtime → Containers → root (pilih container yang Anda inginkan)

Klik Addyang akan mengarah ke kotak pop-up. Cari profil yang Anda inginkan dan kemudian klik lagiAdd.

Profil harus ditampilkan dalam daftar seperti yang ditunjukkan pada gambar layar berikut.

Menerapkan Bundel

Untuk menerapkan bundel, gunakan jalur berikut -

Runtime → Containers → root (pilih container yang Anda inginkan) → First_profile (pilih profil)

Klik tab Bundel. Atur jalur bundel dalam format berikut dan kemudian klik+.

mvn:group.id/artifact.id/version

Sebagai contoh: mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

Sebuah bundel akan ditambahkan ke profil dan akan diterapkan pada semua penampung tempat profil ditetapkan.

Membatalkan penerapan Bundle

Untuk membatalkan penerapan bundel, gunakan jalur berikut -

Runtime → Containers → root (pilih container yang Anda inginkan) → First_profile (pilih profil)

Klik tab Bundel dan cari bundel yang ingin Anda hapus lalu klik X. Bundel akan dihapus dari semua penampung tempat profil diterapkan.

Sebuah Kontainer Anak menyediakan cara termudah untuk mengelola beban yang meningkat. Ketika sistem mengalami beban mendadak dalam lalu lintas dan satu kontainer tidak dapat mengatasi beban tersebut, kita dapat dengan mudah membuat satu set kontainer anak dan mendistribusikan beban di antara mereka, daripada membuat kontainer baru yang lengkap.

Membuat Penampung Anak

Masuk ke FMC menggunakan localhost:8181

Sekarang, ikuti jalur: Runtime → container → + Create (tombol di sisi kanan)

Masukkan detail seperti nama anak, penampung induk, Jumlah instance, dll.

Klik Create And Start Container

Mengelola Penampung Anak

Wadah Anak hanya berfungsi sebagai wadah normal.

Menghentikan Kontainer Anak

Untuk menghentikan container turunan, ikuti jalur: Runtime → Container → Child1

Klik Berhenti untuk menghentikan Penampung Anak.

Memulai Penampung Anak

Untuk memulai container anak, ikuti jalur: Runtime → Container → Child1

Klik Mulai untuk memulai penampung anak.

Dalam bab ini, kita akan membahas beberapa masalah umum yang mungkin Anda temui saat bekerja dengan Fuse. Kami juga akan membahas bagaimana Anda bisa mengatasi masalah ini.

Perubahan Kode tidak Tercermin

Hubungkan ke instance Fuse menggunakan skrip klien. Cari bundel yang Anda hadapi masalah, menggunakan perintah berikut.

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 - Bundel ID untuk bundel dari keluaran perintah di atas dan gunakan perintah di bawah ini.

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

Bundel tidak Sedang Diunduh

Itu mungkin terjadi karena dua alasan berikut -

  • Repositori Maven tidak ditentukan
  • Paket tidak ada dalam repositori

Repositori Maven tidak Ditentukan

Maven adalah alat yang digunakan untuk membangun artefak Fuse. Fuse pencarian pertama di repositori lokal Maven untuk artefak, ketika kita mengeluarkan perintah untuk menginstal artefak. Jadi kita harus memberi tahu Fuse di mana Maven diinstal dan jalur repositori lokal Mavens.

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

Perbarui dua properti berikut -

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

Note - Silakan ubah $ local_repo dengan path sebenarnya dari repositori lokal Anda yang disebutkan di Mavens settings.xml

Bundel tidak Ada di Repositori

Jika pengaturan Maven ada tetapi masih jika Anda menghadapi masalah saat mengunduh bundel, pastikan bundelnya JAR ada di lokasi yang benar di Maven Repository.

Misalnya, jika bundel berikut menampilkan kesalahan saat mengunduh -

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

Kita harus memeriksa $ M2_REPO / com / tutorialpoint / app / camel-first-app / 1.0-SNAPSHOT jika JAR sebenarnya ada.

Note - $ M2_REPO perlu diganti dengan path sebenarnya dari repositori Maven yang telah dikonfigurasi Fuse untuk digunakan.

Tidak Mampu Masuk ke FMC (GUI berbasis browser)

Users not Created - Jika Anda mendapatkan UI berikut tetapi tidak dapat masuk dengan pesan yang mengatakan "Gagal masuk, Terlarang".

Periksa apakah Anda telah menambahkan pengguna di $FUSE_INSTALLATION_HOME/etc/users.properties

Format yang benar untuk menambahkan pengguna adalah -

Username = Password,Role

Port HAWTIO berbeda

Jika Anda bahkan tidak bisa mendapatkan UI di localhost: 8181 di browser, periksa apakah Anda telah menyebutkan porta yang benar di URL.

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

Edit properti berikut di file untuk menggunakan port yang ingin Anda akses.

org.osgi.service.http.port=8181

AMQ Broker tidak bekerja

Pastikan port 61616 terbuka dan saat ini tidak digunakan oleh port lain. Jika Anda ingin mengubah port 61616 default untuk hal yang sama, Anda dapat mengeditnya di$FUSE_INSTALLATION_HOME/etc/System.properties

activemq.port = 61616
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved