利用io.fabric8 java客户端操作k8s

1、导入jar包<dependency><groupId>io.fabric8</groupId><artif...

神奇at

7009人浏览 · 2019-05-21 12:33:42

神奇at · 2019-05-21 12:33:42 发布

1、导入jar包

        <!-- https://mvnrepository.com/artifact/io.fabric8/kubernetes-client -->
        <dependency>
            <groupId>io.fabric8</groupId>
            <artifactId>kubernetes-client</artifactId>
            <version>4.2.1</version>
        </dependency>

2、创建k8s客户端

由于是多集群的k8s客户端，利用集群id做key，缓存客户端

package com.cn21.mec.meao.common.cache;

import com.cn21.mec.core.entity.api.model.Cluster;
import com.cn21.mec.core.exception.ResourceNotFoundException;
import com.cn21.mec.core.utils.BaseCache;
import com.cn21.mec.meao.dao.ClusterDao;
import io.fabric8.kubernetes.client.Config;
import io.fabric8.kubernetes.client.ConfigBuilder;
import io.fabric8.kubernetes.client.DefaultKubernetesClient;
import io.fabric8.kubernetes.client.KubernetesClient;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static com.cn21.mec.core.constants.Constants.MEC_CLUSTER;

@Component
public class KubeClientCache extends BaseCache<Cluster, KubernetesClient> {
    private Map<Integer, KubernetesClient> kubernetesClientMap;

    @Resource
    private ClusterDao clusterDao;

    public KubeClientCache() {
        kubernetesClientMap = new HashMap<>();
    }

    @Override
    public void refresh() {
        List<Cluster> clusters = loadFromDB();

        for (Cluster cluster: clusters) {
            Config config = new ConfigBuilder()
                    .withMasterUrl(cluster.getCcpAccessAddress())
                    .withCaCertData(cluster.getAccessCaData())
                    .withClientCertData(cluster.getAccessCrtData())
                    .withClientKeyData(cluster.getAccessKeyData())
                    .build();

            this.kubernetesClientMap.put(cluster.getClusterId(), new DefaultKubernetesClient(config));
        }
    }

    @Override
    protected List<Cluster> loadFromDB() {
        return clusterDao.getAll();
    }

    @Override
    public KubernetesClient get(Object key) {
        KubernetesClient kubernetesClient = kubernetesClientMap.get((Integer) key);
        if (kubernetesClient == null) {
            throw new ResourceNotFoundException(MEC_CLUSTER, key);
        }
        return kubernetesClient;
    }

    @Override
    public void set(Object key, KubernetesClient kubernetesClient) {
        this.kubernetesClientMap.put((Integer) key, kubernetesClient);
    }

    @Override
    public void delete(Object key) {
        this.kubernetesClientMap.remove((Integer) key);
    }

    @Override
    public void setWithExpireTime(Object key, KubernetesClient kubernetesClient, long seconds) {

    }
}

package com.cn21.mec.core.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;

import java.util.List;

/**
 * Base Redis Cache
 * @author zoup
 * @version 2018-09-27
 */
public abstract class BaseCache<T, V> implements CommandLineRunner {
    @Autowired
    private CacheCenter cacheCenter;

    /**
     * 初始化
     * @author zoup
     */
    public void init() {
        cacheCenter.newCache(this);
        refresh();
    }

    /**
     * 刷新
     * @author zoup
     */
    public abstract void refresh();

    /**
     * 加载表数据
     * @author zoup
     * @return List<T> 数据库实体
     */
    protected abstract List<T> loadFromDB();

    /**
     * 读取缓存
     * @author zoup
     * @param key 缓存key
     * @return V 缓存实体
     */
    public abstract V get(Object key);

    /**
     * 写入缓存
     * @author zoup
     * @param key 缓存key
     * @param v 缓存实体
     */
    public abstract void set(Object key, V v);

    /**
     * 删除缓存
     * @param key 缓存key
     */
    public abstract void delete(Object key);

    /**
     * 写入缓存并设置过期时间，默认为String类型，时间单位为秒
     * @author zoup
     * @param key 缓存key
     * @param v 缓存实体
     */
    public abstract void setWithExpireTime(Object key, V v, long seconds);

    @Override
    public void run(String... args) throws Exception {
        init();
    }
}

3、对deployment进行操作


/* 1、设置deployment的唯一LabelSelector
*  2、设置pods的selector：orgId/serviceSetId/departmentId/deploymentName
*  3、创建，由缓存获取客户端，之后代码类似
*/
//设置deployment的唯一LabelSelector
pDeployment.getDeployment().getSpec().getSelector().getMatchLabels().put(Constants.ORG_ID,pDeployment.getDpOrgId().toString());

pDeployment.getDeployment().getSpec().getSelector().getMatchLabels().put(Constants.DEPARTMENT_ID,pDeployment.getDpDepartmentId().toString());

pDeployment.getDeployment().getSpec().getSelector().getMatchLabels().put(Constants.SERVICE_SET_ID,pDeployment.getServiceSetId().toString());

pDeployment.getDeployment().getSpec().getSelector().getMatchLabels().put(Constants.DEPLOYMENT_NAME,pDeployment.getName());


// 设置pods的selector：orgId/serviceSetId/departmentId/deploymentName

pDeployment.getDeployment().getSpec().getTemplate().getMetadata().getLabels().put(ORG_ID,pDeployment.getDpOrgId().toString());

pDeployment.getDeployment().getSpec().getTemplate().getMetadata().getLabels().put(Constants.DEPARTMENT_ID,pDeployment.getDpDepartmentId().toString());

pDeployment.getDeployment().getSpec().getTemplate().getMetadata().getLabels().put(Constants.SERVICE_SET_ID,pDeployment.getServiceSetId().toString());

pDeployment.getDeployment().getSpec().getTemplate().getMetadata().getLabels().put(Constants.DEPLOYMENT_NAME,pDeployment.getName());


// 创建
kubeClientCache.get(clusterId).apps().deployments().inNamespace(pDeployment.getNamespace()).create(deployment);

// 修改deployment
kubeClientCache.get(clusterId).apps().deployments().inNamespace(pDeployment.getNamespace()).withName(pDeployment.getName()).replace(deployment);

//获取详情
kubeClientCache.get(clusterId).apps().deployments().inNamespace(pDeployment.getNamespace()).withName(pDeploy.getName()).get();


// k8s删除 deployment rs pods，其中pods的labels为deployment中LabelSelector设置

//删除deployment，需要删除rs以及对应Labels的pods
Map<String, String> map = new HashMap<>();
map.put(ORG_ID, pDeploy.getDpOrgId().toString());
map.put(DEPARTMENT_ID, pDeploy.getDpDepartmentId().toString());
map.put(SERVICE_SET_ID, pDeploy.getServiceSetId().toString());
map.put(DEPLOYMENT_NAME, pDeploy.getName());

//删除deployment
kubeClientCache.get(clusterId).apps().deployments().inNamespace(pDeploy.getNamespace()).withName(pDeploy.getName()).delete();

//删除rs kubeClientCache.get(clusterId).apps().replicaSets().inNamespace(pDeploy.getNamespace()).withLabels(map).delete();

//删除pods
kubeClientCache.get(clusterId).pods().inNamespace(pDeploy.getNamespace()).withLabels(map).delete();

4、对service进行操作

//创建service
// 设置pods的selector :ServiceSetId作为service选择pods的唯一选择器   pService.getService().getSpec().getSelector().put(Constants.SERVICE_SET_ID,pService.getServiceSetId().toString());

pService.getService().getSpec().getSelector().put(Constants.ORG_ID,pService.getDpOrgId().toString());

pService.getService().getSpec().getSelector().put(Constants.DEPARTMENT_ID,pService.getDpDepartmentId().toString());

// 设置service的labels：orgId/departmentId/serviceSetId

pService.getService().getMetadata().getLabels().put(Constants.ORG_ID,pService.getDpOrgId().toString());

pService.getService().getMetadata().getLabels().put(Constants.DEPARTMENT_ID,pService.getDpDepartmentId().toString());

pService.getService().getMetadata().getLabels().put(Constants.SERVICE_SET_ID,pService.getServiceSetId().toString());


// 创建service
kubeClientCache.get(clusterId).services().inNamespace(pService.getNamespace()).create(service);


// 修改k8s service
kubeClientCache.get(clusterId).services().inNamespace(pService.getNamespace()).withName(redisPService.getName()).replace(service);


//获取service详情
kubeClientCache.get(clusterId).services().inNamespace(pService.getNamespace()).withName(redisPService.getName()).get();


//删除service
kubeClientCache.get(clusterId).services().inNamespace(redisPService.getNamespace()).withName(redisPService.getName()).delete();

5、对命名空间进行操作

// 创建命名空间
kubeClientCache.get(kubeBaseBean.getClusterId()).namespaces().create(namespace);

// 删除命名空间
 kubeClientCache.get(kubeBaseBean.getClusterId()).namespaces().withName(kubeBaseBean.getNamespace()).delete();

6、configMap进行操作

// 创建 configMap   其他操作与上类似
kubeClientCache.get(pConfigMap.getClusterId())
                .configMaps()
                .inNamespace(pConfigMap.getNamespace())
                .create(pConfigMap.getConfigMap());

Cloudpods

开源、云原生的融合云平台

更多推荐

面向未来的 IT 基础设施管理架构——融合云（Unified IaaS）

随着数字化时代的到来，IT系统已成为人类社会正常运转不可或缺的组成部分。不远的未来，智能制造，5G和人工智能等技术将成为推动生产力发展的重要引擎，人类社会将面临前所未有的全面彻底的数字化浪潮。IT基础设施作为IT系统运行的平台和载体，是实现数字化的基石。在这场数字化浪潮中，企业必须积极拥抱云计算技术，采用符合技术发展趋势、面向未来的IT基础构架，才能在未来的竞争中赢得先机。一、云计算历经十余年

Cloudpods

Cloudpods负载均衡的功能介绍

作者:周有松今天的内容会从以下几个方面展开：负载均衡产品简介。主要介绍负载均衡作为一个云上产品，它的功能模型是怎样的，日常使用中会遇到的业务词汇负载均衡的功能与典型应用场景。这部分主要结合业务词汇，对负载均衡服务中常见的一些功能选项进行介绍，并举例介绍一些典型的应用场景最后，我们做一下总结，讨论一下负载均衡产品相比传统方式的优点一、产品简介 1. 以NGINX为例提到负载均衡，我们以

Cloudpods

使用Linux vfio将Nvidia GPU透传给QEMU虚拟机

Linux 上虚拟机 GPU 透传需要使用 vfio 的方式。主要是因为在 vfio 方式下对虚拟设备的权限和 DMA 隔离上做的更好。但是这么做也有个缺点，这个物理设备在主机和其他虚拟机都不能使用了。 qemu 直接使用物理设备本身命令行是很简单的，关键在于事先在主机上对系统、内核和物理设备的一些配置。单纯从 qemu 的命令行来看，其实和普通虚拟机启动就差了最后那个-device的选项。这

Cloudpods

所有评论(0)

查看更多评论

神奇at

@Ay_Ly

已为社区贡献3条内容