Sistema Operacional Linux

From VeRLab Wiki
Jump to: navigation, search

As máquinas do Verlab/J utilizam em sua maioria o sistema operacional Ubuntu LTS que sempre são lançadas em anos pares: 2016, 2018, 2020, 2022...

Em geral, usamos a mais madura e não a recém lançada do ano, por motivos de já terem corrigidos os bug de lançamento. Por exemplo, em 2022 usávamos o ubuntu 20.04 e não o ubuntu 22.04. Porém em 2023 começamos a migrar as máquinas para ubuntu 22.04.



Introdução ao Uso do Linux





Dicas sobre uso de TMux, Byobu, screen e etc



Restaurar o .bashrc default no Ubuntu

Talvez o usuário editou incorretamente o .bashrc ou corrompeu o mesmo, e precisa restaurar para a versão default que o ubuntu cria ao criar a home do usuário. O arquivo default fica armazenado em /etc/skel/.bashrc e pode ser usado para sobreescrever o arquivo corrompido na home:

cat /etc/skel/.bashrc > ~/.bashrc
ou
cp /etc/skel/.bashrc ~/
referencias: link1 link2


Para comparar o conteúdo de /etc/skel.bashrc do ubuntu 22.04 foi colado abaixo: 
# ~/.bashrc: executed by bash(1) for non-login shells.
# see /usr/share/doc/bash/examples/startup-files (in the package bash-doc)
# for examples

# If not running interactively, don't do anything
case $- in
    *i*) ;;
      *) return;;
esac

# don't put duplicate lines or lines starting with space in the history.
# See bash(1) for more options
HISTCONTROL=ignoreboth

# append to the history file, don't overwrite it
shopt -s histappend

# for setting history length see HISTSIZE and HISTFILESIZE in bash(1)
HISTSIZE=1000
HISTFILESIZE=2000

# check the window size after each command and, if necessary,
# update the values of LINES and COLUMNS.
shopt -s checkwinsize

# If set, the pattern "**" used in a pathname expansion context will
# match all files and zero or more directories and subdirectories.
#shopt -s globstar

# make less more friendly for non-text input files, see lesspipe(1)
[ -x /usr/bin/lesspipe ] && eval "$(SHELL=/bin/sh lesspipe)"

# set variable identifying the chroot you work in (used in the prompt below)
if [ -z "${debian_chroot:-}" ] && [ -r /etc/debian_chroot ]; then
    debian_chroot=$(cat /etc/debian_chroot)
fi

# set a fancy prompt (non-color, unless we know we "want" color)
case "$TERM" in
    xterm-color|*-256color) color_prompt=yes;;
esac

# uncomment for a colored prompt, if the terminal has the capability; turned
# off by default to not distract the user: the focus in a terminal window
# should be on the output of commands, not on the prompt
#force_color_prompt=yes

if [ -n "$force_color_prompt" ]; then
    if [ -x /usr/bin/tput ] && tput setaf 1 >&/dev/null; then
	# We have color support; assume it's compliant with Ecma-48
	# (ISO/IEC-6429). (Lack of such support is extremely rare, and such
	# a case would tend to support setf rather than setaf.)
	color_prompt=yes
    else
	color_prompt=
    fi
fi

if [ "$color_prompt" = yes ]; then
    PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '
else
    PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
fi
unset color_prompt force_color_prompt

# If this is an xterm set the title to user@host:dir
case "$TERM" in
xterm*|rxvt*)
    PS1="\[\e]0;${debian_chroot:+($debian_chroot)}\u@\h: \w\a\]$PS1"
    ;;
*)
    ;;
esac

# enable color support of ls and also add handy aliases
if [ -x /usr/bin/dircolors ]; then
    test -r ~/.dircolors && eval "$(dircolors -b ~/.dircolors)" || eval "$(dircolors -b)"
    alias ls='ls --color=auto'
    #alias dir='dir --color=auto'
    #alias vdir='vdir --color=auto'

    alias grep='grep --color=auto'
    alias fgrep='fgrep --color=auto'
    alias egrep='egrep --color=auto'
fi

# colored GCC warnings and errors
#export GCC_COLORS='error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01'

# some more ls aliases
alias ll='ls -alFh'
alias la='ls -A'
alias l='ls -CF'

# Add an "alert" alias for long running commands.  Use like so:
#   sleep 10; alert
alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'

# Alias definitions.
# You may want to put all your additions into a separate file like
# ~/.bash_aliases, instead of adding them here directly.
# See /usr/share/doc/bash-doc/examples in the bash-doc package.

if [ -f ~/.bash_aliases ]; then
    . ~/.bash_aliases
fi

# enable programmable completion features (you don't need to enable
# this, if it's already enabled in /etc/bash.bashrc and /etc/profile
# sources /etc/bash.bashrc).
if ! shopt -oq posix; then
  if [ -f /usr/share/bash-completion/bash_completion ]; then
    . /usr/share/bash-completion/bash_completion
  elif [ -f /etc/bash_completion ]; then
    . /etc/bash_completion
  fi
fi




Stress test CPU, GPU, IO, etc



Criar regra udev para dispositivo USB

Para descobrir o idProduct e idVendor do dispositivo, pode-se usar:

udevadm info -a -n /dev/ttyACM0


Para criar o arquivo com a regra:

sudo nano /etc/udev/rules.d/99-ublox-gps.rules

Adicionar essa linha no arquivo e salvar o arquivo:

SUBSYSTEM=="tty", ATTRS{idVendor}=="1546", ATTRS{idProduct}=="01a9", MODE="0666", GROUP="dialout"

Se quiser criar um novo nome (link simbolico /dev/ublox) adicionar SYMLINK:

SUBSYSTEM=="tty", ATTRS{idVendor}=="1546", ATTRS{idProduct}=="01a9", SYMLINK+="ublox", MODE="0666", GROUP="dialout"

Desconectar e conectar o dispositivo da USB novamente para acionar a nova regra


Instalação de aplicativos

Caso esteja usando alguma maquina desktop do verlab, de preferencia por instalar via AppImage, aplicativos também pode ser instalados via contêiner Docker.

Snap

O Snap é um sistema de empacotamento e distribuição de aplicativos mantido pela Canonical, empresa responsável pelo Ubuntu. Diferente do Flatpak, o Snap já vem instalado por padrão no Ubuntu e sua instalação e gerenciamento de aplicativos geralmente exigem permissões de superusuário (sudo).

Alguns aplicativos disponíveis em Snap podem estar desatualizados em relação às versões oficiais, mas, em contrapartida, o Snap oferece grande compatibilidade e integração com o Ubuntu, justamente por ser desenvolvido e mantido pela própria Canonical.

Sua instalação é feita com o comando: sudo apt install snapd

A instalação de aplicativos via Snap é feita com: sudo snap install (nome-do-aplicativo)


Flatpak

O Flatpak é um formato de empacotamento de aplicativos que funciona de forma independente das bibliotecas do sistema. Cada aplicativo traz consigo suas próprias dependências, o que pode torná-los mais pesados em comparação a outros métodos de instalação, como os pacotes nativos da distribuição.

Entre as vantagens, destacam-se:

  • Compatibilidade: os aplicativos em Flatpak funcionam em diversas distribuições Linux, sem depender de versões específicas das bibliotecas do sistema.
  • Atualizações recentes: geralmente oferecem versões mais novas dos aplicativos em comparação aos repositórios oficiais de algumas distribuições.
  • Instalação sem privilégios de superusuário: não é necessário usar sudo para instalar ou executar aplicativos em Flatpak, sendo exigido apenas para a instalação inicial do próprio Flatpak na máquina.

Instalação do Flatpak

Para instalar o Flatpak no Ubuntu 18.10 ou superior: Guia oficial.

sudo apt update

sudo apt install flatpak

Instalando os plugins do GNOME para gerenciar aplicativos sem linha de comando:

sudo apt install gnome-software-plugin-flatpak

Adicionando o Flathub (repositório centralizado com diversos aplicativos):

flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo

Após adicionar, reinicie a máquina.

Uso do Flatpak

Instalar aplicativos: flatpak install nome.do.aplicativo

Desinstalar aplicativos: flatpak uninstall nome.do.aplicativo

Listar aplicativos instalados: flatpak list

Gerenciador gráfico recomendado: Flatseal Instalação: flatpak install flathub com.github.tchx84.Flatseal


AppImage

O AppImage é outro formato de empacotamento multiplataforma que permite executar aplicativos no Linux sem precisar de instalação tradicional. Ele é um arquivo único (extensão .AppImage) que contém todas as dependências necessárias para rodar o aplicativo.

Entre suas principais características:

  • Portabilidade: pode ser executado diretamente, sem necessidade de instalação no sistema.
  • Independência: não modifica bibliotecas ou arquivos do sistema.
  • Facilidade: basta dar permissão de execução e abrir o arquivo.

Como usar um AppImage

1. Baixe o arquivo .AppImage no site oficial do aplicativo. 2. Dê permissão de execução: chmod +x nome-do-arquivo.AppImage 3. Execute o arquivo: ./nome-do-arquivo.AppImage

O AppImage não precisa ser instalado no sistema e pode ser armazenado em qualquer pasta (ex.: ~/Aplicativos). Também é possível integrá-lo ao menu do sistema usando ferramentas como AppImageLauncher (github do projeto).
Tem esse tutorial que pode ajudar a entender e utilizar o AppImageLaucher:
https://www.edivaldobrito.com.br/integrador-appimagelauncher-no-linux/
e também o github do projeto e o guia de instalação oficial. Foi testado a ver~so .deb para ubuntu 18 (bionic) no ubuntu 20.04 e 24.04 e funcionou corretamente!


Backup de Discos

Este procedimento serve para criar cópias de segurança completas de um disco, caso algo seja corrompido ou perdido no original.

Existem várias formas de clonar discos. Em arquiteturas x86, o Clonezilla é uma boa opção. Para arquiteturas ARM (incluindo as placas Jetson), o utilitário de linha de comando dd faz bem o trabalho de clonagem bit a bit.



Usando dd para clonar discos

O dd copia o disco de origem byte a byte, incluindo MBR/bootloader, tabela de partições, sistemas de arquivos e dados. Isso é poderoso, mas também perigoso: um comando errado pode sobrescrever um disco inteiro.


Conectar o dispositivo

Conecte o disco que será clonado (fonte) a algum computador. Pode ser:

  • Diretamente em uma porta SATA / NVMe interna; ou
  • Em um case/enclosure USB para SSD/HDD/NVMe.

Em muitos cases/enclosures USB, um SSD NVMe pode aparecer como, por exemplo, /dev/sda.

Para identificar o nome do dispositivo (por exemplo, /dev/sda, /dev/sdb, /dev/nvme0n1), pode-se usar:

lsblk
ou
sudo fdisk -l

Atenção: verifique com cuidado qual é o disco de origem e qual é o de destino. Inverter estes dois no dd leva à perda definitiva de dados.


Verificar espaço disponível

A imagem clonada de um disco terá, em geral, o mesmo tamanho do disco de origem (por exemplo, um disco de 256 GB → imagem de ~256 GB). Logo, o local onde você salvará a imagem precisa ter espaço livre igual ou maior que a capacidade total do disco de origem.

  • Não é suficiente “caber só os dados”; o dd copia também o espaço vazio.
  • Compressão (por exemplo, com zstd) ajuda a economizar espaço em disco para armazenamento, mas para restaurar a imagem você ainda precisará de um disco de destino com o mesmo tamanho ou maior que o original.

Exemplo de comando para verificar o espaço na pasta de backups:

df -h /home/vitor/Documents/backups/

Adapte o caminho para a pasta onde as imagens de backup serão armazenadas.


Copiar o disco original para um arquivo de imagem

A seguir, considere:

  • /dev/sdX → disco de origem (que será clonado);
  • /caminho/para/backups/ → pasta onde a imagem será salva;
  • nome_da_imagem → nome escolhido para o arquivo de imagem.


  • Imagem bruta (mais rápida, porém maior)

Cria uma imagem sem compressão, copiando o disco inteiro byte a byte:

sudo dd if=/dev/sdX of=/caminho/para/backups/nome_da_imagem.img bs=4M status=progress conv=fsync

Onde:

  • if (input file) é o disco de origem;
  • of (output file) é o arquivo de imagem;
  • bs=4M define o tamanho do bloco de cópia (4 MB);
  • status=progress mostra o progresso;
  • conv=fsync força a gravação dos dados em disco ao final.

Exemplo real:
sudo dd if=/dev/sda of=/home/vitor/Documents/Verlab/GO2/backups/go2_edu_backup.img bs=4M status=progress conv=fsync


  • Imagem comprimida (usando zstd)

Aqui o dd envia a saída diretamente para o compressor zstd. Isso reduz o tamanho do arquivo armazenado, ao custo de mais uso de CPU.

sudo dd if=/dev/sdX bs=4M status=progress | zstd -12 -T0 > /caminho/para/backups/nome_da_imagem.img.zst

Onde:

  • -12 define o nível de compressão (maior = mais compacto, porém mais lento);
  • -T0 usa todos os núcleos de CPU disponíveis.

Exemplo real:
sudo dd if=/dev/sda bs=4M status=progress | zstd -12 -T0 > /home/vitor/Documents/Verlab/GO2/backups/go2_edu_backup.img.zst


Restaurar a imagem em outro disco (clonar para o destino)

O disco de destino deve ter tamanho igual ou maior que o disco original (o disco fonte usado na criação da imagem), não apenas igual ao tamanho do arquivo de imagem.

Quando o dd é usado para restaurar a imagem:

  • Todo o conteúdo do disco de destino será sobrescrito: tabela de partições, sistemas de arquivos e dados.
  • Se o disco de destino tem, por exemplo, 1 TB e o disco original tinha 250 GB, ao final você terá um disco com a mesma estrutura de 250 GB clonada e ~750 GB não particionados.
  • Depois da clonagem, será necessário usar uma ferramenta de particionamento (por exemplo, gparted, parted) para expandir a partição principal, caso você queira aproveitar o espaço extra.

Não tente:

  • Criar partições antes e depois rodar dd – o dd irá sobrescrever a tabela de partições.
  • Rodar dd diretamente para uma partição (por exemplo, /dev/sda1) quando a imagem contém o disco inteiro – isso não é equivalente e não funcionará corretamente.

Antes de gravar a imagem, desmonte o disco de destino (se alguma partição estiver montada):

sudo umount /dev/sdY1

(adaptando /dev/sdY1 para as partições do disco de destino).

Considere agora:

  • /dev/sdY → disco de destino.


  • Restaurar a partir de uma imagem bruta

sudo dd if=/caminho/para/backups/nome_da_imagem.img of=/dev/sdY bs=4M status=progress conv=fsync

Exemplo real:
sudo dd if=/home/vitor/Documents/Verlab/GO2/backups/go2_edu_backup.img of=/dev/sda bs=4M status=progress conv=fsync


  • Restaurar a partir de uma imagem comprimida (zstd)

Neste caso, a imagem é descompactada on the fly e enviada diretamente ao dd:

zstd -dc -T0 /caminho/para/backups/nome_da_imagem.img.zst | sudo dd of=/dev/sdY bs=4M status=progress conv=fsync

Onde:

  • -d → descomprimir;
  • -c → enviar saída descomprimida para stdout (console), permitindo o pipe para dd.

Exemplo real:
zstd -dc -T0 /home/vitor/Documents/Verlab/GO2/backups/go2_edu_backup.img.zst | sudo dd of=/dev/sda bs=4M status=progress conv=fsync


Testar o disco clonado

Depois de escrever a imagem no disco de destino, é recomendável fazer alguns testes básicos.

  • Criar um diretório temporário para montagem:

mkdir /tmp/test_mount

  • Montar uma das partições do disco clonado em modo somente leitura (-o ro). 
 Em geral, a partição maior é a que contém o sistema (pastas /home, /usr, etc.):

sudo mount -o ro /dev/sda1 /tmp/test_mount

(adapte /dev/sda1 para a partição correta).

  • Verificar o conteúdo:

ls /tmp/test_mount

Se aparecerem diretórios como home, usr, etc etc., é um bom sinal de que a clonagem foi bem-sucedida.

Mensagens como "wrong fs type" ou "bad superblock" indicam que:

  • A clonagem falhou; ou
  • Você montou a partição errada (por exemplo, uma partição de boot em vez da partição de sistema).
  • Desmontar a partição de teste:

sudo umount /tmp/test_mount

Sempre que possível, faça também um teste de boot a partir do disco clonado (por exemplo, usando um enclosure USB e configurando a BIOS/UEFI para inicializar por ele). Isso é a validação mais forte de que o backup está funcional.



Compressão e integridade dos backups

Imagens de disco costumam ser arquivos muito grandes. Para facilitar armazenamento e aumentar a segurança contra corrupção de dados (bit rot, problemas em HD, etc.), vale combinar compressão com arquivos de reparo.


  • Compressão com zstd

O zstd (Zstandard) é um compressor moderno, rápido e com bom nível de compactação. Para comprimir uma imagem já criada:

zstd -12 -T0 nome_da_imagem.img

Isto irá gerar um arquivo nome_da_imagem.img.zst.


  • Arquivos de reparo com par2

O par2 cria arquivos de redundância (parity files) que permitem reparar a imagem caso alguns bytes sejam corrompidos.

Exemplo de criação de arquivos de reparo com 10% de redundância:

par2create -r10 -n2 nome_da_imagem.img

Onde:

  • -r10 → cria aproximadamente 10% de dados extras de paridade;
  • -n2 → número de arquivos .par2 gerados (pode variar conforme preferência).

Depois de criar os arquivos de reparo, é recomendável verificar a integridade com:

par2verify nome_da_imagem.img.par2

Armazene juntos, na mesma pasta de backup:

  • A imagem comprimida (por exemplo, nome_da_imagem.img.zst);
  • Os arquivos .par2 de reparo.

Assim, mesmo que haja pequenos danos no arquivo de imagem, há chance de recuperação usando os arquivos de paridade.

Retrieved from "http://www.verlab.dcc.ufmg.br/mediawiki/index.php?title=Sistema_Operacional_Linux&oldid=1602"