Um die Verfügbarkeit und Leistung moderner verteilter Systeme sicherzustellen, sind Lastausgleich und Failover von entscheidender Bedeutung. Java-Frameworks können diese Funktionen einfach durch ausgereifte Middleware-Lösungen implementieren. Mit einem Load Balancer kann der eingehende Datenverkehr für eine bessere Skalierbarkeit und Verfügbarkeit gleichmäßig auf den Backend-Server-Cluster verteilt werden. Failover kann den Datenverkehr auf fehlerfreie Komponenten umleiten, wenn eine Komponente ausfällt, und so einen stabilen Betrieb der Anwendung gewährleisten. In diesem Artikel werden die spezifischen Praktiken der Verwendung von Middleware für Lastausgleich und Failover in Java-Frameworks untersucht, einschließlich praktischer Beispiele für die Erstellung von Zielpools, Integritätsprüfungen und Lastausgleichsfunktionen in Google Cloud.
Lastausgleich und Failover im Java Framework: Verwendung von Middleware
In modernen verteilten Systemen sind Lastausgleich und Failover von entscheidender Bedeutung. Sie stellen sicher, dass Anwendungen Spitzenverkehr oder Komponentenausfälle überstehen und gleichzeitig Verfügbarkeit und Leistung aufrechterhalten können. Java-Frameworks können diese Funktionen einfach über eine Vielzahl ausgereifter Middleware-Lösungen implementieren.
Load Balancer
Der Load Balancer verteilt den eingehenden Datenverkehr gleichmäßig über den Backend-Servercluster, um eine bessere Skalierbarkeit und Verfügbarkeit zu gewährleisten. Zu den häufig verwendeten Load Balancern in Java gehören:
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 ist der Prozess der Umleitung des Datenverkehrs zu einer fehlerfreien Komponente, wenn eine Komponente, z. B. ein Server oder eine Datenbank, ausfällt. Zu den häufig verwendeten Failover-Lösungen in Java gehören:
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);
}
}
}Praktischer Fall: Verwendung von Google Cloud Load Balancing
Das Folgende ist ein praktischer Fall der Verwendung von Google Cloud Load Balancing, um Lastausgleich und Failover zu erreichen:
Indem Sie diese Schritte befolgen, können Sie Middleware ganz einfach verwenden
Das obige ist der detaillierte Inhalt vonVerwendung von Middleware im Java-Framework zur Verwaltung von Lastausgleich und Failover. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
