当前位置:

首页 > 编程开发 > Java简单操作k8s,创建Deployment、Service、访问Nginx实践

Java简单操作k8s,创建Deployment、Service、访问Nginx实践

使用fabric8的kubernetes-client库,基于kubeconfig文件连接Kubernetes集群,通过Java代码动态创建Deployment和Service,并封装为工具类,实现Pod、Deployment、Service的创建与获取,简化K8s资源管理操作。

本文目录

    在Ja va中操作Kubernetes,很多人的第一反应是写一堆繁琐的yaml然后手动kubectl apply——但如果是程序内部需要动态创建Deployment、Service呢?这时候就需要一个靠谱的客户端库。fabric8的kubernetes-client是Ja va生态里比较成熟的选择,版本4.10.2已经够用,下面直接上步骤。

    1.Ma ven依赖

    
    
        io.fabric8
        kubernetes-client
        4.10.2
    

    2.初始化 k8s 客户端

    初始化KubernetesClient客户端

    首先需要找到 /etc/kubernetes/admin.conf文件

    Ja va简单操作k8s,创建Deployment、Service、访问Nginx实践

    这是连接k8s的配置文件,通过这个文件,就可以在Ja va程序中连接上k8s,初始化KubernetesClient客户端

    将该文件的内容复制进kubeconfig,预先存好kubeconfig的文件位置:C:\Users\26411\Desktop\AI平台\kubeconfig

    application.yml

    k8s:
      kubeconfig: C:\Users\26411\Desktop\AI平台\kubeconfig

    编写配置类,初始化KubernetesClient为Bean

    @Configuration
    public class K8sConfig {
        
        @Value("${k8s.kubeconfig}")
        private String kubeconfigPath;
        
        @Bean
        public KubernetesClient getClient() throws IOException {
            File configFile = new File(kubeconfigPath);
            final String configYaml = String.join("\n", Files.readAllLines(configFile.toPath()));
            Config config = Config.fromKubeconfig(configYaml);
            config.setTrustCerts(true);
            return new DefaultKubernetesClient(config);
        }
    }
    

    3.测试类测试简单功能

    测试后,在 Xshell 中使用 kubectl 命令查看正常,测试成功。

    @SpringBootTest
    public class K8sTest {
        String namespace = "default";
        @Autowired
        private KubernetesClient kubernetesClient;
    
        /**
         * 获取Pod
         */
        @Test
        void testGetPod(){
            Pod pod = kubernetesClient.pods().inNamespace("kube-system").withName("kube-apiserver-master").get();
            System.out.println(pod);
        }
    
        /**
         * 创建deployment
         */
        @Test
        void testCreateDeployment(){
            Deployment deployment = getDeployment();
            Deployment de = kubernetesClient.apps().deployments().inNamespace(namespace).create(deployment);
        }
        
        private Deployment getDeployment() {
            Map labels = new HashMap<>();
            labels.put("run","nginx");
            LabelSelector labelSelector = new LabelSelector();
            labelSelector.setMatchLabels(labels);
            return new DeploymentBuilder()
                    .withNewMetadata()
                        .withName("nginx")
                        .withNamespace(namespace)
                        .addToLabels(labels)
                    .endMetadata()
                    .withNewSpec()
                        .withSelector(labelSelector)
                        .withNewTemplate()
                            .withNewMetadata()
                                .withName("nginx")
                                .addToLabels(labels)
                                .withNamespace(namespace)
                            .endMetadata()
                            .withNewSpec()
                               .addToContainers(buildContainer())
                            .endSpec()
                        .endTemplate()
                    .endSpec()
                    .build();
        }
    
        private Container buildContainer() {
            ContainerPort containerPort = new ContainerPort();
            containerPort.setProtocol("TCP");
            containerPort.setContainerPort(80);
    
            return new ContainerBuilder()
                    .withNewName("nginx")
                    .withNewImage("nginx:latest")
                    .withPorts(containerPort)
                    .build();
        }
    
        /**
         * 创建Service
         */
        @Test
        void testCreateService(){
            Service service = kubernetesClient.services().inNamespace(namespace).create(getService());
            System.out.println(service);
        }
    
        private Service getService() {
            HashMap selector = new HashMap<>();
            selector.put("run","nginx");
            ServicePort port = new ServicePort();
            port.setProtocol("TCP");
            port.setPort(80);
            port.setTargetPort(new IntOrString(80));
            return new ServiceBuilder()
                    .withNewMetadata()
                        .withName("svc-nginx")
                        .withNamespace(namespace)
                    .endMetadata()
                    .withNewSpec()
                        .withClusterIP("10.109.179.231")
                        .withPorts(port)
                        .withSelector(selector)
                        .withType("NodePort")
                    .endSpec().build();
        }
    
    }
    

    4.编写工具类封装简单功能

    @Component
    public class K8sUtil {
        
        @Autowired
        private KubernetesClient kubernetesClient;
    
        /**
         * 获取一个 Pod
         *
         * @param namespace 名称空间
         * @param podName   Pod名字
         * @return {@link Pod}
         */
        public Pod getOnePod(String namespace, String podName){
            return kubernetesClient.pods().inNamespace(namespace).withName(podName).get();
        }
    
        /**
         * 创建一个 Pod
         *
         * @param namespace 名称空间
         * @param podBody   Pod内容
         * @return {@link Pod}
         */
        public Pod createOnePod(String namespace, Pod podBody){
            return kubernetesClient.pods().inNamespace(namespace).create(podBody);
        }
    
        /**
         * 创建Deployment
         *
         * @param deploymentDto 部署dto
         * @return {@link Deployment}
         */
        public Deployment createDeployment(DeploymentDto deploymentDto){
            Deployment deployment = getDeployment(deploymentDto);
            return  kubernetesClient.apps().deployments()
                    .inNamespace(deploymentDto.getNamespace())
                    .create(deployment);
        }
        
        private Deployment getDeployment(DeploymentDto deploymentDto) {
            return new DeploymentBuilder()
                    .withNewMetadata()
                        .withName(deploymentDto.getDeploymentName())
                        .withNamespace(deploymentDto.getNamespace())
                        .addToLabels(deploymentDto.getLabels())
                    .endMetadata()
                    .withNewSpec()
                        .withReplicas(deploymentDto.getReplicas())
                        .withSelector(deploymentDto.getLabelSelector())
                        // Template() Pod模板
                        .withNewTemplate()
                            .withNewMetadata()
                                .addToLabels(deploymentDto.getLabels())
                            .endMetadata()
                            .withNewSpec()
                                .addToContainers(buildContainer(deploymentDto))
                            .endSpec()
                        .endTemplate()
                    .endSpec()
                    .build();
        }
    
        private Container buildContainer(DeploymentDto deploymentDto) {
            ContainerPort containerPort = new ContainerPort();
            containerPort.setProtocol(deploymentDto.getProtocol());
            containerPort.setContainerPort(deploymentDto.getContainerPort());
    
            return new ContainerBuilder()
                    .withNewName(deploymentDto.getContainerName())
                    .withNewImage(deploymentDto.getImage())
                    .withPorts(containerPort)
                    .build();
        }
    
        /**
         * 创建Service
         *
         * @param serviceDto 服务dto
         * @return {@link Service}
         */
        public Service createService(ServiceDto serviceDto) {
            Service service = getService(serviceDto);
            return kubernetesClient.services().inNamespace(serviceDto.getNamespace()).create(service);
        }
    
        private Service getService(ServiceDto serviceDto) {
            ServicePort port = new ServicePort();
            port.setProtocol(serviceDto.getProtocol());
            port.setPort(serviceDto.getPort());
            port.setTargetPort(new IntOrString(serviceDto.getTargetPort()));
            
            return new ServiceBuilder()
                    .withNewMetadata()
                        .withName(serviceDto.getServiceName())
                        .withNamespace(serviceDto.getNamespace())
                    .endMetadata()
                    .withNewSpec()
                        //.withClusterIP()
                        .withPorts(port)
                        .withSelector(serviceDto.getSelector())
                        .withType(serviceDto.getType())
                    .endSpec()
                    .build();
        }
        
    }
    

    附上两个封装信息的实体类

    @Data
    public class DeploymentDto {
        /**
         * 名称空间
         */
        private String namespace;
        /**
         * deployment名字
         */
        private String deploymentName;
        /**
         * 副本个数
         */
        private Integer replicas;
        /**
         * Pod模板的标签、Deployment标签选择器 会匹配到的标签
         */
        private Map labels;
        /**
         * Deployment标签选择器
         */
        private LabelSelector labelSelector;
    
        // spec下的 containers
        /**
         * 容器要拉取运行的镜像
         */
        private String image;
        /**
         * 容器名称
         */
        private String containerName;
        /**
         * 容器端口
         */
        private Integer containerPort;
        /**
         * 协议
         */
        private String protocol;
    }
    
    
    @Data
    public class ServiceDto {
        /**
         * 名称空间
         */
        private String namespace;
        /**
         * Service名称
         */
        private String serviceName;
        /**
         * 端口
         */
        private Integer port;
        /**
         * 协议
         */
        private String protocol;
        /**
         * 目标端口
         */
        private Integer targetPort;
        /**
         * Service的标签选择器    选择有对应标签的Pod (但是其实通过Deployment操控)
         */
        private Map selector;
        /**
         * 类型   :NodePort、ClusterIP等等
         */
        private String type;
    }
    

    5.访问部署的Nginx

    Ja va简单操作k8s,创建Deployment、Service、访问Nginx实践

    访问 http://192.168.242.100:30439/

    Ja va简单操作k8s,创建Deployment、Service、访问Nginx实践

    6.后续扩展

    封装操作更多的功能,操作更多资源,例如 ingress

    总结

    以上就是通过Ja va操作K8s创建Deployment和Service的基本流程,后续还可以根据需求封装更多功能,比如Ingress等。

    本站声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系bd@zhengruan.com
    作者最新文章
    编程开发
    相关文章 更多
    BTIG调研:ServiceNow(NOW.US)AI叙事正经历“实质性”积极转变 Q2或成关键起跳点
    BTIG调研:ServiceNow(NOW.US)AI叙事正经历“实质性”积极转变 Q2或成关键起跳点

    BTIG一线调研显示,ServiceNow的AI叙事正经历实质性积极转变:客户提前续约并接受两位数涨价,分析师给予买入评级与150美元目标价。公司聚焦高端市场,第二季度或成关键起跳点,AI战略驱动增长,市场信心持续增强。

    解决apollo的configService服务启动异常
    解决apollo的configService服务启动异常

    前言 apollo是一个非常流行的开源的配置中心项目,这里就不多介绍了。接触过apollo和运行过apollo的人肯定都遇到过启动configService时抛异常了,而且100%会抛一个异常。原因是,在apollo的架构中configService既作为config服务,同时也承载了metaSer

    4.2.1 Service初涉
    4.2.1 Service初涉

    本节引言 好的,我们在前三节中对Android中的Activity进行了研究学习,相信大家获益良多吧! 本节开始我们继续来学习Android中的第二个组件:Service(服务), 好,废话不多说,开始本节内容! 1.线程的相关概念 在开始学习Service之前我们先来了解下线程的一些概念! 1)相

    4.2.2 Service进阶
    4.2.2 Service进阶

    本节引言 上节我们学习了Service的生命周期,以及两种启动Service的两种方法, 本节继续来深入了解Service中的IntentService,Service的使用实例: 前台服务与轮询的实现! 1.IntentService的使用 在上一节后我们已经知道了如何去定义和启动Service,

    android service 常见报错与处理办法汇总
    android service 常见报错与处理办法汇总

    AndroidService作为后台组件,其开发常遇多种报错。主要涉及生命周期管理不当、进程间通信错误及权限配置问题。例如前台服务未及时调用startForeground()会导致异常,绑定服务时需确保清单文件正确定义和Intent明确。系统后台限制趋严,需适配WorkManager或前台服务。同时须防范内存泄漏,如在Activity销毁前解绑服务,并利用日

    java调用webservice 对比指南:不同方案优缺点分析
    java调用webservice 对比指南:不同方案优缺点分析

    Java调用WebService主要有JAX-WS、ApacheCXF/Axis2、HTTP客户端直接调用及Spring-WS等方案。JAX-WS标准化程度高,适合企业级SOAP服务,但依赖较重。第三方框架如CXF灵活性更强,支持更多功能,但增加了复杂度。直接使用HTTP客户端依赖最简、可控性高,但开发效率低。Spring-WS与Spring生态集成良好,适

    ttsservice是什么 使用中遇到的问题怎么解决
    ttsservice是什么 使用中遇到的问题怎么解决

    TTS服务将文本转为语音,常见问题包括无声或音质异常,应检查音量、引擎及语音数据包;语言或语速不准确,需调整设置与滑块;特定应用无法朗读,应检查权限与兼容性。系统故障可重启、清除数据或恢复出厂设置。用户也可选用第三方引擎优化体验。

    pcidevice 实操经验总结:这些技巧很实用
    pcidevice 实操经验总结:这些技巧很实用

    PCI设备是连接主板与外部硬件的关键接口,其管理与配置对系统优化和虚拟化部署至关重要。Linux下可使用lspci查看设备信息,结合grep过滤定位。高级场景中可通过sysfs文件手动绑定或解绑驱动,实现SR-IOV或设备直通。setpci工具能直接读写配置寄存器,但需谨慎操作。虚拟化直通需启用IOMMU并将设备绑定至vfio-pci驱动。故障排查可。

    pcidevice 选型思路:使用场景与区别整理
    pcidevice 选型思路:使用场景与区别整理

    PCIe设备选型需综合考虑物理接口、版本带宽与使用场景。需明确主板插槽类型、支持的PCIe版本,确保设备兼容。根据图形处理、存储扩展或网络升级等具体需求选择设备类别,并比较关键参数与软硬件兼容性。同时应权衡品牌、预算、散热及未来升级空间,做出适宜选择。

    pcidevice 用不好怎么办?问题排查指南
    pcidevice 用不好怎么办?问题排查指南

    当PCI设备无法识别或运行时,应先检查物理连接与插槽状态,并在设备管理器中更新或重装官方驱动,清理旧驱动残留。随后排查BIOS/UEFI设置、系统资源冲突与电源管理选项。若问题仍存,可尝试更换测试平台、更新主板固件或查看系统日志。最后需考虑硬件故障的可能性及替代解决方案。

    查看更多
    精品专题 更多
    装机必备
    装机必备

    正软商城装机必备专区,精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件,帮助用户快速完成新电脑软件配置。

    Windows
    Windows

    正软商城Windows软件专区,汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件,提供软件介绍、系统要求、正版授权及购买下载服务。

    PDF教程
    PDF教程

    正软商城PDF教程频道提供PDF编辑、转换、合并、拆分、压缩及格式处理方法,同时介绍常用PDF软件和工具的使用技巧。

    Mac软件 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    Aperty macOS版
    Aperty macOS版
    macOS

    Aperty 是 Skylum 推出的 AI 人像修图软件,支持自然肤质修饰、瑕疵处理、面部与身体调整、预设及批量同步。

    WINDOWS 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    PixTV 网页版
    PixTV 网页版
    Windows

    PixTV 是一款在浏览器中使用的 AI 视觉内容创作平台,提供图片、视频、音频、文字生成、AI 分镜、局部重绘、提示词反推和无限画布等工具,适合短剧、漫剧、广告及社交媒体内容制作。