java使用io.kubernetes.client-java呼叫k8s api創建pod/service/ingress示例-有解無憂

1.maven配置

<!-- k8s client -->
<dependency>
    <groupId>io.kubernetes</groupId>
    <artifactId>client-java</artifactId>
    <version>12.0.1</version>
</dependency>

2.工具類

/**
 * k8s客戶端
 *
 * @author wanghuidong
 * @date 2021/6/18 14:14
 */
@Slf4j
public class K8sClient {

    /**
     * k8s-api客戶端
     */
    private ApiClient apiClient;

    /**
     * 構建集群POD內通過SA訪問的客戶端
     * loading the in-cluster config, including:
     * 1. service-account CA
     * 2. service-account bearer-token
     * 3. service-account namespace
     * 4. master endpoints(ip, port) from pre-set environment variables
     */
    public K8sClient() {
        try {
            this.apiClient = ClientBuilder.cluster().build();
        } catch (IOException e) {
            log.error("構建K8s-Client例外", e);
            throw new RuntimeException("構建K8s-Client例外");
        }
    }

    /**
     * 構建集群外通過UA訪問的客戶端
     * loading the out-of-cluster config, a kubeconfig from file-system
     *
     * @param kubeConfigPath kube連接組態檔
     */
    public K8sClient(String kubeConfigPath) {
        try {
            this.apiClient = ClientBuilder.kubeconfig(KubeConfig.loadKubeConfig(new FileReader(kubeConfigPath))).build();
        } catch (IOException e) {
            log.error("讀取kubeConfigPath例外", e);
            throw new RuntimeException("讀取kubeConfigPath例外");
        } catch (Exception e) {
            log.error("構建K8s-Client例外", e);
            throw new RuntimeException("構建K8s-Client例外");
        }
    }

    /**
     * 獲取所有的Pod
     *
     * @return podList
     */
    public V1PodList getAllPodList() {
        // new a CoreV1Api
        CoreV1Api api = new CoreV1Api(apiClient);

        // invokes the CoreV1Api client
        try {
            V1PodList list = api.listPodForAllNamespaces(null, null, null, null, null, null, null, null, null, null);
            return list;
        } catch (ApiException e) {
            log.error("獲取podlist例外:" + e.getResponseBody(), e);
        }
        return null;
    }

    /**
     * 創建k8s service
     *
     * @param namespace   命名空間
     * @param serviceName 服務名稱
     * @param port        服務埠號（和目標pod的埠號一致）
     * @param selector    pod標簽選擇器
     * @return 創建成功的service物件
     */
    public V1Service createService(String namespace, String serviceName, Integer port, Map<String, String> selector) {
        //構建service的yaml物件
        V1Service svc = new V1ServiceBuilder()
                .withNewMetadata()
                .withName(serviceName)
                .endMetadata()
                .withNewSpec()
                .addNewPort()
                .withProtocol("TCP")
                .withPort(port)
                .withTargetPort(new IntOrString(port))
                .endPort()
                .withSelector(selector)
                .endSpec()
                .build();

        // Deployment and StatefulSet is defined in apps/v1, so you should use AppsV1Api instead of CoreV1API
        CoreV1Api api = new CoreV1Api(apiClient);
        V1Service v1Service = null;
        try {
            v1Service = api.createNamespacedService(namespace, svc, null, null, null);
        } catch (ApiException e) {
            log.error("創建service例外:" + e.getResponseBody(), e);
        } catch (Exception e) {
            log.error("創建service系統例外:", e);
        }
        return v1Service;
    }

    /**
     * 創建k8s V1Ingress
     *
     * @param namespace   命名空間
     * @param ingressName ingress名稱
     * @param annotations ingress注解
     * @param path        匹配的路徑
     * @param serviceName 路由到的服務名稱
     * @param servicePort 路由到的服務埠
     * @return 創建成功的ingress物件
     */
    public V1Ingress createV1Ingress(String namespace, String ingressName, Map<String, String> annotations, String path,
                                     String serviceName, Integer servicePort) {
        //構建ingress的yaml物件
        V1Ingress ingress = new V1IngressBuilder()
                .withNewMetadata()
                .withName(ingressName)
                .withAnnotations(annotations)
                .endMetadata()
                .withNewSpec()
                .addNewRule()
                .withHttp(new V1HTTPIngressRuleValueBuilder().addToPaths(new V1HTTPIngressPathBuilder()
                        .withPath(path)
                        .withPathType("Prefix")
                        .withBackend(new V1IngressBackendBuilder()
                                .withService(new V1IngressServiceBackendBuilder()
                                        .withName(serviceName)
                                        .withPort(new V1ServiceBackendPortBuilder()
                                                .withNumber(servicePort).build()).build()).build()).build()).build())
                .endRule()
                .endSpec()
                .build();

        //呼叫對應的API執行創建ingress的操作
        NetworkingV1Api api = new NetworkingV1Api(apiClient);
        V1Ingress v1Ingress = null;
        try {
            v1Ingress = api.createNamespacedIngress(namespace, ingress, null, null, null);
        } catch (ApiException e) {
            log.error("創建ingress例外:" + e.getResponseBody(), e);
        } catch (Exception e) {
            log.error("創建ingress系統例外:", e);
        }
        return v1Ingress;
    }


    /**
     * 創建k8s ExtensionIngress
     *
     * @param namespace   命名空間
     * @param ingressName ingress名稱
     * @param annotations ingress注解
     * @param path        匹配的路徑
     * @param serviceName 路由到的服務名稱
     * @param servicePort 路由到的服務埠
     * @return 創建成功的ingress物件
     */
    public ExtensionsV1beta1Ingress createExtensionIngress(String namespace, String ingressName, Map<String, String> annotations, String path,
                                                           String serviceName, Integer servicePort) {
        //構建ingress的yaml物件
        ExtensionsV1beta1Ingress ingress = new ExtensionsV1beta1IngressBuilder()
                .withNewMetadata()
                .withName(ingressName)
                .withAnnotations(annotations)
                .endMetadata()
                .withNewSpec()
                .addNewRule()
                .withHttp(new ExtensionsV1beta1HTTPIngressRuleValueBuilder().addToPaths(new ExtensionsV1beta1HTTPIngressPathBuilder()
                        .withPath(path)
                        .withBackend(new ExtensionsV1beta1IngressBackendBuilder()
                                .withServiceName(serviceName)
                                .withServicePort(new IntOrString(servicePort)).build()).build()).build())
                .endRule()
                .endSpec()
                .build();

        //呼叫對應的API執行創建ingress的操作
        ExtensionsV1beta1Api api = new ExtensionsV1beta1Api(apiClient);
        ExtensionsV1beta1Ingress extensionsV1beta1Ingress = null;
        try {
            extensionsV1beta1Ingress = api.createNamespacedIngress(namespace, ingress, null, null, null);
        } catch (ApiException e) {
            log.error("創建ingress例外:" + e.getResponseBody(), e);
        } catch (Exception e) {
            log.error("創建ingress系統例外:", e);
        }
        return extensionsV1beta1Ingress;
    }
}

3.測驗類

/**
 * @author wanghuidong
 * @date 2021/6/18 14:33
 */
public class K8sClientTest {


//    @Test
    public void getAllPodListTest() {
        String kubeConfigPath = "C:\\Users\\admin\\.kube\\config";
        if (!new File(kubeConfigPath).exists()) {
            System.out.println("kubeConfig不存在，跳過");
            return;
        }
        K8sClient k8sClient = new K8sClient(kubeConfigPath);
        V1PodList podList = k8sClient.getAllPodList();
        for (V1Pod item : podList.getItems()) {
            System.out.println(item.getMetadata().getNamespace() + ":" + item.getMetadata().getName());
        }
    }


//    @Test
    public void createServiceTest() {
        String kubeConfigPath = "C:\\Users\\admin\\.kube\\config";
        if (!new File(kubeConfigPath).exists()) {
            System.out.println("kubeConfig不存在，跳過");
            return;
        }
        K8sClient k8sClient = new K8sClient(kubeConfigPath);
        String namespace = "default";
        String serviceName = "my-nginx-service";
        Integer port = 80;
        Map<String, String> selector = new HashMap<>();
        selector.put("run", "my-nginx");
        V1Service v1Service = k8sClient.createService(namespace, serviceName, port, selector);
        System.out.println(v1Service != null ? v1Service.getMetadata() : null);
    }

//    @Test
    public void createV1IngressTest() {
        String kubeConfigPath = "C:\\Users\\admin\\.kube\\config";
        if (!new File(kubeConfigPath).exists()) {
            System.out.println("kubeConfig不存在，跳過");
            return;
        }
        K8sClient k8sClient = new K8sClient(kubeConfigPath);
        String namespace = "default";
        String ingressName = "my-nginx-ingress";
        Map<String, String> annotations = new HashMap<>();
        annotations.put("nginx.ingress.kubernetes.io/rewrite-target", "/");
        String path = "/my-nginx";
        String serviceName = "my-nginx-service";
        Integer servicePort = 80;
        V1Ingress v1Ingress = k8sClient.createV1Ingress(namespace, ingressName, annotations, path, serviceName, servicePort);
        System.out.println(v1Ingress != null ? v1Ingress.getMetadata() : null);
    }

//    @Test
    public void createExtensionIngressTest() {
        String kubeConfigPath = "C:\\Users\\admin\\.kube\\config";
        if (!new File(kubeConfigPath).exists()) {
            System.out.println("kubeConfig不存在，跳過");
            return;
        }
        K8sClient k8sClient = new K8sClient(kubeConfigPath);
        String namespace = "default";
        String ingressName = "my-nginx-ingress";
        Map<String, String> annotations = new HashMap<>();
        annotations.put("nginx.ingress.kubernetes.io/rewrite-target", "/");
        String path = "/my-nginx";
        String serviceName = "my-nginx-service";
        Integer servicePort = 80;
        ExtensionsV1beta1Ingress extensionsV1beta1Ingress = k8sClient.createExtensionIngress(namespace, ingressName, annotations, path, serviceName, servicePort);
        System.out.println(extensionsV1beta1Ingress != null ? extensionsV1beta1Ingress.getMetadata() : null);
    }
}

4.附錄

4.1 創建pod應用

my-nginx.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  selector:
    matchLabels:
      run: my-nginx
  replicas: 2
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - name: my-nginx
        image: nginx
        ports:
        - containerPort: 80

應用部署單，生成pod

kubectl apply -f ./my-nginx.yaml

查看相關pod資訊
kubectl get pods -l run=my-nginx -o wide

4.2 創建service

my-nginx-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: my-nginx-service
  labels:
    run: my-nginx-service
spec:
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
  selector:
    run: my-nginx

應用service單，創建service

kubectl apply -f ./my-nginx-service.yaml

查看相關服務
kubectl get svc my-nginx-service

查詢服務詳情
kubectl describe svc my-nginx-service

查看service后端結點
kubectl get ep my-nginx-service

4.3 創建ingress(ExtensionV1beta1)

my-nginx-ingress.yaml

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: my-nginx-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - http:
      paths:
      - path: /my-nginx
        backend:
          serviceName: my-nginx-service
          servicePort: 80

應用ingress單，創建ingress

kubectl apply -f ./my-nginx-ingress.yaml

查看ingress

kubectl get ingress

4.4 創建Ingress(V1)

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-nginx-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - http:
      paths:
      - path: /my-nginx
        pathType: Prefix
        backend:
          service:
            name: my-nginx-service
            port:
              number: 80

4.5 相關概念總結

k8s中配置客戶端訪問pod中應用的流程如下：

client->ingress->service->pod->container

INGRESS

Ingress 是對集群中服務的外部訪問進行管理的 API 物件，典型的訪問方式是 HTTP，

Ingress 可以提供負載均衡、SSL 終結和基于名稱的虛擬托管，

SERVICE

將運行在一組 Pods 上的應用程式公開為網路服務的抽象方法，Kubernetes Service 定義了這樣一種抽象：邏輯上的一組 Pod，一種可以訪問它們的策略 —— 通常稱為微服務， Service 所針對的 Pods 集合通常是通過選擇算符來確定的，

POD

Pod 是可以在 Kubernetes 中創建和管理的、最小的可部署的計算單元，

Pod （就像在鯨魚莢或者豌豆莢中）是一組（一個或多個）容器；這些容器共享存盤、網路、以及怎樣運行這些容器的宣告， Pod 中的內容總是并置（colocated）的并且一同調度，在共享的背景關系中運行， Pod 所建模的是特定于應用的“邏輯主機”，其中包含一個或多個應用容器，這些容器是相對緊密的耦合在一起的，在非云環境中，在相同的物理機或虛擬機上運行的應用類似于在同一邏輯主機上運行的云應用，

節點（Node）

Kubernetes 集群中其中一臺作業機器，是集群的一部分，

集群（Cluster）

一組運行由 Kubernetes 管理的容器化應用程式的節點，在此示例和在大多數常見的 Kubernetes 部署環境中，集群中的節點都不在公共網路中，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/288130.html

標籤：其他

上一篇：Swagger3 更新配置詳解

下一篇：java并發編程JUC第十篇：CyclicBarrier執行緒同步