【kubernetes】Java操作k8s-API

前言

提示：这里可以添加本文要记录的大概内容：

在k8s平台上，我们可以使用kubectl命令对deployment、pod、service等资源进行增删改查。本文章将提供一些java代码操作api方式实现与集群交互，来创建、更新、删除和查询资源。

一、准备工作

1、maven依赖

        <!--k8s集群依赖-->
        <dependency>
            <groupid>io.kubernetes</groupid>
            <artifactid>client-java</artifactid>
            <version>7.0.0</version>
        </dependency>

        <dependency>
            <groupid>io.kubernetes</groupid>
            <artifactid>client-java-api</artifactid>
            <version>7.0.0</version>
        </dependency>

2、配置文件

import io.kubernetes.client.openapi.apiclient;
import io.kubernetes.client.util.clientbuilder;
import io.kubernetes.client.util.credentials.accesstokenauthentication;

import java.io.ioexception;

public class kubernetesconfig {
    // 返回client,默认使用这个方法
    public static apiclient defaultclient() throws ioexception {

        /*
         * 机器配置
         * */

		// ip：默认端口
        string master = "https://192.168.0.200:6443";
        // 会很长
        string oauthtoken = "eyjhbxxx...............xxxxxxxxxxxxxxxxx";

        apiclient apiclient = new clientbuilder()
                //设置 k8s 服务所在 ip地址
                .setbasepath(master)
                //是否开启 ssl 验证
                .setverifyingssl(false)
                //插入访问 连接用的 token
                .setauthentication(new accesstokenauthentication(oauthtoken))
                .build();
        io.kubernetes.client.openapi.configuration.setdefaultapiclient(apiclient);
        return apiclient;
    }
}

2.1、tonken获取

可以借助dashboard用户token，获取同样的结果

# 创建用户
kubectl create serviceaccount dashboard-admin -n kube-system

# 用户授权
kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kube-system:dashboard-admin

# # 获取用户token
kubectl describe secrets -n kube-system $(kubectl -n kube-system get secret | awk '/dashboard-admin/{print $1}')

二、deployment

1、创建deployment

import io.kubernetes.client.openapi.apiclient;
import io.kubernetes.client.openapi.apiexception;
import io.kubernetes.client.openapi.configuration;
import io.kubernetes.client.openapi.apis.appsv1api;
import io.kubernetes.client.openapi.models.*;
import io.kubernetes.client.util.config;

import java.io.ioexception;
import java.util.hashmap;
import java.util.map;

public class createnamespaceddeployment {

    public static void createnamespaceddeployment() throws ioexception {

        // 连接交互
        apiclient client = config.defaultclient();
        configuration.setdefaultapiclient(client);
        appsv1api apiinstance = new appsv1api(client);

        //命名空间
        string namespace = "default";
        string name = "depdemo";

        // service.spec.selector下的值
        map<string, string> selectlabels = new hashmap<>();
        selectlabels.put("app", name);

        // 构建deployment
        v1deployment body = new v1deploymentbuilder()
                .withmetadata(new v1objectmetabuilder()
                        .withname(name) // 容器名称
                        .withnamespace(namespace)   // 命名空间
                        .withlabels(selectlabels)   // 标签参数
                        .build())
                .withspec(new v1deploymentspecbuilder()
                        .withreplicas(1)    // 设置默认副本数
                        //设置选择器
                        .withselector(new v1labelselectorbuilder()
                                .withmatchlabels(selectlabels)
                                .build())
                        .withtemplate(new v1podtemplatespecbuilder()
                                .withmetadata(new v1objectmetabuilder()
                                        .withlabels(selectlabels)   //选择器
                                        .build())
                                .withspec(new v1podspecbuilder()
                                        .withcontainers(new v1containerbuilder()
                                                .withname("redisdeployment")  //设置docker名
                                                .withimage("redis:latest")    //docker镜像名
                                                .withimagepullpolicy("ifnotpresent")    // 镜像拉取策略
                                                .build())
                                        .build())
                                .build())
                        .build())
                .build();

        //定义返回结果
        map<string, string> messages = new hashmap<>();

        try {
            // 发送请求
            v1deployment result = apiinstance.createnamespaceddeployment(namespace, body, null, null, null);//调用createnamespaceddeployment方法创建容器部署
            system.out.println(result);
        } catch (apiexception e) {

            if (e.getcode() == 409) {
                messages.put("error", "工作负载创建已重复！");
            } else if (e.getcode() == 200) {
                messages.put("success", "工作负载创建成功！");
            } else if (e.getcode() == 201) {
                messages.put("error", "工作负载创建已重复！");
            } else if (e.getcode() == 401) {
                messages.put("error", "无权限操作！");
            } else {
                messages.put("error", "工作负载创建失败！");
            }
        }

        system.out.println("最终结果----" + messages);
    }

2、删除deployment

import io.kubernetes.client.openapi.apiclient;
import io.kubernetes.client.openapi.apiexception;
import io.kubernetes.client.openapi.configuration;
import io.kubernetes.client.openapi.apis.appsv1api;
import io.kubernetes.client.openapi.models.*;
import io.kubernetes.client.util.config;

import java.io.ioexception;
import java.util.hashmap;
import java.util.map;

    /**
     * 删除对应的容器部署
     * 默认命名空间下-default
     *
     */
    public static void deletedeployment(string deployname) {

        apiclient client = null;
        try {
            client = config.defaultclient();
        } catch (ioexception e) {
            system.out.println("集群连接失败！！！");
            throw new runtimeexception(e);
        }
        appsv1api apiinstance = new appsv1api(client);
        map<string, string> messages = new hashmap<>();

        //deployment 名称    命名空间   控制
        try {
            v1status v1status = apiinstance.deletenamespaceddeployment(deployname, "default", null, null, null, null, null, null);
            system.out.println("v1status-->>>" + v1status);
        } catch (apiexception e) {
            system.out.println("e->>>>" + e.getcode());
            if (e.getcode() == 404) {
                messages.put("error", "工作负载删除失败，请检查参数是否正确！");
            } else if (e.getcode() == 409) {
                messages.put("error", "工作负载删除已重复！");
            } else if (e.getcode() == 200) {
                messages.put("success", "工作负载删除成功！");
            } else if (e.getcode() == 201) {
                messages.put("error", "工作负载删除已重复！");
            } else if (e.getcode() == 401) {
                messages.put("error", "无权限操作！");
            } else {
                messages.put("error", "工作负载删除失败！");
            }
        }

    }

3、查询deployment

import io.kubernetes.client.openapi.apiclient;
import io.kubernetes.client.openapi.apiexception;
import io.kubernetes.client.openapi.configuration;
import io.kubernetes.client.openapi.apis.appsv1api;
import io.kubernetes.client.openapi.models.v1deploymentlist;
import io.kubernetes.client.util.config;

import java.io.ioexception;

public class k8sdemo {

    public static void main(string[] args) throws ioexception {
        try {
            // 加载kubeconfig文件
            apiclient client = config.defaultclient();
            configuration.setdefaultapiclient(client);

            // 创建appsv1api实例
            appsv1api api = new appsv1api();

            // 指定命名空间
            string namespace = "default";

            // 查询指定命名空间下的所有deployment
            v1deploymentlist deploymentlist = api.listnamespaceddeployment(namespace, null, null, null, null, null, null, null, null, null);

            // 输出查询结果
            system.out.println("deployments in namespace " + namespace + ":");
            deploymentlist.getitems().foreach(deployment -> system.out.println(deployment.getmetadata().getname()));

        } catch (apiexception e) {
            system.err.println("exception when calling appsv1api#listnamespaceddeployment: " + e.getmessage());
        }
    }
}

三、pod

1、创建pod

package com.k8s.k8s_demo_chained.server.csdn;

import com.k8s.k8s_demo_chained.config.config;
import io.kubernetes.client.custom.quantity;
import io.kubernetes.client.openapi.apiclient;
import io.kubernetes.client.openapi.apiexception;
import io.kubernetes.client.openapi.configuration;
import io.kubernetes.client.openapi.apis.corev1api;
import io.kubernetes.client.openapi.models.*;

import java.io.ioexception;
import java.util.arrays;
import java.util.hashmap;
import java.util.list;
import java.util.map;

public class codepod2 {


    public static void main(string[] args) throws ioexception {
        apiclient client = config.defaultclient();
        configuration.setdefaultapiclient(client);

        corev1api apiinstance = new corev1api(client);

        // 构建选择器
        map<string, string> selectlabels = new hashmap<>();
        string name = "162-3";
        selectlabels.put("deploy", name);

        // 容器暴漏端口
        list<v1containerport> portlist = arrays.aslist(
                new v1containerport().containerport(8080).protocol("tcp")
        );

        // 资源限制map,--默认会转换成字节
        hashmap<string, quantity> limitsmap = new hashmap<>();
        limitsmap.put("memory", new quantity("4gi"));
        hashmap<string, quantity> requestsmap = new hashmap<>();
        requestsmap.put("memory", new quantity("4gi"));

        // 构建pod
        v1pod body = new v1pod()
                .metadata(new v1objectmeta()
                        .name(name) // 名称
                        .namespace("default")   //命名空间
                        .labels(selectlabels))
                .spec(new v1podspec()
                        .containers(arrays.aslist(new v1container()
                                .name("nginxpod")   // 容器名称
                                .image("nginx:latest")   // 镜像名称
                                .imagepullpolicy("ifnotpresent")   // 镜像拉取策略
                                .ports(portlist)    //对外暴漏接口
                                .volumemounts(arrays.aslist(new v1volumemount()
                                        .name("声明挂载名称-同下")
                                        .mountpath("挂载到容器内执行目录")))
                                .resources(new v1resourcerequirements()
                                        .limits(limitsmap)  //限制参数，构建在上面
                                        .requests(requestsmap))  //限制参数，构建在上面
                                .livenessprobe(new v1probe()
                                        .exec(new v1execaction()
                                                .command(arrays.aslist("/bin/sh", "-c", "shell执行结果"))   // 存活探针-shell方式
                                        )
                                        .initialdelayseconds(300)   // 启动后等待/秒
                                        .periodseconds(60)         // 探测的时间间隔/秒
                                        .failurethreshold(1)        // 失败次数
                                )
                        ))
                        .restartpolicy("never") // pod重启策略
                        .volumes(arrays.aslist(new v1volume()
                                .name("声明挂载名称-同上")
                                .hostpath(new v1hostpathvolumesource()
                                        .path("宿住机目录"))))   //需挂载宿住机的目录结构
                );


        //定义返回结果
        map<string, string> messages = new hashmap<>();
        try {
            v1pod result = apiinstance.createnamespacedpod("default", body, null, null, null);
        } catch (apiexception e) {
            if (e.getcode() == 409) {
                messages.put("error", "pod创建已重复！");
            } else if (e.getcode() == 200) {
                messages.put("success", "pod创建成功！");
            } else if (e.getcode() == 201) {
                messages.put("error", "pod创建已重复！");
            } else if (e.getcode() == 401) {
                messages.put("error", "无权限操作！");
            } else {
                messages.put("error", "pod创建失败！");
            }
        }

        system.out.println("最终结果----" + messages);
    }

}

2、删除pod

import com.k8s.k8s_demo_chained.config.config;
import io.kubernetes.client.custom.quantity;
import io.kubernetes.client.openapi.apiclient;
import io.kubernetes.client.openapi.apiexception;
import io.kubernetes.client.openapi.configuration;
import io.kubernetes.client.openapi.apis.corev1api;
import io.kubernetes.client.openapi.models.*;
import okhttp3.response;
import okhttp3.responsebody;

import java.io.ioexception;
import java.util.arrays;
import java.util.hashmap;
import java.util.list;
import java.util.map;

public class deletepod {
    public static void main(string[] args) throws ioexception {
        apiclient client = config.defaultclient();
        configuration.setdefaultapiclient(client);
        corev1api apiinstance = new corev1api(client);
        try {
            // 删除pod    pod名称    命名空间
            apiinstance.deletenamespacedpodcall("162-3", "default", null, null, null, null, null, null, null).execute();

        } catch (apiexception e) {
        	system.out.println(e);
        }
    }

}

3、查询pod

import io.kubernetes.client.openapi.apiclient;
import io.kubernetes.client.openapi.apiexception;
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.config;

import java.io.ioexception;

public class k8sdemo {
    public static void main(string[] args) throws ioexception {
        try {
            // 加载kubeconfig文件
            apiclient client = config.defaultclient();
            configuration.setdefaultapiclient(client);

            // 创建corev1api实例
            corev1api api = new corev1api();

            // 指定命名空间
            string namespace = "default";

            // 查询指定命名空间下的所有pod
            v1podlist podlist = api.listnamespacedpod(namespace, null, null, null, null, null, null, null, null, null);

            // 输出查询结果
            system.out.println("pods in namespace " + namespace + ":");
            podlist.getitems().foreach(pod -> system.out.println(pod.getmetadata().getname()));
        } catch (apiexception e) {
            system.err.println("exception when calling corev1api#listnamespacedpod: " + e.getmessage());
        }
    }
}

四、sevice

1、创建serivce

import com.k8s.k8s_demo_chained.config.config;
import io.kubernetes.client.custom.intorstring;
import io.kubernetes.client.openapi.apiclient;
import io.kubernetes.client.openapi.apiexception;
import io.kubernetes.client.openapi.apis.corev1api;
import io.kubernetes.client.openapi.models.*;

import java.io.ioexception;
import java.util.arraylist;
import java.util.hashmap;
import java.util.list;
import java.util.map;
import java.util.stream.collectors;

public class codeserve {

    public static void main(string[] args) throws ioexception {
        apiclient client = config.defaultclient();
        corev1api corev1api = new corev1api(client);


        //端口暴露服务的对应的是 service.spec.selector下的值
        map<string, string> selectlabels = new hashmap<>();
        string name = "162-3";
        string servicename = "service-162-3";
        selectlabels.put("deploy", name);

// 创建 v1serviceportbuilder 对象列表
        list<v1serviceportbuilder> portbuilders = new arraylist<>();

        // 添加端口构建器到列表中
        portbuilders.add(new v1serviceportbuilder()
                .withprotocol("tcp")
                .withport(8080)
                .withtargetport(new intorstring(8080))  //目标接口
                .withnodeport(30880));  // 对外网暴漏端口

        // 使用 stream api 将 portbuilders 列表转换为 serviceports 列表
        list<v1serviceport> serviceports = portbuilders.stream()
                .map(v1serviceportbuilder::build)
                .collect(collectors.tolist());


        v1service body = new v1servicebuilder()
                .withmetadata(new v1objectmetabuilder()
                        .withname("网络名称") //dns-1035
                        .withnamespace("default")   //命名空间
                        .build())
                .withspec(new v1servicespecbuilder()
                        .withtype("nodeport") // 设置服务类型为nodeport
                        .withselector(selectlabels) // 设置选择器
                        .withports(serviceports)
                        .build())
                .build();


        //定义返回结果
        map<string, string> messages = new hashmap<>();
        try {
            corev1api.createnamespacedservice("default", body, null, null, null);
            messages.put("success", "网络创建成功！");
        } catch (apiexception e) {
            system.out.println(e);
            if (e.getcode() == 409) {
                messages.put("error", "网络创建已重复！");
            } else if (e.getcode() == 200) {
                messages.put("success", "网络创建成功！");
            } else if (e.getcode() == 201) {
                messages.put("error", "网络创建已重复！");
            } else if (e.getcode() == 401) {
                messages.put("error", "无权限操作！");
            } else {
                messages.put("error", "网络创建失败！");
            }
        }

        system.out.println("最终结果----" + messages);
    }
}

2、删除serivce

package com.k8s.k8s_demo_chained.server.csdn;

import com.k8s.k8s_demo_chained.config.config;
import io.kubernetes.client.openapi.apiclient;
import io.kubernetes.client.openapi.apiexception;
import io.kubernetes.client.openapi.configuration;
import io.kubernetes.client.openapi.apis.corev1api;
import io.kubernetes.client.openapi.models.v1status;

import java.io.ioexception;
import java.util.hashmap;
import java.util.map;

public class deleteservice {

    public static void main(string[] args) throws ioexception {
        apiclient client = config.defaultclient();
        configuration.setdefaultapiclient(client);
        corev1api apiinstance = new corev1api(client);

        map<string, string> selectlabels = new hashmap<>();
        string name = "162-3";
        selectlabels.put("deploy", name);
        
        try {
            v1status v1status = apiinstance.deletenamespacedservice("service-162-3", "default", null, null, null, null, null, null);
        } catch (apiexception e) {
         system.out.println(e)
        }
    }

}

3、查询serivce

package com.k8s.k8s_demo_chained.server.csdn;

import io.kubernetes.client.openapi.apiclient;
import io.kubernetes.client.openapi.apiexception;
import io.kubernetes.client.openapi.configuration;
import io.kubernetes.client.openapi.apis.corev1api;
import io.kubernetes.client.openapi.models.v1servicelist;
import io.kubernetes.client.util.config;

import java.io.ioexception;

public class k8sdemo {
    public static void main(string[] args) throws ioexception {
        try {
            // 加载kubeconfig文件
            apiclient client = config.defaultclient();
            configuration.setdefaultapiclient(client);

            // 创建corev1api实例
            corev1api api = new corev1api();

            // 指定命名空间
            string namespace = "default";

            // 查询指定命名空间下的所有service
            v1servicelist servicelist = api.listnamespacedservice(namespace, null, null, null, null, null, null, null, null, null);

            // 输出查询结果
            system.out.println("services in namespace " + namespace + ":");
            servicelist.getitems().foreach(service -> system.out.println(service.getmetadata().getname()));
        } catch (apiexception e) {
            system.err.println("exception when calling corev1api#listnamespacedservice: " + e.getmessage());
        }
    }
}

四、注意事项

在每次的代码操作之前，都会使用默认的apiclient对象，并将其设置为全局默认的apiclient。
具体来说，config.defaultclient()方法返回一个默认的apiclient对象，该对象已经配置了与kubernetes api服务器通信所需的所有参数，例如api版本、认证信息等。然后，通过调用configuration.setdefaultapiclient(client)方法将这个apiclient对象设置为全局默认的apiclient，这样在后续的操作中就不需要每次都创建一个新的apiclient对象了。
用于初始化kubernetes java客户端库，以便在后续的操作中使用它来与kubernetes api服务器进行交互。
那么，都需要区分开不同操作，构建不同的api,区别如下：

• appsv1api：用于管理 kubernetes 应用程序的 api 对象，如 deployment、statefulset、daemonset 和 replicaset 等
• batchv1api：用于管理 kubernetes 批处理作业的 api 对象，如 job 和 cronjob 等。
• corev1api：用于管理 kubernetes 核心 api 对象，如 pod、service、namespace、node 和 persistentvolume 等。