脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java操作k8s,创建Deployment、Service、访问Nginx

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

 更新时间：2026年04月16日 10:44:26   作者：0302huang  
文章介绍了使用Maven依赖并初始化KubernetesClient客户端,通过配置kubeconfig文件连接Kubernetes集群,编写配置类将KubernetesClient初始化为Bean,并测试连接,最后,提供了一个访问部署在Kubernetes中的Nginx服务的示例,以及后续扩展思路

1.Maven依赖

<!-- k8s client -->
<dependency>
    <groupId>io.fabric8</groupId>
    <artifactId>kubernetes-client</artifactId>
    <version>4.10.2</version>
</dependency>

2.初始化 k8s 客户端

初始化KubernetesClient客户端

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

这是连接k8s的配置文件，通过这个文件，就可以在Java程序中连接上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<String, String> 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<String, String> 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<String,String> 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<String,String> selector;
    /**
     * 类型   ：NodePort、ClusterIP等等
     */
    private String type;
}

5.访问部署的Nginx

访问 http://192.168.242.100:30439/

6.后续扩展

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

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

相关文章

  • RocketMQ消息存储文件的加载与恢复机制源码分析

    RocketMQ消息存储文件的加载与恢复机制源码分析

    这篇文章主要介绍了RocketMQ源码分析之消息存储文件的加载与恢复机制详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2023-05-05
  • Flink流处理引擎零基础速通之数据的抽取篇

    Flink流处理引擎零基础速通之数据的抽取篇

    今天不分享基础概念知识了，来分享一个马上工作需要的场景，要做数据的抽取，不用kettle，想用flink。实际就是flink的sql、table层级的api
    2022-05-05
  • Java随机值设置(java.util.Random类或Math.random方法)

    Java随机值设置(java.util.Random类或Math.random方法)

    在编程中有时我们需要生成一些随机的字符串作为授权码、验证码等,以确保数据的安全性和唯一性,这篇文章主要给大家介绍了关于Java随机值设置的相关资料,主要用的是java.util.Random类或Math.random()方法,需要的朋友可以参考下
    2024-08-08
  • Java全面解析XML格式串（JDOM解析）

    Java全面解析XML格式串（JDOM解析）

    下面小编就为大家带来一篇Java全面解析XML格式串（JDOM解析）。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2016-06-06
  • Java并发中的Fork/Join 框架机制详解

    Java并发中的Fork/Join 框架机制详解

    本文主要介绍了 Java 并发框架中的 Fork/Join 框架的基本原理和其使用的工作窃取算法(work-stealing)、设计方式和部分实现源码，感兴趣的朋友跟随小编一起看看吧
    2021-07-07
  • java调用openoffice将office系列文档转换为PDF的示例方法

    java调用openoffice将office系列文档转换为PDF的示例方法

    本篇文章主要介绍了java使用openoffice将office系列文档转换为PDF的示例方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。
    2017-11-11
  • spring boot与spring mvc的区别及功能介绍

    spring boot与spring mvc的区别及功能介绍

    这篇文章主要介绍了spring boot与spring mvc的区别是什么以及spring boot和spring mvc功能介绍，感兴趣的朋友一起看看吧
    2018-02-02
  • 详解SpringMVC 基础教程 简单入门实例

    详解SpringMVC 基础教程 简单入门实例

    这篇文章主要介绍了详解SpringMVC 基础教程 简单入门实例,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2016-12-12
  • java读取文件和写入文件的方式(简单实例)

    java读取文件和写入文件的方式(简单实例)

    下面小编就为大家带来一篇java读取文件和写入文件的方式(简单实例)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2016-10-10
  • SpringBoot中实现数据脱敏的六种常用方案

    SpringBoot中实现数据脱敏的六种常用方案

    在日常的开发开发工作中,我相信各位老铁肯定遇到过这种需求手机号中间四位得用*显示等,既要展示部分数据,又要保证敏感信息不泄露,这就是所谓的数据脱敏,所以今天给大家分享6种我在项目中常用的脱敏方案,需要的朋友可以参考下
    2025-09-09

最新评论