springboot获取k8s的api接口

最新推荐文章于 2024-08-29 19:58:29 发布
最新推荐文章于 2024-08-29 19:58:29 发布
阅读量7.1k 收藏 33
点赞数 6
分类专栏： 容器化 文章标签： k8sApi k8s接口提供 kubernetes api kubernetes接口调用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dfBeautifulLive/article/details/102874791
版权

 因为我们公司现有的项目部署在k8s集群中，然后做的项目是想要查看自己部署集群的项目以及容器信息和运行情况，然后发现k8s其实有对外展示的接口，并且也支持java开发，但是无奈这部分的内容网上偏少但好在最后还是顺利的解决问题，在此说明，我们k8s的可视化使用的是在k8s之上封装的插件或者说是软件叫kuboard，这个可以不用我们部署再自己打yaml文件了，甚至部署应用也可以进行分层是相当的方便，真的推荐使用。

下面说下介绍下具体怎么调用K8s的官方提供的接口 

1.java调用api需要引入jar包

  <dependency>
      <groupId>io.kubernetes</groupId>
      <artifactId>client-java</artifactId>
      <version>5.0.0</version>
      <scope>compile</scope>
  </dependency>

 2 我是用restapi实现的也就是https://ip:6443就可以去获取k8s的一系列的接口，但是前提需要权限的，因为kuboard查看界面需要token，那个token就能有k8s获取接口的权限，我是把相应的信息放入了配置文件，那么上代码

k8s:
  api-http: https://192.168.7.102:6443
  token: eyJhbGciOiJSUzI1NiIsImtpZCI6IlBFRUUtalNxT3FIX0c1aDd3ckRiNFlIVGIxM3lReFBtbzdmWXJ0V3hxTzQifQ.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJrdWJlLXN5c3RlbSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VjcmV0Lm5hbWUiOiJrdWJvYXJkLXVzZXItdG9rZW4tY3E1dGIiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC5uYW1lIjoia3Vib2FyZC11c2VyIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQudWlkIjoiZGQ1YmVmNmUtNjNmMC00ODgyLWI2MjItOWY4YzNlNWJjNjJhIiwic3ViIjoic3lzdGVtOnNlcnZpY2VhY2NvdW50Omt1YmUtc3lzdGVtOmt1Ym9hcmQtdXNlciJ9.MK9WUHJ50DxwqlPqPW6aH-U_Ww0qWNm-HX8PPejBjEPaG4YO3McjdviStT4p8t80iSIYq9NlrLUDcqghmJhxkF-z4Of4cqVwmgSbQ7WML07f0ynSD0UDIWV-YEwBsuMBHVfWGquy1aghlEU8V4gknImwU1_DkvDHZXQFYgGXaqUSf1DyRzkkcZahhlVvx-96ajKZ_4ciVYgxWeTig07bercWrLcMzh8GQoNOjEj_uAjXfoSstR1baK41MU_2qmvpSKu0lacZkInurXjbQ5IXpNQ8XCFiNzCbVGXU5JldQQp5T1DZBKy58TmyRCN0OMaxkf0qNsiNjh0bdJdYc651XQ

3. 开始初始化连接k8s的客户端，只要需要获取接口都需要使用，那么我就封装到工具类里了

package gsa.service.overview.util;

import io.kubernetes.client.ApiClient;
import io.kubernetes.client.Configuration;
import io.kubernetes.client.util.ClientBuilder;
import io.kubernetes.client.util.credentials.AccessTokenAuthentication;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * k8s的初始化
 *
 * @Author df
 * @Date 2019/11/1 15:39
 * @Version 1.0
 */
@Component
public class K8sInit {

    @Value("${k8s.api-http}")
    private String httpApi;

    @Value("${k8s.token}")
    private String token;


    /**
     * k8s的初始化
     *
     * @return
     */
    public ApiClient getConnection() {
        ApiClient client = new ClientBuilder().
                setBasePath(httpApi).setVerifyingSsl(false).
                setAuthentication(new AccessTokenAuthentication(token)).build();
        Configuration.setDefaultApiClient(client);
        return client;
    }
}

4.然后咱们示例获取应用空间列表的接口

public V1NamespaceList getNamespace() {
        ApiClient client = k8sInit.getConnection();
        CoreV1Api apiInstance = new CoreV1Api();
        String pretty = "true";
        V1NamespaceList namespaceList = new V1NamespaceList();
        try {
            namespaceList = apiInstance.listNamespace(null, pretty, null, null, null, null, null, null, null);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreV1Api#listNamespace");
            e.printStackTrace();
        }
        return namespaceList;
    }

5.然后controller运行以后咱们postman来运行一下获取k8s集群部署的应用空间名称

{
    "msg": "成功",
    "code": 200,
    "data": {
        "apiVersion": "v1",
        "items": [
            {
                "metadata": {
                    "creationTimestamp": {
                        "year": 2019,
                        "dayOfMonth": 23,
                        "dayOfWeek": 3,
                        "era": 1,
                        "dayOfYear": 296,
                        "weekOfWeekyear": 43,
                        "yearOfCentury": 19,
                        "weekyear": 2019,
                        "monthOfYear": 10,
                        "centuryOfEra": 20,
                        "yearOfEra": 2019,
                        "hourOfDay": 15,
                        "minuteOfHour": 38,
                        "millisOfSecond": 0,
                        "secondOfMinute": 9,
                        "millisOfDay": 56289000,
                        "secondOfDay": 56289,
                        "minuteOfDay": 938,
                        "millis": 1571816289000,
                        "zone": {
                            "fixed": false,
                            "uncachedZone": {
                                "fixed": false,
                                "cachable": true,
                                "id": "Asia/Shanghai"
                            },
                            "id": "Asia/Shanghai"
                        },
                        "chronology": {
                            "zone": {
                                "fixed": false,
                                "uncachedZone": {
                                    "fixed": false,
                                    "cachable": true,
                                    "id": "Asia/Shanghai"
                                },
                                "id": "Asia/Shanghai"
                            }
                        },
                        "afterNow": false,
                        "equalNow": false,
                        "beforeNow": true
                    },
                    "name": "default",
                    "resourceVersion": "153",
                    "selfLink": "/api/v1/namespaces/default",
                    "uid": "0f647b80-f568-11e9-ac35-5254001afee7"
                },
                "spec": {
                    "finalizers": [
                        "kubernetes"
                    ]
                },
                "status": {
                    "phase": "Active"
                }
            },
            {
                "metadata": {
                    "creationTimestamp": {
                        "year": 2019,
                        "dayOfMonth": 23,
                        "dayOfWeek": 3,
                        "era": 1,
                        "dayOfYear": 296,
                        "weekOfWeekyear": 43,
                        "yearOfCentury": 19,
                        "weekyear": 2019,
                        "monthOfYear": 10,
                        "centuryOfEra": 20,
                        "yearOfEra": 2019,
                        "hourOfDay": 15,
                        "minuteOfHour": 38,
                        "millisOfSecond": 0,
                        "secondOfMinute": 6,
                        "millisOfDay": 56286000,
                        "secondOfDay": 56286,
                        "minuteOfDay": 938,
                        "millis": 1571816286000,
                        "zone": {
                            "fixed": false,
                            "uncachedZone": {
                                "fixed": false,
                                "cachable": true,
                                "id": "Asia/Shanghai"
                            },
                            "id": "Asia/Shanghai"
                        },
                        "chronology": {
                            "zone": {
                                "fixed": false,
                                "uncachedZone": {
                                    "fixed": false,
                                    "cachable": true,
                                    "id": "Asia/Shanghai"
                                },
                                "id": "Asia/Shanghai"
                            }
                        },
                        "afterNow": false,
                        "equalNow": false,
                        "beforeNow": true
                    },
                    "name": "kube-node-lease",
                    "resourceVersion": "6",
                    "selfLink": "/api/v1/namespaces/kube-node-lease",
                    "uid": "0d7d0cda-f568-11e9-ac35-5254001afee7"
                },
                "spec": {
                    "finalizers": [
                        "kubernetes"
                    ]
                },
                "status": {
                    "phase": "Active"
                }
            },
            {
                "metadata": {
                    "creationTimestamp": {
                        "year": 2019,
                        "dayOfMonth": 23,
                        "dayOfWeek": 3,
                        "era": 1,
                        "dayOfYear": 296,
                        "weekOfWeekyear": 43,
                        "yearOfCentury": 19,
                        "weekyear": 2019,
                        "monthOfYear": 10,
                        "centuryOfEra": 20,
                        "yearOfEra": 2019,
                        "hourOfDay": 15,
                        "minuteOfHour": 38,
                        "millisOfSecond": 0,
                        "secondOfMinute": 6,
                        "millisOfDay": 56286000,
                        "secondOfDay": 56286,
                        "minuteOfDay": 938,
                        "millis": 1571816286000,
                        "zone": {
                            "fixed": false,
                            "uncachedZone": {
                                "fixed": false,
                                "cachable": true,
                                "id": "Asia/Shanghai"
                            },
                            "id": "Asia/Shanghai"
                        },
                        "chronology": {
                            "zone": {
                                "fixed": false,
                                "uncachedZone": {
                                    "fixed": false,
                                    "cachable": true,
                                    "id": "Asia/Shanghai"
                                },
                                "id": "Asia/Shanghai"
                            }
                        },
                        "afterNow": false,
                        "equalNow": false,
                        "beforeNow": true
                    },
                    "name": "kube-public",
                    "resourceVersion": "5",
                    "selfLink": "/api/v1/namespaces/kube-public",
                    "uid": "0d7ca439-f568-11e9-ac35-5254001afee7"
                },
                "spec": {
                    "finalizers": [
                        "kubernetes"
                    ]
                },
                "status": {
                    "phase": "Active"
                }
            },
            {
                "metadata": {
                    "creationTimestamp": {
                        "year": 2019,
                        "dayOfMonth": 23,
                        "dayOfWeek": 3,
                        "era": 1,
                        "dayOfYear": 296,
                        "weekOfWeekyear": 43,
                        "yearOfCentury": 19,
                        "weekyear": 2019,
                        "monthOfYear": 10,
                        "centuryOfEra": 20,
                        "yearOfEra": 2019,
                        "hourOfDay": 15,
                        "minuteOfHour": 38,
                        "millisOfSecond": 0,
                        "secondOfMinute": 6,
                        "millisOfDay": 56286000,
                        "secondOfDay": 56286,
                        "minuteOfDay": 938,
                        "millis": 1571816286000,
                        "zone": {
                            "fixed": false,
                            "uncachedZone": {
                                "fixed": false,
                                "cachable": true,
                                "id": "Asia/Shanghai"
                            },
                            "id": "Asia/Shanghai"
                        },
                        "chronology": {
                            "zone": {
                                "fixed": false,
                                "uncachedZone": {
                                    "fixed": false,
                                    "cachable": true,
                                    "id": "Asia/Shanghai"
                                },
                                "id": "Asia/Shanghai"
                            }
                        },
                        "afterNow": false,
                        "equalNow": false,
                        "beforeNow": true
                    },
                    "name": "kube-system",
                    "resourceVersion": "4",
                    "selfLink": "/api/v1/namespaces/kube-system",
                    "uid": "0d7be3a0-f568-11e9-ac35-5254001afee7"
                },
                "spec": {
                    "finalizers": [
                        "kubernetes"
                    ]
                },
                "status": {
                    "phase": "Active"
                }
            },
            {
                "metadata": {
                    "creationTimestamp": {
                        "year": 2019,
                        "dayOfMonth": 28,
                        "dayOfWeek": 1,
                        "era": 1,
                        "dayOfYear": 301,
                        "weekOfWeekyear": 44,
                        "yearOfCentury": 19,
                        "weekyear": 2019,
                        "monthOfYear": 10,
                        "centuryOfEra": 20,
                        "yearOfEra": 2019,
                        "hourOfDay": 17,
                        "minuteOfHour": 26,
                        "millisOfSecond": 0,
                        "secondOfMinute": 9,
                        "millisOfDay": 62769000,
                        "secondOfDay": 62769,
                        "minuteOfDay": 1046,
                        "millis": 1572254769000,
                        "zone": {
                            "fixed": false,
                            "uncachedZone": {
                                "fixed": false,
                                "cachable": true,
                                "id": "Asia/Shanghai"
                            },
                            "id": "Asia/Shanghai"
                        },
                        "chronology": {
                            "zone": {
                                "fixed": false,
                                "uncachedZone": {
                                    "fixed": false,
                                    "cachable": true,
                                    "id": "Asia/Shanghai"
                                },
                                "id": "Asia/Shanghai"
                            }
                        },
                        "afterNow": false,
                        "equalNow": false,
                        "beforeNow": true
                    },
                    "name": "test",
                    "resourceVersion": "534065",
                    "selfLink": "/api/v1/namespaces/test",
                    "uid": "f9eca43c-f964-11e9-ac35-5254001afee7"
                },
                "spec": {
                    "finalizers": [
                        "kubernetes"
                    ]
                },
                "status": {
                    "phase": "Active"
                }
            }
        ],
        "kind": "NamespaceList",
        "metadata": {
            "resourceVersion": "1078870",
            "selfLink": "/api/v1/namespaces"
        }
    }
}

6.那么如果想获取pod容器信息呢！通过以下这个接口获取容器的信息

package gsa.service.overview.service.impl.k8s;

import gsa.service.overview.service.k8s.K8sPodApiService;
import gsa.service.overview.util.K8sInit;
import io.kubernetes.client.ApiClient;
import io.kubernetes.client.ApiException;
import io.kubernetes.client.apis.CoreV1Api;
import io.kubernetes.client.models.V1PodList;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * @Author df
 * @Date 2019/11/1 17:24
 * @Version 1.0
 */
@Service
public class K8sPodApiServiceImpl implements K8sPodApiService {
    @Resource
    private K8sInit k8sInit;

    @Override
    public V1PodList getPodByNamePace(String namespace) {
        ApiClient client = k8sInit.getConnection();
        CoreV1Api apiInstance = new CoreV1Api();
        namespace = namespace; 
        String pretty = "pretty_example";
        V1PodList result = new V1PodList();
        try {
            result = apiInstance.listNamespacedPod(namespace, null, pretty, null, null, null, null, null, null, null);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreV1Api#listNamespacedPod");
            e.printStackTrace();
        }
        return result;
    }
}

7.然后结果是这样的

然后还想看更多的k8s调用信息请看官方提供的api文档可以看这个文档

https://github.com/kubernetes-client/java/tree/master/kubernetes/docs

里边的api后缀全部都是k8s提供的接口

点击进去查看具体都是怎么调用接口的都可以看到

比如我说查询某个应用空间下的所有service

 

 

PromisingGirl-Du
关注
专栏目录
K8s（二十二）：k8s集群如何部署一个Spring Boot项目（依赖于MySQL和Redis外部服务)
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
04-21 1万+
🔴 K8s（二十二）：k8s集群如何部署一个Spring Boot项目（依赖于MySQL和Redis外部服务)
KubernetesAPIJavaClient
04-11
java 实现kubernetesApi 调用
java 调用 k8s api_k8s api(官方api)调用(java版)
weixin_42465953的博客
03-05 3406
获取API在GitHub上找到该项目 https://github.com/kubernetes-client/java/下载到Maven仓库在maven仓库的文件夹里面执行下面代码git clone --recursive https://github.com/kubernetes-client/javacd javamvn install这样在maven就可以直接导入给项目(可以在在maven...
K8s 核心组件——API Server
谦虚使人发胖的博客
07-23 1793
Kubernetes API Server（API Server）是 Kubernetes 的核心组件之一，负责暴露 Kubernetes API 给用户和客户端，接收和处理来自客户端的请求，并将其存储到 etcd 中。Kubernetes API Server 主要作用是提供 Kubernetes 各类资源对象（如 Pod、Deployment、Service等）的增、删、改、查及 Watch 等 HTTP REST 接口，是集群内各个功能模块直接数据交互和通信的中心枢纽，是整个系统的数据总线和数据中心。
Springboot使用fabric8调用Kubernetes Api(token方式)
Zhangmaoyang的博客
02-18 5033
fabric8官方Github地址 其中kubernetes-examples模块中有大量示例代码可以参考 一、引入依赖 <dependency> <groupId>io.fabric8</groupId> <artifactId>kubernetes-client</artifactId> <version>5.0.0</version> </dependency> 二、获取t
springboot调用k8s-api以io.fabric8方式创建容器删除命名空间
dfBeautifulLive的博客
11-15 3404
上一篇博客讲的是client-java方式来调用k8s客户端接口进行操作https://blog.csdn.net/dfBeautifulLive/article/details/103084362 这一篇就用io.fabric8方式来调用k8s客户端接口进行操作把！ 1.初始化连接 public KubernetesClient fabric8Connection...
基于K8sSVC springboot 服务间调用
weixin_39041673的博客
05-19 1050
apiVersion: v1kind: Servicemetadata: labels: app: my-dep name: my-depspec: ports: - port: 8000 #设定Serivce对集群内部暴露的端口. protocol: TCP targetPort: 80 #设定Pod的端口,即Pod网络的端口。1.endpoint是k8s集群中的一个资源对象，存储在etcd中，用来记录一个service对应的所有pod的访问地址。
Spring Boot集成kubernetes客户端实现API操作k8s集群
最新发布
HBLOG
08-29 1665
Kubernetes（也称 k8s 或 “kube”）是一个开源的容器编排平台，可以自动化在部署、管理和扩展容器化应用过程中涉及的许多手动操作。Kubernetes 最初是由 Google 工程师作为Borg项目开发和设计的，后于 2015 年捐赠给云原生计算基金会（CNCF）。红帽® 是第一批与 Google 合作研发 Kubernetes 的公司之一，作为 Kubernetes 上游项目的第二大贡献者，我们甚至在这个项目启动之前就已参与其中。早期，各个组织是在物理服务器上运行应用程序。
持续交付+springboot+k8s
星月IWJ
12-07 1709
容器化部署持续交付 1,课程导学 snapshot 是开发版本 release 是发布版本 devOps(敏捷开发) 2,如何持续集成 计划--->代码--->构建(敏捷开发)--->测试(持续集成)--->发布(持续交付)--->部署(持续部署)--->运维(devOps) jenkins--->ansible--->Vault--->不同环境 发布 灰度(蓝绿发布) 先一小部分用户体验新版本 金丝雀发布...
javaweb k8s_使用Java调用 K8S API获取信息
weixin_29207149的博客
02-01 3390
k8s管理不仅提供了命令行工具，还提供了完整的rest api接口供用户使用，其dashboard就是基于该api接口实现的，我们可以通过这些api实现自定义的管理及监控等功能，本文我们使用java实现最基本的接口调用。实现过程配置文件进入 master节点，导出k8s证书config文件cd /root/.kubesz config #下载该文件然后我们将文件改名为k8s.config，复制...
把springboot项目弄到K8S集群上，并开放端口供外部访问
wobupeiai的博客
09-21 3050
1.用idea创建一个project，new project->spring initializr->添加一个spring web，groupId随便取，artifactId取test，点finish即可，不要用webflux 2.新建一个controller，随便写个web接口，如 @GetMapping("/{args}") public String helloWorld(...
手把手带你玩转k8s-一键部署springboot项目
mldong的博客
05-11 787
前言 本文的一键部署，其实就是将部署流程化的命令转成shell脚本，当然，因为是发布到k8s集群上，所以发布的命令和需要的东西会有些不一样。本文的一键部署脚本是基于 打造一款适合自己的快速开发框架-持续部署之一键发布脚本设计与实现这篇文章进行改造的。所以建议大家先把该篇文章先看一篇。 知识准备 关于基础镜像制作 基础镜像一般可以直接使用openjdk: 8u212-jdk-alpine，但是直接使用的话，其功能还是不够，所以我们需要在其基础上进行加工。加入一些必要安装包。以及进行一些初始化工作。 修改源
springboot 接入k8s探活
minjun的博客
06-21 201
有你在 我就放心了
java k8s-client api操作 kubernetes
batman
09-26 3159
API Server简介 k8s API Server提供了k8s各类资源对象（pod,RC,Service等）的增删改查及watch等HTTP Rest接口，是整个系统的数据总线和数据中心。 kubernetes API Server的功能： 提供了集群管理的REST API接口(包括认证授权、数据校验以及集群状态变更)； 提供其他模块之间的数据交互和通信的枢纽（其他模块通过API Server查询或修改数据，只有API Server才直接操作etcd）; 是资源配额控制的入口； 拥有完备的集群安全机.
K8S API调用：使用client-go工具调用kubernetes API接口进行增删改查示例（v1.17.9）
学亮编程手记
12-20 751
go mod init client-go-demo go get k8s.io/client-go@v1.17.9 go mod tidy package main import ( "flag" "fmt" "log" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/kubernetes" "k8s.io/client-go/tools/clientcmd" "time" "bufio" "os"
Spring Boot与Kubernetes结合：构建高可靠、高性能的微服务架构
hitpter的专栏
10-09 1064
Spring Boot和Kubernetes（K8s）是当今非常热门的技术，它们的结合可以帮助开发者更高效地构建、部署和管理应用程序。本文将详细介绍Spring Boot和Kubernetes的主要特点，以及它们结合使用的优势。
docker的接口 外部如何访问k8s_把springboot项目弄到K8S集群上，并开放端口供外部访问...
weixin_31064353的博客
12-23 490
1.用idea创建一个project，new project->spring initializr->添加一个spring web，groupId随便取，artifactId取test，点finish即可，不要用webflux2.新建一个controller，随便写个web接口，如@GetMapping("/{args}")public String helloWorld(@PathV...
istio实战：springboot项目在istio中服务调用
luckywuxn的博客
02-25 1905
在经过前面几天k8s和Istio的安装之后，开始进入最核心的阶段。微服务在抛弃传统的服务注册和服务发现之后，是怎么在istio怎么做服务间的调用的呢？本次实战花费了我2-3天的时间，经过不断的尝试，折腾，最后终于把服务间的调用调通了。下面我将介绍我本次的实践过程，希望对于同样在研究这个技术有困难的同学提供一定的帮助。另外学会了xshell 批量发送请求done。
利用 Swagger Kubernetes 调试 Kubernetes 的 Spring 应用 API & 生成 API 文档
qq_32641153的博客
06-25 954
文章目录一、简介二、架构图三、如何使用1、创建 ServiceAccount2、创建 Swagger kubernetes 服务3、查看创建的资源4、访问 Swagger Kubernetes四、可配置环境变量参数 系统环境： Kubernetes 版本：1.14.0 Swagger Kubernetes 版本： v1.0.0 Swagger Kubernetes Github 地址: http...
springboot整合k8s获取k8s中的数据
08-12
要在Spring Boot中获取K8s中的数据，你可以通过使用K8s Java客户端库来实现。首先，你需要添加以下依赖到你的Spring Boot项目中： ``` <groupId>io.kubernetes <artifactId>client-java <version>xx.x.x ``` ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值