Cliente java oficial ocho de Kubernetes: estilo fluido

Bienvenido a mi GitHub

https://github.com/zq2599/blog_demos
content: resumen de clasificación de todos los artículos originales y código fuente de apoyo, que involucran Java, Docker, Kubernetes, DevOPS, etc .;

Visión general

Este artículo es el octavo de la serie "Cliente java oficial de Kubernetes". Los clientes java que se mencionan a continuación se refieren a client-jar.jar;
El artículo anterior "Kubernetes Official Java Client Seven: Patch Operation" involucra demasiados puntos de conocimiento, códigos y operaciones, lo cual es una gran tortura para el autor y los lectores . En este artículo, relajémonos y escribamos algunos códigos simples y fluidos. , Comprenda el soporte del cliente java para la programación de estilo fluido, y la operación de verificación después de la codificación es muy simple;

Acerca del estilo fluido

También conocido como codificación fluida, programación fluida, es un estilo que mejora la legibilidad del código, haciéndolo más natural y fluido al leer el código. La característica es que la función devuelve el tipo relevante, lo que hace múltiples llamadas de función antes y después del enlace.
Para un estilo fluido, consulte el artículo de Martin Flowler publicado en 2005 en https://martinfowler.com/bliki/FluentInterface.html. La comparación de códigos antes y después de usar el estilo fluido se muestra en la siguiente figura:

Descarga de fuente

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

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:

Resumen de los pasos de combate reales

Crear un nuevo subproyecto llamado fluidez en el marco del proyecto principal kubernetesclient ;
Solo hay una clase FluentStyleApplication en el proyecto fluido, el método principal de inicio y el código de estilo fluido están en esta clase;
FluentStyleApplication.java proporciona cuatro interfaces web, las funciones son: nuevo espacio de nombres, nueva implementación, nuevo servicio y eliminar todos los recursos creados por las tres interfaces anteriores;
Una vez codificado el proyecto fluido , no es necesario convertirlo en un espejo e implementarlo dentro del entorno de kubernetes, sino como una aplicación SpringBoot normal para encontrar un entorno Java para iniciar, implementar y comenzar con el artículo "Cliente oficial Java tres de Kubernetes: Aplicación externa". Consistente
Llame a cada interfaz a su vez para verificar si la función cumple con las expectativas;

codificación

Crear un nuevo subproyecto experto nombrado fluidez en el marco del proyecto principal kubernetesclient. El contenido del pom.xml es el siguiente Cabe señalar que. Resorte de arranque-motor de arranque-JSON se excluye Por las razones, consulte. "Kubernetes Oficial de Java Client Dos: La serialización y Anti Problemas de serialización :

<?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>fluent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>fluent</name>
    <description>Demo project for fluent style</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>

Cree un nuevo FluentStyleApplication.java . En primer lugar, esta clase se utiliza como clase de inicio y tiene un método principal:

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

Defina la constante NAMESPACE como el espacio de nombres de este combate real:

private final static String NAMESPACE = "fluent";

Utilice la anotación @PostConstruct para modificar el método setDefaultApiClient de modo que se ejecute una vez durante la instanciación. Se han realizado algunos ajustes de inicialización global. Tenga en cuenta que la ruta del archivo de configuración correspondiente a la variable kubeConfigPath debe ser correcta:

/**
     * 默认的全局设置
     * @return
     * @throws Exception
     */
    @PostConstruct
    private void setDefaultApiClient() 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();

        // 会打印和API Server之间请求响应的详细内容，生产环境慎用
        client.setDebugging(true);

        // 创建操作类
        Configuration.setDefaultApiClient(client);
    }

Lo siguiente es crear el servicio web de espacio de nombres, como se muestra a continuación, debido a que la apiVersion del espacio de nombres en kubernetes es v1, se crea la instancia V1Namespace :

 @RequestMapping(value = "/fluent/createnamespace")
    public V1Namespace createnamespace() throws Exception {
    
    

        V1Namespace v1Namespace = new V1NamespaceBuilder()
                .withNewMetadata()
                .withName(NAMESPACE)
                .addToLabels("label1", "aaa")
                .addToLabels("label2", "bbb")
                .endMetadata()
                .build();

        return new CoreV1Api().createNamespace(v1Namespace, null, null, null);
    }

Para mostrar el efecto de estilo fluido con mayor claridad , compare el código anterior con el contenido del archivo yaml que creó el espacio de nombres. Como se muestra en la figura siguiente, se puede ver que el código se puede escribir comparando el archivo yaml:
A continuación está el código para crear el servicio. Para facilitar la correspondencia con yaml, el código está especialmente sangrado:

 @RequestMapping(value = "/fluent/createservice")
    public V1Service createservice() throws Exception {
    
    
        V1Service v1Service = new V1ServiceBuilder()
                // meta设置
                .withNewMetadata()
                    .withName("nginx")
                .endMetadata()

                // spec设置
                .withNewSpec()
                    .withType("NodePort")
                    .addToPorts(new V1ServicePort().port(80).nodePort(30103))
                    .addToSelector("name", "nginx")
                .endSpec()
                .build();

        return new CoreV1Api().createNamespacedService(NAMESPACE, v1Service, null, null, null);
    }

El código para crear la implementación es el siguiente. Debido al contenido, es relativamente complicado. Tenga en cuenta que debido a que la apiVersion de implementación en kubernetes es extensions / v1beta1 , se crea la instancia de ExtensionsV1beta1Deployment :

 @RequestMapping(value = "/fluent/createdeployment")
    public ExtensionsV1beta1Deployment createdeployment() throws Exception {
    
    
        ExtensionsV1beta1Deployment v1Deployment = new ExtensionsV1beta1DeploymentBuilder()
                // meta设置
                .withNewMetadata()
                    .withName("nginx")
                .endMetadata()

                // spec设置
                .withNewSpec()
                    .withReplicas(1)
                    // spec的templat
                    .withNewTemplate()
                        // template的meta
                        .withNewMetadata()
                            .addToLabels("name", "nginx")
                        .endMetadata()

                        // template的spec
                        .withNewSpec()
                            .addNewContainer()
                                .withName("nginx")
                                .withImage("nginx:1.18.0")
                                .addToPorts(new V1ContainerPort().containerPort(80))
                            .endContainer()
                        .endSpec()

                    .endTemplate()
                .endSpec()
                .build();

        return new ExtensionsV1beta1Api().createNamespacedDeployment(NAMESPACE, v1Deployment, null, null, null);
    }

Se puede ver en el código anterior que withXXX y endXXX aparecen como un par. Tenga cuidado de no omitir endXXX al programar. Se recomienda escribir endXXX mientras escribe conXXX;
El último método es limpiar todos los recursos. La implementación, el servicio y el espacio de nombres creados anteriormente se limpian aquí. Se descubrió una situación embarazosa en la operación real: cuando se eliminan la implementación y el espacio de nombres, se reciben todas las solicitudes de eliminación enviadas al servidor API. La operación recibida es una respuesta exitosa, pero el cliente de kubernetes lanza una excepción al deserializar el contenido de la respuesta (los detalles se muestran en el registro). Tengo una capacidad limitada y aún no he encontrado una solución , así que solo puedo usar try catch para evitar todo el método. Se lanza una excepción. Afortunadamente, Kubernetes se ha eliminado con éxito, con poco impacto:

    @RequestMapping(value = "/fluent/clear")
    public String clear() throws Exception {
    
    

        // 删除deployment
        try {
    
    
            new ExtensionsV1beta1Api().deleteNamespacedDeployment("nginx", NAMESPACE, null, null, null, null, null, null);
        } catch (Exception e)
        {
    
    
            log.error("delete deployment error", e);
        }

        CoreV1Api coreV1Api = new CoreV1Api();

        // 删除service
        coreV1Api.deleteNamespacedService("nginx", NAMESPACE, null, null, null, null, null, null);

        // 删除namespace
        try {
    
    
            coreV1Api.deleteNamespace(NAMESPACE, null, null, null, null, null, null);
        } catch (Exception e)
        {
    
    
            log.error("delete namespace error", e);
        }

        return "clear finish, " + new Date();
    }

La codificación se ha completado, inicie el proyecto fluido y luego comience a verificar si la función es normal;

verificación

Inicie el proyecto fluido directamente en el entorno de IEDA;
Visita del navegador: http: // localhost: 8080 / fluent / createnamespace , la página mostrará la información completa del espacio de nombres devuelta por el servidor API:
Visita del navegador: http: // localhost: 8080 / fluent / createdervice , la página mostrará la información completa del servicio devuelta por el servidor API:
Visita del navegador: http: // localhost: 8080 / fluent / createdeployment , la página mostrará la información de implementación completa devuelta por el servidor API:
Verifique que los servicios creados por las interfaces anteriores estén disponibles. La dirección IP de mis kubernetes es 192.168.50.135 , así que visito: http://192.168.50.135:30103 , y la página de inicio de nginx se puede mostrar normalmente:
Inicie sesión en el servidor de kubernetes a través de SSH para ver que los recursos creados a través del cliente java de kubernetes son todos normales:
Una vez completada la verificación, el navegador visita: http: // localhost: 8080 / fluent / clear para borrar los recursos creados por las tres primeras interfaces;

En este punto, el combate real de llamar al cliente java basado en un estilo fluido está completo. Espero que puedas usar este estilo de llamada API con soltura para hacer que la codificación sea más fácil y fluida. Por cierto, observemos algunas operaciones simples y fáciles en el próximo artículo. El objetivo es Familiarizado con las operaciones comunes del cliente java;

Cliente java oficial ocho de Kubernetes: estilo fluido

Bienvenido a mi GitHub

Visión general

Acerca del estilo fluido

Descarga de fuente

Resumen de los pasos de combate reales

codificación

verificación

Supongo que te gusta