Como instalar aplicativos em um cluster Slurm no Compute Engine

Neste tutorial, mostramos como instalar um aplicativo em um cluster Slurm no Google Cloud para que o aplicativo esteja disponível em todo o cluster, mesmo quando o cluster for escalonado automaticamente (links em inglês). Um aplicativo pode ser empacotado como um arquivo .tar ou como RPM (em inglês). No tutorial, mostramos como instalar aplicativos usando cada tipo de arquivo. Neste tutorial, também mostramos como usar um script para instalar diferentes versões do Python.

Neste documento, os administradores de clusters do Slurm precisam ter um conhecimento básico sobre os seguintes tópicos:

• Administração do sistema Linux
• Uso da linha de comando
• Slurm

Neste tutorial, você instalará várias versões do mesmo aplicativo e criará modulefiles para usar as diferentes versões do aplicativo em jobs distintos. Existem muitos casos de uso para instalar várias versões:

• Resultados de teste que foram conseguidos com uma versão ou outra.
• Use código que exija uma versão específica de um aplicativo.

Neste documento, também mostramos como usar módulos de ambiente (em inglês) para que qualquer job em execução no cluster possa acessar o aplicativo. Você usa um cluster Slurm para executar jobs em lote ou jobs de computação paralelos.

O diagrama a seguir ilustra a estrutura de um cluster do Slurm implantado no Google Cloud.

Para agendar jobs nos nós de computação do Compute Engine, efetue login no nó de login, também conhecido como nó principal. Jobs programados são executados em um ou mais nós de computação. Os nós de computação podem ser estáticos (sempre on-line) ou efêmeros, criados em resposta a jobs programados e destruídos posteriormente.

Ao instalar aplicativos em clusters, sua instalação precisa atender aos seguintes requisitos:

• As instalações de software estão disponíveis nos dois tipos de nós.
• Várias versões da mesma ferramenta ou biblioteca estão disponíveis simultaneamente.
• Diferentes versões do software estão disponíveis no cluster.

Para atender a esses requisitos, instale pacotes de software no servidor NFS do cluster.

Objetivos

• Entender os aplicativos montados em NFS e diretórios iniciais em um cluster do Slurm no Google Cloud
• Instalar o software no diretório de aplicativos montados em NFS.
• Configure um modulefile de ambiente para pacotes de software instalados recentemente.
• Instale versões diferentes do Python

Custos

Neste tutorial, usamos os seguintes componentes faturáveis do Google Cloud:

• Compute Engine

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir este tutorial, exclua os recursos criados para evitar o faturamento contínuo. Para mais informações, consulte Limpeza.

Antes de começar

1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como verificar se o faturamento está ativado em um projeto.

4. Ative a API Compute Engine.

   Ative a API

5. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

6. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como verificar se o faturamento está ativado em um projeto.

7. Ative a API Compute Engine.

   Ative a API

8. No Console do Google Cloud, ative o Cloud Shell.

   Ativar o Cloud Shell

   Na parte inferior do Console do Google Cloud, uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

9. Para seguir este tutorial, é necessário criar ou ter acesso a um cluster do Slurm no Google Cloud. Aprenda a implantar um cluster do Slurm no Google Cloud.

Como instalar aplicativos

Todo cluster do Slurm no Google Cloud inclui um servidor NFS que exporta montagens para os diretórios /apps e /home. Dependendo da implantação, o servidor NFS pode ser executado nestes locais:

• Nó do controlador do cluster
• Instância do Filestore
• Cluster do Google Cloud Elastifile
• Seu servidor NFS local

As montagens /apps e /home estão disponíveis em cada nó no cluster independentemente de onde o servidor NFS esteja sendo executado.

Depois que você implanta o cluster, o diretório /apps em um cluster do Slurm no Google Cloud contém os dois diretórios a seguir:

• /apps/modulefiles: contém os arquivos em que serão alteradas ou definidas as variáveis de ambiente.
• /apps/slurm: contém todos os arquivos e diretórios associados ao aplicativo de gerenciamento de carga de trabalho do Slurm.

Instalar arquivos tar no diretório de aplicativos

As etapas a seguir mostram como instalar um aplicativo empacotado como um arquivo tar. Neste exemplo, você instala o compilador e o ambiente de execução da linguagem de programação Julia.

1. No Cloud Shell, faça login no nó de login do cluster usando SSH. Substitua cluster-name pelo nome do cluster.

   gcloud compute ssh cluster-name-login0
   sudo -i
   

2. Crie um diretório /julia no diretório /apps:

   mkdir /apps/julia
   

3. Instale a versão mais recente de Julia:

   wget https://julialang-s3.julialang.org/bin/linux/x64/1.3/julia-1.3.1-linux-x86_64.tar.gz
   mv julia-1.3.1-linux-x86_64.tar.gz /apps/julia
   cd /apps/julia
   tar zxf julia-1.3.1-linux-x86_64.tar.gz
   rm julia-1.3.1-linux-x86_64.tar.gz
   mv julia-1.3.1 1.3.1
   

4. Instale a versão com suporte de longo prazo (LTS, na sigla em inglês) de Julia no diretório /apps/julia:

   cd
   wget https://julialang-s3.julialang.org/bin/linux/x64/1.0/julia-1.0.5-linux-x86_64.tar.gz
   mv julia-1.0.5-linux-x86_64.tar.gz /apps/julia
   cd /apps/julia
   tar zxf julia-1.0.5-linux-x86_64.tar.gz
   rm julia-1.0.5-linux-x86_64.tar.gz
   mv julia-1.0.5 1.0.5
   

   Agora há duas versões de Julia instaladas.

Instalar RPMs no diretório de aplicativos

Nas etapas a seguir, mostramos como instalar um aplicativo empacotado como RPM. Neste exemplo, você instala o ambiente de execução de contêiner Singularity.

1. No Cloud Shell, faça login no nó de login do cluster usando SSH:

   gcloud compute ssh cluster-name-login0
   sudo -i
   

2. Crie um diretório /singularity no diretório /apps:

   mkdir /apps/singularity
   

3. Crie um diretório para a versão 3.5.3-1.1 de Singularity:

   mkdir /apps/singularity/3.5.3-1.1
   

4. Acesse o Singularity 3.5.3-1.1 RPM e desempacote-o:

   wget http://rpmfind.net/linux/opensuse/tumbleweed/repo/oss/x86_64/singularity-3.5.3-1.1.x86_64.rpm
   rpm2cpio singularity-3.5.3-1.1.x86_64.rpm | cpio -idmv
   rm singularity-3.5.3-1.1.x86_64.rpm
   

Como usar módulos de ambiente

O pacote Environment Modules (em inglês) simplifica a inicialização e o gerenciamento do ambiente shell quando você executa um job do Slurm. Você cria modulefiles que alteram ou definem variáveis de ambiente shell, por exemplo, PATH ou MANPATH. Todos os shells conhecidos são compatíveis, bem como algumas linguagens de script, incluindo Perl, Python e Ruby.

Use o comando module para trabalhar com o pacote Environment Modules. A variável de ambiente MODULEPATH informa ao comando module onde procurar modulefiles no sistema. Em um cluster do Slurm no Google Cloud, a variável de ambiente MODULEPATH especifica os três diretórios a seguir:

• /usr/share/Modules/modulefiles contém os modulefiles que fazem parte da distribuição do pacote Environment Modules.
• /etc/modulefiles contém o arquivo do módulo openmpi-x86_64.
• /apps/modulefiles contém os modulefiles de todos os aplicativos que você instala no cluster.

Você decide como organizar os modulefiles dos aplicativos instalados no diretório /apps/modulefiles. Recomendamos que você crie um diretório para cada aplicativo que instalar no /apps/modulefiles, e, em seguida, crie um modulefile para cada versão do aplicativo no diretório específico do aplicativo.

Criar um modulefile simples

Os modulefiles são escritos na Tool Command Language (Tcl) (em inglês) e interpretados pelo programa Tcl modulecmd.tcl por meio da interface do usuário do módulo. Usando Tcl, você permite que os modulefiles manipulem configurações complexas, mas a maioria das modulefiles é relativamente simples.

1. No Cloud Shell, faça login no nó de login do cluster usando SSH:

   gcloud compute ssh cluster-name-login0
   sudo -i
   

2. Crie o arquivo /apps/modulefiles/julia/1.0.5.

3. Em um editor de texto, abra o arquivo 1.0.5 e cole este código:

   #%Module1.0#####################################################################
   ##
   ## modules julia/1.0.5.
   ##
   ## modulefiles/julia/1.0.5.
   ##
   proc ModulesHelp { } {
           global version modroot
           puts stderr "julia/1.0.5 - sets the environment for Julia 1.0.5"
   }
   module-whatis   "Sets the environment for using Julia 1.0.5"
   # for Tcl script use only
   set     topdir          /apps/julia/1.0.5
   set     version         1.0.5
   set     sys             linux86
   prepend-path    PATH            $topdir/bin
   prepend-path    MANPATH         $topdir/man
   

   Considere estes aspectos no código:

   • A primeira linha é um cookie mágico (em inglês) que indica a versão mínima do programa Tcl modulecmd.tcl necessária para interpretar o modulefile.
   • O procedimento ModulesHelp é chamado pelo comando module help para fornecer mais informações sobre um modulefile.
   • O comando module-whatis define uma string exibida em resposta ao comando module-whatis.
   • Os comandos set criam vinculações de variáveis Tcl entre o primeiro argumento e o segundo.
   • O prepend-path modifica a variável de ambiente referenciada no primeiro argumento anexando o valor especificado no segundo argumento.

   Para mais informações, consulte a documentação do modulefile (em inglês).

Como instalar versões do Python

Este passo é opcional. Siga estas etapas se os aplicativos em execução no cluster exigirem versões personalizadas do Python ou versões complexas da biblioteca.

Execute o script a seguir para instalar uma versão do Python usando a ferramenta virtualenv (em inglês). Esse script cria uma entrada de módulo chamada python2. É possível modificar o script para atender às necessidades personalizadas de sua configuração. Quando você usa virtualenv, o arquivo executável do Python e todas as bibliotecas são instaladas no diretório virtualenv. Essa configuração permite congelar um binário e uma coleção distintos de bibliotecas para um aplicativo específico.

Em vez de editar diretamente um módulo, crie o seguinte script bash.

1. No Cloud Shell, faça login no nó de login do cluster usando SSH:

   gcloud compute ssh cluster-name-login0
   

2. Instale o pip (em inglês):

   curl https://bootstrap.pypa.io/get-pip.py | python -
   

3. Instale os pacotes virtualenv, absl-py, e google-cloud-storage (em inglês):

   pip install virtualenv
   cd /apps
   virtualenv python2
   source ./python2/bin/activate
   pip install absl-py
   pip install google-cloud-storage
   

4. Crie o modulefile /apps/modulefiles/python2:

   cat > /apps/modulefiles/python2 << "PYTHONEND"
   #%Module1.0#####################################################################
   ##
   ## python2 for Google modulefile
   ##
   proc ModulesHelp { } {
          global version modroot
   
          puts stderr "\n\tThis adds $modroot/* to several of the"
          puts stderr "\tenvironment variables."
          puts stderr "\n\tVersion $version\n"
   }
   
   module-whatis    "Runs Virtualenv for python. Included Google Cloud Storage.";
   
   # for Tcl script use only
   set    version        000
   set    modroot        /apps/python2
   
   if {[module-info mode] == "load"} {
      puts stdout "source /apps/python2/bin/activate;"
   } elseif {[module-info mode] == "remove"} {
      puts stdout "deactivate;"
   }
   
   PYTHONEND
   

5. Adicione o módulo python2 ao seu ambiente:

   module load python2
   

   O job Slurm agora pode usar o Python 2.x.

Limpeza

A maneira mais fácil de eliminar o faturamento é excluir o projeto do Cloud criado para o tutorial. A outra opção é excluir os recursos individuais.

Exclua o projeto

Cuidado: excluir um projeto tem os seguintes efeitos:
• Tudo no projeto é excluído. Se você tiver usado um projeto atual para seguir este tutorial, a exclusão dele incluirá quaisquer outras ações feitas no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.
1. No Console do Google Cloud, acesse a página Gerenciar recursos.

   Acessar "Gerenciar recursos"

2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

A seguir

• Explore arquiteturas de referência, diagramas, tutoriais e práticas recomendadas sobre o Google Cloud. Confira o Centro de arquitetura do Cloud.