Utilizando o cluster do ParGO para rodar experimentos

Porvictoitor

Apresentamos aqui o cluster do ParGO, com foco no seu uso para rodar experimentos computacionais. No que segue, assumimos que você está logado na instância bastion por ssh. Caso ainda não tenha acesso à bastion, por favor entre em contato para obter acesso.

O software que utilizamos para coordenar o uso do cluster é o incus. Usamos o incus por algumas facilidades que ele fornece, mas é importante mencionar que ele não é feito especificamente para rodar experimentos como rodamos. Digo isto no sentido de que é possível um usuário mal intencionado atrapalhar o uso de experimentos de outros usuários. Esperamos que o uso seja feito de forma respeitosa para evitar problemas.

O incus é utilizado para rodar máquinas virtuais ou contêineres. O cluster do ParGO roda exclusivamente contêineres para rodar experimentos, dado que estes são bem leves em recursos, praticamente equivalente a rodar diretamente na máquina. O seu uso serve para isolar os experimentos de forma que os pacotes e serviços instalados por um usuário não afetem o experimento de outro. O termo utilizado para se referir a contêiner específico será de uma instância, termo utilizado no incus para se referir a contêineres ou a máquinas virtuais.

Além disto, saibam que estou disponível para ajudar quem tiver dificuldades e para conversar sobre o seu uso. Vejam este projeto como uma construção coletiva em que o diálogo deve levar à sua melhoria.

Obs: O resultado dos comandos para listar máquinas, projetos ou instâncias que aparecem abaixo tem colunas limitadas para facilitar a apresentação. Caso rodem comandos que contenham list, o resultado pode variar com o que é apresentado aqui.

Normas de boa convivência

  • Não mexa em instâncias de outro usuário sem permissão
  • Ao terminar seu experimento, apague ou mova sua instância ao projeto auxiliar para liberar a máquina
  • Não coloque experimento para rodar na mesma máquina que outro usuário também esteja rodando experimento
  • Não tente burlar os limites de uso de núcleos e de memória RAM das máquinas
  • Adicione seu nome ao nome das suas instâncias para facilitar a identificação do responsável

Obter acesso ao cluster

Para obter acesso ao cluster, você deve me enviar os seguintes dados para a criação do seu usuário.

  • Nome completo
  • Orientador (caso não seja professor do ParGO)
  • Nome de usuário
  • Chave pública ssh

Caso não tenha uma chave ssh, ela pode ser gerada com o seguinte comando:

ssh-keygen -t ed25519

Lembre-se de passar apenas a chave pública. A chave privada não deve ser passada para mais ninguém.

Uma vez que seu usuário for criado, você receberá informações sobre a instância bastion, utilizada para controlar o cluster. As informações que você receberá são o IP do bastion junto com a porta de conexão ssh. Você pode se conectar por ssh com seguinte comando.

ssh <usuário>@<IP bastion> -i <arquivo chave privada> -p <porta bastion>

Uma forma alternativa mais fácil de se conectar consiste em adicionar ao arquivo ~/.ssh/config a seguinte configuração.

Host	bastion
	HostName			<IP bastion>
	User					<usuário>
	Port					<porta bastion>
	IdentityFile	<arquivo chave privada>

Em seguida, você pode se conectar com um comando mais simples.

ssh bastion

Visão geral

Atualmente temos 2 tipos de máquinas, com processador Amd 5700g que possui 8 núcleos (16 threads) e com processador Intel 12700 que possui 8 núcleos (16 threads) de performance e 4 núcleos mais lentos de eficiência. Cada máquina tem 4 threads em núcleos dedicados para rodar serviço e deixar instâncias em montagem ou paradas. Assim, as instâncias nas máquinas Amd são restritas a 6 núcleos e 12 threads enquanto as instâncias nas máquinas Intel são restritas a 8 núcleos (performance) e 16 threads. Todos estes núcleos são dedicados e cada máquina tem 24GB dedicado para rodar experimentos.

Máquinas

É possível listar as máquinas atualmente no cluster usando:

incus cluster list

Rodando este comando, o mais importante é saber quais máquinas estão disponíveis e em que situação elas se encontram.

victoitor@bastion:~$ incus cluster list
+---------+--------------+--------+-------------------+
|  NAME   | ARCHITECTURE | STATUS |      MESSAGE      |
+---------+--------------+--------+-------------------+
| amd01   | x86_64       | ONLINE | Fully operational |
+---------+--------------+--------+-------------------+
| amd02   | x86_64       | ONLINE | Fully operational |
+---------+--------------+--------+-------------------+
| amd03   | x86_64       | ONLINE | Fully operational |
+---------+--------------+--------+-------------------+
| amd04   | x86_64       | ONLINE | Fully operational |
+---------+--------------+--------+-------------------+
| intel01 | x86_64       | ONLINE | Fully operational |
+---------+--------------+--------+-------------------+
| intel02 | x86_64       | ONLINE | Fully operational |
+---------+--------------+--------+-------------------+
| intel03 | x86_64       | ONLINE | Fully operational |
+---------+--------------+--------+-------------------+

Projetos

Utilizamos projetos para separar experimentos em máquinas de tipos diferentes e para salvar instâncias que não estão rodando no momento. Os projetos amd-5700g e intel-12700 servem para rodar experimentos. Temos um projeto auxiliar para preparar sua instância antes de rodar ou para deixar instâncias paradas sem rodar. A ideia é que experimentos de pessoas diferentes rodem em máquinas diferentes e que todo experimento tenha núcleos de processamento e memória dedicada.

Com este comando, podemos listar todos os projetos e saber qual o projeto atual:

incus project list

Os comandos que rodamos são realizados no projeto atual e podemos mudar o projeto atual utilizando:

incus project switch <projeto>

O uso destes comandos pode ser visto a seguir.

victoitor@bastion:~$ incus project list
+--------------------+-------------------------------------+
|        NAME        |             DESCRIPTION             |
+--------------------+-------------------------------------+
| amd-5700g          | Experimentos - máquinas amd-5700g   |
+--------------------+-------------------------------------+
| auxiliar (current) | Montagem e estacionamento           |
+--------------------+-------------------------------------+
| intel-12700        | Experimentos - máquinas intel-12700 |
+--------------------+-------------------------------------+
victoitor@bastion:~$ incus project switch intel-12700
victoitor@bastion:~$ incus project list
+-----------------------+-------------------------------------+
|         NAME          |             DESCRIPTION             |
+-----------------------+-------------------------------------+
| amd-5700g             | Experimentos - máquinas amd-5700g   |
+-----------------------+-------------------------------------+
| auxiliar              | Montagem e estacionamento           |
+-----------------------+-------------------------------------+
| intel-12700 (current) | Experimentos - máquinas intel-12700 |
+-----------------------+-------------------------------------+

Para rodar comandos em outro projeto, basta adicionar --project <projeto> ao seu comando.

Instâncias

As instâncias do projeto atual podem ser listadas usando:

incus list

As instâncias de todos os projetos podem ser listadas usando:

incus list --all-projects

As colunas mais relevantes são o nome da instância, o seu estado e o local onde ela está rodando. Os locais são as máquinas listadas com incus cluster list. Nos comandos abaixo, o projeto atual é o auxiliar.

victoitor@bastion:~$ incus list --project intel-12700
+------------------------+---------+----------+
|          NAME          |  STATE  | LOCATION |
+------------------------+---------+----------+
| israel-qsort-dedicado1 | RUNNING | intel03  |
+------------------------+---------+----------+
| pedrojorge-PAPCMC      | RUNNING | intel02  |
+------------------------+---------+----------+
victoitor@bastion:~$ incus list --project amd-5700g
+-----------------------------+---------+----------+
|            NAME             |  STATE  | LOCATION |
+-----------------------------+---------+----------+
| israel-qsort-compartilhado1 | STOPPED | amd01    |
+-----------------------------+---------+----------+
victoitor@bastion:~$ incus list
+-----------------------+---------+----------+
|         NAME          |  STATE  | LOCATION |
+-----------------------+---------+----------+
| heron-npb-mz-00       | STOPPED | amd02    |
+-----------------------+---------+----------+
| israel-qsort          | STOPPED | amd02    |
+-----------------------+---------+----------+
| rodrigo-experimento   | STOPPED | amd03    |
+-----------------------+---------+----------+
victoitor@bastion:~$ incus list --all-projects
+-------------+-----------------------------+---------+----------+
|   PROJECT   |            NAME             |  STATE  | LOCATION |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | israel-qsort-compartilhado1 | STOPPED | amd01    |
+-------------+-----------------------------+---------+----------+
| auxiliar    | heron-npb-mz-00             | STOPPED | amd02    |
+-------------+-----------------------------+---------+----------+
| auxiliar    | israel-qsort                | STOPPED | amd02    |
+-------------+-----------------------------+---------+----------+
| auxiliar    | rodrigo-experimento         | STOPPED | amd03    |
+-------------+-----------------------------+---------+----------+
| intel-12700 | israel-qsort-dedicado1      | RUNNING | intel03  |
+-------------+-----------------------------+---------+----------+
| intel-12700 | pedrojorge-PAPCMC           | RUNNING | intel02  |
+-------------+-----------------------------+---------+----------+

Rodar experimentos

Para rodar um experimento, você deve criar a sua instância e depois prepará-la para rodar seu experimento. Para isto, você pode instalar pacotes, copiar seu código/programa para a instância e colocá-lo para rodar. Uma observação importante é que toda instância nos projetos de experimentos ocupam a máquina, de forma que outras pessoas não podem rodar seus experimentos lá.

Caso a preparação da sua instância seja rápida, você pode fazer isto diretamente na máquina de experimentos para simplificar. Caso contrário, recomendamos que a montagem seja feita no projeto auxiliar. Quando estiver pronta para rodar, você pode copiá-la para algum projeto de experimentos. Observe que uma instância dentro de projeto de experimentos ocupa a máquina. Então caso sua instância não esteja rodando algum experimento, você pode apagá-la ou movê-la para o projeto auxiliar, caso ainda seja necessária depois.

Criar instância

Para criar uma instância, você precisa passar a distribuição linux, o nome da instância e quem é responsável pela instância.

incus launch images:<distribuição> <instância> -c user.responsavel="<Nome Sobrenome>"

Caso esteja em um projeto de experimentos, ela será alocada para não ter conflito com outras instâncias já criadas.

victoitor@bastion:~$ incus launch images:debian/12 d1 -c user.responsavel="Victor Campos"
Launching d1
victoitor@bastion:~$ incus launch images:ubuntu/24.04 u1 -c user.responsavel="Victor Campos"
Launching u1
victoitor@bastion:~$ incus launch images:opensuse/tumbleweed o1 -c user.responsavel="Victor Campos"
Launching o1
victoitor@bastion:~$ incus launch images:fedora/40 f1 -c user.responsavel="Victor Campos"
Launching f1
Error: Failed instance creation: Failed instance placement scriptlet: Failed to run: fail: Não há máquina válida disponível.
victoitor@bastion:~$ incus list
+-----------------------------+---------+----------+
|            NAME             |  STATE  | LOCATION |
+-----------------------------+---------+----------+
| d1                          | RUNNING | amd02    |
+-----------------------------+---------+----------+
| israel-qsort-compartilhado1 | STOPPED | amd01    |
+-----------------------------+---------+----------+
| o1                          | RUNNING | amd04    |
+-----------------------------+---------+----------+
| u1                          | RUNNING | amd03    |
+-----------------------------+---------+----------+

Observe que, quando não há máquina disponível, a instância não será criada.

Executar comandos dentro da instância

Você pode rodar um comando como root dentro da instância utilizando:

incus exec <instância> -- <comando>

No caso, o comando mais comum seria para rodar bash e abrir um terminal dentro da instância. O comando incus exec <instância> -- bash tem uma forma abreviada usando:

incus shell <instância>

Os comandos dentro da instância são executados como root, então você pode rodar e instalar o que quiser. Como a sua instância é isolada das outras, não tem problema rodar tudo como root, mas você pode utilizar um usuário não root também, se quiser.

victoitor@bastion:~$ incus launch images:debian/12 d1 -c user.responsavel="Victor Campos"
Launching d1
victoitor@bastion:~$ incus shell d1
root@d1:~# apt update && apt install htop
Hit:1 http://deb.debian.org/debian bookworm InRelease
Get:2 http://deb.debian.org/debian bookworm-updates InRelease [55.4 kB]
Get:3 http://deb.debian.org/debian-security bookworm-security InRelease [48.0 kB]
Fetched 103 kB in 11s (9,155 B/s)
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
All packages are up to date.
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
The following additional packages will be installed:
  libnl-3-200 libnl-genl-3-200
Suggested packages:
  lm-sensors lsof strace
The following NEW packages will be installed:
  htop libnl-3-200 libnl-genl-3-200
0 upgraded, 3 newly installed, 0 to remove and 0 not upgraded.
Need to get 237 kB of archives.
After this operation, 633 kB of additional disk space will be used.
Do you want to continue? [Y/n] 
Get:1 http://deb.debian.org/debian bookworm/main amd64 libnl-3-200 amd64 3.7.0-0.2+b1 [63.1 kB]
Get:2 http://deb.debian.org/debian bookworm/main amd64 libnl-genl-3-200 amd64 3.7.0-0.2+b1 [21.6 kB]
Get:3 http://deb.debian.org/debian bookworm/main amd64 htop amd64 3.2.2-2 [152 kB]
Fetched 237 kB in 0s (4,027 kB/s)
debconf: delaying package configuration, since apt-utils is not installed
Selecting previously unselected package libnl-3-200:amd64.
(Reading database ... 11527 files and directories currently installed.)
Preparing to unpack .../libnl-3-200_3.7.0-0.2+b1_amd64.deb ...
Unpacking libnl-3-200:amd64 (3.7.0-0.2+b1) ...
Selecting previously unselected package libnl-genl-3-200:amd64.
Preparing to unpack .../libnl-genl-3-200_3.7.0-0.2+b1_amd64.deb ...
Unpacking libnl-genl-3-200:amd64 (3.7.0-0.2+b1) ...
Selecting previously unselected package htop.
Preparing to unpack .../htop_3.2.2-2_amd64.deb ...
Unpacking htop (3.2.2-2) ...
Setting up libnl-3-200:amd64 (3.7.0-0.2+b1) ...
Setting up libnl-genl-3-200:amd64 (3.7.0-0.2+b1) ...
Setting up htop (3.2.2-2) ...
Processing triggers for libc-bin (2.36-9+deb12u8) ...
root@d1:~# exit
logout
victoitor@bastion:~$

Distribuições

É possível buscar por distribuições linux disponíveis.

incus image list images: <distribuição>

A coluna do alias indica o identificador a ser passado na criação da instância. Se a distribuição não for fornecida, serão listadas todas as distribuições disponíveis (lista muito grande). Para reduzir os resultados de busca, podemos buscar apenas por imagens da arquitetura x86_64 do tipo contêiner com o seguinte comando:

incus image list images: <distribuição> architecture=x86_64 type=container

Nos resultados listados, a variante cloud permite rodar uma configuração inicial que preparamos para as instâncias. No caso, os pacotes do sistema serão atualizados, o fuso horário é trocado para Fortaleza e um usuário pargo é criado com acesso a sudo sem necessidade de senha. As distribuições que não são cloud podem ter um usuário padrão que depende da distribuição.

victoitor@bastion:~$ incus image list images: debian architecture=x86_64 type=container
+------------------------------+----------------------------------------+
|            ALIAS             |              DESCRIPTION               |
+------------------------------+----------------------------------------+
| debian/10 (7 more)           | Debian buster amd64 (20240926_05:24)   |
+------------------------------+----------------------------------------+
| debian/10/cloud (3 more)     | Debian buster amd64 (20240926_05:24)   |
+------------------------------+----------------------------------------+
| debian/11 (7 more)           | Debian bullseye amd64 (20240926_05:24) |
+------------------------------+----------------------------------------+
| debian/11/cloud (3 more)     | Debian bullseye amd64 (20240926_05:24) |
+------------------------------+----------------------------------------+
| debian/12 (7 more)           | Debian bookworm amd64 (20240926_05:24) |
+------------------------------+----------------------------------------+
| debian/12/cloud (3 more)     | Debian bookworm amd64 (20240926_05:24) |
+------------------------------+----------------------------------------+
| debian/trixie (3 more)       | Debian trixie amd64 (20240926_05:24)   |
+------------------------------+----------------------------------------+
| debian/trixie/cloud (1 more) | Debian trixie amd64 (20240926_05:24)   |
+------------------------------+----------------------------------------+
victoitor@bastion:~$ incus launch images:debian/12 d1 -c user.responsavel="Victor Campos"
Launching d1
victoitor@bastion:~$ incus launch images:debian/12/cloud d2 -c user.responsavel="Victor Campos"
Launching d2
victoitor@bastion:~$ incus exec d1 -- timedatectl
               Local time: Fri 2024-09-27 15:10:06 UTC
           Universal time: Fri 2024-09-27 15:10:06 UTC
                 RTC time: n/a
                Time zone: Etc/UTC (UTC, +0000)
System clock synchronized: yes
              NTP service: n/a
          RTC in local TZ: no
victoitor@bastion:~$ incus exec d2 -- timedatectl
               Local time: Fri 2024-09-27 12:10:14 -03
           Universal time: Fri 2024-09-27 15:10:14 UTC
                 RTC time: n/a
                Time zone: America/Fortaleza (-03, -0300)
System clock synchronized: yes
              NTP service: n/a
          RTC in local TZ: no
victoitor@bastion:~$ incus exec d2 -- sudo -i -u pargo
pargo@d2:~$ sudo apt update
Hit:1 http://deb.debian.org/debian bookworm InRelease
Hit:2 http://deb.debian.org/debian bookworm-updates InRelease
Hit:3 http://deb.debian.org/debian-security bookworm-security InRelease
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
All packages are up to date.
pargo@d2:~$ exit
logout
victoitor@bastion:~$

Parar e iniciar instâncias

Uma instância que está rodando pode ser parada com

incus stop <instância>

Uma instância parada pode ser iniciada com

incus start <instância>
victoitor@bastion:~$ incus list
+-----------------------------+---------+----------+
|            NAME             |  STATE  | LOCATION |
+-----------------------------+---------+----------+
| d1                          | RUNNING | amd02    |
+-----------------------------+---------+----------+
victoitor@bastion:~$ incus stop d1
victoitor@bastion:~$ incus list
+-----------------------------+---------+----------+
|            NAME             |  STATE  | LOCATION |
+-----------------------------+---------+----------+
| d1                          | STOPPED | amd02    |
+-----------------------------+---------+----------+
victoitor@bastion:~$ incus start d1
victoitor@bastion:~$ incus list
+-----------------------------+---------+----------+
|            NAME             |  STATE  | LOCATION |
+-----------------------------+---------+----------+
| d1                          | RUNNING | amd02    |
+-----------------------------+---------+----------+

Apagar instância

Quando sua instância não for mais necessária e estiver parada, você pode apagá-la com:

 incus delete <instância>

Observe que a instância precisa estar parada para que este comando funcione.

victoitor@bastion:~$ incus stop d1
victoitor@bastion:~$ incus list
+-----------------------------+---------+----------+
|            NAME             |  STATE  | LOCATION |
+-----------------------------+---------+----------+
| d1                          | STOPPED | amd02    |
+-----------------------------+---------+----------+
victoitor@bastion:~$ incus delete d1
victoitor@bastion:~$ incus list
+-----------------------------+---------+----------+
|            NAME             |  STATE  | LOCATION |
+-----------------------------+---------+----------+

Mover instância entre projetos

Uma instância parada em um projeto de experimentos ainda ocupa a máquina. Para liberar a máquina, a instância pode ser movida para o projeto auxiliar utilizando:

 incus move <instância> --target-project <projeto destino>

Observe que a instância precisa estar parada antes da movimentação.

victoitor@bastion:~$ incus list --all-projects
+-------------+-----------------------------+---------+----------+
|   PROJECT   |            NAME             |  STATE  | LOCATION |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d1                          | RUNNING | amd02    |
+-------------+-----------------------------+---------+----------+
victoitor@bastion:~$ incus stop d1
victoitor@bastion:~$ incus move d1 --target-project auxiliar
victoitor@bastion:~$ incus list --all-projects
+-------------+-----------------------------+---------+----------+
|   PROJECT   |            NAME             |  STATE  | LOCATION |
+-------------+-----------------------------+---------+----------+
| auxiliar    | d1                          | STOPPED | amd02    |
+-------------+-----------------------------+---------+----------+

Criar cópia de instância

Caso queira rodar seu experimento em mais de uma máquina, você pode criar cópias do seu experimento.

incus copy <instância> <nome da cópia> --target-project <projeto destino>

Um uso comum para as cópias é de montar seu experimento para rodar no projeto auxiliar. Em seguida, quando estiver pronto para rodar, fazer cópias em outros projetos mantendo a instância montada no projeto auxiliar.

victoitor@bastion:~$ incus list --all-projects
+-------------+-----------------------------+---------+----------+
|   PROJECT   |            NAME             |  STATE  | LOCATION |
+-------------+-----------------------------+---------+----------+
| auxiliar    | d1                          | RUNNING | amd02    |
+-------------+-----------------------------+---------+----------+
victoitor@bastion:~$ incus stop d1
victoitor@bastion:~$ incus copy d1 d1-intel --target-project intel-12700
victoitor@bastion:~$ incus copy d1 d1-amd --target-project amd-5700g
victoitor@bastion:~$ incus copy d1 d2-amd --target-project amd-5700g
victoitor@bastion:~$ incus list --all-projects
+-------------+-----------------------------+---------+----------+
|   PROJECT   |            NAME             |  STATE  | LOCATION |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d1-amd                      | STOPPED | amd02    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d2-amd                      | STOPPED | amd03    |
+-------------+-----------------------------+---------+----------+
| auxiliar    | d1                          | STOPPED | amd02    |
+-------------+-----------------------------+---------+----------+
| intel-12700 | d1-intel                    | STOPPED | intel01  |
+-------------+-----------------------------+---------+----------+

Utilidades

Apresentamos aqui algumas utilidades que não são relativos ao incus, mas ao uso do linux de forma remota. Estas utilidades não são a única forma de resolver estes problemas, mas servem como uma forma de resolvê-los para usuários leigos no uso de linux. O que apresentamos aqui será bem simples apenas para ajudar àqueles que desconhecem o uso. Caso queiram mais informações, tem bastante documentação online.

Terminal persistente

É comum a conexão ssh cair e isso levar ao fim do experimento. Uma solução simples para manter o experimento em execução e retornar para ele posteriormente seria utilizando o tmux. Este pode ser instalado em distribuições com base debian usando o seguinte comando:

sudo apt install tmux

Sem entrar em muitos detalhes sobre como utilizar o tmux, é possível criar um novo terminal persistente utilizando o comando:

tmux

Para retornar ao terminal caso a conexão caia, utilize:

tmux attach

Uso de CPU e memória

Uma forma visual de observar o gasto de CPU e memória da sua instância é utilizando o htop. Este pode ser instalado em distribuições com base debian usando o seguinte comando:

sudo apt install htop

Você pode iniciar o htop usando:

htop

O htop tem uma interface visual pelo terminal que apresenta o uso dos núcleos de processamento junto com a memória total e utilizada pela sua instância como a seguir.

    0[        offline]  4[        offline]   8[        offline]  12[        offline]
    1[        offline]  5[        offline]   9[        offline]  13[        offline]
    2[        offline]  6[           0.0%]  10[        offline]  14[           0.0%]
    3[        offline]  7[||         1.3%]  11[        offline]  15[           0.0%]
  Mem[|||||||                 22.3M/1.86G] Tasks: 9, 0 thr, 0 kthr; 1 running
  Swp[                              0K/0K] Load average: 0.07 0.05 0.00 
                                           Uptime: 00:23:13

  [Main] [I/O]
    PID USER       PRI  NI  VIRT   RES   SHR S  CPU%▽MEM%   TIME+  Command            
    211 root        20   0  7880  3460  2980 R   2.6  0.2  0:00.02 htop               
      1 root        20   0  163M 11760  9136 S   0.0  0.6  0:00.10 /sbin/init
    121 root        20   0 32992 12272 11212 S   0.0  0.6  0:00.05 /lib/systemd/system
    130 root        20   0 23128  5472  4480 S   0.0  0.3  0:00.03 /lib/systemd/system
    133 systemd-re  20   0 19824 10756  9392 S   0.0  0.6  0:00.02 /lib/systemd/system
    135 systemd-ne  20   0 18024  9008  7860 S   0.0  0.5  0:00.02 /lib/systemd/system
    139 messagebus  20   0  9128  4236  3836 S   0.0  0.2  0:00.00 /usr/bin/dbus-daemo
    141 root        20   0 16572  6940  6048 S   0.0  0.4  0:00.02 /lib/systemd/system
    144 root        20   0  5496  1068   976 S   0.0  0.1  0:00.00 /sbin/agetty -o -p

F1Help  F2Setup F3SearchF4FilterF5Tree  F6SortByF7Nice -F8Nice +F9Kill  F10Quit

Uso avançado

Aqui descrevemos algumas utilidades do incus que vão além do uso básico para rodar experimentos, mas que podem facilitar alguns casos de uso.

Copiar arquivos

Há múltiplas formas de copiar arquivos para dentro e fora de uma instância. Uma forma bem comum seria utilizando o git. Mas caso envie um arquivo para a máquina bastion por ssh, este pode ser colocado dentro da instância com o comando

incus file push <arquivo> <instância>/<caminho destino>

Para mover um arquivo de uma instância para o bastion, você pode utilizar o comando

incus file pull <instância>/<arquivo> <caminho destino>

Um diretório pode ser movido adicionando -r. Alguns exemplos estão a seguir.

victoitor@bastion:~$ echo "bar" > foo
victoitor@bastion:~$ cat foo
bar
victoitor@bastion:~$ incus file push foo d1/tmp/
victoitor@bastion:~$ incus exec d1 -- cat /tmp/foo
bar
victoitor@bastion:~$ incus shell d1
root@d1:~# pwd
/root
root@d1:~# echo "world" > hello
root@d1:~# exit
logout
victoitor@bastion:~$ incus file pull d1/root/hello .
victoitor@bastion:~$ ls
foo  hello
victoitor@bastion:~$ cat hello 
world

Identificar responsável

Identificar a pessoa responsável por uma instância pode ser feito com o seguinte comando.

incus config get <instância> user.responsavel

Por exemplo:

victoitor@bastion:~$ incus launch images:debian/12 d1 -c user.responsavel="Victor Campos"
Launching d1
victoitor@bastion:~$ incus config get d1 user.responsavel
Victor Campos

Rodar em núcleos isolados

Os projetos de experimentos não permitem criar instâncias compartilhando núcleos de processador ou memória. Por outro lado, caso seu experimento não utilize muitos núcleos de processador ou muita memória, é possível rodar múltiplos experimentos em núcleos isolados.

Para uma instância que esteja no projeto auxiliar, podemos criar cópias dele em projetos de experimento usando o seguinte comando:

incus copy <instância> <nome cópia> --target-project <projeto destino> -p default -p <profile cpu>

O nome do profile de cpu pode ser obtido com:

incus profile list --project <projeto experimentos>

Para os projetos amd-5700g e intel-12700 temos:

victoitor@bastion:~$ incus profile list --project amd-5700g
+---------+-----------------------------------------------------+
|  NAME   |                     DESCRIPTION                     |
+---------+-----------------------------------------------------+
| cpu1    | Restrito a core 1 e 4GB memoria                     |
+---------+-----------------------------------------------------+
| cpu1-2  | Restrito a cores 1-2 e 8GB memoria                  |
+---------+-----------------------------------------------------+
| cpu1-3  | Restrito a cores 1-3 e 12GB memoria                 |
+---------+-----------------------------------------------------+
| cpu2    | Restrito a core 2 e 4GB memoria                     |
+---------+-----------------------------------------------------+
| cpu3    | Restrito a core 3 e 4GB memoria                     |
+---------+-----------------------------------------------------+
| cpu3-4  | Restrito a cores 3-4 e 8GB memoria                  |
+---------+-----------------------------------------------------+
| cpu4    | Restrito a core 4 e 4GB memoria                     |
+---------+-----------------------------------------------------+
| cpu4-6  | Restrito a cores 4-6 e 12GB memoria                 |
+---------+-----------------------------------------------------+
| cpu5    | Restrito a core 5 e 4GB memoria                     |
+---------+-----------------------------------------------------+
| cpu5-6  | Restrito a cores 5-6 e 8GB memoria                  |
+---------+-----------------------------------------------------+
| cpu6    | Restrito a core 6 e 4GB memoria                     |
+---------+-----------------------------------------------------+
| default | Profile default restrito a cores 1-6 e 24GB memoria |
+---------+-----------------------------------------------------+
victoitor@bastion:~$ incus profile list --project intel-12700
+---------+-----------------------------------------------------+
|  NAME   |                     DESCRIPTION                     |
+---------+-----------------------------------------------------+
| cpu1    | Restrito a core 1 e 3GB memoria                     |
+---------+-----------------------------------------------------+
| cpu1-2  | Restrito a cores 1-2 e 6GB memoria                  |
+---------+-----------------------------------------------------+
| cpu1-4  | Restrito a cores 1-4 e 12GB memoria                 |
+---------+-----------------------------------------------------+
| cpu2    | Restrito a core 2 e 3GB memoria                     |
+---------+-----------------------------------------------------+
| cpu3    | Restrito a core 3 e 3GB memoria                     |
+---------+-----------------------------------------------------+
| cpu3-4  | Restrito a cores 3-4 e 6GB memoria                  |
+---------+-----------------------------------------------------+
| cpu4    | Restrito a core 4 e 3GB memoria                     |
+---------+-----------------------------------------------------+
| cpu5    | Restrito a core 5 e 3GB memoria                     |
+---------+-----------------------------------------------------+
| cpu5-6  | Restrito a cores 5-6 e 6GB memoria                  |
+---------+-----------------------------------------------------+
| cpu5-8  | Restrito a cores 5-8 e 12GB memoria                 |
+---------+-----------------------------------------------------+
| cpu6    | Restrito a core 6 e 3GB memoria                     |
+---------+-----------------------------------------------------+
| cpu7    | Restrito a core 7 e 3GB memoria                     |
+---------+-----------------------------------------------------+
| cpu7-8  | Restrito a cores 7-8 e 6GB memoria                  |
+---------+-----------------------------------------------------+
| cpu8    | Restrito a core 8 e 3GB memoria                     |
+---------+-----------------------------------------------------+
| default | Profile default restrito a cores 1-8 e 24GB memoria |
+---------+-----------------------------------------------------+

O campo de descrição contém as especificações de quais núcleos de CPU serão utilizados consumindo todos os threads destes núcleos. Assim, para cada núcleo de CPU você terá dois threads na sua instância. A alocação de uma instância será feita de forma que não haja conflito de núcleos de experimentos, que a memória total não ultrapasse os 24GB reservados e para que cada máquina seja utilizada apenas por uma pessoa responsável.

Observe que o último profile aplicado indica a configuração de núcleos de CPU e memória, logo o profile default não será utilizado para definir estes parâmetros. Ao mesmo tempo, o profile default ainda é necessário ser aplicado pois tem outras definições necessárias para a criação da instância.

victoitor@bastion:~$ incus list --all-projects
+-------------+-----------------------------+---------+----------+
|   PROJECT   |            NAME             |  STATE  | LOCATION |
+-------------+-----------------------------+---------+----------+
| auxiliar    | d1                          | STOPPED | amd03    |
+-------------+-----------------------------+---------+----------+
victoitor@bastion:~$ incus copy d1 d11 --target-project amd-5700g -p default -p cpu1-3
victoitor@bastion:~$ incus copy d1 d12 --target-project amd-5700g -p default -p cpu4-6
victoitor@bastion:~$ incus list --all-projects
+-------------+-----------------------------+---------+----------+
|   PROJECT   |            NAME             |  STATE  | LOCATION |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d11                         | STOPPED | amd02    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d12                         | STOPPED | amd02    |
+-------------+-----------------------------+---------+----------+
| auxiliar    | d1                          | STOPPED | amd03    |
+-------------+-----------------------------+---------+----------+
victoitor@bastion:~$ incus copy d1 d21 --target-project amd-5700g -p default -p cpu1-2
victoitor@bastion:~$ incus copy d1 d22 --target-project amd-5700g -p default -p cpu3-4
victoitor@bastion:~$ incus copy d1 d23 --target-project amd-5700g -p default -p cpu5-6
victoitor@bastion:~$ incus list --all-projects
+-------------+-----------------------------+---------+----------+
|   PROJECT   |            NAME             |  STATE  | LOCATION |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d11                         | STOPPED | amd02    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d12                         | STOPPED | amd02    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d21                         | STOPPED | amd03    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d22                         | STOPPED | amd03    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d23                         | STOPPED | amd03    |
+-------------+-----------------------------+---------+----------+
| auxiliar    | d1                          | STOPPED | amd03    |
+-------------+-----------------------------+---------+----------+
victoitor@bastion:~$ incus copy d1 d31 --target-project amd-5700g -p default -p cpu1
victoitor@bastion:~$ incus copy d1 d32 --target-project amd-5700g -p default -p cpu2
victoitor@bastion:~$ incus copy d1 d33 --target-project amd-5700g -p default -p cpu3
victoitor@bastion:~$ incus copy d1 d34 --target-project amd-5700g -p default -p cpu4
victoitor@bastion:~$ incus copy d1 d35 --target-project amd-5700g -p default -p cpu5
victoitor@bastion:~$ incus copy d1 d36 --target-project amd-5700g -p default -p cpu6
victoitor@bastion:~$ incus list --all-projects
+-------------+-----------------------------+---------+----------+
|   PROJECT   |            NAME             |  STATE  | LOCATION |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d11                         | STOPPED | amd02    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d12                         | STOPPED | amd02    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d21                         | STOPPED | amd03    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d22                         | STOPPED | amd03    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d23                         | STOPPED | amd03    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d31                         | STOPPED | amd04    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d32                         | STOPPED | amd04    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d33                         | STOPPED | amd04    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d34                         | STOPPED | amd04    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d35                         | STOPPED | amd04    |
+-------------+-----------------------------+---------+----------+
| amd-5700g   | d36                         | STOPPED | amd04    |
+-------------+-----------------------------+---------+----------+
| auxiliar    | d1                          | STOPPED | amd03    |
+-------------+-----------------------------+---------+----------+

Para copiar uma instância de volta ao projeto auxiliar, você pode receber um erro caso tenha algum profile aplicado na instância que não seja o default. Isto ocorre pois o projeto auxiliar não possui estes profiles adicionais. Para evitar este erro, copie de volta ao projeto auxiliar indicando como profile apenas o default com o seguinte comando:

incus copy <instância> <nome cópia> --target-project auxiliar -p default

Informações do ambiente

Para falar sobre o ambiente de testes em que seu experimento rodou, você pode mencionar que foi utilizando X núcleos com 2X threads de computação e Y de memória RAM dentro de um contêiner linux usando incus. O número de núcleos é determinado pelo profile de CPU utilizado ou pela definição do profile default. Todas as informações sobre a máquina podem ser obtidas com o seguinte comando:

incus info --resources --target <máquina>

Observe que este comando retornará informação detalhada sobre a máquina do cluster específica, sendo muito longo o resultado. A seguir apresentamos um recorte de informações de CPU, memória e disco.

victoitor@bastion:~$ incus info --resources --target amd01
System:
(...)
Load:
  Processes: 339
  Average: 0.07 0.07 0.06

CPU:
  Architecture: x86_64
  Vendor: AuthenticAMD
  Name: AMD Ryzen 7 5700G with Radeon Graphics
  Caches:
    - Level 1 (type: Data): 32KiB
    - Level 1 (type: Instruction): 32KiB
    - Level 2 (type: Unified): 512KiB
    - Level 3 (type: Unified): 16MiB
  Cores:
(...)
  Frequency: 2788Mhz (min: 1400Mhz, max: 4672Mhz)

Memory:
  Free: 28.23GiB
  Used: 3.27GiB
  Total: 31.50GiB

GPU:
(...)
NIC:
(...)
Disks:
  Disk 0:
    NUMA node: 0
    ID: nvme0n1
    Device: 259:0
    Model: ADATA SWORDFISH
    Type: nvme
    Size: 465.76GiB
    WWN: eui.324d34303239414b4ce0001835484452
    Read-Only: false
    Removable: false
    Partitions:
      - Partition 1
        ID: nvme0n1p1
        Device: 259:1
        Read-Only: false
        Size: 953.00MiB
      - Partition 2
        ID: nvme0n1p2
        Device: 259:2
        Read-Only: false
        Size: 464.83GiB
(...)
PCI devices:
(...)