使用NVMe云盘多重挂载及Reservation实现应用间的数据共享

阅读前提示

为了让您更好地使用NVMe云盘多重挂载及Reservation功能，建议您在阅读本文档之前，了解以下内容：

• NVMe协议介绍，请参见NVMe协议概述。

• NVMe云盘介绍，请参见NVMe云盘概述。

应用场景

云盘多重挂载主要有以下应用场景：

• 数据共享

  NVMe最简单的应用场景为数据共享，当数据被写入云盘后，其他节点均可以访问该数据，从而有效节省成本并提升读写性能。例如，在云上容器镜像场景，同一套系统的镜像通常相似，因此多个不同实例可以读取加载同一份镜像。

  

• 高可用故障转移

  业务高可用是共享盘最常见的应用场景之一。传统基于SAN的数据库，例如Oracle RAC、SAP HANA以及云原生高可用数据库等场景中，实际业务使用过程中可能存在单点故障，确保故障情况下业务连续性是高可用系统的核心能力，在云上存储和网络具备极高的可用性。而计算节点则经常受断电、宕机、硬件故障等影响，所以业务通常搭建主备模式解决计算的高可用问题。

  例如数据库场景，当主库故障时迅速切换到备库对外提供服务，实例切换后，可以通过NVMe PR命令释放旧实例的写入权限，从而确保旧实例不再写入数据确保数据一致性。如图所示，故障转移流程说明如下：

  说明

  PR（PersistentReservation）属于NVMe协议的一部分，PR可精确地控制某个云盘的读写权限，从而确保计算端按照预期写入数据。更多信息，请参见NVMe PR协议。

  1. 数据库主实例1故障，导致业务停止。

  2. 下发NVMe PR命令，禁止数据库实例1继续写入数据，允许数据库实例2写入数据。

  3. 数据库实例2通过日志回放等方式恢复到和数据库实例1一致的状态。

  4. 切换数据库实例2为主实例，继续对外提供服务。

  

• 分布式缓存加速

  开启多重挂载功能的云盘具备较高的IOPS和吞吐性能，可以为其他中低速的存储系统提供性能加速能力。例如数据湖场景，数据湖通常基于OSS搭建，可同时被多个客户端访问，同时具备较高的顺序读吞吐和追加写吞吐能力，但是其顺序读写吞吐和延迟较差，其随机读写性能较差。通过在计算节点上挂载高速云盘作为缓存，可以极大地提升数据湖等场景的访问性能。

  

• 机器学习

  在分布式机器学习训练中，将样本标注写入后，会将数据集分割成小块分发到多个计算节点上并行处理。云盘多重挂载使得每个计算节点都能直接访问共享的存储资源，无需通过网络频繁传输数据，减少了数据传输的延迟，从而加速了模型训练过程。云盘的高性能与多重挂载功能相结合，为机器学习场景提供了一个高效、灵活的存储解决方案，特别是针对需要高速数据访问和处理的大规模模型训练任务，能够显著提升整个机器学习流程的效率和效果。

  

使用限制

• 单个NVMe云盘支持同时挂载到同一可用区内的最多16个ECS实例。

• ACK仅支持通过volumeDevices的方式挂载可从多个节点读写的云盘，即不能通过文件系统访问。

• 更多使用限制，请参见多重挂载使用限制。

前提条件

• 已创建ACK托管集群，且集群为1.20及以上版本。具体操作，请参见创建ACK托管集群。

• 已安装csi-plugin和csi-provisioner组件，且组件为v1.24.10-7ae4421-aliyun及以上版本。关于csi-plugin和csi-provisioner组件的升级操作，请参见管理CSI组件。

• 集群至少包含2个在同一可用区的且支持使用多重挂载功能的节点，支持的实例规格族详见多重挂载使用限制。

• 已准备好业务应用且符合以下要求，然后将应用打包至容器镜像中用于在ACK集群中部署。

  • 应用支持同时从多个副本中访问同一云盘中的数据。

  • 应用能自行通过标准的NVMe Reservation等功能确保数据的一致性。

计费说明

云盘多重挂载功能不会产生额外费用，支持NVMe协议的相关资源仍保持各资源原有的计费方式。关于云盘相关计费的更多信息，请参见计费说明。

应用示例

本文使用下方应用示例的源代码和Dockerfile，将其构建后上传至镜像仓库以便后续在集群中部署。该示例应用中的多个副本共同管理一个租约，但仅有一个副本持有该租约。若该副本无法正常工作，其他副本将自动抢占该租约。编写应用注意事项如下：

• 示例中使用O_DIRECT打开块设备进行读写，避免任何缓存对测试的影响。

• 示例中使用Linux内核提供的Reservation简化接口，应用也可使用以下两种方法执行与Reservation相关的命令，以下方法需要特权。

  • C代码：ioctl(fd, NVME_IOCTL_IO_CMD, &cmd);

  • 命令行工具：nvme-cli

• 关于NVMe Reservation功能的详细信息，请参见NVMe Specification。

#define _GNU_SOURCE
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/pr.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <time.h>
#include <unistd.h>

const char *disk_device = "/dev/data-disk";
uint64_t magic = 0x4745D0C5CD9A2FA4;

void panic(const char *restrict format, ...) {
    va_list args;
    va_start(args, format);
    vfprintf(stderr, format, args);
    va_end(args);
    exit(EXIT_FAILURE);
}

struct lease {
    uint64_t magic;
    struct timespec acquire_time;
    char holder[64];
};

volatile bool shutdown = false;
void on_term(int signum) {
    shutdown = true;
}

struct lease *lease;
const size_t lease_alloc_size = 512;

void acquire_lease(int disk_fd) {
    int ret;

    struct pr_registration pr_reg = {
        .new_key = magic,
        .flags = PR_FL_IGNORE_KEY,
    };
    ret = ioctl(disk_fd, IOC_PR_REGISTER, &pr_reg);
    if (ret != 0)
        panic("failed to register (%d): %s\n", ret, strerror(errno));

    struct pr_preempt pr_pre = {
        .old_key = magic,
        .new_key = magic,
        .type  = PR_WRITE_EXCLUSIVE,
    };
    ret = ioctl(disk_fd, IOC_PR_PREEMPT, &pr_pre);
    if (ret != 0)
        panic("failed to preempt (%d): %s\n", ret, strerror(errno));

    // register again in case we preempted ourselves
    ret = ioctl(disk_fd, IOC_PR_REGISTER, &pr_reg);
    if (ret != 0)
        panic("failed to register (%d): %s\n", ret, strerror(errno));
    fprintf(stderr, "Register as key %lx\n", magic);


    struct pr_reservation pr_rev = {
        .key   = magic,
        .type  = PR_WRITE_EXCLUSIVE,
    };
    ret = ioctl(disk_fd, IOC_PR_RESERVE, &pr_rev);
    if (ret != 0)
        panic("failed to reserve (%d): %s\n", ret, strerror(errno));

    lease->magic = magic;
    gethostname(lease->holder, sizeof(lease->holder));

    while (!shutdown) {
        clock_gettime(CLOCK_MONOTONIC, &lease->acquire_time);
        ret = pwrite(disk_fd, lease, lease_alloc_size, 0);
        if (ret < 0)
            panic("failed to write lease: %s\n", strerror(errno));
        fprintf(stderr, "Refreshed lease\n");
        sleep(5);
    }
}

int timespec_compare(const struct timespec *a, const struct timespec *b) {
    if (a->tv_sec < b->tv_sec)
        return -1;
    if (a->tv_sec > b->tv_sec)
        return 1;
    if (a->tv_nsec < b->tv_nsec)
        return -1;
    if (a->tv_nsec > b->tv_nsec)
        return 1;
    return 0;
}

int main() {
    assert(lease_alloc_size >= sizeof(struct lease));
    lease = aligned_alloc(512, lease_alloc_size);
    if (lease == NULL)
        panic("failed to allocate memory\n");

    // char *reg_key_str = getenv("REG_KEY");
    // if (reg_key_str == NULL)
    //     panic("REG_KEY env not specified");

    // uint64_t reg_key = atoll(reg_key_str) | (magic << 32);
    // fprintf(stderr, "Will register as key %lx", reg_key);


    int disk_fd = open(disk_device, O_RDWR|O_DIRECT);
    if (disk_fd < 0)
        panic("failed to open disk: %s\n", strerror(errno));

    // setup signal handler
    struct sigaction sa = {
        .sa_handler = on_term,
    };
    sigaction(SIGTERM, &sa, NULL);
    sigaction(SIGINT, &sa, NULL);

    struct timespec last_active_local;
    struct timespec last_active_remote;

    int ret = pread(disk_fd, lease, lease_alloc_size, 0);
    if (ret < 0)
        panic("failed to read lease: %s\n", strerror(errno));

    if (lease->magic != magic) {
        // new disk, no lease
        acquire_lease(disk_fd);
    } else {
        // someone else has the lease
        while (!shutdown) {
            struct timespec now;
            clock_gettime(CLOCK_MONOTONIC, &now);
            if (timespec_compare(&lease->acquire_time, &last_active_remote)) {
                fprintf(stderr, "Remote %s refreshed lease\n", lease->holder);
                last_active_remote = lease->acquire_time;
                last_active_local = now;
            } else if (now.tv_sec - last_active_local.tv_sec > 20) {
                // remote is dead
                fprintf(stderr, "Remote is dead, preempting\n");
                acquire_lease(disk_fd);
                break;
            }
            sleep(5);
            int ret = pread(disk_fd, lease, lease_alloc_size, 0);
            if (ret < 0)
                panic("failed to read lease: %s\n", strerror(errno));
        }
    }

    close(disk_fd);
}

#!/bin/bash

set -e

DISK_DEVICE="/dev/data-disk"
MAGIC=0x4745D0C5CD9A2FA4

SHUTDOWN=0
trap "SHUTDOWN=1" SIGINT SIGTERM

function acquire_lease() {
    # racqa:
    # 0: aquire
    # 1: preempt

    # rtype:
    # 1: write exclusive

    nvme resv-register $DISK_DEVICE --iekey --nrkey=$MAGIC
    nvme resv-acquire $DISK_DEVICE --racqa=1 --rtype=1 --prkey=$MAGIC --crkey=$MAGIC
    # register again in case we preempted ourselves
    nvme resv-register $DISK_DEVICE --iekey --nrkey=$MAGIC
    nvme resv-acquire $DISK_DEVICE --racqa=0 --rtype=1 --prkey=$MAGIC --crkey=$MAGIC

    while [[ $SHUTDOWN -eq 0 ]]; do
        echo "$MAGIC $(date +%s) $HOSTNAME" | dd of=$DISK_DEVICE bs=512 count=1 oflag=direct status=none
        echo "Refreshed lease"
        sleep 5
    done
}

LEASE=$(dd if=$DISK_DEVICE bs=512 count=1 iflag=direct status=none)

if [[ $LEASE != $MAGIC* ]]; then
    # new disk, no lease
    acquire_lease
else
    last_active_remote=-1
    last_active_local=-1
    while [[ $SHUTDOWN -eq 0 ]]; do
        now=$(date +%s)
        read -r magic timestamp holder < <(echo $LEASE)
        if [ "$last_active_remote" != "$timestamp" ]; then
            echo "Remote $holder refreshed the lease"
            last_active_remote=$timestamp
            last_active_local=$now
        elif (($now - $last_active_local > 10)); then
            echo "Remote is dead, preempting"
            acquire_lease
            break
        fi
        sleep 5
        LEASE=$(dd if=$DISK_DEVICE bs=512 count=1 iflag=direct status=none)
    done
fi

securityContext:
  capabilities:
    add: ["SYS_ADMIN"]

# syntax=docker/dockerfile:1.4

FROM buildpack-deps:bookworm as builder

COPY lease.c /usr/src/nvme-resv/
RUN gcc -o /lease -O2 -Wall /usr/src/nvme-resv/lease.c

FROM debian:bookworm-slim

COPY --from=builder --link /lease /usr/local/bin/lease
ENTRYPOINT ["/usr/local/bin/lease"]

# syntax=docker/dockerfile:1.4
FROM debian:bookworm-slim

RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
    --mount=type=cache,target=/var/lib/apt,sharing=locked \
    sed -i 's/deb.debian.org/mirrors.aliyun.com/g' /etc/apt/sources.list.d/debian.sources && \
    rm -f /etc/apt/apt.conf.d/docker-clean && \
    apt-get update && \
    apt-get install -y nvme-cli

COPY --link lease.sh /usr/local/bin/lease
ENTRYPOINT ["/usr/local/bin/lease"]

步骤一：部署应用并配置多重挂载

创建名为alicloud-disk-shared的StorageClass，并开启云盘的多重挂载功能。

创建名为data-disk的PVC，并设置accessModes为ReadWriteMany；volumeMode为Block。

创建名为lease-test的StatefulSet应用，使用本文应用示例的镜像。

1. 使用以下内容，创建lease.yaml文件。

   请将以下YAML中容器镜像地址替换为您实际应用的镜像地址。

   重要

   • 由于NVMe Reservation在节点维度生效，同一节点上的多个Pod可能会互相干扰，所以本示例中通过podAntiAffinity以避免多个Pod调度到同一个节点上。

   • 如果您的集群中包括其他不使用NVMe协议的节点，您需要自行设置亲和性，以确保将Pod调度到使用NVMe协议的节点上。

   展开查看lease.yaml文件

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     name: alicloud-disk-shared
   parameters:
     type: cloud_essd
     multiAttach: "true"
   provisioner: diskplugin.csi.alibabacloud.com
   reclaimPolicy: Delete
   volumeBindingMode: WaitForFirstConsumer
   ---
   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: data-disk
   spec:
     accessModes: [ "ReadWriteMany" ]
     storageClassName: alicloud-disk-shared
     volumeMode: Block
     resources:
       requests:
         storage: 20Gi
   ---
   apiVersion: apps/v1
   kind: StatefulSet
   metadata:
     name: lease-test
   spec:
     replicas: 2
     serviceName: lease-test
     selector:
       matchLabels:
         app: lease-test
     template:
       metadata:
         labels:
           app: lease-test
       spec:
         affinity:
           podAntiAffinity:
             requiredDuringSchedulingIgnoredDuringExecution:
             - labelSelector:
                 matchExpressions:
                 - key: app
                   operator: In
                   values:
                   - lease-test
               topologyKey: "kubernetes.io/hostname"
         containers:
         - name: lease
           image: <IMAGE OF APP>   # 替换为您应用的镜像地址。
           volumeDevices:
           - name: data-disk
             devicePath: /dev/data-disk  
         volumes:
         - name: data-disk
           persistentVolumeClaim:
             claimName: data-disk

   参数		使用多重挂载功能配置说明	普通挂载配置说明

   参数		使用多重挂载功能配置说明	普通挂载配置说明
   StorageClass	parameters.multiAttach	设置为true，以开启云盘的多重挂载功能。	无需配置
   PVC	accessModes	ReadWriteMany	ReadWriteOnce
   	volumeMode	Block	Filesystem
   存储卷挂载方式		volumeDevices：直接通过块设备访问云盘中的数据。	volumeMounts：主要用于挂载文件系统类型的Volume。

2. 执行以下命令，部署应用。

   kubectl apply -f lease.yaml

步骤二：验证多重挂载及Reservation效果

为了确保NVMe云盘的数据一致性，您可以在应用中通过Reservation控制读写权限，如果一个Pod进行写操作，其他Pod就只能进行读操作。

多个节点可读写同一个云盘

执行以下命令，查看Pod日志。

kubectl logs -l app=lease-test --prefix -f

预期输出：

[pod/lease-test-0/lease] Register as key 4745d0c5cd9a2fa4
[pod/lease-test-0/lease] Refreshed lease
[pod/lease-test-0/lease] Refreshed lease
[pod/lease-test-1/lease] Remote lease-test-0 refreshed lease
[pod/lease-test-0/lease] Refreshed lease
[pod/lease-test-1/lease] Remote lease-test-0 refreshed lease
[pod/lease-test-0/lease] Refreshed lease
[pod/lease-test-1/lease] Remote lease-test-0 refreshed lease
[pod/lease-test-0/lease] Refreshed lease
[pod/lease-test-1/lease] Remote lease-test-0 refreshed lease

预期输出表明，Pod lease-test-1可以即时读取到Pod lease-test-0的写入的内容。

NVMe Reservation创建成功

1. 执行以下命令，获取云盘ID。

   kubectl get pvc data-disk -ojsonpath='{.spec.volumeName}'

2. 登录两个节点中的任意一个节点，执行以下命令确认NVMe Reservation是否创建成功。

   请替换以下代码中2zxxxxxxxxxxx为您上一步获取到的云盘ID中d-之后的内容。

   nvme resv-report -c 1 /dev/disk/by-id/nvme-Alibaba_Cloud_Elastic_Block_Storage_2zxxxxxxxxxxx

   预期输出：

   NVME Reservation status:
   
   gen       : 3
   rtype     : 1
   regctl    : 1
   ptpls     : 1
   regctlext[0] :
     cntlid     : ffff
     rcsts      : 1
     rkey       : 4745d0c5cd9a2fa4
     hostid     : 4297c540000daf4a4*****

   预期输出表明，NVMe Reservation已创建成功。

通过Reservation可阻断异常节点的写入IO

1. 登录Pod lease-test-0所在的节点上执行以下命令，暂停该进程用于模拟故障场景。

   pkill -STOP -f /usr/local/bin/lease

2. 等待30秒后，执行以下命令，再次查看日志。

   kubectl logs -l app=lease-test --prefix -f

   预期输出：

   [pod/lease-test-1/lease] Remote lease-test-0 refreshed lease
   [pod/lease-test-1/lease] Remote is dead, preempting
   [pod/lease-test-1/lease] Register as key 4745d0c5cd9a2fa4
   [pod/lease-test-1/lease] Refreshed lease
   [pod/lease-test-1/lease] Refreshed lease
   [pod/lease-test-1/lease] Refreshed lease

   预期输出表明，此时Pod lease-test-1已接管，持有租约成为服务的主节点。

3. 再次登录Pod lease-test-0所在的节点上执行以下命令，恢复之前暂停的进程。

   pkill -CONT -f /usr/local/bin/lease

4. 执行以下命令，再次查看日志。

   kubectl logs -l app=lease-test --prefix -f

   预期输出：

   [pod/lease-test-0/lease] failed to write lease: Invalid exchange

   预期输出表明，Pod lease-test-0将无法再写入该云盘，容器lease自动重启。说明其写入IO的操作已成功被Reservation阻断。

相关文档

如果您的NVMe云盘空间不满足要求或磁盘已满，请参见扩容云盘存储卷。