在 Kubernetes 上使用 Infinispan 部署 Vert.x 集群应用程序

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>io.vertx.howtos</groupId>
  <artifactId>clustering-kubernetes-frontend</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <verticle>io.vertx.howtos.cluster.FrontendVerticle</verticle>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>io.vertx</groupId>
        <artifactId>vertx-stack-depchain</artifactId>
        <version>5.0.0.CR2</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <dependencies>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-launcher-application</artifactId>
    </dependency>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-web</artifactId>
    </dependency>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-infinispan</artifactId>
    </dependency>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-health-check</artifactId>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.5.12</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.13.0</version>
        <configuration>
          <release>11</release>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <version>3.5.0</version>
        <configuration>
          <systemProperties>
            <systemProperty>
              <key>java.net.preferIPv4Stack</key>
              <value>true</value>
            </systemProperty>
            <systemProperty>
              <key>vertx.jgroups.config</key>
              <value>default-configs/default-jgroups-udp.xml</value>
            </systemProperty>
          </systemProperties>
          <mainClass>${verticle}</mainClass>
        </configuration>
      </plugin>
      <plugin>
        <groupId>com.google.cloud.tools</groupId>
        <artifactId>jib-maven-plugin</artifactId>
        <version>2.4.0</version>
        <configuration>
          <to>
            <image>clustering-kubernetes/frontend</image>
          </to>
          <container>
            <mainClass>io.vertx.launcher.application.VertxApplication</mainClass>
            <args>
              <arg>${verticle}</arg>
              <arg>-cluster</arg>
            </args>
            <ports>
              <port>8080</port>
              <port>7800</port>
            </ports>
          </container>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>io.vertx.howtos</groupId>
  <artifactId>clustering-kubernetes-backend</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <verticle>io.vertx.howtos.cluster.BackendVerticle</verticle>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>io.vertx</groupId>
        <artifactId>vertx-stack-depchain</artifactId>
        <version>5.0.0.CR2</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <dependencies>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-launcher-application</artifactId>
    </dependency>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-web</artifactId>
    </dependency>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-infinispan</artifactId>
    </dependency>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-health-check</artifactId>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.5.12</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.13.0</version>
        <configuration>
          <release>11</release>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <version>3.5.0</version>
        <configuration>
          <systemProperties>
            <systemProperty>
              <key>java.net.preferIPv4Stack</key>
              <value>true</value>
            </systemProperty>
            <systemProperty>
              <key>vertx.jgroups.config</key>
              <value>default-configs/default-jgroups-udp.xml</value>
            </systemProperty>
          </systemProperties>
          <mainClass>${verticle}</mainClass>
        </configuration>
      </plugin>
      <plugin>
        <groupId>com.google.cloud.tools</groupId>
        <artifactId>jib-maven-plugin</artifactId>
        <version>2.4.0</version>
        <configuration>
          <to>
            <image>clustering-kubernetes/backend</image>
          </to>
          <container>
            <mainClass>io.vertx.launcher.application.VertxApplication</mainClass>
            <args>
              <arg>${verticle}</arg>
              <arg>-cluster</arg>
            </args>
            <ports>
              <port>8080</port>
              <port>7800</port>
            </ports>
          </container>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

plugins {
  java
  application
  id("com.google.cloud.tools.jib") version "2.4.0"
}

repositories {
  mavenCentral()
}

val vertxVersion = "5.0.0.CR2"
val verticle = "io.vertx.howtos.cluster.FrontendVerticle"

dependencies {
  implementation("io.vertx:vertx-launcher-application:${vertxVersion}")
  implementation("io.vertx:vertx-web:${vertxVersion}")
  implementation("io.vertx:vertx-infinispan:${vertxVersion}")
  implementation("io.vertx:vertx-health-check:${vertxVersion}")
  implementation("ch.qos.logback:logback-classic:1.5.12")
}

application {
  applicationDefaultJvmArgs =
    listOf("-Djava.net.preferIPv4Stack=true", "-Dvertx.jgroups.config=default-configs/default-jgroups-udp.xml")
  mainClass = verticle
}

jib {
  to {
    image = "clustering-kubernetes/frontend"
  }
  container {
    mainClass = "io.vertx.launcher.application.VertxApplication"
    args = listOf(verticle, "-cluster")
    ports = listOf("8080", "7800")
  }
}

plugins {
  java
  application
  id("com.google.cloud.tools.jib") version "2.4.0"
}

repositories {
  mavenCentral()
}

val vertxVersion = "5.0.0.CR2"
val verticle = "io.vertx.howtos.cluster.BackendVerticle"

dependencies {
  implementation("io.vertx:vertx-launcher-application:${vertxVersion}")
  implementation("io.vertx:vertx-web:${vertxVersion}")
  implementation("io.vertx:vertx-infinispan:${vertxVersion}")
  implementation("io.vertx:vertx-health-check:${vertxVersion}")
  implementation("ch.qos.logback:logback-classic:1.5.12")
}

application {
  applicationDefaultJvmArgs =
    listOf("-Djava.net.preferIPv4Stack=true", "-Dvertx.jgroups.config=default-configs/default-jgroups-udp.xml")
  mainClass = verticle
}

jib {
  to {
    image = "clustering-kubernetes/backend"
  }
  container {
    mainClass = "io.vertx.launcher.application.VertxApplication"
    args = listOf(verticle, "-cluster")
    ports = listOf("8080", "7800")
  }
}

  private static final int HTTP_PORT = Integer.parseInt(System.getenv().getOrDefault("HTTP_PORT", "0"));
  private static final String POD_NAME = System.getenv().getOrDefault("POD_NAME", "unknown");

  @Override
  public Future<?> start() {
    Future<Void> registration = registerConsumer();

    Router router = setupRouter();

    Future<HttpServer> httpServer = vertx.createHttpServer()
      .requestHandler(router)
      .listen(HTTP_PORT)
      .onSuccess(server -> log.info("Server started and listening on port {}", server.actualPort()));

    return Future.join(registration, httpServer);
  }

  private Future<Void> registerConsumer() {
    return vertx.eventBus().<String>consumer("greetings", msg -> {
      msg.reply(String.format("Hello %s from %s", msg.body(), POD_NAME));
    }).completion();
  }

  private Router setupRouter() {
    Router router = Router.router(vertx);

    router.get("/health").handler(rc -> rc.response().end("OK"));

    Handler<Promise<Status>> procedure = ClusterHealthCheck.createProcedure(vertx, false);
    HealthChecks checks = HealthChecks.create(vertx).register("cluster-health", procedure);
    router.get("/readiness").handler(HealthCheckHandler.createWithHealthChecks(checks));
    return router;
  }

  public static void main(String[] args) {
    Vertx.clusteredVertx(new VertxOptions())
      .compose(vertx -> vertx.deployVerticle(new BackendVerticle()))
      .await();
  }

  private static final int HTTP_PORT = Integer.parseInt(System.getenv().getOrDefault("HTTP_PORT", "8080"));

  @Override
  public Future<?> start() {
    Router router = Router.router(vertx);

    setupRouter(router);

    return vertx.createHttpServer()
      .requestHandler(router)
      .listen(HTTP_PORT)
      .onSuccess(server -> log.info("Server started and listening on port {}", server.actualPort()));
  }

  private void setupRouter(Router router) {
    router.get("/hello").handler(this::handleHelloRequest);

    router.get("/health").handler(rc -> rc.response().end("OK"));

    Handler<Promise<Status>> procedure = ClusterHealthCheck.createProcedure(vertx, false);
    HealthChecks checks = HealthChecks.create(vertx).register("cluster-health", procedure);
    router.get("/readiness").handler(HealthCheckHandler.createWithHealthChecks(checks));
  }

  private void handleHelloRequest(RoutingContext rc) {
    vertx.eventBus().<String>request("greetings", rc.queryParams().get("name"))
      .map(Message::body)
      .onSuccess(reply -> rc.response().end(reply))
      .onFailure(rc::fail);
  }

  public static void main(String[] args) {
    Vertx.clusteredVertx(new VertxOptions())
      .compose(vertx -> vertx.deployVerticle(new FrontendVerticle()))
      .await();
  }

apiVersion: v1
kind: Service
metadata:
  name: clustered-app
spec:
  selector:
    cluster: clustered-app
  ports:
    - name: jgroups
      port: 7800
      protocol: TCP
  publishNotReadyAddresses: true
  clusterIP: None

apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend-deployment
  labels:
    app: frontend
spec:
  replicas: 2
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
        cluster: clustered-app
    spec:
      containers:
        - name: frontend
          image: clustering-kubernetes/frontend:latest
          imagePullPolicy: IfNotPresent
          env:
            - name: JAVA_TOOL_OPTIONS
              value: "-Djava.net.preferIPv4Stack=true -Dvertx.jgroups.config=default-configs/default-jgroups-kubernetes.xml -Djgroups.dns.query=clustered-app.default.svc.cluster.local"
            - name: HTTP_PORT
              value: "8080"
          ports:
            - containerPort: 8080
            - containerPort: 7800
          livenessProbe:
            httpGet:
              path: /health
              port: 8080
            failureThreshold: 1
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /readiness
              port: 8080
            initialDelaySeconds: 5
            periodSeconds: 5
          startupProbe:
            httpGet:
              path: /readiness
              port: 8080
            failureThreshold: 30
            periodSeconds: 10

apiVersion: v1
kind: Service
metadata:
  name: frontend
spec:
  selector:
    app: frontend
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer

apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend-deployment
  labels:
    app: backend
spec:
  replicas: 3
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
        cluster: clustered-app
    spec:
      containers:
        - name: backend
          image: clustering-kubernetes/backend:latest
          imagePullPolicy: IfNotPresent
          env:
            - name: JAVA_TOOL_OPTIONS
              value: "-Djava.net.preferIPv4Stack=true -Dvertx.jgroups.config=default-configs/default-jgroups-kubernetes.xml -Djgroups.dns.query=clustered-app.default.svc.cluster.local"
            - name: HTTP_PORT
              value: "8080"
            - name: POD_NAME
              valueFrom:
                fieldRef:
                  fieldPath: metadata.name
          ports:
            - containerPort: 8080
            - containerPort: 7800
          livenessProbe:
            httpGet:
              path: /health
              port: 8080
            failureThreshold: 1
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /readiness
              port: 8080
            initialDelaySeconds: 5
            periodSeconds: 5
          startupProbe:
            httpGet:
              path: /readiness
              port: 8080
            failureThreshold: 30
            periodSeconds: 10