Cliente java oficial de Kubernetes tercero: aplicaciones externas

Bienvenido a mi GitHub

https://github.com/zq2599/blog_demos

Visión general

1. El cliente java mencionado a continuación se refiere a client-jar.jar ;
2. Este artículo es el tercer artículo de la serie "Cliente Java oficial de Kubernetes". En el artículo "Cliente Java oficial de Kubernetes: Preparación" , hemos hecho los preparativos para el combate real y hemos entrado en la fase de combate real desde este artículo;
3. El objetivo de este artículo es desarrollar una aplicación SpringBoot llamada OutsideclusterApplication . La aplicación no se implementa en el entorno K8S. El archivo de configuración utilizado se copia manualmente del entorno K8S. El cliente java puede acceder de forma remota al servidor API en K8S a través de este archivo de configuración. , Para lograr todas las funciones del cliente, la implementación general es la siguiente:
   

• Después de la introducción, comience a codificar;

Descarga de fuente

1. Si no desea codificar, puede descargar todo el código fuente en GitHub. La dirección y la información del enlace se muestran en la siguiente tabla (https://github.com/zq2599/blog_demos):

nombre	enlace	Observaciones
Página de inicio del proyecto	https://github.com/zq2599/blog_demos	La página de inicio del proyecto en GitHub
dirección del almacén de git (https)	https://github.com/zq2599/blog_demos.git	La dirección del almacén del código fuente del proyecto, protocolo https
dirección del almacén de git (ssh)	[email protected]: zq2599 / blog_demos.git	La dirección del almacén del código fuente del proyecto, protocolo ssh

2. Hay varias carpetas en este proyecto de git. La aplicación de este capítulo se encuentra en la carpeta kubernetesclient , como se muestra en el cuadro rojo a continuación:
   

Aplicación implementada fuera de K8S: OutsideclusterApplication

La aplicación denominada OutsideclusterApplication no se implementa en el entorno K8S. La clave para que la aplicación pueda acceder al entorno K8S es copiar una copia del archivo de configuración del entorno K8S y colocarlo en una ubicación accesible por OutsideclusterApplication:

1. Inicie sesión en el entorno K8S, busque el archivo de configuración en el directorio ~ / .kube, copie este archivo en la máquina donde se ejecuta OutsideclusterApplication (la ruta que guardo aquí es / Users / zhaoqin / temp / 202007/05 /, que es coherente con el código subyacente) ；
2. Abra el proyecto kubernetesclient creado en "Cliente Java oficial de Kubernetes: Preparación" y cree un subproyecto en él llamado OutsideclusterApplication . Este es un proyecto SpringBoot. El contenido de pom.xml es el siguiente:

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>com.bolingcavalry</groupId>
        <artifactId>kubernetesclient</artifactId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>

    <groupId>com.bolingcavalry</groupId>
    <artifactId>outsidecluster</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>outsidecluster</name>
    <description>Demo project for Spring Boot</description>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-json</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>io.kubernetes</groupId>
            <artifactId>client-java</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.0.RELEASE</version>
            </plugin>
        </plugins>
    </build>

</project>

3. En el pom.xml anterior, debe tenerse en cuenta que cuando se confía en spring-boot-starter-web, la sintaxis de exclusión se usa para excluir la dependencia de spring-boot-starter-json. Esto es para eliminar todas las dependencias de jackson (spring- boot-starter-json se basa en jackson), por lo que no hay una biblioteca jackson en toda la ruta de clases.En este momento, el marco SpringBoot usará gson como una herramienta de serialización y deserialización (client-java.jar depende de la biblioteca gson); (Este problema se describe en detalle en el artículo "Cliente oficial Java dos de Kubernetes: Problemas de serialización y deserialización" )
4. Se agregó OutsideclusterApplication.java, por simplicidad, esta clase es una clase de arranque y un controlador:

package com.bolingcavalry.outsidecluster;

import com.google.gson.GsonBuilder;
import io.kubernetes.client.openapi.ApiClient;
import io.kubernetes.client.openapi.Configuration;
import io.kubernetes.client.openapi.apis.CoreV1Api;
import io.kubernetes.client.openapi.models.V1PodList;
import io.kubernetes.client.util.ClientBuilder;
import io.kubernetes.client.util.KubeConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.FileReader;

@SpringBootApplication
@RestController
@Slf4j
public class OutsideclusterApplication {
    
    

    public static void main(String[] args) {
    
    
        SpringApplication.run(OutsideclusterApplication.class, args);
    }

    @RequestMapping(value = "/hello")
    public V1PodList hello() throws Exception {
    
    
        // 存放K8S的config文件的全路径
        String kubeConfigPath = "/Users/zhaoqin/temp/202007/05/config";

        // 以config作为入参创建的client对象，可以访问到K8S的API Server
        ApiClient client = ClientBuilder
                .kubeconfig(KubeConfig.loadKubeConfig(new FileReader(kubeConfigPath)))
                .build();

        Configuration.setDefaultApiClient(client);

        CoreV1Api api = new CoreV1Api();

        // 调用客户端API取得所有pod信息
        V1PodList v1PodList = api.listPodForAllNamespaces(null, null, null, null, null, null, null, null, null);

        // 使用jackson将集合对象序列化成JSON，在日志中打印出来
        log.info("pod info \n{}", new GsonBuilder().setPrettyPrinting().create().toJson(v1PodList));

        return v1PodList;
    }

}

5. Ejecute el código anterior y visite http: // localhost: 8080 / hello en el navegador para obtener los detalles de todos los pods de K8S, como se muestra a continuación (para que los datos devueltos sean más ordenados y hermosos, uso el navegador Firefox):
   

6. Compruebe la consola, el registro visible también imprimirá los detalles:
   

• En este punto, nuestra primera aplicación que usa el cliente java oficial de K8S está completa, y el próximo combate real intentará implementar la aplicación en el entorno K8S y realizar varias operaciones dentro de K8S;