Ative a montagem paralela de discos - Container Service for Kubernetes: Central de Documentação do Alibaba Cloud

Quando muitos pods compartilham um nó e cada um exige vários discos — cenário comum em cargas de trabalho de banco de dados, integração contínua (CI) e processamento em lote — a montagem serial padrão aumenta o tempo de inicialização dos pods. A montagem paralela de discos anexa os discos simultaneamente, reduzindo a latência de inicialização.

Pré-requisitos

Você possui um cluster ACK gerenciado executando Kubernetes 1.26 ou posterior, com csi-plugin e csi-provisioner na versão v1.30.4 ou superior.
Você instalou e configurou a Alibaba Cloud CLI.

Observações de uso

A montagem paralela é compatível apenas com discos que possuem números de série. Para mais informações sobre como consultar o número de série de um disco, consulte Query serial number.

Discos criados antes de 10 de junho de 2020 não possuem números de série reconhecíveis. Se você ativar a montagem paralela para esses discos, a montagem falhará.
Ao desmontar vários discos do mesmo nó, as operações de desmontagem ainda ocorrem no modo serial.
Após ativar a montagem paralela, os campos Device retornados pela API (como ECS DescribeDisks) e o destino de montagem exibido no console podem estar imprecisos. Não confie nesse caminho de montagem em suas cargas de trabalho. Utilize o número de série do disco para determinar o caminho real de montagem.

Procedimento

Para ativar a montagem paralela de discos, utilize o script automatizado ou o procedimento manual abaixo.

Usar um script automatizado

Salve o script a seguir em um arquivo chamado enable_parallel_attach.sh.

Visualize o script

#!/bin/bash

set -e
set -o pipefail

readonly REQUIRED_VERSION="v1.30.4"
CLUSTER_ID=$1

if [ -z "$CLUSTER_ID" ]; then
    echo "Usage: enable_parallel_attach.sh <cluster-id>"
    exit 1
fi

check_version() {
    local ADDONS VERSION
    ADDONS=$(aliyun cs GET "/clusters/${CLUSTER_ID}/addon_instances")

    VERSION=$(echo "$ADDONS" | jq -r '.addons[] | select(.name=="csi-plugin") | .version')
    if !  printf "%s\n" "$REQUIRED_VERSION" "$VERSION" | sort -V -C; then
        echo "csi-plugin version $VERSION is not supported, please upgrade to $REQUIRED_VERSION or later"
        exit 1
    fi

    PROVISIONER=managed-csiprovisioner
    VERSION=$(echo "$ADDONS" | jq -r '.addons[] | select(.name=="managed-csiprovisioner") | .version')
    if [ -z "$VERSION" ]; then
        PROVISIONER=csi-provisioner
        VERSION=$(echo "$ADDONS" | jq -r '.addons[] | select(.name=="csi-provisioner") | .version')
    fi
    if !  printf "%s\n" "$REQUIRED_VERSION" "$VERSION" | sort -V -C; then
        echo "$PROVISIONER version $VERSION is not supported, please upgrade to $REQUIRED_VERSION or later"
        exit 1
    fi
}

update_node_pool() {
    local NODE_POOL_DOC
    NODE_POOL_DOC=$(aliyun cs GET "/clusters/${CLUSTER_ID}/nodepools/$1")

    if [ -n "$(echo "$NODE_POOL_DOC" | jq -r '(.scaling_group.tags // [])[] | select(.key=="supportConcurrencyAttach")')" ]; then
        echo "node pool already has supportConcurrencyAttach tag"
        return
    fi

    aliyun cs PUT "/clusters/${CLUSTER_ID}/nodepools/$1" --header "Content-Type=application/json" \
        --body "$(echo "$NODE_POOL_DOC" | jq -c '{
    "scaling_group": {
        "tags": ((.scaling_group.tags // []) + [{
            "key": "supportConcurrencyAttach",
            "value": "true"
        }])
    }
}')"
}

# Configure existing nodes.
update_nodes() {
    local PAGE=1
    local IDX TOTAL NODES_DOC ARGS
    while :; do
        echo "tagging nodes, page $PAGE"
        NODES_DOC=$(aliyun cs GET "/clusters/${CLUSTER_ID}/nodes" --pageSize 50 --pageNumber $PAGE)
        TOTAL=$(echo "$NODES_DOC" | jq -r '.page.total_count')

        ARGS=()
        IDX=0
        for node in $(echo "$NODES_DOC" | jq -r '.nodes[] | select(.is_aliyun_node) | .instance_id'); do
            IDX=$((IDX+1))
            ARGS+=("--ResourceId.$IDX" "$node")
        done
        if [ "$IDX" != "0" ]; then
            aliyun ecs TagResources --region "$ALIBABA_CLOUD_REGION_ID" --ResourceType Instance "${ARGS[@]}" \
                --Tag.1.Key supportConcurrencyAttach --Tag.1.Value true
            echo "finished nodes $(( (PAGE-1)*50+IDX ))/$TOTAL"
        fi

        if [[ $(( PAGE*50 )) -ge $TOTAL ]]; then
            break
        fi
        PAGE=$((PAGE+1))
    done
}

update_addon() {
    local ADDON=$1
    shift
    local CONFIG STATE
    CONFIG=$(aliyun cs GET "/clusters/${CLUSTER_ID}/addon_instances/${ADDON}" | \
        jq -c '.config | fromjson | (.FeatureGate // "" | split(",")) as $fg | .FeatureGate = ($fg + $ARGS.positional | unique | join(",")) | {config: . | tojson}' --args "$@")

    aliyun cs POST "/clusters/${CLUSTER_ID}/components/${ADDON}/config" --header "Content-Type=application/json" --body "$CONFIG"

    echo "Waiting for $ADDON config to complete"
    while true; do
        STATE=$(aliyun --secure cs GET "/clusters/${CLUSTER_ID}/addon_instances/${ADDON}" | jq -r '.state')
        echo "state: $STATE"
        if [ "$STATE" != "updating" ]; then
            break
        fi
        sleep 5
    done
    if [ "$STATE" != "active" ]; then
        echo "Failed to update $ADDON config"
        return 1
    fi
}

check_version

aliyun cs GET "/clusters/${CLUSTER_ID}/nodepools" | jq -r '.nodepools[]|.nodepool_info|"\(.nodepool_id)\t\(.name)"' | \
while read -r NODE_POOL_ID NODE_POOL_NAME; do
    echo "Updating tags for node pool $NODE_POOL_NAME ($NODE_POOL_ID)"
    update_node_pool "$NODE_POOL_ID"
done

ALIBABA_CLOUD_REGION_ID=$(aliyun cs GET "/clusters/${CLUSTER_ID}" | jq -r .region_id)

update_nodes

update_addon $PROVISIONER DiskADController=true DiskParallelAttach=true
update_addon csi-plugin DiskADController=true

echo "All done!  Now the disks can be attached concurrently to the same node."

Execute o script para montar discos no modo paralelo.
```
bash enable_parallel_attach.sh <Cluster ID>
```

Ativar o recurso manualmente

Adicione ECS Tags ao pool de nós do cluster. Defina a chave da tag como supportConcurrencyAttach e o valor como true. Certifique-se de adicionar a tag à nova instância ECS.
1. Faça login no ACK console. No painel de navegação à esquerda, clique em Clusters.
2. Na página Clusters, clique no nome do cluster. No painel de navegação à esquerda, clique em Nodes > Node Pools.
3. Na página Node Pools, localize o pool de nós a modificar e clique em Edit na coluna Actions.
4. Na parte inferior da página, localize a seção Advanced e adicione uma ECS Tags. Defina a chave como supportConcurrencyAttach e o valor como true.
Adicione uma tag às instâncias ECS de todos os nós existentes no cluster. Defina a chave como supportConcurrencyAttach e o valor como true. Para mais informações, consulte Add a custom tag.
No painel de navegação à esquerda, clique em Components and Add-ons. Clique na aba Storage, localize o add-on csi-provisioner, clique em Configuration no canto inferior direito do componente e defina o parâmetro FeatureGate como DiskADController=true,DiskParallelAttach=true.

Nota
Ao especificar DiskADController=true, o csi-provisioner passa a executar as operações attach e detach relacionadas a discos. Ao especificar DiskParallelAttach=true, você ativa o recurso de montagem paralela de discos.
Após configurar o csi-provisioner, defina o parâmetro FeatureGate do csi-plugin como DiskADController=true.

Verificar o desempenho da montagem paralela de discos

Neste exemplo, cria-se pods com vários discos montados no mesmo nó para verificar a aceleração da inicialização após ativar a montagem paralela.

Importante

Os resultados de teste neste tópico são valores de referência. Os resultados reais podem variar conforme o ambiente.

Adicione um nó compatível com múltiplos discos a um cluster ACK. Por exemplo, uma instância ecs.g7se.16xlarge suporta até 56 discos.

Crie um arquivo de teste chamado attach-stress.yaml e copie o conteúdo a seguir para o arquivo. Substitua <YOUR-HOSTNAME> pelo nome real do nó.

Visualize o arquivo attach-stress.yaml

---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: alibabacloud-disk
provisioner: diskplugin.csi.alibabacloud.com
parameters:
  type: cloud_auto
volumeBindingMode: WaitForFirstConsumer
reclaimPolicy: Delete
allowVolumeExpansion: true
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: attach-stress
spec:
  selector:
    matchLabels:
      app: attach-stress
  serviceName: attach-stress
  replicas: 1
  podManagementPolicy: Parallel
  persistentVolumeClaimRetentionPolicy:
    whenScaled: Retain
    whenDeleted: Delete
  template:
    metadata:
      labels:
        app: attach-stress
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: kubernetes.io/hostname
                operator: In
                values:
                - <YOUR-HOSTNAME> # Replace this parameter with the actual name of the node. 
      hostNetwork: true
      containers:
      - name: attach-stress
        image: registry-cn-hangzhou.ack.aliyuncs.com/acs/busybox
        command: ["/bin/sh", "-c", "trap exit TERM; while true; do date > /mnt/0/data; sleep 1; done"]
        volumeMounts:
        - name: volume-0
          mountPath: /mnt/0
        - name: volume-1
          mountPath: /mnt/1
  volumeClaimTemplates:
  - metadata:
      name: volume-0
    spec:
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: alibabacloud-disk
      resources:
        requests:
          storage: 1Gi
  - metadata:
      name: volume-1
    spec:
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: alibabacloud-disk
      resources:
        requests:
          storage: 1Gi

Execute o comando a seguir para confirmar que a aplicação inicia conforme esperado. Em seguida, escale a contagem de réplicas para 0 para preparar os testes de montagem em lote.

kubectl apply -f attach-stress.yaml
kubectl rollout status sts attach-stress
kubectl scale sts attach-stress --replicas 0

Saída esperada:

storageclass.storage.k8s.io/alibabacloud-disk created
statefulset.apps/attach-stress created
partitioned roll out complete: 1 new pods have been updated...
statefulset.apps/attach-stress scaled

Execute os comandos a seguir para iniciar o teste de montagem em lote e medir o tempo de inicialização do pod:

Nota

Neste caso, a montagem paralela está desativada para o cluster. Ajuste o número de pods para o teste com base no número máximo de discos compatíveis com o seu nó.

date && \
  kubectl scale sts attach-stress --replicas 28 && \
  kubectl rollout status sts attach-stress && \
  date

Saída esperada:

Tuesday October 15 19:21:36 CST 2024
statefulset.apps/attach-stress scaled
Waiting for 28 pods to be ready...
Waiting for 27 pods to be ready...
<Omitted...>
Waiting for 3 pods to be ready...
Waiting for 2 pods to be ready...
Waiting for 1 pods to be ready...
partitioned roll out complete: 28 new pods have been updated...
Tuesday October 15 19:24:55 CST 2024

A saída indica que são necessários mais de 3 minutos para iniciar todos os 28 pods quando a montagem paralela está desativada.

Ative a montagem paralela seguindo as instruções na seção Procedure.
Execute o comando a seguir para excluir os pods anteriores e preparar a próxima rodada de testes:

Nota
Monitore os recursos volumeattachments no cluster. Após a exclusão desses recursos, os discos serão desmontados. Esse processo leva alguns minutos.
```
kubectl scale sts attach-stress --replicas 0
```

Execute novamente o comando a seguir para calcular o tempo necessário para iniciar os pods após ativar a montagem paralela. O tempo esperado é de aproximadamente 40 segundos, muito mais rápido que os 3 minutos observados com a montagem paralela desativada.

date && \
  kubectl scale sts attach-stress --replicas 28 && \
  kubectl rollout status sts attach-stress && \
  date

Saída esperada:

Tuesday October 15 20:02:54 CST 2024
statefulset.apps/attach-stress scaled
Waiting for 28 pods to be ready...
Waiting for 27 pods to be ready...
<Omitted...>
Waiting for 3 pods to be ready...
Waiting for 2 pods to be ready...
Waiting for 1 pods to be ready...
partitioned roll out complete: 28 new pods have been updated...
Tuesday October 15 20:03:31 CST 2024

Execute o comando a seguir para excluir as aplicações de teste no cluster:
```
kubectl delete -f attach-stress.yaml
```