初试 Kubernetes 集群使用 Ceph RBD 块存储

Kubernetes PersistentVolumes 介绍
环境、软件准备
单节点使用 Ceph RBD
Kubernetes PV & PVC 方式使用 Ceph RBD
测试单节点以及多节点使用 Ceph RBD

1、Kubernetes PersistentVolumes 介绍

Kubernetes PersistentVolumes 持久化存储方案中，提供两种 API 资源方式: PersistentVolume(简称PV) 和 PersistentVolumeClaim(简称PVC)。PV 可理解为集群资源，PVC 可理解为对集群资源的请求，Kubernetes 支持很多种持久化卷存储类型。Ceph 是一个开源的分布式存储系统，支持对象存储、块设备、文件系统，具有可靠性高、管理方便、伸缩性强等特点。在日常工作中，我们会遇到使用 k8s 时后端存储需要持久化，这样不管 Pod 调度到哪个节点，都能挂载同一个卷，从而很容易读取或存储持久化数据，我们可以使用 Kubernetes 结合 Ceph 完成。

2、环境、软件准备

本次演示环境，我是在虚拟机 Linux Centos7 上操作，通过虚拟机完成 Ceph 存储集群搭建以及 Kubernetes 集群的搭建，以下是安装的软件及版本：

Centos：release 7.4.1708 (Core)
Ceph：jewel-10.2.10
Kubernetes：v1.6.2
Docker：v1.12.6

注意：这里我们着重描述一下 Kubernetes 集群如何使用 Ceph RBD 来实现持久化存储，所以需要提前搭建好 Kubernetes 集群和 Ceph 存储集群，具体搭建过程可参考之前文章国内使用 kubeadm 在 Centos 7 搭建 Kubernetes 集群和初试 Centos7 上 Ceph 存储集群搭建，这里就不在详细讲解了。同时由于本机内存限制，共开启了 3 个虚拟机节点，每个节点既是 Ceph 集群节点又是 Kubernetes 集群节点，所以功能节点图如下：

这里写图片描述

3、单节点使用 Ceph RBD

在正式开始之前，要提一下的是，为了方便后续测试 k8s 跨节点使用 RBD，这里我们先只使用 admin 和 node0，这样就将所有的 Pod 都调度到 node0 上执行，方便演示单节点使用 RBD，后续跨节点操作时使用 kubeadm join ... 命令将 node1 加入到集群中即可。

k8s 集群单节点使用 Ceph RBD，我们可以使用 Kubernetes Examples Github 官方示例代码，稍加修改即可。

$ cd /home/wanyang3/k8s
$ git clone https://github.com/kubernetes/examples.git
$ tree examples/staging/volumes/rbd
|-- rbd-with-secret.yaml
|-- rbd.yaml
|-- README.md
`-- secret
    `-- ceph-secret.yaml

可以看到，官方示例代码中提供了 rbd-with-secret.yaml、rbd.yaml 和 ceph-secret.yaml 三个文件。我们知道，在搭建 Ceph 集群时，默认开启了 cephx 安全认证的，所以在 k8s 集群使用 Ceph RBD 时，也是要配置认证信息的，下边我分别演示下如何配置安全认证信息。

3.1 使用 rbd.yaml

$ cat examples/staging/volumes/rbd/rbd.yaml 
apiVersion: v1
kind: Pod
metadata:
  name: rbd
spec:
  containers:
    - image: kubernetes/pause
      name: rbd-rw
      volumeMounts:
      - name: rbdpd
        mountPath: /mnt/rbd
  volumes:
    - name: rbdpd
      rbd:
        monitors:
        - '10.16.154.78:6789'
        - '10.16.154.82:6789'
        - '10.16.154.83:6789'
        pool: kube
        image: foo
        fsType: ext4
        readOnly: true
        user: admin
        keyring: /etc/ceph/keyring
        imageformat: "2"
        imagefeatures: "layering"

简要说明一下 volumes 下 rbd 配置各个字段大概的意思：

monitors：这是 Ceph 集群的 monitor 监视器，Ceph 集群可以配置多个 monitor，如有多多个配置所有，本次我们搭建的 Ceph 集群只有一个 monitor，所以这里需要修改为 10.222.76.119:6789
pool：这是 Ceph 集群中存储数据进行归类区分使用，可使用 ceph osd pool ls 命令列出所有，默认创建的 pool 为 rbd，所以这里可以修改为 rbd，也可以创建一个新的名称为 kube 的 pool。
image：这是 Ceph 块设备中的磁盘映像文件，可使用 rbd create ... 命令创建指定大小的映像，这里我们就创建 foo
fsType：文件系统类型，默认使用 ext4 即可。
readOnly：是否为只读，这里测试使用只读即可。
user：这是 Ceph Client 访问 Ceph 存储集群所使用的用户名，这里我们使用 admin 即可。
keyring：这是 Ceph 集群认证需要的密钥环，记得搭建 Ceph 存储集群时生成的 ceph.client.admin.keyring 么，就是这个文件。
imageformat：这是磁盘映像文件格式，可以使用 2，或者老一些的 1
imagefeatures：这是磁盘映像文件的特征，需要 uname -r 查看集群系统内核所支持的特性，这里我们安装的 Ceontos7 内核版本为 3.10.0-693.5.2.el7.x86_64 只支持 layering。

好了，那么我们将 rbd.yaml 文件修改如下：

apiVersion: v1
kind: Pod
metadata:
  name: rbd1
spec:
  containers:
    - image: kubernetes/pause
      name: rbd-rw
      volumeMounts:
      - name: rbdpd
        mountPath: /mnt/rbd
  volumes:
    - name: rbdpd
      rbd:
        monitors:
        - '10.222.76.119:6789'
        pool: rbd
        image: foo
        fsType: ext4
        readOnly: true
        user: admin
        keyring: /etc/ceph/keyring
        imageformat: "2"
        imagefeatures: "layering"

不过，在执行创建该 Pod 之前，需要先手动创建 Image foo，否则创建 Pod 会报错。这里我就不在详细描述过程了，具体可以参照文章初试 Ceph 存储之块设备、文件系统、对象存储中块设备部分，贴下操作代码。

# 创建一个大小为 1024M 的 ceph image
$ rbd create foo --size 1024
$ rbd list
foo
# 临时关闭内核不支持的特性
$ rbd feature disable foo exclusive-lock, object-map, fast-diff, deep-flatten
$ rbd info foo
rbd image 'foo':
    size 1024 MB in 256 objects
    order 22 (4096 kB objects)
    block_name_prefix: rbd_data.10602ae8944a
    format: 2
    features: layering
    flags:

# 把 foo image 映射到内核
$ sudo rbd map foo
/dev/rbd0
$ rbd showmapped
id pool image snap device    
0  rbd  foo   -    /dev/rbd0

# 将 foo image 格式化为 ext4 格式的文件系统，注意这里也可以不执行，后边创建 Pod 时也会自动完成
$ sudo mkfs.ext4 -m0 /dev/rbd0

我们期望的是，下边创建的 Pod 会将该块设备挂载到 /mnt/rbd 目录，不过在创建前还有一步不要忘记了，那就是去 k8s 节点上生成 keyring 密钥文件，否则是连接不上 Ceph 存储集群的，执行时会报错如下。

 1s 1s  1   kubelet, node0      Warning FailedMount MountVolume.SetUp failed for volume "kubernetes.io/rbd/57437366-f05d-11e7-b073-080027ee5979-rbdpd" (spec.Name: "rbdpd") pod "57437366-f05d-11e7-b073-080027ee5979" (UID: "57437366-f05d-11e7-b073-080027ee5979") with: rbd: map failed exit status 22 rbd: sysfs write failed
2018-01-03 16:09:02.753112 7faa5534dd80  0 librados: client.admin authentication error (22) Invalid argument
rbd: couldn't connect to the cluster!

所以，我们要去 node0 节点生成 keyring (因为现在是单节点测试，pod 只会被调度到 node0，后续加入node1 时也需要生成 keyring)，同时这里 node0 既是 Ceph 集群 osd 节点又是 k8s 节点，所以已存在该文件，复制一份即可，

$ cp /etc/ceph/ceph.client.admin.keyring /etc/ceph/keyring

好了，现在可以创建使用 Ceph RBD 作为后端存储的 Pod 啦！

$ kubectl create -f rbd.yaml
pod "rbd1" created
$ kubectl get pod
NAME      READY     STATUS    RESTARTS   AGE
rbd1      1/1       Running   0          13s

接下来我们去 node0 上验证一下是否正确启动并挂载该 Ceph rbd 吧！

# node0 节点上执行
$ docker ps
CONTAINER ID        IMAGE                                                                                                COMMAND                  CREATED             STATUS              PORTS               NAMES
070605ea0186        docker.io/kubernetes/pause@sha256:2088df8eb02f10aae012e6d4bc212cabb0ada93cb05f09e504af0c9811e0ca14   "/pause"                 3 minutes ago      Up 3 minutes                           k8s_rbd-rw_rbd1_default_edc7712b-f057-11e7-b073-080027ee5979_0

# 查看节点挂载信息 
$ mount | grep /dev/rbd0
/dev/rbd0 on /var/lib/kubelet/plugins/kubernetes.io/rbd/rbd/rbd-image-foo type ext4 (ro,relatime,stripe=1024,data=ordered)
/dev/rbd0 on /var/lib/kubelet/pods/edc7712b-f057-11e7-b073-080027ee5979/volumes/kubernetes.io~rbd/rbdpd type ext4 (ro,relatime,stripe=1024,data=ordered) 

# 容器挂载信息
# docker inspect 070605ea0186
...
"Mounts": [
            {
                "Source": "/var/lib/kubelet/pods/edc7712b-f057-11e7-b073-080027ee5979/volumes/kubernetes.io~rbd/rbdpd",
                "Destination": "/mnt/rbd",
                "Mode": "",
                "RW": true,
                "Propagation": "rprivate"
            },
            {
                "Source": "/var/lib/kubelet/pods/edc7712b-f057-11e7-b073-080027ee5979/volumes/kubernetes.io~secret/default-token-b177v",
                "Destination": "/var/run/secrets/kubernetes.io/serviceaccount",
                "Mode": "ro",
                "RW": false,
                "Propagation": "rprivate"
            },
            {
                "Source": "/var/lib/kubelet/pods/edc7712b-f057-11e7-b073-080027ee5979/etc-hosts",
                "Destination": "/etc/hosts",
                "Mode": "",
                "RW": true,
                "Propagation": "rprivate"
            },
            {
                "Source": "/var/lib/kubelet/pods/edc7712b-f057-11e7-b073-080027ee5979/containers/rbd-rw/ff5f0f93",
                "Destination": "/dev/termination-log",
                "Mode": "",
                "RW": true,
                "Propagation": "rprivate"
            }
        ],

3.2 使用 rbd-with-secret & ceph-secret

接下来使用 rbd-with-secret 和 ceph-secret 方式，这种方式跟上边直接使 keyring 文件认证最大的区别就是使用 k8s secret 对象，该 secret 对象用于 k8s volume 插件通过 cephx 认证访问 ceph 存储集群。不过要提一下的是，k8s secret 认证 key 需要使用 base64 编码。

# 获取 Ceph keying 并生成 secret key
$ grep key /etc/ceph/ceph.client.admin.keyring |awk '{printf "%s", $NF}'|base64
QVFBM1QweGFKTFVVSFJBQUZrU3dpV08rNGM0Wjh1dUNlVHdMSUE9PQ==

或者

$ ceph auth get-key client.admin |base64
QVFBM1QweGFKTFVVSFJBQUZrU3dpV08rNGM0Wjh1dUNlVHdMSUE9PQ==

修改 ceph-secret.yaml 文件中，key 字段替换成上边生成的字符串。

$ cat ceph-secret.yaml 
apiVersion: v1
kind: Secret
metadata:
  name: ceph-secret
type: "kubernetes.io/rbd"  
data:
  key: QVFBM1QweGFKTFVVSFJBQUZrU3dpV08rNGM0Wjh1dUNlVHdMSUE9PQ==

创建名称为 ceph-secret 的 Secret。

$ kubectl create -f ceph-secret.yaml 
secret "ceph-secret" created
$ kubectl get secret
NAME                  TYPE                                  DATA      AGE
ceph-secret           kubernetes.io/rbd                     1         24s

接下来，需要修改一下 rbd-with-secret.yaml 文件，主要修改 rbd 相关信息，修改完成后如下。

$ cat rbd-with-secret.yaml 
apiVersion: v1
kind: Pod
metadata:
  name: rbd2
spec:
  containers:
    - image: kubernetes/pause
      name: rbd-rw
      volumeMounts:
      - name: rbdpd
        mountPath: /mnt/rbd
  volumes:
    - name: rbdpd
      rbd:
        monitors: 
        - '10.222.76.119:6789'
        pool: rbd
        image: foo
        fsType: ext4
        readOnly: true
        user: admin
        secretRef:
          name: ceph-secret

我们看到跟上边不使用 secret 的最大区别就是将 keyring 修改为 secretRef 指向创建的 ceph-secret。接下来创建该 Pod 啦！

$ kubectl create -f rbd-with-secret.yaml 
pod "rbd2" created

$ kubectl get pod
NAME      READY     STATUS    RESTARTS   AGE
rbd2      1/1       Running   0          58s

跟上边示例一样，妥妥没问题，可以去 node0 上查看 mount 信息验证一下，这里就不在演示了。

4、Kubernetes PV & PVC 方式使用 Ceph RBD

上边我们演示了单节点 k8s volume 使用 Ceph RBD 存储，但是实际应用中不会这么简单，一旦 Pod 删除掉，那么挂载 volume 中的数据就不会存在了，那是因为 volume 跟 pod 的生命周期是一样的。那么有什么办法可以解决呢？也就是即使 pod 被删除，volume 中的数据依旧存在。为此，k8s 提供了两种 API 资源方式：PersistentVolume 和 PersistentVolumeClaim 来解决这个问题。

PersistentVolume (PV) 可以理解为在集群中已经由管理员配置的一块存储，作为集群的资源，而且拥有独立与 Pod 的生命周期，意思就是 Pod 删除了，但 PV 还在，PV 上的数据依旧存在。
PersistentVolumeClaim (PVC) 可以理解为用户对存储资源的请求，跟 Pod 类似，Pod 消耗节点资源，PVC 消耗 PV 资源，Pod 可以配置请求分配特定大小的资源，比如 CPU、内存，PVC 可以配置请求特定大小资源和访问方式，比如 RWO（ReadWriteOnce） ROX（ ReadOnlyMany） RWX（ReadWriteMany）。

PV 支持 Static 静态请求，即提前准备好固定大小的资源。同时支持 Dynamic 动态请求，当静态 PV 不能满足需求时，k8s 集群可以提供动态分配的方式，但是需要配置 StorageClasses。k8s 支持的 PV 类型有很多，官网列出的有如下类型：

GCEPersistentDisk
AWSElasticBlockStore
AzureFile
AzureDisk
FC (Fibre Channel)
FlexVolume
Flocker
NFS
iSCSI
RBD (Ceph Block Device)
CephFS
Cinder (OpenStack block storage)
Glusterfs
VsphereVolume
Quobyte Volumes
HostPath (Single node testing only – local storage is not supported in any way and WILL NOT WORK in a multi-node cluster)
VMware Photon
Portworx Volumes
ScaleIO Volumes
StorageOS

其中就有我们熟悉的 Ceph RBD 和 CephFS，接下来就演示一下如何使用 PV & PVC 结合 Ceph RBD 完成上边演示操作。

4.1 创建测试 Image

首先跟上边一样创建一个测试使用的 Image 命名为 ceph-rbd-pv-test ，大小为 1024 M 测试够用即可。

# 创建一个大小为 1024M 的 ceph image
$ rbd create ceph-rbd-pv-test --size 1024
# rbd list
ceph-rbd-pv-test
foo

# 临时关闭内核不支持的特性
$ rbd feature disable ceph-rbd-pv-test exclusive-lock, object-map, fast-diff, deep-flatten
$ rbd info ceph-rbd-pv-test
rbd image 'ceph-rbd-pv-test':
    size 1024 MB in 256 objects
    order 22 (4096 kB objects)
    block_name_prefix: rbd_data.10812ae8944a
    format: 2
    features: layering
    flags: 

# 把 ceph-rbd-pv-test image 映射到内核
$ sudo rbd map ceph-rbd-pv-test
/dev/rbd1

# rbd showmapped
id pool image            snap device    
0  rbd  foo              -    /dev/rbd0 
1  rbd  ceph-rbd-pv-test -    /dev/rbd1

4.2 创建 PV

还记得上边提过 Ceph 认证的 secret，这里也是需要的，这次就不用再创建了，直接复用上边的即可。新建 PV 文件 rbd-pv.yaml 如下：

$ vim rbd-pv.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
  name: ceph-rbd-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  rbd:
    monitors:
      - 10.222.76.119:6789
    pool: rbd
    image: ceph-rbd-pv-test
    user: admin
    secretRef:
      name: ceph-secret
    fsType: ext4
    readOnly: false
  persistentVolumeReclaimPolicy: Recycle

这里就不在一一解释每个字段了，直接创建 PV Pod。

$ kubectl create -f rbd-pv.yaml 
persistentvolume "ceph-rbd-pv" created
$ kubectl get pv
NAME          CAPACITY   ACCESSMODES   RECLAIMPOLICY   STATUS      CLAIM     STORAGECLASS   REASON    AGE
ceph-rbd-pv   1Gi        RWO           Recycle         Available                                      13s

4.3 创建 PVC

好了，上边 PV 资源已经创建好了，接下来创建对资源的请求 PVC，新建 PVC 文件 rbd-pv-claim.yaml 如下：

$ vim rbd-pv-claim.yaml
apiVersion: v1
metadata:
  name: ceph-rbd-pv-claim
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

PVC 很简单，只需指定 accessModes（这里使用 ReadWriteOnce，k8s 对 RBD 只支持 ReadWriteOnce 和 ReadOnlyMany，因为接下来验证测试需要写入文件，所以使用 ReadWriteOnce 即可）和对资源的请求大小即可，那么就创建一下 PVC Pod。

$ kubectl create -f rbd-pv-claim.yaml 
persistentvolumeclaim "ceph-rbd-pv-claim" created
$ kubectl get pvc
NAME                STATUS    VOLUME        CAPACITY   ACCESSMODES   STORAGECLASS   AGE
ceph-rbd-pv-claim   Bound     ceph-rbd-pv   1Gi        RWO

4.4 创建挂载 RBD 的 Pod

PV 和 PVC 都创建好了，接下来就需要创建挂载该 RBD 的 Pod 了，这里我使用官方示例中的 busybox 容器测试吧！新建 Pod 文件 rbd-pvc-pod1.yaml 如下：

$ vim rbd-pvc-pod1.yaml
apiVersion: v1
kind: Pod
metadata:
  labels:
    test: rbd-pvc-pod
  name: ceph-rbd-pv-pod1
spec:
  containers:
  - name: ceph-rbd-pv-busybox
    image: busybox
    command: ["sleep", "60000"]
    volumeMounts:
    - name: ceph-rbd-vol1
      mountPath: /mnt/ceph-rbd-pvc/busybox
      readOnly: false
  volumes:
  - name: ceph-rbd-vol1
    persistentVolumeClaim:
      claimName: ceph-rbd-pv-claim

从文件可以看出，我们要将上边创建的 ceph-rbd-pv-claim 请求的资源挂载到容器的 /mnt/ceph-rbd-pvc/busybox 目录。接下来创建一下该 Pod，看是否能够正常运行吧！

$ kubectl create -f rbd-pvc-pod1.yaml 
pod "ceph-rbd-pv-pod1" created
$ kubectl get pod
NAME               READY     STATUS    RESTARTS   AGE
ceph-rbd-pv-pod1   1/1       Running   0          19s
rbd1               1/1       Running   0          1h

等待一段时间后（因为他要执行 ext4 格式化以及挂载路径）容器就运行起来啦！那到底有没有真正挂载到容器内部指定位置呢？我们可以登录到 node0 查看一下。

# node0 节点上操作
$ docker ps
CONTAINER ID        IMAGE                                                                                                COMMAND                  CREATED              STATUS              PORTS               NAMES
65cde9254c64        docker.io/busybox@sha256:bbc3a03235220b170ba48a157dd097dd1379299370e1ed99ce976df0355d24f0            "sleep 60000"            About a minute ago   Up About a minute                       k8s_ceph-rbd-pv-busybox_ceph-rbd-pv-pod1_default_1c5f5d10-f06a-11e7-b073-080027ee5979_0

$ docker exec -it 65cde9254c64 df -h |grep /dev/rbd1
Filesystem                Size      Used Available Use% Mounted on
/dev/rbd1               975.9M      2.5M    906.2M   0% /mnt/ceph-rbd-pvc/busybox

$ docker exec -it 65cde9254c64 mount |grep /dev/rbd1
/dev/rbd1 on /mnt/ceph-rbd-pvc/busybox type ext4 (rw,relatime,stripe=1024,data=ordered)

OK 我们可以看到的确将映射的 /dev/rbd1 挂载到 /mnt/ceph-rbd-pvc/busybox 目录，大小为 1G 左右。

5、测试单节点以及多节点使用 Ceph RBD

接下来我们要进行一下测试，分别测试同一节点上和不同节点上，Pod 之间是否能够共享同一个 Ceph RBD 存储。

5.1 单节点测试

我们继续使用上边演示 PV & PVC 方式创建的测试 Pod，写入一些数据到 RBD 存储中，然后删除该 Pod，创建一个新的 Pod，使用相同的 PVC 并挂载同样的目录，看能否读取到写入的数据。注意：此时还未加入 node1，所有所有创建的 Pod 都会被调度到 node0，从而实现单节点测试。

# node0 执行，往 pod ceph-rbd-pv-pod1 容器的挂载目录写入测试数据
$ docker exec -it 65cde9254c64 touch /mnt/ceph-rbd-pvc/busybox/ceph-rbd-test.txt
$ docker exec -it 65cde9254c64 vi /mnt/ceph-rbd-pvc/busybox/ceph-rbd-test.txt
$ docker exec -it 65cde9254c64 cat /mnt/ceph-rbd-pvc/busybox/ceph-rbd-test.txt
This is ceph rbd test file.

写入完毕，接下来我们删除 ceph-rbd-pv-pod1 该 Pod，同时可以查看下创建的 PV 和 PVC 是否会受到影响。

# 删除 Pod
$ kubectl delete -f rbd-pvc-pod.yaml 
pod "ceph-rbd-pv-pod1" deleted

# 查看 PV 和 PVC 是否存在
$ kubectl get pv,pvc
NAME             CAPACITY   ACCESSMODES   RECLAIMPOLICY   STATUS    CLAIM                       STORAGECLASS   REASON    AGE
pv/ceph-rbd-pv   1Gi        RWO           Recycle         Bound     default/ceph-rbd-pv-claim   

NAME                    STATUS    VOLUME        CAPACITY   ACCESSMODES   STORAGECLASS   AGE
pvc/ceph-rbd-pv-claim   Bound     ceph-rbd-pv   1Gi        RWO

OK 从上边可以看到当删除 Pod 后，对应的 PV 和 PVC 依旧存在，并没有随着 Pod 删除而消失。也就是当再次创建原 Pod 或新 Pod 时可以继续使用该 PVC，那么我们就创建一个新的 Pod，使用该 PVC 并挂载同一目录，查看测试数据是否存在吧！新建 Pod 文件 rbd-pvc-pod2.yaml 如下：

# vim rbd-pvc-pod2.yaml 
apiVersion: v1
kind: Pod
metadata:
  labels:
    test: rbd-pvc-pod
  name: ceph-rbd-pv-pod2
spec:
  containers:
  - name: ceph-rbd-pv-busybox2
    image: busybox
    command: ["sleep", "60000"]
    volumeMounts:
    - name: ceph-rbd-vol2
      mountPath: /mnt/ceph-rbd-pvc/busybox
      readOnly: false
  volumes:
  - name: ceph-rbd-vol2
    persistentVolumeClaim:
      claimName: ceph-rbd-pv-claim

从文件可以看出，我们使用了同一个 ceph-rbd-pv-claim 并且将请求的资源挂载到容器的 /mnt/ceph-rbd-pvc/busybox 同一个目录，接下来创建一下该 Pod。

$ kubectl create -f rbd-pvc-pod2.yaml 
pod "ceph-rbd-pv-pod2" created

$ kubectl get pods
NAME               READY     STATUS    RESTARTS   AGE
ceph-rbd-pv-pod2   1/1       Running   0          26s
rbd1               1/1       Running   0          1h

创建成功，登录到 node0 验证一下是否能够读取到测试文件吧！

# node0 节点执行
$ docker ps
CONTAINER ID        IMAGE                                                                                                COMMAND                  CREATED             STATUS              PORTS               NAMES
63d648257636        docker.io/busybox@sha256:bbc3a03235220b170ba48a157dd097dd1379299370e1ed99ce976df0355d24f0            "sleep 60000"            35 seconds ago      Up 34 seconds                           k8s_ceph-rbd-pv-busybox2_ceph-rbd-pv-pod2_default_d48eaaae-f06c-11e7-b073-080027ee5979_0

$ docker exec -it 63d648257636 cat /mnt/ceph-rbd-pvc/busybox/ceph-rbd-test.txt
This is ceph rbd test file.

OK 数据能够完整的被同节点的 rbd-pvc-pod2 读取到。

5.2 多节点测试

同一 node 上多个 Pod 是可以挂载同一个 Ceph RBD，接下来我们尝试下跨节点挂载同一个 Ceph RBD ，看下能不能够成功吧！此时我们加入 node1 到 k8s 集群中，然后启动多个 pod，并且挂载同一个 Ceph RBD，使 Pod 分配到不同节点上去。我们就以上边 rbd-pvc-pod1 和 rbd-pvc-pod2 为例，删除掉 Pod 并重新创建一次看看。

# node1 上执行，加入 k8s 集群
$ kubeadm join --token b87453.4c4b9e895774f3be 10.222.76.189:6443

# admin 节点查看集群所有节点
$ kubectl get node
NAME      STATUS    AGE       VERSION
admin     Ready     1h        v1.6.2
node0     Ready     1h       v1.6.2
node1     Ready     22s       v1.6.2

# 删除并重新创建一下 Pod
$ kubectl delete -f rbd-pvc-pod1.yaml
$ kubectl delete -f rbd-pvc-pod2.yaml
$ kubectl create -f rbd-pvc-pod1.yaml 
pod "ceph-rbd-pv-pod1" created
$ kubectl create -f rbd-pvc-pod2.yaml
pod "ceph-rbd-pv-pod2" created

$ kubectl get pods --all-namespaces -o wide
NAMESPACE     NAME                            READY     STATUS              RESTARTS   AGE       IP              NODE
default       ceph-rbd-pv-pod1                1/1       Running             0          3m        10.96.2.2       node1
default       ceph-rbd-pv-pod2                0/1       ContainerCreating   0          6s        <none>          node0

我们看到，貌似不可行！ceph-rbd-pv-pod1 被分配到 node1 并且成功 Running 运行，ceph-rbd-pv-pod2 被分配到 node2 但是状态为 ContainerCreating。查看下 ceph-rbd-pv-pod2 出错的原因。

$ kubectl describe pod/ceph-rbd-pv-pod2
Name:       ceph-rbd-pv-pod2
Namespace:  default
Node:       node0/10.222.76.119
Start Time: Thu, 04 Jan 2018 10:31:21 +0800
Labels:     test=rbd-pvc-pod
Annotations:    <none>
Status:     Pending
IP:     
Controllers:    <none>
Containers:
  ceph-rbd-pv-busybox2:
    Container ID:   
    Image:      busybox
    Image ID:       
    Port:       
    Command:
      sleep
      60000
    State:      Waiting
      Reason:       ContainerCreating
    Ready:      False
    Restart Count:  0
    Environment:    <none>
    Mounts:
      /mnt/ceph-rbd-pvc/busybox from ceph-rbd-vol2 (rw)
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-b177v (ro)
Conditions:
  Type      Status
  Initialized   True 
  Ready     False 
  PodScheduled  True 
Volumes:
  ceph-rbd-vol2:
    Type:   PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
    ClaimName:  ceph-rbd-pv-claim
    ReadOnly:   false
  default-token-b177v:
    Type:   Secret (a volume populated by a Secret)
    SecretName: default-token-b177v
    Optional:   false
QoS Class:  BestEffort
Node-Selectors: <none>
Tolerations:    node.alpha.kubernetes.io/notReady=:Exists:NoExecute for 300s
        node.alpha.kubernetes.io/unreachable=:Exists:NoExecute for 300s
Events:
  FirstSeen LastSeen    Count   From            SubObjectPath   Type        Reason      Message
  --------- --------    -----   ----            -------------   --------    ------      -------
  25s       25s     1   default-scheduler           Normal      Scheduled   Successfully assigned ceph-rbd-pv-pod2 to node0
  25s       8s      6   kubelet, node0              Warning     FailedMount MountVolume.SetUp failed for volume "kubernetes.io/rbd/59beacee-f0f7-11e7-b073-080027ee5979-ceph-rbd-pv" (spec.Name: "ceph-rbd-pv") pod "59beacee-f0f7-11e7-b073-080027ee5979" (UID: "59beacee-f0f7-11e7-b073-080027ee5979") with: rbd: image ceph-rbd-pv-test is locked by other nodes

从输出中，我们可以明显看到 rbd: image ceph-rbd-pv-test is locked by other nodes 错误信息。说明 Ceph RBD 仅能被 k8s 中的一个 node 挂载，也就是不支持跨节点挂载同一 Ceph RBD。其实从 kubernetes 官网 Persistent Volumes 文档中 Access Modes 部分支持 mode 列表中可以看到，rbd 只支持 ReadWriteOnce 和 ReadOnlyMany，暂时并不支持 ReadWriteMany。不过也指出 Ceph 另一种存储类型 cephfs 文件存储对三种 Mode 方式都支持。下一篇我们继续研究 Kubernetes 集群多节点挂载 CephFS 文件存储，来实现挂载分布式存储。

参考资料

初试 Kubernetes 集群使用 Ceph RBD 块存储

猜你喜欢