Membuat aplikasi Java Service Fabric Reliable Actors pertama Anda di Linux

• Java - Linux
• C# - Linux

Mulai cepat ini membantu Anda membuat aplikasi Azure Service Fabric Java pertama Anda di lingkungan pengembangan Linux hanya dalam beberapa menit. Setelah selesai, Anda akan memiliki aplikasi layanan tunggal Java sederhana yang berjalan di klaster pengembangan lokal.

Prasyarat

Sebelum Anda memulai, instal Service Fabric SDK, Service Fabric CLI, Yeoman, atur lingkungan pengembangan Java, dan siapkan klaster pengembangan di lingkungan pengembangan Linux Anda. Jika Anda menggunakan Mac OS X, Anda dapat Mengatur lingkungan pengembangan di Mac menggunakan Docker.

Instal juga Service Fabric CLI.

Menginstal dan mengatur generator untuk Java

Service Fabric menyediakan alat perancah yang membantu Anda membuat aplikasi Service Fabric dari terminal menggunakan generator templat Yeoman. Jika Yeoman belum diinstal, lihat Service Fabric memulai Linux untuk petunjuk tentang pengaturan Yeoman. Jalankan perintah berikut untuk menginstal generator templat Service Fabric Yeoman untuk Java.

npm install -g generator-azuresfjava

Konsep dasar

Untuk memulai dengan Reliable Service, Anda hanya perlu memahami beberapa konsep dasar:

• Layanan aktor. Reliable Actors dikemas dalam Reliable Service yang dapat digunakan dalam infrastruktur Service Fabric. Instans aktor diaktifkan dalam instans layanan bernama.

• Pendaftaran aktor. Seperti halnya Reliable Service, layanan Reliable Actor perlu didaftarkan ke runtime Service Fabric. Selain itu, tipe aktor perlu didaftarkan ke runtime Aktor.

• Antarmuka aktor. Antarmuka aktor digunakan untuk mendefinisikan antarmuka publik yang diketik dengan kuat dari seorang aktor. Dalam terminologi model Reliable Actor, antarmuka aktor mendefinisikan jenis pesan yang dapat dipahami dan diproses oleh aktor. Antarmuka aktor digunakan oleh aktor lain dan aplikasi klien untuk "mengirim" (secara asinkron) pesan kepada aktor. Reliable Actor dapat mengimplementasikan beberapa antarmuka.

• Kelas ActorProxy. Kelas ActorProxy digunakan oleh aplikasi klien untuk memanggil metode yang diekspos melalui antarmuka aktor. Kelas ActorProxy menyediakan dua fungsi penting:

  • Resolusi nama: Ia dapat menemukan aktor dalam klaster (menemukan node klaster tempatnya dihosting).
  • Penanganan kegagalan: Ini dapat mencoba kembali pemanggilan metode dan menyelesaikan ulang lokasi aktor setelah, misalnya, kegagalan yang mengharuskan aktor untuk dipindahkan ke node lain dalam klaster.

Aturan berikut yang berkaitan dengan antarmuka aktor layak disebutkan:

• Metode antarmuka aktor tidak dapat kelebihan beban.
• Metode antarmuka aktor tidak boleh memiliki parameter keluar, ref, atau opsional.
• Antarmuka generik tidak didukung.

Membuat aplikasi

Aplikasi Service Fabric berisi satu atau beberapa layanan, masing-masing dengan peran khusus dalam memberikan fungsionalitas aplikasi. Generator yang Anda instal di bagian terakhir, memudahkan Anda membuat layanan pertama dan menambahkan lebih banyak nanti. Anda juga dapat membuat, membangun, dan menyebarkan aplikasi Service Fabric Java menggunakan plugin untuk Eclipse. Lihat Membuat dan menggunakan aplikasi Java pertama Anda menggunakan Eclipse. Untuk mulai cepat ini, gunakan Yeoman untuk membuat aplikasi dengan satu layanan yang menyimpan dan mendapatkan nilai

1. Di terminal, ketik yo azuresfjava.
2. Beri nama aplikasi Anda.
3. Pilih jenis layanan pertama Anda dan beri nama. Untuk tutorial ini, pilih Reliable Actor Service. Untuk informasi selengkapnya tentang jenis layanan lainnya, lihat Gambaran umum model pemrograman Service Fabric.

Jika Anda menamai aplikasi "HelloWorldActorApplication" dan aktor "HelloWorldActor", perancah berikut dibuat:

HelloWorldActorApplication/
├── build.gradle
├── HelloWorldActor
│   ├── build.gradle
│   ├── settings.gradle
│   └── src
│       └── reliableactor
│           ├── HelloWorldActorHost.java
│           └── HelloWorldActorImpl.java
├── HelloWorldActorApplication
│   ├── ApplicationManifest.xml
│   └── HelloWorldActorPkg
│       ├── Code
│       │   ├── entryPoint.sh
│       │   └── _readme.txt
│       ├── Config
│       │   ├── _readme.txt
│       │   └── Settings.xml
│       ├── Data
│       │   └── _readme.txt
│       └── ServiceManifest.xml
├── HelloWorldActorInterface
│   ├── build.gradle
│   └── src
│       └── reliableactor
│           └── HelloWorldActor.java
├── HelloWorldActorTestClient
│   ├── build.gradle
│   ├── settings.gradle
│   ├── src
│   │   └── reliableactor
│   │       └── test
│   │           └── HelloWorldActorTestClient.java
│   └── testclient.sh
├── install.sh
├── settings.gradle
└── uninstall.sh

Blok penyusun dasar Reliable Actors

Konsep dasar yang dijelaskan sebelumnya diterjemahkan ke dalam blok bangunan dasar layanan Reliable Actor.

Antarmuka aktor

Antarmuka ini berisi definisi antarmuka untuk aktor. Antarmuka ini mendefinisikan kontrak aktor yang dibagikan oleh implementasi aktor dan klien yang memanggil aktor, sehingga biasanya masuk akal untuk mendefinisikannya di tempat yang terpisah dari implementasi aktor dan dapat dibagikan oleh beberapa layanan lain atau aplikasi

HelloWorldActorInterface/src/reliableactor/HelloWorldActor.java:

public interface HelloWorldActor extends Actor {
    @Readonly   
    CompletableFuture<Integer> getCountAsync();

    CompletableFuture<?> setCountAsync(int count);
}

Layanan aktor

Layanan ini berisi implementasi aktor dan kode pendaftaran aktor Anda. Kelas aktor mengimplementasikan antarmuka aktor. Di sinilah aktor Anda melakukan pekerjaannya.

HelloWorldActor/src/reliableactor/HelloWorldActorImpl:

@ActorServiceAttribute(name = "HelloWorldActorService")
@StatePersistenceAttribute(statePersistence = StatePersistence.Persisted)
public class HelloWorldActorImpl extends FabricActor implements HelloWorldActor {
    private Logger logger = Logger.getLogger(this.getClass().getName());

    public HelloWorldActorImpl(FabricActorService actorService, ActorId actorId){
        super(actorService, actorId);
    }

    @Override
    protected CompletableFuture<?> onActivateAsync() {
        logger.log(Level.INFO, "onActivateAsync");

        return this.stateManager().tryAddStateAsync("count", 0);
    }

    @Override
    public CompletableFuture<Integer> getCountAsync() {
        logger.log(Level.INFO, "Getting current count value");
        return this.stateManager().getStateAsync("count");
    }

    @Override
    public CompletableFuture<?> setCountAsync(int count) {
        logger.log(Level.INFO, "Setting current count value {0}", count);
        return this.stateManager().addOrUpdateStateAsync("count", count, (key, value) -> count > value ? count : value);
    }
}

Pendaftaran aktor

Layanan aktor harus terdaftar dengan jenis layanan dalam runtime Service Fabric. Agar Layanan Aktor dapat menjalankan instans aktor Anda, jenis aktor Anda juga harus terdaftar di Layanan Aktor. Metode pendaftaran ActorRuntime melakukan pekerjaan ini untuk aktor.

HelloWorldActor/src/reliableactor/HelloWorldActorHost:

public class HelloWorldActorHost {

private static final Logger logger = Logger.getLogger(HelloWorldActorHost.class.getName());

public static void main(String[] args) throws Exception {

        try {

            ActorRuntime.registerActorAsync(HelloWorldActorImpl.class, (context, actorType) -> new FabricActorService(context, actorType, (a,b)-> new HelloWorldActorImpl(a,b)), Duration.ofSeconds(10));
            Thread.sleep(Long.MAX_VALUE);
        } catch (Exception e) {
            logger.log(Level.SEVERE, "Exception occurred", e);
            throw e;
        }
    }
}

Membangun aplikasi

Templat Service Fabric Yeoman menyertakan skrip build untuk Gradle, yang dapat Anda gunakan untuk membangun aplikasi dari terminal. Ketergantungan Service Fabric Java diambil dari Maven. Untuk membuat dan mengerjakan aplikasi Service Fabric Java, Anda perlu memastikan bahwa Anda telah menginstal JDK dan Gradle. Jika tidak diinstal, lihat Service Fabric yang memulai Linux untuk petunjuk tentang menginstal JDK dan Gradle.

Untuk membangun dan mengemas aplikasi, jalankan tindakan berikut:

cd HelloWorldActorApplication
gradle

Menyebarkan aplikasi

Setelah aplikasi dibangun, Anda dapat menyebarkannya ke klaster lokal.

1. Sambungkan ke klaster Service Fabric lokal (klaster harus disiapkan dan dijalankan).

   sfctl cluster select --endpoint http://localhost:19080
   

2. Jalankan skrip instal yang disediakan di templat untuk menyalin paket aplikasi ke penyimpanan klaster gambar, daftarkan jenis aplikasi, dan buat instans aplikasi.

   ./install.sh
   

Menyebarkan aplikasi yang dibangun sama dengan aplikasi Service Fabric lainnya. Lihat dokumentasi tentang mengelola aplikasi Service Fabric dengan Service Fabric CLI untuk petunjuk terperinci.

Parameter untuk perintah ini dapat ditemukan dalam manifes yang dihasilkan di dalam paket aplikasi.

Setelah aplikasi disebarkan, buka browser dan navigasi ke Service Fabric Explorer di http://localhost:19080/Explorer. Kemudian, perluas node Aplikasi dan perhatikan bahwa sekarang ada entri untuk jenis aplikasi Anda dan entri lain untuk instans pertama dari jenis itu.

Penting

Untuk menyebarkan aplikasi ke klaster Linux yang aman di Azure, Anda perlu mengonfigurasi sertifikat untuk memvalidasi aplikasi Anda dengan runtime Service Fabric. Melakukannya memungkinkan layanan Reliable Actors Anda untuk berkomunikasi dengan API runtime Service Fabric yang mendasarinya. Untuk mempelajari selengkapnya, lihat Mengonfigurasi aplikasi Reliable Services untuk dijalankan di klaster Linux.

Memulai klien uji dan melakukan failover

Aktor tidak melakukan apa pun sendiri, mereka memerlukan layanan atau klien lain untuk mengirimi mereka pesan. Templat aktor mencakup skrip uji sederhana yang dapat Anda gunakan untuk berinteraksi dengan layanan aktor.

Catatan

Klien pengujian menggunakan kelas ActorProxy untuk berkomunikasi dengan aktor, yang harus berjalan dalam klaster yang sama dengan layanan aktor atau berbagi ruang alamat IP yang sama. Anda dapat menjalankan klien uji di komputer yang sama sebagai klaster pengembangan lokal. Namun, untuk berkomunikasi dengan aktor di klaster jarak jauh, Anda harus menerapkan gateway pada klaster yang menangani komunikasi eksternal dengan para aktor.

1. Jalankan skrip menggunakan utilitas jam tangan untuk melihat output layanan aktor. Skrip pengujian memanggil metode setCountAsync() pada aktor untuk menambah penghitung, memanggil metode getCountAsync() pada aktor untuk mendapatkan nilai penghitung baru, dan menampilkan nilai itu ke konsol.

   Dalam kasus MAC OS X, Anda perlu menyalin folder HelloWorldTestClient ke beberapa lokasi di dalam kontainer dengan menjalankan perintah tambahan berikut.

    docker cp HelloWorldTestClient [first-four-digits-of-container-ID]:/home
    docker exec -it [first-four-digits-of-container-ID] /bin/bash
    cd /home
   

   cd HelloWorldActorTestClient
   watch -n 1 ./testclient.sh
   

2. Di Service Fabric Explorer, temukan node yang menghosting replika utama untuk layanan aktor. Cuplikan layar di bawah ini adalah node 3. Replika layanan utama menangani operasi baca dan tulis. Perubahan status layanan kemudian direplikasi ke replika sekunder, berjalan pada node 0 dan 1 pada cuplikan layar di bawah ini.

   

3. Di Node, klik node yang Anda temukan di langkah sebelumnya, lalu pilih Nonaktifkan (restart) dari menu Tindakan. Tindakan ini merestart node yang menjalankan replika servis utama dan memaksa failover ke salah satu replika sekunder yang berjalan pada node lain. Replika sekunder dipromosikan menjadi replika utama, replika sekunder lain dibuat pada node yang berbeda, dan replika utama mulai mengambil operasi baca/tulis. Saat node direstart, perhatikan output dari klien pengujian dan perhatikan bahwa penghitung terus bertambah meskipun terjadi failover.

Hapus aplikasi

Gunakan skrip uninstal yang disediakan dalam templat untuk menghapus instans aplikasi, membatalkan pendaftaran paket aplikasi, dan menghapus paket aplikasi dari penyimpanan gambar klaster.

./uninstall.sh

Di Penjelajah Service Fabric, Anda melihat bahwa jenis aplikasi dan aplikasi tidak lagi muncul di node Aplikasi.

Pustaka Service Fabric Java di Maven

Pustaka Service Fabric Java telah dihosting di Maven. Anda dapat menambahkan dependensi di pom.xml atau build.gradle proyek Anda untuk menggunakan pustaka Service Fabric Java dari mavenCentral.

Aktor

Dukungan Service Fabric Reliable Actor untuk aplikasi Anda.

<dependency>
    <groupId>com.microsoft.servicefabric</groupId>
    <artifactId>sf-actors</artifactId>
    <version>1.0.0</version>
</dependency>

repositories {
    mavenCentral()
}
dependencies {
    compile 'com.microsoft.servicefabric:sf-actors:1.0.0'
}

Layanan

Dukungan Service Fabric Reliable Services untuk aplikasi Anda.

<dependency>
    <groupId>com.microsoft.servicefabric</groupId>
    <artifactId>sf-services</artifactId>
    <version>1.0.0</version>
</dependency>

repositories {
    mavenCentral()
}
dependencies {
    compile 'com.microsoft.servicefabric:sf-services:1.0.0'
}

Lainnya

Transportasi

Dukungan lapisan transportasi untuk aplikasi Service Fabric Java. Anda tidak perlu menambahkan dependensi ini secara eksplisit ke aplikasi Reliable Actor atau Service Anda, kecuali jika Anda memprogram di lapisan transportasi.

<dependency>
    <groupId>com.microsoft.servicefabric</groupId>
    <artifactId>sf-transport</artifactId>
    <version>1.0.0</version>
</dependency>

repositories {
    mavenCentral()
}
dependencies {
    compile 'com.microsoft.servicefabric:sf-transport:1.0.0'
}

Dukungan fabric

Dukungan tingkat sistem untuk Service Fabric, yang berbicara dengan runtime Service Fabric asli. Anda tidak perlu menambahkan dependensi ini secara eksplisit ke aplikasi Reliable Actor atau Service Anda. Depedensi ini diambil secara otomatis dari Maven, saat Anda menyertakan dependensi lain di atas.

<dependency>
    <groupId>com.microsoft.servicefabric</groupId>
    <artifactId>sf</artifactId>
    <version>1.0.0</version>
</dependency>

repositories {
    mavenCentral()
}
dependencies {
    compile 'com.microsoft.servicefabric:sf:1.0.0'
}

Langkah berikutnya

• Buat aplikasi Service Fabric Java pertama Anda di Linux menggunakan Eclipse
• Pelajari selengkapnya tentang Reliable Actors
• Berinteraksi dengan klaster Service Fabric menggunakan Service Fabric CLI
• Pelajari tentang opsi dukungan Service Fabric
• Memulai Service Fabric CLI