Linux

Introdução
Embora a grande maioria das pessoas não conheça ou ache que nunca usou esse
sistema pra nada, o Linux é um sistema operacional muito presente no mundo da tecnologia e
mesmo no nosso cotidiano.
Basicamente, o Linux é um sistema operacional, assim como o Windows 10 ou o Mac
OS. Sua função é gerenciar o hardware do computador e estabelecer a comunicação entre o
usuário e os recursos do computador. Quando falamos em Linux estamos nos referindo a uma
grande família de sistemas operacionais open source (código aberto), como o Ubuntu, Linux
Mint, Debian, Fedora, Red Hat, etc.
Facilmente encontramos dados que dizem, por exemplo, que o Windows está presente
em mais de 90% dos computadores pessoais, e isso é fato (basta consultar a OS Market Share
da StatCounter Global Stats). Contudo, sabemos que TI não é só desktop: temos que
considerar também servidores, celulares, softwares executados nos computadores, etc., e aí a
figura muda. Ainda que seu uso não seja muito difundido nos desktops, o Linux e os softwares
livres são presentes em diversas áreas, não somente na TI. Veja:
 Dados de novembro de 2020 apontam que os 500 maiores supercomputadores do
mundo executam Linux, e o motivo pra isso é simples: sua característica open
source, que permitem a esses equipamentos (que são projetados para fazerem
funções muito específicas – normalmente pesquisas científicas) executarem com o
melhor desempenho.
 Dos 25 maiores sites no mundo, apenas 2 não usam Linux como sua base, além
disso, dentre 1 milhão dos principais domínios do mundo, 95% usam Linux.
 Nos celulares, o Android domina o mercado com mais de 75% - sim, o Android é
um Linux com núcleo modificado.
 No Stack Overflow, uma das principais comunidades de desenvolvedores no
mundo, 25% dos profissionais de programação apontam que usam Linux.
 Até 2017, mais de 15 mil desenvolvedores contribuíram com o desenvolvimento
do Linux – por ser um sistema de código aberto, qualquer pessoa pode pegar seu
código, estuda-lo, melhorá-lo e compartilhar seus avanços com os demais – isso
forma a chamada comunidade do software livre. Até mesmo a Microsoft tem
contribuído com isso, e aos poucos tem integrado funções do Linux dentro do
Windows.
 Todos os principais programas espaciais usam Linux.
 90% das cargas de trabalho da nuvem são executadas em cima de Linux
 90% dos efeitos especiais de Hollywood são produzidos em cima de Linux.
 O Playstation 4 executa um SO chamado Orbis OS, que é baseado no kernel Linux
 Vários governos (como o da China, Turquia, EUA), exércitos e polícias (como o
norte americano, o holandês e o francês), bancos (como o nosso Banco do Brasil)
usam Linux em suas infraestruturas.

Enfim, deu pra ter uma ideia. Pode parecer que ele não está presente no nosso dia-a-
dia, mas é exatamente o contrário: o Linux é parte do nosso cotidiano, e é exatamente por isso
que é importante entende-lo, estuda-lo e acrescentar o conhecimento sobre esse sistema ao
nosso arsenal de competências.
Além disso, dada a vasta gama de aplicações que esse sistema possui, também existe a
necessidade do mercado por profissionais que tenham conhecimentos no assunto. De
analistas de suporte a administradores de sistemas e redes, diversas oportunidades são dadas
àqueles que possuem conhecimento em Linux.
Certificações
Uma certificação é um documento que atesta e aprova as habilidades de alguém em
alguma área, processo ou solução. Em TI é bastante comum encontrarmos certificações, e o
mercado valoriza bastante profissionais que as possuem, sendo um bom caminho para
ascensão profissional.
É possível estudar por conta para uma certificação ou entrar em programas de
treinamento específicos para tanto, e diversas organizações e empresas cuidam destes
processos.
Para Linux, as certificações mais comuns são:
 LPI – Linux Professional Institute. É subdividida em 6 certificações, cada uma com
um nível diferente de conhecimentos e habilidades. A mais básica delas é a LPI
Linux Essentials, para atender aqueles que usam o Linux em um nível mais básico.
Depois, temos a LPIC-1 – Linux Administrator (a mais conhecida e procurada no
Brasil), voltada para administradores de sistemas Linux e analistas de suporte,
sendo concentrada em atividades de instalação, configuração e manutenção do
sistema. A LPIC-2 – Linux Engineer tem a LPIC-1 como requisito, e avalia a
capacidade do profissional em administrar ambientes cliente-servidor pequenos e
médios baseados em Linux. Por fim, a LPIC-3 – Linux Enterprise, é o nível mais alto,
e atesta que o profissional é capaz de administrar ambientes complexos e com
altas exigências. Ela é subdividida em 300 – Mixed Environment, 303 – Security e
304 – Virtualization and High Availability.
 CompTIA – Computing Technology Industry Association. Essa organização promove
diversas certificações em TI, como Fundamentos, redes, segurança, mobilidade e
Linux (a certificação da CompTIA é a Linux+). É bastante reconhecida nos EUA.
 Red Hat: a distribuição Red Hat é uma das mais utilizadas em grandes empresas,
por isso suas certificações são bastante procuradas, contudo, são bastante caras
(tanto os cursos quanto as provas), e as avaliações são bastante complexas, o que
torna quem a tem um profissional bastante valorizado e diferenciado. As 3
principais são a RHCSA (Red Hat Certified System Administrator, semelhante a
LPIC-1 e a Linux+, mas concentrada em Red Hat), RHCE (Red Hat Certified Engineer,
voltada para administradores de sistemas sêniores) e a RHCA (Red Hat Certified
Architect, o nível mais alto)
 Suse: a distribuição Suse também possui um programa de certificações bastante
reconhecido no exterior. É dividido em 3 níveis: SCA (Suse Certified Administrator),
SCE (Suse Certified Engineer) e SEA (Suse Enterprise Architect)

Do UNIX ao GNU/Linux
Tido como um dos sistemas operacionais mais influentes da história da computação,
na proposição da utilização de um ambiente multiusuário e multitarefa, o UNIX ainda hoje é
base para diversos sistemas operacionais (como Linux, Android, MAC OS e outros), aplicações
de grandes corporações e aparelhos do cotidiano, tendo larga utilização em servidores devido
à sua estabilidade e segurança.
Este sistema tem seu embrião em um projeto executado na década de 60, através do
desenvolvimento de um sistema operacional de grande porte conhecido como MULTICS
(Multiplexed Information and Computing Service), desenvolvido pelo MIT (Massachusetts
Institute of Technology) em parceria com a Bell Labs (divisão de pesquisas da AT&T) e a
General Eletric.
 A ideia do MULTICS era disponibilizar um sistema 24/7 que se destinava a servir
milhares de terminais burros (que não fazem nenhum processamento, apenas exibem imagens
e enviam comandos do usuário para um servidor) simultaneamente, onde as pessoas
comprariam estes terminais para suas casas e o uso seria tarifado. Esta ideia fracassou e o
MULTICS acabou sendo utilizado para fins educacionais e processamento pesado de
informações. O último servidor MULTICS foi desativado em 2000, e seu código fonte foi aberto
em 2007.
Mesmo com a saída da Bell Labs do projeto, Kenneth Thompson continuou estudando
o projeto MULTICS, e criou um sistema com pretensões menores, para utilizar em seu
computador “pessoal”, chamado de UNICS (Uniplexed Information and Computing Service),
utilizando linguagem Assembly para isso, porém, a utilização desta linguagem dificultava a
portabilidade do sistema, ou seja, era difícil replicar este sistema em outros computadores.
A linguagem Assembly também é conhecida como linguagem de montagem, é uma
linguagem de programação de baixo nível, criada na década de 50, onde escrevemos
programas de computador usando uma notação humanamente legível para o código de
máquina que o computador compreende. O código de máquina é um padrão de bits que são
interpretados e traduzidos pela CPU em comandos funcionais. Cada um desses comandos
executa uma tarefa específica baseada em uma tabela de códigos predefinidos, assim, o
Assembly é uma linguagem que pega essa tabela de códigos e substitui por símbolos
(mnemônicos) legíveis por nós. Para traduzir o Assembly para a linguagem de máquina temos
o chamado Assembler. Atualmente, a Assembly é usada para manipulação direta de hardware
(como em drivers, sistemas embarcados de baixo nível) e para sistemas que precisam de
desempenho crítico, como sistemas de tempo real.
Para diferenciar linguagem de programação de baixo nível de linguagem de
programação de alto nível, basta compreender que quanto mais baixo o nível da linguagem,
mais próximo da linguagem de máquina propriamente dita ela está. Quanto mais alto, mais
distante a linguagem está do código de máquina e mais próxima ela está da linguagem
humana, o que permite que os programas sejam feitos sem a preocupação com o hardware
que executará o sistema. Portanto, a definição de alto ou baixo nível não se refere ao poder ou
importância da linguagem, mas sim ao nível de proximidade entre o código fonte e a lógica
final da CPU.
Mais baixo que o Assembly só se programarmos diretamente em hexadecimal ou
binário e escrevermos os bytes diretamente na memória do computador. Por ela ter essa
proximidade com o hardware do sistema, é necessário conhecer as características da
arquitetura do sistema que será utilizado (já que enviamos comandos diretamente para o
processador e unidades de armazenamento), e como cada família de processadores tem sua
própria linguagem assembly, ela não é uma linguagem portável, que pode ser facilmente
replicada em outros computadores.

Figura 1 - Programa em Assembly

 Em 1973, o também pesquisador da Bell Labs, Dennis Ritchie, criou uma das mais
importantes linguagens de programação de alto nível existentes, a linguagem C, e utilizou-a
para reescrever o UNICS. Nesta época, o UNICS foi rebatizado para UNIX, tornando-o o
primeiro sistema operacional não acadêmico a ser escrito em linguagem de alto nível.

Figura 2 - Ken Thompson e Dennis Ritchie

Figura 3 - Programa em Linguagem C

A popularidade do UNIX com a linguagem C se dá pelo fato de que passou a ser

possível portar o sistema para outras arquiteturas, bastando para isso colocar o compilador C
para estes computadores. Nestas, o sistema é recompilado, o código fonte fica praticamente
inalterado (com alterações somente para as particularidades das arquiteturas), e o
desenvolvimento de aplicações é facilitado. Perceba então que o papel do compilador é pegar
um código fonte escrito em linguagem compreensível por nós (normalmente uma linguagem
de alto nível), e criar um programa equivalente em linguagem de máquina. As primeiras
versões do UNIX foram utilizadas exclusivamente pela AT&T, mas rapidamente o sistema virou
alvo de interesse de outras instituições.
 Figura 4 - O processo de compilação

A possibilidade de acesso ao código fonte foi fundamental para o crescimento do

sistema, pois permitia aos utilizadores modificar e adaptar o sistema de acordo com suas
necessidades. Dentro do meio científico e universitário, notoriamente reconhecidos pela
tradição de troca de informações, várias pessoas tinham conhecimentos profundos em
programação e algum conhecimento teórico sobre o funcionamento de sistemas operacionais,
de forma que estes conhecimentos foram utilizados para criar novas versões baseadas no
UNIX. Nesta altura, as instituições de ensino já tinham redes de dados simples que as
interligavam, o que permitia a troca de informações e dados via e-mail sobre o sistema.
Versões notáveis do UNIX nessa época são o BSD da universidade de Berkley e o
System V da AT&T.
Com o passar dos anos, o UNIX expandiu-se bastante, entrando em diversos setores,
até se tornar um verdadeiro sistema operacional comercial. Uma grande variedade de
fabricantes de hardware começou a incluir o sistema em seus computadores.
Por outro lado, a AT&T começou a restringir cada vez mais a licença de uso do sistema,
tornando o sistema cada vez mais comercial e dificultando o acesso para muitos utilizadores.
Este fato começou a criar descontentamento nos usuários originais, que mais contribuíram
para a expansão e desenvolvimento do UNIX.
Em paralelo a isso, no início dos anos 80, Richard Stallman era funcionário do AI Lab do
MIT. Ao enfrentar dificuldades com o software para impressão de uma máquina Xerox 9700,
descobriu que não podia fazer nada para arrumar o problema, já que não tinha acesso ao
código fonte.
Contrário a esta imposição e limitação dos softwares proprietários, cada vez mais
presentes no mercado corporativo, criou uma fundação, chamada FSF (Free Software
Foundation), que se propunha desenvolver e proteger o software livre. Um dos maiores
objetivos da FSF era construir um ambiente de trabalho constituído integralmente por
software livre, recriando o espírito inicial da comunidade de utilizadores de UNIX.
Para proteger legalmente o software livre, foi criada em 1989 uma nova licença de uso,
chamada GPL (General Public Licence) que garante a qualquer pessoa o direito de copiar,
redistribuir e até modificar e melhorar todo o software por ela protegido. Um trabalho
derivado de projeto que utiliza licença GPL só pode ser distribuído se usar a mesma licença.
Dela se originam as 4 liberdades do software livre:
 Liberdade 0: liberdade de executar o programa, para qualquer propósito;
 Liberdade 1: liberdade de estudar como o programa funciona, e adaptá-lo às
nossas necessidades. Para isso, o acesso ao código fonte é um pré-requisito;
 Liberdade 2: liberdade de redistribuir cópias de modo que possamos ajudar ao
próximo;
 Liberdade 3: liberdade de aperfeiçoar o programa, e liberar estes
aperfeiçoamentos, de modo que toda a comunidade se beneficie. Mais uma vez, o
acesso ao código fonte é um pré-requisito para essa liberdade.
 Figura 5 - Richard Stallman

Os ativistas da FSF eram, em grande parte, programadores e especialistas na criação de

software para sistemas. Quando estes programadores tiveram de escolher um modelo como
base para criar um novo sistema operacional, utilizaram o UNIX. Desta ideia surge a palavra e o
projeto GNU, que além de representar um animal real, é um acrônimo recursivo (uma
abreviatura que faz referência a si própria na expressão que a simboliza), pois GNU significa
GNU is Not Unix.
A ideia do projeto era desenvolver um ambiente composto por programas e utilitários
capazes de substituir totalmente um sistema UNIX apenas com software livre. Por esse motivo,
todas essas aplicações foram desenvolvidas mantendo a compatibilidade com as versões
padrão do UNIX. Aliado ao crescimento da Internet na época, temos aí uma época de grande
crescimento da iniciativa do software livre.
Em 1991, o sistema operacional estava quase pronto, mas ainda faltava o kernel.
Através do projeto GNU foi criado o kernel Hurd, mas ele ainda era instável. Neste cenário,
surgem duas figuras: Andrew Tanenbaum e Linus Torvalds.

Figura 6 - Linus Torvalds e Andrew Tanenbaum

Tanenbaum é reconhecido mundialmente por suas contribuições acadêmicas no

âmbito da Tecnologia da Informação. Em 1987, ele criou o sistema operacional open source
Minix (Mini-UNIX), um sistema UNIX-like (semelhante ao UNIX) pago escrito em linguagem C e
Assembly, a fim de explicar os princípios de seu livro Sistemas Operacionais: Projeto e
Implementação.
Torvalds, por sua vez, se inspirou neste projeto para criar, como um passatempo, um
novo kernel de sistema operacional. Durante quatro meses no ano de 1991 ele desenvolveu
este sistema, que foi batizado inicialmente de Freax (numa ideia de sistema gratuito – free – e
uma analogia ao termo “freak”, que pode ser entendido como “aberração”). Porém, o dono da
página FTP onde Torvalds deixou o kernel achou o nome muito ruim, e associando o nome do
desenvolvedor, renomeou o arquivo como Linux, disponibilizando-o para a comunidade.
Figura 7 – Mensagem de Torvalds ao postar a primeira versão do kernel Linux num fórum na internet

Este núcleo poderia usar todas as peças do sistema operacional GNU, e a partir da
junção destas duas forças temos o surgimento do sistema completo, o GNU/Linux. Stallman
queria que o sistema se chamasse Lignux, mas o nome não pegou. Embora a maioria das
pessoas utilize apenas o termo “Linux” para se referir ao sistema, quando nos referimos a ele
estamos falando do sistema GNU/Linux, ou seja, o sistema operacional GNU com núcleo Linux.
Contudo, o próprio Linus Torvalds defende que a forma a qual nos referimos ao sistema não
importa, desde que o usemos.
A partir daí, o desenvolvimento do sistema vem do resultado da soma dos esforços de
Linus Torvalds, da FSF de Richard Stallman, e da comunidade do software livre, o que nos leva
ao sistema atual, com funcionamento em processadores de 32 e 64 bits, suporte a múltiplos
processadores, amplo suporte a drivers, e um vasto suporte da comunidade, que disponibiliza
recursos e a documentação para utilização das aplicações. O princípio de funcionamento deste
SO fez surgir a Lei de Linus: quando várias pessoas enxergam um problema e trabalham nele,
este pode ser resolvido de forma mais rápida do que individualmente. Literalmente, o Linux é
resultado da contribuição de milhares de desenvolvedores espalhados pelo mundo.
Atualmente, o kernel Linux está na versão 5.10.6 e é utilizado em smartphones
(através do Android), carros, aplicações domésticas, é a base de boa parte dos
supercomputadores que trabalham em descobertas científicas, bolsas de valores, grandes
servidores, etc.
É importante notar que apesar das boas características que estamos discutindo até
aqui, o Linux não vingou nos desktops. Alguns fatores contribuíram pra isso. As primeiras
distribuições exigiam um nível de conhecimento alto de quem as manipulava, e muitas não
possuíam interface gráfica. Isso criou uma cultura de que o Linux é um sistema difícil de mexer,
o que já não é mais verdadeiro há muito tempo: diversas distribuições são tão ou mais simples
de usar que o próprio Windows. Além disso, durante anos houve propaganda negativa, até
mesmo do antigo CEO da Microsoft, que em 2001 disse que o Linux “é um câncer que se une a
qualquer propriedade intelectual quando a toca”. Anos depois ele se retratou da frase,
contudo, desfazer a imagem é outra história.
Fato é que essa cultura e propagandas negativas não retratam a realidade, o que só é
reforçado pelo posicionamento do Linux em diversas áreas na atualidade.
Distros
Essa natureza open source do Linux permite que sejam criadas uma série de diferentes
distribuições do sistema. Uma distribuição, também chamada de distro, é um conjunto de
softwares, ferramentas e utilitários, tendo como base o sistema GNU/Linux. A comunidade
explica as distribuições fazendo uma comparação com sorvetes: o sorvete em si é o
GNU/Linux, a base, a massa. Os sabores são as distribuições.
Em termos práticos, isso significa que uma pessoa pode pegar o sistema base,
adicionar os aplicativos e configurações que quiser, a interface gráfica do seu gosto, compilar
isso através de uma aplicação e criar a nova imagem do sistema, resultando em uma nova
distribuição que essa pessoa pode ter para uso particular ou oferecer para uso da comunidade.
A primeira distribuição Linux completa foi chamada de SLS 1, porém, como não tinha
atualizações, não teve muito sucesso. Dela surgem três “famílias” de distribuições, que temos
até hoje: Slackware (com a filosofia de estabilidade utilizando recursos mínimos de hardware),
Debian (com a ideia de ser totalmente open source gratuito, por consequência, suas
atualizações demoram para serem lançadas. Nenhuma linha de código proprietário entra em
softwares utilizados pelo Debian) e Red Hat (paga, atualmente focada em servidores).
Das “famílias” surgem outras diversas distribuições 2. Por exemplo, do Debian surgiu o
Ubuntu e o Mint, do Red Hat surgiu o OpenSUSE e o Fedora.
Hoje vemos distribuições com diversos focos distintos, por exemplo:
 Para desktop: Ubuntu, Mint, ElementaryOS;
 Para servidores: RHEL, Debian, CentOS;
 Para segurança, testes de invasão: Kali, Parrot;
 Para auxílio na investigação de crimes digitais: Caine, Deft;
 Para educação: Linux Educacional, EDuzeru;
 Que executam em computadores antigos mesmo nos dias atuais: TinyCore, Damn
Small Linux, Lubuntu;
 Distribuições minimalistas, onde o usuário precisa compilar o código fonte de
todos os programas, deixando-os totalmente adaptados ao hardware, obtendo
melhor desempenho: Arch, Gentoo;

Com isso, a gama de possibilidades de expansão do Linux é tremenda, visto que existe
um amplo suporte da comunidade de desenvolvedores, as possibilidades de customização
estão abertas para todos, e cada vez mais a imagem do Linux ser um sistema “difícil de mexer”
diminui.
O Minix ainda existe, está em versão 3.3.0 e é usado para estudos. A FSF se dedica a
defender os aspectos mais estruturais do software livre, como as 4 liberdades, licenças e
documentação. O UNIX, por sua vez, atualmente é um sistema proprietário de código fechado,
está em sua 5ª versão, e ainda é utilizado em servidores, mainframes e mega computadores
para cálculos, tendo versões comerciais específicas entregues por empresas como IBM (AIX),
HP (HP-UX) e Oracle (Solaris). Muitos sistemas, como distribuições Linux e o MAC OS, hoje são
chamados de UNIX based ou UNIX like, por terem suas bases na ideia deste SO. Para que um
sistema seja considerado compatível com UNIX (UNIX-like), como o Linux, ele precisa se
enquadrar no Single UNIX Specifications (Especificações Únicas do UNIX), definidas pela norma
POSIX (Portable Operating System Interface, com o X para representar a herança do sistema
UNIX), criada a fim de padronizar determinados pontos dos sistemas UNIX based, como a

1
Mais detalhes sobres as primeiras distribuições podem ser vistos em
https://sempreupdate.com.br/conheca-as-primeiras-distribuicoes-linux/
2
O site https://distrowatch.com/ traz uma lista com várias centenas de distribuições de mercado, e
novidades relacionadas a elas. Diversos sites possuem recomendações de distros para aplicações
específicas (usuários iniciantes no Linux, distribuições para desenvolvimento, segurança, leves, etc.)
estrutura do sistema de arquivos, APIs e serviços sistema, por exemplo. A ideia é que um
programa ou sistema compatível com POSIX seja mais fácil de portar para outro sistema ou
programa POSIX.
Além disso, também precisamos notar que existem dois movimentos distintos nos dias
atuais dentro da comunidade: que divergem em um ponto específico: a cobrança. A Open
Source Initiative, criada em 1998, surge devido a preocupações da comunidade com as
confusões que já aconteciam entre usuários, que pensavam que todo software livre também é
gratuito. Então, essa vertente da comunidade passa a adotar o termo open source para se
referir a esta categoria de softwares, pensando na metodologia de desenvolvimento, onde
várias pessoas podem contribuir. Em resumo, um programa de código aberto deve garantir
livre distribuição, não podendo restringir a venda ou distribuição gratuita, deve incluir o código
fonte (ou indicar onde obtê-lo) e permitir distribuição compilada, e não deve proibir uso de
softwares que tenham outras licenças associadas. Contudo, Stallman e a FSF se posicionaram
“contra” essa ideologia, defendendo também que os softwares, além de permitirem o acesso
ao código fonte e as contribuições dos usuários, também devem ser adquiridos sem custos,
por entenderem que isso é um “problema social”, e também defendem a ideia de não
propriedade do software.3

Baixando distros e o distrowatch

As distribuições possuem páginas próprias que possuem seções de download, então,
basta escolher uma, busca-la num mecanismo de pesquisa, acessar o site e baixar.
Normalmente o arquivo virá em formato .ISO, e as opções de download incluem servidores
associados à distro ou torrents.
Escolher a distribuição talvez seja o passo mais “complicado” do processo. Existem
diversos guias que dão dicas sobre as distribuições mais indicadas para cada tipo de público.
Normalmente, para iniciantes, recomenda-se o uso do Ubuntu (ou suas variantes) ou o Linux
Mint.
Também existe o site distrowatch, que é uma espécie de observatório das
distribuições Linux existentes, trazendo detalhes sobre elas, notícias sobre atualizações,
ranking de popularidade, etc. Ele é interessante pois também traz o caminho das páginas de
download das distribuições, fóruns de usuários com as dúvidas e ajudas da comunidade

Criando um pen drive de boot

Uma vez que temos o arquivo com a distribuição em mãos, precisamos criar um pen
drive bootável ou queimar a ISO em um DVD para que o SO possa ser instalado. Trabalhar com
o pen drive é o mais comum e simples atualmente, visto que são dispositivos acessíveis e
muitos equipamentos já não vêm mais com unidades de DVD.
No Windows um dos programas mais conhecidos para fazer essa tarefa é o Rufus, que
inclusive possui uma versão portátil, ou seja, ele nem precisa ser instalado na máquina. Basta
inserir o pen drive, apontar onde está a ISO do SO e dar sequência ao processo. Tenha em
mente que o pen drive é formatado nesse processo, então, não use um que tenha arquivos
pessoais, pois eles serão perdidos.
O Rufus não possui uma versão para Linux, então, caso você use esse sistema e queira
outras alternativas, existem programas como o UNetbootin, balenaEtcher e o próprio
comando dd para realizar essa tarefa de criação do pen drive de boot.
3
Mais detalhes podem ser vistos no artigo original (em inglês): https://www.gnu.org/philosophy/free-
software-for-freedom.html e neste outro: https://www.digitalocean.com/community/tutorials/Free-vs-
Open-Source-Software
Live Media e a Instalação de um Linux
Ao iniciar o computador com um pendrive ou DVD de uma distribuição Linux, em
algumas distribuições a primeira tela vai pedir a seleção de idioma. Em seguida, escolhemos a
forma que queremos que o sistema seja carregado.
Em alguns casos, já temos disponibilizada a opção de iniciar a instalação do sistema,
em outros, o SO é carregado a partir da unidade usada (pen drive ou DVD), e no final temos
um sistema pronto para uso – mas não instalado na máquina. Isso é o que chamamos de Live
CD ou Live Media. Basicamente, temos o SO inteiro disponível para uso, podemos fazer o que
quisermos nele (navegar na internet, gerenciar documentos, etc.), e no final, ao reiniciar o
computador, o sistema antigo continua lá e é carregado. O Live CD é bastante útil para
fazermos testes, para conhecermos a distribuição em si, e até mesmo para operações de
suporte ele é interessante, pois temos acesso a unidade do sistema operacional instalado (e
outras, se existirem), e podemos, por exemplo, copiar os arquivos (útil em casos onde o SO da
máquina está inacessível). Contudo, tenha em mente que por não estar instalado de fato no
HD, e os pen drives terem uma velocidade de leitura inferior, o desempenho do SO não será o
mesmo se comparado com o SO instalado.
A instalação muitas vezes é bastante simples e intuitiva. Selecione o idioma,
localização, teclado, tome bastante cuidado na tela de particionamento, defina usuário e
senha, e aguarde o processo ser concluído.

Multi Boot
Dual Boot ou Multi Boot significa instalar dois ou mais sistemas operacionais no
mesmo computador. De fato, podemos instalar quantos sistemas quisermos, seguindo o limite
que o gerenciador de boot da máquina nos permite.
Toda vez que ligarmos o computador, um menu é exibido e escolhemos qual sistema
queremos que seja carregado. Isso nos permite ter no mesmo computador, por exemplo,
Windows e Linux, um Windows mais recente e outro mais antigo para compatibilidade de
programas, duas distribuições Linux com finalidades diferentes, enfim, as possibilidades são
inúmeras.
Opte pelo uso do multi boot quando precisar extrair o máximo do desempenho do
hardware da máquina – por exemplo, usar Windows para jogos e Linux para as atividades do
dia a dia -, contudo, se quiser o segundo sistema apenas para alguns testes ou se for
necessário executar os dois sistemas ao mesmo tempo, considere o uso de virtualização ao
invés do multi boot.
Tenha em mente que usar o multi boot tem suas desvantagens: para alternar entre os
sistemas é necessário reiniciar o computador, e os programas que são instalados em um SO
não podem ser acessados pelo outro.
Caso o cenário do dual boot seja entre Windows e Windows, recomenda-se que
primeiro seja instalada a versão mais antiga e depois a mais recente, pois o sistema mais
antigo pode ter problemas ao interpretar arquivos de sistema mais novos e substituir por
versões mais antigas, danificando o mais novo.
Agora, caso o cenário do multi boot seja entre Windows e Linux, recomenda-se que
primeiro seja instalado o sistema da Microsoft e depois o Linux, pois este possui um
gerenciador de boot chamado GRUB, que reconhece todos os sistemas instalados no disco e
permite fazer a escolha entre eles. Caso o Windows seja instalado depois, ele sobrescreve o
GRUB4 e ignora outros sistemas existentes (na dúvida, sempre deixe o Windows primeiro e os
demais depois, pois o sistema da Microsoft não gosta de concorrência).
Outro problema que pode ocorrer com o multi boot vem do fato que a partir do
Windows 8, ao desligar o computador, o sistema deixa o HD em modo stand by (como se fosse
uma hibernação), a fim de iniciar de forma mais rápida (por exemplo, a sessão do kernel e
drivers são salvos num arquivo de hibernação), contudo, se precisarmos acessar os dados em
outro sistema, a partição do Windows pode ficar inacessível. Caso encontre esse problema, a
solução é desligar a inicialização rápida nas opções de energia do Windows (o que é uma
solução definitiva, porém, vai deixar a inicialização do Windows mais lenta), desligar o
Windows pelo prompt através do comando shutdown /s /full /t 0, ou ainda, desligar/reiniciar o
Windows pressionando a tecla Shift, o que faz com que o sistema acione o desligamento total
apenas naquela vez.
Para o dual boot é necessário ter em mente que são dois sistemas operacionais que
precisam de espaço em disco, logo, o particionamento é fundamental para que essa tarefa seja
feita com sucesso. Por exemplo, o Windows 10 recomenda pelo menos 32 GB para ser
instalado (fora os programas e arquivos do usuário), ao passo que o Ubuntu recomenda que
pelo menos 20 GB seja reservado para seu uso. Caso o HD esteja todo particionado e seja
necessário instalar um Linux, será preciso redimensionar o HD do Windows, reduzindo-o para
que a instalação da distribuição possa criar o novo espaço, determinar um sistema de arquivos
e gravar os arquivos.
Os passos para a instalação dos dois sistemas do zero basicamente são: criar um pen
drive de boot com o Windows, instalá-lo tomando cuidado para deixar espaço em disco
suficiente para o Linux, instalar drivers e programas no Windows, depois criar o pen drive de
boot do Linux, instalá-lo tomando o cuidado para não apagar o Windows no processo na tela
de particionamento, e essencialmente é isso.

Navegação básica no sistema e Configurações básicas

Embora as coisas tenham nomes diferentes, a navegação no Linux é bastante
semelhante ao que encontraríamos no Windows. Claro que leva um tempo para nos
acostumarmos com os locais e nomes das coisas, mas não há grandes dificuldades no
processo.
Muitas distribuições procuram um visual limpo nas suas áreas de trabalho, trazendo
poucos ou nenhum ícone. O gerenciador de arquivos fica ao lado do “menu iniciar”, que
também pode ser acessado usando a tecla “Windows” (que pode ser referida com o nome
“meta” no Linux). Vários atalhos do Windows também são acessíveis da mesma forma no Linux
(embora isso possa mudar de distro para distro). Então, Windows + E abre o explorador de
arquivos, Windows + D mostra o desktop, Windows + R traz o executar, e por aí vai. Tudo isso
é configurável.
As distribuições normalmente trazem 4 áreas de trabalho que podem ser usadas
simultaneamente – um recurso adotado em versões recentes do Windows, e que já existe no
Linux há bastante tempo.
No canto inferior direito da barra de tarefas temos botões semelhantes aos que
encontraríamos num Windows: data e hora, dispositivos removíveis conectados, status de
rede, som e bateria. Tudo configurável clicando com o botão direito, e – é sempre bom
ressaltar – isso pode variar de acordo com o Linux usado e a interface gráfica em questão (por
exemplo, tem interfaces que mostram as opções no canto superior da tela, outras no canto
esquerdo, enfim, tudo depende de qual é a GUI e a configuração realizada).

4
Veja como recuperar o GRUB caso o Windows o sobrescreva aqui:
https://www.edivaldobrito.com.br/recuperando-o-boot-grub-ubuntu-depois-de-instalar-o-windows/
 No menu iniciar temos organizações também semelhantes a um Windows: lá
encontramos as opções de desligamento, preferências do sistema (semelhantes a um painel
de controle), acesso a aplicativos, gerenciadores de programas, etc.
No explorador de arquivos também temos uma organização semelhante ao sistema
Microsoft: no painel esquerdo temos atalhos a seções de navegação frequente, como
Downloads, Desktop, etc., acesso a árvore completa do sistema de arquivos e outros
diretórios.
Independentemente disso poder mudar de lugar de acordo com a distribuição
escolhida, o modo de navegação no Linux não difere muito de um Windows. Claro, as coisas
mudam de nome ou de lugar, mas não é nada que o uso não nos permita acostumar.
Quanto às configurações, normalmente há uma seção de preferências no menu inicial
que nos permite ter acesso a cada um dos itens de uso comum: teclado, mouse, vídeo, tela de
descanso, opções de energia, usuários, impressoras, rede, etc. Basta explorar e encontrar as
opções desejadas.
Em alguns casos pode ser necessário instalar drivers atualizados para que o sistema
tenha seu desempenho melhorado. Isso pode ser feito através de download dos drivers
através dos sites dos fabricantes, ou mesmo pela seção de atualização do sistema.

Programas do Linux que são “equivalentes” aos do Windows

Uma vez que estamos num sistema diferente, é normal nos perdermos nos programas
que ele nos oferece. A lista abaixo tem uma breve relação dos programas do Linux que são
“equivalentes” aos do Windows:

Funcionalidade No Windows No Linux

Aplicativos de Escritório Office (Word, Excel, etc.) LibreOffice, OpenOffice
Navegadores Edge, Internet Explorer Chrome, Firefox, Opera
Cliente para gerenciar e-mails Outlook Thunderbird, Evolution
Criação de diagramas Visio Kivio, Dia, CalligraFlow
Desenvolvimento de softwares VisualStudio Eclipse, NetBeans
Reprodutor de áudio Windows Media Player VLC Media Player
Edição de imagens Adobe Photoshop GIMP
Edição de imagens vetoriais Adobe Illustrator Inkscape
Diagramação, criação de Adobe InDesign Scribus
revistas, jornais, panfletos, etc.
Edição de vídeos Adobe Premiere Cinelerra, Kdenlive
Pós-produção de vídeos Adobe After Effects Natron
Montagem de imagens em Daemon Tools Mount
formato ISO
Gerenciador de anotações, Evernote NixNote
tarefas pessoais, agenda
Gravação de CDs/DVDs Nero K3b
Aquisição/reprodução de iTunes Amarok
músicas
Software de desenho assistido AutoCAD FreeCAD
por computador (CAD)
Modelagem 3D Maya Blender
Clientes Torrent uTorrent, BitTorrent Transmission, qBitTorrent
Edição de Áudio SoundForge, Adobe Audacity
Audition
Bloco de Notas Bloco de Notas Gedit, NotepadQQ
Clonagem de disco Norton Ghost Clonezilla

Nota: alguns destes programas listados para Linux também possuem versões para
Windows.

Gerenciamento de Programas: GUI e apt

Assim como boa parte das tarefas que podemos realizar num sistema operacional,
temos duas maneiras de gerenciar os programas instalados no computador: via interface
gráfica usando os gerenciadores de pacotes e via linha de comando. Note que com frequência
a senha do usuário será requerida para fazer as alterações desejadas no sistema.
Gerenciadores de pacotes são programas utilizados para instalação, remoção e
atualização de programas no Linux. Normalmente, cada distribuição possui milhares de
pacotes distintos.
Os programas são distribuídos através de pacotes, que estão ligados a metadados, que
por sua vez possuem informações adicionais, como descrição do aplicativo e lista de
dependências, ou seja, os programas necessários para que o aplicativo em questão funcione
corretamente. Outros metadados incluem um resumo do pacote, sua descrição, licença,
versão do software, etc.
Um programa pode ser dividido em vários pacotes, onde podemos instalar apenas as
partes que nos forem convenientes, deixando o sistema mais leve. Estes programas podem ser
desde aplicativos simples de usuário, como reprodutores de música, até arquivos essenciais do
sistema operacional. Os pacotes normalmente são criados para uma versão específica de uma
determinada distribuição, pois as dependências podem variar entre distribuições e até mesmo
entre versões da mesma distro.
Um pacote de software é um arquivo, normalmente compactado de acordo com a
distribuição, que contém todos os arquivos necessários para a instalação de um software. Isso
inclui os binários, scripts de instalação, configurações, dados, bibliotecas, documentação,
ícones, etc.
É bastante comum que um pacote tenha uma série de dependências para funcionar.
Muitas vezes essas dependências são outros pacotes ou bibliotecas que precisam estar
instalados no sistema, então, não se assuste se várias dependências forem instaladas sendo
que você “só” desejava um programa específico. Ainda que pareça ser algo desnecessário (o
que não é), isso é uma peça chave para que o Linux mantenha o sistema mais enxuto, pois
somente pacotes e dependências necessárias são instalados. Essa modularização também
aumenta a segurança do sistema, pois se existe uma vulnerabilidade num pacote ou biblioteca,
atualizá-lo automaticamente atualiza os pacotes que dele dependem – e mesmo que não seja
uma falha de segurança, uma atualização num pacote dá novos recursos para seus
dependentes. As dependências são resolvidas pelos gerenciadores de pacotes.
Os programas e seus metadados podem ser encontrados em repositórios, que podem
ser locais (via CD, DVD ou HD) ou online (servidores FTP) e são acessados pelos gerenciadores
de pacotes. A grande vantagem no uso de pacotes baixados via repositórios oficiais é que a
segurança do sistema é aumentada, uma vez que para fazer parte de um repositório o
programa precisa ter seu funcionamento certificado. É bem diferente do que temos no
Windows, onde encontramos um mesmo programa em vários locais, e não temos
necessariamente uma “central” de programas eficaz para Windows (até existe a tentativa disso
a partir do Windows 8, mas a Microsoft ainda está atrás das distribuições Linux neste quesito –
o fator da gratuidade da maioria dos programas ajuda muito o Linux nesse sentido). Também
existem os repositórios adicionais (ou não oficiais), onde os pacotes adicionais são inseridos e
administrados por terceiros. Neles podemos ter pacotes mais atualizados (embora menos
testados) e até mesmo pacotes que não entram no repositório oficial por diversas questões
(exemplo: pacotes de suporte a MP3).
Em distribuições Debian, o arquivo /etc/apt/sources.list 5contém a lista dos
repositórios que o sistema e os gerenciadores de pacotes em uso buscarão ao trabalhar com
os pacotes. Nele, encontramos linhas com formato parecido com a imagem abaixo:

Figura 8 - Estrutura do sources.list

Cada linha corresponde a uma configuração diferente, sendo dividida em 4 partes:

 1ª parte (deb): significa que o sistema baixará programas já compilados. Para
baixar os fontes dos programas, devemos alterar para deb-src
 2ª parte (endereço web): é o endereço do repositório, o site que contém os
pacotes. Esses sites podem ser de servidores nacionais que suportam a distribuição
ou até mesmo o servidor oficial.
 3ª parte (focal ou focal-updates): é a versão do sistema.
 4ª parte (main restricted, universe, multiverse, main contrib non-free, etc.):
especifica qual repositório será usado no download. Main significa pacotes
totalmente livres (FOSS – Free Open Source Software). Universe também traz
pacotes de software livre aberto, mas a equipe de suporte não garante
atualizações regulares de segurança (a comunidade mantém o software).
Multiverse são programas que NÃO são software livre, portanto, também não são
suportados pela equipe de desenvolvedores da distribuição e cabe ao usuário
verificar se ele tem direito de usar o programa em questão. Restricted diz respeito
a drivers proprietários.

Nada nos impede de fazer o download dos programas em sites, ou obtê-los de

qualquer outra forma. Os programas podem ser instalados via interface gráfica de forma
semelhante ao que temos no Windows, clicando no executável e seguindo os passos para
instalação. Contudo, os programas também podem ser instalados via linha de comando, ou
então podemos adquirir o programa com seu código fonte 6 e realizar todo o processo de
compilação, possibilitando melhor desempenho dentro do computador.
Como exemplos de gerenciadores de pacotes7 temos:
 o pkgtool (padrão do Slackware)
 dpkg (padrão no Debian e seus derivados), trabalha com arquivos .deb
 apt (advanced package tool, também padrão no Debian), difere do dpkg pois
consegue administrar os pacotes de forma automática, inclusive as dependências.
 Rpm (red hat packet manager), padrão das distribuições baseadas no Red Hat

5
Lembre que o Linux trata tudo como arquivo. Veja que esse é um arquivo de texto que contém toda a
configuração de repositórios do sistema e podemos alterá-lo livremente (desde que tenhamos a
permissão)
6
Para mais detalhes sobre instalação de programas via linha de comando e sobre a compilação dos
programas para instalação, consulte o link https://www.vivaolinux.com.br/artigo/Instalando-programas-
no-Linux-Completo-e-total
7
Para mais detalhes sobre gerenciadores de pacotes, consulte o link
https://www.vivaolinux.com.br/artigo/Gerenciadores-de-pacotes-GNULinux
  Yum (yellow dog updater modified), também padrão nos sistemas Red Hat, sendo
o padrão atual (o RPM continua ativo, porém, cuidando das rotinas de baixo nível).
Também lida automaticamente com dependências
 Pacman (package manager), padrão no Arch Linux e seus derivados.
 Smart, um gerenciador de pacotes universal, que trabalha com pacotes deb, rpm,
etc.
 Alien, permite converter pacotes entre formatos diferentes. Deve ser usado com
cautela, pois nem todo pacote aceita esse tipo de conversão.

Através da GUI, as distribuições entregam diferentes gerenciadores de pacotes que

permitem navegar por possíveis programas que podem ser instalados e podemos navegar
neles, encontrar o aplicativo desejado e instalá-lo. No Lubuntu, por exemplo, temos o Discover
e o Gerenciador de Pacotes Muon – e podemos instalar outros, como o Synaptic.
De todos, vamos nos concentrar no apt, dado que estamos trabalhando numa
distribuição baseada em Debian. Usamos o apt para instalar aplicativos, removê-los, procura-
los, atualizá-los, resolver problemas com dependências, etc. Ele trabalha com o comando dpkg
para instalar e atualizar o sistema. Ele substituiu o apt-get, que ainda funciona, mas tinha
várias opções que não eram usadas pelos usuários. Para executar o apt precisamos ter
permissão de administrador, então, o sudo será necessário (por exemplo: sudo apt...). Dentre
os comandos, temos:
 Apt update: atualiza os repositórios de software. Ele traz informações sobre os
programas que estão instalados no computador com base no repositório da
distribuição, mostrando qual é o status dos programas, se precisam de atualização
ou não. É bom enfatizar que este comando não irá alterar a versão do programa
instalado, ele apenas vai mostrar a informação que há uma nova versão e
atualizará o banco de repositórios, para que você possa baixar essa nova versão
em outro momento. Ele pode trazer 3 resultados: hit (atingido) indica que não há
alteração no pacote, ign (ignorado) indica que o pacote será ignorado (porque o
pacote é muito novo ou porque houve um erro trivial na busca), e get (obtido),
indica que há nova versão do pacote.
 Apt list—upgradable: lista os pacotes que podem ser atualizados no sistema
 Apt list –installed: lista todos os pacotes instalados
 Apt upgrade: atualiza os pacotes instalados no sistema para uma nova versão
 Apt upgrade nome_do_pacote: atualiza um pacote especificado
 Apt dist-upgrade: atualiza a versão da distribuição
 Apt install nome_do_pacote: instala um pacote qualquer. Podemos listar vários
pacotes no mesmo apt install. Ele listará as dependências e o espaço ocupado no
disco depois da instalação. Se quiser prosseguir, basta pressionar a tecla indicada
no processo.
 Apt install nome_do_pacote=número_da_versão: instala um programa numa
versão especificada.
 Apt remove nome_do_pacote: remove o pacote do sistema, mas deixa seus
arquivos de configuração. Use este caso ache que ainda vai instalar o programa
novamente em algum momento.
 Apt purge nome_do_pacote: exclui o pacote e tudo que é relacionado a ele. Use
este caso tenha certeza que não irá mais usar o programa.
 Apt autoremove: remove pacotes que foram instalados automaticamente para
atender dependências e não são mais necessários. Quando um pacote é removido
estes que foram instalados automaticamente permanecem no sistema, mesmo
que sejam inúteis. É semelhante a limpeza de disco do Windows.
 Apt search nome_do_pacote: busca pacotes de acordo com o nome especificado
  Apt show nome_do_pacote: mostra informações sobre um pacote especificado,
como nome, dependências, tamanho do download, etc.
 Apt depends nome_do_pacote: mostra as dependências de um pacote
 Apt –fixbroken tenta corrigir pacotes quebrados
 Apt clean: limpa pacotes deb do cache do sistema. Seu uso não é muito
recomendado.

Wine
Mas e se quisermos executar programas do Windows dentro do Linux? Isso é possível?
Um programa quando compilado é moldado para ser executado dentro de uma
plataforma de sistema operacional. Dessa forma, inicialmente não é possível utilizar
naturalmente executáveis do Windows no Linux nem o contrário, porque cada executável usa
os recursos que o sistema entrega, e um programa compilado em Windows, por exemplo,
espera um conjunto de APIs e comportamentos do sistema para funcionar.
Para superar essa barreira surgiu o Wine, cujo nome é um acrônimo recursivo que
significa Wine Is Not an Emulator – Wine não é um emulador. Ele é uma camada de
compatibilidade para sistemas compatíveis com UNIX que permite implementar APIs do
Windows. Dessa forma, ele permite executar aplicações nativas do Windows dentro de um
sistema Linux. Note que ele não é um emulador que cria uma máquina virtual para executar
programas.
Uma API é um conjunto de pequenos programas e códigos que pode ser utilizado por
outros programas. Imagine a API como um garçom que dá acesso aos recursos do sistema
operacional. Você não precisa ir até a cozinha para fazer seu pedido ou ter acesso aos recursos
oferecidos por um restaurante, com a API é semelhante: o programa não precisa se preocupar
em implementar detalhes específicos para usar o sistema operacional, basta solicitar o que é
oferecido por uma API.
Dessa forma, o Wine atua fazendo essa implementação de APIs do Windows,
traduzindo as chamadas que um programa preparado para Windows faz para chamadas que o
Linux entenda. Isso permite que programas desenhados para Windows possam ser executados
no Linux e em outros sistemas também (Mac, Solaris, etc.).
Pense no Wine como algo que funciona em duas frentes: na primeira temos a API do
Windows, que é enxergada pelos programas, na segunda, temos as APIs padrão POSIX, Linux e
X11 (interface que suporta janelas no Linux). Toda vez que um executável em padrão Windows
é executado, as bibliotecas que o programa precisa para funcionar são conectadas com as
bibliotecas do Wine, permitindo o funcionamento do software. Claro que nem sempre o
desempenho é o ideal, mas ainda assim esta é uma solução que permite aos usuários
executarem, por exemplo, Office, Photoshop e jogos dentro do Linux.
Para instalar o Wine no Linux, siga os passos abaixo:
 Abra o terminal (Ctrl + Alt + T)
 Adicione o suporte a arquitetura i386:

sudo dpkg --add-architecture i386

 O Wine não faz parte do repositório oficial do Ubuntu. Dessa forma, precisamos
adicioná-lo. Para isso, primeiro, baixe e instale a chave do repositório, e depois
adicione o repositório:

wget -nc https://dl.winehq.org/wine-builds/Release.key

sudo apt-key add Release.key
sudo add-apt-repository 'deb https://dl.winehq.org/wine-builds/ubuntu/ focal main'
  Atualize o apt com o comando:

sudo apt update

 Use um dos comandos abaixo para instalar o Wine:

sudo apt-get install --install-recommends winehq-stable -y

sudo apt-get install wine-stable -y

 Para executar um programa, abra o gerenciador de arquivos, localize o programa,

clique com o botão direito sobre ele e escolha “Open with Wine” (“Abrir com o
Wine”), ou abra um terminal, vá até o diretório que possui o arquivo e digite wine
nome_do_programa. Se o programa for compilado para 64 bits, digite wine64
nome_do_programa.

Como o repositório de download pode mudar, é interessante consultar a página de

download na wiki do wine (disponível em https://wiki.winehq.org/Download) para ter sempre
os passos atualizados.
Para acessar a janela de configurações do Wine, digite na linha de comando winecfg. É
interessante mudar a versão dos aplicativos que o Wine deverá implementar para Windows
10:

Figura 9 - winecfg

O Wine cria um diretório chamado .Wine na pasta pessoal do usuário logado, onde ele
mantém os arquivos de configuração e uma emulação da estrutura de uma unidade C: no
Windows.
 Figura 10 - diretórios do Wine

Para instalar uma aplicação nativa do Windows, tenha ela na máquina ou faça o
download do arquivo. Nesse exemplo usaremos o notepad++. Com o arquivo em mãos, vá ao
diretório de download onde se localiza o instalador, clique com o botão direito, e escolha
“Abrir com” – “Outras aplicações”:

Figura 11 - abrindo um executável no Wine

Caso o Wine não apareça listado entre as opções, em “Comando personalizado”, digite
wine.

Figura 12 - abrindo o Wine na interface gráfica

 Ou, então, pelo terminal, navegue até o diretório onde está o arquivo executável e
digite wine seguido do nome do arquivo:

Figura 13 - abrindo o Wine pela linha de comando

Recomenda-se fortemente que o local de instalação do programa não seja alterado,

pois ao executar a instalação de um programa do Windows ele espera uma estrutura de
diretórios semelhante a esse sistema, e isso é emulado pelo Wine no diretório drive_c dentro
da pasta .wine na pasta pessoal do usuário.

Figura 14 - diretório de destino de instalação do programa - não mude!

Uma vez instalado, o Wine gera uma nova entrada no menu iniciar do sistema onde o
programa pode ser iniciado.

Figura 15 - programa do Windows instalado no Linux através do Wine

Interfaces Gráficas no Linux

Diferente do mundo Windows, onde temos a interface gráfica “presa” ao sistema, nos
sistemas Linux temos uma variedade de opções de GUI (Graphic User Interfaces), umas mais
voltadas para leveza, outras mais focadas nos efeitos visuais, sendo que podemos instalar a
interface de nossa preferência a qualquer momento. Estas GUIs podem também trabalhar com
mais de uma Área de Trabalho, e são originadas dos projetos de interface gráfica do MIT,
batizadas como sistema de janelas X. O terminal gráfico do Linux é atualmente suportado pelo
programa X.org, também conhecido como X Window System, XFree86 ou simplesmente X11.
Vamos destacar algumas interfaces gráficas 8bem utilizadas nos parágrafos seguintes.

KDE

8
Um breve comparativo de interfaces gráficas (feito em 2015) pode ser conferido em
https://www.youtube.com/watch?v=ooJDA8N8vQg
 Similar a interface do Windows, é indicada para os iniciantes no Linux. Atualmente está
na versão 5.20, e é uma das mais modernas e elegantes GUIs para Linux, possibilitando várias
customizações, inclusão de widgets, etc., sendo também uma das mais pesadas, então, sua
instalação é recomendada em sistemas com boa capacidade de memória ou placa de vídeo.
Demonstração: https://www.youtube.com/watch?v=4n2dthDSGkc

Figura 16 - Interface gráfica KDE

GNOME

Uma das mais tradicionais interfaces para Linux, foi criada em 1997 e as versões 2.x
fizeram muito sucesso em várias distribuições do Linux, incluindo Ubuntu e Debian. O GNOME
foi reprojetado e atualmente está na versão 3.38, ganhando ares mais modernos, e gerando
desconfiança em parte da comunidade de usuários. Muitas distribuições partiram para outras
opções de interface, já que o novo modelo vem pedindo cada vez mais recursos de hardware
para funcionar, o que não acontecia antes (por isso era uma interface bastante aceita, por sua
baixa requisição de hardware). Comparado ao KDE, possui capacidades limitadas de
customização. Demonstração: https://youtu.be/DZ_P5W9r2JY

Figura 17 - Interface gráfica GNOME

Cinnamon

Criada como uma alternativa ao GNOME e ao Unity do Ubuntu, esta interface foi
criada utilizando como base o código do GNOME 3, porém, adaptando-o para parecer mais
com o GNOME 2. O resultado é uma interface mais leve que as anteriores, com bons efeitos e
altamente customizável. Atualmente está na versão 4.6. Demonstração:
https://www.youtube.com/watch?v=PrY6bbIAK1A

Figura 18 - Interface gráfica Cinnamon

XFCE

Criada para rodar em computadores com poucos recursos, pode ser executada em
computadores com processador de pelo menos 500 MHz e cerca de 256 MB de RAM. Bastante
similar ao GNOME 2 e altamente customizável. Atualmente está na versão 4.16.
Demonstração: https://www.youtube.com/watch?v=tjY9KM2nmUs

Figura 19 - Interface gráfica XFCE

 Outros exemplos de GUIs: LXDE, MATE, Openbox e FluxBox.

Customização da GUI
Além da interface em si, existem diversas ferramentas que permitem a customização
da GUI no Linux. Programas como o Compiz permitem controlar efeitos nas janelas do sistema,
ou o Docker, que permitem a “emulação” de um menu semelhante ao MacOS. Outros sites,
como o gnome-look, kde store, box-look, etc., trazem arquivos que permitem a customização
total da interface. Normalmente os itens baixados devem ser colocados dentro da pasta
pessoal do usuário, em diretórios ocultos como .icons e .themes. Esses itens podem ser
manipulados pelo próprio gerenciador de interface do sistema ou aplicações como o Gnome
Tweaks. Todos os itens do sistema são customizáveis: dos ícones da barra de tarefas ao
terminal, dos ícones do mouse a interface das janelas.

Gerenciadores de Arquivos
Da mesma forma que existem diversas interfaces gráficas, também existem no Linux
diversos Gerenciadores de Arquivos9 (“equivalentes” ao Windows Explorer). É possível notar
que existe uma tendência de eles serem intuitivos, lembrando em momentos o navegador de
pastas do Windows ou do próprio Android. Alguns exemplos de gerenciadores podem ser
vistos abaixo.

Figura 20 - Gerenciador de Arquivos Dolphin

9
Para vídeos com detalhes e comparações entre os Gerenciadores de Arquivos, consulte os seguintes
links (em inglês): https://www.youtube.com/watch?v=T0GBBl8bZmc https://www.youtube.com/watch?
v=fQhihnb2PV0
 Figura 21 - Gerenciador de Arquivos Nautilus

Figura 22 - Gerenciador de Arquivos Konqueror

Outros exemplos de gerenciadores de arquivos: Thunar, Caja, PCMan, XFE.

É comum as distribuições que utilizam interface gráfica Gnome utilizarem o Nautilus,
enquanto que as distribuições que utilizam KDE vêm adotando o Dolphin como gerenciador.

Processo de Inicialização do Linux

O começo do processo de inicialização do Linux é semelhante ao que vimos
anteriormente. Antes do SO entrar em ação, temos:
 O computador acessa a CMOS, colocando a BIOS ou o UEFI em execução para
realizar o reconhecimento dos itens de hardware, como placa de vídeo e memória
RAM.
 Em seguida são feitos os testes de todos os componentes de hardware instalados
para verificar se estão funcionando corretamente.
  Terminado o teste, é iniciada a busca pela fonte que possui o sistema operacional,
o chamado bootstrap. Esta informação é cedida pelo Setup da máquina, que indica
a ordem de locais em que o sistema deve ser procurado.
 Identificado o local com o sistema, seja lendo a MBR na BIOS ou o Boot Manager
no UEFI, o bootloader é lido.

A mudança começa a partir daqui:

 O kernel é carregado na memória. Este programa pode ser localizado no caminho
/boot/vmlinuz. Ele é um arquivo compactado apontado pelo bootloader no passo
anterior, e é carregado em conjunto com o arquivo initrd, que cria um sistema de
arquivos temporário que dá tempo para o arquivo do kernel ser descompactado e
já executa algumas funções para auxiliar o carregamento do núcleo.
 Agora, o kernel testa a quantidade de memória disponível e localiza os dispositivos
instalados no computador.
 Na sequência, o primeiro processo do Linux em nível de usuário é carregado, o
INIT (abreviatura de initialization). Este programa possui um ID 1, e é o responsável
por iniciar todos os demais processos do sistema. O init fica no diretório /sbin.
 Estes outros processos são chamados de daemons principais, programas do
sistema que rodam em segundo plano (equivalente aos serviços do Windows). Eles
podem ser configurados por arquivos que estão no diretório /etc/init. A
identificação dos processos em execução pode ser vista no diretório /proc.

Figura 23 - Daemons sendo carregados pelo sistema

 Em seguida, o shell em forma de linha de comando é carregado através do
programa getty. A partir daqui, o sistema já está funcional e pode ser controlado
pelo usuário. Aqui, o nome de usuário e senha já podem ser solicitados para login.
 Depois, a interface gráfica é carregada (se houver uma). Para tanto, utiliza-se o
servidor gráfico X, que chama o ambiente gráfico desktop (que pode ser Gnome,
KDE, Unity, Cinnamon, etc.).
 Por fim, após o login os demais aplicativos são carregados.

Caso o kernel não consiga carregar o INIT, ele tenta carregar o shell no caminho
/bin/sh. Se isso também falhar, a inicialização do sistema é abortada.
Quando o INIT é carregado, o sistema finaliza o processo de inicialização ao executar
uma série de tarefas administrativas, como checagem dos sistemas de arquivos e limpeza do
diretório /tmp.
Níveis de Execução - Runlevels
O INIT cria no sistema vários níveis de execução (runlevels), onde cada nível possui o
seu próprio conjunto de processos a serem iniciados. Em outras palavras, o sistema possui um
nível de execução padrão, onde podemos definir os processos que são carregados com ele.
Isso permite controlar como o sistema deve se comportar na inicialização, em seu
funcionamento, e no momento do desligamento. Existem sete runlevels no Linux, sendo que:
 O nível 0 encerra o sistema;
 O nível 1 inicia o sistema em modo monousuário, sendo este um modo de
recuperação, e apenas a conta do superusuário está ativa, não sendo possível
acessar recursos de rede nem rodar programas gráficos. Aqui podemos alterar
configurações do sistema, alterar senhas dos usuários, etc.;
 Os níveis 2 a 5 iniciam o sistema em modo multiusuário, podendo ou não ter uma
interface gráfica associada. Em sistemas baseados no Debian, o runlevel mais
comum é o 2, em sistemas da família Red Hat, o mais comum é o 5;
 O nível 6 reinicia o sistema.

Vamos citar o exemplo de uma máquina Linux sendo desligada. Para que a máquina
seja desligada com segurança, todos os dados pendentes devem ser escritos em disco, todos
os serviços devem ser parados, o kernel deve instruir o hardware a interromper quaisquer
envios de instruções à CPU de forma ordenada e tudo deve ser escrito em log para que o
administrador tenha rastreabilidade do que está acontecendo durante estas etapas. Estas
tarefas são executadas no runlevel 0.
Para ver qual o runlevel é usado por padrão na distribuição, podemos verificar o
conteúdo do arquivo /etc/inittab (onde etc é o diretório e inittab é realmente o arquivo). A
linha que armazena o runlevel padrão possui o formato: id:x:initdefault, onde x é o runlevel
padrão.
Para ver qual nível de execução está sendo utilizado, digite no terminal o comando
runlevel. Uma possível resposta pode ser “N 5”, o que indica que o nível de execução não foi
alterado desde a inicialização (se tivesse sido, o número do runlevel apareceria) e que o
runlevel atual é o 5.
É possível desligar o sistema com o comando “sudo init 0”, ou reiniciá-lo com o
comando “sudo init 6” (o sudo faz com que o usuário tenha permissão de administrador para
executar o comando especificado – init. Se o usuário já for administrador, o termo “sudo” não
é necessário no comando).
Os scripts para configuração de cada runlevel podem ser verificados nos diretórios
/etc/rc*.d (onde * representa o número de identificação do runlevel). Cuidado ao manipular os
runlevels10, pois se a configuração for salva apontando para os níveis 0 ou 6, o sistema entrará
em looping e não será mais iniciado. Os arquivos iniciados com K indicam um processo que
deve ser encerrado, ao passo que os iniciados com S indicam processos que devem ser
iniciados.
Podemos usar o init para controlar o funcionamento de serviços do sistema. Por
exemplo, para reiniciar um serviço em sistemas Debian, na linha de comando, podemos usar
um comando parecido com este:

/etc/init.d/networking restart

Isso faria com que a placa de rede reiniciasse. Podemos usar, ao invés de restart, os
complementos start ou stop, que, respectivamente, iniciam ou param o serviço.
10
Mais detalhes sobre runlevels podem ser verificados em
http://www.agilitynetworks.com.br/blogdaagility/niveis-de-execucao-runlevels-no-linux/
Formatação, Badblocks e Journaling
Toda vez que formatamos um disco, estamos fazendo uma formatação lógica, e nela,
estabelecemos um sistema de arquivos para que os dados sejam gravados. Nas áreas de
dados, os blocos (nomenclatura do Linux. No Windows são chamados de clusters) são gerados
para receber as informações. O tamanho do bloco varia entre os sistemas de arquivos.
Obviamente, nenhum sistema de arquivos é imune a falhas, pois não consegue impedir
totalmente que sua estrutura de dados fique corrompida ou danificada após um desligamento
inesperado causado por falha de energia, travamento no sistema ou aplicação.
Estes desligamentos incorretos, reinicializações forçadas, esbarrões no HD, pancadas
no gabinete, etc., podem gerar os chamados badblocks no HD.
Um badblock é uma área danificada de um disco que não pode ser mais utilizada. Seu
dano é físico e, portanto, permanente. Quando há muitos badblocks no HD, a vida útil do disco
é drasticamente reduzida. Se alguma informação importante do sistema estava no local do
badblock, ela ficará corrompida, podendo até mesmo impedir o acesso ao SO.
Outra situação que pode ocorrer nos casos de desligamentos incorretos é o
corrompimento de arquivos: se algum dado estava sendo utilizado pelo SO no momento da
paralisação, as informações não serão salvas corretamente, e os arquivos abertos ficarão
incompletos, portanto, serão corrompidos. Isso também pode levar a um travamento do
sistema.
Para minimizar estes impactos sobre os arquivos e tentar garantir a consistência
destes, muitos dos sistemas de arquivos do GNU/Linux utilizam o Journaling11. Este recurso
consiste em uma área dedicada pelo sistema de arquivos para registros, armazenando todas as
ações que serão feitas nos arquivos, como gravação e/ou alteração nos dados, seja para os
arquivos ou seus metadados12, permitindo restaurar o filesystem caso ocorra um erro
inesperado.
Com isso, após um erro no sistema de arquivos, seja ele causado pelo sistema, por
aplicações ou por desligamentos incorretos, é possível localizar todas as operações que não
haviam sido completadas, restaurando a consistência do filesystem e permitindo que o SO
continue a ser executado. Basicamente, no momento da inicialização do sistema
operacional, se o sistema de arquivos não estava totalmente inoperante (sem nenhum dado
sendo escrito) quando houve o desligamento inesperado do computador (devido a uma
reinicialização forçada, por exemplo), é acionado este registro completo (journal) das
alterações feitas no sistema de arquivos antes do desligamento, garantindo a integridade do
sistema.
As ações feitas nos arquivos são armazenadas no journal antes da gravação no
filesystem propriamente dito. Enquanto as alterações não são salvas, os dados permanecem
no journal e, somente após a gravação, as operações registradas neste log são tidas como
concluídas e são, portanto, eliminadas. Se por acaso o computador sofrer uma falha de energia
elétrica, o SO verificará depois da normalização os registros do journal e executará aquilo que
não foi realizado. Em outras palavras, esta é uma maneira do sistema saber onde ele parou seu
trabalho. Ele é uma espécie de diário, e ocupa, normalmente, de 10 a 15% do espaço em disco.
Portanto, a ideia do journaling é manter a integridade do sistema de arquivos e ter
tolerância em caso de falhas.

11
O NTFS do Windows também possui Journaling. Ele fica na raiz do sistema, num arquivo chamado
$LogFile.
12
No Linux, os metadados são armazenados numa estrutura do sistema chamada inode. Todo arquivo
possui um inode único dentro da partição, com dados como data de criação, bloco de armazenamento
no disco, etc.
Sistemas de Arquivos no Linux
Existe uma série de sistemas de arquivos suportados pelo Linux. Cada um, é óbvio,
possui vantagens e desvantagens em relação aos outros. O primeiro filesystem utilizado pelo
Linux foi o minix-fs, vindo do Minix de Tanembaum, mas logo foi substituído por um sistema
projetado especificamente para o Linux, o Ext, sigla para Extended File System, desenvolvido
por Rémy Card em 1992. Suportava discos de 2 GB, arquivos com nomes de até 255 caracteres
e com o tempo o sistema ficava fragmentado e lento (mais até que o FAT do Windows). Foi
utilizado até 1999.
No início de 1993, foi disponibilizado o Ext2, projetado para suportar os HDs maiores
que estavam surgindo e corrigir as falhas de seu antecessor, e que o levaram a ser o filesystem
mais popular no Linux durante anos. Suporta arquivos de até 2 TB e discos de até 8 TB. Seu
maior defeito era que não possuía nenhum sistema de tolerância a falhas. Sempre que o
sistema era desligado incorretamente, era necessário executar o fsck (semelhante ao scandisk
do Windows, só que mais demorado).
O sistema Ext3, lançado em 2001, foi desenvolvido por Stephen Tweedie e, dentre
outras funções, teve o acréscimo da função journaling (trazendo, portanto, maior tolerância a
falhas), passou a poder indexar uma quantidade maior de diretórios e maiores tamanhos de
volume. Com clusters de 8 KB, é possível armazenar arquivos com até 2 TB e criar partições de
até 32 TB. O tamanho dos blocos (clusters) é quem determina o tamanho máximo que um
arquivo pode ter, e quanto maior o tamanho do bloco, maior o desperdício de espaço
(especialmente ao guardar arquivos pequenos), em contrapartida, além dos arquivos maiores,
permite um pequeno ganho de desempenho, pois menos processamento e atualizações na
estrutura do sistema de arquivos se fazem necessárias ao alterar dados gravados.
Em 2006 foi lançado o Ext4, com melhorias no journaling, suporte a arquivos de até 16
TB e partições de 1 EB (Exabyte), maior indexação de diretórios, checagem aprimorada de
arquivos e estrutura do filesystem, entre outros. É tido como o sistema de arquivos mais
eficiente do Linux, e sua utilização é recomendada atualmente.
Um tipo de sistema de arquivos a parte dos anteriores é a área de troca, ou SWAP (No
Windows é a memória virtual, armazenada no arquivo pagefile.sys), que serve para armazenar
temporariamente os dados contidos em páginas da memória RAM, quando ela começar a ficar
cheia (o tamanho padrão de uma página de memória RAM é de 4 KB). Em outras palavras, a
função da partição SWAP é abrir espaço na memória RAM para que um programa seja
executado ou para trocas de grandes volumes de dados dentro da memória, sendo
especialmente útil em computadores com pouca memória disponível, evitando o chamado
estado Starvation, quando o sistema congela por não conseguir executar um programa por
falta de memória. Mesmo com os hardwares atuais robustos, é recomendado ter uma partição
de pelo menos 2 GB para SWAP em sistemas 32 bits, e 4 GB em sistemas 64 bits.
Dentre outros tipos de sistemas de arquivos no mundo Linux, temos também:
 ReiserFS: já teve performance melhor que o ext3. Tinha uma sistemática de
otimização do espaço em disco. Não trabalha com blocos (clusters) como a maioria
dos filesystems, trabalha a nível de setor. O problema é que isso gera muito uso de
CPU para fazer os cálculos do sistema de arquivos. Não é mais usado porque o
criador for preso e o sistema foi descontinuado
 JFS (Journal FS): usado pelos mainframes IBM AIX, possui baixo uso de CPU e seu
uso é recomendado para bases de dados por lidar bem com altas atividades de
disco
 XFS: padrão da SGI/IRIX. Possui tamanho de bloco manipulável e consegue
endereçar arquivos de mais de 2 GB. É recomendado pela Red Hat Enterprise Linux
e é bastante empregado em supercomputadores e servidores.
  Btrfs: desenvolvido pela Oracle, trabalha com compactação nativa, ou seja, quando
o arquivo é criado ele já compacta e grava no disco, usa b-tree (árvore binária, que
ajuda na busca, reduzindo operações necessárias, melhorando a estrutura do
sistema). Possui o recurso COW – Copy on Write (quando criamos a cópia de um
arquivo ou usamos um recurso duplicado, ele não cria um mesmo arquivo com o
mesmo conteúdo, otimizando o espaço. Quando vai para a memória, mesmo
sendo enxergados dois arquivos, só 1 é mandado). Alguns apontam este como o
sistema de arquivos do futuro, tendo um bom desempenho especialmente em
unidades SSD.
 HFS/HFS+/APFS: padrões do mundo Apple. O APFS é o mais atual.
 UFS: “pai” dos sistemas de arquivos, utilizado em UNIX. Permite a divisão do bloco
em 2 endereços diferentes, o que possibilita dois arquivos no mesmo
bloco/cluster, otimizando uso de disco

A árvore de diretórios do Linux

A grosso modo, pode-se dizer que, no Linux, tudo é arquivo. Se há algo que não seja
um arquivo, então este algo é um processo. No GNU/Linux (como no UNIX), não há diferença
entre arquivo e diretório, uma vez que um diretório (pasta) é apenas um arquivo contendo
nomes de outros arquivos. Imagens, músicas, textos, programas, serviços e assim por diante
são todos arquivos. Dispositivos de entrada e saída, e geralmente, todos os dispositivos, são
considerados como arquivos.
A estrutura de diretórios do Linux apresenta um formato em árvore, em que o
diretório principal se chama root (representado pelo caractere /), porque corresponde à raiz
da árvore de diretórios (root = raiz), e tudo está associado a este diretório: arquivos, partições,
unidades de CD, dispositivos removíveis, etc. Além disso, somente o administrador do sistema
(chamado de superusuário ou root) pode manipular estes diretórios.
O conteúdo do diretório / numa instalação de Ubuntu pode ser visto na figura abaixo.
Esta organização é definida pelo FHS – (Filesystem Hierarchy Standard - Padrão de Hierarquia
do Sistema de Arquivos), um conjunto de regras que define como os diretórios em um sistema
Linux devem ser organizados. Este padrão está na versão 2.3, lançada em 2004. Dentro do
root, temos normalmente os diretórios listados a seguir:
 Figura 24 – Estrutura de diretórios do Linux

Subdiretório Descrição
/bin Sigla para binaries, é diretório onde estão os arquivos executáveis e comandos
essenciais para os usuários comuns do sistema. Contém os comandos
normalmente executados no shell (ex: ls, cd, mkdir, etc.).
/boot Diretório que possui os arquivos necessários para iniciar o sistema. Aqui fica a
imagem do kernel do Linux, a configuração do gerenciador de boot, a
configuração dos módulos de kernel que devem ser carregados na
inicialização, o initrd (que auxilia o carregamento do kernel), o system.map
(que possui um sumário de como o sistema deve organizar a memória).
/dev Sigla para devices, contém os arquivos 13 que o kernel usa para se comunicar
diretamente com os dispositivos de hardware e periféricos do sistema (HDs,
mouses). Podemos dizer que é uma espécie de Gerenciador de Dispositivos.
Note que são arquivos que servem como ponteiros para os dispositivos. Por
exemplo, podemos acessar as informações enviadas pelo mouse em
/dev/mouse, ou pela placa de som em /dev/dsp.
/etc Contém os arquivos de configuração do sistema. Por exemplo, o diretório
/etc/X11 contém dados de configuração da interface gráfica instalada no
sistema, o /etc/passwd possui os usuários. De certa forma, é como se fosse o
Registro do Windows.
/home Contém os diretórios dos usuários (equivalente ao C:\Users). Cada usuário
possui um diretório pessoal, onde pode guardar seus arquivos. A princípio,
cada usuário só pode modificar as informações dentro de seu próprio
diretório.
/lib Sigla para libraries, diretório onde estão localizadas as bibliotecas essenciais
do sistema (subprogramas ou códigos auxiliares), utilizadas pelos programas
em /bin, pelos módulos do kernel e pelos dispositivos em /dev. É equivalente
às DLLs e APIs encontrados no Windows. Por exemplo, os drivers do sistema
ficam localizados no diretório /lib/modules/versão_do_kernel/kernel/drivers, e
13
Lembre-se: tudo no Linux é tratado como arquivo (a maioria de texto): o driver é tratado em um
arquivo texto, um diretório é tratado em arquivo, um dispositivo é representado por arquivo com
propriedades especiais, um arquivo é um arquivo.
 são ativados ou desativados do kernel conforme os dispositivos são instalados
no computador, o que torna o núcleo do sistema mais enxuto, com execução
mais eficiente, e auxiliando nos mecanismos de detecção automática de
hardware. A versão do kernel pode ser verificada aqui. Bibliotecas de
aplicações do sistema normalmente são arquivos *.so.*, e módulos do kernel
*.ko
/mnt Diretório usado para montar14 discos rígidos
/media Diretório usado para montar e acessar o conteúdo de drives ópticos (CD-ROM
e DVD-ROM) e dispositivos removíveis (Pen Drives e cartões de memória).
/proc Possui informações sobre o kernel e os processos em execução do sistema.
Para tanto, o Linux cria uma espécie de sistema de arquivos virtual, que só
existe na RAM. Sempre que um processo é criado, um arquivo texto é criado
nesta pasta. Estes arquivos possuem tamanho 0, e estão somente na
memória. Estas informações são usadas por utilitários de detecção e
configuração do sistema, ou podem ser checadas manualmente. Por exemplo,
o comando “cat /proc/net/dev” mostra informações sobre interfaces de rede,
“cat /proc/cpuinfo” mostra informações sobre uso de CPU, e assim por diante.
/root Diretório pessoal do superusuário (a “home” dele).
/sbin Sigla para secure binaries, possui arquivos essenciais para administrar e
reparar o sistema. Estes executáveis só podem ser acessados pelo root.
/tmp Diretório para armazenamento de arquivos temporários.
/usr Sigla para Unix System Resources, este diretório é de longe o que possui mais
arquivos em uma distribuição Linux, e armazena os executáveis,
documentação e bibliotecas (arquivos de programação usados pelos
aplicativos) de todos os programas instalados. Subdiretórios importantes:
 /usr/bin: possui os binários (executáveis) de todos os programas
instalados para o usuário;
 /usr/lib: possui as bibliotecas usadas pelos programas;
 /usr/local: reservada para programas e scripts instalados
manualmente;
 /usr/sbin: reservada para executáveis que só podem ser usados pelo
root;
 /usr/src: usada para armazenar o código fonte de programas;
 /usr/share: dados partilhados entre os programas;
 /usr/share/doc: possui os verdadeiros manuais do sistema, acessados
pelo comando man.
/var Diretório onde são guardadas informações variáveis do sistema, como logs
15
de eventos (/var/log), utilização e travamento de periféricos para uso de um
único usuário (/var/lock), informações sobre processos em execução
(/var/run), arquivos na fila de impressão ou na fila para envio de e-mail
(/var/spool), etc.
/lost+found Armazena arquivos que foram perdidos em um desligamento incorreto do
sistema.

Este padrão, porém, não é fixo. As distribuições podem redefinir alguns diretórios ou
criar outros para determinadas funções do sistema.
14
a montagem de um disco cria uma pasta para receber a estrutura de diretórios e para que possamos
manipular os arquivos. A partir do momento que montamos a pasta em /mnt, tudo que for feito é
encaminhado pra /dev para se comunicar com o disco.
15
Log é um arquivo que armazena registros de eventos relevantes de um programa ou do próprio
sistema
Linha de Comando no Linux - Introdução
Muito embora tenhamos várias interfaces gráficas para manipular os sistemas Linux,
várias tarefas podem requerer o uso da CLI (Command Line Interface – Interface de Linha de
Comando).
Esta interface funciona através de comandos que indicam ao computador o que fazer.
Estes comandos são lidos por um interpretador de comandos, responsável por pegar essas
instruções, traduzi-las e enviar para o kernel. Um interpretador de comandos também é
conhecido como shell ou modo texto.
Entre os programas interpretadores de comandos podemos destacar o sh, o csh e o
bash (Bourne Again Shell), sendo este último o mais usado. Entre as interfaces de linha de
comando temos o Terminal, xterm, Kterm, entre outros.
A grande vantagem desse modo é a flexibilidade que é possível obter através dos
comandos, que trazem funcionalidades que muitas vezes não são exploradas pelos aplicativos
de interface gráfica. Além disso, não utilizando uma interface gráfica podemos liberar recursos
importantes para a execução de outras tarefas do sistema.
Observação: o Linux é um sistema case sensitive, ou seja, ele diferencia maiúsculas de
minúsculas, então, comando, CoMaNDo e COMANDO, por exemplo, são entendidos como
coisas diferentes dentro do sistema.
Para usar os comandos, no Ubuntu, utilizamos o Terminal. Ele pode ser acessado ao
clicar no botão Painel Inicial do Ubuntu, e digitando terminal. Outra forma de inicia-lo é
pressionando as telas Alt + F2, e digitando o comando gnome-terminal. Podemos ter até 7
seções diferentes no terminal, cada uma podendo ter um usuário diferente também. Para
alternar entre os diferentes modos do terminal, pressiona Ctrl + Alt + F1 (ou F2, F3... até F7).
Note que o F7 é a interface gráfica. Detalharemos o estudo da CLI mais adiante.
É importante estudar a linha de comando do Linux porque as interfaces gráficas
podem mudar a localização dos itens do sistema, enquanto que os comandos digitados na CLI
variam muito pouco (ou não variam) de distribuição para distribuição. Isso faz com que a CLI
seja uma espécie de “porto seguro”, pois não importa se você está usando o Ubuntu, o Fedora,
o Slackware ou outra distribuição, já que a estrutura de comandos é a mesma.
Muitas tarefas podem ser facilitadas com o uso do terminal, pois em vez de ficar
procurando um ícone em um menu qualquer para executar um programa, podemos
simplesmente digitar o nome do executável no terminal e ele entrará em execução. Por
exemplo, podemos abrir o terminal e digitar firefox www.google.com e o Ubuntu abrirá o
navegador, solicitando o carregamento da página informada.
Nota: Se abrirmos um programa pelo terminal, o prompt fica “preso”, e só é liberado
quando o programa que foi iniciado é fechado. Para abrir um programa pelo terminal e deixa-
lo liberado, basta colocar & no final. Por exemplo, gedit abre um editor de texto do Linux e
deixa o terminal preso enquanto o programa fica aberto. Para deixa-lo liberado, basta digitar
gedit & ao invés do comando anterior.
Quando entramos no terminal, temos como resultado algo semelhante à imagem
abaixo:

Figura 25 - O terminal no Linux

Esta linha que é impressa possui algumas informações importantes:

  A primeira informação mostra o nome do usuário atual;
 O @ é um termo utilizado para designar a palavra at (traduzindo, em);
 A próxima informação mostra o nome do computador que está sendo acessado.
No caso, yuri-VirtualBox, seguido de dois pontos. Note então que esta primeira
seção de informações significa algo como “usuário tal na máquina tal”;
 Em seguida, temos o caractere ~. Ele significa que o usuário está atualmente na
sua pasta pessoal, em sua home. No caso, então, o caminho atual é /home/yuri;
 Por fim, temos o caractere $. Ele indica que o usuário atual é um usuário comum
do sistema. Quando o root acessa o terminal, o símbolo dele é o #. Quando
acessamos o terminal como super usuário, a interface fica da seguinte forma:

Figura 26 - Terminal em modo root

Note que temos a mudança do usuário no início da linha, temos a descrição do

diretório atual em /home/yuri, e temos a mudança do símbolo, indicando que o usuário atual
possui permissões de administrador, e devemos ter cuidado com as ações que serão
realizadas.
Obs: lembre-se sempre que o Linux é case sensitive!
Dica – Colando com o terceiro botão do mouse: uma funcionalidade interessante
dentro do Linux é que o botão central do mouse permite copiar e colar entre aplicativos ou até
mesmo entre aplicativos gráficos e terminais abertos dentro da interface gráfica. Isso substitui
o Ctrl + C, Ctrl + V, com a vantagem do comando ser dado com um único clique do mouse.
Basta selecionar o trecho de texto, a imagem ou o que quiser copiar e clicar com o botão
central na janela onde quiser colar a seleção.
Ao utilizar o terminal, temos diversos atalhos que auxiliam na edição e correção do
código escrito. São eles:

Tecla Ação
Enter Confirma e executa o comando digitado
Backspace Apaga o caractere que esta atrás do cursor
Delete Apaga o caractere que está sob o cursor
Teclas direcionais  e  Movimenta o cursor ao longo da linha que está sendo editada
Ctrl + A Movimenta o cursor para o início da linha
Ctrl + E Movimenta o cursor para o fim da linha
Ctrl + W Apaga a palavra atrás do cursor
Ctrl + U Apaga toda a linha
Teclas direcionais ↑ e ↓ Recupera os comandos que haviam sido escritos anteriormente
Ctrl + L Apaga todo o conteúdo da tela usada
Ctrl +C Cancela o comando que estava sendo escrito. Também serve
para interromper comandos em execução, caso estes estejam
bloqueados.
Tab Completa automaticamente o comando ou nome do arquivo que
estava sendo escrito. Também mostra as possibilidades para
complementar um comando que está sendo escrito.
Ctrl +D Se for executado no início da linha, encerra a sessão atual do
interpretador de comandos e faz logout. Se for executado após
ter uma palavra parcialmente escrita, mostra uma lista com
 todas as possibilidades para completar o comando.
Ctrl +Z Congela o comando que estava em execução, mas não o
encerra, aguardando que o usuário mande continuar, com o
comando fg.
Ctrl +S Para a exibição de uma listagem
Ctrl +Q Continua as listagens (após Ctrl + S)

Muitos comandos possuem parâmetros, que são que opções (complementos) que
podemos agregar a um comando qualquer, para incrementar a funcionalidade e os resultados
trazidos por este.

Comandos para manipulação da CLI

Informação sobre comandos e obtenção de ajuda

Cada comando no sistema possui um manual, que mostra o que o comando

propriamente dito faz, seus parâmetros e exemplos de uso. Todos estes manuais possuem um
comando único, o man. Assim, se quisermos, por exemplo, ver o manual do comando sudo,
basta digitar man sudo. Utilize as setas do teclado para rolar a tela e, para sair do manual,
pressione a tecla “q”.
Devido à grande possibilidade de parâmetros e combinações que um único comando
possui, os manuais de muitos destes executáveis acabam sendo longos. Por isso, muitos
comandos possuem a opção --help, que exibe uma ajuda resumida, contendo apenas os
parâmetros mais usados. Por exemplo, poderíamos digitar ls --help.
No meio de tantos comandos existentes, temos também outros utilitários bem simples
que nos trazem informações sobre os comandos do sistema. São eles:
 whatis: Mostra uma curta descrição de comandos do sistema
 which: Exibe o caminho completo na hierarquia de diretórios para comandos do
sistema.
 whereis: Usado para localizar o binário, os arquivos fonte e os manuais dos
comandos do sistema.
 No primeiro exemplo acima, o comando whatis chmod pergunta para o sistema o que
significa o comando digitado (chmod). No segundo, o comando whereis mostra a localização
dos binários e dos arquivos de manual do comando ls. No terceiro exemplo, o comando which
mostra a localização do binário do programa Firefox.
O comando file analisa o conteúdo dos arquivos e nos informa, com boa possibilidade
de acerto, o tipo de informação contida no arquivo. Um exemplo desse comando pode ser
visto na imagem acima.

Listagem de arquivos e diretórios

Para apresentar uma lista dos arquivos e pastas existentes no diretório atual no
terminal, usamos o comando ls, que significa list statistics. Por exemplo, ao digitar este
comando na pasta home do usuário logado no sistema, temos algo parecido com a imagem
abaixo:

Note que o prompt está localizado na pasta home do usuário (caracterizada pelo “~”
em yuri@yuri-VirtualBox:~$).
Uma série de parâmetros pode ser associada ao ls. Para isso, basta colocar um – antes
do parâmetro a ser utilizado. Por exemplo:
 ls nome_do_diretório exibe os arquivos e pastas no local especificado em
nome_do_diretório, sem alterar a pasta em que o usuário está navegando.
  ls –l exibe os arquivos e diretórios em formato de lista longa.

As vezes, a listagem pode ser longa demais para caber na tela. Para verificar as
informações que porventura não foram exibidas, utilize as teclas Shift + PgUp e Shift + PgDn,
que fazem a rolagem da janela para cima ou para baixo.
Cada linha dessa listagem representa um arquivo ou diretório e contém a informação
organizada em várias colunas. Indo do fim para o começo, a última coluna apresenta os nomes
das pastas ou arquivos (como “Documentos” e “Downloads”). A penúltima contém a data em
que os dados foram criados ou modificados pela última vez (como em “Ago 25 20:22”). A
informação anterior mostra o tamanho dos arquivos e pastas em bytes (como o 4096).
A quarta coluna exibe o nome do grupo de usuários que o dono do arquivo pertence. A
terceira coluna mostra o nome do dono de cada arquivo/diretório. Como estamos na pasta
pessoal do usuário, é natural que grande parte dos arquivos pertençam a ele.
A segunda coluna mostra um número inteiro que representa o número de links
(atalhos) associados ao arquivo. No caso das pastas, este valor mostra a quantidade de
subdiretórios contidos em seu interior.
A primeira coluna mostra as permissões de cada arquivo ou pasta. Quando a primeira
letra apresenta um “-“ trata-se de um arquivo comum, quando a primeira letra é um “d” trata-
se de um diretório (as demais opções serão tratadas mais adiante). Ainda na primeira coluna,
temos nove caracteres que representam as permissões associadas aos arquivos. Estes dados
serão estudados em outro momento.

 ls –lh exibe os dados em formato “legível para humanos”. Por exemplo, em vez de
mostrar informações em bytes, mostra as notações em formatos de KB ou MB.
 Note que podemos combinar mais de um parâmetro nos comandos. Acima usamos
uma combinação dos parâmetros –l e –h, exibindo os dados em formato de lista longa e com
formatação em modo legível para humanos.

 ls –a mostra arquivos e diretórios ocultos. No Linux, todo arquivo que começa com
“.” –e um arquivo oculto16.

É comum termos vários arquivos e diretórios ocultos na pasta home do usuário, como
podemos observar na imagem acima em .profile, .gnome2, etc. Estes arquivos são usados para
guardar informações de configuração de programas do sistema e aplicativos do usuário.
Note também que temos o diretório (representado pela letra azul) “.” na listagem. Ele
representa o diretório atual onde estamos trabalhando. O diretório “..” representa o diretório
acima do atual, que contém o diretório de trabalho atual (“.”).
Estas são apenas algumas opções que o ls nos trás. Para mais detalhes, acesse o
manual.

16
Para ativar ou desativar a exibição de arquivos ocultos na interface gráfica, pressione Ctrl + H
 Note no comando acima o arquivo .bash_history. Ele tem o histórico 17 dos comandos
executados pelo usuário no terminal.

Manipulação de diretórios

Para facilitar os exemplos a seguir, faremos tudo dentro do diretório home do usuário.
Nota: evite criar arquivos e diretórios com acentos ou espaços em branco, pois isso
dificulta a manipulação destes no prompt e dificulta a indexação do sistema.
Para criar pastas, usamos o comando mkdir, que significa make directory. A imagem a
seguir tem um exemplo de criação de um diretório chamado exercicios e a listagem do
diretório home do usuário:

17
Este histórico também pode ser acessado através do comando history.
 Observe na imagem que o diretório exercicios já aparece na listagem. Contudo, o
nome correto do diretório seria Batata, e não exercicios. Por isso, vamos apagar o diretório e
recriá-lo. O comando para eliminar diretórios vazios é o rmdir, que significa remove directory.

O ls nestes exemplos serve apenas para verificarmos se os diretórios foram

corretamente criados e removidos.
Agora que o diretório Batata foi criado, vamos começar a trabalhar dentro dele. Para
acessar diferentes diretórios, usamos o comando chdir, ou o mais comum, cd, que significa
change directory.

Note que o prompt deixa de exibir somente o “~” e passa a exibir depois dos dois
pontos “~/Batata”, que indica que estamos no diretório Batata, dentro da pasta home do
usuário (neste caso, /home/yuri). Veja também que desta vez o ls retornou “total 0”, o que é
previsível, já que esta pasta ainda não tem nada. Se usarmos o comando ls –la, somente os
diretórios “.” e “..” serão exibidos, indicando o diretório atual e o diretório acima do atual.
A qualquer momento, podemos usar o comando clear para “limpar” a tela dos
comandos anteriores e seus resultados (na verdade, o que esse comando faz de fato é
movimentar a barra de rolagem do prompt para baixo, deixando o que foi executado antes
“escondido” acima da tela visível).
Para exibir na tela exatamente em qual diretório estamos, podemos usar o comando
pwd, que significa print working directory.
 Para nos movermos um diretório acima do atual, podemos usar o comando cd ..

Podemos acessar qualquer diretório a partir do comando cd, bastando colocar o

diretório desejado junto do comando. Por exemplo, se digitarmos cd /, acessamos a raiz do
sistema. Se digitarmos cd /usr/lib acessamos o diretório com as bibliotecas usadas no sistema.
Se digitarmos cd ~/Batata voltamos ao diretório que criamos anteriormente. Se digitarmos
apenas cd, o prompt acessa o diretório home do usuário atual.
Nota: se o diretório que quisermos acessar estiver dentro do diretório atual, basta
digitar seu nome. Se quisermos acessar outro local do sistema (por exemplo, se estivermos
em /home e quisermos ir para /etc), precisamos colocar a barra (/) antes do nome do
diretório. O mesmo vale para os demais comandos.

Se acessarmos o diretório /etc com o comando cd e tentarmos criar uma pasta nele,
obteremos uma mensagem de erro, já que somente usuários com permissão de administrador
podem modificar o /etc, que contém os arquivos de configuração do sistema.

No entanto, se utilizarmos o comando sudo antes do mkdir, daí obtemos a permissão

de administrador para criar o diretório. Para isso, basta informar a senha e o diretório será
criado. O comando ficaria sudo mkdir teste. Isto é útil quando precisamos lidar com a
instalação de arquivos de maneira avançada no sistema e também para lidar com arquivos de
configuração.
Manipulação de arquivos

Vamos, antes de mais nada, acessar o diretório de exemplo que estávamos

trabalhando anteriormente: cd ~/Batata.
Para criarmos arquivos, usamos o comando touch. Exemplo: touch novo_arquivo. Para
copiarmos arquivos, utilizamos o comando cp, que significa copy.

Precisamos sempre especificar o local de origem e o local de destino para a cópia do

arquivo. No destino, podemos alterar o nome dele já na cópia. Repare na imagem anterior:
usamos o comando cp para a cópia, depois especificamos o caminho e o arquivo de origem
(/etc/passwd e /etc/services) e em seguida especificamos o destino. Como nenhum local foi
determinado, o sistema copia no diretório atual em que o usuário está localizado
(/home/yuri/Batata). Note que no processo de cópia mudamos o nome dos arquivos. O
primeiro foi chamado de abcd em vez de passwd e o segundo foi chamado de xpto em vez de
services.
Também podemos usar o comando cp para copiar arquivos dentro do mesmo
diretório. Para isso, basta especificarmos nomes diferentes para os arquivos.

Para copiarmos um arquivo ou pasta de um diretório para outro mantendo o nome

original, basta usar o nome do diretório de destino. Sendo assim, poderíamos especificar a
cópia para a pasta atual usando o caminho completo (/home/yuri/Batata ou ~/Batata) ou,
como já estamos usando o diretório no prompt, podemos simplesmente usar o símbolo “.”:
 O comando cp mantém as permissões dos arquivos originais, porém, os arquivos
copiados deixam de pertencer ao dono original e passam a pertencer ao usuário que fez a
cópia.
Para mover ou alterar o nome de um arquivo ou pasta, usamos o comando mv, que
significa move.

No exemplo acima, a pasta original, cal, foi renomeada para se chamar calendário.

No exemplo acima temos, no primeiro comando, a movimentação do arquivo abcd

para o diretório acima. O comando seguinte faz a listagem do diretório superior (/home/yuri).
O terceiro comando move o arquivo abcd do diretório acima para o diretório atual do prompt
(~/Batata). Os dois últimos comandos ls fazem a listagem do diretório home do usuário e do
diretório Batata, mostrando que o arquivo foi movido de volta.
Para remover arquivos, usamos o comando rm, de remove.

Por definição, o comando rm só funciona com arquivos. Porém, podemos usar o

parâmetro –r, que significa recursive, para apagar árvores de diretórios, ou seja, o diretório e
todos os arquivos e subpastas que estiverem dentro dele. Devemos ter cuidado com este
comando, pois seus efeitos podem ser devastadores se executado em locais indevidos.
O rm também tem a opção –i, que pede a confirmação do usuário antes de apagar um
arquivo.
O comando cp também tem uma opção –r, que permite copiar um diretório e todos
seus subdiretórios escrevendo um único comando. O comando mv já é aplicado para
subpastas automaticamente, então, ele não necessita de uma opção destas.
O comando ls também tem uma opção –R para listar diretórios e o que estiver em cada
subdiretório. Uma alternativa é o comando tree, que apresenta essa mesma estrutura de
maneira mais fácil de entender.
O comando ln é semelhante ao cp, porém, em vez de copiar os arquivos, ele cria links,
atalhos para o arquivo ou pasta original. Todos os comandos que tentarem acessar o conteúdo
de um link são automaticamente redirecionados para o local que ele referencia.
Existem dois tipos de links no Linux:
 Links simbólicos: são os atalhos convencionais aos quais estamos acostumados.
Eles fazem referência a um arquivo ou diretório que está armazenado de fato em
outro local do sistema (ou até mesmo em outro computador). Quando lemos ou
editamos o link simbólico, estamos na verdade lendo ou editando o arquivo
original. Ao excluir este link, o arquivo original continua intacto. Ao excluir o
arquivo original, o link continua existindo, embora aponte para lugar nenhum. Um
link simbólico é um arquivo que possui seu próprio inode no sistema (isso pode ser
verificado com o comando ls -i nome_do_arquivo).
 Hardlinks: é um link com uma relação mais forte com o arquivo original, pois
compartilha o mesmo inode. Também possuem características específicas:
o Só podem referenciar arquivos, nunca diretórios
o Não podem referenciar arquivos em outros volumes ou partições
o Continuam funcionando mesmo que o arquivo original seja excluído
o Fazem referência ao inode do arquivo original, pois não referenciam
nomes de arquivos ou diretórios, mas sim, uma posição física da partição.
 No exemplo acima, temos a criação de um link18 simbólico para o arquivo /etc/services,
que chamamos de serv e ficou armazenado no diretório /home/yuri/Batata. Ao fazermos um ls
–l na pasta, perceba que temos uma nova descrição do arquivo no primeiro caractere. Em vez
de “-“ ou “d”, agora temos um “l”, que significa link. Note também que no final temos o nome
do arquivo (serv) e o arquivo original que ele referencia (/etc/services).
Um hardlink é criado sem o uso do parâmetro -s no comando ln, portanto, sua sintaxe
seria:

ln arquivo_original nome_do_novo_hardlink

É bastante útil para backup, por exemplo, pois basta replicar o arquivo criando
hardlinks. Caso o arquivo original ou o link seja atualizado, todos também serão, e caso o
original seja excluído, a cópia persiste funcionando, e isso também gera economia de espaço
em disco.

Coringas

Muitas vezes precisamos localizar informações que não sabemos exatamente o nome,
ou então precisamos manipular somente arquivos de determinado tipo. Para evitar ter de
repetir o mesmo comando várias vezes, podemos usar os chamados wildcards, ou coringas,
que são caracteres especiais utilizados junto aos comandos do sistema. A tabela a seguir
apresenta os coringas do sistema:

Caractere Significado
* Substitui qualquer sequência de 1 ou mais caracteres
? Substitui um único caractere indiferenciado
[] Substitui uma sequência de um ou mais caracteres pertencentes ao conjunto dos
colchetes.

Exemplo 1: obter a listagem de todos os arquivos no diretório /bin que começam com
a letra s:

Exemplo 2: obter a listagem de todos os arquivos com extensão .conf (arquivos de

configuração) do diretório /etc:

18
Para mais detalhes sobre links e seus tipos (simbólicos e hard links), consulte:
https://canaltech.com.br/linux/aprenda-a-usar-links-simbolicos-e-hardlinks-no-linux/
 Exemplo 3: listar todos os arquivos do diretório /etc que possuem pelo menos um x no
seu nome:

Exemplo 4: listar todos os arquivos do diretório /bin cujo segundo caractere do nome é
a letra a:

Exemplo 5: listar todos os arquivos do diretório /bin que possuam exatamente três
caracteres de comprimento:

Também podemos usar os coringas com outros comandos. Por exemplo, podemos
usar para mover ou copiar todos os arquivos de um diretório para outro:
 No exemplo acima, criamos uma pasta chamada subdir e, com o comando cp * subdir,
copiamos tudo que estava no diretório Batata para a nova pasta. O comando também vai
tentar copiar a pasta subdir para dentro de si própria, o que não é possível. No entanto, os
demais arquivos são copiados, como podemos ver na listagem feita em ls –l subdir.
Também podemos usar para remover arquivos:

O comando rmdir só funciona com diretórios vazios, portanto, o primeiro comando

retorna um erro. Então, podemos apagar todo o conteúdo da pasta com o comando rm
subdir /* e, em seguida, apagar a pasta criada com sucesso.

Utilitários simples

 clear: usado para “limpar a tela”

 echo: escreva uma mensagem de texto na tela ou em algum arquivo. Não tem
muita utilidade na CLI, mas é útil quando usado em scripts.

 sleep: pausa o sistema por x segundos. Exemplo: sleep 10 pausa a linha de

comando pelo tempo determinado. Assim como o echo, este comando é bastante
 utilizado em scripts. Como alternativa, temos o comando usleep, que faz a pausa
com um controle em microssegundos.
 date: mostra a data e hora atual
 cal: mostra o calendário do mês atual do sistema ou de um mês determinado no
comando.

 time: mede o tempo de execução de terminada tarefa. Exemplo: time sort

/etc/services na verdade executa dois comandos: o sort, que ordena algum
arquivo (neste caso, /etc/services) em ordem alfabética, e o time, que mostra no
final o tempo de execução da tarefa e o tempo real gasto pela CPU.

Verificação de usuários acessando o sistema

  id: mostra informações do usuário atual e os grupos que ele pertence.

No exemplo acima, vemos a saída do comando para um usuário comum e para o

usuário root. O comando exit encerra a sessão do root e volta para o usuário comum. Repare,
portanto, que não precisamos fazer logoff em um usuário para chamar o root para execução.

 who – mostra quem está logado no sistema

 w – mostra quem está logado no sistema e o que está fazendo
 whoami – mostra o nome do usuário atual
 last – mostra os últimos usuários que entraram no sistema e o tempo de duração
de sua sessão de login

Nota: tty (teletypewriter) é o terminal propriamente dito. Indica o usuário aberto no

terminal 7 neste caso, que é o que usa interface gráfica. O termo pts indica um
pseudoterminal, aberto por um programa intermediário, como o gnome-terminal ou o xterm.

Encerramento do sistema

 exit: termina uma sessão de trabalho de um usuário em uma aplicação. Ctrd + D ou

o comando logout tem o mesmo efeito.
 halt: desliga imediatamente o sistema. Pode ser necessário utilizar o sudo junto
deste comando. O comando sudo init 0 tem o mesmo efeito.
 reboot: reinicia o sistema. O comando sudo init 6 tem o mesmo efeito.
 shutdown: possui o mesmo efeito do halt, porém, permite temporizar o momento
que o sistema será desligado, exibe mensagens para os usuários logados sobre o
desligamento ou reinicialização do sistema.

Visualização de arquivos de texto

 Para visualizar o conteúdo de arquivos, temos inicialmente três programas: cat, more,
e uma variante deste segundo, o less, sendo que estes dois últimos são mais eficientes que o
cat, pois exibem os conteúdos com pausas no final de cada página, entregando o controle para
o usuário navegar pelo texto, enquanto o comando cat exibe todo o conteúdo do arquivo,
mesmo que ele não caiba todo na tela, e para ver o que não apareceu devemos utilizar as
combinações de teclas Shift + PgUp e Shift + PgDn.

Comando more:

Comando less:

Comando cat:
 O exemplo acima mostra os dados da CPU instalada no sistema, dados estes que ficam
no arquivo /proc/cpuinfo.
O comando head mostra apenas as primeiras n linhas de um arquivo. O comando tail
mostra apenas as n últimas linhas.
 No primeiro comando do exemplo acima, determinamos com o parâmetro –n a
exibição das últimas cinco linhas do arquivo /etc/services, que apresenta as portas de rede e
os protocolos associados no sistema. No segundo exemplo, são exibidas as primeiras 14 linhas
da listagem do diretório /usr/lib. Note que utilizamos um pipe (representado pelo caractere |)
neste exemplo, que “emenda” um comando no outro. Primeiro o sistema efetua o ls, depois
efetua o head e exibe o resultado na tela. Veremos mais sobre a utilização dos pipes mais
adiante.
Podemos usar também o comando tail –f /var/log/syslog, que mostra as últimas dez
linhas do arquivo de log do sistema e fica monitorando o referido arquivo verificando se
existem novas entradas. Sempre que um novo registro for adicionado, o tail exibe
automaticamente na tela.
Vale ressaltar que o trabalho com arquivos de arquivos de texto é algo útil, pois grande
parte dos arquivos de configuração no Linux é armazenada em arquivos deste tipo.

Tipos de usuários no Linux

No Linux, existem basicamente três tipos de usuários: o root, usuários comuns e
usuários de sistema.
O superusuário, também chamado de supervisor, administrador, su ou simplesmente
root, possui privilégios especiais e tem acesso a todos os dados do sistema, incluindo os que
pertencem aos demais usuários. O nome root vem do fato deste usuário ter privilégios para
controlar toda a árvore de diretórios do sistema.
Devido aos poderes deste usuário, não é recomendado utilizá-lo, muito menos deixa-lo
nas mãos de um usuário inexperiente, pois basta um pequeno equívoco neste login para
causar danos enormes ao sistema inteiro. Em vez disso, é aconselhável criar uma conta
normal, específica para uso cotidiano, que não pode, por exemplo, formatar o sistema nem
apagar diretórios importantes.
Os usuários de sistema não se conectam na máquina. São contas para propósitos
específicos do sistema e não possuem um dono em particular. Exemplos: nobody, usado para
mandar solicitações HTTP, e lp, que manipula solicitações de impressão.
Os usuários comuns são aqueles que podem se conectar ao sistema sem permissões
de administrador. Estes usuários possuem um diretório base dentro de /home (por exemplo,
/home/ze ou /home/joao), podem manipular este diretório e tem acesso restrito a outros
arquivos e pastas na máquina, não podendo executar funções a nível de sistema.
Como os usuários comuns têm acesso somente à sua pasta pessoal, e não podem
modificar os demais diretórios do sistema, se um malware for adquirido, este infectará
somente o usuário corrente, não afetando o resto da estrutura do sistema.

O Sudo

Por padrão, o superusuário é bloqueado no Ubuntu e em diversas outras distribuições

GNU/Linux. Isso significa que não podemos fazer login como root ou usar o comando “su” no
terminal para chamar este usuário administrador para execução. Ao invés disso, o instalador
do sistema configura o comando “sudo”, para possibilitar que o usuário comum possa executar
todos os comandos de administração.
Sudo é uma forma abreviada de dizer super user do, ou “faça como superusuário”. Na
interface gráfica, quando a senha do usuário for solicitada com o comando sudo, significa que
o sistema precisa de uma permissão de administrador para executar o que está sendo pedido.
Nesse caso, basta informar a sua senha, e o sistema executará a ação como sudo.
Para executar como sudo um programa que normalmente é executado como usuário
comum, como o gedit, na interface gráfica utilize o comando gksudo seguido do nome do
programa. Por exemplo, aperte Alt + F2 e digite gksudo gedit. A senha do usuário comum será
solicitada e o programa será aberto com privilégios administrativos. Na linha de comando,
basta digitar o comando sudo, por exemplo, sudo gedit. Isso é útil para abrirmos arquivos de
configuração do sistema para alterá-los de acordo com nossas necessidades.
O arquivo /etc/sudoers define quais usuários podem utilizar o comando sudo, em
quais computadores eles podem fazê-lo e quais comandos podem executar através dele. Ele
possui este nome pois cada usuário que possui permissão de sudo é chamado de sudoer.
Vantagens na utilização do sudo e deixar o root desabilitado:
 Menos configurações são necessárias na instalação do sistema;
 Menos senhas para o usuário ter de lembrar;
 A conta com poderes totais no sistema fica desabilitada, e a senha para utilização
do sudo será sempre requisitada quando alterações importantes no sistema
tiverem de ser feitas, o que pode ajudar o usuário a pensar antes de fazer alguma
coisa;
 O sudo adiciona um log de cada comando que é executado em /var/log/auth.log.
Isso pode ajudar a verificarmos algo que pode ter dado errado e é útil em casos de
auditoria;
  Os crackers que utilizam técnicas de força-bruta normalmente tentam invadir o
sistema usando o root primeiro. Como eles (inicialmente) não sabem os nomes dos
usuários da máquina, fica mais difícil tentar força-bruta nestes usuários.

Desvantagens na utilização do sudo:

 Alguns comandos ficam relativamente mais complexos com a utilização desta
opção, o que pode confundir usuários iniciantes;
 Muitos sistemas não têm suporte para o sudo, e só podem ser administrados com
as permissões de root

A conta de root do Ubuntu pode ser habilitada a qualquer momento, mas esta prática
não é recomendada. Também podemos usar o comando sudo su, que faz com que o usuário
trabalhe como root no sistema. Isto não habilita o super usuário, somente faz com que o
usuário comum trabalhe o tempo inteiro como se fosse o administrador.

Mais uma vez, lembre-se que como root temos acesso a todos os recursos do sistema,
e um simples comando equivocado pode danificar totalmente o SO.
Utilize o sudo na frente de todos os comandos caso esteja trabalhando em um
diretório ou em arquivos que não lhe pertencem, como arquivos do sistema.

Passwd, Shadow e Group

O arquivo que possui os dados dos usuários do sistema é o /etc/passwd:
 Cada linha deste arquivo é o registro de um usuário específico do sistema. Por
exemplo, vamos verificar os dados da última linha:
 yuri – nome do usuário no sistema. Deve ser único;
 x – a senha criptografada do usuário. A letra x indica que a senha está armazenada
no arquivo /etc/shadow.
 1000 – número de identificação do usuário. O SO usa este número para saber o
que o usuário pode acessar;
 1000 – a segunda ocorrência do número mostra a identificação do grupo do
usuário. Usado para ver o que este pode fazer no sistema;
 Yuri – informações GECOS (General Electric Comprehensive Operating System),
com dados sobre o usuário como nome, telefone, etc.;
 /home/yuri – diretório base do usuário. É aqui que ele pode armazenar arquivos
pessoais.
 /bin/bash – shell padrão do usuário. É o programa que aceitará e executará os
comandos inseridos por este.
No arquivo passwd, a senha é representada na segunda informação, com o caractere
“x”. Antigamente, as senhas dos usuários eram criptografadas e mostradas no próprio passwd,
sendo que este arquivo possui permissão de leitura para todos os usuários, o que tornava o
sistema vulnerável a ataques de diversos tipos, mesmo com o uso da criptografia. Por
exemplo, se alguém invadisse o sistema como um usuário comum, ele poderia copiar o arquivo
passwd e tentar inúmeras formas de cracking para desvendar as senhas – principalmente a do
root.
Atualmente, as senhas do sistema são armazenadas no arquivo /etc/shadow, que dá
permissões de leitura e escrita somente para o root. As senhas são armazenadas nesse arquivo
com a função crypt ou algum algoritmo de mão única, como MD5, SHA1, SHA2, $5$, $6$, etc.

Note no exemplo acima que o usuário comum não consegue acessar o conteúdo do
shadow, sendo necessária uma permissão de administrador para isso.
Neste arquivo, também temos as informações separadas por “:”, onde temos primeiro
o nome do usuário, em seguida a senha criptografada. Se a senha aparece como “!” ou “*”
significa que a conta foi bloqueada ou a senha ainda não foi definida. Também são exibidos
dados como a data 19da última alteração da senha, tempo mínimo para que a senha possa ser

19
Muitos dados sobre datas em sistemas Linux utilizam-se do padrão de datas UNIX Epoch (também
chamado de POSIX time), que conta as datas em segundos passados desde 1 de Janeiro de 1970.
Especula-se que devido a limitação dos bits para essa contagem de tempo, em 2038 podemos ter uma
nova espécie de “bug do milênio”, que afetaria o funcionamento de programas baseados neste tempo
Epoch.
alterada, tempo máximo com a mesma senha, aviso de expiração de senha, número de dias
após o vencimento da senha para que a conta seja desabilitada e o número de dias em que a
conta irá expirar. Nem todas as informações são obrigatórias.
O arquivo que possui os grupos que são cadastrados no sistema é o /etc/group, que
mostra o nome dos grupos, se eles têm ou não senhas associadas (o “x” indica que não), o
identificador do grupo e quais usuários do sistema estão associados ao referido grupo.

Comandos para manipulação da CLI - Continuação

Controle de Permissões

Como o sistema pode ter muitos usuários, o Linux implementa um sistema de

permissões, que permite definir regras de acesso ao conteúdo de cada arquivo ou pasta. Dessa
forma, a informação pode estar acessível para alguns usuários e escondida dos demais.
Para simplificar a gestão do sistema, os usuários podem ser colocados em grupos, e em
vez de definir as permissões para cada usuário, definimos uma regra geral para o grupo, e
todos aqueles que estão neste grupo passam a obedecer a nova permissão.
Para entendermos como funcionam as permissões no Linux, vamos fazer uma listagem
no nosso diretório home:

As permissões ficam localizadas na primeira coluna da listagem, a partir da segunda

letra, e são divididas em três blocos com três caracteres. Chamamos este conjunto de
permissões de modo. Dentro de um bloco, “r” significa permissão para leitura (read), “w”
significa permissão para escrita (write) e “x” significa permissão para execução (execute). No
caso dos diretórios, o “x” indica a possibilidade de acessar os arquivos contidos em seu
interior.
O primeiro bloco de três caracteres representa as permissões associadas ao próprio
dono do arquivo, sendo que eles podem alterar as permissões de seus arquivos sempre que
quiserem. O segundo bloco de três caracteres representa as permissões dos usuários que
pertencem ao mesmo grupo que o dono do arquivo. O terceiro bloco de três caracteres
representa as permissões de todos os usuários que não se encaixam em nenhuma das duas
categorias anteriores.
Na imagem da listagem anterior, o arquivo examples.desktop possui as seguintes
permissões: “-rw-r--r--". Para ficar mais simples de identificar, vamos separar essa seção da
seguinte forma: -(rw-)(r--)(r--). O primeiro “-“ indica que se trata de um arquivo normal. Em
seguida, temos uma sequência “rw-“ que significa que o usuário dono do arquivo tem
permissão de leitura e escrita, mas não tem permissão de execução no arquivo. Depois, temos
dois blocos com “r--", que mostram que os usuários do mesmo grupo que o usuário corrente e
os demais usuários têm permissão de leitura, mas não têm permissão de escrita ou de
execução. Perceba, então, que somente o dono do arquivo tem a permissão de modifica-lo e
excluí-lo. Agora imagine isso aplicado ao root: somente ele tem permissão de excluir o arquivo
do sistema, qualquer outro usuário não poderá fazê-lo.
O comando para definir e alterar permissões de arquivos e diretórios é o chmod, que
significa change mode.
Os usuários só podem modificar as permissões de seus próprios arquivos, com exceção
do root, que pode modificar as permissões de qualquer arquivo ou pasta do sistema.
O chmod classifica os usuários em três categorias:
 O usuário dono do arquivo é classificado como user, ou simplesmente u;
 Os usuários que pertencem ao mesmo grupo do dono entram na categoria group,
ou g;
 Os demais usuários entram na categoria others, ou o.
 Se quisermos nos referenciar a todas as categorias, temos a classificação all, ou a.

Vamos analisar agora as permissões de nosso diretório exemplo criado anteriormente,

chamado “Batata”. Note que a primeira saída do comando ls –l traz a letra “d”, indicando que
se trata de um diretório. As permissões dele indicam que:
 O dono pode ler (r), escrever (w) e executar (x). Como se trata de um diretório, o
executar nesse caso indica que o usuário dono do diretório pode acessar o
conteúdo dentro da pasta criada.
 O grupo do usuário dono tem as mesmas permissões.
 Os outros usuários podem ler (x) e executar (x) o diretório, mas não podem
escrever nele, ou seja, não podem incluir, alterar ou excluir coisas.

Vamos acessar nosso diretório de exemplo para manipular os arquivos que estão
dentro dele:

Para melhorar nossos exemplos, vamos copiar novamente a calculadora do sistema e

fazer algumas manipulações de permissões nos arquivos de nosso diretório:
 No primeiro comando acima, o arquivo xpto teve suas permissões alteradas, sendo
que para o usuário dono do arquivo e o grupo deste usuário foi acrescentada a permissão de
execução. Para confirmar as permissões podemos usar o comando ls –l. Note que para dar a
permissão especificamos quem a está recebendo e, com o sinal + nós acrescentamos a
permissão. As demais permissões ficam inalteradas.
No segundo exemplo, com o sinal – retiramos toda a permissão para o grupo outros
usuários no diretório acima do que estamos trabalhando, nesse caso, (home/yuri). Somente o
dono do diretório e os usuários do mesmo grupo ainda tem permissões.
No terceiro caso, especificamos permissões de leitura, escrita e gravação no diretório
atual (.) para o diretório atual de navegação (/home/yuri/Batata). Note que para definir a
permissão podemos usar o símbolo do igual (=). Para o grupo do usuário dono do diretório
especificamos permissões de leitura e execução e para o grupo outros removemos as
permissões de escrita e execução. Para este comando funcionar, não podem existir espaços
em branco entre os diferentes atributos.
Existe uma sintaxe alternativa para o comando chmod, que permite especificar todas
as permissões de uma única vez, usando números em base octal (de 0 a 7). A equivalência
entre números octais, binários e as permissões é demonstrada na tabela a seguir:

Octal Binário Permissões

0 000 ---
1 001 --x
2 010 -w-
3 011 -wx
4 100 r--
5 101 r-x
6 110 rw-
7 111 rwx

Repare que podemos representar um octal como um número binário de três casas
(pois 23 = 8). Essa quantidade de casas pode ser enxergada exatamente como as possibilidades
de permissões que podemos aplicar a um arquivo ou pasta. Se está em 0, a permissão é
negada, se é 1, a permissão é concedida. Analise a tabela acima reparando neste detalhe.
Assim, o comando chmod 740 é equivalente a chmod rwx r-- ---. Ambas sintaxes são
aceitas, embora as pessoas que estão familiarizadas com números binários e octais prefiram
este modo alternativo de atribuir permissões pois ele é mais compacto.
Além do comando chmod, temos mais dois comandos relacionados à permissões de
arquivos: o chown (change owner), que altera o nome do dono do arquivo ou diretório, e
chgrp (change group), que altera o grupo de cada arquivo. Lembre-se que usuários comuns só
podem mudar o dono de seus próprios arquivos.

No primeiro exemplo, com o auxílio do comando sudo, alteramos o dono do arquivo

cal, que passa do usuário atual para o root. Note que a ordem do comando é chown usuário
arquivo. Em seguida, alteramos o nome do grupo do arquivo xpto para bin, seguindo a ordem
chgrp grupo arquivo. Como o dono do arquivo não foi alterado, ele ainda pode modificar as
permissões.
Os comandos chmod, chown e chgrp possuem o parâmetro –R, que, se usado, aplica as
alterações recursivamente a todos os arquivos de uma determinada árvore de diretórios.

Gerenciamento de Usuários e Grupos

Também temos a possibilidade de controlar a criação de usuários (através do comando

adduser), apagar usuários (comando deluser), definir senhas (comando passwd), criar grupos
(addgroup), entre outras opções20.

20
Para mais informações a respeito de criação de usuários e controle de permissões via linha de
comando, leia: https://www.hardware.com.br/tutoriais/usuarios-grupos-permissoes/
Permissões avançadas: https://www.vivaolinux.com.br/artigo/Linux-Permissoes-de-acesso-especiais
 No exemplo acima, através do comando adduser é criado o usuário thanos no sistema.
Note que além do usuário também é criado um novo grupo (linha 3), que já recebe o novo
usuário (linha 4), o diretório home também é criado (linha 5), e as demais informações como a
senha e os dados GECOS são informados nas linhas seguintes. Podemos ver o novo usuário
criado ao visualizar o conteúdo do arquivo passwd buscando pelo nome dele através do
comando grep.
Para modificar dados de um usuário, usamos o comando usermod, que permite,
dentre outras coisas, mudar o diretório home (parâmetro -d), grupo (-g), comentário (-c), e
shell padrão (-s). Exemplo: usermod -g [nome_usuario] [nome_grupo]: insere o usuário no
grupo especificado.

O comando passwd serve para trocar a senha dos usuários. Se não especificarmos o
nome do usuário, alteraremos a senha do usuário atual.

Acima temos exemplos de uso do comando su (switch user), que serve para trocar o
usuário que está sendo usado na sessão do terminal. Note a diferença na identificação do
usuário ao efetuarmos as trocas.
 No exemplo acima vemos a utilidade do diretório /etc/skel, que é usado como um
modelo para criação dos novos usuários. Todos os arquivos e diretórios que estão nele são
copiados para a home de novos usuários. Note também o preenchimento das informações
GECOS na criação do usuário, que são exibidos ao visualizarmos o conteúdo do arquivo
passwd.
 Acima vemos exemplos de comandos para manipulação dos grupos dos usuários no
computador:
 groups: mostra em quais grupos um usuário está inserido.
 addgroup: cria um novo grupo.
 addgroup [nome_usuario] [nome_grupo]: insere o usuário no grupo especificado.
 gpasswd -d [nome_usuario] [nome_grupo]: remove o usuário do grupo
especificado
 groupmod: modifica um grupo existente.

Para gerenciar usuários também temos os seguintes comandos:

 groupdel: apaga um grupo
 usermod -l [novo_nome_login] [nome_atual_login]: renomeia o nome de login de
um usuário
 userdel nome_usuario: apaga um usuário do sistema. Sem parâmetros ele não
apaga seus dados do sistema. Se usado com o parâmetro -r apaga o usuário e
todos os dados dele do sistema (note a diferença entre os comandos ls no
diretório home na imagem acima).

Pesquisa de informação

O comando mais utilizado em Linux para localizar informações é o find. Ele permite
fazer buscas e localizar listas de arquivos ou diretórios correspondentes aos parâmetros
passados como argumento. Este comando é bastante versátil e possui várias opções. Na sua
forma de uso, basicamente nós dizemos ao comando “procure no diretório tal arquivos que
sejam condizentes com essa pesquisa”.
 No exemplo acima, o comando find foi usado para buscar um arquivo chamado
ghostscript dentro do diretório /usr. Tenha em mente que buscar dessa forma só trará
resultados se o sistema encontrar algo que tenha exatamente o nome digitado.

Neste segundo exemplo, usamos o find para encontrar todos os arquivos com nomes
iniciados por “a” e terminados em “s” dentro do diretório /usr/bin e respectivos subdiretórios.
Perceba que usando o coringa nesse caso não nos limitamos a um nome específico. Isso pode
ser bastante útil caso saibamos apenas parte do nome do arquivo. Por exemplo, se sabemos
que o arquivo tem em parte de seu nome a palavra “conta”, podemos fazer um filtro usando
*conta*.

Neste exemplo é feita uma lista de todos os arquivos contidos no diretório atual e em
seus subdiretórios.
É preciso lembrar também que o find é case sensitive, portanto, leve isso em
consideração ao fazer as buscas, ou use o parâmetro -i para que ele ignore as caixas. Veja o
exemplo:

Repare que na primeira busca só é exibido um resultado e na segunda, sendo usado o

parâmetro -i, são trazidos resultados ignorando maiúsculas ou minúsculas no nome. Vamos
para mais um exemplo:
 Aqui temos um diretório e um arquivo com o mesmo nome: financeiro. Quando
buscamos por esse termo temos como retorno ambos os objetos. Com o find é possível
especificar a busca para trazer somente arquivos no resultado (com o parâmetro -type f) ou
somente diretórios (com o parâmetro -type d). Com isso se quisermos, por exemplo, buscar
arquivos ocultos dentro do diretório pessoal, o comando seria: find ~ -type d -name “.*”.
Podemos usar outros critérios na busca de informações, como data de modificação
(parâmetro -ntime, -atime, -mtime), tamanho (parâmetro -size), permissões (parâmetro -
perm), grupo (parâmetro -group), dono (parâmetro -user), etc. Esses critérios podem ser
conjugados com os operadores and, or e not, expressões regulares, etc., criando lógicas
bastante complexas, mas que permitem buscas muito específicas no sistema. Também é
possível remover resultados na busca usando !. Por exemplo: find . -iname financeiro* ! -name
financeiro.txt
As buscas também podem ser feitas com o comando locate, com resultados
semelhantes ao find, porém retornados com maior velocidade. Contudo, tome cuidado: para
arquivos recém-criados ele não é eficiente. Para tanto, é preciso atualizar a base de dados dele
através do comando updatedb.
Muitas vezes, não queremos localizar algo no nome do arquivo, mas sim, o conteúdo
deste. Para estes casos, existe o comando grep, que procuram palavras ou sequências de
caracteres dentro de arquivos. Sua sintaxe básica é grep [opções] padrão [arquivo]. do
comando busca linhas que comecem com os caracteres #d.
As opções mais comuns usadas no grep são:
 -i: para a pesquisa não diferenciar maiúsculas e minúsculas
 -c: mostra o número de linhas que combinam com o resultado
 -n: mostra o número da linha onde o resultado foi encontrado
 -r: habilita a pesquisa recursiva a partir do diretório atual
 -v: exibe as linhas que não combinam com o padrão pesquisado.

Veja alguns exemplos:

 Nesse exemplo temos várias coisas acontecendo. Vamos por partes:
 O arquivo financeiro.txt é criado com o comando touch
 Em seguida várias palavras são enviadas para esse arquivo com o comando echo. A
opção -n serve para o echo não exibir as saídas na tela, e a opção -e serve para que
o comando não ignore as barras invertidas, indicando as quebras de linha com \n
 Depois, o conteúdo do arquivo é visualizado com cat
 Agora começam os filtros com grep. Nesse primeiro, buscamos a palavra casa no
arquivo. Note que como não há nenhuma opção inserida, a busca vai ser case
sensitive, logo, a palavra Casa será ignorada.
 Na segunda busca usamos o parâmetro -i, para ignorar o case sensitive. Aqui, tanto
casa quanto Casa são trazidos no resultado.
 Na terceira busca procuramos com o parâmetro -c quantas vezes a palavra casa
aparece no arquivo
 Na quarta busca combinamos os parâmetros -i e -c
 Na quinta busca, com o parâmetro -v queremos todos os resultados que não sejam
a palavra da expressão
 Na última busca, com o parâmetro -n queremos o número da linha que tem a
palavra Linux.

No exemplo acima, buscamos quais arquivos no diretório /usr/include possuem a

palavra Linux no seu interior. O resultado traz os locais onde a palavra chave foi encontrada e
uma transcrição da linha onde a palavra aparece.
O comando grep serve para realizar pesquisas bastante complexas, usando padrões de
pesquisa chamados expressões regulares 21(regular expressions, também chamadas de regex).
Estas expressões são fundamentais para o sistema, por isso, é importante aprender a usar os
padrões de pesquisa regulares, pois muitos comandos e aplicações as usam. Exemplos do

21
Mais detalhes sobre expressões regulares em https://medium.com/trainingcenter/entendendo-de-
uma-vez-por-todas-express%C3%B5es-regulares-parte-1-introdu%C3%A7%C3%A3o-dfe63e289dc3
Para testar suas próprias expressões: https://regexr.com/
comando grep com expressões regulares podem ser vistos na imagem a seguir (note que os
resultados da busca são destacados em vermelho):

No primeiro comando, a expressão “lib.*y” serve para encontrar qualquer sequência

de caracteres começados pelas letras lib e terminados pela letra y, não importando o que tem
no meio. A palavra library obedece a essa expressão.
No segundo comando, estamos procurando por palavras completas, por isso o uso dos
símbolos \< e \>. Neste caso, são buscadas palavras que comecem pelas palavras li e depois
tenham outros caracteres. Library, licence e linked obedecem a este padrão.
No terceiro comando, o caractere ^ significa o início de uma linha. Assim, a expressão
do comando busca linhas que comecem com os caracteres #d.
Dentre outras opções para buscas, temos também:
 whereis: para localizar arquivos de código fonte, binários e manuais
correspondentes a um comando. Exemplo: whereis -b cp
 type: ajuda a descobrir como comandos são executados no sistema, dando uma
breve explicação do que o comando faz e sua localização
 apropos: ferramenta para listar todas as entradas da pesquisa nas man pages do
termo pesquisado. Exemplos: apropos sudo, apropos editor – trará todos os
programas que tenham o termo “editor” em seu nome ou descrição de
funcionalidade.

Filtros e redirecionamento de entrada e saída

Qualquer comando ou programa que seja executado sempre está associado a três
arquivos virtuais de entrada/saída, chamados standard-input (entrada padrão), standard-
output (saída padrão) e standard-error (erro padrão, ou, saída padrão de erro).
 O standard-input é usado pelos programas para ler informações. O segundo, standard-
output, é usado pelos programas para enviar toda a informação que geram. Por fim, o
standard-error é usado para enviar as mensagens de erro.
Por norma, o standard-input está associado ao teclado do usuário, e os arquivos
standard-output e standard-error estão associados ao dispositivo /dev/tty, que na verdade é o
terminal que mostra as coisas na tela do usuário. Ou seja, a entrada normal de dados será feita
pelo teclado e a saída padrão e a saída de erros irão para a tela do usuário.
Por exemplo, quando executamos o comando ls –l, o programa ls limita-se a escrever a
listagem do diretório atual para o arquivo standard-output, e como este está redirecionado
para a tela, todo o texto que resulta do comando ls é mostrado no monitor. Porém, podemos
redirecionar qualquer um destes três arquivos virtuais para outros locais.

No exemplo acima, primeiro fizemos uma listagem em lista longa com o ls –l, apenas
para mostrar o que existe no diretório. Note que a saída foi toda gerada na tela, então, o
standard-output normal foi usado. O segundo comando realizado foi ls –l > listagem.txt. O
caractere > serviu para redirecionar o standard-output para um arquivo chamado listagem.txt.
Repare que logo após foi feita uma listagem com o comando ls –l e agora surgiu um arquivo
chamado listagem.txt. Quando usamos o comando cat para verificar o conteúdo deste arquivo,
vemos que este arquivo recebeu o conteúdo da saída do comando ls feito anteriormente.
Vamos analisar outro exemplo:
 Neste segundo exemplo, o caractere < mudou o standard-input para o comando cat,
deixando de ser o teclado e passando a ser o arquivo listagem.txt. A saída também foi
redirecionada com o caractere >, para o arquivo listagem2.txt, que é exibido no segundo
comando. O resultado do primeiro comando é, portanto, uma cópia exata. O exemplo a seguir
trabalha com os redirecionamentos usando echo:

No exemplo acima, o primeiro comando echo mostra uma mensagem usando o

standard-output, o monitor. No segundo, a saída é redirecionada para o arquivo teste.txt. No
terceiro, o caractere >> redireciona a saída para o final do arquivo informado. Agora, vamos
verificar o seguinte exemplo:

ls –l /usr/bin | more

Neste caso, usamos o caractere |, que se chama pipe, e estabelece um canal de

comunicação entre dois programas. No comando acima, o ls –l /usr/bin mostra o conteúdo do
diretório /usr/bin, que contém aproximadamente mil arquivos. O efeito do pipe consiste em
redirecionar a saída do comando ls para a entrada do comando more. Como resultado, temos
a listagem de diretório com pausas no fim de cada página.
Outro exemplo de uso dos pipes: sabemos que o arquivo /etc/passwd possui a lista de
todos os usuários criados no computador. Se quisermos ver o conteúdo desse arquivo, o
comando seria cat /etc/passwd. Agora, e se quisermos encontrar apenas um usuário? Tendo o
nome dele, é simples, pois basta usar um pipe com o cat e especificar no comando grep o
nome do usuário.

Em Linux, usamos os pipes com frequência, pois eles permitem juntar o efeito de
vários comandos simples em uma única tarefa complexa, sendo um utilitário bastante eficaz
para administradores de sistemas e desenvolvedores trabalharem. Alguns programas já foram
escritos pensando na utilização dos pipes. Vamos analisar o seguinte exemplo:

cat /etc/services | sort | uniq | more

 O primeiro commando, cat, lê o arquivo /etc/services e envia-o para a saída. Contudo,
a saída dele foi redirecionada usando um pipe para a entrada do comando sort, que lê uma
sequência de linhas de texto, ordena elas e envia para a saída.
Em vez de a saída ir para a tela, ela é novamente redirecionada com o pipe servindo
como entrada para o comando uniq, que filtra linhas de texto repetidas, só enviando para a
saída as linhas únicas no texto. Mais uma vez, a saída é redirecionada, e o que foi gerado até
aqui serve de entrada para o comando more, que vai exibir a saída de dados com pausas no
fim de cada página. Finalmente, o resultado é exibido no monitor.

Compactação e descompactação de arquivos

Compactação e descompactação de arquivos é uma tarefa que faz parte do cotidiano

de diversos usuários. Muitas vezes precisamos enviar diversos arquivos diferentes para uma
pessoa, e é muito mais simples fazer isso quando juntamos tudo num único arquivo. Também
é comum baixarmos arquivos compactados, e também é usual utilizar dessa técnica para
reduzir o consumo do espaço em disco. O objetivo dessa técnica, portanto, é essa união de
vários arquivos em um e facilitar o armazenamento e transferência.
Para isso usamos compactadores de arquivos. No Windows conhecemos o WinRAR,
WinZip, 7Zip, dentre outros. No Linux é bastante comum que as distribuições já venham com
um compactador nativo para lidar com arquivos com extensão tar.gz. ou tar.bz2
Quando encontramos arquivos desses tipos precisamos entender que duas operações
ocorreram: os arquivos foram empacotados, gerando o .tar, e em seguida foram compactados
no formato gzip ou bzip2.
O tar é interessante porque mantém as permissões e links diretos e simbólicos mesmo
após a compactação. Alguns parâmetros do comando tar são:
 v: modo verbose, dá detalhes em tela dos arquivos que estão sendo compactados
ou descompactados conforme o tar trabalha;
 c: serve para criar um novo arquivo
 x: serve para descompactar arquivos
 z: utiliza compactação gzip
 j: utiliza compactação bzip2
 f: serve para indicar que o destino é um arquivo e não com uma fita ou outros
dispositivos – isso porque tar significa tape archive, então ele naturalmente serve
para lidar com fitas, por isso precisamos especificar quando lidamos com arquivos.

Portanto, para compactar um arquivo, podemos fazer:

tar -cvzf arquivo.tar.gz [nomes_arquivos_ou_diretórios]

E para descompactar:

tar -xvzf arquivo.tar.gz

Na documentação do comando tar é dito que o parâmetro z só serve no modo de

criação, portanto, poderíamos deixar o comando acima como: tar -xvf arquivo.tar.gz e termos
o mesmo resultado.

Informações do sistema – hardware e processos

Vamos analisar agora utilitários que nos trazem informações sobre o sistema pela CLI:
 uname: mostra a versão do sistema. Se usarmos o parâmetro –a temos uma lista
mais vasta, com versão do sistema, tipo de hardware, etc

 free: mostra dados sobre o uso de memória. Pode ser combinado com vários
parâmetros para mudar a unidade de medida (-h para exibir em KB, MB, etc.), para
executar ininterruptamente a cada x segundos (com o parâmetro –s. Neste caso,
devemos pressionar Ctrl + C para finalizar a execução do comando).
 uptime: informa há quanto tempo o sistema está funcionando, sem reiniciar.
Muito útil em servidores, onde o uptime atinge vários meses ou anos.

 df (disk-free): mostra o espaço em disco do sistema usado por todas as partições

montadas, exibindo tamanho total, espaço usado, tamanho disponível, etc. Tem
um resultado com leitura mais fácil se usado com o parâmetro –h, que trás uma
saída em formato mais legível para humanos.
 du (disk-usage): determina o espaço em disco ocupado por um arquivo ou
diretório inteiro. Também pode ser usado com o parâmetro –h.

 lspci: mostra informações dos barramentos PCI do computador e dos dispositivos a

eles conectados;
 lsusb: mostra informações sobre os barramentos USB do computador e dos
dispositivos a eles conectados;
 lsdev: lista o hardware instalado no computador, especificando endereços de I/O
(Input e Output - Entrada e Saída) e outras informações.
  ps (process-statistics): lista todos os processos em execução, incluindo informações
acerca dos recursos ocupados por cada um deles.

A primeira coluna do comando os trás o ID do processo em execução, a segunda trás o

TTY (teletype) e representa o nome do terminal onde o usuário que iniciou o processo estava
trabalhando. A terceira coluna indica o tempo que a CPU já gastou para executar a tarefa. Note
que mesmo que um processo esteja em execução há muito tempo, isso não significa que ele
necessariamente tenha ocupado tempo de CPU: ele pode ter ficado esperando dados ou
entradas do usuário. A última coluna mostra o nome do programa que cada processo está
executando.
Por padrão, somente os processos iniciados pelo próprio usuário são exibidos. Para ver
todos os processos em execução no sistema, usamos a opção ax junto com o ps. A opção a
seleciona todos os processos de todos os usuários e a opção x seleciona os processos que
foram iniciados automaticamente pelo sistema e não estão associados a nenhum terminal nem
a nenhum usuário. Também poderíamos incluir a opção u, para trazer o nome do responsável
pelo processo.
 A coluna stat nessa exibição relata o estado em que cada processo está. Quando
aparece a letra R significa que o processo está em execução (running), se a letra S aparece
significa que o processo está esperando alguma ordem (sleeping), se a letra D (uninterruptible
sleep) aparece significa que uma operação de leitura ou escrita está em execução.
Também podemos usar a opção “l” com o comando ps, para mostrar dados dos
recursos ocupados pelos processos, como memória, prioridades, etc. Além do ps, também
temos o comando pstree, que mostra os processos em execução em formato de árvore.

 top: mostra estatísticas acerca do estado geral do sistema, além de uma lista dos
processos com maior atividade, como quantidade de processamento ou memória
em uso. Este utilitário possui uma série de comandos internos que permitem
matar processos, enviar sinais e mudar prioridades de execução. Para mais
detalhes, veja o manual. Também podemos usar o htop para essa tarefa.

o Primeira linha: tempo em que o sistema está ligado desde a última

inicialização, quantidade de usuários logada, load average – média de
processos esperando recursos do sistema
o Segunda linha: número de tarefas em execução
o Terceira linha: utilização média da CPU por usuário (us), sistema (sy),
processos com prioridade modificada nos comandos nice ou renice (ni),
CPU livre para uso (id), uso da CPU em operações de entrada e saída (wa),
uso da CPU para tratar interrupções de hardware (hi), uso da CPU para
tratar interrupções de software para o kernel (si), CPU esperada pelo
hospedeiro (st)
o Quarta e quinta linha: utilização da memória
o Sexta linha em diante: processos em execução
  kill: usado para enviar sinais para os processos e, principalmente, para encerrá-los
(mata-los).

No exemplo acima, o firefox é chamado para execução, com o ID 2391, como podemos
verificar também com o comando ps. Para encerrá-lo, usamos o comando kill 2391.
Alguns processos, contudo, podem ignorar o sinal recebido pelo terminal, ou seja, se
recusam a serem assassinados. Porém, existem dois sinais que nunca podem ser ignorados,
porque o sistema não permite: KILL e STOP.
O sinal STOP congela os processos, que ficam parados até que um sinal CONT seja
enviado a eles.
O sinal KILL garante que o processo é mesmo terminado. Dessa forma, quando o
processo se recusa a terminar com o kill normal, podemos fazer uma das alternativas da
imagem a seguir:

No exemplo acima, criamos dois processos: um para o Firefox (ID 2423) e um para o
editor de texto Gedit (2450). Na sequência, usamos as duas variações do comando para
encerrar os processos.
Um comando alternativo ao kill é o killall, que permite terminar muitos processos de
uma só vez. Por exemplo, se quiséssemos enviar sinais a todos os processos que estão
executando o programa vi, faríamos o seguinte: killall -9 vi. Note que neste comando não
precisamos saber o id do processo, apenas o nome do que queremos encerrar. Dessa forma,
ele acaba sendo bastante prático. Para saber o nome do processo, basta usar o ps.
Obs: também existe o xkill, que permite matar processos com o mouse.
Vale sempre ressaltar que o usuário só tem permissão para encerrar seus próprios
processos, enquanto que o root tem permissão para enviar sinais para todos os processos do
sistema.
Também podemos controlar a prioridade que cada processo tem com os comandos
nice e renice. O comando nice executa o programa com a prioridade desejada (por padrão,
+10), enquanto o renice altera a prioridade de um processo em execução. Quando um
programa é executado normalmente, sua prioridade é 0. Sintaxe e exemplos:

# nice -n (-20 a +19) nome_do_programa  # nice -n 1 firefox

# renice (-20 a +19) nome_do_processo  # renice -n 0 firefox

 dmesg (diagnostic message): mostra logs úteis do sistema. É interessante para

procurar por erros do sistema. Para filtrar, podemos usar o grep. Exemplos:
o dmesg | grep -i segfault
o dmesg | grep -i oom
o dmesg | grep -i Killed
o dmesg | grep -i error
o dmesg | grep -i ‘I/O Error’
o dmesg | tail
o dmesg | grep “Linux version”
o dmesg -T (mostra as mensagens com a data e hora em que ocorreram. T
vem de timestamp)
o dmesg –level=err (mostra mensagens com o nível de erro. No lugar de err
podemos usar warn, info e notice).
o dmesg | grep -i “Mouse” (mostra erros relacionados a um dispositivo
específico. Exemplo: Keyboard)

 iostat -x 1: sumário da utilização do disco. Valores muito altos em %util podem

mostrar uma lentidão no disco
 iotop: mostra qual processo está com maior utilização de disco no sistema

Comandos de rede

Existem diversos comandos para configuração de rede, verificação de conectividade e

solução de problemas de rede.
Para testar a conectividade de rede temos o comando ping. Como em nossos casos
não estamos trabalhando conectados a outras máquinas, podemos testar este comando
fazendo o ping para o endereço de loopback (placa de rede local).

O ping consiste no envio de vários pacotes ICMP para o destino, para verificar se ele
está ativo e respondendo. Diferente do Windows, que limita o comando ping a enviar quatro
pacotes por padrão, no Linux o comando ping envia pacotes ilimitados. Se não especificarmos
a quantidade de pacotes com o parâmetro –c, teremos de parar a execução do comando com
as teclas Ctrl + C.
Para mostrar o endereço IP das placas de rede do computador temos o comando
ifconfig e o comando ip addr show. O ifconfig é um dos mais conhecidos comandos Linux,
contudo, ele foi tornado obsoleto (embora ainda funcione), sendo substituído pela suíte de
comandos ip, tanto que em algumas distros o ifconfig nem funciona mais, sendo necessário
instalá-lo. Para fins de aprendizado, ainda que o ifconfig esteja entrando em obsolescência,
vamos analisar os dois comandos.

Note que aparecem duas interfaces. A primeira, lo, significa loopback, e não é uma
interface física, e sim lógica. Ela faz a comunicação em nível de rede com a própria placa do
computador, e recebe o endereço 127.0.0.1, servindo para verificar se a placa de rede está
funcionando. A segunda entrada da listagem é efetivamente a instalada no computador,
identificada como enp0s3 (enp significa ethernet network peripheral – periférico de rede
ethernet). O endereço da placa é mostrado na seção inet.
Para manipular a configuração da placa de rede, precisamos de permissões
administrativas. Dessa forma, os comandos devem ser precedidos de sudo. Para desabilitar ou
habilitar o funcionamento da placa de rede com o comando ifconfig, podemos fazer: ifconfig
[nome_da_placa] [up|down]. Veja na imagem:
 Note que ao desabilitar (com down), ao listar as interfaces ativas somente o loopback
é exibido. Quando reativamos a placa (com up), as duas interfaces são mostradas. Também é
possível ter o mesmo efeito usando o comando ifup para ativar e ifdown para desativar, caso
eles estejam instalados no sistema.
Com o comando ip, para desabilitar ou habilitar uma interface fazemos o seguinte:

ip link set [nome_da_interface] [up|down]

 Note que, diferente do ifconfig, a interface continua sendo listada quando digitamos ip
addr show, porém, note que na seção state é exibido se a placa está desativada (state DOWN)
ou ativada (state UP).
Para atribuir um endereço para uma placa, usando ifconfig, a sintaxe é:

sudo ifconfig [nome_da_interface] [endereço_IP]

Para também atribuir a máscara de rede:

sudo ifconfig [nome_da_interface] [endereço_IP] netmask [máscara]

Neste exemplo, atribuímos o endereço IP 192.168.0.1, depois atribuímos o mesmo

endereço usando uma máscara diferente (255.255.0.0), e por fim revertemos ao endereço
original. Através do comando ip, a sintaxe para atribuir um endereço para uma placa é a
seguinte:

sudo ip addr add [endereço/máscara] dev [nome_da_placa]

 Para adicionar um broadcast para o endereço podemos usar:

ip addr add brd [endereço] dev [interface]

ip addr add broadcast [endereço] dev [interface]
ip addr add [endereço/máscara] brd + dev [interface]

Para remover um endereço, a lógica é semelhante:

ip addr del [endereço] dev [interface]

Existem diversos comandos extras que podem ser explorados caso haja necessidade.
Por exemplo:
 ip n show ou ip neigh show: mostra entradas da tabela ARP
 ip r ou ip r list ou ip route list: mostra entradas de rotas

Para configurar automaticamente as propriedades de rede, as distribuições possuem

caminhos diferentes, e com o tempo novas formas podem ser adotadas. Por exemplo, durante
muito tempo o Ubuntu baseou sua configuração através do arquivo /etc/network/interfaces,
contudo, desde a versão 18.04 migrou para o netplan, e além dele existe a ferramenta nmtui.
Portanto, a forma de configurar a rede automaticamente via CLI ou usando os arquivos de
sistema pode mudar de acordo com a distro e a versão dela.

Figura 27 - exemplo do arquivo /etc/network/interfaces

Figura 28 - nmtui

O Netplan é um sistema de configuração de rede que usa arquivos com

extensão .yaml, um formato de codificação semelhante ao XML cujo nome significa YAML Ain’t
Markup Language (YAML não é uma linguagem de marcação), e serve justamente para
serializar dados em forma de uma lista que seja legível para humanos e entendível por
linguagens de alto nível e ferramentas de sistemas operacionais. Na configuração de rede, ele
serve como entrada para que o sistema possa fazer as alterações.
Os arquivos do netplan podem estar em 3 locais diferentes: /run/netplan, /etc/netplan
e /lib/netplan, sendo que as configurações que faremos serão armazenadas dentro do
segundo. Por padrão, no Ubuntu e suas variantes (Xubuntu, Lubuntu, etc), temos somente um
arquivo dentro em /etc/netplan, chamado 01-network-manager-all.yaml.

Como podemos ver na linha comentada, essa configuração tem o propósito de deixar
toda a configuração das placas de rede através do NetworkManager (um serviço de
configuração de rede bastante comum em desktops e notebooks - a outra possibilidade seria o
networkd, mais comum em ambientes de rede estáticos e servidores). Nesse arquivo vemos
que as diretivas são criadas dentro do nó principal, chamado network (rede). Nele, temos duas
chaves criadas: versão, que diz respeito a sintaxe yaml que deve ser usada, e o renderer
(renderizador), que diz respeito ao serviço que cuidará da configuração de rede (novamente,
NetworkManager ou networkd).
Podemos fazer nossa configuração criando um novo arquivo dentro de /etc/netplan.
Para isso, vamos criar um novo arquivo e alterá-lo usando o editor padrão do Lubuntu, o
featherpad:

Nesse arquivo precisamos criar a(s) regra(s) para a(s) interface(s) de rede. Podemos
fazer uma configuração como a do código abaixo:

# Configura um endereço estático para a interface enp0s3

network:
version: 2
renderer: NetworkManager
ethernets:
enp0s3:
dhcp4: false
addresses:
- 192.168.10.200/24
nameservers:
addresses:
- 8.8.8.8
gateway4: 192.168.10.1

É extremamente importante que os espaços sejam seguidos a risca em arquivos yaml,

caso contrário a configuração não funcionará. O nó principal desse arquivo é network (rede), e
nele definimos:
 novamente a versão da sintaxe yaml em version,
 o serviço que cuidará da configuração em renderer (NetworkManager)
 o tipo de dispositivo, que pode ser ethernets, wifis ou bridges
 o nome da interface que estamos configurando
 desativamos o dhcp com a chave dhcp4:false
 atribuímos de fato o endereço e a máscara na chave adresses
  definimos os endereços de servidores DNS na chave nameservers
 definimos o gateway padrão na chave gateway4. Lembrando: gateway padrão é o
endereço para onde o computador vai mandar toda a comunicação com
dispositivos que ele não conseguir alcançar.

Para testar a configuração, usamos o comando netplan try. Podemos confirmar ou não
a aplicação da nova configuração, e para verificar o resultado usamos o comando para verificar
o endereço das placas (que pode ser simplificado de ip addr show para ip a s).
Para reverter a configuração, basta retirar o arquivo de /etc/netplan e executar
novamente o comando netplan try.

Para lidar com rotas usamos o comando route, que também pode ser usado para
inserir novas rotas estáticas. Lembrando: rotas são configurações dos caminhos que o
computador tem para alcançar algum destino. Normalmente a configuração da rota incluirá a
rede de destino, a máscara e o gateway para onde os pacotes devem ser enviados. Rotas
possuem, dentre outras coisas, métricas que indicam o melhor caminho para o destino e a
interface que deve ser usada para alcançar o destino.

Para verificar quais portas estão abertas no host, ver tabelas de roteamento,
estatísticas de interface, etc., usamos o comando netstat, para exibir informações do host
temos o nmap, para forçar uso de dhcp temos o dhclient, traçar routas até um destino temos o
traceroute, enfim, há diversos comandos de rede que podem ser usados para lidar com um
sistema ou rede Linux.
Outros comandos de rede podem ser verificados em
https://www.linuxnaweb.com/comandos-de-rede-linux/
Comandos de formatação e montagem de partições

Como já sabemos, o Linux não trabalha com partições C:, D: e semelhantes. Dentro do
Linux encontramos referências a partições e discos como /dev/sda, /dev/sdb, etc., pois os
dispositivos são guardados como arquivos de armazenamento em bloco em /dev, e a partir
desse diretório temos as nomenclaturas que fazem referência aos diferentes hardwares. Por
exemplo: sda refere-se a solid disk A (um disco instalado via SATA. Se tivesse um segundo disco
ele seria o B, e assim por diante), hda refere-se a hard disk A (um HD instalado via
controladora IDE), e assim por diante.
Caso seja necessário instalar um novo disco rígido no computador, ou mesmo acessar
esse disco ou um pen drive, é importante ter conhecimento de alguns comandos para realizar
essa tarefa.
Lembre-se que um disco novo para receber arquivos precisa ser particionado e deve
ter um sistema de arquivos. Particionar é, como o nome sugere, dividir o disco em partes,
como se fosse uma pizza (só que com pedaços de tamanhos variados). Essas partições são
divisões lógicas no disco, e são cuidadas pelo gerenciador de boot da máquina (BIOS ou UEFI)
através de uma tabela de particionamento (MBR ou GPT, respectivamente), que determina a
“forma” que uma partição pode ter, ou seja, ela determina a quantidade de partições,
tamanho máximo, tipos, formas de acessá-las, etc.
Com o novo disco instalado, vamos descobrir qual a nomenclatura que ele recebeu.
Para isso, usamos o comando fdisk, que serve para manipular as partições de um disco. Para
listar os discos e partições que eles possuem, usamos o parâmetro -l. O comando fdisk precisa
ser executado como root, então, usaremos o sudo:

O primeiro disco instalado, que possui o sistema operacional e foi o alvo de todas os
exercícios que fizemos até aqui, é encontrado como /dev/sda, como previsto. O novo disco
instalado é exibido para nós como /dev/sdb. Note em “tipo de rótulo de disco” (se estivesse
em inglês apareceria “disklabel type”) que é exibido dos, indicando que o gerenciador de boot
em uso é BIOS. Para manipularmos as partições desse disco, digitamos: fdisk /dev/sdb.
 Para exibir as opções disponíveis para manipular o disco, digite m. Para listar o espaço
livre disponível, digite a opção F.

Para criarmos uma nova partição, digitamos n. Em seguida, p para criar uma partição
primária, 1 para indicar o número da partição (caso já tenha outras partições altere esse valor),
enter para selecionar o primeiro setor do disco (ele inicia automaticamente no setor 2048
porque os anteriores são reservados para controle do gerenciador de boot em uso). Depois
definimos o tamanho da partição: podemos definir o último bloco que será usado (lembrando
que cada bloco possui 512 bytes), ou podemos usar + e indicar o valor na unidade de bytes que
queremos, por exemplo, +20G. Para efetivar as alterações no disco, digite w.

Para criar uma partição estendida22, o processo é quase o mesmo: abra o fdisk, crie
uma nova partição com n, digite e para criar uma partição estendida, defina o número da
partição, selecione o primeiro setor e o último – note que podemos pressionar enter para a
ferramenta pegar o primeiro setor livre (sem partição) e enter novamente para ele pegar o
último setor livre, contudo, nesse caso não deixaremos mais espaço disponível para outras
partições primárias serem criadas -, e pressione w para salvar as alterações. Com o fdisk
podemos verificar o resultado:

22
Lembre-se que no particionamento GPT só existem partições primárias.
 Por fim, o processo de criação de partições lógicas: abra o fdisk no disco desejado,
pressione n para criar uma nova partição. Note que a ferramenta informa que todo o espaço
para partições primárias está em uso (pois criamos uma estendida que ocupou todo o espaço
livre), logo, a ferramenta de cara nos diz que criará uma partição lógica. Pressionamos enter
para ele usar o primeiro setor livre encontrado, determinamos o tamanho (no primeiro
exemplo é criada uma partição de 10GB e no segundo uma de 30GB) e pressionamos w para as
alterações serem salvas no disco. Com o fdisk podemos verificar o resultado:

Para verificar o resultado no fdisk, usamos a opção p para exibir as partições:

 Podemos, inclusive, verificar o resultado no gerenciador de partições da interface
gráfica:

Uma vez que as partições estão criadas, agora elas precisam ter um sistema de
arquivos para que possamos de fato acessá-las e armazenar dados nelas, e para que o próprio
SO consiga armazenar os metadados nos inodes para manter o controle do disco. Lembre que
como as partições estendidas são, na verdade, partições primárias especiais com a única
função de abrigar as lógicas, elas não podem receber um sistema de arquivos.
Para determinar um sistema de arquivos usamos o comando mkfs 23. É ele quem de
fato formata o disco, então, use-o com muito cuidado. A sintaxe básica do comando é:

mkfs -t [sistema_de_arquivos] [partição]

Por exemplo, podemos pegar a primeira partição do novo disco e definir um sistema
de arquivos EXT4 nela da seguinte forma:

Obviamente, várias opções a mais poderiam ser agregadas 24 a este comando, como
tamanho do inode, tamanho dos blocos (clusters), rótulo do volume, etc. Existe uma variação
do comando onde ao invés de usarmos o parâmetro -t para determinar o tipo do sistema de
arquivos, já especificamos direto no comando esta informação. Por exemplo: mkfs.ext4 seria o
equivalente do comando da imagem acima. Veja na imagem abaixo as possibilidades de
sistemas de arquivos que podem ser criados com o mkfs, lembrando que isso pode variar de
acordo com a distribuição usada:

23
Vale uma curiosidade aqui: usamos o comando mkfs, mas quem de fato é executado ao chamarmos
ele é o mke2fs
24
Os padrões usados na criação de uma partição estão no arquivo /etc/mke2fs.conf
 Então, podemos usar o mkfs nas partições lógicas restantes com diferentes sistemas
de arquivos. No exemplo abaixo, são usados os sistemas btrfs e NTFS em sdb5 e sdb6,
respectivamente:

Partições formatadas, agora passamos para a etapa do acesso. Diferente do Windows,

que normalmente torna as partições acessíveis automaticamente, no Linux precisamos
“avisar” o sistema quais partições devem ser acessíveis. Esse processo de tornar uma partição
acessível é chamado de montagem, e vale também para dispositivos removíveis. Basicamente,
a montagem consiste em ter um diretório criado que possa receber a estrutura com todos os
outros diretórios e arquivos da partição em questão. Esse processo pode ser feito de forma
automática, na inicialização do sistema, ou manualmente.
Para montar uma partição de forma automática precisamos alterar o arquivo
/etc/fstab. Como ele é um arquivo importante no sistema, antes de alterá-lo vamos fazer uma
cópia:

Nesse exemplo vamos inserir a partição EXT4 /dev/sdb1 que criamos anteriormente
nesse arquivo, para que ela possa ser montada automaticamente. Para isso precisamos obter o
UUID (Universally Unique IDentifier – Identificador Único Universal) da partição, e fazemos isso
usando o comando blkid:
 Copie o valor da seção UUID e abra o arquivo /etc/fstab usando o editor de sua
preferência. Nele, insira os dados de forma semelhante a imagem abaixo, salve, feche o
arquivo e reinicie o computador:

As informações inseridas dizem respeito a:

 file system: onde colocamos o UUID. Refere-se ao dispositivo, partição ou diretório
de rede a ser montado
 mount point: é o ponto de montagem, ou seja, o diretório que deverá receber os
arquivos e diretórios do dispositivo/partição/diretório montado
 type: é o sistema de arquivos usado pelo dispositivo que será montado
 options: refere-se as opções de montagem da partição
 dump: referente ao backup do sistema de arquivos (0 – desativado, 1 – ativado)
 pass: referente a verificação de erros do dispositivo no boot do sistema (0 – sem
verificação, 1 – verificação da partição raiz, 2 – verificação em outras partições)

Podemos verificar a nova partição montada usando o comando df -h:

E pronto, a partição pode ser usada normalmente para criar arquivos, navegar, etc. O
processo de montagem manual usa o comando mount. Para isso, antes vamos criar com mkdir
mais dois diretórios em /mnt para abrigar as partições criadas anteriormente. Em seguida,
fazemos a montagem. A sintaxe básica do comando é:

mount [opções] [dispositivo] [ponto_de_montagem]

Para saber exatamente o nome do dispositivo, lembre-se que podemos usar fdisk.
Dentre as diversas opções do mount, podemos definir, por exemplo, montagem somente
leitura, remontar uma partição já montada (remount), etc. Então, para montar as partições
lógicas criadas anteriormente:
 Para desmontar uma partição, usamos o comando umount. Com ele, podemos
desmontar tanto o dispositivo em /dev ou no ponto de montagem. Veja nos exemplos:

Solução de problemas

Quando pensamos em solução de problemas no Linux podemos pensar em diferentes

comandos que podem ajudar na tarefa. Alguns deles já foram trabalhados anteriormente,
como o top, ps, kill, dmesg, entre outros, já servem para termos uma boa noção do controle de
processos e visualização de mensagens de erro do sistema. Também temos o journaling, por
padrão ativo, e bastante útil para manter a integridade do sistema de arquivos. Além desses,
também podemos citar:
 badblocks [dispositivo]: faz uma checagem manual de setores defeituosos no disco
rígido (é uma verificação física). Normalmente essa checagem e o isolamento de
tais setores já é feito automática pelo SMART (Self-Monitoring, Analysis and
Reporting Technology). Exemplo de uso: badblocks -sv /dev/sda
 fsck: busca erros no sistema de arquivos. Cada sistema de arquivos tem uma
ferramenta própria. No caso do sistema ext a ferramenta é o fsck. Exemplo de uso:
fsck -vy /dev/sda
 testdisk: tenta recuperar a tabela de partições, recuperar partições excluídas por
acidente e constrói uma nova tabela de partições. Exemplo de uso: testdisk
/dev/sda

Também existem ferramentas que permitem a realização de backups, criação de

estado de sistema e snapshots, como o Timeshift, Back In Time e Systemback. Nenhuma delas
é nativa, requerendo a instalação.
 Tão importante quanto saber solucionar é saber identificar a origem do problema. Algo
relacionado a conectividade pode ser investigado com comandos como ip addr, ping, route.
Problemas com processos podem ser tratados com kill, top, os, dentre outros. Problemas com
o disco podem ser cuidados com badblocks, fsck, testdisk. Dicas do que está acontecendo vão
aparecer no dmesg ou em /var/log/messages. Um problema de inicialização pode estar
relacionado ao init, ao GRUB, ao fstab... existem diversas possíveis origens para problemas.
Identificá-las é o passo essencial para isolar as possíveis ferramentas para tratar os erros.