Compartilhar via


CycleCloud GridEngine Cluster

O Agendador de Grade Aberta (Mecanismo de Grade) pode ser facilmente habilitado em um cluster do Azure CycleCloud modificando o "run_list" na definição do cluster. Um cluster do Grid Engine consiste em dois componentes principais. O primeiro é o nó 'mestre', que fornece um sistema de arquivos compartilhado no qual o software Grid Engine é executado. O segundo é o conjunto de nós 'execute', que são os hosts que montam o sistema de arquivos compartilhado e executam os trabalhos enviados. Por exemplo, um snippet de modelo de cluster do Mecanismo de Grade simples pode ser semelhante a:

[cluster grid-engine]

[[node master]]
    ImageName = cycle.image.centos7
    MachineType = Standard_A4 # 8 cores

    [[[configuration]]]
    run_list = role[sge_master_role]

[[nodearray execute]]
    ImageName = cycle.image.centos7
    MachineType = Standard_A1  # 1 core

    [[[configuration]]]
    run_list = role[sge_execute_role]

Observação

Os nomes dos papéis contêm 'sge' por motivos de legado: o Grid Engine era um produto da Sun Microsystems.

Importar e iniciar um cluster com uma definição no CycleCloud resulta em um único nó 'mestre'. Os nós de execução podem ser adicionados ao cluster por meio do cyclecloud add_node comando. Por exemplo, para adicionar mais 10 nós de execução:

cyclecloud add_node grid-engine -t execute -c 10

Dimensionamento automático do mecanismo de grade

O Azure CycleCloud dá suporte ao dimensionamento automático para o Grid Engine. Esse comportamento significa que o software monitora continuamente o status da fila e ativa ou desativa automaticamente os nós conforme necessário para concluir a carga de trabalho com eficiência em termos de tempo e custo. Você pode habilitar o dimensionamento automático para o Mecanismo de Grade adicionando Autoscale = true à sua definição de cluster:

[cluster grid-engine]
Autoscale = True

Por padrão, todos os trabalhos enviados para a fila do Grid Engine são executados em máquinas do tipo 'execute'. Esses computadores definidos pela matriz de nós chamada "execute". Você não está limitado ao nome 'execute', nem está limitado a um único tipo de configuração de computador para executar trabalhos e dimensionamento automático.

Por exemplo, um cenário comum envolve um cluster com duas definições de nó diferentes. Um foi projetado para executar trabalhos 'normais' que usam CPUs padrão. O outro destina-se a trabalhos que exigem computadores habilitados para GPU. Nesse caso, você vai querer escalar sua fila de forma independente tanto para trabalhos normais quanto para trabalhos de GPU, para garantir que você tenha uma quantidade apropriada de cada máquina para processar a fila de trabalho. Uma definição de exemplo seria algo como:

[cluster grid-engine]
Autoscale = True

[[node master]]
    ImageName = cycle.image.centos7
    MachineType = Standard_A3  # 4 cores

    [[[configuration]]]
    run_list = role[sge_master_role]

[[nodearray execute]]
    ImageName = cycle.image.centos7
    MachineType = Standard_A4  # 8 cores

    [[[configuration]]]
    run_list = role[sge_execute_role]

[[nodearray gpu]]
    MachineType = Standard_NV12 # 2 GPUs
    ImageName = cycle.image.centos7

    # Set the number of cores to the number of GPUs for autoscaling purposes
    CoreCount = 2  

    [[[configuration]]]
    run_list = role[sge_execute_role]
    gridengine.slot_type = gpu
    gridengine.slots = 2

No exemplo mostrado, existem agora duas matrizes de nós: uma é uma matriz de nó de execução 'standard', a segunda é chamada de 'gpu', fornecendo um tipo de máquina que possui duas GPUs NVIDIA (Standard_NV12 no Azure). Observe também que agora há dois novos itens na seção de configuração além da receita 'csge:sgeexec'. Adicionar gridengine.slot_type = gpu informa ao agendador do Grid Engine que esses nós devem ser chamados de nós 'gpu' e, portanto, devem executar apenas trabalhos 'gpu'. O nome "gpu" é arbitrário, mas um nome que descreve o nó é mais útil. Set gridengine.slots = 2, que informa ao software para garantir que esse tipo de nó só possa executar dois trabalhos ao mesmo tempo (Standard_NV12 tem apenas duas GPUs).

Por padrão, o Mecanismo de Grade atribui o número de slots por nó com base na contagem de CPU do sistema. Nesse caso, esse comportamento padrão pode resultar em tarefas demais sendo executadas simultaneamente em um único nó. No exemplo mostrado, CoreCount=2 é definido no nodearray para corresponder ao número de GPUs disponíveis no MachineType, permitindo que o CycleCloud dimensione corretamente essa matriz na contagem de GPU versus CPU.

Você pode verificar o número de slots e slot_type que seus computadores têm executando o comando:

    -bash-4.1# qstat -F slot_type
    queuename                      qtype resv/used/tot. load_avg arch          states
    ---------------------------------------------------------------------------------
    all.q@ip-0A000404              BIP   0/0/4          0.17     linux-x64
        hf:slot_type=execute
    ---------------------------------------------------------------------------------
    all.q@ip-0A000405              BIP   0/0/2          2.18     linux-x64
        hf:slot_type=gpu
    ---------------------------------------------------------------------------------
    all.q@ip-0A000406              BIP   0/0/4          0.25     linux-x64

Observe que há um de cada "slot_type" especificado "execute" e "gpu". Os slot_types são configurados individualmente e o número de slots para o slot 'execute' é 4, que é o número de CPUs no computador. O número de slots para o tipo de slot 'gpu' é 2, que especificamos em nosso modelo de configuração de cluster. O terceiro computador é o nó mestre que não executa trabalhos.

Uso Avançado do Grid Engine

Essas configurações permitem a personalização avançada de nós e matrizes de nós. Por exemplo, se os trabalhos exigirem uma quantidade específica de memória, digamos 10 GB cada, você poderá definir uma nodearray de execução que inicia computadores com 60 GB de memória e, em seguida, adicionar as opções gridengine.slots = 6 de configuração para garantir que apenas 6 trabalhos possam ser executados simultaneamente nesse tipo de nó (garantindo que cada trabalho tenha pelo menos 10 GB de memória para trabalhar).

Nós agrupados no mecanismo de grade

Quando um trabalho paralelo é enviado ao mecanismo de grade, o comportamento de dimensionamento automático padrão que o CycleCloud usa para tratar cada trabalho de MPI como uma solicitação de nó agrupado. Os nós agrupados são firmemente acoplados e idealmente adequados para fluxos de trabalho de MPI.

Quando um conjunto de nós agrupados ingressa em um cluster do Mecanismo de Grade, a ID do grupo de cada nó é usada como o valor complexo affinity_group. Ao exigir que um affinity_group seja especificado para trabalhos, ele permite que o agendador do Mecanismo de Grade garanta que os trabalhos só cheguem em computadores que estejam no mesmo grupo.

A automação do CycleCloud solicita automaticamente nós agrupados e os atribui a grupos de afinidade disponíveis quando trabalhos paralelos são encontrados.

Enviando trabalhos para o Grid Engine

A maneira mais genérica de enviar trabalhos para um agendador do Mecanismo de Grade é o comando:

qsub my_job.sh

Esse comando envia um trabalho que é executado em um nó do tipo "execute", que é um nó definido pelo nodearray "execute". Para fazer um trabalho ser executado em um nodearray de um tipo diferente, por exemplo, o tipo de nó "gpu" mostrado, modificamos nosso envio:

qsub -l slot_type=gpu my_gpu_job.sh

Esse comando garante que o trabalho seja executado apenas em um "slot_type" de "gpu".

Se slot_type for omitido, "execute" atribuirá automaticamente ao trabalho. O usuário pode modificar o mecanismo que atribui automaticamente slot_type a trabalhos. Um script python localizado em /opt/cycle/jetpack/config/autoscale.py pode ser criado, o que deve definir uma única função "sge_job_handler". Essa função recebe uma representação de dicionário da tarefa, semelhante à saída de um comando qstat -j JOB_ID e deve retornar um dicionário de recursos fixos que precisam ser atualizados para a tarefa.

Por exemplo, o script a seguir atribui um trabalho ao 'gpu' slot_type se o nome dos trabalhos incluir as letras 'gpu'. Os usuários têm permissão para submeter seus trabalhos automaticamente sem alterar os parâmetros de trabalho, garantindo que os trabalhos sejam executados e escalem automaticamente para os nós corretos.

#!/usr/env python
#
# File: /opt/cycle/jetpack/config/autoscale.py
#
def sge_job_handler(job):
  # The 'job' parameter is a dictionary containing the data present in a 'qstat -j JOB_ID':
    hard_resources = {'slot_type': 'execute', 'affinity_group' : 'default' }

  # Don't modify anything if the job already has a slot type
  # You could modify the slot type at runtime by not checking this
  if 'hard_resources' in job and 'slot_type' in job['hard_resources']:
      return hard_resources

  # If the job's script name contains the string 'gpu' then it's assumed to be a GPU job.
  # Return a dictionary containing the new job_slot requirement to be updated.
  # For example: 'big_data_gpu.sh' would be run on a 'gpu' node.
  if job['job_name'].find('gpu') != -1:
      hard_resources {'slot_type': 'gpu'}
  else:
      return hard_resources

O parâmetro "job" passado é um dicionário que contém os dados em uma chamada qstat -j JOB_ID:

{
    "job_number": 5,
    "job_name": "test.sh",
    "script_file": "test.sh",
    "account": "sge",
    "owner": "cluster.user",
    "uid": 100,
    "group": "cluster.user",
    "gid": 200,
    "submission_time": "2013-10-09T09:09:09",
    "job_args": ['arg1', 'arg2', 'arg3'],
    "hard_resources": {
       'mem_free': '15G',
       'slot_type': 'execute'
    }
}

Você pode usar essa funcionalidade de script para atribuir slot_type automaticamente com base em qualquer parâmetro de trabalho definido, como argumentos, requisitos de recursos como memória ou o usuário que está enviando.

Suponha que você envie 5 trabalhos para cada tipo de slot:

qsub -t 1:5 gpu_job.sh
qsub -t 1:5 normal_job.sh

Agora haveria 10 trabalhos na fila. Devido ao script definido, os cinco trabalhos com 'gpu' no nome seriam configurados automaticamente para serem executados apenas em nós de 'slot_type=gpu'. O mecanismo de dimensionamento automático do CycleCloud detectaria que há 5 trabalhos de "gpu" e 5 trabalhos de "execução". Como o nodearray "gpu" é definido como tendo 2 slots por nó, o CycleCloud iniciaria 3 desses nós (5/2=2,5 arredondado para 3).

Há 5 trabalhos normais, uma vez que o tipo de computador para o nodearray "execute" tem 4 CPUs cada, o CycleCloud iniciaria 2 desses nós para lidar com os trabalhos (5/4=1,25 arredondado até 2). Após um breve período de inicialização, os nós recém-iniciados inicializam e se configuram. Uma vez pronto, todos os 10 trabalhos são executados até a conclusão. Os cinco nós são desligados automaticamente antes que outro ciclo de cobrança comece com o provedor de nuvem.

Supõe-se que os trabalhos tenham uma duração de uma hora. Se o runtime do trabalho for conhecido, o algoritmo de dimensionamento automático poderá se beneficiar dessas informações. Informe o dimensionamento automático do tempo de execução do trabalho esperado adicionando-o ao contexto do trabalho. O exemplo a seguir define o runtime do trabalho para dimensionamento automático como 10 minutos:

qsub -ac average_runtime=10 job_with_duration_of_10m.sh

Referência de configuração do mecanismo de grade

Veja a seguir as opções de configuração específicas do Mecanismo de Grade que você pode alternar para personalizar a funcionalidade:

Opções de configuração do SGE-Specific Descrição
gridengine.slots O número de slots de um determinado nó a ser relatado ao Mecanismo de Grade. O número de slots é o número de trabalhos simultâneos que um nó pode executar; esse valor é, por padrão, igual ao número de CPUs em uma determinada máquina. Você pode substituir esse valor em casos em que não executa trabalhos com base na CPU, mas na memória, GPUs etc.
gridengine.slot_type O nome do tipo de "slot" que um nó oferece. O padrão é 'execute'. Quando um trabalho é marcado com o recurso rígido 'slot_type=', esse trabalho é executado apenas em um computador do mesmo tipo de slot. Essa marcação permite que você crie diferentes configurações de software e hardware por nó e verifique se um trabalho apropriado está sempre agendado no tipo correto de nó.
gridengine.ignore_fqdn Padrão: true. Defina como "falso" se os nós do seu cluster não fizerem parte de um único domínio DNS.
gridengine.version Padrão: "2011.11". Essa opção de configuração especifica a versão do Mecanismo de Grade a ser instalada e executada. Atualmente, é a opção padrão e a única disponível. Outras versões do software do Mecanismo de Grade podem ter suporte no futuro.
gridengine.root Padrão: "/sched/sge/sge-2011.11" Esse local é onde o Mecanismo de Grade instala e monta em cada nó no sistema. É melhor manter esse valor inalterado. No entanto, se você modificar, certifique-se de definir o mesmo valor em cada nó no cluster.

O CycleCloud oferece suporte a um conjunto padrão de atributos de parada automática entre os agendadores.

Atributo Descrição
cyclecloud.cluster.autoscale.stop_enabled O autostop está habilitado neste nó? [verdadeiro/falso]
cyclecloud.cluster.autoscale.tempo_ocioso_após_trabalhos A quantidade de tempo (em segundos) para um nó ficar ocioso depois de concluir trabalhos antes de ser reduzido.
cyclecloud.cluster.autoscale.tempo_ocioso_antes_dos_trabalhos A quantidade de tempo (em segundos) que um nó fica ocioso antes de completar tarefas para depois ser redimensionado para baixo.

Problemas conhecidos

  • qsh O comando para sessão interativa não funciona. Use qrsh como alternativa.
  • O dimensionamento automático não respeita o complexo exclusive=1, o que pode causar a inicialização de menos nós do que o esperado.

Observação

Embora o Windows seja uma plataforma GridEngine com suporte oficial, atualmente, o CycleCloud não dá suporte à execução do GridEngine no Windows.

Esta página diz respeito aos recursos e à configuração do uso do GridEngine (Altair) com o CycleCloud.

Configurando recursos

O aplicativo cyclecloud-gridengine relaciona os recursos do SGE aos recursos de nuvem do Azure para fornecer ferramentas avançadas de configuração de cluster e dimensionamento automático. O aplicativo é implantado automaticamente para clusters criados por meio da interface do usuário do CycleCloud ou pode ser instalado em qualquer host de administrador de gridengine em um cluster existente.

Instalando ou atualizando cyclecloud-gridengine

O pacote cyclecloud-gridengine está disponível no github como um artefato de versão. A instalação e a atualização seguem o mesmo processo. O aplicativo requer python3 com virtualenv.

tar xzf cyclecloud-gridengine-pkg-*.tar.gz
cd cyclecloud-gridengine
./install.sh

Arquivos importantes

O aplicativo analisa a configuração de sge sempre que é executado – trabalhos, filas, complexos. As informações são fornecidas no stderr e stdout do comando e em um arquivo de log, ambos em níveis configuráveis. Todos os comandos de gerenciamento de gridengine com argumentos também são registrados no arquivo.

Descrição Localização
Configuração de Dimensionamento Automático /opt/cycle/gridengine/autoscale.json
Log de Dimensionamento Automático /opt/cycle/jetpack/logs/autoscale.log
log de rastreamento qconf /opt/cycle/jetpack/logs/qcmd.log

Filas SGE, grupos de host e ambientes paralelos

O utilitário de dimensionamento automático, azge, cyclecloud-gridengine adiciona hosts ao cluster de acordo com a configuração do cluster. As operações de dimensionamento automático executam as ações a seguir.

  1. Ler a solicitação de recurso de trabalho e encontrar uma VM apropriada para iniciar
  2. Inicie a VM e aguarde até que ela esteja pronta
  3. Ler a fila e o ambiente paralelo do trabalho
  4. Com base na fila/pe, atribua o host a um grupo de host apropriado
  5. Adicionar o host ao cluster e a qualquer outra fila que contenha o grupo de host

Considere a seguinte definição de fila para uma fila chamada short.q

hostlist              @allhosts @mpihg01 @mpihg02 @lowprio 
...
seq_no                10000,[@lowprio=10],[@mpihg01=100],[@mpihg02=200]
pe_list               NONE,[@mpihg01=mpi01], \
                      [@mpihg02=mpi02]

O envio de um trabalho por qsub -q short.q -pe mpi02 12 my-script.sh inicia pelo menos uma VM. Quando o cluster é adicionado, ele se une ao grupo de anfitriões @mpihg02, pois esse é o grupo de anfitriões disponível tanto para a fila quanto para o ambiente paralelo. Ele também une @allhosts, um grupo de host especial.

Se você enviar um trabalho com qsub -q short.q my-script.sh e não especificar um ambiente paralelo pe, a VM resultante ingressará no @allhosts e @lowpriority grupos de host vinculados à fila que não está atribuída a nenhum pes.

Por fim, um trabalho enviado com qsub -q short.q -pe mpi0* 12 my-script.sh resulta em uma VM ser adicionada a @mpihg01 ou @mpihg02 dependendo das previsões de alocação do CycleCloud.

Ambientes paralelos equivalem implicitamente ao grupo de posicionamento de nuvem de ciclo. As VMs em um PE são restritas a estar dentro da mesma rede. Se você quiser usar um PE que não mantenha um grupo de posicionamento, use o autoscale.json para recusar.

Aqui, recusamos grupos de posicionamento para o make pe:

"gridengine": {
    "pes": {
      "make": {
        "requires_placement_groups": false
      }
    },

Grupos de Posicionamento do CycleCloud

Os grupos de posicionamento do CycleCloud mapeiam um para um para o VMSS do Azure com SinglePlacementGroup – as VMs em um grupo de posicionamento compartilham um Infiniband Fabric e compartilham apenas com VMs dentro do grupo de posicionamento. Para preservar intuitivamente esses silos, os grupos de posicionamento também mapeiam 1:1 com o ambiente paralelo de gridengine.

Especificar um ambiente paralelo para um trabalho restringe a execução do trabalho em um grupo de posicionamento por meio da lógica de atribuição de grupo de host inteligente. Você pode desabilitar esse comportamento por meio da configuração correspondente em autoscale.json: "required_placement_groups" : false.

Configuração de dimensionamento automático

Esse plug-in dimensiona automaticamente a grade para atender às demandas da carga de trabalho. O arquivo de configuração autoscale.json determina o comportamento do autoscaler do Grid Engine.

  • Definir os detalhes da conexão do cyclecloud
  • Definir o temporizador de terminação para nós ociosos
  • O dimensionamento automático multidimensional é possível, defina quais atributos usar no empacotamento de trabalho, por exemplo, slots, memória
  • Registrar as filas, os ambientes paralelos e os grupos de host a serem gerenciados
Configuração Tipo Descrição
URL fio CC URL
nome de usuário/senha fio Detalhes da conexão CC
nome_do_cluster fio Nome do cluster CC
recursos_padrão Mapa Vincular um recurso de nó a um recurso de host do Mecanismo de Grade para dimensionamento automático
idle_timeout Int Tempo de espera antes de encerrar nós ociosos (s)
boot_timeout Int Tempo de espera antes de encerrar nós durante fases de configuração longas (s)
gridengine.relevant_complexes Lista (Cadeia) Complexos do mecanismo de grade a serem considerados no dimensionamento automático, por exemplo, slots mem_free
gridengine.logging Arquivo Local do arquivo de configuração de log
gridengine.pes Estrutura Especificar o comportamento de PEs, por exemplo, requires_placement_group = false

O programa de dimensionamento automático considera apenas o Recurso Relevante

Outro recurso de dimensionamento automático

Por padrão, os trabalhos solicitam muitos slots e o cluster é dimensionado com base nessas solicitações.

Digamos que queremos dimensionar automaticamente pela solicitação de recurso de trabalho para m_mem_free.

  1. Adicionar m_mem_free ao gridengine.relevant_resourcesautoscale.json
  2. Vincular m_mem_free ao recurso de memória no nível do nó no autoscale.json

Esses atributos podem ser referenciados com node.* como o valor em _default/recursos.

Tipo Descrição
nodearray fio Nome da nodearray do cyclecloud
placement_group fio Nome do grupo de posicionamento do cyclecloud em um nodearray
vm_size fio Nome do produto da VM, por exemplo, "Standard_F2s_v2"
vcpu_count Int CPUs virtuais disponíveis no nó, conforme indicado em páginas de produtos individuais
pcpu_count Int CPUs físicas disponíveis no nó
memória fio Memória física aproximada disponível na VM com indicador de unidade, por exemplo, "8,0g"

Outros atributos estão no node.resources.* namespace, por exemplo, 'node.resources.

Tipo Descrição
ncpus fio Número de CPUs disponíveis na VM
pcpus fio Número de CPUs físicas disponíveis na VM
ngpus Número Inteiro Número de GPUs disponíveis na VM
memb fio Memória física aproximada disponível na VM com indicador de unidade, por exemplo, "8,0b"
memkb fio Memória física aproximada disponível na VM com indicador de unidade, por exemplo, "8,0k"
memmb fio Memória física aproximada disponível na VM com indicador de unidade, por exemplo, "8,0m"
memgb fio Memória física aproximada disponível na VM com indicador de unidade, por exemplo, "8,0g"
memtb fio Memória física aproximada disponível na VM com indicador de unidade, por exemplo, "8.0t"
Slots Número Inteiro O mesmo que ncpus
slot_type fio Rótulo de adição para extensões. Não usado.
m_mem_free fio Memória gratuita esperada no host de execução, por exemplo, "3,0g"
mfree fio O mesmo que _m/_mem/gratuito

Mapeamento de recursos

Também há matemática disponível para o default_resources – reduza os slots em uma matriz de nó específica em dois e adicione o recurso do docker a todos os nós:

    "default_resources": [
    {
      "select": {"node.nodearray": "beegfs"},
      "name": "slots",
      "value": "node.vcpu_count",
      "subtract": 2
    },
    {
      "select": {},
      "name": "docker",
      "value": true
    },

O mapeamento das vCPUs do nó para os slots é complexo, e memmb a mem_free são padrões comumente usados. A primeira associação é obrigatória.

    "default_resources": [
    {
      "select": {},
      "name": "slots",
      "value": "node.vcpu_count"
    },
    {
      "select": {},
      "name": "mem_free",
      "value": "node.resources.memmb"
    }
 ],

Se um complexo tiver um atalho que não seja igual ao valor inteiro, defina ambos em default_resources onde physical_cpu está o nome complexo:

"default_resources": [
    {
      "select": {},
      "name": "physical_cpu",
      "value": "node.pcpu_count"
    },
    {
      "select": {},
      "name": "pcpu",
      "value": "node.resources.physical_cpu"
    }
]

A ordenação é importante quando você deseja um comportamento específico para um atributo específico. Para alocar um único slot para uma nodearray específica, mantendo a contagem de slots padrão para todas as outras nodearrays:

    "default_resources": [
    {
      "select": {"node.nodearray": "FPGA"},
      "name": "slots",
      "value": "1",
    },
    {
      "select": {},
      "name": "slots",
      "value": "node.vcpu_count"
    },
]

Grupos de host

O dimensionador automático do CycleCloud, ao tentar atender os requisitos de trabalho, mapeia os nós para o grupo de hospedagem apropriado. Filas, ambientes paralelos e complexos são considerados. Grande parte da lógica está correspondendo ao bucket de nuvem de ciclo apropriado (e quantidade de nó) com o grupo de host sge apropriado.

Para um trabalho enviado como: qsub -q "cloud.q" -l "m_mem_free=4g" -pe "mpi*" 48 ./myjob.sh

O CycleCloud localiza obter a interseção de grupos de host que:

  1. São incluídos no pe_list para cloud.q e correspondem ao nome pe, por exemplo, pe_list [@allhosts=mpislots],[@hpc1=mpi].
  2. Tenha recursos adequados e cota de assinatura para fornecer todos os recursos de trabalho.
  3. A configuração de restrições do grupo de host não as filtra.

Vários grupos de host podem atender a esses requisitos. Quando isso acontece, o sistema deve decidir qual deles usar. Há três maneiras de resolver conflitos de associação do grupo de host:

  1. Configure as filas para evitar ambiguidades.
  2. Adicionar restrições a autoscale.json.
  3. Permita que o CycleCloud escolha os grupos de host correspondentes de forma ordenada por nome ajustando weight_queue_host_sort < weight_queue_seqno na configuração do agendador.
  4. Defina seq_no 10000,[@hostgroup1=100],[@hostgroup2=200] na configuração da fila para indicar uma preferência de grupo de host.

Restrições de grupo de host

Quando uma fila ou xproject define vários grupos de host, qualquer um desses grupos pode receber novos hosts. Para controlar quais hosts são qualificados para quais filas, você pode aplicar restrições de grupo de host com base nas propriedades do nó.

"gridengine": {
    "hostgroups": {
      "@mpi": {
        "constraints": {
          "node.vm_size": "Standard_H44rs"
        }
      },
      "@amd-mem": {
        "constraints" : { 
            "node.vm_size": "Standard_D2_v3",
            "node.nodearray": "hpc" 
            }
        },
    }
  }

DICA: inspecione todas as propriedades de nó disponíveis por azge buckets.

azge

Esse pacote vem com uma linha de comando, azge. Este programa é usado para executar o dimensionamento automático e interrompe todos os subprocessos em dimensionamento automático em componentes separados. Esses comandos dependem das variáveis de ambiente de gridengine a serem definidas– você deve ser capaz de chamar qconf e qsub do mesmo perfil em que azge é chamado.

comandos azge Descrição
validar Verifica se há erros de configuração conhecidos no escalador automático ou no GridEngine
Empregos Mostra todos os trabalhos na fila
Baldes Mostra os pools de recursos disponíveis para dimensionamento automático
Nós Mostra os hosts e propriedades do cluster
demanda Alinha os requisitos de trabalho aos buckets do CycleCloud e fornece o resultado do dimensionamento automático
escalonamento automático Faz dimensionamento automático completo, iniciando e removendo nós de acordo com as configurações

Ao modificar configurações do agendador (qconf) ou configurações de dimensionamento automático (autoscale.json) ou até mesmo configurar pela primeira vez, o azge pode ser usado para verificar se o comportamento de dimensionamento automático corresponde às expectativas. Como usuário root, você pode executar as seguintes operações. Para entender como o dimensionamento automático funciona, é importante se familiarizar com esses conceitos.

  1. Execute azge validate para verificar as configurações de problemas conhecidos.
  2. Execute azge buckets para verificar os recursos oferecidos pelo cluster CycleCloud.
  3. Execute azge jobs para inspecionar os detalhes do trabalho na fila.
  4. Execute azge demand o trabalho para correspondência de bucket. Em seguida, examine quais trabalhos são correspondidos a quais buckets e grupos de host.
  5. Execute azge autoscale para iniciar o processo de alocação de nó ou adicione nós que estão prontos para ingressar.

Depois que os comandos estiverem funcionando conforme o esperado, habilite o dimensionamento automático contínuo adicionando o azge autoscale comando ao crontab raiz. Certifique-se de obter as variáveis de ambiente de gridengine com antecedência.

* * * * * . $SGE_ROOT/common/settings.sh && /usr/local/bin/azge autoscale -c /opt/cycle/gridengine/autoscale.json

Criando um cluster híbrido

O CycleCloud dá suporte ao cenário de intermitência de nuvem. A configuração base pressupõe que o $SGE_ROOT diretório está disponível para os nós de nuvem. Essa suposição pode ser relaxada definindo gridengine.shared.spool = falsegridengine.shared.bin = falsee instalando o GridEngine localmente.

Para um caso simples, você deve fornecer um sistema de arquivos que os nós de execução possam montar. Esse sistema de arquivos deve incluir o... e você configura a montagem nas configurações opcionais. Quando as dependências dos diretórios sched e compartilhado são liberadas, você pode desligar o nó do agendador que faz parte do cluster por padrão e usar as configurações do sistema de arquivos externo.

  1. Crie um novo cluster de gridengine.
  2. Desabilite o proxy de retorno.
  3. Substitua /sched e /shared por sistemas de arquivos externos.
  4. Salve o cluster.
  5. Remova o nó do agendador como uma ação na interface do usuário.
  6. Inicialmente, inicie o cluster, sem nós.
  7. Configurar cyclecloud-gridengine com autoscale.json para usar o novo cluster

Usando o Univa Grid Engine no CycleCloud

O projeto CycleCloud para GridEngine usa sge-2011.11 por padrão. Você pode usar seus próprios instaladores do Altair GridEngine de acordo com seu contrato de licença Altair. Esta seção documenta como usar Altair GridEngine com o projeto CycleCloud GridEngine.

Pré-requisitos

Este exemplo usa a versão de demonstração 8.6.1, mas todas as versões > ge 8.4.0 têm suporte.

  1. Os usuários devem fornecer os binários do UGE
  • ge-8.6.x-bin-lx-amd64.tar.gz
  • ge-8.6.x-common.tar.gz
  1. A CLI do CycleCloud deve ser configurada. A documentação está disponível aqui

Copiar os binários para o cofre de nuvem

Uma versão complementar do AGE (8.6.7-demo) é distribuída com o CycleCloud. Para usar outra versão, carregue os binários na conta de armazenamento que o CycleCloud usa.


$ azcopy cp ge-8.6.12-bin-lx-amd64.tar.gz https://<storage-account-name>.blob.core.windows.net/cyclecloud/gridengine/blobs/
$ azcopy cp ge-8.6.12-common.tar.gz https://<storage-account-name>.blob.core.windows.net/cyclecloud/gridengine/blobs/

Modificando configurações no modelo de cluster

Faça uma cópia local do modelo de gridengine e modifique-o para usar os instaladores UGE em vez do padrão.

wget https://raw.githubusercontent.com/Azure/cyclecloud-gridengine/master/templates/gridengine.txt

No arquivo gridengine.txt, localize a primeira ocorrência de [[[configuration]]] e insira um texto que corresponda ao trecho a seguir. O arquivo não é sensível à indentação.

Observação

Os detalhes na configuração, particularmente a versão, devem corresponder ao nome do arquivo do instalador.

[[[configuration gridengine]]]
    make = ge
    version = 8.6.12-demo
    root = /sched/ge/ge-8.6.12-demo
    cell = "default"
    sge_qmaster_port = "537"
    sge_execd_port = "538"
    sge_cluster_name = "grid1"
    gid_range = "20000-20100"
    qmaster_spool_dir = "/sched/ge/ge-8.6.12-demo/default/spool/qmaster" 
    execd_spool_dir = "/sched/ge/ge-8.6.12-demo/default/spool"
    spooling_method = "berkeleydb"
    shadow_host = ""
    admin_mail = ""
    idle_timeout = 300

    managed_fs = true
    shared.bin = true

    ignore_fqdn = true
    group.name = "sgeadmin"
    group.gid = 536
    user.name = "sgeadmin"
    user.uid = 536
    user.gid = 536
    user.description = "SGE admin user"
    user.home = "/shared/home/sgeadmin"
    user.shell = "/bin/bash"

Essas configurações de gridengine substituem a versão padrão do gridengine e o local de instalação quando o cluster é iniciado. Não é seguro sair de /sched, pois ele é um local nfs compartilhado no cluster.