Kubernetes with Java - Introduction

By Salman Malik

Spring expert, Kubernetes expert, Borders, ITHAKA/JSTOR.

What are we going to do?

• Learn how to initialize the k8s api client in a java spring-boot application
• Extract metadata from deployments in a namespace and transform that metadata into new views
• Prepare you for more sophisticated problem solving using the k8s API in future articles

Motivation

• You have a few dozen different applications (as Kubernetes deployment resources) running in your cluster
• All of those applications use labels to designate the name of the team that manages that application, and the application name
• You want to provide APIs that:
  • Lists all teams that have applications running in the cluster
  • Lists all apps that belong to a team

Scenario

kubectl create namespace dev

curl -Lo petnames.txt https://fnjoin.com/data/2021-08-21-show-pods-petnames.txt 
cat petnames.txt | paste - - - - - - - - - - | \
while read line ; do 
  set -- $line
  team=team-$1
  shift
  for app ; do 
    app=app-$app
    kubectl create deployment $app --image=k8s.gcr.io/echoserver:1.4 -n dev
    kubectl label deployment $app team=$team -n dev
  done
done

NAME                         READY   UP-TO-DATE   AVAILABLE   AGE
app-acaroid-emilee           0/1     1            0           47s
app-ageless-lynna            0/1     1            0           35s
app-airless-jettie           0/1     1            0           12s
app-announceable-yasmin      0/1     1            0           18s
app-apocopic-chanel          0/1     1            0           27s
app-benmost-rudy             0/1     1            0           39s
app-blastular-sparkle        0/1     1            0           29s
app-bromidic-kamden          0/1     1            0           23s
app-buggier-helga            0/1     1            0           32s
app-bullheaded-tran          0/1     1            0           19s
....

kubectl get deployments -n dev -o json | jq '[ .items[] | { name: .metadata.labels.app, team: .metadata.labels.team, readyInstances: .status.readyReplicas }]'

This is a contrived example, as almost all Kubernetes platforms make some kind of dashboard available that let you view resources in the cluster along with their labels. This example mainly shows you how one would go about interacting with the Kubernetes API using Java.

Introducing the Kubernetes Java Client libraries

implementation 'io.kubernetes:client-java-extended:13.0.0'

<dependency>
    <groupId>io.kubernetes</groupId>
    <artifactId>client-java-extended</artifactId>
    <version>13.0.0</version>
</dependency>

Initializing the client

import io.kubernetes.client.openapi.ApiClient;
import io.kubernetes.client.util.ClientBuilder;
import io.kubernetes.client.util.KubeConfig;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

@Slf4j
@Configuration
public class ApiClientConfig {

    @Bean
    public ApiClient externalApiClient() throws IOException {
        KubeConfig kubeConfig = KubeConfig.loadKubeConfig(new FileReader(getConfigFile()));
        log.info("Current Context: Name={}", kubeConfig.getCurrentContext());
        return ClientBuilder
                .kubeconfig(kubeConfig)
                .build();
    }

    private File getConfigFile() {
        String kubeConfigVar = System.getenv("KUBECONFIG");
        if (StringUtils.isNotBlank(kubeConfigVar)) {
            log.info("Using KUBECONFIG variable: Value='{}'", kubeConfigVar);
            return new File(kubeConfigVar);
        } else {
            File configDir = new File(System.getProperty("user.home"), ".kube");
            File configFile = new File(configDir, "config");
            log.info("Using home file: Path='{}'", configFile.getPath());
            return configFile;
        }
    }
}

Use the client to lookup the deployments

• We are only interested in deployments running in the dev namespace
• We are only interested in deployments containing app and team labels
• We are interested in the following attributes of the deployments:
  • App name
  • Team that app belongs to
  • How many instances/replicas of that app are running/ready

import lombok.Builder;
import lombok.Value;

@Value
@Builder
public class TeamApp {
    String name;
    String team;
    int readyInstances;
}

import java.util.List;
import java.util.Set;

public interface TeamAppsService {

    String APP_LABEL = "app";
    String TEAM_LABEL = "team";

    Set<String> listTeams();
    List<TeamApp> listTeamApps(String team);
}

import io.kubernetes.client.openapi.ApiClient;
import io.kubernetes.client.openapi.apis.AppsV1Api;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class SynchronousTeamAppsService implements TeamAppsService {

    private final AppsV1Api appsV1Api;
    private final String namespace;

    public SynchronousTeamAppsService(
            ApiClient client,
            @Value("${namespace}") String namespace) {
        
        log.info("Creating synchronous team-app service, Namespace={}", namespace);
        this.appsV1Api = new AppsV1Api(client);
        this.namespace = namespace;
    }

    ...
}

public Set<String> listTeams() {
    return appsV1Api.listNamespacedDeployment(
                    namespace,
                    null,
                    null,
                    null,
                    null,
                    TEAM_LABEL,
                    null,
                    null,
                    null,
                    null,
                    null)
            .getItems()
            .stream()
            .map(deployment -> deployment.getMetadata().getLabels().get("team"))
            .collect(Collectors.toSet());
}

public V1DeploymentList listNamespacedDeployment(
        String namespace,
        String pretty,
        Boolean allowWatchBookmarks,
        String _continue,
        String fieldSelector,
        String labelSelector,
        Integer limit,
        String resourceVersion,
        String resourceVersionMatch,
        Integer timeoutSeconds,
        Boolean watch)
        throws ApiException {
    ...
}

There is a pattern at play here. In the api object you'll find methods of the form listNamespacedSomething() that pretty much takes this exact set of arguments. It returns a V1SomethingList object which has a getItems() method that returns a list of V1Something objects.

public List<TeamApp> listTeamApps(String team) {
    return appsV1Api.listNamespacedDeployment(
                    namespace,
                    null,
                    null,
                    null,
                    null,
                    TEAM_LABEL + "=" + team,
                    null,
                    null,
                    null,
                    null,
                    null)
            .getItems()
            .stream()
            .map(this::toTeamApp)
            .collect(Collectors.toList());
}

private TeamApp toTeamApp(V1Deployment v1Deployment) {
    return TeamApp.builder()
            .name(v1Deployment.getMetadata().getLabels().get(APP_LABEL))
            .team(v1Deployment.getMetadata().getLabels().get(TEAM_LABEL))
            .readyInstances(v1Deployment.getStatus().getReadyReplicas())
            .build();
}

Using the service to serve the results

import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Set;

@RestController
@RequiredArgsConstructor
public class TeamAppsController {

    private final TeamAppsService service;

    @GetMapping("/teams")
    private Set<String> listTeams() {
        return service.listTeams();
    }

    @GetMapping("/teams/{team}/apps")
    private List<TeamApp> listTeamApps(@PathVariable String team) {
        return service.listTeamApps(team);
    }
}

Whats next

Conclusion

Referenced Code