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 requer 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 em série 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ê tem um an ACK managed cluster executando o Kubernetes 1.26 ou posterior, com o csi-plugin e o csi-provisioner na versão v1.30.4 ou posterior.
Você instalou e configurou a Alibaba Cloud CLI.

Observações de uso

A montagem paralela é compatível apenas com discos que têm 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 têm 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 são executadas em série.
Após ativar a montagem paralela, os campos Device retornados pela API (como o ECS DescribeDisks) e o destino de montagem exibido no console podem ficar imprecisos. Não dependa deste caminho de montagem em suas cargas de trabalho. Use o número de série do disco para determinar o caminho de montagem real.

Procedimento

Para ativar a montagem paralela de discos, use o script automatizado ou o procedimento manual a seguir.

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 os discos em paralelo.
```
bash enable_parallel_attach.sh <Cluster ID>
```

Ative o recurso manualmente

Adicione ECS Tags ao pool de nós do cluster. Defina a chave da tag como supportConcurrencyAttach e o valor da tag como true. Certifique-se de que a tag seja adicionada a uma nova instância ECS.
1. Acesse o ACK console. No painel de navegação à esquerda, clique em Clusters.
2. Na página Clusters, clique no nome do seu cluster. No painel de navegação à esquerda, clique em Nodes > Node Pools.
3. Na página Node Pools, selecione o pool de nós, clique em Edit na coluna Actions e edite as configurações. Modifique os parâmetros conforme necessário.
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
Especifique DiskADController=true para que o csi-provisioner passe a executar as operações de attach e detach relacionadas aos discos. Especifique DiskParallelAttach=true para que o recurso de montagem paralela de discos seja ativado.
Configure o csi-provisioner e, em seguida, atualize o parâmetro FeatureGate do csi-plugin como DiskADController=true.

Verifique o desempenho da montagem paralela de discos

Neste exemplo, crie 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 dos testes neste tópico servem apenas como referência. Os resultados reais podem variar de acordo com o seu ambiente.

Adicione um nó que suporte vários 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 ele. 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 e confirme se o aplicativo é iniciado conforme o esperado. Em seguida, reduza 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 dos pods:

Nota

Neste cenário, a montagem paralela está desativada no cluster. Ajuste o número de pods do teste com base no número máximo de discos suportados pelo 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 os 28 pods com a montagem paralela desativada.

Ative a montagem paralela conforme as instruções da seção Procedure.
Exclua os pods anteriores e prepare a próxima rodada de testes executando o comando a seguir:

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 o comando a seguir novamente 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 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

Exclua os aplicativos de teste do cluster executando o comando a seguir:
```
kubectl delete -f attach-stress.yaml
```