Use gang scheduling - Container Compute Service: Central de Documentação do Alibaba Cloud

O gang scheduling oferece agendamento do tipo "tudo ou nada" para jobs com múltiplos pods no Alibaba Cloud Container Compute Service (ACS). O scheduler retém todos os pods até alocar simultaneamente a quantidade mínima necessária, o que evita deadlocks de recursos em workloads distribuídas, como jobs de treinamento de IA, tarefas MPI e pipelines de inferência com múltiplas funções.

Como funciona o gang scheduling

Quando um job cria vários pods, todos devem iniciar juntos. O gang scheduling garante a alocação de recursos para todo o grupo de uma só vez: se não for possível agendar o número mínimo de pods simultaneamente, nenhum pod será agendado. Isso evita deadlocks de recursos causados por jobs que adquirem recursos parcialmente e bloqueiam uns aos outros.

No ACS, o gang scheduling usa o recurso personalizado PodGroup (podgroups.scheduling.sigs.k8s.io/v1alpha1). Crie um PodGroup para definir a restrição de grupo e associe os pods do job a ele por meio de um rótulo.

Importante

Todos os pods configurados para gang scheduling devem pertencer à mesma classe de computação.

Pré-requisitos

O kube-scheduler deve estar instalado em uma versão que atenda aos seguintes requisitos:

Versão do cluster ACS	Versão mínima do scheduler
1.31	v1.31.0-aliyun-1.2.0
1.30	v1.30.3-aliyun-1.1.1
1.28	v1.28.9-aliyun-1.1.0

O gang scheduling suporta apenas o tipo de computação GPU de rede de alto desempenho (gpu-hpn). Para mais informações, consulte Definição de tipos de computação.
A configuração Enable Custom Labels And Schedulers For GPU-HPN Nodes deve estar desativada. Para mais informações, consulte Configuração de componentes.

Configure o gang scheduling

Crie um recurso personalizado PodGroup. O campo minMember define o número mínimo de pods para agendamento simultâneo. O campo scheduleTimeoutSeconds determina o tempo de espera do scheduler antes de marcar a tentativa como falha.
```
apiVersion: scheduling.sigs.k8s.io/v1alpha1
kind: PodGroup
metadata:
  name: demo-job-podgroup
  namespace: default
spec:
  scheduleTimeoutSeconds: 10
  minMember: 3 # Set the minimum number of running pods.
```

Crie um job e associe-o ao PodGroup. Salve o conteúdo abaixo em gang-job.yaml. O rótulo pod-group.scheduling.sigs.k8s.io: demo-job-podgroup no template do pod associa cada pod à instância do PodGroup especificada.

apiVersion: batch/v1
kind: Job
metadata:
  name: gang-job
  namespace: default
spec:
  parallelism: 3 # The number of pods must be greater than or equal to minMember in the PodGroup object.
  template:
    metadata:
      labels:
        alibabacloud.com/compute-class: "gpu-hpn" # Specify the compute class as gpu-hpn.
        alibabacloud.com/gpu-model-series: "example-model" # A GPU model must be specified for the GPU compute class.
        pod-group.scheduling.sigs.k8s.io: demo-job-podgroup # Associate with the demo-job-podgroup PodGroup instance.
    spec:
      containers:
      - name: demo-job
        image: registry.cn-hangzhou.aliyuncs.com/acs/stress:v1.0.4
        args:
          - 'infinity'
        command:
          - sleep
        resources:
          requests:
            cpu: "1"
            memory: "1Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "1"
            memory: "1Gi"
            nvidia.com/gpu: "1"
      restartPolicy: Never
  backoffLimit: 4

Implante o job no cluster.
```
kubectl apply -f gang-job.yaml
```
Verifique o agendamento dos pods. Em caso de sucesso, todos os pods passam do estado Pending para Running simultaneamente.
```
kubectl get podgroup -n default
kubectl get pods -n default -l pod-group.scheduling.sigs.k8s.io=demo-job-podgroup
```

Importante

Certifique-se de que o número de pods associados seja maior ou igual ao valor minMember configurado na instância do PodGroup. Caso contrário, os pods não serão agendados.

Exemplos

Este exemplo demonstra cenários de sucesso e falha no agendamento ao usar o gang scheduling para um job.

Execute o comando a seguir para criar o namespace test-gang.
```
kubectl create ns test-gang
```
Execute o comando abaixo para criar um ResourceQuota no namespace test-gang e demonstrar o comportamento do gang scheduling quando os recursos são insuficientes.
```
cat << EOF | kubectl apply -f -
apiVersion: v1
kind: ResourceQuota
metadata:
  name: object-counts
  namespace: test-gang
spec:
  hard:
    pods: "2"
EOF
```
Execute o seguinte comando para criar um objeto PodGroup. Neste objeto, minMember está definido como 3, o que exige o agendamento simultâneo e bem-sucedido de pelo menos 3 pods associados. Se a criação ou o agendamento de um dos pods falhar, todos os pods do grupo permanecerão no estado Pending.
```
cat << EOF | kubectl apply -f -
apiVersion: scheduling.sigs.k8s.io/v1alpha1
kind: PodGroup
metadata:
  name: demo-job-podgroup
  namespace: test-gang
spec:
  minMember: 3 # Set the minimum number of running pods.
EOF
```

Use o conteúdo YAML a seguir para criar o arquivo gang-job.yaml. Esse arquivo define um objeto Job com quatro réplicas de pod associado ao objeto PodGroup.

apiVersion: batch/v1
kind: Job
metadata:
  name: gang-job
  namespace: test-gang
spec:
  parallelism: 4 # The number of pods must be greater than or equal to minMember in the PodGroup object.
  template:
    metadata:
      labels:
        alibabacloud.com/compute-class: "gpu-hpn" # Specify the compute class as gpu-hpn.
        alibabacloud.com/gpu-model-series: "example-model" # A GPU model must be specified for the GPU compute class.
        pod-group.scheduling.sigs.k8s.io: demo-job-podgroup # Associate with the demo-job-podgroup PodGroup instance.
    spec:
      containers:
      - name: demo-job
        image: registry.cn-hangzhou.aliyuncs.com/acs/stress:v1.0.4
        args:
          - 'infinity'
        command:
          - sleep
        resources:
          requests:
            cpu: "1"
            memory: "1Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "1"
            memory: "1Gi"
            nvidia.com/gpu: "1"
      restartPolicy: Never
  backoffLimit: 4

Execute o comando a seguir para implantar o job gang-job no cluster.
```
kubectl apply -f gang-job.yaml
```
Visualize o status dos pods com o comando abaixo.
```
kubectl get pod -n test-gang
```
Saída esperada:
```
NAME             READY   STATUS    RESTARTS   AGE
gang-job-hrnc6   0/1     Pending   0          23s
gang-job-wthnq   0/1     Pending   0          23s
```
O ResourceQuota limita a execução a dois pods, portanto, apenas dois pods são criados para este job. Como esse número é inferior ao valor minMember especificado no PodGroup, ambos os pods permanecem no estado Pending e não são agendados.
Execute o comando a seguir para excluir o ResourceQuota e remover o limite de pods.
```
kubectl delete resourcequota -n test-gang object-counts
```

Visualize novamente o status dos pods com o comando abaixo.

kubectl get pod -n test-gang

Saída esperada:

NAME             READY   STATUS    RESTARTS   AGE
gang-job-24cz9   1/1     Running   0          96s
gang-job-mmkxl   1/1     Running   0          96s
gang-job-msr8v   1/1     Running   0          96s
gang-job-qnclz   1/1     Running   0          96s

A saída indica que os pods foram agendados com sucesso.