Linux - Do - Zero - Livro PDF 2024

Linux do Zero
Copyright © 2020 by Uirá Ribeiro
Todos os Direitos Reservados
Linux do Zero
Guia para Iniciantes
Uirá Ribeiro
ISBN 978-65-990965-1-8
Esta có pia deste Livro está licenciada exclusivamente para:
carmen
79003052549
[email protected]
+351920273542
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 [email protected]
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, 24 de Julho de 2024

Sobre o Autor
O Prof. Uirá Ribeiro é um Executivo Sênior de nível C com sólida formação em

Tecnologia da Informação, Desenvolvedor de Software e Engenheiro Arquiteto da
Internet, com uma carreira de 23 anos. Ele acompanha de perto as tendências em
tecnologia Open Source. Como educador, alcançou o topo, sendo diretor de uma
universidade brasileira por mais de 15 anos.
Ele possui um Mestrado em Informática e Bacharelado em Processamento de Dados,

entre outras quinze certificações de TI, como "AWS Certified Cloud Practitioner", "AWS
Certified Architect", "AWS Certified SysOps", "CompTIA Linux+ce", "Scrum Foundation
Professional Certificate", "Linux Foundation Certified System Administrator", "Linux
Foundation Certified Kubernetes Administrator (CKA)", "CompTIA Project+", "CompTIA
Linux+", "LPIC-3", "CompTIA Security+ce", "RHCSA", "RHCE" e "Red Hat Specialist in
Containers and Kubernetes".
Ele é autor de 11 livros, reconhecidos no mercado mundial de TI, publicados em

inglês, português, espanhol e italiano, como parceiro de publicação do LPI.
CEO e fundador da Edutech Certificação Linux, há 20 anos ministra aulas de Linux

online, com mais de 14.000 alunos certificados.
Ele é o Chair do Board da LPI, uma organização dedicada à promoção e certificação de

habilidades em Linux e tecnologias open source. Como líder do conselho, ele trabalha
para fortalecer as iniciativas da LPI e expandir seu impacto global, garantindo que
profissionais de TI em todo o mundo tenham acesso às melhores certificações e
recursos disponíveis, fomentando a adoção do software livre e desenvolvimento de
carreiras.
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
Chair Emeritus of the Board do LPI

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).
Este livro usa as convenções adotadas pela Linux Stardard Base.
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.
Linux do Zero
Sumário
Linux do Zero .................................................................................................................... i

Agradecimentos .............................................................................................................. iv
Sobre o Autor ................................................................................................................... v
Prefácio ............................................................................................................................ vi
Como aproveitar este livro ao máximo ..................................................................... viii
Tópico 1: Por que estudar Linux? ................................................................................. 1
1.1 A Importância de Estudar Linux para a Carreira Profissional .................... 3
Vantagens de Estudar Linux ................................................................................. 3
Linux no Contexto da TI .......................................................................................... 4
Linux no Cotidiano das Pessoas ............................................................................ 6
1.2 Certificações Linux: Pilar Fundamental para a Carreira em TI .................. 6
O Que São Certificações Linux? ............................................................................ 7
Benefícios das Certificações Linux ........................................................................ 8
Validação de Competências .................................................................................. 8
Aumento da Empregabilidade .............................................................................. 8
Potencial de Salário .............................................................................................. 8
Desenvolvimento Pessoal e Profissional ............................................................... 8
Credibilidade e Reconhecimento .......................................................................... 8
Custos das Certificações Linux ............................................................................. 8
Linux Essentials .................................................................................................... 8
LPIC (Linux Professional Institute Certification) .................................................... 9
RHCE (Red Hat Certified Engineer) ....................................................................... 9
CompTIA Linux+ ................................................................................................... 9
LFCS (Linux Foundation Certified System Administrator) ..................................... 9
Comparação de Certificações Linux ...................................................................... 9
Certificações Linux e a Carreira em TI ................................................................ 10
Início de Carreira ................................................................................................ 10
Avanço na Carreira ............................................................................................. 10
Especialização .................................................................................................... 10
Tópico 2: A comunidade Linux e a carreira Open Source ....................................... 12
2.1 A evolução do Linux e sistemas operacionais populares ................................. 15
Distribuições Linux ................................................................................................ 15
Sistemas Embarcados ............................................................................................ 17
Android .................................................................................................................... 17
Raspberry Pi ............................................................................................................ 17
Linux na Nuvem ...................................................................................................... 17
2.2 Principais Aplicações Open Source ...................................................................... 18
Aplicativos de Escritório ....................................................................................... 18
Navegadores Web .................................................................................................. 18
Multimídia ................................................................................................................ 19
Desenvolvimento de Software ............................................................................. 19
Linguagens de Programação ................................................................................ 19
Programas para Servidor ...................................................................................... 20
ix
Prof. Uirá Ribeiro
Servidores Web ................................................................................................... 21

Apache HTTP Server ........................................................................................... 21
NGINX ................................................................................................................. 21
Servidores de Banco de Dados ........................................................................... 21
Oracle Database ................................................................................................. 21
MySQL ................................................................................................................. 21
PostgreSQL ......................................................................................................... 21
MongoDB ............................................................................................................ 22
Servidores de E-Mail ........................................................................................... 22
NTP - Network Time Protocol .............................................................................. 22
DHCP - Dynamic Host Configuration Protocol ..................................................... 22
DNS - Resolução de Nomes ................................................................................ 23
Servidor de Arquivos ........................................................................................... 23
Servidores de Impressão .................................................................................... 23
Web Proxy e Cachê ............................................................................................. 23
Autenticação ....................................................................................................... 24
Keberos ............................................................................................................... 24
SAMBA ................................................................................................................ 24
LDAP ................................................................................................................... 24
VPN - Virtual Private Network ............................................................................. 24
Monitoramento ................................................................................................... 25
Logging ............................................................................................................... 25
Autoridade de Certificado ................................................................................... 25
SSH - Secure Shell .............................................................................................. 26
Clustering ........................................................................................................... 26
Balanceamento de Carga ................................................................................... 26
Conteineres ........................................................................................................ 26
Gerenciamento de Pacotes Debian ............................................................................ 26
apt-get ............................................................................................................................ 28
Gerenciamento de Arquivos Red Hat e YUM ............................................................. 30
yum .................................................................................................................................. 31
Repositórios no Yum ........................................................................................... 32
dnf ................................................................................................................................... 37
2.3 Ambiente Gráfico .................................................................................................... 38
KDE ..................................................................................................................... 39
GNOME ............................................................................................................... 40
Xfce .................................................................................................................... 42
Cinnamon ........................................................................................................... 44
Linha de Comando .................................................................................................. 45
Usos do Linux na Indústria ................................................................................... 45
Virtualização como motor da inovação ............................................................... 46
Modelos de Computação em Nuvem .................................................................. 46
Infraestrutura como Serviço (IaaS) ..................................................................... 47
Plataforma como Serviço (PaaS) ......................................................................... 48
Software como Serviço (SaaS) ............................................................................ 48
Tópico 3: Encontrando seu caminho em um Sistema Linux ................................... 50
x
Linux do Zero
3.1 As bases da linha de comando ............................................................................. 53

A Linha de Comandos ......................................................................................... 53
Variáveis de Shell ............................................................................................... 55
Uso de Coringas .................................................................................................. 58
history ............................................................................................................................. 59
echo ................................................................................................................................. 61
3.2 Como obter ajuda na linha de comando ............................................................. 62
Help dos Comandos ............................................................................................ 62
Utilizando as Páginas Info ................................................................................... 63
Encontrando a Documentação em /usr/share/doc .............................................. 63
man .................................................................................................................................. 64
locate .............................................................................................................................. 65
Como Localizar Arquivos ..................................................................................... 65
find ................................................................................................................................... 66
3.3 Como usar diretórios e listar arquivos ................................................................ 67
/ .......................................................................................................................... 69
/bin .................................................................................................................... 69
/boot ................................................................................................................... 69
/dev ..................................................................................................................... 69
/etc ..................................................................................................................... 69
/home ................................................................................................................. 70
/lib ....................................................................................................................... 70
/mnt .................................................................................................................... 70
/media ................................................................................................................. 70
/proc ................................................................................................................... 70
/opt ..................................................................................................................... 70
/root .................................................................................................................... 70
/run ..................................................................................................................... 70
/sbin .................................................................................................................... 70
/tmp .................................................................................................................... 71
/usr ..................................................................................................................... 71
/var ..................................................................................................................... 71
Detalhes sobre os Arquivos e Diretórios ................................................................... 72
Arquivos e Diretórios Escondidos ........................................................................ 72
Diretório Corrente e Diretório Anterior ............................................................... 73
Diretório Home ................................................................................................... 74
ls ...................................................................................................................................... 75
pwd .................................................................................................................................. 76
3.4 Criar, mover e remover arquivos ......................................................................... 77
touch ............................................................................................................................... 77
cp ..................................................................................................................................... 79
mv .................................................................................................................................... 80
rm ..................................................................................................................................... 81
mkdir ............................................................................................................................... 82
rmdir ................................................................................................................................ 83
xi
Prof. Uirá Ribeiro
Tópico 4: O Poder da Linha de Comando ................................................................... 84

4.1 Como comprimir arquivos com a linha de comando ......................................... 87
gzip e gunzip .................................................................................................................. 87
bzip2 e bunzip2 ............................................................................................................. 87
xz e unxz ......................................................................................................................... 88
Arquivos tarball ............................................................................................................. 89
4.2 Como buscar e extrair dados de arquivos .......................................................... 92
cat .................................................................................................................................... 97
less .................................................................................................................................. 98
head ................................................................................................................................. 99
tail .................................................................................................................................... 99
sort .................................................................................................................................. 99
wc ................................................................................................................................... 101
grep ............................................................................................................................... 102
Editor de Textos vi/vim .............................................................................................. 104
Nano .............................................................................................................................. 105
Tópico 5: Processos e Rede no Linux ....................................................................... 108
5.1 Processos no Linux ............................................................................................... 110
O que é um processo? ...................................................................................... 110
ps ................................................................................................................................... 111
Usuário dono do processo (UID) ....................................................................... 115
Número de Processo - Process ID (PID) ............................................................. 115
Processo Pai (PPID) ........................................................................................... 115
% de CPU .......................................................................................................... 115
% de Memória ................................................................................................... 115
Hora de início (STIME) ....................................................................................... 116
Tempo de CPU (TIME) ....................................................................................... 116
Linha de comando (CMD) .................................................................................. 116
Terminal (TTY) .................................................................................................. 116
top ................................................................................................................................. 117
free ................................................................................................................................ 119
uptime ........................................................................................................................... 120
Serviços de LOG ........................................................................................................... 121
rsyslog .............................................................................................................. 121
Journal do Systemd ..................................................................................................... 122
journalctl ........................................................................................................... 123
5.2 Rede no Linux ........................................................................................................ 124
Localhost .......................................................................................................... 125
Redes Privadas ................................................................................................. 125
Protocolos que Compõem o TCP/IP ................................................................... 125
Camada de Transporte ..................................................................................... 126
TCP - Transmission Control Protocol ................................................................. 126
UDP - User Datagram Protocol .......................................................................... 126
IP - Internet Protocol ......................................................................................... 126
xii
Linux do Zero
ICMP - Internet Control Message Protocol, ........................................................ 127

Serviços e Portas TCP/IP ................................................................................... 127
Tabelas de Rotas .............................................................................................. 128
IPv6 ......................................................................................................................... 129
/etc/hostname ................................................................................................... 130
/etc/hosts .......................................................................................................... 130
/etc/resolv.conf ................................................................................................. 131
/etc/host.conf .................................................................................................... 131
/etc/nsswitch.conf ............................................................................................. 131
ip .................................................................................................................................... 132
ping e ping6 ................................................................................................................. 133
ss .................................................................................................................................... 134
Configurar o Cliente DNS ........................................................................................... 136
host ................................................................................................................................ 139
route .............................................................................................................................. 140
netstat .......................................................................................................................... 141
Tópico 6: Segurança e Permissões de Arquivos .................................................... 144
6.1 Segurança básica e identificação de tipos de usuário ................................... 147
/etc/passwd ....................................................................................................... 147
/etc/shadow ...................................................................................................... 148
/etc/group ......................................................................................................... 149
passwd .......................................................................................................................... 149
Identificando Qual Usuário Está Conectado ou Última Conexão ......................... 150
last .......................................................................................................................... 150
id ............................................................................................................................. 150
whoami ................................................................................................................... 151
who ................................................................................................................................ 151
w .................................................................................................................................... 152
Executando Programas com a Permissão de Outro Usuário ................................ 152
sudo ............................................................................................................................... 152
su ................................................................................................................................... 153
6.2 Criando usuários e grupos .................................................................................. 154
useradd ......................................................................................................................... 154
Diretório Padrão (skel) ............................................................................................... 156
userdel .......................................................................................................................... 156
groupadd ...................................................................................................................... 157
groupdel ....................................................................................................................... 157
6.3 Gerenciando Permissões de Arquivo e Propriedade ....................................... 158
Modificando as Permissões de Arquivos ................................................................. 163
chmod ............................................................................................................................ 163
Alterando o Dono dos Arquivos e Grupos ............................................................... 166
chown ............................................................................................................................ 166
chgrp ............................................................................................................................. 167
xiii
Prof. Uirá Ribeiro
6.4 Diretórios e Arquivos Especiais .......................................................................... 168

Arquivos temporários ........................................................................................ 168
/tmp .................................................................................................................. 168
/var/tmp ............................................................................................................ 169
/run ................................................................................................................... 169
Links Simbólicos e Hard Links ................................................................................... 169
Links Simbólicos ............................................................................................... 169
Hard Links ou Links Físicos ............................................................................... 169
ln .................................................................................................................................... 170
Outros Livros do Autor ............................................................................................... 172
Índice Remissívo ................................................................................................... 177
xiv
Linux do Zero
Tópico 1: Por que estudar

Linux?
Licenciado para: carmen - Proibido copiar/distribuir 1

79003052549
Prof. Uirá Ribeiro
Licenciado para: carmen - 79003052549 - [email protected]
À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
2 Licenciado para: carmen

79003052549
Linux do Zero
-- Steve Jobs
1.1 A Importância de Estudar Linux para a

Carreira Profissional
Eu sou o Professor Uirá Ribeiro, autor de livros sobre Linux, CEO do Certificação Linux
e Chair do Board do Linux Professional Institute (LPI). No mundo da tecnologia da
informação (TI), onde a inovação e a evolução são constantes, é fundamental estar
atualizado e preparado para enfrentar novos desafios. Entre as diversas tecnologias
que compõem o cenário atual, o Linux destaca-se como um sistema operacional
essencial para profissionais de TI. Neste artigo, discutiremos a importância de estudar
Linux, suas vantagens para a carreira e como ele está integrado ao cotidiano das
pessoas.
Vantagens de Estudar Linux

1. Alta Demanda por Profissionais Qualificados
O mercado de trabalho busca constantemente profissionais qualificados em Linux.
Empresas de todos os tamanhos e setores precisam de especialistas para administrar
servidores, desenvolver soluções e manter a infraestrutura de TI. Certificações como
Linux Essentials e LPIC-1 são altamente valorizadas e podem abrir portas para
oportunidades de emprego.
2. Versatilidade e Flexibilidade
O Linux é conhecido por sua versatilidade e flexibilidade. Ele pode ser utilizado em
diversos dispositivos, desde servidores robustos até dispositivos embarcados,
passando por desktops e dispositivos móveis. Isso permite que profissionais de TI
possam aplicar seus conhecimentos em uma ampla variedade de ambientes e
contextos.
3. Custo-Benefício
Sendo um sistema operacional de código aberto, o Linux oferece uma alternativa
econômica em comparação com sistemas proprietários. Empresas podem reduzir
custos com licenciamento e personalizar o sistema conforme suas necessidades, sem
comprometer a qualidade e a segurança.
4. Segurança e Estabilidade
O Linux é reconhecido por sua segurança e estabilidade. Sua arquitetura permite uma
gestão eficiente de permissões e acesso, além de ser menos suscetível a malwares.
Profissionais que dominam Linux são capazes de implementar soluções seguras e
robustas, essenciais para a proteção de dados e continuidade dos negócios.

79003052549
Prof. Uirá Ribeiro
Linux no Contexto da TI
O Linux desempenha um papel crucial no contexto da TI. Ele é amplamente utilizado

em servidores de grandes empresas, data centers e serviços de nuvem. Plataformas
como Amazon Web Services (AWS), Google Cloud Platform (GCP) e Microsoft Azure
oferecem suporte robusto para o Linux, permitindo que organizações escalem suas
operações com eficiência.
Exemplos de Uso Clássico do Linux
1.Servidores de Web
•A maioria dos servidores web no mundo operam com Linux. Segundo a W3Techs,
aproximadamente 78% dos servidores web utilizam alguma distribuição Linux, como
Ubuntu Server, CentOS ou Red Hat Enterprise Linux (RHEL).
•Apache e Nginx, os dois servidores web mais populares, rodam majoritariamente em

ambientes Linux.
2.Serviços de Nuvem
•Provedores de nuvem como AWS, GCP e Azure oferecem uma ampla gama de
instâncias baseadas em Linux.
•Segundo a Linux Foundation, mais de 90% das cargas de trabalho na nuvem pública
rodam em Linux.
•Empresas como Netflix, Airbnb e Amazon utilizam Linux para suas operações na
nuvem, aproveitando a escalabilidade e a eficiência do sistema.
3.Desenvolvimento de Software
•Ambientes de desenvolvimento e sistemas de controle de versão, como Git, são

otimizados para Linux.
•Containers e orquestradores de containers, como Docker e Kubernetes, foram

desenvolvidos inicialmente para Linux. Kubernetes, por exemplo, é amplamente
utilizado para gerenciar ambientes de microsserviços em nuvem.
4.Computação de Alta Performance (HPC)
•Linux é a escolha predominante em supercomputadores. De acordo com o TOP500,

mais de 90% dos supercomputadores mais rápidos do mundo rodam alguma versão
de Linux.
•Instituições de pesquisa e universidades utilizam Linux para tarefas complexas de

computação, como simulações científicas e análises de big data.
5.Segurança e DevOps
•Ferramentas de automação e DevOps, como Ansible, Puppet e Chef, foram

projetadas para funcionar em ambientes Linux.

79003052549
Linux do Zero
•Profissionais de segurança cibernética utilizam distribuições Linux, como Kali Linux,

para testes de penetração e auditorias de segurança.
O grande uso do Linux nos provedores de cloud computing ressalta ainda mais sua
importância e relevância no cenário tecnológico atual. Empresas líderes em serviços
de nuvem, como Amazon Web Services (AWS), Google Cloud Platform (GCP) e
Microsoft Azure, utilizam Linux extensivamente em suas infraestruturas devido à sua
robustez, segurança, flexibilidade e eficiência de recursos. A predominância do Linux
nestes ambientes se deve à sua capacidade de oferecer suporte a uma ampla gama
de aplicações, desde serviços web e bancos de dados até inteligência artificial e big
data, proporcionando aos provedores de cloud uma plataforma confiável e escalável
para atender às demandas variadas e crescentes de seus clientes. Este cenário
reforça a necessidade de profissionais de TI possuírem habilidades e certificações em
Linux, garantindo a competência necessária para operar e gerenciar esses ambientes
de nuvem críticos.
Provedores de Cloud
1.Amazon Web Services (AWS)
•AWS oferece Amazon Linux, uma distribuição projetada para uso na infraestrutura da
AWS, além de suporte para outras distribuições populares como Ubuntu, CentOS e
RHEL.
•Ferramentas como EC2, Lambda e ECS permitem a criação e gestão de ambientes

Linux na nuvem.
2.Google Cloud Platform (GCP)
•GCP suporta várias distribuições Linux, oferecendo integração com serviços como
Google Kubernetes Engine (GKE) e Compute Engine.
•O Google Cloud Run permite executar contêineres baseados em Linux em uma

plataforma serverless.
3.Microsoft Azure
Em 2001, o então CEO da Microsoft, Steve Ballmer, reclamou que “Linux é um

câncer”. Ele estava se referindo ao fato de que a licença de código aberto do Linux —
a Licença Pública Geral (GPL) — exige que todo o software construído sobre ele seja
transformado em código aberto também.
Passados Vinte anos, é o Linux — não o Windows — o sistema operacional mais

amplamente utilizado no Microsoft Azure.
Atualmente, a Microsoft se esforça consideravelmente para que o Linux funcione da

forma mais suave possível no Azure, de acordo com uma palestra realizada no início
deste ano no Linux Foundation Open Source Summit: “Linux é o sistema operacional
número 1 no Azure hoje”.
Estatísticas Relevantes

79003052549
Prof. Uirá Ribeiro
•De acordo com a Stack Overflow Developer Survey 2020, mais de 55% dos
desenvolvedores profissionais usam Linux como seu sistema operacional de
desenvolvimento principal.
•A Linux Foundation reporta que há uma demanda crescente por profissionais

certificados em Linux, com um aumento de 44% em empregos relacionados a Linux
nos últimos cinco anos.
Além disso, o Linux é a escolha preferida para o desenvolvimento de software e

ambientes de testes. Ferramentas de desenvolvimento, servidores web, bancos de
dados e sistemas de automação frequentemente operam em ambientes Linux,
tornando-o indispensável para desenvolvedores e engenheiros de software.
Linux no Cotidiano das Pessoas
Embora muitas pessoas possam não estar cientes, o Linux está presente no cotidiano
de quase todos nós, especialmente através dos dispositivos Android. O sistema
operacional Android, utilizado em bilhões de smartphones e tablets, é baseado no
kernel Linux. Isso significa que, ao utilizar um dispositivo Android, as pessoas estão
interagindo indiretamente com o Linux.
Além dos dispositivos móveis, muitos roteadores, televisores inteligentes e outros

dispositivos de IoT (Internet das Coisas) operam com sistemas baseados em Linux.
Isso demonstra a onipresença e a importância do Linux na vida moderna.
Estudar Linux é, sem dúvida, uma decisão estratégica para qualquer profissional de TI.
As vantagens incluem alta demanda por profissionais qualificados, versatilidade,
custo-benefício, segurança e estabilidade. No contexto da TI, o Linux é essencial para
servidores, desenvolvimento de software e serviços de nuvem. Além disso, sua
presença no cotidiano das pessoas, especialmente através do Android, ressalta sua
relevância.
Portanto, investir no aprendizado do Linux não só fortalece a carreira de um

profissional de TI, como também abre inúmeras oportunidades em um mercado em
constante evolução. Se você está buscando avançar na sua carreira e se destacar no
mercado, o estudo e a certificação em Linux são passos fundamentais nessa jornada.
1.2 Certificações Linux: Pilar Fundamental

para a Carreira em TI
No dinâmico e competitivo mundo da tecnologia da informação (TI), a busca por

especialização e reconhecimento profissional é constante. As certificações Linux têm
se destacado como um dos principais diferenciadores para profissionais que desejam
se destacar no mercado. Este artigo explora a importância dessas certificações e
como elas podem alavancar a carreira de um profissional de TI.

79003052549
Linux do Zero
O Que São Certificações Linux?

As certificações Linux são credenciais oferecidas por diversas organizações que
validam as habilidades e conhecimentos de um profissional no uso e administração do
sistema operacional Linux. Entre as certificações mais renomadas estão:
Linux Essentials: Oferecida pelo Linux Professional Institute (LPI), é uma

certificação de entrada que valida o conhecimento básico de Linux.
LPIC (Linux Professional Institute Certification): Oferecida pelo Linux
Professional Institute (LPI), reconhecida mundialmente com vários níveis
profissionais:
LPIC-1: Valida conhecimentos básicos e intermediários de Linux.
Necessário fazer 2 exames (101 e 102)
LPIC-2: Valida habilidades avançadas de administração de sistemas
Linux. Necessário fazer 2 exames (201 e 202)
LPIC-3: Alta especialização com quatro áreas diferentes de foco, sendo
um exame somente para cada área foco:
LPIC-3 300: Mixed Environment
LPIC-3 303: Security
LPIC-3 305: Virtualization and Containerization
LPIC-3 306: High Availability and Storage Clusters
RHCSA (Red Hat Certified System Administrator): Também oferecida pela

Red Hat, é uma certificação de nível inicial que valida as habilidades essenciais
para administração de sistemas Red Hat.
RHCE (Red Hat Certified Engineer): Oferecida pela Red Hat, foca em
habilidades práticas de administração de sistemas Red Hat. Precisa ser RHCSA
para ser RHCE.
CompTIA Linux+: Uma certificação vendida pela CompTIA que cobre uma
variedade de distribuições Linux e aspectos fundamentais da administração de
sistemas.
LFCS (Linux Foundation Certified System Administrator): Oferecida pela
Linux Foundation, valida habilidades práticas na administração de sistemas
Linux, abrangendo diversas distribuições.
A diversidade de certificações, como Linux Essentials, LPIC-1, LPIC-2, as várias

especializações LPIC-3, RHCSA, RHCE, CompTIA Linux+ e LFCS, reflete a complexidade
e a profundidade do conhecimento necessário para dominar o Linux. Cada certificação
atende a diferentes níveis de competência e áreas de especialização, proporcionando
aos profissionais de TI uma oportunidade de validar suas habilidades específicas e
aprofundar seus conhecimentos conforme suas carreiras progridem.
O vasto número de certificações disponíveis no mercado para profissionais de Linux é

uma clara demonstração da importância e relevância do Linux no campo da tecnologia
da informação (TI). Com certificações que cobrem desde os fundamentos básicos até

79003052549
Prof. Uirá Ribeiro
habilidades avançadas em áreas especializadas, fica evidente que o Linux é uma

plataforma crítica para uma carreira bem-sucedida em TI.
Benefícios das Certificações Linux

Validação de Competências
As certificações Linux servem como uma prova concreta das habilidades e

conhecimentos do profissional. Elas são obtidas através de exames rigorosos que
cobrem uma ampla gama de tópicos, desde a instalação e configuração do sistema
operacional até a administração de redes e segurança.
Aumento da Empregabilidade
Empresas de todos os portes e setores utilizam o Linux em suas operações, tornando

a demanda por profissionais qualificados cada vez maior. As certificações Linux
tornam os candidatos mais atraentes para os empregadores, pois garantem que o
profissional possui as competências necessárias para administrar e solucionar
problemas em ambientes Linux.
Potencial de Salário
Profissionais certificados frequentemente têm acesso a melhores oportunidades

salariais. As certificações são um indicativo de especialização e compromisso com a
carreira, atributos valorizados pelas empresas. Estudos de mercado mostram que
profissionais certificados em Linux tendem a ganhar salários mais altos em
comparação com aqueles sem certificação.
Desenvolvimento Pessoal e Profissional
O processo de preparação para os exames de certificação exige estudo e prática

intensiva. Isso não apenas amplia o conhecimento técnico do profissional, mas
também desenvolve habilidades importantes, como resolução de problemas,
pensamento crítico e capacidade de aprendizado contínuo.
Credibilidade e Reconhecimento
Ter uma certificação Linux reconhecida internacionalmente confere ao profissional

uma credibilidade que pode ser crucial em um mercado competitivo. É uma forma de
se destacar entre muitos candidatos, especialmente em processos seletivos rigorosos.
Custos das Certificações Linux

Os custos por exame estão expressos em dolar, com cotação em julho de 2024, com
preços para o Brasil.
Se você optar por estudar através de escolas parceiras das instituições provedoras
dos exames, é bem capaz que consiga algum desconto na compra dos exames.
Linux Essentials
$100 por exame.

79003052549
Linux do Zero
LPIC (Linux Professional Institute Certification)
LPIC-1: $165 por exame, sendo dois exames necessários (101-500 e 102-500).
LPIC-2: $165 por exame, sendo dois exames necessários (201-450 e 202-450).
É preciso ser LPIC-1 primeiro.
LPIC-3: $165 por exame, com um exame necessário dependendo da
especialização escolhida. É preciso ser LPIC-2.
RHCE (Red Hat Certified Engineer)
RHCSA: $400.
RHCE: $400, além de ser necessário ter a certificação RHCSA.
CompTIA Linux+
Aproximadamente $369 por exame, sendo um exame necessário (XK0-005).
LFCS (Linux Foundation Certified System Administrator)
Aproximadamente $395 por exame.
Comparação de Certificações Linux

Certificação Vantagens Desvantagens
Linux Essentials • Baixo custo ($100). • Não é suficiente para cargos avançados.
• Introdução básica ao Linux. • Foco limitado em conceitos básicos.
• Boa para iniciantes. • Ideal para desenvolvedores de software
que executam suas aplicações em Linux.
LPIC-1 • Reconhecida mundialmente. • Custo total relativamente alto (aprox.

• Cobre uma ampla gama de $330).
distribuições Linux. • Requer dois exames.
• Base sólida para avançar para
LPIC-2 e LPIC-3.
LPIC-2 • Avança em conhecimentos • Custo total relativamente alto (aprox.

adquiridos no LPIC-1. $330).
• Foco em administração e redes. • Requer dois exames.
• Necessário ter LPIC-1
LPIC-3 • Alta especialização. • Custo total relativamente alto (aprox.

• Valorizada para cargos seniores. $165 por exame).
• Opções de especialização • Necessário ter LPIC-2.
(Segurança, Virtualização, etc.).
RHCSA • Foco prático em Red Hat. • Custo relativamente alto (aprox. $400).
• Boa entrada para carreiras com • Específico para Red Hat.
Red Hat.
• Requisito para RHCE.

79003052549
Prof. Uirá Ribeiro
RHCE • Alta especialização em Red Hat. • Custo relativamente alto (aprox. $400).
• Valorizada para cargos seniores. • Necessário ter RHCSA.
• Foco prático e em problemas do • Específico para Red Hat.
mundo real.
CompTIA Linux+ • Cobre várias distribuições Linux. • Custo relativamente alto (aprox. $369).
• Boa para administradores de • Considerada menos específica em
sistemas gerais. comparação com outras certificações
• Reconhecida em diversas avançadas.
indústrias.
LFCS • Validação prática em várias • Custo relativamente alto (aprox. $395).

distribuições. • Menos focada em aspectos específicos
• Alta flexibilidade em escolher a de uma distribuição.
distribuição para o exame.
• Boa para administradores de
sistemas.
Certificações Linux e a Carreira em TI

Início de Carreira
Para aqueles que estão começando na área de TI, obter uma certificação Linux pode
ser um excelente ponto de partida. Ela fornece uma base sólida de conhecimento e
abre portas para posições de entrada em suporte técnico e administração de
sistemas.
Avanço na Carreira
Profissionais que já possuem experiência na área de TI podem usar as certificações

Linux para avançar em suas carreiras. Elas podem ser um passo importante para
posições mais avançadas, como engenheiro de sistemas, arquiteto de soluções e
especialista em segurança.
Especialização
As certificações Linux permitem que os profissionais se especializem em áreas

específicas, como segurança, redes e DevOps. Isso pode ser particularmente útil em
setores que demandam conhecimentos avançados e especializados.
As certificações Linux são um investimento valioso para qualquer profissional de TI.

Elas não apenas validam habilidades e conhecimentos, mas também aumentam a
empregabilidade, potencial de salário e oportunidades de crescimento na carreira. Em
um mundo onde a tecnologia está em constante evolução, as certificações fornecem
uma forma de manter-se atualizado e competitivo.
Ao considerar a obtenção de uma certificação Linux, os profissionais estão se

posicionando para um futuro de sucesso em uma das áreas mais dinâmicas e
empolgantes da tecnologia da informação.

79003052549
Linux do Zero
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

79003052549
Prof. Uirá Ribeiro
Tópico 2: A comunidade
Linux e a carreira Open
Source

79003052549
Linux do Zero

79003052549
Prof. Uirá Ribeiro
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

79003052549
Linux do Zero
2.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", com consentimento de 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:

79003052549
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).

79003052549
Linux do Zero
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.

79003052549
Prof. Uirá Ribeiro
2.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
Opera, da empresa de mesmo nome

79003052549
Linux do Zero
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
Java

79003052549
Prof. Uirá Ribeiro
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.

79003052549
Linux do Zero
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

79003052549
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 computadores 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

79003052549
Linux do Zero
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

79003052549
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

79003052549
Linux do Zero
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 servido 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

79003052549
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

79003052549
Linux do Zero
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

79003052549
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
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).

79003052549
Linux do Zero
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.
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).

79003052549
Prof. Uirá Ribeiro
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
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;

79003052549
Linux do Zero
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:
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.
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

79003052549
Prof. Uirá Ribeiro
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.
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".

79003052549
Linux do Zero
$ 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
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

79003052549
Prof. Uirá Ribeiro
00:11
(2/2): postgresql-libs-9.0.4-5.fc15.x86_64.rpm | 203 kB
00:00
------------------------------------------------------------
------
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:

79003052549
Linux do Zero
aws-cli noarch 1.7.12-1.3.amzn1 amzn-

updates 604 k
Resumo da transação
=========================================================
====== 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

79003052549
Prof. Uirá Ribeiro
Nome : mysql
Arquitetura : noarch
Versão : 5.5
Lançamento : 1.6.amzn1
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:

79003052549
Linux do Zero
# 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
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:

79003052549
Prof. Uirá Ribeiro
# 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

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.
2.3 Ambiente Gráfico
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

79003052549
Linux do Zero
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
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

79003052549
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

do Projeto GNU. Seu principal contribuidor e mantenedor é a Red Hat.

79003052549
Linux do Zero
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 á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

79003052549
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.

79003052549
Linux do Zero
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

79003052549
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

79003052549
Linux do Zero
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

79003052549
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

79003052549
Linux do Zero
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

79003052549
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.
Em uma visão extrema, o mundo pode ser visto como apenas

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

79003052549
Linux do Zero

79003052549
Prof. Uirá Ribeiro
Tópico 3: Encontrando seu

caminho em um Sistema Linux

79003052549
Linux do Zero

79003052549
Prof. Uirá Ribeiro
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

79003052549
Linux do Zero
3.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.
$ ls –lt --all

79003052549
Prof. Uirá Ribeiro
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).
$ echo $PS1; echo $PS2

79003052549
Linux do Zero
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ém 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.
Estas duas variáveis do shell não afetam como o interpretador irá processar os

79003052549
Prof. Uirá Ribeiro
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
digitar um comando ou tentar rodar um programa que está na pasta corrente não

79003052549
Linux do Zero
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.

79003052549
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 “ertificado”.

79003052549
Linux do Zero
{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 algo é um comando.
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.
O "~" é um atalho para o diretório HOME do usuário logado.
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

79003052549
Prof. Uirá Ribeiro
Você também pode usar o history com o grep para filtrar os comandos:
$ history | grep ssh

144 history |grep ssh
145 ssh [email protected]
148 ssh [email protected]
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 [email protected]
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

79003052549
Linux do Zero
Atalho Descrição
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
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.
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.
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

79003052549
Prof. Uirá Ribeiro
Bom dia Uirá
3.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:
-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

79003052549
Linux do Zero
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.
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.

79003052549
Prof. Uirá Ribeiro
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);
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;

79003052549
Linux do Zero
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;
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, com o comando
updatedb.
Nem sempre o comando locate é instalado como padrão nas distribuições.

79003052549
Prof. Uirá Ribeiro
$ locate passwd
/etc/passwd
/etc/passwd-
/etc/pam.d/passwd
/etc/security/opasswd
/usr/bin/gpasswd
( ... )
Para atualizar o banco de dados do locate, é necessário executar o comando

updatedb de tempos em tempo.
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,
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:

79003052549
Linux do Zero
$ 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:
$ find / -size +50M
3.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

79003052549
Prof. Uirá Ribeiro
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:
Figura 12 - FHS

79003052549
Linux do Zero
/
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.
/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.

79003052549
Prof. Uirá Ribeiro
/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.
/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.

79003052549
Linux do Zero
/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.
/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.

79003052549
Prof. Uirá Ribeiro
/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:
$ 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

79003052549
Linux do Zero
. .. 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
/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 de exemplo
Ou usar o caminho absoluto:
$ cat /home/carlacruz/public_html/arquivo
Este é um arquivo de exemplo
Se quisermos listar o conteúdo do diretório /home, pode-se da mesma forma usar o

79003052549
Prof. Uirá Ribeiro
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 "..".
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:

79003052549
Linux do Zero
$ 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
Este é um arquivo texto de exemplo
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

79003052549
Prof. Uirá Ribeiro
--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
• 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

simbó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.

79003052549
Linux do Zero
$ 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
3.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 arquivo informado
não existir.
As opções mais comuns são:

79003052549
Prof. Uirá Ribeiro
-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
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 -d "09/12" teste1.c

$ ls -l
-rw-rw-r-- 1 ec2-user ec2-user 226 set 12 22:35 teste1.c
-rw-rw-r-- 1 ec2-user ec2-user 0 set 13 22:31 teste1.txt

79003052549
Linux do Zero
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.
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ém 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.
As opções mais frequentes são:
-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

79003052549
Prof. Uirá Ribeiro
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:
$ 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.

79003052549
Linux do Zero
-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 ../
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

79003052549
Prof. Uirá Ribeiro
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. Você precisa ter 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

79003052549
Linux do Zero
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 :
$ 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

79003052549
Prof. Uirá Ribeiro
Tópico 4: O Poder da Linha

de Comando

79003052549
Linux do Zero

79003052549
Prof. Uirá Ribeiro
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

79003052549
Linux do Zero
4.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
compressores convencionais de dados. Ao compactar um arquivo, o bzip2 adiciona o

79003052549
Prof. Uirá Ribeiro
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,
veja o exemplo comparativo do pacote TAR de um arquivo de backup de um site:

79003052549
Linux do Zero
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:
-j: Utiliza o bzip2 para compactar e descompactar os arquivos .tar.bz2;

-J: Utiliza o xz para compactar e descompactar os arquivos .tar.xz

79003052549
Prof. Uirá Ribeiro
-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
Se o arquivo for compactado com o bzip2, ele deve ser descompactado pelo bunzip2
ou utilizar a opção –d do bzip2.

79003052549
Linux do Zero
$ 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:
Extensão Compactador Utilizado Opção do Tar
.tar.gz Gzip $ tar xvzf arquivo.tar.gz

79003052549
Prof. Uirá Ribeiro
Extensão Compactador Utilizado Opção do Tar
.tar.bz2 Bzip2 $ tar xvjf arquivo.tar.bz2
.tar.xz Xz $ tar xvJf arquivo.tar.xz
4.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.
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

79003052549
Linux do Zero
/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
( ... )
O Linux mantém os terminais, mas de forma virtual, que podem ser acessados com a

79003052549
Prof. Uirá Ribeiro
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
0.28s -bash
uiraribe pts/1 10.211.55.2 23:36 1.00s 0.03s
0.00s w

79003052549
Linux do Zero
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 [email protected] < 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":
./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) :

79003052549
Prof. Uirá Ribeiro
$ ./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 [email protected] -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:
$ mail [email protected] -s urgent <<fim

> Olá,
> Este é um email de teste

79003052549
Linux do Zero
> 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.
$ cat texto1.txt > texto.txt

79003052549
Prof. Uirá Ribeiro
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.

79003052549
Linux do Zero
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

79003052549
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
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
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:

79003052549
Linux do Zero
$ 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
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

79003052549
Prof. Uirá Ribeiro
6 6 41
Nossa lista tem 6 itens (um por linha), seis palavras e 41 caracteres.
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:

79003052549
Linux do Zero
$ 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

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

79003052549
Prof. Uirá Ribeiro
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
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
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

79003052549
Linux do Zero
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
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
Nano
$ nano arquivo
Outro editor muito utilizado no Linux, principalmente para iniciantes, é o nano. Ele
lembra um pouco o bloco de notas do Windows, mas para terminal do Linux.

79003052549
Prof. Uirá Ribeiro
O nano é um editor pequeno e amigável. Ele não tem modo de comando. Tudo é
simples como editar textos no Bloco de Notas do Windows.
Para executar o nano:
$ nano arquivo
Os comandos do nano são bem simples, e podem ser acionados com a tecla Control
mais a letra correspondente.
Figura 26 - Nano
Software está comendo o mundo

-- Marc Andreessen

79003052549
Linux do Zero

79003052549
Prof. Uirá Ribeiro
Tópico 5: Processos e Rede

no Linux

79003052549
Linux do Zero

79003052549
Prof. Uirá Ribeiro
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
5.1 Processos no Linux
É 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.
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

79003052549
Linux do Zero
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.
ps
$ ps [opções]
O comando ps gera uma lista com todos os processos em execução e os seus

atributos.

79003052549
Prof. Uirá Ribeiro
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:
$ 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

79003052549
Linux do Zero
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
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

79003052549
Prof. Uirá Ribeiro
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]
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:

79003052549
Linux do Zero
$ 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
(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

79003052549
Prof. Uirá Ribeiro
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
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

79003052549
Linux do Zero
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;
-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;

79003052549
Prof. Uirá Ribeiro
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.
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.

79003052549
Linux do Zero
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;
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

79003052549
Prof. Uirá Ribeiro
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
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:

79003052549
Linux do Zero
$ 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.
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.

79003052549
Prof. Uirá Ribeiro
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)
O exame requer que você tenha a noção da existência de outros dois sistemas de
Logs: syslog e o syslog-ng.
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.

79003052549
Linux do Zero
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.
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

79003052549
Prof. Uirá Ribeiro
$ journalctl /bin/bash
Ou mostrar os registros recentes:
$ 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
5.2 Rede no Linux
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

79003052549
Linux do Zero
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.
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,

79003052549
Prof. Uirá Ribeiro
independentemente da rede física.
Ela garante que os dados tenham níveis de qualidade previamente negociados e que
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

79003052549
Linux do Zero
dados sem conexão e trabalha com o endereçamento dos pacotes e seu roteamento.
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.

79003052549
Prof. Uirá Ribeiro
O arquivo /etc/services define os serviços e as portas conhecidas pelo sistema Linux.

Veja as portas cobradas no exame:
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.

79003052549
Linux do Zero
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

79003052549
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

79003052549
Linux do Zero
/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.

79003052549
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:

79003052549
Linux do Zero
# 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:

79003052549
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]

79003052549
Linux do Zero
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

79003052549
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

79003052549
Linux do Zero
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á

79003052549
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;

79003052549
Linux do Zero
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

79003052549
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".

79003052549
Linux do Zero
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:

79003052549
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

79003052549
Linux do Zero

79003052549
Prof. Uirá Ribeiro
Tópico 6: Segurança e
Permissões de Arquivos

79003052549
Linux do Zero

79003052549
Prof. Uirá Ribeiro
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

79003052549
Linux do Zero
6.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
passwd deverá ser colocado o caminho completo do diretório home;

79003052549
Prof. Uirá Ribeiro
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
As senhas no Linux são criptografadas de uma forma que não é possível recuperação
usando a engenharia reversa.

79003052549
Linux do Zero
/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
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

79003052549
Prof. Uirá Ribeiro
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)
Observe que o usuário que está logado no Linux é o uiraribeiro, com User ID iqual a

79003052549
Linux do Zero
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:

79003052549
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

79003052549
Linux do Zero
nenhum usuário, já que o root tem superpoderes.
Exemplo:
# sudo -u uira /bin/mail [email protected]

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.

79003052549
Prof. Uirá Ribeiro
Você também pode especificar um usuário para executar o shell como se fosse ele:
# 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.
6.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.

79003052549
Linux do Zero
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
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

79003052549
Prof. Uirá Ribeiro
o login. Neste caso as opções do /etc/default/useradd foram usadas para configurar a

conta de usuário:
# 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.

79003052549
Linux do Zero
A opção disponível é:
-r: Remove o diretório home do usuário junto com a sua conta.

-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

79003052549
Prof. Uirá Ribeiro
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.
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
6.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

79003052549
Linux do Zero
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)

79003052549
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

79003052549
Linux do Zero
programas executem sob a permissão de grupo do dono do arquivo. Se aplicado em

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

79003052549
Prof. Uirá Ribeiro
7 para as permissões do dono do arquivo (rwx), 5 para as permissões do Grupo (r-x) e

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:

79003052549
Linux do Zero
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

79003052549
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;

79003052549
Linux do Zero
-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

79003052549
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.

79003052549
Linux do Zero
: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;

79003052549
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.
6.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.

79003052549
Linux do Zero
/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.

79003052549
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.

79003052549
Linux do Zero
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.

79003052549
Prof. Uirá Ribeiro
Outros Livros do Autor

Certificação Linux LPIC-1
Livro para a Prova LPIC-101

79003052549
Linux do Zero
Livro para a Prova LPIC-102

79003052549
Prof. Uirá Ribeiro
Certificação CompTIA Linux+ XK0-004
Livro para a Prova CompTIA Linux+

79003052549
Linux do Zero
Certificação Red Hat
Livro para Certificação Red Hat EX-200

79003052549
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

79003052549
Linux do Zero
Índice Remissívo
2 C
2.1 A evolução do Linux e sistemas cat 97
operacionais populares 14 chgrp 167
2.2 Principais Aplicações Open Source 18 chmod 163
2.3 Ambiente Gráfico 38 chown 166
Configurar o Cliente DNS 136
3 cp 79
3.1 As bases da linha de comando 52
3.2 Como obter ajuda na linha de D
comando 62 Detalhes sobre os Arquivos e Diretórios
3.3 Como usar diretórios e listar arquivos 72
67 Diretório Padrão (skel) 156
3.4 Criar, mover e remover arquivos 77 dnf 37
4 E
4.1 Como comprimir arquivos com a linha echo 61
de comando 86 Editor de Textos vi/vim 104
4.2 Como buscar e extrair dados de Executando Programas com a Permissão
arquivos 92 de Outro Usuário 152
5 F
5.1 Processos no Linux 110 find 66
5.2 Rede no Linux 124 free 118
6 G
6.1 Segurança básica e identificação de Gerenciamento de Arquivos Red Hat e
tipos de usuário 146 YUM 30
6.2 Criando usuários e grupos 154 Gerenciamento de Pacotes Debian 26
6.3 Gerenciando Permissões de Arquivo e grep 102
Propriedade 158 groupadd 157
6.4 Diretórios e Arquivos Especiais 168 groupdel 157
gzip e gunzip 87
A
Alterando o Dono dos Arquivos e Grupos H
166 head 98
apt-get 28 history 59
Arquivos tarball 89 host 139
B I
bzip2 e bunzip2 87 Identificando Qual Usuário Está
Conectado ou Última Conexão 150

79003052549
Prof. Uirá Ribeiro
ip 132
R
J rm 81
rmdir 82
Journal do Systemd 122
route 140
L S
less 98
Serviços de LOG 121
Links Simbólicos e Hard Links 169
sort 99
ln 170
ss 134
locate 65
su 153
ls 75
sudo 152
M T
man 64 tail 99
mkdir 82 top 117
Modificando as Permissões de Arquivos touch 77
163
mv 80 U
uptime 120
N useradd 154
Nano 105 userdel 156
netstat 141
W
O w 152
Outros Livros do Autor 171 wc 101
who 151
P
passwd 149 X
ping e ping6 133 xz e unxz 88
ps 111
pwd 76 Y
yum 31

79003052549

Linux - Do - Zero - Livro PDF 2024

Enviado por

Direitos autorais:

Formatos disponíveis

Linux - Do - Zero - Livro PDF 2024

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

Linux - Do - Zero - Livro PDF 2024

Enviado por

Direitos autorais:

Formatos disponíveis

Linux do Zero

Copyright © 2020 by Uirá Ribeiro

Todos os Direitos Reservados

Guia para Iniciantes

Esta có pia deste Livro está licenciada exclusivamente para:

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, 24 de Julho de 2024

O Prof. Uirá Ribeiro é um Executivo Sênior de nível C com sólida formação em

Ele possui um Mestrado em Informática e Bacharelado em Processamento de Dados,

Ele é autor de 11 livros, reconhecidos no mercado mundial de TI, publicados em

CEO e fundador da Edutech Certiﬁcação Linux, há 20 anos ministra aulas de Linux

Ele é o Chair do Board da LPI, uma organização dedicada à promoção e certiﬁcação de

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

Chair Emeritus of the Board do LPI

É possível que ao tentar rodar um determinado comando ou ver o conteúdo de um

Este livro usa as convenções adotadas pela Linux Stardard Base.

Linux do Zero .................................................................................................................... i

Servidores Web ................................................................................................... 21

3.1 As bases da linha de comando ............................................................................. 53

Tópico 4: O Poder da Linha de Comando ................................................................... 84

ICMP - Internet Control Message Protocol, ........................................................ 127

6.4 Diretórios e Arquivos Especiais .......................................................................... 168

Tópico 1: Por que estudar

Licenciado para: carmen - Proibido copiar/distribuir 1

Às vezes, a vida vai te acertar um tijolo na cabeça.

2 Licenciado para: carmen

1.1 A Importância de Estudar Linux para a

Vantagens de Estudar Linux

Licenciado para: carmen - Proibido copiar/distribuir 3

O Linux desempenha um papel crucial no contexto da TI. Ele é amplamente utilizado

Exemplos de Uso Clássico do Linux

•Apache e Nginx, os dois servidores web mais populares, rodam majoritariamente em

•Ambientes de desenvolvimento e sistemas de controle de versão, como Git, são

•Containers e orquestradores de containers, como Docker e Kubernetes, foram

4.Computação de Alta Performance (HPC)

•Linux é a escolha predominante em supercomputadores. De acordo com o TOP500,

•Instituições de pesquisa e universidades utilizam Linux para tarefas complexas de

•Ferramentas de automação e DevOps, como Ansible, Puppet e Chef, foram

4 Licenciado para: carmen

•Proﬁssionais de segurança cibernética utilizam distribuições Linux, como Kali Linux,

1.Amazon Web Services (AWS)

•Ferramentas como EC2, Lambda e ECS permitem a criação e gestão de ambientes

2.Google Cloud Platform (GCP)

•O Google Cloud Run permite executar contêineres baseados em Linux em uma

Em 2001, o então CEO da Microsoft, Steve Ballmer, reclamou que “Linux é um

Passados Vinte anos, é o Linux — não o Windows — o sistema operacional mais