Utilisation d'un middleware dans le framework Java pour gérer l'équilibrage de charge et le basculement

Pour garantir la disponibilité et les performances des systèmes distribués modernes, l'équilibrage de charge et le basculement sont cruciaux. Les frameworks Java peuvent facilement implémenter ces fonctions via des solutions middleware matures. Avec un équilibreur de charge, le trafic entrant peut être réparti uniformément sur le cluster de serveurs back-end pour une meilleure évolutivité et disponibilité. Le basculement peut rediriger le trafic vers des composants sains lorsqu'un composant tombe en panne, garantissant ainsi un fonctionnement stable de l'application. Cet article explore les pratiques spécifiques d'utilisation d'un middleware pour l'équilibrage de charge et le basculement dans les frameworks Java, y compris des exemples pratiques de création de pools cibles, de vérifications d'état et d'équilibreurs de charge sur Google Cloud.

Équilibrage de charge et basculement dans le framework Java : utilisation d'un middleware

Dans les systèmes distribués modernes, l'équilibrage de charge et le basculement sont cruciaux, ils garantissent que les applications peuvent survivre aux pics de trafic ou aux pannes de composants tout en maintenant la disponibilité et les performances. Les frameworks Java peuvent facilement implémenter ces fonctions via une variété de solutions middleware matures.

Load Balancer

L'équilibreur de charge répartit le trafic entrant uniformément sur le cluster de serveurs backend pour une meilleure évolutivité et disponibilité. Les équilibreurs de charge couramment utilisés en Java incluent :

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

Le basculement est le processus de redirection du trafic vers un composant sain lorsqu'un composant, tel qu'un serveur ou une base de données, tombe en panne. Les solutions de basculement couramment utilisées en Java incluent :

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);
    }
  }
}

Cas pratique : utilisation de Google Cloud Load Balancing

Ce qui suit est un cas pratique d'utilisation de Google Cloud Load Balancing pour réaliser l'équilibrage de charge et le basculement :

1. Créer une cible A pool qui contient des instances de serveur backend.
2. Créez un Health Check pour vérifier périodiquement la santé de votre instance backend.
3. Créez un Load Balancer et configurez-le pour acheminer le trafic vers le pool cible.
4. En cas de panne ou de charge excessive, l'équilibreur de charge redirige automatiquement le trafic pour maintenir la disponibilité des applications.

En suivant ces étapes, vous pouvez facilement utiliser le middleware

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!