一、引言：开启部署大门

在当今数字化浪潮中，高效的项目部署对于企业的发展至关重要。想象一下，某电商公司在业务飞速发展时，原有的 SpringCloud 项目部署方式难以满足日益增长的用户需求。服务器资源时常捉襟见肘，运维团队也被繁琐的管理工作搞得焦头烂额。但当他们果断将 SpringCloud 项目部署在 K8S 上后，情况发生了翻天覆地的变化。资源利用率大幅提升，运维成本显著降低，系统的稳定性和扩展性更是上了一个大台阶。这个真实案例足以证明，掌握 SpringCloud 项目在 K8S 上的部署技术，对于企业和开发者来说是多么关键。接下来，就让我们一起揭开这神秘的部署面纱，开启技术进阶之旅 。

二、知识小课堂：SpringCloud 与 K8S 初相识

在正式开启部署之旅前，我们先来深入了解一下 SpringCloud 和 K8S 这两位 “主角” ，知己知彼，才能在部署过程中得心应手。

（一）SpringCloud 是啥

SpringCloud 是基于 Spring Boot 构建的一套微服务开发工具集，它就像是一个庞大而有序的工具库，为开发者提供了一系列用于构建分布式系统的实用工具和组件，大大简化了分布式系统的开发过程。在这个工具库中，有几个核心组件堪称 “中流砥柱” 。

Eureka 作为服务注册与发现组件，就如同一个精准的导航仪。在一个分布式系统中，众多微服务就像一个个分散在各地的小商店，Eureka Server 就是那个记录了所有商店位置信息的服务注册表，而 Eureka Client 则负责将各个微服务的信息注册到这个注册表中。当某个微服务需要调用其他服务时，只需向 Eureka Server 查询，就能轻松找到目标服务的地址，实现高效的服务调用。

Ribbon 是客户端负载均衡组件，它仿佛是一个智能的调度员。当有多个服务实例提供相同的服务时，Ribbon 会根据预设的负载均衡算法，如轮询、随机等，将请求均匀地分发到各个实例上，避免单个实例因负载过高而 “不堪重负”，确保系统的性能和可靠性。

Hystrix 是服务容错保护组件，它犹如一位忠诚的卫士。在微服务架构中，服务之间相互依赖，一旦某个服务出现故障，可能会引发连锁反应，导致整个系统瘫痪，这就是可怕的 “雪崩效应”。Hystrix 通过实现断路器模式，当某个服务出现故障时，能自动切断对该服务的调用，防止故障扩散。同时，它还提供降级处理，在服务不可用时，返回一个预设的默认值或执行一个备用的逻辑，保证系统的基本可用性。

还有 Feign，它是声明式服务调用组件，让服务调用变得更加简洁直观。开发者只需通过简单的注解定义一个 FeignClient 接口，就可以像调用本地方法一样调用远程服务，无需编写繁琐的 HTTP 请求代码，大大提高了开发效率。

SpringCloud 的优势不言而喻。它提供了强大的服务治理能力，使得服务的注册、发现、调用和管理变得轻松便捷；通过集中式配置管理，能方便地对应用的配置信息进行管理和动态更新；可靠的容错处理机制，有效保障了系统在面对故障时的稳定性；全面的分布式追踪功能，便于开发者了解请求在系统中的调用路径和耗时情况，快速定位和解决问题。基于 Spring Boot 构建的 SpringCloud，继承了 Spring Boot 简洁、快速开发的特点，让开发者能够更加专注于业务逻辑的实现 。

（二）K8S 大揭秘

Kubernetes，简称 K8S，是一个开源的容器编排引擎，它的出现，彻底改变了容器化应用的部署和管理方式，就像一位全能的指挥官，能够高效地管理云平台中多个主机上的容器化应用。

K8S 具备众多令人瞩目的功能特点。它的自我修复能力十分强大，当节点出现故障时，能自动重启失败的容器，替换和重新部署，确保预期的副本数量，保障服务的连续性；弹性伸缩功能也非常实用，通过简单的命令、UI 操作或者基于 CPU 使用情况，就能自动快速地对应用实例进行扩容和缩容，以适应业务高峰和低谷时的不同需求；自动部署与回滚功能，采用滚动更新应用的方式，一次更新一个 Pod，避免了同时删除所有 Pod 带来的风险，若更新过程中出现问题，能及时回滚更改，确保升级过程平稳，不影响业务正常运行；服务发现和负载均衡功能，为多个容器提供了一个统一的访问入口，并能自动负载均衡关联的所有容器，让用户无需操心容器的 IP 网络问题；机密和配置管理功能，能安全地管理机密数据和应用程序配置，无需将敏感数据暴露在镜像中，提高了系统的安全性；存储编排功能，可以方便地挂载外部存储系统，无论是本地存储、公有云存储还是网络存储，都能作为集群资源的一部分灵活使用。

K8S 的核心组件各司其职，共同构建了一个稳定、高效的容器编排平台。Pod 是 K8S 中最小的部署单元，它可以看作是一个逻辑主机，里面包含了一个或多个紧密相关的容器，这些容器共享网络命名空间和存储卷，就像住在同一屋檐下的亲密伙伴，相互协作完成特定的任务。Service 是一组 Pod 的逻辑集合，它为这些 Pod 提供了服务发现和负载均衡的能力，就像一个对外的服务窗口，外界通过 Service 来访问 Pod 提供的服务，而无需关心 Pod 的具体 IP 地址和端口。Deployment 用于管理无状态应用的部署和升级，它可以方便地创建、更新和回滚应用程序，确保应用始终处于预期的状态；StatefulSet 则用于管理有状态应用的部署，保证应用的状态在扩缩容、故障恢复等过程中能够得到正确的维护；DaemonSet 用于确保每个 Node 节点上都运行同一个 Pod，常用于部署一些系统级的服务，如日志收集、监控代理等。

（三）为啥他俩要在一起

SpringCloud 和 K8S 的结合，堪称珠联璧合，优势互补，为企业带来了诸多显著的好处。

K8S 强大的容器编排和管理能力，能够很好地管理 SpringCloud 微服务。它可以将 SpringCloud 微服务打包成容器镜像，然后进行自动化部署，大大简化了部署流程，提高了部署效率。在部署过程中，K8S 可以根据预先定义的规则，将微服务容器调度到合适的节点上运行，充分利用集群资源，实现资源的高效利用。同时，K8S 的自我修复和弹性伸缩功能，能够确保 SpringCloud 微服务的高可用性和弹性。当某个微服务容器出现故障时，K8S 会自动检测并重启该容器，保证服务的正常运行；在业务高峰期，K8S 可以根据预设的策略，自动增加微服务容器的数量，以应对高并发的请求；在业务低谷期，又可以自动减少容器数量，节省资源成本。

SpringCloud 的服务治理能力与 K8S 的服务发现和负载均衡功能相得益彰。SpringCloud 的 Eureka 等服务注册与发现组件，可以与 K8S 的 Service 配合使用，实现更加灵活和强大的服务发现机制。微服务可以通过 SpringCloud 的组件将自身的信息注册到 K8S 的 Service 中，其他微服务在调用时，可以通过 K8S 的服务发现功能，快速找到目标服务，并通过负载均衡实现高效的调用。SpringCloud 的配置管理、容错处理等功能，也可以在 K8S 的环境中得到更好的应用，进一步提升系统的稳定性和可靠性。

三、准备工作：搭建魔法实验室

在开始部署 SpringCloud 项目到 K8S 之前，我们得先搭建好一个稳定的 “魔法实验室”，也就是准备好相关的环境和工具。这就好比建造一座高楼，前期的准备工作做得越扎实，后续的部署过程就越顺利。接下来，让我们一步一步地来完成这些准备工作 。

（一）创建 K8S 集群

创建 K8S 集群的方式有多种，就像通往成功的道路不止一条，我们可以根据不同的需求和场景来选择合适的方式。

如果你是在本地进行开发和测试，想要快速搭建一个 K8S 集群来体验一下它的魅力，那么 Minikube 是一个非常不错的选择。它就像是一个小巧玲珑的工具箱，能帮助你在本地轻松创建一个单节点的 K8S 集群，让你在自己的电脑上就能尽情探索 K8S 的奥秘。下面是使用 Minikube 创建 K8S 集群的详细步骤：

1. 首先，确保你的系统已经安装了虚拟化软件，比如 VirtualBox、VMware 等。这些虚拟化软件就像是一个虚拟的计算机世界，为 Minikube 提供了运行的环境。

2. 接着，前往 Minikube 的官方网站，下载适合你系统的 Minikube 安装包。下载完成后，按照安装向导的提示，一步一步地完成安装过程。这就像是安装一个普通的软件一样，非常简单。

3. 安装完成后，打开命令行工具，输入以下命令来启动 Minikube 集群：

minikube start

这个命令就像是给 Minikube 发出了一个启动的信号，它会开始在你的本地环境中创建一个 K8S 集群。在启动过程中，你可能会看到一些提示信息，比如正在下载相关的镜像文件，这都是正常的，耐心等待一会儿，直到看到 “Kubernetes is available” 这样的提示，就说明你的 K8S 集群已经成功启动啦！

如果你是在生产环境中部署 SpringCloud 项目，那么就需要考虑集群的稳定性、扩展性和性能等因素。Kubeadm 是一个专门用于在生产环境中搭建 K8S 集群的工具，它就像是一个专业的建筑团队，能够帮助你构建一个高可用、高性能的 K8S 集群。下面是使用 Kubeadm 搭建生产环境 K8S 集群的一般步骤：

1. 准备多台服务器作为 K8S 集群的节点，这些服务器就像是搭建高楼的基石，每一台都至关重要。确保这些服务器的操作系统、网络配置等都符合 K8S 的要求。

2. 在每台服务器上安装必要的软件包，比如 Docker、kubelet、kubeadm、kubectl 等。这些软件包就像是搭建 K8S 集群的各种工具，缺一不可。可以使用以下命令来安装：

# 安装Docker

sudo apt-get update

sudo apt-get install docker.io -y

# 安装kubelet、kubeadm、kubectl

sudo apt-get update

sudo apt-get install -y kubelet kubeadm kubectl

sudo systemctl enable kubelet

3. 对服务器进行初始化配置，比如关闭防火墙、禁用 SELinux、配置主机名和 hosts 文件等。这些配置就像是为服务器做好了前期的准备工作，让它们能够更好地协同工作。

4. 在主节点上使用 kubeadm 来初始化 K8S 集群，输入以下命令：

sudo kubeadm init --pod-network-cidr=10.244.0.0/16

这个命令中的--pod-network-cidr参数指定了 Pod 网络的地址范围，你可以根据实际情况进行调整。在初始化过程中，kubeadm 会自动下载相关的镜像文件，并配置好 K8S 集群的核心组件。初始化完成后，会得到一些提示信息，按照提示信息进行后续的操作，比如创建$HOME/.kube目录，并将
/etc/kubernetes/admin.conf文件复制到该目录下，这样就可以使用 kubectl 来管理 K8S 集群了。

5. 安装网络插件，比如 Flannel、Calico 等。这些网络插件就像是 K8S 集群的神经网络，负责 Pod 之间的网络通信。以 Flannel 为例，可以使用以下命令来安装：

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

6. 将其他节点加入到 K8S 集群中，在每个节点上执行主节点初始化完成后给出的kubeadm join命令，这个命令就像是一把钥匙，能够让其他节点顺利地加入到 K8S 集群中，成为集群的一部分。

（二）安装 Docker

Docker 在 SpringCloud 项目部署到 K8S 的过程中起着举足轻重的作用，它就像是一个神奇的集装箱，能够将 SpringCloud 微服务及其依赖项打包成一个独立的、可移植的容器镜像。这个容器镜像可以在任何支持 Docker 的环境中运行，大大提高了应用的部署效率和可移植性。

在安装 Docker 之前，我们需要先确认系统的内核版本是否满足要求，一般来说，Linux 系统要求内核版本在 3.0 以上，CentOS 系统需要是 7 版本。接下来，就可以按照以下步骤来安装 Docker 了：

1. 首先，更新系统的软件包列表，确保安装的是最新版本的软件包，输入以下命令：

sudo apt-get update

2. 如果之前安装过 Docker，需要先卸载已安装的 Docker，以免出现冲突，使用以下命令卸载：

sudo apt-get remove docker docker-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-engine

3. 安装 yum 工具包和存储驱动，这些工具和驱动就像是 Docker 的 “助手”，能够帮助它更好地运行，输入以下命令：

sudo apt-get install -y yum-utils

4. 设置镜像的仓库，为了提高下载速度，我们可以使用国内的镜像源，比如阿里云的镜像源，输入以下命令：

sudo yum-config-manager \

--add-repo \

https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

5. 安装 Docker，这里我们安装社区版的 Docker CE，输入以下命令：

sudo yum install docker-ce docker-ce-cli containerd.io

6. 安装完成后，启动 Docker 服务，让它开始工作，输入以下命令：

sudo systemctl start docker

7. 为了确保 Docker 安装成功，可以查看一下 Docker 的版本信息，输入以下命令：

docker version

如果能够看到 Docker 的版本号等信息，就说明 Docker 已经成功安装啦！

（三）安装 Kubectl

Kubectl 是 Kubernetes 命令行工具，它就像是 K8S 集群的 “遥控器”，通过它，我们可以方便地与 K8S 集群进行交互，执行各种管理操作，比如创建、删除、查看资源等。

安装 Kubectl 也很简单，以下是在 Linux 系统上的安装步骤：

1. 下载 Kubectl 的二进制文件，可以从 Kubernetes 的官方网站下载最新版本的 Kubectl，输入以下命令：

curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl

2. 下载完成后，为 Kubectl 二进制文件添加可执行权限，就像给一把钥匙加上了开锁的能力，输入以下命令：

chmod +x./kubectl

3. 将 Kubectl 二进制文件移动到系统的 PATH 路径中，这样就可以在任何目录下使用 Kubectl 命令了，输入以下命令：

sudo mv./kubectl /usr/local/bin/kubectl

4. 安装完成后，还需要配置 Kubectl 与 K8S 集群进行通信。如果是使用 Minikube 创建的 K8S 集群，Minikube 会自动配置好 Kubectl 的相关配置。如果是使用其他方式创建的 K8S 集群，需要将 K8S 集群的配置文件（一般是kubeconfig文件）复制到$HOME/.kube目录下，并确保KUBECONFIG环境变量指向该配置文件。可以使用以下命令来配置：

mkdir -p $HOME/.kube

sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

sudo chown $(id -u):$(id -g) $HOME/.kube/config

export KUBECONFIG=$HOME/.kube/config

5. 最后，验证一下 Kubectl 是否配置成功，可以输入以下命令查看 K8S 集群的信息：

kubectl cluster-info

如果能够看到 K8S 集群的相关信息，就说明 Kubectl 已经成功配置，可以开始使用它来管理 K8S 集群啦！

四、SpringCloud 项目改造：穿上 K8S 的新衣

在将 SpringCloud 项目部署到 K8S 之前，我们需要对项目进行一些改造，就像给它穿上一件适合 K8S 环境的新衣，让它能够更好地在 K8S 的舞台上施展拳脚。下面，让我们一起来看看具体的改造步骤 。

（一）去除 Eureka，拥抱 K8S 服务发现

在 K8S 的世界里，服务发现机制与 SpringCloud 原有的 Eureka 有所不同。K8S 通过 Service 资源为一组 Pod 提供了一个固定的访问入口，实现了服务的发现和负载均衡。这就好比在一个大型商场里，每个店铺（Pod）都有自己的位置，而商场的指示牌（Service）则为顾客提供了找到这些店铺的便捷方式。相比之下，Eureka 在 K8S 环境中显得有些多余，因为 K8S 自身的服务发现功能已经足够强大和灵活。

去除 Eureka 相关依赖的步骤并不复杂。首先，打开项目的pom.xml文件，找到 Eureka 相关的依赖项，就像在一堆杂物中找出不需要的物品。比如，移除以下依赖：

org.springframework.cloud

spring-cloud-starter-netflix-eureka-client

然后，在项目的代码中搜索并删除所有与 Eureka 相关的配置和注解。这一步就像是打扫房间，把不需要的东西都清理出去。比如，删除启动类上的@EnableEurekaClient注解，以及application.yml文件中关于 Eureka 的配置。

（二）修改 FeignClient 配置

在 SpringCloud 中，FeignClient 通常与 Eureka 结合使用，通过服务名来调用其他服务。但在 K8S 环境下，我们需要调整 FeignClient 的调用方式，以适应 K8S 的服务发现机制。这就好比你原本习惯了通过一个特定的导航系统找到目的地，现在换了一个新的导航系统，你需要重新学习如何使用它。

一种常见的修改方法是直接在 FeignClient 注解中指定服务的 URL。例如，假设我们有一个名为user-service的服务，在 K8S 中它的 Service 名称为user-service，对应的 URL 为http://user-service:8080（这里的端口号根据实际情况而定），那么我们可以这样修改 FeignClient 的配置：

@FeignClient(name = "user-service", url = "http://user-service:8080")

public interface UserServiceClient {

// 定义服务调用的方法

@GetMapping("/user/{id}")

User getUserById(@PathVariable("id") Long id);

}

在这个例子中，name属性仍然保留，用于标识 FeignClient，而url属性则指定了服务的具体访问地址。这样，FeignClient 就可以直接通过这个 URL 来调用user-service服务了。

（三）配置中心调整

配置中心是 SpringCloud 项目中非常重要的一部分，它负责管理项目的各种配置信息。在 K8S 环境下，我们可以选择使用 K8S 的 ConfigMap 作为配置中心，也可以对 Spring Cloud 原生配置中心进行调整。

如果选择使用 K8S 的 ConfigMap 作为配置中心，首先需要创建一个 ConfigMap 资源。这就像是创建一个新的文件柜，用来存放配置文件。可以通过以下命令创建一个简单的 ConfigMap：

kubectl create configmap my-config --from-literal=key1=value1 --from-literal=key2=value2

在这个命令中，my-config是 ConfigMap 的名称，key1=value1和key2=value2是配置项及其对应的值。创建好 ConfigMap 后，就可以在 Pod 中通过挂载的方式将其作为配置文件使用。比如，在 Pod 的定义文件中添加以下配置：

apiVersion: v1

kind: Pod

metadata:

name: my-pod

spec:

containers:

- name: my-container

image: my-image

volumeMounts:

- name: config-volume

mountPath: /config

volumes:

- name: config-volume

configMap:

name: my-config

在这个配置中，config-volume是一个卷的名称，它将my-config这个 ConfigMap 挂载到容器的/config目录下。这样，容器就可以读取/config目录下的配置文件了。

如果仍然使用 Spring Cloud 原生配置中心，比如 Spring Cloud Config，那么需要调整相关的配置。例如，在bootstrap.yml文件中，将配置中心的地址和其他相关配置修改为适应 K8S 环境的配置。假设配置中心的地址为http://config-server:8888，可以这样配置：

spring:

application:

name: my-service

cloud:

config:

fail-fast: true

retry:

max-attempts: 10

max-interval: 10000

initial-interval: 1000

profile: ${SPRING_CLOUD_CONFIG_PROFILE:dev}

uri: ${SPRING_CLOUD_CONFIG_URI:http://config-server:8888}

在这个配置中，
SPRING_CLOUD_CONFIG_PROFILE和SPRING_CLOUD_CONFIG_URI可以通过环境变量的方式在 K8S 中进行动态配置，以适应不同的环境需求。

五、构建 Docker 镜像：打造可移植的容器

在将 SpringCloud 项目部署到 K8S 之前，我们需要先将项目构建成 Docker 镜像，这就像是把项目装进一个集装箱里，使其可以在不同的环境中轻松运输和部署。下面，我们就来详细了解一下构建 Docker 镜像的过程 。

（一）编写 Dockerfile

Dockerfile 是一个用于构建 Docker 镜像的文本文件，它包含了一系列的指令，这些指令就像是一个个施工步骤，告诉 Docker 如何构建镜像。下面是一个简单的 SpringCloud 项目的 Dockerfile 示例：

# 使用官方的OpenJDK 8镜像作为基础镜像

FROM openjdk:8-jdk

# 将本地jar包添加到容器中，并命名为app.jar

ADD target/*.jar app.jar

# 暴露应用程序的端口，这里假设SpringCloud项目的端口是8080

EXPOSE 8080

# 设置容器启动命令，运行app.jar

ENTRYPOINT ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "app.jar"]

在这个 Dockerfile 中，各指令的含义如下：

• FROM：指定基础镜像，这里我们使用官方的 OpenJDK 8 镜像，它就像是搭建房子的基石，为我们的镜像提供了一个基础环境。

• ADD：将本地的 jar 包添加到容器中，并命名为 app.jar。target/*.jar表示项目编译后生成的 jar 包，会被复制到容器的根目录下并命名为 app.jar，这一步就像是把项目的核心 “货物” 装进了集装箱。

• EXPOSE：声明容器内应用程序监听的端口，这里是 8080 端口，它就像是在集装箱上标明了货物的 “出入口”，告诉外界可以通过这个端口来访问容器内的应用程序。

• ENTRYPOINT：指定容器启动时执行的命令，这里是运行app.jar，它就像是给集装箱设置了一个启动开关，当容器启动时，就会执行这个命令来启动我们的 SpringCloud 项目。

（二）构建镜像

编写好 Dockerfile 后，就可以使用 Docker 命令来构建镜像了。在命令行中，切换到包含 Dockerfile 的项目目录，然后执行以下命令：

docker build -t your-image-name:your-tag.

在这个命令中：

• -t：用于指定镜像的标签，格式为镜像名:标签，比如my-springcloud-app:1.0，其中my-springcloud-app是镜像名，1.0是标签，你可以根据实际情况进行修改，它就像是给集装箱贴上了一个独特的标签，方便识别和管理。

• .：表示当前目录，即 Dockerfile 所在的目录，它告诉 Docker 从当前目录读取 Dockerfile 来构建镜像，就像是告诉施工队从哪个地方开始施工。

例如，假设我们的项目名为my-springcloud-project，想要构建一个标签为v1.0的镜像，那么命令就是：

docker build -t my-springcloud-project:v1.0.

执行这个命令后，Docker 会根据 Dockerfile 中的指令，逐步构建镜像。在构建过程中，你会看到一系列的输出信息，显示构建的进度和状态。如果构建成功，你会得到一个新的 Docker 镜像，它包含了我们的 SpringCloud 项目及其依赖项 。

（三）推送镜像到仓库

构建好镜像后，我们需要将其推送到 Docker Registry，这样在 K8S 集群中就可以方便地拉取并使用这个镜像了。Docker Registry 就像是一个大型的仓库，专门用来存放 Docker 镜像。

首先，你需要登录到 Docker Registry。如果你使用的是 Docker Hub，执行以下命令：

docker login

然后输入你的 Docker Hub 账号和密码进行登录。如果你使用的是私有 Registry，比如阿里云的镜像仓库，登录命令会有所不同，例如：

docker login --username=your-username registry.cn-hangzhou.aliyuncs.com

其中，your-username是你的阿里云账号，
registry.cn-hangzhou.aliyuncs.com是阿里云镜像仓库的地址，根据实际情况进行替换。

登录成功后，就可以推送镜像了。推送镜像的命令如下：

docker push your-image-name:your-tag

例如，对于我们之前构建的
my-springcloud-project:v1.0镜像，如果要推送到 Docker Hub，命令就是：

docker push my-springcloud-project:v1.0

如果是推送到阿里云镜像仓库，假设仓库地址为
registry.cn-hangzhou.aliyuncs.com/your-namespace/your-repository，那么命令就是：

docker tag my-springcloud-project:v1.0 registry.cn-hangzhou.aliyuncs.com/your-namespace/your-repository:v1.0

docker push registry.cn-hangzhou.aliyuncs.com/your-namespace/your-repository:v1.0

在这个过程中，docker tag命令用于给镜像打标签，将镜像标记为目标仓库的格式，然后使用docker push命令将镜像推送到指定的仓库中 。

六、K8S 部署：让项目在集群中起飞

经过前面一系列的准备和改造，我们终于来到了激动人心的部署环节，就像一场精彩的演出即将拉开帷幕。现在，我们要将精心准备的 SpringCloud 项目部署到 K8S 集群中，让它在这个强大的容器编排平台上展翅翱翔 。

（一）创建 Deployment

Deployment 是 K8S 中用于管理无状态应用部署的重要资源对象，它就像是一个贴心的管家，负责管理应用的副本数量、更新策略以及回滚操作等。通过 Deployment，我们可以轻松地实现应用的弹性伸缩和版本管理，确保应用始终以最佳状态运行。

下面是一个 Deployment 的 YAML 文件示例：

apiVersion: apps/v1

kind: Deployment

metadata:

name: springcloud-demo

labels:

app: springcloud-demo

spec:

replicas: 3

selector:

matchLabels:

app: springcloud-demo

template:

metadata:

labels:

app: springcloud-demo

spec:

containers:

- name: springcloud-demo

image: your-docker-registry/your-image:your-tag

ports:

- containerPort: 8080

在这个示例中，各配置项的含义如下：

• apiVersion：指定 K8S API 的版本，这里使用的是apps/v1版本，它就像是一个协议版本号，告诉 K8S 系统我们遵循的是哪种规范。

• kind：指定资源类型，这里是Deployment，明确了我们创建的是一个部署资源。

• metadata：包含了资源的元数据信息，比如name指定了 Deployment 的名称为springcloud-demo，这个名称就像是给 Deployment 取了一个独一无二的名字，方便我们在 K8S 集群中识别和管理它；labels则是一组标签，这里定义了app: springcloud-demo，标签可以用于对资源进行分类和筛选，就像给物品贴上不同的标签，便于快速找到它们。

• spec：定义了 Deployment 的详细规格，是整个配置文件的核心部分。replicas指定了期望的 Pod 副本数量为 3，这意味着 K8S 会努力确保集群中始终运行着 3 个该应用的实例，就像安排了 3 个员工同时工作，以满足业务的需求；selector用于选择要管理的 Pod，通过matchLabels指定了与app: springcloud-demo标签匹配的 Pod，它就像是一个精准的过滤器，将符合条件的 Pod 筛选出来，由这个 Deployment 进行管理；template定义了 Pod 的模板，包括metadata和spec两部分。在metadata中，再次定义了app: springcloud-demo标签，确保 Pod 与 Deployment 的标签一致，便于关联和管理；spec则定义了 Pod 中容器的详细信息，name指定了容器的名称为springcloud-demo，image指定了要使用的 Docker 镜像，格式为your-docker-registry/your-image:your-tag，这里需要替换为你实际的镜像仓库地址、镜像名和标签，就像告诉 K8S 要从哪个仓库中取出哪个镜像来运行；ports指定了容器暴露的端口，这里将容器的 8080 端口暴露出来，外界可以通过这个端口来访问容器内的应用程序。

（二）创建 Service

创建好 Deployment 后，我们的应用在 K8S 集群中已经开始运行了，但是此时它还隐藏在集群内部，外界无法直接访问。这时候，就需要 Service 登场了。Service 是 K8S 中用于暴露应用服务的资源对象，它就像是一个对外的服务窗口，为一组 Pod 提供了一个稳定的访问入口，并实现了负载均衡功能，将请求均匀地分发到后端的 Pod 上，确保应用的高可用性和高性能。

下面是一个 Service 的 YAML 文件示例：

apiVersion: v1

kind: Service

metadata:

name: springcloud-demo-service

labels:

app: springcloud-demo

spec:

selector:

app: springcloud-demo

ports:

- protocol: TCP

port: 80

targetPort: 8080

type: LoadBalancer

在这个示例中，各配置项的含义如下：

• apiVersion：同样指定了 K8S API 的版本为v1。

• kind：指定资源类型为Service。

• metadata：包含了 Service 的元数据信息，name指定了 Service 的名称为springcloud-demo-service，labels与 Deployment 的标签保持一致，方便关联和管理。

• spec：定义了 Service 的详细规格。selector通过标签app: springcloud-demo选择了要暴露的 Pod，确保 Service 与对应的 Pod 建立联系；ports定义了服务的端口映射关系，protocol指定协议为 TCP，port指定 Service 暴露的端口为 80，这个端口是外界访问 Service 的入口，就像一个商店的大门；targetPort指定了后端 Pod 中容器暴露的端口为 8080，当外界请求到达 Service 的 80 端口时，会被转发到后端 Pod 的 8080 端口上，实现请求的正确转发；type指定了 Service 的类型为LoadBalancer，这种类型的 Service 会在支持的云平台上自动创建一个外部负载均衡器，为应用分配一个外部 IP 地址，使得外界可以通过这个 IP 地址来访问应用，就像在商店门口设置了一个显眼的招牌，方便顾客找到。

（三）部署应用

有了 Deployment 和 Service 的配置文件后，我们就可以使用 Kubectl 命令将应用部署到 K8S 集群中了。Kubectl 就像是一个神奇的遥控器，通过它，我们可以轻松地控制 K8S 集群，实现各种管理操作。

部署应用的步骤如下：

1. 确保你已经切换到包含 Deployment 和 Service 配置文件的目录下，这就像是找到存放工具的地方，方便随时取用。

2. 使用以下命令创建 Deployment：

kubectl apply -f deployment.yaml

这个命令会读取deployment.yaml文件中的配置信息，并在 K8S 集群中创建对应的 Deployment 资源。执行命令后，你会看到类似以下的输出信息：

deployment.apps/springcloud-demo created

这表示 Deployment 已经成功创建。

3. 使用以下命令创建 Service：

kubectl apply -f service.yaml

同样，这个命令会读取service.yaml文件中的配置信息，在 K8S 集群中创建对应的 Service 资源。执行命令后，输出信息可能如下：

service/springcloud-demo-service created

这说明 Service 也创建成功了。

4. 验证应用是否部署成功，可以使用以下命令查看 Pod、Deployment 和 Service 的状态：

kubectl get pods

kubectl get deployments

kubectl get services

执行kubectl get pods命令后，你会看到类似以下的输出：

NAME                                 READY   STATUS    RESTARTS   AGE

springcloud-demo-6b8d859988-5gq5h 1/1 Running 0 2m

springcloud-demo-6b8d859988-7d7t7 1/1 Running 0 2m

springcloud-demo-6b8d859988-j7d8f 1/1 Running 0 2m

这里显示了每个 Pod 的名称、状态、重启次数和运行时间等信息。如果 Pod 的STATUS为Running，说明 Pod 正在正常运行。

执行kubectl get deployments命令后，输出可能如下：

NAME               READY   UP-TO-DATE   AVAILABLE   AGE

springcloud-demo 3/3 3 3 2m

这里的READY表示当前运行的 Pod 副本数量与期望的副本数量一致，UP-TO-DATE表示已经更新到最新版本的 Pod 数量，AVAILABLE表示可用的 Pod 数量，AGE表示 Deployment 的运行时间。

执行kubectl get services命令后，输出可能如下：

NAME                      TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE

springcloud-demo-service LoadBalancer 10.100.100.100 80:32367/TCP 2m

这里显示了 Service 的名称、类型、集群 IP、外部 IP、端口映射和运行时间等信息。如果 Service 的类型是LoadBalancer，EXTERNAL-IP字段可能会显示，这表示云平台正在为其分配外部 IP 地址。稍等片刻后，再次执行该命令，EXTERNAL-IP字段会显示实际分配的外部 IP 地址。

5. 当EXTERNAL-IP字段显示实际的外部 IP 地址后，你就可以使用浏览器或其他 HTTP 工具，访问http://，来验证 SpringCloud 应用是否正常运行。如果一切顺利，你将看到应用的页面或接收到应用返回的响应数据，这就意味着你的 SpringCloud 项目已经成功部署到 K8S 集群中啦！

七、常见问题与解决：扫除部署路上的障碍

在部署 SpringCloud 项目到 K8S 的过程中，难免会遇到一些 “拦路虎”，但只要我们掌握正确的解决方法，就能轻松应对。下面为大家列举一些常见问题及解决方法 。

（一）镜像拉取失败

在部署过程中，最常见的问题之一就是镜像拉取失败。这可能是由于多种原因导致的，比如镜像名称拼写错误、网络连接问题、私有镜像仓库认证失败等。当遇到镜像拉取失败的问题时，首先要检查镜像名称是否正确，包括镜像仓库地址、镜像名和标签，确保没有拼写错误。例如，假设我们要拉取的镜像地址为
registry.cn-hangzhou.aliyuncs.com/your-namespace/your-repository:v1.0，要仔细核对每个部分是否准确无误。

网络连接问题也是导致镜像拉取失败的常见原因之一。我们可以通过在 K8S 集群的节点上执行ping命令，来检查是否能够访问镜像仓库的地址。比如，执行ping
registry.cn-hangzhou.aliyuncs.com，如果无法 ping 通，说明网络存在问题，需要检查网络配置、防火墙设置等。如果是私有镜像仓库，还需要确保 K8S 集群已经正确配置了认证信息。可以使用以下命令创建一个用于认证的 Secret：

kubectl create secret docker-registry my-registry-secret --docker-server=REGISTRY_SERVER --docker-username=REGISTRY_USERNAME --docker-password=REGISTRY_PASSWORD --docker-email=REGISTRY_EMAIL

然后在 Pod 的配置文件中引用这个 Secret：

apiVersion: v1

kind: Pod

metadata:

name: my-pod

spec:

containers:

- name: my-container

image: my-private-registry/my-image:latest

imagePullSecrets:

- name: my-registry-secret

（二）Pod 无法启动

Pod 无法启动也是一个令人头疼的问题，其原因可能多种多样。容器端口冲突是常见原因之一，如果 Pod 中定义的容器端口与其他正在运行的服务端口冲突，就会导致 Pod 无法启动。比如，我们在 Pod 中定义容器暴露 8080 端口，但节点上已经有其他服务占用了 8080 端口，这时就需要检查 Pod 的端口配置，确认没有与其他正在运行的服务端口冲突。如果端口确实被占用，可以停止占用端口的服务，或者更改容器的端口配置。

资源不足也可能导致 Pod 无法启动。当节点上的资源（如 CPU、内存、磁盘空间等）不足以满足 Pod 的资源请求时，Pod 就无法正常启动。我们可以使用kubectl top node命令查看节点的资源使用情况，确认是否有足够的资源可用。同时，要检查 Pod 的资源请求和限制配置是否合理。例如，在 Pod 的配置文件中，我们可以设置资源请求和限制：

apiVersion: v1

kind: Pod

metadata:

name: my-pod

spec:

containers:

- name: my-container

image: nginx

resources:

requests:

cpu: 100m

memory: 200Mi

limits:

cpu: 200m

memory: 300Mi

如果发现节点资源不足，可以考虑增加集群中的节点数量，或者调整其他 Pod 的资源使用情况，以确保有足够的资源分配给当前 Pod。

（三）服务无法访问

部署完成后，有时会遇到服务无法访问的情况。这可能是由于 Service 配置错误、网络策略限制等原因导致的。首先，要检查 Service 的配置是否正确，比如 Service 的类型、端口映射等。以 LoadBalancer 类型的 Service 为例，如果EXTERNAL-IP字段一直显示，可能是云平台的负载均衡器配置出现问题。这时，可以查看云平台的相关日志，了解具体的错误信息。同时，要确保 Service 的selector能够正确匹配到后端的 Pod，否则请求无法转发到正确的 Pod 上。

网络策略限制也可能导致服务无法访问。K8S 中的网络策略可以限制 Pod 之间的网络通信，如果网络策略配置不当，可能会阻止外部请求访问到服务。可以使用kubectl describe networkpolicy命令查看网络策略的详细信息，确认是否存在限制服务访问的规则。如果发现网络策略限制了服务的访问，可以根据实际需求调整网络策略，或者创建新的网络策略来允许服务的访问。

八、总结与展望：部署后的新世界

通过以上步骤，我们成功地将 SpringCloud 项目部署到了 K8S 上，实现了从项目改造、镜像构建到集群部署的全流程操作。在这个过程中，我们深入了解了 SpringCloud 和 K8S 的相关知识，掌握了如何将两者有机结合，发挥出它们的最大优势。回顾整个部署过程，关键要点在于对项目的合理改造，确保其适应 K8S 的环境；精心编写 Dockerfile，构建出高质量的 Docker 镜像；以及准确配置 K8S 的 Deployment 和 Service，实现应用的稳定部署和对外访问。

展望未来，SpringCloud 与 K8S 的结合将在企业级应用开发中发挥更加重要的作用。随着云计算和容器技术的不断发展，这种组合将为企业提供更加高效、灵活、可靠的解决方案，助力企业在数字化转型的道路上加速前行。对于开发者来说，这也是一个充满机遇和挑战的领域。掌握 SpringCloud 项目在 K8S 上的部署技术，不仅能够提升个人的技术能力，还能为企业创造更大的价值。希望大家能够积极尝试和探索，在这个充满创新的领域中不断前行，收获更多的技术成果和实践经验 。