Cara menggunakan Spring Cloud untuk membina kluster perkhidmatan mikro berprestasi tinggi

Dengan peningkatan pengkomputeran awan dan perkhidmatan mikro, semakin banyak syarikat mencari seni bina yang diedarkan dan tersedia untuk membina aplikasi mereka sendiri, dan Spring Cloud adalah salah satu peneraju dalam bidang ini. Spring Cloud menyediakan banyak komponen dan perkhidmatan untuk membina sistem teragih dengan cepat dan menggunakan perkhidmatan ini dengan mudah ke platform awan. Dalam artikel ini, saya akan memperkenalkan anda cara menggunakan Spring Cloud untuk membina kluster perkhidmatan mikro berprestasi tinggi.

1. Membina seni bina perkhidmatan mikro

Sebelum mula membina sistem perkhidmatan mikro kami, mari semak apa itu perkhidmatan mikro. Microservices ialah corak seni bina yang memecahkan aplikasi kepada perkhidmatan kecil yang bekerjasama antara satu sama lain dalam keseluruhan sistem. Ia membolehkan pembangun membina dan mengeluarkan aplikasi yang boleh skala dan diedarkan dengan cepat.

Spring Cloud menyediakan satu set alatan dan rangka kerja untuk menyokong seni bina perkhidmatan mikro, termasuk tetapi tidak terhad kepada pendaftaran perkhidmatan, penemuan perkhidmatan, pengimbangan beban dan konfigurasi yang diedarkan. Berikut ialah langkah untuk melaksanakan perkhidmatan mikro menggunakan Spring Cloud:

1) Bina pelayan Eureka

Eureka ialah salah satu komponen penemuan perkhidmatan pilihan dalam Spring Cloud Ia adalah perkhidmatan berasaskan REST . Boleh membantu kami menguruskan kebergantungan antara perkhidmatan mikro. Untuk menggunakan Eureka, anda perlu menyediakan pelayan Eureka terlebih dahulu. Anda boleh mencipta pelayan Eureka menggunakan kod berikut:

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

Selepas memulakan aplikasi, anda boleh mengakses konsol Eureka melalui http://localhost:8761/ dan melihat semua perkhidmatan mikro berdaftar.

2) Cipta perkhidmatan mikro

Sekarang, kami akan mencipta dua perkhidmatan mikro: satu ialah perkhidmatan pengguna dan satu lagi ialah perkhidmatan pesanan. Perkhidmatan pengguna akan menyediakan fungsi menambah, memadam, mengubah suai dan menyemak maklumat pengguna, manakala perkhidmatan pesanan akan menyediakan fungsi menambah, memadam, mengubah suai dan menyemak maklumat pesanan. Berikut ialah contoh kod untuk perkhidmatan pengguna:

@SpringBootApplication
@EnableDiscoveryClient
@RestController
public class UserServiceApplication {

    @Autowired
    private UserRepository userRepository;

    @GetMapping("/users")
    public List<User> getUsers() {
        return userRepository.findAll();
    }

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        return userRepository.findById(id).orElse(null);
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }

    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        return userRepository.save(user);
    }

    @DeleteMapping("/users/{id}")
    public void deleteUser(@PathVariable Long id) {
        userRepository.deleteById(id);
    }

    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

Berikut ialah contoh kod untuk perkhidmatan pesanan:

@SpringBootApplication
@EnableDiscoveryClient
@RestController
public class OrderServiceApplication {

    @Autowired
    private OrderRepository orderRepository;

    @GetMapping("/orders")
    public List<Order> getOrders() {
        return orderRepository.findAll();
    }

    @GetMapping("/orders/{id}")
    public Order getOrderById(@PathVariable Long id) {
        return orderRepository.findById(id).orElse(null);
    }

    @PostMapping("/orders")
    public Order createOrder(@RequestBody Order order) {
        return orderRepository.save(order);
    }

    @PutMapping("/orders/{id}")
    public Order updateOrder(@PathVariable Long id, @RequestBody Order order) {
        order.setId(id);
        return orderRepository.save(order);
    }

    @DeleteMapping("/orders/{id}")
    public void deleteOrder(@PathVariable Long id) {
        orderRepository.deleteById(id);
    }

    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

3) Daftar perkhidmatan mikro

Untuk mendaftar perkhidmatan mikro ke dalam Pelayan Eureka , kita perlu menambah kebergantungan berikut dalam fail binaan setiap perkhidmatan mikro:

<!-- Eureka Discovery Client -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

Pada masa yang sama, kami perlu menambah anotasi @EnableDiscoveryClient pada kelas permulaan setiap perkhidmatan mikro untuk membolehkan pendaftaran perkhidmatan fungsi.

Selepas menggunakan semua perkhidmatan mikro ke pelayan awan atau setempat, daftarkannya ke dalam pelayan Eureka, yang akan menguruskan perkhidmatan mikro ini untuk kami.

2. Mencapai pengimbangan beban

Dalam sistem mikroperkhidmatan sebenar, kami mungkin mempunyai berbilang kejadian yang menjalankan perkhidmatan mikro yang sama untuk meningkatkan kebolehskalaan dan toleransi Ralat. Walau bagaimanapun, kami memerlukan cara untuk memutuskan contoh yang boleh mengendalikan permintaan pelanggan.

Spring Cloud menyediakan dua kaedah untuk mencapai pengimbangan beban: pengimbangan beban pelanggan dan pengimbangan beban pelayan. Pengimbangan beban pelanggan merujuk kepada menggunakan algoritma pengimbangan beban untuk memilih contoh perkhidmatan mikro biasa untuk mengendalikan permintaan sebelum pelanggan memulakan permintaan. Pengimbangan beban sebelah pelayan merujuk kepada cara permintaan diedarkan di kalangan contoh perkhidmatan mikro. Setiap kaedah mempunyai kelebihan dan kekurangannya, dan keputusan tentang kaedah yang hendak dipilih hendaklah berdasarkan senario aplikasi khusus anda.

Dalam artikel ini, kami akan menggunakan pengimbangan beban sebelah pelanggan untuk melaksanakan perkhidmatan mikro. Untuk menggunakan pengimbangan beban sisi klien, kami perlu menambah kebergantungan berikut dalam setiap pelanggan:

<!-- Ribbon -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

Kini, kami boleh menganotasi RestTemplate dengan anotasi @LoadBalanced untuk melengkapkan pengimbangan beban secara automatik apabila permintaan dibuat dibuat. Sebagai contoh, kita boleh menggunakan kod berikut untuk menggunakan RestTemplate dalam perkhidmatan pengguna:

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    return new RestTemplate();
}

3. Mencapai pemutus litar perkhidmatan dan menurunkan taraf

Dalam seni bina perkhidmatan mikro, antara pelbagai perkhidmatan mikro. panggilan akan menjana sejumlah besar permintaan rangkaian. Jika terdapat masalah dengan satu perkhidmatan mikro dalam sistem, keseluruhan sistem mungkin terjejas. Untuk menangani masalah ini, kami boleh menggunakan komponen Hystrix Spring Cloud untuk melaksanakan gangguan perkhidmatan dan menurunkan taraf.

Apabila masalah berlaku dalam perkhidmatan mikro tertentu, Hystrix akan menghalang kesan runtuhan salji melalui mod pemutus litar. Pengguna perkhidmatan tidak lagi akan meminta perkhidmatan mikro dan mengembalikan respons lalai. Pada masa yang sama, Hystrix juga boleh melaksanakan fungsi turun taraf Apabila perkhidmatan mikro tertentu terlebih beban atau gagal, ia akan bertukar secara automatik kepada pelaksanaan alternatif.

Sebagai contoh, kita boleh menggunakan kod berikut untuk melaksanakan Hystrix dalam perkhidmatan pengguna:

<!-- Hystrix -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

<!-- Hystrix Dashboard -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>

@EnableHystrix anotasi untuk mendayakan kefungsian Hystrix.

Anotasi @HystrixCommand akan membolehkan pemutus litar Hystrix dalam kaedah getUserById:

@HystrixCommand(fallbackMethod = "defaultUser")
@GetMapping("/users/{id}")
public User getUserById(@PathVariable Long id) {
    return restTemplate.getForObject("http://user-service/users/" + id, User.class);
}

public User defaultUser(Long id) {
    return new User();
}

4. Melaksanakan pengurusan konfigurasi teragih

Spring Cloud Config ialah praktikal Alat yang memisahkan konfigurasi antara aplikasi dan persekitaran. Menyimpan konfigurasi aplikasi secara berasingan dalam pelayan konfigurasi dan menyuntik setiap konfigurasi aplikasi ke dalam persekitarannya membolehkan kami mengkonfigurasi dan mengurus berbilang contoh dan persekitaran aplikasi dengan cepat.

Untuk menggunakan Spring Cloud Config, kita perlu mencipta pelayan konfigurasi dan kemudian menyimpan konfigurasi aplikasi dalam pusat konfigurasi. Pelayan konfigurasi menolak konfigurasi ini ke aplikasi.

Berikut ialah contoh mudah cara menggunakan Spring Cloud Config:

1) Buat pelayan konfigurasi

Untuk mencipta pelayan konfigurasi, anda perlu menambah @ terlebih dahulu EnableConfigServer pada kelas permulaan Anotasi dan nyatakan repositori fail konfigurasi:

@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApplication.class, args);
    }
}

在配置中心的存储库中可以存储多种类型的配置文件，包括.properties，.yml和.json等。配置可以根据应用程序和环境进行管理。例如，可以为生产环境存储prod.properties文件，而为测试环境存储test.properties文件。

2）将应用程序连接到配置服务器

要将应用程序连接到配置服务器，首先需要添加以下依赖项：

<!-- Config Client -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

然后，我们需要在应用程序的bootstrap.properties文件中指定配置服务器的位置：

spring.cloud.config.uri=http://localhost:8888

现在，当我们启动应用程序时，它将自动从配置服务器中获取配置。

5. 实现API网关

API网关是一个重要的组件，它充当了客户端和分布式后端系统之间的中间层。API网关可以用于路由请求，验证和授权请求，以及调用其他微服务。

Spring Cloud提供了Zuul组件来实现API网关。Zuul支持多种请求路由策略，如轮询，随机和会话保持等，并支持限流和动态路由等高级特性。

以下是如何将Zuul添加到应用程序中的简单示例：

1）添加依赖项

要将Zuul添加到应用程序中，需要添加以下依赖项：

<!-- Zuul -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>

2）创建Zuul代理

创建Zuul代理非常简单。我们只需要在启动类上添加@EnableZuulProxy注解，并且可以在配置文件中指定路由规则。例如，以下规则将路由到服务名称为user-service中的所有请求：

zuul:
  routes:
    users:
      path: /users/**
      serviceId: user-service

3）使用Zuul代理

现在，API网关应用程序已准备就绪。我们可以使用以下代码在应用程序中处理请求：

@RestController
public class ApiController {

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        return restTemplate.getForObject("http://api-gateway/user-service/users/" + id, User.class);
    }

    public static void main(String[] args) {
        SpringApplication.run(ApiGatewayApplication.class, args);
    }
}

以上是如何使用Spring Cloud搭建一个高性能的微服务集群的一些步骤和示例。当然，在实际项目中，还需要考虑更多的特性和问题，如服务注册与发现的高可用、分布式事务、服务治理、微服务监控和链路跟踪等。但希望这篇文章对您有所帮助！

Atas ialah kandungan terperinci Cara menggunakan Spring Cloud untuk membina kluster perkhidmatan mikro berprestasi tinggi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!