Menggunakan perisian tengah dalam rangka kerja java untuk menguruskan pengimbangan beban dan failover

Untuk memastikan ketersediaan dan prestasi sistem teragih moden, pengimbangan beban dan failover adalah penting. Rangka kerja Java boleh melaksanakan fungsi ini dengan mudah melalui penyelesaian middleware yang matang. Dengan pengimbang beban, trafik masuk boleh diagihkan sama rata ke kluster pelayan bahagian belakang untuk kebolehskalaan dan ketersediaan yang lebih baik. Failover boleh mengubah hala trafik ke komponen yang sihat apabila komponen gagal, memastikan operasi aplikasi yang stabil. Artikel ini meneroka amalan khusus menggunakan perisian tengah untuk pengimbangan beban dan failover dalam rangka kerja Java, termasuk contoh praktikal untuk membuat kumpulan sasaran, pemeriksaan kesihatan dan pengimbang beban di Google Cloud.

Load Balancing dan Failover dalam Rangka Kerja Java: Menggunakan Middleware

Dalam sistem edaran moden, pengimbangan beban dan failover adalah penting, mereka memastikan aplikasi dapat bertahan pada trafik puncak atau kegagalan komponen sambil mengekalkan ketersediaan dan prestasi. Rangka kerja Java boleh melaksanakan fungsi ini dengan mudah melalui pelbagai penyelesaian middleware yang matang.

Pengimbang Beban

Pengimbang beban mengagihkan trafik masuk secara sama rata merentasi gugusan pelayan bahagian belakang untuk kebolehskalaan dan ketersediaan yang lebih baik. Pengimbang beban yang biasa digunakan di Java termasuk:

import com.google.cloud.compute.v1.GlobalForwardingRule;
import com.google.cloud.compute.v1.ForwardingRuleService;
import com.google.cloud.compute.v1.RegionForwardingRule;
import com.google.cloud.compute.v1.ForwardingRule;
import com.google.cloud.compute.v1.TargetPool;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;

public class CreateLoadBalancer {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample
    String project = "your-project-id";
    String zone = "zone-name"; // optional, only required for region-wide forwarding rules
    String region = "region-name"; // optional, only required for global forwarding rules
    String forwardingRuleName = "your-forwarding-rule-name";
    String targetPoolName = "your-target-pool-name";
    String healthCheckName = "your-health-check-name";
    String backendServiceName = "your-backend-service-name";
    String port = "8080"; // your port

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `client.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ComputeEngine client = ComputeEngine.create()) {
      // Create a new forwarding rule
      ForwardingRule forwardingRule;
      if (region == null) {
        // Create regional forwarding rule
        forwardingRule =
            ForwardingRule.newBuilder()
                .setName(forwardingRuleName)
                .setTarget(String.format("/region/%s/targetPools/%s", region, targetPoolName))
                .addPortRange(port)
                .build();
        RegionForwardingRule regionForwardingRule =
            RegionForwardingRule.newBuilder().setForwardingRule(forwardingRule).setRegion(zone).build();
        forwardingRule = client.insertRegionForwardingRule(regionForwardingRule, zone);
      } else {
        // Create global forwarding rule
        forwardingRule =
            ForwardingRule.newBuilder()
                .setName(forwardingRuleName)
                .setTarget(String.format("/global/targetPools/%s", targetPoolName))
                .addPortRange(port)
                .build();
        GlobalForwardingRule globalForwardingRule =
            GlobalForwardingRule.newBuilder()
                .setForwardingRule(forwardingRule)
                .setProject(project)
                .build();
        forwardingRule = client.insertGlobalForwardingRule(globalForwardingRule);
      }
      System.out.printf("Forwarding rule %s created.\n", forwardingRule.getName());
    }
  }
}

Failover

Failover ialah proses mengubah hala trafik ke komponen yang sihat apabila komponen, seperti pelayan atau pangkalan data, gagal. Penyelesaian failover yang biasa digunakan di Java termasuk:

import com.google.cloud.compute.v1.HealthCheck;
import com.google.cloud.compute.v1.HealthCheckService;
import com.google.cloud.compute.v1.RegionHealthCheck;
import com.google.cloud.compute.v1.ResourceGroupReference;
import com.google.cloud.compute.v1.TargetPool;
import com.google.cloud.compute.v1.TargetPoolService;
import java.io.IOException;

public class CreateHealthCheck {
  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample
    String project = "your-project-id";
    String zone = "zone-name";
    String region = "region-name";
    String targetPoolName = "your-target-pool-name";
    String healthCheckName = "your-health-check-name";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `client.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ComputeEngine client = ComputeEngine.create()) {
      // Create a new health check
      HealthCheck hc =
          HealthCheck.newBuilder()
              .setName(healthCheckName)
              .setType("TCP")
              .setPort(8080) // optional, ignored by TCP-based heath checks
              .addTcpHealthCheck(
                  com.google.cloud.compute.v1.TcpHealthCheck.newBuilder()
                      .setRequest("/index.html")
                      .setResponse("200"))
              .build();

      // Add the health check to target pool
      TargetPool targetPool =
          TargetPool.newBuilder()
              .setName(targetPoolName)
              .addHealthChecks(String.format("/zone/%s/healthChecks/%s", zone, healthCheckName))
              .build();

      if (region == null) {
        targetPool = client.updateRegionTargetPool(targetPool, zone);
      } else {
        targetPool = client.updateGlobalTargetPool(targetPool);
      }

      System.out.printf("Added health check %s to target pool %s.\n", healthCheckName, targetPoolName);
    }
  }
}

Kes praktikal: Menggunakan Google Cloud Load Balancing

Berikut ialah kes praktikal menggunakan Google Cloud Load Balancing untuk mencapai pengimbangan beban dan failover:

1. Buat sasaran A pool yang mengandungi kejadian pelayan bahagian belakang.
2. Buat Pemeriksaan Kesihatan untuk memeriksa kesihatan instance bahagian belakang anda secara berkala.
3. Buat Pengimbang Beban dan konfigurasikannya untuk menghalakan trafik ke kumpulan sasaran.
4. Sekiranya berlaku kegagalan atau beban berlebihan, pengimbang beban secara automatik mengubah laluan trafik untuk mengekalkan ketersediaan aplikasi.

Dengan mengikuti langkah ini, anda boleh menggunakan perisian tengah dengan mudah

Atas ialah kandungan terperinci Menggunakan perisian tengah dalam rangka kerja java untuk menguruskan pengimbangan beban dan failover. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!