【K8S系列】深入解析K8S存储

悠悠 2023-10-12 20:57 20阅读 0赞

![4ee1d1d10fcf4af9bc2385542a6bbefc.png][]

# 序言 #

> 做一件事并不难，难的是在于坚持。坚持一下也不难，难的是坚持到底。

> 文章标记颜色说明：
> 
>  *  黄色：重要标题
>  *  红色：用来标记结论
>  *  绿色：用来标记一级论点
>  *  蓝色：用来标记二级论点

> Kubernetes (k8s) 是一个容器编排平台，允许在容器中运行应用程序和服务。今天学习一下k8s存储相关知识

> 希望这篇文章能让你不仅有一定的收获，而且可以愉快的学习，如果有什么建议，都可以留言和我交流

# 专栏介绍 #

> 这是这篇文章所在的专栏，欢迎订阅：[【深入解析k8s】专栏][k8s]

> 简单介绍一下这个专栏要做的事：
> 
>  *  主要是深入解析每个知识点，帮助大家完全掌握k8s,以下是已更新的章节
>  *  这是专栏介绍文章地址：[【深入解析K8S专栏介绍】][K8S]

> 今天我们来看一下K8s 存储相关问题
> 
>  *  k8s存储类型
>  *  存储使用场景
>  *  存储使用案例

# 1 存储类型 #

![103ba33336384bef8b132f83ca69e599.png][]

> Kubernetes 存储可以分为两类：
> 
>  *  临时存储
>  *  持久存储

## 1.1 临时存储 ##

> 临时存储：通常是短暂的、易失性的存储，例如 Pod 的本地存储或内存存储。
> 
> 常见的临时存储有：

>  *  EmptyDir：EmptyDir 是一种在 Pod 中创建的空目录，它用于在容器之间共享文件。EmptyDir 的数据存在于 Pod 所在节点的本地磁盘上，当 Pod 被删除时，数据也会被删除。
>  *  HostPath：HostPath 卷将主机节点上的文件系统路径挂载到容器中。这种存储卷通常用于测试和开发环境，不适合生产环境。

## 1.2 持久存储 ##

> 持久存储：是一种长期存储，用于存储应用程序的数据和状态，例如数据库或文件系统。

> 常见的持久存储有：
> 
>  *  NFS：NFS 卷将网络文件系统 (NFS) 挂载到容器中。这种存储卷可以跨多个 Pod 和节点共享数据。
>  *  ConfigMap 和 Secret：ConfigMap 和 Secret 卷将配置文件和密钥挂载到容器中。这种存储卷可以用于配置 Pod 中的应用程序或存储敏感数据。
>  *  PersistentVolumeClaim (PVC)：PVC 卷是一种抽象层，它将 Kubernetes 集群中的物理存储资源抽象为逻辑存储卷。PVC 卷可以动态地分配和释放存储资源，并且可以在不同的 Pod 之间共享。
>  *  StatefulSet：StatefulSet 卷是一种特殊的 PVC 卷，它可以为有状态应用程序提供稳定的、持久的存储。StatefulSet 卷会为每个 Pod 分配唯一的持久卷，并且可以按照顺序启动和关闭 Pod。

> 除了上述持久存储选项之外，Kubernetes 还支持动态存储卷和 CSI 存储插件。
> 
>  *  动态存储卷：是一种自动化管理存储资源的方法，它可以根据需求动态地创建和删除存储卷。
>  *  CSI 存储插件：是一种标准化的存储插件接口，它可以与多种不同类型的存储后端集成。

# 2 使用场景 #

![7741c3cd67d742ac97e59046ffb2d0b6.png][]

> 在 Kubernetes 中，存储通常是通过挂载存储卷的方式来实现的。存储可以用于许多场景，包括但不限于以下几个方面：
> 
> 1.  持久化数据
> 2.  分布式存储
> 3.  数据库
> 4.  日志和监控
> 5.  静态资源
> 6.  分布式文件系统
> 7.  镜像仓库
> 8.  大数据分析
> 9.  云存储

## 2.1 持久化数据 ##

> 在容器化的应用程序中，数据通常是存储在容器内部的文件系统中。但是，当容器被删除或重新启动时，数据也会被清除。
> 
> 为了解决这个问题，可以将数据存储在持久存储卷中，以保证数据的持久性。

## 2.2 分布式存储 ##

> 在分布式系统中，数据通常会被分散存储在多个节点上。可以使用 Kubernetes 中的分布式存储来存储数据，并且可以通过存储卷的方式将存储卷挂载到多个容器中，以便它们可以共享数据。

## 2.3 数据库 ##

> 在容器化应用程序中，数据库通常是存储在容器内部的文件系统中。但是，当容器被删除或重新启动时，数据库也会被清除。
> 
> 解决这个问题，可以将数据库存储在持久存储卷中，以保证数据的持久性。

## 2.4 日志和监控 ##

> 在容器化应用程序中，日志和监控数据可以被存储在持久存储卷中，以便它们可以在容器被删除或重新启动后继续存在。
> 
> 这可以帮助开发人员和管理员更好地了解应用程序的运行状况，并对其进行监控和调试。

## 2.5 静态资源 ##

> 在 Web 应用程序中，静态资源（如图像、CSS 文件和 JavaScript 文件等）可以被存储在持久存储卷中，以便它们可以在容器被删除或重新启动后继续存在。
> 
> 这可以提高应用程序的性能和可靠性。

## 2.6 分布式文件系统 ##

> 在分布式系统中，可以使用分布式文件系统来存储和管理数据。在 Kubernetes 中，可以使用分布式文件系统来存储容器化应用程序中的数据，并将存储卷挂载到多个容器中，以便它们可以共享数据。

## 2.7 镜像仓库 ##

> 在 Kubernetes 中，可以使用镜像仓库来存储和管理容器镜像。镜像仓库可以帮助开发人员和管理员更好地管理应用程序的镜像，并确保应用程序在不同环境中的镜像版本的一致性。

## 2.8 大数据分析 ##

> 在大数据分析中，需要处理大量的数据。可以使用 Kubernetes 中的大数据存储来存储和管理数据，并将存储卷挂载到多个容器中，以便它们可以共享数据。这可以帮助分析师更好地处理和分析数据。

## 2.9 云存储 ##

> 在云环境中，可以使用云存储来存储和管理数据。在 Kubernetes 中，可以使用云存储来存储容器化应用程序中的数据，并将存储卷挂载到多个容器中，以便它们可以共享数据。

## 2.10 总结 ##

> 总之，在 Kubernetes 中，存储具有非常广泛的应用场景。可以根据实际需求选择适合自己的存储方案，以便更好地管理容器化应用程序中的数据和资源。

# 3 使用案例 #

![e3d7df650cd3402bb4bb2b1caa0f0800.png][]

> 介绍一下持久存储使用案例和临时存储使用案例。

## 3.1 持久存储使用详细案例介绍 ##

> 以下是一个使用持久存储的详细案例介绍：

> 在这个案例中，将创建一个简单的 WordPress 应用程序，并使用持久存储来保存应用程序的数据。
> 
> WordPress 是一个流行的开源博客平台，它通常需要一个 MySQL 数据库来存储文章、评论和其他相关数据。

> 在 Kubernetes 中，可以使用持久存储来存储 MySQL 数据库的数据，并将其挂载到多个 MySQL 容器中，以便它们可以共享数据。这样，即使 MySQL 容器被删除或重新启动，数据也不会丢失。
> 
> 下面是在 Kubernetes 中使用持久存储来部署 WordPress 应用程序的步骤：
> 
> 1.  创建 PersistentVolume
> 2.  创建 PersistentVolumeClaim
> 3.  创建 MySQL Pod
> 4.  创建 WordPress Pod
> 5.  创建 Service
> 6.  部署应用程序

### 3.1.1 创建 PersistentVolume ###

> 首先，需要创建一个 PersistentVolume（持久卷），用于存储 MySQL 数据库的数据。
> 
> 可以使用 Kubernetes 中的各种持久化存储解决方案，例如本地存储、云存储或分布式存储。
> 
> 在这个案例中，会使用本地存储来存储 MySQL 数据库的数据。可以通过创建一个 YAML 文件来定义 PersistentVolume。

> 下面是一个定义本地存储 PersistentVolume 的 YAML 文件示例：
> 
>     apiVersion: v1
>     kind: PersistentVolume
>     metadata:
>       name: mysql-pv
>     spec:
>       capacity:
>         storage: 10Gi
>       accessModes:
>         - ReadWriteOnce
>       persistentVolumeReclaimPolicy: Retain
>       storageClassName: local-storage
>       local:
>         path: /mnt/data/mysql
> 
> 这个 YAML 文件定义了一个名为 mysql-pv 的 PersistentVolume，它使用本地存储来存储数据，并将数据存储在 /mnt/data/mysql 目录中。
> 
> 这个 PersistentVolume 的大小为 10GB，访问模式为 ReadWriteOnce（即只能被一个 Pod 挂载），持久化策略为 Retain（即在 PersistentVolume 被删除时不会删除数据），存储类名称为 local-storage。

### 3.1.2 创建 PersistentVolumeClaim ###

> 完成 PersistentVolume 的创建之后，需要创建一个 PersistentVolumeClaim（持久卷声明），用于请求 PersistentVolume 中的存储空间。
> 
> 可以通过创建一个 YAML 文件来定义 PersistentVolumeClaim。

> 下面是一个定义 PersistentVolumeClaim 的 YAML 文件示例：
> 
>     apiVersion: v1
>     kind: PersistentVolumeClaim
>     metadata:
>       name: mysql-pvc
>     spec:
>       accessModes:
>         - ReadWriteOnce
>       resources:
>         requests:
>           storage: 10Gi
>       storageClassName: local-storage
> 
> 这个 YAML 文件定义了一个名为 mysql-pvc 的 PersistentVolumeClaim，它请求 10GB 的存储空间，并使用 storageClassName 属性来指定使用的存储类名称。
> 
> 在这个示例中，使用的是之前创建的 local-storage 存储类。

### 3.1.3 创建 MySQL Pod ###

> 完成 PersistentVolumeClaim 的创建之后，可以创建一个 MySQL Pod，并将它与 PersistentVolumeClaim 和 PersistentVolume 关联起来。
> 
> 在这个案例中，会使用官方的 MySQL 镜像，并将其挂载到 PersistentVolumeClaim 中。
> 
> 可以通过创建一个 YAML 文件来定义 MySQL Pod。

> 下面是一个定义 MySQL Pod 的 YAML 文件示例：
> 
>     apiVersion: v1
>     kind: Pod
>     metadata:
>       name: mysql
>     spec:
>       containers:
>         - name: mysql
>           image: mysql:5.7
>           env:
>             - name: MYSQL_ROOT_PASSWORD
>               value: password
>           ports:
>             - containerPort: 3306
>               name: mysql
>           volumeMounts:
>             - name: mysql-pv
>               mountPath: /var/lib/mysql
>       volumes:
>         - name: mysql-pv
>           persistentVolumeClaim:
>             claimName: mysql-pvc
> 
> 这个 YAML 文件定义了一个名为 mysql 的 Pod，它使用官方的 MySQL 镜像，并将其挂载到名为 mysql-pv 的存储卷上，该存储卷与名为 mysql-pvc 的 PersistentVolumeClaim 关联。
> 
> 在容器中，使用 volumeMounts 属性将 PersistentVolumeClaim 挂载到 /var/lib/mysql 目录。

### 3.1.4 创建 WordPress Pod ###

> 完成 MySQL Pod 的创建之后，可以创建 WordPress Pod，并将其与 MySQL Pod 关联起来。
> 
> 在这个案例中，会使用官方的 WordPress 镜像，并将其挂载到一个名为 wp-pv 的存储卷上，该存储卷与名为 wp-pvc 的 PersistentVolumeClaim 关联。
> 
> 可以通过创建一个 YAML 文件来定义 WordPress Pod。

> 下面是一个定义 WordPress Pod 的 YAML 文件示例：
> 
>     apiVersion: v1
>     kind: Pod
>     metadata:
>       name: wordpress
>     spec:
>       containers:
>         - name: wordpress
>           image: wordpress:latest
>           env:
>             - name: WORDPRESS_DB_HOST
>               value: mysql
>             - name: WORDPRESS_DB_USER
>               value: root
>             - name: WORDPRESS_DB_PASSWORD
>               value: password
>             - name: WORDPRESS_DB_NAME
>               value: wordpress
>           ports:
>             - containerPort: 80
>               name: wordpress
>           volumeMounts:
>             - name: wp-pv
>               mountPath: /var/www/html
>       volumes:
>         - name: wp-pv
>           persistentVolumeClaim:
>             claimName: wp-pvc
> 
> 这个 YAML 文件定义了一个名为 wordpress 的 Pod，它使用官方的 WordPress 镜像，并将其挂载到名为 wp-pv 的存储卷上，该存储卷与名为 wp-pvc 的 PersistentVolumeClaim 关联。
> 
> 在容器中，使用 volumeMounts 属性将 PersistentVolumeClaim 挂载到 /var/www/html 目录。
> 
> WordPress Pod 还通过环境变量设置了 MySQL 数据库的主机、用户名、密码和数据库名称。

### 3.1.5 创建 Service ###

> 完成 WordPress Pod 的创建之后，需要创建一个 Service，用于将 WordPress Pod 暴露给外部访问。
> 
> 可以通过创建一个 YAML 文件来定义 Service。

> 下面是一个定义 Service 的 YAML 文件示例：
> 
>     apiVersion: v1
>     kind: Service
>     metadata:
>       name: wordpress-service
>     spec:
>       selector:
>         app: wordpress
>       ports:
>         - protocol: TCP
>           port: 80
>           targetPort: 80
>       type: NodePort
> 
> 这个 YAML 文件定义了一个名为 wordpress-service 的 Service，它选择 app 标签为 wordpress 的 Pod，并将其暴露在端口 80 上。
> 
> 在这个示例中，Service 的类型为 NodePort，这意味着它将在每个节点上暴露一个随机端口，用于外部访问。

### 3.1.6 部署应用程序 ###

> 完成以上步骤之后，可以使用 kubectl 命令来部署 WordPress 应用程序。
> 
> 以下是部署 WordPress 应用程序的 kubectl 命令：
> 
>     kubectl apply -f mysql-pv.yaml
>     kubectl apply -f mysql-pvc.yaml
>     kubectl apply -f mysql-pod.yaml
>     kubectl apply -f wp-pvc.yaml
>     kubectl apply -f wp-pod.yaml
>     kubectl apply -f wp-service.yaml

> 这些命令将按照顺序：
> 
> 1. 创建 PersistentVolume
> 
>     kubectl apply -f mysql-pv.yaml
> 
> 2. 创建PersistentVolumeClaim
> 
>     kubectl apply -f mysql-pvc.yaml
> 
> 3. 创建MySQL Pod
> 
>     kubectl apply -f mysql-pod.yaml
> 
> 4. 创建WordPress PersistentVolumeClaim
> 
>     kubectl apply -f wp-pvc.yaml
> 
> 5. 创建WordPress Pod
> 
>     kubectl apply -f wp-pod.yaml
> 
> 6. 创建Service
> 
>     kubectl apply -f wp-service.yaml
> 
> 完成部署之后，可以在浏览器中访问 WordPress 应用程序，以确保它可以正常工作。如果需要对应用程序进行修改或升级，可以重复这些步骤，并使用新的 YAML 文件来定义新的 Pod、PersistentVolumeClaim 和 Service。

## 3.2 临时存储使用详细案例介绍 ##

> 以下是一个使用临时存储的详细案例介绍：

> 在这个案例中，将创建一个简单的 Redis 应用程序，并使用临时存储来保存应用程序的数据。
> 
> Redis 是一个流行的开源内存数据结构存储系统，它通常需要一个本地磁盘来保存持久化数据。

> 在 Kubernetes 中，可以使用临时存储来保存 Redis 数据库的持久化数据。可以将临时存储挂载到 Redis Pod 中，并在 Redis Pod 中启用持久化功能。
> 
> 这样，即使 Redis Pod 被删除或重新启动，数据也不会丢失。

> 下面是在 Kubernetes 中使用临时存储来部署 Redis 应用程序的步骤：
> 
> 1.  创建 Redis Pod
> 2.  创建 Service
> 3.  部署应用程序

### 3.2.1 创建 Redis Pod ###

> 首先，需要创建一个 Redis Pod，并将临时存储挂载到 Redis Pod 中。可以通过创建一个 YAML 文件来定义 Redis Pod。

> 下面是一个定义 Redis Pod 的 YAML 文件示例：
> 
>     apiVersion: v1
>     kind: Pod
>     metadata:
>       name: redis
>     spec:
>       containers:
>         - name: redis
>           image: redis:6.0
>           command:
>             - redis-server
>           args:
>             - "--appendonly yes"
>           ports:
>             - containerPort: 6379
>               name: redis
>           volumeMounts:
>             - name: redis-data
>               mountPath: /data
>       volumes:
>         - name: redis-data
>           emptyDir: {}
> 
> 这个 YAML 文件定义了一个名为 redis 的 Pod，它使用官方的 Redis 镜像，并将其挂载到一个名为 redis-data 的临时存储卷上。
> 
> 在容器中，使用 volumeMounts 属性将临时存储卷挂载到 /data 目录。
> 
> 这个 Redis Pod 还启用了 Redis 的持久化功能，通过 args 属性将 "--appendonly yes" 传递给 Redis 服务器。

### 3.2.2 创建 Service ###

> 完成 Redis Pod 的创建之后，需要创建一个 Service，用于将 Redis Pod 暴露给外部访问。可以通过创建一个 YAML 文件来定义 Service。

> 下面是一个定义 Service 的 YAML 文件示例：
> 
>     apiVersion: v1
>     kind: Service
>     metadata:
>       name: redis-service
>     spec:
>       selector:
>         app: redis
>       ports:
>         - protocol: TCP
>           port: 6379
>           targetPort: 6379
> 
> 这个 YAML 文件定义了一个名为 redis-service 的 Service，它选择 app 标签为 redis 的 Pod，并将其暴露在端口 6379 上。

### 3.2.3 部署应用程序 ###

> 完成以上步骤之后，可以使用 kubectl 命令来部署 Redis 应用程序。例如，以下是一个部署 Redis 应用程序的 kubectl 命令：
> 
>     kubectl apply -f redis-pod.yaml
>     kubectl apply -f redis-service.yaml

> 这些命令将按照顺序创建
> 
> 1.创建Redis Pod
> 
>     kubectl apply -f redis-pod.yaml
> 
> 2.创建Service
> 
>     kubectl apply -f redis-service.yaml
> 
> 完成部署之后，可以使用 Redis 客户端连接到 Redis Pod，并将数据存储在 Redis 中。如果需要对应用程序进行修改或升级，可以重复这些步骤，并使用新的 YAML 文件来定义新的 Pod 和 Service。

# 4 投票 #

[4ee1d1d10fcf4af9bc2385542a6bbefc.png]: https://img-blog.csdnimg.cn/4ee1d1d10fcf4af9bc2385542a6bbefc.png
[k8s]: http://t.csdn.cn/wer7E
[K8S]: http://t.csdn.cn/9ELXe
[103ba33336384bef8b132f83ca69e599.png]: https://img-blog.csdnimg.cn/103ba33336384bef8b132f83ca69e599.png
[7741c3cd67d742ac97e59046ffb2d0b6.png]: https://img-blog.csdnimg.cn/7741c3cd67d742ac97e59046ffb2d0b6.png
[e3d7df650cd3402bb4bb2b1caa0f0800.png]: https://img-blog.csdnimg.cn/e3d7df650cd3402bb4bb2b1caa0f0800.png