HTTP & Web

Client side load balancing on Kubernetes

This document will show you how to perform client side load balancing on Kubernetes with a microservice.

What you will build

You will build a Vert.x microservice which:

listens to HTTP requests for the / URI
makes an HTTP request to a back-end service using a load balancer
sends the back-end service HTTP response content

It consists of a single part named microservice communicating with another pod deployed in Kubernetes.

What you need

A text editor or IDE
Java 11 higher
Maven or Gradle
Minikube or any Kubernetes cluster
kubectl command-line tool

Create the project

The code of the microservice project contains Maven and Gradle build files that are functionally equivalent.

The Service Resolver library is a plugin that lets Vert.x clients call services using logical service names instead of network addresses. The service resolver is also capable of performing client side load balancing with the usual strategies.

Containerization

To create containers we will use Jib because:

it creates images with distinct layers for dependencies, resources and classes, thus saving build time and deployment time
it supports both Maven and Gradle
it requires neither Docker nor Podman

Using Maven

Here is the content of the pom.xml file you should be using for the microservice:

Microservice Maven pom.xml

<?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>k8s-client-slide-lb-microservice</artifactId>
  <version>1.0.0-SNAPSHOT</version>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <vertx.version>5.0.0.CR2</vertx.version>

    <main.verticle>io.vertx.howtos.clientsidelb.MicroServiceVerticle</main.verticle>
    <launcher.class>io.vertx.launcher.application.VertxApplication</launcher.class>

  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>io.vertx</groupId>
        <artifactId>vertx-stack-depchain</artifactId>
        <version>${vertx.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <dependencies>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-core</artifactId>
    </dependency>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-launcher-application</artifactId>
    </dependency>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-service-resolver</artifactId>
    </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>com.google.cloud.tools</groupId>
        <artifactId>jib-maven-plugin</artifactId>
        <version>3.4.4</version>
        <configuration>
          <to>
            <image>client-side-lb/microservice</image>
          </to>
          <container>
            <mainClass>${launcher.class}</mainClass>
            <args>
              <arg>${main.verticle}</arg>
            </args>
            <ports>
              <port>8080</port>
            </ports>
          </container>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

Using Gradle

Assuming you use Gradle with the Kotlin DSL, here is what your build.gradle.kts file should look like for the microservice:

Microservice Gradle build.gradle.kts

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

repositories {
  mavenCentral()
}

val vertxVersion = "5.0.0.CR2"
val verticle = "io.vertx.howtos.clientsidelb.MicroServiceVerticle"

dependencies {
  implementation("io.vertx:vertx-core:${vertxVersion}")
  implementation("io.vertx:vertx-service-resolver:${vertxVersion}")
  implementation("io.vertx:vertx-launcher-application:${vertxVersion}")
}

jib {
  to {
    image = "client-side-lb/microservice"
  }
  container {
    mainClass = "io.vertx.launcher.application.VertxApplication"
    args = listOf(verticle)
    ports = listOf("8080")
  }
}

tasks.wrapper {
  gradleVersion = "8.11.1"
}

Implement the service

Let’s implement the microservice and then test it on the development machine.

The frontend service is encapsulated in a MicroServiceVerticle class.

The service will request another pod of the Kubernetes cluster with a service address. The microservice Verticle creates an HttpClient configured with a load-balancer and a resolver.