Pada bagian sebelumnya dari artikel ini, Spring Cloud: How to Implement Service Discovery (Bagian 1), kita melihat dasar-dasar Service Discovery dalam konteks Spring Cloud. Kami telah melihat bahwa komponen Netflix OSS Eureka tetap menjadi pilihan utama. Pada artikel ini, kita akan membahas beberapa topik tambahan Eureka, seperti:

Penemuan Layanan: Klien Java API

Pada contoh di bagian pertama artikel ini, fungsi perekaman dan pengambilan berjalan di bawah tenda dan kami hanya melihat hasil pengujian seluruh arsitektur dengan memanggil klien REST titik akhir. Ada juga cara untuk berinteraksi dengan Eureka API secara terprogram, menggunakan pemanggilan metode Java. Pilihan yang mungkin adalah menggunakan the EurekaClient kelas. Misalnya, jika kita ingin mendapatkan semua instance layanan yang diidentifikasi oleh id tertentu, kita dapat menulis kode berikut, dengan asumsi kita memiliki klien yang diimplementasikan sebagai aplikasi Spring Boot yang menampilkan layanan REST:

  	@Autowired
	private EurekaClient eurekaClient;
		
	@GetMapping("/testEurekaClient")
	public String testEurekaClient() {
		Application application = eurekaClient.getApplication("CLIENT-SERVICE");
		List<InstanceInfo> instanceInfos = application.getInstances();
	    if (instanceInfos != null && instanceInfos.size() > 0 ) {
	        return instanceInfos.get(0).getHomePageUrl();
	    }
	    return null;
	}

Spring Cloud menawarkan alternatif di atas dengan caranya sendiri DiscoveryClient kelas. Jadi kita juga bisa mengimplementasikan kode di atas dengan yang berikut:

	@Autowired
	private DiscoveryClient discoveryClient;
			         	
	@GetMapping("/testDiscoveryClient")
	public String testDiscoveryClient() {
	    List<ServiceInstance> serviceInstances = discoveryClient.getInstances("CLIENT-SERVICE");
	    if (serviceInstances != null && serviceInstances.size() > 0 ) {
	        return serviceInstances.get(0).getServiceId();
	    }
	    return null;
	}

Penemuan Layanan: Eureka REST API

Kami melihat di bagian sebelumnya bagaimana menggunakan Java API untuk berinteraksi dengan server penemuan Eureka. Dalam skenario yang lebih umum, kita mungkin memiliki komponen yang tidak ditulis di Java. Dalam hal ini, kita bisa menggunakan REST API yang disediakan oleh Eureka. Beberapa parameternya dijelaskan di bawah ini:

• /eureka/v2/apps: Dengan operasi GET, dapatkan semua instance
• /eureka/v2/apps/appID: Jika digunakan dengan tindakan POST, ia mendaftarkan instance aplikasi, dan dengan GET, ia mengambil semua ID aplikasi.
• /eureka/v2/apps/appID/instanceID: Jika digunakan dengan tindakan DELETE, tindakan ini akan menghapus instance tertentu dari registri server, sementara PUT mengirimkan “detak jantung” ke server untuk instance tertentu tersebut.
• /eureka/v2/apps/appID/instanceID/metadata?key=nilai: Dengan PUT digunakan untuk memperbarui metadata

Penemuan Layanan: Mengamankan Server

Menetapkan tingkat keamanan minimum penting untuk instans penemuan di lingkungan produksi. Kami dapat melindungi server penemuan, misalnya, dengan fase otentikasi sederhana berdasarkan nama pengguna dan kata sandi. Untuk melakukan ini, kita perlu menetapkan nama pengguna dan kata sandi di file application.yml oleh Spring.keamanan.pengguna properti:

spring:
   security:
      user:
         name: myusername
         password: mypassword   

Selanjutnya, agar dapat mengotentikasi dan berkomunikasi dengan server penemuan layanan, kita perlu mengatur sesuatu seperti berikut pada konfigurasi sisi klien, dengan asumsi port server adalah 8760 dan berjalan secara lokal dengan klien :

eureka:
   client:
      serviceUrl:
         defaultZone:  

Penemuan Layanan: Mengamankan Klien

Sisi klien dalam diskusi ini adalah komponen layanan dari sistem layanan mikro kami. Mengamankan mereka berarti mengamankan saluran komunikasi untuk setiap komponen. Jika klien mengekspos fungsionalitasnya melalui layanan REST, saluran komunikasi bergantung pada protokol HTTP. Kami dapat mengamankannya dengan menerapkan komunikasi SSL.

Untuk mengaktifkan SSL sisi klien, pertama-tama kita memerlukan sertifikat. Kami dapat membuat sertifikat yang ditandatangani sendiri menggunakan keytool program Java, seperti ini:

keytool -genkey -alias client -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -validity 365

Kemudian kita dapat mengambil yang dihasilkan keystore.p12 file dan salin ke /sumber daya folder aplikasi Spring Boot kami dan atur konfigurasi berikut di aplikasi.yml untuk mengajukan:

server:
   ssl:
      key-store: classpath:keystore.p12
      key-store-password: mypassword
      keyStoreType: PKCS12
      keyAlias: client

Dengan cara di atas, kami dapat memanggil layanan kami menggunakan HTTPS di bagian protokol URL. Kami dapat meningkatkan konfigurasi dengan mengaktifkan HTTPS dan bukan HTTP, dengan menyetel properti instans Eureka berikut:

eureka: 
   instance: 
      securePortEnabled: true 
      nonSecurePortEnabled: false 
      statusPageUrl:  
      healthCheckUrl: 
      homePageUrl: 

Di sini kami juga telah menetapkan beberapa parameter, seperti informasi, kesehatan, dan URL beranda.

Penemuan Layanan: Gabungkan dengan Konfigurasi Jarak Jauh

Kami dapat menggabungkan penemuan layanan dengan konfigurasi terdistribusi dalam dua cara berbeda:

• Pendekatan pengaturan pertama
• Penemuan pendekatan pertama

Kami akan menjelaskan kedua pendekatan ini di bagian berikut.

Konfigurasikan terlebih dahulu

Dalam pendekatan Config First, server konfigurasi jarak jauh adalah titik pusat arsitektur. Instance layanan dan penemuan klien akan terhubung ke server konfigurasi untuk mengambil konfigurasinya.

Untuk mengatur server konfigurasi, kita perlu menambahkan dependensi ini ke file Maven POM:

    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-config-server</artifactId>
    </dependency>

Dalam aplikasi.yml file, untuk menyederhanakan contoh, kami akan mendefinisikan file spring.profiles.aktif properti seperti native. Dengan cara ini kita bisa menggunakan repositori lokal, berdasarkan file konfigurasi yang disimpan di classpath, dan kita bisa memilih untuk meletakkannya di / konfigurasi subfolder dari /sumber daya boot musim semi direktori aplikasi. Kami juga mengamankan server dengan autentikasi dasar melalui pengguna.keamanan Properti.

spring:
  profiles:
     active: native
  application:
    name: config-server
  security:
    user:
      name: myusername
      password: mypassword

Dalam aplikasi.yml berkas dari pelanggan Dan layanan penemuan aplikasi, kami hanya akan menyimpan properti dasar; misalnya, yang diperlukan untuk terhubung ke server konfigurasi. Properti lainnya akan disimpan di server konfigurasi itu sendiri, dalam file tertentu yang disimpan di / konfigurasi folder yang disebutkan di atas.

Konfigurasi basis pelanggan

Untuk konfigurasi layanan klien dasar, kita perlu menambahkan konfigurasi jarak jauh dan dependensi klien penemuan Eureka:

    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-config</artifactId>
    </dependency>   
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>

Dan di aplikasi.yml file, kita akan mendefinisikan config.import parameter dengan optional:configserver nilai, untuk terhubung ke server konfigurasi (tidak perlu menentukan URL, karena ini adalah nilai default untuk server konfigurasi):

spring:  
  application:
    name: client-service
  config:
    import: "optional:configserver:"
  cloud:
    config:
      username: myusername
      password: mypassword

Konfigurasi Server Penemuan Dasar

Discovery server juga membutuhkan spring-cloud-starter-config kecanduan:

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

Dan aplikasi.yml konten akan serupa dengan yang diperlukan untuk klien:

spring:  
  application:
    name: discovery-service
  security:
     user:
        name: myusername
        password: mypassword
  config:
    import: "optional:configserver:"
  cloud:
    config:
      username: myusername
      password: mypassword

Konfigurasi khusus untuk layanan klien dan penemuan

Setelah mendefinisikan konfigurasi dasar klien dan komponen penemuan seperti di atas, kita perlu mendefinisikan lebih spesifik di dalam server konfigurasi. Kami akan menggunakan dua file konfigurasi yang disimpan di /sumber daya/config Folder aplikasi Spring Boot disebutkan sebelumnya. File diberi nama setelah Nama aplikasi properti dari setiap aplikasi:

• /config/client-service.yml
• /config/discovery-service.yml

Isi dari layanan-klien.yml akan:

server:
   port: ${PORT:8080}

myproperty: value

eureka:
  instance:
    hostname: localhost
  client:
    serviceUrl:
       defaultZone: 

Seperti yang bisa kita lihat di atas, the defaultZone Properti berisi URL instance server Eureka, dengan nama pengguna dan kata sandi di dalamnya, karena kami mengamankan server penemuan dengan autentikasi dasar, sebagai server konfigurasi.

Adapun konfigurasi jarak jauh dari server penemuan, mis. discovery-service.yml file, kami akan memiliki konten berikut:

eureka:
   instance:
      hostname: localhost
   client:
      registerWithEureka: false
      fetchRegistry: false
      
server:
   port: ${PORT:8760}

Konfigurasi Pertama: Contoh Proyek dari GitHub

Anda dapat menemukan tiga proyek contoh dengan konfigurasi di atas di GitHub:

Kita dapat menguji contoh dengan mengkompilasi dan membangun ketiga proyek dengan “mvn clean install”, lalu menjalankan single jar file dari baris perintah:

java -jar spring-cloud-discovery-configserver-configfirst-1.0-SNAPSHOT.jar 
... 
java -jar spring-cloud-discovery-client-configfirst-1.0-SNAPSHOT.jar 
...
java -jar spring-cloud-discovery-server-configfirst-1.0-SNAPSHOT.jar

Kemudian kita dapat memeriksa dasbor layanan penemuan, di mana kita akan melihat instance klien tunggal terdaftar sebagai ‘CLIENT-SERVICE’, dan memverifikasi klien, misalnya, dengan menjalankan layanan REST yang diimplementasikan olehnya .

penemuan pertama

Dalam pendekatan Discovery First, layanan penemuan tidak seharusnya menyimpan konfigurasinya dari jarak jauh. Sebaliknya, server konfigurasilah yang mendaftarkan dirinya sendiri pada register penemuan. Adapun layanan klien, itu juga akan mendaftar pada layanan penemuan, untuk mengambil properti yang diperlukan untuk terhubung ke server konfigurasi. Dalam arsitektur ini, klien hanya perlu mengetahui ID aplikasi server konfigurasi dan kredensial keamanan, jika ada.

Layanan penemuan tidak lagi memerlukan ketergantungan klien server konfigurasi dan konfigurasinya dapat disimpan seluruhnya di tempatnya. aplikasi.yml untuk mengajukan:

spring:
   application:
      name: discovery-service
   security:
      user:
         name: myusername
         password: mypassword
               
eureka:
   instance:
      hostname: localhost
   client:
      registerWithEureka: false
      fetchRegistry: false
      
server:
   port: ${PORT:8760}

Klien konfigurasi lokal dan konfigurasi server dijelaskan dalam dua bagian di bawah ini.

Konfigurasi basis pelanggan

Dependensi Maven POM sama dengan skenario Config First, sedangkan konfigurasi lokal dasar di file application.yml lokal harus berisi URL layanan Eureka.

spring:
   application:
      name: client-service
      
eureka:
  client:
     serviceUrl:
        defaultZone: 

Konfigurasi dasar dari server konfigurasi

Sebagai tambahan spring-cloud-config-server dalam skenario penemuan pertama, aplikasi server konfigurasi juga memerlukan ketergantungan klien Eureka:

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-config-server</artifactId>
</dependency>

Dan aplikasi.yml konten akan berisi URL layanan penemuan, seperti komponen klien:

server:  
  port: ${PORT:8888}
  
spring:
  profiles:
     active: native
  application:
     name: config-server
           
eureka:
  instance:
    hostname: localhost
  client:
    serviceUrl:
      defaultZone: 

Konfigurasi khusus untuk layanan pelanggan

Dalam skenario penemuan pertama, repositori server konfigurasi lokal hanya akan berisi file konfigurasi klien:

• /config/client-service.yml

Dan isi dari layanan-klien.yml akan:

server:
   port: ${PORT:8080}

myproperty: value

spring:
   cloud: 
      config: 
         discovery: 
            enabled: true 
            serviceId: config-server

eureka:
  client:
    serviceUrl:
       defaultZone: 

Di sini, selain URL layanan penemuan, yang diperlukan karena klien harus terhubung terlebih dahulu, kita juga dapat melihat spring.cloud.config.discovery.enabled properti diatur ke true. Properti ini menunjukkan kepada aplikasi klien bahwa ia harus terhubung ke server konfigurasi dengan metadatanya yang disimpan di registri layanan penemuan. Properti serviceId menyimpan ID aplikasi server konfigurasi yang cocok dengan yang disimpan di registri layanan penemuan.

Kita dapat menyimpulkan bahwa dalam skenario layanan penemuan, instance server konfigurasi (atau instance) dapat diubah untuk dijalankan pada host/port yang berbeda tanpa perlu mengubah konfigurasi klien.

Penemuan Pertama: Contoh Proyek dari GitHub

Di bawah ini adalah tautan GitHub dari proyek sampel untuk skenario Discovery First:

Kita dapat menguji contoh seperti yang telah kita lakukan untuk skenario konfigurasi pertama.

Kesimpulan

Pada artikel ini, kami telah menyelesaikan diskusi yang dimulai pada bagian pertama artikel dan memperkenalkan topik lain, seperti:

• API Java terprogram
• REST-API
• Cara memasang lapisan keamanan dasar pada server penemuan dan aplikasi klien
• Gabungkan fitur penemuan dan konfigurasi jarak jauh dengan dua cara berbeda: konfigurasikan terlebih dahulu Dan penemuan pertama.

Anda dapat menemukan kode sumber untuk contoh di artikel ini di GitHub berikut modul: