fix some bug

src/main/java/cn/qg/holmes/controller/k8s/K8sController.java

@@ -45,7 +45,7 @@ public class K8sController {
      * @param namespace 环境
      * @return
      */
-    @GetMapping("/pod/list")
+    @GetMapping("/service/list")
     public JsonResult getServiceList(@RequestParam String namespace) {
         List<Map<String, Object>> podList = tkeService.getPodList(namespace);
         return JsonResult.buildSuccessResult(podList);
@@ -53,29 +53,30 @@ public class K8sController {
 
     /**
      * 根据服务名称获取镜像列表
-     * @param serviceName 服务名称
+     * @param repoName 服务名称
      * @return
      */
     @GetMapping("/image/list")
-    public JsonResult getImageListByServiceName(@RequestParam String serviceName) {
-        return JsonResult.buildSuccessResult(imageService.getImageListByService(serviceName));
+    public JsonResult getImageListByServiceName(@RequestParam String repoName) {
+        return JsonResult.buildSuccessResult(imageService.getImageListByService(repoName));
     }
 
     /**
-     * 新增pod
+     * 新增deployment, 如果service和pvc没有，也会同时创建
      * @param serviceCreateVo 创建实体类
      * @return
      */
-    @PostMapping("/pod/create")
+    @PostMapping("/service/create")
     public JsonResult createPod(@RequestBody ServiceCreateVo serviceCreateVo) {
         try {
             String serviceName = serviceCreateVo.getServiceName();
             String type = serviceCreateVo.getType();
+            String label = serviceCreateVo.getLabel();
             String namespace = serviceCreateVo.getNamespace();
             String image = serviceCreateVo.getImage();
             QueryWrapper<DockerProject> queryWrapper = new QueryWrapper<>();
             queryWrapper.eq("project_name", serviceName);
-            if (type.equals("base")) {
+            if (label.equals("base")) {
                 // Service
                 if (!tkeService.queryIfServiceExistByName(namespace, serviceName)) {
                     if (serviceName.equals("mysql")) {
@@ -99,9 +100,10 @@ public class K8sController {
                     if (serviceName.equals("mysql")) {
                         tkeService.createMysqlPvc(namespace);
                     }
-                    if (serviceName.equals("redis")) {
-                        tkeService.createRedisPvc(namespace);
-                    }
+                    // redis不需要pvc
+//                    if (serviceName.equals("redis")) {
+//                        tkeService.createRedisPvc(namespace);
+//                    }
                     if (serviceName.equals("mongodb")) {
                         tkeService.createMongodbPvc(namespace);
                     }
@@ -130,7 +132,7 @@ public class K8sController {
                         tkeService.createRabbitmqDeployment(namespace, image);
                     }
                 }
-            } else if (type.equals("java")) {
+            } else if (label.equals("java")) {
                 DockerProject dockerProject = dockerProjectService.getOne(queryWrapper);
                 if (!tkeService.queryIfServiceExistByName(namespace, serviceName)) {
                     tkeService.createJavaService(namespace, serviceName);
@@ -138,9 +140,8 @@ public class K8sController {
                 if (!tkeService.queryIfDeploymentExistByName(namespace, serviceName)) {
                     tkeService.createJavaDeployment(serviceCreateVo, dockerProject);
                 }
-            } else if (type.equals("ui") || type.equals("node")) {
+            } else if (label.equals("ui") || label.equals("node")) {
                 DockerProject dockerProject = dockerProjectService.getOne(queryWrapper);
-                String label = serviceCreateVo.getLabel();
                 if (!tkeService.queryIfServiceExistByName(namespace, serviceName)) {
                     tkeService.createUIAndNodeService(namespace, serviceName, type, label);
                 }
@@ -163,19 +164,19 @@ public class K8sController {
      * @param podName podName
      * @return
      */
-    @PostMapping("/pod/redeploy")
+    @PostMapping("/service/redeploy")
     public JsonResult resetPodByName(String namespace, String podName) {
         return JsonResult.buildSuccessResult(tkeService.resetPod(namespace, podName));
     }
 
     /**
-     * 更新部署
+     * 实际上是更新pod
      * @param namespace 环境
      * @param serviceName 服务名
      * @param image 镜像名
      * @return
      */
-    @PostMapping("/pod/modify")
+    @PostMapping("/service/modify")
     public JsonResult modifyPod(String namespace, String serviceName, String image) {
         return JsonResult.buildSuccessResult(tkeService.updateDeployment(namespace, serviceName, image));
     }
@@ -186,7 +187,7 @@ public class K8sController {
      * @param serviceName 服务名称
      * @return
      */
-    @PostMapping("/pod/delete")
+    @PostMapping("/service/delete")
     public JsonResult deletePodByName(String namespace, String serviceName) {
         return JsonResult.buildSuccessResult(tkeService.deleteDeployment(namespace, serviceName));
     }

src/main/java/cn/qg/holmes/service/k8s/ImageService.java

 package cn.qg.holmes.service.k8s;
 
+import com.alibaba.fastjson.JSON;
 import com.tencentcloudapi.common.Credential;
 import com.tencentcloudapi.common.profile.ClientProfile;
 import com.tencentcloudapi.tcr.v20190924.TcrClient;
 import com.tencentcloudapi.tcr.v20190924.models.DescribeImagePersonalRequest;
 import com.tencentcloudapi.tcr.v20190924.models.DescribeImagePersonalResponse;
+import com.tencentcloudapi.tcr.v20190924.models.TagInfo;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
 /**
  * 镜像仓库相关服务
  * @author libo 2021
@@ -34,16 +40,15 @@ public class ImageService {
 
     /**
      * 根据服务名获取镜像列表
-     * @param serviceName 服务名
+     * @param repoName 服务名
      * @return
      */
-    public String getImageListByService(String serviceName) {
+    public Map<String, Object> getImageListByService(String repoName) {
         try {
-            String repoName = "qa-test/" + serviceName;
             DescribeImagePersonalRequest request = new DescribeImagePersonalRequest();
             request.setRepoName(repoName);
             DescribeImagePersonalResponse response = tcrClient.DescribeImagePersonal(request);
-            return DescribeImagePersonalResponse.toJsonString(response);
+            return JSON.parseObject(DescribeImagePersonalResponse.toJsonString(response.getData()), Map.class);
         } catch (Exception e) {
             e.printStackTrace();
             return null;

src/main/java/cn/qg/holmes/service/k8s/TkeService.java

@@ -2,6 +2,8 @@ package cn.qg.holmes.service.k8s;
 
 import cn.qg.holmes.entity.k8s.DockerProject;
 import cn.qg.holmes.entity.k8s.ServiceCreateVo;
+import com.alibaba.fastjson.JSON;
+import com.jayway.jsonpath.JsonPath;
 import io.fabric8.kubernetes.api.model.*;
 import io.fabric8.kubernetes.api.model.apps.Deployment;
 import io.fabric8.kubernetes.api.model.apps.DeploymentSpec;
@@ -36,16 +38,15 @@ public class TkeService {
             kubernetesClient = new DefaultKubernetesClient(config);
             String configCrt = String.join("\n", readConfigFile("tke-cluster-ca.crt"));
             config.setCaCertData(configCrt);
+            log.info("k8s连接初始化成功！");
         } catch (Exception e) {
             log.info("k8s service 初始化失败！");
             e.printStackTrace();
         }
-
     }
 
     /**
      * 读取k8s配置文件
-     *
      * @param file 配置文件名
      * @return
      * @throws IOException
@@ -64,7 +65,6 @@ public class TkeService {
 
     /**
      * 构造ObjectMeta对象
-     *
      * @param namespace   环境
      * @param serviceName 服务名称
      * @param type        类型，java、ui、base等等
@@ -107,14 +107,12 @@ public class TkeService {
 
     /**
      * 获取namespace列表
-     *
      * @return
      */
     public List<Map<String, Object>> getNamespaceList() {
         List<Map<String, Object>> resultList = new ArrayList<>();
         List<Namespace> namespaceList = kubernetesClient.namespaces().list().getItems();
         for (Namespace namespace : namespaceList) {
-            log.info(namespace.toString());
             if (namespace.getMetadata().getAnnotations() != null) {
                 Map<String, Object> map = new HashMap<>();
                 map.put("name", namespace.getMetadata().getName());
@@ -130,7 +128,6 @@ public class TkeService {
 
     /**
      * 获取运行中的pod列表
-     *
      * @param namespace 环境
      * @return
      */
@@ -144,24 +141,27 @@ public class TkeService {
                 List<Map<String, Object>> portMappingList = new ArrayList<>();
                 ObjectMeta podMetadata = pod.getMetadata();
                 String serviceName = podMetadata.getLabels().get("qcloud-app");
+                // 端口暴露在Service
                 Service service = kubernetesClient.services().inNamespace(namespace).withName(serviceName).get();
-                List<ServicePort> servicePortList = service.getSpec().getPorts();
-                if (servicePortList.size() > 0) {
-                    for (ServicePort servicePort : servicePortList) {
-                        if (servicePort.getNodePort() != null) {
-                            map.put("port_" + servicePort.getName(), servicePort.getNodePort());
+                if (service != null) {
+                    List<ServicePort> servicePortList = service.getSpec().getPorts();
+                    if (servicePortList.size() > 0) {
+                        for (ServicePort servicePort : servicePortList) {
+                            if (servicePort.getNodePort() != null) {
+                                map.put("port_" + servicePort.getName(), servicePort.getNodePort());
+                            }
+                            Map<String, Object> portMap = new HashMap<>();
+                            portMap.put("name", servicePort.getName());
+                            portMap.put("nodePort", servicePort.getNodePort());
+                            portMap.put("port", servicePort.getPort());
+                            portMap.put("protocol", servicePort.getProtocol());
+                            portMap.put("targetPort", servicePort.getTargetPort());
+                            portMappingList.add(portMap);
                         }
-                        Map<String, Object> portMap = new HashMap<>();
-                        portMap.put("name", servicePort.getName());
-                        portMap.put("nodePort", servicePort.getNodePort());
-                        portMap.put("port", servicePort.getPort());
-                        portMap.put("protocol", servicePort.getProtocol());
-                        portMap.put("targetPort", servicePort.getTargetPort());
-                        portMappingList.add(portMap);
                     }
-                }
-                if (portMappingList.size() > 0) {
-                    map.put("portMappings", portMappingList);
+                    if (portMappingList.size() > 0) {
+                        map.put("portMappings", portMappingList);
+                    }
                 }
                 map.put("createdAt", podMetadata.getCreationTimestamp());
                 map.put("serviceName", serviceName);
@@ -205,12 +205,12 @@ public class TkeService {
         LabelSelector labelSelector = new LabelSelector();
         labelSelector.setMatchLabels(map);
         // 删除deployment
+        log.info("删除{}环境的pod：{}", namespace, serviceName);
         return kubernetesClient.apps().deployments().inNamespace(namespace).withName(serviceName).delete();
     }
 
     /**
      * 部署Java服务
-     *
      * @return
      */
     public Service createJavaService(String namespace, String serviceName) {
@@ -244,7 +244,7 @@ public class TkeService {
         selector.put("qcloud-app", serviceName);
 
         // 设置serviceSpec
-        serviceSpec.setType("java");
+        serviceSpec.setType("ClusterIP");
         serviceSpec.setPorts(portList);
         serviceSpec.setSelector(selector);
 
@@ -253,12 +253,12 @@ public class TkeService {
         service.setKind("Service");
         service.setMetadata(objectMeta);
         service.setSpec(serviceSpec);
+        log.info("开始创建Java Service: {}", service.toString());
         return kubernetesClient.services().inNamespace(namespace).create(service);
     }
 
     /**
      * 部署Java Deployment
-     *
      * @param serviceCreateVo
      * @param dockerProject
      * @return
@@ -444,12 +444,12 @@ public class TkeService {
         deployment.setMetadata(objectMeta);
         deployment.setSpec(deploymentSpec);
 
+        log.info("开始创建Java Deployment：{}", deployment.toString());
         return kubernetesClient.apps().deployments().inNamespace(namespace).create(deployment);
     }
 
     /**
      * 创建UI或Node 服务
-     *
      * @param namespace   环境
      * @param serviceName 服务名
      * @param serviceType 服务类型
@@ -477,7 +477,7 @@ public class TkeService {
         selector.put("qcloud-app", serviceName);
 
         // 设置serviceSpec
-        serviceSpec.setType(serviceType);
+        serviceSpec.setType("ClusterIP");
         serviceSpec.setPorts(portList);
         serviceSpec.setSelector(selector);
 
@@ -486,12 +486,12 @@ public class TkeService {
         uiService.setKind("Service");
         uiService.setMetadata(objectMeta);
         uiService.setSpec(serviceSpec);
+        log.info("开始创建UI/Node Service：{}", uiService.toString());
         return kubernetesClient.services().inNamespace(namespace).create(uiService);
     }
 
     /**
      * 部署UI或Node deployment
-     *
      * @param serviceCreateVo
      * @param dockerProject
      * @return
@@ -665,12 +665,14 @@ public class TkeService {
         deployment.setMetadata(objectMeta);
         deployment.setSpec(deploymentSpec);
 
+        log.info("开始创建ui/node Deployment：{}", deployment.toString());
         return kubernetesClient.apps().deployments().inNamespace(namespace).create(deployment);
     }
 
     public PersistentVolumeClaim createRedisPvc(String namespace) {
         PersistentVolumeClaim redisPvc = new PersistentVolumeClaim();
 
+        log.info("开始创建redis pvc：{}", redisPvc.toString());
         return kubernetesClient.persistentVolumeClaims().inNamespace(namespace).create(redisPvc);
     }
 
@@ -716,6 +718,8 @@ public class TkeService {
         redisService.setKind("Service");
         redisService.setMetadata(objectMeta);
         redisService.setSpec(serviceSpec);
+
+        log.info("开始创建redis Service: {}", redisService.toString());
         return kubernetesClient.services().inNamespace(namespace).create(redisService);
     }
 
@@ -783,7 +787,6 @@ public class TkeService {
         container.setReadinessProbe(readinessProbe);
 
         return container;
-
     }
 
     /**
@@ -864,12 +867,12 @@ public class TkeService {
         redisDeployment.setSpec(deploymentSpec);
         redisDeployment.setStatus(deploymentStatus);
 
+        log.info("创建redis Deployment：{}", redisDeployment);
         return kubernetesClient.apps().deployments().inNamespace(namespace).create(redisDeployment);
     }
 
     /**
      * 创建mysql service
-     *
      * @param namespace 环境
      * @return
      */
@@ -904,6 +907,7 @@ public class TkeService {
         mysqlService.setMetadata(objectMeta);
         mysqlService.setSpec(serviceSpec);
 
+        log.info("开始创建Mysql Service：{}", mysqlService.toString());
         return kubernetesClient.services().inNamespace(namespace).create(mysqlService);
     }
 
@@ -940,6 +944,8 @@ public class TkeService {
         mysqlPvc.setKind("PersistentVolumeClaim");
         mysqlPvc.setMetadata(objectMeta);
         mysqlPvc.setSpec(pvcSpec);
+
+        log.info("开始创建Mysql pvc：{}", mysqlPvc);
         return kubernetesClient.persistentVolumeClaims().inNamespace(namespace).create(mysqlPvc);
     }
 
@@ -1097,6 +1103,8 @@ public class TkeService {
         mysqlDeployment.setMetadata(objectMeta);
         mysqlDeployment.setSpec(deploymentSpec);
         mysqlDeployment.setStatus(deploymentStatus);
+
+        log.info("开始创建Mysql Deployment：{}", mysqlDeployment.toString());
         return kubernetesClient.apps().deployments().inNamespace(namespace).create(mysqlDeployment);
     }
 
@@ -1128,6 +1136,8 @@ public class TkeService {
         mongodbService.setKind("Service");
         mongodbService.setMetadata(objectMeta);
         mongodbService.setSpec(serviceSpec);
+
+        log.info("开始创建mongodb Service: {}", mongodbService.toString());
         return kubernetesClient.services().inNamespace(namespace).create(mongodbService);
     }
 
@@ -1162,6 +1172,7 @@ public class TkeService {
         mongodbPvc.setMetadata(objectMeta);
         mongodbPvc.setSpec(pvcSpec);
 
+        log.info("开始创建mongodb pvc：{}", mongodbPvc.toString());
         return kubernetesClient.persistentVolumeClaims().inNamespace(namespace).create(mongodbPvc);
     }
 
@@ -1307,6 +1318,8 @@ public class TkeService {
         mongodbDeployment.setMetadata(objectMeta);
         mongodbDeployment.setSpec(deploymentSpec);
         mongodbDeployment.setStatus(deploymentStatus);
+
+        log.info("开始创建mongodb Deployment：{}", mongodbDeployment);
         return kubernetesClient.apps().deployments().inNamespace(namespace).create(mongodbDeployment);
     }
 
@@ -1340,6 +1353,8 @@ public class TkeService {
         zookeeperPvc.setKind("PersistentVolumeClaim");
         zookeeperPvc.setMetadata(objectMeta);
         zookeeperPvc.setSpec(pvcSpec);
+
+        log.info("开始创建Zookeeper pvc: {}", zookeeperPvc.toString());
         return kubernetesClient.persistentVolumeClaims().inNamespace(namespace).create(zookeeperPvc);
     }
 
@@ -1379,6 +1394,8 @@ public class TkeService {
         zookeeperService.setKind("Service");
         zookeeperService.setMetadata(objectMeta);
         zookeeperService.setSpec(serviceSpec);
+
+        log.info("开始创建zookeeper Service: {}", zookeeperService.toString());
         return kubernetesClient.services().inNamespace(namespace).create(zookeeperService);
     }
 
@@ -1528,6 +1545,8 @@ public class TkeService {
         zookeeperDeployment.setMetadata(objectMeta);
         zookeeperDeployment.setSpec(deploymentSpec);
         zookeeperDeployment.setStatus(deploymentStatus);
+
+        log.info("开始创建zookeeper Deployment：{}", zookeeperDeployment.toString());
         return kubernetesClient.apps().deployments().inNamespace(namespace).create(zookeeperDeployment);
     }
 
@@ -1558,10 +1577,12 @@ public class TkeService {
         resourceRequirements.setRequests(requests);
         pvcSpec.setResources(resourceRequirements);
 
-        rabbitmqPvc.setApiVersion("apps/v1");
+        rabbitmqPvc.setApiVersion("v1");
         rabbitmqPvc.setKind("PersistentVolumeClaim");
         rabbitmqPvc.setMetadata(objectMeta);
         rabbitmqPvc.setSpec(pvcSpec);
+
+        log.info("开始创建rabbitmq Pvc：{}", rabbitmqPvc.toString());
         return kubernetesClient.persistentVolumeClaims().inNamespace(namespace).create(rabbitmqPvc);
     }
 
@@ -1599,10 +1620,12 @@ public class TkeService {
         selector.put("qcloud-app", "rabbitmq");
         serviceSpec.setSelector(selector);
 
-        rabbitmqService.setApiVersion("apps/v1");
+        rabbitmqService.setApiVersion("v1");
         rabbitmqService.setKind("Service");
         rabbitmqService.setMetadata(objectMeta);
         rabbitmqService.setSpec(serviceSpec);
+
+        log.info("开始创建rabbitmq Service: {}", rabbitmqService.toString());
         return kubernetesClient.services().inNamespace(namespace).create(rabbitmqService);
     }
 
@@ -1640,6 +1663,21 @@ public class TkeService {
 
         // livenessProbe
         Probe livenessProbe = new Probe();
+        ExecAction execAction = new ExecAction();
+        List<String> commandList = new ArrayList<>();
+        commandList.add("/opt/readyCheck.sh");
+        execAction.setCommand(commandList);
+        livenessProbe.setExec(execAction);
+        livenessProbe.setInitialDelaySeconds(100);
+        livenessProbe.setSuccessThreshold(1);
+
+        //readinessProbe
+        Probe readinessProbe = new Probe();
+        readinessProbe.setExec(execAction);
+        readinessProbe.setInitialDelaySeconds(30);
+        readinessProbe.setTimeoutSeconds(2);
+        readinessProbe.setPeriodSeconds(5);
+        readinessProbe.setSuccessThreshold(1);
 
         List<Container> containerList = new ArrayList<>();
         Container container = new Container();
@@ -1649,6 +1687,8 @@ public class TkeService {
         container.setResources(resourceRequirements);
         container.setEnv(envVarList);
         container.setLivenessProbe(livenessProbe);
+        container.setReadinessProbe(readinessProbe);
+        containerList.add(container);
 
         List<Volume> volumeList = new ArrayList<>();
 
@@ -1680,6 +1720,8 @@ public class TkeService {
         rabbitmqDeployment.setMetadata(objectMeta);
         rabbitmqDeployment.setSpec(deploymentSpec);
         rabbitmqDeployment.setStatus(deploymentStatus);
+
+        log.info("开始创建rabbitmq Deployment：{}", rabbitmqDeployment.toString());
         return kubernetesClient.apps().deployments().inNamespace(namespace).create(rabbitmqDeployment);
     }
 
@@ -1724,74 +1766,11 @@ public class TkeService {
         Deployment deployment = kubernetesClient.apps().deployments().inNamespace(namespace).withName(serviceName).get();
         List<Container> containerList = deployment.getSpec().getTemplate().getSpec().getContainers();
         containerList.get(0).setImage("ccr.ccs.tencentyun.com/" + image);
-        deployment.getSpec().getTemplate().getSpec().setContainers(containerList);
         return kubernetesClient.apps().deployments().inNamespace(namespace).withName(serviceName).createOrReplace(deployment);
     }
 
     public static void main(String[] args) {
         TkeService tkeService = new TkeService();
-//        List<Service> serviceList = k8sService.kubernetesClient.services().inNamespace("fe").list().getItems();
-//        List<Pod> podList = k8sService.kubernetesClient.pods().inNamespace("fe").list().getItems();
-//        Pod pod =  podList.get(22);
-
-//        System.out.println("Metadata: " + pod.getMetadata());
-//        System.out.println("Spec: " + pod.getSpec());
-//        System.out.println("Status: " + pod.getStatus());
-//        System.out.println("Api: " + pod.getApiVersion());
-//        System.out.println(pod.getStatus().getContainerStatuses().get(0).getImage());
-//        System.out.println(pod.getStatus().getContainerStatuses().get(0).getImageID());
-//        System.out.println(pod.getStatus().getPhase());
-//        System.out.println(pod.getSpec().getContainers().get(0).getName());
-
-//        System.out.println(serviceList.get(19).getSpec().getPorts());
-//        Service service = k8sService.kubernetesClient.services().inNamespace("fe").withName("holmes").get();
-//        System.out.println(service);
-
-//        System.out.println(k8sService.resetPod("fe", "acm-ui-58864499d9-h47rl"));
-//        tkeService.deleteService("fe", "kdsp");
-
-        //创建deployment
-//        ServiceCreateVo serviceCreateVo = new ServiceCreateVo();
-//        serviceCreateVo.setServiceName("gu-bei");
-//        serviceCreateVo.setNamespace("test1");
-//        serviceCreateVo.setCluster("qa");
-//        serviceCreateVo.setMock(1);
-//        serviceCreateVo.setDebug(0);
-//        serviceCreateVo.setLabel("java");
-//        serviceCreateVo.setImage("qa-test/gu-bei:master-20210707165716636");
-//        DockerProject dockerProject = new DockerProject();
-//        dockerProject.setCpuRequest("200");
-//        dockerProject.setMemRequest("500");
-//        dockerProject.setCpuLimit("2000");
-//        dockerProject.setMemLimit("1000");
-//        tkeService.createJavaDeployment(serviceCreateVo, dockerProject);
-
-//        tkeService.updateDeployment("fe", "mo-clotho", "qa-test/mo-clotho:master-20210707143546990");
-//        tkeService.createRedisService("fe", "redis");
-//        tkeService.createRedisDeployment("fe", "base", "redis", "redis", "qa-base/redis:3");
-//        tkeService.createJavaService("test1", "gu-bei", "NodePort", "java");
-//        tkeService.createUIAndNodeService("tob", "new-op-optimized-ui", "ClusterIP", "ui");
-
-//        tkeService.createRedisPvc("fe");
-//        tkeService.createRedisService("fe");
-//        tkeService.createRedisDeployment("fe", "qa-base/redis:3");
-
-//        tkeService.createMysqlPvc("fe");
-//        tkeService.createMysqlService("fe");
-//        tkeService.createMysqlDeployment("fe", "qa-base/mysql:5.6");
-
-//        tkeService.createMongodbPvc("fe");
-//        tkeService.createMongodbService("fe");
-//        tkeService.createMongoDbDeployment("fe", "qa-base/mongodb:3.6");
-
-//        tkeService.createZookeeperPvc("fe");
-//        tkeService.createZookeeperService("fe");
-//        tkeService.createZookeeperDeployment("fe", "qa-base/zookeeper:3.4.13");
-
-//        System.out.println(tkeService.queryIfDeploymentExistByName("test4", "vcc-talos"));
-//        System.out.println(tkeService.queryIfPvcExistByName("test4", "mysql"));
-//        System.out.println(tkeService.queryIfServiceExistByName("test4", "vcc-talos"));
-
+        tkeService.updateDeployment("k8s", "qa-platform", "qa-test/qa-platform:master-20210729112805284");
     }
-
 }