Certificacao Linux Essentials PDF

Certificação Linux
Essentials
Copyright © 2019 by Uirá Ribeiro
Todos os Direitos Reservados
Certificação Linux Essentials
Guia Para o Exame 010-160 – Versão Revisada e Atualizada
Uirá Ribeiro
ISBN 978-65-990965-1-8
Esta có pia deste Livro está licenciada exclusivamente para:
Fabricio Soares Bicca

00445518006
fabricio.soares@cieers.org.br
5132847132
Este livro e todo seu conteúdo é protegido pela Lei de Direitos Autorais - LEI Nº 9.610,
de 19 de Fevereiro de 1998. Este livro e suas partes não poderão ser reproduzidos /
distribuídos / copiados / cedidos / vendidos / emprestados sem a autorização pré via e
por escrito do autor, sob pena da adoção das medidas cabı́veis na esfera cı́vel e penal.
Os conceitos emitidos neste livro sã o de inteira responsabilidade do Autor.
Apesar de toda a atenção, erros de digitação e/ou de impressã o nã o sã o descartados.
Em caso de alguma dú vida, entre em contato conosco pelo e-mail uribeiro@gmail.com
para que possamos ajudá -lo.
O Autor se exclui de quaisquer responsabilidades por eventuais perdas ou danos a

pessoas ou bens por uso deste livro.
Agradecimentos
O paradoxo dos agradecimentos é quase impossível de ser completo e aceitavelmente

breve.
No sagrado mistério da vida, cada coração possui no Infinito a alma gêmea da sua,
companheira divina para a viagem à gloriosa imortalidade. Agradeço à minha alma de
minhalma, Carla Cruz, por tecer-me a felicidade em sorrisos de esplendor.
Ao meu “pequeno” grande amigo, meu filho, Arthur. Que torna todos os momentos
mais doces e engraçados.
Aos meus pais, minha gratidão sempre.
Ao amigo Jon “Maddog” Hall, que tão gentilmente me honrou ao escrever o prefácio
deste livro.
Aos milhares de programadores e pessoas que dão o melhor de si ao desenvolverem

soluções OpenSource adequadas, tornando a vida em sociedade cada vez melhor.
Ao companheirismo e apoio das diversas pessoas que foram cruciais em diversas

ocasiões, a minha gratidão.
A Deus, pela força, pela saúde, pelo pão nosso de cada dia e pela fé.
Uirá Endy Ribeiro
Belo Horizonte, 29 de Março de 2020

Sobre o Autor
Se colocarmos todos os sistemas e linguagens em que prof. Uirá Ribeiro é fluente,

você terá a certeza de que ele é um Jedi. Vamos deixar você na dúvida dizendo
apenas que ele é Mestre em Sistemas distribuídos, especialista em telecomunicações,
redes de comutação de pacotes, Voz sobreIP, gateways de acesso remoto,
gatekeepers. A sopa de letrinhas você encontra nas buscas on-line.
Se buscar, vai descobrir também que Uirá une duas paixões em suas atividades: TI e
educação. A aventura que começou como diretor de TI de nove campi o levou a
assumir a Direção geral da Universidade Salgado de Oliveira em Belo Horizonte.
Achando que era pouco, o nosso autor continuou se dedicando ao site

www.certificacaolinux.com.br, com vários cursos OpenSource e preparatório para os
exames da LPI e CompTIA.
A Força permite que ele durma pouco, de forma que ainda consegue tempo para
alimentar o hábito de cozinhar e viver inventando soluções – a última foi uma câmera
de segurança criada com um computador de 8 dólares rodando Linux!
Enquanto restaura a paz na república, mantém seus penguins alimentados e

saudáveis desde 1998, e aprenderam a voar nas "núvens" já faz tempo.
Também é autor do livro “Sistemas Distribuídos: desenvolvendo aplicações de alta

performance no Linux”, “Metodologia Científica: teoria e prática”, “TCC – Trabalho de
Conclusão de Curso”, "Certificação Linux", "Certificação Linux para LPIC-101",
"Certificação Linux para LPIC-102" e “37 Hábitos dos Professores Altamente Eficazes”.
E assim, entre invenções, linguagens e delícias, o prof. Uirá divide com você o
conhecimento para o treinamento em Certificação Linux Essentials nessas páginas.
Prefácio
Saudações,
Se você está lendo estas palavras, é porque você, provavelmente, tomou várias
decisões.
Em primeiro lugar, você, provavelmente, conhece algo sobre o movimento de

Software Livre no Brasil, e sua importância para a economia de seu país. Você,
provavelmente, já percebeu que existe uma disponibilidade de código-fonte de
projetos como GNU e o Linux Kernel, através dos quais você pode adequar o sistema
operacional para melhor se enquadrar às suas necessidades ou às necessidades de
seu empregador.
Em segundo lugar, você pode estar usando Linux em seu PC em casa, ou talvez você
seja um administrador de um sistema como Solaris, AIX, HP/UX, ou algum outro
sistema de propriedade Unix e, logo, você começou a usar Linux no trabalho. Ou
ainda, você se sente pronto para trabalhar em uma empresa que trabalha com o
sistema Linux em tempo integral.
Em terceiro lugar, você pode ter olhado em um jornal e percebeu que alguns anúncios
de emprego já estão exigindo que o candidato tenha “Certificação de LPI”, e você
deseja saber o motivo de tal requisito. Afinal de contas, você já sabe como manter um
sistema de Linux!
Quando eu comecei em informática, trinta e cinco anos atrás, as coisas eram muito,
mas muito mais simples do que elas são hoje. Um programador só precisava saber
como perfurar cartões e como escrever na linguagem FORTRAN (ou COBOL). Não
havia Internet ou vírus, somente interfaces gráficas pobres, e a memória principal era
medida em kilobytes, nada de megabytes ou gigabytes. Na realidade, nem sequer
existia algum título oficial para o cargo que temos hoje de “administrador de
sistemas”, uma vez que cada sistema era executado por “operadores” que se
preocupavam com uma máquina específica, e não com a interatividade de várias
máquinas que trabalham em conjunto.
Hoje, nós temos que nos preocupar com segurança, tráfico de rede e tabelas de rotas,
subnets, e demais assuntos de rede. Temos que controlar migração de dados e de
programas de um sistema para o outro, e a interoperabilidade de várias redes e
protocolos. Nós temos que ser capazes de planejar o crescimento, além de resolver
problemas. É a partir dessas necessidades que se originaram as tarefas e o título de
“Administrador de Sistemas.”
Em reconhecimento ao crescimento fenomenal do sistema operacional GNU/ Linux, o

Linux Professional Institute, uma organização sem fins lucrativos sediada no Canadá,
estipulou uma série de qualificações que um administrador de sistemas Linux deve
possuir. Eles também criaram testes com o intuito de verificar se essas atribuições são
dominadas pelo administrador em questão.
Assim, se o administrador dominar uma média predefinida desses requisitos, então

ele, provavelmente, possui o conhecimento necessário para administrar sistemas de
GNU/Linux. Mantendo o espírito de Software Livre, o instituto publicou os objetivos dos
testes em seu site, de modo que diferentes métodos de estudo podem ser
desenvolvidos.
Este livro é um exemplo de um método de treinamento para lhe ajudar a alcançar este
nível de conhecimento.
O conhecimento de sistemas de GNU/Linux por si só não desenvolve um mestre em

administração de sistemas, mas, para o gerente que está contratando, ter alguém que
passou no teste LPI lhe dá a segurança de que o mesmo está contratando um
administrador com um desempenho adicional e medido através da certificação.
Claro que o contratante também pode conferir o potencial do candidato com seus ex-
empregadores ou professores. E por que também não verificar as realizações prévias
do empregado como listado em seu currículo? Mas o fato do candidato ter sido
aprovado nos exames de LPI assegura para o empregador que o candidato em
questão, com certeza, se trata de um BOM administrador de sistemas GNU/Linux.
Para aqueles que desejam estudar e desenvolver uma carreira em Administração de

Sistemas, por favor, sinta-se seguro ao utilizar os objetivos listados para cada um dos
exames LPI e os veja como um bom guia de estudo com as informações que você
deve saber. Pois eles foram desenvolvidos para administradores de sistemas e por
administradores de sistemas. Assim, mesmo que você não tenha a intenção de fazer
os exames de LPI formalmente, saiba que este material lhe tornará um melhor
administrador de sistemas.
Finalmente, dê as boas-vindas a este livro, pois se trata de um guia relativamente

barato para estudar e alcançar a sua meta de se tornar um administrador de sistemas
GNU/Linux certificado.
Não será o fim de sua aprendizagem, mas um BOM começo.
Meus cumprimentos,
Jon “Maddog” Hall
Diretor executivo Linux International

Como aproveitar este livro
ao máximo
Este livro possui uma série de exemplos de comandos. Convencionou-se que os
comandos que iniciam com "$" são aqueles que podem ser executados com um
usuário comum no Linux.
Já os comandos que iniciam com "#", são aqueles que precisam de permissões do
super-usuário root para serem executados. Portanto, se você for testar estes
comandos, você precisa estar logado como root, ou então usar o comando "sudo"
antes do comando indicado no exemplo.
Alguns comandos podem aceitar algum parâmetro ou opção como opcional. Quando
isso acontecer, o livro vai apresentar o parâmetro entre colchetes [ ] para indicar que
é opcional.
É possível que ao tentar rodar um determinado comando ou ver o conteúdo de um

determinado arquivo você depare com algum erro. Isto é porque nem todos os
comandos ou arquivos podem estar instalados como padrão na distribuição Linux que
você escolheu para estudos. Isto não significa que o livro está errado, ou que o
comando não existe, mas simplesmente que o comando ou arquivo em questão não
está instalado. Então você deve instalar o software usando o gerenciador de pacotes
adotado pela distribuição que você está utilizando.
Também é possível que haja pequenas variações nos caminhos dos arquivos indicados
no livro. Isto é um problema oriundo da distribuição que você escolheu que não seguiu
o padrão definido pelo Linux Standard Base (LBL).
Como a prova da LPI é neutra, ela segue naturalmente o padrão Linux Standard Base,
que é o indicado para as distribuições seguirem. Este livro usa as convenções
adotadas pela LPI e a Linux Stardard Base.
Para os amantes do Ubuntu, lamento dizer, mas o ele é muito bom em não seguir a
risca o Linux Standard e trocar as coisas de lugar.
Este livro também tem vídeos sobre os comandos exemplificados, para você ver o uso
do comando em questão em ação. Para ver os vídeos use seu celular com o aplicativo
da câmera ou aplicativo de ler QR-Code.
Certificação Linux Essentials
Sumário
Certificação Linux Essentials .......................................................................................... i

Agradecimentos .............................................................................................................. iii
Sobre o Autor .................................................................................................................. iv
Prefácio ............................................................................................................................. v
Como aproveitar este livro ao máximo ...................................................................... vii
Como se preparar para o exame ................................................................................... 1
Como Marcar a Prova? ............................................................................................. 3
Onde encontrar um Centro PearsonVue? .............................................................. 3
Como é o ambiente da prova? .............................................................................. 3
A Importância de Fazer Exercícios ........................................................................ 4
Aprendendo de Acordo com o Funcionamento do seu Cérebro ........................ 4
Físico ..................................................................................................................... 4
Linguístico / Sonoro .............................................................................................. 5
Visual .................................................................................................................... 6
Mapas Mentais .......................................................................................................... 6
Flashcards ................................................................................................................. 7
Você Precisa Fazer Simulados! .............................................................................. 8
Aulas dos Comandos ................................................................................................ 8
Um Linux para você na Web ................................................................................... 9
Desconto pra quem é da America Latina e Caribe ............................................ 10
.......................................................................................................................................... 11
Tópico 1: A comunidade Linux e a carreira Open Source ....................................... 12
1.1 A evolução do Linux e sistemas operacionais populares ................................. 13
Distribuições Linux ................................................................................................ 13
Sistemas Embarcados ............................................................................................ 15
Android .................................................................................................................... 15
Raspberry Pi ............................................................................................................ 15
Linux na Nuvem ...................................................................................................... 15
1.2 Principais Aplicações Open Source ...................................................................... 16
Aplicativos de Escritório ....................................................................................... 16
Navegadores Web .................................................................................................. 16
Multimídia ................................................................................................................ 17
Desenvolvimento de Software ............................................................................. 17
Linguagens de Programação ................................................................................ 17
Programas para Servidor ...................................................................................... 18
Servidores Web ................................................................................................... 19
Apache HTTP Server ........................................................................................... 19
NGINX ................................................................................................................. 19
Servidores de Banco de Dados ........................................................................... 19
Oracle Database ................................................................................................. 19
MySQL ................................................................................................................. 19
PostgreSQL ......................................................................................................... 19
MongoDB ............................................................................................................ 20
ix
Prof. Uirá Ribeiro
Servidores de E-Mail ........................................................................................... 20

NTP - Network Time Protocol .............................................................................. 20
DHCP - Dynamic Host Configuration Protocol ..................................................... 20
DNS - Resolução de Nomes ................................................................................ 21
Servidor de Arquivos ........................................................................................... 21
Servidores de Impressão .................................................................................... 21
Web Proxy e Cachê ............................................................................................. 21
Autenticação ....................................................................................................... 22
Keberos ............................................................................................................... 22
SAMBA ................................................................................................................ 22
LDAP ................................................................................................................... 22
VPN - Virtual Private Network ............................................................................. 22
Monitoramento ................................................................................................... 23
Logging ............................................................................................................... 23
Autoridade de Certificado ................................................................................... 23
SSH - Secure Shell .............................................................................................. 24
Clustering ........................................................................................................... 24
Balanceamento de Carga ................................................................................... 24
Conteineres ........................................................................................................ 24
Gerenciamento de Pacotes Debian ............................................................................ 24
dpkg ................................................................................................................................. 26
apt-get ............................................................................................................................ 28
Gerenciamento de Arquivos Red Hat e YUM ............................................................. 30
rpm .................................................................................................................................. 31
yum .................................................................................................................................. 36
Repositórios no Yum ........................................................................................... 37
dnf ................................................................................................................................... 42
1.3 Software open source e licenciamento ............................................................... 43
Copyleft .............................................................................................................. 45
Creative Commons ............................................................................................. 45
Modelos de Negócio OpenSource ....................................................................... 45
1.4 Conhecimentos de TIC e o trabalho com o Linux .............................................. 46
KDE ..................................................................................................................... 46
GNOME ............................................................................................................... 48
Xfce .................................................................................................................... 50
Cinnamon ........................................................................................................... 52
Linha de Comando .................................................................................................. 53
Usos do Linux na Indústria ................................................................................... 53
Virtualização como motor da inovação ............................................................... 54
Modelos de Computação em Nuvem .................................................................. 54
Infraestrutura como Serviço (IaaS) ..................................................................... 55
Plataforma como Serviço (PaaS) ......................................................................... 56
Software como Serviço (SaaS) ............................................................................ 56
Privacidade e Segurança na Internet ........................................................................ 56
Senhas ................................................................................................................ 57
.......................................................................................................................................... 57
x
Tópico 2: Encontrando seu caminho em um Sistema Linux ................................... 58

2.1 As bases da linha de comando ............................................................................. 59
A Linha de Comandos ......................................................................................... 59
Variáveis de Shell ............................................................................................... 61
Uso de Coringas .................................................................................................. 64
history ............................................................................................................................. 65
type ................................................................................................................................. 67
echo ................................................................................................................................. 67
2.2 Como obter ajuda na linha de comando ............................................................. 68
Help dos Comandos ............................................................................................ 68
Utilizando as Páginas Info ................................................................................... 69
Encontrando a Documentação em /usr/share/doc .............................................. 69
man .................................................................................................................................. 70
locate .............................................................................................................................. 72
Como Localizar Arquivos ..................................................................................... 72
find ................................................................................................................................... 72
2.3 Como usar diretórios e listar arquivos ................................................................ 74
/ .......................................................................................................................... 75
/bin .................................................................................................................... 75
/boot ................................................................................................................... 75
/dev ..................................................................................................................... 75
/etc ..................................................................................................................... 76
/home ................................................................................................................. 76
/lib ....................................................................................................................... 76
/mnt .................................................................................................................... 76
/media ................................................................................................................. 76
/proc ................................................................................................................... 76
/opt ..................................................................................................................... 77
/root .................................................................................................................... 77
/run ..................................................................................................................... 77
/sbin .................................................................................................................... 77
/tmp .................................................................................................................... 77
/usr ..................................................................................................................... 77
/var ..................................................................................................................... 78
Detalhes sobre os Arquivos e Diretórios ................................................................... 78
Arquivos e Diretórios Escondidos ........................................................................ 78
Diretório Corrente e Diretório Anterior ............................................................... 79
Diretório Home ................................................................................................... 81
ls ...................................................................................................................................... 82
pwd .................................................................................................................................. 83
2.4 Criar, mover e remover arquivos ......................................................................... 84
touch ............................................................................................................................... 84
cp ..................................................................................................................................... 86
mv .................................................................................................................................... 87
rm ..................................................................................................................................... 88
xi
Prof. Uirá Ribeiro
mkdir ............................................................................................................................... 88
rmdir ................................................................................................................................ 89
.......................................................................................................................................... 91
Tópico 3: O Poder da Linha de Comando ................................................................... 92
3.1 Como comprimir arquivos com a linha de comando ......................................... 93
gzip e gunzip .................................................................................................................. 93
bzip2 e bunzip2 ............................................................................................................. 93
xz e unxz ......................................................................................................................... 94
Arquivos tarball ............................................................................................................. 95
3.2 Como buscar e extrair dados de arquivos .......................................................... 98
cat .................................................................................................................................. 103
less ................................................................................................................................ 104
head ............................................................................................................................... 105
tail .................................................................................................................................. 105
sort ................................................................................................................................ 105
cut .................................................................................................................................. 107
wc ................................................................................................................................... 108
grep ............................................................................................................................... 109
3.3 Como transformar comandos em script ............................................................ 111
Escolhendo o Interpretador de Script #! shebang ................................................ 111
Permissões de Execução ............................................................................................ 113
Variáveis Especiais ..................................................................................................... 114
O Comando test ........................................................................................................... 116
Uso de [ ] no lugar do "test" ............................................................................ 117
Operadores || e && ........................................................................................... 118
if ..................................................................................................................................... 119
for .................................................................................................................................. 119
Editor de Textos vi/vim .............................................................................................. 121
........................................................................................................................................ 123
Tópico 4: O Sistema Operacional Linux ................................................................... 124
4.1 Escolhendo um Sistema Operacional ................................................................ 125
Como Escolher um Sistema Operacional .......................................................... 125
Microsoft Windows ............................................................................................ 125
MacOS ............................................................................................................... 126
Linux ................................................................................................................. 126
Ciclo de Vida .................................................................................................... 127
4.2 Noções básicas sobre o hardware do computador ......................................... 127
Fontes de Energia ............................................................................................. 127
Placas Mãe ........................................................................................................ 128
CPU ou Processadores ...................................................................................... 128
Gerência de Dispositivos .................................................................................. 128
Armazenamento ............................................................................................... 129
Informações de Hardware no Linux .................................................................. 130
xii
4.3 Onde os dados são armazenados ...................................................................... 131

O que é um processo? ...................................................................................... 131
ps ................................................................................................................................... 133
Usuário dono do processo (UID) ....................................................................... 136
Número de Processo - Process ID (PID) ............................................................. 136
Processo Pai (PPID) ........................................................................................... 136
% de CPU .......................................................................................................... 137
% de Memória ................................................................................................... 137
Hora de início (STIME) ....................................................................................... 137
Tempo de CPU (TIME) ....................................................................................... 137
Linha de comando (CMD) .................................................................................. 137
Terminal (TTY) .................................................................................................. 137
top ................................................................................................................................. 138
free ................................................................................................................................ 140
uptime ........................................................................................................................... 141
Serviços de LOG ........................................................................................................... 142
rsyslog .............................................................................................................. 143
A seguir uma tabela com os principais arquivos de LOG e seus propósitos que
podem estar configurados no sistema de Log. Cada distribuição pode ou
não fazer uso deles. ................................................................................... 143
Rodízio de Logs com Logrotate ................................................................................. 144
Journal do Systemd ..................................................................................................... 144
journalctl ........................................................................................................... 145
4.4 Seu computador na rede ..................................................................................... 146
Localhost .......................................................................................................... 147
Redes Privadas ................................................................................................. 147
Protocolos que Compõem o TCP/IP ................................................................... 147
Camada de Transporte ..................................................................................... 148
TCP - Transmission Control Protocol ................................................................. 148
UDP - User Datagram Protocol .......................................................................... 148
IP - Internet Protocol ......................................................................................... 148
ICMP - Internet Control Message Protocol, ........................................................ 149
Serviços e Portas TCP/IP ................................................................................... 149
Tabelas de Rotas .............................................................................................. 150
IPv6 ......................................................................................................................... 151
/etc/hostname ................................................................................................... 152
/etc/hosts .......................................................................................................... 152
/etc/resolv.conf ................................................................................................. 153
/etc/host.conf .................................................................................................... 153
/etc/nsswitch.conf ............................................................................................. 153
ip .................................................................................................................................... 154
ping e ping6 ................................................................................................................. 155
ss .................................................................................................................................... 156
Configurar o Cliente DNS ........................................................................................... 158
host ................................................................................................................................ 161
xiii
Prof. Uirá Ribeiro
route .............................................................................................................................. 162

netstat .......................................................................................................................... 163
........................................................................................................................................ 165
Tópico 5: Segurança e Permissões de Arquivos .................................................... 166
5.1 Segurança básica e identificação de tipos de usuário ................................... 167
/etc/passwd ....................................................................................................... 167
/etc/shadow ...................................................................................................... 168
/etc/group ......................................................................................................... 169
passwd .......................................................................................................................... 169
Identificando Qual Usuário Está Conectado ou Última Conexão ......................... 170
last .......................................................................................................................... 170
id ............................................................................................................................. 170
whoami ................................................................................................................... 171
who ................................................................................................................................ 171
w .................................................................................................................................... 172
Executando Programas com a Permissão de Outro Usuário ................................ 172
sudo ............................................................................................................................... 172
su ................................................................................................................................... 173
5.2 Criando usuários e grupos .................................................................................. 174
useradd ......................................................................................................................... 174
Diretório Padrão (skel) ............................................................................................... 176
userdel .......................................................................................................................... 176
groupadd ...................................................................................................................... 177
groupdel ....................................................................................................................... 177
5.3 Gerenciando Permissões de Arquivo e Propriedade ....................................... 178
Modificando as Permissões de Arquivos ................................................................. 183
chmod ............................................................................................................................ 183
Alterando o Dono dos Arquivos e Grupos ............................................................... 186
chown ............................................................................................................................ 186
chgrp ............................................................................................................................. 187
5.4 Diretórios e Arquivos Especiais .......................................................................... 188
Arquivos temporários ........................................................................................ 188
/tmp .................................................................................................................. 188
/var/tmp ............................................................................................................ 189
/run ................................................................................................................... 189
Links Simbólicos e Hard Links ................................................................................... 189
Links Simbólicos ............................................................................................... 189
Hard Links ou Links Físicos ............................................................................... 189
ln .................................................................................................................................... 190
Outros Livros do Autor ............................................................................................... 192
Índice Remissívo ................................................................................................... 197
xiv
Como se preparar para o

exame
Licenciado para: Fabricio Soares Bicca Proibido copiar/distribuir 1

- 00445518006
Prof. Uirá Ribeiro
Licenciado para: Fabricio Soares Bicca - 00445518006 - fabricio.soares@cieers.org.br
Às vezes, a vida vai te acertar um tijolo na cabeça.

Não perca a fé. Eu estou convencido de que a única coisa que me
fez seguir em frente era que eu amava o que fazia
-- Steve Jobs
Sempre existiu e vai existir uma lacuna no mercado de TI: os profissionais que saem
das faculdades nem sempre estão preparados para aquilo que o mercado quer e
precisa. Ainda mais no mercado de TI, onde a velocidade é muito grande e as
tecnologias mudam e se aprimoram a cada 6 meses.
Desta maneira, a indústria de TI, formada por grandes empresas, como IBM, HP, SuSe,
Microsoft, Cisco, Intel, RedHat, Apple, dentre outras, se reuniram através de
associações ou programas próprios de certificações para preencher essa lacuna no
mercado de profissionais capazes de trabalhar com eficácia nas suas plataformas,
equipamentos e tecnologias.
A Certificação, além de ser um grande incentivo, garante a entrada e sustentabilidade

dos técnicos no mercado de trabalho capazes de realizar tarefas no Linux. Desta
forma, a prova Linux Essentials foi desenvolvida para certificar a competência do
sistema de administração usando o sistema operacional Linux e suas ferramentas
associadas. O exame foi desenvolvido para ser neutro em termos de distribuição,
seguindo o Linux Standard Base entre outros padrões e convenções relevantes.
Se você está lendo esse livro, com certeza quer ter uma certificação de peso
reconhecida internacionalmente no seu currículo e no seu cartão de visitas. O
mercado de software livre está em crescimento e à procura de profissionais
certificados. E isso é ótimo para você, sua carreira e também seu bolso.
Este é um livro de Linux, objetivo, didático e focado nos temas da prova da LPI Linux
Essentials Exame 010-160, na última versão da prova. Você irá encontrar exatamente
aquilo que precisa estudar e na medida certa para o exame.
O exame é composto de 40 questões com mínimo de 500 pontos, sendo que o range é
de 200-800 pontos.
Para ser aprovado é necessário acertar pelo menos 26 questões. Mas é um pouco
mais complexo que isso, já que as questões envolvem pesos diferentes para cada
tópico e você não pode zerar um tópico
A maioria das questões são de múltipla escolha onde existe somente uma opção
correta. Algumas irão apresentar um cenário onde alguma medida administrativa
precisa ser tomada e em outras se pergunta qual o comando apropriado para uma
determinada tarefa.
A prova testará os conhecimentos do candidato em 5 tópicos:
2 Licenciado para: Fabricio Soares Bicca

00445518006
Tópico 1: A comunidade Linux e a carreira Open Source

Tópico 2: Encontrando seu caminho em um Sistema Linux
Tópico 3: O Poder da Linha de Comando
Tópico 4: O Sistema Operacional Linux
Tópico 5: Segurança e Permissões de Arquivos
Este exame irá testar seu conhecimento teórico e prático, comandos e suas opções
comuns, localização de arquivos importantes, sintaxe de configurações e
procedimentos mais usados, uma vez que você tenha conseguido solidificar os
conceitos básicos do sistema operacional e ferramentas associadas.
Os exames não tem a intenção de fazer perguntas de dupla interpretação e nem

maldosas, mas os tópicos abordados são mais complexos e exigem maior experiência
do candidato.
Este livro também é dividido em 5 capítulos, separados e ordenados conforme o Guia

Oficial do exame LPIC 010-160, e cobre todos os tópicos requeridos pelo exame.
A certificação LPI Essentials tem validade para toda a vida.
Como Marcar a Prova?
Existem duas formas de prestar os exames: por computador com agendamento, ou

através de exames de papel.
O exame é aplicado no computador, com hora e local definidos pelo candidato, é feito
em um centro Pearson Vue. Existem vários centros espalhados pelo país.
Os exampes em papel podem ser aplicados por empresas parceiras da LPI, também de
forma agendada. A LPI também promove festivais de certificação, especialmente nas
feiras e encontros de tecnologia.
Onde encontrar um Centro PearsonVue?

Escolha pelo site deles: http://www. pearsonvue.com. Selecione “TEST TAKERS”.
Depois Digite LPI no Box que irá aparecer. Então você poderá clicar no botão “Find a
Test Center” e digitar o nome da sua cidade.
Como é o ambiente da prova?

A prova feita pelo computador é simples. Este computador fica em uma pequena sala
fechada e isolada do som e distrações, como um biombo pequeno. Você não pode
levar nada. Deve deixar celular, agenda, papel, tudo guardado. Eles vão te dar papel,
lápis e um dicionário inglês-português se a prova for em inglês. Qualquer
movimentação estranha eles anulam seu teste. Você também será filmado por uma
webcam durante o exame para garantir que ele foi devidamente aplicado e nada
anormal ocorreu. Os exames aplicados pela PearsonVue foram reconhecidos
mundialmente por sua segurança e por serem à prova de fraudes.

- 00445518006
Prof. Uirá Ribeiro
Outro detalhe importante da prova em computador é que, se você errar alguma

questão de algum tópico, o computador seleciona mais questões do mesmo tópico
para testar ainda mais seus conhecimentos sobre o tema. Isto tem um lado bom e
outro ruim. O lado bom é que, se você tiver errado de “bobeira”, terá outra chance de
redimir seu erro. Mas se você de fato não estiver devidamente preparado para o tema,
estará lascado.
A Importância de Fazer Exercícios
O cérebro é um “músculo”. Quanto mais exercitado, mais forte e resistente ele fica.
Mais conexões sinápticas ele será capaz de fazer e responder ao ambiente de forma
apropriada. Portanto, faça muitos exercícios sobre os tópicos. Exercite os comandos.
Veja suas opções e argumentos. Teste as funcionalidades de cada um deles.
Muitas pessoas me perguntam sobre qual distribuição de Linux é a mais adequada

para a certificação, testar os comandos, etc. Eu sempre respondo: aquela que você
gostar mais. A LPI preza pela independência das distribuições e neutralidade. A prova
é focada em LINUX, seja ele qual for.
De forma que toda configuração e manejo do servidor são feitos com comandos no
Shell e diretamente nos arquivos de configuração. Isto é muito bom porque o
profissional fica experiente em qualquer Linux e não fica viciado em alguma
ferramenta amigável.
Mas existe alguma que eu indico? Sim. Mas se trata de minha opinião pessoal. Eu
gosto do Open-SuSE. É uma distribuição muito estável, feita por alemães que prezam
muito pela obediência completa aos padrões do Linux Standard Base. Os comandos,
arquivos e estrutura são exatamente como manda o figurino.
Só um detalhe importante: você precisará se familiarizar com os gerenciadores de

pacote Debian e RedHat. E geralmente uma distribuição adota um OU outro. E para
preparar-se para a prova é bom você estar afiado nos dois modelos. Portanto, escolha
uma distribuição baseada em Debian e outra em RedHat.
Aprendendo de Acordo com o Funcionamento do

seu Cérebro
Você também precisa se conhecer um pouco para que o aprendizado seja efetivo.
Nossa mente trabalha basicamente com 3 tipos de estilos de aprendizagem: físico,
visual e linguístico/sonoro. Como você fixa melhor aquilo que aprendeu?
Veja como são estes estilos e tente se identificar neles:
Físico
As pessoas com estas características são os inquietos, são os fuçadores, os
desmontadores de equipamentos e brinquedos, os que querem saber como funciona e

00445518006
ver por dentro, os que não conseguem ficar sossegados em seu lugar.
Eles são pessoas que não conseguem ficar sentadas por muito tempo. Eles
simplesmente raciocinam melhor quando seus corpos estão em movimento,
balançando o corpo entre uma perna e outra, para frente e para trás. Eles interagem
melhor com o mundo através do contato manual e corporal. Os “Aprendizes” físicos
adoram esportes, inventar, construir e dançar.
Quando estão aprendendo ou adquirindo capacitação acadêmica, essas pessoas se

beneficiarão mais com atividades de expressão corporal, manipulando e tocando
objetos, realizando exercícios, etc.
Dicas para você aprender melhor:
• Realize seus estudos com montagens e construções de

objetos e simulações;
• Inclua aulas virtuais em computadores;
• Alterne seções teóricas e práticas durante o estudo.
Linguístico / Sonoro
São aquelas pessoas que vivem cantando ou entoando algum som mesmo com a boca
fechada, os cantores e aqueles descritos com tendo um ouvido musical. Veem sons
em tudo. Eles podem não ser os melhores cantores ou músicos, mas eles têm uma
habilidade natural para interagir e entender os sons, musicais ou não.
Sua relação com o mundo é através dos sons e ritmos sonoros. As atividades que
podem ser mais proveitosas para elas são ouvir músicas, tocar instrumentos,
interpretar sons e cantar.

beneficiarão mais escrevendo letras e canções para músicas, tocando instrumentos
para acompanhar seus trabalhos ou de outros, ou desenvolvendo projetos de
multimídia.
• Tente transformar aquilo que você está aprendendo em

música;
• Grave aquilo que está aprendendo para escutar depois;
• Utilize música agradável durante os estudos.

- 00445518006
Prof. Uirá Ribeiro
Visual
Estas pessoas são os modernos Picassos e Renoirs, os grafiteiros e rabiscadores, e
indivíduos que têm um talento natural para as cores e para harmonizar ambientes. Os
indivíduos Visuais parecem ter um senso artístico que faz com que tudo que criem
pareça agradável aos olhos. Sua relação com o mundo é através de pinturas e
imagens. As atividades que podem ser mais proveitosas para elas incluem pintura,
escultura e a criação de artes gráficas.

beneficiarão mais com desenho e criação de diagramas, inclusive gráficos, leitura
cartográfica, criação de mapas ou realizando demonstrações.
• Crie apresentações multimídia;

• Utilize interpretação de mapas, diagramas e gráficos;
• Use e abuse de ilustrações, gráficos, slides, filmes etc.
Uma vez que você tenha se identificado em pelo menos um destes estilos, faça uso
das potencialidades do seu cérebro. Isso facilita seu aprendizado.
Mapas Mentais
Você talvez possa conhecer esse artifício de estudos chamado Mapa Mental, ou
esquema de espinha de peixe. Ele é muito útil, pois além de ser visual, ajuda a
organizar as idéias de uma forma muito prática para memorização. Na entrada dos
capítulos será apresentado um esquema de mapa mental dos temas daquele tópico.
Figura 1 - Esquema Espinha de Peixe

00445518006
Como exercício, execute cada comando de cada tópico pelo menos mais de uma vez,
exercitando as possíveis situações. Faça as seguintes perguntas para cada comando
estudado:
Para que serve este comando?

Como ele é usado?
Quando ele é usado?
Quais arquivos ele afeta?
Eu sugiro que você faça um esquema de espinha de peixe para os comandos, de

forma que você trabalhe com todas as potencialidades de aprendizado do seu cérebro:
visual, físico, e leia o texto em voz alta para também exercitar o lado sonoro.
Neste tipo de esquema atente a pelo menos dois tipos de estilo de aprendizagem: o
físico pois você está fazendo movimentos ao escrever; visual pois você está fazendo
um diagrama. Também ajuda na lógica e memorização pois você está categorizando a
informação em COMO, O QUE, QUANDO e ARQUIVOS. Se possível compre fichas
pautadas 10x15cm que são excelente para fazer consultas rápidas e podem te ajudar
na memorização.
Tente imaginar as situações em que os comandos são usados e teste os diversos tipos
de opções que eles têm. Isto é importante porque uma opção de um comando pode
inverter o resultado.
Por exemplo, o comando “grep uira texto.txt” vai filtrar todas as ocorrências da
palavra “uira” no arquivo texto.txt. Já o grep com a opção “-v” inverte, de forma que o
comando irá mostrar todas as linhas que não têm a palavra “uira” no texto.txt.
Você pode recorrer aos manuais “MAN” dos comandos de cada tópico. Eles têm
informações importantes que o programador que desenvolveu o software deixou ali de
forma especial para você. Vários comandos também tem os vídeos demonstrando seu
uso, que podem ser acessados através do QR-CODE.
Flashcards
O flashcard é uma metodologia amplamente utilizada para memorização de conceitos

e fórmulas.
Basta recortar pequenos pedaços de papel (fichas, cartões, postit) e escrever uma
pergunta na frente e uma resposta no verso.
Este método simples é eficaz porque:
Você precisa pensar para formular as perguntas;

Você precisa ser conciso para escrever as respostas;
Ao escrever perguntas e respostas estabelece vínculos entre os assuntos;
Ao escrever, fortalece o estímulo físico;

- 00445518006
Prof. Uirá Ribeiro
Ao ler os cartões, pode usar voz alta, para fortalecer o estímulo

sonoro/linguístico;
Ao visualizar os cartões também fortalece o estímulo visual;
Ao responder as perguntas e verificar as respostas, estimula os conexões
neurais e favorece a memorização.
Você Precisa Fazer Simulados!
Este item é um complemento do anterior, mas é tão importante que resolvi separá-lo
para que você dê mais atenção a ele.
Um simulado vai te dar uma ideia exata do tipo de questões das provas com que você
vai se deparar pelo caminho. Há questões que são maldosamente formuladas para
que você caia na vala do senso comum.
Veja que existem questões que vão priorizar pela simples memorização, outras vão
exercitar sua capacidade de análise em entender um problema do “mundo real” e sua
capacidade de transpor para o “mundo computacional”; outras vão exercitar seu
julgamento diante de um problema em questão e outras vão te apresentar um
problema e a solução e você deverá avaliar se a solução é a correta ou não e por que.
A prova é feita para não ser fácil. E isto é de suma importância para atestar a
qualidade das pessoas que são certificadas. Se qualquer um com pouco preparo pode
ser certificado, de que adianta exibir este título no currículo? Mas se é para os poucos
que realmente se dedicaram e estudaram a fundo, ora, é uma certificação de peso.
Ao término de cada capítulo, você poderá fazer o simulado dos tópicos abordados,
clicando no link ou no QR-CODE.
Aulas dos Comandos
Este livro contém diversos Qr-Codes que apontam para pequenas video-aulas sobre os
comandos citados. São mais de 8 horas de aula no total. Assim, esperamos que ao ler
sobre os comandos, você também possa ver um vídeo de uso do comando. Desta
forma, você não fica com dúvidas e ainda exercita os 3 modelos de aprendizado:
visual, linguistico e físico.
Para usar o QR-CODE, basta usar o App de câmera ou App de leitura de QR-CODE no
seu celular, apontar para o QR-CODE e curtir a aula.

00445518006
Figura 2 - Usando o QR-CODE
Um Linux para você na Web
Também disponibilizamos para você um Terminal Linux Fedora via navegador para
você treinar todos os comandos do livro, de forma fácil e descomplicada.
Para usar esta máquina virtual você precisa abrir o link usando um navegador de
Internet atualizado como Firefox, Chrome ou Safari. O Linux Fedora vai rodar no seu
navegador, em uma máquina virtual executada localmente no seu computador, em
segundos.
http://bit.ly/labvirtuallinux

- 00445518006
Prof. Uirá Ribeiro
Desconto pra quem é da America Latina e

Caribe
Em Parceria com a LPI, para os leitores deste livro, oferecemos um voucher de

desconto de 10% para o exame Linux Essentials 010, via site da Pearson Vue.
Este desconto somente é válido para pessoas físicas residentes nos seguintes países:
Argentina, Bolívia, Brasil, Caribe, Chile, Colômbia, Costa Rica, Equador, El
Salvador, Guatemala, Haiti, México, Nicarágua, Panamá, Paraguai, Peru,
República Dominicana, Uruguai e Venezuela.
Se você é residente em um destes países, pode comprar o voucher da prova Linux

Essentials com desconto.
Para solicitar seu desconto, por favor preencha o formulário no site:
https://www.certificacaolinux.com.br/descontoessentials/
Escolho uma pessoa preguiçosa para desenvolver um trabalho árduo.

Por causa da preguiça, ela vai descobrir um meio simples de
resolver o problema
-- Bill Gates

00445518006

- 00445518006
Prof. Uirá Ribeiro
Tópico 1: A comunidade
Linux e a carreira Open
Source
Você vai precisar passar horas e horas todos os dias, por pelo
menos uns 10 anos. Se você fizer isso você será um dos melhores
em alguma coisa. Mas o único jeito de se conseguir fazer algo por
horas e horas é se você encontrar algo em que realmente esteja
interessado em fazer!
-- Linus Torvalds

00445518006
1.1 A evolução do Linux e sistemas

operacionais populares
O Linux é um sistema operacional criado em 1991 por um estudante de computação

finlandês, que queria se conectar ao mainframe Unix da Universidade utilizando o seu
PC 386.
Na época a única portabilidade do sistema Unix para PCs era o sistema operacional
educacional chamado MINIX.
O MINIX era um sistema operacional mínimo baseado em UNIX, criado pelo renomado
professor de computação Andrew S. Tanenbaum, com intuito de ensinar o
funcionamento de sistemas operacionais. O licenciamento do MINIX na época limitava
o seu uso para questões educacionais, fora outras limitações.
No princípio Torvalds se baseou no MINIX para escrever o seu próprio Kernel e

aplicativos básicos, aproveitando muita coisa do MINIX. Mais tarde, todo o código foi
substituído por componentes do Projeto GNU.
O Torvalds queria que a sua criação se chamasse "Freax", um derivado de "Free"

(Livre), "Freak" (Aberração) e o "X" do Unix.
Desde o início, o Linux foi uma sensação entre os programadores e apaixonados por
tecnologia, sendo distribuído através dos canais de FTP, fóruns de discussão e
aprimorado por diversos entusiastas.
Alguns meses depois do lançamento público do "Freax", Ari Lemmke, colega de

Torvalds, renomeou o projeto para "Linux", que consentido por Linus.
Hoje o sistema operacional criado por Torvalds é utilizado largamente em toda a

infraestrutura da Internet, em todos os super-computadores, em quase todos os
celulares através da sua versão embarcada chamada Android.
Isso se deve em grande parte ao licenciamento de software adotado, o GNU GPL, que
obriga a livre distribuição do código-fonte, permite o seu aperfeiçoamento, e obriga a
livre distribuição do novo código aperfeiçoado.
Distribuições Linux
Por se tratar de um sistema operacional de código aberto, o Linux pode ser alterado e
personalizado por qualquer pessoa ou empresa.
Com isso, nos anos 90 surgiram diversos grupos, amadores e empresariais com fins
comerciais, que personalizaram o Linux, criando as suas próprias distribuições.
Uma distribuição Linux consiste em:

- 00445518006
Prof. Uirá Ribeiro
Núcleo do sistema operacional, chamado de Kernel;

Utilitários do projeto GNU;
Gerenciador de serviços: System V ou Systemd;
Ambiente gráfico: KDE, Gnome, XFCE, etc;
Gerenciador de software.
Cada distribuição Linux pode alterar qualquer um destes componentes,

personalizando ao gosto do grupo de usuários, ou para um propósito específico, ou
aplicação bem definida.
É por isso que existem distribuições voltadas para usuário final para uso em Desktop,
como o Fedora, Ubuntu e OpenSuSE, que utilizam ferramentas amigáveis, ambiente
gráfico robusto, e as distribuições voltadas para servidores, com propósito de uso
eficiente de recursos computacionais, como o Red Hat, Fedora para Servidores, SuSe e
o CentOS.
Há ainda a possibilidade de classificar as distribuições pela família de distribuição ao

qual ela faz parte. Basicamente existem duas grandes famílias: Debian e Red Hat.
Justamente por serem as distribuições estáveis mais antigas, quase todas as outras
distribuições existentes em 2020 se baseiam em uma delas.
Lançado em 1993 por Ian Murdock, o Debian é uma distribuição Linux que contou com
milhares de voluntários, que compartilharam dos ideais de Richard Stallman, quanto à
liberdade dos usuários para usar, distribuir e aprimorar o software.
Em 2004, Mark Shuttleworth e seu time, com objetivo de tornar o Linux o mais
amigável possível para os usuários Desktop, aprimorou o Debian, deixando a curva de
aprendizado para novos usuários a menor possível, e desse trabalho ele criou a
distribuição Ubuntu.
Em 1994, foi criada a primeira empresa comercial totalmente baseada em Linux,

chamada de Red Hat Linux. Especificamente voltada para aplicações empresariais, o
seu Linux é voltado para uso em servidores, e a sua receita anual de mais de um
bilhão de dólares é mantida com contratos de suporte. Em 2019 a Red Hat foi
comprada pela IBM por 34 bilhões de dólares. Nada mal para uma empresa de
Software livre.
Do Red Hat nasceram outras distribuições como o Fedora, voltado para Desktops e o
CentOS para servidores. O Fedora é mantido pela Red Hat, e adota novas tecnologias
de forma bem rápida.
Outra empresa antiga de Linux é a SUSE Linux, nascida em 1992 na Alemanha, é uma
distribuição conhecida por sua seriedade e também por seu Linux comercial SUSE
Enterprise para servidores. EM 2004 a empresa criou o OpenSUSE, uma versão livre e
gratuita do Linux, aberta para desenvolvedores externos. O SUSE Linux ficou
conhecido por sua ferramenta de gerenciamento de software chamada YaST, que
facilita muito a instalação de software, muito antes do Debian e Red Hat criarem
ferramentas parecidas (apt e yum).

00445518006
Sistemas Embarcados
No quesito de sistemas embarcados o Linux também é campeão, justamente por ter

código aberto, que facilita adaptações e funcionar num leque enorme de arquitetura
de processadores (x86, ARM, IA-64, m68k, MIPS, OpenRISC, PA-RISC, powerpc, s390,
Sparc, etc).
Os sistemas embarcados são equipamentos criados para uma funcionalidade

específica, mas que nos bastidores são um computador ligado à interfaces específicas.
Pode-se citar: multimídia automotivo, smartTVs, carros autônomos, roteadores de
internet, instrumentos médicos, automação industrial, sistemas de navegação, etc.
Android
Sem dúvida, com 2,5 bilhões de dispositivos ativos em 2019, o Android é uma forma
de Linux embarcado de muito sucesso. Criada em 2003, a empresa Android Inc.
inicialmente começou a desenvolver um sistema para ser usado em câmeras digitais.
Em 2005 foi adquirida pela gigante Google e transformou-se no sistema operacional
mais utilizado em dispositivos móveis.
O Android utiliza uma versão modificada do Kernel do Linux, especialmente

desenhado para funcionar com pequenas telas touchscreen. O projeto do Android
também conta com uma série de softwares proprietários dos aplicativos do Google,
como Calendário, Mapas, Mail e Navegador.
Raspberry Pi
O Raspberry Pi é um computador de baixo custo (US$25), do tamanho de um cartão

de crédito, com Wifi, entradas USB, HDMI e som. Além disso possui diversas interfaces
de entrada e saída, conhecidas como GPIO, que podem se conectar em outros
dispositivos eletrônicos, placas extensoras, sensores, servo-motores, e outros
hardwares. Os criadores do Raspberry personalizaram uma versão do Debian para
funcionar no Raspberry, chamada de Raspbian.
O Raspberry é um dos vetores do crescimento de dispositivos embarcados, devido a

sua versatilidade e preço.
Linux na Nuvem
O termo computação na nuvem foi cunhado para designar o consumo de recursos

computacionais em data centers distribuídos, em nuvens públicas ou privadas. Em
2017, estima-se que 90% das aplicações em nuvem executem em Linux.
Os grandes players de computação em nuvem são: Amazon Web Services (AWS),

Google Cloud Platform, Rackspace, Digital Ocean, e Microsoft Azure. Todos eles
oferecem várias versões de Linux nas suas infraestruturas.

- 00445518006
Prof. Uirá Ribeiro
1.2 Principais Aplicações Open

Source
Por melhor que seja um sistema operacional, sem um ecossistema rico em aplicativos,
estará fadado ao desprezo e esquecimento.
Pois são os aplicativos que tornam o sistema relevante e útil aos olhos dos usuários,
realizando uma variedade de tarefas, com programas de edição de texto, planilhas,
navegadores web, reprodução e edição de vídeos, leitores de e-mail, interfaces de
desenvolvimento, comunicadores, etc.
Sem dúvida, independente da aplicação escolhida, é quase certo que haverá mais de
um aplicativo disponível para a escolha do usuário. Cabe a ele escolher um que seja
adequado aos requisitos e que atenda satisfatoriamente os seus desejos.
Há dez anos que o ecossistema de aplicativos para Linux cresceu enormemente,

rivalizando com elegância com os outros sistemas operacionais, como o Windows.
Aplicativos de Escritório
Os aplicativos de escritório, que servem basicamente para escrever textos, criar

planilhas, editar apresentações e pequenos banco de dados são as aplicações mais
comuns quando se fala em computação desktop.
Há várias alternativas profissionais para o Microsoft Office para Linux, tais como:
LibreOffice
OpenOffice
Calligra Suite
WPS Office
OnlyOffice
Todas elas oferecem leitura de documentos compatível com o formato aberto, bem
com o formato da Microsoft.
Navegadores Web
No quesito de navegadores Web, o Linux suporta todos os grandes navegadores, tais

como:
Chromium do Google
Firefox da Mozilla

00445518006
Opera, da empresa de mesmo nome

Tor, para navegação privada
Multimídia
Neste quesito o Linux também possui fortes concorrentes para todos os softwares
pagos:
Blender, para animação em 3D

GIMP para editar imagens, tão bom quanto o Photoshop
Inkscape para imagens vetoriais, em substituição para o Corel Draw e
Illustrator
Audacity para editar áudio
ImageMagick para criar documentos em PDF
VLC para reproduzir vídeos
Desenvolvimento de Software
Para os programadores o Linux também fornece um leque enorme de Interfaces de

Desenvolvimento (IDE), tais como:
Bluefish
Geany
Gedit
Kate
Eclipse
Brackets
Visual Studio Code
Atom
Sublime
Linguagens de Programação
O Linux também é muito rico em suporte às linguagens de programação, trabalhando

com todas as maiores e melhores linguagens:
C/C++
Perl
Python
PHP

- 00445518006
Prof. Uirá Ribeiro
Java
Javascript
Ruby
Bash
Dart
Golang
Programas para Servidor
Enquanto o Linux nunca conseguiu um relativo sucesso no mundo dos computadores

Desktop, com toda a certeza ele domina o mundo dos servidores e dispositivos
móveis.
Segundo dados da W3Cook, em Julho de 2015, 96,4% dos computadores servidores

conectados à Internet eram servidos com Linux. E dos 500 supercomputadores, todos
eles rodam Linux.
No mundo Mobile, 40,44% dos acessos à Internet em setembro de 2019 foram feitos
com dispositivos rodando Android.
Como sistema operacional, não há muita diferença entre um Linux Desktop que roda
em um Notebook e um Linux servidor que executa numa máquina em algum gabinete
em um Rack de servidores. Ambos tem o mesmo Kernel, e são capazes de executar as
mesmas aplicações.
A diferença está nas aplicações que estão instaladas no Linux, e como estas
aplicações executam no sistema.
Enquanto um Linux voltado para Desktop executa aplicações pessoais, geralmente em

ambiente gráfico, com muita interação com usuário, o Linux Servidor foi desenhado
para não ter interação direta com o usuário, nem mesmo na maioria das vezes há um
terminal conectado.
Os servidores são especificamente feitos para executar programas que vão prover
serviços para os usuários, geralmente via rede. Estes programas geralmente são
executados como serviços do sistema, em modo texto, no Shell do Linux.
Hoje, a maioria das aplicações são feitas para funcionar em ambiente Web ou Mobile,
e o Linux atua a fornecer um Servidor Web ou provendo serviços de processamento de
dados para os dispositivos móveis.
É na utilização de programas para servidores que o Linux detém pelo menos 90% do
mercado, com programas que fornecem a infraestrutura para sites, aplicativos, base
de dados, serviços de streaming, comunicação, etc.
A seguir descreveremos as aplicações de servidor Linux comuns por tipo.

00445518006
Servidores Web
Apache HTTP Server
Um dos primeiros e mais populares servidores é o Apache Web Server, desenvolvido

pelo Centro Nacional de Aplicações de Supercomputadores (NCSA). Sua popularidade
se deve a sua modularidade, de forma que as suas funcionalidades podem ser
habilitadas na forma de plug-in. Com isso, ele se torna bem versátil, e economiza CPU
e recursos.
NGINX
O NGINX é um servidor web lançado em 2004 com o objetivo de substituir o Apache,

com desempenho melhorado, principalmente para páginas estáticas. Ele também tem
funcionalidades adicionais, podendo atuar como web proxy, mail proxy, cachê de
páginas web e também como balanceador de carga.
O uso de memória do Nginx é bem menor que no Apache, podendo lidar com mais de
10.000 clientes simultaneamente.
Servidores de Banco de Dados

O Linux é bem seguro e largamente utilizado para hospedar aplicações de servidores
de banco de dados. Seu sistema de arquivo robusto e confiável é ideal para armazenar
os arquivos grandes dos gerenciadores de banco de dados.
Oracle Database
O banco de dados relacional da Oracle foi um dos primeiros bancos de dados a ser
largamente utilizado por empresas, e há até uma distribuição Linux da própria Oracle
customizada para hospedar seu banco de dados.
MySQL
O MySQL foi um dos primeiros banco de dados relacionais de código livre, provendo
serviços de banco de dados de forma rápida e simples. Sua combinação com
servidores Web, como o Apache, e com a linguagem de programação PHP foi explosiva
e decisiva para a ascensão das aplicações web. Esta combinação ficou conhecida
como LAMP (Linux Apache MySQL e PHP).
Há poucos anos o MySQL foi comprado pela Oracle e uma versão comercial
aprimorada foi lançada, mas mantendo uma versão mais simples comunitária.
Parte dos desenvolvedores do projeto original do MySQL fizeram um novo banco de

dados aproveitando tudo que tinham do MySQL e chamaram de MariaDB, que
comunga com os princípios do software livre.
PostgreSQL
O PostgreSQL é outro banco de dados relacional de código aberto que sempre teve
como objetivo rivalizar com os softwares comerciais, trazendo características que

- 00445518006
Prof. Uirá Ribeiro
geralmente são encontradas somente em softwares comerciais de alto custo. Seu uso
nunca foi grande no mundo web, devido a sua má reputação de ser lento.
MongoDB
O MongoDB é um banco de dados não relacional, que armazena dados com o método
NoSQL. Ele não usa tabelas como os banco de dados relacionais, mas sim em
documentos com elementos independentes, no formato JSON (Javascript Object
Notation).
Mesmo não sendo relacional, o MongoDB suporta indexes, consultas, replicação e

balanceamento de carga. Seu uso em sites que utilizam o Javascript é o casamento
perfeito.
Servidores de E-Mail
Uma das primeiras aplicações servidoras que o Linux hospedou na Internet é o serviço
de e-mail. Ao invés de utilizar aplicações monolíticas para receber e enviar e-mails, o
Linux utiliza uma série de programas, que juntos servem para enviar e-mails entre os
servidores, receber e-mails dos clientes, enviar e-mails para os clientes e armazenar
as mensagens.
Os principais softwares de servidores e-mail no Linux são:
Sendmail: o mais antigo software de serviço de e-mail da Internet, com muitas

funcionalidades interessantes, mas bem complexo para ser configurado a mão.
Postfix: sua principal característica é a simplicidade. Foi escrito para ser
modular e de fácil configuração. Bem popular em pequenos servidores de e-
mail.
Exim: bem completo, e menos complexo que o sendmail.
NTP - Network Time Protocol

O serviço de NTP serve para ajustar o relógio local do Linux, bem como o relógio de
diversos compuladores ligados em rede. Ele utiliza uma rede de servidores na Internet
que utilizam relógio atômico para contar o tempo de forma exata. Este tipo de serviço
é essencial para os computadores, uma vez que seus relógios contam o tempo através
de software que pode sofrer um "escorregamento" da hora, deixando o sistema com o
relógio atrasado. Estar com o relógio certo é necessário para os serviços de
autenticação de usuários.
No Linux, os pacotes Chrony ou NTPD geralmente são utilizados como serviço de NTP.
DHCP - Dynamic Host Configuration Protocol

O serviço de DHCP é essencial para controlar e distribuir endereços IP de forma
dinâmica em uma rede local ou WIFI. Este serviço é responsável por autenticar os
dispositivos na rede, e prover um endereço IP local para os computadores e
dispositivos conectados. É tão essencial esse tipo de serviço que costuma vir

00445518006
embarcado em modems de Internet caseiros. No entanto, em redes corporativas, este

tipo de serviço geralmente é amarrado junto com algum serviço de autenticação de
usuários. O Linux possui vários pacotes que atuam como servidores de DHCP, tais
como dhcpd e pump.
DNS - Resolução de Nomes

O serviço de resolução de nomes DNS é responsável por resolver um endereço de
Internet (ex: www.certificacaolinux.com.br) em um endereço IP de algum servidor
responsável por prover algum tipo de serviço para este endereço. O pacote mais
popular para prover a resolução de nomes no Linux é o Bind. Este servidor faz a
tradução de endereços por IPs na rede utilizando uma rede de servidores DNS, que
fazem a tradução dos endereços de forma descentralizada.
É comum nas redes locais uma das máquinas atuarem como servidor de DNS para as
demais máquinas na rede, de forma que é feito um cachê local dos nomes de rede já
resolvidos, evitando assim novas consultas pela Internet.
O serviço do Systemd no Linux também utiliza um serviço de resolução de nomes local

chamado Systemd-Resolved, que faz a resolução de nomes e cachê local
Servidor de Arquivos
O Linux pode atuar como um confiável servidor de arquivos para usuários e máquinas
em uma rede local ou em nuvem. Há várias maneiras do Linux servir arquivos em uma
rede, através de diferentes maneiras e pacotes de software:
Web: O linux pode atuar com um servidor Web preparado para servir arquivos
via páginas de Internet;
NFS: Network FIle Systems é um sistema de compartilhamento de pastas
largamente utilizado no Linux e Unix;
SAMBA: O serviço de SAMBA é um sistema de compartilhamento de pastas e
impressoras utilizado no Linux para compartilhar volumes entre máquinas
Windows e Linux;
Servidores de Impressão
O Linux também pode atuar como servidor de Impressão, controlando uma ou mais
impressoras locais, com serviços de autenticação e controle de impressões. O pacote
mais popular no Linux para este serviço é o CUPS.
Web Proxy e Cachê

O serviço de web proxy é utilizado para interceptar as requisições de páginas de
Internet de máquinas conectadas em uma rede local, com o objetivo de prover
controle de uso de Internet, liberando ou não o acesso a algum site, baseado em uma
lista de controle de acesso por máquina, usuário, horário, etc. Além de controlar o
acesso à Internet, o servidor de proxy geralmente também atua como um cachê local

- 00445518006
Prof. Uirá Ribeiro
de objetos de Internet (páginas, imagens, js, css, etc) de forma que uma segunda
requisição para um mesmo site seja bem mais rápida, economizando tempo e largura
de banda do link de Internet. Existem distribuições Linux especialmente desenvolvidas
para atuar como Web Proxy e Firewall de Internet. O pacote Linux mais popular para
serviço de Web proxy é o squid.
Autenticação
O serviço de autenticação de usuários pode ser fornecido pelo Linux de diversas
maneiras diferentes.
Em termos de autenticação de usuários locais, o Linux utiliza o esquema de controle

de contas e autenticação por senha localmente usando os arquivos /etc/passwd e
/etc/shadow.
No entanto, o Linux pode ser utilizado para autenticar usuários para uma rede local,
utilizando os servidores de SAMBA, KEBEROS e LDAP:
Keberos
Desenvolvido pelo MIT, o sistema de autenticação do Keberos utiliza chaves

criptografadas para fazer a autenticação de usuários, tanto em aplicações locais ou
através de plug-ins que podem ser utilizados em diveras aplicações para autenticar
seus usuários.
SAMBA
O Samba pode prover serviços de autenticação de usuários em uma rede, imitando os

serviços de autenticação do Microsoft Windows Server, atuando como um servidor de
autenticação de domínio de um Microsoft Active Directory.
LDAP
O serviço de LDAP foi primeiramente utilzado comercialmente pela Microsoft para

prover serviço de Diretório, concentrando os objetos de uma rede (máquinas,
impressoras, usuários) em um só local, em um esquema hierárquico. Os objetos na
rede podem ser agrupados por alguma lógica que faça sentido, como por exemplo,
divisão por departamentos, e as propriedades dos objetos também são armazenadas
no LDAP. Um objeto de conta de usuário pode conter seu nome, email, telefone, local
de trabalho, login na rede, etc. O Linux possui um pacote muito bom para prover o
serviço de diretório com o OpenLDAP.
VPN - Virtual Private Network

O serviço de VPN é essencial para prover conexão remota via Internet à uma rede
local, de forma segura e criptografada. Uma vez conectado a uma VPN, um dispositivo
cliente (mobile ou desktop) pode ter acesso a dados e serviços sensíveis, cujo acesso
direto via Internet não seja comercialmente apropriado. Via VPN um usuário pode ter
acesso a um servidor de arquivos, web ou de aplicações da empresa de forma segura,
uma vez que existe uma autenticação por chaves envolvida, e também criptografia

00445518006
dos dados. O pacote popular no Linux para fornecer VPN é o OpenVPN.
Monitoramento
O serviço de monitoramento no Linux serve para monitorar servidores e aplicações, de
forma que o administrador fique sabendo quando um evento importante aconteceu,
como por exemplo falha ou indisponibilidade de algum serviço. Os servidores de
monitoramento podem se conectar diretamente em um serviço, como por exemplo
um servidor web, banco de dados, etc, para testar se o serviço está funcionando, ou
através de um protocolo especial chamado SNMP (Simple Network Management
Protocol), implementado em diversos dispositivos, servidores e aplicações para
difundir na rede o status dos seus ativos. Este protocolo é implementado geralmente
em dispositivos de rede, como roteadores, switches, modems e outros equipamentos.
No Linux, os pacotes de software NAGIOS e ZABBIX são populares para monitorar

servidores, aplicações e equipamentos de rede.
Logging
O serviço de Logging servidodo junto com os serviços de autenticação e
monitoramento. Ele fornece um jornal de log de eventos de sistema, usuários e
aplicativos, guardando informações das situações importantes, para posterior consulta
e depuração de problemas. O Linux possui um jornal de Logging nativo no Systemd,
bem como serviços de Log herdados do Unix, como o Syslog e SyslogNG. Estes
servidores de LOG podem armazenar as informações sobre os eventos da máquina
Linux localmente, bem como armazenar eventos de dispositivos remotos.
Autoridade de Certificado
O serviço de autoridade de certificado se tornou comum na Internet para autenticação
de usuários. Os certificados atuam como um método de autenticação por 2 fatores. A
autenticação por 2 fatores utiliza dois métodos diferentes para autenticar um usuário.
Geralmente envolve o usuário apresentar algo que ele tenha (como um certificado, ou
uma senha gerada por algum dispositivo ou algum cartão de combinações) e algo que
ele saiba (como uma senha pessoal). Os dois fatores fortalecem a autenticação, pois é
necessário apresentar os dois fatores.
A autoridade de certificado é utilizada pelos governos e bancos, para autenticar

pessoas físicas e jurídicas, e prover serviços governamentais e financeiros através da
Internet. No Brasil existem vários tipos de certificado como o e-CNPJ e e-CPF.
Os certificados são emitidos por autoridades de certificado, que são empresas que
conferem a documentação de uma empresa ou pessoa, e então emitir um certificado.
O certificado então pode ser verificado através de uma cadeia de servidores, que
atestam sua autenticidade.
Na Internet também existem certificados SSL que fornecem autenticidade (o site é

quem diz que é) e criptografia ponta a ponta.
O pacote OpenSSL no Linux é capaz de prover os serviços de emissão e

- 00445518006
Prof. Uirá Ribeiro
reconhecimento de certificados, bem como de SSL para os serviços de web.
SSH - Secure Shell

O serviço de ssh é bem comum em servidores Linux, e provê acesso remoto ao shell
do Linux com criptografia. Geralmente este serviço opera na porta 22 TCP em
máquinas Linux. O pacote que provê o serviço de ssh é o OpenSSH, que contém a
aplicação servidora sshd, e o cliente ssh para fazer conexão remota. É incomum
prover o serviço de ssh para usuários comuns, sendo mais utilizado pelos
administradores de sistema.
Clustering
O clustering é a divisão da carga de processamento em diversos servidores que atuam
como irmãos gêmeos, provendo os mesmos serviços, com as mesmas aplicações.
Dependendo da aplicação, é necessário que os servidores em cluster compartilhem
alguma informação de sessão, como autenticação de usuários, etc. Este tipo de
topologia permite que um determinado serviço seja distribuído em diversos servidores
para aumentar a sua confiabilidade e disponibilidade.
Balanceamento de Carga
O serviço de balanceamento de carga é inerente ao serviço de clustering, uma vez
que pode ser necessário que algum agente na rede atue dividindo a carga ou o
processamento entre os servidores em clustering. O tipo de software que vai fazer o
balanceamento de carga depende do tipo de aplicação. O mais comum é
balanceamento de servidores web, que pode ser feito com um proxy reverso, ou com
servidor web configurado para tal.
Conteineres
Um dos grandes problemas do desenvolvimento de software é garantir que o software
que funcionou como esperado no ambiente de desenvolvimento funcione da mesma
forma nos servidores em produção. Quem já lidou com isso sabe que mesmo uma
aplicação web simples pode enfrentar problemas com variáveis ambientais erradas,
configurações diferentes, plugins ou módulos faltando.
Para contornar isso, foi criado um encapsulamento de aplicações junto com o

ambiente que ela necessita, da jeito que o desenvolvedor pensou e testou o software.
Este encapsulamento pode ser copiado junto com a aplicação para o servidor de
produção em forma de contêiner, garantindo que o software irá executar da forma
esperada em qualquer lugar.
Existem muitos pacotes de conteineres para Linux, sendo os mais populares o Docker,
Kubernetes e o LXC.
Gerenciamento de Pacotes Debian

00445518006
O gerenciamento de pacotes é uma excelente maneira de distribuir, instalar e

desinstalar software.
Um pacote em poucas palavras é um arquivo que contém as informações necessárias

para que o gerenciador de pacotes possa instalar, manter e remover os programas
como também os demais arquivos necessários de um determinado aplicativo.
Uma característica importante do Linux é a modularização de seus componentes e o

uso intensivo de bibliotecas compartilhadas. Isso se aplica também aos pacotes de
aplicativos. É bastante comum um programador utilizar bibliotecas compartilhadas e
não as incluir no seu aplicativo.
É comum ao tentarmos instalar um determinado pacote ser necessário primeiro

instalar outro pacote que contenha os pré-requisitos ou as bibliotecas para a sua
instalação. Cada pacote carrega as informações de dependências necessárias.
Grandes projetos de software usam distribuir os diversos módulos de seu aplicativo

em diversos pacotes que podem ou não ser instalados de acordo com o seu uso. A
organização de um aplicativo em vários pacotes permite que o administrador instale
somente aqueles que são realmente necessários, evitando ter que instalar
componentes que não serão utilizados. Seguindo a linha de gerenciadores de pacotes,
duas grandes distribuições Linux se destacaram.
A Debian uniu as ferramentas GNU, o Kernel do Linux e outros softwares livres

importantes formando a distribuição chamada Debian GNU/Linux. Esta distribuição é
feita de um grande número de pacotes de softwares. Cada pacote na distribuição
contém programas executáveis, scripts, documentação e informações de
configuração. O gerenciador de pacotes do Debian é versátil e robusto. O Ubuntu e o
SteamOS seguem o padrão Debian.
Também a empresa americana Red Hat foi uma das pioneiras no tratamento sério do
Linux. Desde o início ela é uma das principais distribuições mundiais com grande
influência. Criadora do RPM, o gerenciador de pacotes mais usado atualmente no
Linux, a Red Hat tem uma distribuição voltada para o mercado de servidores. O
Fedora, Mandriva, SuSE, OpenSuSe, CentOS e o Oracle Linux seguem o padrão RPM.
A Debian está atenta para detalhes que nos permitem produzir programas de alta
qualidade e estabilidade. As instalações podem ser facilmente configuradas para
servir múltiplos propósitos, como firewalls com poucos pacotes, estações desktop
científicas e servidores de rede de alto desempenho.
Esta distribuição é especialmente popular entre usuários avançados por causa de sua
excelência técnica e atenção às necessidades e expectativas da comunidade Linux. A
Debian também introduziu muitas características ao sistema que agora são rotineiras
como o sistema de gerenciamento de pacotes para instalação e remoção fácil de
software e também a possibilidade de permitir a atualização do sistema sem requerer
a reinstalação.
As ferramentas do gerenciador de pacotes possibilitam ao administrador de um

sistema Debian o controle completo dos softwares instalados, incluindo a habilidade

- 00445518006
Prof. Uirá Ribeiro
de instalar um simples pacote ou automaticamente atualizar todo o sistema

operacional. Os pacotes também podem ser protegidos para não serem atualizados.
Os nomes dos pacotes Debian acompanham o seguinte padrão:
Nome do Pacote: O nome do pacote é uma breve descrição do seu conteúdo.

Se mais de uma palavra for usada, é separada por traço;
Versão do software: Cada pacote tem um número de versão próprio, que
pode variar entre versão principal e correções aplicadas;
Versão do pacote: Os pacotes também podem ter versões diferentes de
distribuição. A versão do pacote também pode indicar para qual plataforma ele
foi preparado;
Extensão .deb: Para fácil identificação dos pacotes Debian.
Exemplos:
abiword-gtk_1.0.2+cvs.2002.06.05-1_i386.deb
abiword-plugins_1.0.2+cvs.2002.06.05-1_i386.deb
abook_0.4.16-1_i386.deb
abuse_2.00+-3_i386.deb
abuse-frabs_2.10-3_all.deb
abuse-lib_2.00-14_all.deb
abuse-sdl_0.6.1-1_i386.deb
acct_6.3.5-32_i386.deb
ace-of-penguins_1.2-3_i386.deb
acfax_981011-7_i386.deb
dpkg
# dpkg [opções] ação
O utilitário dpkg é responsável pelo gerenciamento de pacotes em sistemas Debian.
Ele mantém as informações dos pacotes instalados basicamente nos arquivos

/var/lib/dpkg/available e /var/lib/dpkg/status. Estes arquivos contêm a lista de pacotes
disponíveis e status, respectivamente.
As opções mais frequentes são:
-E: Esta opção não regrava um pacote já instalado de mesma versão;

-G: Esta opção não regrava um pacote já instalado, mesmo que seja mais
antigo;
-R: Processa todos os pacotes encontrados em determinado diretório de forma

00445518006
recursiva.
As ações mais frequentes são:
-i nomedopacote: Instala o pacote nomedopacote. Este processo envolve

fazer cópia backup dos arquivos antigos que já existirem no sistema,
desempacotamento, instalação e configuração. Esta ação também pode ser
referenciada com –install nomedopacote;
-l chavebusca: Lista as informações dos pacotes que contenham no nome a
mesma chave de busca;
-L nomedopacote: Lista os arquivos instalados pelo pacote nomedopacote;
--print-avail nomedopacote: 'Lista todas as informações disponíveis sobre o
pacote nomedopacote em /var/lib/dpkg/avaliable;
--purge nomedopacote: Remove todo o pacote nomedopacote;
-r nomedopacote: Remove todos os arquivos do pacote, menos as
configurações;
-s nomedopacote: Mostra o status do pacote;
-S arquivo: Procura por um arquivo nos pacotes instalados;
--unpack nomedopacote: Desempacota um pacote, mas não instala;
--configure nomedopacote: Configura um pacote não instalado.
Exemplos:
Instala o pacote acct_6.3.5-32_i386.deb.
# dpkg -i acct_6.3.5-32_i386.deb
Remove o pacote ace-of-penguins_1.2-3_i386.deb do sistema completamente.
# dpkg --purge ace-of-penguins_1.2-3_i386.deb
Configura o pacote abook_0.4.16-1_i386.deb.
# dpkg --configure abook_0.4.16-1_i386.deb
O dpkg também pode ser utilizado para se descobrir a qual pacote determinado
arquivo pertence:
# dpkg -S stdio.h
libc6-dev: /usr/include/stdio.h
libc6-dev: /usr/include/bits/stdio.h

- 00445518006
Prof. Uirá Ribeiro
perl: /usr/lib/perl/5.6.0/CORE/nostdio.h
Outra possibilidade é descobrir os pacotes instalados no sistema a partir de uma

chave:
# dpkg -l | grep mozilla

ii mozilla-browse 0.9.6-7 Mozilla Web Browser
O arquivo /etc/dpkg/dpkg.cfg contém as opções padrão quando o dpkg é executado.
Os arquivos de controle do dpkg residem no diretório /var/lib/dpkg. Dois arquivos

interessantes neste diretório são:
/var/lib/dpkg/available: Lista de pacotes disponíveis;

/var/lib/dpkg/status: Estado dos pacotes instalados. Informa quando foram
instalados, removidos etc.
apt-get
# apt-get [opções] [comando] [nome do pacote]
O comando apt-get (Advanced Package Tool) é um gerenciador avançado de pacotes.

Ele pode utilizar arquivos locais ou remotos para realizar instalação ou atualização de
pacotes. Desta maneira é possível atualizar todo o sistema Debian via ftp ou http. Este
gerenciador também mantém informações dos pacotes e suas dependências.
Devido a sua facilidade de operação, o apt-get é o método preferido para se manipular

pacotes. Este utilitário oferece dezenas de opções configuradas no arquivo
/etc/apt/apt.conf.
O arquivo /etc/apt/sources.list contém os locais onde o apt-get encontrará os

pacotes, a distribuição verificada (stable, testing, unstable, Woody, Sarge) e a seção
que será copiada (main, non-free, contrib, non-US).
Abaixo um exemplo simples de arquivo /etc/apt/sources.list com explicação das

seções:
deb http://www.debian.org/debian stable main contrib non-

free
deb http://nonus.debian.org/debian-non-US stable non-US
No arquivo /etc/apt/apt.conf podemos especificar opções que modificarão o

comportamento do programa apt-get durante a manipulação dos pacotes.

00445518006
O apt-get utiliza uma lista de pacotes para verificar se os pacotes existentes no

sistema precisam ou não ser atualizados. A lista mais nova de pacotes é copiada
através do comando apt-get update.
O apt-get é muito útil, pois o administrador não precisa copiar manualmente da

Internet o pacote que deseja instalar, muito menos lidar com as dependências, desde
que o que ele precisa esteja nos repositórios indicados no sources.list.
As opções mais frequentes deste utilitário são:
-d: Baixa os arquivos, mas não instala. É útil para baixar grandes volumes de
pacotes para posterior instalação;
-s: Simula a instalação dos pacotes, mas não realiza modificações;
-y: Responde afirmativamente por todas as perguntas feitas durante o
processo de instalação/desinstalação dos pacotes.
Os comandos mais frequentes são:
dist-update: Este comando faz a atualização automática do sistema Debian;

install: Este comando instala um determinado pacote especificado pelo nome;
remove: Este comando remove um determinado pacote especificado pelo
nome;
update: Este comando faz uma lista de todos os pacotes disponíveis. O
processo é feito automaticamente antes de qualquer modificação nos pacotes;
upgrade: Este comando é utilizado para fazer uma atualização segura do
sistema, pois ele não instala pacotes que podem causar algum conflito ou falha
nos arquivos de configuração.
Exemplos:
# apt-get install airsnort
Instala o pacote airsnort.x.y.deb. Este comando aceita instalar mais de um pacote

separando os nomes por espaços. Somente é preciso especificar o nome do pacote,
sem a versão (X), revisão (Y) e sufixo (.deb).
Se for preciso, o apt-get irá instalar automaticamente as dependências necessárias

para o funcionamento correto de um pacote.
O apt-get é muito usado também para fazer atualização de todos os pacotes do

sistema, com o comando update para atualizar as bases de dados com os pacotes
novos e posteriormente o comando upgrade para fazer as atualizações:
# apt-get update
# apt-get upgrade

- 00445518006
Prof. Uirá Ribeiro
O apt-get pode atualizar toda a sua distribuição de uma forma inteligente e segura.
Ele lê a listagem de pacotes disponíveis no servidor remoto, verifica quais estão
instalados e suas versões e atualiza os pacotes antigos.
# apt-get dist-update
Gerenciamento de Arquivos Red Hat

e YUM
O Red Hat Package Manager – RPM é um poderoso gerenciador de pacotes que

permite ao administrador instalar, remover e obter informações sobre pacotes. É um
método de distribuição de software largamente usado em várias distribuições Linux,
além do Red Hat.
Ele também possibilita construir pacotes a partir de arquivos fonte, verificar a

assinatura digital, simular uma instalação, dentre outras. É tão poderoso quanto o
dpkg e apt-get.
Este gerenciador de pacotes realiza de forma simples a instalação, manutenção e

remoção de pacotes de software.
Cada pacote rpm contém programas binários, arquivos de configuração,

documentação e informações de como eles devem ser instalados e suas
dependências.
Este utilitário mantém um banco de dados de todos os pacotes instalados e seus

arquivos, controle de versões e dependências. Em algumas situações especiais o
banco de dados pode ficar corrompido. O gerenciador de pacotes conta com funções
especiais para recuperar a sua integridade.
Os pacotes rpm acompanham a seguinte nomenclatura:
Nome_do_pacote: Assim como nos pacotes Debian, um pacote rpm tem um

nome curto que descreve seu conteúdo. Se mais de uma palavra for utilizada é
utilizado o traço;
Versão do Software: Cada arquivo rpm tem a sua versão que podem variar
de acordo com os pacotes. Geralmente é numérica e são separada do nome
por um traço;
Distribuição do Software: Cada arquivo também pode ter uma distribuição
ou empacotamento diferente;
Arquitetura: O pacote rpm costuma carregar o nome da arquitetura para a
qual foi montado;
Sufixo .rpm: Ele utiliza a terminação .rpm para fácil identificação.
Exemplos:

00445518006
binutils-2.27-28.base.el7_5.1.x86_64
python-backports-1.0-8.el7.x86_64
libstaroffice-0.0.4-1.el7.x86_64
adcli-0.8.1-4.el7.x86_64
Podemos encontrar também pacotes com nomes no formato pacote-versao.src.rpm.

Esses pacotes contêm os arquivos fontes de um software e são na grande maioria
independentes de arquitetura.
O gerenciador de pacotes rpm é utilizado por várias distribuições Linux. Mas os

pacotes podem diferir nas informações adicionais de uma distribuição para outra.
Procure sempre utilizar pacotes feitos especificamente para a sua distribuição.
Este gerenciador também faz o controle de dependências entre os pacotes. Eles

contêm informações das dependências de cada aplicativo, e essa informação é
utilizada durante sua instalação ou remoção. Caso a instalação de um novo pacote
requeira outro, o rpm alertará o administrador.
rpm
# rpm [modo] [opções] [pacotes]
O comando rpm é responsável pela instalação, remoção, atualização, conversão dos

pacotes. Este comando é organizado primeiro em modos de operação, que podem ser:
consulta, verificação, integridade, instalação, remoção, atualização e reconstrução do
banco de dados rpm. Cada modo de operação pode ou não conter várias opções
disponíveis.
Os modos de operação mais frequentes são:
Para consultar a base de dados
# rpm {-q|--query} [opções de consulta] nome_do_pacote
Exemplo:
# rpm –q bash
bash-2.05b-207
Para verificar o status dos pacotes
# rpm {-V|--verify} nome_do_pacote

- 00445518006
Prof. Uirá Ribeiro
Exemplo:
# rpm -V snort-2.0.1-98.i586.rpm
package snort-2.0.1-98.i586.rpm is not installed
Para verificar a assinatura e integridade dos pacotes
# rpm {-K|--checksig} nome_do_pacote
Exemplo:
# rpm -K libpcap-0.7.2-37.i586.rpm
libpcap-0.7.2-37.i586.rpm: sha1 md5 gpg OK
Para instalar um novo pacote:
# rpm {-i|--install} [opções de instalação] nome_do_pacote
Exemplo:
# rpm –i libpcap-0.7.2-37.i586.rpm
Para instalar um novo pacote mostrando detalhes da instalação:
# rpm –ivh libpcap-0.7.2-37.i586.rpm

Preparing... ####################### [100%]
1:libcap ####################### [100%]
Para atualizar um pacote:
# rpm {-U|--upgrade} [opções de instalação] nome_do_pacote
Exemplo:
# rpm -U libpcap-0.7.2-37.i586.rpm
package libpcap-0.7.2-37 is already installed
Para remover um pacote:

00445518006
# rpm {-e|--erase} [opções de remoção] nome_do_pacote
Exemplo:
# rpm –e libpcap-0.7.2-37.i586.rpm
Para refazer o banco de dados RPM:
# rpm {--initdb|--rebuilddb}
Exemplo:
# rpm --initdb
Para consultar as dependências de um pacote:
# rpm {—qpR }
Exemplo:
# rpm —qpR BitTorrent-5.2.2-1-Python2.4.noarch.rpm

/usr/bin/python2.4
python >= 2.3
python(abi) = 2.4
python-crypto >= 2.0
python-psyco
python-twisted >= 2.0
python-zopeinterface
rpmlib(CompressedFileNames) = 2.6
Para instalar um pacote ignorando as dependências (algo bem estúpido de

se fazer):
# rpm {—ivh --nodeps }
Exemplo:
# rpm -ivh --nodeps BitTorrent-5.2.2-1-Python2.4.noarch.rpm

Preparing... ####################### [100%]

- 00445518006
Prof. Uirá Ribeiro
1:BitTorrent ####################### [100%]
Para listar os pacotes instalados recentemente:
# rpm {—qa --last }
Exemplo:
# rpm -qa --last

kernel-headers-3.14.34-27.48.amzn1.x86_64 Sex 06 Mar
2015 11:55:01 BRT
graphviz-gd-2.38.0-18.44.amzn1.x86_64 Sex 06 Mar
2015 11:55:00 BRT
file-devel-5.19-7.26.amzn1.x86_64 Sex 06 Mar
2015 11:55:00 BRT
Para saber a qual pacote um arquivo pertence:
# rpm {—qf arquivo }
Exemplo:
# rpm -qf /usr/bin/htpasswd

httpd24-tools-2.4.10-15.58.amzn1.x86_64
Para saber informações de um determinado pacote instalado:
# rpm {—qi nome_do_pacote }
Exemplo:
# rpm -qi httpd24

Name : httpd24
Version : 2.4.10
Release : 15.58.amzn1
Architecture: x86_64
Install Date: Sex 13 Fev 2015 21:56:14 BRST
Group : System Environment/Daemons
Size : 3792099
License : ASL 2.0

00445518006
Signature : RSA/SHA256, Qui 12 Fev 2015 17:35:50 BRST, Key

ID bcb4a85b21c0f39f
Source RPM : httpd24-2.4.10-15.58.amzn1.src.rpm
Build Date : Qui 12 Fev 2015 14:43:53 BRST
Build Host : build-64003.build
Relocations : (not relocatable)
Packager : Amazon.com, Inc. <http://aws.amazon.com>
Vendor : Amazon.com
URL : http://httpd.apache.org/
Summary : Apache HTTP Server
Description :
The Apache HTTP Server is a powerful, efficient, and
extensible web server.
Para verificar a integridade dos arquivos instalados com o banco de dados

de pacotes:
# rpm {—Va }
Exemplo:
# rpm -Va
S.5....T. c /etc/sysconfig/svnserve
....L.... c /etc/localtime
..?...... /usr/sbin/glibc_post_upgrade.x86_64
S.5....T. c /etc/httpd/conf/httpd.conf
..?...... /usr/sbin/suexec
As opções de consulta de informações de pacotes mais frequentes são:
-a Lista todos os pacotes instalados no sistema;

-f arquivo: Lista o nome do pacote que contém o arquivo procurado;
-p nomedopacote: Mostra se um determinado pacote está instalado;
-i nomedopacote: Mostra informações extras sobre um determinado pacote;
-l nomedopacote: Mostra a lista dos arquivos que um pacote contém;
-R nomedopacote: Mostra a lista de dependências que um pacote necessita
para ser instalado.
As opções de instalação e atualização de pacotes mais frequentes são:

- 00445518006
Prof. Uirá Ribeiro
--force: Esta opção força a instalação de um pacote e seus arquivos mesmo se

ele já estiver instalado. Esta opção inclusive força a instalação de um pacote
mais antigo por cima de um mais novo;
-h: Esta opção mostra o progresso da instalação;
---nodeps: Esta opção desabilita a checagem de dependências para a
instalação de um pacote;
-v: Mostra informações extras durante a instalação e atualização dos pacotes;
-vv: Mostra muito mais informações durante a instalação e atualização dos
pacotes. Geralmente utilizada por desenvolvedores.
As opções de desinstalação dos pacotes são:
--nodeps: Desabilita a checagem de dependências, desinstalando o pacote

mesmo que ele seja necessário por outros;
--test: Testa a remoção do pacote, sem de fato removê-lo. É útil para testar se
a remoção do pacote vai causar algum dano ao sistema ou aplicativo.
Prefira ao atualizar um pacote por uma versão mais nova utilizar o modo –U. Assim o
pacote mais antigo será removido, o pacote novo será instalado e as configurações
serão mantidas.
Como você pode ver, o uso do rpm é complicado a primeira vista, e pouco prático, já
que o administrador precisa baixar os pacotes e instalar as dependências de forma
manual.
yum
# yum [opções] [comando] [nome do pacote]
Devido a dificuldade de se lidar com gerenciamento de pacotes utilizando o comando

rpm, as distribuições Linux baseadas em Red Hat usam o utilitário yum.
O Yum é um acrônimo para Yellow dog Updater, Modified. É uma ferramenta utilizada
para gerenciar a instalação e remoção de pacotes em distribuições Linux, que utilizam
o sistema RPM.
O Yum é um gerenciador de pacotes de arquivos similar ao APT-GET que lida

automaticamente com dependências computando-as e resolvendo o que deve ser
feito para tratá-las.
Ele possui um arquivo de configuração que especifica quais os repositórios que o YUM
deve utilizar para procurar e baixar os pacotes RPM.
Nem sempre um Linux baseado em RPM terá o gerenciador de pacotes YUM instalado.
Se for necessário instalar o YUM, ele pode ser conseguido no site
http://yum.baseurl.org.

00445518006
O comando para instalação é:
# rpm -ivh yum.rpm
Repositórios no Yum
O YUM também permite que repositórios de software sejam customizados no arquivo
de configuração yum.conf.
Exemplo do /etc/yum.conf
[main]
cachedir=/var/cache/yum/$basearch/$releasever
keepcache=0
debuglevel=2
logfile=/var/log/yum.log
exactarch=1
obsoletes=1
gpgcheck=1
plugins=1
installonly_limit=5
distroverpkg=centos-release
[fedora-us-3-core]
name=Fedora Core 3 — Fedora US mirror
baseurl=http://SERVERNAME/fedora/fedora/$releasever/$basear
ch/RPMS.os
[fedora-us-3-updates]
name=Fedora Core 3 Updates — Fedora US mirror
baseurl=http://SERVERNAME/fedora/fedora/$releasever/$basear
ch/RPMS.updates
Além do arquivo de configuração /etc/yum.conf, o YUM permite que você coloque

arquivos de configuração de repositórios no diretório /etc/yum.repos.d/. Neste
diretório ficam as configurações de cada repositório.
Os arquivos deste diretório tem a extensão ".repo".
$ ls -l /etc/yum.repos.d/
-rw-r--r--. 1 root root 1664 Ago 13 2018 CentOS-Base.repo
-rw-r--r--. 1 root root 630 Ago 13 2018 CentOS-Media.repo

- 00445518006
Prof. Uirá Ribeiro
Você pode adicionar repositórios extras ou de software em “beta-teste” na lista de

repositórios do YUM.
Um arquivo de repositório geralmente tem um nome e aponta para uma URL na

Internet. Veja o arquivo CentOS-Base.repo:
[base]
name=CentOS-$releasever - Base
mirrorlist=http://mirrorlist.centos.org/?release=$releasever
&arch=$basearch&repo=os&infra=$infra
#baseurl=http://mirror.centos.org/centos/$releasever/os/$bas
earch/
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-7
Alguns comandos do yum:
yum list: Lista todos os pacotes disponíveis;

yum check-update ou yum list updates: Verifica se há pacotes disponíveis
para um update;
yum update: Faz o update de seu sistema;
yum install <pacote(s)>: Instala um pacote específico e suas dependências;
yum remove <pacote(s)>: Remove um pacote específico
yum info <pacote>: Apresenta informações básicas de um determinado
pacote.
yum whatprovides arquivo: Lista todos os pacotes que possuem o arquivo
indicado na busca
Veja os exemplos:
Para instalar um pacote:
# yum install postgresql
Resolving Dependencies
Install 2 Package(s)
Is this ok [y/N]: y
Package(s) data still to download: 3.0 M

(1/2): postgresql-9.0.4-5.fc15.x86_64.rpm | 2.8 MB
00:11
(2/2): postgresql-libs-9.0.4-5.fc15.x86_64.rpm | 203 kB
00:00
------------------------------------------------------------

00445518006
------
Total 241 kB/s | 3.0 MB
00:12
Running Transaction
Installing : postgresql-
libs-9.0.4-5.fc15.x86_64 1/2
Installing : postgresql-9.0.4-5.fc15.x86_64
2/2
Uma opção do Yum é o "-y" que instala ou faz update de pacotes sem perguntar. Não
é muito indicado para produção.
Para fazer update dos pacotes instalados:
# yum update
Plugins carregados: priorities, update-motd, upgrade-
helper
amzn-main/latest
Resolvendo dependências
---> Executando verificação da transação
---> O pacote aws-cli.noarch 0:1.7.5-1.2.amzn1 será
atualizado
---> O pacote aws-cli.noarch 0:1.7.12-1.3.amzn1 será uma
atualização
---> Resolução de dependências finalizada
Dependências resolvidas
=========================================================
======
Package Arq. Versão Repo
Tam.
=========================================================
======
Instalando:
kernel x86_64 3.14.34-27.48.amzn1 amzn-
updates 16 M
Atualizando:
aws-cli noarch 1.7.12-1.3.amzn1 amzn-
updates 604 k
Resumo da transação
=========================================================

- 00445518006
Prof. Uirá Ribeiro
====== Instalar 1 Package

(+4 Dependent packages)
Upgrade 1 Package
Tamanho total do download: 16 M

Is this ok [y/d/N]:
Para remover um pacote:
# yum remove postgresql
Para procurar todos os pacotes com a palavra “firefox”:
# yum search firefox

Loaded plugins: langpacks, presto, refresh-packagekit
============== N/S Matched: firefox ======================
firefox.x86_64 : Mozilla Firefox Web browser
gnome-do-plugins-firefox.x86_64 : gnome-do-plugins for
firefox
mozilla-firetray-firefox.x86_64 : System tray extension for
firefox
mozilla-adblockplus.noarch : Adblocking extension for
Mozilla Firefox
mozilla-noscript.noarch : JavaScript list extension for
Mozilla Firefox
Name and summary matches only, use “search all” for

everything.
Para obter informações sobre um determinado pacote:
# yum info mysql

Plugins carregados: priorities, update-motd, upgrade-helper
newrelic
59/59
Pacotes instalados
Nome : mysql
Arquitetura : noarch
Versão : 5.5
Lançamento : 1.6.amzn1

00445518006
Tamanho : 0.0
Repo : installed
Do repositório : amzn-main
Sumário : MySQL meta package
URL : http://www.mysql.com
Licença : GPLv2 with exceptions
Descrição: MySQL is a multi-user, multi-threaded SQL
database server. MySQL is a
: client/server implementation consisting of a
server daemon (mysqld)
: and many different client programs and libraries.
The base package
: contains the standard MySQL client programs and
generic MySQL files.
Para ver todos os pacotes disponíveis no repositório do yum:
# yum list
Pacotes instalados
GeoIP.x86_64
1.4.8-1.5.amzn1 @amzn-main
GeoIP-devel.x86_64
1.4.8-1.5.amzn1 @amzn-main
PyYAML.x86_64
3.10-3.6.amzn1 installed
acl.x86_64
2.2.49-6.9.amzn1 installed
acpid.x86_64
1.0.10-2.1.6.amzn1 installed
alsa-lib.x86_64
1.0.22-3.9.amzn1 installed
apr.x86_64
1.5.0-2.11.amzn1 @amzn-
updates
(…)
Para saber a qual pacote um determinado arquivo pertence:
# yum provides /etc/sysconfig/nfs

Plugins carregados: priorities, update-motd, upgrade-helper
1:nfs-utils-1.2.3-39.15.amzn1.x86_64 : NFS utilities and
supporting clients and daemons for the kernel NFS server

- 00445518006
Prof. Uirá Ribeiro
Repo : amzn-main
Resultado a partir de:
Nome de arquivo : /etc/sysconfig/nfs
Para saber quais são os repositórios ativos no YUM:
# yum repolist
id do repo nome do repo status
amzn-main/latest amzn-main-Base 5.019
amzn-updates/latest amzn-updates-Base 1.085
newrelic/x86_64 New Relic packages 59
dnf
# dnf [opções] [comando] [nome do pacote]
A distribuição Linux Fedora fez o seu próprio gerenciador de pacotes baseado em Red
Hat, chamado DNF.
O DNF é um gerenciador de pacotes de software que instala, atualiza e remove

pacotes em distribuições Linux baseadas em RPM, muito parecido com o YUM.
Ele calcula automaticamente dependências e determina as ações necessárias para

instalar pacotes.
O DNF também facilita a manutenção de grupos de máquinas, eliminando a

necessidade de atualizar manualmente cada uma delas usando rpm.
Introduzido no Fedora 18, é o gerenciador de pacotes padrão desde o Fedora 22.
Para muitos o DNF ou "Dandified Yum" é a versão de próxima geração do Yum.
Ele mantém a compatibilidade da interface do Yum e define uma API rigorosa para
extensões e plugins. O fato dele possibilitar a instalação de plugins é muito bem
vinda, pois estes podem modificar ou ampliar os recursos do DNF e fornecer
comandos de interface adicionais.
Se o DNF não estiver instalado na sua distribuição baseado em Red Hat, você pode
fazê-lo usando o Yum:
# yum install dnf
Os comandos que o DNF aceita são bem parecidos com o Yum:
autoremove: remove um pacote e suas dependências (somente se não

00445518006
utilizadas por outros programas)

check: Verifica o banco de dados RPM e produz informações
check-update [nome do pacote]: Verifica se há atualizações dos pacotes
clean: Apaga os arquivos temporários dos repositórios
distro-sync: Faz upgrade ou downgrade dos pacotes para mantê-los iguais à
última versão do repositório
downgrade [nome do pacote]: faz o downgrade de um pacote
group [info] [install] [list] [remove] [upgrade]: Realiza comandos com
grupos de software
history: lista as transações realizadas
info [nome do pacote]: mostra informações sobre um pacote
install nome_do_pacote: instala um determinado pacote e suas
dependências
list: lista os pacotes instalados e disponíveis
provide [nome]: lista os pacotes que contém o nome buscado
remove nome_do_pacote: remove um determinado pacote
repolist: lista os repositórios conhecidos
upgrade [nome do pacote]: faz upgrade de um pacote ou de todos se o
nome do pacote não for especificado
Os exemplos de uso do DNF são muito parecidos com o YUM e a prova requer somente
conhecimento sobre o DNF.
1.3 Software open source e

licenciamento
A primeira coisa que se tem em mente quando se fala de Linux é o termo "Software
Livre", que é frequentemente associado a ideia de "sem custo". Mas, na verdade, o
Software Livre deve ser associado a "código aberto". E o que isso quer dizer, na
prática?
Estes termos se referem à forma de licenciamento do software. Como toda a criação

intelectual, o software pertence a seu criador, que detém os direitos de dizer o que
pode e o que não pode ser feito com ele.
Existem diversas formas do autor "dar a licença" para que as outras pessoas façam
uso do seu software. A forma comum, é a licença comercial, em que se permite o uso
do software, em troca de alguma compensação para o seu autor.
Esse era o modelo padrão da nascente indústria de software no início dos anos 80.
Quase na sua maioria o software produzido era proprietário. Os usuários podiam usar
os programas em troca de alguma acordo comercial, e de forma alguma tinham

- 00445518006
Prof. Uirá Ribeiro
acesso ao código-fonte, para realizar os aprimoramentos de que necessitavam.
Contra esse movimento, em 1983, um programador chamado Richard Stallman criou o

Projeto GNU, com o objetivo de desenvolver um sistema operacional totalmente livre
das amarras e contratos do software proprietário, com a bandeira de que qualquer um
poderia ter acesso ao código-fonte do seu sistema e fazer melhorias, e se quisesse
redistribuir o código alterado para toda a comunidade.
O Projeto GNU tinha como objetivo criar um sistema operacional baseado em UNIX,
que até então era um software proprietário do Bell Labs, mas composto inteiramente
de software livre. O termo "GNU" é um acrônimo recursivo, que significa "Gnu is Not
Unix".
O Projeto GNU foi capaz de criar muitos programas necessários a um sistema

operacional, tais como bibliotecas, compiladores, editores de texto, um shell Unix, e
até um sistema de janelas. Mas até 1989 o projeto não tinha sido concluído, faltando
as partes principais que era o desenvolvimento de drivers para acesso ao hardware e
um Kernel.
Graças as ferramentas e compiladores criados pelo projeto GNU - e a falta de um

Kernel - que o jovem Linus Torvalds criou o Linux em 1991.
Em 1985, envolto com o Projeto GNU, Stallman aprimorou a sua ideia de

licenciamento, e criou uma modalidade chamada "Software Livre", que em inglês é
"Free Software". Ele mesmo ressalta que o termo "free" ou "livre" se refere a
"liberdade", e não ao preço.
Para fomentar a sua ideia, Stallman criou em outubro do mesmo ano a "Free Software
Foundation", organização sem fins lucrativos para promover o desenvolvimento e uso
do software livre em todas as áreas da computação e apoiar o projeto GNU.
Em janeiro de 1989, a Free Software Foundation publica a primeira versão de uma

licença de software não restritiva, chamada de Licença Pública Geral GNU - GNU GPL.
A GNU GPL se baseia em quatro liberdades essenciais:
1. A Liberdade para usar o programa para qualquer propósito;

2. A Liberdade para modificar o programa;
3. A Liberdade para redistribuir cópias do programa original;
4. A Liberdade para modificar e melhorar versões do programa e disponibilizar
para o uso público.
Justamente para assegurar essas quatro liberdades, que os usuários precisam ter
acesso completo ao código do programa. Mas dar ao usuário acesso ao código-fonte
cria implicações comerciais, de forma que as empresas precisam encontrar outras
maneiras de faturar.
Isto porque, em termos práticos, os programas sob licença do GPL tem preço
praticamente nulo, uma vez que o usuário tem igual direito de revendê-lo. Desta
forma, as empresas que focam os seus negócios em software livre, trabalham na
venda de serviços, novas funcionalidades e suporte, e não na venda do software

00445518006
propriamente.
Seguindo na mesma linha, em 1998, com uma pegada mais comercial e de marketing,
entusiastas do movimento de software livre, Jon Maddog Hall e Eric S Raymond,
estabeleceram a Open Source Iniciative (OSI), para também promoverem e
incentivarem a aproximação de entidades comerciais com o software livre. Embora
com uma diferença filosófica, a FSF e a OSI tem os mesmos objetivos.
Copyleft
É importante dizer que as licenças de software livre são automaticamente transferidas
aos softwares modificados, as suas variantes e os seus derivados.
Esse princípio se chama "Copyleft" - em contraste aos direitos restritivos da

"Copyright". Desta forma, se um software livre é aprimorado, transferem-se os direitos
"generosos" e "livres" de uma licença de software livre para os seus derivados.
É este conceito que levou Steve Ballmer, ex-CEO da Microsoft, a chamar o Linux e o
seu licenciamento de "câncer", que atinge tudo que toca. Mas é exatamente essa a
beleza do Software Livre, que o faz crescer e melhorar de forma abundante em todo o
ecossistema da Internet: ninguém pode reter para si as melhorias que produz.
Neste sentido, criaram-se outras formas de licença de software livre que permitem
conectar componentes "não livres" componentes livres, como ocorre com as
bibliotecas e frameworks. A LGPL (Lesser General Public License), por exemplo,
permite essa abordagem.
Creative Commons
Todo esse conceito criado pelas licenças de software livre foi tão bem-sucedido, que
outras iniciativas foram criadas para levar o progresso tecnológico e disseminação de
conhecimento para outras áreas não tecnológicas. A iniciativa do Creative Commons é
uma das mais importantes, que "permitem o compartilhamento e reutilização da
criatividade e do conhecimento através de ferramentas legais gratuitas".
As licenças do Creative Commons é frequentemente utilizada no mercado editorial

com certo sucesso, fomentando a troca e a cooperação.
Modelos de Negócio OpenSource

Ao contrário do que possa pensar, há várias iniciativas de grande sucesso comercial e
monetário no modelo de Software Livre.
A pioneira e de maior sucesso é a Red Hat, que faturou 3 bilhões de dólares em 2019,
e foi vendida para a IBM por 34 bilhões de dólares. As suas receitas vieram de
contratos de desenvolvimento de recursos e de suporte.
Várias empresas também atuam no modelo dual de licenciamento. Possuem um

software com mais recursos, licenciado de forma proprietária, sem o código-fonte, e
uma versão mais simples, com distribuição do código-fonte, geralmente ofertada

- 00445518006
Prof. Uirá Ribeiro
gratuitamente para a comunidade.
Outra modalidade em grande crescimento é o software como serviço (SaaS), em que

um software é executado na nuvem, geralmente em ambiente web, e o cliente paga
pelo quanto utilizar da plataforma. Por exemplo, empresas de CRM cobram por cliente
atendido e empresas de contabilidade cobram por nota fiscal emitida.
Outro modelo criado para as startups é o crowdfunding, que coleta doações ou venda
de produtos por um preço mais barato, em sites específicos, no momento que os
criadores estão desenvolvendo seus produtos. O dinheiro coletado pode servir para
desenvolver a ideia, ou mesmo coloca-la em produção. Em troca, os doadores ou
compradores da primeira hora recebem descontos e benefícios exclusivos.
Ainda há o modelo de venda de consultoria para implantação do software livre, ou

mesmo de desenvolvimento por encomenda de extensões, ou características
específicas para clientes particulares.
Qualquer seja o modelo adotado, é importante que se saiba que muitos negócios ao
redor do mundo foram criados em torno da filosofia do software livre, e que a
liberdade não restringe a criação de negócios lucrativos.
1.4 Conhecimentos de TIC e o

trabalho com o Linux
No seu nascedouro o Linux era um simples shell no padrão Unix, e foi assim por muito
tempo. Era algo para feito por programadores para programadores, então ser
amigável e bonito não era um requisito importante.
Mas há 5 anos essa narrativa deu lugar a um sistema operacional bonito, com uma
variedade de ambientes gráficos e aplicativos de primeira, culminando numa
experiência Desktop completa, com tudo que um usuário inexperiente possa ter a mão
para trabalhar, se comunicar e divertir.
Sem dúvida uma das belezas do Linux é a sua pluralidade de ambientes gráficos para
todos os gostos, através de inúmeras distribuições e ainda assim manter toda a
conformidade de ser um sistema operacional padrão.
Ao longo do tempo diversos ambientes gráficos foram construídos para funcionar no

servidor de janelas do Linux.
Dentre eles, podemos citar os ambientes KDE, GNOME, XFCE e Cinnamon.
KDE
O KDE é uma grande comunidade de desenvolvedores desde 1996 que desenvolvem
um ambiente gráfico multiplataforma conhecido como KDE Plasma. Seu nome deriva

00445518006
de K Desktop Environment, e a letra "K" foi escolhida simplesmente porque vem

depois de "L" de Linux. O KDE e seus aplicativos são escritos com o framework Qt.
O objetivo da comunidade KDE é tanto providenciar um ambiente que ofereça os

aplicativos e funcionalidades básicas para as necessidades diária quanto permitir que
os desenvolvedores tenham todas as ferramentas e documentação necessárias para
simplificar o desenvolvimento de aplicativos para a plataforma.
O KDE se baseia no princípio da facilidade de uso e da personalização. Todos os

elementos do ambiente gráfico podem ser personalizados: painéis, botões das janelas,
menus e elementos diversos como relógios, calculadoras e miniaplicativos. A extrema
flexibilidade para personalização da aparência permite até que temas sejam
compartilhados pelos usuários.
O gerenciador de janelas KWin é responsável por fornecer uma interface gráfica

organizada e consistente, e barra de tarefas intuitiva.
Figura 3 - KDE Plasma com Tema OSX

- 00445518006
Prof. Uirá Ribeiro
Figura 4 - KDE Plasma outra variação estilo OSX
Figura 5 - KDE Plasma estilo Windows
GNOME
O GNOME (acrônimo para GNU Network Object Model Environment) é um projeto de
software livre para ambiente gráfico também multiplataforma com ênfase especial a
usabilidade, acessibilidade e internacionalização.
O Projeto GNOME é mantido por diversas organizações e desenvolvedores e faz parte

00445518006
do Projeto GNU. Seu principal contribuidor e mantenedor é a Red Hat.
O GNOME 3 é o ambiente gráfico padrão de grandes distribuições como Fedora, SUSE

Linux, Debian, Ubuntu, Red Hat Enterprise, CentOS e tantos outros.
Há ainda uma divisão do GNOME 2 conhecida como MATE, uma vez que a mudança no
ambiente do GNOME 2 para o GNOME 3 foi grande, e alguns usuários simplesmente
preferiram ficar com o ambiente mais parecido com o GNOME 2.
Criado por dois mexicanos em 1997, descontentes na época com a falta de software
livre para o Framework Qt, utilizado para desenvolvimento de aplicações para o KDE.
Desta forma, eles preferiram utilizar o GTK (Gimp Tool Kit) como framework padrão
para o desenvolvimento do GNOME, uma vez que este já era licenciado pela GPL.
O GNOME 1 e 2 seguiram a tradicional da área de trabalho com "barra de tarefas".
O GNOME 3 mudou isso com o GNOME Shell, com um ambiente abstrato onde a
alternância entre diferentes tarefas e desktops virtuais ocorre em uma área separada
chamada “Visão Geral”.
Figura 6 - GNOME 3 no CentOS

- 00445518006
Prof. Uirá Ribeiro
Figura 7 - GNOME 3 no Ubuntu
Figura 8 - MATE no Linux Mint
Xfce
Xfce é um ambiente de Desktop para sistemas operacionais Unix Like, como Linux e
BSD, fundado em 1996.

00445518006
O Xfce tem objetivo de ser leve, rápido e visualmente atraente. Ele incorpora a
filosofia Unix de modularidade e reutilização e consiste em partes separadas
empacotadas que, juntas, fornecem todas as funções do ambiente de trabalho, mas
podem ser selecionadas em subconjuntos para atender às necessidades e
preferências do usuário.
Como no GNOME, o Xfce é baseado no framework GTK, mas é um projeto totalmente

diferente.
Ele é muito utilizado em distribuições que tem a intenção de serem leves,

especialmente projetadas para rodar em hardware antigos.
O Xfce pode ser instalado em diversas plataformas UNIX, tais como NetBSD, FreeBSD,
OpenBSD, Solaris, Cygwin, MacOS X, etc.
Dentre as distribuições que usam o Xfce, podemos citar:
Linux Mint Xfce edition

Xubuntu
Manjaro
Arch Linux
Linux Lite
Figura 9 - Xfce no Linux Mint

- 00445518006
Prof. Uirá Ribeiro
Figura 10 - Xfce no Linux Manjaro
Cinnamon
O Cinnamon é um projeto de desktop gráfico derivado do GNOME 2, criado pelo
pessoal do Linux Mint. Sua experiência de usuário é muito parecida com o Windows
XP, 2000, Vista e 7, facilitando a curva de aprendizagem de usuários que tenham
migrado destes sistemas operacionais.
Figura 11 - Cinnamon no Linux Mint

00445518006
Linha de Comando
É importante dizer que mesmo com um ambiente gráfico bonito, prático e

diversificado, é na linha de comando que reside a força do Linux. Para os usuários
avançados, é no shell do sistema operacional que a mágica acontece, pois, o Linux
permite que o usuário faça o que quiser, com a facilidade de se alterar um arquivo. A
concatenação de comandos também permite criar verdadeiros canivetes suíços
computacionais.
O acesso ao terminal é simples e rápido. Basta procurar o aplicativo Terminal no

ambiente gráfico, ou apertar a sequencia de teclas Ctrl-Alt-F1...F2...F3.. para se ter
acesso ao terminal.
Usos do Linux na Indústria
Impossível falar de um ambiente computacional sem falar em virtualização e

contêineres. Os velhos CPD's nas empresas deram lugar a computação nas nuvens,
com ambientes flexíveis.
O termo computação na nuvem foi descrito pela primeira vez em 1997 em

documentos da ARPAnet, que foi a rede de computadores precursora da Internet como
conhecemos. Ele foi designado para representar uma grande rede de servidores
interconectadas e dispersas geograficamente, de modo que cada ambiente é auto-
suficiente e independente.
Popularizado por grandes empresas como a Amazon Web Services (AWS), Microsoft
Azure e Google Cloud Platform, o termo computação em nuvem serve atualmente
para designar computação distribuída, onde recursos computacionais são
compartilhados e distribuídos para completar uma determinada tarefa ou aplicação.
O Linux é perfeitamente adaptável a esse tipo de ambiente computacional, que

parece que foi feito para ele, em uma simbiose perfeita.
Apesar de ter acesso a hardware cada vez mais eficiente e poderoso, as operações
executadas nos servidores físicos tradicionais - ou bare-metal - inevitavelmente
enfrentam limites práticos significativos.
O custo e a complexidade da criação e do lançamento de um único servidor físico

significam que adicionar ou remover efetivamente recursos para atender rapidamente
às demandas é difícil ou, em alguns casos, impossível. Some o custo do servidor, com
custo de energia e refrigeração. Custo de link de Internet e ainda de segurança de um
bom firewall.
Testar com segurança novas configurações ou aplicativos completos antes do

lançamento também pode ser complicado, caro e demorado.
Neste sentido a computação evoluiu para fornecer servidores virtuais, que podem ser
criados ou destruídos em poucos segundos, ou mesmo ter a capacidade de aumentar

- 00445518006
Prof. Uirá Ribeiro
e diminuir rapidamente seu poder computacional.
Isto fornece um diferencial ímpar para as aplicações corporativas, que devem atender
às necessidades de negócios em constante mudança.
A virtualização de máquinas envolve as seguintes premissas:
Acesso do software aos recursos e drivers de hardware de forma indistinguível

de uma experiência não virtualizada;
Deve permitir o controle completo do cliente sobre o hardware do sistema
virtualizado.
Permitir que os recursos físicos de computação, memória, rede e
armazenamento (“núcleo quatro”) sejam divididos entre várias entidades
virtuais.
Cada dispositivo virtual é representado em seus ambientes de software e
usuário como uma entidade real e independente.
Configurados corretamente, recursos praticamente isolados podem fornecer
aplicativos mais seguros sem conectividade visível entre ambientes.
A virtualização também permite que novas máquinas virtuais sejam
provisionadas e executadas quase instantaneamente e depois destruídas
assim que não forem mais necessárias.
O tipo de adaptabilidade que a virtualização oferece ainda permite que scripts

adicionem ou removam máquinas virtuais em segundos ... em vez das semanas que
demoram para comprar, provisionar e implantar um servidor físico.
Virtualização como motor da inovação

Em essência, a virtualização aumenta a flexibilidade, dissociando um sistema
operacional e os serviços e aplicativos suportados por esse sistema a partir de uma
plataforma de hardware físico específica. Permite o estabelecimento de vários
ambientes virtuais em uma plataforma de hardware compartilhada.
As organizações que desejam inovar descobrem que a capacidade de criar novos

sistemas e serviços sem instalar hardware adicional (e derrubar rapidamente esses
sistemas e serviços quando não forem mais necessários) pode ser um impulso
significativo à inovação.
Entre as abordagens possíveis estão o rápido estabelecimento de sistemas de

desenvolvimento para a criação de software personalizado, a capacidade de
configurar rapidamente ambientes de teste, a capacidade de fornecer soluções
alternativas de software e compará-las sem grandes investimentos em hardware,
suporte a prototipagem rápida e ambientes de desenvolvimento ágil, e a capacidade
de estabelecer rapidamente novos serviços de produção sob demanda.
Modelos de Computação em Nuvem

Os recursos computacionais em computação distribuída podem ser comercializados

00445518006
em três modelos diferentes. Os grandes Players geralmente oferecem os três

modelos, a gosto do cliente.
Infraestrutura como Serviço (IaaS)
No modelo de Infraestrutura como Serviço, os provedores de computação em nuvem

oferecem recursos de "baixo-nível", com todos os componentes que um servidor físico
é capaz de prover, como tempo de CPU, espaço de memória, armazenamento,
serviços de rede, etc. Neste modelo, o cliente é responsável por administrar o sistema
operacional, bem como todas as aplicações que este sistema operacional vai
executar.
Por exemplo, a Amazon Web Services (AWS) oferece neste modelo suas instâncias
EC2, de forma que o cliente escolhe a CPU, Memória, Armazenamento e qual sistema
operacional virá pré-instalado. Toda a manutenção do sistema operacional, bem como
as aplicações são de responsabilidade do cliente.
Neste modelo você paga pelo que utiliza, pelo tempo que utiliza. Isto permite uma
grande flexibilidade de adaptação e mudança do ambiente computacional.
Instâncias de máquina virtual
É como são chamadas as máquinas virtuais em ambientes de cloud computing. É

possível definir no momento da criação a CPU, Memória e Discos da máquina
desejada, bem como tipo e versão de sistema operacional. Alguns ambientes ainda
permitem alterar o hardware virtual da instância em funcionamento.
Este tipo de ambiente ainda permite personalizar as máquinas virtuais ao gosto do

cliente, bem como criar clones de VM's aos montes se necessário.
Instâncias e opções de armazenamento
Por padrão, cada instância tem um disco permanente de inicialização pequeno que
contém o sistema operacional.
Se precisar de mais espaço de armazenamento nos aplicativos em execução na

instância, basta adicionar outros discos. Várias opções são possíveis, desde HDs em
disco, armazenamento de backup, discos SSD e outras opções de armazenamento de
alta capacidade e baixa latência e grande redundância.
Instâncias e redes
Os ambientes virtuais em cloud computing permitem ainda a criação de redes virtuais

privadas entre as instâncias e também entre instâncias e alguma outra rede na
Internet, garantindo a privacidade e conectividade.
Instâncias e contêineres
Os players de Cloud Computing também fornecem instâncias otimizadas para criação

de contêineres Docker ou Kubernetes, com gerenciamento fácil dos contêineres.
Ferramentas para gerenciar instâncias

- 00445518006
Prof. Uirá Ribeiro
É possível criar e gerenciar instâncias usando várias ferramentas do Player escolhido,

bem como um conjunto de API's que permitem uma customização do ambienten
computacional e também ferramentas de linha de comando.
Plataforma como Serviço (PaaS)
No modelo de Plataforma como Serviço, existe uma pequena variação do modelo

anterior, de forma que o provedor de serviços é responsável por administrar o sistema
operacional, e mantê-lo funcionando com as atualizações, correções e segurança.
Por exemplo na AWS, os serviços de Lightsail são um exemplo de PaaS. O usuário

escolhe a capacidade computacional da instância e o tipo de aplicação que ela vai
executar, como Apache Web Server, Nginx Web Server, bem como a pilha de
aplicativos que vai executar, tais como Wordpress, Magento, Drupal, Joomla, Redmine,
Plesk, Node.Js, etc.
Software como Serviço (SaaS)
No modelo Software como Serviço, o provedor fornece e é responsável por tudo, de

forma que o cliente tem acesso a aplicação, sem a necessidade de se preocupar nem
com o software que está sendo executado. Esse é o modelo vendido por diversas
empresas, que prestam algum serviço, através de suas aplicações.
Por exemplo na AWS, temos o RDS (Relational Database Service), que provê serviços
de banco de dados relacionais como MySQL, Aurora, PostgreSQL, MariaDB, Oracle
Database e SQL Server. O cliente não precisa se preocupar com o sistema operacional,
nem mesmo com a administração do banco de dados. Ele simplesmente acessa o
banco.
Privacidade e Segurança na
Internet
Como grande parte dos aplicativos e serviços computacionais está na Web, e se

transferindo rapidamente para os Apps em dispositivos móveis, é importante que o
usuário saiba algumas premissas básicas de navegação, criptografia e políticas
adequadas de senhas.
Esta questão de proteção do usuário enquanto navega da rede ficou tão importante,
que muitos legisladores criaram leis específicas de proteção a dados, aos quais as
empresas devem observar, e proteger o direito a privacidade das pessoas.
A primeira questão está no rastreamento de cookies. Os Cookies são pequenos

arquivos salvos no computador do usuário pelo navegador, que contém alguma
informação que possa ser útil posteriormente. Os sites de e-coommerce utilizam muito
esta estratégia para marcar buscas de usuários por produtos e carrinhos
abandonados. Com isso, é possível fazer o que se chama de "remarketing" com os
usuários, de forma a impacta-los em diversos sites.

00445518006
É importante que os usuários tenham consciência de que podem utilizar um

gerenciador de cookies, de forma a autorizar ou não os coockies que os sites
demandam.
Outra forma de utilizar a Internet sem ser rastreado é utilizar o modo anônimo dos
navegadores. Esta forma de navegação somente evita que os cookies armazenados
previamente sejam lidos, tornando as sessões anônimas, e sem gravar o histórico de
sites acessados. O modo anônimo não mascara o endereço IP do cliente, de forma que
ainda assim é possível que o site seja capaz de rastrear o acesso.
Senhas
Uma boa política de senhas é importante para prevenir os ataques de força bruta,
bem como a adivinhação de senhas. Uma boa política de senhas leva em conta as
seguintes observações:
mínimo de 8 caracteres;
utilizar letras maiúsculas e minúsculas;
utilizar números;
utilizar caracteres especiais;
não reutilizar senhas em todos os sites;
não anotar as senhas em papel;
não utilizar nomes de entes queridos ou datas de aniversário;
trocar as senhas de tempos em tempos;
deixar as senhas de banco únicas;
utilizar tokens de autenticação de dois fatores quando disponível;
Neste quesito, o usuário também pode utilizar algum software de criptografia de

senhas. Os próprios navegadores proveem este serviço para as senhas de Internet.
Em uma visão extrema, o mundo pode ser visto como apenas

conexões, nada mais.
— Tim Berners-Lee

- 00445518006
Prof. Uirá Ribeiro
Tópico 2: Encontrando seu

caminho em um Sistema Linux
Os problemas do mundo real são principalmente aqueles com os

quais você fica quando você se recusa a aplicar suas soluções
eficazes.
-- E. W. Dijkstra

00445518006
2.1 As bases da linha de comando
A Linha de Comandos
Entrar com comandos no shell é mais do que simplesmente digitá-los.
Primeiro, o comando precisa ser válido e estar nos diretórios listados na variável PATH
ou com sua localização explícita. O comando também pode requerer opções,
geralmente precedidos pelo símbolo “-” ou “--” e por argumentos. O importante é que
cada comando tem sua sintaxe única e pode haver variações dependendo da
distribuição do Linux.
Vejamos alguns exemplos simples com o comando ls:
$ ls
Este comando lista os arquivos no diretório corrente. Ele não requer nenhuma opção
ou argumento para ser executado. O argumento –l pode ser acrescentado para gerar
uma lista de arquivos detalhada:
$ ls –l
Podemos ainda colocar mais opções para o comando ls:
$ ls –l –a –t
Ou
$ ls –lta
No caso do comando ls, as opções podem ser passadas separadamente ou

combinadas. A opção –a mostra todos os arquivos incluindo os ocultos. A opção –t
mostra os arquivos ordenados pela última data de modificação. A ordem das opções
não é importante para o ls.
Para ocultar um arquivo no Linux, o seu nome deve necessariamente começar com o
símbolo “.” (ponto). Ex: .bash_history
Para alguns comandos as opções têm de ser precedidas com dois traços “--” ao invés
de um traço. Ainda, alguns comandos oferecem formas alternativas de indicar uma
mesma opção. No caso do ls, as opções –a e --all produzem o mesmo efeito. O detalhe
é que opções que são chamadas com dois traços não podem ser combinadas.

- 00445518006
Prof. Uirá Ribeiro
$ ls –lt --all
E não:
$ ls --lalllt
Alguns comandos podem aceitar argumentos como opcional. Para outros comandos os
argumentos são necessários. Os argumentos são os parâmetros que os comandos
aceitam ou necessitam. Vejamos o comando ls:
$ ls –l *.txt
No exemplo acima o comando ls recebeu a opção –l e o argumento *.txt que filtra os

arquivos terminados com a extensão .txt.
Outra variação possível são os comandos que precisam obrigatoriamente de uma

opção para executar uma tarefa que geralmente não é precedida pelo traço. É comum
para esse tipo de comando que suas opções sejam sucedidas por argumentos. Veja
como exemplo o comando dd:
$ dd if=bootdisk.img of=/dev/fd0
O comando dd copia e converte arquivos de acordo com as opções passadas. No

exemplo, o comando irá ler uma imagem de um disco de boot (opção if=bootdisk.img)
e irá gravar esta imagem no drive a: (opção of=/dev/fd0).
Quase todos os comandos aceitam a opção –-help que mostra uma ajuda simples das
opções e argumentos aceitos pelo comando.
É importante que você tenha em mente que o Linux somente vai executar os
comandos que sejam internos do interpretador, ou comandos cuja localização esteja
na variável PATH ou comandos chamados com o seu caminho explícito.
$ ls
Ou
$ /bin/ls
No exame é muito importante que você esteja bem familiarizado com os comandos
listados neste capítulo e sua sintaxe. Portanto você precisa saber quando o comando
aceita opções com um traço, dois traços ou nenhum traço.
O Bash também permite que você entre com uma sequência de comandos em uma
mesma linha. Para isso você deve separar os comandos com o símbolo ; (ponto e
vírgula).

00445518006
$ echo $PS1; echo $PS2
O Bash escreve em um arquivo chamado .bash_history localizado no diretório home de

cada usuário o histórico de todos os comandos digitados pelos usuários. A
possibilidade de recuperar os comandos digitados é fabulosa. Isto pode ser bastante
útil para fins de auditoria, relembrar a memória ou simplesmente economizar os
dedos.
Você poderá ver os comandos que digitou visualizando o conteúdo do arquivo

.bash_history.
$ cat ~/.bash_history
O comando cat, dentre outras coisas, serve para visualizar o conteúdo dos arquivos.
O símbolo “~” faz referência ao diretório home do usuário

logado.
Variáveis de Shell
O primeiro contato do usuário com o shell do Linux é o prompt de comandos.
Como este prompt de comandos se apresenta pode mudar em cada distribuição,

desde o mais simples, com um simples "$" ou com informações de usuário, nome do
servidor e até mesmo o diretório corrente:
[uira@server1 ~]$
O prompt de comandos pode ser personalizado através da configuração de uma

variável que o shell do Linux mantémm chamada de PS1.
As variáveis são carregadas no início da execução do bash e também podem ser

configuradas manualmente em qualquer momento.
A primeira variável que iremos abordar é a PS1 ou simplesmente Prompt String 1.
Esta variável guarda o conteúdo do prompt de comandos do bash quando ele está
pronto para receber comandos.
Existe também a variável PS2 que guarda o conteúdo do prompt de comandos quando
são necessários múltiplas linhas para completar um comando.

- 00445518006
Prof. Uirá Ribeiro
Estas duas variáveis do shell não afetam como o interpretador irá processar os
comandos recebidos, mas podem ser de grande ajuda quando carregam informações
extras como nome do usuário, diretório corrente, etc.
Convencionou-se que as variáveis são todas escritas em caixa-alta. Mas é importante

que você saiba que $nome e $NOME são duas variáveis diferentes para o shell.
O conteúdo de qualquer variável do Shell poderá ser visualizado com o comando echo
sucedido pelo símbolo $ mais o nome da variável:
$ echo $PS
\$
O caractere \ diz que qualquer outro caractere que o sucede deve ser interpretado
exatamente como ele é e não processado pelo shell. Ele é o que chamamos de
metacaractere.
É comum que o prompt de comandos padrão do bash venha no formato: \u@\h:\W\$
Os comandos e variáveis no Linux são sensíveis às letras maiúsculas e minúsculas.

Cada um destes caracteres é interpretado de forma especial.
O \u é utilizado para representar o nome do usuário, o \h é utilizado para representar o

nome do sistema (hostname) e o \W é o diretório corrente.
Um exemplo para este prompt é: uira@notebook:home$
Outra variável importante do Shell é o PATH. O path guarda uma lista dos diretórios
que contêm os programas que você poderá executar sem precisar passar na linha de
comandos o caminho completo de sua localização.
$ echo $PATH
/sbin:/bin:/usr/sbin:/usr/bin
É importante que você saiba que o interpretador de comandos do bash acompanha a

seguinte ordem para achar e executar os comandos digitados:
1. O comando digitado é um comando interno do interpretador de comandos?

2. Se não for, o comando é um programa executável localizado em algum diretório
listado na variável PATH?
3. A localização do comando foi explicitamente declarada?
Uma dica interessante é incluir “:.” no final da variável PATH para que o bash inclua o
diretório corrente na sua lista de busca por programas executáveis.
Diferentemente do MS-DOS, o diretório corrente não está incluso na lista de busca

padrão. Sem incluir o “:.” no PATH é necessário informar o caminho relativo ao chamar
programas no diretório corrente com “./nomedoprograma”.
Isto é um problema para usuários novatos no Linux que não entendem porque ao

00445518006
digitar um comando ou tentar rodar um programa que está na pasta corrente não
funciona na maioria das vezes. Simplesmente é a falta que o ":." faz no $PATH.
Uma lista completa das variáveis do shell poderá ser obtida com o comando:
$ set
Você poderá também alterar ou criar uma nova variável do shell através do comando:
$ LIVRO=”Certificação Linux”
Preferencialmente as variáveis devem ser declaradas em caixa alta e não coloque

espaços entre o nome da variável, o símbolo = e o seu conteúdo.
Se o conteúdo for alfanumérico é desejável que ele esteja entre aspas simples ou
duplas.
Quando o texto de uma variável é uma sequência comum de letras e números, pouco
importa se você vai usar aspas simples ou duplas.
$ FRASE1=”Este é um teste”
$ FRASE2='de direfença entre aspas'
$ echo $FRASE1 $FRASE2
Este é um teste de diferença entre aspas
Mas se você for utilizar as variáveis entre aspas, há diferença:
$ echo “$FRASE1 $FRASE2”

Este é um teste de diferença entre aspas
$ echo '$FRASE1 $FRASE2'

$FRASE1 $FRASE2
Então as aspas duplas expandem o conteúdo das variáveis, enquanto as aspas

simples não. Isto faz diferença se você quer, por exemplo, incluir um diretório na
variável PATH:
$ echo $PATH
/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin:/opt/aws/bi
n:/home/ec2-user/bin
$ PATH="$PATH:/ora/oracle/admin/bin"
$ echo $PATH
/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin:/opt/aws/bi
n:/home/ec2-user/bin:/ora/oracle/admin/bin
Neste caso as aspas simples não funcionariam.

- 00445518006
Prof. Uirá Ribeiro
Depois de criar uma variável do shell, é preciso exportá-la para o ambiente com o
comando export.
Quando uma variável é exportada para o ambiente ela fica disponível para todos os
processos filhos do shell (todos os programas e aplicações que você executar no
bash).
Cada vez que um programa é executado pelo shell, ele somente irá receber as
variáveis criadas pelo shell se elas forem exportadas com o comando export.
Assim o processo filho (o programa que desejamos executar) vai herdar do processo
pai (o shell) as variáveis criadas.
Veja o exemplo abaixo, onde criamos uma variável chamada LIVRO:
$ LIVRO=”Certificação Linux”
$ echo $LIVRO
Certificação Linux
Se executarmos o bash novamente no mesmo terminal, para criar um processo filho,

você verá que a variável LIVRO não existe, porque ela não foi exportada para os
processos filho:
$ bash
$ echo $LIVRO
Uso de Coringas
Quando estamos trabalhando com arquivos e diretórios no shell é muito comum
precisarmos trabalhar com diversos arquivos de uma vez. Para tornar este tipo de
tarefa mais simples, o Linux oferece o recurso de coringa para os nomes dos arquivos
e diretórios.
Assim como no baralho de cartas, os coringas são símbolos que podem significar
muitas coisas. No Linux possibilitam que você os utilize como parte do nome dos
arquivos e diretórios. Veja a tabela abaixo:
Símbolo Descrição
* Significa “vale qualquer coisa” e pode substituir um ou mais caracteres de um nome.

Por exemplo “Certifi*” pode significar “Certificado”, “Certificação” ou qualquer outra
combinação de nomes de arquivos que inicie com “Certifi”.
? Significa que pode substituir um caractere somente de um nome. Por exemplo:

“?ertificado” pode substituir “Certificado”, “certificado” ou qualquer outra
combinação de nomes de arquivos que inicie com um caracter qualquer e termine
com “certificado”.

00445518006
{texto1, Substitui a parte dentro das chaves pelos texto1, depois pelo texto2, assim por
texto2...} diante. Por exemplo: “parte_{a,b,c}” vai resultar em “parte_a”, “parte_b” e
“parte_c”.
Exemplos:
$ ls *.txt
Lista todos os arquivos com o sufixo .txt
$ cat doc??? >> documentos
Concatena todos os arquivos iniciados com “doc” que tenham 6 caracteres de

tamanho no arquivo documentos.
Vejamos os comandos para listar os comandos digitados, exportar variáveis e verificar

se um termo é comandos.
history
$ history [número]
O comando history serve para listar o conteúdo do ~/.bash_history do usuário logado,

e enumera as linhas do histórico de comandos.
Você pode passar como parâmetro a quantidade de linhas que você quer ele ele
mostre desde o último comando digitado:
$ history 10
564 cd ..
565 ll
566 cp cadastro.php cadastro_livro.php
567 sudo cp cadastro.php cadastro_livro.php
568 sudo vi cadastro_livro.php
569 mv geralivro.php geraflivro.php
570 sudo mv geralivro.php gerarlivro.php
571 cat grava.php
Você também pode usar o history com o grep para filtrar os comandos:

- 00445518006
Prof. Uirá Ribeiro
$ history | grep ssh

144 history |grep ssh
145 ssh uira@192.30.0.105
148 ssh uira@172.30.0.107
Ao saber o número da linha que você quer usar novamente, basta colocar exclamação
seguido do número da linha correspondente:
$ !144
ssh -i uribeiro.pem ec2-user@172.30.0.107
Last login: Thu Sep 12 09:51:33 2019 from 172.30.0.241
O comando history tem algumas opções a saber:
-c Limpa a lista do histórico

-d x Apaga a linha de número x
-a Adiciona os comandos da sessão corrente do bash ao arquivo de
histórico
O bash também oferece outras possibilidades de trabalho com o histórico de

comandos:
Atalho Descrição
!! Executa o último comando digitado
!n Executa o comando na linha n no arquivo .bash_history
!texto Executa o comando mais recente que inicia com o texto
!?texto Executa o comando mais recente que contém o texto
^texto1^texto2 Executa o último comando substituindo o texto1 pelo texto2
Alt M < Vai para o início do arquivo .bash_history
Alt M > Vai para o fim do arquivo .bash_history
Ctrl p Recupera os comandos armazenados no arquivo .bash_history de trás para frente
Ctrl n Recupera os comandos já listados de frente para trás
Ctrl b Volta um caractere nos comandos já recuperados
Ctrl f Anda um caractere para frente nos comandos já recuperados
Ctrl a Volta para o início da linha nos comandos já recuperados
Ctrl e Vai para o fim da linha nos comandos já recuperados
Ctrl l Limpa a tela
Ctrl d Apaga caracteres do texto do cursor até o fim da linha
Ctrl k Apaga o texto do cursor até o fim da linha de uma só vez

00445518006
Atalho Descrição
Ctrl y Cola o texto apagado pelo comando anterior na tela
Ctrl rtexto Procura comandos que contenham o texto do último comando para o primeiro
Ctrl stexto Procura comandos que contenham o texto do primeiro comando para o último
Símbolo "CTRL" da tabela significa que você deve manter

pressionado a tecla Control do teclado e a tecla
correspondente. O mesmo vale para a tecla Alt.
Veja outros comandos auxiliares para trabalhar com eficiência no bash.
type
$ type palavra
O comando type é utilizado para descrever alguma nome informado como parâmetro,
como comando interno do bash, programa, função, apelido ou arquivo. Se nenhum
nome for informado, ele não faz nada.
Exemplos:
$ type bash
bash is /usr/bin/bash
$ type ll
ll is aliased to `ls -l --color=auto'
$ type for
for is a shell keyword
echo
$ echo parâmetro
O comando echo imprime algo na tela ou na saída padrão. Ele também pode ser usado
para imprimir os valores de variáveis.

- 00445518006
Prof. Uirá Ribeiro
Veja neste exemplo a diferença entre aspas simples e duplas:
$ echo "Bom dia"

Bom dia
$ NOME="Uirá"
$ echo "Bom dia $NOME"
Bom dia Uirá
$ echo 'Bom dia $NOME'

Bom dia $NOME
A saída do comando echo também pode ser redirecionada para um arquivo:
$ echo "Bom dia $NOME" > /tmp/arquivo

$ cat /tmp/arquivo
Bom dia Uirá
2.2 Como obter ajuda na linha de

comando
O Linux tem um conjunto de manuais que podem ser utilizados pelos usuários e
administradores para consultarem informações sobre os comandos em busca de
ajuda.
O Linux possui alguns canais de ajuda ao usuário, tais como:
Help dos comandos, com a opção "--help";

Páginas de informação com o comando "info";
Documentação do sistema em "/usr/share/doc";
Manuais através do comando "man";
Help dos Comandos

A maioria dos comandos possui uma pequena ajuda através da opção "--help", que
traz um pequeno manual:
$ free --help
Usage:
free [options]
Options:

00445518006
-b,--bytes show output in bytes

-k,--kilo show output in kilobytes
-m,--mega show output in megabytes
-g,--giga show output in gigabytes
--tera show output in terabytes
--peta show output in petabytes
-h, --human show human-readable output
--si use powers of 1000 not 1024
-l, --lohi show detailed low and high memory
statistics
-t, --total show total for RAM + swap
-s N, --seconds N repeat printing every N seconds
-c N, --count N repeat printing N times, then exit
-w, --wide wide output
--help display this help and exit
-V, --version output version information and exit
Utilizando as Páginas Info

Uma fonte interessante de consulta são as páginas info. Esta documentação foi
desenvolvida pelo projeto GNU e cobre grande parte das ferramentas do projeto.
Para ter acesso a esta documentação, é preciso utilizar o comando info seguido do
nome do comando desejado. Veja um exemplo, digitando o comando no shell:
# info test
O info possibilita a navegação entre os tópicos relacionados. Para navegar no info,

basta encontrar um “link” que é formado pelo símbolo “*” e uma palavra e apertar a
tecla enter.
Para passar para a próxima página do conteúdo, digite “N” (Next) e, para voltar, digite
“P” (Previous). A tecla “q” sai do info.
O comando info sem nenhum argumento lista todas as páginas existentes.
# info
Encontrando a Documentação em /usr/share/doc

O diretório /usr/share/doc possui grande parte da documentação de uma distribuição
Linux e diversos aplicativos na forma de HOWTOS, FAQs, arquivos README, guias de
instalação e manuais de usuário.

- 00445518006
Prof. Uirá Ribeiro
O subdiretório /usr/share/doc/howto possui quase 2000 páginas de documentação

detalhando passo a passo diversas tarefas.
Veja um exemplo:
3Dfx-HOWTO.html
AI-Alife-HOWTO.html
Acer-Laptop-HOWTO.html
Alpha-HOWTO.html
Bash-Prog-Intro-HOWTO.html
Benchmarking-HOWTO.html
Este tipo de documentação é útil quando não se sabe como começar uma
determinada tarefa ou quais ferramentas devem ser utilizadas.
No subdiretório /usr/share/doc/packages podem ser encontradas informações sobre

quase todos os pacotes de software instalado no sistema. Esta informação pode incluir
arquivos com conteúdos distintos como README, INSTALL, CHANGES, INFO, FAQ, etc.
Nem sempre os how-tos podem estar instalados na distribuição, e o seu caminho pode
ser diferente.
man
$ man [sessão] comando
O comando man oferece um manual de vários comandos do GNU Linux, bem como
manual de outros programas de terceiros. O man oferece uma interface simplificada
para os programadores oferecerem um manual de seus programas.
As páginas de manual acompanham quase todos os programas GNU/Linux e podem

ser instaladas de acordo com a língua escolhida, se estiver disponível na distribuição.
As informações do man são chamadas de "Páginas do Man" e elas trazem uma

descrição básica de comandos e detalhes sobre o funcionamento de suas opções.
Uma página de manual é visualizada na forma de texto único com rolagem vertical.
Também documenta parâmetros usados em alguns arquivos de configuração.
Os documentos do manual são divididos em sessões de acordo com o assunto

abordado. As sessões são numeradas de 1 a 9, a seguir:
1. Programas executáveis ou comandos de shell;

2. Chamadas do Sistema (funções fornecidas pelo Kernel);
3. Chamadas de Biblioteca (funções fornecidas pelas bibliotecas);

00445518006
4. Arquivos especiais, especialmente aqueles localizados em /dev;

5. Formatos de arquivos e convenções;
6. Jogos;
7. Pacotes Macro;
8. Comandos administrativos;
9. Rotinas do kernel.
É possível que uma mesma palavra possa referenciar a uma função de programação,
comando ou arquivo de configuração. Desta maneira é importante saber em qual
sessão iremos encontrar a documentação desejada.
Cada página do manual é dividida em partes:
NAME: Nome do item procurado com uma descrição curta;

SYNOPSIS: Descrição completa do uso e sintaxe;
DESCRIPTION: Descrição breve das funcionalidades;
OPTIONS: Descrição de cada opção e argumentos;
FILES: Uma lista de arquivos importantes;
SEE ALSO: Uma lista de itens relacionados ao procurado;
BUGS: Descrição de possíveis problemas com o item;
AUTHOR: Lista de pessoas responsáveis pelo item.
Para acessar o manual, o comando é o man seguido do item procurado. Como opção,
o número da sessão pode ser passada como parâmetro.
$ man passwd
Neste exemplo o man visualiza o manual do comando passwd, pertencente à sessão

1.
$ man 5 passwd
Já neste exemplo o man exibirá o manual do arquivo /etc/passwd.
A navegação dentro das páginas de manual é feita usando-se as teclas:
q Sai da página de manual;

PageDown ou f Rola 25 linhas abaixo;
PageUP ou w Rola 25 linhas acima;
SetaAcima ou k Rola 1 linha acima;
SetaAbaixo ou e Rola 1 linha abaixo;
r Redesenha a tela (refresh);
p ou g Início da página;

- 00445518006
Prof. Uirá Ribeiro
h Ajuda sobre as opções da página de manual;

s Salva a página de manual em formato texto no arquivo especificado.
locate
$ locate arquivo
Como Localizar Arquivos

O comando locate pode ser usado para encontrar arquivos no sistema através de um
banco de dados de arquivos que o comando locate mantém. Como ele faz a busca em
uma base de dados, o resultado é instantâneo. Porém, a base de dados precisa ser
atualizada de tempos e tempos para corresponder com a realidade.
Nem sempre o comando locate é instalado como padrão nas distribuições.
$ locate passwd
/etc/passwd
/etc/passwd-
/etc/pam.d/passwd
/etc/security/opasswd
/usr/bin/gpasswd
( ... )
find
$ find [caminho] [expressão]
O comando find procura por arquivos e diretórios no sistema de arquivos. Dependendo

do tamanho do sistema de arquivos, esse comando pode ser muito demorado.
Sua sintaxe básica é:
$ find [caminho] [expressão]
Você deve indicar um ponto de início da busca na árvore de diretórios do Linux. Se

quiser que ele comece no raiz, indique "/". Se quiser que a busca inicie a partir do
diretório corrente, use como caminho "./" ou simplesmente ".".
O find permite uma infinidade expressões como opções de busca, tais como nome,
tamanho, data de criação de arquivo, data de acesso, por tipo de arquivo, permissões,

00445518006
etc.
Exemplos:
Procura pelo arquivo texto.txt a partir do raiz (/), do tipo arquivo (f):
$ find / -name texto.txt -type f
Procura por todos os arquivos com extensão .txt a partir do diretório corrente (.):
$ find . -name “*.txt”
Procura pelo diretório “usuarios” a partir do diretório corrente, independente se está

escrito com letras maiúsculas ou minúsculas:
$ find . -iname usuarios -type d
Procura por arquivos que não terminam com .html a partir do diretório corrente:
$ find . -type f -not -name “*.html”
O find também permite executar um comando com a lista de arquivos que ele
encontrar. Neste exemplo o find copia todos os arquivos .mp3 encontrados a partir do
diretório corrente para /tmp:
$ find . -type f -name “*.mp3” -exec cp {} /tmp/ \;
Apaga todos os diretórios BACKUP encontrados a partir do diretório corrente:
$ find . -type d -name BACKUP -exec rm -r {} \;
Procura os arquivos modificados nos últimos 7 dias:
$ find . -mtime -7 -type f
Procura arquivos com permissão 0777:
$ find . -type f -perm 0777 –print
Procura todos os arquivos com mais de 50Mb:

- 00445518006
Prof. Uirá Ribeiro
$ find / -size +50M
2.3 Como usar diretórios e listar

arquivos
A necessidade de guardar informações em objetos que pudessem ser acessados

posteriormente de uma forma organizada vem de longe nos sistemas operacionais.
Para isso foram criados os sistemas de arquivos.
Nos sistemas de arquivos de uma forma geral, os objetos são organizados de uma
forma hierárquica e cada objeto possui uma identificação única dentro de uma tabela.
Como exemplo, vejamos o sistema operacional Windows da Microsoft: ele organiza

seus arquivos em uma partição nomeada como drive “C:\”, e nela temos o diretório
Windows, que contém o sistema operacional; o diretório “Arquivos de Programas”, que
contém a maioria dos produtos instalados, e assim por diante. Os arquivos ficam
divididos em diretórios e subdiretórios diferentes por uma questão de afinidade e
organização. Da mesma maneira temos uma organização no Linux.
A identificação dos objetos de um sistema de arquivo no Linux é conhecida como

inode. Ele carrega as informações de onde o objeto está localizado no disco,
informações de segurança, data e hora de criação e última modificação dentre outras.
Quando criamos um sistema de arquivos no Linux, cada dispositivo tem um número
finito de inodes que será diretamente proporcional ao número de arquivos que este
dispositivo poderá acomodar.
Basicamente no Linux tudo é um arquivo, que dependendo do seu tipo, pode se tornar
um arquivo comum, um diretório, um link, um socket, um condutor, um descritor de
dispositivos, etc.
Comparando com o Windows, a organização dos diretórios no Linux é um pouco mais

complexa. O sistema de arquivos no Linux é semelhante a uma árvore de cabeça para
baixo. No topo da hierarquia do Linux existe um diretório raiz nomeado simplesmente
como root e identificado como o sinal “/”. Não confunda diretório raiz (root) com o
superusuário root.
A estrutura do sistema de arquivos do Linux é definida por um padrão de mercado

chamado Filesystem Hierarchy Standard ou FHS, criado pela comunidade Linux em
1994 e mantida pela Linux Foundation. Atualmente a FHS está na versão 3.0. As
distribuições não são obrigadas a seguir este padrão, mas elas entendem a
importância da localização dos arquivos e diretórios padronizados.
Toda a estrutura de diretórios do sistema é criada abaixo do root:

00445518006
Figura 12 - FHS
/
Diretório raiz do sistema de arquivos;
/bin
Contêm os comandos que podem ser utilizados pelos usuários e pelo administrador do
sistema. São requeridos no modo monousuário ou de manutenção (single-user mode)
e também podem conter comandos que são utilizados indiretamente por alguns
scripts. Nele ficam os arquivos executáveis, tais como: cat, chgrp, chmod, chown, cp,
date, dd, df, dmesg, echo, hostname, kill, ln, more, mount, mv, ps, pwd, rm, rmdir,
sed, su, umount e uname;
/boot
Arquivos estáticos necessários à carga do sistema. É onde fica localizada a imagem do
Kernel, initramfs e alguns arquivos do Grub. Este diretório contém tudo que é
necessário para carregar o sistema, exceto os arquivos de configuração e o
gerenciador de boot. O /boot inclui o setor master de carga do sistema (master boot
sectors) e arquivos de mapa de setor.
/dev
Abstração do Kernel onde ficam os arquivos para acesso dos dispositivos do sistema,
como discos, cd-roms, pendrives, portas seriais, terminais, etc. Os arquivos são
descritores que facilitam o acesso aos dispositivos. Este diretório é um pseudo-
filesystem, e não existe no disco. Seu conteúdo, por exemplo, tem descritores de
dispositivos como /dev/sda, /dev/cdrom, etc.

- 00445518006
Prof. Uirá Ribeiro
/etc
Arquivos necessários à configuração do sistema. São necessários para a carga do
sistema operacional. Ele possui arquivos importantes tais como: fstab, exports,
passwd, shadow, group, hosts, hosts.allow, hosts.deny, inittab, ld.so.conf, mtab,
profile, services, etc. Nele também residem os arquivos de configuração nas interfaces
de rede.
Tipicamente /etc possui dois subdiretórios:
/etc/X11: Arquivos de configuração para a interface gráfica do Linux (X Window

System);
/etc/skel: Esqueletos da configuração usuários. No diretório /etc/skel ficam

localizados os arquivos de "modelo” para os usuários. O conteúdo deste diretório
é replicado para o diretório home dos novos usuários quando são criados no
sistema.
/home
Geralmente é neste diretório onde ficam os diretórios home dos usuários. Neste
diretórios localizam-se scripts de carga de perfil e do shell bash de cada usuário.
/lib
Arquivos de bibliotecas essenciais ao sistema, utilizadas pelos programas em /bin e
módulos do Kernel. É comum existir um diretório /lib[arquitetura]. Nos processadores
de 64 bits, existe o diretório /lib64. Nos processadores de 32 bits, deve existir um
diretório /lib32.
/mnt
Diretório vazio utilizado como ponto de montagem de dispositivos na máquina. Usado
pelo administrador para montar discos.
/media
Diretório vazio utilizado como ponto de montagem de dispositivos na máquina, tais
como cdrom, dvd, pendrives, etc.
/proc
Informações do Kernel e dos processos. É um pseudo-filesystem e não existe
realmente no disco. Neste diretório ficam as abstrações de descritores de tudo quanto
há no Kernel do sistema. É possível não só ler os dados, bem como fazer alterações no
comportamento do Kernel alterando o conteúdo de arquivos em /proc.

00445518006
/opt
Neste diretório ficam instalados os aplicativos que não são da distribuição do Linux,
como por exemplo, banco de dados de terceiros, software de vetores Cad, etc.
/root
Diretório home do superusuário root. Dependendo da distribuição pode estar presente
ou não;
/run
Este diretório contém informações do sistema desde a última carga. Os arquivos deste
diretório são apagados ou zerados no início do processo de boot. Arquivos como
aqueles que indicam o PID do processo em execução devem residir neste diretório.
/sbin
Arquivos essenciais ao sistema, como aplicativos e utilitários para a administração da
máquina. Normalmente só o superusuário tem acesso a estes arquivos, tais como:
fdiskm fsck, ifconfig, init, mkfs, mkswap, route, reboot, swapon e swapoff.
/tmp
Diretório de arquivos temporários. Em algumas distribuições este diretório é montado
em memória. Recomenda-se que seu conteúdo seja apagado de tempos em tempos
ou a cada reboot.
/usr
Arquivos pertencentes aos usuários e a segunda maior hierarquia de diretórios no
Linux. Seu conteúdo pode ser distribuído via rede para diversos sistemas Linux da
mesma distribuição sem problema algum. Ele tem alguns subdiretórios a saber:
/usr/bin: Ferramentas e comandos auxiliares de usuários, bem como

interpretadores de programação, como o perl, python, etc;
/usr/include: Cabeçalhos e bibliotecas da linguagem C;
/usr/lib e /usr/lib64: bibliotecas de aplicações de usuários;
/usr/libexec: binários que não são executados normalmente por usuários;
/usr/local: hierarquia de diretórios para instalação de aplicativos locais no

sistema. Possui vários subdirtórios como bin, etc, include, lib, man, sbin, share e
src;
/usr/sbin: contém ferramentas não essesnciais, mas exclusivas da

administração do sistema.

- 00445518006
Prof. Uirá Ribeiro
/usr/share: arquivos de somente leitura de arquitetura independente. São

arquivos que podem ser compartilhados entre distribuições de Linux iguais,
independente da arquitetura. O diretório man por exemplo é onde residem os
manuais dos comandos e fica em /usr/share.
/usr/src: pode conter arquivos de código fonte de programas.
/var
Diretório onde são guardadas informações variáveis sobre o sistema, como arquivos
de log, arquivos de e-mail etc. Possui subdiretórios importantes, a saber:
/var/cache: mantém informações de cache das aplicações como cálculos, etc;
/var/lib: mantém informações de estado das aplicações;
/var/lock: mantém arquivos de trancamento que retém dispositivos para uso

exclusivo de alguma determinada aplicação;
/var/log: mantém os arquivos de log do sistema, tais como messages, lastlog e

wtmp.
/var/mail: mantém os diretórios de contas de email dos usuários;
/var/opt: mantém os arquivos variáveis das aplicações;
/var/run: a funcionalidade deste diretório foi movida para o /run.
/var/spool: mantém dados de processos que mantém filas de arquivos, tais

impressão e saída de email;
/var/tmp: mantém os arquivos temporários das aplicações que precisem ser

preservados entre o reboot do sistema
Detalhes sobre os Arquivos e

Diretórios
Arquivos e Diretórios Escondidos

Para esconder os arquivos e diretórios no Linux, basta renomear o seu nome,
iniciando-o com um ponto ".".
Por exemplo, ao listar um conteúdo de uma pasta, o diretório "musicas" está presente:

00445518006
$ ls
arquivo musicas
Se renomearmos o diretório musicas, iniciando com um ".", ele não irá aparecer mais
na lista de arquivos e diretórios:
$ mv musicas .musicas
O comando "mv" serve para mover, ou renomear arquivos e diretórios.
Ao listar a pasta, o diretório "musicas" não irá aparecer:
$ ls
arquivo
Os arquivos e diretórios ocultos somente irão aparecer na listagem com a opção "-a"
do comando ls:
$ ls -a
. .. arquivo .musicas
Diretório Corrente e Diretório Anterior

Todo diretório no Linux possuem dois arquivos especiais, ocultos.
O primeiro arquivo é o ponto "."
Ele serve para referenciar o diretório corrente.
O segundo arquivo é o ponto-ponto ".."
Ele serve para referenciar o diretório anterior.
Desta forma, estes dois arquivos especiais servem para se fazer referência relativa
aos arquivos e diretórios do sistema. Chama-se relativa, porque a referência depende
do ponto de partida, do diretório corrente.
Em contraponto, uma referência absoluta, ou caminho completo, é a referência de um

arquivo ou diretório, tomando como base o diretório raiz "/".
Para se saber o diretório corrente, deve-se usar o comando "pwd".
Observe o diretório corrente:
$ pwd

- 00445518006
Prof. Uirá Ribeiro
/home/carlacruz
Se quisermos listar o conteúdo do diretório, pode-se usar o comando "ls":
$ ls
bin public_html
Para listar o conteúdo de algum arquivo dentro do diretório public_html, pode-se usar
a referência relativa, à partir do diretório corrente, usando o arquivo ".":
$ cat ./public_html/arquivo
Este é um arquivo texto de exemplo
Ou usar o caminho absoluto:
$ cat /home/carlacruz/public_html/arquivo
Se quisermos listar o conteúdo do diretório /home, pode-se da mesma forma usar o

arquivo especial ".." que faz referência ao diretório anterior:
$ ls ../
carlacruz uiraribeiro arthur
O arquivo especial ".." pode ser usado também para navegar nos diretórios, com o
comando "cd":
$ cd ..
$ pwd
/home
$ cd ..
$ pwd
/
Observe que entre o comando "cd" e o arquivo especial ".." é necessário um espaço,
para separar o comando "cd" e o arquivo especial "..".

00445518006
Diretório Home
Cada usuário no Linux possui um diretório especial único, chamado de diretório HOME.
É no seu diretório HOME que cada usuário pode criar, apagar, mover e renomear
arquivos e pastas à vontade.
Nenhum outro usuário comum do sistema pode ter acesso ao diretório home de outro
usuário. Somente o super-usuário root pode ter acesso a qualquer diretório no
sistema.
É no diretório home que também residem arquivos especiais de configuração do perfil

e do ambiente de trabalho dos usuários, bem como suas chaves privadas de acesso a
outros hosts e de criptografia.
O padrão da hierarquia de arquivos do Linux determina que o diretório HOME dos

usuários sejam criados dentro do diretório /home.
É no arquivo de contas de usuário /etc/passwd que é definido o caminho do diretório

home dos usuários:
$ cat /etc/passwd | grep carla

carla:1000:1000:Carla Cruz:/home/carlacruz:/bin/bash
A variável $HOME mantém o caminho do diretório HOME do usuário logado no

sistema:
$ echo $HOME
/home/carlacruz
O Linux mantém um atalho para o diretório HOME do usuário conectado através do

símbolo til "~":
$ cd ~
$ pwd
/home/carlacruz
Desta forma, pode-se usar o caminho do "~" para fazer referência aos arquivos e
diretórios do diretório HOME do usuário conectado:
$ cat ~/public_html/arquivo

- 00445518006
Prof. Uirá Ribeiro
ls
$ ls [opções] [arquivo]
O comando ls é sem dúvida um dos mais utilizados. Ele serve basicamente para listar
arquivos e conteúdo de diretórios.
Suas opções mais comuns são:
-a, --all Mostre todos os arquivos, inclusive os arquivos escondidos

que começam com "."
-A, --almost-all Mostra quase todos os arquivos, menos as entradas "." e ".."
-b, --escape Mostra os arquivos com escape, para caracteres não gráficos
-c Mostra e ordena pela adata de modificação dos arquivos
-C Mostra por colunas
-d Mostra somente os diretórios
-1 Mostra uma coluna somente com nomes dos arquivos
-h Mostra tamanho dos arquivos em formato humano
-l Mostra uma lista longa dos arquivos
-m Listas os arquivos separados por virgula
-S Ordena por tamanho
-R Lista os subdiretórios recursivamente
-x Lista em linhas ao invés de colunas
--color=auto Diferencia os tipos de arquivos por cor
Exemplos:
$ ls -m /boot/*138*
/boot/config-4.14.138-114.102.amzn2.x86_64,
/boot/initramfs-4.14.138-114.102.amzn2.x86_64.img,
/boot/symvers-4.14.138-114.102.amzn2.x86_64.gz,
/boot/System.map-4.14.138-114.102.amzn2.x86_64,
/boot/vmlinuz-4.14.138-114.102.amzn2.x86_64
$ ls -Sl ~/
-rw-rw-r-- 1 ec2-user ec2-user 221427 dez 7 2018
mysqltuner.pl
-rw-rw-r-- 1 ec2-user ec2-user 35487 mai 21 2017
vfsync-2017-05-21.tar.gz

00445518006
• No Linux os arquivos que iniciam com "." ficam ocultos, e só

são mostrados com a opção -a do ls
• O arquivo "." é um apontador para o diretório corrente
• O arquivo ".." é um apontador para o diretório acima (ou
anterior)
• Todos os diretórios possuem os arquivos "." e ".."
• Os nomes de arquivos e diretórios são sensíveis a letras
maiúsculas e minúsculas
pwd
$ pwd [opção]
O comando pwd informa o diretório absoluto corrente. Por absoluto entende-se que
ele mostra o caminho completo desde a raiz do sistema.
Ele tem algumas opções:
-L ou --logical Lista o conteúdo da variável PWD, mesmo se conter links

sombólicos
-P ou --physical Evita todos os links simbólicos
Neste exemplo, o diretório /home/programa é o link simbólico do /home/software.
O comando pwd sem opção ou com a opção "-L" , o link simbólico é indicado.
Já com a opção "-P", o pwd resolve o link simbólico apontando para o diretório original.
$ ls -l
lrwxrwxrwx 1 root root 8 set 12 13:16 programa -> software
drwxr-xr-x 7 apache users 4096 fev 1 2013 software
$ cd /home/programa
$ pwd
/home/programa
$ pwd -L
/home/programa
$ pwd -P
/home/software

- 00445518006
Prof. Uirá Ribeiro
2.4 Criar, mover e remover

arquivos
Neste capítulo aborda os comandos para criar, copiar, mover, renomear e apagar
arquivos e diretórios.
touch
$ touch [opções] arquivo
Todo arquivo contém informações de metadados, como o seu nome, data de criação,
data de modificação e data de último acesso, dentre outras informações. O comando
touch serve para alterar os metadados de tempo dos arquivos, modificando a data de
último acesso ou de modificação dos arquivos.
Isto pode ser útil para marcar um arquivo sofrer backup incremental ou diferencial a
partir de uma determinada data, ou ser sincronizado num repositório, sem a
necessidade de alterar o conteúdo do arquivo, bastando alterar a sua data de
modificação.
O comando touch também é útil para criar um arquivo vazio, se o parâmetro de

arquivo informado não existir.
As opções mais comuns são:
-a Muda a informação de último acesso do arquivo

-c Não cria o arquivo se ele não existir
-d data Permite que uma data no formato texto seja informada ao invés da
data e hora corrente
-m Muda a hora de modificação do arquivo
-t stamp Usa o formato [[CC]YY]MMDDhhmm[.ss] ao invés da data e hora
corrente
--time=PALAVRA Muda a informação de tempo informada, que pode ser
atime (acesso) ou modificação (mtime)
A opção -d=data é texto de data legível por humanos, na sua maioria livre, como
"Dom, 29 de fevereiro de 2004 16:21:42 -0800 "ou" 2004-02-29 16:21:42 "ou até
"próxima quinta-feira". Uma sequência de datas pode conter itens indicando data do
calendário, hora do dia, fuso horário, dia da semana, hora relativa, data relativa e

00445518006
números.
No exemplo abaixo o touch é usado para criar um arquivo fazio chamado config.txt:
$ touch config.txt
$ ls -l
-rw-rw-r-- 1 ec2-user ec2-user 0 set 13 22:29
config.txt
Uma lista também pode ser usada para criar vários arquivos:
$ touch teste{1..3}.txt
$ ls -l
-rw-rw-r-- 1 ec2-user ec2-user 226 set 12 16:14 teste1.c
teste1.txt
teste2.txt
teste3.txt
O touch pode ser usado para alterar a data de modificação de um arquivo, como por
exemplo teste1.c que foi alterando em 12/set:
$ touch teste1.c
$ ls -l
-rw-rw-r-- 1 ec2-user ec2-user 226 set 13 22:35 teste1.c
-rw-rw-r-- 1 ec2-user ec2-user 0 set 13 22:31 teste1.txt
Você também pode especificar uma data e hora específica ao invés da data e hora
correntes. Neste exemplo: 11/05/1978 às 18:40:30 :
$ touch -t 197805111840.30 teste1.c

$ ls -l
-rw-rw-r-- 1 ec2-user ec2-user 226 mai 11 1978 teste1.c
O formato da hora específica é definido pelo padrão CCYYMMDDhhmm.ss, em que:
CC – Os dois primeiros dígitos do ano.

YY – Os dois dígitos subsequentes do ano.

- 00445518006
Prof. Uirá Ribeiro
MM – O mês do ano [01-12].

DD – O dia do mês [01-31].
hh – A hora do dia [ 00-23].
mm – O minuto da hora [00-59].
ss – O segundo do minuto [00-59]
Você tambén pode especificar a data e a hora como um conjunto (string) usando a
opção -d. A linha de comando a seguir mostra um exemplo que define a data para 23
de fevereiro e a hora é automaticamente definida para 00:00:
$ touch -d '23 Feb' teste1.c

$ ls -l teste*
-rw-rw-r-- 1 ec2-user ec2-user 226 fev 23 2019 teste1.c
cp
$ cp [opções] origem destino
O comando cp copia os arquivos para outros arquivos ou para diretórios. O comando

cp pode copiar um arquivo ou múltiplos arquivos.
-d: Preserva os links ao copiar os arquivo;

-p: Preserva todas as informações dos atributos dos arquivos, como dono do
arquivo, grupo, permissões e data;
-R: Copia os arquivos recursivamente. Útil para copiar os arquivos e diretórios
abaixo do diretório especificado;
-a: Faz o mesmo que as opções “-dpR” combinadas;
-f: Força a cópia gravando por cima do destino;
-i: Pergunta ao usuário antes de copiar cada arquivo por cima do local de
destino;
-v: Mostra o nome de cada arquivo copiado.
Exemplos:
Copia o arquivo1 para arquivo2 no mesmo diretório:
$ cp arquivo1 arquivo2
Copia o arquivo1 para o diretório /tmp:

00445518006
$ cp arquivo1 /tmp
Copia o arquivo1 localizado no diretório /tmp para o diretório local. O símbolo “.”
(ponto) especifica o diretório como local:
$ cp /tmp/arquivo1 .
Copia todo o conteúdo do diretótio /var/log, incluindo todos os subdiretórios para o

diretório "loglocal":
$ cp –Rf /var/log/ loglocal
mv
$mv [opções] origem destino
O mv move ou renomeia arquivos e diretórios. Ele não altera os atributos dos arquivos
ou diretórios movidos se a transferência for o mesmo sistema de arquivos. Se o
destino para onde os arquivos ou diretórios forem movidos não existir, o comando
renomeia a origem, senão os dados são gravados por cima.
-f: Força a movimentação dos arquivos suprimindo mensagens de confirmação

para gravar por cima.
-i: Pergunta ao usuário antes de mover cada arquivo.
Exemplos:
Renomeia o arquivo1 para arquivo2:
$ mv arquivo1 arquivo2
Move o arquivo1 para o diretório /tmp:
$ mv arquivo1 /tmp
Você também pode usar o mv com o ".." para mover algo para o diretório superior:
$ mv arquivo1 ../

- 00445518006
Prof. Uirá Ribeiro
rm
$ rm [opções] arquivo
O comando rm é utilizado para remover arquivos.
Você precisa ter a permissão de gravação no diretório onde o arquivo está localizado
para removê-lo. Utilizando as opções –R e –f o comando rm remove diretórios.
Em algumas distribuições o comando "rm -i" é utilizado como apelido do comando rm,
forçando sempre confirmar antes de remover.
As opções são:
-f Força a remoção dos arquivos sem perguntar ao usuário.

-r, -R Remove um diretório e todo o seu conteúdo.
-i Pergunta antes de remover
-d, --dir Remove diretórios vazios
Exemplos:
Remove o arquivo1:
$ rm arquivo1
Remove o diretório documentos e todo o seu conteúdo:
$ rm –Rf documentos
Mesmo que um arquivo seja apagado pelo comando rm, é

possível recupera-lo com algumas técnicas avançadas e
tempo, uma vez que o rm apaga os metadados dos arquivos
na tabela do sistema de arquivos, de forma que os inodes
ainda podem existir no disco, permitindo recuperação. Para
apagar arquivos de forma virtualmente irrecuperável, o
comando shred deve ser usado.
mkdir
$ mkdir [opcões] diretório
O comando mkdir cria um ou mais diretórios abaixo do diretório local. Você precisa ter

00445518006
permissões para escrita no diretório para executar o mkdir.
-p: Cria o diretório especificado mesmo que o diretório pai não exista. Neste
caso, cria também o diretório pai;
-m: Configura a permissão do diretório criado. As permissões possíveis são
rxwrxwrxw (veremos mais adiante).
Exemplos:
Cria o diretório documentos:
$ mkdir documentos
Cria o diretório cartas abaixo do diretório documentos. Se documentos não existir,

cria-o primeiro antes do cartas:
$ mkdir –p documentos/cartas
Cria o diretório modelos abaixo do diretório documentos com as permissões de leitura,

escrita e execução para o dono do diretório, seu grupo e outros usuários:
$ mkdir –m 777 documentos/modelos
rmdir
$ rmdir [opções] diretório
O comando rmdir remove um ou mais diretórios vazios do sistema.
-p Remove um diretório e seus sub diretórios

--ignore-fail-on-non-empty Ignora o erro em caso do diretório não estar vazio
Exemplos:
Remove o diretório favoritos:
$ rmdir favoritos
Remove os subdiretórios a/b/c/d :

- 00445518006
Prof. Uirá Ribeiro
$ rmdir -p a/b/c/d
Tenta remover o diretório musicas, mas ele não está vazio:
$ rmdir musicas
rmdir: falhou em remover “musicas”: Directory not empty
Eu realmente não distingo entre Linux e coisas que são

descendentes mais ou menos diretos do Unix. Acho que são todos
iguais em algum nível. Muitas vezes, as pessoas me perguntam:
“Você sente ciúmes sobre o Linux ser a grande coisa.” E a
resposta é não, pela mesma razão. Acho que são iguais.
-- Dennis Ritchie

00445518006

- 00445518006
Prof. Uirá Ribeiro
Tópico 3: O Poder da Linha

de Comando
Eu não sei como parar, nunca houve intenção de escrever uma

linguagem de programação [...] Eu não tenho absolutamente nenhuma
idéia de como escrever uma linguagem de programação, eu apenas
continuei adicionando o próximo passo lógico no caminho.
-- Rasmus Lerdorf

00445518006
3.1 Como comprimir arquivos com a

linha de comando
Para uma maior eficiência e economia de mídias de backup, existe o recurso de

compressão de dados.
O Linux trabalha normalmente com três programas com algoritmos de compressão de

dados diferentes. O primeiro a surgir foi o GZIP, depois o BZIP2 e por último o XZ.
gzip e gunzip
$ gzip arquivo
O primeiro compressor de dados muito utilizado é o gzip. Ele utiliza um algoritmo de

compreensão chamado Lempel-Ziv. Esta técnica encontra caracteres duplicados nos
dados de entrada. A segunda ocorrência dos caracteres é substituída por ponteiros
para a referência anterior, na forma de pares de distância e comprimento. Ao
compactar um arquivo, o gzip adiciona o sufixo .gz.
Para compactar um arquivo:
$ gzip arquivo
Para descompactar um arquivo:
$ gzip –d arquivo.gz
Ou
$ gunzip arquivo.gz
bzip2 e bunzip2
$ bzip2 arquivo
O compactador bzip2 compacta arquivos utilizando o algoritmo de Burrows-Wheeler e

Huffman. Esta técnica opera em blocos de dados grandes. Quanto maior o tamanho
dos blocos, maior a taxa de compressão atingida. Ele é considerado melhor que os

- 00445518006
Prof. Uirá Ribeiro
compressores convencionais de dados. Ao compactar um arquivo, o bzip2 adiciona o

sufixo .bz2.
$ bzip2 arquivo
Para descompactar um arquivo:
$ bzip2 –d arquivo.bz2
Ou
$ bunzip2 arquivo.bz2
Existem alguns casos onde o arquivo compactado pode ficar maior que o arquivo
original. Isto pode ocorrer se o algoritmo utilizado não encontrar ocorrências para
fazer a compressão dos dados e o cabeçalho do compactador é adicionado ao arquivo
original.
xz e unxz
$ xz arquivo
Ainda, temos o compressor de dados xz, que utiliza o algoritmo similar ao gzip. Ele
produz arquivos com a extensão .xz ou .lzma.
$ xz arquivo
Para descompactar:
$ xz --decompress arquivo.xz
Ou
$ unxz arquivo.xz
Para você ter uma ideia da diferença entre os três compactadores gzip, bzip2 e xz,

00445518006
veja o exemplo comparativo do pacote TAR de um arquivo de backup de um site:
site.tar 9,8M # arquivo sem compactação

site.tar.gz 2,6M # arquivo compactado com gzip
site.tar.bz2 2,4M # arquivo compactado com bzip
site.tar.xz 2,1M # arquivo compactado com xz
Arquivos tarball
Os arquivos tarball são empacotamentos de arquivos e diretórios que mantêm a

estrutura de diretórios e arquivos original em um arquivo tar, com a possibilidade de
compressão de dados.
O comando para empacotar arquivos e diretórios é o tar. O nome deste comando

provém de “Tape-ARchive”. Ele lê arquivos e diretórios e salva em fita ou arquivo.
Juntamente com os dados, ele salva informações importantes como a última

modificação, permissões de acesso e outros. Isso o torna capaz de restaurar o estado
original dos dados.
As opções do comando tar não são tão opcionais assim. Ele recebe pelo menos dois
argumentos:
opções: Diz o que o tar deve fazer

[fonte]: Se o tar for utilizado para fazer backup, este parâmetro pode ser um
arquivo, um dispositivo, um diretório a ser copiado;
[destino]: Se o comando for utilizado para backup, esta opção irá especificar
o destino para os dados. Pode ser um arquivo tarball ou um dispositivo. Se for
utilizado para restaurar os arquivos, ela irá especificar um arquivo tarball e um
dispositivo de onde os dados serão extraídos.
Primeiro deve-se escolher o que tar deve fazer através das opções:
-c: Cria um novo arquivo .tar;

-u: Adiciona mais arquivos ao arquivo .tar somente se estes forem novos ou
modificados;
-r: Adiciona os arquivos especificados no final do arquivo .tar;
-g: Cria um backup incremental;
-t: Lista o conteúdo de um arquivo .tar;
-x: Extrai os arquivos de arquivo .tar;
Ele ainda tem opções auxiliares:

- 00445518006
Prof. Uirá Ribeiro
-j: Utiliza o bzip2 para compactar e descompactar os arquivos .tar.bz2;

-J: Utiliza o xz para compactar e descompactar os arquivos .tar.xz
-z: Utiliza o gzip para compactar e descompactar os arquivos .tar.gz;
-v: Lista todos os arquivos processados;
-f: Indica que o destino é um arquivo em disco, e não uma unidade de fita
magnética;
As opções do tar podem ser combinadas em um único parâmetro como "cvzf".
Por ser um comando que originalmente foi feito para ler/gravar em fita, para criar um
arquivamento tar ou ler um arquivamento tar em disco, deve-se sempre usar a opção
"f".
Exemplos:
Para salvar um determinado diretório /var/lib/mysql em um no arquivo

/var/backup/mysql.tar.gz:
$ tar cvzf /var/backup/mysql.tar.gz /var/mysql
Para extrair o mesmo pacote:
$ tar xvzf /var/backup/mysql.tar.gz –C /
Você poderá abrir o conteúdo de um arquivo tarball de duas formas:
$ gzip –d arquivo.tar.gz
O comando gzip descomprime o arquivo.tar.gz e retira o sufixo .gz.
$ tar xvf arquivo.tar
O utilitário tar extrai o conteúdo do pacote.
Podemos também utilizar formas mais simples:
$ tar xvzf arquivo.tar.gz
Ou
$ gzip –dc arquivo.tar.gz | tar xv

00445518006
Se o arquivo for compactado com o bzip2, ele deve ser descompactado pelo bunzip2
ou utilizar a opção –d do bzip2.
$ bzip2 –d arquivo.tar.bz2
Ou
$ bunzip2 arquivo.tar.bz2
$ tar xvf arquivo.tar
No caso dos arquivos compactados com xz, pode-se utilizad o comando xz:
$ xz -d linux.tar.xz
Seguido de:
$ tar xvf linux.tar
OU
$ tar xvJf linux.tar.xz
No ambiente gráfico, você pode descompactar e extrair um arquivo tarball sem muito
esforço, apenas clicando no arquivo. Desta forma o Linux invocará em segundo plano
o compactador de dados apropriado, juntamente com o tar para extrair o pacote de
dados no diretório corrente.
Veja a comparação entre a compactação realizada pelos compactadores gzip, bzip2 e

xz e um arquivo tar sem compactação:
$ ls -1shS linux*
895M linux.tar
165M linux.tar.gz
126M linux.tar.bz2
105M linux-5.4.3.tar.xz
Para o exame, é recomendado memorizar a seguinte tabela:

- 00445518006
Prof. Uirá Ribeiro
Extensão Compactador Utilizado Opção do Tar
.tar.gz Gzip $ tar xvzf arquivo.tar.gz
.tar.bz2 Bzip2 $ tar xvjf arquivo.tar.bz2
.tar.xz Xz $ tar xvJf arquivo.tar.xz
3.2 Como buscar e extrair dados de

arquivos
Outro conceito importante é o redirecionamento. Como o Linux foi criado por

programadores para programadores, fez-se necessário que os comandos e processos
tivessem a habilidade de tratar as entradas e saídas de dados com grande facilidade.
Antes de detalharmos a habilidade de redirecionamento do Linux precisamos definir o

que são entradas padrão, saída padrão e saída de erro:
A Entrada Padrão (stdin) é a entrada de um fluxo de texto. Como exemplos

temos o teclado, o mouse, um disquete, etc. Todos eles alimentam o
computador com informações. Pode ser representado pelo número 0.
A Saída Padrão (stdout) é a saída de um fluxo de texto em condições
normais. Como exemplos temos o monitor, a impressora, o disquete, um
arquivo, etc. Todos eles recebem informações do computador. Pode ser
representado pelo número 1.
A Saída de Erro (stderr) é a saída de um fluxo de texto em condições de
erro ou insucesso em um determinado processamento. A saída de erro poderá
ser direcionada para o monitor ou para um arquivo de LOG. Pode ser
representado pelo número 2.
Você pode ver esses fluxos de dados no diretório /dev com o comando:
$ ls -l /dev/std*
lrwxrwxrwx 1 root root 15 ago 15 10:53 /dev/stderr ->
/proc/self/fd/2
lrwxrwxrwx 1 root root 15 ago 15 10:53 /dev/stdin ->
/proc/self/fd/0
lrwxrwxrwx 1 root root 15 ago 15 10:53 /dev/stdout ->
/proc/self/fd/1
Como você pode perceber, o arquivo /dev/stderr é um link simbólico para um arquivo
no /proc/self/fd/2. O arquivo /dev/stdin aponta para o /proc/self/fd/0 e /dev/stdout para
/proc/self/fd/1.

00445518006
O diretório /proc/self é uma representação do Kernel para dar informações sobre o

processo em execução. Neste pseudo-diretório especial é possível acessar várias
informações sobre o processo que está sendo executado no momento. O diretório
/proc/self/fd é também uma abstração que contém os descritores de arquivos (file
descriptors), que é outra abstração que o Linux e o Unix fazem para representar
através de um arquivo um recurso de entrada ou saída de dados. É a forma que os
programadores encontraram de dar acesso fácil para entrada e saída de dados.
É por isso que o stderr é representado pelo número 2, o stdin pelo número 0 e o
stdout pelo 1.
É por causa dos descritores de arquivos que podemos redirecionar a entrada padrão
ou a saída padrão do fluxo de dados de um determinado processo para outro processo
ou um arquivo com muita facilidade.
Para redirecionar um resultado de uma saída para uma entrada de dados ou arquivo
utilizamos o sinal de maior ">".
E para direcionarmos algum arquivo como uma entrada de dados usamos o sinal de
menor "<".
O sinal duplo ">>" significa adicionar algo, geralmente ao final de um arquivo, sem
sobrescrever o seu conteúdo.
E o sinal duplo <<palavra geralmente serve para permitir que o usuário entre com
dados digitando no terminal, até que a palavra indicada seja digitada, uma vez que a
palavra funciona como um delimitador.
O sinal "&" pode ser usado para juntar as saídas como em 2>&1.
Ainda podemos redirecionar uma saída para uma entrada usando uma barra vertical
especial, o sinal em inglês chamado “pipe” "|" ou duto.
E os processos podem estar ligados aos terminais, conhecidos como tty. O termo tty
deriva da palavra Teletype.
Nos primórdios do Linux, o administrador utilizava o terminal principal do computador,

que era representado pelo arquivo /dev/console e os usuários eram ligados aos
terminais "burros" através de placas e conexões seriais, representados pelos
arquivos /dev/ttySN, onde N era o número do terminal ao qual o usuário estaria
ligado.
Assim, terminais no Linux são representados pelos descritores de arquivos no diretório

/dev/ com prefixo tty:
$ ls -1 /dev/tty*
/dev/tty
/dev/tty0
/dev/tty1

- 00445518006
Prof. Uirá Ribeiro
( ... )
O Linux mantém os terminais, mas de forma virtual, que podem ser acessados com a
combinação de teclas Ctrl-Alt-F1, Ctrl-Alt-F2 até Ctrl-Alt-F6, tanto em ambiente gráfico
como em ambiente texto.
O comando "ps -a" pode mostrar quais processos estão conectados a quais terminais:
$ ps -a
PID TTY TIME CMD
2738 tty2 00:12:41 Xorg
2751 tty2 00:00:00 gnome-session-b
9274 pts/0 00:00:00 ps
Observe que o ambiente gráfico está atrelado ao terminal tty2.
No exemplo o comando "ps" não está atrelado a um tty, mas ao pts.
O termo pts vem de Pseudo-Terminal, que nada mais é do que um terminal tty
emulado por um programa, como, por exemplo, o ssh. Então os programas em
execução através de uma conexão remota, estarão atrelados a um terminal falso
denominado pts.
Existe também o comando tty, devolve qual é o terminal que o processo do shell está
atrelado, seja ele um terminal real (tty) ou emulado (pts):
$ tty
/dev/pts/0
Usando essa premissa, é simples manipular dispositivos no Linux através dos

descritores de arquivos no diretório /dev/.
Por exemplo, é possível mandar uma mensagem para um usuário remoto conectado
via ssh num terminal. Para isto, basta saber qual é o terminal que ele está conectado
com o comando w:
$ w
23:40:41 up 1 day, 17:57, 2 users, load average: 0.00,
0.02, 0.02
USER TTY FROM LOGIN@ IDLE JCPU
PCPU WHAT
arthur pts/0 10.211.55.2 10:31 1:52 0.28s

00445518006
0.28s -bash
uiraribe pts/1 10.211.55.2 23:36 1.00s 0.03s
0.00s w
Desta forma, pode-se mandar uma mensagem para o Arthur no pts/0, utilizando o
comando echo seguido do redirecionador ">" e o descritor de arquivos que
representa o pseudo-terminal pts/0:
$ echo "Hello" > /dev/pts/0
Qualquer comando pode ter a sua saída redirecionada para um arquivo, ou para um
dispositivo utilizando um descritor de arquivos que o representa.
No exemplo seguinte listamos os arquivos num diretório gravando o resultado no

arquivo saída.txt :
$ ls > saida.txt
O redirecionamento é utilizando principalmente por programas ou quando o resultado

de um processamento não será observado diretamente pelo usuário no terminal, mas
enviado para outro programa, para um arquivo ou para um dispositivo.
Aqui o programa mail recebe como argumento o endereço de e-mail e ao invés de

utilizarmos o teclado como entrada padrão, redireciona-se o arquivo texto e-mail.txt
para o programa mail na entrada padrão dele com o sinal "<":
$ mail uribeiro@gmail.com < e-mail.txt
Para enviar toda a saída do programa folha_pagamento para o arquivo1, inclusive com
os erros:
$ ./folha_pagamento > arquivo1
É possível filtrar somente a saída padrão do programa folha_pagamento para

arquivo1, SEM os erros, usando somente o descritor "1":
$ ./folha_pagamento 1 > arquivo1
Se quisermos enviar toda a saída de erros para o arquivo arquivo_ erro.log, podemos
usar o descritor "2":

- 00445518006
Prof. Uirá Ribeiro
./folha_pagamento 2 > arquivo_erro.log
Tanto a saída padrão e os erros podem ser enviados de forma combinada para o
arquivo arquivo1, usando "2>&1" ou "1>&2" (não faz diferença a ordem) :
$ ./folha_pagamento > arquivo1 2>&1
É possível também separar as saídas em arquivos diferentes, enviando o resultado

com a saída normal para o arquivo_sucesso.log e a saída de erro para o
arquivo_erro.log.
$ ./folha_pagamento 1 > arquivo_sucesso.log 2>

arquivo_erro.log
Outra possibilidade é enviar somente a saída de erros para o limbo usando a

abstração de /dev/null:
$ ./folha_pagamento 2 > /dev/null
O mesmo pode ser feito para enviar os erros para a impressora, usando a abstração
que representa impressoras no /dev/lp0:
$ ./folha_pagamento 2 > /dev/lp0
Toda vez que você quer enviar a saída padrão de um programa para a entrada padrão
de outro programa, você precisa usar um condutor, com o sinal "|" do teclado.
Neste exemplo, o resultado do programa folha_pagamento é enviado como entrada

para o programa imprime_boletos e a saída de erro do imprime_boletos para o arquivo
erro.log:
$ ./folha_pagamento | imprime_boletos 2> erros.log
Para mandar um email do terminal com o conteúdo de um arquivo, pode-se usar o

redirecionador "<":
$ mail uribeiro@gmail.com -s urgent < mail.txt
Para receber dados do terminal e enviá-los para a entrada padrão de um comando,

pode-se usar o "<<palavra". Desta forma o terminal irá receber um texto do teclado,
até que a palavra "fim" for digitada em uma linha:

00445518006
$ mail uribeiro@gmail.com -s urgent <<fim

> Olá,
> Este é um email de teste
> fim
É comum o Linux redirecionar a saída de erros para o descritor de arquivos especial

/dev/null. Este arquivo especial é o limbo do Linux, onde tudo que vai para lá some:
$ find / -name arquivo 2>/dev/null
Desta forma, os erros que o find encontrar não serão mostrados no terminal, somente
a saída padrão.
cat
$ cat [opções] arquivo
O comando cat concatena arquivos, imprime seu conteúdo de tela e ainda pode
receber texto digitado pelo teclado para um arquivo.
As opções mais comuns do cat são:
-b Numera as linhas que não estão em branco

-E Mostra $ no final de cada linha
-n Numera todas as linhas, inclusive em branco
-s Elimina as linhas repetidas em branco
-T Troca o código da tecla TAB por Î
Vejamos como criar um arquivo com apenas algumas linhas de texto:
$ cat > teste.txt
Agora você pode digitar qualquer texto. Quando terminar, pressione Ctrl d em uma
linha vazia para finalizar a entrada de dados e salvar o arquivo teste.txt.
Para ver o conteúdo do arquivo recém-criado:
$ cat teste.txt
O cat também pode servir para concatenar arquivos.

- 00445518006
Prof. Uirá Ribeiro
$ cat texto1.txt > texto.txt
Observe que neste exemplo o conteúdo do arquivo texto.txt é substituído pelo

texto1.txt.
Para adicionar o conteúdo do texto1.txt no final arquivo texto.txt o correto seria:
$ cat texto1.txt >> texto.txt
Mostra o conteúdo de um arquivo de código fonte com as linhas numeradas:
$ cat -n teste.c
1 #include <stdio.h>
2 int main()
3 {
4 printf("Certificação Linux!\n");
5 };
less
$ less [opções] arquivo
Imagine agora que você quer ver o conteúdo de um arquivo grande. O comando
less serve para paginar o conteúdo de um arquivo, e permite que você navegue para
frente e para trás.
Além disso, o comando less carrega o arquivo de forma paginada, desta forma ele
inicia mais rapidamente que os editores de texto como o vi.
O comando less permite que você pressione Seta para Cima e Seta para Baixo ou
PgUP/PgDown para fazer o rolamento da página. Para sair do less pressione q.
Exemplos:
$ less /var/log/messages
$ cat /var/log/messages | less
Nem sempre o comando less está instalado como padrão nas distribuições. Você pode
instalar o pacote usando o gerenciador de pacotes da sua distribuição.

00445518006
head
$ head [opções] arquivo
Suponha que você quer ler somente as primeiras linhas de um arquivo.
O comando head (Do inglês cabeçalho) mostra as primeiras 10 linhas do início de um

arquivo.
A opção frequentemente utilizada é:
-n número: Configura o número de linhas que o head irá mostrar.
Exemplo:
$ head –n 50 LEIAME.TXT
tail
$ tail [opções] arquivo
O inverso do head também é possível. O comando tail (do inglês cauda) visualiza as
últimas 10 linhas de um arquivo.
-n número: Especifica o número de linhas finais que o tail irá mostrar de um

arquivo;
-f: Mostra as últimas linhas finais de um arquivo continuamente enquanto
outro processo grava mais linhas. Muito útil para visualizarmos arquivos de
LOG.
Exemplos:
$ tail –n 50 /var/log/messages
$ tail –f /var/log/messagens
sort
$ sort [opções] arquivo

- 00445518006
Prof. Uirá Ribeiro
O comando sort ordena as linhas de um arquivo.
Suas opções são:
-b: Ignora espaços no início da linha;

-d: Coloca as linhas em ordem alfabética e ignora a pontuação;
-f: Ignora a diferença entre maiúsculas e minúsculas;
-I: Ignora caracteres de controle;
-h: ordenar em formato humano
-m: Mescla dois ou mais arquivos em um arquivo ordenado de saída;
-M: Trata as três primeiras letras das linhas como mês (ex: JAN);
-n: Ordena pelos números no início das linhas;
-r: Ordena em ordem inversa;
-u: Se a linha for duplicada, mostra somente a primeira;
-o: Envia a saída do comando para o arquivo.
Como exemplo, vamos ordenar um arquivo de emails:
$ sort emails
alessandra@empresa.com
arthur@empresa.com
carla@empresa.com
demetrios@empresa.com
flavia@empresa.com
paulo@empresa.com
root@empresa.com
uira@empresa.com
Um cuidado deve ser tomado ao ordenar números. Veja o exemplo do arquivo

desordenado abaixo:
$ cat numeros
330
40
4
3
31
19
1
Ao usar o sort sem nenhum parâmetro, ele ordena primeiro usando o primeiro byte,
depois o segundo:

00445518006
$ sort numeros
1
19
3
31
330
4
40
Para ordenar usando os números como caracter, você pode usar a opção -n, ou a
opção -h para ordenar em formato humano:
$ sort -n numeros
1
3
4
19
31
40
330
cut
$ cut [opções] arquivo
O comando cut traduzido ao pé da letra significa cortar. Ele lê o conteúdo de um ou

mais arquivos e tem como saída uma coluna vertical.
Suas opções mais frequentes são:
-b número: Imprime uma lista vertical com o byte número (da esquerda para
direita);
-c número: Imprime uma lista vertical com o caractere número (da esquerda
para direita);
-d delimitador: Configura o delimitador que separa uma coluna da outra. O
padrão é o Tab;
-f número: Imprime a coluna número.
Exemplos:
Para pegar só os logins das contas de usuários no arquivo /etc/passwd, usando o cut.

- 00445518006
Prof. Uirá Ribeiro
Neste caso o delimitador será o ":" e a primeira coluna.
$ cut –d":" -f 1 /etc/passwd
Para pegar só o primeiro byte do arquivo /etc/passwd:
$ cut –b 1 /etc/passwd
Para pegar os nomes de grupos:
$ cat /etc/group | cut -f1 -d':'
O comando cut funciona exatamente como o comando awk. O exemplo a seguir

produz o mesmo resultado do comando anterior:
$ awk -F':' '{ print $1 }' /etc/group
wc
$ wc [opções] [arquivo]
Suponha que você quer contar o número de linhas, palavras ou caracteres de um

arquivo. O comando wc pode ser usado para contar as linhas, palavras e caracteres de
um ou mais arquivos. Se mais de um arquivo for passado como argumento, ele irá
apresentar as estatísticas de cada arquivo e também o total.
-c: Conta o número de caracteres de um ou mais arquivos;

-l: Conta o número de linhas de um ou mais arquivos;
-L: Conta o número de caracteres da maior linha do arquivo;
-w: Conta as palavras de um ou mais arquivos.
Neste exemplo, vamos usar o wc para contar os itens únicos da lista de

supermercado:
$ sort supermercado | uniq | wc

6 6 41
Nossa lista tem 6 itens (um por linha), seis palavras e 41 caracteres.

00445518006
grep
$ grep [opções] expressão-regular arquivos
O comando grep é largamente usado no dia a dia das tarefas administrativas em

Linux. Ele filtra as linhas de um determinado arquivo procurando por uma expressão
regular como padrão. O grep pode ler um ou mais arquivos que são passados como
argumento ou pode receber na entrada padrão o redirecionamento da saída de outro
processo. Se o grep receber mais de um arquivo ou um wildcard como argumento
para efetuar a sua busca, ele vai indicar o nome do arquivo seguido de dois pontos e a
linha encontrada.
O grep utiliza o padrão de Expressões Regulares POSIX BRE.
Assim, os meta-characters ? + { } | ( ) não tem significado especial. No padrão BRE

esses caracteres somente são interpretados com significado especial se precedidos
com a contra-barra \? \+ \{ \} \| .
Suas opções mais frequentes são:
-c: Mostra somente a contagem das ocorrências nos arquivos e não as linhas
onde as ocorrências foram encontradas;
-h: Mostra somente as linhas encontradas, sem a indicação do nome dos
arquivos;
-i: Procura as ocorrências ignorando se as letras estão em maiúsculas ou
minúsculas;
-v: Mostra todas as linhas do arquivo procurado menos as ocorrências
encontradas. Tem o efeito inverso;
-n: Mostra, além do texto das linhas encontradas, o número das linhas dentro
dos arquivos;
-B n: Mostra n linhas antes da linha encontrada;
-A n: Mostra n linhas depois da linha encontrada.
-E Muda o padrão POSIX BRE para POSIX ERE.
-F Não interpreta nenhum meta-caractere
Exemplos:
Procura a palavra uira no arquivo /etc/passwd:
$ grep uira /etc/passwd

uira:x:500:100:uira:/home/uira:/bin/bash
Procura todas as linhas começadas com a letra u no arquivo /etc/passwd. O acento

- 00445518006
Prof. Uirá Ribeiro
circunflexo simboliza o início de uma linha:
$ grep "û" /etc/passwd

uucp:x:10:14:Unix-to-Unix CoPy system:/etc/uucp:/bin/bash
Procura todas as linhas terminadas com a palavra false. O símbolo $ representa o fim

de uma linha:
$ grep "false$" /etc/passwd

mail:x:8:12:Mailer daemon:/var/spool/clientmqueue:/bin/false
wwwrun:x:30:8:WWW daemon apache:/var/lib/wwwrun:/bin/false
Procura todas as linhas que iniciam com as vogais no /etc/passwd. A expressão regular
chamada lista procura qualquer um dos caracteres dentro do colchete:
$ grep "^[aeiou]" /etc/passwd

uucp:x:10:14:Unix-to-Unix CoPy system:/etc/uucp:/bin/bash
at:x:25:25:Batch jobs daemon:/var/spool/atjobs:/bin/bash
alias:x:501:1000::/var/qmail:/bin/false
Procura por todas as linhas em que o primeiro caracter seja qualquer um e o segundo
caracter seja uma vogal. O ponto final na expressão regular simboliza “um caractere
qualquer”:
$ grep "^.[aeiou]" /etc/passwd

root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/bin/bash
news:x:9:13:News system:/etc/news:/bin/bash
Procura por linhas que contenham uma sequência de pelo menos quatro números
consecutivos:
$ grep "[0-9][0-9][0-9][0-9]" /etc/passwd

squid:x:31:65534:WWW-proxy squid:/var/cache/squid:/bin/false
nobody:x:65534:65533:nobody:/var/lib/nobody:/bin/bash
alias:x:501:1000::/var/qmail:/bin/false
qmaild:x:502:1000::/var/qmail:/bin/false

00445518006
Procura em todos os arquivos num diretório a ocorrência da palavra security.
$ grep security *
Veja o arquivo datas:
$ cat datas
1978-05-11 João
1976-02-23 Maria
2001-07-11 Pedro
1980-05-14 Carla
Para procurar as pessoas nascidas no dia 11 usando o grep, deve-se indicar que os
caracteres { } são metacaracteres usando a contra-barra:
$ grep "^[0-9]\{4\}-[0-9]\{2\}-11" datas

1978-05-11 João
2001-07-11 Pedro
3.3 Como transformar comandos em

script
O Linux possibilita concatenar um ou mais comandos num arquivo texto, e tornar esse
arquivo executável, que ganha o nome de script.
Este arquivo quando executado é interpretado pelo shell, que executa os comandos
em fila, um a um.
É possível dar um pouco de inteligência para o script, possibilitando alguns controles

de execução, através de variáveis, argumentos, testes condicionais e loops.
Escolhendo o Interpretador de
Script #! shebang
Todo script que será executado no Shell deve começar com uma linha especial que
inicia com os caracteres “#!” seguido do caminho completo do interpretador de
comandos. Esses caracteres são conhecidos como "shebang".
Exemplo de um script de shell chamado bomdia:

- 00445518006
Prof. Uirá Ribeiro
#!/bin/bash
clear
echo “Olá $USER”
echo “Hoje é “;date
echo “Número de usuários conectados: ” ; who | wc -l
echo “Calendário”
cal
exit 0
Como estudado anteriormente, para um arquivo ser considerado executável é preciso

que a sua permissão seja alterada e o bit executável habilitado:
$ chmod +x bomdia
Desta maneira o pequeno script poderá ser executado no prompt:
Olá uiraribeiro
Hoje é
sex set 27 10:56:54 -03 2019
Número de usuários conectados:
2
Calendário
setembro 2019
do se te qu qu se sá
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30
Outros interpretadores podem ser invocados pela linha “#!”, tais como o /bin/sh,
/usr/bin/perl, /usr/bin/awk, dentre outros.
Quando um script é executado, o shell analisa o conteúdo da linha “#!” e carrega o

programa definido para interpretar o script.
Em um script de shell esta linha faz com que um novo programa do shell seja
executado para interpretar o script. Enquanto isso o shell que o executou fica em
estado de espera.
O novo processo iniciado executa novamente os arquivos /etc/bashrc e ~/.bashrc.
Um aspecto importante é que o shell pai (em que o script foi chamado) pode passar
variáveis para o processo shell filho que irá executar de fato o script. Mas o shell filho

00445518006
não poderá passar variáveis ou alterar o conteúdo delas para o processo pai. A
herança é um caminho de mão única de processo pai para processo filho.
É importante que a chamada na linha “#!” que define qual interpretador deve ser
executado esteja correta. Se o caminho estiver incorreto, o script poderá não ser
executado.
Já os comentários nos scripts de Bash são sinalizados com apenas uma tralha "#".
Todo o restante da linha será ignorado pelo shell.
Permissões de Execução
Para que um script possa ser executado, ele precisa ter permissão de execução e o
comando chmod pode ser utilizado para habilitar esse bit para um script.
$ chmod +x script
Um script sempre será executado com as permissões do usuário que o executou, e de

forma alguma o Kernel obedecerá ao bit SUID ou SGID para script.
No entanto, o script poderá ser executado com as permissões de outro usuário se

utilizado o comando "sudo".
Veja o exemplo este script que imprime o UID do usuário:
#!/bin/bash
echo "eu sou:"
id
Se executado normalmente:
$ ./meuscript
eu sou:
uid=1000(uira) gid=1000(uira)
grupos=1000(uira),4(adm),10(wheel),190(systemd-journal)
Mas se executado com o sudo:
$ sudo ./meuscript
eu sou:
uid=0(root) gid=0(root) grupos=0(root)
Logo, deve-se tomar extremo cuidado ao se executar um script com o "sudo", uma

- 00445518006
Prof. Uirá Ribeiro
vez que todos os comandos que o script invoca serão executados com as permissões
de outro usuário, e, possivelmente o root.
Utilizou-se no exemplo o caminho relativo "./" para chamar o script, porque o diretório
corrente não está listado na variável PATH.
Variáveis Especiais
Uma característica importante dos scripts de shell é a possibilidade de confirmação da

execução com sucesso de um determinado comando. Ela é chamada de variável de
retorno.
A variável de retorno é preenchida toda vez que um comando é executado. Se o valor

retornado for 0, o comando foi executado com sucesso. Se o valor for diferente de 0,
algum problema foi encontrado.
Para utilizar ler o valor da variável de retorno, ela precisa ser verificada
imediatamente após a execução do comando desejado.
Para verificar o conteúdo da variável de retorno:
$ echo $?
0
Veja o exemplo de um script muito simples que verifica se o arquivo

/tmp/arquivoteste.txt existe:
#!/bin/bash
cat /tmp/arquivoteste.txt
if [ $? = 0 ]; then
echo “o arquivo existe”
else
echo “o arquivo não existe”
fi
$ chmod +x testederetorno
$ ./testederetorno
o arquivo não existe
Se o arquivo /tmp/arquivoteste.txt existir, o comando cat irá retornar $? igual a 0 e a

frase “o arquivo existe” será impressa.

00445518006
Outras variáveis especiais podem ser utilizadas:
Variável Para que serve
$# Retorna o número de argumentos que o programa recebeu.
$_ O sublinhado (underscore) contém o nome absoluto do arquivo do shell ou script que está
sendo executado como passado na lista de argumentos.
$? Variável de retorno do término da execução de um programa.
$$ Fornece o PID do processo do Shell.
$! Fornece o PID do último programa em execução em segundo plano.
$0 Retorna o nome do programa executado.
$n Retorna o argumento número n do programa.
$* Retorna todos os argumentos informados na execução do programa.

$@
Veja o script de exemplo em que se usa essas variáveis:
#!/bin/bash
echo "Meu nome é: $0"
echo "Eu tenho $# argumentos passados na minha execução"
echo "Este é o resultado da última execução: $_"
echo "O primeiro argumento é: $1"
echo "O segundo argumento é: $2"
echo "O terceiro argumento é: $3"
echo "Meu PID é: $$"
echo "Meus argumentos são: $@"
echo "Meus argumentos são: $*"
Ao ser executado, produzirá o seguinte resultado:
$ ./script um dois tres

Meu nome é: ./script
Eu tenho 3 argumentos passados na minha execução
Este é o resultado da última execução: Eu tenho 3 argumentos
passados na minha execução
O primeiro argumento é: um
O segundo argumento é: dois
O terceiro argumento é: tres
Meu PID é: 6210
Meus argumentos são: um dois tres

- 00445518006
Prof. Uirá Ribeiro
Meus argumentos são: um dois tres
O Comando test
$ test expressão
O comando test é uma grande ferramenta para testar condições. Com base na
variável de retorno do comando test, lógicas de programação podem ser montadas
para executar algo se uma condição for satisfeita ou não.
Ele pode testar condições em arquivos, permissões, textos, números, e até através de
expressões e fornece o resultado através da variável de retorno $?.
Neste exemplo o comando test verifica se 1 é menor que 2 (-lt = less than - menor
que):
$ test 1 -lt 2
$ echo $?
0
Como a variável de retorno foi 0, o número 2 é menor que 1.
Neste outro exemplo ele testa com o "-d" se o arquivo /usr/src é um diretório:
$ test –d /usr/src
$ echo $?
0
As opções mais comuns do comando test são:
Opção Para que Serve Exemplo
-d /diretorio Verifica se um arquivo é um diretório e se ele $ test -d /etc

existe
-e arquivo Verifica se um arquivo existe, independente $ test -e /etc/passwd

do seu tipo
-f arquivo Verifica se um arquivo existe e se ele é $ test -f /etc/passwd

comum
-z arquivo Verifica se o arquivo está vazio $ test -z /etc/groups
-n "$variavel" Verifica se o tamanho de um texto é maior $ test -n "$LIVRO"

que zero

00445518006
Opção Para que Serve Exemplo
-s arquivo Verifica se um arquivo existe e se seu $ test -s /etc/passwd

tamanho é maior que zero
s1 = s2 Verifica se um texto é igual a outro $ test "$LIVRO" =

"Certificação Linux"
s1 != s2 Verifica se um texto diferente de outro $ test "$LIVRO" !=

"Certificação Linux"
x -eq y Verifica se um número x é igual a y $ VAR=10 ; test $VAR -eq 10
x -gt y Verifica se um número x é maior que y $ VAR=10 ; test $VAR -gt 9
x -lt y Verifica se um número x é menor que y $ VAR=10 ; test $VAR -lt 11
x -ne y Verifica se um número x não é igual y $ VAR=10 ; test $VAR -ne 11
x -ge y Verifica se um número x é maior ou igual a y $ VAR=10 ; test $VAR -ge 9
x -le y Verifica se um número x é menor ou igual $ VAR=10 ; test $VAR -le 11

ay
expressão -a Verifica se ambas as expressões são $ test 10 -ge 9 -a 22 -gt 10;

expressão verdadeiras echo $?
expressão -o Verifica se uma OU expressão são $ test 10 -ge 11 -o 22 -gt 10;

expressão verdadeiras echo $?
arquivo1 -nt Verifica se o arquivo1 foi modificado depois $ test arquivo1 -nt arquivo2
arquivo2 de arquivo2 (mais novo)
arquivo1 -ot Verifica se o arquivo1 foi modificado antes de $ text arquivo1 -ot arquivo2
arquivo2 arquivo2 (mais velho)
-r arquivo Verifica se o arquivo tem permissão de $ test -r aquivo

leitura
-w arquivo Verifica se o arquivo tem permissão de $ test -w arquivo

escrita
-x arquivo Verifica se o arquivo tem permissão de $ test -x arquivo

execução
-O arquivo Verifica se você é o dono do arquivo $ test -O arquivo
Uso de [ ] no lugar do "test"

O comando test pode ser abreviado com colchetes [ ]. Observe que deve haver um
espaço entre a expressão e os colchetes:
$ [ 10 -ge 8 ]
$ echo $?

- 00445518006
Prof. Uirá Ribeiro
Operadores || e &&
Os operadores (pipe pipe) II e && servem para verificar se a expressão à direita
retorna verdadeiro ou falso.
O operador && verifica se algo que está à sua direita é verdadeiro, e assim sendo
executa o comando à sua esquerda.
Neste exemplo, forçamos o retorno verdadeiro com o comando "true" que sempre irá
retornar verdadeiro:
$ true && echo "Deu certo"

Deu certo
Se usarmos o comando "false", que sempre retorna falso, o operador && não vai
executar o comando à esquerda:
$ false && echo "Deu certo"
O operador II verifica se algo que está à sua direita é falso, e assim sendo executa o
comando à sua esquerda.
Neste exemplo, forçamos o retorno verdadeiro com o comando true. Neste caso, o II
não irá executar nada.
$ true || echo "Deu certo"
Já agora, o forçando o retorno falso com o comando false, o II executa o comando

echo:
$ false || echo "Deu certo"

Deu certo
Os operadores && e II também podem ser usados juntos:
$ test 100 -gt 99 && echo "SIM" || echo "NÃO"
Neste caso irá retornar SIM porque 100 é maior que 99.

00445518006
if
if [ expressão ]; then comando else comando fi
Controles de fluxo (if) são comandos que testam algumas alternativas e, de acordo
com o resultado, executam comandos.
A lógica do comando if é “se isso for verdadeiro, faça isso, se não, faça aquilo”. Veja o
exemplo:
if [ $? = 0 ]; then
echo ‘O comando foi completado com sucesso...’
else
echo ‘O comando falhou.’
fi
Neste exemplo o if testa se o conteúdo da variável de retorno $? é 0. Caso positivo,

executa o comando echo "O comando foi completado com sucesso...". Se a condição
for falsa, executa o comando echo "O comando falhou.".
Diferente de outras linguagens, o if testa um comando e não uma condição. Assim

sendo, devemos utilizar o comando test em conjunto com o if. Geralmente escreve-
se usando o atalho dos colchetes [ ] para o comando test.
for
$ for algo; do comando; comando2; done
O shell possui estruturas para testar condições e executar determinadas sequências

de programas várias vezes (loop), até que a condição testada seja satisfeita.
Os três comandos que possibilitam isso são o for (até que), o while (enquanto for
verdadeiro) e until (enquanto for falso).
O comando for permite que laços (loops) sejam feitos para que um ou mais comandos
sejam executados até que uma determinada variável percorra todos os valores de
uma dada lista.
Veja um exemplo simples:
$ for numero in um dois três quatro cinco

do
echo "Contando: $numero"

- 00445518006
Prof. Uirá Ribeiro
done
Contando: um
Contando: dois
Contando: três
Contando: quatro
Contando: cinco
O mesmo comando pode ser escrito em uma só linha:
$ for numero in um dois três quatro cinco; do echo

"Contando: $numero"; done
Veja o exemplo:
$ ls -1 > lista_arquivos.txt
Pode-se agora usar o for para executar diversos comandos para cada arquivo da lista:
$ for i in $(cat lista_arquivos.txt); do cp $i $i.backup; mv

$i.backup /tmp/backup; done;
Este laço atribui para a variável $i cada linha do arquivo lista_arquivos.txt.
A expressão $(comando) gera uma lista com resultado do comando. Tem o mesmo
efeito que utilizar o comando entre crases: `comando`.
Em seguida ele executa os comandos para renomear e mover os arquivos até que a
lista esteja completa.
Agora um exemplo um pouco mais complexo, com uso do for com if:
$ for i in `ls -1`; do if test -f $i; then echo “$i é um

arquivo “; else echo “$i não é um arquivo”; fi ; done
Desktop não é um arquivo

Documents não é um arquivo
Downloads não é um arquivo
HR_PROFESSOR.sql é um arquivo
Nesta linha, o resultado do comando ls -1 é colocado na variável $i; Depois cada linha

00445518006
da variável $i é testada para saber se é um arquivo; se for verdadeiro, será exibida

uma frase e, se for falso, outra frase.
Editor de Textos vi/vim

$ vi [opções] arquivo
O vi é um editor de textos ASCII poderoso e muito usado na interface de caractere do

Linux para edição de arquivos e programas. Seu uso não é muito intuitivo à primeira
vista, mas a edição simples de textos pode ser feita usando poucos comandos.
Basicamente ele tem dois modos de trabalho: o modo de operação e o modo de

inserção. No modo de operação o vi espera comandos que vão realizar alguma ação.
No modo de inserção, tudo que for digitado é considerado texto.
O modo de operação é acessado através da tecla ESC. O vi sempre inicia nesse modo.
Para entrar no modo de inserção, basta a pressionar a tecla INSERT ou o comando “i”.
Para fazer a edição simples de arquivos no vi:
$ vi nomedoarquivo
Altere o modo para inserção com a tecla INSERT. O cursor pode ser movido neste
modo com as setas de posição. Ao terminar a digitação aperte a tecla ESC e digite:
:w para salvar as modificações;

:wq para salvar e sair do vi;
:q! para sair sem salvar;
Veja a seguir a tabela de comandos aceitos pelo vi. Todos os comandos deverão ser
dados no modo de operação. O sinal “+” indica teclas que devem ser pressionadas
simultaneamente. A vírgula indica que as teclas devem ser digitadas em sequência.
Ação Comando
Abrir Arquivo :e arquivo
Salvar Arquivo :w
Salvar Arquivo Como :w arquivo
Salvar e Sair :wq
Sair sem salvar :q!
Apagar texto à frente (DEL) x

- 00445518006
Prof. Uirá Ribeiro
Ação Comando
Apagar texto para trás (BACKSPACE) X
Apagar uma linha dd
Localizar texto à frente /texto
Localizar novamente /
Desfazer alterações u
Refazer alterações CTRL+r
Ajuda :help
Insere texto antes do cursor i
Insere texto depois do cursor a
Insere texto em uma nova linha o
Software está comendo o mundo

-- Marc Andreessen

00445518006

- 00445518006
Prof. Uirá Ribeiro
Tópico 4: O Sistema
Operacional Linux
Eu acredito que às vezes são as pessoas que ninguém espera nada

que fazem as coisas que ninguém consegue imaginar.
-- Alan Turing

00445518006
4.1 Escolhendo um Sistema

Operacional
A escolha do sistema operacional de um computador geralmente é feita no momento

da compra do hardware, pois dificilmente um computador Desktop é vendido sem
sistema operacional nos dias atuais.
É com essa premissa que há mais de 25 anos a Microsoft detém fortemente o espaço
dos sistemas operacionais de computadores Desktops compatíveis com o IBM PC.
A Apple também fornece o seu sistema operacional proprietário nos seus

computadores, sejam iMacs ou MacBooks.
É no mercado de servidores que o Linux floresceu, e detém grande parte do

ecossistema da Internet, e 100% dos supercomputadores do mundo.
Apesar dos fabricantes quase sempre enviarem o hardware com um sistema

operacional pré-instalado, é possível que o usuário troque o sistema operacional para
um do seu gosto e que cumpra com os requisitos necessários.
Há cinco anos instalar Linux em um Notebook era algo experimental, e que nem
sempre a distribuição escolhida era capaz de identificar e fazer uso correto do
hardware. Mas isso hoje mudou drasticamente. É perfeitamente possível instalar
qualquer grande distribuição Linux com sucesso em praticamente qualquer notebook,
sem prejuízo algum de mal funcionamento.
O Linux até tem sido uma escolha sábia para reavivar velhos notebooks, com
distribuições leves, capazes de rodar em hardware antigo.
Como Escolher um Sistema Operacional

Microsoft Windows
O Windows por mais de 25 anos tem sido a escolha de quase todos os fabricantes de
computadores como sistema operacional pré-instalado, com um tipo de licença OEM
(Original Equipment Manufacturer). A cada ciclo de 5 anos, a Microsoft costuma lançar
uma nova versão do seu sistema operacional.
A grande vantagem do Windows é a larga base de aplicativos desenvolvidos para o

seu ecossistema, e a facilidade de uso, já que geralmente vem com o hardware, e é
adaptado a ele. Como desvantagem, o Windows não é gratuito, o seu ambiente gráfico
é fixo, e habilitar recursos no sistema podem requerer uma atualização da licença de
software, que gera um custo extra.
Também há versões de Windows para servidores, que podem trabalhar com serviços
de autenticação (AD), controle de acesso, servidores de arquivos e impressão,
servidores de Internet (IIS), Firewall e comunicação (Sharepoint).

- 00445518006
Prof. Uirá Ribeiro
MacOS
O sistema operacional dos computadores da Apple é baseado no BSD Unix. Ele possui
um Kernel Unix, uma interface gráfica única e otimizada para o hardware, e até pode
executar um Shell, como o Bash e Zsh.
O comando "uname" mostra informações do Kernel, tanto no Linux, quanto no

MacOS:
% uname -a
Darwin MacBook-Pro-de-Uira.local 19.4.0 Darwin Kernel
Version 19.4.0 RELEASE_X86_64 x86_64
O sistema operacional do Iphone e Ipads também é um BSD Unix, com interface

amigável.
Linux
O Linux basicamente pode ser dividido em três categorias: empresarial, consumidor e

experimental.
As distribuições empresariais podem ser gratuitas ou comerciais, geralmente

envolvem um contrato de suporte, e fornecem um sistema operacional robusto e
testado exaustivamente, para aplicações e serviços empresariais.
As distribuições desta categoria são:
Red Hat
CentOS
SUSE Enterprise
Debian
Ubuntu LTS
Fedora Server
Existem as distribuições de consumidor final, voltadas para os computadores Desktop,

tais como:
Ubuntu não LTS (Lubuntu, Xubuntu, Kubuntu, etc)

OpenSUSE
Fedora Workstation
Elementaty OS
Linux Mint
Deepin
Ainda existem as distribuições experimentais, para hackers (no bom sentido) e

usuários avançados:

00445518006
Arch
Gentoo
Backtrack
Kali
PureOS
Ciclo de Vida
Dependendo da aplicação que o Linux irá executar, é importante considerar o ciclo de
vida de suporte do sistema operacional.
Depois que o ciclo de vida de uma versão do software acaba, os desenvolvedores

oficiais descartam qualquer suporte, atualização e correção de erros naquela
determinada versão. As opções do usuário então neste caso são: fazer as correções
por conta própria, ficar a deriva, ou fazer o upgrade de versão.
O ciclo de vida das distribuições Linux podem variar de acordo com a categoria, e
também do distribuidor. As versões empresariais costumam manter o suporte ativo de
uma versão por 10 anos. Isto é necessário porque nas aplicações empresariais, as
mudanças são feitas de forma cautelosa e lenta. É comum hoje o hardware perder a
serventia antes do fim do ciclo de vida de um software.
As distribuições voltadas para o consumidor mantém o suporte através de fóruns,

geralmente no site do fabricante, por um período de lançamento de três versões, que
geralmente pode durar por volta de 5 anos.
As versões experimentais, geralmente também tem suporte via Wiki, que são
construídos de forma ativa, sempre em movimento.
Ainda, é possível encontrar distribuições que colocam disponíveis para o público

versões beta dos seus sistemas, que não foram amplamente testados, e podem conter
vários bugs, e que não usufruem do desempenho máximo por incluir rotinas de
depuração. Depois de inúmeros testes e correções, o fabricante lança uma versão
"stable" (estável).
4.2 Noções básicas sobre o

hardware do computador
Um computador tem muitos dispositivos de hardware ligados a ele. Desde fontes de

energia, monitores, discos rígidos, memória RAM, teclado, placas de áudio, placas de
vídeo, placas de rede, wifi, USB, bluetooth, cameras web, mouses, dispositivos
biométricos, telas touchscreen, impressoras, etc.
Fontes de Energia

- 00445518006
Prof. Uirá Ribeiro
As fontes de energia transformar a energia alternada, geralmente de 110v ou 220v

para uma voltagem e amperagem adequadas ao funcionamento do computador. A
maioria dos desktops tem uma única fonte que consome por volta de 80 watts de
energia por hora. Já os servidores podem possuir mais de uma fonte de energia, em
caso de falha de uma delas, e devido ao grande número de placas e dispositivos
conectados, consomem centenas de watts por hora.
Placas Mãe
As placas-mãe são responsáveis por conectar os diversos componentes de um

computador utilizando conectores padrão. As placas mãe possuem conectores para as
CPUs, pentes de memória, placas PCI, adaptadores de vídeo, som, rede, etc. Os
modelos mais baratos possuem chips integrados que oferecem serviços de vídeo, som
e rede integrados, geralmente para computadores Desktop. Já os servidores possuem
placas mãe de alto desempenho, para memórias de alta velocidade, CPUs rápidas, e
muitos conectores PCI para placas dedicadas de vídeo, som e rede.
A placas-mãe antigas possuam um software gravado em memória para controle dos

dispositivos conectados chamado de BIOS (Basic Input/Output System). Esse software
era responsável por identificar, carregar e transferir a operação para um sistema
operacional como o Linux.
As placas-mãe atuais possui um firmware avançado conhecido como EFI (Extensible

Firmware Interface), que evoluiu o software para suportar os diversos dispositivos
modernos dos computadores.
CPU ou Processadores
As CPUs são o "cerebro do computador", responsáveis por executar todos os

programas. As CPUs podem possuir um ou mais núcleos, ou "cores", que significa
quantas operações simultâneas pode fazer. O desempenho da CPU também pode ser
medido por ciclos por segundo, medidos em Hertz. Essa frequencia pode variar de 2.0
GHz até 4.2 GHz. Existem outros parâmetros que definem uma CPU, como os cachês
de memória interna, capacidade de transferir dados entre a CPU e a memória (bus).
As CPUs também podem variar de acordo com a sua arquitetura. Os celulares e

computadores compactos como o Raspberry Pi, usam CPU com arquitetura RISC. Já os
computadores pessoais usam arquitetura CISC x86.
Gerência de Dispositivos
Essa infinidade de hardware precisa ser devidamente reconhecida pelo sistema

operacional para que tudo funcione a contento. Graças aos constantes esforços dos
desenvolvedores do Kernel e fabricantes de hardware, o suporte aos diversos
dispositivos no Linux tem sido cada vez melhor e ultimamente detectados de forma
transparente para o usuário.
O gerenciamento dinâmico de dispositivos (udev) é responsável por manter a

estrutura de diretório do /dev (diretório que contém os links que representam os
dispositivos) de forma a permitir que somente dispositivos conectados sejam listados

00445518006
na estrutura do /dev.
Geralmente este gerenciador é executado na forma do programa chamado udevd em

modo de servidor (daemon) que fica escutando os eventos do Kernel para encontrar
quando um dispositivo é removido ou adicionado ao sistema. Quando se percebe um
evento de dispositivo no Kernel ele compara com as regras relacionadas no sysfs para
identificar o dispositivo e, depois disso, cria ou remove o link simbólico do dispositivo
no diretório /dev.
No diretório /dev encontramos geralmente dois tipos de descritores de arquivos: de

bloco e de caracteres.
Os dispositivos de bloco tem o tipo de arquivo indicado com a letra "b" e representam
dispositivos de armazenamento de dados, como discos rígidos, SSDs, CD-ROMs, DVDs,
etc.
Já os dispositivos de caractere tem seu tipo indicado com a letra "c" e representam os
dispositivos de entrada e saída de dados lentas, como mouses, teclados, monitores e
terminais.
$ ls -la /dev/sd* /dev/tt*

brw-rw---- 1 root disk 8, 0 Dec 18 22:16 /dev/sda
brw-rw---- 1 root disk 8, 1 Dec 18 22:16 /dev/sda1
crw-rw-rw- 1 root tty 5, 0 Dec 26 18:29 /dev/tty
crw--w---- 1 root tty 4, 0 Dec 18 22:16 /dev/tty0
Armazenamento
O Linux suporta diversos tipos de armazenamento de dados em massa. Estes

dispositivos podem ser categorizados em óticos, magnéticos ou em memória.
Os discos óticos são os CD-ROMs (700Mb), DVDs (4,7-8,5 Gb) e Blu-Rays (2550Gb).
Não são rápidos como os HDs, mas têm grande durabilidade se acondicionados em
locais apropriados e não permitem gravar os dados diversas vezes.
Os discos magnéticos têm grande capacidade de armazenamento de dados, que pode

chegar a 8 Terabytes. Alguns modelos são híbridos, pois possuem discos magnéticos e
grandes memórias flash para armazenar os dados mais lidos ou até mesmo o sistema
operacional. São sensíveis a solavancos e quedas.
Ainda na categoria de dispositivos magnéticos, temos as fitas magnéticas, bastante

utilizadas para backup de dados. Permitem gravar dados de forma sequencial com
baixo custo. Seu uso é cada vez menor devido ao baixo preço dos discos, computação
em cloud e outras estratégias de cópia de segurança mais avançadas.
Os “discos” em memória são na realidade bancos de memória flash chamados de

Solid State Drive (SSD) – drive de estado sólido – encapsulados em uma caixa do
tamanho de um HD e não possuem partes móveis como os discos óticos e magnéticos.

- 00445518006
Prof. Uirá Ribeiro
Seu tempo de acesso aos dados é incrivelmente veloz se comparado aos discos
magnéticos e óticos, são resistentes a quedas e solavancos, consomem menos
energia, dentre outros benefícios. No entanto a capacidade de armazenamento não
ultrapassa 1 Terabyte, e seu custo é elevado em comparação com os discos
magnéticos. Eram muito utilizados em Ultrabooks e em servidores de alta-
performance, mas como seu preço vem a cair drasticamente, o que possibilitou o seu
uso em computadores pessoais.
Há os discos SCSI de alto desempenho, geralmente utilizado em servidores, com RAID

implementado por hardware. Estes discos tem confiabilidade maior, e também
garantem altas taxas de transferência devido ao barramento utilizado.
O comando lsblk é útil para informar os dispositivos de armazenamento conectados e

montados:
$ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
xvda 202:0 0 8G 0 disk
└─xvda1 202:1 0 8G 0 part /
xvdb 202:16 0 4G 0 disk
└─xvdb1 202:17 0 4G 0 part [SWAP]
xvdf 202:80 0 16G 0 disk
└─xvdf1 202:81 0 16G 0 part
xvdg 202:96 0 20G 0 disk /home
Informações de Hardware no Linux
O diretório /proc reúne informações do Kernel e dos processos. Ele é um pseudo-

filesystem e não existe realmente no disco. Neste diretório ficam as abstrações de
descritores de tudo quanto há no Kernel do sistema.
É possível não só ler os dados, bem como fazer alterações no comportamento do

Kernel alterando o conteúdo de arquivos em /proc. Neste diretório pode-se encontrar
informações importantes sobre o hardware conectado.
Os seguintes arquivos fornecem informações sobre o Hardware:
Arquivo Descrição Comando que

consulta este
arquivo
/proc/cpuinfo Fornece informações sobre a CPU -
/proc/devices Fornece informações sobre os dispositivos conectados lspci
/proc/dma Fornece informações o acesso direto a memória lsdev
/proc/interrupts Fornece informações sobre os IRQs lsdev
/proc/iomem Fornece informações sobre a entrada e saída de memória lsdev

00445518006
Arquivo Descrição Comando que

consulta este
arquivo
/proc/ioports Fornece informações sobre as portas de entrada e saída lsdev
/proc/meminfo Fornece informações sobre a memória RAM e virtual free
/proc/modules Fornece informações sobre os módulos carregados no Kernel lsmod
/proc/partitions Fornece informações sobre as partições de disco lsblk
Não é comum o usuário consultar diretamente os arquivos do diretório /proc, mas

preferencialmente utilizar uma ferramenta que trate a informação.
4.3 Onde os dados são armazenados
É bem verdade que o Kernel do Linux tem uma capacidade excelente para trabalhar
com processos sem intervenção do usuário. Mas às vezes é preciso que o root
intervenha e termine um processo que esteja comportando de forma egoísta e
exaurindo os recursos da máquina.
Este controle de processos é especialmente importante porque o Linux é um sistema

multitarefa, multiusuário e multiprocessado.
O conceito de multitarefa significa que o Linux é capaz de executar diversos

programas e serviços ao mesmo tempo, de forma preemptiva.
O conceito de preemptivo é se tivermos apenas um processador central no

computador, o sistema fará o escalonamento (rodízio) dos processos de forma tão
eficiente que o usuário terá a impressão de que ele pode executar mais de um
programa ao mesmo tempo.
E o Linux ainda possui a capacidade de gerenciar os processos de forma eficaz com o

multiprocessamento, quando temos mais de um processador central envolvido.
O que é um processo?
Quando um programa está em execução, ele é chamado de processo.
Um processo no Linux possui alguns atributos, tais como:
Process ID (PID): ou identificação do processo: Cada processo possui um número

de identificação único. O primeiro processo init sempre terá o PID 1 e para o
restante dos processos este número é incrementado à medida que novos
processos são executados. Em sistemas que usam o Systemd, o
processo systemd assume o PID 1.

- 00445518006
Prof. Uirá Ribeiro
User ID e Group ID: (ID do usuário e ID do grupo): Os processos precisam ser

executados com os privilégios de uma conta de usuário e do grupo associado a
eles. Isto é importante porque assim o sistema pode determinar e gerenciar o
acesso aos recursos;
Processo Pai: No Linux nenhum processo é executado de forma independente dos

outros. Todos os processos no sistema, com exceção do init, possuem um
processo pai, que é responsável pela sua execução. O atributo ParentID grava o
PID do processo pai. Caso o processo pai termine sua execução antes do processo
filho, o processo filho é “apadrinhado” pelo init, ganhando o Parent ID igual a 1;
Variáveis de Ambiente: Cada processo herda do processo pai algumas variáveis

de ambiente que simplesmente guardam alguns valores que podem ou não ser
importantes para o processo em execução. É possível que durante sua execução
um processo altere, incremente ou apague uma variável de ambiente. Um
processo filho pode herdar as variáveis de um processo pai. Mas um processo pai
não consegue acessar as variáveis criadas ou alteradas por seus filhos.
Diretório de Trabalho: Os processos também são associados a um diretório de

trabalho, onde podem fazer a leitura e a escrita do disco;
Temporizadores: O Kernel mantém registros da hora em que os processos são

criados bem como o tempo de CPU que eles consomem durante a sua execução.
Terminal: Um processo pode ou não estar ligado à um terminal TTY.
Num ambiente multi programado, com apenas um processador, cada processo é

executado aos poucos de cada vez, de forma intercalada. O sistema operacional aloca
a CPU um pouco para cada processo. Um processo após receber o controle do
processador só o perderá quando ocorrer uma interrupção ou quando requerer algum
serviço do sistema operacional.
Estas interrupções são transparentes aos processos, pois apenas interrompem

temporariamente a sua execução, que depois continuará a ser executada como se
nada tivesse acontecido. Ao requerer um serviço do sistema operacional, o processo é
bloqueado até que o serviço requerido ao sistema operacional seja satisfeito.
O Linux utiliza um algoritmo para fatiar o tempo de CPU entre os processos baseado
em prioridades. A ideia é classificar os processos com base no valor e na necessidade
de tempo do processador. Os processos com prioridade mais alta serão executados
antes daqueles com prioridade mais baixa, enquanto os processos com a mesma
prioridade são agendados como round-robin (um após o outro, repetindo).
Em alguns sistemas, incluindo o Linux, os processos com maior prioridade também

recebem um tempo maior de CPU. O usuário root e o sistema podem definir uma
prioridade de processos para influenciar o comportamento do agendamento do
sistema.
O principal comando para verificar os processos é o ps.

00445518006
ps
$ ps [opções]
O comando ps gera uma lista com todos os processos em execução e os seus

atributos.
Houve um momento no Linux que coexistiram duas versões do comando ps em

diferentes distribuições. Há pouco tempo os desenvolvedores resolveram juntar as
duas versões do ps numa única versão, mas deixaram as opções de ambas as versões
diferentes coexistindo.
Desta forma, ao informar um parâmetro no ps, os resultados vão ser diferentes:
Sem usar o sinal de menos, o ps se comporta mostrando os processos no

estilo BSD;
Com um sinal de menos apenas "-" o ps se comporta mostrando os processos
no estilo do Unix, usando o padrão POSIX;
Com dois sinais de menos "--" o ps se comporta mostrando os processos no
estilo GNU.
Não existe certo ou errado, apensa preferência histórica.
As opções mais frequentes do ps são:
a Mostra os processos em execução ligados a um terminal, de todos os

usuários;
-a Mostra os processos em execução ligados a um terminal, menos os
processos de sessão;
-e, -A Mostra todos os processos;
-u Mostra a lista de processos incluindo o nome dos usuários donos dos
processos e início das execuções, percentual de CPU utilizada, percentual de
memória utilizada e terminal associado;
-x Mostra a lista de processos, incluindo aqueles que não têm um terminal
associado a ele. Útil para visualizar processos servidores (daemons);
-f Mostra os processos em forma de árvore. Muito útil para identificarmos a
relação de processo pai e filho entre os processos em execução;
-H Mostra hierarquia dos processos em forma de árvore;
Veja o help do comando ps para mais opções.
Neste exemplo o ps somente mostra os processos do usuário logado e ligados ao

terminal:

- 00445518006
Prof. Uirá Ribeiro
$ ps
PID TTY TIME CMD
1415 pts/0 00:00:00 ps
30019 pts/0 00:00:00 bash
Para mostrar todos os processos de todos os usuários ligados a um terminal:
$ ps a
PID TTY STAT TIME COMMAND
1628 pts/0 R+ 0:00 ps a
3297 tty1 Ss+ 0:00 /sbin/agetty --noclear tty1 linux
27159 pts/0 T 0:00 sudo find / -iname backup.sh
27160 pts/0 T 0:00 find / -iname backup.sh
30019 pts/0 Ss 0:00 -bash
Repare como a opção "-a" é diferente do "a":
$ ps -a
PID TTY TIME CMD
1675 pts/0 00:00:00 ps
27159 pts/0 00:00:00 sudo
27160 pts/0 00:00:00 find
A opção "u" adiciona alguns atributos dos processos:
$ ps au
USER PID %CPU %MEM VSZ RSS TTY STAT START
TIME COMMAND
root 3297 0.0 0.0 121336 1600 tty1 Ss+ ago15
0:00 /sbin/agetty --noclear tty1 linux
root 3298 0.0 0.1 120984 2064 ttyS0 Ss+ ago15
0:00 /sbin/agetty --keep-baud 115200,38400,9600
ec2-user 3414 0.0 0.1 164440 4032 pts/0 R+ 18:38
0:00 ps au
root 27159 0.0 0.3 216984 6608 pts/0 T 17:46
0:00 sudo find / -iname backup.sh
root 27160 0.0 0.1 128308 3944 pts/0 T 17:46
0:00 find / -iname backup.sh
ec2-user 30019 0.0 0.2 127120 4348 pts/0 Ss 14:48
0:00 -bash

00445518006
Para obter uma lista completa dos processos em execução, não só aqueles que estão
conectados ao terminal, adicione a opção "x":
$ ps aux
TIME COMMAND
root 1 0.0 0.2 199452 4968 ? Ss ago15
9:23 /usr/lib/systemd/systemd --switched-root --
root 2 0.0 0.0 0 0 ? S ago15
0:00 [kthreadd]
( ... )
ec2-user 30018 0.0 0.2 152864 4384 ? S 14:48
0:00 sshd: ec2-user@pts/0
ec2-user 30019 0.0 0.2 127120 4348 pts/0 Ss 14:48
0:00 -bash
postfix 30391 0.0 0.3 90536 6928 ? S 18:06
0:00 pickup -l -t unix -u
Os processos cujo comando estão envoltos em chaves, como no destaque do

[ktheradd], indicam que eles foram retirados da memória RAM, e colocados na
memória virtual em disco. Quando os processos estão na memória virtual em disco,
são chamados de sleeping.
O Kernel coloca com frequência os processos para dormir, enquanto eles estão à
espera de algum evento, que pode ser, por exemplo, carregar dados do disco, ou uma
conexão de rede.
Quando o evento é acionado, o Kernel envia um sinal ao processo.
Se o processo estiver em modo de suspensão interruptível, ele receberá o sinal do

Kernel e imediatamente acordará.
Se o processo estiver em modo de suspensão ininterrupto, ele só será ativado com

base num evento externo, como, por exemplo, o retorno de um hardware. No modo de
suspensão initerrupto, os sinais que porventura o processo receber serão salvos, e
processados somente quando o processo acordar.
As opções "efH" mostram todos os processos, com a hierarquia deles em forma de

árvore:
$ ps -efH
UID PID PPID C STIME TTY TIME CMD
root 3252 1 0 ago15 ? 00:00:00
/usr/sbin/sshd -D
root 29998 3252 0 14:48 ? 00:00:00 sshd:
ec2-user [priv]

- 00445518006
Prof. Uirá Ribeiro
ec2-user 30018 29998 0 14:48 ? 00:00:00 sshd:

ec2-user@pts/0
ec2-user 30019 30018 0 14:48 pts/0 00:00:00 -
bash
ec2-user 4176 30019 0 18:43 pts/0 00:00:00 ps
-efH
É possível brincar com os comandos, como, por exemplo, saber quais são os processos
que mais consomem a CPU:
$ ps aux | sort -nrk 3,3 | head -n 5

TIME COMMAND
nginx 3342 0.2 1.6 426976 34048 ? Sl ago15
133:04 amplify-agent
rpc 2729 0.0 0.1 73828 3276 ? Ss ago15
0:02 /sbin/rpcbind -w
root 9421 0.0 0.0 0 0 ? I set13
0:01 [kworker/u30:1]
root 9 0.0 0.0 0 0 ? I ago15
0:00 [rcu_bh]
Independente de como se queira ver os processos em execução, alguns atributos são

importantes para um administrador Linux, tais como:
Usuário dono do processo (UID)

É impossível executar um programa no Linux sem que ele tenha um usuário dono. Isto
significa que o programa vai ter as permissões de acesso ao disco e recursos do
usuário que executou o programa. Essa noção é importante, pois é possível executar
um programa como outro usuário que não seja o usuário logado.
Número de Processo - Process ID (PID)

Todo programa em execução recebe um ID numérico único. Esse número pode ser
usado para enviar sinais para o programa em execução.
Processo Pai (PPID)

Todo programa exceto o init ou systemd, tem processo pai, que originou a sua
execução. É comum um programa servidor, por exemplo, ter um processo pai (master)
e vários processos ou threads (filhos).
Threads podem ser entendidas como pedaços do programa que executam como se
fossem processos filhos, porém mais leves, pois compartilham muita coisa com o
processo pai. Esta tecnologia é muito usada nos processadores com vários núcleos

00445518006
(cores) para permitir execução de várias threads ao mesmo tempo.
% de CPU
Cada processo ganha uma fatia do tempo da CPU, que pode ser contabilizada, e serve
como parâmetro para o administrador saber quais são os processos que consomem
muita CPU.
% de Memória
Cada processo em execução também ganha uma fatia da memória RAM, que também
pode ser contabilizada para que o administrador saiba os processos que consomem
muita RAM
Hora de início (STIME)

Cada processo também tem como atributo a hora em que foi executado.
Tempo de CPU (TIME)

Cada processo também tem como atributo o tempo de CPU acumulado na sua
execução.
Linha de comando (CMD)

Os processos também mantém um atributo que é a linha de comando que foi usada
na execução
Terminal (TTY)
Cada processo pode ou não ter um Terminal associado.
A título de curiosidade, o que o comando ps realidade faz é varrer algumas

informações do diretório /proc. Tome como exemplo o processo sshd:
$ ps aux | grep ssh

root 3252 0.0 0.3 112928 7848 ? Ss ago15
0:00 /usr/sbin/sshd -D
Se olharmos o diretório /proc, ele terá um subdiretório com o número 3252, que
corresponde ao PID do programa sshd:
# cd /proc/3252
# ls
attr coredump_filter gid_map mem oom_adj
root stack timerslack_ns
autogroup cpuset io mountinfo
oom_score sched stat uid_map

- 00445518006
Prof. Uirá Ribeiro
auxv cwd latency mounts

oom_score_adj schedstat statm wchan
cgroup environ limits mountstats pagemap
sessionid status
clear_refs exe loginuid net
patch_state setgroups syscall
cmdline fd map_files ns
personality smaps task
comm fdinfo maps numa_maps
projid_map smaps_rollup timers
Por exemplo, a linha de comando do programa com o PID 3252 pode ser consultada
com um simples cat:
# cat cmdline
/usr/sbin/sshd-D
Várias informações sobre um processo podem ser visualizadas no diretório

/proc/[número do PID]. O utilitário ps apenas organiza a informação para uma
leitura mais humana.
top
$ top [opções]
Outra forma interessante de ver os processos em execução é com o comando top.
O comando top mostra os processos em execução como o comando ps, mas

atualizando a tela. Este recurso é útil para monitorarmos como um ou mais processos
agem no sistema. Este comando também ordena os processos que utilizam mais CPU
no TOPo da tela.
As opções mais utilizadas são:
-b: Executar em modo batch ou arquivo em lote. É utilizada para direcionarmos

a saída do comando para outro processo ou para um arquivo;
-d n: Determina o tempo das atualizações da tela em n segundos. O padrão é
cinco segundos;
-n num: Mostra o número de vezes na tela as atualizações dos processos em
execução e depois termina. Útil para ser utilizado com a opção –b;
-q: Executar com atualizações em tempo real. Esta opção deve ser utilizada
com cautela, pois pode consumir uma grande quantidade de cpu;
-u: Monitora os processos em execução de um determinado usuário;

00445518006
-p: Monitora um determinado processo identificado pelo seu PID. Mais de um

processo pode ser definido com esta opção.
O comando top ainda pode suportar alguns comandos que alteram o seu
comportamento durante a sua execução. São eles:
Z: Muda o esquema de cores do top. Para que esta opção esteja ativa é
necessário que o terminal suporte ANSI;
F: Adiciona colunas com mais opções de monitoramento dos processos;
u: Mostra os processos de um determinado usuário;
k: Termina (kill) com um determinado processo;
r: Muda a prioridade de execução do processo (renice);
R: Muda a ordem dos processos de acordo com a utilização da CPU;
q: Sai do modo interativo do top.
Figura 13 - Top
O comando top na primeira linha fornece a média de carga da CPU (load average),
correspondente a 1 minuto, 5 minutos e a 15 minutos, igual ao comando "uptime".
Quanto maiores os números, mais sobrecarregado o sistema estará.
É comum o sistema experimentar taxas altas na média de 1 minuto. Mas uma taxa
média alta constante no indicador de 15 minutos é um sinal de que a CPU está mal
dimensionada.

- 00445518006
Prof. Uirá Ribeiro
Na segunda linha tem o total de processos, quantidade em estado de execução

(running - que corresponde ao número de CPUs e núcleos), sleeping (que estão em
disco), parados (stop) e processos zombie (processos filhos que pararam de
executar, mas o processo pai não foi alertado).
Na terceira linha o top mostra a quantidade total de memória, memória livre, usada e
em buffer/cache.
Na quarta linha mostra o uso do Swap.
free
$ free [opções]
O comando free mostra a quantidade de memória total, em uso e disponível.
As opções “-b”, “-k” e “-m” mostram a quantidade em bytes, kbytes e megabytes

respectivamente:
$ free
total used free shared buff/cache
available
Mem: 2039524 189396 178424 131684 1671704
1503316
Swap: 0 0 0
A opção -h mostra as quantidades de maneira mais fácil de ler:
$ free -h
total used free shared buff/cache available
Mem: 1,9G 153M 205M 128M 1,6G 1,5G
Swap: 0B 0B 0B
Abaixo o significado de cada campo:
total: Total de memória RAM instalada no sistema;

used: Memória utilizada (total - free - buffers - cache);
free: Memória disponível;
shared: Memória compartilhada entre os processos usando o tmpfs. Os
processos podem alocar memória que compartilham por exemplo com seus
processos filhos;

00445518006
buffers: Memória usada como área de transferência pelo kernel;

cache: Memória usada pelo cachê de páginas de memória;
available Memória disponível sem levar em conta a memória utilizada em
buffers e cache
Nas versões antigas do comando free, a informação de buffer e cachê eram separadas
em duas colunas, porque o Linux dividia o buffer cachê em duas categorias. O buffer
era a memória usada pelo Kernel, e o Cachê era a memória usada pelos processos
para cachê. Resolveu-se juntar essa informação em uma só coluna.
O comando free também mostra a quantidade de memória disponível e usada em

swap.
O swap é uma área de disco que pode ser usada como espaço de troca de páginas de
memória entre a RAM e o disco, possibilitando aumentar virtualmente a memória do
sistema através das paginações entre memória e disco. É um recurso que pode ser
usado para evitar um esgotamento da memória RAM.
Se o sistema faz bastante uso do Swap, é um forte indicativo que há necessidade de

se aumentar a quantidade de memória RAM em função do uso do sistema.
uptime
$ uptime [opções]
O comando uptime mostra quanto tempo o sistema está no ar, a quantidade de

usuário logados e a carga da CPU.
-p Mostra desde quando o sistema está ligado de uma forma "bonitinha"

-s Mostra desde quando o sistema está ligado no formato ANO-MES-DIA
HORA:MINUTO:SEGUNDO
As médias de carga de CPU mostradas pelo comando uptime são calculadas com uma
média dos processos em execução ou esperando pela CPU. Essas médias não são
normalizadas pelo número de CPUs.
É muito importante memorizar que o uptime mostra a média de carga de CPU no

último 1 minuto, nos últimos 5 minutos e nos últimos 15 minutos, nesta ordem.
Se a carga de CPU for maior que 1, e se o sistema tem apenas uma CPU, significa que
o uso da CPU está além da capacidade, portanto, há uma espera grande por CPU pelos
processos.
Mas para tirar conclusões mais acertadas, vai depender do tempo em que a média de
CPU está acima de 1. Se houve um pico de uso de CPU no último minuto, mas as

- 00445518006
Prof. Uirá Ribeiro
médias de carga nos tempos de 5 e 15 minutos são baixas, não é um indicativo que
há necessidade de troca da CPU. Mas se as médias são altas com 5 e 15 minutos
também, significa que a capacidade de processamento pode estar mal planejada em
relação à carga do sistema.
Também é importante saber que essas médias não são normalizadas pelo número de
processadores. Um número de carga de 1 em um sistema com 4 processadores,
significa que as CPUs estão ociosas 75% do tempo. Desta forma, pode-se entender
que para sobrecarregar um sistema com 4 CPUs, a carga média precisa ser maior que
4.
Veja neste exemplo que há CPU de sobra:
$ uptime
20:35:37 up 31 days, 9:41, 1 user, load average: 0,02,
0,02, 0,00
A opção -p mostra desde quando o sistema está ligado no estilo contagem de dias:
$ uptime -p
up 4 weeks, 3 days, 9 hours, 45 minutes
E a opção -s mostra desde quanto tempo o sistema está ligado no formato de data:
$ uptime -s
2019-08-15 10:53:45
A quantidade de CPUs de um sistema pode ser visualizada no arquivo /proc/cpuinfo,

com parâmetro "model name":
$ grep -c 'model name' /proc/cpuinfo

1
Serviços de LOG
Muitos eventos acontecem em um ambiente Linux. Vários deles precisam ser

gravados em um arquivo de histórico (LOG) para que um administrador possa
verificar, posteriormente, quando acontece um erro ou para efeitos de auditoria.
O Linux vários serviços que oferecem essa funcionalidade de registrar os eventos

importantes para consulta do administrador.

00445518006
O mais antigo deles é o syslog, pouco utilizado. O sistema legado rsyslog é comum ser
encontrado ainda nas distribuições, e o mais utilizado na maioria das atualmente é o
Systemd Journal.
rsyslog
O rsyslog foi por muitos anos o serviço padrão de gravação de Logs do sistema. Seu
trabalho consiste em coletar mensagens do Kernel, de outros serviços e de aplicativos,
e grava-los em arquivos de log, enviá-los para outro serviço remoto de rsyslog, gravar
em um banco MySql ou PostgreSQL e também exibir mensagens urgentes no terminal.
Para facilitar a organização das informações, o rsyslog divide as mensagens em

grupos e também por severidade.
Sua instalação é simples, e pode ser feita através do gerenciador de pacotes:
# apt install rsyslog
Seu arquivo de configuração /etc/rsyslog.conf controla o que ele vai gravar e onde.
O rsyslog também trabalha com módulos, que são programas no estilo "plugin" que
podem habilitar novas funcionalidades ao syslog, tais como: envio de mensagens
SNMP, uso do MySQL, uso do PostgreSQL, outras bases de dados, etc.
A seguir uma tabela com os principais arquivos de LOG e seus propósitos que
podem estar configurados no sistema de Log. Cada distribuição pode ou não
fazer uso deles.
Arquivo Propósito
/var/log/messages Este arquivo contém Logs genéricos do sistema, com informações não críticas.
/var/log/secure Este arquivo contém os eventos de autenticação, como logins usando sudo e ssh
e outros serviços de segurança.
/var/log/kern.log Este importante arquivo de Log armazena informações de eventos do Kernel,

como erros e avisos, bem como problemas relacionados ao hardware e
conectividade.
/var/log/wtmp Mantém uma lista dos últimos logins dos usuários.
O comando lastb serve para ler o conteúdo do arquivo wtmp, fornecendo uma lista
dos usuários que se conectaram, como um livro de visitas:
# lastb
uiraribe ssh:notty 10.211.55.2 Sat Dec 28 16:01 -
16:01 (00:00)
uiraribe ssh:notty 10.211.55.2 Sat Dec 29 15:59 -
15:59 (00:00)

- 00445518006
Prof. Uirá Ribeiro
O exame requer que você tenha a noção da existência de outros dois sistemas de
Logs: syslog e o syslog-ng.
Rodízio de Logs com Logrotate
Uma vez que os LOGs podem crescer demasiadamente e se tornar grandes arquivos,
faz-se necessário rotacionar os arquivos de log através de um rodízio. O utilitário que
tem essa função é o logrotate.
O utilitário logrotate é usado para fazer cópias de segurança dos arquivos de LOG
atuais do sistema. Ele copia e compacta os arquivos de LOG e cria novos arquivos.
Esta rotação dos arquivos proporciona maior organização e agilidade quando
precisamos encontrar algum detalhe útil, organizado por datas.
$ ls -l /var/log/messages*
-rw------- 1 root root 1560471 abr 14 14:21 messages
-rw------- 1 root root 5495892 mar 22 03:39
messages-20200322
-rw------- 1 root root 3670195 mar 29 03:21
messages-20200329
-rw------- 1 root root 3666272 abr 5 03:34
messages-20200405
-rw------- 1 root root 3641141 abr 12 03:20
messages-20200412
Dependendo da configuração do serviço de Logrotate, os logs antigos podem ser

compactados, com algum compactador, como gzip, bzip, etc.
Journal do Systemd
As distribuições atuais utilizam um sistema de controle de serviços chamado systemd.
Uma das grandes vantagens do Systemd é a grande capacidade de registrar em Log

aquilo que acontece com os processos e serviços do sistema. Ele permite centralizar
os arquivos de Log dos diversos serviços, facilitando a leitura e interpretação deles.
O sistema que centraliza e gerencia estes logs do systemd é conhecido como journal.
Este journal é implementado pelo serviço journald que organiza todas as mensagens
de log do kernel, processos e serviços do usuário, como initrd, etc.

00445518006
Um Journal segue o conceito de arquivo circular. Ele tem um tamanho determinado, e

quando atinge esse tamanho, ele vai apagando os registros velhos para incluir novos
registros.
A ideia é que as mensagens vindas de diferentes pontos do sistema e diferentes

serviços seja organizada e armazenada em arquivos binários de log chamados de
journal. Deste forma, as mensagens podem ser filtradas e mostradas em diferentes
formatos, desde texto simples ou em forma de objeto JSON para criar um gráfico.
O journal geralmente é armazenado no diretório /var/log/journal.
journalctl
O comando journalctl pode ser utilizado para ler o journal. Quando nenhum parâmetro
for informado, o journalctl mostra o log do systemd, de forma paginada (geralmente
utilizando o comando less):
$ journalctl
-- Logs begin at Mon 2019-04-22 22:15:28 -03, end at Tue
2019-10-22 02:34:11 -03. --
Apr 22 22:15:28 ubuntu kernel: Linux version 5.0.0-13-
generic (buildd@lcy01-amd64-020) (gcc version 8.3.0 (Ubuntu
8.3.0-6ubuntu1)) #14-Ubun
Apr 22 22:15:28 ubuntu kernel: Command line:
BOOT_IMAGE=/boot/vmlinuz-5.0.0-13 root=/dev/sda1
O journalctl também permite filtrar por datas:
$ journalctl --since “2019-10-01 17:12:00”
ou
$ journalctl --since yesterday
Também é possível filtrar por Unit (unidade de serviço do systemd):
$ journalctl –u nginx.service
Ainda, filtro por componente Path
$ journalctl /bin/bash
Ou mostrar os registros recentes:

- 00445518006
Prof. Uirá Ribeiro
$ journalctl –n
E até mostrar os logs enquanto são gravados:
$ journalctl –f
A opção -p permite filtrar a prioridade do alerta:
$ journalctl -p alert
4.4 Seu computador na rede
O TCP/IP Transmission Control Protocol / Internet Protocol se tornou o protocolo de

comunicações padrão entre computadores a partir do crescimento exponencial da
Internet. O UNIX sempre utilizou o TCP/IP como padrão e o Linux herdou este
protocolo, bem como a Internet.
O endereço IP na versão 4 é escrito na notação decimal com quatro posições de 8 bits

cada, totalizando 32 bits. Cada parte do endereço pode ir de 0 a 255 na notação
decimal.
x.y.z.w
192.168.1.1
O protocolo permite que uma rede seja dividida em classes e subclasses de

endereçamento. As classes indicam onde começa e termina uma rede e precisam de
dois IPs para marcar o seu início e final.
A divisão de redes por classes é útil para dividir as redes de alguma forma lógica que
enquadre as necessidades das empresas e pessoas. Por exemplo, você pode dividir as
redes por departamento, por prédios físicos de uma escola, em rede administrativa e
rede de convidado, enfim, qualquer divisão que ajude a administrar melhor a rede.
Esta divisão é feita utilizando um recurso chamado máscara de rede (subnet mask):
Número IP: 192.168.1.1 / Sub-rede: 255.255.255.0
A subnet mask funciona exatamente como uma máscara, indicando quais bits serão
utilizados para definir a parte de endereçamento de rede e quais bits são usados para
definir a parte de endereços de máquinas.

00445518006
Localhost
Existem alguns endereços IP especiais que são reservados para funções específicas e
que não podem ser utilizados como endereços de uma máquina da rede. A Classe A
127.0.0.0 é utilizada como referência à própria máquina. Normalmente o endereço
127.0.0.1 é associado ao nome localhost.
Redes Privadas
Existem classes que são chamadas de IPs privados, pois são utilizadas em redes
locais. Estas classes privadas não são reconhecidas na Internet, e portanto não podem
se conectar na Internet sem o uso de um gateway ou dispositivo que faça a tradução
dos IPs privados para IPs públicos.
Como na versão 4 do IP não há endereços suficientes para todos os computadores e

dispositivos, o comitê gestor entendeu que algumas faixas de endereços podem ser
usadas em redes privadas, e que, quando estas se conectassem à Internet, haveria
uma tradução entre as redes privadas e públicas (Internet) que possibilitasse essa
conexão. Os dispositivos ou gateways que fazem essa tradução operam um
mecanismo chamado NAT – Network Address Translation.
O padrão RFC 1918 regula quais são as redes privadas do IPv4 e o padrão RFC 4193
regula quais são os endereços privados da rede IPv6.
Para a prova é importante você reconhecer quais faixas são utilizadas em redes
privadas:
Faixa de Endereços Número de IPs Descrição / Tamanho Bloco CIDR
10.0.0.0 – 10.255.255.255 16.777.216 Uma classe A 10.0.0.0/8
172.16.0.0 – 1.048.576 16 classes B 172.16.0.0/12

172.31.255.255
192.168.0.0 – 65.536 256 classes C 192.168.0.0/16

192.168.255.255
169.254.0.0 – 65,536 Uma classe B 169.254.0.0/16

169.254.255.255
Protocolos que Compõem o TCP/IP

O TCP/IP é constituído por um conjunto de protocolos que trabalham na camada de
transporte.
A camada de transporte é responsável pelo controle da conversação entre as

aplicações, movimentação dos dados de maneira eficiente e confiável,
independentemente da rede física.
Ela garante que os dados tenham níveis de qualidade previamente negociados e que

- 00445518006
Prof. Uirá Ribeiro
sejam entregues ao seu destino sem erros, em sequência e em segurança.
Camada de Transporte
A camada de transporte utiliza basicamente dois protocolos para transferir
informações: o TCP e o UDP. O primeiro é orientado a conexão e o segundo é não
orientado a conexão. Ambos os protocolos podem servir a mais de uma aplicação
simultaneamente.
Um protocolo orientado a conexão significa que ele negocia uma comunicação entre
transmissor e receptor, e mantém esta conexão ativa enquanto durar a conversa. Já
um protocolo não orientado a conexão simplesmente entrega seu conteúdo do
transmissor para o receptor, mas sem estabelecer uma conexão.
TCP - Transmission Control Protocol
O TCP é um protocolo da camada de transporte confiável, com conexão encapsulada

no IP. Esta conexão permite garantir a entrega dos pacotes, assegura a sequência
correta e faz um “checksum” que valida o cabeçalho e os dados do pacote.
No caso de a rede perder ou corromper um pacote TCP durante a transmissão, ele

retransmite o pacote, sem qualquer interferência da aplicação.
Essa confiabilidade torna o TCP/IP o protocolo escolhido para transmissões baseadas

em sessão, aplicativos cliente-servidor e serviços críticos.
Os cabeçalhos dos pacotes TCP requerem o uso de bits adicionais para assegurar
sequência correta da informação e o “checksum” obrigatório que garante a
integridade do cabeçalho e dos dados. Para garantia da entrega dos pacotes, o
protocolo requisita que o destinatário envie um pacote especial chamado de
“acknowledgement” que confirma o recebimento.
UDP - User Datagram Protocol
O protocolo UDP não garante a entrega dos dados, pois não faz a checagem de
recebimento. Ele possui um “checksum” opcional que está dentro do seu próprio
cabeçalho. É utilizado por aplicações que geram altos volumes de tráfego na rede,
como vídeo e som. Estas aplicações não podem incorrer em atrasos na entrega dos
pacotes, sacrificando a garantia de recepção. Um streaming de vídeo que perder
poucos pacotes UDP será imperceptível para o usuário. Mas, se na transferência de
um download faltar um arquivo, o mesmo será corrompido. Por este motivo o TCP é
utilizado para transferência de dados de forma confiável (mesmo que mais lenta que o
UDP) e o UDP é utilizado para streaming de conteúdo.
IP - Internet Protocol
O IP é o protocolo da camada Internet. Ele é responsável pela entrega de pacotes para

todos os outros protocolos da família TCP/IP. Ele utiliza um sistema de entrega de
dados sem conexão e trabalha com o endereçamento dos pacotes e seu roteamento.

00445518006
ICMP - Internet Control Message Protocol,
O ICMP é um protocolo não orientado a conexão que funciona como um agente de

controle de informações, mensagens de erro e informações de rotas. Ele usa
datagramas IP como meio de transporte. O mecanismo de controle que emite
mensagens quando acontece algum erro é a função principal do protocolo ICMP. Suas
funções básicas são:
Controle de Fluxo: Se o fluxo de entrada de dados for demasiadamente grande

para uma determinada máquina, ela pode emitir um pacote ICMP avisando o
emissor para parar temporariamente o envio de pacotes;
Destinos Inalcançáveis: Alguns dispositivos de rede, como roteadores, são
capazes de detectar falhas na entrega dos pacotes quando o destinatário não
pode ser alcançado por algum motivo. Eles enviam um pacote ICMP para o
remetente avisando esta condição;
Redirecionamento: Alguns dispositivos podem usar o ICMP para avisar o
remetente que utilize um outro caminho para alcançar o seu destinatário.
Checagem de Máquinas: Este protocolo também possibilita que a conexão
entre máquinas possa ser testada.
Figura 14 - Camada de Protocolos
Serviços e Portas TCP/IP

As aplicações fazem acesso à camada de transporte através de portas. Elas podem ser
vistas como canais de comunicações.
Cada porta é referenciada como número inteiro, que a identifica e à aplicação a que
ela dá suporte. Este número é um valor de 16-bit, que vai do 1 ao 65535 em decimal.
Os pacotes TCP e UDP contêm em seu cabeçalho informações como endereço IP do

remetente, porta de origem, endereço IP e porta de destino.
Cada serviço de rede oferecido por um computador deve utilizar uma porta de
comunicação exclusiva.
Os números de 1 a 1024 são chamados de portas privilegiadas porque os serviços

oferecidos através delas executam com autoridade de superusuário. Elas também são
chamadas de “portas bem conhecidas” porque são padronizadas para os mesmos
serviços em vários sistemas.
O arquivo /etc/services define os serviços e as portas conhecidas pelo sistema Linux.

Veja as portas cobradas no exame:

- 00445518006
Prof. Uirá Ribeiro
Quando uma máquina deseja abrir uma página de um site na Internet, ela abre uma
conexão entre ela e o servidor que hospeda a página. A máquina então abre uma
conexão em uma porta local, geralmente de número acima de 1024, e amarra essa
porta local com o programa do navegador web, com a porta 80 (http/tcp) do servidor
em questão. Então haverá, no momento da transferência do site, uma conexão entre
uma porta local de uma máquina e a porta 80 de um servidor. É importante que você
tenha em mente a relação entre estas portas e os serviços oferecidos por cada uma
delas.
No servidor, o programa que serve páginas web (servidor web Apache, por exemplo),
fica “escutando” a porta 80/tcp para aceitar novas conexões dos navegadores, porque
convencionou-se que este serviço trabalhe sempre na porta 80 do lado do servidor e
utilize o protocolo TCP para transferência de dados.
É certo que o arquivo /etc/services seja idêntico entre todos os Unix e Linux, pelo
menos das portas entre 1 e 1024.
Tabelas de Rotas
Para que as redes se interliguem e formem a Internet, cada dispositivo que interliga as
diferentes redes (conhecidos como gateways ou roteadores) é dotado de uma tabela
de rotas. Essa tabela de rotas especifica qual rede é conectada em qual interface do
roteador.
Uma situação especial desta tabela é a rota padrão. Esta rota padrão diz ao roteador
qual será a interface para qual os pacotes deverão ir quando nenhuma ocorrência da
tabela de rotas satisfaz o destino do pacote. Na tabela de rotas convencionou-se o
endereço 0.0.0.0/0 como sendo da rota padrão. Na notação CIDR 0.0.0.0/0 significa
“todo o resto” ou “todas as outras redes”.
Quando uma máquina transmite um pacote para outra máquina que não pertence à
rede local, ele é entregue para o roteador da rede. O roteador consulta sua tabela de
rotas para determinar de qual rede é o pacote. Se a rede à qual o pacote pertence
não está na lista, o pacote é entregue na interface indicada na rota padrão, que muito
provavelmente é um outro roteador ao qual o link está conectado.
Desta forma o pacote vai caminhando de roteador em roteador, até chegar na rede de
destino e então é entregue ao destinatário. Cada roteador por que o pacote passa é
chamado de salto ou hops. Convencionou-se na rede IPv4 que um máximo de 32
saltos atinja 99% de alcance.
Cada vez que um pacote passa por um salto, é incrementado um contador especial no
pacote que conta quantos saltos ele já deu. Se um pacote não é entregue em até 32
saltos, ele pode ser descartado pelo próximo roteador que passar, de forma que não
fique vagando eternamente na Internet.

00445518006
IPv6
O número de endereços de rede IPv4 está acabando. Isto se deve principalmente

porque a Internet como conhecemos atualmente não foi projetada para ser uma rede
comercial, mas acadêmica.
O IPv6 é a versão nova do protocolo IP que vem com o propósito de trazer inúmeras
melhorias à pilha de protocolo, bem como comportar mais endereços.
O IPv6 está sendo implantado gradativamente na Internet e deve funcionar lado a lado
com o IPv4, numa situação tecnicamente chamada de “pilha dupla” por algum tempo.
A longo prazo, o IPv6 tem como objetivo substituir o IPv4.
Veja as principais melhorias propostas pelo IPv6:
Espaço de Endereçamento maior: Os endereços IPv6 têm um tamanho de 128

bits, contra os 32 bits do IPv4.
Autoconfiguração de endereço: Suporte para atribuição automática de
endereços numa rede IPv6, podendo ser omitido o servidor de DHCP a que
estamos habituados no IPv4.
Endereçamento hierárquico: Simplifica as tabelas de encaminhamento dos
roteadores da rede, diminuindo assim a carga de processamento dos mesmos.
Novo formato do cabeçalho: Totalmente remodelados em relação ao IPv4.
Cabeçalhos de extensão: Opção para guardar informação adicional,
principalmente para comportar Qualidade de Serviço.
Suporte a qualidade diferenciada: Aplicações de áudio e vídeo passam a
estabelecer conexões apropriadas tendo em conta as suas exigências em
termos de qualidade de serviço (QoS).
Capacidade de extensão: Permite adicionar novas especificações de forma
simples.
Encriptação: Diversas extensões no IPv6 permitem o suporte para opções de
segurança como autenticação, integridade e confidencialidade dos dados.
O endereçamento no IPv6 é de 128 bits, e inclui prefixo de rede e sufixo de host. No

entanto, não existem classes de endereços, como acontece no IPv4. Assim, a fronteira
do prefixo e do sufixo pode ser em qualquer posição do endereço.
Um endereço padrão IPv6 deve ser formado por um campo provider ID, subscribe ID,
subnet ID e node ID. Recomenda-se que o último campo tenha pelo menos 48 bits
para que possa armazenar o endereço MAC.
Os endereços IPv6 são normalmente escritos como oito grupos de 4 dígitos

hexadecimais. Por exemplo,
3ffe:6a88:85a3:08d3:1319:8a2e:0370:7344

- 00445518006
Prof. Uirá Ribeiro
Se um grupo de vários dígitos seguidos for 0000, pode ser omitido. Por exemplo:
3ffe:6a88:85a3:0000:0000:0000:0000:7344
É o mesmo endereço IPv6 que:
3ffe:6a88:85a3::7344
Várias distribuições oferecem ferramentas próprias para a configuração e carga dos

recursos de rede. Entretanto alguns comandos, arquivos e conceitos são aplicáveis a
todas elas. Neste tópico será abordada a configuração de uma rede TCP/IP em
dispositivos ethernet.
O primeiro passo é conhecer os arquivos de configuração de rede comum a todas as

distribuições.
/etc/hostname
Este arquivo contém o nome do sistema. Em algumas distribuições existe o arquivo
/etc/HOSTNAME que é um link simbólico para o /etc/hostname.
$ cat /etc/hostname
linux.home.com.br
/etc/hosts
Este arquivo faz o mapeamento entre endereços IP e nomes de máquinas na rede e é
utilizado para resolução de nomes durante o processo de boot enquanto nenhum
servidor de DNS entrou em ação.
Antes de consultar um DNS, dependendo da configuração do arquivo /etc/host.conf, o

arquivo /etc/hosts é consultado antes de consultar qualquer servidor de DNS. Se você
quiser alterar a resolução de nomes de um determinado endereço para outro IP (por
exemplo para testar algo em um servidor de desenvolvimento), pode alterar no
arquivo /etc/hosts.
$ cat /etc/hosts
127.0.0.1 localhost
127.0.1.1 ubuntu
::1 ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
10.211.55.50 centos

00445518006
/etc/resolv.conf
Este arquivo especifica o endereço IP de um ou mais servidores de DNS para resolução
de nomes.
$ cat /etc/resolv.conf
nameserver 192.168.1.1
search certificacaolinux.com.br
Você pode especificar o endereço IP dos servidores de DNS que a máquina irá utilizar
com a palavra nameserver seguida do endereço IP.
A chave search determina que uma busca por hosts pode ser passada sem a
necessidade de se escrever o domínio inteiro.
/etc/host.conf
Este arquivo especifica a ordem de procura para a resolução de nomes. O sistema
pode procurar os endereços IPs no arquivo /etc/hosts (hosts) e pelo serviço de DNS
(bind). A opção multi on habilita mais de um IP para uma determinada máquina.
A opção order é que especifica se a máquina irá olhar primeiro no /etc/hosts e depois
do DNS.
$ cat /etc/host.conf
order hosts, bind
multi on
/etc/nsswitch.conf
O Linux mantém um serviço chamado Name Server Switch, que é utilizado pelas
bibliotecas de programação em GNU C para determinar quais são as fontes de
informação para resolução de nomes e em qual ordem.
Ele contém apelidos (passwd, group, hosts, network, etc.) que na verdade são
relacionados a funções na biblioteca de programação. Cada apelido pode estar
relacionado a uma ou mais funções de programação.
Em seguida ao apelido, é destacado qual será a origem da resolução de nomes. Se

mais de uma origem for especificada, a ordem determina a sequencia de resolução de
nomes.
Por exemplo:
networks: files dns.
Isto diz ao sistema que as funções getnetent(), getnetbyname(), getnetbyaddr(),

setnetent() e endnetent() irão consultar primeiro o arquivo /etc/hosts e depois o DNS.

- 00445518006
Prof. Uirá Ribeiro
Este arquivo é a evolução do /etc/host.conf e possibilita que a ordem de procura para

resolução de nomes seja customizada para cada serviço ou conjunto de funções na
biblioteca de programação GNU C. Ele é utilizado nas últimas distribuições por
diversas bibliotecas ao invés do /etc/host.conf (não confunda com /etc/hosts).
$ cat /etc/nsswitch.conf
passwd: compat
group: compat
hosts: files dns
networks: files dns
services: files
protocols: files
rpc: files
ethers: files
netmasks: files
netgroup: files
publickey: files
É importante que você esteja familiarizado com os arquivos de configuração

/etc/hostname, /etc/hosts, /etc/hosts.conf, /etc/resolv.conf e /etc/nsswitch.conf. Estude
muito bem a função de cada um e seu conteúdo.
Veja agora os principais comandos de configuração de rede.
ip
# ip [ opções ] Objeto { comando }
Este comando é uma poderosa ferramenta para mostrar e manipular as interfaces de

rede, configurar endereços IP, alterar as tabelas de rotas e criar túneis.
Com este comando é possível inserir ou alterar entradas na tabela de rotas, adicionar
ou modificar a rota padrão e também configurar endereços de rede.
Este comando substituí os comandos do Net-Tools ifconfig e route.
Os objetos com que o comando ip pode trabalhar são: link, addr, addrlabel, route,
rule, neigh, ntable, tunnel, tuntap, maddr, mroute, mrule, monitor, xfrm, netns,
l2tp, tcp_metrics, token e netconf.
Para o exame é necessário saber como funcionam os objetos addr (que configuram o
endereço IP), link (que habilita uma interface) e route (que modifica a tabela de
rotas).
A primeira função do ip é mostrar o endereço IP das interfaces do host. Utiliza-se o

comando ip seguido do objeto addr:

00445518006
# ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
inet6 ::1/128 scope host
2: enp0s25: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500

link/ether 00:26:55:04:d3:95 brd ff:ff:ff:ff:ff:ff
inet 172.19.1.34/20 brd 172.19.15.255 scope global
enp0s25
inet6 fe80::226:55ff:fe04:d395/64 scope link
Para verificar a tabela de rotas do host, você pode usar o objeto route:
# ip route
default via 172.19.1.1 dev enp0s25
172.19.0.0/20 dev enp0s25 proto kernel scope link src
172.19.1.34
ping e ping6
# ping ip
O comando ping utiliza o protocolo ICMP para enviar mensagens ECHO REQUEST e
receber ECHO RESPONSE para testar a conexão entre o sistema e outra máquina na
rede.
Ele retorna o tempo de resposta que um pacote de rede demora para ir e voltar. Muito
útil para realizar o diagnóstico de uma conexão. O ping irá testar indefinidamente até
que o Crtl-c seja pressionado.
O ping também possui uma versão para o IPv6, chamada de ping6. Seu
funcionamento é similar ao ping do IPv4.
-c num: Esta opção faz com que o ping teste a conexão um deteminado
número de vezes.
-q: Esta opção faz com que o ping somente apresente a estatística final do
teste de conexão.
Exemplo:

- 00445518006
Prof. Uirá Ribeiro
$ ping 192.168.1.1
PING 192.168.1.1 (192.168.1.1) 56(84) bytes of data.
64 bytes from 192.168.1.1: icmp_seq=1 ttl=64 time=0.175 ms
— 192.168.1.1 ping statistics —
5 packets transmitted, 5 received, 0% packet loss, time
4000ms
rtt min/avg/max/mdev = 0.115/0.128/0.175/0.026 ms
O ping é muito utilizado para testar se uma máquina está conectada na rede local ou
se ela é alcançável na rede remota. Para que o ping funcione corretamente, a rede em
questão não deve ter nenhum filtro de ICMP, especialmente os tipos ECHO REQUEST e
ECHO RESPONSE.
O comando ping pode indicar os seguintes possíveis problemas de rede:
Problema com a Resolução de Nomes:
Se ao executar o ping em um determinado host utilizando um nome de rede

(host.certificacaolinux.com.br) o ping demorar para responder, e não conseguir
resolver o nome para o IP, significa que:
O servidor de DNS pode estar errado (verifique o arquivo /etc/resolv.conf);

O servidor de DNS não pode ser acessado (faça um ping com o IP do servidor
de DNS);
Existe um filtro de porta UDP 53 entre o computador e o servidor de DNS
(verifique o iptables);
Problema de Conectividade:
Se ao executar o ping, um determinado host não responder, pode significar que:
O host destino está fora do ar;

Não há rota entre a rede do computador e o host destino (verifique a tabela de
rotas);
O default gateway está errado (verifique a tabela de rotas);
O Network Address Translation está com algum problema de encaminhamento
ou tradução de endereços (verifique o firewall);
Existe um filtro de ICMP ECHO e ECHO-REPLY na rede;
ss
$ ss [opções]

00445518006
O comando ss é extremamente útil para investigar os sockets, fornecendo várias

informações sobre a rede. Ele é a evolução do comando netstat do antigo Net-tools. É
importante que se entenda que um socket pode ser uma conexão de rede, bem como
um socket do tipo Unix, que é um arquivo especial que atua como "ponte de
comunicação" entre dois programas.
Suas opções mais comuns são:
-a: lista todos sockets;

-r: resolve os endereços IPs e portas por nomes de serviços;
-n: não resolve os endereços IPs e portas para serviços;
-l: lista somente as portas abertas (LISTEN);
-e: mostra informações detalhadas sobre o socket;
-m: mostra a alocação de memória do socket;
-p: mostra o processo dono do socket;
-i: mostra estatísticas do TCP sobre o socket;
-K: força o fechamento de um socket;
-s: mostra as estatísticas da rede;
-t: filtra somente os pacotes TCP;
-u: filtra somente os pacotes UDP;
-4: filtra somente os pacotes IPv4;
-6: filtra somente os pacotes IPv6;
Algumas opções podem ser combinadas para formar um determinado resultado.
Exemplos:
Para ver as estatísticas da rede:
$ ss -s
Total: 1020
TCP: 25 (estab 2, closed 1, orphaned 0, timewait 1)
Transport Total IP IPv6
RAW 1 0 1
UDP 9 6 3
TCP 24 22 2
INET 34 28 6
FRAG 0 0 0
Para ver as portas TCP abertas (em LISTENING):
$ ss -lt
State Recv-Q Send-Q Local Address:Port Peer

- 00445518006
Prof. Uirá Ribeiro
Address:Port
LISTEN 0 128 127.0.0.53%lo:domain 0.0.0.0:*
LISTEN 0 128 0.0.0.0:ssh 0.0.0.0:*
LISTEN 0 128 [::]:ssh [::]:*
Para mostrar as portas TCP e UDP abertas e os processos donos do sockets. Para
mostrar os processos, o usuário precisa ser o administrador root:
# ss -ltpu
Netid State Local Address
udp UNCONN 127.0.0.1:323
users:(("chronyd",pid=20898,fd=5))
tcp LISTEN 0.0.0.0:ssh users:(("sshd",pid=9857,fd=3))
Mostra todas as conexões estabelecidas na porta (22) do ssh:
$ ss -o state established '( dport = :ssh or sport = :ssh )'

Netid Recv-Q Send-Q Local Address:Port Peer
Address:Port
tcp 0 0 10.211.55.63:ssh
10.211.55.2:64749 timer:(keepalive,104min,0)
Esse comando é útil para diagnosticar os seguintes problemas:
Verificar quais serviços de rede que estão em execução (-l)

Verificar a quantidade de memória consumida por um socket (-m)
Verificar os processos donos dos sockets (-p)
Verificar as conexões estabelecidas (-o state established)
Verificar o volume de dados trafegado em uma conexão TCP (-i)
Configurar o Cliente DNS
O DNS – Domain Name System é utilizado para resolução de nomes para endereços IP
e vice-versa.
A implementação do serviço de resolução de nomes é feita pelo pacote BIND ou outros

pacotes de servidor de DNS. Este pacote possui os arquivos necessários à
configuração do DNS e o serviço chamado named.
O DNS é estruturado sobre dois pontos básicos, a organização da Internet em

00445518006
domínios e a distribuição dos servidores de nomes na rede em forma de hierarquia.
A organização da Internet em domínios evita a utilização de um mesmo nome por

mais de um equipamento e descentraliza o cadastro de redes e equipamentos.
Os domínios podem ser hierarquizados por instituições e geograficamente.
A distribuição dos servidores DNS faz-se necessária uma vez que a centralização de
uma única base de dados contendo as informações para a conversão dos nomes
simbólicos em endereços IP seria inviável.
A própria Internet nasceu de um projeto chamado ARPANET, criado pelo

Departamento de Defesa americano, que preconizava uma rede sem um backbone
central e sem administração centralizada, tornando-a virtualmente indestrutível caso
algum computador, ou pedaço da rede se tornasse inoperante.
Na internet existem diversos servidores raízes geograficamente espalhados e

organizados através de sufixos. Por exemplo, os servidores raiz do sufixo .br ficam
hospedados no registro.br. Os servidores raiz do registro.br precisam conhecer todos
os servidores DNS que hospedam domínios terminados com .br.
Há 3 arquivos de configuração importantes para a resolução de nomes, já citados no

livro:
/etc/nsswitch.conf: Este arquivo possui uma linha com o comando "hosts"

que determina a ordem de busca para resolução de nomes. A tag "files"
determina que o /etc/hosts seja consultado e a tag "dns" determina que o
arquivo /etc/resolv.conf seja consultado para determinar o IP do servidor de
DNS.
/etc/resolv.conf: Este arquivo possui uma linha com o comando nameserver
que determina o IP do servidor de DNS;
/etc/hosts: Este arquivo pode conter algumas resoluções de nomes em IPs de
forma manual;
Ao acessar a Internet através de um navegador ou qualquer outro aplicativo de rede, o

host Linux segue a seguinte sequência para identificar o endereço IP do nome de
endereço de Internet desejado:
1. O Linux verifica o arquivo /etc/nsswitch.conf para saber a ordem de busca: se

é em arquivo (/etc/hosts) ou por servidor de DNS (/etc/resolv.conf).
2. Se a ordem em /etc/nsswitch.conf for primeiro "files", o arquivo /etc/hosts é
consultado para se tentar determinar a resolução do nome. Se a ocorrência for
encontrada, o endereço IP será retornado. Caso não encontre, o host irá ler o
endereço IP do servidor de DNS no arquivo /etc/resolv.conf e fará uma
consulta ao servidor de DNS para tentar determinar o IP do endereço desejado.
Se o servidor retornar um endereço IP, o nome será resolvido. Caso contrário, a
aplicação receberá uma falha de resolução de nomes.
3. Se a ordem em /etc/nsswitch.conf for primeiro "dns", o arquivo /etc/resolv.conf
é consultado para pegar o endereço IP do servidor de DNS e uma consulta será

- 00445518006
Prof. Uirá Ribeiro
feita ao servidor de DNS para tentar determinar o IP do endereço desejado. Se o

servidor de DNS encontrar o endereço, a aplicação receberá o IP desejado. Caso
contrário, o host irá acessar o arquivo /etc/hosts para tentar determinar o IP do
endereço desejado. Caso encontre, o IP será retornado. Em caso negativo a
aplicação receberá uma falha de resolução de nomes.
Exemplo de configuração do /etc/nsswitch.conf
passwd: files systemd

group: files systemd
shadow: files
gshadow: files
hosts: files dns
networks: files
Exemplo de configuração básica do arquivo /etc/resolv.conf:
search meudominio.com.br
Exemplo de configuração básica do arquivo /etc/hosts:
127.0.0.1 localhost.localdomain localhost

10.25.12.1 www.certificacaolinux.com.br www
É importante que você entenda o funcionamento do processo de resolução de nomes,

que os arquivos /etc/hosts, /etc/nsswitch.conf, /etc/resolv.conf regulam a configuração
do cliente de DNS.
É importante saber que a ordem de resolução de nomes no arquivo /etc/nsswitch.conf

afeta como a resolução de nomes se comportará. Assim que uma ocorrência de
resolução de nomes é encontrada, seja no servidor de DNS ou localmente no arquivo
/etc/hosts, o host se dá por satisfeito e não recorre a outro serviço.
Com isso, pode-se ter os seguintes casos de erro:
Pode existir um endereço listado no /etc/hosts manualmente, que difere do

endereço IP que os servidores de DNS resolvem. Isso pode fazer com que o
host conecte em um servidor errado, ou mesmo não consiga conectar porque o
endereço IP não existe;
Um determinado servidor de DNS listado no /etc/resolv.conf não está ativo ou
o host não consegue uma conexão com ele, impossibilitando a resolução de
nomes;

00445518006
host
$ host [ opções ] endereço
O comando host é utilizado para fazer buscar no serviço de resolução de nomes DNS.
Veja no exemplo que ele diz quais são os registros encontrados para o endereço
www.certificacaolinux.com.br:
$ host www.certificacaolinux.com.br
www.certificacaolinux.com.br is an alias for
myload-1433566614.us-east-1.elb.amazonaws.com.
myload-1433566614.us-east-1.elb.amazonaws.com has address
23.23.152.168
myload-1433566614.us-east-1.elb.amazonaws.com has address
23.21.124.198
O comando ping também é capaz de resolver nomes e testar a conectividade entre o

host e o endeço solicitado.
Se um endereço não existir, o host retornará um erro:
$ host esteendereconaoexiste.com
Host esteendereconaoexiste.com not found: 3(NXDOMAIN)
Também é possível fazer uma consulta a um determinado servidor de DNS, bastando

informar o endereço IP do servidor de DNS alvo:
$ host google.com 1.1.1.1

Using domain server:
Name: 1.1.1.1
Address: 1.1.1.1#53
Aliases:
google.com has address 172.217.162.110
google.com has IPv6 address 2800:3f0:4001:815::200e
Se o comando host demorar muito para responder e retornar o seguinte erro, é porque
o endereço IP do servidor de DNS especificado em /etc/resolv.conf não está acessível:
$ host google.com

- 00445518006
Prof. Uirá Ribeiro
;; connection timed out; no servers could be reached
route
$ route [opções] comando alvo
O comando route manipula a tabela de roteamento IP do kernel. Seu principal uso é

configurar rotas estáticas para hosts ou redes especificadas através de uma interface,
após a mesma ter sido configurada com o programa ip.
Tudo que o comando route faz pode ser realizado pelo comando ip.
Se o route for utilizado sem nenhuma opção, exibe a tabela de rotas.
$ route
Tabela de Roteamento IP do Kernel
Destino Roteador MáscaraGen. Opções
Métrica Ref Uso Iface
default ip-172-30-0-1.e 0.0.0.0 UG 0
0 0 eth0
10.8.0.0 ip-10-8-0-2.ec2 255.255.255.0 UG 0
0 0 tun0
ip-10-8-0-2.ec2 0.0.0.0 255.255.255.255 UH 0
0 0 tun0
instance-data.e 0.0.0.0 255.255.255.255 UH 0
0 0 eth0
172.30.0.0 0.0.0.0 255.255.255.0 U 0
0 0 eth0
A mesma informação pode ser vista com o comando ip:
$ ip route show
default via 172.30.0.1 dev eth0
10.8.0.0/24 via 10.8.0.2 dev tun0
10.8.0.2 dev tun0 proto kernel scope link src 10.8.0.1
169.254.169.254 dev eth0
172.30.0.0/24 dev eth0 proto kernel scope link src
172.30.0.46
Em algumas distribuições, o pacote Net-Tools que contém o comando route sequer é

instalado como padrão, sendo preferido o pacote iproute2 que contém o comando
"ip".

00445518006
netstat
$ netstat [opções]
O comando netstat faz parte do antigo pacote legado Net-Tools e exibe as conexões
de rede, tabela de rotas, estatísticas das interfaces etc. Ele foi elegantemente
substituído pelo comando "ss".
Exemplos:
# netstat -anp
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address
Foreign Address State PID/Program name
tcp 0 0 0.0.0.0:3306 0.0.0.0:*
LISTEN 981/mysqld
tcp 0 0 0.0.0.0:8080 0.0.0.0:*
LISTEN 24929/mini-apache:
tcp 0 0 0.0.0.0:8888 0.0.0.0:*
LISTEN 2160/httpd
tcp 0 0 0.0.0.0:3128 0.0.0.0:*
LISTEN 1994/(squid)
tcp 0 0 127.0.0.1:953 0.0.0.0:*
LISTEN 935/named
Neste exemplo o comando netstat lista todas as conexões abertas e processos que
estão à escuta de conexões e à qual processo eles pertencem. A opção "-p" somente
mostra os programas "donos" das conexões para o root.
A opção -i fornece uma estatística de volume de dados trafegados em cada interface:
$ netstat -i
Tabela de Interfaces do Kernel
Iface MTU RX-OK RX-ERR RX-DRP RX-OVR TX-OK TX-ERR
TX-DRP TX-OVR Flg
eth0 9001 34849988 0 0 0 30552900 0
0 0 BMRU
lo 65536 4407543 0 0 0 4407543 0
0 0 LRU
A opção "-r" mostra a tabela de rotas, bem parecido com o comando route:

- 00445518006
Prof. Uirá Ribeiro
$ netstat -rn
Tabela de Roteamento IP do Kernel
Destino Roteador MáscaraGen. Opções MSS
Janela irtt Iface
0.0.0.0 172.30.0.1 0.0.0.0 UG 0
0 0 eth0
10.8.0.0 10.8.0.2 255.255.255.0 UG 0
0 0 tun0
10.8.0.2 0.0.0.0 255.255.255.255 UH 0
0 0 tun0
169.254.169.254 0.0.0.0 255.255.255.255 UH 0
0 0 eth0
172.30.0.0 0.0.0.0 255.255.255.0 U 0
0 0 eth0
O netstat também provê estatísticas das interfaces de rede com a opção "-s":
$ netstat -s
Ip:
8871 total packets received
0 forwarded
0 incoming packets discarded
7997 incoming packets delivered
5023 requests sent out
( ... )
Tudo está sujeito a refatoração.

-- Ward Cunningham

00445518006

- 00445518006
Prof. Uirá Ribeiro
Tópico 5: Segurança e
Permissões de Arquivos
Se você não é teimoso, abandonará experimentos cedo demais.

E se você não é flexível, baterá a cabeça contra a parede e não
verá uma solução diferente para o problema que está tentando
resolver
-- Jeff Bezos

00445518006
5.1 Segurança básica e

identificação de tipos de usuário
A administração das contas de usuário no Linux é relativamente fácil. As contas de

usuário são gravadas em um arquivo especial chamado /etc/passwd.
/etc/passwd
Neste arquivo são gravados os dados como login do usuário, senha, identificador,
grupo a que ele pertence, nome do usuário, diretório home e shell.
O formato do passwd é:
Login:senha:UID:GID:comentário:home:shell
Cada elemento que constitui o conteúdo do arquivo /etc/passwd é separado por dois-
pontos, na seguinte sequência:
Login: O login é a identificação que o usuário vai utilizar no sistema. Este deve ser
único, sem espaços e geralmente uma abreviação do nome. Algumas aplicações
necessitam ter um usuário próprio que definirá as permissões de segurança;
Senha: O x representa a senha do usuário. Nos primórdios do Linux a senha

criptografada era gravada neste campo no lugar do x. Mas como vários aplicativos e
utilitários precisam ter acesso ao conteúdo do arquivo passwd, ele precisa ter
permissões de leitura para todos. Logo se percebeu que não era muito seguro, e a
senha criptografada foi colocada em outro arquivo especial chamado shadow com
permissões de leitura somente para o root. Se a senha não contiver nenhum caracter
(vazio), o login poderá ser permitido sem perguntar senha;
ID do usuário (User ID – UID): Este ID é numérico único para cada conta de usuário.
Por definição o ID zero (0) é designado para o usuário root, que habilita os seus
poderes como administrador do sistema. Por convenção os IDs de 1 a 99 são utilizados
para uso administrativo e contas de usuário utilizadas por serviços do sistema;
ID do Grupo (Group ID – GID): Este é o ID numérico do grupo ao qual o usuário

pertence. Os usuários podem pertencer a grupos de trabalho para facilitar o
compartilhamento de informações e gerência da segurança do sistema. O Group ID -
GID precisa estar cadastrado no arquivo de controle de grupo /etc/group;
Nome do usuário ou comentário: Este campo alfanumérico aceita espaços e é

reservado para o nome do usuário ou qualquer outra observação pertinente;
Diretório Home: O diretório home é diretório padrão para a conta de usuário. É neste
diretório que o dono da conta tem privilégios especiais. Neste campo do arquivo

- 00445518006
Prof. Uirá Ribeiro
passwd deverá ser colocado o caminho completo do diretório home;
Shell: Neste campo é designado o executável do shell que cada usuário utiliza. O
padrão é o Bourne Again Shell /bin/bash. Outros executáveis podem ser utilizados,
como o /bin/sh, /bin/tcsh ou qualquer outro programa que será executado logo após o
processo de logon do usuário. Existem arquivos especiais como o /bin/false. Este
programa simplesmente não faz nada, proibindo o usuário da conta logar no sistema
interativamente. Outra possibilidade é o arquivo /sbin/nologin. Este programa também
não permite que o usuário entre no sistema de forma interativa, mas exibe uma
mensagem que pode ser configurada no arquivo /etc/nologin.txt
As contas de usuário que contém um falso shell como o /bin/false ou /sbin/nologin

geralmente são usadas como contas especiais, utilizadas por programas, como, por
exemplo, para dar acesso limitado aos arquivos. Por exemplo, o servidor Web Apache
utiliza a conta de usuário "apache" para delimitar em quais arquivos o programa httpd
pode ser capaz de gravar.
Já a conta do superusuário root tem características especiais, como o UserID é zero e

grupo zero. Isso confere à conta superpoderes e acesso ilimitado a todos os recursos
do sistema.
Veja um exemplo de contas de usuário no /etc/passwd:
root:x:0:0:root:/root:/bin/bash
apache:x:48:48:Apache:/var/www:/sbin/nologin
openvpn:x:219:497:OpenVPN:/etc/openvpn:/sbin/nologin
zabbix:x:500:501::/home/zabbix:/bin/bash
uira:x:501:501::/home/uira:/bin/bash
/etc/shadow
Antigamente o Linux mantinha as senhas criptografadas no segundo campo do
arquivo /etc/passwd. Como vários programas precisam de acesso às contas do
sistema, as senhas foram movidas para o arquivo /etc/shadow, que não tem
permissão de leitura para ninguém.
Além disso, se todos tem acesso ao arquivo com as senhas criptografadas, um ataque
do tipo força bruta pode ser feito, gerando combinações de palavras, números e
símbolos que são criptografados e comparados com as senhas criptografadas, até que
uma comparação seja positiva. Por isso, o fato de apenas o root ter acesso ao
/etc/shadow dificulta este ataque.
$ ls -l passwd shadow
-rw-r--r-- 1 root root 1573 out 15 02:12 passwd
---------- 1 root root 760 out 15 02:12 shadow

00445518006
As senhas no Linux são criptografadas de uma forma que não é possível recuperação
usando a engenharia reversa.
/etc/group
Para facilitar a administração das permissões de acesso aos recursos e arquivos do
sistema, o Linux faz uso do conceito de grupos de trabalho. Cada usuário faz parte de
pelo menos um grupo de trabalho, definido no /etc/passwd através do campo Group
ID.
Os Grupos de Trabalho e seus respectivos Group IDs são definidos no arquivo

/etc/group:
nomedogrupo:senha:GID:listademembros
Cada coluna separada por dois pontos do arquivo tem o significado a seguir:
Nome do grupo: O nome do grupo precisa ser único no sistema.
Senha do Grupo: Assim como as contas de usuário, os grupos podem também fazer
uso de senha para que um usuário possa ingressar nele. As senhas de grupo foram
criptografadas e movidas para o arquivo /etc/gshadow. Este campo atualmente
contém um "x";
ID do grupo (Group ID ou GID): Cada grupo precisa de um ID numérico inteiro

positivo único. Este ID é referenciado no arquivo /etc/passwd;
Lista de Membros: Os grupos de usuários podem conter um ou mais membros e um

usuário pode ser membro de mais de um grupo. Este campo contém uma lista de
logins de usuários que fazem parte de um grupo.
Algumas distribuições como o Redhat criam um grupo de usuário para cada usuário
criado no sistema. Outras distribuições como o SuSE utilizam o grupo users (GID 100)
para todos os usuários.
Veja um exemplo do /etc/group:
root:x:0:root
daemon:x:10:wwwrun,sendmail,squid
users:x:500:uira,carla
passwd
# passwd [opção] login

- 00445518006
Prof. Uirá Ribeiro
O comando passwd entra com a senha para uma determinada conta de usuário. Se a
conta de usuário não for fornecida como parâmetro o passwd muda a senha da conta
utilizada no momento. Por questões de segurança não é possível passar a senha na
linha de comando.
Somente o root pode alterar a senha de outros usuários. Um usuário comum pode
executar o passwd para alterar a sua própria senha.
Para mudar a senha do usuário uira:
# passwd uira
Enter new password for ‘uira’:
Identificando Qual Usuário Está

Conectado ou Última Conexão
last
O utilitário last, fornece as últimas conexões efetuadas no sistema e por qual usuário:
$ last
ec2-user pts/0 ip-10-8-0-6.ec2. Tue Apr 14 10:21
still logged in
ec2-user pts/0 ip-10-8-0-6.ec2. Mon Apr 13 23:26 -
00:10 (00:43)
ec2-user pts/5 ip-10-8-0-6.ec2. Sun Apr 12 15:52 -
01:50 (09:57)
ec2-user pts/0 ip-10-8-0-6.ec2. Sun Apr 12 15:51 -
01:50 (09:59)
id
O comando id mostra qual é o usuário efetivo e qual é o usuário real no Linux.
Exemplo:
$ id
uid=1000(uiraribeiro) gid=1000(uiraribeiro)
groups=1000(uiraribeiro),4(adm),24(cdrom),27(sudo),30(dip),4
6(plugdev),119(lpadmin),130(lxd),131(sambashare)

00445518006
Observe que o usuário que está logado no Linux é o uiraribeiro, com User ID iqual a
1000. O comando também mostra todos os grupos que o usuário faz parte.
Com a opção "-un" o comando id mostra o User Name (login) do usuário:
$ id -un
uiraribeiro
Com a opção "-u" o id mostra o User ID do usuário.
uiraribeiro@ubuntu:~$ id -u
1000
O comando id também pode mostrar informações de um determinado usuário, quando

o login for informado como parâmetro:
$ id arthur
uid=1001(arthur) gid=1001(arthur) groups=1001(arthur)
Este comando geralmente é útil para ser utilizado em scripts, onde se deseja pegar o
login ou User Id do usuário.
whoami
Este comando mostra qual é o login do usuário corrente. É o mesmo que o comando
"id -un".
$ whoami
uiraribeiro
$ id -un
uiraribeiro
who
$ who
O utilitário who pode ser utilizado para mostrar quais são os usuários logados no
sistema:

- 00445518006
Prof. Uirá Ribeiro
$ who
ec2-user pts/0 2015-04-14 10:21
(ip-10-8-0-6.ec2.internal)
w
$w
O utilitário w também fornece uma lista de quais usuários estão conectados, mas com
outros detalhes:
$ w
12:10:53 up 218 days, 22:52, 1 user, load average: 0,00,
0,01, 0,05
USER TTY FROM LOGIN@ IDLE JCPU
PCPU WHAT
ec2-user pts/0 ip-10-8-0-6.ec2. 10:21 5.00s 0.45s
0.00s w
O comando "w" exibe qual o comando ou programa os usuários estão executando no

momento, bem como a média de uso de CPU em 1, 5 e 15 minutos.
Executando Programas com a

Permissão de Outro Usuário
O Linux permite que você execute algum programa com a permissão de outro usuário
através do utilitário sudo ou assuma outra conta de usuário como se estivesse logado
com ela com o comando su.
sudo
$ sudo [opções] comando
O comando sudo executa um determinado comando como se fosse outro usuário.
Caso o usuário que executou o sudo seja um usuário comum, ele deverá saber a
senha do usuário que deseja executar o comando.
Caso o usuário que executou o sudo seja o root, o sudo não irá perguntar a senha de
nenhum usuário, já que o root tem superpoderes.

00445518006
Exemplo:
# sudo -u uira /bin/mail uiraribeiro@terra.com.br

Subject: teste
Estou mandando uma mensagem como se eu fosse o prof. Uirá
.
EOT
Neste exemplo, o usuário root está mandando um e-mail como se fosse o usuário
“uira”.
Observe que, se outro usuário tentar fazer o sudo executar um programa com as
permissões de outro usuário, o sudo irá solicitar a senha do usuário:
uira@linux-7rxb:~> sudo -u carla /bin/mail

carla’s password:
Neste exemplo, o usuário “uira” está tentando enviar um e-mail como se fosse o
usuário “carla”.
O sudo é útil quando você deseja que algum processo execute com um usuário
específico, de forma que as permissões de arquivos estejam corretas para o perfeito
funcionamento.
su
$ su [opções] [-] [usuário]
O comando su executa o shell como se fosse outro usuário.
Exemplo:
uira@linux-7rxb:~> su -
Password:
Neste exemplo, o usuário “uira” solicita que o Shell seja executado como o usuário
“root”. Desta forma, o usuário “uira” irá ganhar todas as permissões da conta de
superusuário no sistema.
O sinal “-“ faz com que os scripts de carga do shell da conta “root” sejam lidos, como
se o próprio “root” logasse no sistema.
Você também pode especificar um usuário para executar o shell como se fosse ele:

- 00445518006
Prof. Uirá Ribeiro
# su uira -
Neste exemplo, o usuário root irá executar o shell como se fosse o usuário “uira”.
Em sistemas mais seguros, o usuário “root” nunca tem autorização de entrar

diretamente no sistema. Desta forma, os usuários devem logar com suas contas de
acesso e, se precisarem, deverão executar comandos de superusuário utilizando o
“sudo” ou fazendo acesso à conta de root com o “su”.
Para entrar como root, você pode usar o comando:
$ su root -
Neste caso, você precisa saber a senha do usuário root.
Por este motivo, é comum quando um usuário quer ganhar privilégios do root, utiliza-
se o comando:
$ sudo su -
Desta forma, se o seu usuário estiver no grupo que tem permissões para executar o
sudo no arquivo /etc/sudoers, você só precisa autenticar novamente com a sua própria
senha, e não a senha do usuário root. Essa autenticação é só para confirmar que você
é você mesmo. Dependendo da configuração, nem mesmo essa autenticação é
necessária.
5.2 Criando usuários e grupos
Criar, modificar ou apagar usuários no Linux é tão fácil quanto editar manualmente o
arquivo /etc/passwd.
Porém, existem ferramentas que facilitam esse trabalho, como o useradd, groupadd e
passwd.
useradd
# useradd [opções] login
O comando useradd cria contas de usuário no sistema. Seu único parâmetro

obrigatório é o login do usuário.
Se nenhuma opção for fornecida, o comando useradd utilizará as variáveis

configuradas no arquivo /etc/default/useradd. O conteúdo deste arquivo pode variar

00445518006
de acordo com cada distribuição:
$ cat /etc/default/useradd
GROUP=100
HOME=/home
INACTIVE=-1
EXPIRE=
SHELL=/bin/bash
SKEL=/etc/skel
CREATE_MAIL_SPOOL=yes
Se alguma opção for utilizada ao se criar uma conta de usuário com o useradd, ela
será utilizada ao invés da variável correspondente no /etc/default/useradd. As
informações deste arquivo somente serão totalmente ignoradas se todas as opções
correspondentes forem utilizadas ao criar o usuário.
-c “nome do usuário”: Esta opção grava no arquivo passwd o nome do

proprietário da conta ou qualquer outra observação e comentário importantes.
É um campo alfanumérico e deve estar compreendido entre aspas duplas;
-d diretório_home: Esta opção fornece o caminho completo do diretório
home do usuário;
-m: Cria o diretório home fornecido na opção “-d” com os arquivos e estrutura
definidos na configuração de /etc/skel;
-g número_do_grupo: Esta opção fornece o grupo padrão da conta do
usuário;
-s shell: Esta opção deve fornecer o caminho completo do shell utilizado pela
conta. Por exemplo /bin/bash, /bin/tcsh, /bin/false etc.
A senha da conta deverá ser configurada depois de criada a conta o com o comando
passwd.
Exemplos:
# useradd –d /home/uira –m –c “Uirá Ribeiro” –s /bin/bash –g

100 uira
No exemplo o useradd cria o usuário uira com o diretório home /home/uira com a
estrutura definida em /etc/skel, com o nome “Uirá Ribeiro” nos comentários, com o
shell /bin/bash e o grupo GID 100.
Um usuário pode ser criado simplesmente com o comando abaixo, informando apenas
o login. Neste caso as opções do /etc/default/useradd foram usadas para configurar a
conta de usuário

- 00445518006
Prof. Uirá Ribeiro
# useradd arthur
# cat /etc/passwd|grep arthur

arthur:x:1005:100::/home/arthur:/bin/bash
Uma vez criada a conta de usuário, os dados podem ser alterados manualmente,
editando o arquivo /etc/passwd, ou utilizando o comando usermod.
Diretório Padrão (skel)
Ao se criar um novo usuário utilizando o comando useradd, o comando copia os

arquivos de um diretório especial chamado de /etc/skel para o diretório home do
usuário recém criado.
O diretório /etc/skel funciona como um diretório "home" modelo. Quando uma conta
de usuário é criada com o comando useradd, o conteúdo do diretório /etc/skel é
copiado para o diretório HOME do usuário recém criado. Funciona como uma cópia do
"profile" no Windows.
Geralmente neste diretório são colocados os scripts de login do bash que podem ser
customizados, assim como subdiretórios e outros arquivos que se deseja que façam
parte do diretório HOME dos usuários quando eles forem criados no sistema.
$ ls -lga /etc/skel/
-rw-r--r-- 1 root 18 jul 27 2018 .bash_logout
-rw-r--r-- 1 root 193 jul 27 2018 .bash_profile
-rw-r--r-- 1 root 231 jul 27 2018 .bashrc
Como os arquivos de contas de usuário e grupos de usuário são arquivos texto, o

gerenciamento de usuários pode ser feito manualmente, editando estes arquivos com
um editor de textos qualquer. Mesmo assim, o Linux não carece de ferramentas para
administração das contas de usuários.
userdel
# userdel [opção] login
O comando userdel remove a conta de um determinado usuário do sistema. Ele

remove a conta dos arquivos /etc/passwd, /etc/shadow e /etc/group.
A opção disponível é:
-r: Remove o diretório home do usuário junto com a sua conta.

00445518006
-f: Força a remoção do usuário mesmo que ele esteja logado
Exemplo:
# userdel –r arthur
groupadd
# groupadd nome_do_grupo
O comando groupadd cria um novo grupo de usuários.
Este comando grava informações nos arquivos /etc/group e /etc/gshadow.
-f: Força a saída do comando como sucesso mesmo que o nome do grupo ou
groupid já existam;
-g N: Atribui o número N ao Group ID;
-p SENHA: atribui uma senha à um grupo, de forma que um usuário deve saber
a senha para ingressar em um grupo
Exemplos:
Para criar um grupo chamado contabilidade:
# groupadd contabilidade
# cat /etc/group|grep contabilidade

contabilidade:x:1006:
groupdel
# groupdel nome_do_grupo
Este comando apaga um grupo do sistema.
O comando groupdel modifica os arquivos de contas do sistema, apagando todas as

referências ao grupo. O grupo a ser apagado deve existir.

- 00445518006
Prof. Uirá Ribeiro
Deve-se manualmente checar os sistemas de arquivos para garantir que nenhum dos
arquivos permanece com o grupo ou com a sua identificação.
# groupdel contabilidade
5.3 Gerenciando Permissões de

Arquivo e Propriedade
Como o Linux é um sistema operacional multiusuário, as permissões de acesso a

arquivos, diretório e outros dispositivos são necessárias para garantir que os usuários
tenham acesso somente aos recursos para os quais eles podem utilizar.
Estes recursos podem ser desde um simples arquivo até uma impressora ou um
gravador de CD-ROM.
Cada arquivo no Linux tem definido o seu controle de acesso. Este controle é definido
por três classes:
Permissões de usuário: Definem a permissão para o usuário que é o “dono”

do arquivo, quem o criou e o mantém;
Permissões de grupo: Definem a permissão para o grupo de usuários ao
qual o arquivo pertence;
Permissões para outros usuários: Definem a permissão para todos os
outros usuários (não dono e não faz parte do grupo grupo).
Figura 15 - Classes de Permissões

00445518006
E para cada classe podemos definir três tipos de acesso: leitura (r), escrita (w) e
execução (x). Quando não há o acesso para aquele determinado tipo, o sistema
sinaliza com um traço "-".
As trê s primeiras posições da esquerda representam as permissõ es para o usuá rio

dono do arquivo. Quem cria o arquivo é seu dono.
As trê s outras representam as permissõ e s relativas a um grupo (pode ser que o

usuá rio dono pertença ao grupo ou nã o).
As três últimas permissões representa os outros (que nã o é o usuá rio dono do recurso
e nã o pertence ao grupo).
Então, ao tentar acessar um recurso, ou você é o dono do arquivio, ou faz parte do

grupo a qual o arquivo pertence, ou você é "os outros".
Como no Linux tudo é um arquivo, isto facilita muito trabalhar com as permissões, já
que o esquema é o mesmo para tudo. Não importa se você está falando de um
arquivo, diretório, ou recurso de hardware.
Esta divisão cobre praticamente todas as necessidades em termos de segurança.
A opção "-l" do comando ls mostra as permissões dos arquivos:
Figura 16 - ls
Os arquivos podem ser classificados pelo seu tipo:
(-) Arquivo comum

(d) Diretório
(b) Dispositivo de Bloco
(c) Dispositivo de Caractere
(s) Socket
(p) Pipe (condutores)

- 00445518006
Prof. Uirá Ribeiro
(l) Link Simbólico
A primeira letra que aparece na esquerda do "ls -l" indica o tipo de arquivo. Quando
não há letra, mas um traço, o arquivo é comum.
As definições de leitura, escrita e execução tê m nuances diferentes para arquivos e

diretó rios. Veja o quadro a seguir:
Objeto Leitura (r) Escrita (w) Execução (x)
Arquivo Permite ler o Permite alterar o Permite executar o arquivo como

conteúdo do arquivo. conteúdo do arquivo. um programa
Diretório Permite listar o Permite criar, mover, Permite ler e gravar arquivos no
conteúdo do renomear e apagar diretório, bem como mudar o
diretório. arquivos no diretório. diretório corrente para o diretório
com "cd".
As permissões são gravadas em forma binária, com 12 bits para cada arquivo no
sistema, conforme a figura a seguir:
Figura 17 - Bits de Permissões
Os três primeiros bits da esquerda para a direita são bits de atributos especiais, a
saber:
SUID (Set User ID): O bit de SUID afeta somente os arquivos executáveis.
Normalmente os programas são executados com a permissão do usuário que os
executou. O SUID muda esta condição, fazendo com que o programa seja executado
sob as permissões do usuário Dono do arquivo, não importando quem o chamou. O
SUID geralmente é utilizado para dar a um programa permissões de root. É preciso
que o administrador tenha muito cuidado ao utilizar o SUID, pois um programa mal-
intencionado pode ter acesso elevado ao sistema;
SGID (Set Group ID): O bit de SGID funciona como o bit SUID. Ele faz com que os
programas executem sob a permissão de grupo do dono do arquivo. Se aplicado em

00445518006
um diretório, o SGID vai fazer com que todos os arquivos criados debaixo deste
diretório tenham o mesmo grupo do diretório;
Sticky (Colado na memória): O bit especial chamado de sticky ou bit de colado na

memória originalmente fazia com que os programas permaneçam na memória mesmo
depois de terminados. Isto fazia com que os programas executem mais rapidamente
da próxima vez que forem chamados. Este bit quando aplicado em diretórios faz com
que somente o dono do diretório, o dono do arquivo ou o root possam renomear ou
apagar arquivos neste diretório.
Nas implementações recentes no Linux e Unix este bit já não é mais usado para “colar
na memória”, mas para evitar que arquivos que o tenham habilitado de serem
apagados por usuários que não sejam seu dono. Se habilitado em um diretório este bit
confere que seu conteúdo possa somente ser apagado pelos respectivos donos dos
arquivos nele contidos, o próprio dono do diretório ou o root.
Logicamente, o administrador não precisa escrever as permissões em 12 bits. Desta

forma, as permissões podem ser representadas por letras ou em octetos conforme a
tabela a seguir:
Octal Binário Letras Descrição
0 000 — Sem acesso
1 001 —x Somente Execução
2 010 -w- Somente Escrita
3 011 -wr Somente Escrita e Execução
4 100 r— Somente Leitura
5 101 r-x Somente Leitura e Execução
6 110 rw- Somente Leitura e Escrita
7 111 rwx Leitura, Escrita e Execução
Esta representação pode ser utilizada para cada classe (Dono, Grupo e Outros), bem
como para os bits especiais (SUID, SGID, Sticky).
Exemplo:
rwxr-x--- root users Script.sh
No exemplo, o arquivo Script.sh tem permissões de leitura, gravação e execução para

o usuário root, permissões de leitura e execução para o grupo users e nenhuma
permissão para outros usuários que não sejam do grupo users.
As permissões do arquivo Script.sh podem ser representadas pelos octetos 750, sendo
7 para as permissões do dono do arquivo (rwx), 5 para as permissões do Grupo (r-x) e

- 00445518006
Prof. Uirá Ribeiro
0 para as permissões de Outros (—).
Como os bits de permissão especiais são utilizados com pouca frequência, e sob
condições especiais, eles são representados pela letra (s) no lugar do (x) de execução
para os bits SUID e SGID nas classes de Dono do arquivo e Grupo, e (t) no lugar do (x)
para o bit sticky na classe de Outros.
Veja o Exemplo:
rwsr-x--- root users Firewall
O arquivo Firewall tem permissão de leitura, escrita e execução para o usuário root,
leitura e execução para usuários do grupo users e nenhuma permissão como Outros.
E ainda possui o bit de SUID habilitado (o "s" no lugar de "x" para o Dono do arquivo).
Desta forma, o programa Firewall tem poderes de superusuário quando executado, já

que o seu dono é o root. As permissões dele também podem ser representadas pelo
octeto 4750.
Você não precisa decorar a tabela de permissões.
Basta decorar que as permissões de Leitura tem sempre o valor 4.
As permissões de Gravação tem sempre o valor 2 e as permissões de execução

sempre o valor 1.
As três classes de permissões (Dono, Grupo e Outros) são representadas por 3

números.
Se você decompor cada número, vai encontrar as permissões de cada classe. Veja a
figura a seguir:

00445518006
Figura 18 - Permissões em Octetos
Modificando as Permissões de
Arquivos
O comando utilizado para modificar as permissões de arquivos é o chmod. Este

comando aceita a representação das permissões através de letras ou octetos.
chmod
$ chmod [opções] { letras, octal } arquivo
O comando chmod serve para alterar as permissões de arquivos e diretórios.
Ele aceita como parâmetro das permissões:
Octetos: representando as três classes: 777, 750, 640, etc.

Letras: As letras u para usuáro dono, g para grupo e o para outros para

- 00445518006
Prof. Uirá Ribeiro
representar as classes, seguido de símbolos de adição (+), subtração (-) e

igualdade (=) para as operações, e as letras r, w, x, X, s e t.
O esquema de configurar as permissões por octetos é mais simples, pois se

usa apenas três números para configurar as permissões.
Para utilizar letras para configurar as permissões, veja a Tabela Letras para
Representar as Classes:
Letra Descrição
u Dono do Arquivo (Usuário)
g Grupo
o Outros
a Todos
Deve usar um operador, para adicionar, subtrair ou igualdade para configurar as

permissões exatas:
+ Adicionar uma permissão, sem alterar as demais
- Subtrair uma permissão, sem alterar as demais
= Configurar as permissões com exatidão
E por fim, as permissões podem ser representadas pelas letras que você já conhece
(rwx), adicionando o X, s e t:
Permissão Descrição
r Leitura (Read)
w Gravação (Write)
x Execução (eXecute)
X Configura o bit de execução para outras classes para arquivos que já possuem o bit
(x)
s SUID ou SGID
t Sticky
O comando chmod pode ser utilizado com as seguintes opções:
-v: Reporta as permissões dos arquivos, inclusive as permissões alteradas;

-c: Reporta somente as permissões que foram alteradas;

00445518006
-R: Muda as permissões de todos os arquivos e diretórios recursivamente

dentro da mesma hierarquia.
Exemplos de mudança de permissões:
$ chmod 755 Leiame.txt
Muda as permissões do arquivo Leiame.txt para rwx (7) para o Usuário, r-x (5) para o
Grupo e r-x (5) para Outros.
A mesma permissão poderia ser configurada como:
$ chmod u=rwx,go=rx Leiame.txt
Neste exemplo, usou-se o símbolo = para igualar as permissões as letras indicadas.
Para colocar permissões de execução num arquivo, pode-se simplesmente adicionar a

permissão de execução. Como nenhuma classe foi informada, ele irá adicionar as
permissões de execução para todas as classes:
$ chmod +x Backup.sh
Se quisermos adicionar permissões de escrita para o grupo do arquivo, pode-se

adicionar a permissão de escrita:
$ chmod g+w arquivo.txt
Dessa forma o grupo a que pertence este arquivo passa a ter permissão de gravação
no mesmo.
É possível mudar mais de uma permissão ao mesmo tempo, bastando indicar as letras
das permissões (rw):
$ chmod o+rw contabilidade
Também é possível mudar permissões de uma só vez para diversas classes. Neste
exemplo as permissões de escrita e execução são retiradas de todas as classes:
$ chmod ugo-wx arquivosomenteleitura
Fique atento as permissões que usam os operadores de adição (+) e subtração (-),
pois eles adicionam ou subtraem permissões, alterando as permissões que já existem

- 00445518006
Prof. Uirá Ribeiro
para o arquivo. Já o operador de igualdade (=) coloca as permissões exatamente como

indicado.
Aos usuários comuns, o chmod somente permite que o dono do arquivo ou diretório
altere as suas permissões. Já o root pode alterar as permissões de qualquer arquivo ou
diretório.
Deve-se ter muito cuidado ao alterar as permissões dos arquivos e diretórios, pois
permissões mal configuradas é um prato cheio para malwares e invasores.
Alterando o Dono dos Arquivos e

Grupos
Os comandos chown e chgrp alteram o dono dos arquivos e diretórios assim como o
grupo ao qual o arquivo pertence.
chown
$ chown [opções] usuário.grupo arquivo
O comando chown altera o dono do arquivo e pode também alterar o grupo a que este
arquivo pertence.
Ele permite as seguintes opções:
-v: Reporta o dono dos arquivos, inclusive as mudanças de dono;

-c: Reporta somente a mudança de dono;
-R: Muda o dono de todos os arquivos e diretórios recursivamente dentro da
mesma hierarquia.
O comando chown pode receber como parâmetro:
Login
Se somente for informado o login do usuário, a propriedade do Dono do arquivo
muda, mas a propriedade do grupo permanece inalterada.
Login:grupo
Se for informado um "login:grupo" ou "login.grupo", tanto a propriedade do dono
do arquivo quanto o grupo são alterados.
Login:
Se for informado um "login:" ou "login." sem informar o grupo, o dono do
arquivo é alterado, e o grupo é alterado para o grupo em que o login indicado faz
parte.

00445518006
:grupo
Se for informado ":grupo" ou ".grupo" sem informar o login, o chown vai agir
como o comando chgrp, alterando somente o grupo do arquivo.
Exemplos:
Altera o dono do arquivo Leiame.txt para o usuário uira:
$ chown uira Leiame.txt
Altera o dono do arquivo Leiame.txt para o usuário uira e o grupo do arquivo para o
grupo do usuário:
$ chown uira. Leiame.txt
Altera o dono do arquivo Leiame.txt para o usuário uira e o grupo para users:
$ chown uira:users Leiame.txt
Altera o grupo do arquivo para users e deixa inalterado o dono do arquivo:
$ chown .users Leiame.txt
Altera o dono de todos os arquivos e diretórios dentro de /home/uira para o usuário

uira:
$ chown –R uira /home/uira
Um usuário comum somente pode passar a propriedade de arquivos e diretórios dos

quais ele é dono. O usuário root pode alterar a propriedade de qualquer arquivo ou
diretório.
chgrp
$ chgrp [opções] grupo arquivo
O comando chgrp altera o grupo dos arquivos e diretórios.
Pode ser utilizado com as seguintes opções:
-v: Reporta o grupo dos arquivos, inclusive as mudanças de grupo;

- 00445518006
Prof. Uirá Ribeiro
-c: Reporta somente a mudança de grupo;

-R: Muda o grupo de todos os arquivos e diretórios recursivamente dentro da
mesma hierarquia.
Exemplo:
$ chgrp –R users /home
Altera recursivamente o grupo de todos os arquivos e diretórios dentro de /home para

users.
5.4 Diretórios e Arquivos

Especiais
Arquivos temporários
Como todo sistema operacional, o Linux também mantém um diretório específico para
os arquivos temporários. O propósito deste diretório é manter arquivos que vão existir
por um curto período de tempo, geralmente para armazenar dados durante o
processamento de alguma tarefa, cachê de aplicações, conversão de um formato para
outro, etc.
O padrão adotado pela hierarquia padrão do Linux de sistema de arquivos (FHS)

sugere três diretórios:
/tmp
Este diretório pode ser usado por qualquer usuário ou programa. Geralmente, todo seu
conteúdo é apagado na reinicialização do sistema. Observe que as permissões do /tmp
permitem leitura, escrita e gravação para qualquer usuário ou programa:
drwxrwxrwt 11 root 4096 abr 14 15:07 tmp
Como as permissões no diretório /tmp permitem a qualquer um fazer gravação, um

usuário, ou programa, poderia apagar e modificar o conteúdo criado por outro usuário
ou programa.
Para que isso não aconteça, o diretório /tmp ganha o Sticky bit "t", que faz com que os
arquivos e diretórios contidos nele somente possam ser apagados ou modificados pelo
usuário dono do arquivo ou diretório. Assim, todo o mundo pode gravar à vontade,
mas só no que é seu.

00445518006
/var/tmp
O Linux mantém o diretório "/var/tmp" para arquivos temporários, também com o bit
"t", mas os arquivos gravados nele não são apagados quando o computador é
reiniciado.
/run
Este diretório é utilizado para manter as variáveis de tempo de execução dos

programas, como arquivos de identificador de processo (.pid). Este diretório também é
apagado durante o reinicio do sistema.
Links Simbólicos e Hard Links
Os links são arquivos especiais que funcionam como um atalho para outros arquivos e
diretórios. São especialmente úteis quando você deseja espelhar o conteúdo de um
arquivo ou diretório em outro ponto do seu sistema de arquivos.
Os links podem ser de dois tipos:
Links Simbólicos
É um arquivo especial que contém um ponteiro que aponta para outro arquivo. Eles
consomem pouco espaço em disco e possuem a versatilidade de poderem apontar
para arquivos de outro sistema de arquivos, até mesmo quando mapeado de outro
computador em rede.
O link simbólico não tem permissões de acesso próprio, mas assume as permissões do
arquivo original.
Se o arquivo apontado for apagado, o link simbólico fica quebrado, deixando de

funcionar.
Podemos fazer uma analogia com o “atalho” do Windows. Os links simbólicos ocupam
espaço em disco, mesmo que pouco.
Hard Links ou Links Físicos

Os links físicos são na verdade cópias de um mesmo arquivo, mas com nomes
diferentes e possivelmente em diretórios diferentes.
Eles possuem em comum o mesmo conteúdo e as mesmas permissões. É como se um

arquivo tivesse dois nomes.
Se o arquivo original é apagado, o link permanece.
Os links físicos somente podem ser criados para arquivos e em um mesmo sistema de
arquivos, já que eles apontam para o mesmo inode do arquivo original.

- 00445518006
Prof. Uirá Ribeiro
O comando que cria links simbólicos e físicos é o ln.
ln
$ ln [opções] arquivo link
O comando ln pode ser usado para criar links simbólicos ou físicos.
As opções mais utilizadas para o comando ln são:
-s Cria um link simbólico. O padrão do comando ln são links físicos.

-f Força a criação de um link mesmo que este já exista.
Os links simbólicos podem ser criados entre arquivos, ou entre diretórios, mesmo em
discos e sistemas de arquivos diferentes.
Já os links físicos somente podem ser criados entre arquivos de um mesmo sistema de
arquivos em um mesmo volume físico (disco).
Exemplos:
Observe o arquivo quintana, ele tem o contado de links físicos igual a 1:
$ ls -l
-rw-rw-r--. 1 uira uira 177 Set 18 15:09 quintana
Vamos criar o link físico entre arquivo quintana com o nome poema:
$ ln quintana poema
Se observarmos com o ls -l, veremos que o contador de links físicos destes arquivos
passou de 1 para 2.
A contagem de links é a maneira de saber se um arquivo tem um link físico.
$ ls -l
-rw-rw-r--. 2 uira uira 177 Set 18 15:09 poema
-rw-rw-r--. 2 uira uira 177 Set 18 15:09 quintana
Desta forma, é como se o mesmo conjunto de bytes no disco tivessem dois nomes, um
chamado poema e outro chamado quintana. O conteúdo dos dois é o mesmo, e se
alteramos o conteúdo de um, do outro também será alterado, já que o conjunto de
bytes do arquivo é o mesmo.

00445518006
Observe que ambos os arquivos tem as mesmas permissões, mesmos proprietários,

mesmo tamanho e mesma hora.
Se o arquivo quintana for apagado, o arquivo poema permanece, e nenhum dado é

perdido:
$ rm quintana
$ ls -l
Vamos agora criar um link simbólico chamado poesia do arquivo poema:
$ ln -s poema poesia
$ ls -l
lrwxrwxrwx. 1 uira uira 5 Set 18 15:20 poesia -> poema
Veja que o link simbólico cria um apontador para o arquivo original. Ele terá sempre as
permissões "lrwxrwxrwx", e seu tamanho será sempre pequeno (5 bytes).
A seta " -> " e o tipo de arquivo "l" indicam que o arquivo se trata de um link
simbólico.
Você pode editar e alterar o link simbólico como se estivesse alterando o próprio
arquivo, sem problema algum.
Se você apagar o arquivo original, o link ficará quebrado, e deixará de funcionar.

Geralmente o sistema indica colorindo o arquivo original com fundo preto e o link fica
piscando.
$ rm poema
$ ls -l
lrwxrwxrwx. 1 uira uira 5 Set 18 15:20 poesia -> poema
Os links simbólicos ajudam muito a administração do sistema, uma vez que permitem
que "atalhos" para os arquivos sejam criados sem a necessidade direta de se fazer
cópias.
O uso de um link físico permite que vários nomes de arquivos sejam associados ao
mesmo arquivo, uma vez que um link físico aponta para o inode de um determinado
arquivo. É como fazer uma cópia, mas sem de fato duplicar o espaço em disco.

- 00445518006
Prof. Uirá Ribeiro
Outros Livros do Autor

Certificação Linux LPIC-1
Livro para a Prova LPIC-101

00445518006
Livro para a Prova LPIC-102

- 00445518006
Prof. Uirá Ribeiro
Certificação CompTIA Linux+ XK0-004
Livro para a Prova CompTIA Linux+

00445518006
Certificação Red Hat
Livro para Certificação Red Hat EX-200

- 00445518006
Prof. Uirá Ribeiro
Linux para Developers
Livro Desenvolvedores
Se você não falha em pelo menos 90% das vezes, seus objetivos não
foram ambiciosos o suficente
-- Alan Kay

00445518006
Índice Remissívo
1 A
1.1 A evolução do Linux e sistemas Alterando o Dono dos Arquivos e Grupos
operacionais populares 12 186
1.2 Principais Aplicações Open Source 16 apt-get 28
1.3 Software open source e Arquivos tarball 95
licenciamento 43
1.4 Conhecimentos de TIC e o trabalho B
com o Linux 46 bzip2 e bunzip2 93
2 C
2.1 As bases da linha de comando 58 cat 103
2.2 Como obter ajuda na linha de chgrp 187
comando 68 chmod 183
2.3 Como usar diretórios e listar arquivos chown 186
74 Configurar o Cliente DNS 158
2.4 Criar, mover e remover arquivos 84 cp 86
cut 107
3
3.1 Como comprimir arquivos com a linha D
de comando 92 Detalhes sobre os Arquivos e Diretórios
3.2 Como buscar e extrair dados de 78
arquivos 98 Diretório Padrão (skel) 176
3.3 Como transformar comandos em dnf 42
script 111 dpkg 26
4 E
4.1 Escolhendo um Sistema Operacional echo 67
124 Editor de Textos vi/vim 121
4.2 Noções básicas sobre o hardware do Escolhendo o Interpretador de Script #!
computador 127 shebang 111
4.3 Onde os dados são armazenados 131 Executando Programas com a Permissão
4.4 Seu computador na rede 146 de Outro Usuário 172
5 F
5.1 Segurança básica e identificação de find 72
tipos de usuário 166 for 119
5.2 Criando usuários e grupos 174 free 140
5.3 Gerenciando Permissões de Arquivo e
Propriedade 178 G
5.4 Diretórios e Arquivos Especiais 188
Gerenciamento de Arquivos Red Hat e
YUM 30

- 00445518006
Prof. Uirá Ribeiro
Gerenciamento de Pacotes Debian 24 Permissões de Execução 113

grep 109 ping e ping6 155
groupadd 177 Privacidade e Segurança na Internet 56
groupdel 177 ps 132
gzip e gunzip 93 pwd 83
H R
head 105 rm 88
history 65 rmdir 89
host 161 Rodízio de Logs com Logrotate 144
route 162
I rpm 31
Identificando Qual Usuário Está
Conectado ou Última Conexão 170 S
if 118 Serviços de LOG 142
ip 154 sort 105
ss 156
J su 173
Journal do Systemd 144 sudo 172
L T
less 104 tail 105
Links Simbólicos e Hard Links 189 top 138
ln 190 touch 84
locate 72 type 67
ls 81
U
M uptime 141
man 70 useradd 174
mkdir 88 userdel 176
Modificando as Permissões de Arquivos
183 V
mv 87 Variáveis Especiais 114
N W
netstat 163 w 172
wc 108
O who 171
O Comando test 116
Outros Livros do Autor 191 X
xz e unxz 94
P
passwd 169 Y
yum 36

00445518006

Certificacao Linux Essentials PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Certificacao Linux Essentials PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Certificação Linux

Todos os Direitos Reservados

Certiﬁcação Linux Essentials

Guia Para o Exame 010-160 – Versão Revisada e Atualizada

Esta có pia deste Livro está licenciada exclusivamente para:

Fabricio Soares Bicca

Os conceitos emitidos neste livro sã o de inteira responsabilidade do Autor.

O Autor se exclui de quaisquer responsabilidades por eventuais perdas ou danos a

O paradoxo dos agradecimentos é quase impossível de ser completo e aceitavelmente

Aos meus pais, minha gratidão sempre.

Aos milhares de programadores e pessoas que dão o melhor de si ao desenvolverem

Ao companheirismo e apoio das diversas pessoas que foram cruciais em diversas

Uirá Endy Ribeiro

Belo Horizonte, 29 de Março de 2020

Se colocarmos todos os sistemas e linguagens em que prof. Uirá Ribeiro é ﬂuente,

Achando que era pouco, o nosso autor continuou se dedicando ao site

Enquanto restaura a paz na república, mantém seus penguins alimentados e

Também é autor do livro “Sistemas Distribuídos: desenvolvendo aplicações de alta

Em primeiro lugar, você, provavelmente, conhece algo sobre o movimento de

Em reconhecimento ao crescimento fenomenal do sistema operacional GNU/ Linux, o

Assim, se o administrador dominar uma média predeﬁnida desses requisitos, então

O conhecimento de sistemas de GNU/Linux por si só não desenvolve um mestre em

Para aqueles que desejam estudar e desenvolver uma carreira em Administração de

Finalmente, dê as boas-vindas a este livro, pois se trata de um guia relativamente

Não será o ﬁm de sua aprendizagem, mas um BOM começo.

Jon “Maddog” Hall

Diretor executivo Linux International

É possível que ao tentar rodar um determinado comando ou ver o conteúdo de um

Certiﬁcação Linux Essentials .......................................................................................... i

Servidores de E-Mail ........................................................................................... 20

Tópico 2: Encontrando seu caminho em um Sistema Linux ................................... 58

4.3 Onde os dados são armazenados ...................................................................... 131

route .............................................................................................................................. 162

Como se preparar para o

Licenciado para: Fabricio Soares Bicca Proibido copiar/distribuir 1

Às vezes, a vida vai te acertar um tijolo na cabeça.

A Certiﬁcação, além de ser um grande incentivo, garante a entrada e sustentabilidade

A prova testará os conhecimentos do candidato em 5 tópicos:

2 Licenciado para: Fabricio Soares Bicca

Tópico 1: A comunidade Linux e a carreira Open Source

Os exames não tem a intenção de fazer perguntas de dupla interpretação e nem

Este livro também é dividido em 5 capítulos, separados e ordenados conforme o Guia

A certiﬁcação LPI Essentials tem validade para toda a vida.

Como Marcar a Prova?

Existem duas formas de prestar os exames: por computador com agendamento, ou

Onde encontrar um Centro PearsonVue?

Como é o ambiente da prova?

Licenciado para: Fabricio Soares Bicca Proibido copiar/distribuir 3

Outro detalhe importante da prova em computador é que, se você errar alguma

A Importância de Fazer Exercícios

Muitas pessoas me perguntam sobre qual distribuição de Linux é a mais adequada

Só um detalhe importante: você precisará se familiarizar com os gerenciadores de

Aprendendo de Acordo com o Funcionamento do

Veja como são estes estilos e tente se identiﬁcar neles:

4 Licenciado para: Fabricio Soares Bicca

Quando estão aprendendo ou adquirindo capacitação acadêmica, essas pessoas se

Dicas para você aprender melhor:

• Realize seus estudos com montagens e construções de

Quando estão aprendendo ou adquirindo capacitação acadêmica, essas pessoas se

Dicas para você aprender melhor:

• Tente transformar aquilo que você está aprendendo em

Licenciado para: Fabricio Soares Bicca Proibido copiar/distribuir 5

Quando estão aprendendo ou adquirindo capacitação acadêmica, essas pessoas se