COMPUTAÇÃO CIENTÍFICA
REMOTA NO LABMFA
LINUX, SSH E PÓS-PROCESSAMENTO

Preparado por: Prof. Gustavo R. Anjos
E-mail: gustavo.rabello@coppe.ufrj.br
Versão: 2026-06-22

Introdução

Considerações iniciais

Este texto foi elaborado para atender às necessidades de utilização remota dos computadores de alto desempenho disponíveis no Laboratório de Mecânica dos Fluidos e Aerodinâmica - LabMFA, na Universidade Federal do Rio de Janeiro - UFRJ.

O objetivo é servir como um guia de primeiros passos. O público principal é formado por alunos que precisam usar os servidores do laboratório para simulações, processamento de dados, armazenamento de resultados e controle de arquivos, mas que ainda não têm familiaridade com Linux ou com o uso do terminal.

Ao longo do texto, os comandos são apresentados de forma prática. Primeiro é explicado o que o comando faz, depois são mostrados exemplos simples e, por fim, são indicadas situações comuns no contexto do laboratório. Sempre que aparecer um exemplo como

comando exemplo

isso significa que o texto deve ser digitado no terminal, seguido da tecla Enter. Os nomes de usuários, servidores, endereços IP, portas e diretórios usados aqui são ilustrativos; cada aluno deve substituí-los pelos dados recebidos do responsável pela infraestrutura do LabMFA.

O acesso aos computadores depende do local de onde o aluno está conectado. Dentro da rede do laboratório, cada servidor é acessado diretamente pelo seu IP interno. Fora do laboratório, normalmente existe um único IP externo para entrada na rede, e cada servidor é alcançado por uma porta diferente. Essa diferença aparece principalmente nos comandos ssh e scp.

O uso responsável dos recursos computacionais é essencial. Os computadores do LabMFA são compartilhados e seus recursos são limitados: espaço em disco, memória, processadores, placas gráficas, rede e sistemas de armazenamento precisam atender vários usuários ao mesmo tempo. Uma simulação mal planejada, um processo esquecido ou a geração excessiva de arquivos pode sobrecarregar a máquina e inviabilizar o trabalho de outro aluno. Portanto, antes de executar simulações longas ou que consumam muita memória, procure entender em qual máquina você está, quantos recursos serão usados, onde seus arquivos serão gravados e se há alguma orientação específica para o grupo ou projeto.

O espaço em disco deve ser cuidadosamente respeitado: não grave grandes quantidades de arquivos de dados sem necessidade, não mantenha sequências enormes de arquivos intermediários quando elas já foram pós-processadas e remova ou compacte resultados temporários depois de confirmar que os arquivos importantes foram preservados.

Como estudo complementar, recomenda-se que o aluno faça o curso The Missing Semester of Your CS Education, disponível em português (The Missing Semester of Your CS Education 2026). O curso apresenta, de forma prática, ferramentas que aparecem no uso diário de servidores Linux, como terminal, shell, editores de texto, Git, scripts, automação e organização do ambiente de trabalho.

Recursos computacionais

O LabMFA dispõe de computadores e dispositivos de armazenamento voltados para atividades de pesquisa, desenvolvimento de códigos e execução de simulações numéricas. Esses recursos devem ser usados preferencialmente para tarefas que exigem mais processamento, memória ou armazenamento do que um computador pessoal costuma oferecer. Uma descrição pública das instalações do laboratório também está disponível na página de instalações do LabMFA (LabMFA 2026).

• 1x switch Mikrotik de 48 portas com rede de alta velocidade, usado para interligar servidores, estações de trabalho e dispositivos de armazenamento na rede local do laboratório.

• 1x NAS Synology, com processador dual-core de 2,3 GHz, 4 GB de memória e 24 TB de armazenamento configurado em RAID, usado para armazenamento centralizado de dados e resultados.

• 1x servidor Dell PowerEdge R650, com hostname jacaranda, equipado com um processador Intel Xeon Gold 6348 de 2,60 GHz, 28 cores, 128 GB de RAM e SSD de aproximadamente 1,87 TB.

• 1x servidor Dell R650xs, com hostname abeto, equipado com dois processadores Intel Xeon Silver 4316 de 2,30 GHz, totalizando 40 cores, 256 GB de RAM e SSD de aproximadamente 960 GB.

• 1x servidor Dell R650xs, com hostname pinho, com configuração equivalente ao abeto: dois processadores Intel Xeon Silver 4316, 40 cores no total, 256 GB de RAM e SSD de aproximadamente 960 GB.

Em geral, o aluno acessa esses computadores remotamente a partir do seu notebook ou de uma estação de trabalho do laboratório. Quando o acesso é feito dentro da rede do LabMFA, usa-se o IP interno do servidor desejado. Quando o acesso é feito de fora do laboratório, usa-se um IP externo único e uma porta específica para cada máquina. Essa configuração é comum quando a rede do laboratório usa redirecionamento de portas.

Uma forma simples de registrar esses dados é manter uma tabela de consulta. Na rede interna do LabMFA, cada equipamento possui seu próprio IP:

Dentro da rede local do laboratório, o acesso é feito diretamente para o IP interno do equipamento desejado. Fora do laboratório, use o IP externo único IP_EXTERNO_RESTRITO e a porta correspondente ao servidor desejado.

Arquivos pequenos, scripts e configurações podem ser editados diretamente no terminal. Arquivos maiores, como malhas, resultados de simulação e bases de dados, devem ser organizados em diretórios claros para facilitar a manutenção, o backup e o eventual compartilhamento com orientadores e colegas.

Evite salvar resultados grandes na pasta errada, duplicar arquivos sem necessidade ou deixar simulações abandonadas consumindo recursos. Em um ambiente compartilhado, organização local também é uma forma de respeito aos demais usuários.

Linux e terminal

O que é o Linux

Linux é o sistema operacional utilizado na maior parte dos servidores de computação científica. Ele faz o mesmo papel geral do Windows ou do macOS: organiza arquivos, executa programas, controla usuários, gerencia memória, usa discos e conversa com a rede. A diferença mais importante para este manual é que, em servidores, normalmente usamos o Linux por meio de texto, digitando comandos em um terminal.

Essa forma de trabalho parece estranha no começo, mas é muito eficiente para computação remota. Um servidor do LabMFA pode estar em outra sala, ou mesmo em outra rede, e ainda assim ser usado quase como se estivesse na sua frente. O aluno envia comandos, acompanha programas, copia resultados e organiza arquivos sem precisar de uma interface gráfica.

Arquivos e diretórios

No Linux, tudo é organizado em uma árvore de diretórios. Um diretório é o mesmo que uma pasta. O topo dessa árvore é representado por uma barra /. A partir dela existem diretórios como /home, /usr, /tmp e outros. Em geral, os arquivos pessoais dos usuários ficam dentro de /home.

Se o usuário se chama aluno, sua pasta pessoal provavelmente será /home/aluno. Essa pasta também pode ser escrita como ~, que é um atalho para “minha pasta pessoal”. Assim, os caminhos abaixo apontam para locais equivalentes quando o usuário logado é aluno:

/home/aluno
~

Um caminho que começa com / é chamado de caminho absoluto, pois indica o local desde a raiz do sistema. Um caminho que não começa com / é chamado de caminho relativo, pois depende do diretório em que o usuário está naquele momento. Por exemplo, se você está em /home/aluno e digita resultados/caso1.dat, o Linux entende /home/aluno/resultados/caso1.dat.

O terminal

O terminal é a janela ou sessão onde comandos são digitados. Ele apresenta um indicador chamado prompt. O prompt pode variar de um computador para outro, mas normalmente mostra o usuário, o nome da máquina e o diretório atual. Um exemplo típico é:

aluno@servidor:~/simulacoes$

Nesse exemplo, aluno é o nome do usuário, servidor é o nome do computador, ~/simulacoes é o diretório atual e o símbolo $ indica que o terminal está pronto para receber comandos.

Um comando tem, em geral, três partes: o nome do programa, opções e argumentos. As opções modificam o comportamento do comando e frequentemente começam com - ou --. Os argumentos indicam sobre quais arquivos, diretórios ou textos o comando deve atuar.

ls -lh resultados

No exemplo acima, ls é o comando, -lh são opções e resultados é o argumento. O comando lista o conteúdo do diretório resultados, mostrando tamanhos em unidades mais legíveis.

Shell e Bash

Quando o aluno digita um comando no terminal, quem interpreta esse texto não é o terminal em si, mas um programa chamado shell. O shell lê o comando, expande atalhos, encontra o programa correspondente e inicia sua execução. Em outras palavras, o terminal é a janela de interação; o shell é o interpretador de comandos que trabalha dentro dela.

O shell mais comum em servidores Linux é o bash, abreviação de Bourne Again Shell. Ele é usado há décadas, está disponível em praticamente todas as distribuições Linux e é a escolha mais segura para scripts que precisam funcionar em muitos computadores. Grande parte dos exemplos deste manual assume comportamento compatível com bash.

Para saber qual shell está sendo usado na sessão atual, digite:

echo $SHELL

Para saber qual programa de shell está executando o terminal naquele momento:

echo $0

Esses comandos podem retornar caminhos como /bin/bash, /bin/zsh ou /usr/bin/fish.

Outros shells: zsh, fish e sh

Além do bash, existem outros shells. Eles executam comandos parecidos, mas podem ter diferenças em atalhos, arquivos de configuração e recursos interativos.

• sh: shell histórico e mínimo. É usado como base de compatibilidade para muitos scripts. Quando um script começa com #!/bin/sh, ele deve evitar recursos específicos de bash ou zsh.

• bash: padrão em muitos servidores Linux. É recomendado para scripts de laboratório, automação simples e comandos que precisam funcionar de forma previsível.

• zsh: shell moderno e bastante usado em computadores pessoais, especialmente no macOS. Tem recursos interativos convenientes, como autocompletar avançado e temas de prompt. Scripts simples costumam ser parecidos com bash, mas há diferenças.

• fish: shell amigável e interativo, com sugestões automáticas e sintaxe mais legível. Porém, sua sintaxe de script é diferente da sintaxe de bash; por isso, não é a melhor escolha para scripts que precisam executar em servidores variados.

Para listar shells disponíveis em um sistema Linux, use:

cat /etc/shells

Para iniciar temporariamente outro shell, basta chamar o programa:

bash
zsh
fish

Esse comando muda apenas a sessão atual. Para voltar ao shell anterior, digite:

exit

Arquivos de configuração do shell

Cada shell lê arquivos de configuração quando uma nova sessão começa. Esses arquivos definem aliases, variáveis de ambiente, funções e ajustes do prompt. Os mais comuns são:

• ~/.bashrc: configuração usual do bash em sessões interativas.

• ~/.bash_profile ou ~/.profile: configuração lida em sessões de login, dependendo da distribuição.

• ~/.zshrc: configuração usual do zsh.

• ~/.config/fish/config.fish: configuração usual do fish.

Os aliases de acesso ao LabMFA, por exemplo, podem ser colocados no ~/.bashrc se o aluno usa bash, ou no ~/.zshrc se usa zsh. Depois de editar o arquivo, é possível recarregar a configuração sem fechar o terminal:

source ~/.bashrc
source ~/.zshrc

Como mudar o shell padrão

Em Linux, o shell padrão de um usuário pode ser alterado com o comando chsh, se essa opção estiver habilitada pelo administrador do sistema. Antes de mudar, confira quais shells estão permitidos:

cat /etc/shells

Para mudar o shell padrão para bash:

chsh -s /bin/bash

Para mudar para zsh, quando ele está instalado e listado em /etc/shells:

chsh -s /bin/zsh

Depois de usar chsh, normalmente é necessário sair da sessão e entrar novamente para que a mudança tenha efeito. Em servidores compartilhados do LabMFA, recomenda-se manter bash como shell padrão, a menos que haja um motivo claro para mudar. Isso reduz diferenças entre exemplos do manual, scripts de colegas e instruções fornecidas pelo responsável técnico.

Boas práticas no uso do terminal

Antes de executar um comando que altera arquivos, confirme onde você está e o que será afetado. Dois comandos simples ajudam muito:

pwd
ls

O comando pwd mostra o diretório atual. O comando ls lista os arquivos desse diretório. Usar os dois antes de copiar, mover ou apagar arquivos evita muitos erros.

Também é importante ler as mensagens de erro. No terminal, mensagens como No such file or directory, Permission denied e command not found são pistas úteis. Elas indicam, respectivamente, que um arquivo ou diretório não foi encontrado, que o usuário não tem permissão para a operação, ou que o comando digitado não está instalado ou foi escrito incorretamente.

Ajuda dentro do próprio Linux

Muitos comandos possuem documentação local. Para consultar o manual de um comando, use man:

man ls
man ssh

Dentro do manual, use as setas do teclado para navegar, /palavra para procurar uma palavra e q para sair. Alguns comandos também aceitam a opção --help, que mostra um resumo curto:

ls --help
ssh --help

Ao estudar os comandos deste manual, não é necessário decorar tudo. O mais importante é entender a lógica geral: localizar-se no sistema, listar arquivos, copiar dados, executar programas e acompanhar o que está rodando.

Ambientes Python com Conda

Por que usar ambientes

Em computação científica, é comum que projetos diferentes precisem de versões diferentes de Python, NumPy, SciPy, Matplotlib, Jupyter, FEniCS, meshio, pyvista ou outras bibliotecas. Instalar tudo diretamente no Python do sistema é uma prática ruim em servidores compartilhados, pois pode quebrar programas de outros usuários ou do próprio sistema operacional.

Ferramentas da família Conda resolvem esse problema criando ambientes. Um ambiente é uma instalação isolada de Python e de bibliotecas. Assim, um aluno pode ter um ambiente para uma disciplina, outro para um projeto de mestrado e outro para testar uma versão nova de uma biblioteca, sem misturar dependências.

No LabMFA, a recomendação geral é instalar essas ferramentas dentro da pasta pessoal do usuário, por exemplo em ~/miniforge3 ou ~/miniconda3. Não use sudo para instalar pacotes Python nos servidores, a menos que isso tenha sido explicitamente pedido pelo responsável técnico.

Miniforge

O Miniforge é uma distribuição mínima de Conda mantida pelo projeto conda-forge. Segundo a página oficial do projeto, seus instaladores são voltados para os comandos conda e mamba, com o canal conda-forge configurado como canal padrão (conda-forge 2026).

Na prática, isso significa que o Miniforge é uma boa escolha para computação científica em Linux, porque o canal conda-forge costuma ter pacotes atualizados para bibliotecas numéricas, compiladores, ferramentas de visualização e dependências científicas.

Miniconda

O Miniconda é a distribuição mínima mantida pela Anaconda. A documentação da Anaconda descreve o Miniconda como um instalador leve que inclui Conda, Python e um pequeno conjunto de pacotes essenciais (Anaconda 2026).

A principal diferença prática é o canal padrão. No Miniconda, o usuário normalmente trabalha com os canais da Anaconda, podendo adicionar conda-forge quando necessário. Em ambientes acadêmicos e de pesquisa, é importante observar os termos de uso da Anaconda, especialmente em usos institucionais ou comerciais.

Qual escolher no LabMFA

Para a maioria dos alunos do LabMFA, o Miniforge é uma escolha simples e adequada, pois já usa conda-forge por padrão e também disponibiliza mamba. O mamba executa operações semelhantes ao conda, mas frequentemente resolve e instala pacotes mais rapidamente.

O Miniconda continua sendo uma alternativa válida quando o aluno já usa a distribuição da Anaconda em outros computadores, precisa reproduzir um ambiente específico criado com Miniconda ou recebeu instruções de um projeto que dependem desse instalador.

Instalação do Miniforge no Linux

As instruções oficiais do Miniforge recomendam baixar o instalador apropriado para o sistema operacional e arquitetura usando curl ou wget e depois executar o script com bash (conda-forge 2026). Em um servidor Linux típico do LabMFA, use:

cd ~
curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
bash Miniforge3-$(uname)-$(uname -m).sh

Durante a instalação interativa, leia as mensagens, aceite a licença se concordar com os termos e confirme o local de instalação. Para uso individual, o local padrão na pasta pessoal costuma ser adequado.

Se o instalador perguntar se deve inicializar o Conda no shell, responda yes. Essa etapa modifica arquivos como ~/.bashrc ou ~/.zshrc para que o comando conda fique disponível em novas sessões de terminal.

Depois da instalação, feche e abra o terminal, ou recarregue a configuração:

source ~/.bashrc

Se a instalação foi feita sem inicialização automática, inicialize manualmente com:

~/miniforge3/bin/conda init
source ~/.bashrc

Instalação do Miniconda no Linux

Para Linux em arquitetura x86_64, a documentação da Anaconda apresenta o download do instalador mais recente e a execução com bash (Anaconda 2026):

cd ~
curl -O https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash ./Miniconda3-latest-Linux-x86_64.sh

Também é possível baixar com wget:

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash ./Miniconda3-latest-Linux-x86_64.sh

A documentação recomenda verificar a integridade do instalador comparando o hash SHA-256 com o valor oficial disponibilizado no repositório da Anaconda. Para gerar o hash local:

sha256sum Miniconda3-latest-Linux-x86_64.sh

Durante a instalação, aceite os termos se concordar, confirme o diretório de instalação e responda yes quando o instalador perguntar se deve inicializar o Conda. Em seguida, feche e abra o terminal, ou rode:

source ~/.bashrc

Desativar ativação automática do ambiente base

Após a inicialização do Conda, é comum aparecer (base) no início do prompt. Isso indica que o ambiente base está ativo. Para evitar confusão, é mais organizado não trabalhar diretamente no base. O próprio projeto Miniforge sugere desativar a ativação automática do ambiente base e criar ambientes específicos para cada projeto (conda-forge 2026):

conda config --set auto_activate_base false

Depois disso, feche e abra o terminal. O comando conda continuará disponível, mas nenhum ambiente será ativado automaticamente.

Criar um ambiente para trabalho no LabMFA

Para criar um ambiente chamado labmfa com Python e algumas bibliotecas comuns:

conda create -n labmfa python=3.11 numpy scipy matplotlib pandas jupyterlab

Se estiver usando Miniforge, também pode usar mamba:

mamba create -n labmfa python=3.11 numpy scipy matplotlib pandas jupyterlab

Para ativar o ambiente:

conda activate labmfa

Depois de ativado, os comandos python, pip, jupyter e bibliotecas instaladas passam a se referir a esse ambiente. Para verificar:

which python
python --version
conda list

Para sair do ambiente:

conda deactivate

Criar ambiente a partir de arquivo YAML

Em projetos de pesquisa, a forma mais organizada de criar ambientes é usar um arquivo YAML. Esse arquivo descreve o nome do ambiente, os canais de pacotes e as bibliotecas necessárias. Assim, outro aluno consegue reproduzir o mesmo ambiente no computador pessoal ou em um servidor do LabMFA.

Crie um arquivo chamado environment.yml:

nano environment.yml

Um exemplo básico para um ambiente chamado mef, voltado para estudos de método dos elementos finitos, é:

name: mef
channels:
  - conda-forge
dependencies:
  - python=3.11
  - numpy
  - scipy
  - matplotlib
  - pandas
  - sympy
  - jupyterlab
  - ipykernel
  - pip
  - pip:
      - meshio
      - pygmsh
      - gmsh
      - scienceplots
      - rich

O campo name define o nome do ambiente. O campo channels indica de onde o Conda deve procurar pacotes; neste exemplo, usamos conda-forge. A lista dependencies contém os pacotes instalados pelo Conda. A subseção pip instala pacotes usando pip dentro do próprio ambiente.

Depois de salvar o arquivo, crie o ambiente com:

conda env create -f environment.yml

Se estiver usando Miniforge, o mesmo arquivo pode ser instalado com mamba:

mamba env create -f environment.yml

Para ativar e testar o ambiente:

conda activate mef
python -c "import numpy, scipy, matplotlib; print('ambiente mef ok')"

Para usar esse ambiente em notebooks Jupyter, registre o kernel:

python -m ipykernel install --user --name mef --display-name "Python (mef)"

Quando o arquivo environment.yml for alterado, por exemplo para acrescentar um pacote, atualize o ambiente existente com:

conda env update -n mef -f environment.yml --prune

A opção --prune remove pacotes que não aparecem mais no arquivo. Isso mantém o ambiente mais próximo da descrição oficial do projeto.

Use pip dentro do arquivo YAML com cuidado. Em geral, prefira instalar por Conda quando o pacote existir no canal conda-forge, pois isso reduz conflitos entre bibliotecas compiladas. Deixe pip para pacotes que não estão disponíveis no Conda, versões específicas exigidas por um projeto ou ferramentas Python puras.

Boas práticas

Crie ambientes com nomes claros, como cfd, mef, posprocessamento ou tese. Evite instalar todos os pacotes no ambiente base. Antes de apagar ou recriar um ambiente, confirme se ele não contém configurações importantes.

Para listar ambientes existentes:

conda env list

Para remover um ambiente que não é mais necessário:

conda remove -n labmfa --all

Para registrar os pacotes de um ambiente em um arquivo, use:

conda env export > environment.yml

Esse comando exporta o ambiente ativo com versões detalhadas dos pacotes. Para criar um arquivo mais fácil de revisar manualmente, como no exemplo do ambiente mef, prefira escrever o environment.yml com os pacotes principais do projeto.

Esse arquivo ajuda a reproduzir o mesmo ambiente em outro computador ou em um servidor do laboratório:

conda env create -f environment.yml

Instalar programas e registrar o ambiente

Depois que o Miniforge ou o Miniconda estiver instalado, o aluno deve instalar pacotes dentro de ambientes específicos, e não diretamente no ambiente base. Isso reduz conflitos e torna os projetos mais reprodutíveis.

conda activate mef
conda install -c conda-forge numpy scipy matplotlib

Para procurar um pacote antes de instalar:

conda search -c conda-forge pyvista

Para instalar ferramentas de pós-processamento:

conda install -c conda-forge pyvista pillow imageio ffmpeg imagemagick gnuplot

Quando o ambiente estiver funcionando, registre sua configuração em um arquivo:

conda env export > environment.yml

Esse arquivo pode ser salvo junto com o projeto. Em outro servidor, ou no computador de outro aluno, o ambiente pode ser recriado com:

conda env create -f environment.yml

Se o ambiente já existe e o arquivo environment.yml foi atualizado:

conda env update -f environment.yml --prune

A opção --prune remove pacotes que não aparecem mais no arquivo, ajudando a manter o ambiente consistente com a descrição do projeto.

Fundamentos práticos do terminal

Redirecionamento, pipes e curingas

No terminal, muitos programas escrevem resultados na tela. O Linux permite redirecionar essa saída para arquivos, combinar comandos e selecionar grupos de arquivos por padrões. Esses recursos são fundamentais para trabalhar com simulações, logs e pós-processamento.

Salvar a saída em arquivo

O símbolo > salva a saída de um comando em um arquivo. Se o arquivo já existir, ele será substituído.

ls -lh > lista_arquivos.txt
python simulacao.py > saida.log

O símbolo >> acrescenta a saída ao final do arquivo, sem apagar o conteúdo anterior.

date >> historico_execucoes.log
python pos.py >> historico_execucoes.log

Mensagens de erro geralmente usam uma saída separada chamada stderr. Para salvar saída normal e erros no mesmo arquivo:

python simulacao.py > saida.log 2>&1

Combinar comandos com pipe

O símbolo | envia a saída de um comando para a entrada de outro.

ls -lh | less
history | grep ssh
ps aux | grep python

No primeiro exemplo, a listagem é aberta no less. No segundo, o histórico é filtrado por comandos que contêm ssh. No terceiro, a lista de processos é filtrada por processos relacionados a Python.

Selecionar arquivos com curingas

O caractere * representa qualquer sequência de caracteres.

ls *.vtk
ls interface-*.png
cp *.dat resultados/

O caractere ? representa exatamente um caractere.

ls caso?.dat

Antes de usar curingas com rm, sempre teste o padrão com ls.

ls cropped-*.png
rm cropped-*.png

Permissões: chmod, chown e groups

O Linux controla quem pode ler, escrever e executar cada arquivo. Essas permissões aparecem na listagem longa do ls.

ls -lh script.py
ls -ld resultados

Uma linha pode começar assim:

-rwxr-xr--

O primeiro caractere indica o tipo: - para arquivo comum e d para diretório. Depois vêm três grupos de permissões: usuário, grupo e outros. As letras significam r para leitura, w para escrita e x para execução.

chmod: alterar permissões

Para tornar um script executável:

chmod +x script.py
./script.py

Para remover permissão de escrita para outras pessoas:

chmod o-w resultados.dat

Para ajustar permissões de arquivos SSH:

chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys
chmod 600 ~/.ssh/id_ed25519

groups: ver grupos do usuário

groups
groups aluno

Grupos permitem compartilhar arquivos entre usuários autorizados. Em servidores compartilhados, isso pode ser usado para projetos de pesquisa com mais de uma pessoa.

chown: alterar dono

O comando chown muda o dono de arquivos. Em geral, usuários comuns não podem mudar arquivos para outro dono; isso costuma exigir permissões de administrador.

chown aluno resultados.dat
chown -R aluno:grupo projeto/

No LabMFA, se um arquivo importante ficou com dono incorreto, o aluno deve pedir ajuda ao responsável técnico em vez de tentar corrigir com comandos aleatórios.

Compactação: tar, gzip, zip e unzip

Resultados de simulações podem conter muitos arquivos pequenos. Compactar esses arquivos facilita a cópia, reduz o número de transferências e ajuda a organizar versões finais.

tar: empacotar diretórios

Para criar um arquivo compactado tar.gz:

tar -czvf resultados.tar.gz resultados/

As opções significam: c cria o arquivo, z usa compressão gzip, v mostra os nomes processados e f indica o nome do arquivo de saída.

Para extrair:

tar -xzvf resultados.tar.gz

Para ver o conteúdo sem extrair:

tar -tzvf resultados.tar.gz

gzip: compactar arquivo único

gzip saida.log
gunzip saida.log.gz

O gzip é adequado para arquivos únicos, como saida.log. Ao compactar, ele normalmente substitui o arquivo original por uma versão terminada em .gz.

zip e unzip: compatibilidade com Windows

zip -r resultados.zip resultados/
unzip resultados.zip
unzip -l resultados.zip

Arquivos zip são convenientes quando os resultados precisam ser enviados para usuários de Windows, mas em servidores Linux o formato tar.gz costuma ser mais natural.

Gerenciamento de processos: ps, kill, jobs, fg, bg e nohup

Um processo é um programa em execução. Em computação remota, é essencial saber verificar o que está rodando e encerrar processos que travaram ou foram iniciados por engano.

ps: listar processos

ps
ps aux
ps aux | grep python

O comando ps aux mostra processos de forma detalhada. A coluna PID contém o identificador do processo, usado por comandos como kill.

kill e killall: encerrar processos

Para pedir que um processo termine:

kill 12345

Se o processo não responde, pode ser necessário enviar um sinal mais forte:

kill -9 12345

Use kill -9 apenas quando necessário. Ele encerra o processo sem dar oportunidade para salvar arquivos temporários ou fechar saídas de forma organizada.

Para encerrar processos pelo nome:

killall python

Esse comando pode ser perigoso em servidores compartilhados se o nome for genérico. Antes, confira com ps aux | grep python.

jobs, fg e bg

Se um comando foi iniciado no terminal atual, é possível pausá-lo com Ctrl+z. Depois disso:

jobs
bg %1
fg %1

jobs lista tarefas associadas ao shell atual. bg continua uma tarefa em segundo plano. fg traz a tarefa de volta para primeiro plano.

nohup: manter processo após sair do terminal

nohup python simulacao.py > saida.log 2>&1 &

Esse comando inicia simulacao.py, salva a saída em saida.log e mantém o processo rodando mesmo se a conexão cair. Ainda assim, para trabalho interativo e acompanhamento mais confortável, tmux costuma ser uma escolha melhor.

Variáveis de ambiente e PATH

Variáveis de ambiente são nomes que guardam valores usados pelo shell e por programas. Elas ajudam o sistema a saber onde procurar executáveis, onde fica o diretório pessoal do usuário e qual ambiente está ativo.

echo $HOME
echo $SHELL
echo $PATH

A variável PATH contém uma lista de diretórios onde o shell procura programas. Quando o aluno digita python, por exemplo, o shell procura um executável com esse nome em cada diretório listado no PATH.

which: descobrir qual programa será executado

which python
which conda
which ffmpeg

Depois de ativar um ambiente Conda, o resultado de which python deve apontar para dentro do ambiente ativo.

conda activate mef
which python

export: definir variável temporária

export OMP_NUM_THREADS=4
export PYVISTA_OFF_SCREEN=true

Essas variáveis valem apenas para a sessão atual. Para carregá-las sempre, elas podem ser adicionadas ao ~/.bashrc ou ao ~/.zshrc, com cuidado para não quebrar outros programas.

Adicionar um diretório ao PATH

Se o aluno tem scripts executáveis em ~/bin, pode adicionar esse diretório ao começo do PATH:

export PATH="$HOME/bin:$PATH"

Depois disso, um script executável em ~/bin/processa_caso.py pode ser chamado de qualquer diretório:

processa_caso.py caso01

Comandos

pwd: mostrar o diretório atual

O comando pwd mostra o caminho completo do diretório em que o terminal está naquele momento. Ele é simples, mas muito importante: antes de copiar, mover ou apagar arquivos, o aluno deve conferir onde está.

pwd

Um resultado típico é:

/home/aluno/simulacoes/caso01

Esse caminho informa que os comandos seguintes serão executados dentro de caso01. No LabMFA, use pwd sempre que abrir uma nova conexão ssh, entrar em uma sessão tmux antiga ou mudar entre diretórios de resultados.

pwd
ls -lh

A sequência acima confirma o local atual e mostra os arquivos disponíveis nesse local.

ls: listar arquivos e diretórios

O comando ls mostra o conteúdo de um diretório. Ele é um dos primeiros comandos que o aluno deve aprender, pois permite verificar quais arquivos existem no local atual antes de executar outras operações.

ls

O comando acima lista os arquivos e diretórios da pasta atual. Para obter uma listagem mais detalhada, use:

ls -lh

A opção -l mostra informações em formato longo, como permissões, dono, grupo, tamanho e data de modificação. A opção -h mostra tamanhos em formato mais legível, como 4K, 20M ou 3G.

Para mostrar arquivos ocultos, que no Linux começam com ponto, use:

ls -la

Arquivos como .bashrc, .profile e .ssh são ocultos por padrão porque geralmente guardam configurações do usuário. Não altere esses arquivos sem entender sua função.

Também é possível listar um diretório específico:

ls -lh resultados
ls -lh /home/aluno/simulacoes

No LabMFA, use ls frequentemente para confirmar se uma simulação gerou os arquivos esperados, se os resultados foram copiados para o local certo e se você está trabalhando no diretório correto.

cd: mudar de diretório

O comando cd significa change directory, ou seja, mudar de diretório. Ele permite navegar pela árvore de pastas do Linux.

cd simulacoes

Esse comando entra no diretório simulacoes, desde que ele exista dentro da pasta atual. Para voltar um nível, use:

cd ..

O símbolo .. representa o diretório acima do diretório atual. Para ir diretamente para a sua pasta pessoal, use:

cd

ou

cd ~

Para entrar em um diretório usando caminho absoluto:

cd /home/aluno/simulacoes/caso1

Depois de usar cd, é boa prática confirmar onde você está com:

pwd

Em servidores compartilhados, essa conferência é importante. Muitos erros acontecem porque o usuário executa um programa no diretório errado ou grava resultados em uma pasta diferente da esperada.

mkdir: criar diretórios

O comando mkdir cria diretórios. Ele é útil para organizar casos de simulação, scripts, malhas, figuras e resultados.

mkdir simulacoes

O exemplo acima cria o diretório simulacoes dentro da pasta atual. Para criar uma estrutura com vários níveis de uma vez, use a opção -p:

mkdir -p simulacoes/caso1/resultados

Com -p, o Linux cria também os diretórios intermediários, se eles ainda não existirem. Isso é prático para preparar a organização de um novo projeto.

Uma estrutura simples para trabalhos no LabMFA pode ser:

mkdir -p projeto/malhas
mkdir -p projeto/casos
mkdir -p projeto/resultados
mkdir -p projeto/figuras

Use nomes claros e evite espaços em nomes de diretórios. Prefira nomes como caso_re1000 ou malha_fina. Espaços funcionam no Linux, mas deixam os comandos mais sujeitos a erro.

cp, mv e rm: copiar, mover e apagar

Esses comandos alteram arquivos. Por isso, antes de usá-los, confirme o diretório atual com pwd e liste o conteúdo com ls.

cp: copiar arquivos

O comando cp copia arquivos. A forma geral é:

cp origem destino

Exemplos:

cp entrada.dat entrada_backup.dat
cp script.py resultados/script_usado.py

Para copiar um diretório inteiro, use -r, de recursivo:

cp -r caso01 caso01_backup

No servidor, isso pode ocupar bastante espaço. Para diretórios grandes, prefira rsync, pois ele mostra melhor o progresso e pode continuar transferências interrompidas.

mv: mover ou renomear

O comando mv move arquivos e diretórios. Ele também é usado para renomear.

mv saida.dat resultados/saida.dat
mv caso_teste caso_Re200_We20

O primeiro exemplo move saida.dat para o diretório resultados. O segundo muda o nome do diretório caso_teste para caso_Re200_We20.

rm: apagar arquivos

O comando rm remove arquivos. Use com cuidado, pois no terminal normalmente não há lixeira.

rm teste.tmp
rm *.log

Para apagar diretórios, use -r:

rm -r caso_incorreto

Evite usar rm -rf sem necessidade. Antes de apagar muitos arquivos, confira o que será afetado:

ls *.vtk
rm *.vtk

O primeiro comando mostra os arquivos que combinam com o padrão. O segundo remove esses arquivos.

touch, cat, less, head e tail

Esses comandos ajudam a criar arquivos simples e inspecionar textos no terminal. Eles são úteis para arquivos de entrada, saídas de simulação, logs e scripts.

touch: criar arquivo vazio

touch notas.txt
touch README.md

Se o arquivo ainda não existe, touch cria um arquivo vazio. Se ele já existe, o comando apenas atualiza sua data de modificação.

cat: mostrar conteúdo curto

cat README.md
cat entrada.dat

Use cat para arquivos pequenos. Para arquivos longos, ele joga tudo na tela rapidamente, o que dificulta a leitura.

less: ler arquivos longos

less saida.log
less resultados.dat

Dentro do less, use as setas para navegar, /erro para procurar a palavra erro e q para sair.

head e tail: começo e fim do arquivo

head saida.log
head -n 20 saida.log
tail saida.log
tail -n 50 saida.log

head mostra o começo do arquivo. tail mostra o final. Para acompanhar um arquivo que está sendo escrito por uma simulação, use:

tail -f saida.log

Pressione Ctrl+c para parar o acompanhamento.

echo, history e clear

Alguns comandos parecem pequenos, mas tornam o uso diário do terminal mais claro.

echo: imprimir texto e variáveis

echo "Teste no servidor abeto"
echo $HOME
echo $SHELL

O primeiro comando imprime um texto. Os outros mostram variáveis do shell. $HOME indica o diretório pessoal do usuário. $SHELL indica o shell padrão configurado para a conta.

history: recuperar comandos anteriores

history
history | grep ssh
history | grep conda

O comando history lista comandos já digitados. Com grep, é possível procurar comandos antigos relacionados a um tema específico.

clear: limpar a tela

clear

Esse comando limpa visualmente a tela do terminal. Ele não apaga arquivos, não encerra processos e não muda o diretório atual.

find: encontrar arquivos

O comando find procura arquivos e diretórios a partir de um local indicado. Ele é muito útil quando o usuário não lembra onde salvou um resultado ou quando precisa localizar todos os arquivos de certo tipo.

find . -name "resultado.dat"

Nesse exemplo, o ponto . significa “comece no diretório atual”. A opção -name procura pelo nome indicado. As aspas são recomendadas quando o nome contém caracteres especiais ou padrões com *.

Para encontrar todos os arquivos com extensão .dat:

find . -name "*.dat"

Para procurar somente diretórios:

find . -type d -name "resultados"

Para procurar arquivos modificados recentemente:

find . -type f -mtime -1

O exemplo acima lista arquivos modificados no último dia. Isso ajuda quando uma simulação gerou muitos arquivos e você quer identificar quais foram alterados mais recentemente.

Evite executar buscas muito amplas a partir de /, pois isso pode percorrer o sistema inteiro e gerar muitas mensagens de permissão negada. Prefira iniciar a busca na sua pasta de trabalho.

grep: procurar texto dentro de arquivos

O comando grep procura linhas que contêm uma palavra ou expressão. Ele é útil para examinar arquivos de configuração, códigos-fonte, relatórios de execução e arquivos de saída.

grep "erro" saida.log

Esse comando mostra as linhas de saida.log que contêm a palavra erro. Para ignorar diferença entre letras maiúsculas e minúsculas, use -i:

grep -i "error" saida.log

Para procurar em vários arquivos de um diretório:

grep -R "viscosidade" .

A opção -R faz a busca de forma recursiva, entrando nos subdiretórios a partir do local indicado. Para mostrar também o número da linha:

grep -n "residual" saida.log

Em simulações numéricas, grep é prático para verificar convergência ou encontrar mensagens específicas em arquivos longos:

grep -i "converged" solver.log
grep -i "nan" solver.log
grep -i "warning" solver.log

Se o arquivo for muito grande, grep evita que o usuário precise abrir o arquivo inteiro em um editor de texto.

sed: editar texto automaticamente

O comando sed é usado para transformar texto de forma automática. Ele é muito útil para pequenas substituições em arquivos de entrada, scripts e listas de nomes. Para iniciantes, o uso mais importante é substituir uma palavra por outra.

A forma básica de substituição é:

sed 's/antigo/novo/' arquivo.txt

Esse comando mostra na tela o conteúdo de arquivo.txt trocando a primeira ocorrência de antigo por novo em cada linha. O arquivo original não é alterado.

Para substituir todas as ocorrências em cada linha, use o modificador g:

sed 's/velocidade/velocity/g' entrada.txt

Para gravar o resultado em outro arquivo:

sed 's/Re = 100/Re = 1000/g' caso_base.in > caso_re1000.in

Esse exemplo cria um novo arquivo de entrada trocando o número de Reynolds de um caso base. Essa abordagem é útil para preparar variações de parâmetros sem editar tudo manualmente.

Editar o arquivo diretamente

Em alguns sistemas, é possível alterar o arquivo diretamente com -i:

sed -i 's/tempo_final = 10/tempo_final = 20/g' caso.in

Use esse modo com cuidado, pois ele modifica o arquivo original. Uma prática mais segura é criar uma cópia antes:

cp caso.in caso.in.bak
sed -i 's/tempo_final = 10/tempo_final = 20/g' caso.in

No macOS, o sed -i pode exigir uma extensão de backup explícita:

sed -i.bak 's/tempo_final = 10/tempo_final = 20/g' caso.in

Para trabalhos no LabMFA, sed é útil na criação de séries de casos, ajustes rápidos de arquivos de configuração e limpeza simples de arquivos de texto.

wget: baixar arquivos pela internet

O comando wget baixa arquivos a partir de endereços da internet. Ele é muito usado em servidores Linux porque funciona diretamente no terminal, sem precisar abrir um navegador. Isso é útil para baixar instaladores, bases de dados, scripts, arquivos compactados e resultados disponibilizados por outros grupos de pesquisa.

A forma mais simples é informar o endereço do arquivo:

wget https://exemplo.org/dados/medidas.csv

O arquivo será salvo no diretório atual com o mesmo nome indicado no endereço. Antes de executar o comando, use pwd para confirmar em qual diretório você está.

Escolher o nome do arquivo

Use -O para escolher o nome do arquivo de saída:

wget -O medidas_experimento_01.csv https://exemplo.org/dados/medidas.csv

Esse comando baixa o arquivo remoto medidas.csv, mas salva localmente com o nome escolhido na opção -O:

medidas_experimento_01.csv

Isso é útil quando o nome original é genérico ou pouco informativo.

Escolher o diretório de destino

Use -P para salvar o arquivo em um diretório específico:

mkdir -p dados
wget -P dados https://exemplo.org/dados/medidas.csv

No exemplo acima, o arquivo será salvo dentro do diretório dados. O comando mkdir -p dados cria esse diretório caso ele ainda não exista.

Continuar um download interrompido

Downloads grandes podem ser interrompidos por quedas de conexão ou pelo fechamento do terminal. A opção -c tenta continuar o download a partir do ponto em que ele parou:

wget -c https://exemplo.org/dados/simulacao_grande.tar.gz

Essa opção é especialmente útil para arquivos grandes, como resultados compactados de simulações, imagens de disco ou bancos de dados experimentais.

Baixar uma lista de arquivos

Quando vários arquivos precisam ser baixados, coloque os endereços em um arquivo de texto, um por linha. Por exemplo, crie um arquivo chamado lista_downloads.txt com o seguinte conteúdo:

https://exemplo.org/dados/caso01.csv
https://exemplo.org/dados/caso02.csv
https://exemplo.org/dados/caso03.csv

Depois execute:

wget -i lista_downloads.txt

O wget lerá a lista e baixará todos os arquivos indicados.

Exemplo: baixar o instalador do Miniconda

Um uso comum em servidores Linux é baixar instaladores diretamente no terminal. Por exemplo, para baixar o instalador do Miniconda para Linux:

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh

Depois de baixar, é recomendável verificar o arquivo e então executar o instalador:

ls -lh Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh

Verificar se o endereço existe

Para testar se um endereço está disponível sem baixar o arquivo, use --spider:

wget --spider https://exemplo.org/dados/medidas.csv

Se o arquivo existir e o servidor responder corretamente, o wget mostrará uma mensagem de sucesso. Esse teste é útil antes de iniciar downloads grandes.

Diferença entre wget, scp e rsync

Use wget para baixar arquivos publicados em páginas ou servidores web, normalmente com endereços que começam por http:// ou https://. Para transferir arquivos entre seu computador e os servidores do LabMFA usando login SSH, prefira scp ou rsync. O wget não substitui o acesso por ssh; ele é uma ferramenta para download via web.

df: verificar uso dos discos

O comando df mostra o espaço ocupado e disponível nos sistemas de arquivos montados no Linux. Ele responde a uma pergunta importante: quanto espaço ainda existe no disco ou partição?

df -h

A opção -h mostra os valores em unidades mais fáceis de ler, como G para gigabytes e T para terabytes.

Uma saída típica contém colunas como sistema de arquivos, tamanho total, espaço usado, espaço disponível, porcentagem de uso e ponto de montagem. O ponto de montagem indica onde aquele disco aparece na árvore de diretórios.

Antes de iniciar uma simulação que produzirá muitos dados, confira o espaço disponível:

df -h .

O ponto . faz o df mostrar informações do sistema de arquivos onde está o diretório atual. Isso é mais útil do que olhar discos que não serão usados pela sua simulação.

Se um disco compartilhado estiver muito cheio, avise o responsável e evite gerar grandes volumes de dados sem necessidade. Discos cheios podem fazer simulações falharem e podem afetar outros usuários.

du: verificar tamanho de arquivos e diretórios

O comando du mostra quanto espaço arquivos e diretórios ocupam em disco. Enquanto df mostra o espaço do disco como um todo, du ajuda a descobrir quais pastas estão grandes.

du -sh resultados

A opção -s mostra apenas o total do diretório indicado. A opção -h mostra o tamanho em formato legível.

Para ver o tamanho dos itens dentro da pasta atual:

du -h --max-depth=1

Esse comando ajuda a identificar rapidamente quais diretórios estão ocupando mais espaço. Em alguns sistemas, a opção equivalente pode ser escrita como -d 1.

Um uso comum no LabMFA é verificar o tamanho de resultados antes de copiá-los:

du -sh caso1/resultados

Se uma pasta estiver muito grande, avalie se todos os arquivos são necessários. Muitas simulações geram arquivos temporários, campos intermediários ou saídas duplicadas que não precisam ser mantidos indefinidamente.

top: acompanhar processos

O comando top mostra, em tempo real, os processos em execução no computador. Ele permite observar uso de CPU, memória e tempo de execução.

top

Ao abrir o top, as primeiras linhas mostram um resumo do sistema: carga média, quantidade de tarefas, uso de CPU e uso de memória. A tabela principal lista os processos. Colunas importantes são:

• PID: identificador do processo.

• USER: usuário que iniciou o processo.

• %CPU: porcentagem de CPU usada.

• %MEM: porcentagem de memória usada.

• TIME+: tempo acumulado de CPU.

• COMMAND: comando ou programa em execução.

Para sair do top, pressione q. Para ver apenas processos de um usuário, é possível usar:

top -u aluno

No LabMFA, top é útil para verificar se uma simulação realmente está rodando, se está consumindo CPU, se está usando memória demais ou se existem processos antigos esquecidos. Em máquinas compartilhadas, observe também se outros usuários estão executando tarefas pesadas antes de iniciar uma simulação grande.

ssh: conectar em um computador remoto

O comando ssh permite abrir uma sessão de terminal em outro computador pela rede. Depois da conexão, os comandos digitados passam a ser executados no servidor remoto, não no notebook do aluno.

A forma geral do comando é:

ssh usuario@endereco

Dentro da rede local do laboratório, cada equipamento possui IP interno próprio. O acesso pode ser feito diretamente:

ssh nome_de_usuario@192.168.68.51   # abeto
ssh nome_de_usuario@192.168.68.52   # pinho
ssh nome_de_usuario@192.168.68.53   # jacaranda
ssh nome_de_usuario@192.168.68.71   # synology

Fora do laboratório, o acesso usa um IP único e uma porta diferente para cada máquina. A forma geral passa a ser:

ssh usuario@IP_EXTERNO -p PORTA

Para os acessos pelo IP IP_EXTERNO_RESTRITO, os exemplos são:

ssh nome_de_usuario@IP_EXTERNO_RESTRITO -p PORTA_EXTERNA   # abeto
ssh nome_de_usuario@IP_EXTERNO_RESTRITO -p PORTA_EXTERNA   # pinho
ssh nome_de_usuario@IP_EXTERNO_RESTRITO -p PORTA_EXTERNA   # jacaranda
ssh nome_de_usuario@IP_EXTERNO_RESTRITO -p PORTA_EXTERNA   # synology

O nome nome_de_usuario deve ser substituído pelo usuário de cada aluno, quando a conta individual for fornecida. A opção -p indica a porta de conexão. Sem essa opção, o ssh tenta usar a porta padrão 22, que não identifica corretamente o servidor quando há redirecionamento por portas.

Aliases para facilitar o acesso

Para evitar digitar comandos longos todos os dias, é possível criar aliases. Um alias é um apelido para um comando. No arquivo de configuração do terminal, como ~/.bashrc ou ~/.zshrc, pode-se incluir:

alias abeto='ssh nome_de_usuario@IP_EXTERNO_RESTRITO -p PORTA_EXTERNA'
alias pinho='ssh nome_de_usuario@IP_EXTERNO_RESTRITO -p PORTA_EXTERNA'
alias jacaranda='ssh nome_de_usuario@IP_EXTERNO_RESTRITO -p PORTA_EXTERNA'
alias synology='ssh nome_de_usuario@IP_EXTERNO_RESTRITO -p PORTA_EXTERNA'

Dentro do laboratório, se desejar aliases para os IPs internos, pode-se usar:

alias abeto='ssh nome_de_usuario@192.168.68.51'
alias pinho='ssh nome_de_usuario@192.168.68.52'
alias jacaranda='ssh nome_de_usuario@192.168.68.53'
alias synology='ssh nome_de_usuario@192.168.68.71'

Depois de recarregar o terminal, basta digitar:

abeto
jacaranda

Esses aliases devem ser adaptados para o nome de usuário correto. Se o aluno usa a conta maria, por exemplo, o alias deve conter maria@IP_EXTERNO_RESTRITO no acesso externo, ou maria@192.168.68.53 no acesso interno ao jacaranda.

Primeira conexão

Na primeira conexão, o ssh pode perguntar se você confia na chave do servidor. Essa pergunta serve para confirmar a identidade da máquina remota. Confira se o endereço e a porta estão corretos antes de responder yes. Depois disso, a chave fica registrada no arquivo ~/.ssh/known_hosts.

Ao encerrar o trabalho, saia do servidor com:

exit

ou pressione Ctrl+d. Fechar a janela do terminal sem encerrar a sessão pode deixar processos em estado confuso, especialmente se uma simulação estiver rodando sem tmux ou screen.

Chaves SSH

Além do acesso por senha, o ssh permite autenticação por chave criptográfica. Nesse método, o aluno cria um par de arquivos no computador local: uma chave privada e uma chave pública. A chave privada fica somente no computador do aluno. A chave pública pode ser copiada para os servidores do LabMFA.

A ideia é semelhante a uma fechadura e uma chave. O servidor guarda a parte pública, que funciona como a fechadura autorizada. O computador do aluno usa a parte privada para provar sua identidade. Por isso, a chave privada nunca deve ser enviada por e-mail, copiada para computadores compartilhados ou entregue a outra pessoa.

Para gerar uma chave moderna do tipo ed25519, use no computador local:

ssh-keygen -t ed25519 -C "aluno@labmfa"

O programa perguntará onde salvar a chave. Para iniciantes, aceite o local padrão pressionando Enter. Normalmente os arquivos criados serão:

~/.ssh/id_ed25519
~/.ssh/id_ed25519.pub

O arquivo sem .pub é a chave privada. O arquivo terminado em .pub é a chave pública. Ao gerar a chave, o ssh-keygen também pergunta por uma passphrase. Recomenda-se usar uma frase-senha, pois ela protege a chave privada caso o notebook seja perdido ou acessado por outra pessoa.

Copiar a chave para os servidores

Depois de gerar a chave, a chave pública precisa ser instalada no servidor. Em muitos sistemas, o comando mais simples é ssh-copy-id. Dentro da rede local do laboratório, use o IP interno:

ssh-copy-id nome_de_usuario@192.168.68.51   # abeto
ssh-copy-id nome_de_usuario@192.168.68.52   # pinho
ssh-copy-id nome_de_usuario@192.168.68.53   # jacaranda
ssh-copy-id nome_de_usuario@192.168.68.71   # synology

Fora do laboratório, use o IP externo e a porta correspondente. No ssh-copy-id, a porta é passada dentro da opção -p:

ssh-copy-id -p PORTA_EXTERNA nome_de_usuario@IP_EXTERNO_RESTRITO   # abeto
ssh-copy-id -p PORTA_EXTERNA nome_de_usuario@IP_EXTERNO_RESTRITO   # pinho
ssh-copy-id -p PORTA_EXTERNA nome_de_usuario@IP_EXTERNO_RESTRITO   # jacaranda
ssh-copy-id -p PORTA_EXTERNA nome_de_usuario@IP_EXTERNO_RESTRITO   # synology

Substitua nome_de_usuario pelo usuário correto. Durante essa etapa, o servidor ainda pode pedir a senha normal da conta. Depois que a chave pública for copiada, as próximas conexões poderão usar a chave.

Para testar:

ssh nome_de_usuario@192.168.68.53
ssh nome_de_usuario@IP_EXTERNO_RESTRITO -p PORTA_EXTERNA

Se foi definida uma frase-senha para a chave, o sistema pode pedi-la na primeira conexão. Em computadores pessoais, um agente SSH pode guardar essa frase temporariamente durante a sessão, evitando digitá-la a cada conexão.

Quando ssh-copy-id não está disponível

Se o comando ssh-copy-id não existir no computador local, é possível copiar manualmente o conteúdo da chave pública. Primeiro, mostre a chave pública:

cat ~/.ssh/id_ed25519.pub

Copie a linha inteira mostrada na tela. Depois, entre no servidor com ssh e edite ou crie o arquivo de chaves autorizadas:

mkdir -p ~/.ssh
nano ~/.ssh/authorized_keys
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

Cole a chave pública em uma nova linha do arquivo authorized_keys.

As permissões são importantes. Se o diretório .ssh ou o arquivo authorized_keys estiverem permissivos demais, o servidor pode recusar a autenticação por chave.

Configuração opcional em ~/.ssh/config

Para evitar decorar IPs e portas, também é possível criar atalhos no arquivo ~/.ssh/config. Um exemplo para acesso externo é:

Host jacaranda-labmfa
  HostName IP_EXTERNO_RESTRITO
  Port PORTA_EXTERNA
  User nome_de_usuario
  IdentityFile ~/.ssh/id_ed25519

Depois disso, a conexão pode ser feita com:

ssh jacaranda-labmfa

Esse método é mais organizado do que criar muitos aliases, especialmente quando o mesmo servidor precisa ser acessado por IP interno no laboratório e por porta externa fora dele.

scp: copiar arquivos pela rede

O comando scp copia arquivos entre o computador local e um servidor remoto usando a mesma autenticação do ssh. Ele é útil para enviar scripts e malhas para o servidor ou trazer resultados para o computador pessoal.

A forma geral para copiar um arquivo local para o servidor é:

scp arquivo usuario@endereco:/caminho/remoto/

Para copiar um arquivo do servidor para o computador local:

scp usuario@endereco:/caminho/remoto/arquivo .

O ponto . no final significa “copiar para o diretório atual”.

Uso na rede interna

Dentro da rede do laboratório, use o IP interno do equipamento. Por exemplo, para enviar um arquivo para o abeto:

scp caso1.py nome_de_usuario@192.168.68.51:/home/nome_de_usuario/simulacoes/

Para trazer um arquivo do jacaranda para o computador local:

scp nome_de_usuario@192.168.68.53:/home/nome_de_usuario/simulacoes/saida.log .

Uso com porta externa

Quando o acesso é feito pelo IP único externo do LabMFA, também é necessário indicar a porta. No scp, a opção de porta é -P maiúsculo, diferente do ssh, que usa -p minúsculo.

Exemplo para enviar um arquivo para o servidor jacaranda:

scp -P PORTA_EXTERNA caso1.py nome_de_usuario@IP_EXTERNO_RESTRITO:/home/nome_de_usuario/simulacoes/

Exemplo para copiar um resultado do servidor abeto para o diretório atual do computador local:

scp -P PORTA_EXTERNA nome_de_usuario@IP_EXTERNO_RESTRITO:/home/nome_de_usuario/simulacoes/saida.log .

Para copiar diretórios inteiros, use a opção -r:

scp -P PORTA_EXTERNA -r resultados nome_de_usuario@IP_EXTERNO_RESTRITO:/home/nome_de_usuario/simulacoes/
scp -P PORTA_EXTERNA -r nome_de_usuario@IP_EXTERNO_RESTRITO:/home/nome_de_usuario/simulacoes/resultados .

Antes de copiar muitos dados, verifique o tamanho com du -sh. Copiar diretórios grandes pela rede pode demorar e pode ocupar espaço desnecessário no computador de destino.

Cuidado com a direção da cópia

No scp, a ordem dos argumentos importa. O primeiro caminho é a origem; o segundo é o destino. Leia o comando antes de pressionar Enter. Um erro comum é inverter a direção e sobrescrever arquivos antigos com versões desatualizadas.

rsync: sincronizar arquivos e diretórios

O comando rsync copia arquivos entre diretórios locais ou entre computadores pela rede. Ele é parecido com scp, mas costuma ser mais eficiente para diretórios grandes, porque copia apenas o que mudou desde a última transferência.

Para copiar um diretório local para outro local no mesmo computador:

rsync -av resultados/ backup_resultados/

A opção -a preserva atributos importantes dos arquivos e copia diretórios de forma recursiva. A opção -v mostra o que está sendo feito. A barra final em resultados/ significa “copiar o conteúdo de resultados”.

Uso na rede interna

Dentro do laboratório, use o IP interno do servidor. Para enviar um diretório de resultados para o jacaranda:

rsync -av resultados/ nome_de_usuario@192.168.68.53:/home/nome_de_usuario/simulacoes/resultados/

Para trazer resultados do abeto para o computador local:

rsync -av nome_de_usuario@192.168.68.51:/home/nome_de_usuario/simulacoes/resultados/ resultados/

Uso com porta externa

Fora do laboratório, quando o acesso é feito pelo IP externo único, indique a porta usando a opção -e para dizer qual comando ssh o rsync deve usar:

rsync -av -e "ssh -p PORTA_EXTERNA" resultados/ \
  nome_de_usuario@IP_EXTERNO_RESTRITO:simulacoes/resultados/

O exemplo acima envia arquivos para o jacaranda, que usa a porta externa no acesso externo. Para o abeto, a porta seria PORTA_EXTERNA; para o pinho, PORTA_EXTERNA; para o synology, PORTA_EXTERNA.

Transferência com progresso

Para acompanhar melhor transferências longas, use --progress:

rsync -av --progress resultados/ backup_resultados/

Antes de executar uma sincronização grande, é possível fazer um teste sem copiar nada usando --dry-run:

rsync -av --dry-run resultados/ backup_resultados/

Esse modo mostra o que seria copiado. Ele é recomendado quando há risco de enviar arquivos para o diretório errado ou sobrescrever dados importantes.

tmux: manter sessões remotas ativas

O tmux é um gerenciador de terminal. Ele permite iniciar uma sessão no servidor, deixar programas rodando dentro dela e desconectar sem interromper o trabalho. Isso é muito importante em acesso remoto: se a internet cair, a simulação continua dentro da sessão tmux.

Para criar uma sessão chamada caso1:

tmux new -s caso1

Dentro dessa sessão, execute normalmente seus comandos:

cd ~/simulacoes/caso1
./rodar.sh

Para sair da sessão sem interromper os programas, pressione Ctrl+b e depois d. Essa operação é chamada de detach. Depois, para voltar à sessão:

tmux attach -t caso1

Para listar sessões existentes:

tmux ls

Para encerrar uma sessão depois que o trabalho terminou, entre nela e digite exit, ou use:

tmux kill-session -t caso1

No LabMFA, recomenda-se usar tmux para simulações longas, compilações demoradas e transferências que não devem depender da estabilidade da conexão do notebook do aluno.

screen: alternativa para sessões persistentes

O screen tem função parecida com o tmux: ele cria uma sessão de terminal que pode continuar ativa mesmo depois que o usuário desconecta do servidor. Em alguns sistemas antigos, screen pode estar instalado quando tmux não está.

Para criar uma sessão chamada teste:

screen -S teste

Dentro dela, execute o programa desejado:

cd ~/simulacoes/teste
python simulacao.py

Para sair da sessão sem encerrar o programa, pressione Ctrl+a e depois d. Para listar sessões:

screen -ls

Para voltar a uma sessão:

screen -r teste

Se a sessão já estiver marcada como anexada, por exemplo após queda de rede, pode ser necessário usar:

screen -d -r teste

Ao terminar o trabalho, saia da sessão com exit. Para novos usuários, tmux costuma ser mais amigável, mas é útil conhecer screen porque ele aparece em muitos servidores Linux.

git: controle de versões

O git é um sistema de controle de versões. Ele registra a evolução de arquivos ao longo do tempo, permitindo comparar mudanças, voltar a versões anteriores e compartilhar código com outras pessoas. Em pesquisa, isso é útil para scripts, programas, arquivos de entrada, textos e documentação.

Criar um repositório

Para transformar um diretório em um repositório Git:

mkdir projeto
cd projeto
git init

Depois, crie ou copie arquivos para esse diretório. Para ver o estado do repositório:

git status

O comando git status informa quais arquivos foram modificados, quais ainda não estão sendo acompanhados e se há mudanças prontas para registro.

Registrar mudanças

Um registro de versão no Git é chamado de commit. Antes de criar o commit, é necessário escolher quais arquivos entram nele:

git add caso.in
git add rodar.sh
git commit -m "Adiciona caso inicial"

Para adicionar todos os arquivos modificados no diretório atual, use:

git add .
git commit -m "Atualiza parametros da simulacao"

Mensagens de commit devem ser curtas e descrever a mudança realizada. Evite mensagens vagas como alteracoes ou teste.

Consultar histórico e diferenças

Para ver o histórico:

git log --oneline

Para ver o que mudou antes de registrar um commit:

git diff

Esses comandos ajudam a revisar o trabalho antes de salvar uma nova versão. Em projetos de simulação, isso evita perder a relação entre resultados e parâmetros usados para gerá-los.

Uso com GitHub

O GitHub é um serviço para hospedar repositórios Git na internet. Depois de criar uma conta e um repositório vazio no GitHub, é possível conectar o repositório local ao remoto:

git remote add origin git@github.com:usuario/projeto.git
git branch -M main
git push -u origin main

Em outro computador ou servidor, o repositório pode ser copiado com:

git clone git@github.com:usuario/projeto.git

Para enviar commits novos ao GitHub:

git push

Para trazer mudanças feitas em outro computador:

git pull

Não coloque no Git arquivos enormes de resultado, dados sensíveis, senhas ou chaves privadas. O Git é excelente para código e arquivos de texto, mas não é o melhor lugar para armazenar grandes volumes de saída de simulação.

Editores de texto no terminal

Em servidores Linux, muitas vezes é necessário editar arquivos sem interface gráfica. Isso acontece ao ajustar scripts, arquivos de entrada de simulação, arquivos YAML, configurações do terminal e pequenos programas. Por isso, é importante saber usar pelo menos um editor em modo texto.

Uma boa regra para iniciantes é simples: use nano quando precisar editar rapidamente um arquivo; aprenda o básico de vim porque ele costuma estar presente em quase todo servidor; instale micro ou nvim quando quiser uma experiência mais confortável em um ambiente Conda próprio.

Antes de instalar qualquer editor, verifique se ele já existe no servidor:

which nano
which vim
which nvim
which micro

Se o comando which mostrar um caminho, por exemplo /usr/bin/vim, o programa já está disponível.

nano: editor simples para começar

O nano é um editor simples e indicado para iniciantes. Ele mostra os atalhos principais na parte inferior da tela e não exige conhecer modos de edição.

Para abrir ou criar um arquivo:

nano caso.in

Depois de editar, use Ctrl+o para salvar, pressione Enter para confirmar o nome do arquivo e use Ctrl+x para sair. O símbolo ^ mostrado pelo nano significa a tecla Ctrl.

Exemplo para editar um script:

nano rodar.sh

Exemplo para abrir um arquivo já posicionando o cursor em uma linha específica:

nano +25 parametros.yaml

Esse comando abre parametros.yaml na linha 25, útil quando uma mensagem de erro informa exatamente a linha problemática.

vi: editor mínimo quase sempre disponível

O vi é um editor clássico do Unix. Em muitos sistemas Linux, mesmo quando nano, vim ou emacs não estão instalados, há alguma versão de vi. Por isso, ele é importante como editor de emergência.

Para abrir um arquivo:

vi caso.in

Ao abrir o arquivo, o vi começa em modo de comando. Para inserir texto, pressione i. Para voltar ao modo de comando, pressione Esc. Para salvar e sair:

:wq

Para sair sem salvar:

:q!

Para procurar uma palavra dentro do arquivo:

/viscosidade

Depois da busca, pressione n para ir para a próxima ocorrência.

vim: versão mais completa do vi

O vim é uma versão mais poderosa do vi. Ele também trabalha com modos, mas oferece melhor ajuda, realce de sintaxe, edição mais confortável e muitos recursos extras.

Para abrir um arquivo:

vim caso.in

Para abrir diretamente em uma linha:

vim +120 simulacao.py

Comandos essenciais dentro do vim:

i       # entrar no modo de insercao
Esc     # voltar ao modo de comando
:w      # salvar
:q      # sair
:wq     # salvar e sair
:q!     # sair sem salvar
/texto  # procurar por texto

Apesar de parecer difícil no começo, conhecer o básico de vim é útil porque ele está disponível em muitos servidores. Em uma emergência, saber abrir, editar, salvar e sair já resolve a maior parte das necessidades.

nvim: Neovim

O nvim, também chamado de Neovim, é uma evolução moderna do vim. Para uso básico, os comandos são praticamente os mesmos:

nvim caso.in
nvim simulacao.py

Ele é uma boa opção para quem quer configurar um editor mais moderno no próprio ambiente de usuário, sem depender da configuração global do servidor.

Se estiver usando Miniforge ou Miniconda, é possível instalar o Neovim dentro de um ambiente Conda:

conda activate labmfa
mamba install -c conda-forge neovim

Se mamba não estiver disponível:

conda install -c conda-forge neovim

Depois da instalação, verifique:

which nvim
nvim --version

emacs: editor extensível

O emacs é um editor muito poderoso e extensível. Ele pode ser usado em modo texto no terminal, sem interface gráfica, e é comum em ambientes acadêmicos.

Para abrir um arquivo no terminal:

emacs -nw artigo.tex

A opção -nw significa no window, isto é, executar dentro do terminal atual. Comandos básicos:

Ctrl+x Ctrl+s    # salvar
Ctrl+x Ctrl+c    # sair
Ctrl+s           # procurar texto

Em alguns sistemas, o emacs pode não estar instalado. Em um ambiente Conda, quando o pacote estiver disponível no canal, use:

conda activate labmfa
mamba install -c conda-forge emacs

micro: editor moderno e simples

O micro é um editor de terminal moderno, leve e amigável para quem está acostumado com atalhos comuns de editores gráficos. Ele usa atalhos como Ctrl+s para salvar e Ctrl+q para sair.

Para instalar pelo Conda:

conda activate labmfa
mamba install -c conda-forge micro

Para abrir um arquivo:

micro simulacao.py

Atalhos básicos:

Ctrl+s    # salvar
Ctrl+q    # sair
Ctrl+f    # procurar
Ctrl+g    # ajuda

O micro é uma boa alternativa para alunos iniciantes quando o nano parece limitado e o vim ainda parece pouco intuitivo.

mcedit: editor do Midnight Commander

O mcedit é o editor de texto associado ao Midnight Commander, normalmente instalado junto com o comando mc. Ele é simples, visual e funciona bem dentro do terminal.

Para verificar se está disponível:

which mcedit

Para abrir um arquivo:

mcedit parametros.yaml

Atalhos comuns:

F2     # salvar
F10    # sair
F7     # procurar

Quando disponível no canal usado pelo aluno, o Midnight Commander pode ser instalado no ambiente Conda:

conda activate labmfa
mamba install -c conda-forge mc

joe: editor simples inspirado em editores antigos

O joe é outro editor em modo texto. Ele não é tão comum quanto nano ou vim, mas pode ser confortável para quem prefere uma interface simples e atalhos visíveis.

Para abrir um arquivo:

joe entrada.dat

Comandos básicos:

Ctrl+k h    # mostrar ajuda
Ctrl+k x    # salvar e sair
Ctrl+c      # sair ou cancelar

Se o pacote estiver disponível no canal Conda usado no servidor:

conda activate labmfa
mamba install -c conda-forge joe

Como escolher um editor

Para começar, use nano. Se você acessa servidores com frequência, aprenda o mínimo de vi ou vim, pois eles aparecem em muitos sistemas Linux. Se você quer um editor moderno instalado no seu próprio ambiente, experimente micro ou nvim. Se já conhece emacs, ele também funciona bem em modo texto.

O ponto mais importante é não depender de copiar arquivos para fora do servidor toda vez que uma pequena alteração for necessária. Em trabalho remoto, saber editar diretamente no terminal economiza tempo e evita erros de transferência.

Recursos avançados para processamento de dados remoto

Em trabalhos de computação científica, o servidor remoto não deve ser usado apenas para executar simulações. Ele também pode gerar gráficos, converter imagens, preparar arquivos para visualização e montar animações a partir de resultados. Fazer essas etapas remotamente evita transferir grandes volumes de dados para o computador pessoal e torna o fluxo de trabalho mais reprodutível.

O ponto central é evitar ferramentas que dependem de uma janela gráfica aberta. Em vez disso, prefira programas que salvam arquivos diretamente no disco, como gnuplot, scripts Python com matplotlib em modo offscreen, bibliotecas Python para VTK e o comando magick.

Um fluxo típico em um servidor do LabMFA é:

ssh nome_de_usuario@192.168.68.53
cd ~/simulacoes/caso01
conda activate posproc
python posprocessa.py
gnuplot grafico.gp
magick montage resultados_*.png -tile 4x -geometry 600x600+8+8 resumo.pdf
ffmpeg -framerate 20 -i frames/frame_%04d.png animacao.mp4

Para processamentos longos, execute os comandos dentro de tmux ou screen. Assim, a tarefa continua rodando mesmo que a conexão SSH seja interrompida.

Ambiente Conda para pós-processamento

Para manter as ferramentas de pós-processamento isoladas do sistema do servidor, crie um ambiente específico. O exemplo abaixo instala bibliotecas comuns para leitura de imagens, geração de gráficos, escrita de arquivos VTK e conversão de formatos:

mamba create -n posproc -c conda-forge \
  python=3.11 numpy scipy matplotlib pandas imageio pillow \
  pyvista vtk meshio gnuplot imagemagick

Se o comando mamba não estiver disponível, use conda:

conda create -n posproc -c conda-forge \
  python=3.11 numpy scipy matplotlib pandas imageio pillow \
  pyvista vtk meshio gnuplot imagemagick

Depois de criar o ambiente:

conda activate posproc
which python
which gnuplot
which magick

Esses comandos verificam se o Python, o gnuplot e o magick usados são os do ambiente ativo. Isso evita confusão entre versões do sistema e versões instaladas pelo usuário.

gnuplot: gráficos rápidos no servidor

O gnuplot é uma ferramenta leve para gerar gráficos a partir de arquivos de dados. Ele é muito útil em acesso remoto porque pode gerar arquivos PNG, PDF ou SVG sem abrir uma janela.

Para verificar se está instalado:

which gnuplot
gnuplot --version

Suponha um arquivo residuo.dat com duas colunas: iteração e resíduo. Para ver as primeiras linhas:

head residuo.dat

Crie um arquivo residuo.gp:

nano residuo.gp

Conteúdo do arquivo:

set terminal pngcairo size 1200,800 enhanced font "Arial,16"
set output "residuo.png"
set xlabel "Iteracao"
set ylabel "Residuo"
set grid
set logscale y
plot "residuo.dat" using 1:2 with lines linewidth 2 title "caso01"

Execute no servidor:

gnuplot residuo.gp
ls -lh residuo.png

Para gerar um PDF vetorial, útil para relatórios e artigos:

set terminal pdfcairo enhanced color font "Arial,12"
set output "residuo.pdf"
set xlabel "Iteracao"
set ylabel "Residuo"
set grid
set logscale y
plot "residuo.dat" using 1:2 with lines linewidth 2 title "caso01"

Depois rode:

gnuplot residuo.gp

Também é possível passar comandos diretamente pela linha de comando. Isso é prático para testes rápidos:

gnuplot -e 'set terminal pngcairo; set output "teste.png"; plot sin(x)'

Para comparar dois arquivos de dados:

set terminal pngcairo size 1200,800 enhanced font "Arial,16"
set output "comparacao.png"
set xlabel "Tempo"
set ylabel "Energia"
set grid
plot "caso01.dat" using 1:2 with lines title "caso01", \
     "caso02.dat" using 1:2 with lines title "caso02"

Converter sequências PNG para dados VTK com Python

Em algumas simulações ou experimentos, os resultados aparecem como uma sequência de imagens PNG. Para visualizar esses dados no ParaView ou em outras ferramentas científicas, pode ser útil transformar a sequência em um volume no formato VTK. Um arquivo .vti é uma variante XML do formato VTK para dados em grade regular.

Instale as bibliotecas necessárias no ambiente de pós-processamento:

conda activate posproc
mamba install -c conda-forge numpy imageio pyvista vtk

Organize as imagens com nomes ordenáveis:

ls frames/frame_*.png | head
ls frames/frame_*.png | tail

Crie o script png_para_vti.py:

nano png_para_vti.py

Conteúdo do script:

from pathlib import Path

import imageio.v3 as iio
import numpy as np
import pyvista as pv

arquivos = sorted(Path("frames").glob("frame_*.png"))

if not arquivos:
    raise SystemExit("Nenhum PNG encontrado em frames/frame_*.png")

fatias = []

for nome in arquivos:
    img = iio.imread(nome)

    if img.ndim == 3:
        rgb = img[..., :3].astype(np.float32)
        cinza = 0.299 * rgb[..., 0] + 0.587 * rgb[..., 1] + 0.114 * rgb[..., 2]
    else:
        cinza = img.astype(np.float32)

    fatias.append(cinza)

volume_zyx = np.stack(fatias, axis=0)
volume_xyz = np.transpose(volume_zyx, (2, 1, 0))

nx, ny, nz = volume_xyz.shape

grade = pv.ImageData()
grade.dimensions = (nx, ny, nz)
grade.origin = (0.0, 0.0, 0.0)
grade.spacing = (1.0, 1.0, 1.0)
grade.point_data["intensidade"] = volume_xyz.ravel(order="F")

grade.save("volume_png.vti")
print(f"Arquivo gravado: volume_png.vti ({nx} x {ny} x {nz})")

Execute remotamente:

conda activate posproc
python png_para_vti.py
ls -lh volume_png.vti

O arquivo volume_png.vti pode ser aberto no ParaView. Se o volume representar uma pilha temporal, cada imagem será tratada como uma fatia na direção z. Se a sequência representar instantes de tempo, pode ser melhor gerar um arquivo VTK separado para cada instante, ou usar um formato temporal próprio do ParaView.

Para converter uma única imagem PNG em uma grade VTK 2D:

from pathlib import Path

import imageio.v3 as iio
import numpy as np
import pyvista as pv

img = iio.imread("campo.png")

if img.ndim == 3:
    img = img[..., 0]

campo = img.astype(np.float32)
ny, nx = campo.shape

grade = pv.ImageData()
grade.dimensions = (nx, ny, 1)
grade.spacing = (1.0, 1.0, 1.0)
grade.point_data["intensidade"] = campo.T.ravel(order="F")
grade.save("campo_2d.vti")

Renderizar arquivos VTK em PNG e PDF com PyVista

O fluxo inverso também é muito comum: a simulação gera arquivos .vtk, mas o aluno precisa produzir imagens PNG ou PDF para relatórios, apresentações e artigos. Nesse caso, o PyVista pode abrir os arquivos VTK, renderizar a malha em modo offscreen e salvar a figura diretamente no servidor, sem abrir janela gráfica.

O exemplo abaixo é baseado em um script usado no LabMFA para processar pares de arquivos VTK:

interface-*.vtk
fluid-*.vtk

Ele renderiza o campo de velocidade, desenha a interface, remove a condição inicial, evita repetir figuras já geradas e aplica um corte automático nas bordas transparentes da imagem. Ao final, grava tanto o PNG cortado quanto uma versão PDF com fundo branco.

Instale as dependências no ambiente de pós-processamento:

conda activate posproc
mamba install -c conda-forge pyvista vtk pillow numpy

Se estiver em um servidor sem suporte gráfico configurado, pode ser necessário usar um framebuffer virtual. Em algumas instalações, basta descomentar a linha pv.start_xvfb() no script e instalar o suporte necessário no sistema. Quando o off_screen=True funcionar diretamente, essa linha não é necessária.

Crie o script:

nano vtk_para_png_pdf.py

Conteúdo:

from pathlib import Path
import re

import numpy as np
import pyvista as pv
from PIL import Image, ImageChops

# Se necessario, use framebuffer virtual:
# pv.start_xvfb()

# Diretorio base do caso.
# Ajuste este caminho para o caso que esta sendo processado no servidor.
project_dir = Path("/Users/nome_de_usuario/machines/studio/harmonic/")
project_dir /= "Re200_We20"

vtk_dir = project_dir / "vtk"
png_dir = project_dir / "png-generated"

png_dir.mkdir(parents=True, exist_ok=True)

# Reutilizar um unico Plotter reduz vazamento de memoria em lotes grandes.
plotter = pv.Plotter(off_screen=True)

filenames = sorted(vtk_dir.glob("interface-*.vtk"))

# Remove a condicao inicial, se existir.
if filenames:
    filenames.pop(0)

pattern = re.compile(r"interface-(\d+)\.vtk")

numbers = []
for file in filenames:
    match = pattern.search(file.name)
    if match:
        numbers.append(int(match.group(1)))

if not numbers:
    raise SystemExit("Nenhum arquivo interface-*.vtk valido encontrado.")

max_digits = len(str(max(numbers)))
print(f"Numero de digitos: {max_digits}")

for cfile in filenames:
    file_name = cfile.name

    match = re.search(r"(\d+)", file_name)
    if not match:
        continue

    num = int(match.group(1))
    padded_name = f"interface-{num:0{max_digits}d}.png"
    output_path = png_dir / padded_name
    crop_path = png_dir / padded_name.replace("interface", "cropped")
    pdf_path = crop_path.with_suffix(".pdf")

    if crop_path.exists() and pdf_path.exists():
        print(f"[SKIP] {crop_path.name} e {pdf_path.name} ja existem.")
        continue

    ivtkfile = cfile
    vtkfile = vtk_dir / file_name.replace("interface", "fluid")

    if not vtkfile.exists():
        print(f"[AVISO] Arquivo nao encontrado: {vtkfile}")
        continue

    print(f"Processando: {file_name}")

    mesh = pv.UnstructuredGrid(pv.read(vtkfile))
    imesh = pv.UnstructuredGrid(pv.read(ivtkfile))

    velocity = mesh.point_data.get_array("velocity")

    if velocity is None:
        raise RuntimeError(f"Campo velocity nao encontrado em {vtkfile}")

    # Exemplo: componente y da velocidade.
    field = velocity[:, 1]

    # Alternativa: magnitude da velocidade.
    # vel_magnitude = np.linalg.norm(velocity, axis=1)
    # mesh.point_data["velocity_mag"] = vel_magnitude
    # field = mesh.point_data["velocity_mag"]

    sargs = dict(
        label_font_size=9,
        vertical=True,
        n_labels=5,
        font_family="times",
        fmt="%.3f",
        color="white",
        height=0.6,
        position_x=0.9,
        position_y=0.1,
    )

    plotter.clear()
    plotter.add_mesh(
        mesh,
        scalars=field,
        style="surface",
        show_edges=False,
        line_width=1,
        edge_color="black",
        show_scalar_bar=False,
        scalar_bar_args=sargs,
        cmap="jet",
    )

    plotter.add_mesh(
        imesh,
        show_edges=True,
        style="wireframe",
        color="black",
        line_width=6,
        show_scalar_bar=False,
        cmap="jet",
    )

    plotter.view_xy()
    plotter.remove_legend()

    plotter.screenshot(
        str(output_path),
        transparent_background=True,
        window_size=[600, 600],
        scale=4,
    )

    # Crop automatico: remove bordas iguais ao fundo.
    im = Image.open(output_path)
    bg = Image.new(im.mode, im.size, im.getpixel((0, 0)))
    diff = ImageChops.difference(im, bg)
    diff = ImageChops.add(diff, diff, 2.0, -100)
    bbox = diff.getbbox()

    if bbox is None:
        print(f"[AVISO] Nao foi possivel recortar {output_path.name}")
        continue

    cropped = im.crop(bbox)
    cropped.save(crop_path)

    # PDF final com fundo branco, adequado para relatorios.
    if cropped.mode in ("RGBA", "LA"):
        background = Image.new("RGB", cropped.size, "white")
        background.paste(cropped, mask=cropped.split()[-1])
        background.save(pdf_path)
    else:
        cropped.convert("RGB").save(pdf_path)

    print(f"Arquivos gravados: {crop_path.name}, {pdf_path.name}")

plotter.close()

Execute no servidor:

conda activate posproc
python vtk_para_png_pdf.py

Confira os arquivos gerados:

ls -lh /Users/nome_de_usuario/machines/studio/harmonic/Re200_We20/png-generated | head
ls -lh /Users/nome_de_usuario/machines/studio/harmonic/Re200_We20/png-generated | tail

O diretório de saída terá imagens renderizadas completas, como interface-0001.png, e versões cortadas, como cropped-0001.png e cropped-0001.pdf. As versões cortadas são mais adequadas para incluir em documentos, porque removem margens vazias e preservam a região física de interesse.

Para montar um PDF de resumo com várias figuras cortadas, use o magick:

cd /Users/nome_de_usuario/machines/studio/harmonic/Re200_We20/png-generated
magick montage cropped-*.png -tile 4x -geometry 600x600+12+12 resumo.pdf

Para criar um vídeo a partir das imagens cortadas, prefira o ffmpeg quando o objetivo for gerar MP4:

ffmpeg -framerate 20 -pattern_type glob -i "cropped-*.png" \
  -vf "pad=ceil(iw/2)*2:ceil(ih/2)*2" \
  -c:v libx264 -pix_fmt yuv420p animacao.mp4

Antes de gerar muitos arquivos, verifique o volume de dados:

ls vtk/interface-*.vtk | wc -l
du -sh vtk png-generated

matplotlib: salvar figuras remotamente em modo offscreen

Ao usar Python por SSH, evite comandos que tentam abrir uma janela gráfica, como plt.show(). Em servidores remotos, o fluxo mais robusto é usar o backend Agg do Matplotlib e salvar diretamente em arquivo.

Exemplo de script grafico_offscreen.py:

nano grafico_offscreen.py

Conteúdo:

import matplotlib
matplotlib.use("Agg")

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0.0, 2.0 * np.pi, 400)
y = np.sin(x)

fig, ax = plt.subplots(figsize=(7, 4), dpi=150)
ax.plot(x, y, linewidth=2)
ax.set_xlabel("x")
ax.set_ylabel("sen(x)")
ax.grid(True)
fig.tight_layout()
fig.savefig("seno.png")
fig.savefig("seno.pdf")
plt.close(fig)

Execute no servidor:

conda activate posproc
python grafico_offscreen.py
ls -lh seno.png seno.pdf

Também é possível definir o backend pela variável de ambiente MPLBACKEND, sem modificar o script:

MPLBACKEND=Agg python grafico_offscreen.py

Para gerar uma sequência de figuras:

import matplotlib
matplotlib.use("Agg")

import matplotlib.pyplot as plt
import numpy as np
from pathlib import Path

Path("frames").mkdir(exist_ok=True)

x = np.linspace(0.0, 2.0 * np.pi, 400)

for k in range(100):
    y = np.sin(x - 0.1 * k)

    fig, ax = plt.subplots(figsize=(7, 4), dpi=150)
    ax.plot(x, y, linewidth=2)
    ax.set_ylim(-1.2, 1.2)
    ax.set_xlabel("x")
    ax.set_ylabel("sen(x - ct)")
    ax.grid(True)
    fig.tight_layout()
    fig.savefig(f"frames/frame_{k:04d}.png")
    plt.close(fig)

Depois de gerar os PNG, use magick para converter, reduzir e montar mosaicos. Para preparar vídeos, use ffmpeg.

magick: conversão e edição de imagens

O comando magick, do ImageMagick, converte imagens entre formatos, redimensiona figuras, recorta margens, combina imagens e pode montar animações a partir de sequências de arquivos. Ele é especialmente útil em servidores porque funciona inteiramente pela linha de comando.

Para verificar a instalação:

which magick
magick -version

Para converter uma imagem PNG em PDF:

magick figura.png figura.pdf

Para converter PNG em JPG com fundo branco:

magick figura.png -background white -alpha remove -alpha off figura.jpg

Para redimensionar uma imagem:

magick figura.png -resize 1600x figura_1600px.png

Para recortar bordas brancas automaticamente:

magick figura.png -trim +repage figura_trim.png

Para converter várias imagens PNG para JPG:

mkdir -p jpg
magick mogrify -path jpg -format jpg *.png

O comando acima preserva os arquivos PNG originais e grava as versões JPG no diretório jpg. Use mogrify com cuidado, porque ele também pode sobrescrever arquivos se usado sem -path.

Para criar um mosaico com várias imagens:

magick montage frames/frame_*.png -tile 5x4 -geometry 320x240+4+4 mosaico.png

Para criar um GIF animado a partir de uma sequência de PNG:

magick -delay 5 -loop 0 frames/frame_*.png animacao.gif

Para gerar um MP4, prefira o ffmpeg, discutido na próxima subseção. Algumas instalações do ImageMagick conseguem chamar delegados externos e gravar vídeo diretamente, mas isso depende da configuração local. O comando típico seria:

magick -delay 5 frames/frame_*.png animacao.mp4

Verifique se o formato aparece na instalação local:

magick -list format | grep -E "MP4|MPEG|PNG"

Em algumas instalações, o magick usa o ffmpeg por baixo dos panos para gravar MP4. Se o formato MP4 não aparecer na lista, use o ffmpeg diretamente. Para instalar as duas ferramentas no ambiente Conda:

conda activate posproc
mamba install -c conda-forge imagemagick ffmpeg

Depois, para vídeos, use a subseção de ffmpeg. Um teste rápido com magick, quando houver suporte local, seria:

magick -delay 5 frames/frame_*.png animacao.mp4
ls -lh animacao.mp4

Para reduzir o tamanho de uma sequência antes de montar o vídeo:

mkdir -p frames_pequenos
magick mogrify -path frames_pequenos -resize 1280x720 frames/frame_*.png
ffmpeg -framerate 25 -i frames_pequenos/frame_%04d.png animacao_720p.mp4

Antes de executar conversões grandes, confira quantos arquivos serão processados:

ls frames/frame_*.png | wc -l
du -sh frames

ffmpeg: criar e converter vídeos remotamente

O ffmpeg é a ferramenta mais indicada para criar vídeos a partir de sequências de imagens, converter formatos, ajustar resolução, controlar taxa de quadros e reduzir o tamanho de arquivos. Para gerar MP4 a partir de PNG, ele costuma ser mais previsível que o magick.

Para instalar no ambiente de pós-processamento:

conda activate posproc
mamba install -c conda-forge ffmpeg

Verifique a instalação:

which ffmpeg
ffmpeg -version

Criar MP4 a partir de nomes numerados

Se as imagens estão nomeadas como:

frames/frame_0000.png
frames/frame_0001.png
frames/frame_0002.png

gere um vídeo com 20 quadros por segundo:

ffmpeg -framerate 20 -i frames/frame_%04d.png \
  -c:v libx264 -pix_fmt yuv420p animacao.mp4

O padrão %04d indica números com quatro dígitos. Para nomes como frame_000001.png, use %06d.

A opção -pix_fmt yuv420p melhora a compatibilidade do vídeo com reprodutores comuns, navegadores e programas de apresentação.

Criar MP4 a partir de arquivos com curinga

Se os arquivos não seguem uma numeração perfeita, use o modo glob:

ffmpeg -framerate 20 -pattern_type glob -i "cropped-*.png" \
  -c:v libx264 -pix_fmt yuv420p animacao.mp4

Antes de executar, confira a ordem dos arquivos:

ls cropped-*.png | head
ls cropped-*.png | tail

O ffmpeg seguirá a ordem alfabética. Por isso, nomes com zeros à esquerda são importantes.

Resolver erro de dimensões ímpares

O codec libx264 frequentemente exige largura e altura pares. Se o ffmpeg reclamar de dimensões ímpares, aplique um padding:

ffmpeg -framerate 20 -i frames/frame_%04d.png \
  -vf "pad=ceil(iw/2)*2:ceil(ih/2)*2" \
  -c:v libx264 -pix_fmt yuv420p animacao.mp4

Esse filtro aumenta a imagem em no máximo um pixel por direção, apenas quando necessário.

Controlar qualidade e tamanho do arquivo

Use -crf para controlar qualidade. Valores menores produzem melhor qualidade e arquivos maiores. Valores comuns ficam entre 18 e 28:

ffmpeg -framerate 20 -i frames/frame_%04d.png \
  -c:v libx264 -crf 20 -pix_fmt yuv420p animacao_crf20.mp4

Para reduzir mais o tamanho:

ffmpeg -framerate 20 -i frames/frame_%04d.png \
  -c:v libx264 -crf 28 -pix_fmt yuv420p animacao_crf28.mp4

Redimensionar durante a criação do vídeo

Para gerar um vídeo em largura máxima de 1280 pixels, preservando a proporção:

ffmpeg -framerate 25 -i frames/frame_%04d.png \
  -vf "scale=1280:-2" \
  -c:v libx264 -pix_fmt yuv420p animacao_1280.mp4

O valor -2 deixa o ffmpeg escolher uma altura compatível com o codec.

Converter vídeo entre formatos

Para converter um vídeo MOV ou AVI para MP4:

ffmpeg -i entrada.mov -c:v libx264 -crf 22 -pix_fmt yuv420p saida.mp4
ffmpeg -i entrada.avi -c:v libx264 -crf 22 -pix_fmt yuv420p saida.mp4

Para extrair quadros de um vídeo:

mkdir -p frames_extraidos
ffmpeg -i animacao.mp4 frames_extraidos/frame_%04d.png

Boas práticas

Antes de gerar um vídeo grande, conte os quadros e verifique o tamanho do diretório:

ls frames/frame_*.png | wc -l
du -sh frames

Depois de gerar o vídeo, confira o arquivo:

ls -lh animacao.mp4
ffmpeg -i animacao.mp4

O segundo comando imprime informações do vídeo, como resolução, duração, taxa de quadros e codec. Ele pode terminar com uma mensagem de uso incompleto, mas ainda assim mostra os metadados necessários para inspeção.

Rotina de trabalho no LabMFA

Uso responsável dos servidores

Os computadores do LabMFA são recursos compartilhados. Isso significa que o comportamento de um usuário pode afetar o trabalho de outros alunos. Antes de executar tarefas pesadas, verifique a carga da máquina e combine o uso quando for necessário.

top
df -h
du -sh *

O comando top ajuda a ver CPU e memória. df -h mostra o uso dos discos. du -sh * mostra quais diretórios ocupam mais espaço no local atual.

Boas práticas:

• evite executar muitas simulações pesadas simultaneamente sem combinar com o grupo;

• salve resultados de forma organizada, com nomes que indiquem o caso físico, parâmetros e data quando necessário;

• remova arquivos temporários depois de confirmar que os resultados importantes foram salvos;

• não use o diretório pessoal como depósito permanente de todos os resultados;

• não altere arquivos de outros usuários;

• documente comandos importantes em um README.md ou em um script.

Para conferir processos do próprio usuário:

ps -u $USER
ps -u $USER -o pid,pcpu,pmem,cmd

Se um processo foi iniciado por engano e está consumindo muitos recursos, identifique o PID e encerre:

kill 12345

Estrutura recomendada para projetos

Um projeto organizado economiza tempo e facilita reproduzir resultados meses depois. Uma estrutura simples para simulações e pós-processamento é:

projeto/
  README.md
  environment.yml
  scripts/
  dados/
  casos/
  resultados/
  figuras/
  logs/

Um exemplo de criação dessa estrutura:

mkdir -p projeto/{scripts,dados,casos,resultados,figuras,logs}
touch projeto/README.md
touch projeto/environment.yml

Uso sugerido:

• scripts/: programas Python, shell scripts e arquivos de pós-processamento;

• dados/: dados brutos ou dados externos usados como entrada;

• casos/: arquivos de entrada de simulações;

• resultados/: saídas numéricas, arquivos VTK e tabelas;

• figuras/: PNG, PDF e vídeos gerados para relatórios;

• logs/: arquivos de saída textual de execuções longas.

Um README.md mínimo pode conter:

# Projeto Re200 We20

Ambiente:
conda env create -f environment.yml

Execucao:
python scripts/pos_processa.py casos/caso01.yml

Resultados principais:
resultados/caso01/

Problemas frequentes e diagnóstico

Mensagens de erro são parte normal do uso do terminal. O mais importante é ler a mensagem e testar hipóteses simples antes de modificar muitos arquivos.

ssh: connection refused

Esse erro pode indicar porta errada, serviço indisponível ou tentativa de usar o IP externo sem a porta correta.

ssh nome_de_usuario@IP_EXTERNO_RESTRITO -p PORTA_EXTERNA
ssh nome_de_usuario@192.168.68.53

Fora do laboratório, lembre-se de usar o IP externo com a porta da máquina. Dentro do laboratório, use o IP interno correspondente.

Senha pedida mesmo com chave SSH

Verifique se a chave pública foi copiada e se as permissões estão corretas:

ls -lh ~/.ssh
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

No computador local, confira se a chave existe:

ls -lh ~/.ssh/id_ed25519 ~/.ssh/id_ed25519.pub

No space left on device

Esse erro significa que algum disco está cheio ou sem espaço suficiente para novos arquivos.

df -h
du -sh *
du -sh resultados/*

Procure arquivos temporários, vídeos antigos, sequências PNG intermediárias e diretórios de teste que possam ser arquivados ou removidos.

command not found

O shell não encontrou o programa solicitado. Verifique se o nome está correto e se o ambiente adequado está ativo.

which python
which ffmpeg
conda activate mef
which python

O ambiente Conda não ativa

Se conda activate não funciona, inicialize o shell e abra uma nova sessão:

conda init bash
source ~/.bashrc
conda activate mef

Se o shell for zsh, use:

conda init zsh
source ~/.zshrc

rsync copiou para o lado errado

Sempre confira a direção da cópia. O lado antes do último argumento é a origem; o último argumento é o destino.

rsync -avh resultados/ nome_de_usuario@192.168.68.53:/home/nome_de_usuario/projeto/resultados/
rsync -avh nome_de_usuario@192.168.68.53:/home/nome_de_usuario/projeto/resultados/ ./resultados/

O primeiro comando envia arquivos para o servidor. O segundo baixa arquivos do servidor.

Jupyter remoto com túnel SSH

O Jupyter pode ser executado no servidor e acessado pelo navegador do computador local. A forma mais segura é iniciar o Jupyter sem abrir o navegador no servidor e criar um túnel SSH.

No servidor, dentro de uma sessão tmux:

conda activate mef
jupyter lab --no-browser --port 8888

O terminal mostrará um endereço com um token. Não compartilhe esse endereço publicamente.

No computador local, crie o túnel para o servidor. Dentro do laboratório:

ssh -L 8888:localhost:8888 nome_de_usuario@192.168.68.53

Fora do laboratório:

ssh -L 8888:localhost:8888 nome_de_usuario@IP_EXTERNO_RESTRITO -p PORTA_EXTERNA

Depois, abra no navegador local:

http://localhost:8888

Se a porta 8888 já estiver em uso, escolha outra porta, por exemplo:

jupyter lab --no-browser --port 8890
ssh -L 8890:localhost:8890 nome_de_usuario@192.168.68.53

Ao terminar, encerre o Jupyter com Ctrl+c no terminal onde ele foi iniciado.

VS Code Remote SSH

O VS Code pode editar arquivos diretamente no servidor usando a extensão Remote - SSH. Isso é útil para alunos que ainda não estão confortáveis com editores de terminal, mas o terminal continua importante para executar, monitorar e organizar os trabalhos.

Primeiro, configure um atalho em ~/.ssh/config no computador local:

Host jacaranda-labmfa
  HostName IP_EXTERNO_RESTRITO
  Port PORTA_EXTERNA
  User nome_de_usuario
  IdentityFile ~/.ssh/id_ed25519

Dentro do laboratório, um atalho por IP interno poderia ser:

Host jacaranda-labmfa-interno
  HostName 192.168.68.53
  User nome_de_usuario
  IdentityFile ~/.ssh/id_ed25519

No VS Code, instale a extensão Remote - SSH, escolha o host configurado e abra o diretório do projeto no servidor. Pela linha de comando, quando o comando code está disponível, também é possível usar:

code --remote ssh-remote+jacaranda-labmfa /home/nome_de_usuario/projeto

Evite abrir diretórios enormes como /home inteiro. Abra apenas a pasta do projeto. Isso reduz tráfego, indexação desnecessária e consumo de recursos no servidor.

Resumo rápido de comandos

A tabela abaixo serve como consulta rápida. Para aprender, use os exemplos das seções anteriores; para lembrar, volte a esta página.

Exercícios guiados

Os exercícios abaixo foram pensados para serem executados com calma. O objetivo não é decorar comandos, mas criar familiaridade com a rotina de trabalho.

Exercício 1: entrar no servidor e localizar-se

ssh nome_de_usuario@192.168.68.53
pwd
ls -lh
exit

Repita usando o acesso externo, quando estiver fora do laboratório:

ssh nome_de_usuario@IP_EXTERNO_RESTRITO -p PORTA_EXTERNA

Exercício 2: criar estrutura de projeto

mkdir -p teste_labmfa/{scripts,dados,resultados,logs}
cd teste_labmfa
pwd
touch README.md
ls -lh

Exercício 3: salvar saída de comando

date > logs/execucao.log
ls -lh >> logs/execucao.log
cat logs/execucao.log

Exercício 4: criar ambiente Conda

conda create -n teste-mef -c conda-forge python=3.12 numpy matplotlib
conda activate teste-mef
which python
python -c "import numpy; print(numpy.__version__)"
conda deactivate

Exercício 5: executar processo em tmux

tmux new -s teste
python -c "import time; [print(i) or time.sleep(1) for i in range(10)]"

Durante a execução, saia da sessão com Ctrl+b e depois d. Volte com:

tmux attach -t teste

Exercício 6: copiar resultados para o computador local

No computador local, execute:

rsync -avh nome_de_usuario@192.168.68.53:/home/nome_de_usuario/teste_labmfa/ ./teste_labmfa/

Adapte usuário, servidor e caminho conforme sua conta.

Glossário