Criando um Arch Linux de bolso a partir de

qualquer distribuição

INTRODUÇÃO

O Arch Linux é uma distribuição rolling release que encanta pelo seu vasto
repositório, mas que põe medo em muitos, por sua fama de "distro para usuários
avançados".

Que o Arch é uma distro muito versátil todos nós já sabemos, e por conta disso
podemos adaptar o sistema para os mais diversos cenários, inclusive para ser
um sistema de bolso, num pendrive.

A não muito tempo atrás ajudei um amigo a criar um pendrive com o Arch Linux
instalado, e procurando na internet, não achei muito conteúdo sobre essa
operação, muito menos sobre fazer direto de um terminal do Arch. Sendo assim,
venho trazer no VOL um método de realizar esse processo, sem muita
complicação.

ESCLARECIMENTOS

O artigo foi escrito para pendrives iniciarem em dispositivos UEFI. Mas o que vai
diferenciar a instalação para BIOS e UEFI é justamente a criação da partição
EFI, e também a instalação do Grub para um ou outro. Sendo assim, sinta-se
livre para adaptar à sua necessidade. Está contido o processo para instalação do
Grub Bios na documentação do Arch.

É importante salientar que para instalar o Arch Linux e tudo que é necessário,
recomendo um pendrive de no mínimo 16GB, porém um de 8GB já consegue
suportar algumas poucas coisas e pode ser o suficiente para alguns, é relativo
ao uso que você vai destinar ao aparato.

Os procedimentos aqui descritos foram testados no Arch, Manjaro, Endeavour

OS, Ubuntu, Debian e Fedora. As fontes de pesquisa estão contidas no final do
artigo.

Dito isso, vamos começar.

PREPARANDO O PENDRIVE

Primeiro devemos criar as partições no nosso pendrive, sendo elas: uma para
efi, uma para swap e a partição raiz, onde vai ficar o sistema e nossos arquivos.

Utilize o gparted ou o cfdisk para criar as três partições. A partição efi deve ter no
mínimo 260MB, e recomendo colocar 2GB para a partição de swap, porém, se
tiver apenas um pendrive de 8GB disponível, coloque 1GB para swap. A partição
efi deve ser criada em FAT ou FAT32, e as outras duas em ext4.

Estando o meu pendrive em /dev/sdb e as partições dele sendo sdb1 (FAT ou

FAT32 - efi), sdb2 (ext4 - swap) e sdb3 (ext4 - raiz), devemos realizar o seguinte
processo:

Observações:
■ o nome do pendrive e o nome das partições pode variar pra você, então

use a nomenclatura do seu dispositivo

■ para saber o nome das partições do seu pendrive, rode o seguinte

comando como superusuário:

# fdisk -l

1. Formate a partição efi:

# mkfs.vfat /dev/sdb1 -I

2. Formate a partição de swap:

# mkswap /dev/sdb2

3. Ative a partição de swap:

# swapon /dev/sdb2

Para verificar se o swap está funcionando, utilize:

# swapon -s

4. Formate a partição raiz:

# mkfs.ext4 /dev/sdb3

5. Use o seguinte comando para verificar as partições, se quiser:

# lsblk /dev/sdb

Pronto! Seu pendrive já está ajustado para receber o Arch.

INSTALAÇÃO A PARTIR DE OUTROS SISTEMAS LINUX

Algumas distros, como o Fedora e o Gentoo, têm o gerenciador de pacotes

pacman e o utilitário arch-install-scripts em seu repositório. Nessas distros, o
processo de instalação ocorre da mesma forma do Arch Linux e distros
baseadas no mesmo. Todavia, em distros como o Ubuntu, que não tem o
pacman em sua coleção, o processo é um pouco mais trabalhoso.

Além de prepararmos o pendrive, devemos preparar um ambiente Arch Linux,

para que possamos trabalhar de dentro dele.

Primeiro, é necessário baixar a imagem bootstrap do Arch Linux. Para isso, entre
num dos espelhos do site do Arch, ou acesse diretamente o link:
■ http://br.mirror.archlinux-br.org/iso/latest/

Baixe a imagem bootstrap em tar.gz.

1. Extraia no diretório /tmp:

# tar -xf archlinux-bootstrap-*-x86_64.tar.gz -C /tmp/

Essa extração vai criar a pasta root.x86_64.

2. Descomente o espelho da sua preferência no arquivo mirrorlist:

# nano /tmp/root.x86_64/etc/pacman.d/mirrorlist

3. Para criar o ambiente chroot, rode os seguintes comandos:

# cd /tmp/root.x86_64
# cp /etc/resolv.conf etc/
# mount -t proc /proc proc/
# mount --rbind /sys sys/
# mount --rbind /dev dev/
# mount --rbind /run run/

4. Finalmente, para entrar no ambiente chroot:

# chroot /tmp/root.x86_64 /bin/bash

5. Iniciar o chaveiro do Pacman:

# pacman-key --init
# pacman-key --populate archlinux

Para sair do chroot, utilize exit ou ctrl+d.

A partir do ambiente Arch que acabamos de criar, você pode utilizar o mesmo
procedimento para Arch Linux e distros Arch-based.

CRIANDO UM ARCH LINUX DE BOLSO A PARTIR DO ARCH E DISTROS

ARCH-BASED

Para instalar a partir de sistemas Arch ou Arch-based, é necessário o pacote

arch-install-scripts, que vai nos fornecer comandos como pacstrap e arch-chroot.

1. Monte a partição raiz do pendrive em /mnt:

# mount /dev/sdb3 /mnt

2. Instale o sistema base e alguns outros componentes na partição raiz:

# pacstrap /mnt base base-devel linux linux-firmware

3. Gerar arquivo fstab (File System Table). Utilizaremos o parâmetro -U para criar
uma UUID exclusiva para cada partição.

# genfstab -U -p /mnt/ >> /mnt/etc/fstab

Caso você queira conferir ou editar o fstab:

# nano /mnt/etc/fstab

4. Para entrarmos dentro do nosso pendrive:

# arch-chroot /mnt

5. Recomendo habilitar o repositório multilib, para que aplicações de 32 bits

rodem no seu sistema. Para isso, edite o arquivo pacman.conf:

# nano /etc/pacman.conf

Descomente essas linhas:

include = /etc/pacman.d/mirrorlist

Agora sincronize os repositórios:

# pacman -Sy

Caso o nano não esteja instalado:

# pacman -Sy nano

6. Configurar a localização (descomente essa linha: pt_BR.UTF-8 UTF-8):

# nano /etc/locale.gen

Ler o locale.gen e gerar nossa localização:

# locale-gen

Criar arquivo de configuração de língua:

# echo LANG=pt_BR.UTF-8 > /etc/locale.conf

# export LANG=pt.BR.UTF-8
7. Para configurar o teclado, edite o arquivo vconsole.conf:

# nano /etc/vconsole.conf

Adicione essa linha no arquivo:

KEYMAP=br-abnt2

8. Configurar o fuso-horário:

# ls /usr/share/zoneinfo/America

Identifique o seu estado ou um estado que corresponda ao seu fuso-horário, no

meu caso é Belém, adapte o comando para sua necessidade:

# ln -sf /usr/share/zoneinfo/America/Belem /etc/localtime

Sincronizar o relógio do hardware com o do sistema:

# hwclock --systohc --utc

9. Dê um nome para sua máquina:

# echo archlinux > /etc/hostname

Adicione a linha equivalente:

127.0.1.1 archlinux.localdomain archlinux

10. Instale o microcódigo:

Se você tiver processador Intel:

# pacman -S intel-ucode

No caso de processadores da AMD, o pacote linux-firmware já cobre.

11. Crie uma imagem init ram disk:

# mkinitcpio -p linux
12. Baixe e instale o GRUB. Para baixar:

# pacman -S grub

Monte a partição efi em /boot/efi:

# mkdir /boot/efi
# mount /dev/sdb1 /boot/efi

Instale o GRUB:

# grub-install --target=x86_64-efi --efi-directory=/boot/efi --removable --recheck

# grub-mkconfig -o /boot/grub/grub.cfg

13. Definir senha de root:

# passwd

14. Crie um usuário e defina a senha:

# useradd -m -g users -G wheel,storage,power -s /bin/bash pedro

# passwd pedro

15. Editar o arquivo sudoers:

# nano /etc/sudoers

Encontre essas linhas:

## Uncomment to allow members of group wheel to execute any command

# %wheel ALL=(ALL) ALL

Descomente a linha: %wheel ALL=(ALL) ALL

16. Instale componentes de Wifi e gerenciamento de rede, se quiser:

# pacman -S wpa_supplicant networkmanager net-tools dhcpcd

# systemctl enable NetworkManager

Pronto! Nossa instalação está finalizada :)

Desmonte a partição em /boot/efi:

# umount /boot/efi

Saia do chroot utilizando ctrl+d ou exit.

Desmonte a partição raiz do pendrive:

# umount /mnt

Quando você iniciar o sistema contido no pendrive, pode ativar a conexão com a
internet rodando o comando dhcpcd (ethernet) ou nmtui (wireless).

FONTES

■ Instale o Arch Linux a partir do Linux existente - ArchWiki

■ Installation guide - ArchWiki

■ Install Arch Linux on a removable medium (Português) - ArchWiki

■ GRUB (Português) - ArchWiki

■ GitHub - tokland/arch-bootstrap: Bootstrap a base Arch Linux system

 Trilha Filesystems Linux - Operação de Sistemas de Arquivos

Gostaria de compartilhar com vocês um assunto bem importante para administração de

sistemas Linux, que são os filesystems. Vou dividir o assunto em 3 partes, acredito que seja
melhor para o entendimento e os testes, assim poderemos avançar seguramente. Nesse
artigo, destaco o arquivo /etc/fstab, alguns comandos e também uma forma de montar
partições usando o systemd. Pegue seu café e venha curtir essa leitura!

/ETC/FSTAB E MOUNT

Um arquivo e um comando que sempre andam juntos no Linux /etc/fstab e

mount.

1. /etc/fstab:

O que precisamos entender nesse arquivo:

■ O filesystem (UUID, dispositivo /dev/sdb1 ou LABEL);

■ O ponto de montagem (/opt/teste /);

■ O tipo do filesystem (ext4, xfs, auto) - auto identifica automaticamente o

tipo do filesystem;

■ As opções, aqui podemos usar o defaults (ele agrupa alguns tipos de

opções);

■ O dump (usado para backup, ele faz um dump da partição, normalmente

se usa 0);

■ O pass (se vai rodar um fsck toda vez que inicia o sistema, o / sempre

com 1, as demais usam o 2).

2. mount (lê as informações do /etc/fstab e faz a montagem das partições):

Algumas opções de uso do comando mount:

mount -a

Monta tudo que esta dentro do /etc/fstab - com a opção (auto) setada.

df -Th

Mostra as partições do sistema e se estão montadas:

Sist. Arq. Tipo Blocos de 1K Usado
Disponível Uso% Montado em
udev devtmpfs 498448 0
498448 0% /dev
tmpfs tmpfs 102036 1784
100252 2% /run
/dev/sda1 ext4 19862136 3748892
15081260 20% /
tmpfs tmpfs 510160 0
510160 0% /dev/shm
tmpfs tmpfs 5120 0
5120 0% /run/lock
tmpfs tmpfs 510160 0
510160 0% /sys/fs/cgroup
tmpfs tmpfs 102032 0
102032 0% /run/user/1000
/dev/sdb1 ext4 5095040 20472
4796040 1% /opt/montagem

Pode ver que o /dev/sdb1 está montado em /opt/montagem.

Algumas opções usadas no comando mount:

■ asysnc (joga em cache, buffer os dados e depois que isso é gravado no

disco, performance do sistema);

 ■ auto (significa que a partição será montada no boot do sistema e quando

usado mount -a);

■ noauto (é o contrário do auto);

■ defaults (contem um grupo de opções, que são: rw, suid, dev, exec,

auto, nouser, async);

■ dev (blocos especiais que serão interpretados);

■ nodev (ao contrário);

■ exec (permite executável);

■ noexec (ao contrário);

■ group (permite que um usuário comum faça a montagem da partição se

o dono pertencer a esse grupo);

■ user (permite que qualquer usuário possa manter o filesystem, mas só

quem montou pode desmontar);

■ nouser (qualquer usuário pode montar a partição e qualquer usuário

pode desmontar a partição).

3. mount mais detalhado:

Veja abaixo alguns exemplos de uso do comando mount:

O comando que monta as partições estando ou não montadas:

mount (rodando apenas esse comando ele mostra apenas as partições que
estão montadas)

mount | grep sd
/dev/sda1 on / type ext4
(rw,relatime,errors=remount-ro,data=ordered)
/dev/sdb1 on /opt/montagem type ext4
(rw,relatime,data=ordered)

cat /proc/mounts (seria outro comando que mostra a mesma coisa)

cat /etc/mtab (seria outra forma, também de visualizar as partições que estão
montadas)

Mostra o que está montado nesse momento:

mount -h (algumas opções do comando mount)

Monta um sistema de arquivos. Opções:

■ -a, --all :: monta todos os sistemas de arquivos mencionados no fstab;

■ -c, --no-canonicalize :: não canoniza caminhos;

■ -f, --fake :: teste; ignora a chamada de sistema do mount(2);

■ -F, --fork :: faz fork de cada dispositivo (usa com -a);

■ -T, --fstab <caminho> :: arquivo alternativo ao /etc/fstab;

■ -i, --internal-only :: não chama os ajudantes de mount.<tipo>;

■ -l, --show-labels :: mostra também os rótulos dos sistemas de arquivos;

■ -n, --no-mtab :: não escreve para no /etc/mtab;

■ -o, --options <lista> :: lista separada por vírgula de opções de

montagem;

■ -O, --test-opts <lista> :: limita o conjunto de sistemas de arquivos (usa

com -a).

mount -t ext4 (mostra apenas as partições do tipo ext4)

/dev/sda1 on / type ext4
(rw,relatime,errors=remount-ro,data=ordered)
/dev/sdb1 on /opt/montagem type ext4
(rw,relatime,data=ordered)

Se a partição estiver setada no /etc/fstab:

mount /dev/sdb1 ou $ mount /opt/montagem

Se a partição não estiver no /etc/fstab:

mount /dev/sdb1 /opt/teste (primeiro o dispositivo e depois o ponto de
montagem)
umount /dev/sdb1 (para desmontar essa partição)
mount -t ext4 /dev/sdb1 /opt/teste (monta usando o tipo ext4)
mount -o ro,user,auto,exec /dev/sdb1 /opt/teste

UUID, DISPOSITIVOS E LABEL DE PARTIÇÃO

E como eu posso encontrar mais informações como UUID, dispositivos, LABEL

de uma partição?

Faça:

# blkid (mostra o UUID de todas as partições)

blkid
/dev/sda1: UUID="4d8a74e7-adfe-440e-8f10-050e48099a93"
TYPE="ext4" PARTUUID="c0b6c47f-01"
/dev/sda5: UUID="9261dd6f-5839-4d26-8f56-6fe73575dbb6"
TYPE="swap" PARTUUID="c0b6c47f-05"
/dev/sdb1: UUID="0849ccae-5119-4542-994b-f51a81c06af5"
TYPE="ext4" PARTUUID="5bf7c908-01"

mount -U 0849ccae-5119-4542-994b-f51a81c06af5 /opt/teste (montagem

usando o UUID)
ou:
mount UUID=0849ccae-5119-4542-994b-f51a81c06af5 /opt/teste

Para montar com LABEL:

mount LABEL=partiçãox /opt/teste

# lsblk (mostra informações sobre os dispositivos/partição)

NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sda 8:0 0 20,4G 0 disk
├─sda1 8:1 0 19,4G 0 part /
├─sda2 8:2 0 1K 0 part
└─sda5 8:5 0 1023M 0 part [SWAP]
sdb 8:16 0 20,5G 0 disk
└─sdb1 8:17 0 5G 0 part /opt/montagem
sr0 11:0 1 1024M 0 rom

lsblk -f (mostra o UUID)

NAME FSTYPE LABEL UUID
MOUNTPOINT
sda
├─sda1 xfs
c65b472f-08c5-4ea5-a913-1735eaf817c3 /boot
└─sda2 LVM2_member
iKi6g2-As53-dcoX-cp1a-RD8q-GWUN-XpMQ65
├─centos-root xfs
227ab08e-6fe4-43b7-bdc7-ae34cdb2c7b4 /
└─centos-swap swap
ca56a6b0-c654-4f0f-b5e3-0c27b3190403 [SWAP]
sdb
├─sdb1 LVM2_member
rApJfu-38zu-CXro-1FKz-nk22-SF31-HHi4zw
└─sdb2 LVM2_member
Q2fDSU-FWcn-gXhI-DudD-M9sG-XsMH-LTP9RY
sdc
├─sdc1 LVM2_member
db2i8b-46gF-9whc-HAxB-9n9j-Z1ny-zClZx6
└─sdc2
sr0

# e2label /dev/sda2 (mostra o LABEL dessa partição)

# findfs UUID=4d8a74e7-adfe-440e-8f10-050e48099a93 (mostra o filesystem
desse UUID)
/dev/sda1

findfs LABEL=partiçãon (trás o filesystem dessa LABEL)

findmnt (mostra as partições e pontos de montagem)

TARGET SOURCE
FSTYPE OPTIONS
/ /dev/sda1
ext4
rw,relatime,errors=remount-ro,data=ordered
├─/sys sysfs
sysfs rw,nosuid,nodev,noexec,relatime
│ ├─/sys/kernel/security securityfs
securityfs rw,nosuid,nodev,noexec,relatime
│ ├─/sys/fs/cgroup tmpfs
tmpfs ro,nosuid,nodev,noexec,mode=755
│ │ ├─/sys/fs/cgroup/systemd cgroup
cgroup
rw,nosuid,nodev,noexec,relatime,xattr,release_agen
t=/lib/systemd/systemd-cgroups
│ │ ├─/sys/fs/cgroup/memory cgroup
cgroup rw,nosuid,nodev,noexec,relatime,memory
│ │ ├─/sys/fs/cgroup/net_cls,net_prio cgroup
cgroup
rw,nosuid,nodev,noexec,relatime,net_cls,net_prio
│ │ ├─/sys/fs/cgroup/freezer cgroup
cgroup
rw,nosuid,nodev,noexec,relatime,freezer
│ │ ├─/sys/fs/cgroup/cpu,cpuacct cgroup
cgroup
rw,nosuid,nodev,noexec,relatime,cpu,cpuacct
│ │ ├─/sys/fs/cgroup/cpuset cgroup
cgroup rw,nosuid,nodev,noexec,relatime,cpuset
│ │ ├─/sys/fs/cgroup/perf_event cgroup
cgroup
rw,nosuid,nodev,noexec,relatime,perf_event
│ │ ├─/sys/fs/cgroup/pids cgroup
cgroup rw,nosuid,nodev,noexec,relatime,pids
│ │ ├─/sys/fs/cgroup/devices cgroup
cgroup
rw,nosuid,nodev,noexec,relatime,devices
│ │ └─/sys/fs/cgroup/blkio cgroup
cgroup rw,nosuid,nodev,noexec,relatime,blkio
│ ├─/sys/fs/pstore pstore
pstore rw,nosuid,nodev,noexec,relatime
│ └─/sys/kernel/debug debugfs
debugfs rw,relatime

MONTANDO PARTIÇÕES COM O SYSTEMD

Vimos até o momento que as partições são montadas com base nas informações
do arquivo /etc/fstab. Mas existe uma outra forma de se fazer isso, usando o
systemd para gerenciar pontos de montagem.

Vamos até o diretório /etc/systemd/system:

cd /etc/systemd/system

Lembrando que vamos usar o ponto de montagem (/opt/montagem). É

necessário criar um arquivo chamado (vim opt-montagem.mount) - esse nome
precisa ser o caminho do diretório de montagem.

Nesse arquivo, escrevemos o seguinte:

[Unit]
Description=Ponto de Montagem Teste

[Mount]
What=/dev/sdb1
Where=/opt/montagem
Type=ext4
Options=defaults

[Install]
WantedBy=multi.user.target

Agora, vamos usar o comando systemctl para gerenciar isso:

systemctl status opt-montagem.mount
opt-montagem.mount - Ponto de Montagem Teste
Loaded: loaded
(/etc/systemd/system/opt-montagem.mount; disabled;
vendor preset: enabled)
Active: inactive (dead)
Where: /opt/montagem
What: /dev/sdb1

systemctl status opt-montagem.mount

opt-montagem.mount - Ponto de Montagem Teste
Loaded: loaded
(/etc/systemd/system/opt-montagem.mount; disabled;
vendor preset: enabled)
Active: active (mounted) since Sat 2020-08-01
22:09:12 -03; 2s ago
Where: /opt/montagem
What: /dev/sdb1
Process: 22565 ExecMount=/bin/mount /dev/sdb1
/opt/montagem -t ext4 -o defaults (code=exited,
status=0/SUCCESS)
Tasks: 0 (limit: 4915)
CGroup: /system.slice/opt-montagem.mount

df -Th
Sist. Arq. Tipo Tam. Usado Disp. Uso%
Montado em
udev devtmpfs 487M 0 487M 0%
/dev
tmpfs tmpfs 100M 3,1M 97M 4%
/run
/dev/sda1 ext4 19G 4,6G 14G 26% /
tmpfs tmpfs 499M 0 499M 0%
/dev/shm
tmpfs tmpfs 5,0M 0 5,0M 0%
/run/lock
tmpfs tmpfs 499M 0 499M 0%
/sys/fs/cgroup
tmpfs tmpfs 100M 0 100M 0%
/run/user/1000
/dev/sdb1 ext4 4,9G 20M 4,6G 1%
/opt/montagem

Se eu executar um stop no serviço, ele desmonta a partição:

systemctl stop opt-montagem.mount #(ele executa o umount da partição)

Para que essa partição sempre seja montada no boot, basta:

systemctl enable opt-montagem.mount

Created symlink
/etc/systemd/system/multi.user.target.wants/opt-montagem.m
ount → /etc/systemd/system/opt-montagem.mount.

CONCLUSÃO

Obrigado pela leitura pessoal, fico à disposição para comentar sobre.

Agradeço imensamente ao professor de Linux Ricardo, por todo o ensinamento

até o momento e à comunidade Linux.
 FIND - Encontrar informações no Linux

INTRODUÇÃO

Administradores de sistemas e usuários finais costumam precisar encontrar

informações, como arquivos e diretórios em suas máquinas ou servidores. Um
dos comandos mais utilizados no Linux para essa tarefa é o find, que pode ser
utilizado com diversas opções nas pesquisas realizadas.

Dentre as funcionalidades desse comando, podemos destacar: tamanho; data;

horário de modificação; permissões; usuários; dentre diversas outras. Outro
ponto interessante, é que esse comando está instalado por padrão na grande
maioria das distribuições Linux.

O layout mais comum desse comando é:

find <startingdirectory> <opções> <termo de busca>

Inicia-se com o comando find, depois o argumento <startingdirectory>, que é o

ponto de origem onde iremos iniciar a pesquisa. Quando o usuário desejar
buscar o sistema todo, irá utilizar a raiz do sistema, o / neste argumento.

O segundo argumento utilizado é o filtro para procurar os arquivos (informações).

Pode-se utilizar o nome de um arquivo, tipo, data de criação ou modificação,
dentre outras opções. Já o terceiro argumento é um acompanhamento do
segundo, onde especifica-se o termo de busca relevante.

Irei agora apresentar algumas opções de utilização esse comando.

Busca simples pelo nome de um arquivo:

find . -name arquivo.txt

./arquivo.txt

Neste exemplo, buscou-se na pasta atual (.), um arquivo como o nome

arquivo.txt (-name arquivo.txt). O retorno foi de 1 arquivo com esse nome.

Busca ignorando case sensitive:

find /home/ -iname arquivo.txt
./arquivo.txt
./Arquivo.txt

Agora, buscou-se no diretório /home qualquer arquivo com o nome arquivo.txt,

com letras maiúsculas ou minúsculas. Como retorno obteve-se 2 arquivos.

Busca com coringas:

find /home/ -name *rquivo*

./home/arquivo.txt
./home/Arquivo.txt
./home/Meus_Arquivo-NOVOS.txt
./home/arquivo.sh

Busca realizada no diretório /home, para qualquer arquivo que possua "rquivo".
Como retorno obteve-se 4 arquivos.

Busca por diretórios:

find / -type -d -name Fotos arquivo.txt

/home/user/Fotos

Na busca por diretórios, utilizou-se "-type -d", obtendo 1 resultado no retorno.

Buscar por um tipo de arquivo:

find / -type f -name "*.odt"

./cursos.odt
./artigos.odt

Utilizou-se a opção -name para buscar arquivos com a extensão odt.

Buscar arquivos com a permissão 777:

find . -type f -perm 0777 -print

Este tipo de busca é muito utilizada em servidores Linux, para verificar se os

usuários estão deixando arquivos com esse tipo de permissão, que é vulnerável,
neste tipo de máquina.
Buscar arquivos e diretórios vazios:

find ArquivosCompartilhados/ -empty

ArquivosCompartilhados /DirVazio
ArquivosCompartilhados /arquivoVazio.txt

Buscar pastas ocultas:

find /tmp -type d -name ".*"

Buscar arquivos maiores que 50MB no diretório atual:

find . -type f -size +50M

Buscar e remover um arquivo:

find . -type f -name arquivoVazio.txt -exec rm -f {} ;

Neste exemplo, busca-se o arquivoVazio.txt, e caso ele seja encontrado, será

removido do sistema.

Buscar por uma informações dentro do arquivo:

find ArquivosCompartilhados/ -name "*.*" -exec grep -Hin "drSolutions" {} ;

ArquivosCompartilhados/fornecedores.txt:1:drSolutions

Buscamos arquivos com o texto "drSolutions" dentro deles.

Buscar arquivos acessados nas últimas 24 horas:

find . -type f -atime -1 -exec ls -l {} ;

Buscar arquivos acessados nos últimos 5 minutos:

find . -type f -amin -5

Buscar arquivos criados nas últimas 12 horas:

find . -type f -ctime -0.5 -exec ls -l {} ;

Buscar arquivos executáveis:

find / -perm /a=x

Buscar arquivos disponíveis apenas para leitura:

find / -perm /u=r

Caso você queira conhecer melhor o comando find, utilize o manual da seguinte
forma:

man find

E você, como utiliza o comando find?

 Saiba como compilar e instalar
programas Linux distribuídos
diretamente pelo código-fonte [tar.gz]

Hoje em dia, instalar programas no Linux se tornou a coisa mais simples de se

fazer no sistema. Dependendo da distribuição Linux, você tem recursos
complementares que facilitam ainda mais o processo.

Gerenciadores de pacotes e repositórios oficiais, mantidos pela comunidade

mantenedora da distribuição, enriquecem o processo de instalação dos programas.
Contudo, em muitos momentos você se depara com programas disponibilizados
diretamente pelo código-fonte. Assim, cabe ao usuário ter conhecimento prévio para
compilar e instalar programas Linux distribuídos diretamente pelo código-fonte,
normalmente compactados via tar.gz.

Contextualizando
As distribuições Linux, ao longo do tempo, vem melhorando e criando métodos para
facilitar a instalação de pacotes no Linux. Gerenciadores de pacotes, bem como: apt
e yum, são exemplos legados dessas mudanças. Atualmente, existem projetos
que visam a universalização do modo e distribuição de programas para os
sistemas Linux. Entre eles, destaco o Snap e Flatpak; Canonical e Red Hat como
mantenedoras, respectivamente.

Entretanto, vão aparecer situações onde você não terá nenhuma dessas opções
disponíveis… pois alguns desenvolvedores de softwares disponibilizam seus
programas diretamente pelo código-fonte (source) – que por sinal era, nos
primórdios, o único método utilizado para instalação de programas no Linux
(algumas distribuições ainda mantêm essa técnica com frequência).Em resumo,
você tem acesso a um arquivo compactado no formato .tar.gz (maioria das vezes),
contendo o código-fonte do programa, e a instalação consiste em compilar e
instalar os executáveis gerados na máquina.

Mas por quê ainda se preocupar com isso se existem pacotes pré-compilados
para instalação?!

SAIBA MAIS

Pacotes pré-compilados são pacotes já compilados e distribuídos num arquivo

pronto, com dependências já configuradas, em um formato simples de instalar (.deb
– Debian e .rpm – Red Hat, por exemplo).

Devido às diferenças que existem entre uma distribuição e outra um pacote do

Fedora não funcionará no Debian, por exemplo. Assim, essa técnica garante
suporte a todas as distribuições Linux, universalmente! Ou seja, baixando um
programa distribuído a partir do código-fonte (source), não será preciso se ater a
qual distro Linux você está usando; pois, verificada as dependências necessárias,
será possível compilar e instalar o programa.

Isso se deve ao fato de que essa maneira de distribuir os programas, diretamente

pelo código-fonte (source), não é feita por empacotamento pré-compilado (pacote
.deb ou .rpm, por exemplo). Assim, cabe ao usuário ter conhecimento prévio para
compilar e instalar programas Linux distribuídos diretamente pelo código-fonte,
normalmente compactados via tar.gz.

SAIBA MAIS

Compilar significa transformar o código-fonte, escrito pelo programador, nos

arquivos binários que são executados pelo sistema.

Por outro lado, um problema, em compilar e instalar programas a partir dos fontes, é
que o processo é demorado e, para muitos, nem sempre simples. É preciso ter
instalado uma grande quantidade de compiladores e bibliotecas, necessários para
compilar os mais diversos programas. E isso causa bastante dificuldade para os
usuários, principalmente iniciantes.

Em 4 passos…
Resumindo o processo de instalação de programas disponibilizados a partir do
código-fonte, informo que o mesmo se dá em 4 passos:

1- Descompactar o arquivo tar.gz que contém o código-fonte;

2- Resolver dependências necessárias para a instalação correta do programa –

cada programa possui suas próprias dependências, e isso torna processo demorado
e um pouco mais complicado. Cada programa tem sua peculiaridade;

3- Compilar;

4- Instalar;

DETALHES

Neste tutorial usei como exemplo o programa Pidgin IM e o sistema OpenSUSE

Tumbleweed

1- Baixar e descompactar o arquivo tar.gz

Primeiramente, faça o download do arquivo pidgin-2.11.0.tar.gz AQUI [ Versão

2.11.0 ]
O arquivo baixado é um tarball, geralmente é identificado através do uso de duas
extensões “.tar” e “.gz”, combinadas para formar “.tar.gz”. Uma extensão combinada
simples, .tar.bz também é popular. Esse formato usa o utilitário tar para criar um
único tarfile com todo o conteúdo do diretório – o código-fonte do programa, no
caso.

Para descompactar o conteúdo do arquivo arquivo pidgin-2.11.0.tar.gz, você deve

executar o comando:

tar -xzvf pidgin-2.11.0.tar.gz

Entre no diretório descompactado:

cd pidgin-2.11.0

O conteúdo do diretório contém o código-fonte da aplicação e o arquivo

😉
Makefile, entre outros arquivos. Essa estrutura garante um programa distribuído
a partir do código-fonte (source) Por isso, nem todo arquivo “tar.gz”
significará um programa distribuído dessa forma; poderá ser apenas um arquivo
compactado.

SAIBA MAIS

O Makefile é um arquivo para configuração de compilação utilizado pelo programa

make, cuja ideia é simplificar e agilizar a compilação de programas.

2- Resolver dependências

Esta etapa pode ser considerada a mais “complexa” do processo, pois caso as
dependências necessárias, da aplicação, não sejam atendidas o código-fonte não
poderá ser compilado e instalado, futuramente. E cada aplicação possui um leque
diferente de dependências.
No caso do programa Pidgin existem algumas dependências que precisam ser
resolvidas – ou seja pacotes que já precisam estar instalados no sistema, pois caso
contrário dará erro no processo!

Em distribuições derivadas do Debian, a principal dependência é pacote de

compiladores que contém todas as ferramentas básicas para compilação de um
programa. Muito conhecido, chamado de build-essential:

sudo apt-get install build-essential

Como usei o OpenSUSE, o pacote equivalente é o devel_basis:

sudo zypper install -t pattern devel_basis

Assim, depois de satisfazer as dependências do sistema, é preciso resolver as

pendências da aplicação. Para isso, você DEVE executar o comando:

./configure

Esse comando verifica todas dependências que o programa precisa, como se o

pacote de compiladores está instalado; por exemplo. O prefixo ./ diz ao sistema
Linux para procurar o arquivo de configuração no diretório atual e executá-lo.
Assim, você precisa estar dentro do diretório do programa (pidgin-2.11.0) para
poder executar esse comando:

[….] checking for strdup… yes

checking for strstr… yes

checking for atexit… yes….]

Se tudo correr bem, você não verá quaisquer erros:

] Build with Perl support……. : yes

Build with Tcl support…….. : yes

Build with Tk support……… : yes

Print debugging messages…… : no

Pidgin will be installed in /usr/local/bin.

configure complete, now type ‘make’

Caso apresente algum erro, basta examinar a saída do comando ./configure e

instalar/configurar todas as dependências ausentes usando seu gerenciador de

😉
pacotes. Execute ./configure quantos vezes for preciso até que você não veja
mais erros

No meu caso (com o openSUSE Tumbleweed instalado), tive alguns erros que
avisaram a ausência de alguns pacotes. Portanto, segue lista de todos os pacotes
que foi precisa instalar no meu ambiente de testes:
AVISO

Cada sistema vai apresentar resultados diferentes. Pois, poderão surgir

dependências que estarão resolvidas e outras não. Por isso, essa etapa requer mais
atenção do usuário Linux.

sudo zypper install intltool glib2-devel gtk2-devel libXss1 libXss.so.1 libXss-devel

libSM-devel meanwhile-devel libgnutls-devel tcl-devel tk-devel

3- Compilação

Depois de ter resolvido todas as dependências, você deve compilar o programa.

Use o comando make para fazer isso:

make

Este processo pode demorar alguns minutos, dependendo do programa.

😉
Certifique-se de que a saída não exibirá quaisquer erros antes de continuar para o
próximo passo

4- Instalação

Pronto… não tendo apresentado nenhum erro até agora, você precisa instalar o
programa. Basta executar sudo make install. Este passo move todos os binários
em seu local correto no seu sistema para que o programa fique pronto para usar:

sudo make install

Programa instalado!!
Mas, se você desejar remover o programa, que acabou de instalar, basta entrar no
diretório que você instalou o programa e executar os 2 comandos abaixo:

sudo make uninstall

sudo make clean

Por fim, informo que para instalar a maioria dos programas a partir do código-fonte
(source), você passará pelas mesmas situações do exemplo. Contudo, com
algumas diferenças das mostrados aqui. Por exemplo, você pode precisar usar
cmake em vez de make. Por isso, sempre leia o arquivo “README” contido no

😉
diretório de cada programa!! Além dele, normalmente, existe o arquivo “Install”
também
 Compilação do Kernel

INTRODUÇÃO

Vamos começar com a boa e velha máxima:

Leia todo o artigo antes de sair executando comandos!

Será uma compilação entre básica e intermediária. O objetivo é o aprendizado

do Linux. A compilação foi voltada para o Debian e derivados, mas nada impede
que você tome por base e adapte ela para a tua distribuição. Talvez ocorram
alguns erros durante a compilação, mas faz parte. Eu procurei minimizar ao
máximo os erros que porventura aconteceram. Os erros foram acontecendo e eu
fui sanando. Caso aconteça algum erro para você, leia a mensagem de erro,
pesquise e procure solucioná-lo ou poste o erro nos comentários.

Vamos ver, inicialmente, a versão atual do kernel.

# uname -r

O kernel aqui é o 4.9.0-16-amd64. Caso queira mais informações:

# uname -a

No link https://www.kernel.org/ vemos que a versão mais atualizada é a 5.13.10.

Podemos baixá-la clicando no ícone amarelão ali ou podemos fazer na linha de
comando. Faremos na linha de comando porque é mais divertido.

Veremos também alguma coisa de otimização do kernel, mas nada muito

profundo. O Kernel que se encontra em kernel.org é genérico, se adapta a
qualquer distribuição Linux. Quando você baixa uma distribuição Linux
atualizada ela já vem com o kernel mais recente. Porém, muitas vezes, na
compilação podemos habilitar módulos e suportes específicos para cada
arquitetura de computador.

São muitas opções de configuração no Kernel Linux, portanto, antes de sair

configurando, estude e saiba o que está fazendo... ou saia mexendo feito louco e
bagunce toda tua máquina, pelo menos aprenderá alguma coisa. Então, o
presente artigo tem a finalidade útil de aprendizado.

Esta compilação é a mesma que eu faço já há uns 10 anos, somente atualizei

por causa das dependências, comandos etc. A vantagem de um kernel
atualizado e otimizado é óbvia: maior durabilidade do sistema, melhor
desempenho etc. Tenho esse Debian desde 2012, somente fui atualizando,
compilando kernel e atualizando programas. Isso vale para qualquer distribuição
Linux. Nesse anos compilei o kernel desse mesmo sistema somente três vezes.

INSTALAÇÃO

As instalações seguiram o básico:

■ Instalar o sistema;

■ Particionar manualmente;

■ Configurar o arquivo sources.list;

■ Atualizar o sistema.

Aqui não será abordada a instalação do sistema, somente a compilação do

kernel.

Preparando a compilação (no Debian e derivados):

# apt-get update
# aptitude safe-upgrade
# aptitude install vim vim-doc

O último comando não é necessário (o Vim é um editor de texto, pode usar o

editor da tua preferência).

Caso tua distribuição tenha o Yum, o RPM ou outro gerenciador de pacotes, a

estrutura básica da coisa é a mesma: atualize.

Instalando os pacotes necessários (a maioria dos pacotes abaixo, necessários

para a compilação, tem para a maioria das distribuições, alguns mudam de
nome, mas durante a instalação você verá a mensagem):
# apt-get install build-essential module-init-tools kernel-package
initramfs-tools libaal-dev wget liblzo2-dev gzip libncurses5 libncurses5-dev
dpatch udev binutils module-assistant
# apt-get install binutils module-assistant libelf-dev bin86 flex bison
# apt-get install linux-headers-`uname -r`
# cd /usr/src
(entrando no diretório próprio para isso)
# wget https://www.kernel.org/pub/linux/kernel/v5.x/linux-5.13.10.tar.xz
(baixando)

Essa versão deu 113,82M.

Caso queira conferir se baixou, execute:

# ls
(para ver o conteúdo do diretório)

# tar -xv --xz -f linux-5.13.10.tar.xz

(descompactando)

# cd linux-5.13.10
(não utilizamos link simbólico)

# make mrproper
(limpa prováveis compilações anteriores e deleta o arquivo .config)

# make-kpkg clean
(limpa prováveis compilações anteriores, provavelmente aparecerá "sem regra
para processar o alvo...", esse aviso é normal, pois deve ser uma compilação
"limpa")

Agora vamos descobrir qual o processador da máquina:

# cat /proc/cpuinfo

Abaixo está uma parte da saída do comando acima.

processor : 0
vendor_id : GenuineIntel
cpu family : 6
model : 42
model name : Intel(R) Core(TM) i5-2430M CPU @
2.40GHz
stepping : 7
microcode : 0x1b
cpu MHz : 1150.781
cache size : 3072 KB
physical id : 0
siblings : 4
core id : 0
cpu cores : 2
apicid : 0
initial apicid : 0
fpu : yes
fpu_exception : yes
cpuid level : 13
wp : yes
flags : fpu vme de pse tsc msr pae mce cx8
apic sep mtrr pge mca cmov pat pse36 clflush dts
acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx
rdtscp lm constant_tsc arch_perfmon pebs bts
rep_good nopl xtopology nonstop_tsc aperfmperf pni
pclmulqdq dtes64 monitor ds_cpl vmx est tm2 ssse3
cx16 xtpr pdcm pcid sse4_1 sse4_2 x2apic popcnt
tsc_deadline_timer aes xsave avx lahf_lm epb
kaiser tpr_shadow vnmi flexpriority ept vpid
xsaveopt dtherm ida arat pln pts
bugs : cpu_meltdown spectre_v1 spectre_v2
spec_store_bypass l1tf mds swapgs itlb_multihit
bogomips : 4789.33
clflush size : 64
cache_alignment : 64
address sizes : 36 bits physical, 48 bits
virtual
power management:
Porém, a informação desse comando não é suficiente, execute:

# cc -march=native -E -v - </dev/null 2>&1 | grep cc1

Veja a saída desse comando, que beleza:

/usr/lib/gcc/x86_64-linux-gnu/6/cc1 -E -quiet -v
-imultiarch x86_64-linux-gnu - -march=sandybridge -mmmx
-mno-3dnow -msse -msse2 -msse3 -mssse3 -mno-sse4a -mcx16
-msahf -mno-movbe -maes -mno-sha -mpclmul -mpopcnt
-mno-abm -mno-lwp -mno-fma -mno-fma4 -mno-xop -mno-bmi
-mno-bmi2 -mno-tbm -mavx -mno-avx2 -msse4.2 -msse4.1
-mno-lzcnt -mno-rtm -mno-hle -mno-rdrnd -mno-f16c
-mno-fsgsbase -mno-rdseed -mno-prfchw -mno-adx -mfxsr
-mxsave -mxsaveopt -mno-avx512f -mno-avx512er
-mno-avx512cd -mno-avx512pf -mno-prefetchwt1
-mno-clflushopt -mno-xsavec -mno-xsaves -mno-avx512dq
-mno-avx512bw -mno-avx512vl -mno-avx512ifma
-mno-avx512vbmi -mno-clwb -mno-mwaitx -mno-clzero -mno-pku
--param l1-cache-size=32 --param l1-cache-line-size=64
--param l2-cache-size=3072 -mtune=sandybridge

Na última opção (-mtune=xxxxx), está a informação que precisamos junto com a

de cima, para saber o que colocar na opção do menuconfig.

Antes saía o tipo mtune (Core2, Dual Core etc), agora saiu o nome da "família".
No caso é um Core i5, por isso execute os dois comandos: cat /proc/cpuinfo e a
linha acima do cc). Qualquer dúvida, jogue na internet o nome da "família" que
aparecer em -mtune.

No caso do Core 2 Duo, do Dual Core e dos Pentium 4, foi marcada a opção
Core 2/newer Xeon, por eles terem dois núcleos (cores).

A saída do comando anterior será mais amplamente utilizada adiante. Capture a

tela, ou execute o comando novamente depois de configurar o kernel pelo make
menuconfig. Mas não se preocupe, depois isso será lembrado.

CONFIGURANDO E OTIMIZANDO
Execute:

# make menuconfig
(entra nas configurações do kernel)

Para entrar nas opções, dê Enter e para alterar de "M" para "*", e vice-versa, é
só pressionar a barra de espaços. A opção "M" compila como módulo, a opção
"*" compila embutido no kernel. A escolha vai de cada parâmetro. Como módulo
não fará parte do "monólito" do kernel.

Para sair de uma opção, dê Esc duas vezes seguidas. Navegue com as setas de
direção.

Vá em: Processor type and features (enter) → Processor Family

(Generic-x86-64)

...navegue e marque (barra de espaços) a opção que corresponde ao

processador da sua máquina. Ao dar barra de espaços o menu voltará
automaticamente. No meu caso, marquei Core 2/newer Xeon, por ele ter quatro
núcleos (Cores). Caso ficar na dúvida, deixe a opção padrão: Generic-x86-64

Mais abaixo, vá em "Timer frequency". Se a sua instalação for para servidor,

marque a opção "100 HZ" (isso melhorará o tempo de resposta do servidor para
as requisições). Para Desktop, deixe "250 HZ".

Retorne ao menu principal: Esc + Esc

Vá em: Networking support → Networking options → Network packet filtering

framework (netfilter) → IP: Netfilter Configuration

E marque todas as opções relativas ao nf_tables. Esse parâmetro não tem a ver
com otimização, mas com suporte ao nftables.

Tecle: Esc + Esc

Vá em IPv6: "Netfilter Configuration" e marque as duas opções do Nftables.

Tecle: Esc + Esc

Vá em "IPv4/IPV6 bridge connection tracking support" e marque essa opção.

Volte ao menu principal dando ESC e cuidando até aparecer o menu principal
"Linux/x86 5.13.10 Kernel Configuration".
Vá em "File Systems", marque os sistemas de arquivos utilizados com "*". No
meu caso, ext4 (/boot) com btrfs (demais partições).

* Dica: para ext4, marque a primeira opção (The Extended 4 (ext4) filesystem)
com "*", e deixe as 3 seguintes marcadas.

Caso você quiser, os parâmetros com os arquivos de sistemas os quais tem no

seu sistema Linux você pode colocar "*" para compilar embutido no kernel, o
suporte do kernel ao sistema de arquivos fica melhor, porém, quanto mais
opções se coloca como "*" maior ficará o tamanho do kernel após a compilação.
Alguns parâmetros é melhor ficarem como módulo (M).

Na dúvida, deixe como no padrão que já está ali.

Para o btrfs, ficaram marcadas as opções:

■ Btrfs filesystem support;

■ Btrfs POSIX Access Control Lists e

■ Btrfs will run sanity tests upon loading.

■ Btrfs debugging support

De acordo com os sistemas de arquivos que você tem no seu Linux (ext4, Btrfs
etc) configure como queira.

Mais abaixo, vá em: "Network File Systems"

E se for servidor, coloque um "*" na opção "NFS server support".

Volte: Esc + Esc

Logo abaixo, vá em "Native language support" e marque com "*", as opções:

■ Codepage 860 (Portuguese)

■ ASCII (United States)

■ NLS ISO 8859-1 (Latin 1; Western European Languages)

■ LS UTF-8
Retorne ao menu principal selecionando EXIT. Após o último EXIT, aparecerá a
janela "Do you wish...", deixe como: "Yes" e dê Enter.

Execute:

# ls -a

E veja se o arquivo ".config" foi gravado. Se não, repita a operação.

Agora, vamos alterar os arquivos necessários para otimizar a compilação de

acordo com o processador da máquina:

# cc -march=native -E -v - &1 | grep cc1

Veja a saída desse comando, que beleza de novo:

/usr/lib/gcc/x86_64-linux-gnu/6/cc1 -E -quiet -v
-imultiarch x86_64-linux-gnu - -march=sandybridge -mmmx
-mno-3dnow -msse -msse2 -msse3 -mssse3 -mno-sse4a -mcx16
-msahf -mno-movbe -maes -mno-sha -mpclmul -mpopcnt
-mno-abm -mno-lwp -mno-fma -mno-fma4 -mno-xop -mno-bmi
-mno-bmi2 -mno-tbm -mavx -mno-avx2 -msse4.2 -msse4.1
-mno-lzcnt -mno-rtm -mno-hle -mno-rdrnd -mno-f16c
-mno-fsgsbase -mno-rdseed -mno-prfchw -mno-adx -mfxsr
-mxsave -mxsaveopt -mno-avx512f -mno-avx512er
-mno-avx512cd -mno-avx512pf -mno-prefetchwt1
-mno-clflushopt -mno-xsavec -mno-xsaves -mno-avx512dq
-mno-avx512bwroot@seibei:/usr/src/linux-5.13.10#
-mno-avx512vl -mno-avx512ifma -mno-avx512vbmi -mno-clwb
-mno-mwaitx -mno-clzero -mno-pku --param l1-cache-size=32
--param l1-cache-line-size=64 --param l2-cache-size=3072
-mtune=sandybridge
ignoring nonexistent directory
"/usr/local/include/x86_64-linux-gnu"
ignoring nonexistent directory
"/usr/lib/gcc/x86_64-linux-gnu/6/../../../../x86_64-linux-
gnu/include"
#include "..." search starts here:
#include <...> search starts here:
/usr/lib/gcc/x86_64-linux-gnu/6/include
/usr/local/include
/usr/lib/gcc/x86_64-linux-gnu/6/include-fixed
/usr/include/x86_64-linux-gnu
/usr/include
End of search list.

Para sair, dê enter.

Vamos alterar os arquivos (segue uma lista completa dos arquivos com as linhas
a serem alteradas). É necessário alterar somente 3 arquivos (os 3 primeiros
abaixo), porém, se você é paranoico e obcecado, altere os outros 10 também:

* IMPORTANTE: em todos os arquivos, altere as opções "march" para

"-march=native", as opções "mcpu" para "-mcpu=native" e as opções "mtune"
para "mtune=processador". Nesta última opção, "mtune", coloque o que aparecer
na saída do comando cc -march=native -E -v - &1 | grep cc1. No meu caso ficou
"-mtune=sandybridge".

Se a versão do GCC for 4.5.1, inclusive, para baixo, deixe "-mtune=generic".

Como anteriormente instalamos e atualizamos a versão do GCC (o GCC, o G++
e o MAKE, entre outros, estão no pacotão "build-essential"), não precisa se
preocupar muito com isso. A não ser que seu sistema e seu hardware sejam
bem antigos.

Para ver a versão do GCC, digite:

# gcc --version

Para os arquivos abaixo utilize a busca do editor de texto, as linhas coloquei

somente como parâmetro. Aconselho a alterar manualmente e não usar ctrl+c,
ctrl+v.

Lista de arquivos:

# vim /usr/src/.../...
(use teu editor de texto preferido)

1. /usr/src/linux-5.13.10/arch/x86/boot/compressed/Makefile - linha ~35, opção

march=native;

2. /usr/src/linux-5.13.10/arch/x86/Makefile - linhas 25, 28, 123, 124, 127 e 128

(march); linhas 127, 129 e 130, (mtune);
3. /usr/src/linux-5.13.10/arch/x86/Makefile_32.cpu - tem várias linhas, utilize a
busca do seu editor de texto. Neste arquivo tem duas opções que não devem ser
mudadas: -mtune=$(1),$(2)) e -mcpu=$(1),$(2)), as outras pode mudar.

Neste último arquivo acima, atenção especial na linha 47

"cflags-$(CONFIG_X86_GENERIC += $(call tune,generic,$(call tune,i686))", que
deverá ficar assim:

cflags-$(CONFIG_X86_GENERIC += $(call tune,sandybridge,$(call

tune,sandybridge))

(coloque o correspondente ao teu processador)

Este arquivo de número 3 é o que otimizará a compilação para o processador da

máquina.

A partir daqui, continue se quiser extrair mais, mas preste atenção para alterar
os arquivos da forma certa.

Faça com calma, cuidado e divirta-se, se quiser, mas não é necessário. Veja
bem, talvez ao entrar em algum arquivo abaixo você não encontre as opções,
isso ocorre por causa das distribuições. Recomendo pular essa etapa.
■ /usr/src/Linux-3.10.7/arch/alpha/Makefile;

■ /usr/src/Linux-3.10.7/arch/arm/Makefile;

■ /usr/src/Linux-3.10.7/arch/avr32/Makefile;

■ /usr/src/Linux-3.10.7/arch/frv/Makefile;

■ /usr/src/Linux-3.10.7/arch/m68k/Makefile;

■ /usr/src/Linux-3.10.7/arch/mips/Makefile;

■ /usr/src/Linux-3.10.7/arch/parisc/Makefile;

■ /usr/src/Linux-3.10.7/arch/powerpc/Makefile;

■ /usr/src/Linux-3.10.7/arch/s390/Makefile;

■ /usr/src/Linux-3.10.7/arch/sparc/Makefile.

COMPILANDO E OTIMIZANDO
Execute:

# make config_debug_section_mismatch=y

Configura e previne possíveis erros de compatibilidade durante a compilação.

Deverá demorar de uma a três horas, dependendo do processador. Antes de

dar enter, sugiro fechar os outros programas (não que seja necessário, mas é

recomendável) e após dar enter sugiro deixar a máquina trabalhando e vá fazer

outra coisa. Deixe o terminal aberto e fique monitorando.

# make modules

Compila os módulos. Sempre se deve rodar make modules e make

modules_install.

# make modules_install

(instala os módulos)

# make install

(instala o kernel)
O make install instala o kernel, gera a imagem e atualiza o GRUB, deixando

tudo pronto para reiniciar.

Reiniciando:

# shutdown -r now

Após reiniciar, verifique o kernel:

# uname -r

Deverá aparecer:

5.13.10

Confirme:

# uname -a

Linux xxxxx 5.13.10 #1 SMP Thu Aug 12 20:26:52 -03 2021

x86_64 GNU/Linux
Atualize:

# apt-get update

# aptitude safe-upgrade

Agora vamos remover os kernel antigos.

# apt search linux-image | grep 'installed'

Saída, no meu caso:

WARNING: apt does not have a stable CLI interface. Use

with caution in scripts.

linux-headers-4.9.0-16-amd64/oldstable,now 4.9.272-2 amd64

[installed]

linux-image-4.9.0-15-amd64/oldstable,now 4.9.258-1 amd64

[installed,automatic]

linux-image-4.9.0-16-amd64/oldstable,now 4.9.272-2 amd64

[installed,automatic]

linux-image-amd64/oldstable,now 4.9+80+deb9u14 amd64

[installed]
Veja as versões.

# ls /boot | grep vmlinuz | cut -d'-' -f2,3

4.9.0-15

4.9.0-16

5.13.10

Remova os mais antigos:

# dpkg -l 'linux-*' | sed '/^ii/!d;/'"$(uname -r | sed

"s/\(.*\)-\([^0-9]\+\)/\1/")"'/d;s/^[^ ]* [^ ]* \([^ ]*\).*/\1/;/[0-9]/!d' | xargs sudo

apt-get -y purge

Confirme:

# ls /boot | grep vmlinuz | cut -d'-' -f2,3

Deverá aparecer o último instalado.

5.13.10
Daí:

# update-grub

E é isso.

Você acabou de compilar um kernel no Linux. O aprendizado será imenso.

Um kernel atualizado dura anos e você não precisa ficar reinstalando o sistema

toda hora porque não dará muitos problemas. E quando der problemas, eles

serão de fácil solução.

 TRUQUES ÚTEIS DE LINHA DE COMANDO

LINUX PARA INICIANTES

Diversos novos usuários Linux estão muito acostumados com a interface gráfica
do Windows e possuem receio em utilizar o terminal do Linux. Com o passar do
tempo, percebem a grande versatilidade que podem ter ao utilizar a "tela preta",
onde devemos escrever os comandos, ao invés de clicar nos botões de interface
com o mouse. Depois de algum tempo, costumam utilizar com tanta frequência
esses diversos comandos, buscando sempre conhecer melhor esse tipo de
interface.

Neste material trago alguns truques úteis, principalmente para os iniciantes no

mundo Linux, para que eles tenham mais facilidade na utilização desse sistema
operacional.

ENCONTRAR O COMANDO CORRETO

Executar o comando correto pode ser vital na utilização do sistema, mas existem
diversas opções de comandos no Linux. Muitos me perguntam: Como posso
encontrar o comando que devo utilizar? A resposta é o comando apropos.

Para encontrar quais comandos posso utilizar para listar um diretório (list
directory), devo utilizar:

apropos "list directory"

dir (1) - list directory contents
ls (1) - list directory contents
ntfsls (8) - list directory contents on an NTFS filesystem
vdir (1) - list directory contents
EXECUTAR SEU ÚLTIMO COMANDO

Algumas vezes, você precisa executar o mesmo comando diversas vezes, ou

precisa lembrar de um comando utilizado no passado. Para isso podemos utilizar
o history ou o !<id>.

history
Observe na imagem acima que o comando history traz um histórico com todos
os últimos comandos digitados, sendo que cada comando possui um número
indicando sua linha. Caso eu queira executar novamente o comando que está na
linha 52 (lslogins), poderia fazer da seguinte forma:

!52

UTILIZE O COMANDO MIDNIGHT

Caso você prefira um alternativa aos comandos cd, cp, mv, rm etc, pode utilizar o
comando midnight. Ele possui uma interface visual no modo de texto, onde a
maioria dos comandos são realizados utilizando as teclas F1, F2 etc.

sudo apt install mc

mc
Utilize a tecla <TAB> para alternar entre o painel direito e o esquerdo.

Caso você queira, por exemplo, copiar um arquivo (install.sh) que está no meu
diretório home (~), para a pasta temporária do sistema (/tmp), primeiro navegue
até a pasta temporária no painel direito. Depois volte para o painel esquerdo e
selecione o arquivo que será copiado.

Agora pressione <F5> para realizar a cópia. Veja que agora o arquivo install.sh
está também no diretório /tmp.
DESLIGAR OU REINICIAR O COMPUTADOR EM UM HORÁRIO ESPECÍFICO

Para desligar e reiniciar o computador utilizamos o comando shutdown. Caso

você queira desligar o computador às 21h00, utilize:

sudo shutdown 21:00

Caso queira reiniciar seu computador daqui 15 minutos, utilize:

sudo shutdown -r +15

ENCONTRAR ARQUIVOS

A busca por arquivos pode ser mais simples do que a maioria das pessoas
imagina, utilizando o comando find.

Buscar os arquivos com mais de 10 MB no diretório atual:

find . -type f -size 10M

Buscar arquivos com um nome:

find . -name livros.txt

Buscar os arquivos em uma pasta e alterar suas permissões para 644:

find /home/user/files/ -type f -exec chmod 644 {} ;

Em um próximo artigo irei demonstrar diversas utilizações do comando find.

CRIAR UMA ÁRVORE DE DIRETÓRIOS COM UM ÚNICO COMANDO

O comando mkdir é utilizando para criarmos diretórios.

Caso você queira, por exemplo, criar a seguinte árvore:

Livros/
Livros/Acao
Livros/Drama
Livros/TI

Se você utilizar o comando mkdir da forma tradicional, executaria ele 4 vezes!

Tente usar da seguinte forma, com o argumento -p:

mkdir -p Livros/{Acao,Drama,TI}
ls Livros/

COPIAR UM ARQUIVO PARA DIVERSOS DIRETÓRIOS

Suponha que eu tenha o arquivo autores.txt que é um modelo, que será utilizado
em todos os diretórios de Livros criados no exemplo anterior. Como posso
copiá-lo para todos eles, utilizando um único comando? A solução está no
exemplo abaixo.

echo /home/diego/Livros/Acao/ /home/diego/Livros/Drama/

/home/diego/Livros/TI/ | xargs -n 1 cp /home/diego/autores.txt

EXCLUIR ARQUIVOS MUITO GRANDES

Algumas vezes os arquivos podem crescer muito, ficando enormes! Um exemplo

clássico são os arquivos de log não rotacionados, com 300GB, 500GB , ou
maiores, podendo causar dificuldades para os administradores de sistemas. Em
muitos casos, remover esses arquivos com o comando rm pode não funcionar, já
que eles são muito grandes e essa ação será muito "pesada" para o sistema.
Uma alternativa é limpar o arquivo antes de excluir. No exemplo abaixo, irei
limpar o arquivo log_enorme.log.

> /path-to-file/log_enorme.log

O que aconteceu no comando acima é que foi escrito um arquivo vazio sobre o
log_enorme.log.
LER UM ARQUIVO DE LOG EM TEMPO REAL

Em diversos casos precisamos ler e exibir um arquivo de log em tempo real,

como por exemplo o arquivo de log do Apache, WebLogic, Tomcat etc. Para isto,
utilizamos o "tail -f".
tail -f /var/log/syslog

UTILIZAR O HELP NOS COMANDOS LINUX

Esta dever ser uma das dicas mais importantes, a utilização do parâmetro help
nos comandos Linux. Desta forma, você pode exibir as principais opções de
cada comando, sem utilizar o manual do sistema. No comando abaixo, utilizo o
help com o comando ls.

ls --help

CONCLUSÕES
Espero que os truques expostos acima te ajudem na jornada de utilização do
terminal Linux.
Virtualização com Proxmox VE

INTRODUÇÃO

Proxmox VE é uma plataforma para executar máquinas virtuais e contêineres.

Ele é baseado no Debian Linux e completamente código aberto. Para máxima
flexibilidade, implementamos duas tecnologias de virtualização - máquina virtual
baseada em kernel (KVM) e virtualização baseada em contêiner (LXC).

Um dos principais objetivos do design é tornar a administração mais fácil

possível. Você pode usar Proxmox VE em um único nó ou montar um cluster de
muitos nós. Todas as tarefas de gerenciamento podem ser feitas usando a
interface de gerenciamento via web e até mesmo um usuário novato pode
configurar e instalar o Proxmox VE em minutos.

GERENCIAMENTO CENTRAL

Embora muitas pessoas comecem com um único nó, o Proxmox VE pode ser
dimensionado para um grande conjunto de nós agrupados. A pilha do cluster é
totalmente integrada e acompanha a instalação padrão.

DESIGN MULTI-MASTER ÚNICO

A interface de gerenciamento baseada na web oferece uma visão clara de todos

os seus convidados KVM e contêineres Linux e até mesmo de todo o cluster.
Você pode gerenciar facilmente suas VMs e contêineres, armazenamento ou
cluster a partir da GUI. Não há necessidade de instalar em separado um servidor
de gerenciamento.

SISTEMA DE ARQUIVOS DE CLUSTER PROXMOX (PMXCFS)

Proxmox VE usa o exclusivo sistema de arquivos Proxmox Cluster (pmxcfs), um

sistema de arquivos orientado por banco de dados para armazenar arquivos de
configuração. Isso permite que você armazene a configuração de milhares de
máquinas virtuais.
Ao usar o corosync, esses arquivos são replicados em tempo real em todos os
nós do cluster. O sistema de arquivos armazena todos os dados dentro de um
banco de dados persistente em disco, no entanto, uma cópia dos dados reside
na RAM que fornece um tamanho máximo de armazenamento de 30 MB - mais
do que o suficiente para milhares de VMs. Proxmox VE é a única plataforma de
virtualização que usa este sistema de arquivos de cluster exclusivo.

INTERFACE DE GERENCIAMENTO BASEADA NA WEB

O Proxmox VE é simples de usar. As tarefas de gerenciamento podem ser feitas

através da interface de gerenciamento baseada na web - não há necessidade de
instalar uma ferramenta de gerenciamento separada ou qualquer gerenciamento
adicional nó com bancos de dados enormes.

A ferramenta multimestre permite que você gerencie todo o seu cluster a partir
de qualquer nó do seu cluster. O gerenciamento central baseado na Web -
baseado no JavaScript Framework (ExtJS) - permite que você controle todas as
funcionalidades da GUI e uma visão geral do histórico e syslogs de cada nó
único. Isso inclui a execução de trabalhos de backup ou restauração, migração
ao vivo ou atividades acionadas por HA.

LINHA DE COMANDO

Para usuários avançados que estão acostumados com o conforto do Shell Unix
ou Windows Powershell, Proxmox VE fornece uma interface de linha de
comando para gerenciar todos os componentes do seu ambiente virtual. Esta
interface de linha de comando possui preenchimento de guia inteligente e
documentação completa na forma de UNIX man pages.

API REST

Proxmox VE usa uma API RESTful. Escolhemos JSON como formato de dados
primário e toda a API é formalmente definida usando o esquema JSON. Isso
permite uma integração rápida e fácil para gerenciamento de terceiros
ferramentas como ambientes de hospedagem personalizados.

ADMINISTRAÇÃO BASEADA EM FUNÇÕES

Você pode definir o acesso granular para todos os objetos (como VMs,
armazenamentos, nós etc) usando a função baseada em gerenciamento de
usuários e permissões. Isso permite que você defina privilégios e ajude a
controlar acesso a objetos. Este conceito também é conhecido como listas de
controle de acesso, onde cada permissão especifica um sujeito (um usuário ou
grupo) e uma função (conjunto de privilégios) em um caminho específico.

AUTENTICAÇÃO REALMS

Proxmox VE oferece suporte a várias fontes de autenticação, como Microsoft

Active Directory, LDAP, Linux PAM autenticação padrão ou o servidor de
autenticação Proxmox VE integrado.

ARMAZENAMENTO FLEXÍVEL

O modelo de armazenamento Proxmox VE é muito flexível. As imagens de

máquina virtual podem ser armazenadas em um ou vários armazenamentos
locais ou em armazenamento compartilhado como NFS e em SAN. Não há
limites, você pode configurar como muitas definições de armazenamento como
você gosta. Você pode usar todas as tecnologias de armazenamento disponíveis
para Debian Linux.

Um grande benefício de armazenar VMs em armazenamento compartilhado é a

capacidade de migrar ao vivo máquinas em execução sem qualquer tempo de
inatividade, pois todos os nós do cluster têm acesso direto às imagens de disco
da VM.

Atualmente, oferecemos suporte para os seguintes tipos de armazenamento de

rede:
■ Grupo LVM (suporte de rede com alvos iSCSI);

■ Alvo iSCSI;

■ Compartilhamento NFS;

■ Compartilhamento CIFS;

■ Ceph RBD;

■ Use diretamente iSCSI LUNs;

■ GlusterFS.
Os tipos de armazenamento local suportados, são:
■ Grupo LVM (dispositivos auxiliares locais, como dispositivos de bloco,

dispositivos FC, DRBD etc);

■ Diretório (armazenamento no sistema de arquivos existente);

■ ZFS.

BACKUP E RESTAURAÇÃO INTEGRADOS

A ferramenta de backup integrada (vzdump) cria instantâneos consistentes de

contêineres em execução e convidados KVM. Basicamente, ele cria um arquivo
dos dados VM ou CT que inclui os arquivos de configuração VM / CT. O backup
ao vivo em KVM funciona para todos os tipos de armazenamento, incluindo
imagens VM em NFS, CIFS, iSCSI LUN, Ceph RBD.

O novo formato de backup é otimizado para armazenar backups de VM rápida e

eficaz (arquivos esparsos, dados fora de ordem, E/S minimizada).

CLUSTER DE ALTA DISPONIBILIDADE

Um cluster Proxmox VE HA de vários nós, permite a definição de servidores

virtuais altamente disponíveis. The Proxmox VE HA Cluster é baseado em
tecnologias comprovadas de HA Linux, fornecendo serviços HA estáveis e
confiáveis.

REDE FLEXÍVEL

O Proxmox VE usa um modelo de rede em bridge (ponte). Todas as VMs podem

compartilhar uma ponte como se os cabos de rede virtual de cada convidado
fossem todos conectados ao mesmo switch. Para conectar VMs ao mundo
exterior, bridges são anexados às placas de rede físicas e atribuídos a uma
configuração TCP / IP.

Para maior flexibilidade, VLANs (IEEE 802.1q) e ligação/agregação de rede são

possíveis. Assim é possível construir redes virtuais complexas e flexíveis para os
hosts Proxmox VE, aproveitando todo o poder do Pilha de rede Linux.
FIREWALL INTEGRADO

O firewall integrado permite filtrar pacotes de rede em qualquer VM ou interface

de contêiner. Conjuntos comuns de regras de firewall podem ser agrupadas em
"grupos de segurança".

INFRAESTRUTURA HIPERCONVERGENTE

Proxmox VE é uma plataforma de virtualização que integra totalmente recursos

de computação, armazenamento e rede, gerencia clusters altamente disponíveis,
backup/restauração e recuperação de desastres. Todos os componentes são
definidos por software e compatíveis uns com os outros.

Portanto, é possível administrá-los como um único sistema por meio da interface

de gerenciamento web centralizado. Esses recursos tornam o Proxmox VE a
escolha ideal para implantar e gerenciar uma infraestrutura hiperconvergente de
código aberto.

BENEFÍCIOS DE UMA INFRAESTRUTURA HIPERCONVERGENTE (HCI) COM

PROXMOX VE

Uma infraestrutura hiperconvergente (HCI) é especialmente útil para

implantações em que uma alta infraestrutura à demanda atenda a um baixo
orçamento de administração, para configurações distribuídas, como ambientes
remotos e de filiais ou para nuvens públicas e privadas virtuais.

HCI oferece as seguintes vantagens:

■ Escalabilidade: expansão contínua de dispositivos de computação, rede

e armazenamento (ou seja, aumentar a escala de servidores e

armazenamento de forma rápida e independente um do outro).

■ Baixo custo: Proxmox VE é open source e integra todos os componentes

de que você precisa, como computação, armazenamento, centro de

rede, backup e gerenciamento. Ele pode substituir uma infraestrutura de

computação / armazenamento cara.

 ■ Proteção e eficiência de dados: serviços como backup e recuperação de

desastres estão integrados.

■ Simplicidade: fácil configuração e administração centralizada.

■ Código aberto: sem dependência de fornecedor.

INSTALAÇÃO E CONFIGURAÇÃO

Bom, agora vamos colocar a mão na massa e efetuar a instalação do Proxmox!

Baixe a ISO do Proxmox:

https://www.proxmox.com/en/downloads/category/iso-images-pve

Agora grave em um DVD ou Pendrive e só dê o boot para a instalação:

Aceite os termos da EULA:

Selecione o device para ser instalado, geralmente deixamos no primeiro mesmo:

Agora selecione o País, timezone e layout do teclado:

Vamos definir uma senha e um endereço de email:

Agora defina as configurações de rede, hostname, interface de rede:

Após, ira aparecer um sumário de como vão ficar as configurações:

E agora instalado, ele irá reiniciar:

Iniciando o seu boot:

Podes logar no terminal com a senha que foi definido na instalação:

Podemos acessa via web: https://<ip ou FQDN>:8006

Caso queira usar sem o suporte pago da empresa, vamos alterar o sources.list.
asta alterar o arquivo /etc/apt/source.list.d/pve-enterprise.list e deixá-lo assim:

deb http://download.proxmox.com/debian buster pve-no-subscription

Salve, saia e digite:

# apt update

E depois só executar o comando:

# apt upgrade -y

E reiniciar o Proxmox:

# reboot

CRIANDO UMA MÁQUINA VIRTUAL

Vamos agora subir na primeira máquina virtual.

Acesse o seu Proxmox e vá em: Local > ISO > Upload - é onde vamos subir uma
ISO:
Após efetuar o upload da ISO, vamos criar a nossa máquina virtual. Vá em
"Create VM":

Nessa tela vamos configurar em qual o node do Proxmox vamos subir a VM,
caso tenha mais de um node. Defina o nome da sua máquina virtual:

Selecione a ISO:
A configuração do sistema, pode deixar default mesmo:

Selecione onde ficará o disco da VM e a sua capacidade, como teste deixei com
32GB:
Configure a CPU da VM:

Configure a memória:
Configure a rede:

Verifique se as configurações estão de acordo:

Após criar a máquina virtual, só iniciá-la:

Espero que ajude.

Guia de referência: Proxmox - Powerful open-source server solutions

 Dicas para aprender programação

Neste artigo você vai aprender algumas dicas básicas que costumo usar com meus
"discípulos" quando quero ensinar programação para alguém via internet.

DICA 1: INPUT/OUTPUT - PRIMEIRO DECORAR, DEPOIS APRENDER

INTRODUÇÃO

Algumas vezes pode ser complicado aprender programar, ainda mais sozinho.
Programação é algo que exige mais um esforço solitário do que propriamente de
um grupo de pessoas ao mesmo tempo. Neste artigo veremos algumas dicas
simples para aprender melhor programação e não perder tanto tempo
reinventando a roda, melhor aprender com a experiência de alguém que já
percorreu o caminho do que tentar fazer um caminho novo.

DICA 1: INPUT/OUTPUT - PRIMEIRO DECORAR, DEPOIS APRENDER

Essa é provavelmente a técnica mais efetiva no estudo de programação.

Quando você deve aprender uma linguagem ou iniciar os estudos de
programação, a melhor estratégia é apenas decorar (input) o máximo que puder
para depois aprender como fazer (output). Essa técnica eu aprendi com meu
amigo Thiago Hupner (thihup) quando eu ajudava ele a aprender programação.

Ele fazia exatamente isso e eu ficava surpreso porque ele conseguia decorar o
programa inteiro escrito em C++ com a lib Irrlicht e eu ainda estava
engatinhando no hello world com a mesma lib. Perguntei a ele como era essa
mágica e ele me explicou como fazia. No caso, quanto mais você decorar
programas ou comandos, mais você terá experiência para aprender. Essa
técnica me lembra a teoria do Input/Output da aquisição de língua estrangeira de
Stephen Krashen:

Sugiro que leia este site: Stephen Krashen's Theory of Second Language
Acquisition (Assimilação Natural - o Construtivismo no Ensino de Línguas)

Ou pesquise no Google: teoria do input de Stephen Krashen

Nessa técnica o que você faz é o seguinte:

Se você tem que aprender uma nova linguagem, ou uma nova lib, ou qualquer
tecnologia que seja, siga estes passos:

Supondo que queira aprender uma nova linguagem mas você NÃO sabe
nenhuma linguagem:

1. Pegue um exemplo de programa com poucas linhas, tipo algo como um

programa que imprime a soma de dois números.

2. Como você não tem nenhuma noção (input) do que faz aquilo, então, tente
apenas ler e entender o que faz o programa, assim você ganha input
compreensivo sobre aquele assunto.

3. Depois de ter certeza que você decorou (sim, decorou mesmo!) o programa e
consegue mentalmente visualizar como ele é, basta agora praticar (output).
Tente reproduzir todo o programa como você entende ele, caso surja dúvidas,
olhe imediatamente no código que você decorou para ganhar ainda mais input
(compreensão).

4. Não deixe nenhuma dúvida passar sem resposta no momento de reproduzir o

código do programa.

5. Dicas de sites com códigos de programas para estudar:

■ https://www.vivaolinux.com.br/scripts/

■ https://www.github.com/

■ https://www.sourceforge.net/

No caso, nessa prática eu recomendo que você tente reproduzir todo o programa
a partir de sua mentalização/decorar de antes.

Por exemplo, supondo que você decorou os comandos de um programa que

soma dois números e mostra na tela, então, tente reproduzir todo o programa
DEPOIS de mentalizado.
Reproduzir o mesmo programa já mentalizado é o mesmo que fazer um output
da sua mente para o computador. No caso o input (compreensão) veio dos
comandos decorados.

Quanto mais você decorar programas, maiores serão as chances de mais rápido
você entender qualquer outro programa no mesmo nível dos que você decorou.

NOTA: aqui prefira mais a quantidade de programas entendidos ao invés da

qualidade dos programas que você entendeu. Por exemplo, é melhor você saber
refazer mentalmente 50 programas de 10 linhas do que saber fazer um de 500
linhas, porque no quesito experiência, você possuirá 50 programas
mentalizados, enquanto que mentalizar apenas um de 500 linhas não te fará tão
experiente na habilidade de programação.

O foco principal é apenas esse: ganhar o máximo de input possível

(compreensão do assunto), para depois tentar reproduzi-lo (output) fazendo o
que já se entendeu mas não sabe o significado.

De forma genérica, abaixo segue algo que serve para aprender tudo na
programação:

1. Pegue exemplos de código do que deseja aprender, exemplos pequenos e

não tão complexos, primeiro olhe o código inteiro e veja se você é capaz de
entendê-los. Se sim, siga para o passo 2. Senão, procure outro código mais
simples.

2. [INPUT] depois de ter alguns exemplos que você sentiu ser capaz de
aprender, chegou a hora de decorar (input). Então, leia o programa e tente
apenas entender como ele executa cada instrução. Comece do primeiro
comando, vá para o segundo, depois o terceiro etc, até chegar no fim da
execução. Aqui você está ganhando entendimento sobre o que fazer no passo
seguinte. Só siga para o passo 3 se realmente sentir que é capaz de repetir o
código de exemplo exatamente como você entendeu neste passo.

3. [OUTPUT] agora nesta etapa chegou a hora da prática, apenas tente

reproduzir todo o programa de exemplo que você decorou no passo 2. Se chegar
num ponto onde você esqueceu como o exemplo fazia, imediatamente vá ao
programa de exemplo e veja como ele faça, não deixe nenhuma dúvida viva!
Essa fase é a fase onde você terá dúvidas e isso é normal, então, apenas
procure saná-las o quanto antes. Depois de conseguir refazer todo o programa,
siga para o quarto passo se quiser.
4. [RELEMBRANDO - opcional] neste passo é tipo um desafio para você
realmente aprender de verdade. Aqui, mais do que programar, você irá escrever
num txt ou num caderno, ou em algo que você possa escrever frases. O que eu
sugiro é: escreva o algoritmo do programa completo, sem código, só o algoritmo.
Por exemplo, supondo que o programa do passo 2 que você decorou some dois
números numA e numB e então mostre na tela, assim, seu objetivo neste quarto
passo é apenas escrever todo o algoritmo usado no programa. Esse passo serve
para fixar em seu cérebro o entendimento do programa.

DICA 2: SE NÃO SABE MAIS O QUE FAZER, APENAS ESCREVA OS PASSOS.

Muitas vezes um problema de programação só está mal compreendido, e no

caso para entender melhor você deve fazer algumas perguntas:

1. Pergunte a si mesmo "O que fazer?" e não "Como fazer?"

Nessa dica perguntar "Como fazer tal programa?" é pior do que perguntar "O
que fazer neste programa?". Percebeu a diferença? Quando você usa "O que
fazer" ao invés de "Como fazer", você passa a ser mais objetivo e direcionado
para a solução do problema em questão.

Vamos supor que você tenha o vetor:

int vetor[] = {1, 2, 3, 2, 3, 5, 4};

O possível problema para fazer pode ser:

Ordene este vetor do menor para o maior.

Então, se você perguntar a si mesmo "Como fazer para ordenar este vetor?"
pode dar tantas possibilidades que você será incapaz de usar uma delas. Mas se
você perguntar "O que fazer para ordenar este vetor?", então você poderia
pensar melhor num algoritmo (passo a passo) de como fazer para ordenar este
vetor especificamente:

1. Pegar o terceiro número (3) e o quarto numero (2).

2. Inverter a posição dos dois números.

3. Pegar o sexto número (5) e o sétimo número (4).

4. Inverter a posição dos dois números.

Se você observar bem, este algoritmo serve apenas para este vetor em
particular. Mas se você olhar de forma mais genérica, poderá ver que este
algoritmo pode ser transformado em algo que pode ser reaproveitado para
qualquer vetor:

//passos 1 e 3 são o mesmo que: 1. Vá do primeiro ao penúltimo, chame de

índice i. 1.1. Vá do i + 1 ao último, chame de índice j. 1.1.2. Se o número no
índice i for maior que o número no índice j.

//passos 2 e 5 são o mesmo que 1.1.2.1. Pegue o número no índice i, salve

numa variável auxiliar chamada aux. 1.1.2.2. Faça o número no índice i igual ao
número no índice j. 1.1.2.3. Faça o número no índice j igual à variável auxiliar
aux.

2. Continue percorrendo o vetor até a conclusão do passos 1 e 2.

Esse algoritmo acima é o famoso algoritmo da bolha.

DICA 3: APRENDA ALGORITMOS OU LÓGICA DE PROGRAMAÇÃO, MAS USE

UMA LINGUAGEM DE PROGRAMAÇÃO

Se você for esperar para ter primeiro a lógica afiada para depois aprender
programar de verdade, pode acabar perdendo um tempo precioso. Então, pra
treinar a lógica e ao mesmo tempo aprender uma linguagem, você deve sempre
tentar com uma linguagem de programação.

Exemplo:

Se você ainda não sabe nenhuma linguagem de programação, eu sugiro que

escolha uma, qualquer uma do seu interesse e então estude a lógica de
programação ao mesmo tempo em que tenta programar. Como eu disse na dica
1, aqui o que vale não é a qualidade mas a quantidade de input que você tem da
linguagem, quanto mais input você obtém mais fácil será aprender programar e
por consequência, aprender algoritmos de forma prática.
Mas, como praticar enquanto treina programação com uma linguagem?

Vou tentar transformar em passos:

1. Procure um problema de programação parta estudar

2. Se já sabe algo da linguagem que você quer aprender, então, tente fazer ele
nessa linguagem.

2.1. Se não conseguir, tente escrever o passo a passo num caderno até você ter
uma ideia de "O que fazer?" e não "Como fazer?"

3. Se não sabe nenhuma linguagem, então, sugiro que escreva o algoritmo

primeiro e só depois tente procurar fazer numa linguagem qualquer. Assim você
pode também procurar no Google que comandos são usados na linguagem que
você quer aprender.

Em geral, as primeiras linguagens aprendidas são estruturadas, com comandos

comuns tipo if, eles, while, for etc. Aprendendo estes primeiros comandos, você
já será capaz de fazer pequenos programas.

DICA 4: IDENTIFIQUE PRIMEIRO OS BLOCOS DO PROGRAMA: ENTRADA,

PROCESSAMENTO E SAÍDA

Quando você vai aprender uma nova linguagem, há certas coisas que passam
sem ser percebidas, uma delas é a estrutura lógica da maioria dos programa. No
caso, estou falando das 3 palavrinhas mágicas da computação: entrada,
processamento e saída.

Então, quando você tem um problema como este:

- leia dois números A e B, some eles e mostre o resultado na tela.

Você deve primeiro, começar identificando quem são as entradas, quem é

processamento e quem é saída. No nosso exemplo:

Entradas:

- ler dois números A e B.

Processamento:

- somar A com B.

Saída:

■ mostrar na tela o resultado.

Esse exemplo é muito simples, mas em geral é nesse estilo que se trata
programar. Se você identificar cada parte, poderá facilmente desenvolver um
programa ou algoritmo que resolve o problema em questão.

DICA 5: FAÇA AMIGOS PELA INTERNET E/OU AJUDE PESSOAS COM O QUE

VOCÊ SABE

Essa também é uma dica efetiva, mas as vezes é difícil fazer, porque é difícil
enxergar benefícios diretos de fazer amigos e/ou ajudar pessoas online.

Nessa eu sugiro o seguinte:

- participe de fóruns, grupos do Facebook, grupos do Discord etc, com o assunto

programação. Tente responder dúvidas de outras pessoas que você conhece
porque estas dúvidas são perfeitas para você treinar sua habilidade com
programação, e isso é uma "piranha" oportunidade.

- use a busca do Google para achar estes grupos, exemplo:

■ grupos de programação Facebook

■ grupo de programação iniciantes Discord

Eu consegui meu primeiro emprego graças a um amigo que conheci aqui mesmo
no Viva o Linux, conheci de forma aleatória e eu ajudei ele a aprender
programação e anos mais tarde a arranjar o primeiro emprego dele também, e
depois, ele me ajudou entrar na mesma empresa que está.
Por isso eu reforço: ajude alguém na internet, mesmo que você não veja os
resultados de forma imediata, a longo prazo vale muito a pena.

Se você ajudar alguém de alguma forma, essa pessoa pode acabar

recompensando seu esforço, não apenas com agradecimentos. Siga o velho
conselho do cabelo:

"Competir atrai inimigos, cooperar atrai amigos!"

DICA 6 - AUMENTE SUA AUTODISCIPLINA

Nesta dica você verá um método simples para criar autodisciplina. Ele é
comprovado cientificamente e não é simples achismo.

Então, o método é: fazer meditação.

Simples assim, fazer meditação fará você ser auto disciplinado e talvez até fazer
você ser menos idiota (se isso for um problema pra você).

Segue alguns artigos em inglês:

NOTA: quando você vê algum método para aumentar a inteligência, desconfie

logo, porque ele pode até funcionar mas não vai lhe fazer inteligente de forma
alguma se você não estudar. O que esses métodos mágicos fazem é apenas
melhorar sua cognição e NÃO inserir conhecimento em seu cérebro. O único
modo atual de inserir conhecimento no cérebro é via estudar muito. Você pode
ser muito capaz de aprender mas se não estudar nada, você continuará no
mesmo nível de conhecimento.

Matéria sobre como "aumentar" a inteligência: How Meditation Increases

Intelligence (just 20 minutes a day) - The Best Brain Possible

Artigo sobre meditação mindfullness e aumento do QI: Meditation Increases IQ -

4 Days of Meditation Improves Cognitive Efficiency

Aqui meu canal favorito de meditação guiada: [você pode começar por ele] Canal
Fábio Lima
Depois que você começar meditar, sugiro ainda mais uma coisa: marque um X
no calendário toda vez você conseguir cumprir um meta. Por exemplo, se você
não sabe programar e quer aprender programação, pegue um calendário e
escreva nele ou cole um papel com a meta: "estudar programação", quando você
estudar programação no dia atual, marque um X no dia que você estudar. Se
não estudar, não marque nada. Assim você terá um feedback de progresso e
saberá se conseguiu ou não cumprir a meta.

Ter metas e cumprir partes dela na semana (não precisa ser todo dia) lhe fará
um tremendo bem e até você sentirá que está progredindo e não apenas
sonhando em ser bom em alguma coisa.

Essa técnica de meditação e calendário, funcionam para qualquer tipo de meta.

Se não acredite, seria bom experimentar e tirar suas próprias conclusões antes
mais do que só achar que não funciona.

E o que fazer quando não conseguir cumprir nada da meta?

Simples, apenas abandone tal meta! O que importa mesmo no final das contas é
apenas o que você se interessa, se você focar no que te interessa não precisará
mais se importar com metas ou cumprir qualquer coisa que seja além do seu
alcance.

Como diria Sadhguru: "...se preocupe mais com o processo ou sua meta não
passará de desejos fantasiosos...Se você tiver devoção absoluta ao que você
está fazendo no momento presente, dependendo do tempo e das oportunidades,
iremos até onde for possível.".

Vídeo recomendado:
CONCLUSÃO

Neste artigo foi visto certas dicas que são úteis para quem está querendo
aprender programação, mesmo que sozinho ou com alguns amigos.

Nele, compartilhei algumas coisas de prática deliberada e experiências no

ensino de alguns amigos que aprenderam programar comigo ou que os ajudei a
subir seu nível de habilidade.

Espero que você tenha gostado deste conteúdo, e caso queira saber mais sobre
mim, pode me encontrar nestes links:
Meu perfil no GitHub: https://github.com/cpusam

Meu perfil no Deviantart: (tá meio abandonado)

https://www.deviantart.com/samuelleonardo

Blog que escrevo com meu amigo Patrick: https://nerdki.blogspot.com/

 Instalação do Gentoo GNU/Linux em um SSD

NVMe (UEFI/GPT)

INSTALAÇÃO

Artigo testado em:

■ AMD Ryzen 7 3700X

■ 32 GB RAM SSD4

■ 128 GB SSD NVMe

■ GPU RADEON R5220 2GB

Para a instalação foi usado o "Minimal Installation CD" disponível em:

■ https://www.gentoo.org/downloads/

Obs 1.: este artigo é bem específico para a minha situação (não poderia ser de

outra forma se tratando do Gentoo GNU/Linux). Serve como guia superficial e

lembrete do processo de instalação que pode, talvez, ajudá-lo de alguma forma.

Mas caso queira um conteúdo "genérico" que se adapte a todas as situações, a

melhor a opção seria ler o "handbook" do Gentoo.

Obs 2.: caso você tenha alguma sugestão ou crítica construtiva, por favor deixe

um comentário. Não tenho muita experiência com Gentoo GNU/Linux e estou

constantemente aprendendo.

PARTIÇÕES

Crie duas partições:

■ 128 MB para UEFI ESP

■ E o restante para a raiz

Para isso use o "gdisk".

Exemplo:

# gdisk /dev/nvme0n1

Tecle "o" para criar uma tabela de partição GPT, e confirme com "y".

Criação da tabela de partição GPT:

Command: o (Enter)

This option deletes all partitions and creates a new

protective MBR.
Proceed? (Y/N): y (Enter)

Criação da Partição 1 (UEFI ESP):

Command: n (Enter)

Partition Number: 1 (Enter)

First sector: (Enter)

Last sector: +128M (Enter)

Hex Code: EF00 (Enter)

Criação da Partição 2 (/):

Command: n (Enter)

Partition Number: 2 (Enter)

First sector: (Enter)

Last sector: (Enter)

Hex Code: (Enter)

Salvar alterações no disco:

Command: w (Enter)
Do you want to proceed? (Y/N): Y (Enter)

Formate:

# mkfs.xfs /dev/nvme0n1p2

# mkfs.vfat -F 32 /dev/nvme0n1p1

Monte:

# mkdir -p /mnt/gentoo

# mount /dev/nvme0n1p2 /mnt/gentoo

# mkdir -p /mnt/gentoo/boot/efi

# mount /dev/nvme0n1p1 /mnt/gentoo/boot/efi

STAGE 3 E CHROOT

Baixe o stage3 da versão "openrc" usando o navegador Links e extraia-o:

# cd /mnt/gentoo

# links https://www.gentoo.org/downloads/

# tar --xattrs-include='*.*' --numeric-owner -xpf stage3*

Chroot:

# cd /mnt/gentoo

# mount -t proc none proc

# mount --rbind /sys sys

# mount --make-rslave sys

# mount --rbind /dev dev

# mount --make-rslave dev

# cp /etc/resolv.conf etc

# chroot . /bin/bash

# source /etc/profile

Em uma linha:

# mount -t proc none proc; mount --rbind /sys sys; mount --make-rslave sys;

mount --rbind /dev dev; mount --make-rslave dev; cp /etc/resolv.conf etc;

chroot . /bin/bash; source /etc/profile

Sincronize o repositório:

# emerge-webrsync
CRIAÇÃO DO USUÁRIO E DAS SENHAS

Exemplo com usuário "xerxes":

# sed -i s/everyone/none/ /etc/security/passwdqc.conf

# passwd

# useradd -g users -G wheel,portage,audio,video,usb,cdrom -m xerxes

# passwd xerxes

ARQUIVOS DE CONFIGURAÇÃO

Instale o Vim:

# emerge -vaq app-editors/vim

Edite o Fstab:

# vim /etc/fstab

Exemplo:

/dev/nvme0n1p2 / xfs defaults 0 1

/dev/nvme0n1p1 /boot/efi vfat defaults 0 0

tmpfs /tmp tmpfs noatime,nodev,nosuid,size=20G 0 0

Configure o make.conf:

# vim /etc/portage/make.conf

Exemplo:

# These settings were set by the catalyst build script that automatically

# built this stage.

# Please consult /usr/share/portage/config/make.conf.example for a more

# detailed example.

COMMON_FLAGS="-march=native -O2 -pipe"

CFLAGS="${COMMON_FLAGS}"

CXXFLAGS="${COMMON_FLAGS}"

FCFLAGS="${COMMON_FLAGS}"

FFLAGS="${COMMON_FLAGS}"

# NOTE: This stage was built with the bindist Use flag enabled

PORTDIR="/var/db/repos/gentoo"

DISTDIR="/var/cache/distfiles"
PKGDIR="/var/cache/binpkgs"

# This sets the language of build output to English.

# Please keep this setting intact when reporting bugs.

LC_MESSAGES=C

EMERGE_DEFAULT_OPTS="${EMERGE_DEFAULT_OPTS} --jobs=16

--load-average=16"

MAKEOPTS="-j16"

GRUB_PLATFORMS="efi-64"

USE="X elogind alsa pulseaudio -ahavi -dbus -systemd -wayland -nls -doc

-bluetooth -ios -aqua -cdrom -dvd -kde -qt -qt4 -qt5"

VIDEO_CARDS="radeon r600"

ACCEPT_LICENSE="*"

CPU_FLAGS_X86="aes avx avx2 f16c fma3 mmx mmxext pclmul popcnt rdrand

sha sse sse2 sse3 sse4_1 sse4_2 sse4a ssse3"

PORTAGE_TMPDIR="/tmp"

Configure o "locale":

# vim /etc/locale.gen

Adicione:

en_US.UTF8 UTF-8

pt_BR.UTF8 UTF-8

C.UTF8 UTF-8

# locale-gen

# eselect locale list

# eselect locale set [número]

Troque o "hostname", se quiser. Por exemplo, se quiser trocar o nome da

máquina para "ladybug":

# sed -i s/localhost/ladybug/ /etc/conf.d/hostname

Relógio (opcional):

# vi /etc/conf.d/hwclock

Escolha "local" ou "UTC".

Fuso-horário:

# ln -sf /usr/share/zoneinfo/America/Recife /etc/localtime

Obs.: troque "America/Recife" para sua capital.

# emerge --config sys-libs/timezone-data

KERNEL

Instale o "gentoo-sources" e compile:

# emerge -av sys-kernel/gentoo-sources sys-kernel/linux-firmware

# cd /usr/src/linux

# make localyesconfig

# make menuconfig (ou nconfig)

# make -j16

# make modules_install

# make install

GRUB

Certifique-se de ter colocado GRUB_PLATFORMS="efi-64" no arquivo

"make.conf". Depois execute:

# emerge --ask sys-boot/grub

# grub-install --target=x86_64-efi --efi-directory=/boot/efi

# grub-mkconfig -o /boot/grub/grub.cfg

ESCOLHENDO O "PROFILE"

Mude o perfil, se quiser:

# eselect profile list

# eselect profile set [número]

FERRAMENTAS DE REDE

Instale as ferramentas de rede com:

# emerge --ask sys-apps/iproute2 net-misc/dhcpcd

Se precisar se conectar à uma rede sem fio, instale:

# emerge --ask net-wireless/wireless-tools net-wireless/iw

net-wireless/wpa_supplicant

Habilite o dhcpcd:

# rc-update add dhcpcd default

APLICATIVOS ÚTEIS

Se quiser, aproveite para instalar algumas coisas a mais.

Algumas utilidades:

# emerge --ask gentoolkit eix flaggie layman

Mais aplicativos, incluindo o openssh:

# flaggie p7zip +rar

# emerge --ask www-client/google-chrome sakura dmenu dwm slock

xautolock p7zip htop openssh rust-bin xorg-server pulseaudio pulsemixer

# rc-update add sshd default

# rc-service sshd start

Truque para "enganar" o DWM e usar Sakura ao invés do St:

# ln -s /usr/bin/sakura /usr/bin/st

Finalizando:

# exit

# cd /mnt

# umount -lR gentoo

# reboot

Agora veremos a pós-instalação.