85、使用 Kubernetes 将应用程序部署为容器

脚滑的狐狸160

于 2025-07-25 13:34:46 发布

阅读量54

点赞数

CC 4.0 BY-SA版权

分类专栏： Linux圣经：从入门到精通文章标签： Kubernetes 容器部署应用扩展

本文链接：https://blog.youkuaiyun.com/nginx7reverse/article/details/149706132

Linux圣经：从入门到精通专栏收录该内容

88 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

使用 Kubernetes 将应用程序部署为容器

1. 理解 Kubernetes

Kubernetes 集群由主节点和工作节点组成。对于个人使用，可以在同一系统上运行所有主节点和工作节点服务，例如借助 Minikube 在笔记本电脑的虚拟机上运行 Kubernetes 集群。在生产环境中，则需将 Kubernetes 部署在多个物理或虚拟系统上。以下是搭建生产级 Kubernetes 基础设施时需要考虑的不同组件：
|组件|说明|
| ---- | ---- |
|主节点（Masters）|管理 Kubernetes 集群中运行的组件，负责组件间通信、调度应用程序在工作节点上运行、按需扩展应用程序，并确保运行正确数量的容器（分布在 Pod 中）。建议至少有一个主节点，通常会有三个或更多，以保证始终有可用的主节点。|
|工作节点（Workers）|已部署的容器实际运行的地方。所需工作节点的数量取决于工作负载。在生产环境中，为防止某个节点出现故障或需要维护，通常会设置多个工作节点。|
|存储（Storage）|网络存储允许容器访问相同的存储，而不受运行它们的节点的影响。|
|其他服务（Other services）|为将 Kubernetes 环境集成到现有数据中心，可能需要利用现有服务，如使用公司的 DNS 服务器进行主机名到地址的解析、使用 LDAP 或 Active Directory 服务进行用户认证，以及使用网络时间协议（NTP）服务器同步时间。|

在 Kubernetes 中，部署容器的最小单位称为 Pod。一个 Pod 可以包含一个或多个容器，以及描述其容器的元数据。虽然一个 Pod 可以只包含一个容器，但有时包含多个容器也是合适的，例如一个 Pod 可能包含一个边车容器，用于监控 Pod 中主容器运行的服务。

2. Kubernetes 主节点

Kubernetes 主节点指导 Kubernetes 集群的活动。主节点通过一组服务监督集群的所有活动，其核心是 API 服务器（kube - apiserver），它接收对象请求，集群中所有节点之间的通信都通过 API 服务器进行。

当 Kubernetes 主节点接收到一个对象（如要求运行一定数量的 Pod）时，Kubernetes 调度器（kube - scheduler）会找到可用的节点来运行每个 Pod，并安排它们在这些节点上运行。为确保每个对象保持规定的状态，Kubernetes 控制器（kube - controller - manager）会持续运行，例如确保命名空间存在、定义的服务账户可用、运行正确数量的副本以及定义的端点处于活动状态。

3. Kubernetes 工作节点

每个 Kubernetes 工作节点的核心是 kubelet 服务。kubelet 会将其工作节点注册到 API 服务器，然后 API 服务器会指示 kubelet 执行一些操作，如运行通过 PodSpec 从 API 服务器请求的容器，并确保其持续健康运行。

每个节点上还运行着一个容器引擎（通常称为运行时）。最初，docker 服务是用于根据 PodSpec 启动、管理和删除容器的最流行的容器引擎。不过，现在也有其他容器引擎可供选择，例如 CRI - O 容器引擎（https://cri - o.io/），它被用于一些商业 Kubernetes 平台，如 OpenShift。

工作节点应尽可能通用，以便在需要额外容量时可以轻松启动新节点，并且该节点将被配置为处理大多数运行容器的请求。然而，有时容器可能不适合在特定节点上运行。例如，一个 Pod 可能要求在具有最小内存和 CPU 可用量的节点上运行，或者要求在运行相关容器的节点上运行。同样，如果一个 Pod 需要特殊的运行条件，如特定的计算机架构、硬件或操作系统，也有办法将 Pod 调度到满足这些需求的工作节点上。

4. Kubernetes 应用程序

在 Kubernetes 中，应用程序通过定义 API 对象来管理，这些对象设置集群上资源的状态。例如，可以在 YAML 文件中创建一个 Deployment 对象，该对象定义每个运行一个或多个容器的 Pod，以及它运行的命名空间和每个 Pod 的副本数量。该对象还可以定义每个容器打开的端口和挂载的任何卷。Kubernetes 主节点会响应这些请求，并确保在 Kubernetes 工作节点上执行这些请求。

Kubernetes 使用服务的概念将应用程序的位置与其实际 IP 地址和端口号分离。通过为提供该服务的一组 Pod 分配一个服务名称，集群外部无需知道每个 Pod 的确切位置。相反，由 Kubernetes 将对该服务的请求定向到可用的 Pod。

默认情况下，与活动 Pod 关联的 IP 地址不能从集群外部直接访问。需要定义如何将与一组 Pod 关联的服务暴露到集群外部。使用 Service 对象，可以通过不同的方式暴露服务：
- ClusterIP ：默认情况下，通过 ClusterIP 服务类型暴露的服务仅对集群内的其他组件可用。
- NodePort ：使用 NodePort 可以使提供服务的 Pod 通过每个运行该 Pod 的节点上的外部 IP 地址上的相同 Kubernetes 分配的端口进行访问。
- LoadBalancer ：使用 LoadBalancer 可以分配一个外部固定 IP 地址，该地址作为提供服务的 Pod 的负载均衡器。云的外部负载均衡器会将流量导向后端 Pod。
- ExternalName ：使用 ExternalName 可以将服务与特定的 DNS CNAME 记录关联起来。

无论如何暴露 Kubernetes 服务，当有对该服务的请求时，Kubernetes 会将通信路由到提供该服务的一组 Pod。这样，Pod 可以启动和停止，而不会影响使用该服务的客户端。

5. Kubernetes 接口

Kubernetes 提供了命令行和 Web 控制台两种接口来访问 Kubernetes 集群。本文的示例主要关注命令行工具，包括用于管理 Kubernetes 虚拟机并启动和停止集群的 minikube，以及用于管理 Kubernetes 集群的通用工具 kubectl。

6. 尝试使用 Kubernetes

搭建自己的生产级 Kubernetes 集群需要一些规划，下面介绍两种快速启动并访问个人 Kubernetes 集群的简单方法：
- Kubernetes 教程 ：官方 Kubernetes 网站提供交互式 Web UI 教程，可以在其中启动自己的集群并尝试使用 Kubernetes。从 Kubernetes 教程（https://kubernetes.io/docs/tutorials/）中，可以选择基础、配置、无状态应用程序等不同的教程主题。
- Minikube ：借助 Minikube，可以在自己的计算机上运行 Kubernetes。能够运行虚拟机的 Linux、MacOS 或 Windows 系统可以获取 Minikube VM，并在几分钟内在笔记本电脑或台式机系统上运行 Kubernetes 集群。
- Docker Desktop ：另一个选择（本文未详细介绍）是 Docker Desktop，它允许在工作站上启用预配置的 Kubernetes 集群，该集群运行一个主节点和一个工作节点。

7. 获取 Kubernetes

可以通过 Kubernetes 基础教程或安装并启动 Minikube 来访问 Kubernetes 集群，具体操作如下：

7.1 启动 Kubernetes 基础教程

要启动 Kubernetes 项目的基础交互式教程，请在 Web 浏览器中访问以下 URL：
https://kubernetes.io/docs/tutorials/kubernetes - basics/create - cluster/cluster - interactive

此时，可以按照教程中的提示进行操作。由于该教程会启动一个实时集群，因此也可以使用该界面尝试其他命令。

7.2 启动 Minikube

在个人计算机上运行 Minikube 需要满足以下条件：
- 计算机需要配置为虚拟机管理程序，以便运行 Minikube 虚拟机。
- 需要安装 kubectl 命令（用于访问和操作集群）和 Minikube VM 本身。

对于 Linux、MacOS 和 Windows 系统，可以在以下链接找到最新的安装说明：
https://kubernetes.io/docs/tasks/tools/install - minikube/

可以以 root 用户身份安装 Minikube，但后续需要以普通用户账户运行。在 Fedora、RHEL、Ubuntu 或其他 Linux 系统上安装 Minikube 的步骤如下（如果有变化，请参考 install - minikube 页面）：
1. 安装 kubectl 命令：获取与 Minikube 中的 Kubernetes 版本相差不超过一个版本的 kubectl 命令。安装最新版本的 kubectl 和 minikube 通常可以满足此要求。输入以下命令（所有内容在一行）：

# curl -LO \
 https://storage.googleapis.com/kubernetes - release/release/`curl \
 -s https://storage.googleapis.com/kubernetes - release/release/stable.txt \
 `/bin/linux/amd64/kubectl

将 kubectl 复制到 bin 目录：将 kubectl 命令复制到可访问的 bin 目录并使其可执行。例如：

# mkdir /usr/local/bin
# cp kubectl /usr/local/bin
# chmod 755 /usr/local/bin/kubectl

配置虚拟机管理程序：将 Linux 系统配置为虚拟机管理程序。对于 KVM，请参考相关文档进行配置。
获取 minikube：获取 minikube 可执行文件，输入以下命令（在一行）：

# curl -Lo minikube \
https://storage.googleapis.com/minikube/releases/latest/minikube - linux - amd64 \
&& chmod +x minikube

安装 Minikube：输入以下命令：

# install minikube /usr/local/bin/

运行 Minikube：以普通用户身份，输入以下命令来指定虚拟机驱动（如果使用的是 KVM，请参考 https://minikube.sigs.k8s.io/docs/reference/drivers 了解其他虚拟机驱动的使用方法）：

$ minikube config set vm - driver kvm2
$ minikube start --vm - driver = kvm2

开始使用 Minikube：可以通过运行一些 minikube 和 kubectl 命令来开始使用 Minikube。具体示例将在后续教程中展示。

8. 运行 Kubernetes 基础教程

Kubernetes 基础教程提供了一组很好的命令，帮助用户开始熟悉 Kubernetes：
https://kubernetes.io/docs/tutorials/kubernetes - basics/create - cluster/cluster - interactive

以下将介绍 Kubernetes 基础教程的前五个模块：

8.1 获取集群信息

运行以下命令以获取集群的基本信息：
1. 列出 Minikube 版本：要查看正在使用的 minikube 版本，输入以下命令：

$ minikube version
minikube version: v1.7.2
commit: 50d543b5fcb0e1c0d7c27b1398a9a9790df09dfb

列出集群信息：要查看 Kubernetes 主节点和 DNS 服务的可用 URL，输入以下命令：

$ kubectl cluster - info
Kubernetes master is running at https://192.168.39.150:8443
KubeDNS is running at
https://192.168.39.150:8443/api/v1/namespaces/kube - system/services/kube - dns:dns/proxy
To further debug and diagnose cluster problems, use 'kubectl cluster - info dump'.

列出节点信息：要查看正在运行的节点数量（对于 Minikube 只有一个主节点）及其状态，输入以下命令：

$ kubectl get nodes
NAME     STATUS   ROLES  AGE   VERSION
minikube Ready    master 23m   v1.17.2

列出集群和客户端版本：要列出 kubectl 客户端和 Kubernetes 集群的版本（确保它们的版本相差不超过一个版本），输入以下命令：

$ kubectl version
Client Version: version.Info{Major:"1", Minor:"17",
GitVersion:"v1.17.2", 
GitCommit:"59603c6e503c87169aea6106f57b9f242f64df89", 
GitTreeState:"clean", BuildDate:"2020 - 01 - 18T23:30:10Z", 
GoVersion:"go1.13.5", Compiler:"gc", Platform:"linux/amd64"}

Server Version: version.Info{Major:"1", Minor:"17",
GitVersion:"v1.17.2", 
GitCommit:"59603c6e503c87169aea6106f57b9f242f64df89", 
GitTreeState:"clean", BuildDate:"2020 - 01 - 18T23:22:30Z", 
GoVersion:"go1.13.5", Compiler:"gc", Platform:"linux/amd64"}

8.2 部署 Kubernetes 应用程序

在 Kubernetes 集群上运行和管理容器化应用程序（以 Pod 的形式）的请求称为部署。一旦创建了部署，Kubernetes 集群将确保请求的 Pod 始终运行，具体操作如下：
- 通过 API 服务器接受部署创建请求。
- 要求调度器在可用的工作节点上运行每个 Pod 中请求的容器。
- 监控 Pod，确保它们按要求继续运行。
- 如果 Pod 出现故障（例如容器停止运行），在相同或不同的节点上启动一个新的 Pod 实例。

教程展示了如何从容器镜像创建一个简单部署的示例。在这个示例中，只需提供一个名称并指定要使用的容器镜像，其余部署设置将使用默认值。
1. 创建部署：要启动一个部署，拉取 kubernetes - bootcamp 容器，并将部署名称设置为 kubernetes - bootcamp，输入以下命令：

$ kubectl create deployment kubernetes - bootcamp \
      --image = gcr.io/google - samples/kubernetes - bootcamp:v1
deployment.apps/kubernetes - bootcamp created

列出部署：要查看部署是否存在（并确认请求了一个实例且有一个正在运行），输入以下命令：

$ kubectl get deployments
NAME                  READY   UP - TO - DATE   AVAILABLE   AGE
kubernetes - bootcamp   1/1     1            1           4m38s

描述部署：要查看部署的详细信息，输入以下命令：

$ kubectl describe deployments kubernetes - bootcamp
Name:                   kubernetes - bootcamp
Namespace:              default
...
Replicas:   1 desired | 1 updated | 1 total | 1 available | 0 unavailable
...
Pod Template:
  Labels:  app = kubernetes - bootcamp
  Containers:
   kubernetes - bootcamp:
    Image:        gcr.io/google - samples/kubernetes - bootcamp:v1
    Port:         <none>
    Host Port:    <none>
    Environment:  <none>
    Mounts:       <none>
  Volumes:        <none>
...

在 kubernetes - bootcamp 部署中，注意到它只设置了一个与部署关联的 Pod 实例（副本）可用。该部署在当前命名空间（默认为 default）中运行。同时，注意到默认情况下 Pod 没有打开端口或挂载卷。

8.3 获取部署的 Pod 信息

创建部署后，可以请求有关从该部署创建的 Pod 的信息，并通过代理服务将 VM 中的 Kubernetes API 暴露到本地系统，以便直接连接到 Pod。
1. 将 Kubernetes API 暴露到本地系统：要从系统打开一个代理到 Minikube 中运行的 Kubernetes API（kubectl proxy），输入以下命令：

$ kubectl proxy
Starting to serve on 127.0.0.1:8001

查询 Kubernetes API：打开第二个终端，输入以下命令查询 Minikube 上运行的 Kubernetes API：

$ curl http://localhost:8001/version
{
 "major": "1",
 "minor": "17",
 "gitVersion": "v1.17.2",
 "gitCommit": "59603c6e503c87169aea6106f57b9f242f64df89",
 "gitTreeState": "clean",
 "buildDate": "2020 - 01 - 18T23:22:30Z",
 "goVersion": "go1.13.5",
 "compiler": "gc",
 "platform": "linux/amd64"
}

获取 Pod 信息：此部署中使用的 Pod 名称为 kubernetes - bootcamp 后面跟着一串唯一的字符。输入以下命令输出 Pod 的名称，然后列出该 Pod 的描述信息：

$ kubectl get pods
NAME                                   READY   STATUS    RESTARTS   AGE
kubernetes - bootcamp - 69fbc6f4cf - njc4b   1/1     Running   0          12m
$ kubectl describe pod kubernetes - bootcamp - 69fbc6f4cf - njc4b
Name:         kubernetes - bootcamp - 69fbc6f4cf - njc4b
Namespace:    default
Priority:     0
Node:         minikube/192.168.39.150
...
Containers:
  kubernetes - bootcamp:
    Container ID:    
docker://dd24fd43ff19d6cf12f5c759036cee74adcf2d0e2c55a42e... 
    Image:          gcr.io/google - samples/kubernetes - bootcamp:v1
    Image ID:       docker - pullable://gcr.io/google - samples...
...
Events:
  Type    Reason     Age   From               Message
  ----    ------     ----  ----               -------
  Normal  Scheduled  14m   default - scheduler  Successfully assigned 
default/kubernetes - bootcamp - 69fbc6f4cf - njc4b to minikube
  Normal  Pulled     14m   kubelet, minikube  Container image 
"gcr.io/google - samples/kubernetes - bootcamp:v1"
already present on machine
  Normal  Created    14m   kubelet, minikube  Created container 
kubernetes - bootcamp
  Normal  Started    14m   kubelet, minikube  Started container 
kubernetes - bootcamp

从精简后的输出中，可以看到 Pod 的名称、所在的命名空间（default）以及运行它的节点（minikube/192.168.39.150）。在 Containers 部分，可以看到正在运行的容器的名称（docker://dd24fd43ff19…）、它所使用的镜像（…kubernetes - bootcamp:v1）以及该镜像的 ID。在 Events 部分，从底部开始，可以看到 minikube 节点上的 kubelet 启动并创建了容器，它去拉取镜像时发现该镜像已经在节点上，然后将 Pod 分配到该节点上运行。
4. 连接到 Pod：使用 curl 命令联系 Pod 并获取其响应信息：

$ export POD_NAME=$(kubectl get pods - o go - template --template \
 '{{range .items}}{{.metadata.name}}{{"\n"}}{{end}}') ; \
echo Name of the Pod: $POD_NAME
Name of the Pod: kubernetes - bootcamp - 69fbc6f4cf - njc4b

$ curl \
 http://localhost:8001/api/v1/namespaces/default/pods/$POD_NAME/proxy/
Hello Kubernetes bootcamp!|Running on:kubernetes - bootcamp - 5b48cfdcbd - lf9t2|v = 1

查看日志：要查看所选 Pod 中运行的任何容器的日志，运行以下命令：

$ kubectl logs $POD_NAME
Kubernetes Bootcamp App Started At: 2020 - 02 - 13T21:29:21.836Z
| Running On:  kubernetes - bootcamp - 5b48cfdcbd - lf9t2

Running On: kubernetes - bootcamp - 5b48cfdcbd - lf9t2 | Total Requests:
1 | App Uptime: 34.086 seconds | Log Time: 2020 - 02 - 13T21:29:55.923Z

在 Pod 中执行命令：使用 kubectl exec 在 Pod 内部运行命令。第一个命令运行 env 以查看 Pod 内部的 shell 环境变量，第二个命令在 Pod 内部打开一个 shell，以便运行后续命令：

$ kubectl exec $POD_NAME env
PATH = /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOSTNAME = kubernetes - bootcamp - 5b48cfdcbd - lf9t2
KUBERNETES_SERVICE_HOST = 10.96.0.1
KUBERNETES_SERVICE_PORT = 443
...
$ kubectl exec - ti $POD_NAME bash
root@kubernetes - bootcamp - 5b48cfdcbd - lf9t2:/# date
Thu Feb 13 21:57:18 UTC 2020

kubernetes - bootcamp - 5b48cfdcbd - lf9t2:/# ps - ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 21:29 ?        00:00:00 /bin/sh - c node 
server.js
root         6     1  0 21:29 ?        00:00:00 node server.js
root       115     0  0 21:55 pts/0    00:00:00 bash
root       123   115  0 22:01 pts/0    00:00:00 ps - ef

通过以上步骤，你可以逐步了解并使用 Kubernetes 来部署和管理容器化应用程序。

使用 Kubernetes 将应用程序部署为容器

9. 扩展与更新 Kubernetes 应用

在实际应用中，根据业务需求，我们可能需要对已部署的 Kubernetes 应用进行扩展和更新。

9.1 扩展应用

扩展应用即增加 Pod 的副本数量，以应对更高的流量或工作负载。以下是扩展 kubernetes-bootcamp 部署的步骤：
1. 扩展部署：使用 kubectl scale 命令将 kubernetes-bootcamp 部署的副本数量从 1 扩展到 4。

$ kubectl scale deployments/kubernetes-bootcamp --replicas=4
deployment.apps/kubernetes-bootcamp scaled

验证扩展结果：使用 kubectl get deployments 命令查看部署的状态。

$ kubectl get deployments
NAME                  READY   UP-TO-DATE   AVAILABLE   AGE
kubernetes-bootcamp   4/4     4            4           20m

从输出可以看出， kubernetes-bootcamp 部署现在有 4 个副本正在运行。

查看 Pod 状态：使用 kubectl get pods 命令查看所有 Pod 的状态。

$ kubectl get pods
NAME                                   READY   STATUS    RESTARTS   AGE
kubernetes-bootcamp-69fbc6f4cf-49k8m   1/1     Running   0          2m
kubernetes-bootcamp-69fbc6f4cf-68m7w   1/1     Running   0          2m
kubernetes-bootcamp-69fbc6f4cf-9d7qz   1/1     Running   0          2m
kubernetes-bootcamp-69fbc6f4cf-njc4b   1/1     Running   0          20m

9.2 更新应用

更新应用通常是为了修复漏洞、添加新功能或升级版本。以下是更新 kubernetes-bootcamp 应用的步骤：
1. 更新部署的镜像：使用 kubectl set image 命令将 kubernetes-bootcamp 部署的容器镜像更新为新版本。

$ kubectl set image deployments/kubernetes-bootcamp kubernetes-bootcamp=gcr.io/google-samples/kubernetes-bootcamp:v2
deployment.apps/kubernetes-bootcamp image updated

验证更新结果：使用 kubectl get deployments 命令查看部署的状态。

$ kubectl get deployments
NAME                  READY   UP-TO-DATE   AVAILABLE   AGE
kubernetes-bootcamp   4/4     4            4           25m

查看 Pod 状态：使用 kubectl get pods 命令查看所有 Pod 的状态。

$ kubectl get pods
NAME                                   READY   STATUS    RESTARTS   AGE
kubernetes-bootcamp-769786987f-4d7k5   1/1     Running   0          2m
kubernetes-bootcamp-769786987f-6m7w8   1/1     Running   0          2m
kubernetes-bootcamp-769786987f-9d7qz   1/1     Running   0          2m
kubernetes-bootcamp-769786987f-njc4b   1/1     Running   0          2m

可以看到，所有 Pod 都已经使用了新的镜像。

10. 暴露服务

在前面的步骤中，我们已经部署了应用并进行了扩展和更新，但这些应用只能在集群内部访问。为了让外部用户能够访问这些应用，我们需要将服务暴露出去。

10.1 创建服务

使用 kubectl expose 命令创建一个 NodePort 类型的服务，将 kubernetes-bootcamp 应用暴露到外部。

$ kubectl expose deployment/kubernetes-bootcamp --type=NodePort --port=8080
service/kubernetes-bootcamp exposed

10.2 查看服务信息

使用 kubectl get services 命令查看服务的信息。

$ kubectl get services
NAME                  TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
kubernetes            ClusterIP   10.96.0.1       <none>        443/TCP          30m
kubernetes-bootcamp   NodePort    10.107.242.78   <none>        8080:31634/TCP   2m

从输出可以看出， kubernetes-bootcamp 服务的端口映射为 8080:31634/TCP ，其中 31634 是外部可以访问的端口。

10.3 访问服务

使用 minikube service 命令获取服务的外部 URL，并在浏览器中访问该 URL。

$ minikube service kubernetes-bootcamp --url
http://192.168.39.150:31634

在浏览器中打开该 URL，即可看到 kubernetes-bootcamp 应用的界面。

11. 滚动更新与回滚

在更新应用时，为了确保服务的连续性，Kubernetes 支持滚动更新和回滚操作。

11.1 滚动更新

滚动更新是指逐个替换旧的 Pod 为新的 Pod，而不是一次性全部替换，这样可以保证服务在更新过程中不会中断。以下是滚动更新 kubernetes-bootcamp 应用的步骤：
1. 再次更新部署的镜像：将 kubernetes-bootcamp 部署的容器镜像更新为 v3 版本。

$ kubectl set image deployments/kubernetes-bootcamp kubernetes-bootcamp=gcr.io/google-samples/kubernetes-bootcamp:v3
deployment.apps/kubernetes-bootcamp image updated

查看滚动更新状态：使用 kubectl rollout status 命令查看滚动更新的状态。

$ kubectl rollout status deployments/kubernetes-bootcamp
Waiting for deployment "kubernetes-bootcamp" rollout to finish: 1 out of 4 new replicas have been updated...
Waiting for deployment "kubernetes-bootcamp" rollout to finish: 2 out of 4 new replicas have been updated...
Waiting for deployment "kubernetes-bootcamp" rollout to finish: 3 out of 4 new replicas have been updated...
deployment "kubernetes-bootcamp" successfully rolled out

11.2 回滚更新

如果在更新过程中发现问题，我们可以使用 kubectl rollout undo 命令将部署回滚到上一个版本。

$ kubectl rollout undo deployments/kubernetes-bootcamp
deployment.apps/kubernetes-bootcamp rolled back

12. 故障排查与监控

在 Kubernetes 环境中，故障排查和监控是确保应用稳定运行的重要环节。

12.1 故障排查

当 Pod 出现故障时，可以使用以下命令进行排查：
- 查看 Pod 状态 ：使用 kubectl get pods 命令查看 Pod 的状态，如果 Pod 处于 Error 或 CrashLoopBackOff 状态，则表示可能存在问题。
- 查看 Pod 详细信息 ：使用 kubectl describe pod <pod-name> 命令查看 Pod 的详细信息，包括事件、容器状态等。
- 查看容器日志 ：使用 kubectl logs <pod-name> 命令查看容器的日志，以获取更多的错误信息。

12.2 监控

Kubernetes 本身提供了一些基本的监控功能，例如使用 kubectl top pods 命令查看 Pod 的 CPU 和内存使用情况。

$ kubectl top pods
NAME                                   CPU(cores)   MEMORY(bytes)
kubernetes-bootcamp-769786987f-4d7k5   1m           10Mi
kubernetes-bootcamp-769786987f-6m7w8   1m           10Mi
kubernetes-bootcamp-769786987f-9d7qz   1m           10Mi
kubernetes-bootcamp-769786987f-njc4b   1m           10Mi

13. 总结

通过以上步骤，我们详细介绍了如何使用 Kubernetes 将应用程序部署为容器，包括理解 Kubernetes 的基本概念、搭建集群、部署应用、扩展与更新应用、暴露服务、滚动更新与回滚以及故障排查和监控等内容。以下是整个流程的 mermaid 流程图：

graph LR
    A[理解 Kubernetes] --> B[搭建集群]
    B --> C[部署应用]
    C --> D[扩展应用]
    C --> E[更新应用]
    C --> F[暴露服务]
    E --> G[滚动更新]
    G --> H[回滚更新]
    C --> I[故障排查]
    C --> J[监控]

同时，为了方便大家回顾，以下是本文中涉及的主要操作命令总结表格：
|操作|命令|
| ---- | ---- |
|获取 Minikube 版本| minikube version |
|获取集群信息| kubectl cluster-info |
|获取节点信息| kubectl get nodes |
|获取集群和客户端版本| kubectl version |
|创建部署| kubectl create deployment <deployment-name> --image=<image-name> |
|列出部署| kubectl get deployments |
|描述部署| kubectl describe deployments <deployment-name> |
|扩展部署| kubectl scale deployments/<deployment-name> --replicas=<number> |
|更新部署镜像| kubectl set image deployments/<deployment-name> <container-name>=<new-image> |
|暴露服务| kubectl expose deployment/<deployment-name> --type=NodePort --port=<port> |
|滚动更新| kubectl set image deployments/<deployment-name> <container-name>=<new-image> |
|回滚更新| kubectl rollout undo deployments/<deployment-name> |
|获取 Pod 日志| kubectl logs <pod-name> |
|查看 Pod 资源使用情况| kubectl top pods |