As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Slurm Workload Manager (`slurm`) ## Tamanho e atualização da capacidade do cluster A capacidade do cluster é definida pelo número de nós de computação que o cluster pode escalar. Os nós de computação são apoiados por instâncias do Amazon EC2 definidas nos recursos computacionais AWS ParallelCluster da `(Scheduling/SlurmQueues/`ComputeResources`)` configuração e são organizados em `(Scheduling/SlurmQueues)` filas que mapeiam 1:1 para partições. Slurm [Em um recurso de computação, é possível configurar o número mínimo de nós de computação (instâncias) que sempre devem ser mantidos em execução no cluster (`MinCount`) e o número máximo de instâncias para as quais o recurso computacional pode ser escalado (`MaxCount`3).](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-MaxCount) No momento da criação do cluster, ou após uma atualização do cluster, AWS ParallelCluster inicia quantas instâncias do Amazon EC2 estiverem configuradas `MinCount` para cada recurso computacional (`Scheduling/SlurmQueues/ ComputeResources`) definido no cluster. As instâncias lançadas para cobrir a quantidade mínima de nós para os recursos computacionais no cluster são chamadas de ***nós estáticos***. Uma vez iniciados, os nós estáticos devem ser persistentes no cluster e não são encerrados pelo sistema, a menos que ocorra um evento ou condição específica. Esses eventos incluem, por exemplo, a falha das verificações de integridade do Slurm ou do Amazon EC2 e a alteração do status do nó do Slurm para DRAIN ou DOWN. As instâncias do Amazon EC2, no intervalo de `1` a `‘MaxCount - MinCount’` (`MaxCount ` *menos*` MinCount)`, lançadas sob demanda para lidar com o aumento da carga do cluster, são chamadas de ***nós dinâmicos***. Sua natureza é efêmera, elas são lançadas para atender a trabalhos pendentes e são encerradas quando ficam ociosas por um tempo definido por `Scheduling/SlurmSettings/ScaledownIdletime` na configuração do cluster (padrão: 10 minutos). Os nós estáticos e os nós dinâmicos estão obedecem ao seguinte padrão de nomenclatura: + Os nós estáticos são `-st--`, em que ` = 1..ComputeResource/MinCount` + Os nós dinâmicos são `-dy--`, em que ` = 1..(ComputeResource/MaxCount - ComputeResource/MinCount)` Por exemplo, dada a seguinte AWS ParallelCluster configuração: ``` Scheduling: Scheduler: Slurm SlurmQueues: - Name: queue1 ComputeResources: - Name: c5xlarge Instances: - InstanceType: c5.xlarge MinCount: 100 MaxCount: 150 ``` Os seguintes nós serão definidos no Slurm ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 50 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` Quando um recurso computacional o tiver`MinCount == MaxCount`, todos os nós de computação correspondentes serão estáticos e todas as instâncias serão iniciadas no creation/update momento do cluster e mantidas em funcionamento. Por exemplo: ``` Scheduling: Scheduler: slurm SlurmQueues: - Name: queue1 ComputeResources: - Name: c5xlarge Instances: - InstanceType: c5.xlarge MinCount: 100 MaxCount: 100 ``` ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` ## Atualização da capacidade do cluster A atualização da capacidade do cluster inclui adicionar ou remover filas, recursos computacionais ou alterar o `MinCount/MaxCount` de um recurso computacional. A partir da AWS ParallelCluster versão 3.9.0, reduzir o tamanho de uma fila exige que a frota de computação seja interrompida ou [QueueUpdateStrategy](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-QueueUpdateStrategy)configurada como TERMINATE antes que uma atualização do cluster ocorra. Não é necessário interromper a frota de computação ou configurar [QueueUpdateStrategy](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-QueueUpdateStrategy)para TERMINATE quando: + Adicionar novas filas ao Agendamento/ [`SlurmQueues`](Scheduling-v3.md#Scheduling-v3-SlurmQueues) + Adicionar novos recursos computacionais `Scheduling/SlurmQueues/ComputeResources` a uma fila + Aumentar a `MaxCount` de um recurso computacional + Aumento MinCount de um recurso computacional e aumento MaxCount do mesmo recurso computacional em pelo menos a mesma quantidade ## Considerações e limitações Esta seção tem como objetivo descrever fatores, restrições ou limitações importantes que devem ser levados em consideração ao redimensionar a capacidade do cluster. + Ao remover uma fila de `Scheduling/SlurmQueues`, todos os nós computacionais com nome `-*`, tanto estáticos quanto dinâmicos, serão removidos da configuração do Slurm, e as instâncias correspondentes do Amazon EC2 serão encerradas. + Ao remover um recurso computacional `Scheduling/SlurmQueues/ComputeResources` de uma fila, todos os nós de computação com nome `-*--*`, tanto estáticos quanto dinâmicos, serão removidos da configuração do Slurm, e as instâncias correspondentes do Amazon EC2 serão encerradas. Ao alterar o parâmetro `MinCount` de um recurso computacional, podemos distinguir dois cenários diferentes: se `MaxCount` for mantido igual a `MinCount` (somente capacidade estática) e se `MaxCount` for maior que `MinCount` (capacidade estática e dinâmica mista). ### Alterações de capacidade somente com nós estáticos + Se `MinCount == MaxCount`, ao aumentar `MinCount` (e `MaxCount`), o cluster será configurado estendendo o número de nós estáticos até o novo valor de `MinCount` `-st--` e o sistema continuará tentando iniciar instâncias do Amazon EC2 para atender à nova capacidade estática necessária. + Se `MinCount == MaxCount`, ao diminuir `MinCount` (e `MaxCount`) em N, o cluster será configurado removendo os últimos N nós estáticos `-st--...]` e o sistema encerrará as instâncias correspondentes do Amazon EC2. + Estado inicial `MinCount = MaxCount = 100` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` + Atualizar `-30` em `MinCount` e `MaxCount: MinCount = MaxCount = 70` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 70 idle queue1-st-c5xlarge-[1-70] ``` ### Alterações de capacidade com nós mistos Se `MinCount < MaxCount`, ao aumentar `MinCount` em uma quantidade N (supondo que `MaxCount` será mantido inalterado), o cluster será configurado estendendo o número de nós estáticos até o novo valor de `MinCount` (`old_MinCount + N`): `-st--` e o sistema continuará tentando iniciar instâncias do Amazon EC2 para atender à nova capacidade estática necessária. Além disso, para honrar a capacidade `MaxCount` do recurso computacional, a configuração do cluster é atualizada *removendo os últimos N nós dinâmicos*: `-dy--[...]` e o sistema encerrará as instâncias correspondentes do Amazon EC2. + Estado inicial: `MinCount = 100; MaxCount = 150` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 50 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` + Atualização \+30 para `MinCount : MinCount = 130 (MaxCount = 150)` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 20 idle~ queue1-dy-c5xlarge-[1-20] queue1* up infinite 130 idle queue1-st-c5xlarge-[1-130] ``` Se `MinCount < MaxCount`, ao aumentar `MinCount` e `MaxCount` com a mesma quantidade N, o cluster será configurado estendendo o número de nós estáticos para o novo valor de `MinCount` (`old_MinCount + N`): `-st--` e o sistema continuará tentando iniciar instâncias do Amazon EC2 para atender à nova capacidade estática necessária. Além disso, nenhuma alteração será feita no número de nós dinâmicos para honrar o novo `MaxCount` value. + Estado inicial: `MinCount = 100; MaxCount = 150` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 50 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` + Atualização \+30 para `MinCount : MinCount = 130 (MaxCount = 180)` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 20 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 130 idle queue1-st-c5xlarge-[1-130] ``` Se `MinCount < MaxCount`, ao diminuir `MinCount` em N (supondo que `MaxCount` seja mantido inalterado), o cluster será configurado removendo os últimos N nós estáticos `-st--[...` e o sistema encerrará as instâncias correspondentes do Amazon EC2. Além disso, para honrar a capacidade `MaxCount` do recurso computacional, a configuração do cluster é atualizada ampliando o número de nós dinâmicos para preencher a lacuna `MaxCount - new_MinCount: -dy--[1..]`. Nesse caso, como esses são nós dinâmicos, nenhuma nova instância do Amazon EC2 será inicializada, a menos que o agendador tenha trabalhos pendentes nos novos nós. + Estado inicial: `MinCount = 100; MaxCount = 150` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 50 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` + Atualização -30 no `MinCount : MinCount = 70 (MaxCount = 120)` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 80 idle~ queue1-dy-c5xlarge-[1-80] queue1* up infinite 70 idle queue1-st-c5xlarge-[1-70] ``` Se `MinCount < MaxCount`, ao diminuir `MinCount` e `MaxCount` em N, o cluster será configurado removendo os últimos N nós estáticos `-st--...]` e o sistema encerrará as instâncias correspondentes do Amazon EC2. Além disso, nenhuma alteração será feita no número de nós dinâmicos para honrar o novo valor `MaxCount`. + Estado inicial: `MinCount = 100; MaxCount = 150` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 50 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` + Atualização -30 no `MinCount : MinCount = 70 (MaxCount = 120)` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 80 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 70 idle queue1-st-c5xlarge-[1-70] ``` Se `MinCount < MaxCount`, ao diminuir `MaxCount` a quantidade N (supondo que `MinCount` seja mantido inalterado), o cluster será configurado removendo os últimos N nós dinâmicos `-dy--]` e o sistema encerrará as instâncias correspondentes do Amazon EC2 caso elas estejam em execução. Nenhum impacto é esperado nos nós estáticos. + Estado inicial: `MinCount = 100; MaxCount = 150` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 50 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` + Atualização -30 no `MaxCount : MinCount = 100 (MaxCount = 120)` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 20 idle~ queue1-dy-c5xlarge-[1-20] queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` ## Impactos nos empregos Em todos os casos em que os nós são removidos e as instâncias do Amazon EC2 são encerradas, um trabalho em lote em execução nos nós removidos será enfileirado novamente, a menos que não haja outros nós que satisfaçam os requisitos do trabalho. Nesse último caso, o trabalho falha com o status NODE\_FAIL e desaparece da fila e deve ser reenviado manualmente. Se você estiver planejando executar uma atualização de redimensionamento de cluster, poderá impedir que os trabalhos sejam executados nos nós que serão removidos durante a atualização planejada. Isso é possível configurando os nós para serem removidos na manutenção. Esteja ciente de que a configuração de um nó em manutenção não afetará os trabalhos que já estiverem em execução no nó. Suponha que, com a atualização de redimensionamento do cluster planejada, você vai remover o nó `qeueu-st-computeresource-[9-10`]. Você pode criar uma reserva do Slurm com o seguinte comando ``` sudo -i scontrol create reservation ReservationName=maint_for_update user=root starttime=now duration=infinite flags=maint,ignore_jobs nodes=qeueu-st-computeresource-[9-10] ``` Isso criará uma reserva do Slurm chamada `maint_for_update` nos nós `qeueu-st-computeresource-[9-10]`. Quando a reserva é criada, nenhum outro trabalho pode ser executado nos nós `qeueu-st-computeresource-[9-10]`. Esteja ciente de que a reserva não impedirá que os trabalhos sejam alocados nos nós `qeueu-st-computeresource-[9-10]`. Após a atualização do redimensionamento do cluster, se a reserva do Slurm tiver sido definida apenas em nós removidos durante esse processo, a reserva de manutenção será excluída automaticamente. Em vez disso, se você tiver criado uma reserva do Slurm em nós que ainda estão presentes após a atualização do redimensionamento do cluster, poderá ser necessário remover a reserva de manutenção desses nós após a execução da atualização de redimensionamento, usando o seguinte comando: ``` sudo -i scontrol delete ReservationName=maint_for_update ``` Para conferir mais detalhes sobre a reserva do Slurm, consulte o documento oficial da SchedMD [aqui](https://slurm.schedmd.com/reservations.html). ## Processo de atualização do cluster em alterações de capacidade Após uma alteração na configuração do agendador, as seguintes etapas são executadas durante o processo de atualização do cluster: + Pare AWS ParallelCluster `clustermgtd (supervisorctl stop clustermgtd)` + Gerar configuração de partições do Slurm atualizada com base na configuração do AWS ParallelCluster + Reiniciar `slurmctld` (feito por meio da fórmula do serviço do Chef) + Verificar status do `slurmctld` `(systemctl is-active --quiet slurmctld.service)` + Recarregar configuração do Slurm `(scontrol reconfigure)` + Iniciar `clustermgtd (supervisorctl start clustermgtd)` Para saber mais sobre o Slurm, consulte [https://slurm.schedmd.com](https://slurm.schedmd.com). Para downloads, consulte [https://github.com/SchedMD/slurm/tags](https://github.com/SchedMD/slurm/tags). Para o código-fonte, consulte [https://github.com/SchedMD/slurm](https://github.com/SchedMD/slurm). ## Versões de cluster e SLURM suportadas A tabela a seguir lista as Slurm versões AWS ParallelCluster e AWS compatíveis. | AWS ParallelCluster versão (ões) | Versão do Slurm compatível | | --- | --- | | 3.13.0 | 24.05.07 | | 3.12.0 | 23.11.10 | | 3.11.0 | 23.11.10 | | 3.9.2, 3.9.3, 3.10.0 | 23.11.7 | | 3.9.0, 3.9.1 | 23.11.4 | | 3.8.0 | 23.02.7 | | 3.7.2 | 23.02.6 | | 3.7.1 | 23.02.5 | | 3.7.0 | 23.02.4 | | 3.6.0, 3.6.1 | 23.02.2 | | 3.5.0, 3.5.1 | 22.05.8 | | 3.4.0, 3.4.1 | 22.05.7 | | 3.3.0, 3.3.1 | 22.05.5 | | 3.1.4, 3.1.5, 3.2.0, 3.2.1 | 21.08.8-2 | | 3.1.2, 3.1.3 | 21.08.6 | | 3.1.1 | 21.08.5 | | 3.0.0 | 20.11.8 | **Topics** + [Tamanho e atualização da capacidade do cluster](#cluster-capacity-size-and-update) + [Atualização da capacidade do cluster](#cluster-capacity-update) + [Considerações e limitações](#considerations-limitations) + [Impactos nos empregos](#impacts-on-jobs) + [Processo de atualização do cluster em alterações de capacidade](#cluster-update-process) + [Versões de cluster e SLURM suportadas](#cluster-slurm-version-table) + [Configuração de várias filas](configuration-of-multiple-queues-v3.md) + [Guia do Slurm para o modo de várias filas](multiple-queue-mode-slurm-user-guide-v3.md) + [Slurm modo protegido por cluster](slurm-protected-mode-v3.md) + [Failover rápido de capacidade insuficiente do cluster Slurm](slurm-short-capacity-fail-mode-v3.md) + [Slurm agendamento baseado em memória](slurm-mem-based-scheduling-v3.md) + [Alocação a vários tipos de instância com o Slurm](slurm-multiple-instance-allocation-v3.md) + [Dimensionamento de clusters para nós dinâmicos](scheduler-node-allocation-v3.md) + [Slurmcontabilidade com AWS ParallelCluster](slurm-accounting-v3.md) + [Slurm personalização de configuração](slurm-configuration-settings-v3.md) + [`prolog` e `epilog` da Slurm](slurm-prolog-epilog-v3.md) + [Tamanho e atualização da capacidade do cluster](slurm-cluster-capacity-size-and-update.md)