Apostilapdf - Temp - 052.680.436-09 - Linux LPI - Administracao

Linux LPI - Administração
COD.: 1820_3
Créditos
Copyright © Monte Everest Participações e Empreendimentos Ltda.
Todos os direitos autorais reservados. Este manual não pode ser copiado, fotocopiado, reproduzido,
traduzido ou convertido em qualquer forma eletrônica, ou legível por qualquer meio, em parte ou
no todo, sem a aprovação prévia, por escrito, da Monte Everest Participações e Empreendimentos
Ltda., estando o contrafator sujeito a responder por crime de Violação de Direito Autoral, conforme
o art.184 do Código Penal Brasileiro, além de responder por Perdas e Danos. Todos os logotipos
e marcas utilizados neste material pertencem às suas respectivas empresas.
"As marcas registradas e os nomes comerciais citados nesta obra, mesmo que não sejam assim identificados, pertencem
aos seus respectivos proprietários nos termos das leis, convenções e diretrizes nacionais e internacionais."

Coordenação Geral
Marcia M. Rosa
Coordenação Editorial
Henrique Thomaz Bruscagin
Autoria
Robson Aparecido Ferreira
Revisão Ortográfica e Gramatical

Marcos Cesar dos Santos Silva
Diagramação
Carla Cristina de Souza
Edição nº 1 | 1820_3
Fevereiro/ 2017
4
Sumário
Capítulo 1 - Conceitos básicos .............................................................................................. 17

1.1. Introdução ao GNU/Linux.................................................................... 18
1.1.1. Software livre...................................................................................... 19
1.1.2. Origem do Linux................................................................................. 20
1.1.3. Distribuições GNU/Linux..................................................................... 21
1.1.4. Características herdadas do padrão Unix............................................. 22
1.1.5. Representação por arquivos................................................................ 22
1.1.6. Aspecto case-sensitive........................................................................ 23
1.1.7. Permissão para executar arquivos....................................................... 23
1.1.8. Arquivos e diretórios ocultos............................................................... 23
1.1.9. Divisão em camadas............................................................................ 23
1.1.10. Superusuário (root)............................................................................. 24
1.1.11. Aspecto multitarefa / multiusuário...................................................... 24
1.1.12. Estrutura do Sistema Operacional ....................................................... 24
1.1.13. Shell, Bash e Sessões........................................................................... 25
1.2. Instalação do GNU/Linux..................................................................... 27
1.2.1. Instalação do CentOS ......................................................................... 28
1.2.2. Instalação do Debian .......................................................................... 31
1.2.3. Instalação do Ubuntu ......................................................................... 35
1.2.4. Instalação do Linux Mint .................................................................... 43
1.3. Executando os primeiros comandos.................................................... 44
1.3.1. Iniciando uma sessão (logon).............................................................. 44
1.3.2. Encerrando uma sessão (logout).......................................................... 45
1.3.3. Obtendo ajuda sobre comandos.......................................................... 45
1.3.4. Histórico de comandos........................................................................ 46
1.3.5. Atalhos de teclado utilizados na linha de comando.............................46
1.3.6. Navegação pelos diretórios................................................................. 47
1.3.7. cd....................................................................................................... 47
1.3.8. Exibir o diretório atual de trabalho...................................................... 48
Pontos principais................................................................................................. 49
Material complementar........................................................................................ 49
Mapa mental para fixação do aprendizado .......................................................... 50
Teste seus conhecimentos...................................................................................................... 51
Mãos à obra!................................................................................................................................... 55
Capítulo 2 - Arquitetura do sistema .................................................................................. 59

2.1. Identificar e configurar o hardware...................................................... 60
2.1.1. Detectar dispositivos PCI..................................................................... 60
2.1.2. Detectar dispositivos USB.................................................................... 62
2.1.3. Módulos.............................................................................................. 65
2.1.4. Diretórios /sys e /proc........................................................................ 66
2.1.5. UDEV.................................................................................................. 69
2.1.6. SYSFS.................................................................................................. 70
2.1.7. D-Bus.................................................................................................. 71
2.2. Sistema de boot.................................................................................. 72
2.2.1. SysVinit............................................................................................... 73
2.2.2. SystemD.............................................................................................. 77
2.2.3. Upstart................................................................................................ 79
2.2.4. Eventos do boot.................................................................................. 80
2.3. Níveis de inicialização e desligar/reiniciar o sistema...........................82
2.3.1. Níveis de inicialização e controle dos serviços.....................................82
5
2.3.2. Desligar/reiniciar o sistema................................................................. 84

2.3.3. O comando wall.................................................................................. 86
2.3.4. Encerrar os processos adequadamente................................................ 86
Mãos à obra!................................................................................................................................... 97
Capítulo 3 - Instalação do Linux e gerenciamento de pacotes ............................... 101

3.1. Particionamento do disco.................................................................... 102
3.1.1. Sistemas de arquivos.......................................................................... 105
3.1.2. Conceitos de LVM............................................................................... 107
3.2. Instalando um gerenciador de boot..................................................... 108
3.2.1. Gerenciador de boot GRUB.................................................................. 109
3.2.2. Gerenciador de boot GRUB2................................................................ 114
3.3. Gerenciando bibliotecas compartilhadas.............................................117
3.3.1. Bibliotecas dinâmicas (compartilhadas)............................................... 118
3.3.2. Identificando as bibliotecas dinâmicas................................................ 118
3.3.3. Convenção de nomes.......................................................................... 119
3.3.4. Localização......................................................................................... 121
3.3.5. Utilizando o comando ldconfig............................................................ 121
3.3.6. Variável LD_LIBRARY_PATH.................................................................. 123
3.4. Gerenciador de pacotes .DEB............................................................... 123
3.4.1. Repositórios........................................................................................ 123
3.4.2. Atualizando a lista de repositórios...................................................... 125
3.4.3. Instalação de pacotes.......................................................................... 126
3.4.4. Reconfigurando os pacotes................................................................. 127
3.4.5. Inspecionando o pacote...................................................................... 128
3.4.6. Atualizando pacotes............................................................................ 131
3.4.7. Excluindo pacotes............................................................................... 132
3.5. Gerenciador de pacotes .RPM.............................................................. 135
3.5.1. Arquivos de informações do RPM........................................................ 135
3.5.2. Dependências..................................................................................... 135
3.5.3. Instalando pacotes com o rpm............................................................ 136
3.5.4. Excluindo pacotes com o rpm............................................................. 137
3.5.5. Atualizando pacotes com o rpm.......................................................... 137
3.5.6. Consultando pacotes com o rpm......................................................... 138
3.5.7. Listar o conteúdo de um pacote rpm................................................... 141
3.5.8. Gerenciador de pacotes YUM............................................................... 141
Mãos à obra!................................................................................................................................... 149
Capítulo 4 - Comandos GNU e Unix .................................................................................... 155

4.1. Principais comandos de operação........................................................ 156
4.1.1. Conhecendo o ambiente do shell........................................................ 156
4.1.2. Listando arquivos e diretórios............................................................. 157
4.1.3. Obtendo uma lista detalhada.............................................................. 159
4.1.4. Listando todos os arquivos................................................................. 160
6
Sumário
4.1.5. Listando recursivamente..................................................................... 160

4.1.6. Criando arquivos e diretórios.............................................................. 161
4.1.7. touch.................................................................................................. 161
4.1.8. mkdir.................................................................................................. 162
4.1.9. Excluindo arquivos e diretórios........................................................... 162
4.1.10. rm....................................................................................................... 163
4.1.11. rmdir.................................................................................................. 164
4.1.12. Copiando arquivos e diretórios........................................................... 164
4.1.13. Renomeando e movendo arquivos e diretórios....................................165
4.1.14. Utilizando caracteres curinga.............................................................. 166
4.1.15. Redirecionando a saída e entrada de dados.........................................167
4.1.16. Redirecionador > ou 1>....................................................................... 168
4.1.17. Redirecionador 2>............................................................................... 169
4.1.18. Redirecionador &>.............................................................................. 170
4.1.19. Redirecionador &&.............................................................................. 170
4.1.20. Redirecionador ||................................................................................. 171
4.1.21. Redirecionador >>............................................................................... 171
4.1.22. Redirecionador 2>>............................................................................. 172
4.1.23. Redirecionador <................................................................................. 173
4.1.24. Redirecionador <<............................................................................... 174
4.1.25. Redirecionador |.................................................................................. 175
4.1.26. tee...................................................................................................... 175
4.1.27. Visualizando arquivos e diretórios....................................................... 176
4.1.28. Exibindo a estrutura de um diretório em árvore..................................177
4.1.29. Exibindo e concatenando o conteúdo de arquivos...............................177
4.1.30. more................................................................................................... 179
4.1.31. less..................................................................................................... 181
4.1.32. head................................................................................................... 182
4.1.33. tail...................................................................................................... 183
4.1.34. Preparando um arquivo de texto para impressão.................................184
4.1.35. paste................................................................................................... 185
4.1.36. join..................................................................................................... 186
4.1.37. Exibindo linhas repetidas de um arquivo............................................. 187
4.1.38. od....................................................................................................... 189
4.1.39. hexdump............................................................................................ 189
4.1.40. Exibindo a quantidade de linhas, palavras e caracteres de um arquivo.190
4.1.41. Classificação numérica ou alfabética................................................... 191
4.1.42. Exibindo linhas de texto na tela.......................................................... 192
4.1.43. grep.................................................................................................... 192
4.1.44. egrep.................................................................................................. 194
4.1.45. fgrep................................................................................................... 194
4.1.46. sed..................................................................................................... 195
4.1.47. Obtendo colunas de uma tabela.......................................................... 195
4.1.48. Determinando o tipo de arquivo.......................................................... 197
4.1.49. Substituindo e excluindo caracteres de um arquivo.............................197
4.1.50. Numerando arquivos........................................................................... 199
4.1.51. Formatando parágrafos de arquivos.................................................... 200
4.1.52. Links................................................................................................... 201
4.1.53. Inodes................................................................................................. 201
4.1.54. Link simbólico..................................................................................... 201
4.1.55. Link físico (hardlink)............................................................................ 201
4.1.56. Criando links....................................................................................... 202
7
4.1.57. expand............................................................................................... 203

4.1.58. unexpand........................................................................................... 204
4.1.59. Dividindo um arquivo em partes......................................................... 204
4.1.60. Administração diária do sistema......................................................... 206
4.1.61. Exibindo o espaço em disco................................................................ 206
4.1.62. Exibindo o tamanho de arquivos, diretórios e partições.......................207
4.1.63. Exibindo o consumo de memória RAM................................................ 208
4.1.64. Exibindo/configurando a data e hora do sistema.................................209
4.1.65. Exibindo o tempo de uso do computador............................................ 209
4.1.66. Exibindo a versão e a arquitetura do sistema......................................209
4.1.67. Exibindo a diferença entre arquivos.................................................... 210
4.1.68. Exibindo o tempo necessário para um comando ser executado...........210
4.1.69. find..................................................................................................... 211
4.1.70. locate.................................................................................................. 213
4.1.71. updatedb............................................................................................ 214
4.1.72. sleep................................................................................................... 215
4.1.73. logger................................................................................................. 215
4.1.74. xargs.................................................................................................. 215
4.1.75. seq..................................................................................................... 216
4.1.76. tar....................................................................................................... 216
4.1.77. cpio.................................................................................................... 218
4.1.78. gzip.................................................................................................... 220
4.1.79. Família de comandos do gzip.............................................................. 222
4.1.80. bzip2.................................................................................................. 223
4.1.81. Família de comandos do bzip2............................................................ 225
4.1.82. gunzip................................................................................................ 225
4.1.83. bunzip2.............................................................................................. 226
4.1.84. Considerações sobre backup de dados................................................ 227
4.2. Gerenciando processos no sistema...................................................... 229
4.2.1. Principais propriedades de um processo............................................. 229
4.2.2. Listando processos............................................................................. 231
4.2.3. ps.232
4.2.4. pidof................................................................................................... 237
4.2.5. pstree................................................................................................. 238
4.2.6. top...................................................................................................... 238
4.2.7. htop.................................................................................................... 241
4.2.8. Controlando o nível de execução dos processos..................................242
4.2.9. CTRL + Z............................................................................................. 242
4.2.10. &.. 242
4.2.11. jobs.................................................................................................... 243
4.2.12. Comando bg....................................................................................... 244
4.2.13. Comando fg........................................................................................ 244
4.2.14. Alterando o comportamento dos processos.........................................245
4.2.15. kill...................................................................................................... 245
4.2.16. killall................................................................................................... 246
4.2.17. nice..................................................................................................... 246
4.2.18. renice................................................................................................. 247
4.2.19. nohup................................................................................................. 248
4.2.20. screen................................................................................................. 249
4.2.21. pgrep.................................................................................................. 249
4.2.22. pkill.................................................................................................... 250
4.3. Editor de texto vim.............................................................................. 251
8
Sumário
4.3.1. Modos de comandos e de edição......................................................... 252

4.3.2. Utilizando o vim.................................................................................. 252
4.3.3. Alternando entre o modo de comandos e o modo de edição...............253
4.3.4. Gerenciando arquivos......................................................................... 253
4.3.5. Automatizando tarefas........................................................................ 254
4.3.6. Navegando pelos arquivos.................................................................. 255
4.3.7. Realizando buscas.............................................................................. 256
4.3.8. Outros comandos úteis....................................................................... 257
4.3.9. O arquivo vimrc.................................................................................. 257
Mãos à obra!................................................................................................................................... 267
Capítulo 5 - Dispositivos, Sistemas de arquivos e FHS .............................................. 293

5.1. Criando partições e sistemas de arquivos............................................ 294
5.1.1. fdisk................................................................................................... 294
5.1.2. cfdisk.................................................................................................. 296
5.1.3. Sistema de arquivos............................................................................ 298
5.1.4. Estrutura básica.................................................................................. 298
5.1.4.1. Bloco de boot...................................................................................... 298
5.1.4.2. Superbloco.......................................................................................... 299
5.1.4.3. Tabela de inodes................................................................................. 299
5.1.4.4. Bloco de dados.................................................................................... 300
5.1.5. Tipos de sistemas de arquivos GNU/Linux...........................................300
5.1.5.1. Second Extended File System (ext2).................................................... 300
5.1.5.2. ext3.................................................................................................... 301
5.1.5.3. ext4.................................................................................................... 302
5.1.5.4. reiserfs............................................................................................... 302
5.1.5.5. xfs...................................................................................................... 303
5.1.6. Montando dispositivos........................................................................ 303
5.1.7. mount................................................................................................. 304
5.1.8. umount............................................................................................... 305
5.1.9. /etc/fstab........................................................................................... 305
5.1.10. Particionando discos........................................................................... 307
5.1.11. UUID (Universally Unique Identifier)..................................................... 308
5.1.12. Partição swap...................................................................................... 309
5.1.13. Aplicando um sistema de arquivos...................................................... 310
5.1.14. mkfs................................................................................................... 310
5.1.15. mke2fs............................................................................................... 311
5.1.16. mkreiserfs........................................................................................... 312
5.1.17. mkfs.xfs.............................................................................................. 314
5.1.18. Manutenção do sistema de arquivos.................................................... 315
5.1.19. fsck..................................................................................................... 315
5.1.20. e2fsck................................................................................................. 316
5.1.21. reiserfsck............................................................................................ 316
5.1.22. xfs_repair............................................................................................ 317
5.1.23. debugfs.............................................................................................. 318
5.1.24. dumpe2fs........................................................................................... 320
5.1.25. tune2fs............................................................................................... 321
5.2. Árvore de diretórios FHS..................................................................... 323
9
5.2.1. Diretórios............................................................................................ 323

5.2.2. Hierarquia de diretórios...................................................................... 323
5.2.3. FHS..................................................................................................... 324
5.2.4. Distinção dos diretórios...................................................................... 325
5.2.5. Estrutura de diretórios........................................................................ 326
5.2.5.1. /bin.................................................................................................... 327
5.2.5.2. /boot.................................................................................................. 328
5.2.5.3. /dev.................................................................................................... 329
5.2.5.4. /etc..................................................................................................... 329
5.2.5.5. /lib..................................................................................................... 330
5.2.5.6. /media................................................................................................ 330
5.2.5.7. /mnt................................................................................................... 330
5.2.5.8. /opt.................................................................................................... 331
5.2.5.9. /sbin................................................................................................... 331
5.2.5.10. /srv..................................................................................................... 332
5.2.5.11. /tmp................................................................................................... 332
5.2.5.12. /usr.................................................................................................... 332
5.2.5.13. /var..................................................................................................... 333
5.2.5.14. Diretórios opcionais............................................................................ 334
5.2.5.15. Diretórios especiais............................................................................. 334
5.3. Configuração de cota de disco............................................................ 336
5.3.1. Preparando o sistema para a configuração de cotas............................336
5.3.2. Configurando cotas para usuários e grupos........................................338
5.3.3. quotacheck......................................................................................... 338
5.3.4. edquota.............................................................................................. 338
5.3.4.1. Cotas por bloco e por inode................................................................ 339
5.3.5. repquota............................................................................................. 340
5.3.6. quotaon.............................................................................................. 340
5.3.7. quotaoff.............................................................................................. 341
5.3.8. quota.................................................................................................. 342
5.4. Documentação.................................................................................... 342
5.4.1. Documentação.................................................................................... 343
5.4.2. HOW-TOs............................................................................................ 343
5.4.3. Manuais (man pages).......................................................................... 343
5.4.4. Documentações em /usr/share/doc.................................................... 345
5.4.5. Comandos de ajuda e acesso às documentações.................................345
5.4.6. help.................................................................................................... 345
5.4.7. manpath............................................................................................. 346
5.4.8. man.................................................................................................... 346
5.4.9. apropos.............................................................................................. 349
5.4.10. whatis................................................................................................. 350
5.4.11. info..................................................................................................... 350
5.4.12. whereis............................................................................................... 351
5.4.13. which.................................................................................................. 352
5.4.14. Ferramentas para consulta de documentações....................................352
5.4.15. Outras documentações on-line............................................................ 352
5.4.16. The Linux Documentation Project........................................................ 353
Mãos à obra!................................................................................................................................... 363
10
Sumário
Capítulo 6 - Shell script e gerenciamento de dados .................................................... 375

6.1. Gerenciando o shell............................................................................ 376
6.1.1. Tipos de shell..................................................................................... 376
6.1.2. Variáveis............................................................................................. 377
6.1.2.1. Definindo variáveis.............................................................................. 378
6.1.3. Visualizando variáveis......................................................................... 379
6.1.3.1. env..................................................................................................... 379
6.1.3.2. set...................................................................................................... 380
6.1.4. Retornando o valor de variáveis........................................................... 380
6.1.5. Excluindo variáveis.............................................................................. 380
6.1.6. Alterando o prompt de comando......................................................... 381
6.1.7. Arquivos de configuração do shell....................................................... 382
6.1.8. Alterando o shell atual........................................................................ 383
6.1.9. Utilizando aliases................................................................................ 383
6.1.10. Arquivos para exibição de mensagens................................................. 384
6.1.11. .bash_history...................................................................................... 384
6.2. Shell Script.......................................................................................... 386
6.2.1. Criando scripts.................................................................................... 387
6.2.2. Fornecimento de parâmetros............................................................... 388
6.2.3. Instruções condicionais....................................................................... 390
6.2.3.1. if-then................................................................................................ 390
6.2.3.2. Loops.................................................................................................. 392
6.2.3.3. case.................................................................................................... 394
6.2.4. test..................................................................................................... 395
6.2.5. read.................................................................................................... 396
6.2.6. Operadores......................................................................................... 397
6.3. Gerenciamento de dados..................................................................... 399
6.3.1. Inserindo dados.................................................................................. 400
6.3.2. Consultando dados............................................................................. 401
6.3.2.1. SELECT................................................................................................ 401
6.3.2.2. WHERE................................................................................................ 402
6.3.2.3. ORDER BY........................................................................................... 403
6.3.2.4. GROUP BY........................................................................................... 404
6.3.2.5. INNER JOIN.......................................................................................... 405
6.3.3. Atualizando dados.............................................................................. 406
6.3.4. Excluindo dados.................................................................................. 407
Mãos à obra!................................................................................................................................... 415
Capítulo 7 - Interface do usuário e desktop ................................................................... 423

7.1. Servidor X - Interface gráfica............................................................... 424
7.1.1. Verificando os dispositivos de hardware compatíveis..........................425
7.1.2. Instalando o servidor X....................................................................... 425
7.1.3. Iniciando o servidor X......................................................................... 425
7.1.4. Configurando o servidor X.................................................................. 426
7.1.5. Seções do arquivo xorg.conf............................................................... 426
7.1.6. Instalando fontes................................................................................ 428
7.1.7. Variável DISPLAY................................................................................. 429
7.1.8. Gerenciadores de display (display managers)......................................431
11
7.1.9. Gerenciadores de janela (window managers).......................................433

7.1.10. Exibindo informações sobre um servidor X..........................................433
7.1.11. Exibindo informações sobre janelas.................................................... 435
7.1.12. Controlando o acesso ao servidor X.................................................... 436
7.1.13. Utilizando um servidor X aninhado...................................................... 437
7.2. Acessibilidade..................................................................................... 437
7.2.1. Assistente de digitação....................................................................... 440
7.2.2. Necessidade visuais............................................................................ 440
7.2.3. GNOME Onscreen Keyboard................................................................ 442
Mãos à obra!................................................................................................................................... 449
Capítulo 8 - Tarefas administrativas .................................................................................. 463

8.1. Administração de usuários e grupos................................................... 456
8.1.1. Tipos de usuário................................................................................. 456
8.1.2. Permissões de acesso a arquivos e diretórios......................................457
8.1.3. Tipos de permissões........................................................................... 458
8.1.4. Atribuindo permissões........................................................................ 460
8.1.5. umask................................................................................................. 463
8.1.6. SUID e SGID......................................................................................... 465
8.1.7. Arquivos de administração de usuários e grupos.................................466
8.1.7.1. /etc/passwd........................................................................................ 466
8.1.7.2. /etc/shadow....................................................................................... 467
8.1.7.3. /etc/group.......................................................................................... 467
8.1.7.4. /etc/gshadow..................................................................................... 468
8.1.8. Administrando usuários...................................................................... 468
8.1.8.1. Obtendo informações sobre o usuário................................................. 469
8.1.8.2. Criando usuários................................................................................. 471
8.1.8.3. Alterando configurações de usuários................................................... 476
8.1.8.4. Criando e alterando senhas dos usuários............................................ 478
8.1.8.5. Excluindo usuários.............................................................................. 484
8.1.9. Administran do grupos....................................................................... 484
8.1.9.1. Exibindo os grupos de um usuário...................................................... 485
8.1.9.2. Alterando o dono e grupo de arquivos e diretórios..............................485
8.1.9.3. Criando e alterando grupos................................................................. 487
8.1.9.4. Excluindo grupos................................................................................ 489
8.1.9.5. Definindo a senha de um grupo e adicionando/excluindo seus membros..489
8.1.9.6. Efetuando o login em um grupo diferente...........................................490
8.1.9.7. Convertendo senhas do /etc/group para /etc/gshadow e vice-versa....491
8.2. Agendamento de tarefas..................................................................... 493
8.2.1. Agendamento cron.............................................................................. 493
8.2.2. Utilizando o comando crontab............................................................ 495
8.2.3. Agendamento at................................................................................. 496
8.2.4. Agendamento anacron........................................................................ 497
8.3. Localização e internacionalização........................................................ 499
8.3.1. Comando locale.................................................................................. 499
8.3.2. Comando tzselect............................................................................... 501
8.3.3. Comando timedatectl.......................................................................... 501
8.3.4. Comando date.................................................................................... 502
12
Sumário
8.3.5. Comando iconv................................................................................... 503

Mãos à obra!................................................................................................................................... 511
Capítulo 9 - Serviços essenciais do sistema ................................................................... 519

9.1. Servidor NTP....................................................................................... 520
9.1.1. Configuração de data e hora do sistema e da BIOS..............................520
9.1.2. Comando hwclock............................................................................... 521
9.1.3. Configuração de data e hora com NTP................................................. 521
9.1.4. ntpdate............................................................................................... 522
9.1.5. ntpd.................................................................................................... 523
9.1.6. Configuração do servidor NTP............................................................. 524
9.2. Configuração do serviço de log........................................................... 526
9.2.1. Daemons de log.................................................................................. 528
9.2.2. rsyslogd.............................................................................................. 528
9.2.3. Mais funções do rsyslog...................................................................... 529
9.2.4. Configurando o serviço de log............................................................ 529
9.2.5. Configurando um servidor de logs...................................................... 533
9.2.6. Configurando um cliente de um servidor de logs................................533
9.2.7. Configurando a rotação de logs.......................................................... 535
9.2.8. Criando mensagens de log manualmente............................................537
9.2.9. Monitorando as mensagens de log do sistema....................................537
9.2.10. Syslog-ng............................................................................................ 538
9.3. Agente MTA........................................................................................ 539
9.3.1. Instalação do Postfix........................................................................... 540
9.3.2. Configuração do Postfix...................................................................... 540
9.3.3. Redirecionamento de e-mails.............................................................. 541
9.3.4. Envio de e-mails.................................................................................. 541
9.3.5. Verificar fila de e-mails........................................................................ 542
9.4. Serviço de impressão CUPS.................................................................. 542
9.4.1. Instalando o CUPS............................................................................... 542
9.4.2. Configurando por meio da interface Web............................................ 542
9.4.3. Configurando pela linha de comando.................................................. 546
9.4.4. Arquivos de configuração do CUPS...................................................... 548
9.4.5. Configurando clientes de impressão................................................... 548
9.4.6. Gerenciando a impressão.................................................................... 550
Mãos à obra!................................................................................................................................... 561
Capítulo 10 - Fundamentos de rede ................................................................................... 573

10.1. Introdução a rede de computadores.................................................... 574
10.1.1. Componentes básicos de uma rede..................................................... 575
10.1.1.1. Cabeamento........................................................................................ 575
10.1.1.2. Adaptadores de redes......................................................................... 575
10.1.1.3. Protocolos........................................................................................... 576
10.1.2. Integrantes de uma rede..................................................................... 576
13
10.1.3. Identificando os integrantes de uma rede............................................ 577

10.1.4. Protocolos de rede.............................................................................. 578
10.1.5. TCP..................................................................................................... 578
10.1.6. UDP.................................................................................................... 581
10.1.7. ICMP................................................................................................... 582
10.1.8. O protocolo TCP/IP............................................................................. 583
10.1.9. Endereçamento IP................................................................................ 584
10.1.10. Classes IP............................................................................................ 585
10.1.11. Endereços especiais............................................................................ 585
10.1.12. Máscaras de rede................................................................................ 586
10.1.13. Broadcast............................................................................................ 587
10.1.14. Multicast............................................................................................. 587
10.1.15. ARP..................................................................................................... 587
10.1.16. Network Address Translation (NAT)..................................................... 588
10.1.17. IPv6..................................................................................................... 588
10.2. Conceitos e serviços de rede TCP/IP.................................................... 589
10.2.1. Serviços de rede.................................................................................. 590
10.2.2. Configurando o inetd.......................................................................... 591
10.2.3. Configurando o xinetd........................................................................ 592
10.2.4. Telnet................................................................................................. 594
10.3. Configuração de rede.......................................................................... 596
10.3.1. Verificando o status da interface de rede............................................. 597
10.3.2. Configurando o endereço IP e a máscara de rede................................597
10.3.3. Comando ip........................................................................................ 601
10.3.4. Definindo um gateway padrão............................................................. 601
10.3.5. Configurando o servidor DNS.............................................................. 603
10.3.5.1. Resolvendo nomes a partir do DNS...................................................... 604
10.3.5.2. Definindo um servidor de DNS............................................................ 604
10.3.6. Outros arquivos de configuração......................................................... 605
10.3.6.1. /etc/host.conf..................................................................................... 605
10.3.6.2. /etc/networks..................................................................................... 606
10.3.6.3. /etc/hostname.................................................................................... 606
10.3.6.4. /etc/nsswitch.conf.............................................................................. 607
10.3.7. Configuração estática da rede............................................................. 607
10.3.7.1. Definindo as alterações feitas no arquivo interfaces............................609
10.3.8. Monitorando e reparando problemas de rede......................................612
10.3.8.1. ping.................................................................................................... 612
10.3.8.2. dig...................................................................................................... 613
10.3.8.3. host.................................................................................................... 614
10.3.8.4. netstat................................................................................................ 615
10.3.8.5. traceroute........................................................................................... 616
10.3.8.6. tracepath............................................................................................ 617
Mãos à obra!................................................................................................................................... 625
14
Sumário
Capítulo 11 - Segurança ........................................................................................................... 637

11.1. TCP wrapper....................................................................................... 630
11.1.1. Controle de acesso aos serviços.......................................................... 630
11.1.2. tcpdump............................................................................................. 632
11.1.3. Comando fuser................................................................................... 634
11.1.4. Comando lsof..................................................................................... 634
11.1.5. Comando sudo.................................................................................... 635
11.1.6. Comando last...................................................................................... 636
11.1.7. Arquivos com permissões especiais.................................................... 637
11.2. Limitando recursos do sistema............................................................ 637
11.3. Configuração do SSH........................................................................... 639
11.3.1. SSH..................................................................................................... 639
11.3.2. Criptografia........................................................................................ 639
11.3.2.1. Criptografia simétrica......................................................................... 640
11.3.2.2. Criptografia assimétrica...................................................................... 640
11.3.3. Versões do protocolo SSH................................................................... 641
11.3.3.1. Protocolo versão 1.............................................................................. 641
11.3.3.2. Protocolo versão 2.............................................................................. 642
11.3.4. Administrando remotamente via SSH................................................... 644
11.3.5. Daemon do servidor............................................................................ 644
11.3.6. Utilitários do cliente............................................................................ 645
11.3.6.1. ssh...................................................................................................... 645
11.3.6.2. scp...................................................................................................... 646
11.3.6.3. sftp..................................................................................................... 648
11.3.7. Autenticação por meio de chaves........................................................ 648
Mãos à obra!................................................................................................................................... 657
Referências bibliográficas ...................................................................................................... 664
15
1 Conceitos
básicos
ÃÃ Introdução ao GNU/Linux;
ÃÃ Instalação do GNU/Linux;
ÃÃ Executando os primeiros comandos.
1.1. Introdução ao GNU/Linux
Um sistema operacional é formado por um conjunto de funções que, trabalhando em
perfeita harmonia, manipulam o hardware e, através de uma interface de comunicação,
oferecem todos os recursos úteis para o seu gerenciamento.
O projeto GNU surgiu em meados de 1983. Seu idealizador, Richard Stallman, tinha o
objetivo de criar um sistema operacional que fosse completamente livre e seguisse os
padrões do Unix que, na época, cobrava licenças de alto custo. GNU é um acrônimo
recursivo para a frase GNU Is Not Unix (GNU não é Unix), fazendo uma grande
oposição ao formato proprietário que a maioria dos sistemas Unix seguia.
Nesse contexto, quando fazemos referência à palavra livre, é no sentido de liberdade

com relação ao código-fonte e forma de usar o software. Essa necessidade surgiu
pelo fato de que praticamente todos os softwares da época estavam tomando o
caminho oposto, ou seja, do software proprietário. Nesse tipo de software, o usuário
geralmente detém apenas a permissão de uso sobre o software, sem nenhum acesso
ao código-fonte.
O sistema GNU estava sendo desenvolvido por uma comunidade imensa, que seguia
os passos e as ideologias de Richard Stallman. Porém, com o tempo, o projeto foi
ganhando tal consistência e volume que necessitou urgentemente de um órgão para
gerenciar todo o seu desenvolvimento. Nasceu, então, a Free Software Foundation
(FSF). A FSF é uma organização sem fins lucrativos, que se mantém com a doação
de empresas que apoiam a mesma causa: defender o software livre. Hoje, o foco
principal da FSF é manter a GPL (General Public License, licença utilizada para defender
juridicamente um software livre), assim como disseminar a ideologia de software livre
pelo mundo.
A GPL, que é uma importante ferramenta jurídica criada pela Free Software Foundation,
tinha inicialmente, como principal função, defender a liberdade dos softwares
desenvolvidos pelo projeto GNU. Posteriormente, foi utilizada e empregada por
centenas de outros softwares envolvidos em projetos de terceiros e particulares por
todo o mundo.
A Licença Pública Geral segue, desde a sua primeira versão, as quatro liberdades
citadas anteriormente, sendo também sua intenção poder defender o software livre de
forma prorrogada. O documento oficial da GPL, válido oficialmente como ferramenta
de proteção ao software livre, existe somente em inglês.
Todas as ferramentas desse sistema operacional estavam sendo preparadas do zero,

como o editor de texto (Emacs), o ambiente gráfico (servidor X), compiladores (GCC,
G++) e também um kernel (GNU/Hurd). Assim, um novo sistema operacional livre
surgia, mas com um detalhe muito importante: o desenvolvimento desse sistema
livre deveria seguir os padrões de sistemas operacionais Unix, que é, sem dúvida, um
padrão muito respeitado e conhecido por seu alto grau de segurança e confiabilidade.
18
Conceitos básicos 1
Um dos grandes motivos do sistema operacional GNU não ter sido lançado foi pelo
formato do desenvolvimento do seu kernel, o GNU/Hurd, que seguiu um modelo
complexo, não se adequando ou obtendo uma estabilidade segura para assumir a
posição de um kernel maduro e confiável.
Eis que, no ano de 1991, o finlandês Linus Torvalds criou um kernel denominado
Linux, o qual pôde ser unido aos programas GNU. Dessa junção, nasceu o sistema
GNU/Linux.
Costumamos nos referir aos sistemas GNU/Linux apenas como sistemas Linux,
denominação que não faz justiça aos desenvolvedores de softwares e ferramentas
GNU, afinal, estamos nos referindo apenas ao nome do kernel criado por Linus.
Os sistemas operacionais que muitos usam atualmente, através das inúmeras

distribuições existentes e muito conhecidas, têm a contribuição das diversas
ferramentas e utilitários desenvolvidos pelo projeto GNU no decorrer dos anos.
1.1.1. Software livre
Quando nos referimos ao software livre, estamos nos referindo à sua liberdade de
estudar, executar, alterar, melhorar, copiar e até mesmo distribuir um software
livre.
Essa ideia toda foi minuciosamente detalhada em quatro tipos de liberdades, conforme
veremos a seguir:
•• Liberdade número 0: É a liberdade de executar o software para qualquer

propósito ou finalidade;
•• Liberdade número 1: É estudar o funcionamento do software, podendo fazer

alterações e adaptá-las conforme a necessidade. Um pré-requisito para atingir
essa liberdade é ter o acesso total ao código-fonte;
•• Liberdade número 2: O usuário tem a liberdade de redistribuir cópias do

software para quem quiser;
•• Liberdade número 3: É a liberdade para modificar o programa e, então,

disponibilizar as modificações para que qualquer pessoa possa tirar proveito
delas. O acesso ao código-fonte é condição para que a liberdade número 3 seja
atendida.
A junção dessas quatro liberdades é a essência do software livre, no qual a ideia

principal é sempre prorrogar a liberdade de um software, de forma que jamais um
usuário possa se apoderar de um software livre e torná-lo algo como um software
proprietário. Para tal função, existe a GPL.
19
1.1.2. Origem do Linux
Primeiramente, é importante entender que, tecnicamente falando, o Linux não é um
sistema operacional, mas sim um kernel, ou o centro de execução do seu sistema
operacional. Cada sistema operacional, independentemente da plataforma, possui o
seu próprio kernel, com suas características peculiares.
A história do Linux é um tanto aventureira, pois surgiu pelas mãos de um jovem

estudante Finlandês chamado Linus Benedict Torvalds, que estudava Ciências da
Computação na universidade de Helsinki.
Linus Torvalds, como é mais conhecido, começou o desenvolvimento do Linux a partir

de um projeto pessoal. Teve como base um sistema operacional Unix-like chamado
Minix, que foi desenvolvido por Andrew Tanenbaum em meados de 1987. O Minix
era um sistema operacional básico, porém, seguia os padrões do Unix e era muito
utilizado no meio acadêmico para auxiliar no ensino de sistemas operacionais. Linus
Torvalds iniciou seu projeto a partir do Minix e pretendia criar um Minix melhor que
o original.
Unix-like é um termo para referenciar o padrão de sistemas operacionais Unix,

em que temos um padrão robusto, seguro e estável. Basicamente, um sistema
Unix-like tem o suporte fundamental aos recursos de multiusuário e multitarefa.
Foi a partir dessa ideia que Linus Torvalds começou o desenvolvimento do seu projeto,
conseguindo, na versão 0.01, melhorar o kernel do Minix, acrescentando suporte a
recursos que estavam indisponíveis na versão anterior. O nome Linux é uma junção
de Linus com Unix, e foi escolhido pela nova comunidade que estava surgindo, devido
ao convite público de Linus Torvalds ao anunciar seu projeto na Usenet (internet da
época), pedindo ajuda de colaboradores. Inicialmente, o desenvolvimento do kernel
Linux foi simplesmente um passatempo para Linus Torvalds.
O kernel Linux é um grande exemplo de software livre licenciado utilizando-se da

GPL. A iniciativa ganhou milhares de adoradores e conta atualmente com muitos
desenvolvedores que trabalham de forma minuciosa, adicionando diariamente novas
funções e corrigindo bugs, através da criação de correções (patches).
Em sua primeira versão, o kernel Linux já conseguia trabalhar em conjunto com

algumas ferramentas desenvolvidas pelo projeto GNU, como o compilador GCC e o
interpretador de comandos bash.
A junção das milhares de ferramentas desenvolvidas pelo projeto GNU com o kernel
Linux forma todas as camadas de preenchimento para se ter um sistema operacional
completo.
20
1.1.3. Distribuições GNU/Linux
Com a junção das ferramentas GNU e o kernel Linux, temos tecnicamente um sistema
operacional GNU/Linux. Em suas primeiras versões, instalar um sistema GNU/Linux
era extremamente complexo, pois era necessário praticamente instalar e compilar
manualmente quase todas as ferramentas, incluindo o próprio kernel. Ou seja, o
GNU/Linux era geralmente utilizado por usuários avançados.
Foi a partir dessa dificuldade que surgiram as primeiras distribuições GNU/Linux –

também chamadas de distros –, que tinham a finalidade de facilitar a instalação do
sistema, disponibilizando todas as ferramentas necessárias, com um kernel Linux e um
instalador para automatizar o processo de instalação. Tudo isso era disponibilizado
através de um CD, disquete ou outro tipo de mídia.
Hoje, existe uma quantidade imensa de distribuições disponíveis para instalação, com
praticamente todos os níveis de dificuldade e focos específicos.
Em 1993, Patrick Volkerding reuniu o kernel Linux e diversos aplicativos, o que originou
a distribuição denominada Slackware, tida como a primeira a ser disponibilizada em
CD.
A maioria das distribuições existentes hoje em dia é ramificação da Slackware e de

outras três distribuições: Debian, Red Hat e SUSE. As mais antigas e tradicionais são
Slackware e Debian, que surgiram em meados de 1993.
No site DistroWatch.Com (distrowatch.com), é possível conferir a lista de

distribuições existentes, bem como notícias e últimas atualizações de cada
uma delas. O endereço também disponibiliza links para aquisição das distros.
•• Distribuições livres e corporativas
A maioria das distros é mantida por comunidades de colaboradores localizados em

toda parte do mundo e por corporações. Dada essa característica, as distribuições
podem ser divididas em duas categorias: livres e corporativas. O primeiro tipo é
disponibilizado por comunidades de colaboradores que não visam absolutamente
nenhum lucro sobre suas distribuições, como é o caso das distros Slackware, Debian,
Knoppix, Gentoo e CentOS.
Dentro das distribuições livres, diferem-se ainda as convencionais, tradicionalmente

distribuídas, em algum tipo de mídia, para instalação em disco rígido, e as distribuições
Live, cuja execução se dá a partir da própria mídia, sem instalação no HD e, portanto,
sem risco ao sistema operacional original do servidor. Quase todos os componentes
do sistema já vêm previamente configurados numa distribuição Live, o que a torna
conveniente e fácil de usar.
21
Já as distribuições corporativas, como Ubuntu, Suse, Red Hat e Oracle Linux, são
administradas por empresas que cobram pelo suporte prestado. É importante notar
que, embora um custo esteja envolvido, isso não contradiz os princípios da licença
GPL, pois a liberdade de software é mantida. Qualquer usuário tem acesso ao código-
fonte das distribuições corporativas, de forma que o que é vendido não é o produto,
mas uma prestação de serviço de assistência.
•• Distribuições from scratch e provenientes (baseadas)
As distribuições também podem ser categorizadas de acordo com a maneira como são
desenvolvidas. Assim, são classificadas como from scratch (do zero) ou provenientes
(baseadas).
A diferença básica entre os dois tipos é que as distribuições from scratch não derivam
de nenhuma já existente, sendo todas as suas características desenvolvidas específica
e exclusivamente para elas, como é o caso do Debian, Red Hat, Slackware e Gentoo,
enquanto as provenientes baseiam-se em alguma distribuição anterior e fazem ajustes
visando a um objetivo funcional definido. Exemplos desse tipo são os mencionados
Ubuntu, Fedora, CentOS, entre outras.
1.1.4. Características herdadas do padrão Unix

Os sistemas GNU/Linux herdaram muitas características do padrão Unix, o que
refletirá na maneira como executaremos os comandos a partir do interpretador de
comandos. O sistema operacional MAC OS X, da Apple, por ser Unix-like, também
herda tais características.
1.1.5. Representação por arquivos

Esta é uma herança fundamental do sistema Unix, em que tudo que estiver presente no
sistema será representado por um arquivo. Para tanto, teremos várias classificações
para tipos de arquivos, que representarão dispositivos de armazenamento de dados,
memória física, portas seriais ou paralelas, arquivos especiais, arquivos de texto
comuns, binários e até mesmo diretórios. É importante dizermos que um diretório
também é um arquivo; um arquivo especial que aponta para outros arquivos e
subdiretórios presentes dentro dele.
No momento de gerenciar o sistema, é importante saber lidar com todos esses tipos
de arquivos e tomar as devidas precauções na hora de manipulá-los.
22
1.1.6. Aspecto case-sensitive
Uma qualidade em sistemas Unix-like é a presença da característica case-sensitive, em
que letras maiúsculas serão completamente diferentes de letras minúsculas, e vice-
versa. No início, quando não se tem prática e costume com essa característica, é um
tanto desconfortável, mas depois, com o domínio, ela é útil e prática. A funcionalidade
case-sensitive estará presente no sistema através de nomes de arquivos, diretórios,
comandos etc. Por exemplo, o comando LS é completamente diferente de ls.
1.1.7. Permissão para executar arquivos

Em sistemas Unix-like, para que um arquivo possa ser executado, inclusive pelo
administrador do sistema, deve haver, obrigatoriamente, permissões de execução.
Esse arquivo pode ser um arquivo binário de um comando qualquer, um shell script
etc. A permissão de execução protege o sistema contra arquivos autoexecutáveis e
faz os sistemas Unix-like serem praticamente imunes a vírus ou arquivos com funções
mal-intencionadas.
1.1.8. Arquivos e diretórios ocultos

Por padrão, a forma utilizada para identificar arquivos ou diretórios ocultos no sistema
é iniciar seus respectivos nomes por um ponto (.). Uma vez que na linha de comandos
não há como utilizar efeitos como os usados nos ambientes gráficos, para visualizar
tais arquivos ou diretórios ocultos, basta utilizar uma simples opção com o comando
de visualização ls, o qual será abordado posteriormente neste treinamento.
1.1.9. Divisão em camadas
O sistema é todo dividido e trabalhado em camadas, não sendo necessária a execução
obrigatória de um ambiente gráfico, por exemplo. Teremos o kernel como o centro de
execução do nosso sistema, o qual controlará todo o hardware e fará a interface de
controle e gerenciamento dos usuários, aplicações e processos em execução.
23
1.1.10. Superusuário (root)
O superusuário root é, por padrão, o único usuário com permissões completas
de administração e gerenciamento do sistema. Sua utilização deve ser restrita
e extremamente cautelosa, exatamente pela liberdade que o usuário root terá ao
executar qualquer tipo de tarefa, como excluir um diretório importante, por exemplo.
O login do superusuário é root e o que define esse login como superusuário não é
simplesmente o nome root, mas sim a UID (User Identification), que é o número de
identificação que cada usuário terá no sistema. O superusuário possui UID de número
0 (zero).
1.1.11. Aspecto multitarefa / multiusuário

Uma característica herdada dos primórdios Unix é poder executar várias tarefas ao
mesmo tempo, com vários usuários trabalhando simultaneamente no sistema.
1.1.12. Estrutura do Sistema Operacional

A estrutura de um sistema GNU/Linux é composta por porções denominadas
camadas (layers). A ilustração a seguir demonstra a estrutura em camadas do sistema
operacional GNU/Linux:
24
Para compreender de fato o que é esse sistema, é fundamental saber do que se trata
cada uma de suas camadas. Veja:
•• Ambiente de trabalho (Desktop environment): Hospeda todos os programas

cujo funcionamento depende de um ambiente gráfico;
•• DM (Display Manager): Aqui são gerenciados os logins na interface gráfica e

selecionado o tipo de ambiente gráfico que será executado;
•• ttyn: Terminais virtuais que interpretam os comandos introduzidos por um

usuário e os convertem para uma linguagem inteligível pelo computador. Nessa
camada, os comandos são executados e as configurações são definidas;
•• Sistema Operacional: Camada que auxilia e hospeda todos os aplicativos das

camadas superiores, mencionadas anteriormente;
•• Kernel Linux: Mediadora entre as camadas superiores e o hardware, essa

camada é o núcleo do sistema operacional;
•• Hardware: Camada que compreende os dispositivos do sistema disponíveis

para uso, como CD-ROM, teclado, monitor, entre outros.
1.1.13. Shell, Bash e Sessões

O shell é o mediador entre o usuário e o computador num sistema Unix-like, já que
é ele o responsável por interpretar e executar os comandos enviados por um usuário.
Sua aparência é a de um traço piscante, chamado prompt ou cursor, que fica numa
linha de comandos, onde é possível digitar comandos separados um após o outro ou
vários comandos combinados na mesma linha.
As instruções digitadas no shell podem ser executadas por dois níveis de usuário:
superusuário (root) e usuário comum, os quais apresentam permissões diferentes. O
diretório padrão do usuário root, administrador do sistema, é o /root, enquanto os
usuários comuns usam por padrão o diretório /home. Outra diferença entre os dois
é que, antes do cursor do usuário root no shell, aparece um #, ao passo que, para os
usuários comuns, o cursor segue um $.
O shell usado no sistema operacional GNU é chamado de bash. Hoje, ele é praticamente
o padrão em sistemas Unix-like. O bash, que é o sucessor do interpretador de
comandos sh, apresenta mais funcionalidades e praticidades na hora de realizar
tarefas na linha de comandos, principalmente quando o assunto é a interpretação de
caracteres especiais.
Por se tratar de um interpretador de comandos, o bash terá diversas particularidades,

como poder ser utilizado como uma linguagem de programação para automatizar
tarefas em um shell script, por exemplo. Dominar seu funcionamento faz a diferença
para o administrador.
25
Uma sessão é composta por um login efetuado com sucesso por um usuário
previamente cadastrado no sistema. Esse login dará acesso direto ao interpretador de
comandos padrão determinado no sistema, que geralmente será o bash. As sessões
são iniciadas através dos terminais, que são caracterizados como terminal virtual
somente em modo texto ou pseudoterminal inicializado a partir de um ambiente
gráfico. A única diferença entre eles é a forma de acesso. A seguir, falaremos sobre
esses terminais.
•• Terminal virtual em modo texto
O conjunto teclado/monitor conectado à máquina compreende o que chamamos

de terminal, ou console. Por meio de terminais virtuais, o GNU/Linux permite que
diversos usuários se mantenham simultaneamente conectados, pondo em prática o
aspecto multiusuário/multitarefa, característico do padrão Unix.
Com programas como rlogin, ssh, rsh, rdesktop e telnet, podemos acessar terminais
virtuais remota ou localmente.
Um terminal virtual em modo texto é prático e rápido, pois não é necessário esperar
o ambiente gráfico carregar para iniciar uma sessão a partir dele.
Geralmente, em servidores, o recurso de ambiente gráfico não está habilitado. Em

casos como esse, assim que o processo de inicialização do sistema for concluído, o
primeiro terminal estará disponível aguardando um login para início de uma sessão.
É possível ter acesso a outros terminais que trabalham de forma completamente

independente. O GNU/Linux apresenta mais de 60 terminais em modo texto, mas,
por questões de consumo de memória RAM, somente 6 são disponibilizados por
padrão. Para acessá-los é muito simples: basta manter pressionada a tecla ALT e,
em seguida, pressionar a tecla de função correspondente ao terminal que desejamos
acessar (teclas F1 até F6). Se estivermos no primeiro terminal, temos o seguinte:
Terminal Nome Tecla de atalho para acesso

1 tty1 *(CTRL +) ALT + F1
*(CTRL +): Caso o terminal padrão não seja um terminal em modo texto, é preciso
utilizar também a tecla ALT.
26
Teremos, então, na primeira linha, nome da distribuição, nome do kernel e versão da
distribuição. Na segunda linha, versão do kernel utilizado e arquitetura da máquina.
Na terceira linha, nome do host. No exemplo a seguir, temos CentOS Linux 7 (core):
•• Pseudoterminal
Um pseudoterminal é, basicamente, um terminal virtual inicializado a partir do

ambiente gráfico. Tem a mesma função do terminal em modo texto, porém depende da
execução do ambiente gráfico para que seja carregado. Os gerenciadores de janelas,
como o KDE ou o GNOME, têm aplicações específicas que emulam um terminal no
ambiente gráfico, como konsole no KDE, ou o próprio terminal no GNOME.
1.2. Instalação do GNU/Linux
Durante todo o curso, utilizaremos um programa de virtualização, para a instalação
do GNU/Linux e aprendizado deste. Além do programa de virtualização, você também
precisará realizar o download do arquivo de imagem .ISO da distribuição CentOS. Ela
é desenvolvida com base na distribuição corporativa Red Hat, sendo a mais utilizada
no mundo.
A necessidade de usar uma distribuição corporativa se dá em razão do suporte técnico

especializado da distribuição e homologação de softwares de terceiros como banco
de dados Oracle, sistema de ERP SAP ou TOVS.
Saber trabalhar na distribuição CentOS faz com que, caso necessite usar alguma
distribuição corporativa no mercado de trabalho, você já esteja habituado às
particularidades que esse tipo de distribuição possui.
Quanto à instalação, o que muda em cada distribuição seria basicamente as janelas

apresentadas e a obrigatoriedade de adicionar um usuário comum (sem poder
administrativo).
No decorrer do curso, algumas configurações serão diferentes, de acordo com

a distribuição utilizada. Nesses casos, as particularidades serão brevemente
demonstradas.
Todo o curso terá distribuição CentOS 7 como padrão.
27
1.2.1. Instalação do CentOS
A imagem .ISO poderá ser obtida através do site http://www.centos.org/. Ao acessar
o site, clique no ícone Get CentOS Now, destacado em laranja:
Você poderá escolher entre as três opções, conforme a imagem adiante. O que difere
entre elas é a quantidade de pacotes disponíveis no arquivo .ISO. Para uma instalação
mínima, realize o download da opção Minimal ISO:
Selecione um dos endereços ou mirrors disponíveis para a realização do download da

imagem:
28
Após a preparação e iniciação da máquina virtual, a tela a seguir é apresentada:
Selecione a primeira opção e aguarde o carregamento da janela de seleção do idioma.

Digite português no campo disponível e clique no botão Continuar:
29
Na janela de RESUMO DA INSTALAÇÃO, clique na opção DESTINOINSTALAÇÃO e

depois no botão Finalizado, localizado no canto superior esquerdo:
Clique na opção REDE & NOME DO HOST para definir o nome do computador. No
campo Nome do host, substitua o nome localhost.localdomain por srv<seunome>
e clique no botão Finalizado, localizado no canto superior esquerdo.
As configurações de rede serão realizadas manualmente. Portanto, mantenha a opção

OFF, conforme a imagem adiante:
Clique no botão Finalizado e em seguida no botão Iniciar a instalação. A partir desse

momento, o Sistema Operacional será instalado.
30
Repare que ainda não foi definida a senha do usuário root e também não criamos um
usuário comum. Clique na opção SENHA RAIZ para cadastrar a senha do usuário root.
ATENÇÃO: Se você cadastrar uma senha que não satisfaça os requisitos mínimos
de segurança, uma targeta laranja será apresentada. Se, mesmo assim, você
quiser continuar com a senha informada, clique no botão Finalizado duas vezes.
Após definir a senha do usuário root, clique na opção CRIAÇÃO DE USUÁRIO e

cadastre o usuário com o nome de operador.
Ao término da instalação, o botão Finalizar configuração será apresentado. Clique

no botão e aguarde o carregamento do Sistema Operacional.
1.2.2. Instalação do Debian
A imagem .ISO poderá ser obtida através do site http://www.debian.org/. Clique na
opção Imagens de CD/USB ISO, localizada na coluna Obtendo o Debian:
Clique na opção Baixar as imagens de CD/DVD usando HTTP ou FTP:
Clique na opção Imagens oficiais de CD/DVD da distribuição estável (“stable”):
31
Para realizar o download da imagem .ISO, contendo apenas os arquivos necessários

para a instalação e operação básica do GNU/Linux, selecione a arquitetura do seu
equipamento na coluna identificada CD:
Efetue o download da imagem, selecionando o arquivo debian-8.6.0-amd64-CD-1.iso:
Após a preparação e iniciação da máquina virtual, a tela adiante é apresentada:
32
Selecione a opção Graphical Install e aguarde o carregamento da janela de seleção
do idioma.
Selecione a opção Português do Brasil e clique no botão Continue:
Na janela seguinte, selecione a opção Sim. Na janela de localidade, selecione Brasil

e, na configuração do teclado, mantenha a opção apresentada. Defina o nome do
host, mantenha o nome do domínio em branco, defina uma senha de root, adicione o
usuário operador e senha operador123 e selecione a cidade.
33
Na janela de Particionar discos, selecione a opção Assistido - usar o disco inteiro

e clique no botão continuar.
Na janela a seguir, basta clicar no botão Continuar e, em seguida, selecione a opção

Partições /home, /var e /tmp separadas:
Na janela seguinte, mantenha a opção Finalizar o particionamento e escrever as

mudanças no disco. Confirme as informações apresentadas, selecionando a opção
Sim e aguarde pela instalação do sistema básico.
Na janela Configurar o gerenciador de pacotes e Configurando o popularity-

contest, mantenha a opção Não. Na janela Seleção de software, marque apenas a
opção Utilitário standard de sistema:
34
Na janela do carregador de inicialização GRUB, mantenha a opção Sim e, na última
janela, selecione a opção /dev/sda (ata-VBOX...):
Aguarde a inicialização do sistema.
1.2.3. Instalação do Ubuntu
A imagem .ISO poderá ser obtida através do site http://www.ubuntu.com/. No caso
da instalação do Ubuntu, a imagem .ISO irá carregar todo o ambiente desktop, já
com os programas necessários para o uso. Esse tipo de distribuição se utiliza de uma
tecnologia chamada “Live Cd”, em que não é necessária a instalação do SO no HD
para ser operado.
Clique no menu Download e escolha a opção desktop:
35
Clique no botão Download, destacado em laranja:
Na próxima página apresentada, selecione a opção Not now, take me to the download ›
e aguarde o download da imagem .ISO, identificada como ubuntu-16.04.1-desktop-
amd64.iso.
Assim que aparecer o menu de opção da instalação do sistema, clique no meio da tela
para assumir a máquina virtual.
36
No Ubuntu, antes de realizar a instalação no disco, é possível utilizá-la, carregando
todos os arquivos necessários na memória RAM e posteriormente instalar a distribuição.
Selecione o idioma Português, a opção Teste o ubuntu e aguarde o carregamento do

sistema. Terminado esse processo, a tela de desktop será apresentada com todos os
aplicativos já disponíveis para o uso:
Para a instalação do Ubuntu no disco, execute o ícone apresentado na área de desktop,

identificado como Instalar Ubuntu 16.04.1 LTS. A sigla LTS (Long Time Support),
significa que essa distribuição tem suporte de até 5 anos.
37
Clique no ícone de instalação, encontrado na área de desktop e aguarde o carregamento

das telas. A primeira tela já será apresentada no idioma atual (português), bastando,
então, apenas clicar no botão Continuar:
38
Na próxima tela, você tem a opção de instalar outros softwares adicionais como plug-
ins, codecs, entre outros, assim como também instalar outros softwares de terceiros.
Deixe as duas opções desmarcadas e clique no botão Continuar:
39
Nessa janela, definimos a maneira pelo qual o Ubuntu será instalado. Para usuários
iniciantes, basta selecionar a primeira opção e clicar no botão Instalar agora. Com
isso, o próprio instalador se encarregará de criar as devidas partições para o uso do
Sistema Operacional.
Confirme a tela que será apresentada em seguida, selecione a sua localização e clique
no botão Continuar:
40
Na janela de dispositivos de teclado, selecione Portuguese (Brazil) e clique no botão
Continuar:
Na última tela, defina o nome do usuário e a senha de sua escolha. Mantenha a opção
Pedir minha palavra-passe para iniciar a sessão:
41
Nesse momento, aguarde o término da instalação.
Terminada a instalação, clique no botão Reiniciar agora:
Seu sistema operacional está instalado e disponível para ser operado.
42
1.2.4. Instalação do Linux Mint
A imagem .ISO poderá ser obtida através do site http://www.linuxmint.com/. Tanto
a tecnologia utilizada Live CD quanto a sequência de instalação são parecidas com o
processo do Ubuntu.
Clique no menu Download e escolha a opção Linux Mint 18:
Selecione a opção 64-bits da versão Cinnamon:
Na próxima página apresentada, selecione o mirror do Brasil e aguarde o download

do arquivo linuxmint-18-cinnamon-64bit.iso:
43
Para a instalação no disco, você perceberá que existe um ícone chamado Install Linux
Mint:
1.3. Executando os primeiros comandos

Veja, a seguir, como executar os primeiros comandos a partir do shell do GNU/Linux,
a fim de iniciar e encerrar uma sessão, desligar e reiniciar o sistema e obter ajuda a
respeito da utilização de comandos.
1.3.1. Iniciando uma sessão (logon)

Depois de conhecer melhor os terminais, que são a porta de entrada para o nosso
sistema, é hora de iniciar uma sessão em modo texto (fazer o logon), pois esta exigirá,
em um sistema configurado de modo seguro, que seja feita uma autenticação com
um usuário previamente cadastrado. Em qualquer um dos terminais virtuais em modo
texto, basta inserir o login e a senha, lembrando-se da característica case-sensitive
presente no sistema.
44
Após a autenticação do usuário, a sessão é iniciada, como mostrado a seguir:
Assim que a autenticação for executada com sucesso, o prompt principal do

interpretador de comandos utilizado é apresentado, e o sistema já pode ser operado.
Sobre o prompt principal citado anteriormente, teremos muitas informações caso o

interpretador de comandos seja o bash. Caracteres como [, ], :, - e @ são utilizados
apenas para separar informações e formar o prompt principal. O caractere $ identifica
que o usuário atual não tem permissões ou poderes de administrador.
Para executar comandos com poderes administrativos, é necessário alterar o nível de

usuário comum para superusuário. Para isso, podemos utilizar o comando su (super
user). Ao digitarmos su na linha de comando e teclarmos ENTER, é pedida a senha
do administrador. Basta que a digitemos e, após teclarmos ENTER, teremos elevado
o nível para root. Em vez de um $, teremos o caractere #, o qual indica que o usuário
agora é um superusuário:
1.3.2. Encerrando uma sessão (logout)

Após uma sessão em modo texto ser inicializada, é possível fechá-la (fazer o logout)
com os comandos logout ou exit, assim como também a sequência de teclas CTRL +
D pode ser utilizada para encerrar uma sessão.
1.3.3. Obtendo ajuda sobre comandos

Em sistemas Unix-like, temos um recurso extremamente útil quando o assunto é obter
ajuda sobre o funcionamento de comandos com sua respectiva sintaxe e opções. Tal
funcionalidade é atribuída ao comando man, que é utilizado como uma fonte rápida
de comando, exibindo uma página de manual detalhada sobre o funcionamento dos
principais comandos.
45
Sua sintaxe é a seguinte:
man <comando>
Na linha anterior, <comando> é o comando para o qual se deseja obter informações.

O exemplo a seguir oferece informações sobre o comando ls:
man ls
1.3.4. Histórico de comandos
Centenas de comandos podem ser armazenados pelo terminal do sistema GNU/
Linux. Esse recurso traz grande praticidade ao usuário, pois não é necessário redigitar
diversas vezes um mesmo comando.
Para manter o histórico dos comandos utilizados, basta digitarmos history na linha
de comando e teclarmos ENTER. Então, por meio das teclas direcionais para cima
e para baixo do teclado, temos acesso ao histórico. A imagem a seguir mostra a
execução do comando history:
1.3.5. Atalhos de teclado utilizados na linha de

comando
Ao digitar comandos no shell bash do sistema GNU/Linux, podemos fazer uso de
atalhos de teclado para agilizar tarefas, como apagar e copiar caracteres, mover o
cursor para o local desejado, abrir uma nova linha de comando, entre outras descritas
na seguinte tabela:
Tecla ou atalho Ação

HOME ou CTRL + A Leva o cursor para o início da linha de comandos.
END ou CTRL + E Leva o cursor para o fim da linha de comandos.
BACKSPACE Apaga o caractere à esquerda do cursor.
Apaga tudo o que estiver à esquerda do cursor, porém
CTRL + U
permite colar o conteúdo apagado com o atalho CTRL + Y.
46
Tecla ou atalho Ação
DELETE Apaga o caractere à direita do cursor.
Apaga tudo o que estiver à direita do cursor, porém permite
CTRL + K
colar o conteúdo apagado com o atalho CTRL + Y.
Como o comando clear, limpa a tela e joga o cursor para
CTRL + L a primeira linha. Com o atalho SHIFT + PAGE UP, ainda é
possível visualizar o conteúdo.
CTRL + C Abre uma nova linha de comando na posição do cursor.
Busca algum caractere específico no último comando
CTRL + R
digitado.
CTRL + D Como o comando exit, sai do shell.
1.3.6. Navegação pelos diretórios

Para nos movimentarmos pelos diretórios do sistema, é importante saber utilizar os
comandos cd e pwd.
1.3.7. cd
O comando cd é utilizado para a movimentação entre os diretórios do sistema. Não
devemos esquecer como os diretórios são estruturados em sistemas GNU/Linux,
conforme explicado anteriormente.
Sua sintaxe básica é a seguinte:
cd <diretorio>
Em que diretorio é o caminho do diretório que desejamos acessar.
O comando cd também poderá ser utilizado com alguns caracteres que executam
funções especiais, descritos na tabela seguinte:
Caractere Função
. Link utilizado para fazer referência ao diretório atual.
.. Link utilizado para fazer referência ao diretório anterior.
Caractere que representa o diretório home do usuário que o está
~
utilizando.
Com o comando cd, volta ao último diretório acessado antes do
-
diretório atual.
47
Para ir para o diretório home do usuário atualmente logado, digita-se apenas cd ou

cd ~.
Para ir para o diretório raiz (/), digite o seguinte:
cd /
Para ir para o subdiretório /tmp, por exemplo, digite o seguinte:
cd /tmp
Para ir para o subdiretório cache do diretório var, por exemplo, digite o seguinte:
cd /var/cache
Para subir um nível na árvore de diretório, digite o seguinte:
cd ..
Para subir dois níveis na árvore de diretório, digite o seguinte:
cd ../../
Para retornar um nível na árvore de diretórios, digite o seguinte:
cd -
1.3.8. Exibir o diretório atual de trabalho

O comando pwd é utilizado para exibir o caminho completo do diretório atual. Podemos
recorrer a ele caso não nos recordemos do diretório em que estamos atualmente
localizados. Basta digitarmos pwd e teclarmos ENTER para exibir o nome do diretório.
pwd
48
Pontos principais
Atente para os tópicos a seguir. Eles devem ser estudados com muita atenção,
pois representam os pontos mais importantes do capítulo.
•• Um sistema operacional é formado por um conjunto de funções que, trabalhando

em perfeita harmonia, manipulam o hardware e, através de uma interface de
comunicação, oferecem todos os recursos úteis para o seu gerenciamento;
•• O projeto GNU tinha o objetivo de criar um sistema operacional que fosse

completamente livre e seguisse os padrões do Unix, que cobrava licenças de
alto custo;
•• Em 1991, o finlandês Linus Torvalds criou um kernel denominado Linux, o qual

pôde ser unido aos programas GNU. Dessa junção, nasceu o sistema GNU/Linux;
•• Distribuições GNU/Linux – também chamadas de distros – têm a finalidade

de facilitar a instalação do sistema, disponibilizando todas as ferramentas
necessárias, com um kernel Linux e um instalador para automatizar o processo
de instalação.
Material complementar

Sites Endereços
Projeto GNU http://www.gnu.org/
Free Software Foundation http://www.fsf.org/
General Public License http://www.gnu.org/licenses/licenses.html
Kernel Linux http://www.kernel.org/
Documentação CentOS https://www.centos.org/docs/
https://www.debian.org/doc/manuals/debian-
Documentação Debian
handbook/
https://help.ubuntu.com/lts/serverguide/
Documentação Ubuntu
serverguide.pdf
https://www.linuxmint.com/documentation/user-
Documentação Linux Mint
guide/Cinnamon/portuguese_brazil_18.0.pdf
49
Mapa mental para a fixação do aprendizado
50
1 Conceitos
básicos
Teste seus conhecimentos
1. Qual alternativa a seguir melhor representa o software livre?
☐☐ a) Software grátis disponibilizado na Internet para download.

☐☐ b) Programa desenvolvido por Richard Stallman que pode ser vendido
mediante sua autorização regida pela GPL.
☐☐ c) Software livre é Linux.
☐☐ d) Qualquer programa de computador que pode ser usado, distribuído,
estudado e modificado de acordo com a licença GPL.
☐☐ e) Software, como o Linux, que é amplamente desenvolvido por uma
enorme comunidade, porém sem qualquer controle ou suporte a
usuários.
2. Qual das alternativas a seguir cita categorias nas quais as distribuições

Linux podem se enquadrar?
☐☐ a) Aberta e fechada.
☐☐ b) Livre e proprietária.
☐☐ c) Livre e corporativa.
☐☐ d) Red Hat e Debian.
☐☐ e) GNU e proprietária.
3. Qual organização sem fins lucrativos foi fundada por Richard Stallman
para eliminar restrições sobre cópia, redistribuição, estudo e modificação
de programas de computadores?
☐☐ a) GPL
☐☐ b) FSF
☐☐ c) GNU
☐☐ d) LPI
☐☐ e) Mandriva
4. Estamos logados no sistema e o prompt exibe o seguinte:

aluno@computador1$. Tentamos desligar o computador com o comando
halt, mas o resultado é o seguinte: -sh: halt: command not found. Qual o
motivo dessa mensagem?
☐☐ a) Faltou o parâmetro -a no comando.

☐☐ b) O halt não é um comando para desligar o sistema.
☐☐ c) O usuário não tem permissão para desligar o sistema.
☐☐ d) O comando halt não existe.
☐☐ e) O GNU/Linux está com erro.
52
5. De acordo com a forma de desenvolvimento, quais são as categorias
das distribuições?
☐☐ a) Software livre e software proprietário.

☐☐ b) Debian e Red Hat.
☐☐ c) From Scratch e desenvolvidas do zero.
☐☐ d) Baseadas e provenientes.
☐☐ e) From Scratch e Provenientes.
6. Há algum tempo digitamos um comando bem complexo e agora

precisamos executá-lo novamente. Porém, esquecemos detalhes do
comando e precisamos relembrá-los. Que comando podemos utilizar?
☐☐ a) reboot
☐☐ b) history
☐☐ c) man ls
☐☐ d) halt
☐☐ e) commands
7. Quantos terminais em modo texto podemos usar localmente?
☐☐ a) 1
☐☐ b) 3
☐☐ c) 6
☐☐ d) 8
☐☐ e) 10
8. No Gnu/Linux, como podemos fazer para que um determinado arquivo

se torne oculto?
☐☐ a) Acrescentando um ponto no arquivo.

☐☐ b) Acrescentando um ponto no meio do nome do arquivo.
☐☐ c) Acrescentando um ponto no nome do arquivo.
☐☐ d) Acrescentando um ponto depois do nome do arquivo.
☐☐ e) Acrescentando um ponto antes do nome do arquivo.
53
9. Qual o ID do usuário root?
☐☐ a) -1
☐☐ b) 0
☐☐ c) 3
☐☐ d) 1
☐☐ e) 1001
10. O que representa o arquivo tty3?
☐☐ a) Primeiro terminal.
☐☐ b) Terceiro terminal em modo texto.
☐☐ c) Segundo terminal.
☐☐ d) Terceiro terminal em modo gráfico.
☐☐ e) Quarto terminal.
54
1 Conceitos
básicos
Mãos à obra!
Laboratório 1 - Instalando a distribuição

CentOS 7
Crie a máquina virtual para a instalação da distribuição CentOS 7, conforme a seguinte
configuração:
•• 2 GB de memória RAM;
•• 20 GB de HD;
•• Placa de rede em modo Bridge;
•• Deixar o particionamento automático;
•• Criar o usuário operador com a senha operador 123.

Debian 8
Crie a máquina virtual para a instalação da distribuição Debian 8, conforme a
configuração a seguir:
•• 20 GB de HD;
•• Placa de rede em modo Bridge (desativada);
•• Criar o usuário opera dor com a senha operador 123.

Linux Mint
Crie a máquina virtual para a instalação da distribuição CentOS 7, conforme a seguinte
configuração:
•• 20 GB de HD;
•• Placa de rede em modo Bridge (ativada);
•• Criar o usuário operador com a senha operador 123.
56
Laboratório 4 - Realizando alguns testes
após a instalação das distribuições
Após a instalação das distribuições anteriores, realize o acesso com os usuários root
e operador. Nesse momento, a rede não precisará ser configurada.
57
2 Arquitetura do
sistema
ÃÃ Identificar e configurar o hardware;

ÃÃ Sistema de boot;
ÃÃ Níveis de inicialização e desligar/reiniciar o sistema.
Observações importantes deste capítulo
Este capítulo faz parte do tópico 101 - System Architecture, da primeira

prova identificada como 101-400 ou LX0-103 da certificação LPIC-1.
Você precisará estar apto a configurar o hardware no GNU/Linux, assim

como também entender todo o processo de gerenciamento e inicialização
do sistema, enviar mensagens aos usuários e ter um breve conhecimento
de outro gerenciador de boot, como, por exemplo, o Upstart.
Para esse tópico, 8 questões serão aplicadas entre perguntas alternativas,

dissertativas ou de múltipla escolha.
Para o mercado de trabalho, atente-se em coletar as mensagens de erro no

log do sistema, assim como também entender toda a sequência de boot
para uma possível manutenção ou resolução de problema no sistema.
2.1. Identificar e configurar o hardware

Com exceção da placa de rede, os dispositivos de hardware, em sistemas GNU/Linux,
também são representados como arquivos, armazenados de forma organizada no
diretório /dev, onde podem ser administrados pelo usuário.
Conhecer bem a estrutura e o funcionamento desses arquivos é necessário para um

bom gerenciamento do sistema. Neste capítulo, aprenderemos todo o processo de
identificação do hardware, a sequência de boot, níveis de inicialização, comandos
para desligar/reiniciar do sistema, entre outros assuntos.
2.1.1. Detectar dispositivos PCI

Todo periférico se comunica com o processador através de um barramento, em que
temos:
•• Barramento PCI: Comunicação de 32 ou 64 bits (placas de vídeo, placas de

som, placas de rede etc.);
•• Barramento AGP: Comunicação de 32 bits (placas gráficas);
•• Barramento PCI-Express: Comunicação de 32 ou 64 bits.
60
Arquitetura do sistema 2
Os periféricos são listados em arquivos especiais, contidos no diretório /proc, e suas
informações podem ser consultadas através do comando lspci. A tabela a seguir
descreve as principais opções do comando lspci:
Opção Descrição
-v Exibe as informações em modo detalhado (verbose).
exibe as informações em forma de árvore, contendo todos os barramentos,
-t
pontes, conexões etc. Utilize junto com a opção -v.
-n Mostra os códigos do fornecedor e do dispositivo PCI.
Exibe mais informações, em que o endereço do dispositivo deverá ser
-s
informado.
O comando lspci sem parâmetros exibe todos os dispositivos do barramento PCI:
# lspci
00:00.0 Host bridge: Intel Corporation 440FX - 82441FX PMC [Natoma] (rev
02)
00:01.0 ISA bridge: Intel Corporation 82371SB PIIX3 ISA [Natoma/Triton
II]
00:01.1 IDE interface: Intel Corporation 82371AB/EB/MB PIIX4 IDE (rev 01)
00:0d.0 SATA controller: Intel Corporation 82801HM/HEM (ICH8M/ICH8M-E)
SATA Controller [AHCI mode] (rev 02)
...
Obtenha mais informações dos dispositivos, informando o parâmetro –v:
# lspci -v

SATA Controller [AHCI mode] (rev 02) (prog-if 01 [AHCI 1.0])
Flags: bus master, fast devsel, latency 64, IRQ 21
I/O ports at d040 [size=8]
I/O ports at 0000
I/O ports at 0000
Memory at f0806000 (32-bit, non-prefetchable) [size=8K]
Capabilities: [70] Power Management version 3
Capabilities: [a8] SATA HBA v1.0
Kernel driver in use: ahci
61
Use o parâmetro -d para exibir o código do fornecedor e do dispositivo PCI:
# lspci -n
00:00.0 0600: 8086:1237 (rev 02)

00:01.0 0601: 8086:7000
00:01.1 0101: 8086:7111 (rev 01)
00:02.0 0300: 80ee:beef
...
2.1.2. Detectar dispositivos USB

O USB (Universal Serial Bus) é usado para conectar praticamente todos os dispositivos
externos que não usam tecnologia sem fio. Quando um dispositivo é conectado a
uma porta USB, será atribuído a ele um número de 1 a 127. Todo o processo de
configuração do dispositivo é realizado automaticamente, como, por exemplo, o
driver do dispositivo conectado.
Existem três tipos de controladores USB, sendo eles:
•• UHCI - Universal Host Controller Interface: Apoiado majoritariamente pela

Intel, transferia parte do processamento do protocolo para o software (driver);
•• OHCI - Open Host Controller Interface: Apoiado pela Compaq, Microsoft e

National Semiconductor, transferia a maior parte do esforço para o controlador
eletrônico, simplificando o controlador lógico (driver);
•• EHCI - Enhanced Host Controller Interface: Reúne as qualidades dos dois

modelos anteriores.
Quanto às versões de USB, temos:
Versão USB Taxa de transferência

1.0 e 1.1 12 Mbits/s
2.0 40 Mbits/s
3.0 4 Gbits/s
3.1 10 Gbits/s
62
A tabela a seguir descreve as principais opções do comando lsusb:
Opção Descrição
-t Exibe as conexões USB em forma de árvore.
Exibe informações mais detalhadas, como velocidade atual do
-v
dispositivo, classe etc.
-d Exibe o fabricante e o número de identificação do dispositivo.
Informações básicas são exibidas apenas digitando o comando lsusb, sem nenhum
parâmetro:
# lsusb
Bus 001 Device 002: ID 1058:25a2 Western Digital Technologies, Inc.

Bus 001 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Para exibir as conexões USB em forma de árvore, use o parâmetro –t:
# lsusb -t
/: Bus 01.Port 1: Dev 1, Class=root_hub, Driver=ohci-pci/12p, 12M

|__ Port 1: Dev 2, If 0, Class=Mass Storage, Driver=usb-storage, 12M
Informações mais detalhadas são exibidas usando a opção -v. As informações estão
divididas por descritor, como Dispositivo, Configuração, Interface, entre outros.
# lsusb -v

Device Descriptor:
bLength 18
bDescriptorType 1
bcdUSB 2.10
. . .
63
Para verificar somente um dispositivo USB, o parâmetro -d seguido pelo seu ID deverá
ser informado:
# lsusb -v -d 1058:25a2

Device Descriptor:
bLength 18
bDescriptorType 1
bcdUSB 2.10
bDeviceClass 0 (Defined at Interface level)
bDeviceSubClass 0
bDeviceProtocol 0
bMaxPacketSize0 64
idVendor 0x1058 Western Digital Technologies, Inc.
idProduct 0x25a2
bcdDevice 10.04
iManufacturer 1 Western Digital
. . .
Temos também o comando usb-devices, que nada mais é que um script que tem a
função de exibir detalhes do barramento USB, juntamente com os dispositivos ligados
a ele.
# usb-devices
T: Bus=01 Lev=00 Prnt=00 Port=00 Cnt=00 Dev#= 1 Spd=12 MxCh=12

D: Ver= 1.10 Cls=09(hub ) Sub=00 Prot=00 MxPS=64 #Cfgs= 1
P: Vendor=1d6b ProdID=0001 Rev=03.10
S: Manufacturer=Linux 3.10.0-327.36.3.el7.x86_64 ohci_hcd
S: Product=OHCI PCI host controller
S: SerialNumber=0000:00:06.0
C: #Ifs= 1 Cfg#= 1 Atr=e0 MxPwr=0mA
I: If#= 0 Alt= 0 #EPs= 1 Cls=09(hub ) Sub=00 Prot=00 Driver=hub
T: Bus=01 Lev=01 Prnt=01 Port=00 Cnt=01 Dev#= 2 Spd=12 MxCh= 0

D: Ver= 2.10 Cls=00(>ifc ) Sub=00 Prot=00 MxPS=64 #Cfgs= 1
P: Vendor=1058 ProdID=25a2 Rev=10.04
S: Manufacturer=Western Digital
S: Product=Elements 25A2
S: SerialNumber=57584331453835453159534B
C: #Ifs= 1 Cfg#= 1 Atr=80 MxPwr=500mA
I: If#= 0 Alt= 0 #EPs= 2 Cls=08(stor.) Sub=06 Prot=50 Driver=usb-storage
64
2.1.3. Módulos
Os módulos são gerenciados automaticamente pelo kernel, e são encontrados no
diretório /lib/modules/<versão_kernel>. Há momentos em que existe a necessidade
de carregar algum módulo de forma manual, para a realização de testes ou solução
de problemas.
Para verificar os módulos carregados no sistema, utilizamos o comando lsmod. O

resultado será exibido através de três campos, sendo eles:
•• Module: Nome do módulo;
•• Size: Tamanho do módulo;
•• Used by: Módulos dependentes.
# lsmod
Module Size Used by

bnep 19704 2
bluetooth 372944 5 bnep
rfkill 26536 3 bluetooth
llc 14552 2 stp,bridge
ebtable_filter 12827 0
ebtables 30913 3 ebtable_broute,ebtable_nat,ebtable_filter
A remoção ou o carregamento de um determinado módulo poderá ocorrer através do

comando modprobe. Esse comando nos ajuda quanto à resolução e ao carregamento
de submódulos de forma automática. Ele também consulta o diretório /lib/
modules/<versao_kernel>, assim como o diretório /etc/modprobe.d/, onde você
poderá configurar os módulos que o kernel não carregará na inicialização do sistema.
Para isso, basta criar o arquivo contendo, no final do nome, algo como blacklist.conf.
Dentro desse arquivo, os módulos que não deverão ser carregados no momento do
boot deverão ser configurados conforme o exemplo adiante:
blacklist <nome_módulo>
65
A tabela a seguir descreve as principais opções do comando modprobe:
Opção Descrição
Remove um determinado módulo. Se ele estiver em uso, o módulo
-r
não poderá ser removido.
-v Modo verbose.
Esta opção substitui o diretório de configuração padrão (/etc/
-C
modprobe.d).
Para carregar o módulo, basta informar o comando, seguido pelo nome do módulo:
# modprobe pcspkr
Use o parâmetro -r para remover um determinado módulo. Atenção para o caso do

módulo principal possuir outros submódulos, pois, se isso ocorrer, o comando não
funcionará.
# modprobe -r cdrom
modprobe: FATAL: Module cdrom is in use.
No exemplo anterior, você deverá listar o módulo cdrom e verificar qual o nome do
submódulo que está sendo usado. Tendo essa informação, use o comando modprobe
seguido pelo nome do submódulo em questão.
2.1.4. Diretórios /sys e /proc

Os diretórios /proc e /sys são os dois diretórios “virtuais” existentes nas distribuições
GNU/Linux, criados no momento da inicialização do sistema. O kernel utiliza esses
dois diretórios para efetuar o controle dos dispositivos de hardware ativos e processos
que estão em funcionamento no sistema.
No diretório /sys/, encontramos arquivos referentes ao hardware do sistema,

onde poderemos efetuar a alteração de alguns valores. Os arquivos contidos nesse
diretório são controlados por meio de comandos e programas do sistema. Quando
um dispositivo é adicionado, é gerado um arquivo no diretório e ele é gerenciado pelo
programa UDEV, que cria o arquivo correspondente ao dispositivo no diretório /dev/.
66
A separação dos recursos é realizada por meio de diretórios sendo:
Diretórios Descrição
Informações dos dispositivos de blocos do HD, CD, DVD,
/sys/block
entre outros.
/sys/bus Informações dos barramentos suportados pelo kernel.
Organiza os tipos de dispositivos suportados pelo sistema,
/sys/class
em subdiretórios.
/sys/module Módulos carregados na memória, pelo kernel.
O diretório /proc/, armazena arquivos em tempo de execução, sendo que cada

arquivo contém a informação de um dispositivo de hardware da máquina.
Existem alguns comandos no sistema que solicitam os dados dos arquivos do diretório
/proc/, como, por exemplo, o comando lsmod: este comando informa quais são os
módulos carregados.
Podemos alterar alguns parâmetros de configuração do kernel por meio da edição

de arquivos contidos no diretório /proc/. Como exemplo, podemos, por meio da
alteração do valor do arquivo /proc/sys/net/ipv4/ip_forward de 0 para 1, ativar o
roteamento de pacotes no kernel. A alteração ocorrerá imediatamente e será mantida
enquanto o GNU/Linux estiver em execução. Caso o sistema seja reiniciado, o arquivo
ip_forward voltará ao valor 0.
Alguns arquivos contidos no diretório /proc/:
Arquivo Descrição
Parâmetros de inicialização que o gerenciador de boot
cmdline
repassa para o kernel.
Detalhes sobre o processador do sistema, como
cpuinfo
fabricante, velocidade etc.
Principais números (majors) para os vários tipos de
devices
dispositivos utilizados pelo kernel.
Exibe os sistemas de arquivos disponíveis e é utilizado
filesystems
pelo comando mount.
Exibe uma lista das IRQs e suas associações com os
interrupts
dispositivos correspondentes.
Exibe a relação de faixas da memória associadas aos
ioports
dispositivos do sistema.
Exibe informações do conteúdo atual da memória
kcore
RAM.
67
Arquivo Descrição
meminfo Exibe as estatísticas de uso da memória.
modules Exibe os módulos carregados atualmente no sistema.
Exibe os sistemas de arquivos atualmente montados
mounts
no sistema.
pci Exibe os detalhes dos dispositivos PCI do sistema.
uptime Informa há quanto tempo o sistema está ativo.
Vamos verificar o conteúdo de alguns arquivos, como:
•• /proc/interrupts:
# cat /proc/interrupts
CPU0
0: 139 IO-APIC-edge timer
1: 16 IO-APIC-edge i8042
8: 0 IO-APIC-edge rtc0
9: 0 IO-APIC-fasteoi acpi
•• /proc/ioports:
# cat /proc/ioports
0000-001f : dma1
0020-0021 : pic1
0040-0043 : timer0
0050-0053 : timer1
0060-0060 : keyboard
0064-0064 : keyboard
0070-0071 : rtc_cmos
0070-0071 : rtc0
68
•• /proc/cpuinfo:
# cat /proc/cpuinfo
processor : 0
vendor_id : GenuineIntel
cpu family : 6
model : 42
model name : Intel(R) Core(TM) i5-2435M CPU @ 2.40GHz
stepping : 7

•• /proc/partitions:
# cat /proc/partitions
major minor #blocks name
11 0 1048575 sr0
8 0 31457280 sda
8 1 512000 sda1
8 2 30944256 sda2
•• /proc/cmdline:
# cat /proc/cmdline
BOOT_IMAGE=/vmlinuz-3.10.0-327.36.3.el7.x86_64 root=/dev/mapper/centos-root
ro crashkernel=auto rd.lvm.lv=centos/root rd.lvm.lv=centos/swap rhgb quiet
LANG=pt_BR.UTF-8
2.1.5. UDEV
O udev substituiu o gerenciador de dispositivos devfs a partir da versão 2.6.12 do
kernel. Com o antigo devfs, todos os arquivos de dispositivo eram criados de uma vez
no diretório /dev, de maneira a gerar no diretório os dispositivos de todos os itens
de hardwares que o sistema suportasse, independentemente da existência desses
itens na máquina, ou seja, com o devfs acabavam-se criando arquivos de dispositivo
desnecessários, superpopulando o diretório /dev.
69
No caso do udev, os arquivos de dispositivo são gerados dinamicamente, conforme os

itens de hardware são instalados, o que significa que o que não estiver sendo usado
no computador não ocupa espaço no disco. Nos sistemas mais recentes, o udev
possui capacidade coldplug e hotplug, responsáveis por identificar e configurar os
dispositivos presentes desde o ligamento do computador e aqueles conectados após
a inicialização do sistema, respectivamente.
O arquivo de configuração do udev é o /etc/udev/udev.conf, e os arquivos de regra

ficam no diretório /etc/udev/rules.d/. Os comandos udevmonitor ou udevadm
monitor, dependendo da versão do sistema, permitem monitorar os eventos
armazenados no sistema de arquivos lógico chamado SysFS, onde são registradas as
informações de identificação dos dispositivos.
2.1.6. SYSFS
O sistema de arquivo virtual sysfs, montado em /sys/, exporta informações
sobre dispositivos para que os utilitários de espaço do usuário possam acessar as
informações. Ele é carregado na memória RAM, no momento do boot do sistema,
fazendo com que o kernel identifique e já tenha o controle dos dispositivos. Nesse
diretório, podemos encontrar quase o mesmo conteúdo do /proc/, mas de uma forma
mais organizada.
# ls /sys/
drwxr-xr-x. 2 root root 0 Nov 24 10:55 block

drwxr-xr-x. 23 root root 0 Nov 24 10:55 bus
drwxr-xr-x. 44 root root 0 Nov 24 10:55 class
drwxr-xr-x. 4 root root 0 Nov 24 10:55 dev
Esse diretório está presente desde a versão 2.6 do kernel, agrupando informações
sobre os dispositivos instalados, tipo, fabricante, capacidade, endereços usados etc.
70
No exemplo adiante, utilizando o comando systemctl, é possível verificar o sysfs,

sendo inicializado no momento do boot do sistema:
# systemctl
UNIT LOAD ACTIVE SUB DESCRIPTION

proc-sys-fs-binfmt_misc.automount loaded active waiting Arbitrary Executable File
Formats File System Automount Point
. . .
sys-devices-pci0000:00-0000:00:0d.0-ata4-host3-target3:0:0-3:0:0:0-block-sdb-sdb1.device
loaded active plugged VBOX_HARDDISK 1
sys-devices-pci0000:00-0000:00:0d.0-ata4-host3-target3:0:0-3:0:0:0-block-sdb.device
loaded active plugged VBOX_HARDDISK
sys-devices-platform-serial8250-tty-ttyS0.device loaded active plugged
/sys/devices/platform/serial8250/tty/ttyS0
. . .
2.1.7. D-Bus
O D-Bus (Desktop Bus) é um barramento de software distribuído que permite que os
aplicativos de desktop enviem mensagens uns aos outros e recebam mensagens do
kernel, fornecendo uma abstração adicional do acesso à informação de hardware. O
D-Bus pode ser usado para um cliente de e-mail notificar o gerenciador de janelas
de que um e-mail foi recebido, para que ele possa exibir um ícone, por exemplo. Ele
também pode ser usado pelo udev para notificar o gerenciador de janelas quando um
DVD foi inserido no sistema.
71
O D-Bus permite que os processos se comuniquem uns com os outros, bem como se
registrem para serem notificados nos eventos do sistema, onde todo esse controle
ocorre através do daemon chamado dbus.service.
# systemctl status dbus
● dbus.service - D-Bus System Message Bus

Loaded: loaded (/usr/lib/systemd/system/dbus.service; static; vendor
preset: disabled)
Active: active (running) since Mon 2016-11-21 20:25:12 BRST; 12h ago
Main PID: 661 (dbus-daemon)
CGroup: /system.slice/dbus.service
└─661 /bin/dbus-daemon --system --address=systemd: --nofork
--nopidfile --systemd-activation
2.2. Sistema de boot
Podemos definir o processo de inicialização como um conjunto de tarefas executadas
para obter o sistema até o ponto em que ele pode entrar no nível de execução padrão,
onde as coisas podem se tornar complexas devido aos vários métodos de configuração,
inicialização e gerenciamento do sistema, serviços ou processos.
Esse processo de boot pode ser controlado por diversos sistemas de inicialização,
como: SystemVinit (versões antigas), SystemD (versões atuais), Upstart (utilizado
pela distribuição antigas do Ubuntu), entre outros.
Os passos a seguir descrevem o processo de inicialização do sistema:
1. Assim que o kernel é iniciado, aparecem algumas informações na tela. Nessa etapa,
podemos verificar em que partição do disco está o dispositivo raiz indicado para o
sistema, o sistema de arquivos identificado e o tipo de partição. Além disso, são
exibidas a imagem do kernel a ser utilizada e a imagem initrd, caso haja alguma;
2. Após o kernel assumir o controle do sistema, são exibidas algumas informações de

hardware e outras adquiridas com a BIOS. Por ser muito rápido, é difícil acompanhar
esse processo;
3. São iniciados os itens de hardware básicos, como o teclado, o mouse e as portas

seriais;
4. Procede-se, então, com a identificação e configuração mínima dos demais itens de

hardware, como os HDs e os dispositivos de rede;
72
5. Após os itens de hardware serem identificados e a partição raiz ser montada, o
parâmetro init é acionado e dá-se início às configurações mais avançadas, assim
como aos daemons. É nessa etapa que serão montadas as demais partições, como a
partição swap;
6. Por fim, são iniciados os daemons de serviços restantes e o acesso ao sistema é

disponibilizado ao usuário.
2.2.1. SysVinit
Utilizado em distribuições mais antigas, comparadas à que temos atualmente, o
programa SysVinit usa uma série de scripts de shell, divididos em runlevels separados.
Basicamente, funciona da seguinte maneira:
•• Cada programa usa um script de shell separado para iniciar, parar, recarregar
o programa;
•• Possui níveis de execução (runlevels) no qual o sistema Linux é iniciado, que,

por sua vez, determina qual conjunto de programas está sendo executado;
•• O administrador pode alterar o nível de execução a qualquer momento enquanto

o sistema estiver em execução.
Quanto aos níveis de execução, temos:
RunLevel Descrição
Acionado pelo comando shutdown -h, o nível 0 suspende a
0
execução do sistema. Daemons e programas são encerrados.
Utilizado para manutenção do sistema, executa o sistema sob o
1,s,S
modo monousuário.
Este é o nível de execução padrão no Debian. Executa o sistema
2 sob o modo multiusuário. Para outras distribuições, esse runlevel
é indefinido.
3 Executa o sistema sob o modo multiusuário.
4 Não definido.
Executa o sistema sob o modo multiusuário com a utilização de
5
login gráfico.
Acionado pelo comando shutdown -r e pelas teclas CTRL + ALT +
6 DEL, este nível de execução encerra os programas e daemons para
iniciar o sistema.
73
Os scripts de inicialização estão presentes no diretório /etc/init.d.
Os diretórios /etc/rc?.d possuem links a partir dos quais podemos executar os

sistemas existentes no diretório /etc/init.d. Cada diretório /etc/rc?.d representa um
nível de execução (runlevel) distinto do sistema.
Os diretórios /etc/rc0.d a /etc/rc6.d alocam os serviços que serão habilitados e

desabilitados na inicialização do sistema. Dependendo do link simbólico, podemos
ter diferentes ações, como vemos a seguir:
Características do link
Ação
simbólico
Iniciado com a letra K O serviço será interrompido no nível de execução
(kill) indicado pelo link.
Iniciado com a letra S O serviço será iniciado no nível de execução
(start) indicado pelo link.
Inicialmente, são executados os links simbólicos iniciados pela letra K para, em

seguida, executar aqueles indicados pela letra S. O valor numérico especificado em
cada um dos links irá determinar qual será a sequência de sua execução.
O arquivo /etc/inittab contém as informações necessárias ao processo, para que ele

possa iniciar um nível de execução no momento do boot. Além disso, tal arquivo é
composto por linhas de comentários, as quais são identificadas pelo caractere #. São
compostas da seguinte maneira:
id:niveis_de_execucao:acao:processo
Em que:
•• id: É um nome composto de, no máximo, quatro caracteres que identifica a

entrada no arquivo /etc/inittab;
•• niveis_de_execucao: É definido por números de 0 a 6, que indica o nível de

execução no qual o processo deve ser chamado. O campo pode ser preenchido
por vários números indicadores de níveis, mas, para que um evento seja aplicado
em todos os níveis de execução existentes, basta deixar o espaço reservado à
determinação dos níveis em branco;
•• acao: Determina qual será a ação escolhida. Mais detalhes sobre este campo
serão fornecidos seguir;
•• processo: Determina qual o programa a ser executado no momento de inserção

do nível de execução.
74
O exemplo a seguir exibe as informações do /etc/inittab:
Na tabela a seguir, veremos quais são as opções disponíveis para o preenchimento do

campo ação, na linha do arquivo /etc/inittab.
Opções Descrição
Esta opção indica que assim que o processo for finalizado, ele
respawn
será reiniciado.
Esta opção indica que qualquer preenchimento do campo niveis_
boot
de_execucao será desconsiderado.
Esta opção indica que, apesar de o processo ser executado
durante a inicialização do sistema, somente após a inicialização
bootwait
ter sido concluída é que o init se direcionará à execução do
processo seguinte.
Esta opção indica que, no momento da introdução do nível de
wait execução, o processo será iniciado. No entanto, o init apenas o
iniciará após o término do processo.
Esta opção indica que o init não irá aguardar o término do
once processo para realizar a execução de alguns programas no nível
de execução.
Assim que houver uma solicitação quanto a um nível de execução
ondemand específico, o processo será executado. No entanto, não há
alterações no nível de execução.
Esta opção indica que a execução do processo ocorrerá durante
sysinit a inicialização do sistema e anteriormente a qualquer entrada
boot ou bootwait, as quais foram previamente explicadas.
75
Esta opção atribui um nível de execução ao init durante a
initdefault inicialização, entretanto, o usuário poderá inserir esse nível no
console caso um padrão não tenha sido previamente especificado.
Esta opção indica que, assim que o usuário pressionar as teclas
ctrlaltdel CTRL + ALT + DEL, o init recebe um sinal, permitindo, então, a
execução do processo.
Esta opção indica que, caso haja problemas relacionados à
powerwait energia, outro processo enviará um sinal ao init e será executado,
fazendo com que o init aguarde o seu término para retornar.
Esta opção também indica que o processo que envia sinais ao init
quanto aos problemas de energia será executado. Entretanto,
powerfail
diferentemente da opção powerwait, o init não aguardará o
término do processo.
Um pouco diferente das opções anteriores, a opção em questão
indica que, quando o init recebe sinal quanto aos problemas de
powerokwait energia, o processo que envia o sinal apenas será executado
quando houver o arquivo /etc/powerstatus contendo a string
OK. Nesse caso, o init aguardará o término do processo.
Utilizamos o comando runlevel para visualizar qual é o nível de execução atualmente

apresentado pelo sistema. Assim que é executado, este comando faz a leitura do
arquivo /var/run/utmp e pode exibir uma das seguintes informações:
•• O nível de execução anterior;
•• Caso o nível de execução do sistema ainda não tenha sido alterado, é exibida a
letra N.
Para alteração do nível de execução, podemos utilizar o comando init ou telinit.

Para ambos, utilizamos como argumento o número do nível de execução para o qual
desejamos mudar. Portanto, para alterarmos o nível de execução atual para o nível 1,
por exemplo, devemos executar um dos seguintes comandos:
init 1
Ou:
telinit 1
Para verificarmos se a alteração foi efetuada, devemos utilizar o comando runlevel.
76
2.2.2. SystemD
O SystemD é um sistema de inicialização para iniciar o espaço do usuário e gerenciar
todos os processos posteriormente, em vez dos sistemas de inicialização SystemVinit
ou BSD (Berkeley Software), porém é compatível com eles.
Um dos objetivos principais do SystemD é unificar as configurações básicas do GNU/

Linux e comportamentos de seus respectivos serviços. As unidades de tipo alvo são
importantes porque agrupam várias unidades juntas para que possam ser iniciadas
ao mesmo tempo. Por exemplo, a unidade network.target agrupa todas as unidades
necessárias para iniciar as interfaces de rede para o sistema.
Algumas vantagens do padrão SystemD:
•• Capacidades de paralelização, que aumentam a velocidade de inicialização do

sistema;
•• On-Demand a partir de daemons, sem a necessidade de um serviço separado;
•• Gestão automática de dependência de serviço, impedindo um longo tempo de

espera, como não iniciar um serviço de rede quando a rede não está disponível;
•• Método de rastreamento de processos relacionados em conjunto, utilizando

grupos de controle Linux.
Em vez de usar scripts shell e runlevels, o método SystemD usa unidades e alvos.
Uma unidade SystemD define um serviço ou ação no sistema. Consiste em:
•• Nome;
•• Tipo;
•• Arquivo de configuração.
Quanto às unidades, temos:
•• Automount;
•• Device;
•• Mount;
•• Path;
•• Service;
•• Snapshot;
•• Socket;
•• Target.
77
Os scripts utilizados por SystemD para iniciar e parar daemons são armazenados no
diretório /usr/lib/systemd/system.
Tanto o /lib/systemd/system quanto o /etc/systemd/system contêm subdiretórios

chamados *.target.wants para daemons de carga e outros componentes.
Por convenção, os componentes do sistema e do sistema operacional são tipicamente

carregados a partir de entradas do diretório no /lib/systemd/system/*.target.
wants.
Os componentes que precisam ser carregado no kernel Linux no início do processo

de inicialização do sistema têm links simbólicos para o diretório /lib/systemd/
system/sysinit.target.wants (componentes do núcleo do sistema operacional) e /
etc/systemd/system/multi-user.target.wants (para componentes opcionais).
Para verificar as unidades carregadas no sistema, use o comando systemctl. O

parâmetro list-units é opcional.
# systemctl list-units
. . .
multi-user.target loaded active active Multi-User System
network-online.target loaded active active Network is Online
network.target loaded active active Network
. . .
A tabela a seguir descreve as principais opções do comando systemctl:
Opção Descrição
list-units Mostra o status de todas as unidades configuradas.
default Altera o target da unidade como padrão.
isolate Inicia o nome da unidade e para todas as outras.
start Inicia a unidade.
stop Para a unidade.
reload Recarrega o arquivo de configuração da unidade informada.
restart Reinicia a unidade.
status Informa a situação atual da unidade.
enable Configura a unidade para ser iniciada no momento do boot.
disable Configura a unidade para não ser inicializada no momento do boot.
78
O comando completo poderá ser executado das seguintes formas:
systemctl [acao] <nome>
# systemctl status sshd.service
● sshd.servie.service
Loaded: not-found (Reason: No such file or directory)
Active: inactive (dead)
2.2.3. Upstart
Utilizado como um sistema de inicialização padrão no Ubuntu em versões mais antigas,
o Upstart faz o mesmo trabalho que o SysVinit, porém foi projetado para lidar melhor
com o hardware hotplug, que pode ser conectado e desconectado de um computador
enquanto ele ainda está em execução, fornecendo recursos de compatibilidade com
o SysVinit.
O Upstart elimina o /etc/inittab, fornecendo um conjunto integrado de scripts de

inicialização que podem, em princípio, substituir completamente o /etc/inittab.
Seus scripts também suportam o início ou a parada de serviços com base em uma
variedade mais ampla de ações do que os scripts de inicialização do SysVinit. Por
exemplo, o Upstart pode iniciar um serviço sempre que um dispositivo de hardware
específico é anexado.
Os scripts de inicialização são encontrados no diretório /etc/init/. Para a alteração de

um determinado script, basta editar o arquivo escolhido e alterar a linhas conforme
o exemplo adiante:
# cron - regular background program processing daemon

#
# cron is a standard UNIX program that runs user-specified programs at
periodic scheduled times
description "regular background program processing daemon"
start on runlevel [2345]

stop on runlevel [!2345]
expect fork
respawn
exec cron
79
Para administrar o serviços como parar, iniciar ou recarregar, use o comando initctl.
# initctl status cron
A versão mais recente do Ubuntu, conhecida como 16.04 Xenial Xerus, substituiu o
Upstart pelo SystemD.
2.2.4. Eventos do boot
É muito importante que o administrador do sistema entenda e saiba captar possíveis
mensagens de erro durante a inicialização do sistema. Para isso, dependendo do
sistema de inicialização utilizado, os comandos e os arquivos consultados mudam.
Para o SystemVinit, você poderá executar o comando dmesg ou consultar os arquivos

messages ou syslog, contidos no diretório /var/log/.
Exemplo de uma consulta de mensagens de erro na inicialização do sistema:
# dmesg | grep -ie 'fail\|error\|warning\|alert\|emerg\|crit'
[ 0.296539] acpi PNP0A03:00: _OSC failed (AE_NOT_FOUND); disabling ASPM

[ 0.296755] acpi PNP0A03:00: fail to add MMCONFIG information, can't
access extended PCI configuration space under this bridge.
Quanto ao comando grep, ele será estudado posteriormente.
Para o SystemD, as mensagens ocorridas na inicialização do sistema são armazenadas

em um arquivo binário, e sua visualização ocorre através do comando journalctl.
80
# journalctl
-- Logs begin at Mon 2016-11-21 20:24:48 BRST, end at Tue 2016-11-22

12:50:01 BRST. --
Nov 21 20:24:48 localhost.localdomain systemd-journal[90]: Runtime
journal is using 8.0M (max allowed 92.0M, trying to leave 138.0M free of
911.9M available → current limit 92.0M).
Nov 21 20:24:48 localhost.localdomain systemd-journal[90]: Runtime
journal is using 8.0M (max allowed 92.0M, trying to leave 138.0M free of
911.9M available → current limit 92.0M).
Nov 21 20:24:48 localhost.localdomain kernel: Initializing cgroup subsys
cpuset
cpu
cpuacct
Nov 21 20:24:48 localhost.localdomain kernel: Linux version 3.10.0-
327.36.3.el7.x86_64 (builder@kbuilder.dev.centos.org) (gcc version 4.8.5
20150623 (Red Hat 4.8.5-4) (GCC) ) #1 SMP Mon Oct 24 16:09:20 UTC 2016
. . .
Também é possível verificar as mensagens de log, mas somente de um determinado

dia. Por exemplo, utilizando o parâmetro --list-boots, serão exibidos os registros de
logs ocorridos por dia, e sua identificação ocorre através da seguinte linha:
0 d0c6482793c4452f910273bbc80feebb Mon 2016-11-21 20:24:48
O 0 representa o log do dia atual, podendo ter o valor de até -34.
Já a informação d0c6482793c4452f910273bbc80feebb representa a identificação

do log.
Exemplo:
# journalctl -b d0c6482793c4452f910273bbc80feebb
81
2.3. Níveis de inicialização e desligar/reiniciar

o sistema
Nos tópicos a seguir, aprenderemos sobre os níveis de inicialização, desligamento/
reinicialização do sistema de maneira segura, comando wall e encerramento dos
processos de forma adequada.
2.3.1. Níveis de inicialização e controle dos

serviços
Conforme já mencionado anteriormente neste capítulo, dependendo do sistema de
inicialização utilizado pela distribuição, os comandos responsáveis por determinadas
tarefas poderão ser diferentes:
•• Verificar o nível de inicialização atual:
SYSVINIT - Comando SYSTEMD - Comando

runlevel systemctl get-default
Quanto à resposta do comando runlevel, o primeiro valor corresponde ao runlevel

anterior e o segundo ao runlevel atual.
# runlevel
N 5
•• Alterar o nível de execução atual:
SYSVINIT -
DESCRIÇÃO SYSTEMD - Comando
Comando
Desligar init 0 runlevel.target, poweroff.target
Monousuário init 1 runlevel1.target, rescue.target
Multiusuário init 2 runlevel2.target, multi-user.target
Multiusuário com rede init 3 runlevel3.target, multi-user.target
Experimental init 4 runlevel4.target, multi-user.target
Multiusuário com rede
init 5 runlevel5.target, graphical.target
e interface gráfica
Reinicializar init 6 runlevel6.target, reboot.target
82
Para alterar o nível de execução padrão, podemos realizar isso de duas maneiras:
SYSVINIT SYSTEMD
Editar o arquivo /etc/inittab
Alterar o valor do campo id:,
conforme o valor de runlevel systemctl set-default multi-user.target
desejado.
Exemplo: id:3initdefault:
Para realizar as principais atividades de operação dos serviços do sistema, entre o

SysVinit e o SystemD, façamos a comparação conforme a tabela a seguir:
ATIVIDADES SYSVINIT SYSTEMD

Iniciar service <serviço> start systemctl start <serviço>.service
Parar service <serviço> stop systemctl stop <serviço>.service
service <serviço>
Reiniciar systemctl restart <serviço>.service
restart
service <serviço>
Recarregar systemctl reload <serviço>.service
reload
Habilitar service <serviço> on systemctl enable <serviço>.service
Desabilitar service <serviço> off systemctl disable <serviço>.service
Verificar se o
serviços está
systemctl is-enable <serviço>.
habilitado na service <serviço>
service
inicialização
do sistema
Quanto à estrutura de diretórios para o controle dos scripts dos serviços, temos:
SYSVINIT SYSTEMD
/usr/lib/systemd/ -> Local onde são armazenados
os scripts de configuração do sistema.
/etc/init.d/ -> Local onde são
/etc/systemd/ -> Contém arquivos de
armazenados os scripts dos
configuração.
serviços.
/etc/rc*.d/ -> Contém links
/etc/systemd/system -> Unidades que são
de inicialização/desligamento
controladas pelo sysadmin e têm precedência
dos script, apontando para o
sobre todas as outras unidades.
diretório /etc/init.d/.
/lib/systemd/system -> Contém scripts de
configuração dos serviços.
83
2.3.2. Desligar/reiniciar o sistema
Com o comando shutdown podemos reiniciar ou desligar o computador de maneira
segura, processo este apto a ser realizado imediatamente ou, então, com base em
um tempo predefinido na estrutura do próprio comando. Como padrão, apenas o
superusuário pode utilizar o comando shutdown. Antes que o computador seja
desligado pelo shutdown, os usuários do sistema recebem notificação sobre tal
procedimento.
A seguinte sintaxe é utilizada para o shutdown:
shutdown [opcoes] <hora> [mensagem]
Algumas opções podem ser empregadas juntamente com o comando shutdown,

conforme descrito adiante:
Esta opção é empregada para iniciar o processo de desativação do
-h
computador.
Trata-se da opção responsável por suspender a reinicialização ou o
-c desligamento do computador. Uma mensagem de notificação aos
usuários pode ser definida como complemento para esta opção.
-r Por meio desta opção, o sistema é reinicializado.
Ao ser especificada, esta opção emite um sinal de finalização aos
-t<num> processos ativos no sistema, e, posteriormente, de acordo com o tempo
especificado, emite um sinal KILL.
Por meio desta opção, é possível simular a ação do shutdown. Neste
-k caso, uma notificação a respeito do procedimento de reinicialização ou
desligamento é enviada aos usuários.
Quando definida, esta opção faz com que o sistema de arquivos seja
verificado no decorrer da inicialização do sistema. Vale considerar a
-F execução de processo por meio da gravação de um arquivo chamado /
forcefsck. Durante o processo de inicialização do sistema, tal arquivo
é interpretado por scripts que executam o fsck.
Quando definida, esta opção faz com que o sistema de arquivos não
seja verificado no decorrer da inicialização do sistema. Vale considerar
-f sua execução por meio de gravação de um arquivo chamado /fastboot.
Durante o processo de inicialização do sistema, tal arquivo é interpretado
por scripts que executam o fsck.
Esta opção permita fazer com que o init deixe de ser carregado pelo
-n shutdown, gerando, consequentemente, a finalização de todos os
processos ativos.
84
Alguns exemplos de uso do comando shutdown:
•• Desligar o sistema agora:
# shutdown -h now
•• Reiniciar o sistema para as 18h00:
# shutdown -r 18:00
•• Cancelar a execução do shutdown agendada:
# shutdown -c
•• Enviar mensagem para os usuários do sistema, informando que o sistema será

reiniciado em 20 minutos:
# shutdown -r 20 "O sistema será reiniciado em 20 minutos"
Quando não for necessário efetuar o desligamento/reinicialização do sistema em um

determinado momento agendado, podemos fazer o uso de outros comandos, como:
•• SYSVINIT:
•• halt , poweroff: Desliga a máquina;

•• init 0: Desliga o sistema;
•• reboot, init 6: Reinicia o sistema.
•• SYSTEMD:
•• systemctl halt, systemctl poweroff: Desliga a máquina;

•• systemctl reboot: Reinicia o sistema.
85
2.3.3. O comando wall

Por meio do comando wall, podemos notificar todos os usuários que estão conectados
ao sistema, independentemente do tipo de manutenção que será realizada.
Esse comando poderá ser utilizado de duas formas, conforme os exemplos a seguir:
•• Executar o comando wall e colocar a mensagem na linha abaixo. Dessa maneira,

após o término da digitação da mensagem, a sequência de teclas CTRL + D
deverá ser acionada para que a mensagem seja enviada aos usuários:
# wall
O sistema será reiniciado.

[root@localhost rules.d]#
Broadcast message from root@localhost.localdomain (pts/0) (Tue Nov 22
15:24:05 2016):
O sistema será reiniciado.
•• Executar o comando wall seguido pela mensagem. Dessa maneira, basta

pressionar a tecla ENTER para o envio da mensagem:
# wall "O sistema será reiniciado"
2.3.4. Encerrar os processos adequadamente

Umas das atividades que o administrador do sistema precisa realizar, é a parte de
gerenciamento e controle dos processos do sistema. Todo processo possui uma
identificação única, conhecida como PID (Process Identifier).
O administrador poderá encerrar um determinado processo pelo seu PID de

identificação ou encerrar um conjunto de processos, através de seu nome.
Para este tópico, os dois comandos que podemos utilizar são:
•• Kill: Encerra o processo através do seu PID;
•• Killall: Encerra o processo através do seu nome.
86
Para encontrar o PID do processo, podemos utilizar o comando ps, seguido por outro
comando grep, que tem a função de filtrar o resultado gerado, informando apenas o
valor de pesquisa. Exemplo:
# ps aux | grep ssh

root 1318 0.0 0.1 82560 3580 ? Ss 10:57 0:00 /usr/sbin/sshd-D
Quanto ao resultado, o PID é identificado através da segunda coluna e, com isso,

basta informar esse número ao comando kill:
# kill 1318
No comando anterior, o kill enviou um sinal ao processo, conhecido como SIGTERM,

que também pode ser representado pelo número 15. Esse tipo de sinal é o padrão do
comando, ou seja, você não precisa informar esse tipo de sinal ao kill.
Existem vários sinais que o comando kill pode enviar ao processo. Um outro que é
muito utilizado é o SIGKILL, ou -9, que força a remoção do processo na memória sem
mesmo permitir tempo para limpar a memória e os demais processos do disco. É um
tipo de sinal utilizado em último caso, quando o SIGTERM não foi capaz de encerrar
o processo adequadamente.
# kill -9 1318
O comando killall funciona da mesma forma que o kill, porém fazendo referência
ao nome do processo. É mais utilizado para matar todos os processos que possuem
o nome informado. Isso ocorre, por exemplo, quando se tem um processo pai (PID),
juntamente com vários outros processos filho, também conhecidos como (PPID -
Parent Process Identifier). O nome do processo é representado na última coluna do
resultado do comando ps.
# ps aux | grep httpd

root 3966 0.1 0.2 221908 4988 ? Ss 11:26 0:00 /usr/sbin/
httpd -DFOREGROUND
apache 3971 0.0 0.1 223992 3116 ? S 11:26 0:00 /usr/sbin/
httpd -DFOREGROUND
# killall httpd
87
Vejamos, a seguir, uma tabela de códigos do comando kill:
Sinal Código Descrição

Reinicia um serviço (daemon) apenas relendo seu arquivo
SIGHUP 1
de configuração.
SIGKILL 9 Finaliza um processo de forma forçada.
Finaliza um processo de forma normal, não forçando ou
SIGTERM 15
comprometendo a funcionalidade.
SIGCONT 18 Inicia um processo que esteja em estado Stopped.
SIGSTOP 19 Para momentaneamente a execução de um processo.
88
Pontos principais
•• Com exceção da placa de rede, os dispositivos de hardware, em sistemas GNU/

Linux, também são representados como arquivos, armazenados de forma
organizada no diretório /dev, onde podem ser administrados pelo usuário;
•• O processo de boot pode ser controlado por diversos sistemas de inicialização,

como: SystemVinit (versões antigas), SystemD (versões atuais), Upstart
(utilizado pela distribuição antigas do Ubuntu), entre outros;
•• Com o comando shutdown podemos reiniciar ou desligar o computador de

maneira segura, processo este apto a ser realizado imediatamente ou, então,
com base em um tempo predefinido na estrutura do próprio comando;
•• Por meio do comando wall, podemos notificar todos os usuários que estão
conectados ao sistema, independentemente do tipo de manutenção que será
realizada.
Sites Endereços
SysVinit https://wiki.archlinux.org/index.php/SysVinit
SystemD https://www.freedesktop.org/wiki/Software/systemd/
Upstart http://upstart.ubuntu.com/cookbook/
89
90
2 Arquitetura do
sistema
1. O resultado adiante poderá ser obtido com qual parâmetro do comando

lspci?

SATA Controller [AHCI mode] (rev 02) (prog-if 01 [AHCI 1.0])
Flags: bus master, fast devsel, latency 64, IRQ 21
I/O ports at 0000
I/O ports at 0000
Memory at f0806000 (32-bit, non-prefetchable) [size=8K]
Capabilities: [70] Power Management version 3
Capabilities: [a8] SATA HBA v1.0
Kernel driver in use: ahci
☐☐ a) --v
☐☐ b) -v
☐☐ c) -n
☐☐ d) -t
☐☐ e) -a

2. Qual comando visualiza dispositivos USB?
☐☐ a) lsusb
☐☐ b) usbls
☐☐ c) lsubs -v
☐☐ d) lsub -d
☐☐ e) lsusb -Q
3. Qual o nome do comando utilizado para remoção ou carregamento de

um determinado módulo no sistema?
☐☐ a) probemod
☐☐ b) probmode
☐☐ c) modeprobe
☐☐ d) modeprob
☐☐ e) modprobe
92
4. “No arquivo /proc/_____, podemos encontrar informações referentes
às IRQs associadas aos dispositivos correspondentes”. Qual alternativa
preenche a lacuna corretamente?
☐☐ a) ioports
☐☐ b) interrupts
☐☐ c) mounts
☐☐ d) modules
☐☐ e) devices
5. Qual o nome do comando que, ao ser executado, exibe as primeiras

linhas conforme o exemplo a seguir?
Module Size Used by

bnep 19704 2
bluetooth 372944 5 bnep
☐☐ a) modls
☐☐ b) lmod
☐☐ c) lsmode
☐☐ d) lsmo
☐☐ e) lsmod
6. Em uma distribuição onde o controle dos serviços do sistema ocorre

através do SysVinit, ao executar o comando init 1, o sistema executará
qual ação?
☐☐ a) O sistema será reiniciado.

☐☐ b) O sistema será desligado.
☐☐ c) O sistema ficará inoperante.
☐☐ d) O sistema será reiniciado em modo de monousuário.
☐☐ e) O sistema será reiniciado em modo de hibernação.
93
7. Em uma distribuição onde o controle dos serviços do sistema ocorre

através do SystemD, qual(is) a(s) sintaxe(s) do comando para verificar a
situação do serviço sshd?
☐☐ a) systemctl status sshd.service

☐☐ b) systemctl sshd.service status
☐☐ c) systemctl status sshd
☐☐ d) As alternativas A e C estão corretas.
☐☐ e) As alternativas B e C estão corretas.
8. Informe o parâmetro do comando shutdown que tem a função de

cancelar o desligamento/reinicialização do sistema, agendado pelo mesmo
comando.
☐☐ a) -C
☐☐ b) -c
☐☐ c) -r
☐☐ d) -h
☐☐ e) -s
9. Por padrão, o comando kill envia um sinal ao processo para que este
possa ser encerrado adequadamente. Qual o nome e o número desse sinal?
☐☐ a) SITERM, 15
☐☐ b) SIGKILL, 9
☐☐ c) SIGTERMI, 15
☐☐ d) SIGTERM, 15
☐☐ e) SIGKIL, 9
10. Qual das opções a seguir não é utilizada para a comunicação dos
periféricos com a CPU e outros periféricos?
☐☐ a) IO ports
☐☐ b) Direct memory access channels
☐☐ c) Interrupt requests
☐☐ d) TCP/IP ports
☐☐ e) Nenhuma das alternativas anteriores está correta.
94
11. Informe o diretório que possui um pseudossistema de arquivos
contendo informação sobre o sistema:
☐☐ a) /dev
☐☐ b) /proc
☐☐ c) /usr
☐☐ d) /sbin
12. O primeiro bloco no disco é chamado:
☐☐ a) GRUB
☐☐ b) Bootloader
☐☐ c) Master Boot Record
☐☐ d) Index
13. Qual dos seguintes comandos mostra as mensagens vindas do kernel

ring buffer em formato de saída padrão?
☐☐ a) cat /var/log/messages/kernel
☐☐ b) dmesg
☐☐ c) kernring
☐☐ d) lastlog
14. Qual(is) dos comandos adiante faz(em) parte dos comandos e utilitários
do SystemD?
☐☐ a) journalctl
☐☐ b) shutdownd
☐☐ c) systemctl
95
15. Qual dos comandos a seguir simula um evento de desligamento no

sistema, mas não desliga o sistema realmente?
☐☐ a) shutdown -h
☐☐ b) shutdown -k
☐☐ c) shutdown -r
☐☐ d) shutdown -c
16. Qual dos seguintes comandos faz parte do sistema de inicialização

Upstart?
☐☐ a) servicectl
☐☐ b) haltd
☐☐ c) journald
☐☐ d) initctl
☐☐ e) systemctl
96
2 Arquitetura do
sistema
Mãos à obra!
Laboratório 1 - Identificando o hardware

1. Verifique a quantidade de dispositivos USB na distribuição CentOS ou Debian:
# lsusb
2. Verifique se o módulo referente ao CD-ROM está carregado no sistema:
# lsmod | grep -i cdrom
3. Descarregue o módulo sr_mod do sistema:
# modprobe -r sr_mod
4. Visualize o conteúdo do arquivo partitions:
# cat /proc/partitions
5. Verifique a situação do serviço responsável pelo D-Bus:
# systemctl status dbus
6. Podemos listar os dispositivos PCI conectados à máquina por meio dos comandos:
# lspci -nn
# lspci -k
# lspci -vv
# lspci –d <vendor_ID>
7. Podemos listar os dispositivos USB conectados à máquina por meio dos comandos:
# lsusb
# lsusb -t
# lsusb –t <vendor_ID>
# lsusb –s <bus:device>
98
Laboratório 2 - Desligando/reiniciando o
sistema
1. Programe o desligamento do sistema para as 18h00, informando todos os usuários
conectados:
# shutdown -h 18:00 "O sistema será desligado às 18h00"
2. Cancele o agendamento:
# shutdown -c
3. Envie uma mensagem qualquer a todos os usuários do sistema:
# wall "Mensagem"
4. Encerre todos os processos pai e filho de um determinado serviço:
# killall sshd
5. Verifique as mensagens ocorridas no momento do boot:
# journalctl -b
# dmesg
# dmesg -T
# dmesg -K
99
3 Instalação
do Linux e
gerenciamento
de pacotes
ÃÃ Particionamento do disco;
ÃÃ Instalando um gerenciador de boot;
ÃÃ Gerenciando bibliotecas compartilhadas;
ÃÃ Gerenciador de pacotes .DEB;
ÃÃ Gerenciador de pacotes .RPM.
Este capítulo faz parte do tópico 102 - Linux Installation and Package Management,
da primeira prova identificada como 101-400 ou LX0-103 da certificação LPIC-1.
Você precisará estar apto a particionar o disco conforme as características de cada

diretório, adicionar um sistema de arquivos, realizar a instalação do Sistema
Operacional, gerenciar e configurar o gerenciador de boot e os programas que são
instalados via pacotes .DEB ou .RPM.

Para o mercado de trabalho, você precisará estar confortável para gerenciar os

pacotes tanto .DEB, quanto .RPM, assim como também saber particionar o disco
para uma instalação, de acordo com as necessidades específicas da empresa.
3.1. Particionamento do disco
O particionamento é um processo muito delicado, que deverá ser feito com total
controle e atenção para minimizar futuros problemas.
Para a instalação do Sistema Operacional GNU/Linux, são necessárias, ao menos, uma

partição identificada como raiz (/), que conterá todos os diretórios necessários para o
pleno funcionamento do SO, e uma outra identificada como swap (área de troca), que
permite que o computador supra uma necessidade de memória adicional a partir de
um espaço em disco.
Ainda que um simples arquivo possa ser definido como swap, a funcionalidade de um
espaço de swap é muito maior quando for uma partição separada. Contudo, o mais
indicado é criar partições menores para hospedar partes separadas do sistema. Dessa
forma, não só o reparo de algum corrompimento é mais fácil, pois pode ser feito
de forma localizada, substituindo somente a partição afetada através de backups,
como o desempenho do computador tende a melhorar, pois um problema com algum
procedimento específico não afetará as outras partes do sistema.
102
Instalação do Linux e gerenciamento de pacotes 3
Para planejar o particionamento do disco rígido, deve-se conhecer bem o FHS

(Filesystem Hierarchy Standard), que especifica os diretórios obrigatórios, além de
diretórios opcionais ou recomendados. Os diretórios obrigatórios são os seguintes:
Diretório Descrição
Contém todos os outros diretórios do sistema. É o principal diretório
/ (raiz)
de um sistema GNU/Linux.
Contém arquivos binários de comandos que são essenciais para a
bin
inicialização básica do sistema.
Contém informações dos gerenciadores de inicialização, arquivos
boot
de imagem do kernel e auxiliares.
Arquivos orientados a dispositivos gerais e outros arquivos
dev
especiais.
Contém arquivos de configuração para o sistema, aplicações e
etc
serviços.
Contém bibliotecas dinâmicas, essenciais à inicialização básica do
lib
sistema e armazena módulos do kernel.
media Pontos de montagem para mídias removíveis.
mnt Utilizado em pontos de montagem de uso temporário.
Utilizado para instalar pacotes adicionais por meio do processo de
opt
compilação.
Contém arquivos binários essenciais à inicialização básica do
sbin
sistema, porém, é utilizado somente em nível administrativo.
Contém informações estáticas de serviços disponibilizados pelo
srv
sistema.
tmp Armazena arquivos de ordem temporária.
Mantém informações estáticas de aplicativos e serviços gerais
usr
instalados no sistema.
Contém informações variáveis, tanto do sistema como de aplicativos
var
em geral.
103
Além desses, temos o diretório opcional home, que serve para centralizar dados
pessoais de usuários comuns, e o root, que serve para centralizar dados pessoais
do superusuário root. Recomenda-se, ainda, utilizar o diretório virtual /proc, que
armazena informações sobre o sistema e processos. Ele se localiza na memória RAM,
não ocupando espaço no disco rígido.
É importante relembrar, também, que as partições podem ser primárias, estendidas e

lógicas. As partições primárias possuem suas informações registradas na MBR (Master
Boot Record), que possui um limite de quatro partições primárias. As partições
estendidas são partições primárias especiais que podem conter outras partições.
As partições lógicas são partições contidas dentro de uma partição primária, sendo,
portanto, definidas nestas últimas e não na MBR.
A seguir, veremos algumas recomendações referentes aos principais diretórios e

partições do sistema, lembrando que os valores mudam expressivamente com o uso,
sendo as indicações a seguir apenas sugestões gerais:
•• É altamente recomendável que uma partição seja criada somente para o diretório
raiz (/), pois como ele contém necessariamente os diretórios /etc, /bin, /sbin, /lib
e /dev, que são os componentes mais essenciais do sistema, o corrompimento de
qualquer outra partição ainda permitirá a inicialização do sistema, possibilitando
seu reparo. Entre 150 e 250 MB são normalmente usados pela partição raiz;
•• O diretório /usr é normalmente o que ocupa mais espaço em disco, sendo

recomendável reservar, no mínimo, 500 MB em disco para ele. Em servidores ou
estações de trabalho grandes, esse valor deve ir para algo entre 4 e 6 GB;
•• O diretório /var, onde ficam os dados variáveis, ocupa um espaço absolutamente

dependente do que o usuário pretende. Um tamanho tão reduzido quanto 30
ou 40 MB, no caso de um sistema com poucas atualizações planejadas, ou tão
grande quanto 2 ou 3 GB, para instalações completas, podem ser recomendados.
Uma instalação manual pode usar em torno de 300 a 500 MB;
•• Entre 40 e 100 MB devem ser suficientes para o diretório /tmp, a menos que o
usuário pretenda usar aplicativos que armazenem temporariamente arquivos de
imagem, como ferramentas usadas na criação de CDs e DVDs, por exemplo. É
comum a criação de uma partição própria para o diretório /tmp;
•• Dentro do diretório /home, ficarão os arquivos pessoais de cada usuário,

portanto o tamanho total do diretório varia de acordo com o número de usuários
no servidor e a espécie de arquivos que os usuários armazenam, mas uma
média de 100 MB para cada usuário tende a ser suficiente, a menos que muitos
arquivos multimídias forem salvos. Caso existam muitas contas de usuários, é
recomendável criar uma partição /home grande;
104
•• Se muitos programas que não façam parte da distribuição forem ser instalados,
é bom criar uma partição /usr/local separada para armazená-los;
•• Para computadores que funcionem como servidor de e-mails, é altamente

recomendável que o arquivo /var/mail tenha sua própria partição, já que isso
minimizará os efeitos de spam, lotação e congestionamento nas outras partes
do sistema.
É vantajoso colocar os diretórios /usr, /var, /tmp e /home em partições separadas

na raiz, em sistemas multiusuários ou com muito espaço em disco.
3.1.1. Sistemas de arquivos
Além de definir o particionamento, é de fundamental importância escolher o sistema
de arquivos utilizado. A seguir, abordaremos os principais sistemas de arquivos que
podemos utilizar.
É importante ressaltar que a principal diferença entre eles é que o sistema ext2 não
utiliza journaling, ao passo que os outros três utilizam este recurso, que será descrito
mais adiante.
•• ext2 (Second Extended File System)
O ext2 é um sistema de arquivos cuja estrutura básica é o inode (index node). Cada
arquivo e diretório possui um inode próprio. O inode é uma identificação de cada
arquivo no sistema. Por não possuir journaling, checagens nesse sistema podem ser
demoradas.
Vejamos suas principais características:
•• Utiliza blocos do mesmo tamanho;

•• Partição de até 4 TB;
•• Até 255 caracteres do nome de arquivo;
•• Reserva 5% dos blocos para o usuário root.
•• ext3
O ext3 é uma versão journaling do sistema de arquivos ext2. Um sistema de arquivo

com journaling trabalha com um log chamado journal, onde as informações referentes
a uma operação que será realizada são registradas, antes de serem realizadas de fato.
Assim, caso uma operação seja interrompida, pode ser completada posteriormente,
pois as informações necessárias já estão armazenadas no journal.
105
•• Trabalha com journaling;

•• Permite utilizar sistema de cotas;
•• Trabalha com blocos de 1,2 e 4 Kb;
•• Tamanho máximo de um arquivo é de 2 TB.
•• ext4
Utilizado em desktops, o ext4 é uma melhoria do sistema de arquivos ext3, com

alguns recursos que foram melhorados, como: tolerância a falhas, desempenho,
tamanho maior de volume e arquivos, maior número de subdiretórios, ente outros.
•• Possui um melhor desempenho e capacidade de armazenamento;

•• Trabalha com alocação múltipla de blocos;
•• Trabalha com journaling;
•• Número ilimitado de diretórios;
•• Tamanho máximo de um arquivo é de 16 TB.
•• reiserfs
O reiserfs possui seu núcleo baseado em uma mesma árvore, a conhecida B+ (árvore
balanceada). Cada diretório apresenta uma subárvore da árvore principal, não
havendo uma árvore diferente para cada diretório. Ele utiliza o recurso journaling, e
sua conduta é armazenar apenas os metadados no journal. Estes dados armazenados
se referem ao tamanho e às permissões do arquivo.
•• Núcleo baseado em uma mesma árvore B+;

•• Trabalha com blocos de 4Kb;
•• Tamanho máximo de uma partição é de 1 EB.
•• xfs
xfs é um sistema de arquivos com journaling otimizado para escalabilidade. Usado

em sistemas com fibra óptica e HD SCSI, ele é dotado de relevantes funcionalidades.
No entanto, podemos perder dados se ocorrer uma falha de energia quando arquivos
estiverem sendo gravados em disco. Essa perda ocorre em razão da quantidade de
cache que o xfs faz dos dados transitando na memória RAM, e por falhas de projeto
de muitos programas. Sistemas com no-breaks são os mais sugeridos para a utilização
do xfs.
106
•• Sistema de arquivo mais potente já desenvolvido;

•• Utilizado para desempenho em escalas extremamente grandes;
•• Trabalha com journaling a um endereçamento de 64 bits;
•• Trabalha com blocos de até 64 Kb;
•• Tamanho máximo de uma partição é de 16 Tb para 32 bits e 8,58 EB.
3.1.2. Conceitos de LVM
Existem momentos em que é necessário expandirmos o sistema, e isso pode ser
um grande problema, levando-se em conta os espaços disponíveis em partições,
especialmente nos servidores, onde seria necessário até a paralisação de seu
funcionamento para a migração de dados. Para evitar esses tipos de transtornos,
podemos utilizar o esquema de particionamento por LVM, ou Logical Volume
Management (Gerenciamento de Volumes Lógicos), um gerenciador de discos que nos
permite uma interação completa com os dispositivos de armazenamento, tornando
seu gerenciamento mais simples do que na utilização do particionamento tradicional.
O LVM permite trabalhar com vários discos para realizar uma função determinada. Sendo
assim, podemos utilizar volumes físicos para constituir uma área de armazenamento,
que será o volume lógico. As partições devem estar formatadas com o tipo LVM para
que seja possível trabalharmos com o gerenciador.
A ilustração a seguir resume o esquema LVM:
107
A tabela a seguir explica os elementos do esquema LVM:
Elemento Descrição
Tipicamente um disco rígido, uma partição do disco
ou qualquer dispositivo de armazenamento de mesma
natureza, como um dispositivo RAID, que será usado pelo
formato LVM. O PV serve para dar o número de identificação
Volume Físico de cada disco, o UUID.
PV
(Physical Volume) Quando inserimos um volume físico em um grupo de
volume e cada volume físico é dividido em pequenas
porções de dados, temos um trecho físico PE. Cada porção
é denominada PE (Physical Extent) e possui o mesmo
tamanho de um LE.
É a unidade administrativa com nível mais alto de abstração
Grupo de Volumes
do LVM. Consiste no conjunto de volumes físicos que
VG
serão utilizados no sistema de arquivos do volume lógico.
(Volume Group)
É possível termos diversos VGs.
O volume lógico é utilizado para alocar os grupos de volume
e é o equivalente a uma partição de disco tradicional. O LV
pode conter um sistema de arquivos, pois age como uma
partição tradicional, e pode ser acessado pelos usuários,
Volume Lógico
sendo associado a um ponto de montagem específico.
LV
(Logical Volume)
Volumes lógicos divididos em pequenas porções de
dados caracterizam um trecho lógico LE. Cada porção
é denominada LE (Logical Extent), e todas possuem o
mesmo tamanho.
3.2. Instalando um gerenciador de boot

O gerenciador de boot é um programa cuja função é acessar o disco do computador e
carregar o sistema operacional na memória para assumir o controle do equipamento.
Conforme for a utilização do bootloader, nem sempre ele será visualizado na
inicialização. Na maioria das vezes, ele estará completamente invisível para o usuário.
No GNU/Linux, os bootloaders mais conhecidos são: LILO (não mais utilizado), GRUB
e GRUB2.
108
3.2.1. Gerenciador de boot GRUB
Muito utilizado em distribuições mais antigas, comparado com as atuais, o GRUB
(Grand Unified Bootloader) é um gerenciador de boot que, assim como o LILO,
é bastante versátil. A interface gráfica por ele apresentada pode ser facilmente
configurada, permitindo a alteração das letras e da imagem de fundo, entre outras
opções. Inclusive, é possível que seu ambiente seja apresentado em modo texto.
Além disso, o GRUB é capaz de promover o gerenciamento de diversos kernels sem
que haja a necessidade de gravar a posição física do kernel em disco.
Por meio do GRUB, podem ser carregados diversos sistemas operacionais, tanto
livres quanto proprietários. Tendo em vista que o gerenciador de inicialização em
questão permite a escolha de partições por meio de um menu gráfico, caso o GRUB
seja configurado como gerenciador padrão, após o hardware ter sido checado pela
BIOS, será exibida uma tela gráfica contendo uma listagem de sistemas operacionais
disponíveis para serem selecionados.
O arquivo /boot/grub/menu.lst é o arquivo de configuração do gerenciador de boot

GRUB. Vejamos, na tabela a seguir, as principais opções do arquivo menu.lst:
Arquivo Descrição
Essa opção tem a finalidade de definir o tempo de espera para a
entrada do teclado. Apenas salientando, esse tempo de espera
timeout é definido em segundos. Caso nenhuma tecla seja pressionada
no tempo determinado, o sistema padrão será carregado
automaticamente.
Essa opção é responsável por determinar qual sistema
operacional será definido como padrão quando nenhuma tecla
default for pressionada no tempo especificado. A opção default deve
ser indicada através de um valor numérico, sendo que o número
0 (zero) indica a primeira imagem como padrão.
Caso ocorram erros inesperados e seja impossível carregar a
fallback
imagem padrão, a opção indicada em fallback será carregada.
Essa opção tem a finalidade de definir o número de cores
color
utilizadas no menu do GRUB.
Essa opção é responsável por definir a cor de primeiro plano,
foreground
que deve ser definida em notação hexadecimal.
Essa opção é responsável por determinar a cor de fundo. É
background
fundamental que essa cor seja definida em notação hexadecimal.
Essa opção tem a finalidade de determinar o arquivo que será
splashimage
utilizado como papel de parede pelo GRUB.
Por meio dessa opção, podemos definir uma senha global para
password o GRUB. Com isso, torna-se necessário digitar uma senha para
utilizar o seu prompt.
109
A partir de agora, abordaremos as opções dos sistemas operacionais instalados na

máquina e que podem ser carregados pelo GRUB. Observe, então, na tabela a seguir,
a descrição dessas opções:
Opção Descrição
Utilizamos essa opção para informar o endereço do arquivo initrd.

Vejamos um exemplo:
initrd
initrd /boot/initrd.img-2.6.25
Quando utilizamos essa opção, podemos informar qual imagem

carregaremos. Além disso, podemos passar mais alguns parâmetros
para o kernel:
kernel
•• vga;
•• mem;
•• ramdisk e outros.
Essa opção determina qual é a raiz do sistema. Vejamos um exemplo:

root
root(hd0,0)
Por meio dessa opção, podemos definir um título que será apresentado
no menu do boot. Vejamos um exemplo:
title
title Debian GNU/Linux, kernel 2.6.25
Existe a possibilidade do GRUB não detectar a memória de forma correta durante a

inicialização gráfica. Se isto ocorrer, basta seguir os procedimentos adiante:
1. Adicione o parâmetro mem=xxxM ao final da linha referente ao kernel, no arquivo

/boot/grub/menu.lst;
2. Substitua xxxM pela quantidade de memória disponível no computador, lembrando-

se de descontar a memória compartilhada com a placa de vídeo, se esta for onboard;
3. Reinicie o computador.
Podemos dizer que a interface do menu é bastante simples de usar. Apresentando

comandos que são descritos na tela de forma razoavelmente intuitiva, essa interface
fornece uma relação de entradas de boot com o objetivo de possibilitar ao usuário a
escolha de uma dessas entradas.
110
Para selecionar uma entrada e executá-la, basta seguir os passos adiante:
1. Utilize as teclas direcionais para selecionar a entrada;
2. Pressione ENTER para executar a entrada.
Para efetuar a inicialização da entrada padrão, ou seja, da primeira entrada, desde

que não esteja configurada, está disponível um tempo de expiração opcional. Então,
basta pressionar qualquer tecla.
Quando a tecla C é pressionada, os comandos ficam disponíveis para inserir uma

linha de comandos vazia. Apesar de operar praticamente da mesma maneira que
a versão de arquivo não configurável do GRUB, a tecla C permite que uma linha de
comandos seja digitada. Para retornar ao menu, pressionamos ESC. Com o intuito de
editar quaisquer das entradas de boot, basta pressionar a tecla E.
Nas situações em que a interface de menu está protegida com uma senha, é
necessário selecionar uma entrada e pressionar ENTER ou, então, pressionar P
para inserir a senha.
Uma vez que temos acesso à linha de comandos, podemos verificar os comandos
disponíveis. Para isso, pressionamos a tecla TAB, que permite também completar
nomes e parâmetros de alguns comandos.
Na tabela adiante, temos a descrição dos comandos mais utilizados na linha de

comandos do GRUB:
Comando Descrição
boot Executa o boot.
Esse comando é responsável por carregar o arquivo de

configuração do GRUB. Vejamos um exemplo:
configfile
grub> configfile (hd0,6) /boot/grub/menu.lst
Tem como finalidade exibir informações sobre APM (Advanced

displayapm
Power Management).
displaymem Exibe informações sobre a memória RAM.
Quando utilizamos esse comando, podemos encontrar um

arquivo. Além disso, a saída desse comando torna disponível o
nome completo do caminho para o arquivo, inclusive a partição
find
em que o arquivo está localizado. Vejamos um exemplo:
grub> find issue
111
Comando Descrição
Essa opção é responsável por nos apresentar ajuda. Vejamos
um exemplo:
help
help color
Esse comando é responsável por abandonar a linha de comandos

quit
do GRUB.
reboot Esse comando é responsável por reiniciar o computador.
root Tem como finalidade especificar a partição raiz.
Ao utilizar esse comando, podemos instalar o GRUB. O

procedimento a seguir descreve os passos para instalar o GRUB
utilizando o comando setup:
setup
grub> root = (hd0,0)
grub> setup = (hd0)
Considere que o Linux esteja instalado em (hd0,6). A partir dessa ideia, podemos
passar comandos na linha de comandos. Os comandos transmitidos têm o objetivo
de efetuar a inicialização de uma imagem do GNU/Linux. São eles:
grub> root (hd0,6)

grub> kernel (hd0,6)/boot/vmlinuz-2.6.25 vga=769
grub> boot
É possível passar parâmetros diretamente ao kernel. Para isso, selecione, no menu

de inicialização, a linha iniciada pelo nome kernel e pressione a tecla E, para editá-la
com os parâmetros desejados.
112
A tabela a seguir lista os parâmetros de inicialização mais comuns:
Parâmetro Descrição
Esse parâmetro é responsável por ligar ou desligar o suporte a
ACPI. A seguir, temos um exemplo de utilização desse parâmetro:
acpi
acpi=off
Esse parâmetro tem a função de designar uma alternativa de

programa para executar no lugar de /sbin/init. Por exemplo:
init
init=/bin/bash
Esse parâmetro define um número máximo de processadores que

estarão visíveis para o sistema. Seu uso só é adequado quando o
computador possui suporte a multiprocessamento SMP. Adiante,
temos um exemplo de utilização desse parâmetro, em que x
corresponde ao número que se quer definir:
maxcpus
maxcpus=x
Ao definirmos o valor 0, o suporte a SMP será desligado, o que

equivale a utilizar o parâmetro nosmp.
Esse parâmetro estabelece a quantidade de memória RAM que será
disponibilizada para o sistema. Vejamos um exemplo:
mem mem=xM
Em que x corresponde à quantidade de memória estabelecida e M

é a sigla para megabytes.
Esse parâmetro determina que a maioria das mensagens de
quiet
inicialização não seja exibida.
Esse parâmetro permite selecionar um modo de vídeo. Vejamos o

exemplo a seguir, em que x corresponde ao modo de vídeo que se
vga quer selecionar:
vga=x
Esse parâmetro permite definir uma partição raiz diferente daquela

que o carregador de boot possui definida. Vejamos um exemplo:
root
root=/dev/sda3
Esses parâmetros permitem a realização de uma montagem inicial

ro ou rw como somente leitura (ro – read only) ou leitura e escrita (rw –
read and write).
113
3.2.2. Gerenciador de boot GRUB2

No GRUB2, a maioria das configurações é realizada através de comandos, eliminando,
assim, a necessidade de editar os arquivos de configuração. Seu principal arquivo de
configuração está localizado no diretório /boot/grub2/grub.cfg. Não é aconselhável
a edição manual desse arquivo. Sua atualização ocorre através do comando grub2-
mkconfig.
Vejamos, a seguir, algumas características do GRUB2:
•• Suporte de script, como condicionais, loops, variáveis e funções;
•• Interface gráfica;
•• Carregamento dinâmico de módulos de forma a estender-se no tempo de

execução e não no tempo de compilação;
•• Portabilidade para várias arquiteturas;
•• Modular, hierárquica, objeto quadro orientado para os sistemas de arquivo,

arquivos, dispositivos, discos, terminais, os comandos, as tabelas de partição e
Load de OS;
•• Cross-platform install, que permite a instalação do GRUB de uma arquitetura

diferente;
•• O modo de recuperação salva casos que não realizam boot.
Também temos o diretório /etc/grub.d/, que armazena scripts de configuração, que

são usados pelo comando grub2-mkconfig para gerar o arquivo grub.cfg.
Vejamos, a seguir, a função de alguns arquivos:
•• 00_header: Cabeçalho do grub;
•• 10_linux: Arquivos de configuração;
•• 30_os-prober: Outros SOs;
•• 40_custom e 41_custom: Configurações customizadas.
Dependendo do tipo específico de configuração a ser realizado no GRUB2, como

alterar o tempo de espera para iniciar o sistema operacional default, por exemplo,
você poderá realizar no arquivo encontrado em /etc/default/grub.
114
Todas as vezes que alguma configuração for realizada, o comando grub2-mkconfig
deverá ser executado para a atualização do arquivo grub.cfg.
A tabela a seguir lista os parâmetros de configuração mais comuns:
GRUB_DEFAULT Define a entrada do menu padrão de inicialização.
Define o tempo de inicialização. Coloque 0 para iniciar
GRUB_TIMEOUT
imediatamente ou -1 para anular o contador.
Parâmetros a serem passados na linha de comando
do kernel para todas as entradas do menu do GNU/
Linux. Por exemplo, para suportar a hibernação, os
GRUB_CMDLINE_LINUX
usuários precisarão adicionar GRUB_CMDLINE_LINUX
= "resume =/dev/sdXY" com /dev/sdXY sendo a
partição swap.
GRUB_CMDLINE_LINUX_ Parâmetros a serem passados na linha de comando do
DEFAULT kernel para não recuperação de entradas do menu.
O dispositivo raiz inicial (ou seja, raiz do kernel = parâmetro).
Defina esta opção para substituir autodetecção de
GRUB_DEVICE dispositivo raiz do comando grub2-mkconfig. Por
exemplo, GRUB_DEVICE = /dev/ram0 forçará o root=/
dev/ram0 para ser usado na linha de comando do kernel.
No momento do carregamento do kernel, é possível passar parâmetros específicos,

conforme a necessidade de mudança de algumas ações. Entre elas temos:
rw Realiza a montagem como leitura e escrita.
vga Informa um modo de vídeo.
quiet Omite a maioria das mensagens de inicialização.
mem Informa a quantidade de memória RAM que estará disponível.
Informa outro programa a ser carregado como alternativa ao

primeiro processo do INIT.
init
Init=/bin/bash
Habilita ou desabilita o suporte a ACPI (economia de energia e

acpi
inicialização de vários periféricos).
115
Também é possível ter acesso ao prompt de comando do GRUB2, bastando pressionar

a tecla E no momento da apresentação da tela de boot. Com isso podemos digitar
alguns comandos, como:
Informa a localização física de um arquivo no disco em setores.

blocklist
grub> blocklist (hd0,3)/boot/grub/stage2
Carrega um arquivo grub.cfg. Você provavelmente precisará usar

o comando de busca para encontrar um /boot/grub/grub.cfg em
configfile primeiro lugar. Se for bem sucedido, o GRUB irá apresentar o menu
de inicialização do grub.cfg e você pode utilizar os comandos que
já estão lá para arrancar qualquer sistema operacional listado.
Inicializa outro carregador de inicialização.

chainloader
grub> chainloader (hd0)+1
Insere um módulo. Se um módulo é especificado por ele de nome,

o nome do arquivo correspondente é procurado na pasta apontada
insmod pelo prefixo variável (como (hd0,1)/boot/grub/).
grub> insmod /boot/grub/play.mod
GRUB2 tem um design modular, para que possamos adicionar

novos módulos ou atualizar módulos antigos para adicionar
mais funcionalidades. Cada módulo é projetado para executar
alguma função. Existem módulos para cada comando, módulos
para o display de vídeo, compreendendo os sistemas de arquivos,
module
fornecendo as fontes, e assim por diante. Estes módulos podem
ser "inseridos" quando necessário.
Se você está tentando fazer algo em GRUB e recebe um erro "não
carregado", tente usar o comando insmod para inserir o módulo
amd e, então, tente novamente o comando insmod.
Este comando está implícito no final das entradas do menu grub.
boot
cfg.
116
Para a instalação do GRUB em um determinado disco, basta executar o comando
grub-install, que obtém as devidas instruções no arquivo /boot/grub/menu.lst. Já
para o GRUB2, o comando grub2-install é necessário, que copiará a imagem da MBR
do disco para o diretório /boot/.
# grub2-install /dev/sda
No exemplo adiante, os arquivos do GRUB2 serão instalados no diretório /mnt/boot/:
# grub2-install --boot-directory=/mnt/boot /dev/sda
Informações mais detalhadas sobre o GRUB e o GRUB2 já foram estudadas no capítulo

sobre arquitetura do sistema.
3.3. Gerenciando bibliotecas compartilhadas

As bibliotecas podem ser definidas como arquivos que contêm um conjunto de
módulos ou membros de códigos pré-compilados reutilizáveis.
Diversos programas podem utilizar esses códigos pré-compilados sem a necessidade

de detalhes de sua implementação. Depois de a biblioteca estar fabricada, não haverá
mais necessidade de compilar, basta apenas ligá-la ao programa desejado. Além
disso, o desenvolvedor não precisa se preocupar com detalhes e pode se concentrar
apenas no problema mais relevante. Sendo assim, podemos concluir que a utilização
das bibliotecas oferece vários benefícios.
A seguir, descreveremos os dois tipos de bibliotecas existentes:
•• Bibliotecas de ligação estática: São bibliotecas ligadas ao programa em tempo

de execução e fazem parte do arquivo executável;
•• Bibliotecas dinâmicas: São bibliotecas cuja ligação ocorre por demanda.

Consequentemente, elas não fazem parte do programa principal, o que faz que
o tamanho do arquivo executável seja reduzido.
117
Esses dois tipos de bibliotecas apresentam algumas diferenças quanto à sua utilização,
pois as bibliotecas estáticas permitem que o código executável fique mais livre da
configuração de ambiente, o que significa que todo código que o programa necessita
para ser executado já se encontra no próprio executável.
As bibliotecas dinâmicas, por sua vez, fazem com que o programa seja dividido em
um módulo principal e um ou mais módulos que serão ligados de maneira dinâmica,
ou seja, essa ligação só ocorrerá se o módulo for solicitado.
Essas bibliotecas ocupam menos memória RAM, menos espaço em disco e menos
recursos do sistema, além de possuírem manutenção mais simples. Por exemplo,
a substituição dos módulos defeituosos pode ser realizada sem a necessidade de
compilar novamente todos os outros módulos ou sistemas envolvidos.
3.3.1. Bibliotecas dinâmicas (compartilhadas)

O Linux proporciona flexibilidade quando utilizamos bibliotecas dinâmicas. Algumas
propriedades decorrentes dessa flexibilidade estão descritas a seguir:
•• Atualização de bibliotecas e fornecimento de suporte aos programas que

pretendem utilizar versões mais antigas e retrógradas, incompatíveis, dessas
bibliotecas;
•• Cancelamento de bibliotecas específicas ou de funções específicas em uma

biblioteca, durante a execução de um determinado programa;
•• Realização das tarefas anteriores enquanto os programas estão sendo executados

com a utilização de bibliotecas já existentes.
3.3.2. Identificando as bibliotecas dinâmicas

O comando ldd (list dynamic dependencies, ou listar dependências dinâmicas) é
responsável por imprimir as dependências das bibliotecas dinâmicas. Com a utilização
do ldd, podemos descobrir quais bibliotecas dinâmicas um determinado programa
utiliza.
A sintaxe do ldd é a seguinte:
ldd [opcao] <caminho_aplicativo>
118
A seguir, serão apresentadas algumas opções do comando ldd:
Opção Descrição
Esta opção é responsável por imprimir o número da versão do
--version
ldd.
Esta opção é responsável por imprimir as informações de forma
-v, --verbose
detalhada.
Esta opção tem como finalidade realizar realocações e relatar
-d, --data-relocs qualquer objeto que esteja faltando (somente ELF – Executable
and Linking Format).
--help Exibe informações de ajuda.
No exemplo a seguir, utilizamos o ldd para verificar as bibliotecas necessárias para

execução do programa ssh:
# ldd /usr/bin/ssh
linux-vdso.so.1 => (0x00007ffe8718d000)

libfipscheck.so.1 => /lib64/libfipscheck.so.1 (0x00007fe969a9d000)
libselinux.so.1 => /lib64/libselinux.so.1 (0x00007fe969878000)
libcrypto.so.10 => /lib64/libcrypto.so.10 (0x00007fe96948f000)
. . .
3.3.3. Convenção de nomes
Cada biblioteca dinâmica possui um realname (nome de arquivo que contém o código
atual da biblioteca) e um soname (um nome especial que, sendo completamente
qualificado, é um link simbólico ao realname da biblioteca dinâmica). É muito
importante entender a diferença entre esses nomes.
O formato do soname é composto por:
•• Prefixo lib;
•• Nome da biblioteca;
•• A frase .so;
•• Um ponto (.) e número da versão, adicionados toda vez que ocorrem alterações
na interface.
119
Para a execução do comando echo, por exemplo, é necessária a biblioteca libc.so.6.

O soname dessa biblioteca é libc.so.6.
# ldd /bin/echo
linux-vdso.so.1 => (0x00007ffda6102000)

libc.so.6 => /lib64/libc.so.6 (0x00007f1ba70d8000)
/lib64/ld-linux-x86-64.so.2 (0x00007f1ba74b2000)
Já o conjunto realname, atuando em conjunto com o soname, acrescenta a ele:
•• Um ponto (.);
•• Um número menor que, juntamente com o número de release a seguir, auxilia

no controle de configuração, possibilitando o reconhecimento da(s) versão(ões)
da biblioteca instalada;
•• Outro ponto (.), que é opcional;
•• Número de release (opcional).
No exemplo a seguir, podemos perceber a biblioteca libcre.so.1 (este é o soname). O

soname é um link simbólico para o realname libcre.so.1 (/lib64/libcre.so.1), ambos
na versão 1. Por fim, temos o formato soname => realname.
# ldd /bin/ls
linux-vdso.so.1 => (0x00007fff65897000)

libselinux.so.1 => /lib64/libselinux.so.1 (0x00007faaafcdf000)
libcap.so.2 => /lib64/libcap.so.2 (0x00007faaafada000)
libacl.so.1 => /lib64/libacl.so.1 (0x00007faaaf8d0000)
libc.so.6 => /lib64/libc.so.6 (0x00007faaaf50e000)
libpcre.so.1 => /lib64/libpcre.so.1 (0x00007faaaf2ad000)
120
3.3.4. Localização
As localizações padrão das bibliotecas são os arquivos /lib e /usr/lib. Qualquer
localização adicional deve ser incluída ao arquivo /etc/ld.so.conf ou ao /etc/ld.so.
conf.d/, caso ele exista na distribuição em questão.
As bibliotecas são carregadas e ligadas aos programas que as utilizam graças ao

trabalho em conjunto do programa ld.so com o mapeamento realizado pelo arquivo
/etc/ld.so.cache, que deve ser atualizado com o comando ldconfig, visto em mais
detalhe no tópico a seguir. O ld.so é aberto toda vez que algum programa necessite
de alguma biblioteca externa.
Porém, se o usuário não estiver autorizado a modificar o arquivo /etc/ld.so.conf,

uma maneira de tornar uma biblioteca disponível para o uso do ld.so é adicionar
seu caminho à variável de ambiente LD_LIBRARY_PATH com o comando export LD_
LIBRARY_PATH=[caminho]. Essa medida é temporária, e o caminho não funciona
fora do escopo da variável ou quando ela deixar de existir.
3.3.5. Utilizando o comando ldconfig

Uma das funcionalidades do comando ldconfig é configurar as ligações em tempo
de execução do link dinâmico. Além disso, ele examina os arquivos existentes, cria
sonames como links simbólicos aos realnames e configura o arquivo de cache /etc/
ld.so.cache.
Como dito anteriormente, o ldconfig é essencial para atualizar o etc/ld.so.cache

com qualquer alteração feita no /etc/ld.so.conf, arquivo que contém uma lista de
diretórios que serão pesquisados na procura por bibliotecas, de forma que elas
possam ser usadas pelo ld.so.
Depois de instalar uma nova versão de uma biblioteca em determinados diretórios

especiais, é fundamental utilizar o programa ldconfig. Vale ressaltar que o arquivo /
etc/ld.so.cache não está em um formato que pode ser lido por humanos, portanto,
não devemos modificá-lo manualmente.
É importante salientar que o comando ldconfig não realiza qualquer configuração

nos link names automaticamente. Os instaladores estão encarregados de alterar os
links simbólicos para que os elementos utilizados pelo link sejam atualizados para
uma determinada biblioteca.
A sintaxe de ldconfig é a seguinte:
ldconfig [opcao]
121
A seguir, serão apresentadas as principais opções do comando ldconfig:
Opção Descrição
Exibe detalhes na execução do comando. É responsável por
imprimir o número da versão atual, o nome de cada diretório
-v, --verbose
da forma como ele é examinado e quaisquer links que sejam
criados.
Processará apenas os diretórios definidos na linha de
-n
comandos.
Esta opção não constrói o cache novamente. Vale ressaltar que
-N a atualização dos links também ocorrerá, exceto se a opção -X
também for definida.
-X Esta opção não permite atualizações nos links.
Esta opção utiliza o arquivo determinado na linha de comandos
-f <arquivo>
em vez do /etc/ld.so.conf.
Esta opção imprime as listas de diretórios e as bibliotecas que
-p, --print-cache
estão armazenadas no cache atual.
--help, --usage Esta opção exibe informações de ajuda.
No exemplo a seguir, utilizamos o comando ldconfig para exibir o ld.so.cache

(bibliotecas em cache):
# ldconfig -p | less
1157 libs found in cache '/etc/ld.so.cache'

p11-kit-trust.so (libc6,x86-64) => /lib64/p11-kit-trust.so
libzapojit-0.0.so.0 (libc6,x86-64) => /lib64/libzapojit-0.0.so.0
libz.so.1 (libc6,x86-64) => /lib64/libz.so.1
libz.so.1 (libc6) => /lib/libz.so.1
libyelp.so.0 (libc6,x86-64) => /lib64/libyelp.so.0
libyajl.so.2 (libc6,x86-64) => /lib64/libyajl.so.2
Opcionalmente, podemos editar o arquivo e colocar outros diretórios para o ldconfig

procurar as bibliotecas, e depois reexecutá-lo. Para verificar todas as bibliotecas
presentes em nossa máquina usamos ldconfig -p. Se apagarmos o arquivo /etc/
ld.so.cache, é só executar o comando ldconfig.
122
3.3.6. Variável LD_LIBRARY_PATH
Esta variável de ambiente é utilizada quando se deseja utilizar uma biblioteca diferente
para uma execução particular, por exemplo, quando uma biblioteca não padrão será
empregada para propósitos especiais e, também, no momento de depuração de uma
nova biblioteca.
Ela se apresenta como um conjunto de diretórios que estão separados por dois pontos
(neste caso, antes do conjunto padrão de diretórios, as bibliotecas serão procuradas
em primeiro lugar). Ela não opera em todos os sistemas do tipo UNIX, mas a maioria
dos sistemas trabalha com ela.
3.4. Gerenciador de pacotes .DEB

Os pacotes dos sistemas GNU/Linux podem ser administrados pelos gerenciadores
de pacote, responsáveis pela instalação, atualização e exclusão de programas em
uma distribuição específica.
Para os pacotes Debian, os gerenciadores mais usados são o dpkg, que instala pacotes
individuais, o apt-get e o aptitude, que localizam um pacote em repositórios remotos
e procedem com a instalação e resolução de suas dependências. Para a distribuição Red
Hat, os gerenciadores mais importantes são o yum e o rpm, semelhantes ao aptitude
e o dpkg respectivamente, mas usados somente para pacotes com a extensão .rpm.
Como os pacotes .deb trazem informações sobre as suas dependências, ou seja, as

bibliotecas e os outros programas que precisam ser instalados para que ele funcione,
o gerenciador de pacote verifica essas informações e encarrega-se de sanar todas
essas necessidades, agilizando bastante a instalação e administração de programas
no sistema.
3.4.1. Repositórios
Os gerenciadores apt-get e aptitude, que acabamos de mencionar, só podem
automatizar a administração das dependências dos pacotes, caso a origem desses
pacotes esteja especificada de forma correta nos arquivos chamados repositórios.
Os repositórios poderão ser indicados por meio do arquivo /etc/apt/sources.list.
Arquivos adicionais podem ir para o diretório /etc/apt/sources.list.d/.
123
A indicação de um repositório funcional e acessível é fundamental para o processo

de download e instalação do pacote desejado. Um repositório nada mais é do que
uma centralização de pacotes .deb disponíveis para download por meio do apt para
instalação em um cliente. Repositórios podem ser representados por diversos meios
e tipos, como:
•• Repositórios de Internet acessíveis por meio de protocolos como http e ftp;
•• Repositório local, disponibilizado por um servidor ou cliente da rede e acessível

também pelos protocolos http e ftp;
•• Repositórios representados por mídias específicas, podendo ser um CD, DVD,

ou até mesmo uma determinada partição de um HD.
É interessante saber também que as distribuições possuem repositórios próprios,

oficiais e não oficiais. Independentemente do tipo de repositório escolhido para obter
pacotes, é preciso fazer suas respectivas indicações de uso, além de ser permitido
utilizar vários tipos de repositório ao mesmo tempo.
É por meio do arquivo /etc/apt/sources.list que os repositórios poderão ser

configurados e indicados para uso. Cada linha desse arquivo referenciará um
repositório e o tipo de pacote que poderá ser instalado no sistema. Dentro dos
repositórios, existe uma divisão por sessões, indicando os tipos de pacotes acessíveis
para instalação.
Um arquivo sources.list pode ser acessado por meio de um arquivo modelo em /usr/
share/doc/apt/exemples/sources.list, inclusive com caminhos para repositórios
oficiais de Internet, que poderão ser utilizados para obter pacotes.
O arquivo sources.list terá a seguinte sintaxe para adicionar um repositório, indicando

um protocolo de acesso em um respectivo endereço:
<tipo_de_pacote> <protocolo_de_acesso://endereco> <versao_da_distro>

<secao_de_pacotes>
Vejamos um exemplo:
deb http://debian.usp.br stable main contrib non-free
Sobre os campos do arquivo sources.list, temos:
•• Tipo de pacote: Além dos pacotes com a extensão .deb trabalhados até o
momento, também é possível obter o código-fonte desses pacotes para que
possam ser instalados pelo processo de compilação (visto no início do capítulo).
O código-fonte dos pacotes poderá ser acessado, caso o campo tipo de pacote
seja identificado como deb-src. Se forem utilizados apenas os pacotes normais
com a extensão .deb, basta identificar o campo tipo de pacote como deb;
124
•• Protocolo de acesso: //Endereço: Neste campo, é indicado o protocolo de
acesso a um servidor de Internet ou local, podendo ser http ou ftp, com seu
respectivo endereço de acesso. Também é possível usar a indicação file para
especificar que o repositório é um diretório do sistema com imagens .iso dos
pacotes Debian;
•• Versão da distribuição: É necessário indicar a versão dos pacotes que serão

instalados, que está diretamente associada à versão de distribuição, atualmente
em uso. Se a distribuição for uma versão stable, os pacotes .deb que serão
instalados também deverão ser desta mesma versão, e assim por diante. Nesse
campo, podemos encontrar as versões stable, testing e unstable;
O codinome da distribuição também pode ser utilizado, em vez da versão.
•• Sessão de pacotes: Na sessão de uso dos pacotes que serão instalados, é criada
uma divisão para diferenciar os pacotes em relação às suas características de
licença. São elas:
•• main: Contém apenas pacotes de software livre;
•• contrib: Contém pacotes livres, porém, que dependem de algum software

proprietário;
•• non-free: Contém pacotes com código-fonte fechado.
Com os campos devidamente informados, é possível configurar um repositório, a

cada linha, no arquivo sources.list.
3.4.2. Atualizando a lista de repositórios

Os comandos apt-get update ou aptitude update são utilizados para atualizar a base
de informações locais sobre os repositórios remotos. Sem essa atualização, novas
versões de programas não serão encontradas, causando a perda de atualizações que
podem ser importantes. Isso pode ser facilmente evitado, já que é possível até mesmo
programar a execução periódica de um desses dois comandos.
125
3.4.3. Instalação de pacotes
Antes de instalarmos um programa, devemos procurar por ele. Para isso, utilizamos
o apt da seguinte forma:
apt-cache search <programa>
Também, podemos utilizar o aptitude para verificar a existência do programa a ser

instalado:
aptitude search <programa>
No tópico anterior, aprendemos sobre a utilização dos comandos apt-get update

e aptitude update. Caso nenhum resultado apareça na busca pelos programas
desejados, isso pode ter sido causado pelo fato de as bases de informações não
estarem atualizadas, logo o uso de um desses comandos é recomendado. É possível
também que o programa simplesmente não exista nos repositórios especificados em
/etc/apt/sources.list.
Verificada a existência do programa, podemos instalá-lo por meio da seguinte sintaxe:
apt-get install <programa1> <programa2> …
O processo será totalmente automatizado, além de o apt realizar o download

automático do pacote e suas respectivas dependências a partir dos repositórios
configurados, completando o processo com suas respectivas instalações. Algumas
opções poderão ser utilizadas em conjunto com a ação install.
É possível, também, instalar vários pacotes ao mesmo tempo, pois o apt gerenciará a
instalação de todos eles de forma tranquila. Porém, não é possível executar o comando
apt-get com qualquer ação em paralelo. Vejamos a tabela a seguir:
Opção
Opção GNU Descrição
Unix
Apenas faz o download, não instalando os pacotes e
-d --download-only
as possíveis dependências.
-f --fix-broken Tenta corrigir erros gerados na instalação de pacotes.
Apenas simula o processo de instalação do pacote
-s --simulate com suas respectivas dependências, não realizando
suas instalações.
--reinstall Reinstala um pacote, caso já esteja instalado.
--show-
-u Exibe uma lista dos pacotes que serão atualizados.
upgraded
-y -yes Assume a resposta Yes para todos os questionamentos.
126
O aptitude pode ser utilizado para instalar programas. Para isso, utiliza-se a seguinte
sintaxe:
aptitude install <programa>
Caso haja pendências, o administrador será consultado em relação à instalação

desses programas. As dependências não instaladas serão automaticamente copiadas
e instaladas.
Podemos instalar pacotes copiados separadamente, sem recorrer aos repositórios.

Para isso, é usado o programa dpkg, como mostra a seguinte sintaxe:
dpkg -i <programa>
3.4.4. Reconfigurando os pacotes
O comando dpkg-reconfigure é utilizado para reconfigurar pacotes que, em sua
instalação, apresentaram alguma interface de configuração básica ao pacote específico.
Essa interface é provida pelo debconf.
Com o dpkg-reconfigure, é possível acessar novamente tal interface, definindo novas

configurações para o aplicativo. A sintaxe desse comando é a seguinte:
dpkg-reconfigure [opcoes] <pacote>
A tabela a seguir descreve opções do dpkg-reconfigure:
Opção
Unix
Reconfigura todos os pacotes instalados no sistema,
-a -all que utilizam uma interface de configuração por meio
do debconf.
Sobre a reconfiguração que será iniciada no pacote
especificado, serão configuradas apenas questões
-u --unseen-only que ainda não foram alteradas em configurações
anteriores. Por padrão, todas as questões possíveis
são questionadas ao executar o dpkg-reconfigure.
Força a reconfiguração de um pacote, mesmo que esse
--force
esteja em um estado inconsistente ou corrompido.
127
3.4.5. Inspecionando o pacote
É possível também realizar tarefas de inspeção dos pacotes com a ajuda dos diversos
gerenciadores existentes. Veremos a seguir o que os gerenciadores mais usados
possibilitam em termos de inspeção.
•• Consultando com o dpkg
É possível utilizar o gerenciador dpkg para consultar pacotes. Vejamos a seguir os

principais parâmetros de consulta do dpkg.
•• Consultas em pacotes instalados no sistema
Opção Unix Opção GNU Descrição

Exibe uma lista de todos os pacotes
instalados no sistema, com uma
simples descrição, caso nenhum nome
-l <pacote(s)> --list <pacote(s)> de pacote seja especificado. Se algum
nome de pacote for indicado com a
opção -l, o resultado será apenas sobre
o pacote.
Exibe o status e as informações
-s <pacote(s)> --status <pacote(s)> detalhadas de um pacote instalado ou
removido do sistema.
Lista todos os arquivos relacionados a
-L <pacote(s)> --listfiles <pacote(s)>
um pacote instalado no sistema.
Localiza o pacote ao qual o arquivo
-S <arquivo(s)> ---search <arquivo(s)>
indicado pertence.
•• Consultas em pacotes .deb
Exibe as informações detalhadas de

um pacote .deb ainda não instalado
-I <pacote.deb> --info <pacote.deb>
no sistema, como dependências e
sua devida descrição.
Exibe todo o conteúdo de um pacote

--contents
-c <pacote .deb> .deb que será alocado no sistema
<pacote.deb>
após sua devida instalação.
128
•• Outros tipos de consultas

Exibe uma lista de pacotes com problemas
-C --audit
ocasionados em sua respectiva instalação.
Utilizada para exibir uma lista, caso nenhum
pacote seja indicado por programas
--get-selections
instalados ou removidos. Se um pacote for
[pacote(s)]
indicado, será informado apenas seu status
de instalação.
No exemplo a seguir, consultamos o pacote do ssh. Como resposta, obtivemos

informações relevantes como tamanho do pacote, versão, arquitetura, site do
desenvolvedor, entre outras. Para o funcionamento do comando, você precisará estar
no diretório /var/cache/apt/archive/.
# dpkg --info ssh_1%3a6.7p1-5+deb8u2_all.deb
novo pacote debian, versão 2.0.

119878 bytes de tamanho: arquivo de controle=961 bytes.
581 bytes, 15 linhas control
332 bytes, 5 linhas md5sums
197 bytes, 5 linhas * postinst #!/bin/sh
197 bytes, 5 linhas * postrm #!/bin/sh
197 bytes, 5 linhas * preinst #!/bin/sh
197 bytes, 5 linhas * prerm #!/bin/sh
Package: ssh
Source: openssh
Version: 1:6.7p1-5+deb8u2
Architecture: all
Maintainer: Debian OpenSSH Maintainers <debian-ssh@lists.debian.org>
Installed-Size: 160
Pre-Depends: dpkg (>= 1.17.5)
Depends: openssh-client (>= 1:6.7p1-5+deb8u2), openssh-server (>= 1:6.7p1-5+deb8u2)
Section: net
Priority: extra
Homepage: http://www.openssh.org/
Description: secure shell client and server (metapackage)
This metapackage is a convenient way to install both the OpenSSH client
and the OpenSSH server. It provides nothing in and of itself, so you
may remove it if nothing depends on it.
129
•• Consultando com o apt-cache
Outro modo de fazer consultas na lista de repositório por determinados pacotes e

suas respectivas descrições é utilizar o comando apt-cache.
•• Localizando um pacote no repositório
Com a ação search, o pacote especificado será procurado na lista de repositórios e,

caso seja encontrada alguma palavra relacionada ao pacote desejado, será exibido o
nome do pacote com uma simples descrição sobre ele. Para isso, utilizamos a seguinte
sintaxe:
apt-cache [opcoes] search <pacote>
O exemplo a seguir demonstra o uso do apt-cache com a ação search:
•• Obtendo detalhes de um pacote no repositório
apt-cache [opcoes] show [pacote]
Após localizar um pacote de nome específico, é possível obter suas informações de

forma detalhada. A ação show tem a finalidade de exibir uma descrição completa
sobre um pacote da lista de repositórios.
•• Consultando com o aptitude
Também podemos utilizar o aptitude search, abordado anteriormente, para consultar

pacotes. A seguir, temos um exemplo do seu uso:
# aptitude search ssh-server
i A openssh-server - servidor secure shell (SSH), para acesso seguro a

máquinas remotas
v ssh-server -
p task-ssh-server - servidor SSH
130
•• Verificando e corrigindo falhas do comando apt
Por um motivo qualquer, certas vezes, podem ocorrer falhas na execução de um

comando da família apt, principalmente na instalação ou atualização de pacotes, no
momento de seu download. Para resolver problemas relacionados, é possível executar
a ação check, que verifica arquivos corrompidos, fazendo uma correção automática
deles e atualizando a lista de repositório.
apt-get [opcoes] check
A imagem a seguir demonstra a execução do comando apt-get com a ação check:
# apt-get check
Lendo listas de pacotes... Pronto

Construindo árvore de dependências
Lendo informação de estado... Pronto
3.4.6. Atualizando pacotes
Para atualizar um programa que já esteja instalado, usa-se o comando apt-get
upgrade. Sua sintaxe é a seguinte:
apt-get [opcoes] upgrade <pacote>
A tabela a seguir descreve as principais opções que podemos utilizar com apt-get
upgrade:
Opção
Unix
-f --fix-broken Tenta corrigir erros gerados na atualização de pacotes.
-s --simulate Apenas simula o processo de atualização.
131
Também, é possível atualizar de uma só vez todos os pacotes que possuam alguma
versão mais recente nos repositórios especificados como origem. Para isso, utilizamos
o comando apt-get upgrade sem a especificação de um pacote. Existe também a
opção de utilizar, analogamente, o comando aptitude upgrade para atualização de
todos os pacotes, porém, nas versões mais recentes do programa, é recomendável
que se use o seguinte comando:
aptitude safe-upgrade
Como foi visto anteriormente, sem a utilização constante dos comandos apt-get
update ou aptitude update, os repositórios não são atualizados, de forma que a
atualização de um programa não poderá ser feita com os comandos que acabamos
de ver.
3.4.7. Excluindo pacotes
O apt também pode ser utilizado para remover pacotes instalados e seus respectivos
dependentes, caso existam, devido à ação remove. A remoção também é automatizada.
A ação remove também aceita certas opções para ajustar a execução de desinstalação,
como podemos perceber na sintaxe adiante:
apt-get [opcoes] remove <pacote1> <pacote2> ...
Também, é possível remover vários pacotes ao mesmo tempo com o comando apt-
get e a ação remove.
A tabela a seguir descreve opções que podem ser utilizadas com o apt-get e a ação
remove:
Opção
Unix
Remove os pacotes de forma completa, removendo,

--purge
também, seus respectivos arquivos de configuração.
Apenas simula o processo de remoção do pacote, com

-s --simulate
suas respectivas dependências.
132
O exemplo seguinte demonstra o uso de apt-get com a opção –y e a ação remove:
# apt-get -y remove vim
Lendo listas de pacotes... Pronto

Construindo árvore de dependências
Lendo informação de estado... Pronto
Os pacotes a seguir serão REMOVIDOS:
vim
0 pacotes atualizados, 0 pacotes novos instalados, 1 a serem removidos e
78 não atualizados.
Depois desta operação, 2.287 kB de espaço em disco serão liberados.
(Lendo banco de dados ... 82559 ficheiros e directórios actualmente
instalados.)
A remover vim (2:7.4.488-7) ...
update-alternatives: a usar /usr/bin/vim.tiny para disponibilizar /usr/
bin/vi (vi) em modo auto
bin/view (view) em modo auto
bin/ex (ex) em modo auto
bin/rview (rview) em modo auto
133
Também podemos remover um pacote por meio do aptitude, utilizando a seguinte

sintaxe:
aptitude remove <pacote>
A remoção de pacotes instalados também pode ser feita pelo dpkg, com as seguintes
opções:

Remove um pacote previamente instalado
--remove no sistema. É importante ressaltar que, para
-r <pacote(s)>
<pacote(s)> remover os pacotes instalados, basta fazer
referência simplesmente pelo nome do pacote.
Ignora uma ou várias dependências obrigatórias
--ignore- na remoção de um pacote. Deve-se redobrar
depends= a atenção ao utilizar essa opção, pois,
<pacote1, provavelmente, a dependência obrigatória
pacote2 ...> ignorada será de extrema importância para o
funcionamento correto do programa.
Também é utilizada para remover pacotes, porém
--purge faz uma remoção completa, apagando, também,
-P <pacote(s)>
<pacote(s)> os arquivos de configuração do pacote, ação que
não é feita, por padrão, com a opção –r.
O exemplo a seguir demonstra o uso do comando dpkg com a opção –r para excluir
o pacote linx:
# dpkg -r vim
O comando apt-get –f install também é muito utilizado para correção de problemas

de pacotes quebrados.
134
3.5. Gerenciador de pacotes .RPM
O rpm (Red Hat Package Manager) é o gerenciador de pacotes em distribuições de
base Red Hat e possui a mesma função do comando dpkg, anteriormente apresentado.
Entretanto, o rpm gerenciará apenas pacotes com a extensão .rpm.
Praticidade e simplicidade para instalar e gerenciar pacotes pré-compilados no formato

rpm são as principais características desse gerenciador.
Um pacote .rpm é como um arquivo empacotado, que armazenará, além do programa

pré-compilado, scripts de instalação e remoção do programa no sistema e outras
informações relacionadas.
O rpm terá funcionalidades básicas de gerenciamento de pacotes, como instalação,

remoção, atualização, consultas e verificação. Sua sintaxe é a seguinte:
rpm [opcoes] <pacote(s)>
3.5.1. Arquivos de informações do RPM

A estrutura de controle do rpm é mantida por um banco de dados específico, no
formato Berkeley BD (BDB). Esse banco de dados fica alocado no diretório /var/
lib/rpm e é utilizado de forma direta pelo próprio gerenciador de pacotes rpm na
instalação, controle e gerenciamento completo de seus pacotes.
O arquivo principal de configuração do rpm está alocado em /usr/lib/rpm/rpmrc e

armazena informações como a arquitetura do sistema e caminhos de macros utilizadas
no gerenciamento dos pacotes.
3.5.2. Dependências
As dependências também deverão ser respeitadas na hora de gerenciar pacotes
rpm. Como no método de instalação de programas a partir do código-fonte, em que
a verificação das dependências obrigatórias é um passo essencial à instalação do
programa, com o rpm não será diferente. As dependências devem ser atendidas não
apenas na instalação de um pacote, mas também no momento de sua remoção. Um
pacote que é uma dependência obrigatória de outro pacote no sistema não pode ser
removido.
135
3.5.3. Instalando pacotes com o rpm

A instalação de pacotes com o gerenciador de pacotes rpm é relativamente simples.
Algumas opções poderão ser utilizadas para auxiliar o processo. Observemos, então,
a tabela a seguir:

-i --install
Instala um ou vários pacotes com a extensão
<pacote(s) <pacote(s)
.rpm no sistema.
.rpm> .rpm>
Exibe o caractere # como barra de progresso

-h --hash
para o processo de instalação do pacote.
-v --verbose Exibe o processo da instalação em modo visual.
Utilizado para forçar a instalação de um pacote,

--nodeps
mesmo com a ausência de dependências.
Apenas testa o processo de instalação, fazendo

--test
uma simulação.
Opção utilizada para forçar a reinstalação de
--force
pacotes.
Exibe os requisitos para instalação do pacote
--requires em questão. Deve ser usado como subopção da
opção -q.
Exibe uma lista com os programas que
--whatrequires dependem desse pacote. Deve ser usado como
subopção da opção -q.
136
3.5.4. Excluindo pacotes com o rpm
O gerenciador de pacotes rpm removerá qualquer pacote .rpm instalado no sistema,
mas precisamos atentar à relação de dependências que os pacotes possuem. Vejamos
a tabela adiante:

Remove um ou vários pacotes com a extensão
--erase .rpm. Para que ocorra a remoção dos pacotes
-e <pacote(s)>
<pacote(s)> instalados, basta fazer referência simplesmente
pelo nome do pacote.
Remove um pacote, mesmo se ele for uma
--nodeps
dependência de outro pacote instalado.
Apenas testa o processo de remoção, fazendo
--test
uma simulação.
3.5.5. Atualizando pacotes com o rpm

O rpm disponibiliza uma opção para atualizar pacotes, instalando pacotes de nova
versão no sistema. Vejamos a tabela adiante:

Atualiza um pacote previamente instalado no
sistema. Caso o pacote não tenha sido instalado,
--upgrade
-U <pacote(s) o rpm realiza esse processo automaticamente.
<pacote(s)
.rpm> Sobre o pacote atualizado, as configurações da
.rpm>
versão antiga são salvas para não gerar perdas
importantes de configurações.
Permite atualizar um pacote para uma versão
--oldpackage
anterior à versão atual. Realiza um downgrade.
Utilizada para forçar a atualização de um pacote,
--nodeps mesmo se houver algum questionamento sobre
uma dependência.
137
3.5.6. Consultando pacotes com o rpm

O rpm também disponibiliza várias opções para realizar consultas de pacotes
instalados ou não no sistema. A tabela adiante ilustra a opção principal:
Opção
Unix
Verifica se o pacote especificado está instalado
ou não no sistema. É a principal opção de busca
-q [pacote] --query [pacote] do rpm, que poderá ser utilizada em conjunto
com outras opções para trazer mais informações
detalhadas sobre os pacotes.
Algumas opções extras poderão ser utilizadas com a opção –q apresentada

anteriormente, para definir o local e o tipo de busca efetuado, conforme esboça a
tabela a seguir:
Opção
Unix
-a --all Lista todos os pacotes instalados no sistema.
-f --file Realiza a busca pelo pacote que possui o arquivo
<arquivo> <arquivo> indicado.
A busca será feita em um pacote .rpm ainda não

--package
p<pacote. instalado. Essa opção é, geralmente, usada para
<pacote.
rpm> obter informações de um pacote .rpm, como
rpm>
descrição, arquivos presentes no pacote etc.
138
Há ainda outras opções que serão utilizadas para exibir uma busca sobre um
determinado pacote, com informações mais detalhadas. A tabela adiante ilustra essas
opções:
Opção
Unix
Exibe informações detalhadas de um pacote, como
i --info nome, descrição, revisão, data de criação e instalação,
tamanho e outras informações.
Exibe a lista de arquivos relacionados ao pacote

l --list
específico.
Exibe uma lista com os arquivos de documentação

d --docfiles relacionados a um pacote, como README, páginas de
manual, exemplos de uso etc.
Exibe uma lista de arquivos de configuração
-c --configfiles
relacionados ao pacote indicado.
Além do recurso de consultas disponibilizado pelo rpm, também é possível executar

verificações sobre a integridade geral dos pacotes. O rpm tem como base, para
comparação e verificação de um pacote, as informações presentes em seu banco
de dados. Com isso, o rpm poderá indicar problemas, certas vezes imperceptíveis,
como arquivos alterados, permissões fora do padrão ou arquivos corrompidos. Para
a verificação da integridade geral de pacotes, utiliza-se a opção –V <pacote> (opção
Unix) ou --verify (opção GNU).
A opção –V poderá ser utilizada juntamente com as opções de consultas, como a, f e p.
Dessa forma, é possível verificar um único pacote previamente instalado no sistema,

ou todos os pacotes instalados. Também é possível verificar um pacote .rpm ainda
não instalado, ou apenas um arquivo de configuração de um pacote qualquer.
139
O resultado da verificação exibido pela opção –V poderá ser bem detalhado.

Primeiramente, se nenhuma informação for exibida na verificação, o pacote está
íntegro, porém, em uma verificação, alguns caracteres poderão ser exibidos para
identificar o problema encontrado. Esses caracteres e suas respectivas descrições são
descritos na tabela a seguir:
Atributo Descrição
S O tamanho do arquivo é diferente do original.
M As permissões do arquivo foram alteradas.
5 A soma md5sum é diferente da original.
D Número Major/Minor do dispositivo não coincide com o original.
L Link simbólico quebrado ou inválido.

U Usuário dono é diferente do original.
G O grupo é diferente do original.
T A hora de modificação é diferente da original.
Essa sequência de oito caracteres é a verificação executada. Caso um ponto (.) apareça
no lugar do atributo, significa que não há problemas. Caso uma interrogação (?) seja
exibida, significa que o teste não pôde ser efetuado.
Veja o exemplo de verificação de pacote a seguir:
# rpm –V samba-common
SM5..... c /etc/samba/smb.conf
No exemplo anterior, após a verificação do pacote samba-common, foram identificadas

alterações em seu respectivo arquivo de configuração, em que os atributos S, M e
5 foram exibidos, identificando que o arquivo sofreu alterações em seu tamanho
original, em suas permissões e no valor md5sum.
Uma letra pode ser exibida após os atributos, para identificar o tipo
do arquivo em que c representa um arquivo de configuração, d um
arquivo relacionado à documentação do pacote, e nenhum caractere
é atribuído a outros tipos de arquivos relacionados ao programa.
140
3.5.7. Listar o conteúdo de um pacote rpm
O comando rpm2cpio tem a função de listar o conteúdo de um pacote .rpm, exibindo
a saída no formato cpio. Esse comando aceita a utilização de caracteres curinga,
como o asterisco. A seguir, temos um exemplo do uso de rpm2cpio:
# rpm2cpio <pacote>.rpm | cpio -t
Com a adição da opção -i, é possível fazer a extração de um arquivo específico

encontrado dentro de um pacote. A opção -v mostra o progresso da operação.
No exemplo a seguir, extraímos o arquivo zypper.conf localizado dentro do pacote

de instalação do zypper. O arquivo é baixado na exata estrutura mostrada no pacote.
Podemos notar que a pasta /etc/zypp foi criada e o arquivo zypper.conf foi extraído
dentro dela.
3.5.8. Gerenciador de pacotes YUM

Bastante parecido com os gerenciados apt-get e aptitude, o yum é usado nas
distribuições Red Hat. Traz como vantagem bem conveniente a possibilidade
de instalação de um pacote a partir da Internet e, como os outros gerenciadores,
promove a resolução automática das dependências desse programa. Seu arquivo de
configuração é o /var/cache/yum.
Os repositórios verificados pelo yum possuem a extensão .repo e devem constar na

lista de diretórios encontradas na opção reposdir do arquivo de configuração.
141
A tabela a seguir mostra os principais comandos utilizados com o yum:
Comando Definição
search [pacote] Faz uma busca por um pacote determinado.
install [pacote] Instala o pacote determinado.
remove [pacote] Exclui o pacote determinado.
Exibe qual pacote fornece o recurso ou arquivo
determinado, independente desse pacote estar instalado
provides [recurso]
ou não. É uma alternativa para o comando yum
whatprovides [recurso].
Se usado com argumento, atualiza o pacote determinado.
Sem argumentos, atualiza todos os pacotes disponíveis.
update
Com o subcomando --obsoletes, faz ainda a verificação
dos pacotes obsoletos durante a atualização.
Executa a função do yum update, mas também traz a

upgrade
opção de atualizar a versão da distribuição.
O comando yumdownloader simplesmente baixa um pacote sem instalá-lo. Com

a opção --source, ele ainda copia o código-fonte do pacote no lugar do programa
compilado.
142
Pontos principais
•• O particionamento é um processo muito delicado, que deverá ser feito com

total controle e atenção para minimizar futuros problemas. Para planejar o
particionamento do disco rígido, deve-se conhecer bem o FHS (Filesystem
Hierarchy Standard), que especifica os diretórios obrigatórios, além de
diretórios opcionais ou recomendados;
•• O gerenciador de boot é um programa cuja função é acessar o disco do

computador e carregar o sistema operacional na memória para assumir o
controle do equipamento;
•• Bibliotecas podem ser definidas como arquivos que contêm um conjunto de

módulos ou membros de códigos pré-compilados reutilizáveis;
•• Para os pacotes Debian, os gerenciadores mais usados são o dpkg, que

instala pacotes individuais, o apt-get e o aptitude, que localizam um pacote
em repositórios remotos e procedem com a instalação e resolução de suas
dependências. Para a distribuição Red Hat, os gerenciadores mais importantes
são o yum e o rpm, semelhantes ao aptitude e o dpkg respectivamente, mas
usados somente para pacotes com a extensão .rpm.
Sites Endereços
Gerenciamento de https://access.redhat.com/documentation/en-US/Red_Hat_
pacotes Red Hat Enterprise_Linux/5/html/Deployment_Guide/ch-rpm.html
Gerenciamento de https://www.debian.org/doc/manuals/debian-reference/
pacotes Debian ch02.en.html
Bibliotecas http://www.tldp.org/HOWTO/Program-Library-HOWTO/
compartilhadas shared-libraries.html
143
144
Instalação
3 do Linux e
gerenciamento
de pacotes
1. Qual linha do comando rpm a seguir é utilizada para exibir a lista de

pacotes instalados?
☐☐ a) rpm -pq
☐☐ b) rpm -qp
☐☐ c) rpm -qa
☐☐ d) rpm –list-package
☐☐ e) rpm -inst-package
2. Qual o nome do arquivo de configuração das fontes de pesquisa do apt?
☐☐ a) /etc/apt.conf
☐☐ b) /etc/sources.list
☐☐ c) /var/cache/apt/sources.list
☐☐ d) /var/cache/apt/apt.conf
☐☐ e) /etc/apt/sources.list
3. Qual comando é utilizado para remover o pacote emacs juntamente com

todos os seus arquivos de configuração?
☐☐ a) dpkg -r emacs
☐☐ b) dpkg -P emacs
☐☐ c) dpkg –delete emacs
☐☐ d) dpkg -lr emacs
☐☐ e) dpkg -p emacs
4. Qual comando é utilizado para instalar um pacote via fontes externas

em um servidor Red Hat?
☐☐ a) rpm –install <pacote>

☐☐ b) apt-get install <pacote>
☐☐ c) yum install <pacote>
☐☐ d) yum -ivh <pacote>
☐☐ e) rpm -ivh <pacote>
5. Qual comando é utilizado para verificar detalhes de pacotes instalados

no Red Hat?
☐☐ a) rpm -q <pacote>
☐☐ b) dpkg -q <pacote>
☐☐ c) rpm -info <pacote>
☐☐ d) yum –info <pacote>
☐☐ e) rpm -ivh <pacote>
146
6. Depois de atualizar a lista do arquivo de repositórios remotos do Debian,
qual comando deveria ser rodado?
☐☐ a) dpkg update
☐☐ b) apt-cache fetch
☐☐ c) apt-cache update
☐☐ d) apt-get update
7. Qual dos comandos a seguir mostra o histórico de revisão de uma

aplicação de software, extraindo a informação do arquivo do pacote
contido no disco?
☐☐ a) rpm --revision tree-1.2-7.i386.rpm

☐☐ b) rpm -qp tree-1.2-7.i386.rpm --changelog
☐☐ c) rpm -qc tree-1.2-7.i386.rpm
☐☐ d) rpm -qlp tree-1.2-7.i386.rpm –showrev
8. Qual é o propósito de utilizarmos o programa ldd?
☐☐ a) Recriar os links dos arquivos das bibliotecas.

☐☐ b) Cria um link para um arquivo da biblioteca.
☐☐ c) Exibir as bibliotecas requeridas para o programa.
☐☐ d) Ler as capacidades das bibliotecas de um programa.
9. O link dinâmico é chamado ________ e é configurado no ________.

Qual alternativa preenche corretamente as lacunas?
☐☐ a) ld.so, /etc/ld.so.conf
☐☐ b) so.linux, /etc/ld.so.conf
☐☐ c) ld.so, /etc/so.linux.conf
☐☐ d) so.linux, /etc/so.linux.conf
10. Como você instalaria um pacote chamado foo-1.2.3.deb?
☐☐ a) dpkg --il foo-1.2.3.deb

☐☐ b) rpm -i foo-1.2.3.deb
☐☐ c) dpkg --install foo-1.2.3.deb
147
11. Qual variável de ambiente é utilizada para prover suporte adicional às

bibliotecas e também é considerada um risco à segurança?
☐☐ a) LIBC_EXTRA
☐☐ b) LD_SO_ETC
☐☐ c) LD_LIBRARY
☐☐ d) LD_LIBRARY_PATH
12. Quais diretórios precisam constar na mesma partição?
☐☐ a) /etc, /bin, /sbin, /lib e /dev.

☐☐ b) /usr, /bin, /sbin, /lib e /dev.
☐☐ c) /src, /bin, /sbin, /lib e /dev.
☐☐ d) /etc, /bin, /sbin1, /lib e /dev.
13. O arquivo de configuração grub.cfg pertence a qual Gerenciador de

Boot?
☐☐ a) Upstart
☐☐ b) SystemVinit
☐☐ c) GRUB2
☐☐ d) GRUB
☐☐ e) System D
14. Qual a função do comando grub2-mkconfig?
☐☐ a) Gerar o arquivo grub.cfg.

☐☐ b) Apagar o arquivo grub.cfg.
☐☐ c) Atualizar os arquivos contidos no diretório /etc/default/grub/.
☐☐ d) Atualizar os arquivos contidos no diretório /etc/grub.d/.
☐☐ e) Atualizar o arquivo 00_header.
15. Qual a função do parâmetro GRUB_TIMEOUT do gerenciador de boot

GRUB2?
☐☐ a) Esse parâmetro não existe.

☐☐ b) Definir o tempo de reinicialização da opção padrão do menu.
☐☐ c) Definir o tempo de inicialização da opção padrão do menu.
☐☐ d) Definir o tempo de inicialização da opção padrão.
☐☐ e) Definir o tempo de reinicialização da opção padrão.
148
Instalação
3 do Linux e
gerenciamento
de pacotes
Mãos à obra!
Laboratório 1 - Gerenciamento de pacotes

no Debian
1. Atualize as fontes de pacote:
# apt-get update
2. Atualize a base com o comando aptitude:
# aptitude update
3. Instale o programa lynx para navegação em modo texto:
# apt-get install lynx
4. Instale o programa dnsutils para administração da rede:
# aptitude install dnsutils
5. Instale o programa emacs no computador:
# dpkg -i /root/pacotes/emacs_22.2+2-5_all.deb
6. Remova o pacote lynx:
# apt-get remove lynx
7. Por fim, remova o emacs:
# dpkg -r emacs
8. Procure por pacotes do samba:
# apt-cache search samba*
9. Procure por pacotes do bind:
# aptitude search bind9*
10. Verifique o status de pacotes do vim instalados no computador:
# dpkg -l vim
150
11. Atualize o computador com o comando apt-get:
# apt-get update
12. Atualize o computador com o comando aptitude:
# aptitude update
13. Atualize a distribuição em uso:
# apt-get dist-upgrade
Laboratório 2 - Gerenciamento de pacotes

no CentOS
1. Atualize as fontes de pacote com o yum:
# yum update
2. Remova o gerenciador de pacotes yum:
# yum remove vim
# rpm –e yum-plugin-fastestmirror yum
3. Remova o pacote net-tools:
# yum remove net-tools
4. Instale o gerenciador de pacotes yum por meio do CD de instalação:
# mount –t iso9660 /dev/sr0 /media/
# cd /media/Packages
# rpm –ivh yum-plugin-fastestmirror-1.1.31-34.el7.noarch.rpm
151
5. Instale no computador o pacote net-tools para administração da rede:
# yum install net-tools
6. Procure por pacotes do samba:
# yum search samba
7. Procure por pacotes do bind:
# yum search bind9
8. Verifique o status de pacotes do vim instalados no computador:
# rpm -qi vim
9. Atualize o computador com o comando yum:
# yum update
Laboratório 3 - Gerenciador de boot - CentOS

1. Reinicie o sistema e, ao ser apresentado o menu do GRUB2, digite a tecla E para
visualizar a opção de inicialização. Acione a sequência de teclas CTRL + X para iniciar
o sistema normalmente.
2. Adicione uma senha no GRUB2. Essa senha será solicitada todas as vezes que você
precisar editar o menu de inicialização do GRUB2, conforme realizado no exercício
anterior.
# grub2-setpasswd
Atenção: Caso você se esqueça da senha do GRUB2, seu sistema não será
mais iniciado, e uma manutenção mais avançada deverá ser realizada.
152
3. Altere o tempo de exibição do menu do GRUB2 para 10 segundos:
# sed -i “s/GRUB_TIMEOUT=5/GRUB_TIMEOUT=10/g” /etc/default/grub
# grub2-mkconfig
# reboot
Reinicie o sistema e, no menu do GRUB2, edite-o. Informe o nome root e a senha

cadastrada.
Laboratório 4 - Instalando o programa de

gerenciamento remoto via Web no CentOS
1. Instale o programa webmin, via comando rpm;
2. Acesse o site oficial do programa e siga as instruções de instalação;
3. Adicione a porta 10000 no firewalld para o acesso externo via navegador:
firewalld-cmd –-zone=public –-add-port=10000/tcp
4. No final da implantação, abra o navegador do Windows e acesse o programa, por

meio do endereço IP do servidor. Use o usuário root com a sua respectiva senha para
o acesso.
Laboratório 5 - Instalando o programa de

gerenciamento remoto via Web no Debian
1. Instale o programa webmin, via comando dpkg;
2. Acesse o site oficial do programa e siga as instruções de instalação;
3. No final da implantação, abra o navegador do Windows e acesse o programa, por

meio do endereço IP do servidor. Use o usuário root com a sua respectiva senha para
o acesso.
153
Vejamos a tela de login do Webmin:
Adiante, a tela de administração do servidor:
154
4 Comandos
GNU e Unix
ÃÃ Principais comandos de operação;

ÃÃ Gerenciamento de processos no sistema;
ÃÃ Editor de texto VIM.
Este capítulo faz parte do tópico 103 – GNU and Unix Commands, da primeira
Você precisará estar apto a executar os principais comandos de operação,

utilizando o shell bash.
Para a prova de certificação, 26 questões serão aplicadas entre perguntas

alternativas, dissertativas ou múltipla escolha.
Para o mercado de trabalho, você precisará estar confortável para operar o

sistema, por meio dos principais comandos de operação. Saber utilizar o editor de
texto vim e também controlar os processos do sistema são atividades básicas de
administrador.
4.1. Principais comandos de operação

Como foi visto, o shell é o responsável por fazer a mediação entre o usuário e o
computador, interpretando os comandos enviados. Esses comandos nada mais são
do que instruções que o usuário manda pelo shell para a execução de alguma tarefa.
Os sistemas GNU/Linux contam com uma grande variedade de comandos disponíveis

para sua administração, que possibilitam a execução de diversas operações e ainda
podem ser colocados e documentados em scripts. Neste capítulo, abordaremos os
principais comandos GNU/Linux, organizados aqui em categorias, a fim de facilitar o
entendimento e aprendizado.
Por meio do comando man <comando> (em que <comando> é o nome do comando
desejado), é possível obter informações a respeito de qualquer comando GNU/Linux.
4.1.1. Conhecendo o ambiente do shell

Conhecer o ambiente do shell e sua estrutura é fundamental para a operação do
sistema, mediante os comandos que aprenderemos a seguir. Ao acessar o sistema
por meio de uma conta de usuário e sua respectiva senha, o shell se encarrega de
executar uma série de variáveis, que são responsáveis pelo controle dos comandos
executados, por exemplo.
O comando bash, abre outra sessão, utilizando o mesmo terminal:
bash
156
Comandos GNU e Unix 4
As variáveis podem ser lidas por meio do comando echo, seguido do caractere $ e do
nome da variável:
echo $PWD
As variáveis carregadas podem ser visualizadas por meio do comando env, que
exibirá as variáveis de ambiente, e do comando set, que exibirá tanto as variáveis
locais quanto as variáveis globais:
set
env
Uma variável local poderá ser transformada em global. Para isso, utilize o comando
export:
export VARIAVEL
Para excluir uma variável, basta executar o comando unset:
unset VARIAVEL
Mais detalhes a respeito do ambiente shell bash serão tratados em capítulo posterior
sobre shell script e gerenciamento de dados.
4.1.2. Listando arquivos e diretórios

O comando ls lista o conteúdo ou informações detalhadas de diretórios e arquivos.
ls [opcoes] [arquivo(s)/diretorio(s)]
Se o usuário não especificar um diretório na sintaxe do comando, será mostrado o

conteúdo do diretório em que ele estiver no momento.
Esse comando possui muitos parâmetros. A tabela a seguir descreve os principais

deles:
Opção
Unix
Exibe todo o conteúdo de diretórios, incluindo
-a --all arquivos e diretórios ocultos, que iniciam com .
(ponto) em seu nome.
157
Opção
Unix
Ativa o recurso de cores para os tipos de arquivos
com os parâmetros always (sempre usa cores na
saída do comando ls), auto (usa cores apenas se a
saída do comando ls for um terminal), never (não
usa cores, é padrão).
Cores:
•• Azul: Diretório;
•• Branco: Arquivo comum, texto, sem permissões

--color=[opção] de execução;
opção: auto •• Verde: Arquivo com permissões de execução;

always
never •• Azul claro: Link simbólico;
•• Amarelo: Arquivo especial orientado a

comunicação, bloco ou caractere;
•• Marrom: Arquivo especial do tipo FIFO;
•• Rosa: Arquivo especial do tipo socket;
•• Vermelho: Arquivo compactado, empacotado

ou link quebrado.
Opção que é útil quando combinada com a opção

-l. Exibirá as informações detalhadas do diretório
-d --directory corrente ou indicado, e não dos arquivos presentes
dentro dele.
Adiciona ao final dos arquivos um sufixo que faz

-F --classify referência ao seu respectivo tipo.
Opção útil quando combinada com a opção -l, exibe

--human- o tamanho de arquivos em formato legível por
-h
readable humanos (human-readable).
Exibe o número de identificação que cada arquivo

-i --inode
tem (inode).
Exibe as informações detalhadas dos arquivos do

-l --format=long diretório corrente ou do diretório indicado, conforme
será visto em detalhe no próximo tópico.
158
Opção
Unix
Semelhante à opção -l, porém, exibe a identificação
dos donos (UID – UserIdentification) e grupos (GID
-n --numeric-giduid
– GroupIdentification) dos arquivos e diretórios em
vez de seus respectivos nomes.
Lista o conteúdo de diretórios e seus respectivos
-R --recursive
subdiretórios em modo recursivo.
-r --reverse Inverte a ordem de classificação.
-S --sort=size Classifica a listagem pelo tamanho dos arquivos.

Classifica a listagem pelo tempo de modificação ou
-t --sort=time
acesso.
-x --sort=extension Classifica a listagem pela extensão dos arquivos.
4.1.3. Obtendo uma lista detalhada

O parâmetro –l, visto na tabela anterior, é bastante usado e tem como função listar
detalhadamente os arquivos do diretório atual ou do diretório indicado. Em seu
resultado, o usuário obtém informações sobre os tipos de arquivos, as permissões, o
número de links para outros arquivos, os donos, os grupos, o tamanho dos arquivos,
seus nomes e rótulos de tempo, como podemos ver na imagem a seguir:
159
Por padrão, o rótulo de tempo que é exibido é sobre a última modificação. Para poder
visualizar o rótulo de tempo sobre acesso, usa-se a opção –u em conjunto com a
opção -l.
Quando o comando ls –l é executado, a saída que ele traz mostra caracteres específicos
no começo da cada linha. O primeiro caractere indica o tipo dos arquivos listados,
conforme o seguinte esquema:
•• - : Para um arquivo comum;
•• d: Para um diretório;
•• b: Para arquivo especial orientado à comunicação em bloco;
•• c: Para arquivo especial orientado à comunicação a caractere;
•• l: Para ligação (link) simbólica;
•• p: Para um arquivo FIFO;
•• s: Para um arquivo socket.
4.1.4. Listando todos os arquivos

Se o usuário precisar que o comando ls liste todos os arquivos existentes em um
determinado diretório, deve usar o parâmetro –a. Com ele, até os arquivos ocultos
são exibidos e podem ser identificados por um ponto (.) no começo de seu nome.
Vejamos:
4.1.5. Listando recursivamente
Ao utilizar o comando l com o parâmetro -R, podemos listar arquivos e mostrar
também os subdiretórios contidos no diretório especificado, ou seja, podemos listar
arquivos recursivamente, como mostra o seguinte exemplo:
160
4.1.6. Criando arquivos e diretórios
Simplesmente abrir um editor de texto e salvar o documento é suficiente para criar
um arquivo novo em sistemas GNU/Linux, porém existem outras maneiras para isso,
como será mostrado adiante.
4.1.7. touch
O comando touch gera um arquivo com zero byte de tamanho. Sua sintaxe é a
seguinte:
touch [opcoes] <arquivo>
O comando touch tem várias funcionalidades, como poder alterar a data e/ou hora
(timestamp) de acesso ou modificação de um arquivo de qualquer tipo.
Em [opcoes], podemos utilizar os parâmetros descritos na tabela a seguir:
Opção
Unix
-a --time=atime Altera a data de acesso de um arquivo.
-c --no-create Não cria arquivos caso eles não existam.
-m --time=mtime Altera a data de modificação de um arquivo.
Especifica o formato de data e hora para alteração,
com as opções -m ou –a. O formato passado junto
com a opção –t é [[CC]YY]MMDDhhmm[.SS], sendo:
•• CCYY: Ano no intervalo de 1969-2068;
•• MM: Define o mês;

-t
•• DD: Define o dia;
•• hh: Define a hora;
•• mm: Define o minuto;
•• .SS: Define o segundo.
161
4.1.8. mkdir
Para criarmos um diretório no sistema, podemos utilizar o comando mkdir. Sua
sintaxe é a seguinte:
mkdir [opcoes] <diretorio>
Em [opcoes], podemos utilizar os parâmetros descritos na tabela a seguir:

Cria uma estrutura de diretórios com o diretório
-p --parents
pai, filho etc.
Imprime, em modo visual, os diretórios sendo
-v --verbose
criados.
A linha a seguir cria o diretório impacta:
mkdir impacta
Na criação de subdiretórios, o diretório pai deve já existir. Vejamos a seguinte linha:
/home/arquivos/aulas/linux/aluno/lucas
A criação de uma estrutura como a que acabamos de exibir pede que utilizemos o
comando mkdir cinco vezes. Vejamos a sequência de comandos para criá-la:
mkdir /home/arquivos
mkdir /home/arquivos/aulas
mkdir /home/arquivos/aulas/linux
mkdir /home/arquivos/aulas/linux/aluno
mkdir /home/arquivos/aulas/linux/aluno/lucas
No entanto, há uma maneira mais simples de criar estruturas como essa. Para isso,
podemos utilizar mkdir junto com o parâmetro –p. A linha a seguir cria a estrutura
anterior com uma única execução do comando mkdir:
mkdir -p /home/arquivos/aulas/linux/aluno/lucas
4.1.9. Excluindo arquivos e diretórios

Vejamos, a seguir, como utilizar os comandos rm e rmdir para excluir arquivos e
diretórios do sistema.
162
4.1.10. rm
O comando rm é utilizado para excluir arquivos e diretórios, independentemente de
estarem vazios. Sua sintaxe é a seguinte:
rm [opcoes] <origem>
Em [opcoes], podemos utilizar uma das opções descritas na tabela adiante:

-i --interactive Questiona se a origem pode ser removida.
Remove arquivos ou diretórios sem
-f --force questionamento e suprimindo qualquer tipo de
mensagem de erro.
Utilizada para remover diretórios em modo
-r, -R --recursive
recursivo.
Remove arquivos e diretórios em modo visual,
-v --verbose exibindo seus respectivos nomes no momento
da remoção.
O exemplo a seguir exclui o arquivo impacta.txt:
rm impacta.txt
No uso de rm, há uma forma de que uma mensagem de confirmação seja exibida
antes da exclusão ocorrer. Para isso, utilizamos o parâmetro –i. No exemplo a seguir,
excluímos impacta.txt, mas antes precisamos confirmar a ação (y):
rm -i impacta.txt
rm: remove arquivo comum "impacta.txt" y
Para a remoção de um diretório e todo o seu conteúdo, utilizamos rm com o parâmetro

–r. O exemplo a seguir exclui o diretório arquivos e todo seu conteúdo:
rm –r arquivos
Arquivos e diretórios excluídos com o comando rm não podem ser recuperados.
163
4.1.11. rmdir
O comando rmdir remove diretórios vazios, que não contenham arquivos. Também
remove diretórios que contêm outros subdiretórios, mas apenas se estes também
estiverem sem arquivos. Sua sintaxe é a seguinte:
rmdir [opcoes] <origem>
O rmdir pode ser utilizado com a opção -p, que remove a árvore de diretórios indicada
apenas se não existir qualquer arquivo presente na estrutura que será removida.
A linha a seguir exclui o diretório aulas:
rmdir aulas
Já a linha a seguir exclui tanto o diretório aulas quanto o subdiretório linux:
rmdir -p aulas/linux
4.1.12. Copiando arquivos e diretórios

O comando cp copia arquivos ou, opcionalmente, diretórios, de determinada origem
para um determinado destino. Sua sintaxe é a seguinte:
cp [opcoes] <origem> <destino>
No caso de diretórios, utilizamos o parâmetro –R junto com o comando.
Em [opcoes], podemos utilizar uma das opções descritas na tabela a seguir:

Preserva todos os atributos possíveis para o
-a --archive arquivo copiado (dono, grupo, rótulos de tempo
etc.).
-i --interactive Questiona se a origem pode ser sobrescrita.
Sobrescreve o destino sem questionar, ou
-f --force
pedindo confirmações.
Faz uma cópia em modo recursivo, ideal para
-R ou -r --recursive
cópia de diretórios.
Faz cópias em modo visual, exibindo o nome de
-v --verbose
cada arquivo no momento da cópia.
164
Vejamos as telas de exemplo a seguir:
No primeiro exemplo (primeira linha), temos a cópia do arquivo /etc/services sendo

colada no diretório dir-pai com o nome de services.
No segundo uso do cp, temos uma cópia de todos os arquivos – onde é utilizado o
caractere curinga asterisco (*), o qual explicaremos posteriormente neste capítulo –
do diretório /etc/cron.daily indicando o destino em dir-pai/dir-filho.
Já o terceiro exemplo copia apenas o arquivo /etc/hosts para o diretório atual, que é
representado pelo ponto (.).
No último exemplo, o diretório /etc/ é copiado por completo, com todo seu conteúdo,
sendo ele arquivos e subdiretórios, por meio da opção –r (recursivo), sendo o diretório
de destino o diretório atual. Como o nome do diretório foi alterado para .novo-etc,
isso significa que o diretório foi renomeado com o novo nome, e o caractere . (ponto)
no início do nome caracteriza-o agora como um diretório oculto.
Para que uma cópia conserve os metadados dos arquivos, utilizamos cp com o
parâmetro –p. Assim, as informações de data e hora de criação, proprietário e suas
permissões não sofrem alterações.
4.1.13. Renomeando e movendo arquivos e

diretórios
O comando mv é utilizado para mover ou renomear arquivos e diretórios.
mv [opcoes] <origem> <destino>
165
A tabela a seguir descreve opções utilizadas com o comando mv:

-i --interactive Questiona se o destino pode ser sobrescrito.
Sobrescreve o destino sem questionar, ou pedindo
-f --force
confirmações.
Move ou renomeia arquivos e diretórios em modo
-v --verbose visual, exibindo o nome no momento de mover
ou renomear.
4.1.14. Utilizando caracteres curinga

Existem caracteres especiais, nos ambientes GNU/Linux, que são reconhecidos pelo
sistema operacional como curingas e têm como função especificar, selecionar ou
substituir um caractere ou uma sequência de caracteres, auxiliando em todas as
tarefas relacionadas a arquivos ou diretórios, como cópia, exclusão, movimentação,
entre outras.
Falar sobre esses curingas de maneira unicamente teórica pode deixar sua compreensão
muito vaga, portanto vamos tratar dos três principais tipos de curingas utilizados
pelos sistemas GNU/Linux separadamente, oferecendo alguns exemplos. São eles o
asterisco (*), o ponto de interrogação (?) e os colchetes ([ ]).
O caractere * substitui parte do nome de um arquivo ou até seu nome inteiro, como
nos exemplos a seguir:
# ls *
Nesse exemplo, todos os arquivos contidos no diretório atual serão listados, já que o
curinga não reduziu a busca a nenhum caractere ou termo específico.
# ls *teste*
Nesse caso, serão listados todos os arquivos que contenham a palavra teste no
diretório em que o usuário estiver, porque o curinga, da forma que foi usado, seleciona
todos os nomes em que a palavra teste venha seguida ou antecedida de qualquer
sequência de caracteres.
# ls *.pic
Aqui, o curinga mantém aberto apenas a seção do nome do arquivo que antecede a
sequência .pic, de forma que todos os arquivos cujo nome terminam com .pic serão
listados.
166
O curinga ? substitui um ou mais caracteres numa posição específica, permitindo ao
usuário filtrar mais a busca do que o curinga *, conforme o exemplo adiante:
# ls album?.pic
Dessa forma, serão listados os arquivos cujos nomes comecem com a palavra album,
tenham qualquer caractere no lugar do curinga e terminem com .pic.
Por fim, o curinga [ ] especifica ainda mais o que o usuário pretende buscar, porque
permite dar opções concretas, sejam elas alfabéticas ou numéricas, que o curinga
pode substituir. Novamente, os exemplos a seguir devem tornar seu funcionamento
mais claro:
# ls album[1,3].pic
Esse comando promoverá a listagem de arquivos cujo nome seja album1.pic ou

album3.pic, podendo o curinga ser substituído pelos caracteres 1 ou 3.
# ls album[0-9].pic
Agora, todos os arquivos começados pela palavra album, terminados em .pic e que
tenham, no lugar do curinga, um dos números existentes no intervalo de 0 a 9 serão
listados. Note-se portanto a diferença entre a vírgula (,) e o hífen (-) na sintaxe desse
curinga.
Os curingas podem ser utilizados de forma complementar, de acordo com a

necessidade do usuário, e normalmente haverá mais de uma forma de chegar num
mesmo resultado.
4.1.15. Redirecionando a saída e entrada de dados

O usuário deve estar familiarizado com os termos convencionalmente usados para
entrada e saída de dados e comandos no shell. Para entrada de dados, usa-se o termo
stdin (Standard Input); para saída, o termo stdout (Standard Output); caso a saída
venha com algum erro, o termo é stderr (Standard Error).
Normalmente, é através do teclado que a entrada de dados e comandos é feita. Já a

saída, seja ela bem sucedida ou com erro, é exibida no monitor.
Redirecionar a saída e a entrada de dados dos comandos é uma tarefa importante e

essencial no dia a dia de um administrador, pois é possível deixar o uso dos comandos
mais flexível e avançado.
167
Conforme demonstrado na figura a seguir, é possível redirecionar as saídas geradas

na execução de um comando, como também sua própria entrada de dados. Para isso,
conheceremos a partir de agora os principais redirecionadores para executar tais
funções.
4.1.16. Redirecionador > ou 1>

O redirecionador 1> ou > pode ser utilizado para transferir o resultado executado
com sucesso de um comando, que seria exibido na tela ou no prompt atual, para um
tipo de arquivo especificado.
[comando] [codigo de saida] > <arquivo>
É preciso ter muita cautela na hora de utilizá-lo com arquivos comuns, pois,
caso o arquivo especificado já exista, um novo arquivo será criado em seu lugar,
sobrescrevendo o conteúdo do anterior. O redirecionador > também é utilizado para
criar arquivos vazios (0 byte), como o comando touch, porém, caso o arquivo já
exista, este será apagado e o novo arquivo será criado.
O código de saída 1 é utilizado para representar a saída de um comando executado

com sucesso. A não indicação desse código também é aceita pelo redirecionador >,
interpretando-o como 1>.
168
Vejamos o seguinte exemplo:
No primeiro exemplo, o arquivo chamado arq-novo foi apenas criado com o

redirecionador >. Se já existir um arquivo com o mesmo nome, ele será sobrescrito
pelo novo arquivo recém-criado, de tamanho 0 byte. No segundo exemplo (oitava
linha), o resultado com sucesso do comando ls foi redirecionado para um arquivo
chamado lista, que é criado pelo próprio redirecionador >, ou sobrescrito, caso já
exista.
Para desabilitar a característica do redirecionador > de sobrescrever um arquivo

existente eliminando seu conteúdo, é possível utilizar o comando set. Para desabilitar
essa característica, usa-se set -o noclobber e, para habilitar, set +o noclobber.
4.1.17. Redirecionador 2>
O redirecionador 2> tem por finalidade tratar a saída de erro gerada na execução de
um comando, podendo encaminhá-la para um tipo de arquivo especificado.
[comando] [codigo de saida] 2> <arquivo>
As características do redirecionador 2> são semelhantes às do redirecionador >. A

única diferença é que agora o tratamento de redirecionamento será sobre os erros
gerados.
169
O exemplo anterior está redirecionando os supostos erros gerados na execução no

momento de listar o arquivo de nome não-existe, encaminhando-os para um arquivo
chamado erro e, posteriormente, visualizando seu conteúdo, que serão os erros
gerados no comando anterior.
Assim como no redirecionamento de uma saída com sucesso, o redirecionamento de

erros também criará o arquivo especificado caso não exista, e sobrescreverá o arquivo
se ele já existir. Caso o bloqueio com o comando set -o noclobber seja definido, a
característica de sobrepor arquivos também será desabilitada.
4.1.18. Redirecionador &>
O redirecionador &> tem por finalidade tratar tanto a saída, quanto o erro gerado
na execução de um comando, podendo encaminhá-la para um tipo de arquivo
especificado.
[comando] [codigo de saida] &> <arquivo>
4.1.19. Redirecionador &&
O redirecionador && tem por finalidade verificar se o comando1 foi executado com
sucesso e, caso positivo, o comando2 também será executado.
[comando1] && [comando2]
170
4.1.20. Redirecionador ||
O redirecionador || tem por finalidade verificar se o comando1 foi executado com
sucesso e, caso negativo, o comando2 também será executado.
[comando1] || [comando2]
4.1.21. Redirecionador >>
O redirecionador >> também é utilizado para redirecionar um resultado executado com
sucesso para um arquivo, porém, de forma concatenada, não mais sobrescrevendo
o conteúdo do arquivo existente, mas sim apenas adicionando o resultado ao final
dele. É uma forma segura de se adicionar mais informações ao final de um arquivo,
sem perde-lo.
[comando] [codigo de saida] >> <arquivo>
Exemplos:
Nos exemplos anteriores, os resultados do comando date foram adicionados ao final

do arquivo chamado data-hora, que, caso não exista, será criado automaticamente
pelo primeiro redirecionador >>.
Também não é possível redirecionar um resultado obtido em um arquivo para ele

mesmo. Porém, com o redirecionador >>, não corremos o risco de perder o arquivo
caso o comando set –o noclobber tenha sido definido.
171
4.1.22. Redirecionador 2>>
O redirecionador 2>> também consegue tratar resultados de erros quando o código
2 for informado. Será possível anexar uma saída sem sucesso ao final de um arquivo,
mantendo todas as características do redirecionamento de uma saída com sucesso,
como no exemplo anterior.
[comando] [codigo de saida] 2>> <arquivo>
No exemplo anterior, os supostos erros gerados na execução desses comandos foram

enviados ao final do arquivo chamado erro. Caso tal arquivo não exista, ele será
criado automaticamente na primeira execução.
172
4.1.23. Redirecionador <
O redirecionador < terá a finalidade de redirecionar a entrada de dados do comando,
indicando que esta entrada de dados será agora o conteúdo de um arquivo.
[comando] < <arquivo>
Vejamos:
No primeiro exemplo (primeira linha), o conteúdo do arquivo data-hora foi

encaminhado para o comando cat -n, que irá visualizar tal conteúdo colocando uma
numeração no início de cada linha e exibindo o tal resultado na saída padrão.
No exemplo seguinte (sétima linha), a listagem do diretório atual é transformada em

um arquivo virtual e encaminhada para o comando cat -n, para que ele numere seu
conteúdo.
173
4.1.24. Redirecionador <<
O redirecionador << é utilizado para poder criar, de forma simples e dinâmica, uma
entrada de dados que poderá ser aproveitada por um comando qualquer.
[comando] << <finalizador>
Vejamos:
Na primeira linha da imagem anterior, o comando cat –n foi simplesmente iniciado,

porém, sem indicação de uma entrada de dados como um arquivo. Seu comportamento
foi aceitar a entrada de dados do próprio teclado enquanto a informação era passada.
O encerramento se dá com a entrada do caractere . (ponto) no início da linha.
Em seguida, na mesma imagem, mais informações são inseridas no final do arquivo

chamado data-hora, sem precisar de um editor de textos. A entrada de dados é
redirecionada novamente, conforme o que vai sendo digitado. Para encerrar e enviar
as informações, foi digitado o finalizador determinado nos parâmetros (FIM). Assim,
tudo o que foi digitado é adicionado ao final do arquivo indicado.
174
4.1.25. Redirecionador |
O redirecionador | (PIPE) é, sem dúvida, um dos mais utilizados nas tarefas
administrativas do dia a dia. Com esse redirecionador, podemos fazer com que
comandos distintos se comuniquem, tornando-os muito mais flexíveis e avançados.
O | (PIPE) permite que o resultado com sucesso de um comando possa ser transferido
para uso em outro comando, e assim sucessivamente. Com ele, a saída de um comando
é redirecionada como entrada de outro.
<comando1> | <comando2> ...
Dessa forma, criamos grandes filtros e conseguimos atender a qualquer tipo de

necessidade que requer a utilização de vários comandos ao mesmo tempo.
Vejamos os seguintes exemplos:
ls /etc | less
ls /var | cat –n
Nos exemplos anteriores, as saídas geradas pelo primeiro comando foram

encaminhadas para uso nos comandos posteriores ao | (PIPE). É possível usar qualquer
sequência de comandos, apenas é preciso ter atenção à perfeita sintonia com que eles
deverão trabalhar.
4.1.26. tee
O comando tee é uma extensão dos redirecionadores apresentados anteriormente,
sendo possível encaminhar o resultado de um comando para um destino especificado,
um arquivo qualquer e, ao mesmo tempo, visualizá-lo na saída padrão (tela).
<comando1> |tee [opcao] [arquivo] ...
Em [opcao], podemos utilizar a opção -a, para adicionar o resultado do comando ao

final de um arquivo existente, não o sobrescrevendo.
175
Vejamos:
No exemplo anterior, foi possível visualizar na saída padrão o conteúdo do arquivo

chamado data-hora e também enviar o resultado da visualização para um novo
arquivo chamado data-hora-novo.
Deve-se atentar à utilização do comando tee, pois ele sobrescreve um arquivo no

processo de redirecionamento, como o redirecionador >, mesmo que o comando
set -o noclobber esteja definido. Para que o comando tee apenas adicione ao final
do arquivo indicado um determinado resultado, é preciso utilizar a opção -a, como
no último uso de tee da imagem anterior, com a visualização do arquivo lista e seu
respectivo redirecionamento para o arquivo data-hora-novo e a saída padrão.
4.1.27. Visualizando arquivos e diretórios

Os sistemas GNU/Linux oferecem uma série de comandos para visualização de
arquivos e diretórios, cada qual com propósitos de exibição particulares.
É comum nos depararmos com arquivos cuja extensão ultrapassa as dimensões

do monitor do computador no momento em que são exibidos. Arquivos grandes
são exibidos na tela sequencialmente até a sua última linha, e isso é feito em uma
velocidade que impossibilita a leitura dos dados. Nesses casos, podemos controlar
o fluxo de exibição e aquilo que desejamos visualizar por meio de comandos de
paginação.
A seguir, abordaremos os principais comandos de paginação e visualização de

arquivos e diretórios.
176
4.1.28. Exibindo a estrutura de um diretório em
árvore
O comando tree exibe a estrutura de um diretório e seu conteúdo em formato de
árvore. Sua sintaxe é a seguinte:
tree [opcoes] [diretorio]
Se utilizarmos o parâmetro –d, serão exibidos somente os diretórios.
O exemplo adiante exibe a estrutura do diretório dir-pai, com seu respectivo conteúdo.
No CentOS, esse comando precisará ser instalado. Solicite ajuda ao seu instrutor.
4.1.29. Exibindo e concatenando o conteúdo de

arquivos
O comando cat é utilizado para visualizar o conteúdo de um ou mais arquivos,
exibindo seu resultado na saída padrão. Também pode ser utilizado para capturar
informações da entrada de dados padrão, exibindo-as depois na saída padrão.
cat [opcao] [arquivo]
A tabela a seguir descreve alguns parâmetros que podem ser utilizados com cat:
Opção
Unix
Numera apenas as linhas com conteúdo na
-b --numbernonblank
exibição.
-n --number Numera todas as linhas na exibição.
Suprime linhas em branco, que se repetem de
-s --squeezeblank
forma sequencial na exibição.
177
O exemplo a seguir exibe os conteúdos dos arquivos impacta.txt e aula.txt:
cat impacta.txt aula.txt
Este outro exemplo utiliza o redirecionador > para gravar a saída do comando cat no
arquivo treinamentosimpacta.txt:
cat impacta.txt aula.txt > treinamentosimpacta.txt
O comando tac também é utilizado para visualizar um ou mais arquivos, exibindo

seu resultado na saída padrão, porém de forma invertida. Também pode ser utilizado
para capturar informações da entrada de dados padrão, exibindo-as depois na saída
padrão, de forma invertida. Sua sintaxe é a seguinte:
tac [opcao] [arquivo]
No exemplo a seguir, o comando cat é utilizado para visualizar o conteúdo do arquivo

exemplo_tac:
178
Já no exemplo a seguir, foi executado o comando tac em vez de cat para visualizar o
conteúdo do mesmo arquivo (exemplo_tac). Podemos perceber que o resultado está
invertido em comparação à saída do comando cat:
4.1.30. more
O comando more é utilizado para visualizar um ou mais arquivos na saída padrão,
porém, de forma mais dinâmica. O comando cat, por exemplo, apresentado
anteriormente, não é eficiente para visualizar arquivos grandes. O more tem uma
interface própria, que aceitará diversos comandos internos, o que facilitará a navegação
no arquivo. Sua sintaxe é a seguinte:
more [opcao] [arquivo(s)]
Quando o monitor do computador é preenchido com dados do arquivo, o comando

more aguarda uma ação do usuário para continuar a exibir o restante do conteúdo:
•• Ao pressionar ENTER, é exibida uma nova linha de conteúdo;
•• Ao pressionar a barra de espaço, é exibida uma nova página de dados.
179
A tabela a seguir descreve as principais opções que podemos utilizar com o comando
more:
Opção Unix Descrição

Suprime linhas em branco que se repetem de forma sequencial
-s
na exibição.
Inicializa o more, fazendo uma busca pela expressão indicada,
+/”expressao”
exibindo a primeira linha que contém tal expressão no arquivo.
+”numero” Inicializa o more no número de linha indicado.
O comando more utiliza comandos internos, que têm validade apenas com ele em
funcionamento. Esses comandos são representados por teclas específicas, como é
apresentado na tabela a seguir:
Comando
Descrição
interno
h ou ? Exibe a ajuda do more.
Tecla de navegação. Desce linha a linha, no sentido do final do
ENTER
arquivo.
Tecla de navegação. Desce página a página, no sentido do final do
SPACE
arquivo.
Tecla de navegação. Sobe página a página, no sentido do início do
^b
arquivo.
Localiza a expressão no arquivo, porém, a busca é feita a partir da
/”expressão” página atual, no sentido do final do arquivo. A característica case-
sensitive é habilitada nas buscas.
N Localiza a próxima expressão caso ela exista.
Carrega o arquivo com o editor de textos padrão definido no
v
sistema.
Q Finaliza o more.
180
4.1.31. less
O comando less também é utilizado para visualizar arquivos de forma dinâmica, com
uma melhoria significativa nas teclas de navegação e comandos internos em relação
ao comando more. O comando more só permite navegar para baixo durante a leitura
de um arquivo, ao passo que o less possibilita também a navegação para cima.
less [opcao] [arquivo(s)]
less:

Suprime linhas em branco que se
-s --squeezeblank-linese repetem de forma sequencial na
exibição.
Inicializa o less, fazendo uma busca
pela expressão indicada, exibindo a
+/”expressao”
primeira linha que contém tal expressão
no arquivo.
Inicializa o less no número de linha
+”numero”
indicado.
Ignora o recurso case-sensitive na busca
-i --ignore-case por alguma expressão na inicialização
do less.
181
Assim como o comando more, o comando less também utiliza comandos internos, que
têm validade apenas com ele em funcionamento. Esses comandos são representados
por teclas específicas, como é apresentado na tabela a seguir:
Comando interno Descrição

H Exibe a ajuda do less.
←↑→↓ Teclas de navegação linha a linha dentro do less.
Tecla de navegação. Desce página a página, no sentido do
PAGE DOWN
final do arquivo.
Tecla de navegação. Sobe página a página, no sentido do
PAGE UP
início do arquivo.
Localiza a expressão no arquivo, porém a busca é feita a
/”expressão” partir da página atual, no sentido do final do arquivo. A
característica case-sensitive é habilitada nas buscas.
N Localiza a próxima expressão, caso ela exista.
n Retorna à última expressão localizada.
Carrega o arquivo com o editor de textos padrão definido
v
no sistema.
Q Finaliza o less.
H Exibe a ajuda do less.
4.1.32. head
O comando head é utilizado de forma bem simples para visualizar apenas as primeiras
linhas de um arquivo. Por padrão, o comando head exibe apenas as 10 primeiras linhas
do arquivo indicado, podendo haver alteração para quantas linhas forem necessárias,
com a utilização do parâmetro –n. Sua sintaxe é a seguinte:
head [opcao] <arquivo>
Podemos utilizar o redirecionador | para exibição de trechos entre linhas específicas.
No exemplo a seguir, são exibidas as 17 primeiras linhas do arquivo arq-teste:
head -n17 arq-teste
182
Caso não queira que a exibição seja medida por linhas, mas pelo número de caracteres
(byte), o usuário pode usar o parâmetro –c, conforme o seguinte exemplo:
head –c 100 arq-teste
Nesse exemplo, os cem primeiros caracteres do arquivo arq-teste serão exibidos.
4.1.33. tail
O comando tail é utilizado de forma simples para visualizar apenas as últimas linhas
de um arquivo. Por padrão, o comando tail exibe apenas as 10 últimas linhas do
arquivo indicado, podendo haver alteração para quantas linhas forem necessárias.
tail [opcao] [arquivo]
tail:

-n[N] --lines=[N] Exibe as [N] últimas linhas de um arquivo.
-n[+N] --lines=[+N] Exibe o arquivo a partir da linha [+N] especificada.
Prende as 10 últimas linhas do arquivo, exibindo
-f --follow=name em tempo real qualquer nova informação
adicionada ao final do arquivo monitorado.
Como head, o comando tail também aceita o uso do redirecionador | para exibição de
trechos entre linhas específicas.
No exemplo a seguir, inicialmente todas as linhas são numeradas e seu resultado

redirecionado ao comando tail, que exibe apenas as três últimas linhas do arquivo
messages:
cat –n /var/log/messages | tail -n3
Neste outro exemplo, também depois de numerar o arquivo por inteiro, a sua
visualização inicia a partir da linha de número 50, até o final do arquivo.
cat –n /var/log/messages | tail -n+50
183
Já no exemplo a seguir, com a opção -f é feito um monitoramento em tempo real

do arquivo messages. Qualquer incremento de informação no final desse arquivo
poderá ser visualizado em tempo real.
tail -f /var/log/messages
Para finalizar a visualização em tempo real das 10 últimas linhas de um arquivo

ativado com a opção –f, é preciso finalizar o processo com a sequência de teclas
CTRL + C.
4.1.34. Preparando um arquivo de texto para

impressão
O comando pr prepara um arquivo de texto comum para ser impresso, exibindo o
resultado na saída padrão e podendo dividir o arquivo por páginas e aplicar cabeçalhos
com informações de data, número de página, nome do arquivo etc. Sua sintaxe é a
seguinte:
pr [opcao] [arquivo]
A tabela a seguir descreve algumas opções que podemos utilizar com pr:

+[primeira --pages=[primeira
Indica um intervalo com os números das
página]:[última página]:[última
páginas desejadas para impressão.
página] página]
--date- Define uma data específica para anexar
-D<data>
format=<data> ao cabeçalho de cada página.
Omite a exibição de cabeçalhos nas
-t --omit-header
páginas.
Vejamos o seguinte exemplo do uso de pr:
pr +2:4 -D 07/07/2007 /etc/services
Com o exemplo anterior, foi possível visualizar apenas o intervalo de páginas que vai
da página 2 até a página 4, inserindo a data de 07/07/2007 nos cabeçalhos.
184
4.1.35. paste
O comando paste faz uma junção de linha a linha de dois arquivos indicados,
separando a informação de cada linha, por padrão, com uma tabulação TAB, e exibindo
o resultado da junção dos arquivos na saída padrão. Sua sintaxe é a seguinte:
paste [opcao] [arquivo] [arquivo]
A tabela a seguir descreve as principais opções que podemos utilizar com paste:

Indica um delimitador que irá substituir a
--delimiters=
-d[delimitador] tabulação TAB no momento de separar uma
[delimitador]
informação da outra.
Define que a junção das linhas será feita em
-s --serial
formato paralelo.
Na imagem a seguir, os arquivos numeros e letras são respectivamente criados a

partir dos métodos vistos anteriormente com redirecionadores:
Em seguida, é feita uma junção dos conteúdos dos arquivos, exibindo na saída padrão
cada linha de cada arquivo lado a lado, separadas apenas pela tabulação TAB, como
mostrado a seguir:
185
Já no exemplo a seguir, outra junção foi feita, só que agora em formato paralelo (o
comando paste foi utilizado com o parâmetro –s):
É importante lembrar que a tabulação TAB pode ser substituída por um delimitador
qualquer, como no exemplo a seguir:
4.1.36. join
O comando join também faz a junção de linhas de arquivos distintos, porém, essas
linhas que serão unidas deverão ter um campo em comum, um índice que seja idêntico
em cada linha, exibindo o resultado do processo na saída padrão. O comando join
trata os arquivos como uma espécie de banco de dados primitivo, permitindo tratar
as informações linha a linha. O índice das linhas deverá seguir algumas regras, como
ser numérico ou alfabético, e também estar ordenado tanto de forma crescente como
decrescente.
A sintaxe de join é a seguinte:
join [opcao] <arquivo> <arquivo>
A tabela a seguir descreve as principais opções que podemos utilizar com join:

Exibe também as linhas que não têm um correspondente em uma
combinação de arquivos.
a [arquivo]
Sobre a indicação do arquivo, deverá ser feita através dos números
1 (primeiro) e 2 (segundo).
-t[separador] Especifica o separador de campos.
Exibe somente as linhas que não têm um correspondente em uma
combinação de arquivos.
-v [arquivo]
Sobre a indicação do arquivo, deverá ser feita através dos números
1 (primeiro) e 2 (segundo).
186
Vejamos:
No exemplo anterior, foi feita uma junção do conteúdo do arquivo cidade com
o arquivo estado. Como a linha de índice número 3 do arquivo cidade não tinha
correspondente no arquivo estado, ela não apareceu na saída padrão, mas é possível
forçar a visualização dessa linha órfã com o seguinte exemplo:
Também é possível visualizar apenas a linha que não tem correspondente em outro
arquivo, como no exemplo a seguir:
4.1.37. Exibindo linhas repetidas de um arquivo

O comando uniq pode ser utilizado tanto para informar linhas que se repetem de
forma sequencial em determinado arquivo, como para suprimir a exibição de apenas
uma das linhas que se repetem, exibindo qualquer tipo de resultado na saída padrão.
uniq [opcao] [arquivo]
187
A tabela a seguir descreve as principais opções que podemos utilizar com uniq:

Exibe a quantidade de vezes que cada linha se
-c --count
repete.
Exibe apenas um resumo do que foi suprimido
-d --repeated
das linhas repetidas.
--ignorecase É desabilitada a característica case-sensitive no
-i
momento de comparar as linhas.
Exibe apenas as linhas únicas presentes no
-u --unique
arquivo.
Vejamos o seguinte exemplo do uso de uniq:
No exemplo anterior, depois de criado o ambiente de teste, foi feita uma filtragem
em que só foram exibidas as linhas únicas (uso do parâmetro –u) e posteriormente as
linhas que se repetem sequencialmente no arquivo (uso do parâmetro –d).
188
4.1.38. od
O comando od é utilizado para fazer uma conversão sobre o formato da visualização
de um arquivo, de forma que o arquivo original não é alterado em nada, apenas a sua
visualização é proporcionada no formato desejado pelo usuário.
od [opcao] [arquivo]
A tabela a seguir descreve as principais opções que podemos utilizar com od:

-x Permite a visualização do arquivo no formato hexadecimal.
-o Permite a visualização do arquivo no formato octal.
-c Permite a visualização do arquivo no formato ASCII.
Permite a visualização do arquivo no formato de nome dos
-a
caracteres.
No exemplo a seguir, utilizamos o comando od com a opção –o, o que retorna o

arquivo /etc/resolv.conf em formato octal:
4.1.39. hexdump
O comando hexdump também é utilizado para fazer conversão do formato do
arquivo, com uma mudança notável sobre o od na formatação, no momento de exibir
a conversão na saída padrão.
hexdump [opcao] <arquivo>
A tabela a seguir descreve as principais opções que podemos utilizar com hexdump:

-x Converte o arquivo para o formato hexadecimal.
-o Converte o arquivo para o formato octal.
-c Converte o arquivo para o formato ASCII.
189
No exemplo a seguir, o comando hexdump é utilizado com a opção –x, o que retorna
o arquivo /etc/resolv.conf em formato hexadecimal:
4.1.40. Exibindo a quantidade de linhas, palavras

e caracteres de um arquivo
O comando wc (de word count) é utilizado para obter informações sobre o conteúdo
do arquivo, como quantidade de linhas, quantidade de palavras e quantidade de
caracteres presentes em um arquivo.
wc [opcao] [arquivo]
wc:

Exibe somente a quantidade de linhas existentes
-l --lines
em um arquivo.
Exibe somente a quantidade de palavras
-w --words
existentes em um arquivo.
--bytes / Exibe somente a quantidade de caracteres
-c / -m
--chars existentes em um arquivo.
No exemplo a seguir, temos o resultado do comando wc trazendo as informações

sobre o arquivo passwd, como número de linhas, número de palavras e número de
caracteres presentes nele:
190
4.1.41. Classificação numérica ou alfabética
O comando sort tem a função de classificar um arquivo de texto tanto em modo
alfabético quanto numérico, em formato crescente ou decrescente. O resultado
dessa classificação, por padrão, é exibido na tela, mas pode ser encaminhado para
um arquivo especificado, inclusive para o próprio arquivo original. Sua sintaxe é a
seguinte:
sort [opcao] [arquivo]
Esse comando é útil em tarefas como rápida exibição de nomes e exclusão de itens
repetidos. A tabela a seguir descreve as principais opções que podemos utilizar com
o comando sort:

-n Classifica arquivos numéricos.
-r Inverte a classificação.
Indica um arquivo no qual o resultado classificado poderá ser
-o <arquivo>
salvo, podendo ser inclusive o arquivo original.
Depois de classificar o arquivo, suprime linhas que se repetem
-u
sequencialmente, exibindo apenas uma.
-f Ignora caracteres em maiúsculo e minúsculo.
No exemplo a seguir, é definida uma classificação numérica e em ordem invertida,

salvando o resultado no próprio arquivo em que é aplicada a classificação:
191
4.1.42. Exibindo linhas de texto na tela

O comando echo mostra alguma informação na tela do computador. Pode ser utilizado
pelo usuário para obtenção de dados sobre a tarefa que ele estiver executando no
momento. Um de seus fins mais comuns é a inspeção de variáveis de ambiente.
A informação que o usuário deseja capturar pode ainda ser mandada para um arquivo
determinado, caso se junte o comando echo a algum redirecionador.
Inserindo o comando echo “Isto é um teste”, como feito a seguir, será retornada na
tela a frase Isto é um teste:
O comando echo será muito útil quando estivermos lidando com shell scripts e
variáveis.
4.1.43. grep
O comando grep é utilizado para localizar um padrão especificado, que pode ser uma
palavra ou expressão em um ou vários arquivos. O resultado é a linha por extenso na
qual se encontra tal padrão desejado, que é exibida na saída padrão. Sua sintaxe é a
seguinte:
grep [opcao] [padrao] [arquivo]
grep:

Exibe uma quantidade especificada de linhas
--aftercontext=
-A [numero] após (after) a linha em que se encontra o
[numero]
padrão desejado.
Exibe uma quantidade especificada de linhas
--beforecontext=
-B [numero] antes (before) da linha em que se encontra o
[numero]
padrão desejado.
Em vez de exibir a linha na qual se encontra o
-c --count padrão desejado, é exibida uma quantidade
de linhas na qual o padrão está presente.
Deixa o resultado colorido, colocando em
destaque o padrão relacionado na pesquisa.
--color=[opcao]
[opcao] poder ser igual a auto ou never
(padrão).
192
Não exibe o nome do arquivo no qual foi
-h --no-filename encontrado determinado padrão. É útil
quando a busca é em vários arquivos.
Ignora a característica de case-sensitive no
-i --ignore-case
momento de buscar algum padrão.
Exibe também o número da linha na qual o
-n --line-number
padrão se encontra.
Busca recursiva, preferencialmente utilizada
-r --recursive
em diretórios.
-v --invert-match Inverte a lógica da busca.
Interpreta <padrao> como uma expressão
-E --extended-regexp
regular estendida.
Interpreta <padrao> como uma lista de
-F --fixed-strings
strings fixas.
Vejamos:
Na primeira linha da imagem anterior, há uma simples busca pelo padrão loopback
em todos os arquivos do diretório /etc/; uma busca recursiva utilizando a opção -r.
Na sequência, foi aproveitado o resultado do comando ls, e a partir desse resultado,

utilizando o redirecionador | (PIPE), foi feita uma pesquisa pelos padrões sd e fd,
respectivamente.
193
4.1.44. egrep
É um comando equivalente ao grep –E. O egrep busca uma expressão regular estendida
num arquivo. No exemplo a seguir, o egrep é utilizado em busca da expressão root
no arquivo /etc/passwd:
O egrep é um comando muito utilizado para filtros com expressões regulares, as

quais veremos posteriormente. A partir dessa funcionalidade, surgem infinitas
possibilidades com scripts em shell e comandos de administração do sistema.
4.1.45. fgrep
É um comando equivalente ao grep –F. Busca as ocorrências de uma string fixa num
arquivo, sem interpretá-la como uma expressão regular.
No exemplo a seguir, o comando fgrep é utilizado para filtrar a expressão fixa EXT3
no arquivo de log /var/log/messages:
194
4.1.46. sed
O comando sed não só localiza expressões ou padrões em arquivos, como também
possibilita a alteração dos dados encontrados. Vejamos o seguinte exemplo:
No exemplo anterior, é feita a leitura do arquivo chamado arquivo.txt, que possui 4

linhas. Utilizamos, em seguida, o comando sed para excluir as linhas 1 e 2 (‘1,2d’).
Na saída desse comando, o resultado foi exibido na tela somente com as duas últimas
linhas. Em seguida, se fizermos novamente a leitura do arquivo, o arquivo mostra-se
intacto. Se a intenção fosse alterar o arquivo, utilizaríamos a opção –i. Nos exercícios
de laboratório deste capítulo, veremos como utilizá-la.
4.1.47. Obtendo colunas de uma tabela

O comando cut é utilizado para obter colunas de uma tabela. Com essa definição, um
simples arquivo, com um delimitador qualquer separando uma informação da outra,
já pode ser considerado uma tabela, podendo ter informações de suas respectivas
colunas extraídas. Sua sintaxe é a seguinte:
cut [opcao] [arquivo]
195
cut:
Opção
Unix
Tal opção define cada caractere como
-c [num] --caractere=[num]
membro de uma coluna específica.
Especifica o delimitador, um único caractere
-d [delim.] --delimiter=[delim.] que estará separando uma informação da
outra.
Utilizada em conjunto com a opção –d, após
-f [coluna] --fildes=[coluna] especificar o delimitador, informar o número
de coluna ou intervalo que será extraído.
Vejamos:
No primeiro uso de cut, depois de definido o delimitador sendo o caractere : (dois

pontos) no arquivo /etc/passwd, foi solicitada a visualização das colunas 1, 2 e 3 e
exibido apenas o primeiro resultado.
No exemplo seguinte, com o cut, após uma simples filtragem localizando a linha com
o padrão root, foram exibidos apenas os quatro primeiros caracteres de tal linha,
devido à função do corte de colunas por caractere atribuída à opção –c.
Um comando que realiza a mesma tarefa que o cut é o awk. No entanto, este último
é uma linguagem de processamento e escaneamento de padrões e apresenta uma
quantidade maior de opções e recursos para expressões regulares.
196
4.1.48. Determinando o tipo de arquivo
Diferente de outros sistemas operacionais, os arquivos em plataformas GNU/Linux
não são definidos por suas extensões. Caso o nome de algum arquivo possua o
formato nome.xyz, por exemplo, esses três caracteres finais não passam de uma
ferramenta de opção do usuário, se ele achar que assim se organizará melhor, porém
isso não possui nenhuma funcionalidade para o sistema.
Assim sendo, é impossível ter garantia do tipo de um arquivo levando em conta

apenas o seu nome. Para isso, usa-se o comando file, que analisa o conteúdo do
arquivo e determina seu tipo.
file <arquivo>
4.1.49. Substituindo e excluindo caracteres de

um arquivo
O comando tr pode ser utilizado tanto para converter caracteres de arquivos como
para deletá-los. O comando tr tem uma particularidade, que é sempre ter sua entrada
de dados redirecionada. Depois da conversão, o resultado é exibido na saída padrão.
tr [opcao] <definicao1> [definicao2]

-d <caractere(s)> --delete<caractere(s)> Utilizada para apagar caracteres.
Suprime uma sequência de
-s --squeeze-repeats
caracteres que se repetem.
197
Vejamos:
No primeiro exemplo do uso de tr (primeira linha da imagem anterior), há uma

conversão simples de todos os caracteres que vão do intervalo a-z para A-Z no arquivo
repeteco, gravando seu resultado em um novo arquivo de nome novo-repeteco e
exibindo também o mesmo resultado na saída padrão. Já no segundo exemplo, todos
os caracteres - foram removidos do arquivo repeteco, gravando tal resultado em um
novo arquivo.
No exemplo a seguir, uma sequência de espaços simples foi suprimida e substituída

pelo caractere . (ponto):
Para fazer referência a determinadas definições, é possível usar alguns interpretadores

que facilitarão tal tarefa em determinados casos, como mostra a seguinte tabela:
Interpretador Descrição
[:digit:] Representa os valores numéricos (0-9).
[:lower:] Representa todas as letras do alfabeto em minúsculo.
[:upper:] Representa todas as letras do alfabeto em maiúsculo.
Representa todos os caracteres imprimíveis, letras, números,
[:print:]
pontuações etc.
198
No exemplo a seguir, foram retirados todos os dígitos numéricos de arq-numerico:
4.1.50. Numerando arquivos
O comando nl é utilizado para numerar um arquivo qualquer, exibindo essa numeração
na saída padrão. Sobre a numeração que poderá ser aplicada, existem alguns estilos
e formatos a serem definidos, conforme as opções do comando.
nl [opcao] [arquivo]
A tabela a seguir descreve as principais opções que podemos utilizar com nl:

Ativa o estilo de numeração, em que:
•• a numera todas as linhas do

arquivo;
--budy-
-b[estilo]
numbering=[estilo] •• t numera apenas as linhas que
têm conteúdo (opção padrão do
comando nl);
•• n não numera linhas.

Define um separador que ficará entre
--number-
-s[separador] os números definidos pelo comando
separator=[separador]
nl e o texto de cada linha do arquivo.
--page- Define um valor incremental para a
-i[valor]
increment=[valor] numeração aplicada no arquivo.
-v[início da --first-page=[inicio da Define qual será o início da numeração
numeração] numeração] aplicada no arquivo.
199
No exemplo anterior, o nl é executado com um conjunto de opções, o que exibe uma

numeração completa na saída padrão, em que todas as linhas, incluindo as linhas em
branco do arquivo, serão numeradas, porém, iniciando a numeração no número 0 e
utilizando o valor incremental 2, criando, assim, uma lista de número par e usando o
caractere + como separador da numeração.
4.1.51. Formatando parágrafos de arquivos

O comando fmt é utilizado para formatar parágrafos de arquivos, exibindo seu
resultado na saída padrão. Sua sintaxe é a seguinte:
fmt [opcao] [arquivo]
A tabela a seguir descreve as principais opções do comando fmt:

Quebra linhas longas, que ultrapassem o
-s --split-only
número de colunas definido.
Define a largura máxima de cada linha no
-w[valor] --width=[valor]
arquivo (o valor padrão é 75).
Vejamos o seguinte exemplo do uso do fmt:
fmt -s -w30 /etc/services
Com esse exemplo, o arquivo /etc/services teve seus parágrafos formatados com
uma diminuição da largura das linhas para o valor de coluna 30, quebrando linhas
que tinham tamanho maior que o estipulado. Lembrando que essa formatação foi
feita apenas no momento da exibição na saída padrão, para armazenar esse resultado
em um arquivo, basta utilizar os redirecionadores apresentados anteriormente.
200
4.1.52. Links
Arquivos especiais cuja função é servir de atalho para outros arquivos, os links
facilitam a navegação e o acesso a arquivos diferentes. Antes de partirmos para a
criação de links, é importante compreender o que é um inode, uma característica
muito importante presente nos sistemas Unix-like e base para o funcionamento e
entendimento pleno dos tipos de link com os quais poderemos trabalhar.
4.1.53. Inodes
O inode (abreviação de index node) é uma identificação que cada arquivo tem no
sistema. A referência pode ser por um número, em que tal número pode ser visualizado
com a opção -i do comando ls, ou com o comando stat.
O inode é utilizado de forma direta pelo sistema de arquivos, que é como um relatório
sobre o arquivo, com todas as informações sobre ele, como dono, grupo, permissões,
nome etc.
O exemplo a seguir exibe o número de inode do arquivo arq-novo:
4.1.54. Link simbólico
Um link simbólico é simplesmente um tipo de arquivo especial, que é representado
pela letra l, caso listado com o comando ls -l. Esse arquivo é apenas um apontamento,
um atalho para o arquivo original ao qual o link está ligado. Por ser um atalho ao
arquivo original, e caso seja apagado, o arquivo original continua intacto. Porém, se
for o contrário, o arquivo original for apagado, o link se torna quebrado ou inacessível.
4.1.55. Link físico (hardlink)

Um link físico, ou hardlink, tem características bem diferentes de um link simbólico,
pois um link físico causa uma falsa sensação de que o arquivo original foi duplicado,
o que na verdade foi uma pequena alteração feita em seu inode, no qual é adicionado
um novo nome para ele. Um link físico nada mais é do que relacionar um arquivo por
mais de um nome, alterando diretamente o seu inode.
201
4.1.56. Criando links
O comando ln poderá ser utilizado para criar os dois tipos de link. Sua sintaxe é a
seguinte:
ln [opcao] <origem> <destino>
ln:
Opção
Unix
-s --symbolic Utilizada para criar um link simbólico para arquivos.
-d --directory Cria um link físico para diretórios.
•• Criando um link simbólico
Vejamos a seguinte tela:
No exemplo anterior, foi possível criar um link simbólico para o arquivo chamado
services, apontando para o link de nome link-simbólico. É importante salientar
algumas diferenças entre o arquivo original e o link simbólico, como número de
inode, tamanho e permissões. Isso se deve ao fato de o link simbólico ser apenas
um atalho para o arquivo original, mantendo dependências diretas com relação ao
arquivo original.
•• Criando um link físico
Vejamos esta outra imagem:
202
Nesse exemplo, para criar um link físico com o comando ln, bastou utilizar o comando
ln sem qualquer tipo de opção. É possível observar agora que todas as informações
do arquivo original são idênticas às do arquivo link-físico, mudando apenas o nome,
o que dá a impressão de que o arquivo foi duplicado, mas, devido às características
do inode, apenas um novo nome foi adicionado ao arquivo original.
Podemos observar, também, que uma informação que fica à direita das permissões
também sofreu uma leve alteração. Esse valor é o número de links físicos presentes
para esse arquivo, ou seja, a quantidade de nomes para ele. Na imagem que acabamos
de ver, tal valor é 2. Já na imagem que ilustra a criação de link simbólico, o valor logo
à direita das permissões é 1.
4.1.57. expand
O comando expand é utilizado para converter tabulações TAB (oito espaços) em uma
quantidade de espaços desejada, exibindo o resultado na saída padrão.
expand [opcao] [arquivo]
expand:
Opção
Unix
Converte apenas os TABs que estiverem no
-i --initial
início das linhas.
Define um número de espaços desejados para
-t [numero] --tabs[numero]
a conversão.
No exemplo anterior, primeiro foi criado o cenário com o comando echo, imprimindo
na tela a respectiva frase com uma tabulação TAB em seu início. Por meio do
redirecionador |tee, o resultado foi armazenado no arquivo de nome arq-com-tab e
exibido na tela ao mesmo tempo. Logo em seguida, foi aplicado o comando expand
no arquivo de nome arq-com-tab, que substituiu a tabulação TAB por um simples
espaço.
203
4.1.58. unexpand
O comando unexpand é utilizado para converter agora uma sequência de espaços
em branco (no mínimo dois) em tabulações TAB, exibindo o resultado da conversão
na saída padrão.
unexpand [opcao] [arquivo]
A principal opção que podemos utilizar com o comando unexpand é a -t, que define
um número de tabulações TAB que será utilizado na conversão.
No exemplo anterior, o comando unexpand fez uma conversão da sequência de dois

espaços no início das linhas para duas tabulações TAB.
4.1.59. Dividindo um arquivo em partes

O comando split é utilizado para dividir arquivos em vários pedaços, sendo possível
dividir qualquer tipo de arquivo. Os dois modos de trabalhar com essa divisão é
basicamente dividir o arquivo pelo tamanho ou pelo número de linhas. A última opção
é mais útil no dia a dia.
Para dividir um arquivo por tamanho ou número de linhas, deverá ser informado ao
comando split qual tamanho terá cada arquivo ou a quantidade de linhas. O comando
não calcula automaticamente, e o arquivo original permanecerá intacto e um sufixo
padrão será atribuído aos nomes de arquivos que forem divididos.
A sintaxe de split é a seguinte:
split [opcao] [arquivo] [prefixo]
204
A tabela a seguir descreve as principais opções utilizadas com split:

Divide um arquivo por tamanho. A
divisão padrão dos arquivos é em byte,
mas poderão ser utilizados os sufixos K
-b<tamanho> --bytes= <tamanho>
para kbytes, M para megabytes, G para
gigabytes e assim sucessivamente, T, P, E,
Z, Y.
Usa um sufixo de número em vez de letras
-d --numeric-suffixes
na nomenclatura dos arquivos divididos.
-l<num. de --lines= <num. de Utilizada para dividir um arquivo por
linhas> linha> número de linhas.
Exibe em modo interativo a divisão dos
--verbose
arquivos.
Vejamos a seguinte imagem:
No primeiro uso do comando split (terceira linha da imagem anterior), foi feita uma
divisão do arquivo de nome services por número de linhas, colocando 250 linhas por
arquivo e exibindo o processo de divisão. Já no segundo exemplo (décima primeira
linha da imagem anterior), uma divisão por tamanho foi feita, sendo especificada
uma divisão de arquivos de 6 kilobytes cada, mas com alguns complementos, como
aplicar um nome aos arquivos divididos e também usar sufixo numérico em vez de
alfabético.
205
•• Unindo partes de um arquivo dividido com o split
Para juntar novamente tais arquivos divididos, basta utilizar o recurso do redirecionador
> junto com o comando cat, que visualizará cada arquivo, jogando o resultado para
um arquivo novo. O exemplo a seguir ilustra essa ação:
4.1.60. Administração diária do sistema

Diversos comandos estão disponíveis nos sistemas GNU/Linux para promover a coleta
de dados sobre o sistema em si e seus arquivos, auxiliando na sua administração. As
ferramentas que serão mostradas a seguir podem ser bastante úteis ao usuário.
4.1.61. Exibindo o espaço em disco

O comando df é utilizado para obtermos informações de espaço em disco e traz
detalhes sobre as partições que estão montadas atualmente no sistema, como
quantidade total de espaço, espaço livre, espaço utilizado etc. O sufixo utilizado na
exibição padrão do comando df é em kilobytes. Sua sintaxe é a seguinte:
df [opcao] [ponto de montagem] ...
df:
Opção
Unix
Também exibe na listagem os sistemas de arquivos
-a --all que não ocupam blocos, ou seja, consomem espaço
real. Geralmente são montagens virtuais.
--human- Exibe o tamanho em sufixo amigável, colocando M
-h
readable para Megabyte, G para Gigabyte etc.
Exibe, em vez do tamanho disponível e utilizado,
-i --inodes informações de uso de i-nodes nos sistemas de
arquivos.
Exibe somente os detalhes do sistema de arquivo
-t <S. A.> --type= <S. A.>
indicado.
206
Se entrarmos apenas com o comando df, sem especificar um parâmetro e ponto
de montagem, é gerada uma listagem de todas as partições atualmente em uso no
sistema, com suas respectivas informações de utilização, representando também o
ponto de montagem ao qual cada partição está relacionada.
Vejamos este exemplo:
df -h /
A saída da linha anterior exibirá as informações detalhadas da partição relacionada ao

ponto de montagem /(diretório raiz), em formato amigável.
4.1.62. Exibindo o tamanho de arquivos, diretórios

e partições
O comando du é muito útil para obtermos informações de uso do espaço em disco por
determinado arquivo ou também sobre todos os arquivos em diretórios especificados.
Caso o comando du seja aplicado em um arquivo, é calculado o tamanho dele; caso
seja em um diretório, é calculado, por padrão, o tamanho de cada subdiretório
presente no diretório principal, mostrando no final da listagem o tamanho total que
ele ocupa no sistema. Sua sintaxe é a seguinte:
du [opcao] [arquivo1] [arquivo2] ...
Exemplo:
du /etc/
No exemplo anterior, o que aparece na listagem é o tamanho de todos os subdiretórios

que estão alocados no diretório /etc/ e a última linha do resultado é o tamanho total
dele. O sufixo de tamanho que é exibido nesse exemplo é em kilobytes, o que pode
ser melhorado com as opções do comando du que veremos a seguir:
Opção
Unix
Faz uma contagem geral, exibindo também o tamanho
-a --all
de todos os arquivos presentes nos subdiretórios.
Exibe um total quando é passado mais de um parâmetro
-c --total
para cálculo de tamanho.
Exibe apenas o tamanho total do diretório informado,
-s --summarize
não exibindo o tamanho de cada subdiretório dele.
--human- Exibe o tamanho em sufixo amigável, colocando M para
-h
readable Megabyte, G para Gigabyte etc.
207
Para exibirmos o tamanho em bytes, kilobytes e megabytes, utilizamos du com os

parâmetros –b, -k e –m, respectivamente. Para que du exiba a quantidade de links
existentes para o arquivo, diretório ou partição, utilizamos –l.
4.1.63. Exibindo o consumo de memória RAM

O comando free mostra o consumo de memória RAM, a quantidade de memória livre
e os detalhes sobre uso de memória virtual (swap).
free [opcao]
A tabela a seguir descreve as principais opções utilizadas com free:
Opção Opção
Descrição
Unix GNU
-b --bytes Exibe o resultado em bytes.
Exibe o resultado em kilobytes (KB), que é o formato padrão
-k --kb
da saída do comando free.
-m --mb Exibe o resultado em megabytes (MB).
-g --gb Exibe o resultado em gigabytes (GB).
-t --total Exibe o resumo do total de memória física mais espaço swap.
A seguir, temos o comando free executado com a opção –k, o que faz com que o
resultado na tela seja exibido em kilobytes:
208
4.1.64. Exibindo/configurando a data e hora do
sistema
O comando date exibe a data e a hora do sistema e permite configurar seu modo de
exibição através de opções que podem ser encontradas no manual acessível a partir
do comando man date.
Quando executado pelo administrador, o comando date permite não só a exibição da

data e da hora do sistema, mas também seu ajuste. A imagem a seguir demonstra o
uso de date:
4.1.65. Exibindo o tempo de uso do computador

O comando uptime informa por quanto tempo o computador está sendo usado, além
de mostrar outros detalhes de seu uso, como o número de usuários acessando o
servidor e a carga de trabalho. A imagem a seguir demonstra o uso de uptime:
4.1.66. Exibindo a versão e a arquitetura do

sistema
Com o comando uname, o usuário visualiza informações sobre a versão do kernel
que está sendo utilizada e a arquitetura do sistema. Vejamos o seguinte exemplo:
O exemplo utiliza o comando uname com a opção –a, o que retorna informações
completas sobre o kernel do sistema.
209
4.1.67. Exibindo a diferença entre arquivos

Para visualizar a diferença entre arquivos e diretórios, utiliza-se o comando diff, que
deve ser acrescido da opção -r no caso da comparação entre diretórios, para que
sejam exibidas também as diferenças entre todos os subdiretórios. Vejamos:
No exemplo anterior, foi feita a leitura do arquivo chamado arquivo.txt. A quinta linha
desse arquivo é complementada com a informação Arquivo 1. Em seguida, é feita a
leitura do arquivo chamado arquivo2.txt, no qual a quinta linha é complementada
com a informação Arquivo 2. Também, duas novas linhas são adicionadas, sendo que
a última repete a informação da linha anterior. Então, o comando diff é executado
para fazer a comparação entre os dois arquivos e informar a diferença entre eles.
4.1.68. Exibindo o tempo necessário para um

comando ser executado
O tempo de execução de um comando pode ser exibido com o comando time, cuja
sintaxe é:
time <programa>
210
No exemplo a seguir, a execução do comando time permite verificar qual dos métodos
de compactação, Bzip ou Gzip, é mais rápido. Vejamos:
4.1.69. find
O comando find é, sem dúvida, o comando mais completo quando o assunto é a
busca de arquivos, seja qual for o tipo. Sua sintaxe, dependendo da filtragem aplicada
e da sua utilização, poderá se tornar extensa e complexa. Porém, ele é um comando
muito versátil e proporciona muita flexibilidade na hora de buscar arquivos, podendo
localizar arquivos de determinados tipos (arquivo comum, arquivo de dispositivo
de bloco, arquivo de socket, etc.), arquivos que tenham determinado tamanho, que
sejam de determinado dono etc.
find [caminho da busca] [expressao]
A tabela seguinte descreve as principais opções que podem ser utilizadas com find:
Opção Descrição
Busca arquivos de qualquer tipo, cujo nome seja igual a
-name <nome> <nome>, conforme colocado na busca. A busca é feita com
a característica case-sensitive.
Busca arquivos de qualquer tipo, cujo nome seja igual a
-iname <nome> <nome>, conforme colocado na busca. A busca agora é
feita com a característica case-sensitive desabilitada.
-mindepth <valor> Localiza arquivos em uma estrutura mínima de subdiretórios.
Localiza arquivos em uma estrutura máxima de
-maxdepth <valor>
subdiretórios.
211
Opção Descrição
Especifica o tipo de arquivo desejado na busca, em que o
tipo pode ser:
•• b: Arquivo especial orientado a bloco;
•• c: Arquivo especial orientado a caractere;

-type<tipo>
•• d: Diretório;
•• f: Arquivo regular;
•• p: Arquivo especial do tipo PIPE;
•• s: Arquivo especial do tipo socket.
Localiza apenas os arquivos que pertençam ao usuário

-user<nome>
especificado em <nome>.
Localiza apenas os arquivos que pertençam ao grupo
-group<nome>
primário especificado em <nome>.
Realiza a busca por arquivos que foram acessados a <n>
-amin <n>
minutos.
Realiza a busca por arquivos que foram acessados a <n>
-atime <n>
dias.
Realiza a busca por arquivos que foram modificados a <n>
-cmin <n>
minutos.
Realiza a busca por arquivos que foram modificados a <n>
-mtime <n>
dias.
Realiza uma busca pelo tamanho do arquivo. Se apenas o
valor de n for especificado, o tipo de busca sobre o tamanho
-size equivale a blocos (1 bloco = 512bytes), que também é
<c[nomenclatura]> equivalente à nomenclatura b. Também é possível utilizar
as nomenclaturas c (bytes), k (kilobytes), M (megabytes),
G (Gigabytes).
-exec <comando> {} Executa um comando em cada arquivo que o comando find
\; localizou no tipo de busca especificado.
Realiza a busca por arquivos cuja identificação numérica
-uid <n>
do usuário seja <n>.
Realiza a busca por arquivos cujo modo de permissão seja
-perm <modo>
<modo>. Esse modo pode ser numérico ou literal.
212
Um detalhe importante sobre as buscas por tempo é que o valor de <n> pode receber
alguns complementos, como + ou -, em que:
Tempo
Descrição
<n>
Retorna tudo que foi acessado ou modificado a exatamente
<n>
<n> minutos/dias atrás.
Retorna tudo que foi acessado ou modificado a menos (-) de
<-n>
Retorna tudo que foi acessado ou modificado a mais (+) de
<+n>
A nomenclatura dia equivale a 24 horas x <n>.
Sobre o tamanho dos arquivos, o valor representado por <n> também pode receber
complementos como + ou -, em que:
Tamanho
Descrição
<n>
Retorna um tamanho que tenha exatamente o valor
<n>
especificado em <n>.
<-n> Retorna todo valor menor (-) que o valor especificado em <n>.
<+n> Retorna todo valor maior (+) que o valor especificado em <n>.
No exemplo adiante, o comando find foi utilizado para localizar arquivos com o nome
arquivo.txt:
4.1.70. locate
O comando locate também é utilizado para localizar arquivos no sistema. Ele não
tem toda a versatilidade do comando find, mas, em compensação, é extremamente
rápido. Um dos motivos para tanto é que o comando locate faz as buscas pelos nomes
de arquivos em um banco de dados, em vez de ficar acessando o disco procurando
arquivo por arquivo. É uma boa característica do comando locate, mas ao mesmo
tempo não é tão prática, pois esse banco de dados deverá ser criado e constantemente
atualizado para que a busca seja sempre completa. Esse banco de dados é controlado
pelo comando updatedb, que será o próximo comando que estudaremos.
213
A sintaxe de locate é a seguinte:
locate [opcao] [padrao]
A tabela seguinte descreve as principais opções que podem ser utilizadas com locate:

Exibe apenas a quantidade de ocorrências
-c --count
encontradas.
-d [caminho --database= Especifica o caminho de um banco de dados
BD] [caminho BD] diferente para fazer uma pesquisa.
É desabilitada a característica case-sensitive no
-i --ignorecase
momento de uma busca.
Exibe estatísticas sobre o banco de dados,
-S --statistics
número de arquivos, diretórios etc.
Neste exemplo, utilizamos locate para localizar o arquivo arquivo2.txt:
4.1.71. updatedb
Utilizando o comando updatedb, o banco de dados utilizado pelo comando locate é
criado e atualizado. É esse comando que, com a utilização de algumas regras, poderá
criar um banco de dados que corresponda a necessidades específicas.
Como a criação da primeira base de dados do sistema exige uma varredura do disco
que nunca foi realizada anteriormente, o updatedb funciona de forma lenta na
primeira vez em que é utilizado.
updatedb [opcao]
O arquivo de configuração do updatedb é o arquivo /etc/updatedb.conf. O caminho

e nome do local onde fica armazenado o banco de dados criado pelo comando
updatedb é /var/cache/locate/locatedb.
O comando updatedb não retorna qualquer informação na tela.
214
4.1.72. sleep
O comando sleep aplica uma pausa, em segundos de tempo. O exemplo a seguir
aplica ao sistema uma pausa de 15 segundos para retornar ao prompt:
sleep 15
4.1.73. logger
Com o comando logger, o usuário manualmente cria mensagens de log. O conteúdo
da mensagem deve ser inserido como argumento do comando em sua sintaxe.
No exemplo anterior, utilizamos o comando logger para inserir a frase Log de Teste
Inserido dentro do log do sistema. Pudemos conferir o resultado executando o
comando tail no arquivo de log /var/log/messages.
4.1.74. xargs
O comando xargs permite a criação de linhas de comando para serem executadas por
programas determinados pelo usuário. Vejamos o seguinte exemplo:
Primeiramente, fizemos uma listagem no diretório atual para exibir os arquivos

existentes no local. Na sequência, fizemos uma listagem em arquivos que iniciam
com arquivo2 e, por meio do comando xargs, o comando rm foi adicionado ao
resultado, a fim de que qualquer arquivo encontrado na busca especificada fosse
excluído. Por fim, fizemos novamente a listagem no diretório. É possível notar que o
arquivo arquivo2.txt já não é mais listado, ou seja, ele foi excluído.
215
4.1.75. seq
O comando seq tem a simples função de gerar uma sequência de números, seguindo
os intervalos definidos pelo usuário. Aliado a outros comandos, sua aplicação pode
ser bastante variada e útil. Vejamos o seguinte exemplo:
No exemplo anterior, o comando seq foi executado duas vezes. Na primeira vez, ele
criou uma sequência de 1 a 5. Na segunda, gerou uma sequência de 0 a 10 com um
incremento de 2 em 2, ou seja, somente os números pares foram retornados.
4.1.76. tar
O tar é usado como empacotador de arquivos, preservando as informações do
sistema de arquivos aplicados a eles, ou seja, os metadados. É usado em conjunto
com compactadores como gzip e bzip2.
A sintaxe do tar é a seguinte:
tar [opcoes] <dispositivo/arquivo> <arquivo1> [arquivo2] ...
Assim como existe a ação de empacotar arquivos, também é possível executar o

processo inverso, que seria o desempacotamento. Para isso, utilizamos tar com a
opção -x.
Os arquivos empacotados pelo tar têm a extensão .tar, porém o destino de um arquivo
empacotado pode ser diretamente um dispositivo de fita que foi originalmente iniciado
com a utilização do comando tar.
216
A tabela a seguir descreve as principais opções que podemos utilizar com o
empacotador tar:
Opção Opção Opção

Descrição
Unix GNU BSD
Cria o arquivo empacotado conforme o destino
-c --create c especificado, podendo ser um arquivo no sistema
local ou diretamente em um dispositivo de fita.
Indica se o arquivo empacotado será um
arquivo no próprio sistema, com uma extensão
.tar (recomendada para identificação), ou
-f --file F se será um dispositivo de fita. É importante
estar atento à utilização dessa opção, pois é
obrigatório informar, logo em seguida, a forma
de arquivamento do pacote.
Indica que o pacote será compactado no momento
-j --bzip2 j
do empacotamento, utilizando o utilitário bzip2.
Exibe, na tela, o processo de empacotamento ou
-v --verbose v
desempacotamento.
Utilizada para visualizar o conteúdo de um pacote
-t --list t
tar.
Indica que o pacote será compactado no momento
-z --gzip z
do empacotamento, utilizando o utilitário gzip.
Desempacota ou extrai o conteúdo de um pacote
-x --extract x
tar.
No exemplo a seguir, o comando tar é utilizado para aglutinar (e não compactar,

como veremos mais adiante) a pasta /etc dentro da pasta /root/testetar. O nome do
arquivo gerado foi teste_tar.tar, com o tamanho de 6MB.
217
Já no próximo exemplo, utilizamos a opção –x para descompactar o arquivo. Neste caso,

como não definimos o local de destino com a opção –c, o arquivo foi descompactado
na pasta em que estamos atualmente localizados.
4.1.77. cpio
Como o tar, o comando cpio também exerce as funções de empacotador ou
desempacotador, no caso do uso da opção -i, além de poder ser usado simplesmente
para copiar arquivos. Embora seja capaz de ler e escrever no formato .tar, o cpio
difere do tar por trabalhar apenas com redirecionamentos de entrada e saída padrão.
No exemplo a seguir, compactamos a pasta /etc com o cpio. Além deste último
(executado com a opção –ov), utilizamos também o comando ls. O arquivo compactado
foi redirecionado para a pasta /root/testecpio.
218
Ao verificarmos a pasta de destino utilizando o comando ls –l, podemos notar que o
arquivo foi criado com o tamanho de 5,7 MB:
Já para descompactar o arquivo, devemos estar na pasta de destino, ou seja, onde

ocorrerá a descompactação. Então, executamos o cpio com as opções –iv e acionamos
o arquivo compactado.
Após a descompactação, podemos visualizar os arquivos na pasta, como mostra a

seguinte imagem:
219
4.1.78. gzip
O comando gzip é utilizado para compactar e também descompactar arquivos.
Arquivos compactados com o utilitário gzip são identificados pela extensão .gz. Sua
gzip [opcoes] <arquivo>
Um detalhe muito importante a ser considerado é que um diretório não pode ser
compactado de forma direta pelo gzip. Ele tem que, obrigatoriamente, se tornar um
arquivo empacotado, para depois ser compactado. Porém, é possível compactar todos
os arquivos de um determinado diretório através da função recursiva. A compressão
pode ser programada para seguir automaticamente o processo de empacotamento
realizado pelo tar, com o uso da opção -z.
A seguir, vejamos algumas opções que podem ser utilizadas com o gzip:
Opção
Unix
Não compacta o arquivo original, porém o resultado da
-c --stdout compactação será enviado para a saída padrão (tela), e,
geralmente, redirecionado para um novo arquivo.
-d --decompress Utilizada para descompactar arquivos no formato .gz.
Força a compactação ou descompactação de um
-f --force arquivo, por exemplo, se existe um arquivo de mesmo
nome já compactado ou descompactado.
Exibe informações detalhadas de um arquivo
-l --list compactado, como o tamanho do arquivo compactado
e o tamanho do arquivo pós-compactação.
-q --quiet Não exibe mensagens de alerta.
Compacta, recursivamente, todos os arquivos presentes
-r --recursive em um diretório e também arquivos dentro de supostos
subdiretórios.
Utilizada para testar a integridade do arquivo
-t --test
compactado.
-v --verbose Exibe o processo de compactação ou descompactação.
Utilizada para gerenciar o grau de compactação, sendo
<nivel> um valor de 1 a 9. Quanto menor o valor,
menor a compactação, e, consequentemente, menor
será o tempo de execução do comando. Quanto maior
-<nivel> --fast / --best
o valor, maior a compactação, e, consequentemente,
também será maior o tempo de execução do comando.
O comando GNU --best equivale à opção Unix -9, e --fast
equivale à opção Unix -1.
220
Vejamos:
Na primeira execução de gzip da imagem anterior, temos uma simples compactação

do arquivo teste; o arquivo original foi compactado. Na segunda execução, o arquivo
teste2 foi compactado com a opção –c, utilizando o recurso do redirecionador >,
sendo o resultado da compactação redirecionado para um novo arquivo de nome
testinho.gz, mantendo o arquivo original intacto. Na última execução de gzip, o
arquivo teste.gz foi descompactado por meio da opção –d.
Agora, vejamos este outro exemplo:
No exemplo que acabamos de ver, diferentemente da aglutinação, utilizamos o

tar com gzip (opcao –z). O arquivo, então, é compactado. O tamanho do arquivo
compactado é de 1.4 MB, bem menor do que os 6 MB do arquivo obtido com o
exemplo de utilização do comando tar.
221
A seguir, temos um exemplo de descompactação de um arquivo com uso do gzip –xz:
4.1.79. Família de comandos do gzip

O comando gzip tem uma família de comandos utilizados com a função de simplesmente
visualizar arquivos já compactados, porém utilizando recursos adicionais de alguns
comandos que vimos anteriormente. Essa família de comandos, descrita na tabela
adiante, pode ser útil quando houver a necessidade de executar determinada tarefa
em um arquivo compactado com o formato gzip.
Comando Descrição
Visualiza, com o comando cat, arquivos compactados no formato
zcat
.gz, sem necessariamente descompactar os arquivos.
Utiliza o recurso do comando grep para localizar palavras ou
zgrep expressões em um arquivo compactado no formato .gz, sem
descompactá-lo.
Utiliza o recurso do comando less para visualizar um arquivo
zless
compactado no formato .gz.
Utiliza o recurso do comando more para visualizar um arquivo
zmore
compactado no formato .gz.
222
4.1.80. bzip2
O comando bzip2 é utilizado para compactar e também descompactar arquivos.
Arquivos compactados com o utilitário bzip2 são identificados pela extensão .bz2.
bzip2 [opcoes] <arquivo>
A tabela a seguir descreve as principais opções utilizadas com o bzip2:
Opção
Unix
Não compacta o arquivo original, porém o resultado
da compactação será enviado para a saída padrão
-c --stdout
(tela), e, geralmente, redirecionado para um novo
arquivo.
Utilizada para descompactar arquivos que foram
-d --decompress
compactados pelo comando gzip.
Força a compactação ou descompactação de um
-f --force arquivo, por exemplo, se já existe um arquivo de
mesmo nome, já compactado ou descompactado.
Utilizada para testar a integridade do arquivo
-t --test
compactado.
-v --verbose Exibe o processo de compactação ou descompactação.
Utilizada para gerenciar o grau de compactação,
sendo <nivel> um valor de 1 a 9. Quanto menor o
valor, menor a compactação e, consequentemente,
menor será o tempo de execução do comando.
-<nivel> --fast/--best Quanto maior o valor, maior a compactação e,
consequentemente, também será maior o tempo
de execução do comando. O comando GNU --best
equivale à opção Unix -9, e --fast equivale à opção
Unix -1.
Um detalhe muito importante é que um diretório não pode ser compactado de forma
direta pelo comando gzip, tendo, obrigatoriamente, que se tornar primeiro um
arquivo empacotado, para depois ser compactado.
223
No exemplo a seguir, aproveitamos um arquivo aglutinado com tar e o copiamos

para a pasta de teste do bzip. Podemos perceber que o arquivo possui 6 MB. Após
utilizarmos o comando bzip2 para compactá-lo, seu tamanho reduz para 1,3 MB.
Para descompactarmos esse mesmo arquivo, utilizamos bzip2 com a opção –d, como
mostrado a seguir:
Opcionalmente, podemos utilizar o parâmetro time para obtermos o tempo gasto na

compactação. No exemplo a seguir, adicionamos time ao bzip2. Assim, obtivemos o
tempo gasto na compactação do arquivo especificado:
224
4.1.81. Família de comandos do bzip2
O comando bzip2 também tem uma família de comandos utilizados com a função
de apenas visualizar arquivos compactados, porém utilizando recursos de alguns
comandos vistos anteriormente. Essa família de comandos, descrita na tabela adiante,
pode ser útil quando houver a necessidade de executar determinada tarefa em um
arquivo compactado com o formato bzip2.
Comando Descrição
Visualiza, com o comando cat, arquivos compactados no formato
bzcat
.bz2, sem necessariamente descompactar o arquivo.
Utiliza o recurso do comando grep para localizar palavras ou
bzgrep expressões em um arquivo compactado no formato .bz2, sem
descompactá-lo.
Utiliza o recurso do comando less para visualizar um arquivo
zless
compactado no formato .bz2.
Utiliza o recurso do comando more para visualizar um arquivo
zmore
compactado no formato .bz2.
4.1.82. gunzip
O comando gunzip é utilizado apenas para descompactar arquivos, tendo exatamente
a mesma função do comando gzip -d. Ele é utilizado para descompactar apenas um
arquivo ou todos os arquivos presentes em um diretório específico, devido à função
recursiva.
A sintaxe do gunzip é a seguinte:
gunzip [opcoes] <arquivo>
As principais opções do gunzip estão descritas na tabela a seguir:
Opção Opção
Descrição
Unix GNU
Não descompacta o arquivo original, porém o resultado da
-c --stdout descompactação será enviado para a saída padrão (tela),
e, geralmente, redirecionado para um novo arquivo.
Força a descompactação de um arquivo, por exemplo, se
-f --force
existe um arquivo de mesmo nome já descompactado.
225
Opção Opção
Descrição
Unix GNU
Descompacta recursivamente todos os arquivos presentes
-r --recursive em um diretório, e também arquivos dentro de supostos
subdiretórios.
-v --verbose Exibe o processo de descompactação.
No exemplo a seguir, o comando gunzip foi utilizado para descompactar um arquivo

que foi gerado com o gzip:
4.1.83. bunzip2
O comando bunzip2 é utilizado apenas para descompactar arquivos, e tem exatamente
a mesma função do comando bzip2 –d. A sintaxe do bunzip2 é a seguinte:
bunzip2 [opcoes] [arquivo]
A tabela a seguir descreve as principais opções utilizadas com bunzip2:
Opção Opção
Descrição
Unix GNU
Não descompacta o arquivo original, porém o resultado
-c --stdout da descompactação será enviado para a saída padrão
(tela), e geralmente redirecionado para um novo arquivo.
Força a descompactação de um arquivo, por exemplo, se

-f --force
existe um arquivo de mesmo nome já descompactado.

-v --verbose Exibe o processo de descompactação.
226
No exemplo a seguir utilizamos o bunzip2 para descompactarmos um arquivo criado
pelo bzip2:
4.1.84. Considerações sobre backup de dados

O comando dd é eficiente nas operações de backup, especialmente para copiar
discos ou partições inteiras e imagens de mídias como CDs e DVDs. O dd faz uma
cópia sequencial de dados, byte a byte, de qualquer origem para qualquer destino.
Sua utilização inadequada, porém, pode causar sérios danos ao sistema. Portanto, é
necessário ter cautela ao utilizá-lo.
No exemplo a seguir, o comando dd faz uma cópia fiel do HD master primário (hda)
para o HD slave primário (hdb):
dd if=/dev/hda of=/dev/hdb
Já neste outro exemplo, o comando dd copia o setor MBR (Master Boot Record) para
um arquivo. O MBR localiza-se nos primeiros 512 setores do disco.
Entre os tipos de backup que podemos realizar no sistema, diferem-se o backup

completo, incremental e diferencial.
O backup completo salva todos os dados, independentemente de já terem sido salvos

ou não em backups anteriores, portanto os objetos são armazenados completamente.
Os backups incremental e diferencial podem ser definidos pela sua relação com o
último backup completo realizado. O backup incremental salva as diferenças em
relação ao backup completo, de forma que serão salvos, em cada backup incremental,
os dados adicionais ao último backup completo. Assim, caso sejam feitos três backups
incrementais, em momentos 1, 2 e 3, o primeiro salvará os dados do backup completo
até o momento 1; o segundo salvará do backup completo até o momento 2; já o
terceiro cobrirá os dados do backup completo até o momento 3.
227
O backup diferencial gera um volume menor de dados, pois, usando o mesmo

esquema que usamos para o backup incremental, caso sejam realizados três backups
diferenciais, em momentos 1, 2 e 3, o primeiro deles salvará os dados do backup
completo até o momento 1; o segundo salvará os dados do momento 1 ao momento
2; ao terceiro restarão os dados do momento 2 ao momento 3.
Dicas LPI
•• O Inode é uma estrutura que é responsável por conter informações básicas
sobre seus arquivos e pastas, como permissões de acesso, identificação
dos donos dos arquivos, data e hora do último acesso, alterações, tamanho
e o mais importante: os famosos ponteiros para o arquivo em si. De modo
geral, o Inode é a identidade de um arquivo ou diretório, é uma identificação
única para ele;
•• É importante lembrar que o parâmetro -i do ls permite verificar as informações

de Inodes por objeto no sistema;
•• A grande maioria dos comandos básicos deve formar sua base sólida de
conhecimento e, certamente, será necessária para resolver problemas. O
touch, além de criar arquivos, pode mudar alguns campos da timestamp,
como hora e tempo;
•• Uma opção do comando cp, muito útil em nosso dia a dia, é -p, que faz com
que a cópia mantenha dois arquivos, ou seja, não modifica a data e hora de
criação, seus donos e nem suas permissões;
•• Apesar de parecerem simples, os comandos head e tail fornecem opções de

valiosa utilidade. Um grande exemplo é usar a opção -f no tail para verificar
logs em tempo real;
•• Alguns outros comandos de filtros que também podem ser encontrados no

GNU/Linux são: egrep, ngrep e pgrep;
•• O comando awk é um primo do cut, mas possui mais recursos e opções

para expressões regulares. Há situações nas quais o cut não conseguirá
resolver o problema, para elas use awk;
•• A maioria desses comandos é bastante simples de ser utilizada e possui

poucos parâmetros, entretanto, alguns como awk, sed, fnd, grep, xargs,
uniq, join, paste e cut possuem manuais bastante extensos, dada a
quantidade de tarefas que podem realizar. Dessa forma, a leitura de suas
páginas de man é extremamente importante e recomendável.
228
4.2. Gerenciando processos no sistema
Em sistemas Unix-like, o gerenciamento de processos seguirá um modelo padrão, que
poderá ser utilizado em todos os sistemas operacionais que seguem o padrão POSIX.
Processos são a base do sistema operacional e são controlados de forma direta

pelo próprio kernel, que faz um bom gerenciamento, além de proporcionar muita
confiabilidade.
Algumas aplicações, entretanto, nem sempre são desenvolvidas de acordo com os

padrões POSIX de gerenciamento de processos e, consequentemente, apresentam
algum tipo de anomalia que está fora do controle do próprio kernel. Saber controlar
de forma manual o funcionamento desses processos, portanto, é essencial para obter
o controle real do sistema operacional e resolver problemas provenientes da má
utilização ou desenvolvimento.
Primeiramente, é importante definir o que é um processo. Um processo pode ser

um programa ou comando que, ao ser executado, passa a consumir determinados
recursos do sistema e de hardware. Sempre que houver o consumo de algum tipo de
recurso por parte de alguma aplicação, programa, comando etc., teremos, então, um
processo.
Controlar o funcionamento de um processo junto ao kernel é importante para o

administrador do sistema. Contudo, antes de controlá-lo, é preciso obter a lista de
todos os processos em execução no sistema, para posteriormente realizar algum tipo
de gerenciamento específico, como finalizar sua execução, parar temporariamente,
dedicar mais atenção aos recursos consumidos para tal processo ou minimizar tais
recursos.
4.2.1. Principais propriedades de um processo

Para melhor definirmos um processo e iniciarmos seu gerenciamento, serão abordadas
as seguintes propriedades:
229
•• Estado
Todo processo em execução tem um tipo de estado que o define. Por meio desse
estado, é possível compreender em qual ciclo de execução tal processo se encontra,
uma vez que os processos têm um ciclo de vida em que nascem, executam suas
funções e morrem, caso não tiverem mais utilidade ao terminá-las.
Os principais estados são:
Estado Descrição
O processo se encontra em execução atualmente e consumindo
Running
recursos.
O processo se encontra parado, não consumindo nenhum tipo de
Stopped
recurso até que seja liberado para Running novamente.
Enquanto não é solicitado, o processo fica hibernando e, portanto,
Sleeping
não consome recursos.
O processo fica travado, não executa sua função, porém, continua
Zombie
consumindo algum tipo de recurso.
•• Recursos
A principal definição de um processo é o consumo de determinados recursos, dos quais

ele necessita. É importante ressaltar que os recursos nem sempre serão consumidos,
pois temos uma variação em relação ao seu estado. Esses recursos podem ser de
hardware (memória, processador etc.), e até recursos do próprio sistema (bibliotecas
ou funções do próprio kernel).
•• Proprietário
Os processos terão donos, que poderão intervir na forma como estão sendo
executados no sistema e também gerenciar seu funcionamento. É importante ressaltar
que usuários comuns só podem gerenciar os seus próprios processos, não sendo
permitido que eles modifiquem o funcionamento dos processos de outros usuários
ou do sistema. O usuário root, que é o administrador, terá permissão para gerenciar
qualquer tipo de processo em execução no sistema.
•• Prioridade
Os processos, quando em execução, terão certos tipos de prioridades, que serão

definidos pela quantidade de recursos disponíveis para esses processos. Logo, quanto
maior a prioridade, maior será a quantidade de recursos disponíveis.
Sendo assim, a prioridade é uma propriedade também gerenciável e poderá ser

controlada, aumentando ou diminuindo recursos para os processos, por meio de um
intervalo específico utilizado para definir essa prioridade.
230
•• Número de identificação
Para gerenciar os processos, como o estado em que se encontram ou até mesmo suas
prioridades de execução, é preciso identificá-los por meio de um número, atribuído
em seu início. Esse número de identificação é conhecido como PID (Process Identifier).
Atribuído pelo próprio kernel, ele não pode ser utilizado por mais de um processo ao
mesmo tempo, mas pode ser reaproveitado posteriormente.
Além do PID, existe outra notação, chamada PPID (Parent Process Identifier), que
corresponde ao número do processo pai do processo atual. Processos são executados
em cadeia, desde o momento inicial do carregamento do sistema, no qual o primeiro
processo, de nome init e com PID 1, é carregado. Em uma relação de processo pai e
processo filho, um processo pode gerar outros processos, estabelecendo, assim, um
vínculo direto entre eles. Sobre essa relação, temos:
O processo filho depende, de forma direta, de seu processo pai; assim, se o processo
pai parar por algum motivo, o processo filho também tem sua funcionalidade
interrompida. Entretanto, se o processo filho parar, o processo pai continuará seu
funcionamento normalmente. Essa relação é atribuída a todos os processos em
funcionamento.
4.2.2. Listando processos
Para listar e obter informações sobre os processos em execução no sistema, dispomos
de diversos comandos. Por meio deles, podemos obter qualquer tipo de informação
relacionado aos processos em execução, como PID, estado, prioridade de execução etc.
231
4.2.3. ps
O comando ps é utilizado apenas para obter informações sobre os processos que
estão sendo executados no sistema. Há várias informações que poderão ser obtidas
por meio deste comando, além dos simples nomes dos processos em execução,
PID, donos, prioridades, tempo de execução, entre outros. É um comando completo,
que trabalha com as opções Unix, BSD e GNU para manter uma padronização para
administradores que trabalham com outros sistemas Unix-like.
ps [opcoes]
A utilização do comando ps sem qualquer opção exibe apenas os processos que

estão em execução a partir do terminal em que foram executados. Para se obter uma
lista mais abrangente dos processos que estão sendo executados a partir de outros
terminais (e até mesmo processos de sistema, como daemons), utilizamos as opções
do comando ps.
O cuidado que se deve ter com o comando ps baseia-se na imensa quantidade de

opções que ele possui, justamente por aceitar os sistemas Unix, BSD e GNU. A opção
Unix -a, por exemplo, é bem diferente da opção BSD a.
Outra característica importante do comando ps, que também está ligada, de forma
direta, à grande quantidade de opções, é a quantidade de informações que podem
ser obtidas em sua execução. As informações são divididas em colunas, e cada opção
poderá exibir colunas contendo informações específicas.
Sobre as principais colunas de informações, temos:
Coluna Descrição
USER Nome do usuário dono do processo.
UID Número de identificação (UID) do usuário dono do processo.
PID Número de identificação do processo.
PPID Número de identificação do processo pai.
%CPU Porcentagem do processador em uso.
%MEM Porcentagem da memória em uso.
VSZ (Virtual Size) Tamanho virtual do processo.
RSZ (Resident Set
Indica a quantidade de memória utilizada (em kilobytes).
Size)
Nome do terminal associado ao processo. Caso o valor seja
TTY interrogação (?), o processo é daemon, e sua execução é
independente de um terminal.
232
Coluna Descrição
START Hora em que o processo foi iniciado.
TIME Tempo de processamento consumido pelo processo.
NI Valor de prioridade ajustado pelo comando nice ou renice.
PRI Prioridade real do processo, controlado pelo próprio kernel.
Define o estado do processo, em que temos os valores:
•• D: Processo hibernando, mas com dificuldades para

voltar a executar suas funções;
•• R: Executando;
•• S: Dormindo, suspenso;
•• T: Parado;
•• X: Processo finalizado;
•• Z: Processo Zombie, travado.

STAT
Complementares:
•• >: Processo sendo executado com prioridade maior

que o normal;
•• N: Processo sendo executado com prioridade menor

que o normal;
•• L: Processo com algum tipo de recurso bloqueado na

memória;
•• s: Líder de sessão;
•• +: O processo está sendo executado em primeiro

plano.
233
A tabela a seguir apresenta as opções utilizadas com o comando ps:
Opção
Opção Unix Opção BSD Descrição
GNU
Exibe uma lista completa dos
processos em execução (daemons
-A / -e
e processos ligados a algum
terminal).
Exibe apenas uma lista dos
processos ligados a um terminal,
-a
exceto processos líderes de sessão
(processos pal).
Exibe uma lista dos processos
A ligados a um terminal, incluindo
processos líderes de sessão.
Exibe uma lista completa dos
-d processos em execução, exceto
processos líderes de sessão.
Exibe apenas os processos que têm
R
o estado Running.
-C Exibe informações do processo que
<processo> tenha o nome especificado.
--group Exibe informações dos processos
-g<nome>
<nome> do grupo de nome especificado.
--user Exibe informações do processo que
-u<grupo> U <grupo>
<grupo> pertença ao usuário especificado.
Exibe informações do processo que
-p<pid> <pid> --<pid>
tenha o PID especificado.
Exibe informações dos processos
T --tty
-t<terminal> que estão sendo executados no
<terminal> <terminal>
terminal de nome especificado.
j/l/u/v Exibe mais formatos de colunas na
-F
/x listagem dos processos.
Define manualmente o formato de
colunas desejado na visualização de
o --format informações dos processos. Sobre
-o<coluna>
<coluna> <coluna> as possíveis colunas, podemos
acompanhar a próxima tabela, ou
executar o comando ps L.
234
Opção
Opção Unix Opção BSD Descrição
GNU
Exibe a listagem de processos em
-H
formato hierárquico.
Exibe o nome dos formatos
L de coluna visualizáveis com o
comando ps.
A tabela adiante apresenta os formatos específicos de colunas, que podem ser

utilizados com a opção -o, o ou --format:
Coluna Descrição
%cpu Exibe a coluna de controle de porcentagem de processador em uso.
%mem Exibe a coluna de controle de porcentagem de memória em uso.
command Exibe a coluna com o nome do processo em execução.
Exibe a coluna, especificando o nome dos grupos que estão
group
relacionados ao processo.
Exibe a coluna de valor de prioridade ajustado pelos comandos nice
nice
e renice.
Exibe a coluna com o valor de prioridade real do processo, controlado
pri
pelo próprio kernel.
rsz Exibe a coluna com a quantidade de memória utilizada pelo processo.
start Exibe a coluna com a hora em que o processo iniciou sua execução.
stat Exibe a coluna com o estado de execução do processo.
time Exibe a coluna com o tempo de consumo de recursos pelo processo.
Exibe a coluna com o nome do terminal ao qual o processo está
tty
associado.
uid Exibe a coluna com número de UID relacionado ao dono do processo.
user Exibe a coluna com o nome do usuário dono do processo.
vsz Exibe a coluna com o tamanho virtual do processo.
235
Vejamos o exemplo a seguir:
No primeiro exemplo, o comando ps foi executado sem nenhuma opção, trazendo

como resultado apenas os processos em execução no terminal atual. Já no segundo
exemplo, o comando ps foi executado com duas opções BSD, trazendo informações
mais detalhadas sobre os processos em execução em todo o sistema. No último
exemplo, o comando ps foi executado com a opção de controle de colunas,
selecionando somente as informações desejadas.

Execute o comando ps aux e verifique que ele traz informações de todos os processos
em execução.
Adicione a opção f e perceba que é possível visualizar quem são os processos pai e
filho. Dessa forma, fica mais fácil finalizar ou gerenciar toda uma árvore de processos.
Para visualizar a lista de opções disponíveis, basta executar o comando ps --help,

como mostrado a seguir:
236
Já com o comando ps –e f, é possível visualizar os processos de uma forma mais
organizada e com seus respectivos processos filho:
Por fim, o comando ps –l NI f é executado para exibir os processos por ordem de

prioridade, mas sem perder a facilidade de visualizar os filhos desses processos:
4.2.4. pidof
O comando pidof é utilizado para verificar o PID de um processo em execução, caso
o nome do processo seja especificado. Se nenhum processo for indicado, o comando
informará o PID de todos os processos em execução. Sua sintaxe é a seguinte:
pidof [opcoes] [programa]
Descrevemos opções da sintaxe anterior na tabela a seguir:
Opção Descrição
-s Leva o comando a retornar somente o primeiro PID encontrado.
Retorna somente o PID de processos localizados num mesmo
diretório raiz. Como usuários comuns não têm acesso a informações
-c
relacionadas a processos dos quais eles não são donos, esta opção
só tem funcionalidade para o superusuário.
Retorna o PID de shells que estejam executando os processos
-x
especificados.
Os processos cujo PID sejam informados serão omitidos no retorno
-o
do comando.
237
No exemplo a seguir, o comando pidof é utilizado para descobrir o PID do processo

sshd:
4.2.5. pstree
Com o comando pstree, os processos em andamento no sistema são mostrados no
formato de árvore genealógica, com ligações entre processos pai e processos filho.
Sem argumento nenhum, o comando mostrará todos os processos existentes. Porém

é possível determinar quais processos serão visualizados, com a sintaxe seguinte:
pstree [opcao] [PID ou usuario]
Em conjunto com o comando less, a saída do comando pstree pode ser melhor
visualizada, já que os diagramas em forma de árvore são geralmente grandes demais
para exibição em uma tela só. Com o comando less, a saída será exibida em telas
diferentes e pode ser navegada com a Barra de Espaço e a tecla B, que avançam e
retornam a visualização respectivamente.
A seguir, veremos algumas opções possíveis com o comando pstree:
Opção Descrição
-p Exibe os PIDs dos processos.
Destaca em negrito o processo atual e seus ancestrais, caso esse
-h
destaque seja suportado pelo sistema.
Leva a árvore a ser organizada por ordem de PID, em vez da ordem
-n
alfabética padrão.
Exibe, entre parênteses, os proprietários dos processos, a menos que
-u
sejam filhos de processos de um mesmo proprietário.
Impede o truncamento de informações em árvores cuja exibição não
-l
caiba na largura da tela.
Exibe os argumentos da linha de comandos dos processos iniciados
-a
por um usuário, e não por outro processo.
4.2.6. top
O comando top também é utilizado para obter informações dos processos que estão
sendo executados e ainda exibe as informações dos processos em tempo real, em
nível de monitoramento, sendo possível obter praticamente todas as informações que
o comando ps exibe.
238
top [opcoes]
Outra característica do comando top é que, por meio dele, é possível gerenciar os
processos do estado de execução em que se encontram, e até mesmo suas prioridades.
A imagem a seguir ilustra sua utilização:
O top possui um cabeçalho repleto de informações do sistema e de sua utilização,

além de exibir uma lista de processos organizados por consumo de processamento,
memória etc. Como a exibição dos processos é dinâmica, por meio da organização
anteriormente citada, os processos ficarão separados por páginas. O comando top
trabalha com dois tipos de opções: opções externas, passadas no momento da
execução do comando top, e opções internas, que terão efeito com o top já em
execução. A seguir, abordaremos de forma detalhada esses tipos de opções:
•• Opções externas
Opção externa Descrição

Define um tempo, em segundos, para a atualização das
-d<segundos>
informações dos processos pelo top.
Ignora processos em estado Zombie na exibição da lista de
-i
processos no top.
Exibe apenas os processos que pertencem ao usuário de
-u<usuário>
nome especificado.
-p<pid> ... Inicia o top, monitorando apenas os processos de PID indicado.
239
•• Opções internas
Opção
Descrição
interna
<enter> ou Atualiza o tempo de monitoramento dos processos no momento
<espaço> desejado, sem que seja preciso aguardar a atualização automática.
<h> ou <?> Carrega o menu de ajuda do top.
<B> Desabilita o recurso de destaque em negrito do top.
Redefine o tempo, em segundos, para a atualização automática
<d> ou <s>
das informações dos processos monitorados pelo top.
Determina que sejam monitorados apenas os processos que
<u> ou <U>
pertencem ao dono especificado.
<q> Sai do top.
Define um novo valor nice de prioridade ao processo de PID
<r>
especificado.
<Z> Altera as cores da janela do top.
Salva, de forma permanente, as possíveis alterações feitas no top
<W> com os comandos anteriormente apresentados, deixando essas
configurações salvas como padrão.
Desabilita ou habilita informações de tempo de execução do
<l> sistema e a quantidade de usuários autenticados que aparecem
no cabeçalho do top.
Desabilita ou habilita informações de memória que aparecem no
<m>
cabeçalho do top.
Desabilita ou habilita informações de processos e consumo de
<t>
processador que aparecem no cabeçalho do top.
<z> Desabilita ou habilita o top monocromático.
<n> / <#> Define uma quantidade de processos por página.
Comandos para classificação dos processos no top, em que:
•• M: Classifica por uso de memória;

<M> / <N> /
•• N: Classifica por PID;
<P> / <T>
•• P: Classifica por uso de processador;
•• T: Classifica por tempo de uso de processamento.

<k> Envia sinais a processos, pelo número de PID.
240
4.2.7. htop
O comando htop é semelhante ao comando top anteriormente apresentado, porém,
apresenta mais interatividade e controle sobre os processos em execução.
htop [opcoes]
A tabela a seguir descreve algumas opções utilizadas com htop:

Especifica um tempo, em segundos, para a atualização
-d <segundos>
automática do htop.
Especifica um nome de usuário que terá todos os processos
-u <usuário>
monitorados pelo htop.
No rodapé da página exibida com a execução de htop, há um menu de comandos

com a descrição das suas principais funções, conforme ilustra a imagem a seguir:
241
4.2.8. Controlando o nível de execução dos

processos
Os infinitos processos que estão em execução no nosso sistema são classificados
pelo nível em que estão sendo executados. Sobre as classificações de níveis, temos
Foreground (primeiro plano) e Background (segundo plano).
A maioria dos programas, ou seja, processos que estão em execução no sistema, é

executada em segundo plano (Background), o que significa que não prendem nenhum
terminal durante sua execução. Já os programas em primeiro plano (Foreground),
como top e less, quando executados, prendem o terminal, tornando-o indisponível
para uso até que sejam finalizados.
É possível gerenciar o plano em que os programas se encontram, permitindo que

estes transitem de um plano a outro. Para gerenciar esses processos dessa maneira,
existem comandos específicos. Também é possível obter uma lista dos processos que
estão em execução em segundo plano.
4.2.9. CTRL + Z
Uma vez que o programa está sendo executado em primeiro plano, prendendo o
terminal atual, é possível enviá-lo para segundo plano, sem precisar finalizar sua
execução, utilizando o atalho CTRL + Z.
Ao enviar um processo para o segundo plano com a sequência de teclas CTRL + Z, seu
estado é alterado para Stopped (parado), e, por meio do comando bg (apresentado
logo a seguir), torna-se possível alterar o estado desse processo de Stopped para
Running (executando).
A imagem a seguir ilustra a utilização do atalho CTRL + Z:
4.2.10. &
Outra forma de enviar um processo para segundo plano é no momento de sua execução,
bastando apenas incluir o caractere & no final do comando que será executado. Isso
permite que o processo seja imediatamente enviado para segundo plano, em estado
Running, sem precisar utilizar algum outro comando para tal função. É a forma mais
prática de enviar programas ao segundo plano.
<programa> &
242
A imagem adiante esboça essa ação:
No exemplo anterior, assim que o programa é executado, ele já é enviado

automaticamente para segundo plano, porém, sem alterações em seu estado de
execução, como poderemos acompanhar no comando jobs apresentado a seguir,
que lista os processos executados em segundo plano.
4.2.11. jobs
É possível enviar vários programas para o segundo plano e, para obter uma lista
dos programas que estão em execução no segundo plano e seu respectivo estado,
utilizamos o comando jobs. Sua sintaxe é a seguinte:
jobs [opcoes]
A tabela a seguir mostra opções que podem ser usadas com o jobs:
Opção Descrição
-p Exibe somente o número de PID dos processos em segundo plano.
Além de exibir as informações normais dos processos em segundo
-l
plano, exibe também o número de PID de cada um desses processos.
Todo programa enviado ao segundo plano ganha um número de controle de acordo

com a ordem que ele foi enviado para o segundo plano. Esse número não tem relação
direta com o PID e pode ser utilizado para trazer tal processo, que atualmente está
em execução no segundo plano, novamente para o primeiro plano. O número de
controle, também conhecido como job, poderá ser utilizado para alterar o estado de
programas que estão em segundo plano, de Stopped para Running, por intermédio
do comando bg.
O exemplo a seguir ilustra o uso de jobs:
243
4.2.12. Comando bg
O comando bg é utilizado para alterar o estado de um processo que se encontra em
segundo plano, de Stopped para Running. Também é possível fazer referência aos
processos em segundo plano pelos seus respectivos nomes, porém, isso pode gerar
problemas, caso processos em segundo plano tenham nomes idênticos. A sintaxe de
bg é a seguinte:
bg [job]
Vejamos a imagem a seguir:
O exemplo anterior nos mostra a utilização do comando bg, em que havia um processo
de ordem [1], em segundo plano, em estado Stopped. Após a execução do comando
bg em tal processo, ele teve seu estado alterado para Running.
4.2.13. Comando fg
O comando fg tem a finalidade de trazer um programa de volta ao primeiro plano,
deixando seu estado em Running, independentemente de seu estado em segundo
plano. Também é possível utilizar o nome do processo para executar tal tarefa, porém,
problemas podem ocorrer caso existam processos com nomes idênticos no segundo
plano.
A sintaxe de fg é a seguinte:
fg [job]
A imagem a seguir ilustra a utilização do comando fg:
244
4.2.14. Alterando o comportamento dos processos
Após conhecermos comandos que nos permitem obter informações sobre os processos
em execução, abordaremos o gerenciamento avançado de processos, que lida com o
envio de sinais e permite alterar o comportamento desses por meio de modificações
em seus estados de execução ou prioridade.
4.2.15. kill
O comando kill é utilizado para enviar sinais aos processos que estão sendo executados
pelo sistema. Esses sinais poderão mudar o comportamento dos processos de diversas
maneiras, podendo encerrá-los, pará-los ou até mesmo reiniciá-los. Sua sintaxe é a
seguinte:
kill [-sinal] <pid1> <pid2> ...
Para visualizarmos a lista completa de sinais que poderão ser utilizados pelo comando
kill, devemos digitar kill -l. A tabela a seguir descreve os principais sinais utilizados
com o comando kill no envio de processos:
Sinal Código Descrição

Reinicia um serviço (daemon) apenas relendo seu arquivo
SIGHUP 1
de configuração.
SIGKILL 9 Finaliza um processo de forma forçada.
Finaliza um processo de forma normal, não forçando ou
SIGTERM 15
comprometendo a funcionalidade.
SIGCONT 18 Inicia um processo que esteja em estado Stopped.
SIGSTOP 19 Para momentaneamente a execução de um processo.
Caso nenhum sinal seja especificado ao comando kill para envio a algum processo
pelo PID, o sinal padrão de envio será o SIGTERM.
No exemplo a seguir, após localizar o número de PID relacionado ao programa cron,

foi enviado o sinal SIGKILL a ele:
245
4.2.16. killall
O comando killall é muito parecido com o comando kill anteriormente apresentado.
Ele envia aos processos exatamente os mesmos tipos de sinais que o comando kill.
A diferença, entretanto, é que o comando killall faz referência aos processos pelo
nome, e não pelo número de PID.
killall [opcoes] [-sinal] <processo> <processo> ...
Caso nenhum sinal seja especificado ao comando killall, o sinal padrão SIGTERM é
enviado ao processo de nome especificado.
A forma de envio de sinais é exatamente a mesma do comando kill. O comando killall

trabalha com algumas opções interessantes, conforme veremos a seguir:

-I (“i” Desabilita a característica case sensitive do
--ignore-case
maiúsculo) nome do processo informado.
Questiona se o sinal especificado pode ser
-i --interactive
enviado ou não ao processo.
Envia o sinal determinado a todos os processos
-u <usuário> --user
pertencentes ao usuário especificado.
Reporta informações do envio de sinal ao
-v --verbose
processo especificado.
É necessário atentar para a utilização do comando killall, pois, caso haja processos com
nomes idênticos em execução no sistema, todos eles receberão o sinal especificado.
4.2.17. nice
O comando nice é capaz de trabalhar com o gerenciamento das prioridades dos
processos a serem executados, podendo inicializar um processo com a prioridade
desejada. A prioridade a ser definida segue o padrão adiante:
246
nice [opcoes [prioridade]] [comando]
A principal opção utilizada com o nice é -n <propriedade>, que define a prioridade

conforme o intervalo permitido. A opção GNU equivalente é ---adjustment=
<prioridade>.
Vejamos:
No exemplo anterior, executamos o comando sleep, já com seu valor de prioridade

alterado para 10. Com o comando ps, note que já existia um outro comando sleep
sendo executado, porém com a prioridade padrão 0.
4.2.18. renice
O comando renice também é utilizado para gerenciar prioridades, porém ele tem a
capacidade de alterar a prioridade de processos que já estão em execução no sistema.
Essa alteração é feita em tempo real, com o processo em execução, e a alteração da

prioridade também deve estar de acordo com o intervalo apresentado anteriormente.
renice <prioridade> [opcoes]
A tabela a seguir descreve as principais opções utilizadas com renice:
Opção Descrição
Indica um nome de grupo para alterar todos os processos
-g <grupo>
relacionados a ele.
Indica um nome de usuário para alterar a prioridade de todos os
-u <usuário>
seus processos.
-p <pid> Indica o número de PID cuja prioridade se pretende alterar.
Usuários comuns podem gerenciar apenas a prioridade de seus próprios processos.
247
Considerando que o processo já esteja sendo executado com a prioridade -10, vamos
utilizar o comando renice para reestabelecer o valor de prioridade 0, do processo
sleep, como exibido a seguir:
Para visualizar o resultado da alteração, basta executar o comando ps novamente.
4.2.19. nohup
nohup <comando>
O comando nohup é utilizado para ignorar sinais do tipo SIGHUP enviados a um

determinado processo, em alguma circunstância. Podemos tomar como exemplo um
programa que esteja em execução no segundo plano de um terminal qualquer e
que poderá continuar sua execução mesmo após o encerramento desse terminal,
transformando, indiretamente, o programa em um daemon.
O comando nohup foi herdado do Unix. Atualmente, os interpretadores de comandos

mais conhecidos, como o Bash, já trazem algumas implementações automatizadas,
que não permitem que os processos em segundo plano sejam finalizados, mesmo
após o encerramento de uma sessão.
As saídas geradas pelo processo que foi iniciado com o comando nohup serão
armazenadas (por padrão) em um arquivo de nome nohup.out, que é gravado no
mesmo diretório em que o comando nohup foi inicializado.
A imagem seguinte ilustra essa possibilidade:
No exemplo anterior, o comando ping foi executado junto com o comando nohup,
permitindo, assim, que ele se torne imune ao sinal SIGHUP.
248
4.2.20. screen
Esse programa é utilizado para trabalhar com vários terminais multiplexados, ou
seja, você poderá iniciar um processo em um determinado terminal e monitorá-lo por
outro. Quando você executa dentro de um login SSH remoto, você pode criar várias
novas janelas, todas na mesma sessão, alternar entre elas, ou visualizar de duas ou
mais de uma vez.
Todos os programas continuarão funcionando e você pode posteriormente reconectar

e retomar exatamente de onde parou, pois ele lhe permite começar a execução de
programas, deixá-los em execução em segundo plano e, mais tarde, voltar a eles.
O comando screen deverá ser instalado tanto no CentOS quanto no Debian.
Uma sessão é criada conforme o comando adiante:
screen –S TOP
Execute o comando top. Depois, execute o atalho CTRL + A e, então, aperte a tecla A
, para que o prompt seja apresentado novamente.
Liste as sessões disponíveis:
screen -ls
Você poderá se desconectar desse terminal atual e conectar-se em outro. Com isso,
liste novamente as sessões do screen e abra a sessão de nome TOP.
Perceba que, mesmo você encerrando a sessão onde o top foi criado, ele continua em
execução, podendo ser aberto por qualquer outro terminal.
4.2.21. pgrep
Executa um filtro sobre a saída do comando ps, exibindo apenas os PIDs do comando
informado. Permite ainda que sejam executados filtros adicionais como apenas os
processos de um comando executado por um usuário específico.
Opção Descrição
-l Lista o PID e o comando localizado com base no filtro.
-u <usuário> Lista os processos relativos ao usuário informado.
Somente exibe os processos que casem exatamente com o
-x
padrão informado.
249
Para listar os processos e seus comandos correspondentes:
pgrep –l ssh
Para listar os processos do usuário root que combinem com ssh:
pgrep –l –u root ssh
4.2.22. pkill
Permite a finalização de processos baseado no padrão de pesquisa informado. Funciona
de forma análoga ao comando pgrep e aceita uma lista reduzida de parâmetros.
Finalizando todos os processos do serviço sshd pelo nome (-x):
pkill -9 –x sshd
Dicas LPI
•• Uma listagem completa dos sinais possíveis pode ser vista na seção
STANDARD SIGNALS do man 7 signal. Alguns dos sinais mais utilizados
pelo kill podem ser vistos a seguir:
- SIGHUP (1) Term Hangup detected on controlling terminal or death

of controlling process;
- SIGKILL (9) Term Kill signal;
- SIGTERM (15) Term Termination signal;
- SIGCONT (18) Continue if stopped;
- SIGSTOP (19) Stop process.
•• No diretório /proc você verá diversos arquivos com informações gerais que
o kernel nos fornece, por exemplo os arquivos: cpuinfo, ioport, memstat,
interrupts, mounts e swaps. Com o comando free, conseguimos ver
a quantidade de swap e memória utilizadas, e com o comando uptime,
conseguimos ver o tempo que a máquina está ligada;
•• Para rodar um comando, um script ou um programa em Background, é só

acrescentar o caractere & ao final do comando.
250
4.3. Editor de texto vim
O editor de textos vim (vi improved) é um dos editores de textos mais utilizados
atualmente. O vim é o sucessor do antigo vi, porém muitos sistemas criam alias
(apelidos) para o vim, fazendo com que ele seja referenciado pelo nome vi.
Sendo assim, o editor pode ser facilmente identificado simplesmente por vi, mas é
importante lembrar que sua utilização é extremamente diferente, comparando as
versões atuais do vim e o vi na versão antiga. Essa convenção de nomenclatura facilita
seu acesso e utilização, uma vez que o antigo vi caiu em desuso.
vim [opcoes] [arquivo]
A seguir, temos a tela inicial do editor vim:
Um dos motivos que tornam o vim um editor de textos útil e prático é o seu formato
e interface de comunicação final, que, para o principiante, é um pouco confusa, mas,
após o seu entendimento, é facilitadora. O vim é um editor de textos que poderá
ser utilizado diretamente na linha de comandos, porém, também existem versões
do vim para trabalhar no ambiente gráfico e até versões para sistemas operacionais
diferentes da base GNU/Linux.
Outro recurso interessante do vim é o Syntax Highlight, que é uma coloração

especial da sintaxe nos arquivos. Tais arquivos, como os de configuração ou código-
fonte de várias linguagens, poderão receber uma coloração especial para sua melhor
identificação.
251
4.3.1. Modos de comandos e de edição

Uma particularidade sobre o editor de textos vim, que é essencial para o nosso
aprendizado, é entender internamente seus modos de trabalho, que são basicamente
dois: modo de comandos e modo de edição. Essa divisão é extremamente importante,
pois define o funcionamento básico do vim, e sua manipulação eficaz se dá pela boa
alternância entre esses modos. Sobre os modos de utilização do vim temos:
•• Modo de comandos
A maioria das teclas terá uma funcionalidade específica, como se cada uma delas fosse
um determinado comando que executará uma tarefa. Ou seja, no modo de comandos,
o vim é utilizado para manipular o arquivo, podendo executar tarefas de automação,
como copiar ou apagar uma sequência de linhas, ou tarefas de gerenciamento do
próprio arquivo, como salvar o arquivo simplesmente ou salvá-lo com nome e caminho
diferentes etc.
•• Modo de edição
É exatamente neste modo que o vim trabalhará como um editor de textos comum, no
qual as teclas terão suas funcionalidades reais e o texto poderá ser completamente
redigido ou alterado no formado desejado.
Saber alternar entre esses dois modos é essencial para executar qualquer tarefa
utilizando o editor de textos vim.
4.3.2. Utilizando o vim
O vim poderá ser inicializado diretamente na linha de comandos, a partir da digitação
da palavra vim simplesmente. Nesse modo de carregamento, o vim irá inicializar
com um arquivo novo e ainda sem nome. Mas também é possível inicializá-lo com um
arquivo já existente e a indicação de seu nome ou do caminho completo, caso seja
necessário, como no exemplo a seguir:
Independentemente da forma como o vim foi inicializado, com um arquivo novo ou

um arquivo existente, ele sempre será inicializado em modo de comandos, no qual o
arquivo ainda não poderá ser definitivamente redigido ou alterado. Para tal função, é
preciso alternar para o modo de edição, sobre o que falaremos a seguir.
A tabela a seguir descreve opções que podemos utilizar para iniciarmos o vim:
Opção Descrição
+ Inicia o vim com o cursor no final do arquivo.
+<linha> Inicia o vim com o cursor na linha de número determinado.
252
4.3.3. Alternando entre o modo de comandos e o
modo de edição
O vim é sempre iniciado, por padrão, em modo de comandos, porém é possível
alternar tranquilamente para o modo de edição e, posteriormente, voltar para o modo
de comandos, e vice-versa.
•• Entrando no modo de edição
Comando Descrição
i / <INSERT> Entra no modo de edição, mantendo o cursor na posição original.
Entra no modo de edição, movendo o cursor um caractere à
a
direita de sua posição original.
Entra no modo de edição, inserindo uma nova linha abaixo da
o
posição original do cursor.
•• Entrando no modo de comandos
Basta pressionar ESC para retornar ao modo original de comandos.
4.3.4. Gerenciando arquivos
Depois que um determinado arquivo foi criado ou editado com o vim, também é
preciso conhecer alguns comandos para gerenciar o arquivo em si, por exemplo,
salvando alterações feitas ou simplesmente descartando-as. No modo de comandos,
temos a possibilidade de utilizar outros tipos de comandos, que serão sempre
precedidos pelo caractere : (dois-pontos). O comando passado junto com ele poderá
ser visualizado no rodapé da página do vim, como no exemplo a seguir:
253
A tabela a seguir descreve tais comandos:
Comando Descrição
Sai do vim. Alterações feitas no arquivo, que não foram salvas,
:q
serão questionadas.
:w Salva as últimas alterações feitas.
Tem a mesma função do :w com a diferença de forçar a
:w!
sobrescrição.
:wq Salva as últimas alterações feitas e sai do vim.
:q! Sai sem salvar qualquer alteração feita no arquivo.
Salva o arquivo com o nome <nome-arq>. Como não foi
:w <nome-arq> especificado o caminho, o arquivo será salvo no diretório atual,
no qual o vim foi carregado.
Insere o conteúdo do arquivo de nome <outro-arq> no arquivo
:r <outro-arq>
atual, a partir da posição original do cursor.
Alterna a edição do arquivo atual para o arquivo de nome <arq-
:e <arq-teste>
teste>.
4.3.5. Automatizando tarefas
Com o vim, também é possível automatizar tarefas de gerenciamento do arquivo,
como copiar, apagar, recortar múltiplas linhas, inserir linhas etc. Vejamos:
Comando Descrição
yy Copia a linha inteira na qual se encontra o cursor.
Copia as <N> próximas linhas, a partir da posição atual do
<N>yy
cursor.
Dd Apaga a linha inteira na qual se encontra o cursor.
Apaga as <N> próximas linhas, a partir da posição atual do
<N>dd
cursor.
Apaga a partir da linha em que se encontra o cursor, até o
Dgg
início do arquivo (primeira linha).
Apaga a partir da linha em que se encontra o cursor, até o
dG
final do arquivo (última linha).
X Apaga um único caractere, no qual o cursor se encontra.
<N>x Apaga <N> caracteres, a partir da posição atual do cursor.
Recorta a linha em que se encontra o cursor e armazena-a no
cc
buffer.
254
Comando Descrição
Recorta <N> linhas, a partir da posição atual do cursor, e as
<N>cc
armazena no buffer.
p Cola o trecho de linhas que foi copiado, apagado ou recortado.
<n>p Cola <n> vezes o que estiver na área de transferência.
V Aciona a seleção visual de linhas.
J Junta a linha atual à seguinte.
u Desfaz a modificação mais recente.
Desfaz todas as modificações feitas na linha em que se
U
encontra o cursor.
Exclui todo o conteúdo da linha a partir da posição atual do
D
cursor.
r Substitui o conteúdo do início da linha em que o cursor estiver.
Substitui o caractere sob o cursor pelo que for colocado no
r<caractere>
lugar de <caractere>.
A Adiciona texto no fim da linha onde se encontra o cursor.
O Insere linha acima da linha atual.
CTRL + H Exclui o último caractere.
:%s/<string1>/
Substitui <string1> por <string2>.
<string2>/g
4.3.6. Navegando pelos arquivos

Também existem comandos específicos para uma movimentação automatizada
dentro do arquivo:
Comando Descrição
gg Move o cursos para a primeira linha.
G Avança para a última linha.
<n>G Avança para a linha N especificada.
$ Avança para o fim da linha atual.
^ Leva o cursor para o primeiro caractere não branco da linha atual.
:<n> Avança para a linha <n>.
CTRL + F Avança para a tela seguinte.
CTRL + B Leva o cursor para a tela anterior.
H Leva o cursor para a primeira linha da tela.
255
Comando Descrição
h Leva o cursor um caractere à esquerda.
M Leva o cursor para o meio da tela.
L Avança para a última linha da tela.
j Avança para a linha seguinte.
k Leva o cursor para a linha anterior.
l Avança um caractere à direita.
w Avança para o começo da próxima palavra.
W Avança para o começo da próxima palavra, separada por espaço.
b Leva o cursor para o começo da palavra anterior.
B Leva o cursor para o início da palavra anterior, separada por espaço.
0 (zero) Leva o cursor para o começo da linha atual.
4.3.7. Realizando buscas
Para realizar buscas por palavras no vim, temos os seguintes comandos:
Comando Descrição
Faz uma busca, pelo texto inteiro, por aquilo que for colocado no
/<palavra>
lugar de <palavra>.
? <palavra> Leva o cursor até a ocorrência anterior à <palavra>.
n Repete o comando / ou ? mais recente.
N Repete, na direção inversa, o comando / ou ? mais recente.
Exibe o nome do arquivo, o número da linha atual e o total de
CTRL + G
linhas do texto.
256
4.3.8. Outros comandos úteis
O vim também traz diversos comandos úteis à utilização, ao gerenciamento e à
automatização do arquivo. A tabela a seguir descreve os principais deles:
Comando Descrição
CTRL + R Refaz as últimas ações dos comandos desfeitos.
. Repete o comando anterior.
N Vai para o próximo resultado da pesquisa.
Executa um comando de nome [comando] e exibe o resultado
:![comando] no arquivo simplesmente, não inserindo tal resultado como
conteúdo dele.
Executa um comando de nome [comando] e insere o resultado
:r![comando]
dele no arquivo atual.
Insere uma numeração de identificação das linhas no arquivo.
:set nu Esta numeração é apenas visual, não sendo inserida no arquivo
original.
:set nonu Desabilita a numeração no arquivo.
:help Inicializa a ajuda do vim.
4.3.9. O arquivo vimrc

O vim possui seu arquivo de configuração, no qual poderão ser ativadas e desativadas
diversas funcionalidades, como o recurso de coloração de sintaxe (Syntax Highlight).
O arquivo de configuração do vim é o /etc/vim/vimrc. Os comentários desse arquivo,
ou seja, as linhas que serão ignoradas pelo arquivo de configuração, são linhas
iniciadas com “ (aspas duplas). A linha que ativa o recurso de coloração é a linha
com o conteúdo syntax on, que vem geralmente comentada, bastando simplesmente
descomentá-la.
Ao descomentar as funcionalidades desejadas, o usuário já está configurando o vim,

bastando copiar, com o nome de .vimrc, o arquivo modificado para seu home.
cp /etc/vimrc ~/ .vimrc
257
Pontos principais
•• O shell é o responsável por fazer a mediação entre o usuário e o computador,

interpretando os comandos enviados. Esses comandos nada mais são do que
instruções que o usuário manda pelo shell para a execução de alguma tarefa;
•• Controlar o funcionamento de um processo junto ao kernel é importante para

o administrador do sistema. Contudo, antes de controlá-lo, é preciso obter
a lista de todos os processos em execução no sistema, para posteriormente
realizar algum tipo de gerenciamento específico, como finalizar sua execução,
parar temporariamente, dedicar mais atenção aos recursos consumidos para tal
processo ou minimizar tais recursos;
•• O editor de textos vim (vi improved) é um dos editores de textos mais utilizados
atualmente. O vim é o sucessor do antigo vi, porém muitos sistemas criam alias
(apelidos) para o vim, fazendo com que ele seja referenciado pelo nome vi.
Sites Endereços
Expressões regulares http://aurelio.net/regex/apostila-conhecendo-regex.pdf
Man online http://man7.org/index.html
Vim http://vimdoc.sourceforge.net/
https://access.redhat.com/documentation/en-US/
Processos Red_Hat_Enterprise_Linux/6/html/Deployment_Guide/
ch-System_Monitoring_Tools.html
258
Mapa mental para a fixação do aprendizado 4
259
4 Comandos
GNU e Unix
1. Para listarmos os arquivos e diretórios, incluindo os itens ocultos,

devemos utilizar qual comando?
☐☐ a) ls –o
☐☐ b) ls –l
☐☐ c) ls –a
☐☐ d) ls –R
☐☐ e) ls –p
2. Para criarmos um arquivo vazio, utilizamos qual comando?
☐☐ a) mkfile arquivo
☐☐ b) make file arquivo
☐☐ c) edit arquivo
☐☐ d) touch arquivo
☐☐ e) make arquivo
3. Qual comando podemos utilizar para criar toda a estrutura de diretórios

/novo/diretorio/exemplo?
☐☐ a) mkdir /novo/diretorio/exemplo
☐☐ b) mkdir –p /novo/diretorio/exemplo
☐☐ c) makedir /novo/diretorio/exemplo
☐☐ d) createdir /novo/diretorio/exemplo
☐☐ e) touch /novo/diretorio/exemplo
4. Qual comando é utilizado para excluir toda a estrutura de diretórios

/novo/diretorio/exemplo e todos os arquivos contidos dentro dela?
☐☐ a) rmdir /novo/diretorio/exemplo
☐☐ b) rmdir /novo
☐☐ c) rm –r /novo
☐☐ d) rm /novo/diretorio/exemplo
☐☐ e) rmdir –f /novo
5. Para copiar todos os arquivos com suas permissões e subdiretórios da

pasta /home/usuario para /tmp, podemos utilizar qual sintaxe?
☐☐ a) cp * /tmb
☐☐ b) cp –ar /home/usuario/* /tmp
☐☐ c) cp /home/usuarios /tmp
☐☐ d) cp –ar /home/usuarios/* /tmp
☐☐ e) cp –f /home /tmp
262
6. Para ler o arquivo /var/log/messages, filtrando somente as linhas que
contêm a palavra kernel e redirecionando o resultado para o arquivo /tmp/
logkernel.txt, utilizamos qual sintaxe?
☐☐ a) tail /var/log/messages | grep kernel > /tmp/logkernel.txt

☐☐ b) cat /var/log/messages | grep kernel > /tmp/logkernel.txt
☐☐ c) tail –f /var/log/messages | grep kernel > /tmp/logkernel.txt
☐☐ d) head /var/log/messages | grep kernel > /tmp/logkernel.txt
☐☐ e) read /var/log/messages | grep kernel > /tmp/logkernel.txt
7. Para ler um arquivo, colocando seu conteúdo em ordem alfabética e

suprimindo as linhas repetidas, devemos utilizar qual sintaxe?
☐☐ a) cat arquivo | sort –u

☐☐ b) cat arquivo | uniq
☐☐ c) cat arquivo | sort
☐☐ d) tail arquivo > sort arquivo
☐☐ e) sed arquivo | grep sort –u
8. Qual comando é utilizado para criar um link simbólico?
☐☐ a) ln
☐☐ b) ln symbolic
☐☐ c) create link
☐☐ d) ln –s
☐☐ e) ln –p
9. Um arquivo que foi dividido em várias partes com as iniciais arquivo_

pode ser restaurado com qual comando?
☐☐ a) restore
☐☐ b) split
☐☐ c) mount
☐☐ d) cat
☐☐ e) split arquivo_*
10. Quais comandos são utilizados para verificar o espaço em disco e o

tamanho de um diretório, respectivamente?
☐☐ a) df e du.
☐☐ b) ds e du.
☐☐ c) df e ls.
☐☐ d) du e df.
☐☐ e) ls e df.
263
11. Qual comando copia uma linha no vim?
☐☐ a) cc
☐☐ b) yy
☐☐ c) pp
☐☐ d) dd
☐☐ e) p
12. Qual comando é utilizado para desativar a numeração de linhas?
☐☐ a) :set disablenu
☐☐ b) :set disable
☐☐ c) :set nu
☐☐ d) :set nonu
☐☐ e) :syntax off
13. Qual comando é utilizado para forçar o salvamento do arquivo de texto

e sair?
☐☐ a) :q
☐☐ b) :w!
☐☐ c) :wq!
☐☐ d) :wq
☐☐ e) :q!
14. Quais dos comandos a seguir exibem informações dos processos do

Linux?
☐☐ a) ls e df.
☐☐ b) top e df.
☐☐ c) ps e df.
☐☐ d) ps e top.
☐☐ e) du e df.
15. O que faz o caractere & quando colocado no final do comando?
☐☐ a) Permite que outro comando seja colocado na mesma linha.

☐☐ b) Causa a parada do processo.
☐☐ c) Reinicia um processo parado.
☐☐ d) O processo é enviado para primeiro plano.
☐☐ e) O processo é enviado para segundo plano.
264
16. Qual é o PID do init?
☐☐ a) 0
☐☐ b) 1
☐☐ c) 2
☐☐ d) Ele não tem PID.
☐☐ e) É um PID aleatório.
17. Um processo com PID 3128 está no sistema sem funcionar. Digitamos
o seguinte comando, mas o processo não é finalizado:
# kill 3128
Qual dos comandos a seguir pode encerrar este processo?
☐☐ a) kill -9 3128
☐☐ b) kill -1 3128
☐☐ c) kill +9 3128
☐☐ d) kill 3128
☐☐ e) kill –die 3128
18. Qual das sequências de teclas a seguir é usada para iniciar um processo
em segundo plano e fazer este continuar funcionando?
☐☐ a) CTRL + B e o comando bg.

☐☐ b) CTRL + C e o comando fg.
☐☐ c) CTRL + Z e o comando bg.
☐☐ d) CTRL + C e o comando bg.
☐☐ e) CTRL + Z e o comando fg.
19. Nas alternativas a seguir, qual é a maior prioridade?
☐☐ a) 20
☐☐ b) 10
☐☐ c) -19
☐☐ d) -5
☐☐ e) -10
265
20. Qual parâmetro é utilizado com o comando tar para compactar o

conteúdo com bzip2?
☐☐ a) -j
☐☐ b) -z
☐☐ c) -b
☐☐ d) -x
☐☐ e) -v
21. O comando bunzip2 backup.tar.gz foi utilizado, porém o sistema

retornou o seguinte erro: bunzip2: Can’t guess original name for backup.
tar.gz -- using backup.tar.gz.out. Qual a provável causa do erro?
☐☐ a) O comando foi digitado de forma incorreta.

☐☐ b) Faltou o parâmetro -x para a extração ocorrer.
☐☐ c) O arquivo alvo não é compatível com bunzip2.
☐☐ d) O comando bunzip2 não existe.
☐☐ e) O nome do arquivo alvo está errado.
22. Qual parâmetro do comando tar é utilizado para compactar o conteúdo

com gzip?
☐☐ a) -j
☐☐ b) -z
☐☐ c) -b
☐☐ d) -x
☐☐ e) -v
23. Qual parâmetro deve ser utilizado com o comando cpio para compactar?
☐☐ a) -c
☐☐ b) -ov
☐☐ c) -iv
☐☐ d) -cv
☐☐ e) –d
24. Qual parâmetro deve ser utilizado com o comando cpio para
descompactar?
☐☐ a) -c
☐☐ b) -ov
☐☐ c) -iv
☐☐ d) -cv
☐☐ e) -d
266
4 Comandos
GNU e Unix
Mãos à obra!
Laboratório 1 - Aproveitando ao máximo o

comando ls
1. Logue no sistema com o usuário operador;
2. Liste os arquivos do diretório home do usuário operador:
$ ls
3. Liste todos os arquivos (inclusive os ocultos) do diretório home do usuário operador:
$ ls –a
É possível visualizar os arquivos ocultos do sistema (arquivos iniciados com .).
4. Visualize agora as propriedades dos arquivos, como data de criação, proprietário

e permissões:
$ ls –l
5. Liste recursivamente todos os arquivos (inclusive os ocultos) do diretório /var/log.

Note que serão exibidos todos os arquivos do diretório /var/log e todos os arquivos
contidos nos subdiretórios correspondentes:
$ ls –aR /var/log
Neste último comando foi utilizado mais de um parâmetro: –a para exibir arquivos
ocultos e –R para listagem recursiva.
268
Laboratório 2 - Criando arquivos e diretórios
7. Crie um arquivo em branco chamado operador.txt:
$ touch aluno.txt
8. Liste o diretório e verifique se o arquivo foi criado:
$ ls
9. Liste detalhadamente o diretório e verifique seu proprietário:
$ ls –l
10. Crie um diretório chamado diretorio1:
$ mkdir diretorio1
11. Verifique se diretorio1 foi devidamente criado:
$ ls
12. Crie, dentro de diretorio1, um diretório chamado subdiretorio1:
$ mkdir diretorio1/subdiretorio1
Note que o comando anterior não utilizou a barra (/) antes de diretorio1,
já que diretorio1 está dentro da pasta home do usuário operador e seu
caminho completo é /home/operador/diretorio1, e não /diretorio1.
13. Crie dois diretórios, um chamado diretorio2 e outro, subdiretorio2, que deve
estar dentro do primeiro. Para isso, utilize o comando a seguir:
$ mkdir diretorio2/subdiretorio2
A seguinte mensagem de erro será retornada:
“mkdir: cannot create directory `diretorio2/subdiretorio2’: No such

file or directory”
269
O erro ocorreu porque diretorio2 não existia para que fosse possível criar subdiretorio2
dentro dele. Então, para poder criar a estrutura toda em um único comando, utilize
mkdir com o parâmetro –p:
$ mkdir –p diretorio2/subdiretorio2
14. Verifique se diretorio2 foi criado:
$ ls
15. Entre em diretorio2 e verifique se subdiretorio2 foi criado:
$ cd diretorio2
$ ls
Laboratório 3 - Gerenciando arquivos

16. Copie o arquivo operador.txt criado no laboratório anterior para a pasta
subdiretorio1:
$ cp operador.txt ./diretorio1/subdiretorio1
Note que, no destino do arquivo, o endereço da pasta foi iniciado com uma
barra (/). O ponto (.) significa uma referência ao diretório atual. No nosso
caso, estamos localizados no home do usuário operador (/home/operador).
A sintaxe para a cópia seria esta: <local_atual>/diretorio1/subdiretorio1.
17. Verifique se o arquivo foi copiado para subdiretorio1 conforme desejado:
$ ls /home/operador/diretorio1/subdiretorio1
Desta vez, foi utilizado o caminho completo dos diretórios.
18. Copie o diretorio1 inteiro - com subpastas e arquivos - para o diretório

subdiretorio2:
$ cp –R diretorio1 ./diretorio2/subdiretorio2/.
Note a presença do ponto (.) no final do caminho do destino, o que indica a

intenção em copiar diretorio1 exatamente para dentro do subdiretorio2.
270
19. Verifique se todo o conteúdo foi devidamente copiado para subdiretorio2:
$ ls –R ./diretorio2/subdiretorio2
20. Renomeie o arquivo operador.txt para arquivo.txt:
$ mv operador.txt arquivo.txt
21. Verifique se o arquivo foi renomeado:
$ ls
22. Mova arquivo.txt para dentro de subdiretorio2:
$ mv arquivo.txt ./diretorio2/subdiretorio2/.
23. Verifique se o arquivo foi movido da pasta atual:
$ ls
24. Verifique se o arquivo está na pasta de destino:
$ ls diretorio2/subdiretorio2
Laboratório 4 - Utilizando caracteres curingas

25. Vá para a pasta /etc:
$ cd /etc
26. Liste os arquivos contidos nessa pasta:
$ ls
27. Liste os arquivos iniciados pela palavra mail:
$ ls mail*
28. Liste todos os arquivos que terminam com a extensão .conf:
$ ls *.conf
29. Vá para a pasta /dev:
$ cd /dev
271
30. Liste apenas os primeiros dispositivos seriais (de 0 a 9), ou seja, aqueles que,
após o nome tty, apresentam apenas 1 caractere:
$ ls tty?
31. Liste somente os dispositivos que trazem 2 caracteres após o nome tty:
$ ls tty??
Note que o resultado não mostra os arquivos que foram exibidos no resultado
obtido no passo anterior.
32. Agora, liste apenas os dispositivos seriais ímpares entre 0 e 10:
$ ls tty[1,3,5,7,9]
33. Liste os dispositivos seriais de 3 a 8:
$ ls tty[3-8]
34. Liste todos os arquivos iniciados pela letra M, maiúscula e minúscula:
$ ls [M,m]*
Laboratório 5 - Redirecionando os resultados

35. Logue no sistema como usuário root;
36. Vá para o diretório /var/log:
# cd /var/log
37. Verifique o conteúdo do diretório:
# ls
38. Redirecione o resultado para dentro da pasta pessoal do root:
# ls *.log > /root/lista_logs.txt
39. O resultado foi redirecionado para o arquivo lista_logs.txt localizado na pasta

root. Então, leia o arquivo com o comando cat:
# cat /root/lista_logs.txt
272
40. Agora, redirecione para o arquivo lista_logs.txt os logs de erros, os quais terminam
com .err. Com o redirecionamento, o arquivo lista_logs.txt existente será sobrescrito
(ao ler o arquivo com cat, é possível notar que o conteúdo anterior foi substituído
pelo conteúdo que acabou de ser redirecionado);
# ls *.err > /root/lista_logs.txt

# car /root/lista_logs.txt
41. Corrija o erro e envie novamente a lista de logs, mas desta vez sem perder a lista
de arquivos .err:
# ls *.log >> /root /lista_logs.txt
42. Execute o comando a seguir e observe que a lista cresceu. Agora ela contém os
arquivos .log;
43. Adicione também ao arquivo os logs com extensão .info:
# ls *.info >> /root/lista_logs.txt

Laboratório 6 - Redirecionando mensagens

de erro
44. No capítulo 4, vimos que é possível redirecionar as mensagens de erro. Ao
utilizarmos o redirecionamento normal (comando a seguir), a mensagem de erro não
vai para o arquivo de destino:
# ls > /root/teste_erro.txt
Ao executar a linha anterior, pode-se notar que o erro é exibido na tela. No entanto,
ao listar com cat, percebe-se que o erro não foi para dentro do arquivo gerado, ou
seja, o arquivo está vazio:
# cat /root/teste_erro.txt
45. Então, realize o mesmo teste, desta vez redirecionando as mensagens de erro
com o 2> para o arquivo teste_erro.txt:
# ls 2> /root/teste_erro.txt
46. Note que a mensagem de erro está presente no arquivo de destino:
# cat /root/teste_erro.txt
273
Laboratório 7 - Utilizando o pipe para redirecionar

entre programas
47. Acesse o diretório /etc:
# cd /etc
48. Com o comando adiante, liste detalhadamente todos os arquivos contidos na

pasta e observe que muitos arquivos rolaram a tela rapidamente, a ponto de não ser
possível lê-los;
# ls -l
49. Redirecione o resultado do comando ls -l para dentro do comado more a fim de

obter pausa a cada tela:
# ls -l |more
Utilize a tecla ENTER para rolar linha a linha ou Barra de espaço para rolar páginas.
Tecle q para sair.
50. Vimos anteriormente que é possível executar comandos e redirecionar a saída

deles para algum arquivo. Desta forma, em vez de imprimir o resultado na tela, ele é
encaminhado para o arquivo de destino. Agora, por meio do comando tee, faça com
que o resultado do comando seja exibido na tela e também redirecionado para um
arquivo:
# ls -l | tee /root/teste_tee.txt
# cat /root/teste_tee.txt
51. Da mesma forma que o redirecionador >, o comando tee exclui o arquivo de
destino. Para que a exclusão não ocorra e o comando adicione o resultado no final do
arquivo de destino, utilize a opção –a:
# echo “Nova Linha adicionada no final do arquivo para teste do tee”

| tee -a /root/teste_tee.txt
# cat /root/teste_tee.txt
274
Laboratório 8 - Visualizando a árvore de
diretórios
52. Logue no sistema como usuário operador;
53. Liste a estrutura do diretório /etc:
$ tree /etc
Note que o resultado foi exibido muito rapidamente, pois a quantidade de dados
é muito grande.
54. Liste novamente a estrutura, redirecionando o resultado para um programa que

permite pausa, como o more. Mude linha a linha com a tecla ENTER e role as páginas
com a tecla Barra de Espaço;
$ tree /etc | more
55. Agora, liste apenas os diretórios:
$ tree -d /etc
Laboratório 9 - Lendo arquivos de texto

com cat
56. Leia o arquivo /proc/cpuinfo:
$ cat /proc/cpuinfo
57. Leia o arquivo protocols com o comando cat e redirecione o resultado para o
less, a fim de viabilizar a navegação pelo arquivo:
$ cat /etc/protocols| less
58. Navegue pelo arquivo com as setas direcionais do teclado;
59. Leia o arquivo passwd com cat e observe a ordem do resultado:
$ cat /etc/passwd
275
60. Agora, leia o mesmo arquivo com o comando tac e note que o resultado é o
inverso:
$ tac /etc/passwd
61. Leia apenas as 10 primeiras linhas do arquivo debconf.conf:
$ head /etc/debconf.conf
62. Leia apenas as duas primeiras linhas do arquivo debconf.conf:
$ head -n2 /etc/debconf.conf
63. Leia as últimas 10 linhas do arquivo debconf.conf:
$ tail /etc/debconf.conf
64. Agora, leia apenas a última linha do arquivo debconf.conf:
$ tail -n1 /etc/debconf.conf
Laboratório 10 - Ajustando arquivos para

impressão
65. Eleve as permissões para root:
$ su
66. Vá para a pasta /root:
# cd ~
67. Ajuste o arquivo de logs do kernel para impressão e redirecione o resultado para
o arquivo novo_messages da pasta /root:
# pr /var/log/messages > /root/novo_messages
68. Leia o novo arquivo gerado com cat e less para possibilitar a navegação pelo
arquivo:
# cat novo_messages | less
Observe que o cabeçalho agora exibe a data, a hora, o nome do arquivo e o número
de cada página.
276
69. Em seguida, imprima na tela apenas as páginas 10 e 11 do arquivo de log messages
e mude o nome do cabeçalho utilizando a opção –header:
# pr –pages=10:11 –header=”Paginas 10 e 11 do Arquivo Messages” /

var/log/messages > /root/messages_parcial
70. Leia o novo arquivo gerado e observe que foram impressas apenas as páginas 10
e 11 e que o cabeçalho agora é personalizado:
# cat messages_parcial
Laboratório 11 - Concatenando arquivos

71. Leia o arquivo /etc/passwd:
# cat /etc/passwd
72. Leia o arquivo /etc/shadow:
# cat /etc/shadow
73. Junte os dois arquivos em um único arquivo chamado usuarios_e_senhas na

pasta /root:
# paste /etc/passwd /etc/shadow > /root/usuarios_e_senhas
74. Verifique o resultado:
# cat /root/usuarios_e_senhas
75. Separe na linha os dois arquivos utilizando o delimitador | (pipe):
# paste -d”|” /etc/passwd /etc/shadow > /root/usuarios_e_senhas
76. Verifique como ficou o arquivo. No resultado, note que foi colocado o pipe | no
lugar da tabulação;
# cat /root/usuarios_e_senhas
77. Crie o arquivo Estados.txt constando os seguintes itens:
•• Acre;
•• Alagoas;
•• Amapá;
•• Amazonas;
•• Bahia;
•• Ceará;
•• Distrito Federal;
277
•• Espírito Santo;
•• Goiás;
•• Maranhão;
•• Mato Grosso;
•• Mato Grosso do Sul;
•• Minas Gerais;
•• Pará;
•• Paraíba;
•• Paraná;
•• Pernambuco;
•• Piauí;
•• Rio de Janeiro;
•• Rio Grande do Norte;
•• Rio Grande do Sul;
•• Rondônia;
•• Roraima;
•• Santa Catarina;
•• São Paulo;
•• Sergipe;
•• Tocantins;
•• Nova York;
•• Califórnia;
•• Flórida.
78. Leia o arquivo Estados.txt na pasta /root:
# cat /root/Estados.txt
79. Crie o arquivo Capitais.txt, constando os seguintes itens:
•• Rio Branco;
•• Maceió;
•• Macapá;
•• Manaus;
•• Salvador;
•• Fortaleza;
•• Brasília;
•• Vitória;
•• Goiânia;
•• São Luís;
•• Cuiabá;
•• Campo Grande;
•• Belo Horizonte;
•• Belém;
•• João Pessoa;
•• Curitiba;
•• Recife;
•• Teresina;
•• Rio de Janeiro;
•• Natal;
278
•• Porto Alegre;
•• Porto Velho;
•• Boa Vista;
•• Florianópolis;
•• São Paulo;
•• Aracajú;
•• Palmas.
80. Leia o arquivo Capitais.txt na pasta /root:
# cat /root/Capitais.txt
81. Junte os dois arquivos com o comando join e salve-os no arquivo /root/estados_e_
capitais.txt:
# join -t. /root/Estados.txt /root/Capitais.txt > /root/estados_e_

capitais.txt
82. Leia o arquivo gerado:
# cat /root/estados_e_capitais.txt
Note que, apesar do arquivo Estados.txt ter 30 linhas, ele só concatenou as 27

linhas, pois havia referência entre elas.
83. Liste as linhas sem referência entre os arquivos:
# join -t. -v1 /root/Estados.txt /root/Capitais.txt
84. Crie o arquivo Cidades.txt, constando os seguintes itens:
•• São Paulo;
•• Sorocaba;
•• Bauru;
•• Bauru;
•• Santos;
•• Itanhaém;
•• Praia Grande;
•• São Vicente;
•• São Vicente;
•• Barretos;
•• Alphaville;
•• Barueri;
•• Barueri;
•• Sorocaba.
279
85. Leia o arquivo Cidades.txt:
# cat /root/Cidades.txt
Note que este arquivo tem cidades repetidas (Bauru, São Vicente, Barueri e Sorocaba).
86. Verifique quantas vezes cada linha se repete:
# uniq -c /root/Cidades.txt
87. Com o comando uniq, leia o arquivo para remover as linhas repetidas e redirecionar
o resultado para o arquivo Cidades_Exclusivas.txt:
# uniq /root/Cidades.txt > /root/Cidades_Exlusivas.txt

# cat /root/Cidades_Exclusivas.txt
No resultado, observe que o arquivo não possui mais repetição.
88. Converta na tela o arquivo Cidades.txt em formato hexadecimal:
# od -x /root/Cidades.txt
89. Repita a conversão, desta vez com o comando hexdump:
# hexdump -x /root/Cidades.txt
Laboratório 12 - Coletando informações de

arquivos
90. Verifique quantas linhas tem o arquivo Cidades.txt:
# wc -l /root/Cidades.txt
91. Agora, conte quantos caracteres possui o arquivo de log do kernel:
# wc -c /var/log/messages
92. Leia o arquivo Cidades.txt. No resultado, note que o arquivo não está em ordem
alfabética;
# cat /root/Cidades.txt
280
93. Ordene alfabeticamente as cidades com o comando sort:
# sort /root/Cidades.txt
94. Ordene as cidades e suprima as cidades repetidas:
# sort -u /root/Cidades.txt
95. Compare a diferença dos resultados, contando quantas linhas cada resultado
possui. Inicie a comparação sem suprimir as cidades repetidas:
# sort /root/Cidades.txt |wc -l
96. Agora, suprima as cidades repetidas e conte o resultado:
# sort -u /root/Cidades.txt |wc -l
Laboratório 13 - Localizando textos em

arquivos e filtrando resultados
97. Verifique se há a cidade Bauru no arquivo Cidades.txt:
# grep Bauru /root/Cidades.txt
98. Verifique quantas vezes a cidade Bauru se repete no arquivo Cidades.txt:
# grep -c Bauru /root/Cidades.txt
99. Verifique em quais linhas do arquivo a cidade Bauru está presente:
# grep -n Bauru /root/Cidades.txt
100. Busque pelo nome São Paulo em todos os arquivos e, caso haja ocorrências
desse nome, mostre em qual linha dos arquivos cada uma delas está localizada:
# grep -i -n “Sao Paulo” /root/*
101. Troque o estado Nova York por New York no arquivo Estados.txt:
# sed -i “s/Nova York/New York/g” /root/Estados.txt
281
Laboratório 14 - Extraindo e modificando

dados
102. Obtenha a lista de usuários contidos no arquivo /etc/passwd:
# cat /etc/passwd |cut -f1 -d”:”
103. Identifique o tipo de arquivo:
# file /bin/ls
# file /etc/passwd
# file /root/Estados.txt
104. Converta todas as letras do arquivo Estados.txt em maiúsculas:
# cat /root/Estados.txt | tr ‘a-z’ ‘A-Z’ > /root/Novo_Estados.txt
105. Remova os números e o ponto (.) do arquivo Novo_Estados.txt:
# cat /root/Novo_Estados.txt | tr -d ‘0-9’ | tr -d ‘.’ > /root/Novo_

Estados_2.txt
106. Leia as últimas 10 linhas do arquivo de log messages, porém filtre-o para que
exiba apenas 60 caracteres em cada coluna:
# tail /var/log/messages |fmt -w60
laboratório 15 - Criando links (atalhos) para

os arquivos
107. Crie o diretório novo_dir:
# mkdir /root/novo_dir
108. Liste os arquivos da pasta /root:
# ls /root/
109. Crie um link simbólico do arquivo Capitais.txt para dentro da nova pasta:
# ln -s /root/Capitais.txt /root/novo_dir/Link_Capitais.txt
Note que o link tem nome diferente do arquivo original. Isso não é obrigatório.
282
110. Acesse a nova pasta:
# cd /root/novo_dir
111. Liste os arquivos da pasta:
# ls
112. Liste detalhadamente os arquivos da pasta:
# ls -l
Note a referência ao link simbólico.
113. Crie um link físico do arquivo Cidades.txt:
# ln /root/Cidades.txt /root/novo_dir/Link_Cidades.txt
114. Liste detalhadamente o diretório:
# ls -l
Note que o link físico não possui referência quando o listamos.
Laboratório 16 - Dividindo arquivos

115. Quebre o arquivo de log messages em partes de 250 linhas dentro da pasta /
root:
# split -d -l 250 /var/log/messages /root/messages-parte_
116. Quebre o arquivo de log messages em pedaços de 50K e salve-os na pasta /

root:
# split -d -b 50K /var/log/messages /root/messages-tamanho-parte_
117. Junte todas as partes do arquivo messages-parte_* em um único arquivo:
# cat /root/messages-parte_* > /root/messages_unificado

# cat /root/messages_unificado
283
Laboratório 17 - Administrando o computador

118. Verifique a quantidade de espaço em disco nas unidades existentes:
# df -h
119. Verifique a quantidade de espaço em disco ocupada pela pasta /root:
# du -chs /root
120. Verifique como está o consumo da memória RAM em MB (megabytes):
# free -m
121. Exiba a data atual do sistema:
# date
122. Exiba data e hora atuais em formato detalhado e personalizado:
# date “+%d de %B de %Y as %H:%M”
123. Verifique há quanto tempo o computador está ligado e exiba detalhes da carga
do sistema:
# uptime
124. Verifique a versão e compilação do kernel em uso:
# uname -a
125. Verifique há quanto tempo o programa exim está sendo executado:
# time exim4
Laboratório 18 - Comparando arquivos

126. Copie o arquivo Cidades.txt para Cidades_2.txt:
# cp /root/Cidades.txt /root/Cidades_2.txt
127. Adicione uma nova informação no arquivo Cidades_2.txt:
# echo “Jaguariuna” >> /root/Cidades_2.txt
284
128. Compare a diferença entre os dois arquivos:
# diff /root/Cidades.txt /root/Cidades_2.txt
Laboratório 19 - Localizando arquivos no

computador
129. Localize com o comando find os arquivos referente a passwd em todo o
computador:
# find / -name passwd
130. Localize os arquivos que foram acessados em 1 dia:
# find / -atime 1
131. Atualize a base de dados do locate:
# updatedb
132. Localize os arquivos referentes a passwd:
# locate passwd
Laboratório 20 - Familiarizando-se e testando

alguns comandos com o vim
133. Abra o arquivo messages:
# vim /var/log/messages
Note que não é possível digitar algo sequer, pois o modo de comandos está ativo.
134. Numere as linhas:
:set nu
135. Vá para a última linha digitando G;
285
136. Volte para a primeira linha digitando gg;
137. Remova a numeração das linhas:
:set nonu
138. Localize a palavra input:
/input
139. Vá para a próxima ocorrência da busca:
140. Habilite o modo de programação, tornando o código colorido para facilitar a

leitura:
:syntax on
141. Saia sem salvar:
:q!
Laboratório 21 - Editando o primeiro arquivo

com o vim
142. Vá para a pasta pessoal:
# cd
143. Abra o vim:
# vim
144. Entre no modo de edição pressionando i ou INSERT;
145. Digite algum texto de 5 linhas;
146. Volte para o modo de comandos pressionando ESC;
147. Vá para a primeira linha digitando gg;
148. Copie-a pressionando yy;
286
149. Vá para a última linha digitando G;
150. Cole a linha pressionando p;
151. Desfaça a alteração pressionando u;
152. Vá para a linha 3:
:3
153. Cole novamente o texto com p;
154. Vá para a primeira linha digitando gg;
155. Apague a linha pressionando dd;
156. Salve o arquivo:
:w /root/arquivo-vim.txt
157. Substitua uma palavra do texto por outra:
:%s/palavra_original/nova_palavra/g
158. Salve e saia:
:wq
Laboratório 22 - Executando o comando ps

159. Execute o comando ps para ver todos os processos;
# ps aux
160. Agora, observe apenas os processos do programa cron;
# ps aux | grep cron
161. Observe os processos que têm classificação de processos filho;
# ps faux
162. Verifique o PID do programa cron;
# pidof cron
287
163. Instale o pacote psmisc para utilização do pstree;
# apt-get install pmisc
164. Use o pstree.
# pidof kthreadd
# pstree 2
Laboratório 23 - Gerenciando processos

com o TOP
165. Execute o top;
# top
166. Separe seus processadores na tela digitando 1 (se tiver mais de um, aparecerão
a partir do 0);
167. Defina para ver apenas 20 processos na tela, digitando N e 20;
168. Coloque os processos em ordem de consumo de memória, digitando M;
169. Observe o help do top digitando ?;
170. Saia do top digitando q;
171. Instale o htop;
# apt-get install htop
172. Execute o htop;
# htop
173. Observe as possibilidades de comando no rodapé e execute a opção de sair do

htop, utilizando F10.
288
Laboratório 24 - Gerenciando planos de
processos
174. Execute o comando ping;
# ping www.impacta.com.br
175. Pause o comando utilizando CTRL + Z;
176. Execute o comando jobs para ver as tarefas. Observe que ele está parado
(stopped);
# jobs
177. Envie o comando para segundo plano;
# bg 1
178. Execute novamente o comando jobs. Apesar da resposta na tela, observe que é
possível inserir comandos, pois o processo está em segundo plano. O resultado de
jobs deve ser “Running”;
# jobs
179. Traga novamente para primeiro plano;
# fg 1
180. Pare o processo utilizando CTRL + C;
181. Execute o comando top já em segundo plano;
# top &
182. Traga-o para primeiro plano.
# jobs
# fg [numero do job]
289
Laboratório 25 - Alterando a prioridade dos

processos
183. Pare o processo ntpd;
# pkill ntpd
184. Execute o ntpd com a prioridade -10;
# nice –n -8 ntpd
185. Confira se o ntpd está com a prioridade -10;
# ps -l NI -e f |grep ntpd
186. Altere a prioridade do ntpd para -5;
# pidof ntpd
# renice -5 –p [PID]
187. Confira se o ntpd está com prioridade -5;
# ps -l NI -e f |grep ntpd
188. Encerre todos os processos ntpd.
# killall ntpd
Laboratório 26 - Compactando arquivos e

pastas
189. Crie na pasta /root uma pasta chamada laboratorio:
# mkdir /root/laboratorio
190. Faça um backup para a pasta laboratorio das pastas /etc e /home, compactando
os dados com gzip:
# tar -czvf /root/laboratorio/backup.tar.gz /etc /home
290
191. Faça um backup das pastas /etc e /home para a pasta laboratorio, utilizando o
compactador bzip2:
# tar -cjvf /root/laboratorio/backup.tar.bz2 /etc /home
192. Compare a compactação dos dois métodos anteriores, listando os arquivos e

vendo o tamanho de cada um:
# ls -l /root/laboratorio
193. Faça um backup da pasta /etc/ com cpio e salve o arquivo na pasta laboratorio:
# cd /etc
# ls | cpio -ov > /root/laboratorio/backup.cpio
194. Verifique se o arquivo foi copiado:
# cd /root/laboratorio
# ls
195. Faça um backup do setor MBR com o comando dd (substitua a unidade sda pela
unidade principal):
# dd if=/dev/sda of=/root/laboratorio/backup.mbr bs=512 count=1
196. Verifique se a cópia foi realizada:
# ls -l /root/laboratorio/backup.mbr
Laboratório 27 - Descompactando arquivos

e pastas
197. Crie os diretórios para a descompactação por meio do gzip, bzip2 e cpio:
# mkdir -p /root/laboratorio/descompacta/gzip
# mkdir -p /root/laboratorio/descompacta/bzip2
# mkdir -p /root/laboratorio/descompacta/cpio
198. Descompacte o arquivo backup.tar.gz na pasta gzip:
# tar -xzvpf /root/laboratorio/backup.tar.gz -C /root/laboratorio/

descompacta/gzip
291
199. Verifique se os arquivos foram descompactados:
# ls -laR /root/laboratorio/descompacta/gzip
200. Descompacte o arquivo backup.tar.bz2 na pasta bzip2:
# tar -xjvf /root/laboratorio/backup.tar.bz2 -C /root/laboratorio/

descompacta/bzip2
201. Verifique se os arquivos foram descompactados:
# ls -laR /root/laboratorio/descompacta/bzip2
202. Descompacte o arquivo backup.cpio na pasta cpio:
# cd /root/laboratorio/descompacta/cpio
# cpio -iv < /root/laboratorio/backup.cpio
292
5
Dispositivos,
Sistemas de
arquivos e FHS
ÃÃ Criando partições e sistemas de arquivos;

ÃÃ Árvore de diretórios FHS;
ÃÃ Configuração de cota de disco;
ÃÃ Documentação.
Este capítulo faz parte do tópico 104- Devices, Linux Filesystems, Filesystem
Hierarchy Standard da primeira prova identificada como 101-400 ou LX0-103 da
certificação LPIC-1.
Você precisará estar apto a criar partições, adicionar e realizar manutenções em

sistemas de arquivos, montar e desmontar os sistemas de arquivos, gerenciar
quotas de disco, criar e alterar links físicos e simbólicos e encontrar arquivos no
sistema.
Alguns comandos exigidos para esse tópico já foram mencionados no Capítulo

4 – Comandos GNU e Unix, ou serão mencionados no capítulo 8 – Tarefas
administrativas.

Para o mercado de trabalho, entender os pontos de montagens, gerenciar cotas de

disco e entender as funcionalidades de cada diretório, é fundamental para operar
o sistema de forma profissional.
5.1. Criando partições e sistemas de arquivos

Nos subtópicos a seguir, aprenderemos sobre os comandos utilizados para a criação
de partições de disco e sobre sistemas de arquivos.
5.1.1. fdisk
O comando fdisk é utilizado para criar partições em um determinado disco. No GNU/
Linux, os dispositivos se encontram nos seguintes endereços:
•• /dev/hda: IDE primária master;
•• /dev/hdb: IDE primária slave;
•• /dev/hdc: IDE secundária master;
•• /dev/hdd: IDE secundária slave;
•• /dev/sd*: Dispositivos SCSI.
A sintaxe do comando fdisk é a seguinte:
fdisk <dispositivo>
294
Dispositivos, Sistemas de arquivos e FHS 5
A seguir, são apresentadas algumas opções do comando fdisk:
Opção Descrição
a Alterna a partição ativa, responsável pelo boot.
b Edita o disklabel do BSD.
c Alterna a sinalização de compatibilidade do DOS.
d Exclui uma determinada partição.
l Exibe a lista dos sistemas de arquivos conhecidos.
m Exibe a lista do menu de ajuda.
n Cria uma nova partição.
p Exibe a tabela de partições.
q Sai do programa e não salva as alterações.
s Cria um disklabel da Sun novo e vazio.
t Altera um id de sistema de partição.
u Altera unidades de exibição/entrada.
w Grava a tabela do disco e sai.
Na imagem a seguir, podemos visualizar as partições existentes em um dispositivo:
295
A próxima imagem exibe a remoção da terceira partição do disco:
5.1.2. cfdisk
O comando cfdisk permite efetuar a criação de partições nos dispositivos. Sua sintaxe
é a seguinte:
cfdisk <dispositivo>
O exemplo a seguir demonstra o uso do cfdisk para criação de uma partição no

dispositivo /dev/sda:
296
A próxima imagem exibe a tela do utilitário cfdisk:
A tabela a seguir descreve as opções disponíveis na tela do cfdisk:
Opção Descrição
Inicializar Torna a partição inicializável.
Excluir Exclui partição.
Ajuda Exibe ajuda do cfdisk.
Maximize Permite maximizar o uso do disco.
Mostre Exibe tabela de partições na tela.
Sair Encerra o cfdisk.
Tipo Define o tipo de sistema de arquivos.
Exibe o tamanho das partições em megabytes (MB), setores e
Unidades
cilindros.
Gravar Grava a tabela de partições do disco.
297
5.1.3. Sistema de arquivos
Podemos definir um sistema de arquivos como um meio de deixar os dados de nosso
sistema mais organizados. Todo sistema operacional gera um tipo de sistema de
arquivos.
A seguir, abordaremos as informações sobre os sistemas de arquivos e, também,

sobre como podemos gerenciá-los por meio de ferramentas específicas.
O Linux oferece suporte a vários sistemas de arquivos de outros sistemas operacionais.
A seguir, citamos alguns:
•• xiafs;
•• minix;
•• msdos;
•• vfat;
•• proc;
•• smbfs;
•• iso9660;
•• hpfs;
•• ufs.
Os sistemas de arquivos são alocados em partições lógicas; cada partição aceita um

único sistema de arquivos.
5.1.4. Estrutura básica
De maneira geral, podemos dividir o sistema de arquivos em quatro partes: bloco de
boot, superbloco, tabela de inodes e bloco de dados.
5.1.4.1. Bloco de boot
O bloco de boot fica localizado no início do sistema de arquivos. Para acessá-lo,
podemos utilizar o código mínimo incorporado na ROM da BIOS do computador. O
bloco de boot da partição bootável contém o código necessário para inicializar o
sistema operacional posteriormente.
298
5.1.4.2. Superbloco
Este bloco é responsável por descrever o estado do sistema de arquivos no que diz
respeito ao tamanho e à quantidade de arquivos que tal sistema pode armazenar.
Além disso, ele descreve as informações sobre quais partes da área de armazenamento
já estão sendo utilizadas e quais ainda estão disponíveis, bem como outras informações.
A seguir, listamos as informações contidas no superbloco:
•• Tamanho do sistema de arquivos, que faz referência à área de armazenamento

do dispositivo ou da partição atual no dispositivo;
•• Relação de blocos de armazenamento;
•• Quantidade de blocos disponíveis;
•• Localização de todos os blocos disponíveis;
•• Tamanho da lista de inode: esta lista é inicializada com o propósito de rastrear

a maior quantidade possível de arquivos;
•• Quantidade de inodes disponíveis no sistema de arquivos;
•• Índice do próximo inode disponível na lista de inodes disponíveis.
5.1.4.3. Tabela de inodes
O inode é definido como uma estrutura de dados que apresenta um sistema de
arquivos que adota a semântica de sistemas Unix. Os inodes têm como característica
conter dados de arquivos, tais como localização, tipo, proprietário, tempo de acesso,
entre outros.
Podemos definir a lista de inodes como uma lista estática. O tamanho da lista não
pode ser alterado depois que o sistema de arquivos for criado. O administrador e o
tamanho do dispositivo de armazenamento são responsáveis por definir o tamanho
desta lista.
A seguir, listamos os tipos de informações incluídas em um inode:
•• ID do proprietário do arquivo: Refere-se ao UID especificado no arquivo de

usuários para identificar o proprietário do arquivo;
•• ID do grupo: Refere-se ao GID especificado no arquivo de grupos para identificar

o grupo do arquivo;
299
•• Tipo de arquivo: Responsável por armazenar a especificação do tipo de arquivo,

isto é, especifica se o arquivo é um diretório, um link simbólico, um dispositivo
de bloco ou caractere ou um pipe;
•• Permissões do arquivo: Traz informações de permissões de acesso para as

classes usuário (owner), grupo (group) e outros (other);
•• Tempo de acesso: Por meio deste item, podemos obter informações sobre
tempo de acesso e modificação dos arquivos, além do número de links, tamanho
do arquivo e o local onde os dados estão armazenados no dispositivo.
5.1.4.4. Bloco de dados
Os blocos de dados estão localizados após os blocos que possuem a lista de inodes
e têm a função de armazenar informações administrativas, bem como os dados dos
arquivos.
É importante lembrar que um bloco de dados nunca pode pertencer a mais de um

sistema de arquivos.
5.1.5. Tipos de sistemas de arquivos GNU/Linux

Conheceremos, a seguir, os sistemas de arquivos com os quais o GNU/Linux trabalha.
5.1.5.1. Second Extended File System (ext2)

Um dos sistemas de arquivos com que o Linux trabalha é o ext2. O inode é a estrutura
básica do ext2. Como dito anteriormente, cada arquivo possui o próprio inode. Os
diretórios também possuem um inode próprio.
Uma característica do ext2 é utilizar blocos do mesmo tamanho para armazenar os

arquivos. Podemos determinar o tamanho do bloco quando o sistema de arquivos
ext2 está sendo criado.
Quando utilizamos este sistema de arquivos, os dados importantes para a integridade

do ext2, bem como arquivos e diretórios, são mantidos em grupos de blocos. Os
grupos de blocos são divisões criadas na partição lógica em que o ext2 está incluído.
300
A seguir, listamos alguns dados sobre o sistema de arquivos ext2:
•• Os diretórios, arquivos regulares, arquivos especiais do dispositivo e links

simbólicos, tidos como tipos de arquivo padrão do Unix, são aceitos pelo
sistema de arquivos;
•• Sistemas de arquivos criados em partições consideravelmente grandes podem

ser controlados pelo ext2. Antigamente, o tamanho máximo do sistema
de arquivos era 2 GB, característica imposta pelo código original do kernel.
Atualmente, este tamanho foi ampliado para 4 TB;
•• O tamanho máximo do nome do arquivo é de 255 caracteres. Porém, caso seja

necessário, esse tamanho pode ser aumentado para 1012 caracteres;
•• As entradas de diretório possuem comprimento variável;
•• Reserva normalmente 5% dos blocos para o superusuário (root). Esta

característica ajuda o trabalho do administrador diante de um sistema de
arquivos sobrecarregado pelos processos requeridos pelo usuário.
5.1.5.2. ext3
O ext3 foi desenvolvido por Estephen Tweedie, da Red Hat, e é uma versão journaling
do sistema de arquivos ext2. Um sistema de arquivo com journaling trabalha com um
log chamado journal. As informações referentes a uma operação que será realizada
são agendadas primeiro no journal, para depois serem realizadas de fato.
Caso a operação seja interrompida (por uma queda de energia, por exemplo) no
momento em que suas informações estão sendo registradas no journal, o arquivo
permanecerá intacto, ainda que não seja atualizado. Porém, se a operação for
interrompida durante sua execução, ela poderá ser posteriormente completada, pois
as informações necessárias para execução completa da operação já estão contidas no
journal.
A seguir, descreveremos algumas características do ext3:
•• Utiliza uma API denominada JBD (Journaling Block Device). Esta camada, em
vez de armazenar bytes a serem gravados, armazena na memória os blocos
modificados do sistema de arquivos. Com os blocos modificados já armazenados,
uma operação que foi interrompida pode continuar a ser executada;
•• Permite utilizar o sistema de cotas;
•• Pode trabalhar com blocos de 1,2 e 4 KB;
•• O tamanho máximo do sistema de arquivos é de 16 TB;
•• O tamanho máximo dos arquivos é de 2 TB.
301
5.1.5.3. ext4
Os arquivos ext3 podem facilmente ser convertidos para o formato ext4, de forma
que possam ser trabalhados pelo sistema de arquivos ext4, um sistema moderno
que traz melhorias em desempenho, capacidade de armazenamento, velocidade de
verificação de disco e disponibilidade de ferramentas em relação aos sistemas de
arquivos anteriores a ele. Ele utiliza um esquema de alocação múltipla de blocos, em
vez da tradicional alocação de um bloco por vez, o que também melhora o desempenho
do sistema, pois evita o overhead.
Também disponibiliza o recurso journaling, com verificações no journal para checar

sua integridade. Há ainda a possibilidade de desabilitar o recurso journal, caso o
usuário priorize velocidade a segurança.
Veja, a seguir, outras características do sistema de arquivos ext4:
•• Admite um número ilimitado de subdiretórios;
•• O tamanho máximo dos arquivos é de 16 TB.
5.1.5.4. reiserfs
O reiserfs foi criado por Hans Reiser, e seu núcleo é baseado em uma mesma árvore,
as conhecidas B+ (árvores balanceadas). Cada diretório apresenta uma subárvore da
árvore principal, não havendo uma árvore diferente para cada diretório.
Contudo, a utilização de uma mesma árvore em que estão contidos elementos como
diretórios, links e blocos de arquivos implica a utilização de técnicas de indexação
(hashing) mais complexas.
O reiserfs utiliza o recurso journaling, e sua conduta é armazenar apenas os metadados

no journal. Estes dados armazenados se referem ao tamanho e às permissões do
arquivo.
Caso ocorra uma interrupção durante a gravação dos arquivos journal, um arquivo
poderá apresentar seu conteúdo incompleto.
A seguir, serão apresentadas algumas características do reiserfs:
•• Trabalha com blocos de 4 KB;
•• O tamanho máximo do sistema de arquivos é de 1 EB;
•• O tamanho máximo do arquivo é de 1 EB.
302
5.1.5.5. xfs
O xfs é o sistema de arquivos mais potente já desenvolvido e é utilizado para
desempenhos em escala extremamente grande. Compatível com o Linux 2.4 e versões
superiores, o xfs alia o recurso journaling a um endereçamento de 64 bits e permite
o escalonamento de estruturas e algoritmos.
Os processos realizados pelo xfs são rápidos, pois ele permite a execução de
operações de journaling sem deixar que elas afetem drasticamente o desempenho de
operações de escrita e leitura de dados.
A seguir, vão alguns dados técnicos sobre o xfs:
•• Permite utilizar o sistema de cotas de usuários e de grupos;
•• Trabalha com blocos de até 64 KB;
•• O tamanho máximo do sistema de arquivos é 16 TB para plataformas de 32 bits

e 9 milhões de TB (8,58 EB) em plataformas de 64 bits;
•• O tamanho máximo dos arquivos é de 16 TB no Linux 2.4 e 8,58 EB no Linux

2.6, estando o endereçamento de 64 bits acionado.
5.1.6. Montando dispositivos
Ponto de montagem é uma das características mais importantes em sistemas Unix-
like, pois define a forma como acessaremos um determinado dispositivo. Em sistemas
Windows, o acesso às partições está diretamente relacionado a alguma unidade.
Acessando tal unidade é como se estivéssemos entrando no dispositivo e, a partir
daí, é só utilizar os recursos. Em sistemas Unix-like, o acesso aos dispositivos se dá
pelos pontos de montagem, que são diretórios simplesmente, de preferência vazios,
que serão um recipiente do dispositivo que será acessado.
A ligação e a transformação de um diretório vazio em um ponto de montagem se dão

pelo processo de montagem de dispositivos, através do comando mount que será
estudado a seguir.
O processo de montagem é muito importante, pois define como o acesso a um

dispositivo ocorrerá. Também sobre o processo de montagem, para encerrar essa
ligação que é feita entre dispositivo e ponto de montagem, é preciso fazer o processo
inverso, que chamamos de processo de desmontagem, com o comando umount, que
será estudado adiante.
303
5.1.7. mount
O comando mount é utilizado para montar um sistema de arquivos, permitindo acesso
a um determinado dispositivo. Conforme o conceito apresentado anteriormente sobre
pontos de montagem, o comando mount permitirá a ligação de dispositivos com seu
respectivo ponto de montagem. Sua sintaxe é a seguinte:
mount [opcao] <dispositivo> <ponto de montagem>
A tabela a seguir descreve as principais opções utilizadas com mount:

-a Monta todos os dispositivos predefinidos no arquivo /etc/fstab.
-v Exibe o processo de montagem.
Especifica o tipo de sistema de arquivos utilizado pelo dispositivo
que será montado. Entre os sistemas possíveis, temos: ext, ext2,
-t <sistema>
ext3, hpfs, iso9660, jfs, minix, msdos, nfs, nfs4, ntfs, reiserfs,
smbfs, vfat e xfs.
Opções auxiliares que poderão ser ativadas no processo de
-o
montagem: ro, rw, umask etc.
Sobre os dispositivos que se deseja montar, é preciso indicar o arquivo especial

relacionado a eles, geralmente alocado no diretório /dev/. A seguir, temos uma
tabela que mostra alguns dispositivos e seu respectivo arquivo especial, podendo
ocorrer variações:
Arquivo
Descrição
especial
Primeira partição do primeiro disco rígido IDE, que se encontra no
/dev/hda1
canal primário.
/dev/hdd Pode ser um CD-ROM IDE no segundo canal primário, como slave.
/dev/fd0 Primeira unidade de disquete.
Usado para identificar dispositivos SCSI, SATA e também unidades
/dev/sda1
USB, indicando a primeira partição desse dispositivo.
No exemplo a seguir, temos uma simples montagem do dispositivo de CD-ROM, no

caso representado por /dev/hdd, no ponto de montagem /media/cdrom, lembrando
que mídias ópticas também utilizam sistemas de arquivos, no caso iso9660:
mount -t iso9660 /dev/hdd /media/cdrom
304
Já no exemplo adiante, temos uma montagem de um dispositivo que é aparentemente
uma partição e que usa o sistema de arquivos ext3. O acesso a esse dispositivo será
feito pelo ponto de montagem /mnt/backup:
mount -t ext3 /dev/hda2 /mnt/backup
5.1.8. umount
O comando umount é utilizado para fazer o processo de desmontagem de um
dispositivo para que ele possa ser liberado. A própria unidade de CD-ROM, para
que possa ser ejetada, precisa passar pelo processo de desmontagem, assim como
qualquer tipo de dispositivo montado no sistema.
A sintaxe de umount é a seguinte:
umount <dispositivo> ou <ponto de montagem>
Os exemplos a seguir têm exatamente a mesma função, em que o dispositivo de CD-

ROM foi desmontado e já não tem ligação de acesso no sistema:
umount /dev/hdd
umount /media/cdrom
Para desmontar os dispositivos, eles não podem ter qualquer tipo de recurso em
uso no sistema ou estar dentro do diretório a ser desmontado. Caso contrário,
uma mensagem de erro será exibida informando que o dispositivo está ocupado.
5.1.9. /etc/fstab
O arquivo /etc/fstab é responsável por armazenar as configurações de todos os
sistemas de arquivos do sistema e seus respectivos pontos de montagem, permitindo
que eles sejam montados corretamente a cada inicialização do sistema. Sistemas de
arquivo que não estejam representados no fstab não serão montados automaticamente.
Embora o fstab guarde informações sobre os dispositivos frequentemente acessados,

o usuário deve abrir os arquivos /etc/mtab ou /proc/mounts, caso queira visualizar
uma lista de todos os dispositivos montados no sistema num determinado momento
e seus parâmetros, pois essa informação não está disponível no fstab.
305
O fstab é dividido em colunas, as quais serão explicadas individualmente a seguir:
•• A primeira coluna determina o dispositivo de bloco que contém o sistema de

arquivos que será montado. Neste campo podemos atribuir um sistema de
arquivos remoto;
•• A segunda coluna especifica o ponto de montagem;
•• A terceira coluna especifica o tipo de sistema de arquivos;
•• Na quarta coluna são definidas as opções de montagem para a partição, de

acordo com as possibilidades mostradas na seguinte tabela:
Opção Descrição
defaults Inicializa a partição com valores padrão de montagem.
rw Permite a modificação de dados na partição.
ro Montará a partição com permissão de somente leitura.
Os dados atribuídos aos dispositivos serão gravados de maneira
sync
imediata.
A partição será montada automaticamente na inicialização do
auto
sistema.
noauto A partição não será montada na inicialização do sistema.
Opção exclusiva para montagem manual, promove a remontagem de
remount um dispositivo já montado, com a possibilidade de adicionar outras
opções.
Garante permissão a qualquer usuário para habilitar e desabilitar o
users
dispositivo.
Permite que usuários comuns habilitem o dispositivo, mas só o
user
usuário que o montou tem permissão para desmontá-lo.
Após montado o dispositivo, suas permissões se adequarão ao
owner
usuário responsável por sua montagem.
usrquota Habilita o uso de cotas de disco para usuário.
grpquota Habilita o uso de cotas de disco para grupo.
Vejamos um exemplo de como visualizar as configurações armazenadas em /etc/

fstab. No caso, utilizamos o editor vi:
306
Então, a lista é mostrada:
5.1.10. Particionando discos
Já falamos diversas vezes sobre partições, inclusive com uma explicação detalhada
sobre o padrão seguido por sistemas GNU/Linux para nomeá-las, agora passaremos
à sua definição de fato e aos processos por meio dos quais as partições podem ser
criadas.
Partições são divisões lógicas do disco rígido, sem as quais é impossível gravar
arquivos no computador. Uma vez definidas, as partições delimitam onde será criado e
armazenado cada sistema de arquivos, de forma organizada. Normalmente, os discos
já vêm particionados de fábrica, porém o esquema de partições é personalizável e
pode ser alterado pelo próprio usuário.
Como foi visto recentemente, sistemas operacionais da Microsoft apresentam as

partições num sistema de letras, como C: e D:. Já em sistemas GNU/Linux, as partições,
que podem ser acessadas no diretório /dev, recebem nomes de acordo com o tipo de
dispositivo de armazenamento. Caso queira relembrar como elas são organizadas, o
aluno pode consultar o tópico 4 deste capítulo.
As partições padrão são chamadas primárias e só podem existir num limite de quatro
em qualquer PC. Para superar essa limitação, é possível trocar uma das partições
primárias por uma partição estendida, que funciona como hospedeira para mais
partições lógicas.
O comando cat, quando seguido do caminho completo de uma partição, permite

verificar o conteúdo dessa partição, porém sua saída é inteligível somente ao
computador. Para que o usuário possa compreendê-la, precisa proceder com a
montagem de dispositivo.
O comando cat costuma levar bastante tempo para exibir sua saída. O processo pode
ser interrompido com o atalho CTRL + C ou ainda digitando reset, caso o atalho não
produza resultado.
307
5.1.11. UUID (Universally Unique Identifier)

O UUID é o número de identificação atribuído a um sistema de arquivos. Esse número
não é alterado, independentemente de qualquer mudança na BIOS do computador
ou no kernel, processos que geram uma reorganização e renomeação das partições
dentro do diretório /dev. Uma vez que os nomes dos arquivos tenham sido trocados,
o usuário pode ter problemas em localizar o que procura no /dev, tornando uma
busca pelo UUID eficiente.
Há três formas de aquisição do UUID dos arquivos. A primeira delas é o comando

blkid, que identifica o UUID, o arquivo correspondente no /dev, o tipo de sistema de
arquivos usado e o label, caso exista algum, de todas as partições locais.
O exemplo a seguir demonstra a utilização do comando blkid:
Outro comando que pode ser utilizado é o vol_id, que informa o UUID de uma
participação específica, como podemos ver adiante:
Também, é possível utilizar o comando ls da seguinte maneira, a fim de obter o UUID

de arquivos:
308
5.1.12. Partição swap
Partições swap são espaços alocados em disco que funcionam como memória adicional,
para aliviar a carga sobre a memória RAM do computador, evitando lentidões no
funcionamento do sistema ou travamentos.
Um desses espaços já é gerado automaticamente com a configuração padrão do

sistema e acionado a cada boot, porém, dependendo do que se exige do computador,
ainda mais memória pode vir a ser necessária. Para isso, partições swap podem ser
criadas, separadas das outras partições comuns.
Com o comando mkswap, transforma-se uma partição ou mesmo um arquivo comum

em área de swap, bastando usar como argumento do comando o caminho completo
para a partição ou o arquivo em questão. Após configurados como swap, eles precisam
ser acionados com o comando swapon, que também deve vir seguido do caminho
completo para a partição ou o arquivo no lugar do argumento. Para desativa-los, o
comando usado é o swapoff.
A tabela a seguir descreve opções que podem ser utilizadas com o comando swapon:
Opção Descrição
Ativa todas as partições do fstab que estiverem marcadas como
swap. Quando usado como argumento do comando swapoff, faz
-a justamente o contrário: desativa todos os espaços de swap. As
partições que estiverem com a opção noauto não serão afetadas por
esse argumento nem para ativação, nem para desativação.
-a -e Ignora sem notificação alguma as partições não encontradas.
-s Exibe detalhes do uso de cada partição ou arquivo de swap.
Indica a prioridade de uso dos espaços de swap disponíveis. O valor
de <N> varia de 0 a 32767, sendo que, quanto mais alto o valor,
-p <N>
maior a prioridade. Partições com o mesmo valor de prioridade são
usadas simultaneamente.
-L <nome> Usa a partição de rótulo <nome>.
-U <UUID> Usa a partição cujo UUID seja igual a <UUID>.
309
5.1.13. Aplicando um sistema de arquivos

Uma vez particionado o disco por meio dos processos vistos até agora, é preciso
preparar a partição criada para o recebimento e registro de informações novas de
maneira organizada e estruturada. A forma que o usuário tem de fazer isso é aplicando
um sistema de arquivos à partição.
Embora esse seja um procedimento diferente de formatar discos, ambos compartilham

uma consequência que não pode ser esquecida: todo o conteúdo da partição é
apagado quando um sistema de arquivos é aplicado a ela, portanto o usuário deve
ser extremamente cauteloso durante o processo.
5.1.14. mkfs
Este comando é utilizado para criar um sistema de arquivos no dispositivo. Em outros
termos ele realiza a formatação lógica dos dispositivos. A sintaxe do comando mkfs
é a seguinte:
mkfs [opcao] <dispositivo>
É importante que o sistema de arquivos que aplicaremos seja suportado pelo kernel.
Para consultar a lista de sistemas de arquivos suportados, acesse o arquivo /proc/
filesystems.
Algumas opções do comando mkfs são descritas na tabela a seguir:
Opção Descrição
-v Modo verboso (exibe com detalhes as operações efetuadas).
-c Realiza a verificação de blocos ruins no dispositivo.
Informa qual será o tipo de sistema de arquivos formatado no
-t <sistema_arq>
dispositivo especificado.
310
O exemplo a seguir realiza a formatação lógica do dispositivo e insere o sistema de
arquivos ext3:
Podemos utilizar a seguinte sintaxe para definir os sistemas de arquivos:
mkfs.<sistema_arq>
5.1.15. mke2fs
O comando mke2fs, cuja sintaxe é exibida a seguir, é utilizado para criar sistemas de
arquivos ext2, ext3 e ext4 em dispositivos de armazenamento:
mke2fs [opcao] <dispositivo>
A tabela a seguir descreve as principais opções utilizadas com mke2fs:
Opção Descrição
-F Força a execução do comando no dispositivo informado.
-j Cria um sistema de arquivos ext3 no dispositivo informado.
-c Varre o dispositivo informado à procura de blocos ruins.
-L Atribui um rótulo ao dispositivo.
-v Exibe detalhes sobre a execução do comando.
-V Exibe a versão do comando.
311
O próximo exemplo utiliza o mke2fs para criar um sistema de arquivos ext3 no

dispositivo informado:
5.1.16. mkreiserfs
Este comando é utilizado para criar uma partição e determinar que o dispositivo
trabalhará com o sistema de arquivos reiserfs. Sua sintaxe é a seguinte:
mkreiserfs [opcao] <dispositivo>
A seguir, podemos visualizar a descrição das opções mais utilizadas deste comando:
Opção Descrição
Define o tamanho do bloco, em bytes. Os valores aceitos estão em
-b
uma faixa de 512 até 8192 bytes.
-l Permite definir um nome de volume para o dispositivo.
312
O exemplo a seguir formata o dispositivo com o sistema de arquivos reiserfs:
O próximo exemplo, além de formatar o dispositivo com o formato de arquivo

reiserfs, define uma etiqueta para o volume:
313
5.1.17. mkfs.xfs
Este comando é utilizado para criar uma partição e determinar que o dispositivo
trabalhará com o sistema de arquivos xfs. Sua sintaxe é a seguinte:
mkfs.xfs [opcao] <dispositivo>
A seguir, podemos visualizar a descrição das opções mais utilizadas deste comando:
Opção Descrição
Define o tamanho do bloco, em bytes. Os valores aceitos estão em
-b
uma faixa de 512 até 65535 bytes.
-L Permite definir um nome de volume para o dispositivo.
O exemplo a seguir formata o dispositivo com o sistema de arquivos xfs:
O próximo exemplo, além de formatar o dispositivo com o formato de arquivo xfs,

define uma etiqueta para o volume:
Uma outra forma de adicionar um nome no volume seria utilizando o comando xfs_
admin:
314
5.1.18. Manutenção do sistema de arquivos
Passaremos agora à descrição de alguns comandos que permitem a obtenção de
informações sobre sistemas de arquivos, depuração e configuração de parâmetros,
auxiliando na manutenção dos sistemas.
5.1.19. fsck
O comando fsck realiza a verificação e o reparo de um determinado sistema de
arquivos, ou de um determinado dispositivo de armazenamento. Sua sintaxe é a
seguinte:
fsck [opcao] <dispositivo>
A tabela a seguir descreve as principais opções do comando fsck:
Opção Descrição
Realiza a verificação do sistema de arquivos em todos os
-A
dispositivos listados no arquivo /etc/fstab.
-c Exibe uma barra demonstrando o progresso da instalação.
Exibe somente o resultado do comando, não executa ação
-n
sobre o sistema de arquivo.
-a Realiza o reparo automático do sistema de arquivos.
-t <sistema arq> Define o tipo de sistema de arquivos que o dispositivo contém.
Antes de executarmos a checagem com o comando fsck, devemos desabilitar os

dispositivos e, no caso da raiz do sistema, essa checagem deverá ser realizada no
modo de manutenção.
O exemplo a seguir demonstra o uso do fsck para fazer a checagem e o reparo

automático em um dispositivo que contém o sistema de arquivos ext4:
315
É importante notarmos que, para que possamos utilizar o fsck e ao mesmo tempo
especificar o sistema de arquivos, podemos utilizar a seguinte sintaxe:
fsck.<sistema_arq> <dispositivo>
Exemplo:
fsck.ext4 /dev/sdb1
5.1.20. e2fsck
Este comando realiza a verificação e reparo de sistema de arquivos ext2, ext3 e ext4
em dispositivos de armazenamento. Sua sintaxe é a seguinte:
e2fsck [opcao] <dispositivo>
A tabela a seguir descreve as principais opções do comando e2fsck:
Opção Descrição
-f Força a checagem do dispositivo informado.
-p Realiza o reparo do sistema de arquivos automaticamente.
O exemplo a seguir utiliza o e2fsck para checar e reparar um sistema de arquivos no

dispositivo informado:
5.1.21. reiserfsck
O comando reiserfsck permite realizar a verificação de dispositivos que utilizam o
sistema de arquivos reiserfs. Sua sintaxe é a seguinte:
reiserfsck [opcao] <dispositivo>
Na tabela a seguir, temos a descrição das opções mais utilizadas com reiserfsck:
Opção Descrição
-a Verifica todos os dispositivos listados no arquivo /etc/fstab.
-y Realiza o reparo automático do sistema de arquivos.
316
O exemplo a seguir demonstra a verificação e a correção do sistema de arquivos no
dispositivo definido por meio do reiserfsck:
5.1.22. xfs_repair
O comando xfs_repair permite realizar a verificação de dispositivos que utilizam o
sistema de arquivos xfs. Sua sintaxe é a seguinte:
xfs_repair [opcao] <dispositivo>
Na tabela a seguir, temos a descrição das opções mais utilizadas com xfs_repair:
Opção Descrição
Apenas informa os erros que deverão ser corrigidos, sem efetuar
-n
as devidas alterações.
-v Exibe a saída do comando em modo detalhado.
317
O exemplo a seguir demonstra a verificação e a correção do sistema de arquivos no

dispositivo definido por meio do xfs:
5.1.23. debugfs
O debugfs é o comando responsável por depurar o sistema de arquivos de forma
interativa, nos sistemas de arquivos ext2, ext3 e ext4. Por meio desse comando,
podemos checar e alterar o estado apresentado pelo sistema de arquivos. Sua sintaxe
é a seguinte:
debugfs [opção] [dispositivo]
318
As principais opções utilizadas com o debugfs são as seguintes:
Opção Descrição
-b <tamanho_do_ Esta opção tem a finalidade de forçar a utilização de um
bloco> tamanho de bloco para o sistema de arquivos.
Esta opção faz com que a leitura do superbloco do sistema
de arquivos seja realizada a partir da quantidade de blocos
-s <superbloco>
determinada. Isso significa que, quando utilizamos essa
opção, devemos também definir a opção -b.
-V Essa opção exibe a versão do debugfs.
Esta opção determina que o sistema de arquivos será aberto
-w em modo read-write (leitura e gravação). Caso não utilizemos
essa opção, o modo de abertura do sistema é somente leitura.
O próximo exemplo exibe a execução do comando debugfs:
319
5.1.24. dumpe2fs
O comando dumpe2fs é utilizado para obter informações de sistemas de arquivos
ext2, ext3 e ext4. Sua sintaxe é apresentada a seguir:
dumpe2fs [opcao] <dispositivo>
A seguir, são descritas algumas opções do comando dumpe2fs:
Opção Descrição
-b Exibe os blocos defeituosos.
-x Exibe descrição dos blocos do grupo em formato hexadecimal.
-V Exibe a versão do comando.
Podemos observar a execução do comando dumpe2fs no exemplo a seguir:
O resultado do comando anterior é parecido com o exibido adiante:
320
5.1.25. tune2fs
Por meio do comando tune2fs, o administrador do sistema pode configurar parâmetros
para os sistemas de arquivos ext2, ext3 e ext4. A sintaxe desse comando é a seguinte:
tune2fs [opcao] <dispositivo>
A tabela a seguir descreve as principais opções do comando tune2fs:
Opção Descrição
Esta opção é responsável por configurar o número máximo
-c <valor> de montagens entre duas verificações do sistema de
arquivos.
Esta opção determina o grupo de usuários que poderá
-g <grupo>
utilizar os blocos reservados.
O objetivo desta opção é adicionar um journal ao sistema
-j de arquivos. Muito utilizado para realizar a conversão de
sistema de arquivos ext2 para ext3.
-l Exibe o conteúdo do superbloco do sistema de arquivos.
Esta opção é responsável por configurar a porcentagem de
-m <numero_blocos>
blocos reservados em um determinado dispositivo.
Define o usuário que poderá utilizar os blocos reservados
-u <usuario>
no sistema de arquivos.
Esta opção é responsável por determinar a quantidade de
-C
vezes que o sistema de arquivos já foi montado.
Opção responsável por definir um rótulo para o volume no
-L <rotulo_volume>
sistema de arquivos.
O exemplo a seguir utiliza o tune2fs para alterar a quantidade de montagem máxima

do arquivo:
No exemplo a seguir, o rótulo do volume do dispositivo é alterado:
321
Já no exemplo a seguir, utilizamos o tune2fs para definirmos a quantidade de

montagem máxima para a verificação do sistema de arquivos e alterarmos para 10%
a porcentagem de blocos reservados no sistema de arquivos:
Dicas LPI
•• O UDEV não superpopula o diretório /dev do nosso sistema, além de nos

proporcionar um método de configuração disponível em /etc/udev/;
•• O uso dos métodos de LABEL ou UUID em conjunto com o arquivo /etc/

fstab nos proporciona uma solução inteligente para o dia a dia e para a
prova;
•• Existem muitos comandos que permitem descobrir o que temos conectado

em nossas máquinas, dentre eles: lspci, lsusb e lsscsi;
•• As informações obtidas com o comando dmesg são providas pelo arquivo

/var/log/dmesg;
•• Uma alternativa para a montagem aleatória do sistema é utilizar o pacote

autofs, que provê toda uma estrutura configurável para os dispositivos.
Para usar autofs, seu sistema precisa usar Kernel 2.6 ou superior, e ter a
partição /dev com udev;
•• As ferramentas de manutenção do xfs, conhecidas como xfs-tools, podem

oferecer alguns pontos positivos na prova. O pacote equivalente no Debian
se chama xfsprogs. Vale a pena dar uma estudada nessas ferramentas!
•• As informações dos dispositivos que estão montados podem ser obtidas

no arquivo /etc/mtab ou no /proc/mounts. Ambos os arquivos são uma
tabela atualizada em tempo real e que mostra quais dispositivos estão
montados e com quais parâmetros;
•• Para verificar todas as partições criadas na máquina, use o comando cat /

proc/partitions;
•• O arquivo /etc/fstab é criado automaticamente quando o GNU/Linux é

instalado, gerando a lista de partições padrões a serem carregadas.
322
5.2. Árvore de diretórios FHS
Compreender a estrutura de diretórios em sistemas GNU/Linux não é algo complexo,
entretanto, usuários não acostumados a utilizar a linha de comandos como em
sistemas MS-DOS podem encontrar certa dificuldade. De modo geral, entender a forma
como os diretórios estão organizados e a principal distinção entre eles é essencial
para manipular o sistema de forma ágil e poder trabalhar de forma segura.
Antes de iniciarmos uma abordagem sobre o padrão FHS (Filesystem Hierarchy

Standard), é necessário que tenhamos uma visão mais abrangente dessa hierarquia
de diretórios, navegando e conhecendo os principais aspectos, particularidades e
diferenças.
5.2.1. Diretórios
Diretórios são, basicamente, os lugares onde os arquivos do sistema são armazenados.
Como tudo em sistemas GNU/Linux são arquivos, a estrutura de diretórios do sistema
operacional organiza hierarquicamente todos os textos, imagens, programas,
dispositivos, planilhas, entre outros.
Os sistemas GNU/Linux herdam do Unix o aspecto case-sensitive, que consiste na

habilidade de diferenciar caracteres maiúsculos de minúsculos, de forma que o
usuário deve lembrar-se disso quando for nomear seus arquivos e diretórios para
que, quando precisar, possa localizar e acessar exatamente o que procura.
5.2.2. Hierarquia de diretórios
A estrutura de diretórios GNU/Linux, que segue o padrão POSIX (Portable Operating
System Interface), está dividida de forma hierárquica, na qual temos o conceito de
diretório pai e diretório filho. Diferentemente de outros sistemas operacionais que
dividem sua estrutura por discos e partições, em sistemas Unix-like, essa estrutura
será dividida hierarquicamente em uma árvore de diretórios, em que praticamente
tudo é um arquivo, inclusive os próprios dispositivos, como discos ou partições, que
são representados pelos respectivos arquivos especiais e acessados por meio do
processo de montagem.
Essa diferença e o conceito de tipos de arquivos que podem ser utilizados para
representar os dispositivos permitem que a estrutura e, inclusive, a forma de
manipular e gerenciar o sistema, sejam diferenciadas. Um bom exemplo é comparar
essa estrutura de diretórios a uma árvore, em que o principal diretório presente nos
sistemas Unix-like é referenciado pelo nome raiz e é representado por uma barra (/).
323
O diretório raiz é o diretório pai de todos os diretórios do sistema. É o primeiro

diretório da hierarquia e aloca, consequentemente, toda a estrutura detalhada adiante.
O nome raiz é justamente comparado à raiz de uma árvore e, ao virá-la de cabeça

para baixo, teremos a raiz no topo da hierarquia, o tronco representando a estrutura
estendida, e os galhos, que estão ligados a esse tronco principal, representando os
subdiretórios, e assim sucessivamente.
A imagem adiante ilustra a hierarquia de diretórios descrita:
5.2.3. FHS
As primeiras iniciativas em criar uma padronização para sistemas de arquivos para
distribuições GNU/Linux surgiram em 1994, com a criação do Filesystem Standard
(FSSTND). Mais tarde, foram adotadas regras de estrutura e armazenamento de
diretórios estabelecidas pelo Filesystem Hierarchy Standard, ou FHS.
O FHS foi desenvolvido pela LSB (Linux Standard Base), uma instituição sem fins
lucrativos que foi criada em 1998 para desenvolver e manter padrões para certificar
distribuições GNU/Linux.
324
O FHS provém das especificações de sistemas Unix, formando uma rica base para
manter a compatibilidade e a portabilidade entre as distribuições GNU/Linux. Dessa
forma, fabricantes de software podem aproveitar esse padrão para gerar aplicações
que podem ser executadas em distribuições distintas, certificadas pela Linux
Standard Base, e que seguem o padrão FHS. Mais informações sobre a LSB podem ser
encontradas em www.linuxfoundation.org/en/LSB.
O padrão FHS, desenvolvido e mantido pela LSB, é um dos padrões que uma distribuição
certificada pela LSB deve seguir em relação à posição e à estrutura dos diretórios no
sistema.
Tal definição sobre a distinção dos diretórios se dá por dois motivos essenciais:
os aplicativos desenvolvidos para distribuições que seguem o FHS poderão,
automaticamente, presumir a localização de diretórios específicos e, ainda, os
usuários em geral poderão ter uma ideia dessa estrutura de diretórios, deixando o
gerenciamento do sistema mais ágil e prático no momento de encontrar determinados
arquivos em uma manutenção. É possível encontrar as versões completas do FHS em
www.pathname.com/fhs/.
A seguir, abordaremos o formato do padrão FHS, com base em sua última versão.
5.2.4. Distinção dos diretórios

Existem duas categorias nas quais poderemos encaixar os diretórios do sistema GNU/
Linux. Definir os diretórios em suas respectivas categorias ajuda a entender melhor
seu conteúdo e sua importância para o sistema. Temos a primeira categoria, em que
definiremos o diretório como compartilhado ou não-compartilhado. Já a segunda
categoria poderá definir o conteúdo de um diretório como estático ou variável.
Ambas as categorias foram criadas para definir quais tipos de diretórios poderemos
compartilhar em rede ou, até mesmo, definir como o conteúdo daquele diretório
poderá ser acessado.
•• Diretórios compartilhados ou não-compartilhados
Os diretórios se enquadrarão na categoria de compartilhado ou não-compartilhado

dependendo de seu conteúdo, que pode ser conteúdo essencial para a inicialização
do sistema ou informações específicas da máquina e do hardware presente nela.
Quando um diretório é considerado compartilhado, significa que poderá ser

compartilhado entre diversos hosts em uma rede, como o diretório /home.
Se um diretório for considerado um diretório não-compartilhado, é porque,

provavelmente, ele armazena informações específicas do seu sistema, como o
diretório /etc ou /boot.
325
•• Diretórios estáticos ou variáveis
A categoria de diretório estático ou variável também segue as regras impostas

pela categoria de diretório compartilhado ou não-compartilhado. Porém, quando
um diretório contiver alguma informação específica do sistema atual ou essencial
para a inicialização, ele será considerado um diretório estático, em que apenas o
superusuário terá permissão para editar as informações nele contidas, como o /bin.
Um diretório é considerado variável quando suas informações puderem ser editadas
por qualquer usuário do sistema. Provavelmente, serão informações não relevantes à
inicialização do sistema, ou específicas do host atual, como o diretório /var/spool/.
Assim, poderemos definir quando um diretório terá permissões de leitura e gravação.
5.2.5. Estrutura de diretórios
O padrão FHS mantém a existência dos diretórios descritos na tabela a seguir:
Representado por uma barra, este diretório contém todos os outros
diretórios do sistema. Trata-se do principal diretório de um sistema
/ (raiz)
GNU/Linux. Todos os arquivos e diretórios estão situados sob ele,
mesmo os dispositivos externos.
Contém arquivos binários de comandos que são essenciais para a
bin
inicialização básica do sistema.
Contém informações dos gerenciadores de inicialização, arquivos
boot
de imagem do kernel e auxiliares.
dev Arquivos orientados a dispositivos gerais e outros arquivos especiais.
Contém arquivos de configuração para o sistema, aplicações e
etc
serviços.
Contém bibliotecas dinâmicas, essenciais à inicialização básica do
lib
sistema. Armazena, também, módulos do kernel.
media Pontos de montagem para mídias removíveis.
mnt Utilizado em pontos de montagem de uso temporário.
Utilizado para instalar pacotes adicionais por meio do processo de
opt
compilação.
Como o /bin, contém arquivos binários essenciais à inicialização
sbin
básica do sistema, porém, é utilizado somente em nível administrativo.
Contém informações estáticas de serviços disponibilizados pelo
srv
sistema.
326
tmp Armazena arquivos de ordem temporária.
Mantém informações estáticas de aplicativos e serviços gerais
usr
instalados no sistema.
Contém informações variáveis, tanto do sistema como de aplicativos
var
em geral. Arquivos de log e caixa de correio estão contidos em /var.
A seguir, temos os diretórios opcionais, que podem ser instalados no sistema:
home Diretório para centralizar dados pessoais dos usuários comuns.
root Diretório para centralizar dados pessoais do superusuário root.
Acompanharemos, adiante, informações detalhadas sobre os subdiretórios contidos

em /.
5.2.5.1. /bin
O diretório /bin contém os arquivos binários dos comandos essenciais à inicialização
do sistema, que podem ser utilizados tanto pelo usuário do tipo administrador (root),
como por usuários comuns, pois é um diretório público.
Esses comandos também podem ser utilizados de forma indireta por algum shell
script, um aplicativo criado por meio dos recursos dos interpretadores de comandos
bash ou sh, por exemplo. O shell script segue a ideia de uma linguagem interpretada,
que é lida e executada, linha por linha. Por convenção, não devemos criar subdiretórios
nessa estrutura.
Por ser um diretório essencial à inicialização básica do sistema, como uma inicialização
em modo de segurança, tal diretório não pode ficar em uma partição diferente daquela
em que se encontra o diretório raiz (/).
327
Na tabela a seguir, podemos ver alguns dos comandos presentes em /bin:
Comando Descrição
alias Define um alias (nome alternativo) para algum comando.
cat Exibe o conteúdo do(s) arquivo(s) na saída padrão (stdout).
Comando utilizado para gerenciar as permissões de arquivos
chmod
e diretórios.
cp Utilitário para cópia de arquivos e diretórios.
date Exibe a data e a hora atuais do sistema.
echo Copia um texto específico ou conteúdo da variável.
Quando usado sem argumentos, exibe as variáveis de ambiente
env e seus conteúdos. Pode executar um comando com variável de
ambiente modificada.
exec Substitui a sessão atual do shell.
Seleciona uma variável de ambiente para a sessão e todas as
export
sessões iniciadas a partir dela.
ls Comando para listar o conteúdo de diretórios.
mkdir Cria diretórios.
mv Move ou renomeia arquivos e diretórios.
ps Exibe uma lista de processos em execução.
pwd Exibe o caminho completo do diretório corrente.
sed Editor de textos em nível de linha de comando.
Define o valor de uma variável. Quando usado sem argumentos,
set
mostra todas as variáveis já definidas.
unset Exclui uma variável na sessão.
5.2.5.2. /boot
O diretório /boot mantém informações essenciais à inicialização básica do sistema.
Podemos citar, como exemplo, arquivos estáticos dos gerenciadores de inicialização
(boot-loaders) e o próprio arquivo binário de imagem do kernel, que dará início ao
sistema, assim como seus auxiliares.
O gerenciador de inicialização GRUB 2 armazena seus arquivos de configuração

dentro da estrutura do /boot, no subdiretório grub.
328
5.2.5.3. /dev
O diretório /dev armazenará, em sua estrutura, arquivos especiais de sistema que
poderão ser utilizados para acessar determinados dispositivos, como uma partição,
uma unidade de CD, DVD ou, até mesmo, um pen drive. É através desses arquivos
no /deb que o GNU/Linux estabelece o diálogo entre o sistema e os dispositivos
periféricos do computador.
Tais arquivos especiais também poderão ser utilizados em simples transferências de

informações, utilizando portas seriais, paralelas etc.
Por ser um diretório essencial à inicialização básica do sistema, como

uma inicialização em modo de segurança, tal diretório não pode ficar em
uma partição diferente da partição em que se encontra o diretório raiz (/).
5.2.5.4. /etc
O diretório /etc mantém toda a estrutura de arquivos e diretórios para configurar
tanto o sistema quanto os serviços e aplicações. Configurações padrão de logins de
usuários, scripts de inicialização do sistema, tabela do sistema de arquivos, entre
outros, ficam armazenados nesse diretório.
Por convenção, não devemos alocar arquivos binários executáveis dentro dessa
estrutura. A tabela adiante ilustra a descrição dos principais arquivos:
Arquivo Descrição
/etc/hostname Arquivo para definir o nome da máquina (hostname).
/etc/network Diretório com as configurações das interfaces de rede.
Diretório com as configurações do servidor X atualmente
/etc/X11
instalado.

uma partição diferente da partição em que se encontra o diretório raiz (/).
329
5.2.5.5. /lib
O diretório /lib armazena as bibliotecas dinâmicas que são essenciais à inicialização
básica do sistema. Diversos programas do sistema operacional fazem uso de
bibliotecas.
Essas bibliotecas dinâmicas são utilizadas pelos comandos que se encontram em /

bin e /sbin, por exemplo.
Na estrutura do diretório /lib, teremos os arquivos binários de bibliotecas dinâmicas

em questão, que são chamados de real-name, além de diversos links simbólicos,
chamados de so-name, que são ponteiros para os real-name de bibliotecas. Essa
estrutura se dá pelo fato de gerenciarmos bibliotecas dinâmicas de forma prática.
O diretório /lib armazena um subdiretório importante, como apresentado a seguir:
Estrutura de armazenamento de módulos e informações
modules
das versões de kernel instaladas.

uma partição diferente da partição em que se encontra o diretório / (raiz).
5.2.5.6. /media
O diretório /media é utilizado para manter pontos de montagem para dispositivos de
mídia removíveis, como CD-ROM, DVD, disquetes, dispositivos USB etc.
Antigamente, a convenção para montar tais dispositivos era dentro do diretório /mnt,
ou no próprio diretório / (raiz). Essa organização mantém a localização para o acesso
a esses pontos de montagem, de maneira mais intuitiva e prática.
5.2.5.7. /mnt
O diretório /mnt era utilizado, antigamente, para armazenar os pontos de montagem
para dispositivos em geral, como CD-ROM, disquetes, entre outros. Com a criação
do /media, esse diretório ficou responsável por manter pontos de montagem para
sistemas de arquivos temporários, para acessar uma partição temporariamente,
copiar um dado específico e prover o compartilhamento de arquivos entre sistemas,
por exemplo.
330
5.2.5.8. /opt
É utilizado para manter uma organização importante no sistema no que diz respeito
a programas que serão instalados e que não pertencem à distribuição em uso, os
quais, geralmente, são instalados por meio do método de compilação. Também lida
com a organização de softwares proprietários. Os programas que serão instalados a
partir de /opt deverão ter um diretório específico com o seu respectivo nome, e esse
diretório poderá ser utilizado futuramente para removê-lo, por exemplo.
5.2.5.9. /sbin
Este diretório também armazena arquivos binários de comandos essenciais à
inicialização do sistema, porém, esses comandos são de uso específico do usuário
administrador. Além dos comandos de inicialização, outros de restauração, reparo e/
ou recuperação do sistema ficam guardados nesse diretório.
Existem outros diretórios sbin no sistema, como em /usr/sbin ou /usr/local/sbin/.

Existem semelhanças e diferenças entre eles, as quais serão abordadas a seguir.
Adiante, acompanharemos exemplos de comandos presentes no /sbin:
Comando Descrição
fdisk Gerencia a tabela de partições.
fsck Ferramenta para checar e reparar sistemas de arquivos.
halt Comando para desligar o sistema.
ifconfig Utilizado para gerenciar as interfaces de rede.
mkfs Formata partições com o sistema de arquivos indicado.
reboot Reinicia o sistema.

uma partição diferente da partição em que se encontra o diretório / (raiz).
331
5.2.5.10. /srv
Este diretório possibilita obter informações estáticas de serviços disponibilizados
pelo sistema, que poderão ser compartilhadas. O /srv é usado para centralização
de dados de serviços disponíveis a todos os usuários. As informações poderão ser
compartilhadas somente para leitura, e é importante ressaltar que só poderão ser
removidas pelo administrador do sistema.
Protocolos como CVS, FTP, www e rsync são exemplos de utilização de tal diretório
em nível administrativo.
5.2.5.11. /tmp
Este diretório é utilizado apenas como um centralizador de dados temporário, que é,
geralmente, de uso exclusivo do próprio sistema e, principalmente, das aplicações.
Também pode ser utilizado por usuários para alocar informações temporárias,
porém, é importante ressaltar que qualquer informação alocada no diretório /tmp é
automaticamente apagada ao desligar o sistema.
Por ser um diretório com permissões abertas, em que qualquer usuário pode gravar
dados, recomenda-se alocar o /tmp em uma partição separada da partição / (raiz), ou
redefinir suas permissões especiais e utilizar um controle de limites no sistema, para
não gerar danos por usuários mal-intencionados.
5.2.5.12. /usr
O diretório /usr é conhecido por manter a segunda maior estrutura de subdiretórios
do sistema. Sendo um diretório portável, ele contém praticamente uma segunda
árvore de diretórios inteira, independente da primeira. Os dados desse diretório
são, geralmente, informações estáticas de programas, comandos, serviços e outros,
que seguem o padrão GNU/Linux e que não são essenciais à inicialização básica do
sistema.
É um diretório que poderá ser compartilhado entre vários hosts que seguem o FHS,
disponíveis somente para leitura; porém, seu conteúdo só poderá ser modificado
pelo superusuário. A maior recomendação para este diretório é que não se aloque ou
modifique nenhum tipo de informação de forma manual.
332
Há muitas semelhanças com alguns diretórios já vistos, mas também há diferenças,
justamente pela organização que o diretório /usr apresenta. Seus subdiretórios
organizam as informações, como dados de programas, comandos e serviços, de
forma classificatória e são divididos conforme a tabela a seguir:
Contém, como o /sbin, arquivos binários executáveis, não
bin essenciais para a inicialização básica do sistema, e de uso geral
por parte dos usuários.
Armazena arquivos de cabeçalho, muito utilizados na linguagem C
include
e, geralmente, com a extensão .h.
Mantém bibliotecas dinâmicas, que serão utilizadas, geralmente,
lib
pelos programas em /usr/bin e /usr/sbin.
Hierarquia local não compartilhada (utilizada por aplicativos que
local
são instalados de forma local, instalações a partir do código-fonte).
Contém, como o /bin, arquivos binários executáveis não essenciais
sbin à inicialização básica do sistema, porém de uso específico do
usuário root.
Contém dados e informações específicas das aplicações que podem
ser compartilhadas e são independentes de alguma arquitetura
share
específica. Há também muita documentação sobre o sistema e
programas nesse diretório.
Utilizado para armazenar o código-fonte de programas e,
src
principalmente, do kernel, no momento de sua recompilação.
Apesar de alguns diretórios citados em /usr já existirem dentro da / (raiz), esses

são completamente diferentes, visto que o conteúdo do diretório /usr poderá ser
compartilhado (exceto /usr/local) e não é essencial à inicialização básica do sistema.
5.2.5.13. /var
O diretório /var mantém informações e dados que sofrerão variações constantemente
(conteúdo dinâmico). Uma infinidade de serviços utiliza alguns subdiretórios de /var
para armazenar seus dados, como o gerenciador de fila de impressão, e-mail, log etc.
É um diretório muito importante para o funcionamento geral do sistema e serviços
implantados.
É necessário redobrar a atenção ao querer particionar esse diretório. Um tamanho

mal calculado poderá sobrecarregá-lo, e o sistema poderá ficar indisponível durante
a manutenção.
333
Podemos acompanhar, no quadro a seguir, alguns subdiretórios presentes em /var:
Diretório utilizado por aplicações, como o gerenciador de pacotes
cache
apt.
log Armazena os logs gerados pelo sistema, aplicações e serviços.
Diretório para armazenar a estrutura de serviços de e-mail, como
mail
contas de e-mail dos usuários, domínios etc.
Armazena informações que serão futuramente processadas, como
spool
fila de impressão e agendamento de tarefas.
tmp Arquivos temporários que poderão ser reutilizados mesmo após o reboot.
5.2.5.14. Diretórios opcionais
Dois subdiretórios do diretório raiz (/) merecem destaque: /home e /root. Ambos
não precisam necessariamente existir no sistema, ou seja, são opcionais. No entanto,
para fins de adequação ao padrão FHS, é recomendável mantê-los.
Uma peculiaridade desses dois subdiretórios é a possibilidade de alteração de seus

nomes sem gerar problemas para a estrutura do sistema. Podemos alterar o nome do
/home para /pessoal, por exemplo.
•• /home
O diretório /home é utilizado para centralizar os diretórios pessoais de cada usuário

comum presente no sistema. A presença desse diretório é opcional, porém, caso
exista no sistema, para seguir o padrão FHS, é recomendável centralizar os diretórios
pessoais dos usuários comuns nessa estrutura.
Teremos, como conteúdo para esses diretórios, os arquivos de profile (perfil)

específicos dos usuários, configurações de aplicações e, também, o armazenamento
dos arquivos pessoais. Manter essa estrutura organizada facilita o processo de
backup, por exemplo.
•• /root
O diretório /root tem uma grande semelhança com o diretório /home, porém, é
utilizado para armazenar apenas os arquivos pessoais, profiles e configurações
específicas do administrador do sistema (usuário root). Apesar de ser opcional, manter
o diretório /root é uma boa escolha, pois os arquivos do usuário administrador ficarão
separados dos que pertencem aos usuários comuns.
5.2.5.15. Diretórios especiais
Também são subdiretórios do diretório raiz o /proc e o /sys, considerados arquivos
especiais. O primeiro armazena configurações do sistema. O segundo, arquivos graváveis
que permitem a execução de modificações imediatas por meio de seus valores.
334
•• /proc
Podemos utilizar o diretório virtual /proc para obter informações instantâneas. É

importante notar que as informações contidas nesse diretório não são consideradas
logs, apesar de serem, também, informações do sistema. São apenas um meio de
o kernel, que é o responsável pela manutenção do /proc, comunicar-se com as
aplicações.
Podemos encontrar três tipos de informações no diretório /proc, que são as seguintes:
•• Variáveis do sistema: Arquivos dentro do /proc/sys, um diretório que

possui vários arquivos graváveis que permitem interagir com o kernel e,
assim, fazer modificações imediatas através dos seus valores;
•• Informações de processos: Identificadas por diretórios de formato

numérico como, por exemplo, /proc/N, onde N é o PID (Process ID) do
processo;
•• Informações gerais do sistema: Compostas por arquivos restantes,

que fornecem informações gerais sobre os dispositivos, os sistemas de
arquivos, as partições, e muitos outros tipos de informações. Como essas
informações dependem dos módulos carregados pelo kernel, podem variar
muito de sistema para sistema.
Os subdiretórios do /proc são nomeados de acordo com o PID dos processos a que
eles dizem respeito/sys.
Dentro do diretório /sys podemos encontrar quase o mesmo conteúdo existente em

/proc, mas de uma forma mais organizada para os administradores. O /sys existe
desde a versão 2.6 do kernel e traz funcionalidades no que diz respeito a dispositivos
PnP.
Uma diferença de enfoque entre o /sys e o /proc é que o primeiro hospeda

especificamente informações de dispositivos, ao passo que o segundo abarca também
diversos dados de processos.
Dicas LPI
•• É de vital importância entender bem o FHS para a prova, afinal, é com ele
que devemos trabalhar no dia a dia;
•• Fique atento: Agora, o diretório /media faz parte oficialmente das provas
LPI;
•• O diretório /usr é portável. Perceba que dentro dele existe praticamente

outra árvore de diretórios independente da primeira, contendo lib, bin,
sbin e outros;
•• Fique atento para as diferenças entre “.” e “..” e o que eles representam para
o sistema. Os comandos de movimentação muitas vezes são grandes alvos
nas provas. Uma boa interpretação desses comandos pode ser necessária.
335
5.3. Configuração de cota de disco

O recurso de cotas de disco nos permite restringir a quantidade de espaço de um
disco que poderá ser utilizada por um ou mais usuários. Ativamos o recurso de cotas
quando, por exemplo, o sistema é acessado por vários usuários.
Temos as cotas por blocos, que referem-se ao espaço em disco, e também por inodes,
que determinam o número de arquivos.
O funcionamento do sistema de cotas depende do suporte fornecido a ele pelo sistema

de arquivos e pelo kernel. Concernentes ao sistema de arquivos, existem algumas
alterações que devemos realizar, e que devem ser sucedidas pela remontagem do
sistema de arquivos, edição dos arquivos de controle de cota e distribuição adequada
das quantias. Essas alterações, discriminadas a seguir, serão abordadas ao longo do
capítulo:
•• Inserção de parâmetros de montagem no sistema de arquivos utilizado. Esses

parâmetros são usrquota e grpquota e esse sistema será usado em /etc/fstab;
•• Criação de arquivos de controle na raiz dos sistemas de arquivos utilizados.

Esses arquivos são: aquota.user e aquota.group.
Como mencionado, é possível limitar quanto espaço de disco o usuário – ou o grupo

de usuários – poderá utilizar, impedindo-o de ultrapassar a quantidade determinada.
Essa limitação pode ser feita concedendo parcelas iguais de quantidade de espaço
em disco para cada usuário, proporcionando uma divisão igualitária, já que evita que
certos usuários utilizem mais espaço que outros.
5.3.1. Preparando o sistema para a configuração

de cotas
Para que possamos proporcionar a configuração do serviço de cotas, devemos seguir
basicamente os passos adiante:
1. Instale o pacote de cota. Para isso, você pode utilizar um dos seguintes comandos:
yum install quota (centos)
aptitude install quota (debian)
As imagens a seguir foram extraídas da distribuição Debian, porém elas valem

para a distribuição CentOS. Observe que o que muda no procedimento de quota
diz respeito ao FileSystem utilizado, pois para o Filesystem NFS, por exemplo,
o procedimento é completamente diferente, se comparado ao Filesystem Ext4.
Realizaremos os dois procedimentos no laboratório.
336
2. Edite e altere o arquivo /etc/fstab, inserindo nele as opções usrquota e grpquota
para que o serviço de cotas seja habilitado nos dispositivos. A opção usrquota habilita
cotas para usuários e a opção grpquota habilita cotas para grupos:
3. Crie os arquivos aquota.user e aquota.group para a utilização do serviço de

cotas (estes arquivos devem ser criados em todos os pontos de montagem dos
dispositivos que utilizarão o sistema de cotas). Podemos determinar, tanto para um
usuário como para um grupo, cotas por blocos – ou seja, limites de espaço – e por
inodes. É importante dizer que a criação manual destes dois arquivos só é necessária
em algumas distros. No caso do Debian, ambos serão criados automaticamente ao
reiniciarmos o sistema de arquivos;
4. Remonte os sistemas de arquivos que foram alterados no arquivo /etc/fstab;
# mount -o remount /home
5. Para que as cotas sejam configuradas corretamente, é necessário executar o

comando quotacheck, pois ele faz uma varredura nos dispositivos que têm o serviço
de cota habilitado, informa a quantidade de espaço utilizado em disco e, ainda, a
quantidade de arquivos criados pelo usuário;
337
6. Habilite o serviço de cotas utilizando o comando quotaon.
A seguir, veremos, em detalhes, como usar o quotacheck, o quotaon e outros

importantes comandos aplicados na configuração de cotas de usuários e grupos.
5.3.2. Configurando cotas para usuários e grupos

A seguir, veremos os principais comandos utilizados para configurar cotas.
5.3.3. quotacheck
O comando quotacheck é responsável pela verificação do uso de disco de um sistema
de arquivos. Os arquivos de cota são gerados, conferidos e reparados por ele. Sua
quotacheck [opcoes]
A tabela a seguir descreve algumas opções utilizadas com quotacheck:
Opção Descrição
Esta opção é responsável pela verificação dos sistemas de arquivo
-a
habilitados como automount e localizados em /etc/fstab.
-u Opção padrão, -u verifica as cotas de usuários.
-g Com esta opção, são as cotas de grupos que são verificadas.
Com esta opção, é usado o modo verbose, em que são exibidos mais
-v
detalhes na saída do comando.
5.3.4. edquota
Por meio do comando edquota, é possível configurar as cotas para usuários e grupos
do sistema. Sua sintaxe é a seguinte:
edquota [opcao] <usuario/grupo>
A tabela a seguir descreve as principais opções do comando edquota:
Opção Descrição
-g Efetua a configuração de cotas para um grupo.
Permite definir o tempo do grace period para todos os usuários. O
grace period determina o tempo que o usuário pode utilizar o limite
-t hard. Por padrão, esse tempo é composto por 7 dias. O limite hard
informa a quantidade de espaço que o usuário pode utilizar além do
limite soft (limite comum do espaço), durante um tempo determinado.
-T Permite definir o tempo de grace period para um usuário específico.
-u Efetua a configuração de cotas para um usuário distinto.
338
Vejamos o seguinte exemplo, em que configuraremos as cotas para o usuário teste:

Executado o comando edquota –u teste, editaremos os campos de configuração da
cota do usuário. Costuma-se utilizar o editor de texto padrão do sistema – normalmente
o vi – para a edição desses campos.

Adiante, temos a descrição dos campos existentes para configuração de cotas:
•• blocks: Informa a quantidade de espaço, em kbytes, que o usuário está utilizando

no dispositivo;
•• soft: Informa o limite comum de utilização de espaço em disco;
•• hard: Informa a quantidade de espaço que o usuário poderá utilizar, além do

limite soft, durante um tempo determinado;
•• inodes: Informa a quantidade de arquivos que o usuário criou;
•• soft: Informa o limite comum de criação de arquivos;
•• hard: Informa a quantidade de arquivos que o usuário poderá criar além do

limite soft, durante um tempo determinado.
5.3.4.1. Cotas por bloco e por inode

Com as cotas por bloco, o tamanho de espaço de disco utilizado é limitado. Já as
cotas por inode determinam quantos arquivos e diretórios podemos criar.
A seguir, temos um exemplo de cotas configuradas por bloco:
339
A seguir, temos um exemplo de cotas configuradas por inode:
5.3.5. repquota
Por meio do comando repquota, podemos visualizar um relatório referente à utilização
de cotas dentro do sistema. Sua sintaxe é a seguinte:
repquota [opcoes]
A tabela a seguir descreve as principais opções de repquota:
Opção Descrição
-a Faz referência a todos os usuários e grupos do sistema.
-g Faz referência aos grupos que estão utilizando cotas.
-u Faz referência aos usuários que estão utilizando cotas no sistema.
-v Habilita o modo verbose (detalhado).
A seguir, temos um exemplo de relatório de utilização de cotas obtido por meio do

comando repquota:
5.3.6. quotaon
O comando quotaon é responsável por habilitar o serviço de cotas dentro do sistema.
quotaon [opcoes]
340
A tabela a seguir descreve as principais opções de quotaon:
Opção Descrição
-a Habilita o serviço de cotas para todos os usuários do grupo.
-g Habilita o serviço de cotas somente para os grupos.
-u Habilita o sistema de cotas para os usuários.
-v Exibe o modo verbose.
No exemplo adiante, o serviço de cotas é habilitado:
5.3.7. quotaoff
Para que possamos desabilitar o serviço de cotas, devemos utilizar o comando
quotaoff. Sua sintaxe é a seguinte:
quotaoff [opcoes]
A tabela a seguir descreve as principais opções de quotaoff:
Opção Descrição
-a Desabilita o serviço de cotas para todos os usuários e grupos.
-g Desabilita o serviço de cotas somente para os grupos.
-u Desabilita o sistema de cotas para os usuários.
-v Exibe o modo verbose.
No exemplo a seguir, o serviço de cotas é desabilitado:
Antes de reativar o serviço de cotas desabilitado por meio do quotaoff, é necessário

executar o comando quotacheck, a fim de que seja feita uma nova varredura nos
dispositivos e seja informada a quantidade correta de espaço em disco utilizada e o
número de arquivos criados.
341
5.3.8. quota
Exibe a configuração das cotas de maneira simples, e o resultado é muito parecido
com o arquivo de configuração de cotas. Sua sintaxe é a seguinte:
quota [opcao] <usuario/grupo>
A tabela a seguir descreve as principais opções de quota:
Opção Descrição
Exibe as informações de maneira mais legível, como, por
-s
exemplo, tamanho em MB de espaço em disco utilizado.
-g Exibe a configuração da cota do grupo especificado.
-u Exibe a configuração da cota do usuário especificado.
No exemplo a seguir, o comando quota é utilizado para exibir configurações de cota

do usuário aluno:
5.4. Documentação
Nas últimas décadas, a disseminação de informações adquiriu novos contornos e
proporções, refletidas também na área de tecnologia. Com os sistemas GNU/Linux
não poderia ter sido diferente.
O GNU/Linux dispõe de uma biblioteca de documentação ampla e de qualidade, que

contribui com a eficiência de pesquisas e buscas. É importante termos ciência de que
a contribuição da comunidade GNU/Linux com o desenvolvimento do sistema e de
sua documentação tem sido fundamental para o crescimento do GNU/Linux.
Tudo o que se deseja saber a respeito do sistema GNU/Linux, ou seja, tudo o que se
imagina poder realizar no sistema, está documentado, tanto de forma on-line como
no próprio sistema operacional.
Como formas de se documentar um projeto GNU/Linux, temos as documentações, os

HOW-TOs, também chamados de cook-books, e os manuais (man pages).
342
5.4.1. Documentação
A documentação deve abranger todas as áreas que dizem respeito a determinado
projeto, sendo suficiente para que alguém consiga entendê-lo. São parte da
documentação itens como HOW-TOs e manuais. Existem, no entanto, projetos muito
específicos, que demandam uma consulta individual. Esse é o caso da documentação
de um projeto de rede, na qual detalhes e componentes são especificados e dividem
espaço com os HOW-TOs e manuais.
5.4.2. HOW-TOs
A documentação HOW-TO, disponibilizada de maneira on-line, refere-se aos
procedimentos detalhados para a execução de uma tarefa ou uma função específica
– a configuração de um servidor Web ou de placas de som, por exemplo. Apesar da
objetividade do HOW-TO, a atualização do software demanda uma nova documentação.
Os procedimentos da atividade a ser realizada se encontram nos arquivos do diretório,

que é /usr/share/doc. O aplicativo de um documento HOW-TO pode ser instalado
com ele ou ser parte de um pacote específico.
O site Viva o Linux é um dos sites de HOW-TO para GNU/Linux. Seu endereço é
www.vivaolinux.com.br.
5.4.3. Manuais (man pages)

Quando o sistema operacional Linux é instalado de forma padrão, temos várias páginas
on-line nas quais encontramos uma grande quantidade de informações referentes aos
comandos utilizados. Estamos falando de manuais, também chamados de man pages
ou páginas man, encontradas por meio do comando man.
Os manuais buscam apresentar formas de utilização das ferramentas do software,

incluindo exemplos que facilitam a sua compreensão. Para isso, eles dispensam
conceitos utilizados pelo HOW-TO, como passo a passo e lista de afazeres.
Cada comando possui informações correspondentes ao seu nome, descrição e

sinopse, além de parâmetros e ambiente em que é utilizado e suas opções. Essas
opções também possuem suas próprias informações detalhadas e são visualizadas
em forma de lista.
343
Cada comando é detalhado em uma seção de man page. Essa seção é determinada
pelo número que aparece entre parênteses após um comando, por exemplo:
•• mv (1);
•• quotacl (2);
•• history (3);
•• ttyS (4);
•• lilo.conf (5);
•• xboard (6);
•• bootparam (7);
•• useradd (8).
As seções de man page vão de 1 até 9. Vejamos, a seguir, a descrição de cada uma
delas:
•• Seção 1: Corresponde aos comandos utilizados pelo usuário, entre eles

comandos do shell e programas executáveis. Alguns desses comandos estão
embutidos;
•• Seção 2: A seção de número dois corresponde às chamadas que o sistema

realiza;
•• Seção 3: Esta seção diz respeito às funções da biblioteca C;
•• Seção 4: Nesta seção, podemos visualizar a descrição dos arquivos de dispositivo;
•• Seção 5: Nesta seção, são apresentadas as convenções e arquivos de configuração;
•• Seção 6: Refere-se à seção de jogos;
•• Seção 7: Possui informações variadas, como formatos de textos e conversão de

textos;
•• Seção 8: As informações correspondentes à administração do sistema são

encontradas nessa seção;
•• Seção 9: Possui rotinas referentes ao kernel do sistema Linux.
As informações sobre cada uma das seções podem ser exibidas por meio do
comando man man.
344
5.4.4. Documentações em /usr/share/doc
O diretório /usr/share/doc, também conhecido como /usr/doc, é onde os HOW-
TOs, disponibilizados de maneira on-line, se encontram. Nesse diretório, também
encontramos documentações que dizem respeito às informações relacionadas a um
programa ou até mesmo a um pacote, e incluem, além de FAQs, os READMES e outras.
Essas documentações podem estar nos seguintes formatos:
•• ASCII;
•• HTML;
•• LateX;
•• PostScript.
O modo mais comum de estruturação das informações contidas em um FAQ é

uma sequência de perguntas e respostas relacionadas a um determinado assunto.
5.4.5. Comandos de ajuda e acesso às documentações

Existem comandos usados para acessar documentações de sistemas GNU/Linux,
tais como help, manpath, man, apropos, whatis, info, whereis e which. A seguir,
conheceremos mais sobre eles.
5.4.6. help
Com o help, podemos identificar as opções que devemos usar com os comandos
internos do shell. Ele permite a visualização da ajuda rápida tanto para todos os
comandos internos do sistema como apenas para um deles.
A sintaxe utilizada para visualizar todos os comandos internos é a seguinte:
# help
Já a visualização de apenas um dos comandos internos é feita com uma sintaxe

diferente, como podemos perceber:
# help <comando>
Para mostrar a ajuda para comandos externos, por outro lado, o help assume a posição
de parâmetro --help, com o qual buscamos os parâmetros de qualquer comando.
345
A sintaxe utilizada para que a ajuda rápida sobre um comando externo seja visualizada
é apresentada a seguir:
# [comando] --help
Existem meios de se obter ajuda que não envolvem o parâmetro --help, já que ele
é um parâmetro individual de cada comando.
5.4.7. manpath
O comando manpath permite visualizar os diretórios que são pesquisados no
momento em que chamamos os manuais.
No exemplo a seguir, podemos visualizar os diretórios que são referenciados pelo

comando manpath:
5.4.8. man
Por meio do comando man, podemos consultar o conteúdo dos manuais. No final
deles, está localizada a lista correspondente aos comandos relacionados. A sintaxe
desse comando é a seguinte:
man [opcao] [comando/arquivo]
Caso o nome de um comando não seja conhecido, é possível localizá-lo a partir de

uma palavra-chave. A seguir, são descritas algumas opções:
Opção Descrição
-a Exibe todas as seções referentes ao comando consultado.
-k Consulta pela palavra-chave entre os manuais.
-w Exibe a localização do arquivo do manual solicitado.
A seguir, temos o diretório do man:
# ls /usr/share/man
Nele, é possível verificar quais são os manuais disponíveis e visualizar divisões, tais
como idiomas e níveis. A introdução específica de cada nível é visualizada com o
seguinte comando:
# man <nivel> intro
346
Para que possamos visualizar o manual em determinado idioma, é necessário que o
pacote para o idioma em questão tenha sido instalado no sistema. Assim, podemos
ver os manuais disponíveis em português desde que o sistema esteja instalado nessa
língua.
O parâmetro –L pt_BR do comando man, contudo, permite a visualização de manuais

em português mesmo tendo o sistema instalado no idioma inglês. Para isso, man
deve ser executado da seguinte maneira:
# man –L pt_BR comando
A contribuição da comunidade, como mencionado, é muito importante para a

documentação ser mais completa. Isso também inclui os idiomas. Para que uma
documentação esteja disponível em determinado idioma, como o português,
participantes da comunidade traduziram a documentação feita em outro idioma. O
comando a seguir possibilita esse tipo de contribuição:
# man 7 undocumented
Vejamos um exemplo de consulta pela palavra-chave:
O resultado apresentado é o seguinte:
Já o exemplo a seguir exibe a localização do arquivo especificado:
347
A seguir, podemos visualizar um exemplo de manual:
Podemos, ainda, visualizar os manuais no ambiente gráfico, utilizando o konqueror:
Com relação ao comando man, devemos considerar a variável MANPATH: ao ser

configurada, ela permite realizar uma pesquisa man em vários diretórios. Isso significa
que o man irá buscar informações nos diretórios definidos na variável MANPATH.
Existe, ainda, o arquivo /etc/manpath.config, o qual é utilizado pelo pacote man-db

com o objetivo de configurar os caminhos dos manuais. Vale saber que o comando
manpath também pode ser utilizado para determinar o caminho de busca para
manuais.
348
A linguagem troff/nroff é a linguagem na qual os manuais são escritos. Para visualizá-
los, utilizamos os paginadores more e less. Para alterar o padrão no qual o programa
paginador exibirá os manuais, utilizamos a variável PAGER, como mostrado a seguir:
export PAGER=more
man ls
5.4.9. apropos
Por meio do comando apropos, podemos especificar uma palavra-chave que será
pesquisada nos manuais. O resultado da busca é mais genérico, já que é composto
por manuais cujo nome, parte do nome ou descrição seja o termo pesquisado. A
sintaxe desse comando é a seguinte:
apropos <palavra>
Utilizamos esse comando quando não sabemos qual documentação acessar para um
determinado assunto – para resolver esse problema, o apropos recorre a um banco
de dados, que o auxilia a localizar os manuais. Esse banco é construído mediante a
execução do seguinte comando:
# catman
Em vez de usar o comando apropos, podemos usar o comando a seguir:
# man –k <palavra-chave>
Na próxima imagem, o comando apropos está pesquisando pelo padrão ls nos

manuais do sistema:
349
5.4.10. whatis
Com o comando whatis, temos resultados mais precisos de busca, compostos pelo
manual cujo nome seja exatamente o termo que pesquisamos. A seguir, temos a
sintaxe desse comando:
# whatis <comando>
Alternativamente, podemos usar o comando a seguir, que equivale ao comando

whatis:
# man –f <palavra-chave>
5.4.11. info
O comando info possibilita o acesso às páginas info (info pages), que são navegáveis.
O utilitário info é muito útil em se tratando de ferramenta de ajuda no sistema Linux.

Isso ocorre devido ao fato de que o info utiliza-se de links de hipertexto, indicados
pelo sinal de asterisco (*). Ao pressionarmos ENTER ou BACKSPACE, vamos para a
seção correspondente ou para a página anterior, respectivamente.
Também podemos navegar entre as páginas utilizando as seguintes teclas:
•• N: Vai para a próxima página;
•• P: Vai para a página anterior;
•• U: Sobe um nível;
•• Q: Sai do comando info.
As informações que o info apresenta são mais atuais, pois os manuais não são
atualizados, fazendo com que as informações contidas neles fiquem obsoletas.
A sintaxe do comando info é a seguinte:
info <comando>
A seguir, temos um exemplo do uso do comando info:
350
A próxima imagem exibe um exemplo de página info:
5.4.12. whereis
O comando whereis tem a finalidade de localizar o caminho do arquivo binário,
do arquivo de configuração – caso exista – e a página de manual de determinado
comando do sistema. Sua sintaxe é a seguinte:
whereis [opcao] <comando ou arquivo>
A tabela seguinte descreve algumas opções que podem ser utilizadas com whereis:

-b Localiza apenas o arquivo binário do comando indicado.
-m Localiza apenas a página de manual do comando indicado.
Vejamos:
whereis ls
ls: /bin/ls /usr/share/man/man1/ls.1.gz
No exemplo anterior, é feita uma consulta sobre o comando ls. O resultado segue
basicamente a ordem mostrada, ou seja, primeiramente é exibido o nome e caminho
do arquivo binário e, depois, o nome e o caminho da página de manual.
351
5.4.13. which
O comando which é semelhante ao comando whereis, porém, exibe apenas a
localização do arquivo binário de um determinado comando. A utilização desse
comando engloba abreviações de comandos em shell script. A busca que o comando
which faz é baseada no conteúdo da variável PATH. Sua sintaxe é a seguinte:
which <arquivo>
Para visualizar o valor da variável PATH e os diretórios nos quais o comando which
se baseia para localizar os arquivos binários dos comandos especificados, deve-se
utilizar echo $PATH.
No exemplo a seguir, which indica onde está o executável binário do comando

mke2fs:
5.4.14. Ferramentas para consulta de documentações

Além dos comandos de ajuda e acesso à documentação GNU/Linux, podemos fazer
uso de ferramentas que auxiliam a visualização de documentações. Veja algumas
delas:
•• Yelp: Esta ferramenta gráfica do GNOME 2 serve para consultarmos

documentações e visualizamos manuais de aplicativos gráficos;
•• Xman: É o navegador do comando man. Utilizado para exibir páginas de manuais

no X Window System.
5.4.15. Outras documentações on-line

Há uma grande quantidade de informações on-line a respeito do Linux. Porém, é
importante saber exatamente em que lugar procurar pela documentação. Veremos, a
seguir, duas importantes fontes de documentação disponíveis na Internet: o site The
Linux Documentation Project e os grupos de notícias Usenet.
352
5.4.16. The Linux Documentation Project
Trata-se do endereço oficial de documentações de sistemas GNU/Linux. Esse site é
disponibilizado em diversos idiomas, entre eles o português brasileiro, e formatos,
como PDFs, arquivos .txt, páginas HTML, entre outros.
353
Dicas LPI
•• Toda essa documentação que possuímos no sistema GNU/Linux está

disponível no site: http://www.tldp.org (The Linux Documentation
Project), que é o site oficial de documentações sobre GNU/Linux;
•• Um diferencial deste site é ter a documentação em vários idiomas e formatos

(.pdf, .html, .txt e outros);
•• Não se esqueça de estudar as diferenças entre comandos internos e

externos. Saber a funcionalidade de alguns dos comandos internos como
echo e time, entre outros, pode ajudar em desafios maiores;
•• É comum o exame cobrar mais dos níveis 1, 5 e 8 dos manuais! Então,

lembre-se de estudar binários, arquivos de configuração e comandos
administrativos;
•• Uma forma equivalente ao apropos é usar o comando man juntamente

com a opção –k;
•• Os comandos apropos e whatis utilizam a mesma base de dados, é

importante perceber isso (catman e makewhatis);
•• Uma forma equivalente ao whatis é usar o comando man juntamente com

a opção –f;
•• Não esqueça dos parâmetros grpquota e usrquota dentro do fstab.
354
Pontos principais
•• Os comandos utilizados para a criação de partições são: fdisk e cfdisk;
•• Podemos definir um sistema de arquivos como um meio de deixar os dados de

nosso sistema mais organizados. Todo sistema operacional gera um tipo de
sistema de arquivos;
•• As primeiras iniciativas em criar uma padronização para sistemas de arquivos

para distribuições GNU/Linux surgiram em 1994, com a criação do Filesystem
Standard (FSSTND). Mais tarde, foram adotadas regras de estrutura e
armazenamento de diretórios estabelecidas pelo Filesystem Hierarchy Standard,
ou FHS;
•• Existem duas categorias nas quais podemos encaixar os diretórios do sistema

GNU/Linux: na primeira, definimos o diretório como compartilhado ou não-
compartilhado; na segunda, podemos definir o conteúdo de um diretório como
estático ou variável. Ambas as categorias foram criadas para definir quais tipos
de diretórios poderemos compartilhar em rede ou, até mesmo, definir como o
conteúdo daquele diretório poderá ser acessado;
•• O recurso de cotas de disco nos permite restringir a quantidade de espaço de

um disco que poderá ser utilizada por um ou mais usuários. Ativamos o recurso
de cotas quando, por exemplo, o sistema é acessado por vários usuários. Temos
as cotas por blocos, que referem-se ao espaço em disco, e também por inodes,
que determinam o número de arquivos;
•• Tudo o que se deseja saber a respeito do sistema GNU/Linux está documentado,

tanto de forma on-line como no próprio sistema operacional. Como formas de
se documentar um projeto GNU/Linux, temos as documentações, os HOW-TOs,
também chamados de cook-books, e os manuais (man pages).
Sites Endereços
Documentação FHS http://www.pathname.com/fhs/
https://access.redhat.com/documentation/en-
Cota de disco Red Hat US/Red_Hat_Enterprise_Linux/6/html/Storage_
Administration_Guide/ch-disk-quotas.html
355
Mapa mental para fixação do aprendizado
356
Dispositivos,
5 Sistemas de
arquivos e FHS
1. O que representa o dispositivo sdb5?
☐☐ a) A sexta partição em um disco SCSI.

☐☐ b) A quinta partição no segundo disco SCSI.
☐☐ c) A sexta partição no segundo disco IDE.
☐☐ d) A quinta partição no segundo disco SATA.
☐☐ e) A segunda partição no quinto disco IDE.
2. Qual comando informa a última execução do fsck?
☐☐ a) fsck
☐☐ b) debug2fs
☐☐ c) fdisk
☐☐ d) dumpe2fs
☐☐ e) tune2fs
3. Ao digitar o comando ls -l /dev/sda1, obtemos o seguinte resultado:
brw-rw---- root disk 8, 1 nov 2 18:33 /dev/sda1
Com essa informação, concluímos que se trata de qual dispositivo?
☐☐ a) Um dispositivo de comunicação, provavelmente um modem.

☐☐ b) Um dispositivo de comunicação, provavelmente uma partição.
☐☐ c) Um dispositivo de pipe, provavelmente um pendrive.
☐☐ d) Um dispositivo de bloco serial, provavelmente uma partição.
☐☐ e) Um dispositivo de bloco, provavelmente uma partição.
4. Qual ferramenta é utilizada para verificar um sistema de arquivos ext3?
☐☐ a) fsck
☐☐ b) e2fsck
☐☐ c) e3fsck
☐☐ d) check
☐☐ e) debug2fs
5. Qual dispositivo se refere à terceira partição do disco configurado como

master, instalado na unidade IDE secundária?
☐☐ a) sdc3
☐☐ b) hdc3
☐☐ c) hda3
☐☐ d) hda2
☐☐ e) hdc2
358
6. Qual diretório não pode estar em uma partição separada?
☐☐ a) /tmp
☐☐ b) /etc
☐☐ c) /srv
☐☐ d) /var
☐☐ e) /boot
7. Em qual diretório estão todos os arquivos de configuração do sistema?
☐☐ a) /conf
☐☐ b) /usr/conf
☐☐ c) /srv
☐☐ d) /etc
☐☐ e) /boot
8. O executável do comando pwd fica dentro de qual diretório?
☐☐ a) /sbin, pois é o diretório onde ficam todos os executáveis administrativos.

☐☐ b) /bin, pois é o diretório onde ficam todos os executáveis administrativos.
☐☐ c) /usr/bin, pois é onde ficam os principais executáveis de interesse geral.
☐☐ d) /usr/sbin, pois é onde ficam os principais executáveis do sistema.
☐☐ e) /bin, pois é onde ficam os principais executáveis de interesse geral.
9. Qual dos comandos a seguir é capaz de nos direcionar ao diretório sbin,

que está dentro do diretório /usr?
☐☐ a) operador@localhost: ~$ cd usr/sbin
☐☐ b) operador@localhost: ~$ cd pwd
☐☐ c) operador@localhost: ~$ cd /usr/sbin
☐☐ d) operador@localhost: ~$ cd /sbin
☐☐ e) operador@localhost: ~$ cd /usr/bin
10. Qual diretório contém todos os dispositivos do sistema?
☐☐ a) /disp
☐☐ b) /dev
☐☐ c) /usr/devices
☐☐ d) /pci
☐☐ e) /etc
359
11. No arquivo /etc/fstab, qual opção deve ser utilizada para habilitar
cotas para usuários?
☐☐ a) grpquota
☐☐ b) userquota
☐☐ c) groupquota
☐☐ d) quota
☐☐ e) usrquota
12. Qual o nome do arquivo criado na partição que possui cotas de grupos?
☐☐ a) aquota.user
☐☐ b) quota.group
☐☐ c) aquota.grp
☐☐ d) aquota.group
☐☐ e) aquota.grupo
13. Qual comando deve ser utilizado para ver as cotas de todos os usuários?
☐☐ a) repquota -a
☐☐ b) quotauser -a
☐☐ c) quota -a
☐☐ d) quotacheck -a
☐☐ e) quotacheck -svug
14. Qual comando deve ser utilizado para editar a cota de um usuário
específico?
☐☐ a) quota -u [usuario]
☐☐ b) repquota -u [usuario]
☐☐ c) edquota -u [usuario]
☐☐ d) quotauser [usuario]
☐☐ e) quota -g [usuario]
15. Qual comando é utilizado para visualizar o manual de um comando?
☐☐ a) man
☐☐ b) ls
☐☐ c) ?
☐☐ d) manual
☐☐ e) <comando> manual
360
16. Qual comando é utilizado para saber o que faz um comando?
☐☐ a) whereis
☐☐ b) which
☐☐ c) whatis
☐☐ d) ls
☐☐ e) mount
17. Qual comando é utilizado para descobrir onde está o executável binário
de um comando, suas páginas e demais informações?
☐☐ a) ls
☐☐ b) man
☐☐ c) whereis
☐☐ d) help
☐☐ e) grep
18. Qual comando pode ser utilizado para encontrar o executável de um

comando?
☐☐ a) grep
☐☐ b) which
☐☐ c) man
☐☐ d) help
☐☐ e) ls
19. Qual comando é utilizado para acessar páginas info (info pages)?
☐☐ a) apropos
☐☐ b) mount
☐☐ c) whereis
☐☐ d) manual
☐☐ e) info
361
Dispositivos,
5 Sistemas de
arquivos e FHS
Mãos à obra!
Laboratório 1 - Identificando arquivos de

dispositivos
Antes de realizar as atividades a seguir, adicione um disco virtual em cada VM

(CentOS e Debian), com capacidade de 10 GB.
1. Liste detalhadamente o arquivo /dev/sd*:
# ls -l /dev/sd*
Note que, na informação sobre tipo de arquivo, ele se inicia com a letra b, indicando
que é um dispositivo de bloco.
2. Liste detalhadamente o arquivo do dispositivo serial /dev/tty:
# ls -l /dev/tty
Note que, na informação sobre tipo de arquivo, ele se inicia com a letra c, indicando
que é um dispositivo de caractere.
3. Liste detalhadamente o arquivo /dev/xconsole (debian):
# ls -l /dev/xconsole
Note que, na informação sobre tipo de arquivo, ele se inicia com a letra p, indicando
que é um dispositivo de pipe.
4. Liste detalhadamente o arquivo /dev/log:
# ls -l /dev/log
Note que, na informação sobre tipo de arquivo, ele se inicia com a letra s, indicando
que é um dispositivo de socket.
364
Laboratório 2 - Montando dispositivos
5. Carregue a imagem .ISO da distribuição CentOS 7 e liste o conteúdo do diretório
/media/:
# ls /media/
6. Monte a unidade de CD-ROM no diretório /media/:
# mount –t iso9660 /dev/sr0 /media/
7. Liste novamente o conteúdo do diretório /media/:
# ls /media/
8. Desmonte a unidade de CD-ROM:
# umount /media/
9. Mais uma vez, liste o conteúdo da pasta /media/cdrom:
# ls /media/
Laboratório 3 - Analisando o FSTAB do Debian

10. Leia o arquivo fstab:
# cat /etc/fstab
11. Observando o resultado retornado pelo comando anterior, anote as seguintes

informações:
a) Quantas unidades são iniciadas pelo fstab?
__________________________________________________________________________________
b) Qual unidade corresponde ao ponto de montagem /?
__________________________________________________________________________________
c) Qual o sistema de arquivos da partição /?
__________________________________________________________________________________
365
d) Quantas partições swap existem?
__________________________________________________________________________________
e) Qual o caminho da unidade de swap (referência ao dispositivo dentro de /dev)?
__________________________________________________________________________________
Laboratório 4 - Verificando a estrutura do

disco do Debian
12. Verifique as tabelas de partições formadas no disco:
# fdisk -l
Note que existe uma partição bootável (na coluna boot há um *).
13. Verifique as informações detalhadas da partição bootável:
# dumpe2fs -h /dev/sda1
14. Defina a partição de maneira que, a cada 5 montagens (5 reinicializações da

máquina), o fsck seja executado automaticamente:
# tune2fs -c 5 /dev/sda1
15. Desative a contagem e manutenção automática:
# tune2fs -c -1 /dev/sda1
16. Faça com que o sistema realize a manutenção automática para daqui a 3 dias:
# tune2fs -i3d /dev/sda1
17. Faça com que a manutenção automática ocorra daqui a 3 meses:
# tune2fs -i3m /dev/sda1
18. Desative novamente a manutenção automática:
# tune2fs -id /dev/sda1
366
Laboratório 5 - Analisando a estrutura de
diretórios
20. Eleve as permissões para root com o comando a seguir:
$ su
21. Execute o comando a seguir para observar em qual diretório estamos localizados
no momento:
# pwd
22. Vá para o diretório raiz (/):
# cd /
23. Liste os diretórios existentes e compare-os com o conteúdo descrito do tópico

Estrutura de diretórios do Capítulo 5 da apostila:
# ls
Laboratório 6 - Analisando alguns dos principais

diretórios
24. Entre no diretório /etc (observe que, como o diretório /etc está abaixo do diretório
raiz, é necessário informar o caminho completo):
# cd /etc
25. Liste o conteúdo do diretório com o comando ls:
# ls
Observe que o diretório /etc possui diversos arquivos e muitos deles

terminam com .conf. Essa nomenclatura não é obrigatória, mas auxilia na
orientação. De qualquer maneira, todos os arquivos contidos em /etc e seus
subdiretórios são arquivos de configuração do sistema ou de aplicativos.
367
26. Vá para o diretório /dev e liste seu conteúdo com os seguintes comandos:
# cd /dev
# ls
Observe que o conteúdo listado se refere a dispositivos. Entre eles,

temos cdrom, que é um alias (link simbólico) para o dispositivo de CD.
27. Vá para o diretório /bin e liste seu conteúdo com os seguintes comandos:
# cd /bin
# ls
Observe que os arquivos listados são os comandos utilizados com maior frequência.
Entre eles, estão o ls e o pwd.
Laboratório 7 - Instalando o serviço de cotas

no sistema de arquivos xfs do CentOS
28. Identifique o segundo disco adicionado na máquina virtual, crie a partição pelo
utilitário fdisk, formate a partição criada com o sistema de arquivo xfs, crie a diretório
backup no /mnt e realize o ponto de montagem:
# cat /proc/partitions | grep –i sdb
# fdisk /dev/sdb
| --> opções: n, p, 1, <enter>,<enter>, w
# mkfs.xfs /dev/sdb1
# mkdir /mnt/backup ; mount –t xfs /dev/sdb1 /mnt/backup
29. Instale o pacote de cotas;
# yum install quota
30. Verifique as informações, referentes ao espaço em disco, do ponto de montagem

backup:
# xfs_quota -c ‘df -h’ /mnt/backup/
368
31. Habilite a quota no ponto de montagem backup e verifique seu status;
mount -o remount,pquota /dev/sdb1 /mnt/backup/
32. Defina uma identificação do gerenciamento de árvore, adicionando no arquivo /

etc/backup, que será criado:
# echo 1:/mnt/backup/ >> /etc/projects
33. Mapeie o nome do projeto com a sua identificação, adicionando no arquivo /etc/
projectsid, que será criado:
# echo Backup:1 >> /etc/projectsid
34. Adicione a identificação do gerenciamento da árvore:
# xfs_quota -x -c ‘project -s 1’ /mnt/backup/
35. Adicione a quota de 1 Megabyte para o projeto:
# xfs_quota -x -c ‘limit -p bhard=1m 1’ /mnt/backup/
36. Verifique se a cota foi adicionada com sucesso;
# xfs_quota -x -c ‘report -h’ /mnt/backup/
37. Altere o grupo do usuário operador, no diretório /mnt/backup, abra uma nova
sessão com o usuário operador, acesse o diretório /mnt/backup e crie um arquivo
que tenha um tamanho acima de 1 Megabyte;
# chgrp operador /mnt/backup
# su - operador
$ cd /mnt/backup
$ ls –lR / > resultado.txt
Será criado um arquivo contendo a lista de arquivos gerada pelo comando ls e após
ele atingir o tamanho definido na cota, uma mensagem será apresentada, conforme
o exemplo adiante:
ls: erro de gravação: Não há espaço disponível no dispositivo
369
Laboratório 8 - Instalando o serviço de cotas

no sistema de arquivos ext4 do Debian
38. Instale o pacote de cotas;
# aptitude install quota
39. Edite o arquivo /etc/fstab para suportar as cotas de disco. Altere a linha a seguir:
/dev/sda3 /home ext3 defaults 0 2
Para:
/dev/sda3 /home ext3 defaults,usrquota,grpquota 0 2
40. Salve e saia do arquivo /etc/fstab;
:wq
41. Remonte o sistema de arquivos do /home;
# mount -o remount /home
42. Crie o sistema de cotas para a partição /home;
# quotacheck -cug /home
43. Verifique se os arquivos aquota.user e aquota.group foram criados;
# ls /home
44. Verifique o sistema de cotas;
# repquota -a
45. Desabilite o sistema de cotas;
# quotaoff -a
46. Verifique o sistema de cotas;
# quotacheck -vgum /home
370
47. Habilite novamente o sistema de cotas;
# quotaon -a
48. Defina a cota de 20 KB para o usuário operador:
# edquota -u operador
As colunas soft e hard devem ficar da seguinte forma:
49. Verifique se a cota foi aplicada;
# repquota -a
50. Logue com o usuário operador;
51. Crie um arquivo de teste. O objetivo é estourar a cota:
$ echo “Meu nome é operador, estou testando a cota” > ./testedecota
Imediatamente, deverá surgir a mensagem a seguir:
sda3: write failed, user block limit reached.

-bash: echo: write error: Disk quota exceeded
52. Logue novamente como root;
53. Verifique o status das cotas:
# repquota -a
Deve haver algo parecido com o que vemos a seguir, o que indica que o usuário aluno
estourou o limite soft e tem seis dias para corrigir o problema:
371
54. Com o comando quota, verifique a quota disponível para o usuário operador;
# quota -us operador
55. Verifique os limites;
# ulimit -a
56. Altere o limite de processos executados por usuários para 5.000;
# ulimit -u 5000
57. Verifique novamente os limites.
# ulimit -a
Laboratório 9 - Analisando as man pages e

comandos de ajuda
58. Visualize o manual do comando man:
# man man
59. Visualize o manual do comando whereis:
# man whereis | more
60. Utilize o help para ver as possibilidades do comando ls:
# ls --help
61. Verifique em quais diretórios estão instalados todos os manuais:
# manpath
Note que o resultado, apesar de contemplado em apenas uma linha, exibe vários
locais, separados por dois-pontos (:).
62. Localize comandos ou itens no manual que citem rotas (route):
# apropos route
372
63. Faça a mesma busca do passo anterior, desta vez utilizando o comando man:
# man -k route
64. Supondo que não se sabe o que o ls faz, pergunte ao GNU/Linux do que se trata
o referido comando:
# whatis ls
65. Navegue pela página de ajuda do comando whatis utilizando o comando info:
# info whatis
66. Para saber onde estão todas as informações do comando info, como executável,
man page, entre outras, utilize o comando whereis:
# whereis info
67. Utilize o comando which para saber somente onde está o executável do whereis:
# which whereis
373
Shell script e
6 gerenciamento
de dados
ÃÃ Gerenciando o shell;
ÃÃ Shell Script;
ÃÃ Gerenciamento de dados.
Este capítulo faz parte do tópico 105 - Shell, Scripting and Data Management
da segunda prova identificada como 102-400 ou LX0-104 da certificação LPIC-1.
Você precisará estar apto a customizar o ambiente shell bash, escrever scripts
simples de automação e gerenciar dados, usando MySQL.

Para o mercado de trabalho, é muito importante que você entenda os scripts já

desenvolvidos em Shell Script, para as devidas manutenções, assim como também
entender como o ambiente do usuário é configurado.
6.1. Gerenciando o shell
Já vimos há alguns capítulos que o shell é o mediador entre o computador e o
usuário, pois é por meio dele que podemos enviar comandos que serão interpretados
e executados no sistema. Neste capítulo, serão mostrados alguns tipos de shell,
que variam dos mais simples àqueles indicados a usuários avançados ou com bom
entendimento de programação.
Como o bash é a versão do shell padrão para quase todas as distribuições e também
a versão em que as principais avaliações de certificação para o Linux são baseadas,
a ênfase será dada a ele. Aqui, veremos como configurá-lo, personalizá-lo, trabalhar
com suas variáveis, automatizar tarefas e fazer dele uma ferramenta eficiente de
programação.
6.1.1. Tipos de shell
Há diversos tipos de shell disponíveis para distribuições GNU/Linux. O bash é o tipo
utilizado na maioria das distros.
A seguir, veja a descrição dos principais tipos de shell:
•• sh (Bourne shell)
Desenvolvido por Stephen Bourne, por isso Bourne shell. É o shell original, bem
simples, com poucas ferramentas, mas ainda utilizado em sistemas UNIX e ambientes
relacionados ao UNIX.
376
Shell script e gerenciamento de dados 6
•• bash (Bourne Again shell)
Trata-se do shell padrão do Linux, conveniente tanto para usuários iniciantes, por ser
intuitivo e flexível, quanto para avançados e profissionais, por possuir ferramentas
variadas e eficientes. Compatível com todos os comandos do sh.
•• csh (C shell)
Preferido por alguns programadores, a sintaxe desse shell é semelhante à linguagem

de programação C.
•• tcsh (Turbo C shell)
Versão melhorada do csh, que interpreta linguagens de comando e pode ser usada
tanto como um shell de login interativo quanto como um processador de comandos
de shell scripts. É completamente compatível com o csh.
•• ksh (Korn shell)
Este shell é o Bourne Shell evoluído, portando todos os comandos que funcionavam
no Bourne Shell funcionarão nesse com a vantagem de ter mais opções.
•• zsh (Z shell)
Além de um shell desenvolvido para uso interativo, que engloba várias funções úteis
do bash, ksh e tcsh, o zsh, é também uma linguagem de script eficiente.
6.1.2. Variáveis
Podemos definir variáveis como nomes que contêm algum valor e, ainda, como
espaços de memória que armazenam valores. Sua função é o fornecimento de dados
úteis e necessários a usuários e programas. Tais variáveis apresentam a seguinte
forma:
NOME=VALOR
As variáveis podem ser locais ou globais (de ambiente):
•• Variáveis locais: São as variáveis disponíveis somente para o shell atual. Isso
significa que sua visibilidade é restrita ao ambiente para o qual foram definidas,
elas não ficam disponíveis para o restante do sistema;
•• Variáveis globais (de ambiente): São as variáveis disponíveis tanto para o shell
atual como para os subprocessos que as utilizam, de forma que sua visibilidade
é aberta a outros ambientes além daqueles em que elas são definidas.
377
Vejamos algumas variáveis de ambiente:
Variável Definição
HOME Responsável por identificar o diretório do usuário.
HOSTTYPE Faz referência à plataforma que está sendo utilizada.
SHELL Permite identificar o shell que está sendo utilizado.
TERM Define o tipo de terminal que está sendo utilizado.
USER Predefine o nome da conta como variável global.
Determina quais diretórios devemos pesquisar e, ainda, qual
PATH sequência deverá ser seguida para encontrar um determinado
comando.
PS1 Representa as informações exibidas no prompt.
PS2 Representa o prompt estendido.
MAIL Esta variável informa como o correio eletrônico está definido.
LOGNAME É um sinônimo da variável USER.
Com a utilização desta variável, é possível definir o tipo de sistema
OSTYPE
operacional que está sendo utilizado.
6.1.2.1. Definindo variáveis
A forma de definição é diferente entre variáveis locais e globais. Uma variável local é
definida com a simples atribuição de um nome para ela, como se vê a seguir:
<variavel>=<valor>
Já uma variável global exige o comando export antes da sintaxe usada para variáveis
locais, como podemos ver a seguir:
export <variavel>=<valor>
É convencionado que variáveis globais tenham seu nome iniciado por letra maiúscula.
378
No exemplo que acabamos de ver, foi criada uma variável local chamada LOCAL, a
qual estará disponível apenas a esta seção. Para visualizar o retorno da variável, foi
utilizado o comando echo. Em seguida, por meio do comando export, foi criada uma
variável global, a qual estará disponível para todas as seções do sistema. Por fim, para
verificar o retorno da variável global criada, o comando echo também foi utilizado.
6.1.3. Visualizando variáveis
Os comandos env e set são usados para a visualização de variáveis, cada um com
suas especificidades. Veremos, a seguir, as particularidades de ambos.
6.1.3.1. env
Este comando é utilizado para exibir e trabalhar somente com as variáveis de
ambiente. Sem argumento, o comando lista todas as variáveis de ambiente do sistema
e seus valores. Com base nos argumentos definidos na linha de comandos, o env é
responsável por rodar um programa em uma ambientação modificada.
A sintaxe do comando env é a seguinte:
env [opcao] <variavel>
Vejamos as opções que podem ser utilizadas com esse comando:
Opção Opção
Definição
GNU Linux
--help Esta opção gera uma mensagem de ajuda.
--version Esta opção é utilizada para visualizar a versão.
Esta opção desconsidera o ambiente herdado e inicia um
-i, --ignore
aplicativo com o ambiente vazio.
-u --unset Esta opção exclui, do ambiente, o nome da variável.
No exemplo a seguir, utilizamos o comando env em conjunto com grep para filtrar
as variáveis. Como o comando env só lista as variáveis globais, a variável LOCAL não
traz nenhum resultado.
379
6.1.3.2. set
Diferente do comando env, o comando set é utilizado para visualizar variáveis, tanto
locais quanto globais, e seus atributos. Sua sintaxe é a seguinte:
set [opcoes] <variavel>
No exemplo a seguir, o comando set foi utilizado em conjunto com o comando

grep para filtrar as variáveis LOCAL e GLOBAL, sendo que ambas retornaram seus
resultados:
6.1.4. Retornando o valor de variáveis

O comando echo é utilizado para visualizarmos o valor de uma variável. Para isso,
devemos utilizar o caractere $ antes do nome da variável, como mostra a sintaxe a
seguir:
echo $<variavel>
No exemplo a seguir, echo é utilizado para visualizar o valor da variável GLOBAL:
6.1.5. Excluindo variáveis
Utilizamos o comando unset para excluir variáveis. Sua sintaxe é a seguinte:
unset <variavel>
É importante lembrar que esse comando, quando usado para uma variável global, só
tem efeito na sessão atual, de forma que a variável continuará acessível em outras
sessões.
380
No exemplo a seguir, a variável LOCAL é primeiramente definida. Depois, com a
execução do comando unset, a variável deixa de existir:
6.1.6. Alterando o prompt de comando

Para que possamos alterar o prompt de comandos, devemos alterar os valores que
estão armazenados dentro da variável PS1.
A seguir, serão descritos alguns valores que podem ser utilizados com a variável PS1:
Valor Descrição
\h Faz referência ao nome do host.
\w Caminho completo do diretório corrente.
\W Refere-se ao diretório atual.
\u Exibe o nome do usuário.
\t Exibe a hora do sistema.
\d Refere-se à data do sistema.
\$ Especifica o valor $ para usuários comuns, e o valor # para o root.
No exemplo adiante, alteramos a variável PS1 para que o prompt exiba o nome do
usuário, o nome do host e a hora atual:
381
6.1.7. Arquivos de configuração do shell

Alguns arquivos são automaticamente lidos pelo shell no momento de login e logout
de um usuário ou ainda de invocação do shell a partir de uma sessão que já tenha
sido iniciada. Dependendo de como for iniciado o bash, arquivos diferentes serão
executados de forma automática e, a partir desse conhecimento, o usuário pode
programar a criação de variáveis, aliases, funções e outras personalizações do bash.
Caso o bash seja invocado durante um login, ele lerá os arquivos ~/etc/profile,
~/.bash_profile, ~/.bash_login e ~/.profile, nessa ordem, caso eles existam. O
primeiro aplica-se a todos os usuários do sistema, ao passo que os três últimos,
ocultos por iniciarem com um ponto (.), estão no diretório /home do usuário em
questão. Ao terminar a sessão, o bash executará automaticamente o arquivo ~/.bash_
logout, se ele existir.
Quando não se tratar de um shell invocado numa sessão de login, como é o caso
de terminais em sessões X, os arquivos executados automaticamente, caso existam,
serão o /etc/bash.bashrc e o ~/.bashrc.
Vejamos, separadamente, alguns arquivos de configuração importantes:
•• /etc/profile
O arquivo /etc/profile é executado automaticamente no momento do login e lido

antes dos arquivos de configuração pessoal do usuário. É responsável, ainda, por
definir as variáveis de ambiente para os usuários em geral e armazenar os comandos a
serem executados, quando o usuário efetuar o login no sistema. Sempre que o arquivo
for carregado por meio de um shell que solicita login, ele procurará os arquivos na
sequência descrita no início deste tópico e realizará a execução dos comandos neles
contidos, caso eles existam.
•• /etc/environment
O arquivo /etc/environment é utilizado por sistemas Debian para definir variáveis de

ambiente. Uma vez definidas, todas as variáveis são exportadas, automaticamente,
na inicialização do sistema. Esse arquivo substitui o arquivo /etc/profile em algumas
distros.
•• /.bashrc
Executado por shells invocados em sessões já iniciadas, e não de login, esse arquivo
possui características semelhantes às do ~/.bash.profile.
382
6.1.8. Alterando o shell atual
Para alterarmos o shell atual, utilizamos o comando chsh com a opção –s ou --shell,
seguido do nome do shell que se deseja utilizar.
A linha a seguir altera o shell para o sh:
# chsh –s /bin/sh
6.1.9. Utilizando aliases
Alguns comandos têm uma sintaxe indiscutivelmente grande e digitá-la inteira toda
vez que o comando for necessário tende a se tornar uma tarefa inconveniente,
especialmente quando o comando é usado diversas vezes com os mesmos argumentos
e opções.
Uma forma bastante útil de agilizar a entrada de um comando que seja usado
normalmente com os mesmos parâmetros é atribuir um alias, da palavra apelido
em inglês. Em linha de comando ou em um arquivo próprio para isso, atribui-se um
termo pequeno e de digitação fácil para executar um determinado comando com
parâmetros específicos toda vez que o alias for usado.
No exemplo adiante, executamos propositalmente l, que é um comando inexistente.

Em seguida, com o comando alias, especificamos que l é igual a ls –color –l –a.
Então, ao executarmos novamente o comando l, ele passa a responder como o

comando ls com os parâmetros –color –l –a.
383
Para remover o alias de um comando, utiliza-se o comando unalias, como mostra

este exemplo, que exclui o alias l criado no exemplo anterior:
6.1.10. Arquivos para exibição de mensagens

Existem três arquivos relacionados à exibição de imagens para usuários, que não
afetam a parte operacional do sistema. O primeiro deles é o /etc/issue, que exibe
uma mensagem para um usuário antes do login no sistema. Caso se queira que a
mensagem apareça depois do login, o arquivo utilizado é o /etc/motd. Para visualizar
mensagens exibidas em logins remotos, o arquivo a ser verificado é o /etc/issue.net.
6.1.11. .bash_history
O .bash_history é um arquivo responsável por armazenar o histórico de linhas de
comando. Por padrão, até 500 comandos podem ser armazenados nesse arquivo, que
pode ser verificado por comandos que exibem o seu conteúdo. Por meio das setas
direcionais no teclado, para cima e para baixo, podemos verificar quais comandos já
foram utilizados.
384
O arquivo .bash_history armazena sua configuração em algumas variáveis.
Vejamos quais são elas:
Variável Descrição
Armazena o nome do arquivo utilizado para armazenar
HISTFILE
históricos.
Armazena o número máximo de comandos que o arquivo
HISTSIZE
suportará.
Armazena o número máximo de linhas que o arquivo do
HISTFILESIZE
histórico de comandos suportará.
O comando history permite visualizar comandos que já foram utilizados. No exemplo

a seguir, utilizamos o comando history para exibir os últimos 10 comandos digitados:
Podemos determinar que algumas variáveis não terão seus valores alterados pelos
usuários. Podemos utilizar o comando readonly e, dessa forma, elas se tornarão
constantes.
No exemplo adiante, criamos uma variável e a tornamos uma constante:
385
6.2. Shell Script
Scripts contribuem com a realização de diversas atividades, como na automatização
de trabalhos administrativos que podem se revelar repetitivos e extensos. Temos,
em um script, uma sequência de instruções que se distingue dos programas por seu
caráter não compilado.
Apenas programas cuja compilação foi projetada para o processador de um

computador (programas binários) podem ser executados por ele. Chamar um script
faz com que essa sequência seja executada, desde que tenhamos um programa capaz
de interpretá-lo em tempo de execução, como o programa shell.
Shell scripts são arquivos contendo conjuntos de comandos digitados em texto puro
(ASCII), cuja finalidade é realizar a automatização de tarefas no prompt de comandos.
Existem certas regras para a criação destes scripts que devem ser levadas em conta.
Em relação ao script, temos as seguintes regras:
•• Podem ser inseridos, no script, quaisquer comandos que funcionem no shell;
•• Para que outro usuário possa utilizá-lo, algumas providências devem ser tomadas,
como oferecer atributos de execução ao script e copiá-los para um diretório
devidamente citado na variável PATH. Logicamente, scripts que possuam
funções administrativas não podem ser utilizados por qualquer usuário, já que
somente o superusuário deve ter permissão de execução.
Em relação às linhas de execução, as regras são as seguintes:
•• Linhas iniciadas com # são caracterizadas como comentários, o que faz com
que o shell as ignore. Aliás, a prática de comentar linhas é recomendável por
permitir que outros usuários compreendam a lógica utilizada nos scripts e façam
alterações, caso seja necessário;
•• Devem ser evitadas as linhas em branco, devido ao risco de o usuário ter dúvidas
quanto ao acesso e execução do script.
386
6.2.1. Criando scripts
Para tratarmos da escrita e edição de scripts, é importante destacar dois pontos
fundamentais:
•• A ocorrência da sequência #! na linha inicial de um script significa que ele

indicará o programa com o qual será interpretado, como, por exemplo, o shell
/bin/bash;
•• Para rodar diretamente, o script deve ter permissão de execução. Para atribuir
essa permissão, deve-se utilizar o comando chmod, cuja sintaxe é apresentada
a seguir:
chmod +x <script>
Em que:
•• +: Adiciona uma permissão;
•• x: Define uma permissão de execução;
•• <script>: Refere-se ao script que deverá receber a permissão.
À primeira vista, o trabalho de criação de scripts pode parecer intimidador,

principalmente pelo fato de envolver programação. No entanto, já estudamos
praticamente todos os elementos que compõem um script. Caberá a cada um utilizar
a imaginação para desenvolvê-los.
Vejamos um exemplo de script no qual podemos ver o uso de #! e do comando

chmod. Primeiramente, iniciaremos a edição do script por meio do comando vi:
# vi /root/ola_mundo.sh
Então, temos o seguinte:
387
O script em questão possui três pontos a serem observados:
•• A primeira linha informa qual shell deve ser executado. Essa informação vem
logo após a sequência de caracteres #!;
•• Toda informação iniciada por # não é interpretada pelo script, sendo utilizada
como comentário;
•• O script é executado sequencialmente, ou seja, primeiro é lido qual interpretador

será utilizado, depois é lido o comando echo - os comentários são ignorados –
e, por último, o script será finalizado.
Depois, precisamos dar a permissão de execução para poder utilizá-lo, como mostra
a imagem a seguir:
Por fim, o script pode ser executado, conforme imagem adiante:
6.2.2. Fornecimento de parâmetros
O fornecimento de parâmetros permite que informações como dados, diretórios e
nomes de arquivos, entre outras, possam ser manipuladas diretamente pelos scripts,
o que, por sua vez, faz com que estes possuam uma interatividade e produtividade
extremamente eficazes.
Nesse sentido, temos os chamados parâmetros posicionais, que são variáveis dentro
de um shell script cujos valores são atribuídos pelos usuários. Cada parâmetro
posicional corresponde a um argumento na linha de comando, que é encarregado de
chamar programas. Eles são referidos com um sinal monetário ($); esses sinais são
enumerados pela ordem em que foram colocados na linha de comando ($1, $2, $3 e
assim por diante).
388
Na tabela a seguir, destacamos algumas formas do parâmetro, ou variável $:
Variável Descrição
Representa todas as variáveis existentes, ou todos os valores
$*
passados como argumentos.
$# Representa o número de variáveis, ou argumentos, à disposição.
$0 Refere-se ao nome do arquivo de script.
$n Representa a posição do argumento.
$! Representa o PID (Process ID) do último programa executado.
$$ Representa o PID do shell atual.
$? Representa o valor de retorno do último comando executado.
O exemplo a seguir demonstra a utilização de parâmetros em shell scripts:
No script que acabamos de visualizar, adicionamos algumas funções de variáveis

especiais. A primeira é a $0, que vai exibir na tela o nome do arquivo de script que
está sendo executado. A segunda variável utilizada é a $1, que vai aguardar, junto
com a execução do script, que uma palavra seja digitada. A palavra, então, é repetida.
389
A seguir, temos a execução do script:
6.2.3. Instruções condicionais
Estudamos, até aqui, scripts que são executados com o uso de comandos de execução,
dispostos em linha de comando em série – isto é, scripts sem escolhas.
Devemos considerar, também, a possibilidade de uma parte do script ter diferentes

resultados. As exceções, ou exceptions, nos auxiliam nessa situação, mas não
podemos contar com isso, caso haja dificuldades no processo. Uma condicional pode
ter seu resultado verificado com a condição SE (if). A seguir, estudaremos um pouco
sobre algumas instruções e comandos.
6.2.3.1. if-then
Esta instrução baseia-se em uma lógica extremamente simples, em que uma ação é
executada se a condição proposta existir ou for satisfeita. Para melhor compreensão,
demonstramos a seguir a sintaxe básica de um script com a instrução if-then:
#!/bin/sh
if [ condicao existe ou e satisfeita ]; then
[acao e realizada]
fi
A instrução também pode ser construída em forma de cascata. Tal estrutura pode
ser útil para estabelecer certos filtros em sucessão, para que uma determinada ação
possa ser executada ou não. A estrutura básica é a seguinte:
#!/bin/sh
if [ condicao existe ou e verdadeira ]; then
[acao e realizada];
if [ outra condicao existe ou e satisfeita ]; then
[outra acao e realizada];
else [ acoes alternadas ocorrem ]
fi
fi
exit
390
O comando if é muito eficaz, já que possibilita impedir erros de processamento,
com a vantagem de informar exatamente o local do erro. Isso é possível pelo fato do
comando exit ser colocado justamente para interromper uma instrução condicional,
caso certas ocorrências sejam registradas.
A seguir, temos um exemplo de instrução if-then em um script, em que é verificada

a palavra que será digitada juntamente com o script. Se a palavra for Impacta, será
exibida uma mensagem indicando que a palavra correta foi digitada. Caso contrário,
uma mensagem de erro é exibida.
Se digitarmos Escola, por exemplo, será retornada uma mensagem de erro:
No entanto, se digitarmos a palavra Impacta, o resultado é o seguinte:
391
6.2.3.2. Loops
Por meio das expressões condicionais com loops, os comandos repetem-se
consecutivamente até que certa condição seja satisfeita. São várias as possibilidades
apresentadas na criação dos scripts, como podemos ver na tabela a seguir:
Comando Condição
Para o loop deixar de ocorrer, a condição deve passar de
while verdadeira a falsa (é impossível determinar o número de vezes
que o loop será realizado).
until O loop continuará ocorrendo, enquanto a condição for falsa.
for O loop é realizado até que a função seja completamente cumprida.
A estrutura da sintaxe do loop nas três possibilidades é semelhante, conforme

podemos ver adiante:
( while ou until ou for ) <expressao>

do
comandos
done
No exemplo a seguir, utilizamos o comando while para executar o script enquanto

a condição for verdadeira. Definimos um valor inicial como 0. O comando echo será
executado enquanto VALOR for diferente de 6, como mostra a imagem a seguir:
392
Já no exemplo adiante, utilizamos o comando until para executar o script enquanto a
condição for falsa. Definimos VALOR como 0 novamente, mas utilizamos o comando
until dizendo que o valor é igual a 6. Obviamente que, por se iniciar como 0, ele não
é verdadeiro. O script vai somando até o instante em que a condição for verdadeira,
ou seja, até que VALOR seja igual a 6, para, então, ser finalizado.
No exemplo de script a seguir, que demonstra o uso de for, lista-se todos os arquivos
que estão na pasta /etc e que terminam com .conf, sendo que cada resultado é
armazenado em uma variável chamada i e, para cada resultado, uma mensagem é
exibida na tela:
393
6.2.3.3. case
Este comando permite que se realize uma comparação entre um valor oferecido pelo
usuário e os parâmetros internos do script. Tal processo gera o retorno de uma ação
correspondente.
A seguir, temos um exemplo da utilização de case (devemos atentar para as

informações dos comentários inseridos):
A execução do script anterior é a seguinte:
394
6.2.4. test
O comando test é utilizado para testar condicionais. Ele pode ser usado para strings
(texto), expressões matemáticas (números), variáveis e arquivos.
A seguir, temos um exemplo de script que utiliza o comando test com uma operação
com variáveis:
Vejamos o resultado da execução do script anteriormente mostrado:
395
6.2.5. read
O comando read é utilizado para solicitar, durante a execução do script, um valor do
usuário. Com o read, em vez de digitarmos o valor juntamente com o comando, como
temos feito até o momento, podemos fazer perguntas durante a execução do script.
Vejamos o exemplo a seguir (devemos atentar para as informações dos comentários

inseridos):
Ao executarmos o script, temos o seguinte resultado:
396
6.2.6. Operadores
A seguir, listamos alguns operadores que podemos utilizar em shell script, junto com
suas respectivas funções:
•• Operadores matemáticos •• Operadores lógicos
Operador Descrição Operador Descrição

+ Soma ! NÃO lógico (NOT)
- Subtração -a E lógico (AND)
* Multiplicação -o OU lógico (OR)
/ Divisão •• Operadores numéricos

> Maior
>= Maior ou igual Operador Descrição
< Menor -lt O número é menor que
<= Menor ou igual -gt O número é maior que

O número é menor ou
-le
•• Operadores de strings igual
O número é maior ou
Operador Descrição -ge
igual
= String é igual -eq O número é igual
!= String é diferente -ne O número é diferente
-n String não é nula
-z String é nula
397
•• Operadores para arquivos
Operador Descrição
-b O arquivo é um dispositivo de bloco.
-c O arquivo é um dispositivo de caractere.
-d É um diretório.
-e O arquivo existe.
-f É um arquivo normal.
-g O bit SGID está ativado.
-G O grupo do arquivo é o do usuário atual.
-k O Sticky Bit está ativado.
-L O arquivo é um link simbólico.
-O O dono do arquivo é o usuário atual.
-p O arquivo é um pipe.
-r O arquivo tem permissão de leitura.
-s O tamanho do arquivo é maior que zero.
-S O arquivo é um socket.
-t O descritor de arquivo N é um terminal.
-u O bit SUID está ativado.
-w O arquivo tem permissão de escrita.
-x O arquivo tem permissão de execução.
-nt O arquivo é mais recente que...
-ot O arquivo é mais antigo que...
-ef O arquivo é o mesmo que...
398
É importante, também, destacar outros operadores que funcionam como
redirecionadores, alterando as entradas e saídas dos comandos no shell. A seguir,
encontramos a descrição desses operadores:
Operador
Descrição
redirecionador
; Responsável pela separação dos comandos.
A Standard Output é transformada em Standard Input, de um
|
comando para outro.
A Standard Output é enviada para um arquivo. O conteúdo
>
desse arquivo é criado ou, caso ele já existisse, é sobrescrito.
A Standard Output é enviada para um arquivo. O conteúdo é
>>
inserido no final desse arquivo.
O conteúdo de um arquivo é redirecionado para a Standard
<
Input.
2>&1 A Standard Error é transformada em Standard Output.
2> A Standard Error é enviada para um arquivo.
Responsável por testar o valor da variável $?, este é o operador
||
OU.
$$ Responsável por testar o valor da variável $?, este é o operador E.
6.3. Gerenciamento de dados
Para consultar, editar e incluir dados em banco de dados, costumamos lidar com
a linguagem padrão SQL (Structured Query Language, que significa Linguagem de
Consulta Estruturada). Com ela, não é necessário conhecer as tecnologias específicas
que estão sendo utilizadas para que possamos realizar as principais atividades em
um banco de dados.
Utilizamos a linha de comando para nos comunicarmos com o banco de dados. Essa
interação é feita com um prompt proporcionado pelos principais bancos de dados,
procedimento similar ao prompt de bash.
Para interagir manualmente no banco de dados, é necessário considerar o tipo de

banco com o qual estamos lidando. O banco de dados MySQL e o Postgresql utilizam,
respectivamente, o comando mtsql e o psql.
399
As tabelas dos bancos de dados são parecidas com as das planilhas. Seus componentes
se organizam em:
•• Colunas: Contém as definições dos tipos de dados, além de nomes. Criado

de forma automática, o campo representado pela primeira coluna costuma
identificar determinada linha, sendo assim único;
•• Linhas: Compostas pelos dados que podem ser alterados, bem como inseridos
ou excluídos.
6.3.1. Inserindo dados
O comando SQL INSERT é utilizado para inserir dados. A seguir, vemos o uso do
comando para inserir uma linha em uma tabela existente:
INSERT INTO <tabela> (<coluna1, coluna2, etc>) VALUES (<valor_coluna1,

valor_coluna2, etc>);
Os valores nos primeiros parênteses representam os nomes das colunas nas quais
se deseja inserir os dados. Os valores nos parênteses após VALUES representam os
dados a serem inseridos nas colunas. Uma instrução SQL deve sempre terminar com
ponto e vírgula (;).
Caso uma coluna seja omitida na instrução, o respectivo campo fica vazio na
linha inserida. Um campo id é criado automaticamente para identificar a linha que
corresponde aos dados inseridos.
No exemplo a seguir, inserimos manualmente o campo id. Porém, deixamos o campo

data_cadastro em branco para ser preenchido automaticamente. Na tabela produtos,
foi inserido o produto Lavadora:
400
6.3.2. Consultando dados
Para consultar dados em bancos de dados, utilizamos o comando SELECT e algumas
instruções, que descrevemos adiante.
6.3.2.1. SELECT
O comando SELECT serve para consultar colunas de uma tabela. Para consultar uma
coluna específica, a sintaxe é a seguinte:
SELECT <coluna> FROM <tabela>;
O exemplo a seguir demonstra a seleção de colunas específicas:
Para exibir todas as colunas de uma tabela, utiliza-se a seguinte sintaxe:
SELECT * FROM <tabela>;
401
A seguir, o SELECT * é utilizado para listar tudo o que há na tabela:
6.3.2.2. WHERE
Para que a seleção se limite apenas a uma ou mais linhas que obedeçam a determinado
critério, utilizamos a instrução WHERE, cuja sintaxe é a seguinte:
SELECT <coluna> FROM <tabela> WHERE <criterio>;
A seguir, o WHERE é utilizado para listar apenas os produtos com o nome microondas,
e, em seguida, apenas os produtos com o nome TV:
402
6.3.2.3. ORDER BY
A instrução ORDER BY serve para alterar a ordem de exibição das linhas. Sua sintaxe
é a seguinte:
SELECT <coluna> FROM <tabela> ORDER BY <coluna>;
O valor designado após a instrução ORDER BY, em <coluna>, define o critério de

ordenação. É possível inverter a ordem de exibição, bastando, para isso, inserir a
instrução DESC após a instrução ORDER BY.
A seguir, temos dois exemplos da utilização de ORDER BY. No primeiro, ordenamos

por nome, em ordem crescente e alfabética. No segundo, ordenamos por ID em ordem
decrescente.
403
6.3.2.4. GROUP BY
A instrução GROUP BY permite reunir resultados de um ou mais valores duplicados.
SELECT <coluna1>, SUM(<coluna2>) FROM <tabela> GROUP BY <coluna3>;
Em que:
•• Todas as ocorrências duplicadas em <coluna1> são exibidas na mesma linha;
•• Os valores de todas as linhas agregadas por GROUP BY e presentes em

<coluna2> são somados pela função SUM( ).
Vejamos:
404
Observando a imagem anterior, primeiramente lista-se tudo o que há na tabela
cursos. Em seguida, é feita uma contagem e um agrupamento por curso, o que
permite identificar quantas pessoas estão realizando cada um dos cursos. Por fim, o
GROUP BY é utilizado para identificar quantas pessoas estão relacionadas em cada
modalidade. Podemos notar que há duas pessoas em Modulo 1.
6.3.2.5. INNER JOIN
Com a instrução INNER JOIN, podemos exibir linhas de uma tabela cujo valor em uma
determinada coluna seja igual ao valor de uma coluna localizada em outra tabela.
Dessa forma, é possível cruzar informações localizadas em tabelas diferentes.
No exemplo a seguir, listamos todo o conteúdo das tabelas cursos e cadastro:
405
Já no exemplo a seguir, a instrução INNER JOIN é utilizada para identificar quais

alunos de Patolandia estão realizando o curso de Linux:
No exemplo que acabamos de ver, o SELECT foi utilizado junto com DISTINCT para que
não houvesse repetição de resultado. Em seguida, definimos quais colunas deveriam
ser exibidas na tela, seguindo o formato tabela.coluna. No momento de definir a
tabela (FROM), utilizamos o comando INNER JOIN (cursos INNER JOIN cadastro).
A definição foi feita na (ON) tabela cadastro e coluna cidade (cadastro.cidade),

sendo que a cidade precisaria ser igual a Patolandia e (AND) a tabela cursos e a
coluna curso (cursos.curso) teriam que ser iguais a Linux. Aproveitamos, também,
para exibir o resultado em ordem alfabética, pelo nome do aluno.
6.3.3. Atualizando dados
Com a instrução UPDATE, é possível modificar dados já inseridos em uma tabela. Sua
UPDATE <tabela> SET <coluna> = <'novo_valor'> WHERE <criterio>;
As instruções UPDATE e SET definem a tabela e a coluna que terão os dados alterados.
Os novos dados são inseridos em <'novo_valor'>. Para definir as linhas que terão
seus valores modificados, é fundamental utilizar a instrução WHERE.
406
No exemplo adiante, elevamos o curso do aluno Linus Torvalds de Modulo 1 para
Modulo 2:
6.3.4. Excluindo dados
Para excluirmos as linhas de uma tabela, utilizamos a instrução DELETE, cuja sintaxe
é a seguinte:
DELETE FROM <tabela>;
Essa sintaxe exclui todas as linhas de uma tabela. Para definir quais linhas devem ser
excluídas, deve-se utilizar a instrução WHERE após DELETE:
DELETE FROM <tabela> WHERE <criterio>;
407
No exemplo a seguir, o DELETE é utilizado para excluir o aluno Bill Gates da tabela:
Dicas LPI
•• Saber o conteúdo de algumas variáveis é muito importante, anote o dessa

aqui: HISTSIZE=500;
•• Conhecer um pouco das shells sh e bash pode ser muito importante para
prova.
408
Pontos principais
•• Há diversos tipos de shell disponíveis para distribuições GNU/Linux. Os principais

são: sh, bash, csh, tcsh, ksh e zsh. O bash é o tipo utilizado na maioria das
distros;
•• Shell scripts são arquivos contendo conjuntos de comandos digitados em texto

puro (ASCII), cuja finalidade é realizar a automatização de tarefas no prompt de
comandos;
•• Para consultar, editar e incluir dados em banco de dados, costumamos lidar com
a linguagem padrão SQL (Structured Query Language, que significa Linguagem
de Consulta Estruturada). Com ela, não é necessário conhecer as tecnologias
específicas que estão sendo utilizadas para que possamos realizar as principais
atividades em um banco de dados.
Sites Endereços
Shell Script http://linuxcommand.org/index.php
https://dev.mysql.com/doc/refman/5.7/en/sql-syntax-data-
MySQL
manipulation.html
409
410
6
Shell script e
gerenciamento
de dados
1. Qual o shell padrão nas distribuições Linux?
☐☐ a) sh
☐☐ b) csh
☐☐ c) bash
☐☐ d) rbash
☐☐ e) tsh
2. Qual o tipo de variável que pode ser lido em todas as seções?
☐☐ a) Local
☐☐ b) Global
☐☐ c) Ambiente
☐☐ d) Sistema
☐☐ e) Setada
3. Qual comando é utilizado para remover uma variável?
☐☐ a) unset
☐☐ b) unalias
☐☐ c) unenv
☐☐ d) remvar
☐☐ e) unvar
4. Qual comando é utilizado para visualizar um retorno de uma variável?
☐☐ a) variavel
☐☐ b) var
☐☐ c) ls
☐☐ d) cat
☐☐ e) echo
5. Qual comando pode ser utilizado para visualizar os últimos comandos

executados?
☐☐ a) history
☐☐ b) bash_history
☐☐ c) lastcommands
☐☐ d) ls
☐☐ e) echo
412
6. Qual comando é utilizado para tornar um script executável?
☐☐ a) chmod +x
☐☐ b) chown +x
☐☐ c) chmod x
☐☐ d) chown x
☐☐ e) exec +x
7. Qual variável representa o nome do próprio script?
☐☐ a) $?
☐☐ b) $1
☐☐ c) $n
☐☐ d) $!
☐☐ e) $0
8. Em uma sintaxe de if, se a situação não for atendida, qual comando deve
ser utilizado para executar outra tarefa?
☐☐ a) then
☐☐ b) else
☐☐ c) fi
☐☐ d) case
☐☐ e) for
9. Qual das alternativas a seguir explica melhor o while?
☐☐ a) Executa enquanto for falso.

☐☐ b) Executa se a informação for verdadeira.
☐☐ c) Executa enquanto for verdadeiro.
☐☐ d) Executa somente se a informação for falsa.
☐☐ e) Executa em looping infinito.
10. Em uma tabela chamada Cliente, que possui os campos Empresa,

Contato e Telefone, qual comando deve ser utilizado, em MySQL, para
descobrir o telefone da empresa ACME e quem é o contato?
☐☐ a) SELECT * FROM cliente WHERE Empresa=”ACME”

☐☐ b) SELECT Empresa FROM cliente WHERE Contato= “?”
☐☐ c) SELECT Contato FROM Empresa WHERE cliente=”ACME”;
☐☐ d) SELECT * FROM cliente WHERE Empresa=”ACME”;
☐☐ e) SELECT ACME FROM empresa WHERE Contato=”?”;
413
Shell script e
6 gerenciamento
de dados
Mãos à obra!
Laboratório 1 - Gerenciando variáveis

1. Crie uma variável chamada CURSO:
# CURSO=Impacta
2. Verifique o valor da variável CURSO:
# echo $CURSO
3. Verifique se a variável está na relação de variáveis:
# set |grep CURSO
4. Defina uma variável global:
# export IMPACTA=”Curso Linux”
5. Visualize o valor para a variável global:
# echo $IMPACTA
6. Com o comando env, verifique se a variável global está listada nas definições de
variáveis:
# env |grep IMPACTA
7. Execute um novo shell no mesmo terminal em que se está conectado:
# /bin/bash
8. Verifique se a variável local aparece no shell executado (o resultado deve ser

negativo):
# env |grep CURSO

# set | grep CURSO
9. Verifique se a variável global aparece nesse shell (o resultado deve ser positivo):
# env |grep IMPACTA

# set |grep IMPACTA
10. Saia do shell:
# exit
416
Laboratório 2 - Criando alias
11. Crie um alias para o comando ls:
# alias l=”ls -l”
12. Execute o novo alias:
# l
13. Altere definitivamente o funcionamento do comando ls para o usuário root. Para

isso, abra o arquivo /root/.bashrc em um editor de texto:
# vi /root/.bashrc
14. Adicione a seguinte linha:
alias ls=”ls –color”
15. Salve o arquivo e saia:
# :wq
16. O novo alias terá efeito na próxima vez em que o logon for realizado. Então,
efetue o logoff:
# exit
17. Logue novamente e execute o comando ls. Agora, é possível notar que o resultado
é colorido.
# ls /etc
Laboratório 3 - Visualizando os últimos

comandos executados
18. Analise o arquivo de histórico:
# cat /root/.bash_history | more
19. Execute o comando history:
# history
417
Laboratório 4 - Preparando para iniciar o script

20. Crie uma pasta para armazenar os scripts;
# mkdir /opt/scripts
21. Crie o arquivo para começar a editar os scripts.
# vi /opt/scripts/backup.sh
Laboratório 5 - Criando um script de backup

Este script funcionará da seguinte forma:
•• Identificará as pastas pessoais dos usuários, criará um arquivo compactado

separado para cada pasta e testará se o arquivo está correto;
•• Fará o backup da pasta /etc;
•• Enviará os backups para uma pasta chamada /backup;
•• Gerará o log de todos os passos.
22. Para criar o script de backup, copie o script a seguir. Não é necessário copiar os
comentários (#):
#!/bin/bash
# definicao da variavel data personalizada (ex. 10-maio-2010)

DATA=`date +%d-%B-%Y`
# definicao da variavel de LOG
LOG=/var/log/backup/backup_$DATA.log
# Variavel que define qual e a pasta de backup
PASTA_BACKUP=/backup
# Variavel que define a pasta home dos usuarios
HOME=/home
# Verifica se a pasta para armazenamento dos logs existe

test -d /var/log/backup
# Variavel para verificar o resultado do ultimo comando (test)
VERIFICA_PASTA=$?
# Se o comando anterior for diferente de 0 (diferente de verdadeiro)

if [ $VERIFICA_PASTA != “0” ]
418
then
# Cria a pasta
mkdir /var/log/backup
fi
# Esta e uma forma diferente de usar o comando test

# Verifica se a pasta NAO (!) existe, se for verdadeiro
# cria a pasta
if [ ! -d $PASTA_BACKUP ]; then
mkdir $PASTA_BACKUP
fi
# Insere os textos abaixo no arquivo de log, repare que na primeira

# linha o redirecionador e “>”, isto criara o arquivo nas demais
# linhas, o redirecionador e “>>”, apenas adicionara as informacoes
# ao arquivo
echo “-------------------------------------” > $LOG
echo “Inicio dos Backups $DATA” >> $LOG
echo “-------------------------------------” >> $LOG
echo “Fazendo backup da pasta /etc” >> $LOG
# Compacta a pasta /etc e envia o arquivo compactado para a Pasta de
backup
tar -czf $PASTA_BACKUP/etc_$DATA.tar.gz /etc 2> /dev/null
# Com comando md5sum (nao requisito da LPI), podemos checar se um
arquivo
# compactado nao esta corrompido
# Gera o md5sum para o arquivo e depois verifica se nao esta corrom-

pido
md5sum $PASTA_BACKUP/etc_$DATA.tar.gz | md5sum --check >> $LOG
echo “-------------------------------------” >> $LOG

echo “Fazendo backup das pastas dos usuarios separados” >> $LOG
echo “--------” >> $LOG
# Faz com que a variavel USUARIOS execute um comando no shell e
guarde seu resultado,
# para isto usamos o comando entre crases (`).
USUARIOS=`ls -w 1 /home/`
# Armazena na variavel i cada um dos resultados da Variavel USUARIOS
# e pra cada resultado sera tomada a acao abaixo
for i in $USUARIOS; do
echo “fazendo backup da pasta $i para $PASTA_BACKUP com o
nome de pasta_$i-$DATA.tar.gz” >> $LOG
# compacta a pasta do usuario e grava na pasta /backup as
mensagens de erro da tela
# sao redirecionadas para o /dev/null
tar -czf $PASTA_BACKUP/pasta_$i-$DATA.tar.gz $HOME/$i 2> /
dev/null
419
# verifica se o backup nao esta corrompido

md5sum $PASTA_BACKUP/pasta_$i-$DATA.tar.gz | md5sum --check
>> $LOG
echo “O tamanho da pasta $i e:” >> $LOG
# Verifica o tamanho de cada pasta e armazena no LOG
du -chs $HOME/$i >> $LOG
done
# Faz uma limpeza na pasta backup, procura arquivos com mais de 7

dias, se encontrar deleta
echo “-------------------------------------” >> $LOG
echo “Fazendo Limpeza na pasta /backup” >> $LOG
find $PASTA_BACKUP -mtime +7 -exec rm -f {} \; >> $LOG
echo “Fazendo Limpeza na pasta de logs /var/log/backup” >> $LOG
find /var/log/backup -mtime +7 -exec rm -f {} \; >> $LOG
echo “----------------------------------------” >> $LOG

echo “Fim do backup” >> $LOG
echo “----------------------------------------” >> $LOG
Laboratório 6 - Tornando o script executável

23. Salve e saia do arquivo;
:wq
24. Conceda permissão de execução no arquivo;
# chmod +x /opt/scripts/backup.sh
25. Execute o script;
# /opt/scripts/backup.sh
26. Observe o log gerado (troque $DATA pela data no nome do arquivo);
# ls /var/log/backup
# cat /var/log/backup/backup_$DATA.log
27. Observe os arquivos que foram gerados.
420
# ls /backup
Laboratório 7 - Instalando o banco de dados

MySQL no CentOS
28. Efetue a instalação do banco de dados;
# yum install mysql-server
29. Inicie o serviço;
# systemctl start mysqld
30. Defina uma senha de administração para o usuário root;
# mysqladmin -u root password
31.Acesse o banco de dados;
# mysql -u root -p
32. Crie uma base de dados CURSOS;
create database CURSOS;
33. Acesse a base de dados e crie a tabela LINUX;
create table LINUX (codmodulo varchar(6) not null, modulo var-

char(30) not null, primary key(codcurso));
34. Insira os dados a seguir:
insert into LINUX values (‘000001’,’Administração’);

insert into LINUX values (‘000002’, ‘Engenheiro I’);
insert into LINUX values (‘000002’, ‘Engenheiro II’);
35. Verifique os dados inseridos da tabela LINUX:
select * from LINUX;
421
7 Interface do
usuário e desktop
ÃÃ Servidor X - Interface gráfica;

ÃÃ Acessibilidade.
Este capítulo faz parte do tópico 106 – User Interfaces and Desktops da segunda
Você precisará entender o arquivo de configuração do X Window, Gerenciador de

Janelas, tecnologias de acessibilidade e também um breve entendimento sobre
servidor de fontes.

Para o mercado de trabalho, a interface gráfica não é utilizada em se tratando de

servidor, porém, algumas empresas usam Linux em desktops e, com isso, o
entendimento desse assunto se torna importante.
7.1. Servidor X - Interface gráfica

O servidor X é compatível com o sistema Unix e permite que interfaces gráficas sejam
desenvolvidas para usuários ou ambientes GUI (Graphical User Interfaces). Também
chamado de X Window System, X11 ou simplesmente X, o servidor X é um protocolo
que possibilita o uso do sistema de janelas e a interação do usuário com o sistema
por meio de mouse e teclado em uma máquina, remota ou não. É dono de uma
arquitetura originalmente desenvolvida para uso em ambientes de rede, daí o nome
servidor X.
Tal sistema ganhou importância para desenvolvedores e administradores Linux

na medida em que houve considerável evolução dos aplicativos e expansão da
quantidade de usuários iniciantes. A disponibilidade de um ambiente gráfico que
funcione sem prejudicar as atividades de seus usuários torna o GNU/Linux e seus
aplicativos acessíveis a pessoas sem conhecimentos avançados da arquitetura do
sistema operacional.
Com esse servidor, as janelas são gerenciadas pelos gerenciadores de janela (window
managers, ou WM) e, assim, a estética gráfica delas difere dependendo de cada
gerenciador. Enquanto isso, configurações como mover janelas, desenhar na tela e a
interação com o mouse e teclado são feitas pelo GUI.
424
Interface do usuário e desktop 7
7.1.1. Verificando os dispositivos de hardware
compatíveis
O servidor X costuma ser configurado de forma automática, mas há casos em que sua
configuração ou instalação deve ser realizada manualmente. Para isso, é necessário
verificar os dispositivos de hardware compatíveis, cuja lista pode ser conferida no site
www.x.org/wiki/Projects/Drivers.
Grande parte dos dispositivos de vídeo suporta o modo VESA Framebuffer, permitindo
que o dispositivo nesse modo seja usado mesmo quando apenas parcialmente
compatível.
7.1.2. Instalando o servidor X
A instalação do Linux geralmente é acompanhada pela instalação do servidor X. No
entanto, existem casos em que devemos usar ferramentas de pacotes de distribuição
para fazer essa instalação.
Isso costuma ocorrer quando cada servidor tem uma distribuição específica instalada
nele. O site www.xorg.org disponibiliza o pacote xorg, com o qual adquirimos o X e
que pode ser instalado com o apt-get, o yum e o aptitude.
7.1.3. Iniciando o servidor X
Para iniciar o servidor X, basta digitar X na linha de comando. O resultado é o seguinte:
425
7.1.4. Configurando o servidor X
Para que o servidor X seja configurado, precisamos editar o arquivo /etc/x11/xorg.
conf, no qual temos acesso a informações sobre:
•• Teclado;
•• Mouse;
•• Arquivo do sistema;
•• Dispositivo de vídeo;
•• Monitor.
Um arquivo básico de configuração é criado com uma sintaxe contendo a opção

-configure e o comando X, e pode sofrer ajustes para que o funcionamento do X seja
aperfeiçoado. A seguir, a sintaxe desse arquivo:
# X -configure
O servidor X deve executar algumas atividades, a saber:
•• Carregar os módulos de dispositivo;
•• Testar o driver;
•• Salvar o resultado no diretório do usuário, geralmente /root, no arquivo

xorg.conf.new.
7.1.5. Seções do arquivo xorg.conf

Dividido em seções, o arquivo xorg.conf é composto por informações referentes a
dispositivos como teclado, placa de vídeo e mouse. Essas informações determinam os
arquivos de fontes e módulos que serão carregados, entre outros recursos utilizados
pelo X.
As configurações são, na maioria das vezes, realizadas de forma automática. Certas

dificuldades, no entanto, demandam uma configuração manual, por isso, é importante
conhecer essas seções, que são:
•• Module: Especifica os módulos que serão carregados de forma dinâmica com

Load “nome do módulo”;
•• ServerFlags: Engloba opções, no formato Option “Nome” “Valor”, que são

universais para esse servidor;
426
•• Files: Contém caminhos como RGBPath, ModulePath e FontPath – este
último é responsável por identificar onde as fontes podem ser encontradas –,
indispensáveis ao X;
•• InputDevice: Cada uma dessas seções indica um dispositivo de entrada. Existem

opções que podem ser definidas com Option, pois não são obrigatórias. Elas
são:
•• Option “CorePointer”: O mouse primário é o dispositivo em questão;
•• Option “CoreKeyboard”: Neste caso, o dispositivo é o teclado primário;
•• Option “Device” “/dev/arquivo_do_dispositivo”: Determina o caminho

para o dispositivo.
Os itens indispensáveis desta seção, por outro lado, são:
•• Identifier: Identifica um dispositivo por meio de um nome único;
•• Driver: Mouse e Keyboard são seus valores mais comuns;
•• Device: Indica um dispositivo de vídeo, podendo ter mais de uma seção e, assim,
identificando mais de um desses dispositivos. Existem alguns itens, como BusID
e VideoRam (Option “BusID” “PCI:1:0:0” e Option “VideoRam” “8192” são seus
respectivos exemplos); entre os itens existentes, os obrigatórios são:
•• Identifier: Identifica um dispositivo por meio de um nome único;
•• Driver: Determina o driver, sendo que os disponíveis são encontrados em

/usr/lib/xorg/modules/drivers/.
•• Monitor: Das seções deste tipo, a Identifier é a única obrigatória. É possível

haver mais de uma seção Monitor;
•• Screen: Demanda a existência das opções Identifier e Device, e engloba o

monitor e o dispositivo. O arquivo pode possuir mais de uma seção desta;
•• ServerLayout: Define o display, sendo assim a seção mais importante. Obtemos

uma configuração completa com essa seção junto da seção Screen e da
InputDevice;
•• Display: Determina a resolução que as profundidades devem usar, por exemplo.
427
A seguir, podemos conhecer o formato em que essas seções são divididas:
Section “nome da seção”

Item_1 “Valor item 1”
Item_2 “Valor item 2”
...
EndSection
7.1.6. Instalando fontes
As fontes usadas pelos aplicativos são obtidas por meio do X. Os sistemas básicos
responsáveis por isso são o Core e Xft, cuja principal diferença se encontra na
manipulação das fontes – ela ocorre no servidor no caso do Core, e no cliente quando
se trata do Xft.
No sistema Xft, a instalação das fontes é feita mediante a cópia delas para o diretório
padrão ou no pessoal, respectivamente, /usr/share/fonts/* e ~/.fonts/. As fontes
que podem ser instaladas estão listadas a seguir, e têm o recurso anti-aliasing, com o
qual os cantos ficam arredondados e o serrilhado é diminuído:
•• Type1;
•• TrueType;
•• OpenType;
•• CID;
•• Speedo.
Quando uma sessão X é iniciada, ocorre uma atualização automática do cache –

o comando fc-cache permite que isso seja feito manualmente, se for o caso. Tal
atualização é necessária para que possamos usar a fonte oferecida pelo sistema Xft.
Para modificar as funções desse sistema, podemos recorrer ao:
•• Arquivo de configuração global /etc/fonts/fonts.conf;
•• Arquivo de configurações por usuário, no diretório pessoal, .fonts.conf.
428
O servidor de fontes Xfs permite que, em um servidor de rede, apenas um servidor
tenha as fontes utilizadas pelas outras máquinas. O arquivo de configuração /etc/
X11/fs/config possui algumas opções, descritas na tabela a seguir, e é o padrão para
o Xfs:
Opção Descrição
O limite de clientes com os quais o Xfs se conecta é definido
client-limit
nesta opção.
Esta opção representa os caminhos dos diretórios nos quais
catalogue
as fontes estão armazenadas.
O protocolo em que o servidor não deve operar é
no-listen
determinado nesta opção.
alternate-servers Demais servidores de fontes.
O servidor de fontes pode precisar da liberação da porta TCP padrão de conexão, a

porta 7100. Isso pode ocorrer quando o tráfego de rede é controlado.
Como vimos, um dos itens do arquivo /etc/X11/xorg.conf: é o FontPath, no qual

podemos incluir o caminho para o servidor – isso permitirá que o fornecimento de
fontes seja usado pelo computador em que o servidor Xfs trabalha. Dessa forma,
temos:
FontPath “Unix/:7100”
Inserimos, também, uma linha nos demais computadores. Assim, caso uma conexão
TCP/IP seja utilizada, teremos a seguinte sintaxe, em que numero_ip deve ser
substituído pelo número IP do computador em questão:
FontPath “tcp/numero_ip:7100”
7.1.7. Variável DISPLAY
Um servidor X remoto pode exibir as janelas de um aplicativo sendo executado
localmente. O local onde as janelas serão exibidas é identificado com a variável
DISPLAY.
A sintaxe para definição dessa variável é a seguinte:
<nome ou IP>:<monitor e dispositivo de entrada>
429
Temos duas partes nessa variável, descritas como:
•• Anterior ao sinal de dois-pontos: O nome ou o número IP da máquina é

identificado;
•• Posterior ao sinal de dois-pontos: É feita a identificação do display da máquina.
No valor do display, são identificados um monitor e um dispositivo de entrada, como

teclado e mouse. Geralmente, cada máquina possui apenas um display, mas é possível
que essa quantidade seja maior.
No caso de possuir apenas um display, o valor da variável será :0.0, pois contamos a
partir do número zero. Assim, as janelas serão exibidas tanto nesse display quanto no
computador local, sendo que temos localhost quando omitido o valor antes do sinal
de dois pontos.
A variável DISPLAY deve ser redefinida na própria máquina remota se quisermos

abrir, no computador local, a janela de um programa remoto.
No computador remoto, devemos dizer para qual computador desejamos enviar as

janelas. Também, devemos definir a saída padrão para esse envio. Então, precisamos
modificar a variável DISPLAY para que aponte para o destino desejado, como mostra
o seguinte exemplo:
$ export DISPLAY=192.168.0.5:0.0
Na linha anterior, 192.168.0.5 é o computador que abrirá as janelas remotamente e

0.0 é a saída padrão, ou seja, a tela.
Na estação que receberá as telas, será necessário autorizar a conexão entre as duas
máquinas. Para isso, utilizamos o comando xhost, adicionando (+) ou removendo (-)
o servidor, como no exemplo a seguir:
$ xhost +192.168.0.1
Na linha anterior, o computador com IP 192.168.0.1 foi autorizado a enviar as janelas

para a máquina que irá abri-las.
430
7.1.8. Gerenciadores de display (display managers)
Gerenciadores de display, também conhecidos como display managers, são
responsáveis pela identificação do usuário e inicialização do X11. Na tabela a seguir,
podemos conhecer os principais gerenciadores de display:
Gerenciador
Descrição
de display
Este gerenciador é o padrão do X, e a localização de seu arquivo
XDM
de configuração é etc/X11/xdm/*.
Padrão do KDE, seu arquivo de configuração se encontra em /
KDM
usr/share/config/kdm/*.
Padrão do GNOME, este gerenciador tem seu arquivo de
GDM
configuração em /etc/gdm.
O XDMCP (X Display Manager Control Protocol) é um protocolo de comunicação de

redes bastante rápido que atua como um protocolo de compartilhamento de interface
gráfica no sistema operacional Linux.
Nesse protocolo, as imagens e gráficos são transmitidos na forma de comandos. Estes

não consomem muita banda de rede e são processados rapidamente pelo destinatário
e, mesmo que as imagens sejam executadas a distância, o usuário não perceberá a
demora na atualização delas.
Com ele, que por padrão é desativado, o login pode ser realizado localmente e por
rede. A solicitação de conexão será feita pela máquina remota, com o comando X
-query servidor, sendo que o login por rede necessita do XDM ativo e configurado.
Com o arquivo Xsetup, não é necessário esperar a tela de login ser exibida para
realizar configurações em imagens de fundo e cores, por exemplo. Alterações em
mensagens, cores e fontes do gerenciador XDM são feitas por meio da edição do
arquivo /etc/X11/xdm/Xresources.
431
A seguir, temos um exemplo de Xresources:
O acesso remoto obtido por meio desse protocolo é controlado com o arquivo
/etc/X11/xdm/Xaccess, como mostra a seguinte tela:
Os arquivos de configuração do XDM são englobados pelo principal deles, o xdm-

config. Com esse arquivo, podemos efetuar a liberação ou bloqueio do login remoto,
o que impedirá que pedidos (diretos ou indiretos) de conexão não sejam respondidos.
A seguir, temos a linha necessária para o bloqueio do login remoto por XDMCP:
DisplayManager.requestPort: 0
Como visto, além do gerenciador de display XDM, temos também os gerenciadores

KDM e o GDM. Enquanto o arquivo de configuração do KDM é /usr/share/config/
kdm/kdmrc, os arquivos do GDM são /etc/gdm/gdm.conf e /etc/gdm/Init/Default,
correspondente ao Xresources.
No final da inicialização, o ambiente gráfico X costuma ser iniciado por

padrão nas distros Linux, e no ambiente gráfico é exibida a tela de login.
432
7.1.9. Gerenciadores de janela (window managers)
Com gerenciadores de janela (window managers), tanto a aparência quanto a
localização das janelas do X são administradas. Um dos diferenciais do GNU/Linux é
permitir que o próprio usuário gerencie as janelas, em vez de conceder esse controle
ao sistema, como é feito pelos sistemas Apple e Microsoft, que oferecem apenas uma
aparência básica.
No GNU/Linux, um computador pode ter vários gerenciadores de janela, cabendo

ao usuário usar o que mais lhe convir. Entre os gerenciadores, temos: AfterSteps,
Enlightenment, Kwin (ambiente KDE), Blakbox, Evilwn, IceWM, FluxBox, SawFish,
FVWM, Ion, Metacity (ambiente GNOME), WMN, OpenClasses (Sun), xfce e twm.
Os gerenciadores de janela são diferentes entre si no que diz respeito a diversos

fatores, tais como:
•• Recursos requisitados do computador;
•• Customização de funcionalidades e da aparência;
•• Configuração de menus;
•• Interface gráfica;
•• Capacidade de uso de vários computadores.
Muitas distros GNU/Linux atuais disponibilizam ferramentas de acessibilidade

voltadas para usuários com necessidades especiais, como problemas motores
e visuais. Tais ferramentas serão abordadas posteriormente neste capítulo.
7.1.10. Exibindo informações sobre um servidor X

Para conhecermos as informações a respeito do servidor X, podemos recorrer ao
xdpyinfo. Com esse utilitário, dados sobre os seguintes fatores são exibidos:
•• Telas e visuais;
•• Capacidade de um servidor;
•• Valores predefinidos para parâmetros que a comunicação entre cliente e servidor

utiliza.
433
A seguir, utilizamos o comando xdpyinfo para extrair todas as informações do

servidor X. Para facilitar a leitura, o comando more foi executado:
Neste outro exemplo, utilizamos xdpyinfo para extrair apenas informações sobre a
resolução do X:
434
7.1.11. Exibindo informações sobre janelas
As informações sobre janelas são exibidas com o xwininfo. Esse utilitário possui
algumas opções, entre as quais a –stats é a opção padrão em caso de nenhuma das
outras serem escolhidas. A opção escolhida determinará as informações apresentadas.
Na tela a seguir temos as opções que podemos utilizar com xwininfo:
435
No exemplo demonstrado a seguir, utilizamos a opção -root para exibir detalhes da

janela principal:
7.1.12. Controlando o acesso ao servidor X

O acesso ao servidor X é feito usando o programa xhost, com o qual é possível
determinar quais nomes de usuário ou de host poderão ou não se conectar ao servidor,
isto é, os nomes que serão excluídos ou adicionados.
No exemplo adiante, utilizamos comando xhost para adicionar o computador com

nome aluno2 na lista de hostnames permitidos. Em seguida, esse mesmo hostname
foi removido.
436
7.1.13. Utilizando um servidor X aninhado
Usando a variável DISPLAY, uma saída gráfica é redirecionada ao Xnest, servidor
X aninhado que a recebe. Com esse servidor, as solicitações são redirecionadas ao
servidor cliente, o qual é exibido, na sessão sendo executada, em outra janela. O
servidor X pai é, então, necessário para o funcionamento das fontes.
Nesse exemplo, foi criada com Xnest uma outra saída de vídeo, a :1 (tela ao fundo),
onde pode ser carregado um desktop remoto ou uma aplicação remota.
7.2. Acessibilidade
Como dito anteriormente, as distribuições GNU/Linux possuem recursos para pessoas
com necessidades especiais, que são mais utilizados em computadores desktops.
Entre esses recursos, temos:
•• Teclado virtual;
•• Leitor de tela;
•• Realce de cores;
•• Aumento do tamanho das fontes.
437
Outras opções, como visão, audição, digitação e comportamento do mouse, podem

ser acessadas por meio da opção Acessibilidade do Window Manager GNOME:
438
Vejamos, a seguir, um exemplo do teclado virtual habilitado:
439
7.2.1. Assistente de digitação
AccessX é conhecido como um assistente de digitação. Com ele, podemos habilitar
recursos como teclas de acessibilidade, teclas de aderência, teclas lentas e teclas de
repercussão.
7.2.2. Necessidade visuais
Usuários com deficiência visual poderão trabalhar no sistema por meio de um leitor
de tela chamado Orca, em que uma voz sintetizada é ouvida, conforme o clique do
mouse. Entre os recursos do Orca, temos:
•• Configurações gerais;
•• Voz;
•• Fala;
•• Braille;
•• Eco de tela;
440
•• Atalhos;
•• Pronúncia;
•• Atributos de texto.
A seguir, vejamos a tela de configuração do Orca:
Outro software que possui a mesma função é o Emacspeak, uma interface de voz
que permite aos usuários com deficiência visual interagirem de forma independente
e eficiente com o computador.
Entre os seus recursos, temos:
•• Formatação de áudio – técnica da pioneira AsTeR;
•• Suporte completo ao Aural CSS do W3C (ACSS);
•• Permite produzir ricas apresentações aurais de informação eletrônica;
•• Mistura todos os aspectos da Internet, tais como navegar na Web e enviar

mensagens;
•• Possibilita, por meio de comandos de voz, acesso a informação local e remota

através de uma interface de usuário consistente e bem integrada.
441
7.2.3. GNOME Onscreen Keyboard

Mais conhecido como GOK, o GNOME Onscreen Keyboard atua como um teclado
virtual na tela, em que as funções podem ser substituídas pelo mouse.
442
Pontos principais
•• Também chamado de X Window System, X11 ou simplesmente X, o servidor

X é um protocolo que possibilita o uso do sistema de janelas e a interação do
usuário com o sistema por meio de mouse e teclado em uma máquina, remota
ou não;
•• As distribuições GNU/Linux possuem recursos para pessoas com necessidades

especiais, como teclado virtual, leitor de tela, realce de cores, aumento do
tamanho das fontes, entre outros.
Sites Endereços
Servidor gráfico https://www.x.org/wiki/
GDM https://wiki.debian.org/GDM
KDM https://wiki.archlinux.org/index.php/KDM
Emacs http://emacspeak.sourceforge.net/
http://www.linuxfromscratch.org/blfs/view/6.3/gnome/
GOK
gok.html
Orca https://wiki.gnome.org/Projects/Orca
443
444
7 Interface do
usuário e desktop
1. Qual arquivo de configuração deve ser utilizado para ajustar o teclado

e a resolução de vídeo do ambiente X?
☐☐ a) xorg.conf
☐☐ b) x.conf
☐☐ c) Xresources
☐☐ d) kdm.conf
☐☐ e) gdm.conf
2. Qual comando é utilizado para configurar automaticamente o ambiente X?
☐☐ a) Xconfigure
☐☐ b) X -configure
☐☐ c) Xconfigure
☐☐ d) x -configure
☐☐ e) xconf
3. Qual comando pode ser utilizado para testar a configuração do X?
☐☐ a) dexconf
☐☐ b) xconf
☐☐ c) X -config
☐☐ d) xconfig
☐☐ e) X
4. Qual porta é utilizada pelo servidor X?
☐☐ a) 177/tcp
☐☐ b) 1777/tcp
☐☐ c) 127/udp
☐☐ d) 177/udp
☐☐ e) 1777/udp
5. Qual comando é utilizado para atualizar o banco de dados de fontes?
☐☐ a) fc-cache
☐☐ b) fccache
☐☐ c) fontesdb
☐☐ d) atualiza-fonts
☐☐ e) fonts-update
446
6. Qual o nome do principal leitor de teclas para o GNU/Linux?
☐☐ a) Golfinho
☐☐ b) Orca
☐☐ c) Baleia
☐☐ d) Sardinha
7. Qual o nome do programa que atua como um teclado virtual na tela, em

que as funções podem ser substituídas pelo mouse?
☐☐ a) GOkC
☐☐ b) GOCK
☐☐ c) GOK
☐☐ d) GOC
8. Qual o nome do programa que usa uma interface de voz que permite
que os usuários com deficiência visual interajam de forma independente
e eficiente com o computador?
☐☐ a) Emacspeak
☐☐ b) Emacs
☐☐ c) Speaks
☐☐ d) Macs
447
7 Interface do
usuário e desktop
Mãos à obra!
Laboratório 1 - Executando o servidor X

1. Instale o xorg no computador:
# aptitude -y install xorg
2. Verifique as opções do comando X utilizando o help:
# X –help
3. Verifique se há erros na identificação de hardware:
# X -probeonly
4. Leia o log de resultados do probe:
# cat /var/log/Xorg.0.log | more
5. Execute a configuração do X:
# X -configure
6. Verifique a configuração do X:
# cat /etc/X11/xorg.conf |more
7. Teste a configuração do X:
# X -config /root/xorg.conf.new
8. Teste a configuração do X com o dpkg:
# dpkg-reconfigure xserver-xorg
9. Copie o arquivo de configuração criado para utilização do X:
# cp /root/xorg.conf.new /etc/X11/xorg.conf
10. Inicialize o X:
# X
11. Feche o X pressionando CTRL + ALT + BACKSPACE.
450
Laboratório 2 - Analisando as configurações
12. Analise as configurações do arquivo xorg.conf e identifique as seções:
# cat /etc/X11/xorg.conf | more
13. Analise o arquivo de configuração de fontes:
# cat /etc/fonts/fonts.conf |more
Atente-se para as seguintes seções:
•• Font directory list;

•• Font cache directory list;
•• Rescan.
Laboratório 3 - Instalando um gerenciador de

janelas
14. Instale o WindowMaker:
# aptitude install wmaker
15. Inicie o X:
# X
16. Saia do X e inicie o WindowMaker:
# startx
17. Clique com o botão direito na tela e, em seguida, em Info / Info Panel;
18. Clique com o botão direito na tela e, em seguida, clique em Session / Exit e
confirme para sair;
451
19. Instale o KDE:
# aptitude update
# aptitude install kdebase
20. Inicie o KDE com o comando a seguir:
# startx
21. Instale o GNOME:
# aptitude install gdm gnome xfce4
22. Inicie novamente o ambiente gráfico:
# startx
Laboratório 4 - Configurando um servidor X remoto

23. Edite no computador o arquivo /etc/gdm/gdm.conf:
# vi /etc/gdm/gdm.conf
24. Localize e habilite a seção [xdmcp]:
[xdmcp]
Enable=True
25. Reinicie o GDM:
# /etc/init.d/gdm stop
# /etc/init.d/gdm restart
26. Verifique se o serviço está sendo executado na porta UDP 177 como era previsto:
# netstat -nltup |grep 177

# fuser 177/udp
27. Conceda permissão para o colega de sala se conectar:
# xhost +hostname <nome_da_maquina_do_colega>
452
Laboratório 5 - Acessando um servidor X remoto
28. Para chamar o ambiente X do colega, execute o comando a seguir:
# X -query <IP_do_colega> :1
Laboratório 6 - Configurações de acessibilidade

29. Acesse a distribuição Ubuntu e Linux Mint e verifique se as opções de acessibilidade
estão instaladas/ativas.
453
8 Tarefas
administrativas
ÃÃ Administração de usuários e grupos;

ÃÃ Agendamento de tarefas;
ÃÃ Localização e internacionalização.
Este capítulo faz parte do tópico 107 – Administrative Tasks da segunda

Você precisará estar apto a gerenciar as contas dos usuários e grupos do

sistema, agendar tarefas administrativas e configurar o timezone.

Para o mercado de trabalho, o gerenciamento de usuários e agendamentos

de tarefas são atividades essenciais para a administração do sistema.
8.1. Administração de usuários e grupos

O GNU/Linux é um sistema multiusuário e, portanto, possui um esquema de permissões
que provê a privacidade e/ou compartilhamento de arquivos entre usuários. Esse
esquema de permissões é parte fundamental de um sistema que fornece recursos
para mais de uma pessoa, garantindo seu funcionamento pleno e sua segurança por
meio de restrições de acesso a dados sensíveis, tanto pertencentes ao próprio sistema
como a diferentes usuários.
8.1.1. Tipos de usuário
É possível considerarmos três tipos distintos de usuários em um sistema GNU/Linux:
usuário administrador (superusuário), usuários de sistema e usuários comuns.
•• Usuário administrador
Em sistemas Unix e Linux, o superusuário do sistema tem o nome de root, pois ele
tem total poder dentro do sistema, atuando como seu administrador e definindo
regras e tipos de permissão que os demais usuários poderão acessar ou alterar. Além
disso, o usuário root tem total poder para interagir diretamente com o kernel e,
assim, possibilitar que o sistema atue de acordo com a sua necessidade. Dentro do
sistema, apenas o usuário root tem permissão para alterar o estado de serviços e criar
regras de firewall, entre outras funções.
Não é aconselhável trabalhar com o usuário root, pois, como foi citado, ele praticamente
não possui restrições no sistema. Dessa forma, é indicado que o administrador do
sistema trabalhe como um usuário comum e, só em caso de necessidade, execute
tarefas como superusuário.
456
Tarefas administrativas 8
•• Usuários comuns
Esse é o tipo de usuário adequado para a utilização e operação comuns no sistema

GNU/Linux. Tanto usuários comuns como administradores devem possuir, cada um,
uma conta desse tipo para utilizar o sistema.
Esses dois tipos de usuários, administradores e comuns, são constituídos por cinco
elementos básicos: nome, senha, diretório home, shell e grupo primário. A vinculação
de um usuário comum a um grupo é imprescindível devido ao funcionamento do
esquema de permissões dentro do sistema.
Recomenda-se o uso criterioso das senhas entre esses dois tipos de usuários, para
garantir a segurança do sistema contra acessos não desejados que podem pôr em
risco sua integridade.
•• Usuários de sistema
Os usuários de sistema têm a função de controlar serviços, e não devem possuir shell
válida, e nem senhas, como, por exemplo, o www-data, que controla o servidor web
Apache. Não há necessidade de efetuar logon no sistema com esse tipo de usuário.
Em sistemas GNU/Linux podem existir usuários normais que possuem

alguns privilégios adicionais em relação a certas aplicações, e são chamados
administradores. Eles, porém, não vêm configurados como padrão no sistema.
8.1.2. Permissões de acesso a arquivos e diretórios

Como diversos outros sistemas seguros, o GNU/Linux utiliza um esquema de
permissões de acesso para proteger o sistema do acesso indevido, seja de
programas ou de usuários não autorizados, impedindo que arquivos sejam apagados
desnecessariamente ou o funcionamento de um programa mal intencionado. A
segurança do GNU/Linux também impede o envio não permitido de arquivos para
outros locais e o fornecimento não desejado de acesso de rede que possibilitaria a
invasão do sistema por outros usuários.
Usuários do GNU/Linux, sejam mal intencionados ou por engano, podem ser impedidos
de instalar programas cuja função é desconhecida e que podem causar sérios danos
de larga escala, que afetem os arquivos, computadores ou até toda uma empresa.
457
Para isso, o sistema GNU/Linux define o acesso aos arquivos segundo as definições
seguintes:
•• Dono: Quem cria o arquivo, ou diretório, é considerado seu dono, e é identificado

pelo mesmo nome de usuário utilizado para ter acesso ao sistema, o user id
(UID). O dono é quem define e modifica as permissões de acesso do arquivo
criado. O arquivo /etc/passwd armazena a identificação de usuário ao qual o
arquivo pertence. Já o arquivo /etc/group armazena a identificação de grupo
ao qual o arquivo pertence;
•• Grupo: A divisão em grupos nos permite fornecer acesso a certos arquivos a um

conjunto de usuários, além do dono. Usuários podem participar de apenas um
ou de diversos grupos simultaneamente, e acessam os arquivos que pertencem
a cada um deles. A identificação do grupo é chamada de GID (group id). Como
padrão, um usuário recém-criado que não teve nenhum grupo definido para
fazer parte vai ser automaticamente inserido no grupo de mesmo nome do seu
grupo primário (conforme o parâmetro USERGROUPS=yes, do arquivo /etc/
adduser.conf);
•• Outros: Usuários que não são donos e nem pertencem ao grupo do arquivo são
categorizados nesse terceiro tipo.
Essas três categorias apresentam, cada uma, três tipos de permissões de acesso.
Vejamos os tipos de permissões a seguir.
8.1.3. Tipos de permissões
São três os tipos de permissões que o GNU/Linux aplica ao dono, grupos e outros
usuários. Eles são os seguintes:
•• r: Para arquivos, permite sua leitura, e para diretórios, permite que seu conteúdo
seja listado (utilizando, por exemplo, o comando ls);
•• w: Para arquivos, permite gravação, e para diretórios, permite a gravação de seu

conteúdo (arquivos ou outros diretórios). A remoção de arquivos e diretórios só
é possível com essa permissão ativada;
•• x: Para arquivos, permite que sejam executados, e para diretórios, habilita seu
acesso por meio do comando cd.
458
Por meio do comando ls –l, é possível visualizarmos essas permissões de acesso a
um arquivo ou diretório. A seguir, vemos arquivos listados com informações como as
permissões, proprietários, grupos etc.
Para entendermos melhor o funcionamento, dividimos o comando das permissões

em quatro partes. A primeira parte é constituída por um caractere. As três partes
seguintes são formadas cada uma por três caracteres, que são as permissões.
O primeiro caractere pode ser um dos seguintes encontrados na tabela:
Caractere Função
- Indica a listagem de um arquivo comum.
d Indica um diretório.
l Indica um link simbólico.
p Indica um pipe nomeado.
s Indica um socket.
c Indica um dispositivo de caractere.
b Indica um dispositivo de bloco.
As partes seguintes da sintaxe indicam, nessa ordem, as permissões do usuário dono

do arquivo, permissões de grupo e permissões para outros usuários, e cada uma das
partes é composta por três caracteres, r, w e x. Caso uma ou mais permissões não
forem definidas, substitui-se um dos caracteres por um – (hífen). A presença ou não
das letras r, w e x indica as permissões que o arquivo ou o diretório tem.
Após o comando das permissões, encontramos na sintaxe um número, que vai

definir quantos links simbólicos o arquivo ou o diretório possui, e logo em seguida, a
indicação do usuário dono do arquivo seguido do grupo ao qual ele pertence.
459
8.1.4. Atribuindo permissões
O comando chmod pode ser utilizado para atribuirmos as permissões de acesso de
usuários ou grupos a arquivos e diretórios, seja de leitura, gravação e/ou execução.
Com exceção de diretórios definidos com a permissão de grupo s, um arquivo, quando
criado, sempre tem como dono quem o criou e pertence ao seu mesmo grupo.
Vejamos:
chmod [opcoes] [permissoes] <diretorio/arquivo>
Na sintaxe anterior, diretorio/arquivo é referente ao diretório ou arquivo que terá

sua permissão alterada.
A tabela a seguir descreve as principais opções do comando chmod:
Opção Descrição
-v Mostra todos os arquivos que estão sendo processados.
-f Oculta a maior parte das mensagens de erro.
-c Mostra apenas os arquivos que tiveram as permissões alteradas.
Muda permissões de acesso do diretório ou arquivo no diretório
-R
atual e subdiretórios.
Em que:
•• ugoa: Controla que nível de acesso será mudado.

Especificam, em ordem, usuário (u), grupo (g), outros (o)
e todos (a);
ugoa+-=rwxXst •• +-=: O sinal + coloca a permissão, o sinal - retira a

permissão do arquivo e o sinal = define a permissão
exatamente como especificado;
•• rwx: A letra r indica permissão de leitura do arquivo, w

indica permissão de gravação e x permissão de execução
(ou acesso a diretórios).
As permissões de links simbólicos devem ser mudadas no arquivo alvo do link, pois
o chmod não altera essas permissões.
460
Duas sintaxes são possíveis para o comando chmod, como veremos a seguir:
•• Sintaxe literal
Na tela anterior, após executarmos o comando ls –l para visualizar as propriedades

dos arquivos, pudemos notar que a permissão é apenas de execução para todos eles
(--x--x--x).
Logo em seguida, adicionamos a permissão rw para o proprietário (root) do arquivo,

tornando a permissão -rwx--x--x.
Essa sintaxe define o esquema de permissões, em que cada caractere do parâmetro

tem sua função. O primeiro caractere indica para quem as permissões estão sendo
alteradas, conforme vemos a seguir:
•• A letra u indica o próprio dono;
•• A letra g indica o grupo;
•• A letra o indica outros;
•• A letra a indica todos.
Seguindo esse primeiro caractere, podemos encontrar um sinal + ou -, que significam,

respectivamente, adicionar ou remover a permissão. A terceira parte do parâmetro
pode conter até três caracteres:
•• A letra r, para garantir a leitura;
•• A letra w, para garantir a gravação;
•• A letra x, para garantir a execução.
461
No exemplo adiante, utilizamos o comando chmod para retirar a permissão de escrita

dos usuários pertencentes ao mesmo grupo ao qual o arquivo pertence. As demais
permissões não são alteradas.
•• Sintaxe numérica (octal)
A sintaxe numérica, ou modo octal, é um conjunto de oito números que representam,

cada um, um tipo diferente de acesso. Seu uso é mais simples que o da sintaxe literal,
pois nos permite gerenciar diretamente as permissões do dono, do grupo e de outros
usuários em vez de gerenciar as permissões de cada um separadamente.
O parâmetro que define as permissões no modo octal é composto de três números

que podem ir de 0 a 7, e correspondem às permissões para o dono, para o grupo e
para outros usuários.
Para entendermos mais facilmente como as permissões de acesso octais funcionam,

devemos considerar os seguintes valores para cada tipo de permissão:
•• 1: Executar;
•• 2: Gravar;
•• 4: Ler.
A partir desses valores, podemos chegar a todos os outros possíveis no modo octal,
somando os valores numéricos referentes às permissões desejadas. Vejamos a seguir
o raciocínio:
•• 0: Nenhuma permissão de acesso. Equivale a –rwx;
•• 1: Permissão de execução (x);
•• 2: Permissão de gravação (w);
•• 3: Permissão de gravação e execução (wx). Equivale à permissão 2 + 1, ou

seja, os valores de gravação (2) e execução (1) somados;
•• 4: Permissão de leitura (r);
•• 5: Permissão de leitura e execução (rx). Equivale à permissão 4 + 1, ou

seja, os valores de leitura (4) e execução (1) somados;
462
•• 6: Permissão de leitura e gravação (rw). Equivale à permissão 4 + 2, ou
seja, os valores de leitura (4) e gravação (2) somados;
•• 7: Permissão de leitura, gravação e execução. Equivale a +rwx (4 + 2 + 1),

ou seja, os valores de leitura (4), gravação (2) e execução (1) somados.
Para dono e grupo, devemos multiplicar as permissões anteriores por 100 e 10,
respectivamente.
Para as permissões de acesso especiais, devemos usar:
•• 1000: Salva imagem do texto no dispositivo de troca;
•• 2000: Ajusta o bit setgid na execução;
•• 4000: Ajusta o bit setuid na execução;
•• 5000: Salva imagem do texto e ajusta o bit setuid (equivale a 1000 + 4000 /
Salvar texto + bit setuid);
•• 6000: Ajusta o bit setuid e setgid (equivale a 4000 + 2000 / setuid +

setgid).
Vejamos, a seguir, que o arquivo inicialmente tinha permissão de controle total para
todos os usuários (rwx). Logo em seguida, atribuímos a permissão 755 para o arquivo
(permissão rwxr-xr-x), o que manteve o controle total para o proprietário, mas tirou
o poder de escrita dos demais usuários.
8.1.5. umask
O comando umask é utilizado para definir a máscara de criação de arquivos para o
usuário. Com ela, definimos permissões padrão de um arquivo ou diretório quando
os criamos, por meio de três números. As permissões definidas por esses números
serão aplicadas ao arquivo ou diretório quando eles forem criados ou copiados para
um novo local, de acordo com o tipo de usuário (dono, grupo ou outros usuários).
463
umask <valor>
Para retornar o valor do umask atual, devemos digitar umask sem parâmetros.
Cada tipo de arquivo, seja ele binário (executável) ou texto, recebe um efeito diferente
de umask, conforme podemos visualizar na tabela seguinte:
umask Arquivo Diretório

Binário Texto
0 r-x rw- rwx
1 r-- rw- rw-
2 r-x r-- r-x
3 r-- r-- r--
4 --x -w- --x
5 --- -w- -wx
6 --x --- --x
7 --- --- ---
Programas que criam arquivos e/ou diretórios temporários utilizam muito o umask,
pois desta forma o acesso de outros usuários pode ser bloqueado desde a criação do
arquivo, sendo desnecessário o uso do chmod.
Vejamos um exemplo: um arquivo texto gerado com o comando umask 027;touch

testeumask.txt receberá as permissões -rw-r-----. Isso significa que, respectivamente,
o dono terá permissões rw- (valor 0), o grupo terá permissões r-- (valor 2) e os outros
usuários não terão permissões de acesso --- (valor 7).
Já um arquivo binário copiado com o comando umask 027;cp /bin/ls /tmp/ls vai
receber as seguintes permissões: -rwxrw----. Isso significa que, respectivamente, o
dono terá permissões rwx (valor 0), o grupo terá permissões rw- (valor 2) e os outros
usuários não terão permissões de acesso --- (valor 7).
Devemos tomar cuidado com as atribuições do umask, pois um erro pode causar
problemas de acesso a arquivos e diretórios. Na maioria das distribuições atuais, o
valor padrão do umask é 022. O umask padrão no sistema Debian é a 022.
464
Caso não tenhamos acesso à tabela anterior, podemos recorrer à seguinte regra:
•• Cálculo da máscara para um diretório: 777 (permissão total do diretório)

menos 022 (valor padrão da máscara no Debian);
•• Cálculo da máscara para um arquivo: 777 (permissão total do objeto) menos

111 (valor padrão da máscara no Debian).
8.1.6. SUID e SGID
O SUID, o SGID e o Sticky Bit formam um conjunto de permissões especiais, as quais
também são denominadas bits especiais. Cada um deles é explicado a seguir.
•• SUID (Set User ID Bit)
Essa permissão pode ser uma grande ameaça à segurança, pois, quando atribuída a
um arquivo executável, dá permissões de usuário dono a um usuário qualquer, na
execução desse comando. Caso esse comando pertença a um usuário root, o usuário
comum terá sobre ele todas as permissões que seu dono possui.
•• SGID (Set Group ID Bit)
Essa permissão é atribuída a diretórios, e faz com que o conteúdo gravado dentro do
diretório herde o seu grupo, e não o grupo do usuário que o criou, quando um arquivo
é criado dentro de um diretório com essa permissão ativada. O SGID é muito utilizado
em servidores de arquivos e quando usamos diretórios para grupos de trabalhos.
•• Sticky Bit
O Sticky Bit, a partir da versão 2.6 do kernel do Linux, tem apenas a função de fazer
diretórios de utilização comum a todos os usuários, como no /tmp, visto que a partir
dessa série do kernel, otimizações de acesso a conteúdos são feitas diretamente por
ele. Essa permissão, quando ativada em um diretório, impede que quaisquer usuários
excluam o arquivo ou diretório, mesmo que seu criador atribua permissões totais
para todos os usuários. Apenas o usuário root tem esse controle sobre o arquivo ou
diretório.
O procedimento para atribuirmos essas permissões especiais é o mesmo utilizado

para as permissões comuns, através do comando chmod, porém utilizamos quatro
caracteres, onde o primeiro é o bit referente à permissão especial e os outros três são
a permissão padrão. A tabela a seguir mostra o valor de cada uma dessas permissões:
Nome Valor
SUID 4
SGID 2
Sticky Bit 1
465
Vejamos um exemplo:
# chmod 4750 aplicativo
Na linha anterior, 4 é o valor relativo ao SUID. Os outros três números, 750, referem-
se às permissões padrão e aplicativo, ao comando a ser executado.
8.1.7. Arquivos de administração de usuários e grupos

No que diz respeito à administração de usuários e grupos, podemos utilizar quatro
arquivos básicos, que veremos a seguir.
8.1.7.1. /etc/passwd
O arquivo /etc/passwd mantém uma linha relativa a cada usuário cadastrado,
separadas por : (dois-pontos). Vejamos um exemplo de como se compõe esse arquivo:
usuario:x:1000:1001:nome_do_usuario, 8111-1234:/home/usuario:/bin/
bash
Em que:
•• usuario: Define o login do usuário;
•• x: É a referência da senha do usuário, cujo armazenamento é feito em outro

arquivo;
•• 1000: O UID, que identifica o usuário. Esse valor é divido em três categorias:
•• UID 0: O administrador root;
•• UID de 1 a 999: Os usuários de sistema;
•• UID de 1000 a 65535: Os usuários normais.
•• 1001: O GID, que identifica o grupo primário do usuário. Esse valor é divido em
três categorias:
•• GID 0: O administrador root;
•• GID de 1 a 999: Os usuários de sistema;
•• GID de 1000 a 65535: Os usuários normais.
466
•• nome_do_usuario, 8111-1234: Dados adicionais sobre o usuário, como nome
completo etc.;
•• /home/usuario: Diretório pessoal do usuário;
•• /bin/bash: Shell do usuário.
O único valor padrão é o UID 0, atribuído ao administrador root. Valores referentes

a usuários de sistema e usuários normais podem variar nas distribuições.
8.1.7.2. /etc/shadow
O arquivo /etc/shadow, também conhecido pelo termo senhas sombra, armazena
todas as senhas dos usuários, por se tratar de um arquivo mais seguro que o /
etc/passwd, ao qual todos os usuários podem ter acesso. O arquivo /etc/shadow
contém permissões muito mais restritas e não pode ser copiado ou visualizado por
outros usuários, tornando o sistema muito mais seguro.
Como padrão, o sistema GNU/Linux possui o suporte a senhas sombras ativado,

porém, durante o modo de instalação expert é possível escolhermos se vamos ativar
esse suporte ou não. Para ativá-las depois da instalação, devemos utilizar o comando
pwconv. Para desativá-las, usamos o comando pwunconv.
Além de controlar e armazenar as senhas dos usuários do sistema GNU/Linux, o

arquivo /etc/shadow também trata de políticas de contas do usuário, armazenando
dados como a duração em dias de uma conta, sua data de expiração, a data da troca
da senha, entre outras informações importantes.
8.1.7.3. /etc/group
O arquivo /etc/group lista os grupos que estão presentes no sistema. Como usuário
root, podemos editar esse arquivo para adicionar um usuário em um novo grupo.
Assim, esse usuário passa a acessar os arquivos e diretórios pertencentes àquele
grupo. Indica-se o uso do comando vigr para editar o arquivo /etc/group. Esse
comando bloqueia o arquivo e evita sua alteração indesejada.
Cada grupo é definido, nesse arquivo, em uma linha, dividida em quatro segmentos.
Cada um deles tem uma função diferente, e são separados por : (dois-pontos). A
seguir, veremos as funções de cada segmento da linha:
•• Primeiro segmento: O nome do grupo;
•• Segundo segmento: A senha relativa ao grupo (x se utilizarmos /etc/gshadow);
467
•• Terceiro segmento: Número de identificação do grupo (group ID);
•• Quarto segmento: Lista de usuários que fazem parte do grupo, separados por
vírgula.
8.1.7.4. /etc/gshadow
O arquivo /etc/gshadow tem a função de armazenar as senhas ocultas dos grupos
existentes no sistema. Nesse caso, apenas o usuário root tem acesso liberado a
elas. O suporte a senhas ocultas pode ser ativado e desativado por meio do utilitário
shadowconfig.
Veja o arquivo /etc/gshadow a seguir:
O arquivo /etc/gshadow é dividido em quatro campos:
•• root: Nome do grupo;
•• *: Corresponde à senha do grupo;
•• root: Administrador do grupo;
•• fabricio: Membro do grupo.
8.1.8. Administrando usuários
Este tópico vai nos mostrar como administrar e gerenciar os usuários. Veremos como
devemos proceder para obtenção de informações sobre o usuário, como criá-los,
alterar suas configurações e senhas e como excluí-lo.
468
8.1.8.1. Obtendo informações sobre o usuário
Vejamos, a seguir, os principais comandos disponíveis para obtermos informações
sobre os usuários do sistema:
•• id
O comando id nos permite visualizar as identificações dos usuários. Esse comando

nos mostra dados de UID, GID e grupos secundários dos usuários.
Quando digitamos id, visualizamos informações do usuário atual, e quando

adicionamos o nome do usuário na sintaxe, visualizamos as informações referentes a
esse usuário. A sintaxe é a seguinte:
id <usuario>
Na imagem adiante, o comando id mostra informações do usuário logado (root). Em

seguida, é executado o comando id aluno. Neste caso, são exibidas as informações
do usuário aluno.
•• finger
Dados sobre configurações dos usuários, tais como login, nome, diretório home,
shell e horário das últimas autenticações realizadas por esse usuário, podem ser
visualizados por meio do comando finger.
finger <usuario>
No exemplo a seguir, o comando finger aluno3 é executado para exibir detalhes

do usuário aluno3, tais como shell em uso, diretório home, nome completo, entre
outros:
469
•• users
Os usuários logados no sistema são listados de maneira simples pelo comando users.
A seguir, o comando users exibe os usuários atualmente logados. No caso, há apenas

o usuário aluno:
•• who
Para que possamos visualizar os usuários que estão logados na máquina, utilizamos
o comando who. Além disso, esse comando também nos fornece outros dados sobre
os usuários, como qual terminal está sendo usado, quando o login foi feito e a partir
de qual máquina.
•• w
Caso seja necessário visualizar remotamente as ações de cada usuário, utilizamos

o comando w, que funciona de modo similar ao comando who, porém nos dá
informações que tornam possível controlarmos a existência de conexões indevidas
no sistema, entre outras funções.
Para isso, usamos a seguinte sintaxe, que consiste no comando w mais o nome do
usuário que desejamos visualizar:
w <usuario>
O exemplo a seguir demonstra o uso de who para o usuário aluno:
470
8.1.8.2. Criando usuários
No momento da instalação do sistema, é possível criar usuários e, conforme a
utilização do sistema e a necessidade, mais usuários poderão ser criados. Vejamos, a
seguir, como criar usuários por meio dos comandos useradd e adduser:
•• useradd
O comando useradd tem a função de criar usuários ou atualizar informações para os

novos usuários criados. Ele é utilizado principalmente pelo usuário root. Sua sintaxe
é a seguinte:
useradd [opcoes] <login>
Existem diversas opções para o comando useradd. As mais comuns são descritas
nesta tabela:
Opção Descrição
Comentário (normalmente utiliza-se o nome completo do
-c <comentario>
usuário).
-d <diretorio> Caminho do diretório pessoal do usuário.
-g <grupo> Grupo inicial (GID). É necessário que ele já exista no sistema.
-G <grupo1>,
Grupos adicionais (são separados por vírgula).
<grupo2>...
-u <uid> User ID (UID) do usuário.
-s <shell> Shell padrão para o usuário.
-p <senha> Senha (sempre entre aspas).
-e <data> Data de validade da conta.
-k /etc/skel Copia o diretório modelo /etc/skel.
-m Cria o diretório pessoal, caso não exista ainda.
O diretório /etc/skel aloca arquivos que são copiados para o diretório pessoal do
usuário, assim que uma conta é criada no sistema. Dessa maneira, não há necessidade
de configurar, individualmente, os arquivos para cada usuário.
471
O exemplo a seguir demonstra o uso do comando useradd para criar o usuário

alunovirtual:
•• adduser
O comando adduser também pode ser utilizado para criar usuários e grupos no
sistema. A primeira identificação disponível no sistema será aquela escolhida para ser
a identificação do usuário (UID). Essa identificação é estipulada de acordo com a faixa
de UID definida no arquivo /etc/adduser.conf.
A sintaxe do comando adduser é a seguinte:
adduser [opcoes] <login>
A tabela a seguir descreve opções do comando adduser:
Opção Descrição
Esta opção não executa o comando passwd para gerar a
--disabled-login senha, porém, enquanto o usuário não defini-la, não poderá
efetuar o login.
Com esta opção habilitada, o sistema ignora a verificação de
--force-badname
senhas ruins.
--gid Define o GID do grupo primário do usuário.
Esta opção realiza a criação de um novo grupo em vez de um
--group
novo usuário.
Permite definir o diretório de trabalho do usuário. Caso esta
--home opção não seja definida, o diretório do usuário será definido
pela configuração.
Permite definir a identificação (UID) que o usuário herdará no
--uid
sistema.
--ingroup Permite definir o grupo primário do usuário pelo nome.
--system Permite criar um usuário ou grupo no sistema.
Administradores que necessitam cadastrar usuários com nome, senha e grupo

definido, isto é, no formato tradicional, costumam utilizar o comando adduser. O
adduser é um script customizado que trabalha com o comando useradd.
472
Por meio de adduser <usuario>, o usuário especificado em <usuario> automaticamente
será adicionado já com o pedido de definição da senha e de outros dados adicionais, e
um grupo é criado com o nome igual ao do usuário, copiando para o diretório home do
usuário todos os arquivos que estão no diretório /etc/skel, como mostra o seguinte
exemplo:
O comando adduser segue algumas configurações que são definidas no arquivo /

etc/adduser.conf. A partir de agora, analisaremos o conteúdo desse arquivo:
473
474
Vejamos a descrição de alguns campos de configuração do /etc/adduser.conf:
•• DSHELL: Define o interpretador de comandos que o usuário herdará, caso

não seja utilizada a opção --home junto com o comando adduser;
•• DHOME: Define o local em que o usuário herdará o diretório de trabalho;
•• GROUPHOMES: Cria um diretório com o nome do grupo do usuário;
•• LETTERHOMES: Cria um subdiretório com a primeira letra do login do

usuário. Assim, o diretório ficará organizado em ordem alfabética;
•• SKEL: Define o local que armazena os arquivos que serão copiados para o
diretório de trabalho do usuário;
•• FIRST_SYSTEM_UID: Define o início da faixa de identificação reservada

para usuários administrativos e de sistema;
•• LAST_SYSTEM_UID: Define o final da faixa de identificação reservada para

usuários administrativos e do sistema;
•• FIRST_SYSTEM_GID: Define o início da faixa de identificação reservada

para grupos administrativos e do sistema;
•• LAST_SYSTEM_GID: Define o final da faixa de identificação reservada para

grupos administrativos e do sistema;
•• FIRST_UID: Define o início da faixa de identificação para usuários;
•• LAST_UID: Define o final da faixa de identificação para usuários;
•• FIRST_GID: Define o início da faixa de identificação para grupos;
•• LAST_GID: Define o final da faixa de identificação para grupos;
•• USERGROUPS: Se esta opção estiver habilitada, o GID do grupo do usuário

será igual ao número do UID. Porém, se esta opção estiver desabilitada, o
usuário herdará o GID 100, do grupo users;
•• USERS_GID: Define o identificador do grupo users;
•• DIR_MODE: Define a permissão do diretório que o usuário herdará;
•• SETGID_HOME: Define que os arquivos criados herdarão o mesmo grupo

de trabalho do diretório;
•• QUOTAUSER: Define a cota do usuário.
475
8.1.8.3. Alterando configurações de usuários

Vejamos, neste tópico, a utilização de dois comandos utilizados para alterar
configurações de usuários: usermod e chfn.
•• usermod
O comando usermod é utilizado para permitir que o administrador do sistema possa

realizar alterações na configuração das contas dos demais usuários do sistema.
Podemos visualizar as alterações no arquivo /etc/passwd no campo GID ou

diretamente no arquivo /etc/group.
usermod [opcao] <usuario>
A tabela adiante descreve as opções utilizadas com usermod:
Opção Descrição
Permite definir comentários adicionais para o usuário no arquivo /etc/
-c
passwd.
-d Permite definir ou alterar o diretório de trabalho do usuário.
-e Permite definir ou alterar a data de expiração de uma conta.
-f Permite definir ou alterar o período de inatividade da senha.
-g Altera o grupo primário do usuário.
-G Permite definir grupos complementares para o usuário.
-l Permite alterar o login do usuário.
Permite bloquear a senha do usuário (um caractere ! é acrescentado no
-L
início da linha do usuário no arquivo /etc/passwd).
-o Permite duplicar um UID que está sendo utilizado no sistema.
-s Define ou altera o interpretador de comandos do usuário.
-u Altera a identificação do usuário no sistema.
-U Opção utilizada para desbloquear a senha do usuário.
476
A seguir, o usermod é utilizado para alterar o grupo primário do usuário:
•• chfn
Utilizado para incluir ou alterar dados adicionais sobre os usuários criados. Caso chfn
seja utilizado sem opções, agirá de forma interativa.
Os dados que são incluídos ou alterados ficarão no campo gecos do arquivo /etc/
passwd. A sintaxe de chfn é a seguinte:
chfn [opcao] <usuario>
A tabela a seguir descreve opções utilizadas com o comando chfn:
Opção Descrição
-f Altera o nome completo.
-h Telefone doméstico.
-o Outras informações.
-r Número da sala.
-w Telefone comercial.
No exemplo a seguir, chfn é utilizado para cadastrar os dados adicionais do usuário

fabricio. Podemos perceber que nenhuma opção foi utilizada:
Já na imagem seguinte, o comando chfn é executado com a opção –f, a fim de alterar
as informações sobre o nome completo do usuário:
477
8.1.8.4. Criando e alterando senhas dos usuários

Neste tópico, trabalharemos com a definição e alteração de configuração de senhas,
para que os usuários possam utilizar o sistema. Abordaremos o gerenciamento de
valores de senhas.
•• passwd
Para que possamos definir senhas e valores de configuração para as contas, utilizamos
o comando passwd.
O root, como superusuário, pode alterar a senha de qualquer usuário no sistema,

porém, um usuário comum pode utilizar o comando passwd para alterar sua própria
senha.
A mudança da senha feita por um usuário normal vai solicitar sua senha atual para
que seja possível realizar sua troca. Já um usuário root pode definir uma nova senha
diretamente para ele próprio ou para diferentes usuários, sem a necessidade da
entrada da senha vigente.
passwd [opcoes] [login]
A tabela a seguir descreve opções que podemos utilizar com passwd:
Opção Descrição
-d Utilizada para remover a senha do usuário.
-e Executa a expiração da conta do usuário.
-h Exibe a ajuda do sistema.
-i Define o período de inatividade da senha.
-l Permite bloquear a conta do usuário.
Define o período mínimo de dias que o usuário deverá permanecer com
-n
a senha.
-S Exibe os valores da senha para a conta especificada.
-u Utilizada para desbloquear a conta do usuário.
Opção utilizada para definir o período em que o sistema notificará o
-w
usuário sobre a expiração da senha.
Define o período máximo de dias que o usuário poderá permanecer
-x
com a senha.
478
No exemplo a seguir, o comando passwd é executado de maneira que a senha do
usuário jose expire de forma imediata, forçando-o a gerar uma nova senha:
Já no exemplo a seguir, o passwd define que o usuário deverá permanecer com a

mesma senha pelo período mínimo de 10 dias:
Neste outro exemplo do uso de passwd, a opção –w 5 está determinando que o

sistema envie mensagens de aviso por um período de cinco dias, antes da expiração
da senha:
•• chage
O comando chage pode ser utilizado para configurar parâmetros referentes à senha
dos usuários. Além disso, várias configurações que foram realizadas recentemente
com o comando passwd podem ser efetuadas com o comando chage. A tabela a
seguir descreve opções desse comando:
Opção Descrição
-l (L Exibe as informações de configuração referentes à senha e conta
minúsculo) do usuário.
-I (i
Define o período de inatividade da senha.
maiúsculo)
-m Permite configurar a validade mínima da senha.
-M Permite configurar a validade máxima da senha.
-W Permite definir o tempo de aviso, antes que a senha expire.
479
Caso o comando chage seja executado sem opções, serão realizadas perguntas sobre
os valores de configuração da senha.
Na imagem anterior, executamos chage –l alunovirtual2 para verificar o status do

usuário alunovirtual2. Em seguida, executamos o comando chage com as opções –m
2, para obrigar o usuário a utilizar a senha por, no mínimo, dois dias, e –M 42, para
obrigar o usuário a trocar a senha a cada 42 dias. Por fim, digitamos novamente o
comando chage –l para ver o resultado da nova configuração.
•• pwconv
O comando pwconv habilita o suporte a senhas ocultas no sistema. Assim, as

informações de configuração de usuários e senhas ficam divididas entre os arquivos
/etc/passwd e /etc/shadow.
480
Vejamos a seguinte imagem:
No exemplo que acabamos de ver, executamos o cat no arquivo /etc/passwd.

Podemos notar que as senhas dos usuários são exibidas neste arquivo, de maneira
criptografada. Em seguida, executamos o cat no arquivo /etc/shadow, que não
existe. Digitamos, então, o comando pwconv e depois repetimos o teste inicial.
Pode-se perceber que as senhas sumiram e o arquivo /etc/shadow passou a existir,
contendo as senhas dos usuários.
•• pwunconv
O comando pwunconv desabilita o suporte a senhas ocultas no sistema. As

informações ficam centralizadas no arquivo /etc/passwd.
481
O teste a seguir é parecido com o teste feito por meio do pwconv, porém inversamente.
Agora, ao lermos o arquivo /etc/passwd, podemos notar que as senhas não estão
localizadas nele, mas sim no arquivo /etc/shadow. Então, ao executarmos o comando
pwunconv, as senhas voltaram a aparecer no arquivo /etc/passwd. O arquivo /etc/
shadow deixou de existir.
•• /etc/login.defs
Para que possamos definir o conjunto de senhas shadow, devemos alterar o arquivo
login.defs. Ele é constituído por variáveis e pode trabalhar com opções booleanas
(yes ou no).
A seguir, serão descritas algumas opções existentes dentro do arquivo login.defs e

que utilizam respostas no formato booleano:
Opção Descrição
Induz o sistema a solicitar autenticação, caso o comando chfn
CHFN_AUTH
ou chsh sejam executados.
Define se os diretórios home dos usuários serão criados pelo
CREATE_HOME
comando useradd.
482
Já as opções descritas na tabela a seguir, também presentes no login.defs, podem ser
configuradas com qualquer tipo de caractere:
Opção Descrição
Determina os campos relacionados ao gecos que os usuários
CHFN_RESTRICT
podem alterar.
MAIL_DIR Faz referência ao diretório de spool do correio.
Define o período padrão que será definido como prazo de
PASS_MAX_DAYS
validade máxima da senha.
Defino o período padrão de prazo de validade mínima da
PASS_MIN_DAYS
senha.
PASS_WARN_ Define o tempo padrão de envio de alerta de expiração de
AGE senha ao usuário.
A seguir, temos um exemplo do arquivo /etc/login.defs com algumas alterações

feitas (observemos as linhas PASS_MAX_DAYS 2 e PASS_MIN_DAYS 42):
483
8.1.8.5. Excluindo usuários
O comando userdel é utilizado para remover as contas e todas as informações dos
usuários do sistema. Temos duas opções ao realizarmos esse tipo de ação: excluir
somente as contas ou excluir as contas e outros dados referentes ao usuário, como
seus arquivos e o diretório home.
Para remover apenas a conta do usuário, utiliza-se a seguinte sintaxe:
userdel <usuario>
Para remover a conta, o diretório home e os arquivos do usuário, utiliza-se a opção –r:
userdel -r <usuario>
Como a delegação de UIDs é feita em sequência, existe o risco de um novo usuário

tomar conta do diretório de um usuário que acabou de ser removido. Portanto,
recomenda-se sempre a remoção do diretório do usuário, não sem antes realizarmos
um backup de seu conteúdo ou fazer sua transferência para o responsável.
No exemplo adiante, excluímos o usuário aluno3. Em seguida, ao fazermos a leitura

do arquivo /etc/passwd com o filtro aluno, podemos notar que aluno3 não existe
mais:
8.1.9. Administran do grupos
Grupos podem ser administrados por meio de diversos comandos, os quais permitem
exibir grupos de um usuário, alterar o dono e o grupo de arquivos e diretórios, criar,
alterar, definir senhas e excluir grupos, além de gerenciar seus membros. Podemos
também efetuar o login em um grupo diferente e converter senhas do /etc/group
para /etc/gshadow e vice-versa. Vejamos esses diversos comandos nos tópicos a
seguir.
484
8.1.9.1. Exibindo os grupos de um usuário
O comando groups exibe os grupos aos quais o usuário pertence. Sua sintaxe básica
é a seguinte:
groups <usuario>
No exemplo a seguir, groups é utilizado para exibir os grupos aos quais o usuário
fabricio pertence:
8.1.9.2. Alterando o dono e grupo de arquivos e diretórios

Dois comandos possibilitam, respectivamente, a alteração do dono e do grupo de
um arquivo, e a alteração do grupo de trabalho de um arquivo ou diretório. Esses
comandos, chown e chgrp, funcionam conforme veremos a seguir.
•• chown
O comando chown pode alterar o dono e o grupo de um arquivo. É importante ressaltar

que há necessidade de possuir permissões de gravação no diretório ou arquivo para
realizar essa alteração. Sua sintaxe é a seguinte:
chown [opcao] <dono[:[grupo]]> <arquivo>
A tabela a seguir descreve opções utilizadas com chown:
Opção Opção
Descrição
Unix GNU
Descreve detalhadamente a ação ocorrida para cada
-c --changes
arquivo cujas permissões estão sendo alteradas.
Não mostra mensagens de erro para o arquivo cuja
-f --silent
propriedade não pode ser alterada.
Descreve detalhadamente toda a ação ocorrida em cada
-v --verbose
arquivo.
Altera recursivamente a propriedade de diretórios e de
-R --recursive
seus conteúdos.
485
No exemplo adiante, o comando chown é executado para alterar o dono do arquivo:
Já no exemplo a seguir, alteramos o dono e o grupo do arquivo:
•• chgrp
O comando chgrp permite alterar o grupo de trabalho de um arquivo ou diretório. Sua

chgrp [opcoes] <arquivo>
Vejamos a tabela a seguir:
Opção Descrição
-c Descreve a ação detalhadamente sobre a alteração do grupo do arquivo.
Caso o grupo não possa ser alterado, a mensagem de erro não será
-f
exibida.
-v Descreve todas as ações de maneira detalhada.
-R Altera, de maneira recursiva, o grupo do diretório e seu conteúdo.
No exemplo a seguir, utilizamos chgrp para alterar a propriedade de grupo para o

arquivo:
486
8.1.9.3. Criando e alterando grupos
A criação e alteração de grupos são feitas por meio de comandos como groupadd,
addgroup e groupmod. Vejamos cada uma de suas funções a seguir.
•• groupadd
O comando groupadd realiza a criação de um novo grupo no sistema. Sua sintaxe é

a seguinte:
groupadd [opcoes] <grupo>
Vejamos algumas opções desse comando:
Opção Descrição
-g Permite definir o GID que o grupo herdará.
-o Permite definir um GID que já estava sendo utilizado por outro grupo.
No exemplo a seguir, utilizamos groupadd para criarmos o grupo debian:
No exemplo a seguir, criamos o grupo impacta e definimos que ele herdará o GID de
número 1098:
•• addgroup
O comando addgroup tem a finalidade de adicionar um novo grupo de usuários ao

sistema. As opções que podem ser utilizadas são as mesmas do comando adduser.
487
A sintaxe do comando addgroup é a seguinte:
addgroup [opcoes] <grupo>
A tabela a seguir descreve as principais opções desse comando:
Opção Descrição
Onde <gid> é o valor numérico do GID. Como padrão, o valor utilizado
é o menor valor de ID acima de 500 que seja maior que todos os
-g <gid>
outros grupos. Não é comum a utilização de valores entre 0 e 499,
pois estes são mais comumente utilizados por contas de sistema.
-r Instrui o comando groupadd a adicionar uma conta de sistema.
Encerra a atividade do comando groupadd com um erro caso o grupo
-f a ser adicionado já exista no sistema, fazendo com que o grupo não
seja adicionado novamente e nem alterado.
No exemplo a seguir, é feita uma busca pelo nome impacta no arquivo /etc/group,
mas nada é encontrado. Em seguida, é criado o grupo impacta e a busca passa a exibir
resultados. Depois, por meio de addgroup, é criado um grupo chamado impacta2.
Podemos perceber que o comando retorna o status da criação.
•• groupmod
O comando groupmod permite alterar a configuração de grupos já existentes. Sua

groupmod [opcoes] <grupo>
488
A tabela a seguir descreve as principais opções do comando groupmod:
Opção Descrição
-g Permite alterar o GID do grupo.
-n Permite alterar o nome do grupo.
-o Permite definir um GID que está sendo utilizado por outro grupo.
No exemplo a seguir, estamos alterando o nome do grupo debian para ubuntu:
8.1.9.4. Excluindo grupos
O comando groupdel é utilizado para remover um grupo do sistema. Sua sintaxe é a
seguinte:
groupdel <grupo>
No exemplo a seguir, estamos removendo o grupo ubuntu:
8.1.9.5. Definindo a senha de um grupo e adicionando/

excluindo seus membros
O comando gpasswd pode ser utilizado para várias funções, entre elas, definir uma
senha para o grupo e adicionar e remover membros do grupo. Sua sintaxe é a seguinte:
gpasswd [opcao] <grupo>
489
Vejamos a tabela a seguir:
Opção Descrição
-a Adiciona um membro ao grupo.
-A Define um administrador para o grupo.
-d Remove um membro do grupo.
-M Permite adicionar vários membros ao grupo.
-r Esta opção é utilizada para remover a senha do grupo.
-R Desabilita o acesso ao grupo pelo comando newgrp.
No exemplo a seguir, gpasswd é utilizado para adicionar o usuário fabricio ao grupo

root:
Já no exemplo a seguir, estamos removendo o usuário fabricio do grupo root:
No comando a seguir, estamos criando uma senha para o grupo:
8.1.9.6. Efetuando o login em um grupo diferente

O comando newgrp permite que o usuário altere a identificação do seu grupo,
permitindo que ele efetue um login em um grupo ao qual ele não pertence. Para isso,
o usuário deverá ter o conhecimento da senha do grupo em que deseja entrar. Sua
newgrp <grupo>
490
No exemplo a seguir, o usuário efetua o login no grupo impacta:
8.1.9.7. Convertendo senhas do /etc/group para /etc/

gshadow e vice-versa
O comando grpconv habilita o suporte a senhas shadow, dividindo a configuração
de grupo em dois arquivos: /etc/group e /etc/gshadow. Além disso, esse comando
permite que as senhas do formato antigo /etc/group sejam convertidas para /etc/
gshadow.
O comando grpunconv desabilita o suporte a senhas shadow. Sendo assim, as

informações ficam centralizadas no arquivo /etc/group.
491
No exemplo que acabamos de ver, primeiramente o grupo impacta é localizado dentro

do arquivo /etc/group. Podemos notar que o arquivo /etc/gshadow não existe.
Depois, com a execução do comando grpconv, a senha deixa de existir no arquivo
/etc/group e é criado o arquivo /etc/gshadow com as senhas criptografadas dos
grupos. Por fim, com a execução do comando grpunconv, a senha volta a fazer parte
do arquivo /etc/group e o arquivo /etc/gpasswd deixa de existir.
Dicas LPI
•• Há quatro arquivos básicos que dizem respeito à administração de usuários:
•• passwd: Contém as informações dos usuários;

•• shadow: Contém as informações das senhas dos usuários;
•• group: Contém as informações dos grupos e usuários que fazem
parte deles;
•• gshadow: Contém informações a respeito das senhas de grupo.
•• Usar o comando getent é a maneira certa de acessar arquivos de controle

no GNU/Linux;
•• Muitas perguntas podem ser feitas sobre as senhas shadow e os comandos

pwconv e pwunconv. Fique atento!
•• Para modificar grupos do sistema, utilizamos o comando: # groupmod

-n [novo-nome] [nome-grupo]. Cuidado para não executar utilizando o
grupo do usuário root;
•• Saber as diferenças entre as opções l e L do usermod pode ser relevante

na prova: a fag l modifica o login de um determinado usuário, enquanto a
fag L bloqueia a conta, acrescentando um ! no início da linha do usuário
no arquivo /etc/passwd;
•• Lembre-se da regra de cálculo de umask. Pensar da forma que o sistema

funciona pode gerar confusão:
•• Para diretórios: Sempre substituir de 777;

•• Para arquivos: Verificar o umask. Se o número for ímpar, subtrair
de 7, se for par, subtrair de 6.
•• Todas as permissões especiais que não contiverem execução são

maiúsculas: S e T.
492
8.2. Agendamento de tarefas
Agendar tarefas é bastante útil para automatizar a execução de certos processos
no sistema. Em plataformas GNU/Linux, os dois métodos mais importantes para a
realização desses agendamentos em servidores são o cron e o at. O agendamento cron
permite a execução periódica de tarefas, enquanto o agendamento at é normalmente
usado para agendar uma única execução de um procedimento em uma hora exata.
Para o agendamento em desktops, podemos utilizar o anacron.
8.2.1. Agendamento cron
Muito utilizado em tarefas que envolvem a checagem de integridade do sistema,
execução de programas ou comandos e arquivamento de logs, o crond é um daemon
que permite o agendamento de uma execução de um comando ou programa para
um dia, mês, ano ou horário específico. O agendamento de tarefas que envolve esse
daemon é conhecido como agendamento cron, o qual é indicado para tarefas que
precisam ser executadas regularmente.
As tarefas que o usuário pretende agendar devem ser documentadas nas crontabs,
que são tabelas verificadas a cada minuto pelo crond, com data e hora de execução
indicadas para cada tarefa. As crontabs podem ser de usuário ou do sistema. O primeiro
tipo fica armazenado no diretório /var/spool/cron/crontabs/<nomedousuario> e
a crontab do sistema fica no /etc/crontab. Além disso, elas se diferem pelo fato de
as crontabs de usuário trazerem a especificação de qual usuário irá executar a tarefa
agendada.
Para tarefas cuja hora exata não precise ser especificada, elas podem ser colocadas
nos diretórios /etc/cron.hourly/, para execução de hora em hora, /etc/cron.daily/,
para execução diária, /etc/cron.weekly/, para execução semanal, ou /etc/cron.
monthly/, para execução mensal.
Para especificar o agendamento de uma tarefa que será iniciada pelo daemon crond,
é necessário configurar o arquivo /etc/crontab, inserindo nele uma linha que deve
possuir o seguinte formato:
# minuto hora dia mes dia_da_semana usuario comando
493
Cada um desses campos pode assumir valores de acordo com a tabela seguinte:
Campo Valor
minuto 00 a 59
hora 00 a 23
dia 0 a 31
mes 1 a 12
dia_da_semana 0a7
É o usuário que irá executar o comando, no
usuario
caso de crontabs de usuário.
comando É o comando que deve ser executado.
A seguir, vejamos um exemplo de tarefa inserida no arquivo /etc/crontab:
No exemplo anterior, foi definido que às 23h30, de segunda até sexta, será efetuado
um empacotamento pelo comando tar.
Quanto à edição do arquivo /etc/crontab, é importante considerar a utilização de

alguns caracteres, os quais facilitarão o trabalho de agendamento:
•• É necessário incluir uma linha em branco no final do arquivo para que o último
comando seja executado;
•• No campo que se refere aos dias da semana, o domingo pode ser representado
pelo número 0 ou 7;
•• Os campos devem ser separados por um ou mais espaços ou tabulações;
494
•• O asterisco (*) serve para especificar todo o intervalo disponível nos campos de
data e hora;
•• O hífen (-) é utilizado para especificar períodos de execução, incluindo o valor

inicial e final;
•• A vírgula (,) pode ser usada para especificar uma lista de valores;
•• A barra (/) serve para especificar passos, ou seja, para inserir mais serviços que
serão executados de acordo com o agendamento.
Para editar um arquivo de usuário em /var/spool/cron/crontabs, podemos utilizar

o comando crontab, em vez de editar o arquivo /etc/crontab.
8.2.2. Utilizando o comando crontab

Cada usuário pode possuir um arquivo crontab próprio. Os arquivos crontab não
foram projetados para serem editados diretamente, apesar de estarem localizados no
diretório /var/spool/cron/crontabs. Para editá-los, dispomos do comando crontab,
cuja sintaxe é a seguinte:
crontab [opcoes] <usuario>
Se, na sintaxe, não aparecer um nome de usuário, o usuário atual será considerado.
A tabela a seguir descreve as opções que podemos utilizar com o comando crontab:
Opção Descrição
-l São exibidas as tarefas agendadas pelo usuário.
-e Utilizado para editar a crontab do usuário.
-r Remove a crontab do usuário.
Para usar esse comando, um usuário comum precisa estar listado no arquivo /etc/
cron.allow, caso ele exista, ou não estar listado no arquivo /etc/cron.deny. Se
nenhum desses dois arquivos existir, todos os usuários poderão agendar tarefas.
Vamos supor que utilizamos o comando crontab –e para adicionar o seguinte

agendamento:
495
Em seguida, com crontab –l, verificamos a lista de agendamentos realizados:
Por fim, com o uso de crontab –r, removemos todos os agendamentos:
8.2.3. Agendamento at
Recomendado para a execução única de uma tarefa em um instante futuro, o
agendamento at se dá por meio do comando at.
Analogamente ao comando crontab, para utilizar o comando at, um usuário comum

deve estar listado no arquivo /etc/at.allow. Caso o arquivo não exista, o usuário não
pode constar no arquivo /etc/at.deny, que é consultado em seguida pelo sistema.
Diferente do comando crontab, porém, caso nenhum dos dois arquivos existam,
nenhum usuário comum poderá usar o at, ficando então restrito ao superusuário.
A sintaxe do comando at é a seguinte:
at <quando> <comando>
As expressões que podem substituir o campo <quando> podem ser encontradas no

arquivo /usr/share/doc/at/timespec.
496
Como com o crontab, o parâmetro -l pode ser usado com o at para listar as tarefas
agendadas, e um alias para esse comando é o atq. Nessa listagem, é informado
também o número atribuído para cada trabalho, que pode ser usado com o comando
atrm para excluir o agendamento.
No exemplo a seguir, criamos um agendamento para que o script backup_especial

fosse executado às 22h00 do dia 17/11/2010. Em seguida, com o comando atq,
listamos os agendamentos.
Dicas LPI
•• A única diferença entre as duas crontabs é que na do sistema há um campo

para especificar qual é o usuário que irá executar o comando agendado;
•• Podemos controlar quais usuários podem acessar ou não o cron. Para

isso, basta criar um dos arquivos: /etc/cron.allow ou /etc/cron.deny. A
mesma dica é válida para o comando at e os arquivos serão: /etc/at.allow
ou at.deny.
8.2.4. Agendamento anacron
Em caso de agendamento de tarefa, onde não é necessária a sua execução em um
determinado horário, o anacron deverá ser utilizado. Esse tipo de agendamento é
muito comum para desktops ou laptops. Com isso, caso você agende uma determinada
tarefa em um horário em que o desktop estiver desligado, essa mesma tarefa será
executada assim que o desktop estiver ligado, o que no caso do cron não ocorre.
497
O agendamento pelo anacron poderá ser realizado editando o arquivo /etc/

anacrontab, que possui o seguinte formato:
Em que:
•• SHELL: Define o interpretador de comando onde a tarefa será executada;
•• PATH: Define o local onde os comandos poderão ser executados;
•• MAILTO: Mensagens serão enviadas para o usuário root;
•• RANDOM_DELAY: Número máximo de tempo aleatório, em minutos, que o

anacron adiciona ao parâmetro delay para um job. O atraso mínimo padrão é de
seis minutos. O offset aleatório destina-se a evitar que o anacron sobrecarregue
o sistema com muitos trabalhos ao mesmo tempo;
•• START_HOURS_RANGE: Intervalo de horas durante o dia em que o anacron

pode executar tarefas programadas.
Quanto aos campos de agendamento, temos:
•• period: Frequência da execução do trabalho especificada em dias ou como @

daily, @weekly ou @monthly para uma vez por dia, semana ou mês. Exemplo: 1
para diário, 7 para semanal, 30 para mensal ou <n> para definir um determinado
número de dias;
•• delay: Número de minutos a aguardar antes de executar um trabalho, após o

ligamento da máquina desktop;
•• job-identifier: É o nome do job referente à atividade. Estará disponível como um

arquivo no diretório /var/spool /anacron. Este arquivo conterá uma única linha
que indica a última vez em que este trabalho foi executado;
498
•• command: Comando ou script a ser executado.
No exemplo adiante, foi agendada a execução do backup uma vez a cada sete dias e
que aguardará 15 minutos para executá-lo, após o desktop ser iniciado:
8.3. Localização e internacionalização

Durante a instalação do GNU/Linux, é definido o fuso horário e se o relógio de seu
hardware está definido como local ou UTC.
Essas informações são armazenadas no diretório /usr/share/timezone, onde são

encontrados vários arquivos contendo informações referentes ao fuso horário de
cada país.
Para podermos alterar essas configurações, temos os comandos locale, tzselect,

timedatectl e date.
8.3.1. Comando locale
O comando locale tem a função de alterar algumas configurações, como: renderizar
texto, exibir corretamente valores monetários regionais, exibir corretamente o
formato de data/hora, entre outros.
499
Para verificar as configurações atuais, execute apenas o comando locale:
Repare que uma série de variáveis são informadas, com seus respectivos valores,
sendo eles:
•• LANG
O valor definido para essa variável será utilizado para as demais (LC_*), as quais
não foram apresentadas na saída do comando. Essa definição poderá ser alterada no
arquivo /etc/locale.conf.
•• LC_TIME
Se estiver definida como UTF-8, o formato de data/hora será exibido como MM/DD/
YYYY.
•• LC_ALL
Utilizada apenas para testes ou solução de problemas. A localidade definida para esta
variável sempre substituirá LANG e todas as outras variáveis LC_ *, independentemente
de estarem ou não definidas. Essa variável é a única variável LC_ * que não pode ser
definida no arquivo locale.conf.
Essas variáveis poderão ser alteradas editando o arquivo /etc/locale.conf, ou via

linha de comando, utilizando o comando localectl, conforme o exemplo a seguir:
500
8.3.2. Comando tzselect
A alteração do timezone ocorre através do comando tzselect, o qual, ao ser executado,
apresenta um menu. Entre as suas opções, temos: continente ou oceano, país e região.
Após a resposta de todas as perguntas, o timezone estará configurado.
8.3.3. Comando timedatectl
O comando timedatectl possui diversas funcionalidades, como: verificar as definições
de data e hora do sistema e do hardware, informar se o servidor possui alguma
configuração de NTP etc.
Para alteração da data e hora local, é necessário alterar o valor set-local-rtc para o
valor yes. Caso contrário, as alterações também ocorrerão para o horário UTC.
501
A alteração da data e hora poderá ser realizada conforme o exemplo adiante:
O timezone também poderá ser alterado por esse comando.
Ao selecionar uma localidade com um destes comandos, é criado um link simbólico

chamado /etc/localtime, que aponta para as definições do fuso horário armazenadas
no diretório /usr/share/zoneinfo/.
Além desta indicação, o timezone também é identificado no arquivo /etc/timezone.
8.3.4. Comando date
O comando date é o comando utilizado para visualizar e alterar a data e hora do
sistema. Sua sintaxe é a seguinte:
date [opcoes] [ANO:MÊS:DIA HORA]
502
Na tabela a seguir, estão descritas algumas opções do comando date:
Opção Descrição
%d Dia do mês.
%H Hora (pode variar entre 00 e 23).
%l Hora (pode variar entre 00 e 12).
%j Dia do ano (pode variar entre 1 e 366).
%m Mês do ano (pode variar entre 00 e 12).
%M Minuto (pode variar entre 00 e 59).
Exibe a hora completa, utilizando o formato de 12 horas (HH:MM:SS,
%r
AM ou PM).
%T Exibe a hora completa, utilizando o formato de 24 horas (HH:MM:SS).
%y Formato do ano com dois dígitos.
%Y Formato do ano com quatro dígitos.
%w Dia da semana (pode variar entre 0 e 6).
No exemplo a seguir, a data e hora do sistema são alteradas:
8.3.5. Comando iconv
Arquivos de texto criados no GNU/Linux recebem a codificação UTF-8, diferentemente
do padrão utilizado em sistemas Microsoft Windows, que utilizam a codificação ISO-
8859-1.
Para arquivos que não contenham qualquer caractere especial, como uma cedilha (ç),
por exemplo, o arquivo será criado com a codificação ASCII em ambas as plataformas.
Entre as codificações, temos:
•• UTF-8: Padrão Linux;
•• ISSO-8859: Padrão Microsoft;
•• ASCII: Não contém caracteres especiais;
•• Unicode: Representa todos os caracteres específicos de diversos idiomas.
503
Utilizamos o comando iconv para realizar a conversão dessas codificações. Sua

iconv <opcao>
A seguir, vejamos alguns exemplos de uso:
504
Pontos principais
•• É possível considerarmos três tipos distintos de usuários em um sistema GNU/

Linux: usuário administrador (superusuário), usuários de sistema e usuários
comuns;
•• Em plataformas GNU/Linux, os dois métodos mais importantes para a realização

de agendamentos em servidores são o cron e o at. Para o agendamento em
desktops, podemos utilizar o anacron;
•• Para podermos alterar as configurações de localização e internacionalização,

temos os comandos locale, tzselect, timedatectl, date e iconv.
Sites Endereços
Administração de https://www.centos.org/docs/5/html/Deployment_
usuários Guide-en-US/s1-users-tools.html
https://www.centos.org/docs/5/html/Deployment_
Cron CentOS
Guide-en-US/ch-autotasks.html
Localização e ftp://ftp.lyx.org/pub/sgml-tools/website/HOWTO/
Internacionalização Cyrillic-HOWTO/t1842.html
505
506
8 Tarefas
administrativas
1. Com o umask 027, qual permissão de arquivo é criada?
☐☐ a) 0750
☐☐ b) 0640
☐☐ c) 0760
☐☐ d) 0660
☐☐ e) 0700
2. Qual opção do comando useradd é utilizada para especificar o diretório

pessoal dos usuários?
☐☐ a) -a
☐☐ b) -m
☐☐ c) -f
☐☐ d) -d
☐☐ e) -h
3. Ao criar um arquivo, ele automaticamente adota a permissão 0642. Qual

a umask desse arquivo?
☐☐ a) 0642
☐☐ b) 0724
☐☐ c) 0027
☐☐ d) 0024
☐☐ e) 0012
4. Com qual arquivo é possível definir as configurações padrão para os

usuários que serão cadastrados?
☐☐ a) /etc/user.conf
☐☐ b) /etc/confusers
☐☐ c) /etc/login.defs
☐☐ d) /etc/login.conf
☐☐ e) /etc/login.def
5. Qual comando pode ser utilizado para desabilitar a conta do usuário?
☐☐ a) userblock
☐☐ b) passwd
☐☐ c) userdel
☐☐ d) groupdel
☐☐ e) userremove
508
6. Qual comando é utilizado para criar ou editar um agendamento no cron?
☐☐ a) crontab -l
☐☐ b) crontab -e
☐☐ c) crontab -x
☐☐ d) crontab -d
☐☐ e) crontab -c
7. O agendamento 00 10 * * 5 /bin/ls ocorrerá em quais períodos?
☐☐ a) Todo dia 5 às 00h10.

☐☐ b) Todo dia 5 às 10h.
☐☐ c) Toda sexta-feira às 10h.
☐☐ d) Toda quinta-feira às 10h.
☐☐ e) Toda quinta-feira às 00h10.
8. O agendamento 00-59/5 10 30 * * /bin/ls ocorrerá em quais períodos?
☐☐ a) Todo dia 30, às 10h, às 10h59 e às 5h.

☐☐ b) De 5 em 5 minutos, no dia 30/10.
☐☐ c) De 5 em 5 minutos, entre 10h e 10h59, todo dia 30.
☐☐ d) A cada 5 horas do dia 30/10.
☐☐ e) Nunca, pois o agendamento apresenta erro.
9. Qual comando é utilizado para visualizar a lista de agendamentos do at?
☐☐ a) atq
☐☐ b) at-list
☐☐ c) list-at
☐☐ d) at
☐☐ e) atrm
10. Qual comando é utilizado para remover um agendamento do comando at?
☐☐ a) atq
☐☐ b) at-remove
☐☐ c) remove-at
☐☐ d) atrm
☐☐ e) at
509
11. Qual o nome do arquivo de configuração do anacron?
☐☐ a) crontab
☐☐ b) anacron
☐☐ c) tabanacron
☐☐ d) anacrontab
☐☐ e) anacront
12. Qual comando é responsável por alterar o timezone do servidor?
☐☐ a) alttimezone
☐☐ b) tzselect
☐☐ c) selecttz
☐☐ d) timezoneselect
☐☐ e) alttz
13. Qual a opção correta para alterar a data/hora usando o comando

timedatectl?
☐☐ a) timedatectl –set-time ‘2017-01-30 18:00’

☐☐ b) timedatectl –set-time ‘2017.01.30 18:00’
☐☐ c) timedatectl –set-time ‘2017-01-30/18:00’
☐☐ d) timedatectl –set-time ‘2017-01-30-18:00’
☐☐ e) timedatectl –set-time “”2017-01-30 18:00””
14. Qual o comando responsável pela conversão de codificações de

arquivos?
☐☐ a) inconv
☐☐ b) icov
☐☐ c) imcov
☐☐ d) icomv
☐☐ e) iconv
510
8 Tarefas
administrativas
Mãos à obra!
Laboratório 1 - Gerenciando permissões

1. Crie um arquivo na pasta /tmp:
# touch /tmp/arquivo.txt
2. Liste detalhadamente o arquivo:
# ls -l /tmp/arquivo.txt
3. Altere a permissão do arquivo para que o proprietário tenha controle total do

arquivo:
# chmod u+rwx /tmp/arquivo.txt
4. Confira a alteração:
5. Permita que o grupo altere o arquivo:
# chmod g+rw /tmp/arquivo.txt
6. Confira a alteração:
7. Altere a permissão do arquivo para -rwxrw----:
# chmod 760 /tmp/arquivo.txt
8. Conceda permissão de controle total a todos os usuários:
# chmod 777 /tmp/arquivo.txt
9. Crie um arquivo com umask 017 em /tmp e confira se ele apresenta a permissão
-rw-rw----:
# umask 017;touch /tmp/arquivo2.txt

# ls -l /tmp/arquivo2.txt
10. Crie um diretório com umask 017 em /tmp e confira se ele apresenta a permissão
drwxrw----:
# umask 017;mkdir /tmp/diretorio

# ls -ld /tmp/diretorio
512
11. Copie o executável binário cp para a pasta /tmp utilizando o umask 017 e verifique
se ele ficou com a permissão -rwxr-----:
# umask 017;cp /bin/cp /tmp/.

# ls -l /tmp/cp
12. Aplique a permissão SUID no arquivo /tmp/arquivo.txt e verifique se a aplicação

foi bem sucedida:
# chmod u+s /tmp/arquivo.txt

13. Aplique a permissão SGID no diretório /tmp/diretorio e verifique se a aplicação

foi bem sucedida:
# chmod g+s /tmp/diretorio

# ls -ld /tmp/diretorio
Laboratório 2 - Gerenciando usuários e grupos

14. Crie um usuário chamado teste1:
# useradd teste1
# cat /etc/passwd |grep teste1
15. Defina a senha 123 para o usuário teste1:
# passwd teste1
16. Crie uma pasta para o usuário teste1:
# mkdir /home/teste1
17. Conceda propriedade de acesso desta pasta para o usuário teste1 e para o grupo
users:
# chown -R teste1:users /home/teste1
18. Confira as propriedades da pasta:
# ls -ld /home/teste1
513
19. Altere o shell do usuário teste1 para o bash e confira se a alteração foi bem
sucedida:
# usermod -s /bin/bash teste1

# finger teste1
20. Logue como usuário teste1:
# su teste1
21. Vá para a pasta home para testar se ela foi associada:
# cd ~
# pwd
22. Efetue o logout:
# exit
23. Bloqueie a conta do usuário teste1:
# passwd -l teste1
24. Verifique se a conta foi bloqueada (o caractere ! deve aparecer no início da senha
do usuário):
# cat /etc/shadow | grep teste1
25. Desbloqueie o usuário teste1 e confira o resultado:
# passwd -u teste1
# cat /etc/shadow | grep teste1
26. Defina a senha do usuário teste1 para a validade máxima de dois meses:
# chage -M 60 teste1
27. Confira se o ajuste de validade da senha foi realizado:
# chage -l teste1
28. Crie o grupo Impacta:
# addgroup Impacta
# cat /etc/grops |grep Impacta
514
29. Crie o usuário teste2 com o comando adduser:
# adduser teste2
30. Exclua os usuários teste1 e teste2:
# userdel teste1
# userdel teste2
# cat /etc/passwd |grep teste
31. Exclua o grupo Impacta:
# groupdel Impacta
# cat /etc/group |grep Impacta
Laboratório 3 - Agendando tarefas com o

crontab
32. Abra o editor do crontab:
# crontab -e
33. Adicione a tarefa para que seja executada hoje, daqui a 10 minutos:
# 15 11 16 11 * touch /tmp/testecron.txt && echo “Inicio do Teste do

Cron” >> /tmp/testecron.txt && DATA=`date +%d-%B-%Y_%H-%M` && echo
$DATA >> /tmp/testecron.txt && echo “Fim do Teste do Cron” >> /tmp/
testecron.txt
34. Salve e saia:
:wq
35. Aguarde o horário programado;
36. Verifique se o arquivo foi criado e o teste concluído:
# cat /tmp/testecron.txt
515
37. Altere a crontab para que seja executada todos os dias no horário atual. Para isso,
apenas modifique a linha inserida no passo 34:
# 15 11 * * * touch /tmp/testecron.txt && echo “Inicio do Teste do

Cron” >> /tmp/testecron.txt && DATA=`date +%d-%B-%Y_%H-%M` && echo
$DATA >> /tmp/testecron.txt && echo “Fim do Teste do Cron” >> /tmp/
testecron.txt
38. Verifique se o agendamento foi criado:
# crontab -l
Laboratório 4 - Agendando tarefas com o

comando at
39. Verifique se há tarefas agendadas:
# atq
40. Agende uma tarefa para ser executada 10 minutos depois do horário atual:
# at 11:30
41. Agende a criação de um arquivo na pasta /tmp:
at > touch /tmp/teste_at
42. Salve o agendamento:
CTRL + D
43. Verifique se o agendamento foi criado:
# atq
44. Aguarde o horário agendado e, depois, teste se o arquivo foi criado:
# ls -l /tmp/teste_at
45. Crie um agendamento para a próxima meia-noite:
# at midnight
516
46. Peça a criação de um novo arquivo na pasta /tmp:
at > touch /tmp/teste_at_meia-noite
47. Salve o agendamento:
CTRL + D
48. Verifique se a tarefa está agendada e observe seu número:
# atq
49. Remova o agendamento:
# atrm <numero do agendamento>
50. Verifique se o agendamento foi removido:
# atq
Laboratório 5 - Localização e internacionalização

51. Verifique as configurações de data e hora:
# timedatectl
52. Altere o timezone:
# timedatectl set-timezone America/Sao_Paulo
53. Realize a conversão de codificação:
# iconv arquivo.txt –-to-code ISO-8859-1 > convertido.txt
54. Observe que o arquivo /etc/localtime é um arquivo binário;
# cat /etc/localtime
55. Copie o timezone para o sistema;
# cp /usr/share/zoneinfo/America/Sao_Paulo /etc/timezone
517
56. Verifique se o timezone está correto usando o comando date. O resultado deve
ser parecido com este: Sex Nov 26 23:26:45 BRST 2010;
# date
57. Verifique o timezone;
# cat /etc/timezone
58. Modifique o timezone com tzdata;
# dpkg-reconfigure tzdata
59. Verifique novamente o timezone.
# cat /etc/timezone
518
9 Serviços essenciais
do sistema
ÃÃ Servidor NTP;
ÃÃ Configuração do serviço de log;
ÃÃ Agente MTA;
ÃÃ Serviço de impressão CUPS.
Este capítulo faz parte do tópico 108 – Essencial System services da segunda
Você precisará estar apto a configurar a data/hora do sistema, gerenciar os logs,

realizar uma configuração básica do agente de transferência de e-mail, gerenciar
filas de impressão, além de também estar apto a configurar um servidor de NTP,
LOG e impressão.

Para o mercado de trabalho, a administração de logs do sistema e das respectivas

aplicações é essencial para mantê-los em pleno funcionamento. Não se esqueça de
realizar a configuração da rotação dos logs.
9.1. Servidor NTP
Sabemos da importância e conveniência do agendamento de tarefas no sistema.
No entanto, a programação de processos a serem executados depende de uma
configuração adequada da hora e da data do sistema. Sem seu ajuste correto, existem
chances de que as tarefas sejam executadas fora dos horários desejados.
Não só isso, como manter a hora e a data do sistema corretamente ajustadas também
facilita a definição do horário de ocorrência de eventos no sistema, a leitura de logs e
a manutenção de um servidor de e-mails, por exemplo.
Neste tópico, veremos como ajustar o horário do sistema e da BIOS e como configurar
o horário de computadores em rede, por meio do protocolo NTP.
9.1.1. Configuração de data e hora do sistema e

da BIOS
Antes de se realizar qualquer procedimento referente à configuração do relógio do
sistema, é importante ter em mente que o computador precisa estar com a hora
adequada, principalmente quando estiver em uma rede.
O relógio definido para o hardware (BIOS, CMOS) é carregado de modo independente

do sistema. No mais, é adequado definir a hora mundial para o CMOS e empregar
ferramentas do sistema no intuito de configurar adequadamente o fuso horário para
a localidade física do computador.
520
Serviços essenciais do sistema 9
No caso da configuração do relógio do CMOS, vale considerar a funcionalidade de um
programa chamado hwclock. Por meio dele, é possível exibir a data atual, alterá-la
para uma determinada hora e configurar o relógio de hardware com base na hora do
sistema.
9.1.2. Comando hwclock
O comando hwclock é utilizado para visualizar e alterar o RTC (Real Time Clock), ou
seja, o relógio de hardware da máquina que continua funcionando mesmo quando o
computador está desligado, possibilitando que a hora permaneça ajustada quando a
máquina for utilizada novamente.
Podemos utilizar o comando hwclock para sincronizar a hora do sistema com o

relógio de hardware. Sua sintaxe é a seguinte:
hwclock <opcao>
Na tabela a seguir, são apresentadas algumas opções do comando hwclock:
Opção Descrição
Reajusta o relógio de hardware. Esta opção atualiza o arquivo /
-a ou -adjust
etc/adjtime de acordo com a variação sistemática do relógio.
-r ou -show Exibe, na saída padrão, as informações do relógio de hardware.
Configura a hora do sistema tendo como base o relógio do
-s ou -hctosys
hardware.
Ajusta o relógio de hardware. Podemos também utilizar a opção
-set ou -date
-set quando não possuímos o arquivo /etc/adjtime.
-v ou -version Exibe a versão do comando hwclock.
Configura o relógio de hardware, tendo como base a hora do
-w ou -systohc
sistema.
9.1.3. Configuração de data e hora com NTP

Com a utilização do protocolo NTP (Network Time Protocol), também chamado de
protocolo de data de rede, é possível sincronizar o relógio de um computador com a
hora e a data de outra máquina. Nesse caso, a configuração da hora de um computador
a partir de outras máquinas é realizada por meio do comando ntpdate, que emprega
o protocolo em questão.
521
9.1.4. ntpdate
Este comando é utilizado para configurar a data e a hora do sistema via protocolo
NTP. Para instalar o ntpdate, utilizamos o comando a seguir:
# yum install ntpdate
Após instalar o pacote ntpdate, devemos informar quem será o servidor NTP. Podemos
realizar essa tarefa digitando no shell o seguinte comando:
# ntpdate <servidor_NTP>
Vejamos o exemplo seguinte:
# ntpdate ntp.usp.br
No Debian, existe o comando ntpdate-debian, que busca por padrão os servidores

que estão em /etc/default/ntpdate.
# ntpdate-debian
Os arquivos gerados após a instalação do pacote ntpdate são os seguintes:
•• /etc/default/ntpdate
É um arquivo utilizado para configurar manualmente o endereço do servidor NTP.
Caso o servidor ntpd não esteja rodando, as duas linhas seguintes devem ser
configuradas no arquivo em questão:
NTPDATE_USE_NTP_CONF=no
NTPSERVER=”a.ntp.br 192.168.0.100”
A primeira linha diz que o arquivo /etc/ntp.conf não será procurado pelo servidor
ntpd. Caso instalemos o servidor NTP, essa linha deve ser reconfigurada para yes.
A segunda linha só é lida caso a primeira linha esteja configurada como no. Ela indica
qual é o servidor que fornecerá as informações de hora. No nosso caso, podemos
notar que o servidor especificado é a.ntp.br. No entanto, poderíamos especificar um
IP de um servidor ou computador da rede. Também, é possível especificar mais de um
servidor, desde que separados por espaço dentro das aspas.
522
9.1.5. ntpd
O ntpd (Network Time Protocol Daemon) é responsável por controlar o sincronismo
do relógio de sistema via protocolo NTP e deve ser instalado em máquinas que
funcionarão como servidores NTP. Para utilizar esse serviço, é necessário instalá-lo
por meio do comando seguinte:
# yum install ntp
A sintaxe de ntpd é a seguinte:
ntpd [opcoes] <-f arquivo>
Na tabela a seguir, são apresentadas algumas opções de ntpd:
Opção Descrição
-a Habilita o modo de autenticação.
-A Desabilita o modo de autenticação.
-c<arquivo> Determina o caminho e o nome do arquivo de configuração.
-d Determina o depurador.
-D<nivel> Determina o nível de depuração a ser realizado.
Determina o caminho e o nome do arquivo que contém as chaves
-k<arquivo>
para autenticação.
-l<arquivo> Determina o caminho e o nome do arquivo de log.
Os arquivos de configuração do ntpd são os seguintes:
•• /etc/ntp.conf: Arquivo padrão de configuração de nomes;
•• /etc/ntp.key: Arquivo padrão das chaves (precisa ser criado);
•• /etc/ntp.drift: Importante para guardar a precisão do relógio. Também pode

ser encontrado como /etc/ntp/drift (precisa ser criado).
523
9.1.6. Configuração do servidor NTP

Na página do projeto NTP (www.ntp.org), podemos obter endereços de servidores
NTP oficiais. É importante conhecer o site do NTP.br, um projeto do NIC.br (Comitê
Gestor da Internet no Brasil) que possui servidores públicos para sincronização com a
Hora Legal Brasileira e com o Tempo Universal Coordenado (UTC).
É sempre bom usar mais de um servidor, de forma a conservar a configuração do

sistema, no caso de falha de um servidor.
Acessando o link Public Time Server Lists, na página inicial do site do projeto NTP,
é apresentada a lista de servidores públicos disponíveis, cabendo ao usuário escolher
um pool próximo de sua localidade. Para o Brasil, eles são <numero>.south-america.
pool.ntp.org, onde <numero> pode ser 1, 2 ou 3, sendo cada um deles um servidor
diferente. É bom evitar o uso de stratum inferior a 3, exceto se formos criar um
servidor para integrar a lista dos servidores públicos.
O /etc/ntp.conf é o arquivo de configuração do NTP. Nele podemos definir a forma de

funcionamento dos logs, a lista de servidores a serem utilizados para sincronização e
as pessoas que podem acessar a configuração de hora (sincronizar a partir do nosso
servidor). Também, podemos restringir o acesso a essa configuração a uma única
rede ou host.
Podemos usar o ntpd em todas as máquinas para sincronizar a hora, mesmo que
utilizemos como fonte um servidor local. Porém, é desnecessário grande quantidade
de tráfego para as estações de trabalho, já que estas podem se sincronizar em um
período mais esparso (no momento em que são ligadas, por exemplo). Sendo assim,
nesses computadores podemos trabalhar apenas com o ntpdate.
O ntpd, além do serviço propriamente dito, oferece ferramentas de gerenciamento

e uma estrutura de logs completa. Uma dessas ferramentas é o comando ntpq,
que permite verificar detalhes da sincronização de tempo dos servidores e enviar
mensagens de controle para o host. Para verificar as opções que podem ser utilizadas
com o ntpq, basta executar ntpq --help, como mostrado a seguir:
524

O principal log do servidor NTP é o loopstats, que armazena dados referentes às
variáveis do sistema. Outro log relevante é o peerstats, que apresenta dados sobre
as associações existentes.
525
Os logs do NTP são exibidos da seguinte forma: dia, segundo, deslocamento,

escorregamento, erro estimado, estabilidade e intervalo de consulta. A imagem a
seguir mostra as últimas linhas do log loopstats de um servidor, independentemente
da distribuição utilizada:
9.2. Configuração do serviço de log

Ao executarmos um programa, as atividades deste são registradas em um arquivo
conhecido como arquivo de log. Geralmente, os arquivos de log ficam alocados no
diretório /var/log e neles encontramos informações como data, hora e mensagem
que foi emitida pelo programa executado.
As mensagens que um programa emite correspondem a erros, bem como a violações

do sistema, alertas e outras informações. Isso é importante pelo fato de que essas
informações são utilizadas pelo administrador no gerenciamento do sistema,
permitindo, também, tanto a prevenção quanto a solução de problemas encontrados.
O dia a dia de um bom administrador de sistemas – independentemente da plataforma

em uso – consiste em ler, interpretar e administrar bem os eventos existentes nos
logs.
Antigamente, o gerenciamento dos logs era feito com o serviço syslog. As versões
atuais do Linux trabalham com o serviço rsyslog.
Assim, os logs, como são chamados os arquivos de registro, normalmente compõem-

se da seguinte maneira:
data | hora | computador | daemon | mensagem
526
Em que:
•• computador: Corresponde ao nome do computador que realizou o registro da

mensagem;
•• daemon: Diz respeito ao programa a partir do qual a mensagem foi gravada.
Geralmente são utilizados dois formatos de arquivos pelo diretório padrão dos logs
/var/log:
•• O formato binário, como o /var/log/wtmp, que pode ser visualizado com o

comando específico last;

•• O formato texto, como o /var/log/messages, pode ser visualizado com o
comando tail.
527
9.2.1. Daemons de log
Os daemons são os responsáveis por registrar as mensagens, que são as mensagens
de sistema e de saída do kernel.
As mensagens de sistema e de kernel são representadas pelo daemon rsyslogd. Com

relação à localização, as mensagens encontram-se no diretório /var/log.
Temos, também, o arquivo de configuração /etc/rsyslog.conf. Ele é o responsável

pela forma como o rsyslogd trabalhará, a fim de controlar o tipo de mensagem que
cada um dos arquivos receberá.
9.2.2. rsyslogd
O rsyslogd é o daemon responsável por registrar os logs do sistema, cuja sintaxe é
a seguinte:
rsyslogd [opcoes]
Em que temos as seguintes opções:
•• -f: Esta opção determina um arquivo de configuração como sendo alternativo ao

arquivo /etc/rsyslog.conf;
•• -h: Por meio desta opção, as mensagens recebidas são direcionadas a outros
servidores, cujos logs são determinados;
•• -l: Refere-se a computadores e tem como função determinar um ou mais

computadores a serem registrados. Nesse registro, será utilizado apenas o
nome da máquina, e não o FQDN;
•• -m: Esta opção apresenta o intervalo de tempo, em minutos, que o arquivo

rsyslog tem para enviar a mensagem. Por padrão, a configuração é de 20
minutos, sendo que o número 0 desabilita esta opção;
•• -n: Com esta opção, evita-se que o processo caia em background de modo
automático. Caso o serviço rsyslogd seja controlado pelo init, faz-se necessário
o uso desta opção;
•• -p: Em vez de utilizar o /dev/log, que é padrão, esta opção determina um

socket Unix;
•• -r: Esta opção auxilia na criação de um servidor de logs centralizado, uma vez
que permite que mensagens sejam recebidas por meio da rede. Contudo, o
servidor rsyslog, por padrão, rejeita as conexões externas, e a porta utilizada
para o recebimento de mensagens é a UDP 514;
•• -s: Com esta opção, é possível determinar os domínios que devem ser removidos
antes que sejam enviados ao log.
528
9.2.3. Mais funções do rsyslog
O rsyslog é o substituto do syslog. O rsyslog é um syslogd de múltiplas threads
aprimorado. Ele valoriza a segurança e permite o suporte a:
•• Syslog sobre um protocolo TCP, TSL, SSL e RELP;
•• Buffering sob demanda;
•• Alerta de e-mail;
•• Login e escrita em banco de dados como PostgreSQL e MySQL.
9.2.4. Configurando o serviço de log

O arquivo /etc/rsyslog.conf configura o rsyslog. As regras de configuração contidas
no arquivo /etc/rsyslog.conf possuem o seguinte formato:
facilidade.nivel destino
Em que:
•• facilidade
Determina o tipo de programa que realiza o envio da mensagem. Na tabela a seguir,

mostraremos as opções de facilidade disponíveis:
Facilidade Descrição
Auth Utilizada em mensagens de segurança ou autorização.
Em vez de utilizar a opção auth, é mais recomendável utilizar
Authpriv
esta opção, que possui a mesma utilidade.
Cron Refere-se a daemons de agendamento, tanto cron como at.
Esta opção é utilizada para os demais daemons do sistema,
Daemon
cujas facilidades específicas não existem.
FTP Referente ao daemon ftp do sistema.
Kern Esta opção é utilizada por mensagens do kernel.
Lpr Referente ao subsistema de impressão.
Estas opções ficam reservadas para serem utilizadas
local0 e local7
localmente.
Mail Esta opção se refere ao sistema de e-mail.
News Referente ao sistema de notícias USENET.
Security Opção que deve ser evitada, sendo similar à opção auth.
529
Facilidade Descrição
Esta facilidade é utilizada nas mensagens internas, as quais
Rsyslog
são geradas pelo rsyslogd.
User Refere-se a mensagens genéricas, em nível de usuário.
Uucp Esta opção é utilizada para o subsistema de UUCP.
Ao utilizarmos o caractere asterisco (*), estamos nos referindo a todas as opções

anteriormente de scritas. Adicionalmente, a facilidade security e também outras, além
de emitirem um som de alerta, enviam uma mensagem para o console do usuário ou
administrador que se encontra autenticado no sistema.
•• nivel
Responsável por determinar o nível de importância que a mensagem que está sendo
enviada tem, ou seja, a urgência da mensagem. O programa, por si só, atribui
uma urgência a uma mensagem de log que ele gera. nivel identifica tal urgência e
encaminha para o destino especificado em destino a mensagem de log gerada.
A tabela a seguir descreve os níveis de urgência das mensagens de log que podem ser
especificados em nivel, do menos para o mais importante:
Nível Descrição
None Utilizado quando não há prioridade.
Assim como nas facilidades, este nível diz respeito a todos os
*
demais.
Debug Referente a mensagens de depuração.
Info Este nível refere-se a mensagens informativas.
Mesmo representando um nível de condição normal, esta opção
Notice
é significante.
Warning Refere-se a alertas.
Err Este nível refere-se a erros.
Crit Referente a condições críticas.
A utilização deste nível significa que se deve executar uma ação
Alert de modo imediato a fim de que um problema existente possa ser
resolvido.
Emerg Este nível indica que o sistema não pode mais ser utilizado.
530
Alguns níveis na tabela anterior possuem sinônimos. São eles:
•• warning: Possui o sinônimo warn;
•• emerg: Possui o sinônimo panic;
•• err: Possui o sinônimo error.
•• destino
Determina o local de destino da mensagem, que pode tanto ser um arquivo, um

computador remoto, ou, ainda, um pipe.
A tabela a seguir descreve os destinos para os quais podemos enviar os logs:
Destino Descrição
Ao especificarmos um arquivo como destino, o rsyslog enviará os
Um arquivo
logs para o arquivo especificado.
O envio dos logs através de um pipe – utiliza-se o caractere | – por
Um pipe parte do rsyslog costuma ser adotado para redirecionamento de
logs para um terminal.
Um Podemos fazer com que o rsyslog envie os logs para um
computador computador remoto. Para isso, utiliza-se o caractere arroba (@) no
remoto início do hostname ou endereço IP do computador remoto.
Os logs do rsyslog podem ser enviados para um ou mais usuários
Um ou vários específicos. Para tanto, devemos especificar como destino o(s)
usuários nome(s) do(s) usuário(s). No caso de vários usuários, os nomes
devem ser separados por vírgula (usuario1,usuario2,...).
Todos os Para o envio dos logs do rsyslog para todos os usuários atualmente
usuários logados no sistema, utiliza-se o asterisco (*), via comando wall.
Adicionalmente, podemos agrupar as facilidades e o nível – contudo, devem ser

separados por ponto e vírgula (;). Os espaços que separam os parâmetros devem ser
definidos pela tecla TAB.
531
Alguns caracteres possuem funções especiais, as quais são descritas a seguir:
Caractere Descrição
Assim que o arquivo é gravado, este caractere pode ser utilizado
-
para que o sync imediato do arquivo em questão seja desativado.
Quando este caractere é utilizado, determina que apenas o nível
=
que foi especificado possuirá registro.
Determina que todos os níveis, os quais foram especificados e são
! maiores, não possuirão registro. Pode ser utilizado em combinação
com o caractere sinal de igual (=) na mesma regra.
Este caractere determina que todas as mensagens definidas em
*
facilidade sejam redirecionadas.
Vejamos:
532
Na imagem anterior, podemos observar parte do arquivo /etc/rsyslog.conf, em que
há algumas configurações, como a linha a seguir, que diz que todas as mensagens de
kernel com qualquer prioridade serão redirecionadas para o arquivo /var/log/kern.
log:
kern.* -/var/log/kern.log
Outro exemplo são as mensagens de e-mail, que, de acordo com a prioridade, são
enviadas para um arquivo diferente, como podemos perceber nas linhas a seguir:
mail.info /var/log/mail.info
mail.warn /var/log/mail.warn
mail.err /var/log/mail.err
9.2.5. Configurando um servidor de logs

Outros computadores que fazem parte da rede podem ter suas mensagens enviadas
para o rsyslog, que as registra, impedindo que arquivos de log gravados em um
computador de forma local sejam perdidos. A ativação dessa função deve ser feita
no arquivo /etc/rsyslog.conf. Existe a possibilidade de ativar o recebimento das
mensagens via protocolo UDP ou TCP, o mais comum é por meio do UDP. Para isso, é
necessário descomentar as seguintes linhas:
$ModLoad imudp
$UDPServerRun 514
Após descomentar e salvar o arquivo, é necessário reiniciar o serviço do rsyslogd.

Assim, teremos um servidor de logs.
9.2.6. Configurando um cliente de um servidor de logs

Para que uma máquina possa enviar suas mensagens de log para um servidor, o
arquivo /etc/rsyslog.conf, deve ser alterado de maneira que as linhas de configuração
de serviços sejam direcionados ao servidor específico.
533
Para realizar tal alteração, basta mudar o destino dos logs, inserindo @<endereco_
IP> (onde <endereco_IP> é o endereço IP do servidor de log), como mostra o exemplo
a seguir:
Caso tenha ativado o envio de mensagens via protocolo TCP, deve ser utilizado @@
antes do IP em vez de somente uma @.
Em seguida, o rsyslog deve ser reiniciado:
# /etc/init.d/rsyslog restart
Verifique se a porta do serviço foi aberta:
# netstat –nlpu | grep 514
Por fim, já no servidor de logs, é possível visualizar os logs sendo gravados:
534
9.2.7. Configurando a rotação de logs
O logrotate é um serviço desenvolvido em cron ou até mesmo em outro daemon que
possua a mesma função deste. Sua função consiste em:
•• Criar novos arquivos de log, os quais serão utilizados pelo sistema;
•• Realizar o backup dos logs que se encontram atualmente no sistema.
O serviço logrotate possui uma opção que possibilita que os arquivos de log antigos
sejam compactados. Com isso, o tamanho desses arquivos é reduzido, permitindo
que sejam enviados ao administrador do sistema e que o espaço em disco utilizado
por esses arquivos seja menor.
Adicionalmente, quando há necessidade de localizar uma informação detalhada, a

rotação dos arquivos de logs permite maior agilidade, visto que a mesma tarefa em
um arquivo de log de grande tamanho seria mais complicada. O que determina a
rotação de logs é o tamanho do arquivo de logs que foi determinado, e essa rotação
pode ser forçada fazendo-se uso da opção –f.
Outras opções da rotação de log são apresentadas na tabela a seguir:
Opção Descrição
Sua função é fornecer detalhes do que está sendo executado pelo
-d
logrotate.
Esta opção possui um número máximo de logs a serem mantidos.
Quando esse limite for atingido, ocorre a eliminação dos logs.
Rotate
Estes, por sua vez, são enviados a um usuário determinado na
<num>
opção mail <email>. Para impedir que o limite de logs mantidos
seja atingido, é possível utilizar a diretiva nomail.
Determina o usuário para o qual serão enviados os logs assim que
Mail <email>
o limite da opção rotate <num> for atingido.
É importante observar as seguintes informações relacionadas aos arquivos:
•• Com relação aos parâmetros que forem determinados no arquivo de configuração,

estes irão sobrescrever as definições feitas anteriormente;
•• É recomendável utilizar a sintaxe log-xxx-*.log em vez da sintaxe log-xxx-*, que

não deve ser empregada quando fizer uso de coringas para referenciar arquivos
específicos de um diretório. Isso porque a última sintaxe força a recompactação
de arquivos com extensão .gz, os quais já estão compactados. Essa operação,
contudo, gera novos arquivos e faz com que o processamento da máquina
diminua devido a dois fatores:
535
•• É gerado um loop de compactação desses arquivos;
•• As entradas do diretório recebem grande quantidade de tráfego.
•• Com relação ao arquivo de configuração principal, este é o /etc/logrotate.conf.
É importante que, para não ocorrerem problemas assim que a rotação for realizada,
um sinal HUP seja enviado ao programa que grava o arquivo de log. Para realizarmos
essa tarefa, fazemos uso do parâmetro postrotate.
No exemplo a seguir, o arquivo de configuração /etc/logrotate.conf define que os

logs devem fazer a rotação semanalmente (weekly) e que os logs fiquem armazenados
por quatro semanas (rotate 4):
536
9.2.8. Criando mensagens de log manualmente
O comando logger registra entradas no sistema de logs e fornece uma interface
de comando shell para o módulo de logs do sistema. Por meio de logger, criamos
manualmente mensagens de log que o comando interpreta como argumento.
Há a possibilidade de especificar a prioridade, o nível ou um nome que identifique o

processo, além das outras opções, que serão detalhadas mais adiante.
logger [nível] [mensagem]
Em que:
•• mensagem: É a mensagem que será enviada ao daemon de log.
A tabela a seguir descreve opções utilizadas com o comando logger:
-i Registra o PID do processo.
A mensagem é enviada para a saída padrão (STDOUT) e para
-s
syslog.
Envia o conteúdo de um arquivo especificado para o syslog, como
-f <arquivo>
uma mensagem.
Determina o nome do processo responsável pelo log que será
-t <nome>
exibido antes do PID na mensagem do syslog.
-p Determina a prioridade da mensagem do syslog, especificada
<prioridade> como facilidade.nivel.
9.2.9. Monitorando as mensagens de log do sistema

Para haver segurança no sistema, é importante a existência de um terminal especial a
fim de monitorar as mensagens do sistema.
O arquivo /var/log/messages é um arquivo de log em que tanto as conexões a

serviços, como FTP e telnet, quanto as mensagens de kernel são encontradas. É
para esse arquivo que são enviadas as mensagens de log. Assim, quando houver
a necessidade de visualizar as mensagens do /var/log/messages, basta editá-lo
utilizando o comando tail.
537
O comando tail pode ser utilizado com o parâmetro –f, que permite a visualização do
arquivo de maneira contínua, como mostrado na imagem seguinte. Isso significa que
o arquivo é atualizado e visualizado no seu estado atual, e é apresentada, em tempo
real, a linha criada no momento em que o arquivo estiver sendo visualizado.
9.2.10. Syslog-ng
Com o syslog-ng, a coleta dos logs pode ocorrer de qualquer fonte, processá-los em
tempo quase real e entregá-los a uma grande variedade de destinos.
O syslog-ng permite coletar, analisar, classificar e correlacionar registros de maneira

flexível de toda a sua infraestrutura e armazená-los ou encaminhá-los para ferramentas
de análise de logs.
A configuração é realizada através do arquivo de configuração, encontrado em /etc/

syslog-ng/syslog-ng.conf.
Vejamos um exemplo:
@version: 3.7
@include “scl.conf”
source s_system { system(); internal(); };
destination d_all { file(“/var/log/all.log”); };
log { source(s_system); destination(d_all); };
538
9.3. Agente MTA
O agente MTA – Mail Transfer Agent – é um componente essencial para o
funcionamento do controle de e-mails em um determinado servidor. Os componentes
envolvidos na criação, envio e recepção de mensagens entre o servidor e a caixa
postal do cliente são identificados como:
•• MUA – Mail User Agent: Software de cliente de e-mail;
•• MTA – Mail Transfer Agent: Servidor de e-mail, utilizando o protocolo SMTP;
•• MDA – Mail Delivery Agent: Responsável por enviar as mensagens para o

cliente.
Entre vários servidores de e-mail, os mais conhecidos são:
•• Sendmail: Primeiro servidor de correio eletrônico. Sua configuração é

caracterizada por sua complexidade de funcionamento;
•• Exim: Padrão na distribuição Debian. Possui um nível de segurança melhor,

comparado ao Sendmail, assim como também facilidade de configuração;
•• Qmail: Tem como principais características segurança e agilidade, porém sua

instalação é complexa;
•• Postfix: Foi criado como uma alternativa ao Sendmail e é muito utilizado

atualmente. Possui uma configuração simples e com recursos avançados na
definição de regras de comunicação.
539
9.3.1. Instalação do Postfix
Para verificar se o programa Postfix já se encontra instalado no CentOS 7, informe o
comando a seguir:
# rpm -qi postfix
Name : postfix
Epoch : 2
Version : 2.10.1
Release : 6.el7
Architecture: x86_64
Install Date: Wed Nov 16 09:24:08 2016
Group : System Environment/Daemons
Size : 12773475
License : IBM and GPLv2+
Signature : RSA/SHA256, Fri Jul 4 01:33:15 2014, Key ID 24c6a8a7f4a80eb5
Source RPM : postfix-2.10.1-6.el7.src.rpm
Build Date : Mon Jun 9 22:39:36 2014
Build Host : worker1.bsys.centos.org
Relocations : (not relocatable)
Packager : CentOS BuildSystem <http://bugs.centos.org>
Vendor : CentOS
URL : http://www.postfix.org
Summary : Postfix Mail Transport Agent
Description :
Postfix is a Mail Transport Agent (MTA), supporting LDAP, SMTP AUTH (SASL),
TLS
Caso o Postfix não esteja instalado, realize a instalação com o comando yum install
postfix.
9.3.2. Configuração do Postfix
Os arquivos de configuração do Postfix são encontrados no diretório /etc/postfix. Os
dois principais arquivos são mail.cf e master.cf.
# ls /etc/postfix/
access canonical generic header_checks main.cf master.cf relocated

transport virtual
540
O arquivo main.cf possui as configurações globais do servidor, como:
•• Definição do hostname;
•• Definição do domínio;
•• Restrição das interfaces de rede;
•• Definição da caixa de e-mail.
O arquivo master.cf possui as demais configurações, como a definição da porta TCP,

em que o serviço irá “ouvir” (por padrão, é a porta 25, responsável pelo protocolo
SMTP).
9.3.3. Redirecionamento de e-mails
O redirecionamento de e-mails pode ser configurado através do arquivo identificado
como /etc/aliases. Com isso, todos os e-mails enviados para um determinado
destinatário terão também uma cópia que será enviada para o usuário configurado
nesse arquivo.
Vejamos um exemplo:
Manager: root
Webmaster: operador
Nesse exemplo, todas as mensagens enviadas para o usuário Manager também serão
encaminhadas para o usuário root, assim como também as mensagens enviadas para
o usuário Webmaster serão encaminhadas para o usuário operador.
Após alterar esse arquivo, é necessário executar o comando newaliases para sua
atualização.
Uma outra maneira de encaminhar mensagens a outro usuário ou e-mail é através do

arquivo ~/.forward, encontrado no diretório pessoal de cada usuário.
9.3.4. Envio de e-mails
Um simples teste de envio de mensagem pode ser realizado diretamente na linha de
comando, utilizando o comando sendmail ou mail:
# sendmail -f operador@dominio.com.br webmaster@dominio.com.br
# mail -s “Título do e-mail” operador@dominio.com.br
Após digitar a mensagem, acrescente um ponto(.) e tecle ENTER.
541
9.3.5. Verificar fila de e-mails

A verificação de filas de e-mails no servidor pode ser realizada através do comando
mailq. Caso não haja nenhuma mensagem pendente para o envio, nada deve ser
exibido. O comando sendmail possui a mesma finalidade.
9.4. Serviço de impressão CUPS

Ao trabalharmos com impressões, podemos utilizar o sistema Common Unix
Printing System – CUPS. Ele é o responsável pelo gerenciamento do material que será
impresso e pelo suporte de impressoras. Sua interface Web suporta grande parte das
impressoras, gerencia as filas de impressão e controla cotas de impressão.
Esse sistema, cuja configuração pode ser realizada pela interface Web ou por linha de
comando, administra o material a ser impresso e as filas de impressão com o auxílio
do protocolo IPP (Internet Printing Protocol), com o qual também podemos executar
uma impressão remota. Além disso, ele é compatível com as ferramentas do LPD,
antigo sistema de impressão.
Os comandos utilizados no gerenciamento de impressão também serão abordados

nesta parte do treinamento.
9.4.1. Instalando o CUPS
Para instalar o CUPS, devemos, primeiramente, instalar os seguintes pacotes:
•• cups;
•• cupsys-driver-gutenprint.
Com esses pacotes instalados, podemos passar à configuração do CUPS.
9.4.2. Configurando por meio da interface Web

Utilizar a interface Web que o CUPS disponibiliza é a maneira mais recomendável para
realizar sua configuração.
O CUPS, como vimos, também pode ser usado para controlar uma impressão remota.
Na configuração do CUPS que veremos a seguir, por meio da interface Web, uma
impressora é adicionada e configurada como servidor de impressão:
542
1. Execute o browser de preferência e, na barra de endereço, digite http://
localhost:631. Será apresentado um menu de configuração, como na próxima
imagem:
2. Selecione a guia Administration, exibida a seguir, e clique em Add printer para

adicionar uma nova impressora:
3. Em seguida, escolha o tipo de impressora:
543
4. Depois, defina as seguintes informações e clique em Continue:
•• Name: Nome da impressora;
•• Location: Descrição da localização da impressora;
•• Description: Descrição da impressora.
5. Em seguida, em Device, informe qual dispositivo será utilizado pela impressora,

conforme mostrado na imagem a seguir. Depois, clique em Continue;
544
6. Defina o driver da impressora, como mostra a imagem adiante:
7. Defina o tipo de papel padrão que a impressora usará:
Na imagem a seguir, podemos visualizar a impressora configurada:
545
Requisições remotas são aceitas pelo CUPS mediante a habilitação da opção Share
published printers connected to this system, presente na guia Administration,
exibida a seguir:
9.4.3. Configurando pela linha de comando

Realizar a configuração pela linha de comando é mais complexo do que pela interface
Web, mas pode ser necessário quando esta última não está disponível. A seguir,
temos a descrição dos principais comandos utilizados:
•• lpinfo: Com este comando, os dispositivos e protocolos de impressão que podem

ser utilizados são listados. O tipo do dispositivo é identificado na palavra inicial
da lista. O módulo do dispositivo de uma impressora local deve estar carregado;
O exemplo a seguir demonstra a utilização do comando lpinfo com a opção –m, a fim
de exibir os drivers de impressora disponíveis no sistema:
546
Ao utilizarmos lpinfo com a opção –v, visualizamos os dispositivos de impressão
disponíveis no sistema.
•• lpadmin: Por meio deste comando, executamos a maioria das atividades de

impressão relativas à administração. A tabela a seguir descreve opções utilizadas
com o lpadmin:
Opção Descrição
Determina uma classe para a impressora em questão. Essa
-c <classe>
classe é criada caso seja inexistente.
A impressora especificada é removida da classe que, ao ficar
-r <classe>
vazia, é excluída.
O driver padrão da impressora – um arquivo PPD, na maioria
das vezes – é determinado nesta opção. O comando lpinfo
-m <modelo>
–m nos permite visualizar em uma lista os modelos que estão
disponíveis, como mencionado anteriormente.
-P <arquivo_PPD> Um arquivo PPD de driver local é especificado para a impressora.
O endereço do dispositivo de comunicação da impressora que
-v <dispositivo>
será usada é determinado nesta opção.
Esta opção diz respeito à descrição de texto referente à
-D info
impressora.
-E A impressora recebe permissão para imprimir trabalhos.
Esta opção diz respeito à descrição de texto referente à
-L <localizacao>
localização da impressora.
A seguir, temos um exemplo de utilização do lpadmin:
lpadmin –p teste –E –ipp://192.168.0.200/printers/impressorateste
•• lpstat –a: Responsável pela verificação da situação de impressoras e filas.
547
9.4.4. Arquivos de configuração do CUPS

Localizados em /etc/cups, os principais arquivos de configuração do CUPS estão
descritos na tabela a seguir:
Arquivo de
Descrição
configuração
classes.conf As classes das impressoras locais são determinadas nesta opção.
As impressoras locais com disponibilidade são determinadas
printers.conf
nesta opção.
Esta opção refere-se às configurações específicas de cada
lpoptions
impressora.
mime.types Nesta opção são especificados os tipos de arquivos conhecidos.
Os filtros com disponibilidade para converter formatos de
mime.convs
arquivos são determinados nesta opção.
Esta opção refere-se às configurações que o daemon cupsd
cupsd.conf
apresenta.
9.4.5. Configurando clientes de impressão

O serviço CUPS também pode ser configurado nos clientes que irão enviar requisições
de impressão para o servidor. Para isso, devemos realizar a configuração do cliente
de impressão por meio do seguinte procedimento:
1. Solicite a tela de configuração do CUPS, na guia Administration;
2. Clique em Add printer;
3. Defina, na opção a seguir, o método de acesso à impressora da rede. Sendo assim,

selecionaremos o dispositivo Internet Printing Protocol (ipp). Em seguida, clique em
Continue;
548
4. Informe a localização e o nome da impressora remota, conforme mostrado adiante.
Depois, clique em Continue;
5. Insira um nome local para a impressora e sua localização, que poderá ter qualquer
tipo de descrição (campo Description). Clique em Continue;
6. Defina o modelo e driver da impressora, de acordo com a imagem adiante, e clique

em Add Printer;
549
Finalizado o processo de configuração do cliente, será apresentada uma tela que

exibe grande parte das informações sobre a impressora que foi configurada, conforme
demonstra a seguinte imagem:
9.4.6. Gerenciando a impressão
A seguir, veremos alguns comandos úteis para gerenciar tarefas de impressão.
Com eles, podemos imprimir arquivos, monitorar filas de impressão e configurar
impressoras instaladas como servidores de impressão.
Os trabalhos que ainda não foram impressos são armazenados em um diretório

temporário, a fila de impressão, que pode ser encontrado em /var/spool/cups – no
sistema de impressão antigo, o LPD, a localização era /var/spool/lpd. Utilizamos o
comando lpq para que os trabalhos sejam organizados na fila de impressão.
O envio de um determinado documento para a fila de impressão é feito com o comando

lpr, cujas opções comumente usadas estão descritas adiante:
Opção Descrição
-P<xxx> O arquivo é enviado para a fila <xxx>.
-#<N> O documento é impresso o número de vezes determinado em <N>.
É criado um link simbólico na fila de impressão, embora o documento
-s
não seja copiado para ela.
Para verificar as tarefas de impressão, usamos o comando lpq. Podemos fazer essa
verificação apenas nos trabalhos de um determinado computador, ou em todos os
trabalhos do sistema que estiverem em fila. Para isso, utilizamos, respectivamente,
lpq –P e lpq –a.
550
Os trabalhos de impressão têm, cada um, um número designado que permite que
esse trabalho seja cancelado na fila de impressão pelo comando lprm. A seguir,
descrevemos outras considerações sobre esse comando e o processo de cancelamento:
•• O último trabalho que foi enviado será cancelado caso usemos o lprm sem
argumentos;
•• O usuário pode ter todos os seus trabalhos de impressão cancelados se seu

nome for identificado como argumento;
•• Tanto o comando lprm –a como o lprm – farão com que todos os trabalhos
sejam cancelados.
Como mencionado, o CUPS permite que um trabalho seja impresso remotamente. Para
que isso ocorra, o computador local (o servidor de impressão, isto é, o computador
no qual a impressora foi instalada) deve estar ligado a uma rede, na qual a impressora
deve ser disponibilizada. Tal configuração pode ser realizada por meio de uma das
seguintes alternativas:
•• Interface de configuração Web do CUPS;
•• Ferramenta de impressão da distribuição;
•• Edição direta dos arquivos de configuração.
A seguir, temos um exemplo de configuração de uma impressão remota realizada no

arquivo /etc/cups/cupsd.conf, no qual é possível, por exemplo, configurar a porta
do CUPS, as permissões de acesso, entre outros:
551
As configurações novas poderão ser utilizadas apenas depois que o cupsd tiver sido
reiniciado. Os outros computadores que estiverem na rede precisam ter a seguinte
linha inserida no arquivo /etc/cups/client.conf:
ServerName <endereço_do_servidor_de_impressao>
Utilizamos o comando lpstat –a para verificar a impressora remota no terminal.
lpstat -a
Essa impressora também pode imprimir automaticamente os documentos desejados.

Basta que ela seja a impressora padrão, configuração realizada com o comando
lpoptions –d, como podemos ver adiante:
lpoptions –d <nome_da_impressora>
552
Pontos principais
•• Na página do projeto NTP (www.ntp.org), podemos obter endereços de

servidores NTP oficiais. É importante conhecer o site do NTP.br, um projeto do
NIC.br (Comitê Gestor da Internet no Brasil) que possui servidores públicos para
sincronização com a Hora Legal Brasileira e com o Tempo Universal Coordenado
(UTC);
•• Ao executarmos um programa, as atividades deste são registradas em um

arquivo conhecido como arquivo de log. Geralmente, os arquivos de log ficam
alocados no diretório /var/log e neles encontramos informações como data,
hora e mensagem que foi emitida pelo programa executado;
•• Os componentes envolvidos na criação, envio e recepção de mensagens entre

o servidor e a caixa postal do cliente são identificados como: MUA (Mail User
Agent), MTA (Mail Transfer Agent) e MDA (Mail Delivery Agent). Entre vários
servidores de e-mail, os mais conhecidos são: Sendmail, Exim, Qmail e Postfix;
•• Ao trabalharmos com impressões, podemos utilizar o sistema Common Unix

Printing System – CUPS. Ele é o responsável pelo gerenciamento do material
que será impresso e pelo suporte de impressoras. Sua interface Web suporta
grande parte das impressoras, gerencia as filas de impressão e controla cotas
de impressão.
Sites Endereços
https://access.redhat.com/documentation/en-US/Red_Hat_
LOGS Enterprise_Linux/6/html/Deployment_Guide/ch-Viewing_and_
Managing_Log_Files.html
Agente MTA
Enterprise_Linux/6/html/Deployment_Guide/s1-email-mta.html
Servidor de
https://www.cups.org/
impressão
553
554
do sistema
1. Em que pasta encontramos os arquivos para ajustar o localtime?
☐☐ a) /etc/zoneinfo
☐☐ b) /usr/zoneinfo
☐☐ c) /usr/share/zoneinfo
☐☐ d) /etc/share/zoneinfo
☐☐ e) /share/zoneinfo
2. Qual comando pode ser utilizado para configurar a hora do sistema

tendo como base a hora do hardware?
☐☐ a) hwclock -s
☐☐ b) hwclock -w
☐☐ c) hwclock -systohc
☐☐ d) date –set hw
☐☐ e) date hw set
3. Como ajustamos a data do servidor para 10 de maio de 2011 às 09h10

(a.m.)?
☐☐ a) date –-set 20111005 09:10

☐☐ b) date –-set 10052011 09:10
☐☐ c) date –-set 20110510 09:10
☐☐ d) date –-set 20110510 0910
☐☐ e) date –-set 05102011 0910
4. Qual comando utilizamos para sincronizar a hora do servidor com o

servidor da USP?
☐☐ a) ntpdate ntp.usp.br
☐☐ b) ntpdate -sync ntp.usp.br
☐☐ c) ntpsync ntp.usp.br
☐☐ d) ntpdate -set ntp.usp.br
☐☐ e) date ntp.usp.br
5. Qual é o arquivo de configuração do servidor NTP?
☐☐ a) /etc/ntpd.conf
☐☐ b) /etc/ntpdate.conf
☐☐ c) /etc/default/ntpdate
☐☐ d) /etc/ntp.conf
☐☐ e) /etc/default/ntp.conf
556
6. Com qual comando é possível ler o arquivo wtmp?
☐☐ a) tail
☐☐ b) cat
☐☐ c) more
☐☐ d) last
☐☐ e) vi
7. Qual informação do log determina o tipo de programa que realizou o

envio da mensagem?
☐☐ a) info
☐☐ b) nivel
☐☐ c) destino
☐☐ d) warn
☐☐ e) facilidade
8. Quais parâmetros devem ser descomentados no arquivo /etc/rsyslog.

conf para que o rsyslog passe a funcionar como servidor de logs?
☐☐ a) $ModLoad imudp.so e $InputTCPServerRun 514.

☐☐ b) $ModLoad imtcp.so e $UDPServerRun 541.
☐☐ c) $ModLoad imudp.so e $UDPServerRun 514.
☐☐ d) $ModLoad imtcp.so e $UDPServerRun 514.
☐☐ e) $ModLoad imudp.so e $InputTCPServerRun 541.
9. Qual é o arquivo de configuração do rsyslog?
☐☐ a) /etc/rsyslog.conf
☐☐ b) /etc/syslogd.conf
☐☐ c) /usr/src/rsyslog.conf
☐☐ d) /etc/syslog.conf
☐☐ e) /usr/src/syslogd.conf
10. Que símbolo deve ser utilizado antes do endereço IP do servidor de

logs, no arquivo /etc/rsyslog.conf, para apontar o destino dos logs através
do protocolo UDP?
☐☐ a) #
☐☐ b) @
☐☐ c) %
☐☐ d) !
☐☐ e)&
557
11. Que símbolo deve ser utilizado antes do endereço IP do servidor de

logs, no arquivo /etc/rsyslog.conf, para apontar o destino dos logs através
do protocolo TCP?
☐☐ a) #
☐☐ b) @
☐☐ c) %
☐☐ d) @@
☐☐ e)&
12. Qual é a porta padrão utilizada pelo servidor de impressão CUPS?
☐☐ a) 22
☐☐ b) 621
☐☐ c) 23
☐☐ d) 631
☐☐ e) 321
13. Qual comando deve ser utilizado para verificar o status das impressoras
e filas?
☐☐ a) lpd -a
☐☐ b) lp -a
☐☐ c) lpstat -a
☐☐ d) lpadmin -a
☐☐ e) lpoptions -a
14. Qual é o protocolo utilizado para a administração de filas de impressão?
☐☐ a) TCP/IP
☐☐ b) IPP
☐☐ c) PPP
☐☐ d) CUPS
☐☐ e) ISP
15. Qual comando deve ser utilizado para listar as impressoras disponíveis?
☐☐ a) lpinfo
☐☐ b) lpq
☐☐ c) lpd
☐☐ d) lpadmin -l
☐☐ e) lpinfo -m
558
16. Qual comando deve ser utilizado para verificar configurações
específicas de cada impressora?
☐☐ a) lpoptions
☐☐ b) lpinfo
☐☐ c) lpq
☐☐ d) lpd
☐☐ e) cups
17. Qual o nome do arquivo responsável pelas configurações globais do

agente MTA?
☐☐ a) mail.cf
☐☐ b) main.cf
☐☐ c) man.cf
☐☐ d) main
☐☐ e) cf.main
18. Qual a função do arquivo /etc/aliases?
☐☐ a) Configuração de e-mail.
☐☐ b) Redirecionamento de e-mails.
☐☐ c) Configurações globais do agente.
☐☐ d) Definição da porta TCP.
☐☐ e) Definição da caixa de e-mail.
559
do sistema
Mãos à obra!
Laboratório 1 - Trabalhando com o horário

do hardware
1. Verifique o horário que está no relógio de hardware do computador;
# hwclock -r
2. Ajuste a hora do relógio de hardware para ficar igual à do sistema;
# hwclock -w
3. Verifique novamente a hora do relógio de hardware;
# hwclock –show
4. Compare com a hora do sistema.
# date
Laboratório 2 - Ajustando a hora a partir de

outro computador
5. Instale o ntpdate;
# aptitude install ntpdate
6. Ajuste o arquivo /etc/default/ntpdate;
# vi /etc/default/ntpdate
7. Altere as seguintes linhas, deixando-as como vemos a seguir:
NTPDATE_USE_NTP_CONF=no
NTPSERVERS=”a.ntp.br b.ntp.br”
8. Sincronize manualmente a hora do computador com o servidor principal do NTP.br;
# ntpdate a.ntp.br
9. Verifique a hora do sistema.
# date
562
Laboratório 3 - Instalando o servidor NTP
10. Instale o pacote do NTP;
# yum install ntp
11. Renomeie o arquivo de configuração do NTP;
# mv /etc/ntp.conf /etc/ntp.conf.old
12. Crie um novo arquivo de configuração abrindo com vi (ele aparecerá em branco);
13. Adicione o conteúdo a seguir no arquivo (observe que ele está todo comentado
para maior entendimento do seu funcionamento);
# Arquivo de configuração do valor estimado de erro de

# frequencia entre o relogio do sistema e o servidor de
# sincronia de tempo
driftfile /etc/ntp.drift
# estatisticas do ntp que permitem verificar o historico
# de funcionamento e gerar graficos
statsdir /var/log/ntpstats/
statistics loopstats peerstats clockstats
filegen loopstats file loopstats type day enable
filegen peerstats file peerstats type day enable
filegen clockstats file clockstats type day enable
# servidores publicos onde faremos a sincronização
# do projeto ntp.br
server a.ntp.br iburst
server b.ntp.br iburst
server c.ntp.br iburst
# configuracoes de restricao de acesso
restrict default kod notrap nomodify nopeer
14. Salve e saia do arquivo de configuração;
:wq
15. Crie o arquivo drift;
# touch /etc/ntp.drift
16. Altere o proprietário do arquivo drift para o usuário ntp;
# chown ntp /etc/ntp.drift
563
17. Reinicie o servidor NTP;
# systemctl restart ntpd
18. Faça, manualmente, o primeiro sincronismo com o servidor;
# ntpd -g -n -q
19. Verifique se a hora está correta.
# date
Laboratório 4 - Monitorando o servidor NTP

20. Verifique se o servidor NTP está sincronizando o relógio;
# ntpq -c pe
•• O servidor que inicia com * é o servidor principal;
•• Servidores que iniciam com + são boas fontes de sincronismo e estão sendo
utilizados;
•• Servidores que iniciam com – não estão respondendo e, por isso, não estão
sendo utilizados;
•• A coluna when significa quantos segundos já se passaram desde o último

sincronismo;
•• A coluna poll representa de quanto em quanto tempo a fonte será consultada;
•• A coluna offset representa quanto o relógio será adiantado ou atrasado até ficar
igual à fonte de tempo (em milissegundos).
21. Verifique as informações globais do sistema, como a versão, por exemplo:
# ntpq -c rl
•• version: Versão do ntp;
•• stratum: Estrato do servidor local;
•• precision: Precisão indicada com o expoente de um número base 2;
•• rootdelay: Atraso, ou tempo de ida e volta, dos pacotes até o estrato 0, em

milissegundos;
564
•• rootdispersão: Erro máximo da medida de offset em relação ao estrato 0, em
milissegundos;
•• refid: O par do sistema, ou principal referência;
•• offset: Deslocamento – quanto o relógio local deve ser adiantado ou atrasado

para chegar à hora certa (hora igual à do estrato 0);
•• frequency: Erro na frequência do relógio local em relação à frequência do

estrato 0, em partes por milhão (PPM).
22. Verifique somente a variável offset e a poll com o comando ntpdc;
# ntpdc -c loopinfo
Laboratório 5 - Interpretando os logs do sistema

23. Verifique o log de loops locais (variáveis de sistema). Os dados deste log são
representados na seguinte sequência: dia, segundo, deslocamento, escorregamento,
erro estimado, estabilidade, intervalo de consulta;
# cat /var/log/ntpstats/loopstats
24. Verifique as informações de cada associação existente.
# cat /var/log/ntpstats/peerstats
Laboratório 6 - Analisando os logs do sistema

25. Acesse a pasta de logs:
# cd /var/log
26. Liste os arquivos contidos no diretório, com identificação facilitada (em cores).
Analise com calma o resultado;
# ls –color
A cor azul significa diretório e a branca significa arquivo comum.
565
27. Leia o arquivo de log dmesg (logs de inicialização da máquina) e tente identificar
o máximo de informações possível, de acordo com o que foi visto neste e no módulo
anterior;
# cat dmesg | less
28. Leia as últimas 30 linhas do log messages;
# tail -n 30 messages
29. Leia com atenção as últimas 30 linhas do log syslog.
# tail -n 30 syslog
Laboratório 7 - Configurando o servidor para

receber logs de outros servidores
30. Edite o arquivo /etc/rsyslog.conf;
# vim /etc/rsyslog.conf
31. Descomente as seguintes linhas para ativar o recebimento dos logs através do
protocolo UDP:
$ModLoad imudp
$UDPServerRun 514
:wq
33. Reinicie o serviço do rsyslog;
# /etc/init.d/rsyslog restart
34. Verifique se a porta UDP foi aberta.
# netstat -nlpu | grep 514
566
Laboratório 8 - Configurando as estações ou
servidores para gravar os logs no servidor
de log
35. Na estação de trabalho ou servidor cliente, edite o arquivo /etc/rsyslog.conf;
# vi /etc/rsyslog.conf
36. Adicione a regra para gravar todos os logs de um dos alunos deste treinamento
no servidor. Altere o X para o endereço IP correto do aluno;
*.* @192.168.0.X
37. Salve o arquivo;
:wq
38. Reinicie o rsyslog;
# systemctl restart rsyslog
39. Para testar, leia os logs do outro aluno. Deve aparecer o nome da sua máquina e
informações de logs. No servidor do outro aluno, digite e observe:
# tail -f /var/log/messages
Laboratório 9 - Configurando o logrotate

40. Edite o arquivo /etc/logrotate.conf;
# vi /etc/logrotate.conf
41. Altere a regra de rotação de semanalmente (weekly) para diariamente (daily);
# rotate log files weekly

daily
42. Altere a rotação de 4 para 8;
# keep 4 weeks worth of backlogs

rotate 8
567
:wq
44. Execute o logrotate manualmente.
# logrotate -f /etc/logrotate.conf
Laboratório 10 - Inserindo logs manualmente

45. Insira um log de kernel com a prioridade de informação;
# logger -p kern.info “Mensagem de teste do Logger”
46. Observe se o log foi inserido.
# cat /var/log/syslog
Laboratório 11 - MTA
47. Instale o servidor de e-mail Postfix e envie um e-mail para o seu e-mail pessoal:
# yum install postfix
# systemctl start postfix
# mail –s “Teste de e-mail” e-mail@dominio.com
Escreva a mensagem desejada e depois coloque o ponto “.” para enviar o e-mail.
Laboratório 12 - Instalando e gerenciando o

CUPS
48. Instale os pacotes necessários;
# yum install cups cups-lpd gutenprint-cups
# wget https://kojipkgs.fedoraproject.org//packages/cups-
pdf/2.6.1/11.fc24/ppc64le/cups-pdf-2.6.1-11.fc24.ppc64le.rpm
rpm –ivh cups-pdf-2.6.1-11.fc24.ppc64le.rpm
568
49. Para a distribuição Debian:
# aptitude install cups cups-pdf cups-driver-gutenprint printer-

driver-cups-pdf
50. Após a instalação, acesse o diretório /etc/cups/ e liste os arquivos:
# cd /etc/cups
# ls
51. Caso sua distribuição esteja com a interface gráfica instalada, abra o navegador e
digite o endereço do seu servidor CUPS;
http://localhost:631
52. Permita que este servidor possa ser administrado remotamente. Para tanto, clique
na guia Administration;
53. Marque a caixa de seleção Allow remote administration;
54. Salve as alterações clicando em Save Settings;
55. Insira usuário e senha (do root);
56. Adicione uma impressora clicando em Add Printer;
57. Preencha o formulário da seguinte forma:
•• No campo Name, insira o nome da impressora (ex.: Impressora_Faturamento);
•• No campo Location, insira a localização da impressora (ex.: 2. andar);
•• No campo Description, insira a descrição da impressora (ex.: Impressora jato

de tinta colorida marca tabajara).
58. Confirme a ação clicando em Continue;
59. Selecione o tipo de conexão apropriado para esta impressora (ex.: Internet Printing
Protocol (IPP));
60. Confirme clicando em Continue;
61. Digite o caminho da impressora, por exemplo: ipp://192.168.0.100;
62. Clique em Continue;
63. Selecione a marca da impressora;
64. Clique em Continue;
569
65. Selecione o modelo da impressora;
66. Clique em Add Printer;
67. Configure os detalhes da impressora, tais como tipo de papel, modelo de

impressora (colorida ou preto e branco), origem do papel etc.;
68. Clique em Setting Options;
69. Verifique se a impressora foi criada e clique em Printers.
Laboratório 13 - Gerenciando via linha de comandos

70. Verifique os drivers que o CUPS suporta;
# gs -h
71. Verifique se o serviço está no ar e o estado das impressoras;
# lpstat -t
72. Envie um trabalho para uma impressora (no código a seguir, onde lê-se impressora,
use uma impressora da lista);
# lp -d[impressora] /etc/passwd
73. Verifique a fila de impressão;
# lpstat
74. Verifique o status detalhado das impressoras.
# lpstat -a
570
Laboratório 14 - Lendo arquivos de configuração
do CUPS
75. Verifique o arquivo de configuração do CUPS;
# cat /etc/cups/cupsd.conf
76. Observe as impressoras disponíveis;
# cat /etc/cups/printers.conf
77. Verifique as configurações das impressoras.
# lpoptions
571
10 Fundamentos
de rede
ÃÃ Introdução a redes de computadores;

ÃÃ Conceitos e serviços de rede TCP/IP;
ÃÃ Configuração de rede.
Este capítulo faz parte do tópico 109 – Networking Fundamentals da segunda

Você precisará estar apto a configurar uma rede básica, utilizando o protocolo
TCP/IP.

Para o mercado de trabalho, o gerenciamento de rede e resolução de problemas

são essenciais para o administrador de sistemas GNU/Linux. Tenha um bom
entendimento e domínio dos comandos de rede e dos respectivos arquivos de
configuração.
10.1. Introdução a rede de computadores

Uma rede é constituída por dois ou mais computadores e/ou dispositivos conectados
por um meio específico, estabelecendo assim uma comunicação e troca de informações,
ou também disponibilizando serviços.
A conexão entre os computadores de uma rede pode ser unificada por meio de
conectores, cabos, ondas de rádio e centralizadores. Uma comunicação poderá
ser estabelecida permitindo que todos os computadores participantes dessa rede
compartilhem informações ou acessem serviços disponibilizados para uso distribuído.
Sendo assim, o uso de tais serviços e o acesso a informações compartilhadas podem ser
administrados de maneira centralizada, economizando gastos e melhor gerenciando
os computadores presentes na rede.
Para que essa conexão e as vantagens que ela traz sejam possíveis, deve haver um
bom funcionamento tanto dos componentes de uma rede (cabeamento, adaptadores
de rede e protocolos) como de seus integrantes (servidor, cliente, host, local host,
remote host e gateway). Neste capítulo, aprenderemos mais sobre esses e outros
aspectos da rede, como a configuração de redes Linux e o monitoramento e a
reparação de problemas apresentados por elas.
574
Fundamentos de rede 10
10.1.1. Componentes básicos de uma rede
Para que uma rede de computadores possa estar acessível, necessitamos de um bom
funcionamento de seus respectivos componentes, que irão variar conforme o tipo de
tecnologia adotada. Os componentes básicos para o bom funcionamento de uma rede
são: cabeamento, adaptadores de rede e protocolos. A seguir, aprenderemos mais
sobre eles.
10.1.1.1. Cabeamento
Atualmente, o componente cabeamento é utilizado apenas para referenciar o tipo de
conexão física entre computadores em uma rede. No início, tínhamos apenas cabos
fazendo a interconexão entre esses computadores; agora, contamos também com
a tecnologia Wi-Fi de transmissão de dados via ondas de rádio ou outros meios de
comunicação sem fio como o Bluetooth.
Com a evolução da tecnologia, os tipos de cabos passaram por melhorias que

aumentaram o desempenho e flexibilidade de uma rede. Entre os tipos de cabeamento
mais comuns, temos o antigo cabo coaxial, ainda muito utilizado nas conexões de
antenas wireless, o cabo do tipo par trançado, que é o padrão utilizado atualmente, e
cabos de fibra óptica, que fornecem uma alta taxa de transferência de dados e possuem
um custo mais elevado. Existem, ainda, as tecnologias sem fio, disponibilizadas pelo
padrão Wi-Fi e seus derivados.
10.1.1.2. Adaptadores de redes
A conexão estabelecida entre computadores em uma rede por seu meio físico de
interconexão se dará pelo componente básico, que é o adaptador de rede. Sobre os
adaptadores de rede e suas respectivas tecnologias, temos:
•• Ethernet: Além de ser um padrão criado e homologado pela IANA (Internet

Assigned Numbers Authority) para conexão de dispositivos, também é utilizado
para referenciar o meio de tecnologia de interconexão. É atualmente a tecnologia
padrão para conexões de computadores em uma rede, amplamente utilizada
para conexões físicas de cabeamentos do tipo par trançado e wireless;
•• FDDI (Fiber Distributed Data Interfaces): Utilizado para conexões de alto

desempenho, como o cabeamento de fibra óptica;
•• Token Ring: Originalmente criado pela IBM, em meados de 1980, para conexões
com topologia em anel;
•• CciTT X.25: Utilizado em conexão via RENPAC (disponibilizado no Brasil).
575
10.1.1.3. Protocolos
Para que os computadores de uma rede possam se comunicar, além da estrutura
física mencionada, também será necessário um protocolo de comunicação, o qual é a
base para que um computador possa estar ativo na rede e disponível para conexões.
Ou seja, o protocolo é o componente essencial para disponibilizar acessos e trocas de
informações pelos computadores em uma rede.
10.1.2. Integrantes de uma rede

Assim que uma rede é composta por seus componentes básicos e essenciais, é
possível definir seus integrantes e participantes com alguns conceitos referenciais.
Os integrantes a seguir compõem uma rede; por meio dos termos citados, é possível
referenciá-los melhor.
•• Host
Host é qualquer máquina ou equipamento que faz parte de uma rede. O host pode
ser servidor ou cliente.
•• Servidor
O conceito e a função básica de um servidor é disponibilizar serviços. Ele não é

necessariamente um computador ou um mainframe (computador de grande porte),
mas sim qualquer tipo de equipamento que disponibiliza de alguma forma recursos
e serviços em uma rede.
A seguir, alguns exemplos de tipos de servidores:
•• Servidor de impressão;
•• Servidor de Internet (Proxy);
•• Servidor de arquivos.
•• Cliente
Utiliza algum tipo de serviço ou recurso disponível por algum servidor. Não é
necessariamente um computador, mas sim qualquer tipo de equipamento conectado
à rede, como um celular, por exemplo.
576
•• Local host
O local host, ou máquina local, refere-se ao equipamento em que o usuário está

trabalhando e acessando de forma direta em um determinado momento.
•• Remote host
O remote host, ou máquina remota, é também um integrante de uma rede, porém de

uma rede que está sendo acessada e controlada por meio de recursos remotos – a
partir de um local host, por exemplo.
•• Gateway
O gateway realiza o transporte de pacotes TCP/IP para redes não identificadas pelos
próprios hosts que originaram o pacote. Isso permite que esses pacotes cheguem
a uma rede WAN partindo de uma rede privada. Com o gateway, os pacotes podem
transitar por uma rede fechada ou pela Internet. Geralmente, os hosts possuem
configurações como máscara e classe de IP iguais em uma rede local. Neste caso, o
gateway é o próprio computador nesse tipo de rede.
10.1.3. Identificando os integrantes de uma rede

Independentemente do tipo de integrante de uma rede e de seu respectivo adaptador
de conexão, é preciso identificá-los de forma única, permitindo seu acesso ou
reconhecimento dentro da rede. Assim, cada integrante de uma rede terá seu
respectivo endereço de identificação, sobre o qual temos:
•• Endereço físico
O endereço físico de um adaptador de rede é montado de acordo com a notação

binária e hexadecimal. Ele é único, e as faixas de endereços são distribuídas para os
fabricantes de hardware. Sua identificação é feita com seu endereço físico ou endereço
MAC (Media Access Control).
•• Endereçamento por protocolo
Por meio do protocolo de rede utilizado, é possível definir um endereçamento lógico

para cada integrante da rede a fim de identificá-lo, assim também como a própria
rede.
577
10.1.4. Protocolos de rede
Em uma rede, para que um computador estabeleça uma comunicação com outro
computador, é necessário que haja um protocolo de rede. Alguns desses protocolos
são projetados especificamente para determinados tipos de rede: em redes de
pequeno porte, utilizamos protocolos como NetBios; em redes mundiais, utilizamos
protocolos de roteamento, como o TCP/IP.
Apesar de haver muitos outros protocolos, o mais utilizado atualmente é o TCP/IP,

fato que se deve, além da capacidade de roteamento, à sua velocidade e também ao
projeto em si. Nos próximos subtópicos, conheceremos mais a respeito desse e de
outros protocolos utilizados no Linux.
Os protocolos de rede estão catalogados tecnicamente em documentos chamados de RFC

(Request for Comments). Um RFC é um documento técnico contendo toda a documentação
e especificações sobre o funcionamento do protocolo desejado. O documento RFC dos
protocolos pode ser consultado no seguinte site: www.rfc-editor.org.
10.1.5. TCP
O TCP (Transmission Control Protocol) é um protocolo da camada 4 (camada de
transporte) do modelo OSI. A principal característica desse protocolo é verificar e
controlar erros dos pacotes que serão entregues pela rede. As aplicações que
necessitam de confiabilidade na entrega dos dados pela rede utilizarão esse protocolo
como base no seu transporte.
Os dados transmitidos são divididos em pacotes. Cada pacote conterá um cabeçalho

com um conjunto de informações que serão transmitidas com o pacote, garantindo,
assim, a confiabilidade dos dados entregues. A seguir, temos um breve resumo do
cabeçalho TCP.
O TCP tem características e funcionalidades especiais, conforme veremos a seguir:
•• Handshake
Para que uma conexão seja estabelecida entre dois pontos, é preciso que haja um
controle do estabelecimento até a finalização da conexão. Assim, tal conexão poderá
ter uma autenticação e um processo de verificação dos dados transmitidos. Tal
mecanismo é possível devido ao Handshake, o qual, por meio do processo de três a
quatro tempos, poderá iniciar, manter e finalizar uma conexão TCP.
578
•• Portas TCP
As portas do protocolo TCP são utilizadas para permitir que múltiplos serviços sejam
executados simultaneamente. Elas compõem um número de 16 bits, totalizando
65.536 portas. Tais portas possuem uma padronização que é determinada pelo órgão
IANA. Algumas regras sobre as portas foram definidas por este órgão; são elas:
•• Porta 0: Não utilizada para interconexão de computadores. Esta porta é

utilizada pelos sistemas operacionais Unix para comunicação local (PF_
LOCAL);
•• Portas bem conhecidas: Portas que abrangem o intervalo 1 até 1023 e

que foram determinadas para serviços bem conhecidos, como SSH(22),
WWW(80), FTP(21), entre outros;
•• Portas Livres: Estas portas são utilizadas livremente pelos programadores

para qualquer propósito de aplicação. As portas livres estão no intervalo
de 1024 até 65.535.
No Linux, as portas de saída estão em uma faixa atribuída dinamicamente a partir

da porta 32.000.
•• Controle de flags
O processo de Handshake acontece devido a uma sequência de flags específicas que

são enviadas desde o início até o fim da conexão. Na tabela a seguir, são apresentados
os tipos de flags:
Código Flag
10 User Point
11 Acknowledgement
12 Push
13 Reset
14 Syncronize
15 Finalize

579
A imagem adiante ilustra a comunicação entre dois hosts:
10.1. Exemplo de uma comunicação entre dois hosts (Three Way handshake)
Veja como os elementos apresentados na imagem anterior são descritos:
•• SYN: Flag responsável pelo início da conexão, para a qual o cliente envia
um SYN ativo e aguarda pela confirmação de recebimento do servidor.
Caso a porta, na qual há uma tentativa de conexão, esteja fechada, uma
flag RST é enviada como resposta, e o processo de tentativa de conexão
será finalizado imediatamente. Há, também, um tempo limite de espera na
confirmação de recebimento da flag SYN. Caso a porta esteja disponível,
se o tempo limite for ultrapassado, um timeout é gerado, e a flag SYN é
enviada novamente;
•• SYN+ACK: Seguindo a ilustração anterior, SYN+ACK é a resposta enviada

pelo servidor sobre o recebimento da flag SYN. Assim que a flag SYN+ACK
é enviada, uma confirmação sobre seu recebimento também deverá ser
aguardada, para que a transferência de dados possa ser iniciada;
•• ACK: A flag ACK poderá ser utilizada para situações distintas: como uma
confirmação de que a flag SYN+ACK foi recebida com sucesso, e como
auxílio na entrega dos dados após a conexão estabelecida, confirmando
cada pacote recebido com sucesso;
•• FIN: Flag responsável pela finalização da conexão por ambas as partes.

Assim que os dados são devidamente entregues pela sessão TCP, a
conexão é terminada. A flag FIN é enviada por ambas as partes e seu
recebimento deverá ser confirmado.
580
•• Segurança
O método de confirmação e recebimento de cada pacote enviado em uma sessão

TCP proporcionará um alto nível de confiabilidade sobre os dados transmitidos. Essa
é uma de suas grandes vantagens em relação ao protocolo UDP, além de ser um
dos motivos de seu uso abrangente em redes de grande porte, como a Internet. O
TCP, com seu sistema de tratamento na transmissão dos pacotes, poderá verificar
e recuperar dados corrompidos, restaurar conexões, caso algum problema na rede
tenha interferido no processo de comunicação, recuperar pacotes perdidos e, até
mesmo, descartar pacotes duplicados.
•• Full-duplex
Em uma conexão TCP, é possível transferir dados simultaneamente em ambas as

direções (servidor-cliente e cliente-servidor), em todo o processo de conexão.
•• Sequência de entrega de pacotes
Os dados que serão transmitidos a partir de uma conexão TCP chegam em um

formato de bloco de dados, geralmente com tamanhos desordenados. O TCP
redefine o tamanho dos dados em seu formato específico de pacote, conforme o
valor especificado pela MTU (Maximum Transmit Unit) e envia os pacotes em uma
sequência ordenada. Porém, o endereçador de pacotes (IP) poderá alterar a ordem de
entrega de tais pacotes. O TCP terá a função de restaurar os pacotes na sua respectiva
ordem, baseando-se no campo número de sequência, anexado a cada pacote em seu
cabeçalho.
Como exemplo de serviços que utilizam o protocolo TCP, temos o SMTP, o Telnet, o
pop3 etc.
A RFC do protocolo TCP é a 793.
10.1.6. UDP
Assim como o TCP, o UDP (User Datagram Protocol) também é um protocolo de
transporte. Suas funções são similares, porém, o UDP não controla o fluxo e não
detecta erros durante a comunicação. Dessa forma, não temos a garantia de que o
pacote enviado será entregue intacto.
Isso nos faz atentar para o fato de que o protocolo UDP não tem um bom desempenho
em redes de longa distância, em que o tratamento de erro, bem como a sua correção,
precisa ser realizada pelo aplicativo. Assim, o UDP é mais bem aproveitado para redes
locais.
581
No entanto, o UDP tem muitos pontos positivos, tornando-o um protocolo muito útil
em determinadas situações. Sobre algumas das características do UDP, temos:
•• Portas: Assim como no TCP, o protocolo UDP também utiliza as definições de

portas para determinar um ponto de acesso ao serviço que utilizará os recursos
do protocolo. A porta de destino e a porta de origem são campos do simples
cabeçalho UDP e têm 16 bits de tamanho. Logo, temos 65.536 (2^16) portas
UDP que poderão ser utilizadas como ponto de acesso aos serviços;
•• Não orientado à conexão: O protocolo UDP não controla o fluxo de uma

conexão. Portanto, é conhecido por não manter uma conexão no envio dos
dados, descartando o uso de mecanismos que gerenciam uma conexão, bem
como vários outros tipos de controles apresentados pelo protocolo TCP. Trata-
se de uma ótima escolha para fluxos de dados em tempo real, principalmente
para aplicações que suportam a perda de parte dos dados enviados em uma
comunicação. Aplicações de vídeo e voz são grandes exemplos de utilização do
protocolo UDP;
•• Broadcast e Multicast: O UDP é necessariamente utilizado caso os recursos de

broadcast e multicast sejam requeridos. Algumas aplicações multicast admitem
perda de parte dos dados enviados ou fazem retransmissões automáticas, como
no exemplo do DHCP.
Outros exemplos de serviços que utilizam o protocolo UDP são: NCS, DNS, SNMP e
TFTP.
A RFC do protocolo UDP é a 768.
10.1.7. ICMP
O ICMP (Internet Control Message Protocol) é um protocolo cuja implementação ocorre
juntamente ao IP, mesmo que eles não possuam as mesmas funções.
A função do ICMP é informar os erros que ocorreram durante o processamento de

um pacote IP, porém, ele apenas registra e exibe esses erros; cabe ao administrador
optar por corrigi-los ou não. A tabela a seguir mostra quais são os principais erros
informados pelo ICMP:
Tipo de erro Mensagem apresentada

0 Echoreply
3 Destination Unreachable
5 RedirectMessage
8 Echo Request
582
A RFC do protocolo ICMP é a 792.
10.1.8. O protocolo TCP/IP

O TCP/IP é, na verdade, um conjunto de protocolos. Essa sigla corresponde a
Transmission Control Protocol / Internet Protocol, isto é, Protocolo de Controle de
Transmissão / Protocolo de Internet. Os principais protocolos que compõem o TCP/IP
são justamente o TCP e o IP. Cada um deles possui um nível, a saber:
•• TCP: Nível de transporte;
•• IP: Nível de rede.
Os dados que trafegam em uma rede TCP/IP são divididos em pacotes. Isso é
importante porque possibilita que tanto os recursos de rede sejam compartilhados
como os erros sejam detectados e, consequentemente, corrigidos.
Suponhamos que os dados não sejam divididos em pacotes, e que o recurso utilizado
para enviar esses dados seja um servidor de arquivos. Quando um usuário realizar
o envio de suas informações como sendo apenas um pacote, o servidor não poderá
ser utilizado pelos demais usuários até que esse pacote que está trafegando seja
entregue ao seu destino.
Se esse único pacote for dividido em vários, os usuários poderão enviar todos os seus
pacotes, que serão recebidos pelo servidor de forma alternada. Desse modo, a rede é
compartilhada por todos os usuários ao mesmo tempo.
Quando uma informação é dividida em pacotes, ela passa a ser constituída pelo
cabeçalho e pela parte de dados; dentre outras, esta parte contém as informações a
respeito do pacote que está trafegando na rede.
O transporte de um pacote ocorre da seguinte maneira: quando a mensagem chega

ao seu destino, as informações do cabeçalho são comparadas aos dados que já
estão no destino. Será enviada, em retorno à máquina de origem, uma mensagem
de confirmação. Caso essa mensagem não seja recebida pela origem, o pacote é
reenviado após um determinado tempo.
A RFC do protocolo IP é a 791.
583
10.1.9. Endereçamento IP
O IP (Internet Protocol) é um protocolo de endereçamento que possibilita a criação
de redes, dando endereços a cada estação participante, de modo que o tráfego de
dados seja direcionado para um ou outro participante, de acordo com seu endereço.
No modelo OSI, o protocolo IP se enquadra na camada 3 (camada de rede).
Em suma, as funções principais do IP são endereçar cada computador participante de

uma rede e endereçar redes por meio de um sistema de roteamento.
O endereçamento da Internet dispensa o servidor DNS, servidor este que possibilita a

utilização de nomes, e não de números, para navegar na Internet. Existem dois tipos
de endereços IP: privados e públicos. Enquanto usamos os endereços privados em
redes privadas (LANs e WLANs, por exemplo), os endereços públicos são utilizados
para a Internet.
Com os recursos do IP, podemos criar dois tipos de rede:
•• LAN (Local Area Network): Uma rede local, caseira ou em um escritório;
•• WAN (Wide Area Network): Uma rede expandida, normalmente formada por
várias LANs.
Atualmente, utilizamos o IPv4, cujo nome deve-se ao formato de seu endereço: quatro
octetos com valores decimais. Um octeto é um número composto por 8 bits. Podemos
encontrar alguns exemplos na tabela a seguir:
Decimal Binário
192 11000000
168 10101000
19 00010011
5 00000101
No dia a dia, utilizamos apenas o formato decimal, mas para entender esse protocolo,
é extremamente necessário compreender a forma binária. Sendo assim, o maior
número decimal que podemos ter em um octeto é 255 que, em formato binário, é
11111111.
A RFC do protocolo IP é a 791.
584
10.1.10. Classes IP
Os endereços IP são divididos em cinco classes: A, B, C, D e E. Essa divisão se dá, entre
outros motivos, pela própria notação binária, que é modificada conforme os números
aumentam. Na classe A, todos os endereços entre 1 e 127, quando binários, iniciam
em 0; na classe B, todos os endereços entre 128 e 129, quando binários, são números
iniciados em 10; na classe C são 110, na classe D são 1110 e na classe E são 11110.
10.1.11. Endereços especiais
O primeiro e mais comum endereço especial é o 127.0.0.1, chamado de loopback.
Qualquer sistema que suporte o protocolo IP possui esse endereço, que é utilizado
para acessar serviços de rede no próprio computador. Ele é atribuído a uma interface
virtual de rede, como se fosse uma placa de rede.
Além disso, toda rede tem três informações básicas: o endereço da rede, o endereço
de broadcast (fim da rede) e as estações. Essa informação será esclarecida a seguir,
com as máscaras de rede.
Nem todos os endereços das classes são utilizados na Internet. Alguns, em cada
classe, foram separados para a criação de redes locais e nunca existirão na Internet.
Na tabela a seguir, são indicados os endereços de início e de fim das classes A, B e C:
Classe Início Fim

A 10.0.0.0 10.255.255.255
B 172.0.0.0 172.255.255.255
C 192.168.0.0 192.168.255.255
Sendo assim, são os fornecedores de link que fornecem os IPs ou até as classes de
um link de acesso à Internet. Já na rede local, devemos utilizar os endereços da tabela
anterior, que não são válidos na Internet.
Para mais informações sobre classes de IP válidos ou domínios, basta consultar o site
www.registro.br.
585
10.1.12. Máscaras de rede
Na configuração de uma rede, cada comutador deve possuir um endereço IP e uma
máscara de rede. Apesar da divisão das classes mencionadas anteriormente, é a
máscara de rede que define qual é a rede e o broadcast de um host, a partir do
endereço IP.
As classes A, B e C possuem máscaras de rede padronizadas.
Classe Máscara
A 255.0.0.0
B 255.255.0.0
C 255.255.255.0
Podemos imaginar a configuração de uma rede de apenas dois computadores,

utilizando endereços da classe C, da seguinte maneira:
•• Computador A: IP 192.168.0.1 e máscara 255.255.255.0;
•• Computador B: IP 192.168.1.2 e máscara 255.255.255.0.
Ao atribuir essas informações à placa de rede, o sistema operacional determinará qual

é a rede e qual é o broadcast, por meio de uma operação matemática binária chamada
E (ou AND).
Em uma operação E, é executado o cálculo por meio de valores binários para determinar
se hosts com suas respectivas máscaras estão na mesma rede. O cálculo E por meio
de valores binários se dá pela seguinte regra:
1010
1100
------
1000
Logo, podemos concluir que o resultado só poderá ser 1 quando os valores de

comparação forem iguais a 1, conforme mostra a tabela a seguir:
IP 192 168 0 1
Máscara 255 255 255 0
Rede 192 168 0 0
Broadcast 192 168 0 255
586
Sendo assim, o endereço IP 192.168.0.1, com a máscara 255.255.255.0, pertence à
rede 192.168.0.0, com broadcast 192.168.0.255. Se o mesmo cálculo for aplicado
ao computador B, este irá pertencer agora à rede 192.168.1.0, com broadcast
192.168.1.255.
Não há restrições na utilização de uma máscara de rede em relação a um endereço

IP; um endereço de rede classe B pode ser utilizado com máscara de classe C e vice-
versa.
10.1.13. Broadcast
O termo broadcast (transmitir) é utilizado para o envio ou difusão de uma determinada
informação em grande escala. Sua base e principal característica é o envio das
informações para vários receptores ao mesmo tempo.
Por meio do endereçamento IP e da utilização de máscaras, é possível definir o escopo

da rede (início e fim). Temos o broadcast, utilizado para indicar o último endereço IP
de determinada rede, o qual será utilizado para se comunicar de forma direta com
todos os hosts pertencentes à mesma rede.
10.1.14. Multicast
O multicast também é conhecido como multicast IP. Trata-se de uma forma de
comunicação e difusão da informação, porém, o multicast é conhecido como um
broadcast controlado, o qual propagará determinada informação aos hosts de
interesse.
10.1.15. ARP
As interfaces de uma rede são identificadas pela camada de comunicação ARP (Address
Resolution Protocol), sobre a qual os dados trafegam na camada IP. A conexão é
promovida pelo ARP, uma vez que o mapeamento de endereços IP para endereços
MAC do dispositivo de comunicação é feita nele.
Um pedido ARP é enviado, pelo kernel, para a interface de rede após a conexão ser
solicitada. Isto é, temos a solicitação do endereço MAC do endereço IP da conexão a
ser realizada. A resolução MAC – IP, por sua vez, depende do protocolo RARP (Reverse
Address Resolution Protocol) para ser realizada.
587
10.1.16. Network Address Translation (NAT)

Temos, na implementação do NAT (Network Address Translation), uma solução
temporária com a qual um endereço IPv4 único e roteável em qualquer lugar é
compartilhado por vários computadores de uma rede privada. Ele remedia, de certa
forma, o esgotamento de endereços IPv4 enquanto o IPv6 não é implementado.
Padrão da IETF (Internet Engineering Task Force), o NAT permite que um número
menor de endereços IPv4 públicos sejam necessários para o estabelecimento de
conexão com a Internet.
Para entender a outra implicação do NAT, devemos antes compreender o que é

um tráfego solicitado. Imaginemos a seguinte situação: uma página da Internet é
acessada por um computador de host privado. Os conteúdos dessa página são, então,
solicitados a partir de um servidor da Internet – a esse tráfego damos o nome de
tráfego solicitado.
Com o NAT, os hosts de redes privadas recebem apenas o tráfego solicitado,

encaminhado por ele, que oferece, dessa forma, uma função de filtragem de pacote
simples.
10.1.17. IPv6
O endereçamento IPv6, substituto do IPv4, é uma evolução em que são utilizados
endereços de 128 bits, em vez de 32 bits.
O número de um endereço IPv6 é significativamente maior, com muito mais casas

decimais do que o modelo anterior (IPv4), visando justamente evitar que uma nova
substituição seja necessária no futuro.
Como podemos perceber, o IPv6 é bem diferente do IPv4 em vários aspectos. Vejamos,
a seguir, alguns deles:
•• Enquanto a quantidade de bits no IPv4 é 32, no IPv6 é 128, o que dá 340.282.

366.920.938.463.374.607.431.768.211.456 endereços válidos para utilização,
aproximadamente;
•• A estrutura do endereçamento é diferente. O endereço IPv6 é formado

por 8 conjuntos de 4 dígitos hexadecimais, e possui duas partes lógicas:
uma de 64 bits, para a rede, e outra de 64 bits para o host (um exemplo é
2394:3756:A34C:FAC9:9021:0000:FF3A:9671);
•• Apesar de não ser uma prática obrigatória, a parte do endereçamento do host

pode ser gerada a partir da inserção do endereço MAC da interface de rede;
•• Não existem classes de endereços no IPv6, como A, B, C, D ou E.
588
Há compatibilidade entre o IPv4 e o IPv6, já que o IPv6 pode conter o IPv4, como
em 192.168.0.1. Dessa forma, 96 bits são utilizados para o endereço IPv6 e os 32
bits restantes são utilizados para o IPv4, o que garante interoperabilidade durante a
migração das redes.
Vale lembrar, no entanto, que esse meio de identificação de hosts já não é utilizado,
e implementações modernas não têm a obrigação de aceitá-lo. Maiores informações
sobre este tipo de endereçamento podem ser consultadas na RFC 4038.
10.2. Conceitos e serviços de rede TCP/IP

Para que seja possível a realização da transmissão de dados numa rede, são
necessários diversos protocolos, que efetuam a comunicação entre duas máquinas.
Esses protocolos podem ser vistos como a linguagem com a qual as máquinas se
comunicam. Isso torna possível a transmissão de informações entre elas. Vejamos a
seguir os principais protocolos de rede:
•• IP (Internet Protocol): Protocolo base utilizado pelos protocolos TCP, UDP e

ICMP para endereçamento;
•• TCP (Transfer Control Protocol): Protocolo de controle da formatação e

integridade dos dados transmitidos;
•• UDP (User Datagram Protocol): Funciona do mesmo modo que o TCP, porém o
controle sofre intervenção da aplicação;
•• ICMP (Internet Control Message Protocol): Permite a comunicação entre

roteadores e hosts, para que identifiquem e relatem o estado de funcionamento
da rede.
A cada serviço de rede – o FTP, o HTTP e o SMTP são alguns deles – é atribuída
uma porta específica, determinada pelos protocolos de rede. Assim, a transmissão de
dados é feita por uma porta definida, em um endereço conhecido de uma máquina
na rede.
Os números corretos de portas devem ser estritamente respeitados por todos os

computadores interligados, seguindo à risca a determinação da lista oficial de portas
e serviços associados da IANA (Internet Assigned Number Authority). Essa lista é
disponibilizada para livre consulta no site http://www.iana.org/assignment/port-
numbers.
O arquivo /etc/services armazena a lista de serviços conhecidos e suas respectivas

portas, que são campos de 16 bits, fazendo com que a quantidade máxima disponível
de portas seja de 65.535.
589
A seguinte tabela nos mostra as principais portas de serviço IP no Linux:
Porta Serviço
20 FTP (porta de dados)
21 FTP
22 SSH
23 Telnet
25 SMTP
53 DNS
80 HTTP
110 POP3
119 NNTP (Usenet)
139 Netbios
143 IMAP
161 SNMP
443 HTTPS
465 SMTPS
993 IMAPS
995 POP3S
10.2.1. Serviços de rede
Os serviços tipo inetd e xinetd são aqueles que dependem do superdaemon de
rede inetd (Internet daemon). O xinetd (extended Internet daemon) fornece alguns
recursos além daqueles que o inetd provê, como, por exemplo, controle de acesso,
capacidade de fazer logs e de determinar horários para a disponibilidade do serviço.
Tanto o inetd como o xinetd são ativados no momento em que ocorre a inicialização
do sistema. São eles os responsáveis por realizar o monitoramento das portas de
serviços. Desse modo, assim que é solicitada uma conexão em uma das portas que
o inetd ou o xinetd monitoram, uma instância do serviço requerido é executada. Em
seguida, a conexão é transmitida e controlada pelo serviço em questão.
Podemos perceber, nesse cenário, que os daemons inetd e xinetd impedem que
vários serviços sejam ativados no momento da inicialização do sistema. Isso evita
que os serviços utilizem os recursos da máquina desnecessariamente, visto que não
estariam ali ativos apenas aguardando por uma conexão.
590
Como outra função dos superdaemons, temos que eles controlam acessos e também
realizam o envio de mensagens ao serviço de log do sistema.
Veremos, a seguir, como se dá a configuração de cada um dos superdaemons.
10.2.2. Configurando o inetd
O inetd possui dois arquivos de configuração: o /etc/inetd.conf e o /etc/services.
O /etc/inetd.conf é o arquivo de configuração do inetd. Para configurar esse
daemon, podemos tanto incluir quanto excluir serviços no arquivo /etc/inetd.conf
manualmente. Isso só é possível porque o arquivo /etc/services já possui uma
descrição do serviço que será controlado. É neste último arquivo que encontramos a
lista de serviços conhecidos e suas respectivas portas.
Para ativarmos as alterações realizadas no arquivo de configuração, devemos executar

um dos seguintes comandos:
# /etc/init.d/inetd restart
Ou:
# killall -1 inetd
A ativação das alterações é realizada após o arquivo de configuração ser salvo.
O arquivo /etc/inetd.conf é apresentado com sete colunas e uma linha para cada
serviço. A próxima tabela mostra quais são essas colunas, juntamente com suas
respectivas descrições:
Nome da coluna Descrição

Possui o nome do serviço. Este, contudo, deve ser igual ao
Serviço
nome localizado no /etc/services.
Indica o tipo de socket que a conexão utiliza: stream para
Socket
sockets TCP e dgram para sockets UDP.
Coluna em que o protocolo utilizado pelo serviço é
Protocolo especificado. É importante verificá-lo no arquivo /etc/
protocols.
A informação desta coluna aplica-se aos sockets do tipo
datagram (dgram). Os dois tipos possíveis são wait ou
nowait, os quais especificam se o inetd deve esperar ou
Espera
não o daemon controlado retornar para continuar aceitando
conexões. Para sockets do tipo stream, o campo espera é
definido como nowait.
591
Nome da coluna Descrição

Esta coluna indica sob qual usuário será realizada a ativação
Usuário
do serviço.
Apresenta o nome completo do programa pelo qual o serviço
Programa
é controlado.
Nesta coluna são especificados os argumentos que serão
Argumentos
transmitidos ao programa da coluna anterior.
Ainda em relação à coluna Programa, em alguns serviços é executado o /usr/sbin/

tcpd, ou seja, um TCP wrapper. Após verificar se há uma autorização para o host
estabelecer uma conexão, o TCP wrapper executa o programa que faz o controle
do serviço. É importante saber que, por padrão, qualquer solicitação de conexão
realizada por qualquer máquina pertencente à rede é aceita pelo TCP. Porém, quem
autoriza a conexão é o TCP wrapper.
A seguir, temos um exemplo de configuração do arquivo inetd.conf para liberar

acesso ao servidor FTPD:
10.2.3. Configurando o xinetd
O daemon xinetd possui algumas vantagens que o inetd não possui. Vejamos algumas
delas:
•• O controle sobre as conexões é maior;
•• Possui recursos de máquina, de redirecionamento, de acesso e de interface.
Adicionalmente, o design do xinetd é mais flexível, na medida em que os arquivos de

configuração secundários encontram-se separados dos arquivos principais. Ainda, a
sintaxe desses arquivos encontra-se definida em uma melhor disposição.
Geralmente, as alterações necessárias são realizadas nos arquivos secundários, que

estão no diretório /etc/xinetd.d/, no qual cada serviço que será controlado tem seu
respectivo arquivo de configuração e controle. Com isso, não se fazem alterações
diretas no arquivo de configuração principal /etc/xinetd.conf.
592
O conteúdo do diretório /etc/xinetd.d/ corresponde a um arquivo por serviço, e
os nomes desses arquivos são iguais aos nomes dos serviços que os definem. Além
disso, cada arquivo possui as características para o serviço respectivo. A sintaxe
utilizada pode ser vista a seguir:
service <servico>
{
<parametro> <operador> <valor>
...
}
Em que:
•• O item <servico> necessariamente tem que ser igual ao nome que foi especificado
no arquivo /etc/services;
•• <parametro> é utilizado para determinar como será realizada a execução do

serviço, em que:
•• disable: Desabilita o controle do serviço pelo xinetd caso o valor seja yes;
•• protocol: Indica o tipo de protocolo que o serviço utiliza (TCP ou UDP);
•• socket_type: Indica o tipo de socket utilizado conforme o protocolo

escolhido (stream ou dgram);
•• user: Indica o nome do usuário no qual o serviço será ativado;
•• wait: Indica se o socket irá aguardar ou não o serviço retornar para novas
conexões (yes ou no);
•• server: Indica o nome e caminho completo do programa pelo qual o

serviço é controlado;
•• access_times: Indica um intervalo de tempo, em horas, durante o qual o

serviço poderá ser acessado (por exemplo: 11:00 – 15:00);
•• instances: Indica o número máximo de serviços que poderá ser inicializado

pelo xinetd sobre o daemon controlado.
•• O item <operador> tem as seguintes opções: =, -= ou +=;
•• <valor> corresponde a uma lista de valores. Estes, contudo, variam de acordo

com o parâmetro utilizado no item <parametro>.
593
Ainda em relação aos parâmetros, temos alguns similares às colunas existentes no

inetd.conf. São eles: socket_type, server, user e wait. Temos ainda a opção disable
como descrita anteriormente, cuja configuração pode ser yes, para desabilitar o
serviço, ou no, para habilitar.
Apesar de possuir alguns parâmetros específicos de controle de acesso, o xinetd

também pode utilizar os recursos disponibilizados pelo TCP wrapper.
A seguir, temos um exemplo de configuração do xinetd.conf, em que é ajustado com

o serviço do servidor Telnet:
10.2.4. Telnet
O telnet (Telnet) é um aplicativo utilizado para acesso remoto. É um serviço que deve
ser utilizado com muita cautela, pois gera no sistema algumas falhas de segurança
quando utilizado de forma não controlada.
Para que uma conexão remota possa ser efetuada por meio do telnet, é preciso que o
daemon do telnet (telnetd) esteja instalado na máquina que será acessada e o cliente
Telnet esteja instalado na máquina que será utilizada para fazer o acesso remoto.
O telnet é uma aplicação que será controlada de forma direta pelo superdaemon
inetd ou xinetd, caso instalada. Sendo assim, terá um controle de execução em que
somente será carregado quando houver uma solicitação de conexão em sua porta
padrão, que é a porta 23.
594
Uma vez que o servidor Telnet (telnetd) esteja instalado na máquina que será acessada
remotamente, utilizamos o comando telnet para que o cliente possa se conectar ao
servidor Telnet. Para tal, utilizamos a seguinte sintaxe:
telnet [opcoes] [ip ou nome_do_host] [porta]
As principais opções do comando telnet são descritas na tabela a seguir:
Opção Descrição
Faz com que a conexão seja estabelecida por meio de resoluções
-4
de endereços IPv4.
Faz com que a conexão seja estabelecida por meio de resoluções
-6
de endereços IPv6.
Realiza uma tentativa de logon no sistema de forma automática.
-a O nome de usuário enviado para autenticação é o nome de
usuário armazenado na variável de ambiente USER.
-d Habilita o modo debug.
Especifica o nome de usuário que será utilizado para tentar
-l <usuario>
estabelecer a conexão.
Configurações em equipamentos específicos de rede são comumente realizadas por

meio do telnet, que também elimina a necessidade de programas cliente para testar
o funcionamento de serviços.
Certos aspectos devem ser considerados em relação à utilização do serviço:
•• Um número considerável de vulnerabilidades têm sido descobertas nas

implementações do telnet ao longo dos anos, e existe grande probabilidade de
novas ainda serem descobertas;
•• Como padrão, não existe criptografia nos dados enviados, inclusive para
usuários e senhas;
•• O telnet pode facilitar ataques do tipo man-in-the-middle, pois não possui

um esquema de autenticação que nos garanta a comunicação entre as partes
envolvidas.
Para configurar um servidor Telnet, é necessário primeiramente instalar o pacote

telnetd, como mostrado a seguir:
# aptitude install telnetd
595
Em seguida, devemos reiniciar o xinetd:
# /etc/init.d/xinetd restart
Agora, é preciso executar o comando telnet – utilizar o endereço IP do servidor Telnet

– para que o computador cliente Telnet possa se conectar ao servidor Telnet. Isso é
feito no computador cliente.
# telnet <endereço_IP>
No exemplo adiante, utilizamos o comando telnet com a opção –l para já definir o

usuário a ser conectado. O sistema, então, pede a senha e o login é autorizado. Por
fim, temos o shell permitido para o usuário.
10.3. Configuração de rede
Todo o processo de configuração da rede Linux pode ser executado de forma dinâmica,
usando comandos específicos, ou de maneira estática, por meio de arquivos de
configuração. A diferença entre as configurações é que, na configuração dinâmica, as
definições poderão se perder após a reinicialização do sistema. Já nas configurações
estáticas, é possível definir uma configuração permanente.
Os dois métodos de configuração serão apresentados a seguir por meio dos comandos
e arquivos de configuração específicos.
596
10.3.1. Verificando o status da interface de rede
O comando mii-tool é uma ferramenta utilizada para verificar se as interfaces de rede
estão com seu link devidamente ativo. Ou seja, é possível verificar se o cabo está
devidamente conectado na placa de rede e se ele tem um link ativo e funcional com a
outra ponta. Ele é utilizado da seguinte forma:
# mii-tool
Para que o comando mii-tool funcione adequadamente, é necessário que o módulo

mii esteja devidamente carregado no sistema e que a placa ofereça suporte ao módulo
mii.
10.3.2. Configurando o endereço IP e a máscara

de rede
O comando ifconfig é utilizado para configurar a interface de uma rede, ou para
visualizar as configurações das interfaces de rede já definidas na máquina.
O comando ifconfig deve ser utilizado da seguinte maneira:
ifconfig [opcoes] [interface] [parametros]
O ifconfig possui as seguintes opções:
Opção Descrição
Exibe informações sobre todas as interfaces disponíveis, até
-a
mesmo de interfaces desabilitadas.
Exibe uma lista simples das interfaces e suas informações
-s
estatísticas de uso.
O comando ifconfig também aceita alguns parâmetros para tarefas específicas. A

tabela a seguir descreve esses parâmetros:
up Habilita uma determinada interface de rede.
down Desabilita uma determinada interface de rede.
Parâmetro utilizado para alterar o endereço de MAC de
hw ether
um determinado dispositivo.
597
Podemos utilizar o comando ifconfig sem a inserção de um parâmetro. Deste modo,

serão exibidas as informações referentes a todas as interfaces de rede configuradas.
No exemplo anterior, temos a visualização das informações sobre as interfaces eth0
e lo.
As principais informações que poderão ser visualizadas com o comando ifconfig são:
Informação Descrição
Endereço de HW Endereço físico da interface (MAC).
Inet end Endereço IPv4 atribuído à interface.
Endereço Inet6 Endereço IPv6 atribuído à interface.
Bcast Endereço de broadcast da rede da qual o host faz parte.
Masc Máscara de rede utilizada para definir a rede do host.
O endereço de loopback é utilizado para realizar uma conexão local com a própria
máquina, possibilitando, assim, testar nosso dispositivo de rede sem interferir na
rede local. Por padrão, o endereço de loopback é 127.0.0.1. A interface loopback é
geralmente inicializada automaticamente na inicialização do sistema por determinados
scripts.
É saudável para o sistema manter sempre a interface loopback ativa. Muitos aplicativos
utilizam referência a loopback para executar suas funcionalidades; o gerenciador de
janelas KDE é um exemplo.
Com o comando ifconfig, também é possível habilitar e desabilitar uma determinada

interface de rede. Nas próximas duas telas, a interface eth0 é inicialmente desabilitada
pela utilização do parâmetro down e, logo em seguida, habilitada com o parâmetro
up:
598
Alternativamente, podemos utilizar os comandos ifup e ifdown para,

respectivamente, habilitar e desabilitar uma determinada interface de rede.
Com o comando ifconfig, também é possível alterar as configurações atuais de uma

interface, definindo um novo endereço de rede e uma respectiva máscara. Para isso,
utilizamos o parâmetro netmask, como no exemplo a seguir:
599
É possível habilitar uma interface de rede que já está devidamente desabilitada,

atribuindo a ela seus parâmetros de funcionamento. Por exemplo:
# ifconfig eth0 172.16.26.78 netmask 255.255.255.0 up
No exemplo adiante, o endereço físico da interface eth0 foi alterado. Para se alterar o
endereço físico de um dispositivo, o mesmo deve ser desabilitado antes da execução
do processo.
É importante atentar para o fato de que todas as alterações feitas com o comando
ifconfig são meramente dinâmicas, ou seja, são perdidas após a reinicialização do
sistema.
Em distribuições Red Hat e seus derivados, é muito comum se utilizar de uma

ferramenta chamada nmtui para configurar as interfaces de rede. Para isso, basta
executar o comando e seguir as instruções apresentadas.
# nmtui
600
Quanto à verificação das interfaces configuradas, utilize o comando nmcli d.
10.3.3. Comando ip
Comandos como ifconfig, netmask, route, entre outros, fazem parte do pacote
chamado net-tools, em distribuições Red Hat e seus derivados. Nas novas
distribuições, esses comandos passaram a ser substituídos por outros, como por
exemplo o comando ip. Porém, caso você escolha continuar usando-os, basta instalar
o pacote já mencionado.
Vejamos a sintaxe do comando ip:
# ip [opcoes] [objeto] [comando]
A configuração de uma determinada interface de rede poderá ser realizada conforme

o exemplo adiante:
Definindo uma rota padrão de saída:
Para apagar o endereço IP ou a rota padrão, repita os comandos anteriores, trocando

apenas o parâmetro add por del.
10.3.4. Definindo um gateway padrão

O conceito de gateway pode ser facilmente implementado quando há a necessidade
de se navegar em redes distintas. O papel do gateway é encaminhar requisições de
conexão para redes diferentes da rede local, com uma rota de seu conhecimento.
Para definir o gateway da rede, utiliza-se o comando route, cuja sintaxe é a seguinte:
route <acao> default gw <endereco_ip> [interface]
601
A tabela a seguir descreve duas opções que podemos utilizar com route:
Ação Descrição
add Adiciona um gateway na tabela de rotas.
del Remove um gateway na tabela de rotas.
Para definirmos um gateway padrão, podemos utilizar o comando route com o

parâmetro –n. Vejamos o seguinte exemplo:
No exemplo anterior, o comando route foi utilizado inicialmente apenas para exibir a
tabela de rotas (comando route –n). Logo em seguida, foi adicionada uma rota para
o gateway 172.16.126.2 – comando route add default gw 172.16.126.2 eth0 – e foi
exibida a nova tabela de rotas.
Para que um gateway possa ser removido, basta seguir o exemplo adiante. Nele, o
gateway padrão foi removido da tabela de rotas – comando route del default gw
172.16.126.2 – e a nova visualização da tabela de rotas pôde ser visualizada com o
comando route –n.
602
10.3.5. Configurando o servidor DNS
Para que a configuração básica da rede seja finalizada, é preciso indicar um resolvedor
de nomes. O primeiro sistema de resolução de nomes implementado desde as
primeiras versões de Unix e utilizado até hoje é o recurso disponível por meio do
arquivo /etc/hosts, que tem a função de converter o nome de um computador em
um endereço IP.
A partir daí, fica mais fácil identificar um micro em uma rede local. Não há necessidade
de ter sempre em mente o endereço IP dos hosts da rede – basta saber o nome da
máquina. Na prática, é muito mais simples memorizar nomes do que uma sequência
de números representando o endereço IP.
A configuração do arquivo hosts é bem simples, como demonstra a sintaxe a seguir:
<endereço IP> nome_do_host.nome_do_dominio nome_do_host
Vejamos um exemplo:
127.0.0.1 localhost
172.16.19.1 P19-01.impacta.com.br P19-01
172.16.19.2 P19-02.impacta.com.br P19-02
172.16.200.202 prodigy.impacta.com.br
Para testar a resolução de nomes, basta utilizar o simples comando ping:
# ping P19-01
Caso o host descrito no arquivo troque de endereço IP, o arquivo /etc/hosts deve ser
atualizado manualmente.
A configuração do arquivo hosts pode, no entanto, se tornar uma tarefa desgastante

em uma rede expandida. No caso de ter um novo computador com seu respectivo
nome e endereço IP na rede, é necessário cadastrar em todos os arquivos hosts de
cada máquina na rede essa nova informação. Assim, todas as máquinas podem se
referenciar ao novo host pelo seu respectivo nome, em vez de seu endereço de rede.
Tal procedimento, consequentemente, não é uma tarefa simples, principalmente se

a rede local atingir um número grande de estações. Para tal problema, existe um
sistema de resolução de nomes mais avançado chamado DNS (Domain Name Server).
603
10.3.5.1. Resolvendo nomes a partir do DNS

Para uma resolução de nomes mais avançada e estruturada, temos o DNS, cuja função
é justamente realizar a conversão dos nomes em endereços IP. Ele é muito utilizado,
principalmente por sua adoção mundial por meio da Internet. Adicionalmente, o
serviço de DNS pode realizar a conversão a partir de um banco de dados localizado
na Internet, que mantém uma estrutura hierárquica, no qual retornará o endereço IP
para o nome da máquina especificada.
A base do funcionamento e resolução de nomes na Internet é estruturada a partir

da integração de vários servidores DNS espalhados ao redor do mundo. O recurso
de resolução de nomes disponibilizado pelo DNS é utilizado com muita frequência,
quando, por exemplo, um site é requisitado para exibição por meio do browser.
Uma das principais facilidades proporcionadas pelo serviço DNS é poder centralizar
as requisições de resolução de nomes a um único servidor, para que ele, de alguma
forma, mapeie um determinado nome para um endereço IP específico.
No que diz respeito aos nomes de domínio na Internet, a estrutura assemelha-se

à dos diretórios de sistemas Unix-like, ou seja, ela segue uma hierarquia. Dessa
forma, é preciso entender como é formado um nome de domínio da Internet, com seu
respectivo nome de host.
10.3.5.2. Definindo um servidor de DNS

Já que o servidor DNS é também uma alternativa ao mapeamento de nomes em uma
rede e essencial para uso na Internet, é preciso saber defini-lo no sistema, o que é
feito por meio de um simples arquivo de configuração presente no diretório /etc e
chamado resolv.conf. Com ele, podemos especificar um ou vários servidores DNS
para resolver requisições de nomes e até mesmo definir o nome do domínio local ao
qual o host atual pertence.
O arquivo pode ser editado utilizando o vi ou qualquer outro editor de texto, visto
que este arquivo é um arquivo de texto normal. O arquivo resolv.conf configura
basicamente três opções:
•• domain: Determina o nome do domínio local;
•• nameserver: Determina o endereço IP do servidor de nomes de domínio para

que seja realizada a resolução de nomes. Esta opção pode ser utilizada várias
vezes no mesmo arquivo;
•• search: Determina uma lista de nomes de domínio alternativos ao procurar por

um computador. A linha search pode conter no máximo seis domínios, ou 256
caracteres.
604
A seguir, com o comando vi, editamos o arquivo /etc/resolv.conf e adicionamos o
servidor de DNS 192.168.0.1 (nameserver 192.168.0.1):
10.3.6. Outros arquivos de configuração

Neste tópico, abordaremos alguns arquivos de configuração adicionais relacionados
com as possíveis definições de rede.
10.3.6.1. /etc/host.conf
O arquivo /etc/host.conf poderá definir uma ordem para a resolução de nomes no
sistema e estará ligado diretamente com as definições feitas nos arquivos /etc/hosts
e /etc/resolv.conf, respectivamente. A seguir, podemos visualizar um exemplo do
arquivo:
order hosts, bind

multi on
Nesse exemplo, temos:
•• order hosts, bind: Define a ordem de resolução de nomes, que, primeiramente,

irá consultar o arquivo /etc/hosts, para depois verificar um servidor de nomes;
•• multi on: Determina que serão retornados todos os endereços IP resolvidos que
se encontram no arquivo /etc/hosts.
605
10.3.6.2. /etc/networks
O arquivo /etc/networks é utilizado para criar um vínculo entre o nome de uma
determinada rede e seu respectivo endereço IP.
Para visualizarmos tal vínculo, podemos utilizar o comando route sem nenhuma
opção. Visualizaremos, então, ao invés dos números IP das redes, os seus respectivos
nomes.
10.3.6.3. /etc/hostname
O arquivo /etc/hostname é responsável por armazenar e definir o nome da estação
de trabalho.
Para que as alterações feitas no arquivo hostname tenham efeito, é preciso reiniciar
o sistema ou utilizar o próprio comando hostname, como no exemplo adiante, para
redefinir dinamicamente o nome da máquina. Ou seja, basta reiniciar a sessão atual
para que o novo nome seja utilizado.
No exemplo anterior, o nome da máquina foi alterado de debian para novo-nome,

por meio do comando hostname. Caso o comando hostname seja utilizado sem
nenhum parâmetro, ele exibirá o nome atual do host. Após a definição, basta reiniciar
a sessão para que as alterações tenham efeito.
Se o nome da máquina for alterado no arquivo, é preciso alterar possíveis definições

de mapeamento no arquivo /etc/hosts.
606
10.3.6.4. /etc/nsswitch.conf
Neste arquivo, encontramos a indicação e a forma de acesso às bases de dados do
sistema, como:
•• Arquivos /etc/passwd e /etc/shadow;
•• Resolução de nomes;
•• Grupos de usuários.
O arquivo nsswitch.conf é o local onde especificamos a busca de um login em um

meio de autenticação (servidor NIS ou LDAP, por exemplo). A seguir, temos o conteúdo
padrão desse arquivo:
passwd : compat
group : compat
shadow : compat
Apesar de poder ser levemente alterado com a utilização de determinados serviços,

como o NIS (Network Information Service), o arquivo nsswitch.conf é utilizado
exclusivamente por determinadas bibliotecas do sistema.
10.3.7. Configuração estática da rede

Por meio das ferramentas apresentadas anteriormente, foi possível configurar, de
forma dinâmica, definições de endereçamento IP e rotas. No entanto, tal método
apresenta um inconveniente, uma vez que tais configurações poderão ser perdidas
após a reinicialização do sistema. Com o arquivo interfaces, que fica alocado no
diretório /etc/network/, é possível determinar configurações permanentes para as
interfaces de rede.
Para configurar a rede com esse arquivo, devemos possuir as configurações básicas
da rede. É possível definir o endereço IP, rede, broadcast e o gateway padrão que será
utilizado por cada interface.
607
A configuração do arquivo interfaces é simples, desde que se respeite sua sintaxe,

como no exemplo adiante:
As configurações das interfaces são definidas por blocos, onde cada interface terá
suas respectivas configurações. Na tabela a seguir, podemos encontrar algumas
opções com as descrições para o arquivo interfaces:
Opção Definição
A interface especificada será carregada automaticamente na
auto <interface> inicialização do sistema, caso a opção auto seja inserida com
a interface desejada.
É preciso indicar a interface que será configurada com as
<interface> referências vistas anteriormente. Por exemplo: Io, eth0,
wlan0, entre outras.
iface Determina o início da configuração de uma interface de rede.
Determina que a família de protocolos a ser utilizada para a
interface de rede é o TCP/IP na versão 4. Caso seja necessário
inet
utilizar a tecnologia de IPv6, é preciso indicar a opção inet6,
ou ipx para usar a Tecnologia de IPX.
608
Opção Definição
Determina o método no qual a interface de rede está sendo
configurada (static significa que a interface de rede está
sendo configurada como endereço estático, fixo). Para tal
opção, é possível usar os seguintes parâmetros:
•• address: Especifica um endereço IP;
•• netmask: Especifica uma máscara para o endereço IP;
static •• network: Especifica o endereço de rede do qual o host

faz parte;
•• broadcast: Especifica o endereço de broadcast da rede;
•• gateway: Indica um endereço para um gateway padrão

da rede, dispensando, assim, o uso do comando route;
•• hwaddress ether: Utilizado para alterar permanentemente

o MAC de uma interface.
Determina o método no qual a interface de rede está sendo
configurada. DHCP significa que a interface de rede será
DHCP
configurada com um endereço dinâmico, que será atribuído
por um servidor DHCP local.
No exemplo anterior, foi possível configurar automaticamente as interfaces lo, eth0

e eth1, na inicialização do sistema, sendo que as configurações para a interface eth0
foram baseadas em uma definição de IP estático, e as configurações para eth1 foram
baseadas em uma definição de IP dinâmico, que é atribuído de um servidor DHCP
presente na rede.
A interface loopback é essencial para a funcionalidade básica de muitos aplicativos,

como o gerenciador de janelas KDE. É interessante manter as definições no arquivo
interfaces, para que a loopback inicie automaticamente durante a inicialização.
10.3.7.1. Definindo as alterações feitas no arquivo

interfaces
O arquivo interfaces é lido automaticamente na inicialização do sistema graças ao
script chamado networking, localizado em /etc/init.d/. Porém, caso alguma alteração
seja feita nesse arquivo, é possível atribuí-la sem a necessidade de reiniciar o sistema.
609
É possível executar o script manualmente com seus respectivos parâmetros,

apresentados na tabela a seguir:
Relê o arquivo interfaces, habilitando todas as interfaces com
start
as supostas novas configurações.
Desabilita todas as interfaces (exceto a interface loopback) que
stop
estão ativas no sistema.
Desabilita todas as interfaces e, logo em seguida, habilita
restart novamente, reiniciando assim as interfaces e definindo novas
configurações.
Exemplo:
# /etc/init.d/networking restart
O arquivo /etc/network/options é utilizado para armazenar as opções da(s)

interface(s) de rede aplicada(s) durante a inicialização do sistema, no momento em
que ocorre a execução do script /etc/init.d/networking.
Para o Red Hat e seus derivados, essa configuração será realizada no arquivo /etc/
sysconfig/network-scripts/ifcfg-<nome_interface>.
610
Na tabela a seguir, podemos encontrar algumas opções com as descrições para o
arquivo ifcfg-<nome_interface>:
Opção Definição
TYPE Define o tipo de rede.
Define a maneira como a interface será configurada:
•• dhcp: Para receber a configuração de rede através de um

BOOTPROTO
servidor de DHCP;
•• none: Para configuração de rede estática.

DEVICE Identificação do dispositivo de rede.
ONBOOT Inicia a interface de rede, no momento do boot.
IPADDR Define o endereço IP.
NETMASK Define a máscara de subrede.
Para a configuração do endereço do gateway, este poderá ser informado no arquivo /

etc/sysconfig/network.
Após a configuração da rede, reinicie o serviço.
611
10.3.8. Monitorando e reparando problemas de rede

Para monitorarmos e repararmos problemas de rede, contamos com alguns comandos,
os quais serão descritos neste tópico. São eles: ping, dig, host, netstat, traceroute,
e tracepath.
10.3.8.1. ping
O ping é o comando utilizado para verificar se uma determinada máquina encontra-
se conectada à rede. Podemos verificar também o tempo que cada máquina leva para
responder aos pacotes enviados por este comando.
Este comando trabalha enviando pacotes ICMS ECHO_REQUEST para um determinado

endereço. Quando o pacote chega ao seu destino, a máquina que o recebeu envia
outro pacote como resposta. A seguir, encontramos a sintaxe do ping:
ping [opcoes] <IP ou nome_do_host>
Na tabela adiante, temos a descrição das opções:
Opção Descrição
Envia pacotes para o endereço broadcast, onde todas as máquinas
-b ativas na rede receberão o pacote ping. Opção mais útil para
descobrir os IPs ocupados em um endereço de rede.
Especifica a quantidade de pacotes a serem enviados para um
-c <num> determinado destino. Após o envio do número determinado de
pacotes, o comando é encerrado.
Especifica que o sistema não deverá esperar a resposta do
destinatário para enviar outros pacotes. Este comando exibirá em
-f
tela um ponto (.), que é apagado quando recebido com sucesso na
outra ponta.
Especifica, em segundos, o intervalo entre o envio de um pacote e
-i [seq]
outro.
Oculta a exibição dos pacotes enviados, e só mostra o resultado do
-q
comando quando este for encerrado.
-s <tam> Especifica o tamanho do pacote que será enviado.
612
No exemplo a seguir, executamos o comando ping para o site www.impacta.com.br.
É retornada a mensagem de resposta com o tempo de execução.
Para redes configuradas em IPv6, poderá ser utilizado o comando ping6. Sua sintaxe
é a seguinte:
ping6 [opcoes] <IP ou nome_do_host>
Vejamos o exemplo de um teste realizando o ping no endereço de loopback:
ping6 ::1
A seguir, um teste realizando o ping em um endereço de IPV 6:
ping6 2002:c000:203::1
10.3.8.2. dig
O comando dig (Domain Information Groper) é um aplicativo muito flexível e nos
permite fazer perguntas a determinados servidores de nomes DNS. É utilizado para
exibir informações do servidor de nomes especificado. A sintaxe do comando é a
seguinte:
dig <dominio>
613
Vejamos um exemplo:
dig www.impacta.com.br
Indicamos um servidor específico depois do caractere @ se quisermos utilizá-lo. O

teste padrão será feito no(s) servidor(es) do arquivo /etc/resolv.conf, na ausência de
qualquer argumento.
10.3.8.3. host
O comando host é utilizado para fazer pesquisas em DNS. É utilizado, normalmente,
para converter nomes em endereços IP e vice-versa. Serve para detectar e corrigir
problemas de resolução de nomes.
host [opcoes] [IP ou nome_do_host]
Quando nenhuma opção é informada, o comando host exibe uma pequena lista de
seus argumentos de linha de comando e opções.
Na tabela a seguir, temos as opções mais utilizadas com o comando host:
Opção Descrição
Equivalente ao uso das opções -v, que acionam o modo verboso, e
-a
-t, que especifica um tipo de pergunta.
Tenta exibir os registros SOA para o nome da zona de todos os
-C servidores de nomes autorizados listados para ela. Essa lista é
definida pelos registros NS que são encontrados para a zona.
-l Seleciona o Listmode.
No exemplo a seguir, primeiramente utilizamos o comando host para identificarmos o

endereço IP do servidor do site da Impacta. Em seguida, host foi utilizado para verificar
a existência do DNS reverso do site em questão. Como último teste, propositalmente
executamos o comando host para identificarmos um domínio inexistente; a resposta
indicou um erro de conexão.
614
10.3.8.4. netstat
O comando netstat é o responsável por exibir, entre outras coisas, as interfaces de
rede configuradas, as conexões de rede e as tabelas de roteamento. Sua sintaxe é a
seguinte:
netstat [opcoes]
A seguir, são descritas as opções mais utilizadas do comando netstat:
Opção Opção GNU Descrição

-a --all Lista todas as conexões socket (abertas e fechadas).
Exibe a listagem de informações a cada segundo. Esta
-c --continuous listagem é interrompida ao pressionarmos as teclas
CTRL + C.
-i --interfaces Exibe a tabela de todas as interfaces de rede.
-M -- masquerade Exibe uma lista referente às conexões mascaradas.
Exibe os endereços em formato numérico, não
-n --numeric
utilizando nomes para resolver os endereços.
-r --route Exibe as tabelas de roteamento do kernel.
-t --tcp Exibe conexões TCP.
-u --udp Exibe conexões UDP.
Quando o comando netstat for utilizado sem opção, os sockets ativos

das famílias que possuem os endereços configurados serão apresentados.
No exemplo a seguir, o comando netstat é utilizado com a opção –r para verificar a

tabela de roteamento, onde é possível identificar o gateway padrão (10.0.2.2):
615
10.3.8.5. traceroute
O traceroute é o comando utilizado para exibir o caminho (ou rota) percorrido por
um pacote entre os gateways da rede até chegar ao seu destino, e o tempo gasto na
retransmissão.
Uma das utilidades deste comando é encontrar o computador que está provocando
a falha na comunicação entre o emissor dos pacotes e o destinatário. Necessitamos
desse tipo de informação quando ocorrem problemas no envio e recebimento de
pacotes via rede.
A sintaxe do traceroute é a seguinte:
traceroute [opcoes] <IP ou nome_do_host>
Vejamos um exemplo:
# traceroute -v www.impacta.com.br
A seguir, são descritas as principais opções do comando traceroute:
-l Exibe o tempo de vida do pacote.
Utilizamos esta opção para especificar a quantidade máxima de
-m <num>
TTL dos pacotes.
Exibe os endereços em formato numérico, não utilizando, assim, o
-n
serviço de DNS.
A porta padrão utilizada para teste é a 33434. Podemos utilizar
-p <porta> esta opção para determinar que os testes serão realizados da porta
especificada.
Utilizamos esta opção quando não desejamos que a tabela de
-r roteamento seja consultada. Portanto, os pacotes são enviados
diretamente ao computador conectado à rede.
-v Exibe o resultado do comando em detalhes (modo verboso).
Especifica o tempo máximo que o comando aguardará por uma
-w <num> resposta. Se não utilizarmos esta opção, será utilizado o valor
padrão de três segundos para o tempo máximo de resposta.
616
10.3.8.6. tracepath
Com o comando tracepath, descobrimos o MTU (Maximum Transmission Unit)
durante o caminho traçado até um host de rede. Mesmo usuários que não sejam
administradores do sistema podem fazer uso desse comando, característica que o
diferencia do comando traceroute, apesar das semelhanças entre eles. O tracepath
possui a seguinte sintaxe:
tracepath <destino> [porta]
No caminho até <destino>, é utilizada uma porta aleatória ou a porta UDP especificada
em [porta].
No exemplo a seguir, o comando netstat é utilizado para verificar a tabela de

roteamento e, então, identificar o gateway padrão (10.0.2.2):
617
Pontos principais
•• Uma rede é constituída por dois ou mais computadores e/ou dispositivos

conectados por um meio específico, estabelecendo assim uma comunicação e
troca de informações, ou também disponibilizando serviços;
•• Os componentes básicos para o bom funcionamento de uma rede são:

cabeamento, adaptadores de rede e protocolos;
•• os principais protocolos de rede são: IP (Internet Protocol), TCP (Transfer

Control Protocol), UDP (User Datagram Protocol) e ICMP (Internet Control
Message Protocol);
•• Todo o processo de configuração da rede Linux pode ser executado de forma

dinâmica, usando comandos específicos, ou de maneira estática, por meio de
arquivos de configuração.
Sites Endereços
Configuração de https://www.debian.org/doc/manuals/debian-reference/
rede Debian ch05.en.html
Configuração de
Enterprise_Linux/6/html/Deployment_Guide/ch-Network_
rede Red Hat
Interfaces.html
IPV4 https://en.wikipedia.org/wiki/IPv4
IPV6 https://en.wikipedia.org/wiki/IPv6
618
Mapa mental para fixação do aprendizado 10
619
10 Fundamentos
de rede
1. Qual comando é utilizado para verificar se a placa de rede está conectada

e em qual velocidade?
☐☐ a) ifconfig
☐☐ b) mii-tool
☐☐ c) ipconfig
☐☐ d) arp
☐☐ e) traceroute
2. Um computador com o endereço IP 192.168.1.120 não consegue se

comunicar com um computador que possui o endereço IP 192.168.2.130.
A rede está configurada para os dois computadores com a máscara
255.255.255.0. Qual o problema de comunicação existente entre as duas
máquinas?
☐☐ a) O DNS não está respondendo.

☐☐ b) Os dois computadores estão em redes diferentes.
☐☐ c) Os endereços IP estão em conflito.
☐☐ d) Está faltando o MAC Address.
☐☐ e) O ifconfig não foi executado.
3. Em qual arquivo de configuração deve-se digitar os endereços de DNS?
☐☐ a) /etc/dns.conf
☐☐ b) /etc/dnsresolv.conf
☐☐ c) /etc/resolv.conf
☐☐ d) /etc/nsswitch.conf
☐☐ e) /etc/hosts
4. Quais comandos são utilizados para verificar o gateway padrão?
☐☐ a) ifconfig ou route.
☐☐ b) route ou arp.
☐☐ c) ifconfig ou netstat.
☐☐ d) route ou netstat.
☐☐ e) arp ou ifconfig.
5. A máscara de rede 255.255.224.0 está em qual classe?
☐☐ a) B
☐☐ b) A
☐☐ c) C
☐☐ d) E
☐☐ e) D
622
6. Sobre o endereço 127.0.0.1, qual das alternativas a seguir é verdadeira?
☐☐ a) É um endereço exclusivo para uso em intranets.

☐☐ b) É o endereço de loopback, em que qualquer pacote enviado a este
endereço é retornado ao próprio computador.
☐☐ c) É um endereço público de Internet e não pode ser usado em redes
locais.
☐☐ d) É um endereço inválido, não provê qualquer tipo de comunicação ou
resposta.
☐☐ e) É um endereço de loopback; qualquer pacote enviado a este
endereço é destinado a toda a rede.
7. Qual das alternativas a seguir representa o endereço IP 192.168.5.100?
☐☐ a) 11111111.00011101.01101011.10010011
☐☐ b) 11001101.10100100.10110101.10100010
☐☐ c) 11000000.10101000.00000101.01100100
☐☐ d) 00110000.10100100.00010011.11010110
☐☐ e) 11000000.11001010.00001000.00010101
8. Em uma máscara de 16 bits em que o endereço de rede é 169.254.0.0,

qual é o endereço de Broadcast?
☐☐ a) 169.254.0.255
☐☐ b) 169.254.255.0
☐☐ c) 169.255.255.255
☐☐ d) 169.254.255.255
☐☐ e) 169.254.254.255
9. A qual máscara pertence o endereço de rede 200.254.223.129/27?
☐☐ a) 255.255.255.224
☐☐ b) 255.255.255.0
☐☐ c) 255.255.255.192
☐☐ d) 255.255.254.0
☐☐ e) 255.255.255.252
10. A máscara binária 11111111.11111111.11111111.11110000 representa

qual máscara, em decimal?
☐☐ a) 255.255.255.248
☐☐ b) 255.255.248.0
☐☐ c) 255.255.255.240
☐☐ d) 255.255.255.192
☐☐ e) 255.255.255.224
623
11. Qual é a porta padrão do serviço SSH?
☐☐ a) 21
☐☐ b) 22
☐☐ c) 23
☐☐ d) 993
☐☐ e) 53
12. Qual a alternativa correta do comando ip?
☐☐ a) ip addr dev enp0s3 192.168.0.20/24

☐☐ b) ip addr 192.168.0. dev enp0s3
☐☐ c) ip addr 192.168.0./24 dev enp0s3
☐☐ d) ip addr 192.168.0.20/ dev enp0s3
☐☐ e) ip addr 192.168.0.20/24 dev enp0s3
13. Qual a alternativa correta do comando route para excluir um gateway

padrão?
☐☐ a) route del default 192.168.0.1 gw

☐☐ b) route del default 192.168.0.1
☐☐ c) route del default gw 255.255.255.0
☐☐ d) route default gw 192.168.0.1
☐☐ e) route del gw 192.168.0.1 default
14. Na distribuição Debian e seus derivados, qual o nome do arquivo

responsável pela configuração das interfaces de rede?
☐☐ a) interfaces
☐☐ b) interface
☐☐ c) ifcfg-enp0s3
☐☐ d) resolv.conf
☐☐ e) Interfaces
15. Na distribuição Red Hat e seus derivados, qual o nome do arquivo

responsável pela configuração de uma determinada interface de rede?
☐☐ a) ifcfg-<nome da interface>
☐☐ b) icg-<nome da interface>
☐☐ c)fcfg-<nome da interface>
☐☐ d) iffg-<nome da interface>
☐☐ e) ifcf-<nome da interface>
624
10 Fundamentos
de rede
Mãos à obra!
Laboratório 1 - Identificando dados de rede

1. Utilize o comando a seguir para verificar quais placas de redes estão conectadas:
# mii-tool
2. Verifique as configurações da placa eth0:
# ifconfig eth0
3. Com o resultado, anote as seguintes informações de configuração da placa eth0:
•• Endereço IP;
•• Máscara;
•• MAC Address;
•• Broadcast.
4. Desative a placa de rede:
# ifdown eth0
5. Ative novamente a placa de rede:
# ifup eth0
6. Na placa virtual eth0:1, crie o endereço IP da rede de classe C 192.168.100.0/24:
# ifconfig eth0:1 192.168.100.x netmask 255.255.255.0 up
Na linha anterior, x é o endereço IP do computador. Combine com o instrutor qual

endereço IP será utilizado em x.
7. Verifique o endereço IP configurado:
# ifconfig eth0:1
8. Execute o ping para o computador de um dos colegas. Para isso, pergunte a ele
qual é o endereço IP de sua máquina (no lugar de x, informe o endereço IP obtido);
# ping 192,168.100.x
9. Verifique a tabela de rotas e anote o gateway padrão:
# route -n
626
Laboratório 2 - Configurando respostas de DNS
10. Verifique o arquivo resolv.conf para identificar a configuração de DNS:
# cat /etc/resolv.conf
11. Configure o computador para que responda pelo seguinte nome: srvYY.impacta.
com.br. O endereço YY é numérico, portanto, a escolha do valor a ser utilizado deve
ser feita com auxílio do instrutor, a fim de evitar valores repetidos em sala de aula;
# vi /etc/hosts
12. Então, adicione a seguinte linha:
192.168.100.x srvYY.impacta.com.br srvYY
13. Execute o ping para o novo endereço de domínio:
# ping srvYY.impacta.com.br
14. Execute o ping para o endereço reduzido:
# ping srvYY
Laboratório 3 - Verificando rotas e diagnosticando

a rede
15. Verifique a rota de acesso do computador do aluno até o site da Impacta:
# traceroute www.impacta.com.br
16. Verifique o status das conexões das placas:
# netstat -i
17. Consulte as configurações de servidor DNS ajustadas no computador:
# cat /etc/resolv.conf
18. Anote um dos endereços DNS:
# dig @ip_do_dns
627
Laboratório 4 - Configuração da rede no

CentOS
19. Para esta atividade, utilize o capítulo de fundamentos de rede como procedimento
técnico.
628
11 Segurança
ÃÃ TCP wrapper;
ÃÃ Limitando recursos do sistema;
ÃÃ Configuração do SSH.
Este capítulo faz parte do tópico 110 – Security da segunda prova identificada
como 102-400 ou LX0-104 da certificação LPIC-1.
Você precisará estar apto a realizar tarefas administrativas de segurança no host e

configurar conexão SSH por meio de chaves de criptografia.

Para o mercado de trabalho, o entendimento sobre segurança e servidores Linux

e a administração das conexões remotas são essenciais para a administração do
sistema.
Obs.: Alguns comandos ou arquivos exigidos nesse tópico já foram mencionados

em capítulos anteriores.
11.1. TCP wrapper
Os TCP wrappers demonstram grande funcionalidade no GNU/Linux por atuarem na
verificação de solicitações da rede. Eles definem uma camada de segurança que é
aplicada em diferentes serviços, como o SSH e o SMTP, ou seja, os TCP wrappers
constituem um mecanismo de controle de acesso aos serviços disponíveis.
Um programa chamado tcpd atua como wrapper na realização de diferentes tarefas

que diminuem os riscos de problemas na segurança da rede. Dentre essas tarefas,
vale considerar a verificação e geração de resposta às solicitações da rede, requisições
de logs para serviços internos da rede e o fornecimento de um método de controle de
acesso para serviços da rede. A biblioteca responsável por viabilizar a funcionalidade
do TCP wrapper é a libwrap.
11.1.1. Controle de acesso aos serviços

A requisição de logs para serviços internos é realizada por meio da facilidade authpriv
do syslog. O controle de acesso aos serviços, por sua vez, é realizado por meio dos
arquivos /etc/hosts.allow e /etc/hosts.deny, que dizem respeito aos arquivos de
controle de acesso do tcpd.As regras referentes aos endereços remotos que poderão
acessar o computador local estão contidas em /etc/hosts.allow. Já o arquivo etc/
hosts.deny armazena as regras dos endereços remotos que não poderão acessar o
computador local. Sendo assim, é importante entender o seguinte:
630
Segurança 11
•• Caso o endereço atenda a uma regra do arquivo etc/hosts.allow, o acesso será
liberado. Nesse caso, a consulta ao arquivo /etc/hosts.deny não será realizada;
•• O endereço será negado caso esteja em /etc/hosts.deny;
•• O endereço será liberado caso não esteja em nenhum desses dois arquivos.
O conteúdo das linhas dos arquivos /etc/hosts.allow e /etc/hosts.deny define as

regras de acesso aos serviços. Essas linhas apresentam o seguinte formato:
<servicos>: <clientes> [comando]
Em que:
•• servicos: Compreende uma lista de serviços separados por vírgula. Devemos

especificar os daemons de serviço;
•• clientes: Compreende uma lista de clientes separados por vírgula. Podemos

informar um endereço IP de rede, um IP incompleto ou um domínio, e fazer uso
de caracteres curinga, como * e ?;
•• comando: Permite a definição de um comando shell opcional a ser executado.
O acesso será liberado caso o par servicos:clientes esteja localizado no arquivo /etc/
hosts.allow e negado caso o par servicos:clientes esteja localizado no arquivo /etc/
hosts.deny.
Podemos utilizar instruções especiais nos campos servicos e clientes. A tabela a

seguir descreve tais instruções:
Instrução Descrição
ALL Todos os serviços/hosts têm a condição atendida.
Hosts que apresentam nome sem um ponto (.) têm a condição
LOCAL
atendida.
Usuários de nome conhecido e hosts de nome e endereço conhecidos
KNOW
têm a condição atendida.
Usuários de nome desconhecido e hosts de nome e endereço
UNKNOWN
desconhecidos têm a condição atendida.
Hosts que não apresentam nome correspondente ao endereço têm
PARANOID
a condição atendida.
EXCEPT Excetua de determinada condição um ou mais endereços.
631
Também, podemos fazer uso de algumas variáveis wrapper, as quais descrevemos a

seguir:
•• %H: Contém o nome de host do servidor;
•• %a: Contém endereços IP de clientes;
•• %c: Contém o conjunto de informações referentes aos clientes;
•• %%: Contém o símbolo %;
•• %s: Contém o conjunto de informações referentes ao servidor;
•• %d: Contém o nome do processo daemon da rede;
•• %A: Contém endereços IP dos servidores;
•• %h: Contém o nome de host do cliente;
•• %n: Contém o nome de host do servidor. Quando desconhecido, é definido

UNKNOWN e, nas situações em que o lookup reverso falha, é especificado
PARANOID;
•• %p: Contém o ID do processo daemon da rede.
11.1.2. tcpdump
O tcpdump atua na segurança dos pacotes que são transmitidos através da rede e na
solução de possíveis falhas. Sua atuação consiste em ler pacotes a partir da interface
TCP, que pode ser ethernet ou token ring, e comparar esses pacotes com um filtro
especificado.
Quando a especificação do filtro e o pacote são compatíveis, este último é exibido na

tela. Ele é utilizado da seguinte forma:
tcpdump [opcoes] [filtros]
632
Segurança 11
A tabela a seguir apresenta opções de tcpdump:
Opção Descrição
-A Exibe o conteúdo do pacote em formato ASCII.
-i <interface> Indica a interface que será monitorada.
-n Não resolve nomes, exibindo o endereço de IP.
-s <tamanho> Captura pacotes pelo tamanho especificado (bytes).
-c <numero> Captura uma quantidade específica de pacotes.
-w <arquivo> Salva o resultado em um arquivo determinado.
-v <arquivo> Exibe as informações em um nível detalhado.
-vv <arquivo> Nível maior de detalhamento sobre as informações exibidas.
-vvv <arquivo> Nível máximo de detalhamento sobre as informações exibidas.
-x Exibe o conteúdo do pacote em formato hexadecimal.
Segue a descrição de alguns filtros utilizados junto ao tcpdump:
•• dst host | net port value: Responsável por capturar pacotes destinados ao host,
à porta ou à rede especificada;
•• src host | net port value: Responsável por capturar pacotes a partir de um host,
porta ou rede especificada;
•• host <host>: Responsável por capturar pacotes para o host definido ou a partir
dele;
•• net <endereco/mascara>: Responsável por capturar pacotes para a rede

definida ou a partir dela;
•• port <porta>: Responsável por capturar pacotes para a porta definida ou a

partir dela;
•• ip proto <protocolo>: Responsável por capturar pacotes do tipo de protocolo

definido;
•• ip broadcast | multicast: Responsável por capturar pacotes IP multicast ou

broadcast.
633
Vejamos um exemplo:
tcpdump -i eth0 -n -s 1000 -c 500 -w resultado.file
No exemplo apresentado, o comando tcpdump monitora o tráfego da interface eth0

(-i), sem resolver nomes (-n). Captura pacotes que tenham no máximo 1000 bytes (-s)
e uma quantidade máxima de 500 pacotes (-c), salvando o resultado no arquivo de
nome resultado.file.
11.1.3. Comando fuser
O comando fuser é utilizado nos casos em que é necessário verificar os processos
que estão utilizando um determinado arquivo, como nos casos de um bloqueio de
algum dispositivo ou mapeamentos.
A tabela a seguir apresenta suas opções:
Opção Descrição
-u Exibe o PID e o nome do usuário em que está executando o comando.
Altera o formato de exibição para a saída do comando ps, com os
-v
seguintes campos: PID, USER, ACCESS e COMMAND.
-k Finaliza os processos que estão acessando o arquivo.
Vejamos exemplos de uso:
fuser –k /dev/tty1
fuser /etc
11.1.4. Comando lsof
Podemos recorrer a arquivos ou proto-arquivos para acessar a maioria dos recursos
em ambientes Unix. Os recursos e arquivos que estiverem sendo usados são listados
pelo comando lsof que, além disso, investiga os processos, no computador local,
relacionados a recursos de rede.
634
Segurança 11
As conexões abertas cuja base é o protocolo IP são selecionadas pela opção –i, que
exibe dados como o programa e o usuário que a utiliza. Por exemplo:
Essa opção exibe, também, informações referentes a conexões que envolvam

determinado endereço ou porta.
Vale lembrar que o comando lsof fornece informações referentes somente às conexões
com o computador local. Para estabelecer uma conexão com um computador remoto,
é interessante recorrer a uma maneira mais prática.
Uma porta é especificada quando a informamos logo depois do sinal de dois pontos,
como vemos a seguir:
lsof -i :<porta>
O endereço também pode ser especificado juntamente com a porta. Para isso, usamos
a seguinte sintaxe:
lsof –i @[ endereco ip]:<porta>
11.1.5. Comando sudo
O comando sudo é um programa desenvolvido para possibilitar que um administrador
de sistemas conceda privilégios limitados de superusuário aos usuários comuns.
Através do arquivo de configuração identificado como /etc/sudoers, são encontrados

o controle referente aos usuários e quais os respectivos comandos que poderão ser
executados.
Esse arquivo em seu estado original, apresenta uma série de configurações onde elas
estão comentadas. O arquivo neste estado facilita a configuração para um determinado
usuário do sistema.
Para edição desse arquivo, utilize o comando visudo, cujos comandos de edição e
gravação das informações são iguais ao editor de texto vim.
635
O arquivo está dividido em partes, como:
•• Host Aliases
Define alias para grupos de máquinas ou para hosts específicos.
Host_Alias MAILSERVERS = 192.168.100.1, 192.168.100.2
•• User Aliases
Define alias para grupos de usuários ou para um usuário específico.
User_Alias ADM = %administradores

User_Alias ADMINS = operador, tux
•• Command Aliases
Define alias para grupos de comandos ou para um comando específico.
Cmnd_Alias KILL = /usr/bin/kill
Recomenda-se atenção para esse tipo de configuração. Vejamos um exemplo de uso:
sudo <comando>
Ao executar um comando de administração, o usuário comum deverá digitar sua

senha e, caso o comando sudo encontre no arquivo de configuração sudoers as
configurações necessárias desse usuário, o comando será executado.
11.1.6. Comando last
O comando last realiza a leitura do arquivo binário /var/log/wtmp, que tem a função
de armazenar os eventos ocorridos em um processo de desligamento, reinicialização
e acesso ao sistema.
636
Segurança 11
11.1.7. Arquivos com permissões especiais
Através do comando find, podemos encontrar arquivos com Bit SUID ou SGID
habilitados em arquivos que não necessitam desse tipo de permissão, evitando assim,
falhas ou ataques.
Vejamos exemplos de uso:
find / -perm -4000
find / -perm -2000
Também é possível verificar arquivos que não possuem um dono ou grupo associado:
find / \( -nouser –o –nogroup \ )
11.2. Limitando recursos do sistema

O comando ulimit, utilizado em uma sessão bash, impõe restrições que dizem
respeito à quantidade de processos, uso de memória e criação de arquivos, evitando
problemas causados pelo uso excessivo de recursos do computador.
ulimit [opcoes] [valor_limite]
O estabelecimento dos limites ocorre, na maioria das vezes, nos arquivos de

configuração da sessão. Esses limites influenciam a sessão atual do shell e suas
sessões e processos derivados.
Há dois tipos de limites que são definidos para cada recurso, a saber:
•• Hard: Especificado pela opção –H, este limite é a expressão do valor máximo;
•• Soft: Especificado pela opção –S, este limite expressa o valor de alerta enquanto
o limite hard não tiver sido atingido.
Todos os recursos terão o mesmo limite caso nenhuma das opções mencionadas
(–S e –H) seja determinada.
637
A tabela a seguir descreve as opções mais utilizadas com ulimit:
Opção Descrição
-a Com esta opção, os limites atuais são exibidos.
Com esta opção, é determinada a quantidade máxima de arquivos de
-f
uma sessão do shell.
Com esta opção, é expressa a quantidade máxima de processos a que
-u
o usuário tem acesso.
Esta opção refere-se à quantidade máxima de memória virtual que o
-v
shell pode utilizar.
No exemplo adiante, o comando ulimit –a é utilizado para identificar que o limite de

processos por usuário é de, no máximo, 8191 processos:
Em seguida, por meio do comando ulimit –u 5000, o limite máximo de processos é

alterado para 5000:
638
Segurança 11
A limitação de recursos, também poderá ser configurada no arquivo /etc/security/
limits.conf.
11.3. Configuração do SSH
Neste tópico, abordaremos aspectos acerca do funcionamento do protocolo SSH,
da configuração de servidores SSH e da administração remota de computadores
utilizando o SSH.Para que o usuário possa compreender efetivamente o funcionamento
do SSH, também serão contempladas aqui considerações sobre os diferentes tipos de
criptografia utilizadas e suas particularidades, além das versões existentes para esse
protocolo e dos utilitários do cliente SSH.
11.3.1. SSH
No sistema operacional GNU/Linux, para que seja possível estabelecer uma
comunicação segura entre um cliente e um servidor, ou entre dois computadores,
utilizamos o Secure Shell (SSH), um conjunto de padrões e protocolo com base
criptografada por meio do qual o usuário faz a autenticação de um sistema remoto
ou de usuários. Além disso, o SSH permite realizar conexões X11, tunelamentos,
redirecionar portas e transferir arquivos.
Com o SSH, as sessões de autenticação são criptografadas. Isso se torna uma

característica importante em termos de segurança e integridade, na medida em que
os usuários mal-intencionados não têm como obter acesso às senhas sem codificação.
Por meio do SSH é possível ter acesso aos aplicativos ssh, scp e sftp, os quais
substituem aplicações como telnet, rcp e o ftp.
11.3.2. Criptografia
A criptografia é uma técnica utilizada para proteger o acesso direto aos dados e
informações, em que um algoritmo de criptografia pode converter e proteger um
arquivo de texto puro por meio do uso de uma chave para um formato ilegível. Tal
chave é utilizada para criptografar e decriptografar dados.
Existem dois tipos de criptografia:
•• Criptografia simétrica;
•• Criptografia assimétrica.
639
11.3.2.1. Criptografia simétrica
No processo de criptografia simétrica, a chave é única, ou seja, a mesma chave
que é utilizada para criptografar as informações também é utilizada no processo
de decriptografia. Se tal chave secreta for descoberta, ou interceptada de maneira
indevida, todos os dados criptografados poderão estar comprometidos.
Uma observação importante sobre as chaves simétricas é em relação ao seu

tamanho. Uma chave de criptografia simétrica de 40 bits terá 1.099.511.627.776
de possibilidades, podendo ser quebrada em um curto espaço de tempo através de
um ataque de força bruta. Porém, atualmente, temos chaves de 128 bits e maiores,
aumentando consideravelmente o grau de segurança e tornando praticamente
impossível sua quebra por meio de ataques de força bruta.
Exemplos de técnicas de criptografia simétrica: DES, RC4, RC6, Blowfish e AES. As

vantagens apresentadas por chaves simétricas são: ótima capacidade e eficiência na
criptografia e decriptografia das informações e velocidade superior em relação às
chaves assimétricas.
11.3.2.2. Criptografia assimétrica
Na criptografia assimétrica, são utilizadas duas chaves diferentes: uma chave privada
e uma chave pública. Nesse processo, todos os dados que forem criptografados
com a chave privada só poderão ser decriptografados pela chave pública, assim
como todos os dados que forem criptografados pela chave pública só poderão ser
decriptografados pela chave privada.
Logo, a chave pública poderá ser distribuída livremente, já que sem a utilização da
chave privada, que deverá ser guardada com sua devida segurança, ela se torna inútil.
A única desvantagem apresentada pelas chaves assimétricas é o tempo utilizado no
processo de criptografia e decriptografia, consideravelmente maior que o tempo do
processo de criptografia simétrico.
Ambas as tecnologias poderão ser utilizadas em conjunto, ou seja, uma

criptografia simétrica pode ser enviada através de uma conexão criptografada
com a tecnologia assimétrica. O SSH apresenta tais características.
640
Segurança 11
Vejamos dois exemplos de criptografia assimétrica:
•• DSA: A chave assimétrica do tipo DSA (Digital Signature Algorithm) é um tipo

de chave utilizada para assinaturas digitais. É um recurso muito utilizado em
chaves públicas, cuja finalidade é garantir que um determinado documento
eletrônico tenha uma procedência confiável;
•• RSA: A chave assimétrica RSA (que deriva dos sobrenomes de seus criadores
Ronald Rivest, Adi Shamir e Leonard Adleman) é uma das chaves de criptografia
mais seguras, que utiliza o fundamento da teoria clássica dos números, a qual,
por meio de números primos, cria as chaves públicas e privadas utilizadas no
processo de criptografia. A RSA também permite a utilização de assinaturas
digitais.
11.3.3. Versões do protocolo SSH

O SSH atualmente utiliza dois tipos de versões de protocolo que, apesar de serem bem
parecidos, possuem suas respectivas particularidades: o protocolo versão 1 (SSH1) e
o protocolo versão 2 (SSH2).
11.3.3.1. Protocolo versão 1
O processo de conexão utilizando o protocolo SSH versão 1 é descrito na próxima
imagem:
641
A seguir, temos uma descrição do processo ilustrado na imagem anterior:
1. Uma conexão é estabelecida pelo cliente na porta 22 do servidor. Nesse processo,

a versão de protocolo utilizada na conexão é definida;
2. A versão 1 do protocolo SSH se utiliza de dois pares de chaves do tipo RSA.
Nesse processo, as chaves públicas são enviadas ao cliente. Sobre os dois tipos de
chaves utilizadas nesse processo, temos:
•• HK (Host Key): Chave utilizada para identificar e garantir a originalidade do

servidor SSH. É composta pela chave pública (/etc/ssh/ssh_host_key.pub), que
é enviada aos clientes, e pela chave privada (/etc/ssh/ssh_host_key), que fica
armazenada no servidor e tem seu acesso restrito. As chaves HK são comparadas
em todo início de conexão para garantir que o servidor SSH esteja íntegro;
•• SK (Server Key): O tipo de par de chaves SK é criado aleatoriamente a partir de

um tempo determinado (geralmente de uma em uma hora). O par de chaves é
composto por uma chave pública (SK pública) e uma chave privada (SK privada).
Esse par de chaves nunca é armazenado em arquivos e fica dinamicamente
disponível na memória RAM. Com isso, o processo de segurança é ainda mais
alto, principalmente se, por algum motivo, a chave HK for comprometida.
3. O cliente verifica se a chave pública HK, enviada pelo servidor, está correta, por
meio dos arquivos /etc/ssh/ssh_know_hosts e ~/.ssh/know_hosts;
4. O cliente cria um valor randômico de 256 bits que é gerado de forma aleatória. Esse
valor é enviado em formato criptografado para o servidor, onde é usado como uma
chave de sessão que será utilizada para criptografar toda a comunicação;
5. Toda a informação enviada pelo cliente poderá ser tranquilamente decriptografada

pelo servidor, o qual possui as chaves privadas.
11.3.3.2. Protocolo versão 2
A versão 2 do protocolo SSH é semelhante à versão 1. Porém, na versão 2, não há
a utilização de chaves de servidor (Server Key), as quais são substituídas por outro
método de gerenciamento de chaves, conhecido como Diffie-Hellman. O servidor se
utiliza de um par de chaves RSA ou DSA.
642
Segurança 11
Vejamos a ilustração a seguir:
A descrição do processo ilustrado na imagem anterior é a seguinte:
1. O cliente estabelece uma conexão no servidor por meio da porta 22;
2. Na versão 2 do protocolo, é utilizado apenas um par de chaves do tipo HK (Host

key). O servidor envia uma cópia da chave pública que será utilizada no processo, a
qual pode ser do tipo RSA ou DSA. As chaves públicas são geralmente referenciadas
por /etc/ssh/ssh_host_rsa_key.pub (RSA) e /etc/ssh/ssh_host_dsa_key.pub (DSA);
3. Assim como no protocolo versão 1, o cliente verifica se a chave pública HK está

correta por meio do arquivo /etc/ssh/ssh_know_hosts ou ~/.ssh/know_hosts;
4. A segurança principal nesse tipo de versão de protocolo é a utilização de uma

chave Diffie-Hellman, que terá uma distribuição de chaves avançada para o processo
de criptografia dos dados;
643
5. Assim que a troca de chaves for bem-sucedida através do processo anterior, os

dados são criptografados usando um algoritmo simétrico como DES, RC4, RC6,
Blowfish ou AES.
A principal diferença entre as versões do SSH é o suporte ao mecanismo de controle

à integridade dos dados que são criptografados durante o processo de comunicação.
Tal característica está presente na versão 2 do protocolo SSH e é mantida por um
código de autenticação de mensagem criptográfico (HMAC).
11.3.4. Administrando remotamente via SSH

Por meio do SSH, é possível administrar máquinas remotamente, copiar arquivos
remotos e até mesmo acessar sessões do VNC por meio de conexões seguras.
Para o funcionamento do SSH no cliente, o pacote openssh-client é necessário, ao

passo que, no servidor, exige-se o pacote openssh-server.
Além dos pacotes citados, há também o pacote openssl. A partir dele, são instaladas
as bibliotecas de criptografia utilizadas na comunicação entre os hosts.
Os aplicativos do openssh-client e openssh-server são divididos nas seguintes

categorias:
Aplicativos para Programa

Utilitários de clientes ssh, scp e sftp
Daemon do servidor sshd
Outra forma de utilizar o SSH é proteger outros protocolos que não

possuem nenhuma característica de criptografia ou segurança, como o POP.
11.3.5. Daemon do servidor
O servidor SSH é controlado pelo daemon /etc/init.d/sshd, que poderá ser manipulado
conforme seus parâmetros de gerenciamento. Tal daemon poderá ser personalizado
através do seu arquivo de configuração /etc/ssh/sshd_config. As principais opções
de configurações desse arquivo são:
Opção Descrição
Define a porta TCP na qual o servidor irá aceitar
Port
conexões. O padrão é 22.
Quantidade de bits utilizados na criptografia dos dados.
ServerKeyBits
O padrão é geralmente 768 bits.
644
Segurança 11
Opção Descrição
O tempo máximo (em segundos) que o servidor SSH irá
LoginGraceTime
aguardar a autenticação do usuário após sua conexão.
Habilita ou desabilita o login como usuário root no
PermitRootLogin
servidor.
Permite ou não a utilização de senhas em branco na
PermitEmptyPassword
autenticação dos usuários.
Lista dos usuários que têm permissão para se
autenticarem no servidor. A opção AllowGroups
AllowUsers
também pode ser utilizada para permitir a autenticação
por grupos.
Lista dos usuários que não têm permissão para se
autenticarem no servidor. A opção DenyGroups
DenyUsers
também pode ser utilizada para proibir a autenticação
por grupos.
Habilita o suporte à execução de aplicações gráficas a
X11Forwarding
partir do servidor SSH.
No caso do Debian, o servidor SSH é controlado pelo daemon /etc/init.d/ssh.
11.3.6. Utilitários do cliente
O cliente SSH possui alguns utilitários básicos, os quais serão apresentados a seguir.
11.3.6.1. ssh
A sintaxe desse utilitário é a seguinte:
ssh [opcoes] <usuario>@<host> [comando]
Em que:
Opção Descrição
-1 Força o ssh a utilizar o protocolo de versão 1.
-2 Força o ssh a utilizar o protocolo de versão 2.
-p <porta> Indica uma porta específica para conexão no servidor ssh.
-q Modo silencioso, não exibe informações.
-X Permite executar aplicativos gráficos remotamente.
645
Opção Descrição
-v Exibe informações detalhadas no processo de conexão.
-l Indica o nome do usuário que irá se conectar.
O ssh é utilizado para iniciar sessões remotas a partir de um terminal ou simplesmente

executar comandos remotamente, tendo como base a criptografia de toda a
comunicação, conforme as características já apresentadas.
O cliente SSH faz uso de alguns arquivos específicos. São eles:
Arquivo Descrição
/etc/ssh/ssh_config Arquivo de configuração do cliente ssh.
Relação das chaves públicas enviadas pelos servidores
~/.ssh/know_hosts
ssh na primeira conexão.
Relação das chaves públicas utilizadas para login sem
~/.ssh/authorized_keys
senha ou com frase secreta.
No exemplo a seguir, com uma conexão com o usuário aluno no host com IP
especificado, foi possível iniciar uma conexão SSH. Porém, como é a primeira vez que
o host de origem inicia uma conexão com o servidor SSH, é preciso obter sua chave
pública de conexão, que será alocada no arquivo ~/.ssh/know_hosts:
No próximo exemplo, o comando date foi executado no host especificado como

usuário aluno:
11.3.6.2. scp
A ferramenta scp (secure copy) é utilizada para cópia remota de arquivos e diretórios
através de um canal criptografado. É possível utilizar o comando scp de duas maneiras:
copiando arquivos do host atual para um host remoto ou copiando arquivos de um
host remoto para o host atual.
646
Segurança 11
Para obter arquivos remotamente, utilizamos a seguinte sintaxe:
scp [opcoes] <usuario>@<host>:<origem> <destino>
No exemplo a seguir, foi possível copiar remotamente o diretório /home/aluno para

o host atual como usuário aluno, tendo como seu destino o diretório /tmp:
Para enviar arquivos remotamente, utiliza-se a sintaxe a seguir:
scp [opcoes] <origem> <usuario>@<host>:<destino>
No próximo exemplo, o arquivo /etc/services foi enviado para o host remoto como
usuário aluno, indicando seu destino em /tmp:
As opções do comando scp são descritas a seguir:
Opção Descrição
-1 Força o scp a utilizar o protocolo de versão 1.
-2 Força o scp a utilizar o protocolo de versão 2.
-P <porta> Especifica uma porta para conexão com o host remoto.
-q Não exibe o medidor de progresso.
-r Cópia recursiva de diretórios.
-v Exibe informações detalhadas no processo de conexão.
647
11.3.6.3. sftp
O sftp (secure file transfer program) tem seu funcionamento similar ao FTP padrão.
O sftp utiliza o protocolo SSH para realizar a transferência de arquivos, ou seja, os
arquivos são criptografados antes de serem enviados.
A sintaxe do sftp é a seguinte:
sftp [opcoes] <usuario>@<host>
No exemplo a seguir, uma conexão SFTP foi iniciada no host especificado como usuário
aluno. Após o estabelecimento da conexão, os comandos básicos FTP funcionam
perfeitamente na utilização do serviço sftp. É feita uma cópia de um arquivo com o
comando get e, logo após, a finalização da conexão com o comando bye:
11.3.7. Autenticação por meio de chaves

Em uma conexão SSH, é possível iniciar uma conexão com sua respectiva autenticação
sem a necessidade de senha, utilizando para isso chaves de autenticação. O par de
chaves é criado pelo host que deseja estabelecer uma conexão com um determinado
servidor SSH. O tipo de par de chaves pode ser DSA ou RSA.
Para criação e envio da chave pública, o processo começa com a criação do par de
chaves com o comando ssh-keygen, no host que será utilizado para estabelecer a
comunicação com o servidor SSH. Este comando, quando utilizado com a opção –t,
pode indicar o tipo da chave (DSA ou RSA) utilizada no processo de criptografia. A
opção -b é utilizada para especificar o tamanho da chave, que pode ter um tamanho
de 1024 bits.
648
Segurança 11
O exemplo a seguir cria o par de chaves RSA com 1024 bits. Durante o processo
de criação do par de chaves, é possível fazer algumas alterações. Primeiramente,
é solicitada a localização e nome da chave privada (poderá ser alterado, caso
necessário). Logo em seguida, é possível criar uma frase secreta que será utilizada
em toda conexão.
Assim que o par de chaves for criado, é preciso enviar a chave pública ao servidor SSH
que estabelecerá a conexão através do processo de autenticação por chave. A chave
ficará armazenada no arquivo ~/.ssh/authorized_keys do usuário que utilizará tal
mecanismo de autenticação. Vejamos um exemplo de envio de chave:
Nesse exemplo, a chave pública id_rsa.pub foi enviada ao host especificado, ficando
armazenada no diretório pessoal do usuário aluno em .ssh/authorized_keys. Assim,
todo processo de autenticação do usuário aluno (que se encontra no host em que o
par de chaves foi criado) no host em que a chave pública foi enviada e armazenada
será feito através de chaves.
Durante a criação da chave, é possível deixar a senha em branco, de maneira que as

conexões SSH entre os computadores ou servidores fiquem sem autenticação. Trata-se
de uma prática muito comum, pois muitas pessoas trocam arquivos entre servidores
via shell script utilizando conexões SSH. Todavia, não recomendamos deixar a senha
em branco, pois um invasor que obtiver acesso a um dos servidores poderá facilmente
se conectar a todos os outros servidores.
649
Pontos principais
•• Os TCP wrappers demonstram grande funcionalidade no GNU/Linux por

atuarem na verificação de solicitações da rede. Eles definem uma camada de
segurança que é aplicada em diferentes serviços, como o SSH e o SMTP, ou seja,
os TCP wrappers constituem um mecanismo de controle de acesso aos serviços
disponíveis;
•• O comando ulimit, utilizado em uma sessão bash, impõe restrições que dizem
respeito à quantidade de processos, uso de memória e criação de arquivos,
evitando problemas causados pelo uso excessivo de recursos do computador;
•• Secure Shell (SSH) é um conjunto de padrões e protocolo com base criptografada

por meio do qual o usuário faz a autenticação de um sistema remoto ou de
usuários;
•• Existem dois tipos de criptografia: criptografia simétrica (em que a chave é

única) e criptografia assimétrica (duas chaves diferentes: uma chave privada e
uma chave pública).
Sites Endereços
https://www.centos.org/docs/5/html/Deployment_Guide-en-
TCP wrapper
US/ch-tcpwrappers.html
SSH https://wiki.centos.org/HowTos/Network/SecuringSSH
650
Mapa mental para a fixação do aprendizado 11
651
11 Segurança

1. No arquivo hosts.allow, foi feita a liberação de um acesso ao serviço SSH,

porém, o mesmo acesso está bloqueado no hosts.deny. Qual o resultado
disto?
☐☐ a) A liberação funcionou porque o hosts.allow é checado primeiro.

☐☐ b) A liberação não funcionou porque o hosts.deny é checado primeiro.
☐☐ c) A liberação não funcionou porque a regra existe nos dois arquivos e
é cancelada.
☐☐ d) A liberação funcionou porque, quando há conflito, o sistema libera
tudo.
☐☐ e) Estes arquivos não controlam acessos.
2. No GNU/Linux, qual o daemon responsável pelo TCP Wrapper?
☐☐ a) tcp
☐☐ b) tcpdump
☐☐ c) tcpd
☐☐ d) tcptraceroute
☐☐ e) tcpdmatch
3. Das variáveis wrapper, qual delas contém o conjunto de informações

referentes ao servidor?
☐☐ a) %H
☐☐ b) %s
☐☐ c) %d
☐☐ d) %S
☐☐ e) %h
4. Qual opção deve ser utilizada para especificar a placa de rede a ser
monitorada pelo tcpdump?
☐☐ a) –r
☐☐ b) –A
☐☐ c) –i
☐☐ d) –w
☐☐ e) –n
5. Qual filtro pode ser utilizado para ver apenas pacotes vindos do host X?
☐☐ a) dst host
☐☐ b) src host
☐☐ c) net host
☐☐ d) ip proto
☐☐ e) not host
654
Segurança 11
6. Sobre a criptografia simétrica, qual das alternativas a seguir é falsa?
☐☐ a) A chave de criptografia é única; a mesma chave usada para

criptografar é usada para decriptografar.
☐☐ b) Com chave de 40 bits, há apenas 1.099.511.627.776 possibilidades,
assim, a chance desta chave ser quebrada rapidamente é muito grande.
☐☐ c) É possível usar chaves de até 128 bits e maiores.
☐☐ d) Possui chave privada e pública.
☐☐ e) DES, RC4, RC6, Blowfish e AES são técnicas de criptografia simétrica.
7. Qual a finalidade da chave pública?
☐☐ a) Proteger o documento.
☐☐ b) Ser distribuída livremente, já que é necessária a chave privada para
decriptografar.
☐☐ c) Abrir a segurança da criptografia, pois esta chave é facilmente
encontrada.
☐☐ d) Apenas decriptografar os dados.
☐☐ e) Apenas criptografar os dados.
8. No cliente, qual pacote é preciso estar instalado?
☐☐ a) openssh-client
☐☐ b) client-ssh
☐☐ c) openssl-client
☐☐ d) client-ssl
☐☐ e) opensshssl-client
9. Qual o daemon necessário para iniciar o servidor SSH?
☐☐ a) /etc/ssh
☐☐ b) /etc/init.d/ssh
☐☐ c) /etc/init.d/ssh-init
☐☐ d) /etc/sshd
☐☐ e) /etc/init/sshd
10. Qual o arquivo de configuração do servidor SSH?
☐☐ a) /etc/ssh_config
☐☐ b) /etc/ssh/sshd_config
☐☐ c) /etc/ssh/ssh_config
☐☐ d) /etc/sshd_config
☐☐ e) /etc/init.d/sshd_conf
655
11 Segurança
Mãos à obra!
Laboratório 1 – Instalando o servidor SSH

1. Instale o pacote do SSH;
# yum install ssh
2. Inicie o serviço do SSH;
# systemctl start sshd
3. A partir do computador de outro aluno, tente conectar no seu computador.
# ssh root@[Seu IP]
Laboratório 2 – Entendendo liberações de

acesso
1. Verifique primeiramente se o serviço SSH possui apoio do TCP Wrapper:
# ldd /usr/sbin/sshd |grep libwrap
Se tiver apoio, a resposta deve ser a seguinte:
libwrap.so.0 => /lib/libwrap.so.0 (0xb76a8000)
2. Libere todos os hosts, exceto um específico. Para isso, edite o arquivo hosts.deny;
# vi /etc/hosts.deny
3. Adicione a regra para bloquear o host específico. Escolha o endereço IP de um ou-

tro aluno;
sshd: 192.168.0.X
4. Salve e saia;
:wq
5. Reinicie o serviço SSH;
systemctl restart sshd
658
Segurança 11
6. Vá até a máquina de outro aluno e tente conectar via SSH no seu computador;
7. Agora, faça o contrário: bloqueie todos e libere apenas o host do outro aluno. Para
isso, edite novamente o arquivo hosts.deny;
# vi /etc/hosts.deny
8. Adicione a seguinte regra, que bloqueará todos exceto o host do outro aluno:
sshd: ALL EXCEPT 192.168.0.X
9. Salve e saia;
:wq
10. Reinicie o serviço SSH;
# systemctl restart sshd
11. Faça o teste da máquina do outro aluno e, depois, escolha uma máquina qualquer
na sala de aula e tente conectar.
Laboratório 3 – Analisando pacotes de rede

12. Instale o tcpdump no seu computador;
# yum install tcpdump
13. Monitore as atividades da placa de rede, sendo a origem dos pacotes o computa-
dor do outro aluno (troque o X pelo endereço IP do outro aluno);
# tcpdump –i enp0s3 src host 192.168.0.X
14. Agora, monitore as atividades da placa de rede, de forma que sejam vistos apenas
os pacotes destinados ao computador do outro aluno;
# tcpdump –i enp0s3 dst host 192.168.0.X
15. Observe todo o tráfego de rede, exceto do computador do outro aluno;
# tcpdump –i enp0s3 not host 192.168.0.X
16. Agora, monitore apenas as conexões na porta 22.
# tcpdump –i enp0s3 port 22
659
Laboratório 4 – Personalizando as
configurações do servidor SSH
20. Abra o arquivo de configuração do servidor SSH;
# vi /etc/ssh/sshd_config
21. Altere a porta padrão de 22 para 4321, alterando a seguinte linha:
# What ports, IPs and protocols we listen for

Port 22
Para:
# What ports, IPs and protocols we listen for

Port 4321
22. Salve o arquivo e saia;
:wq
23. Antes de reiniciar o serviço SSH, limpe as regras de firewall e desabilite o SELinux.
Nesse caso, o servidor deverá ser reiniciado:
•• Desabilite o SELinux:
# vim /etc/selinux/config
SELINUX=disable
# systemctl reboot
•• Limpe as regras de firewall:
# iptables -F
•• Com o servidor reiniciado, reinicie o serviço do SSH:
# systemctl restart sshd
24. Teste a conexão do computador de um outro aluno;
# ssh -l root -p 4321 [Seu IP]
660
Segurança 11
25. De volta ao seu computador, edite novamente o arquivo sshd_config;
# vi /etc/ssh/sshd_config
26. Não permita mais que o usuário root conecte via SSH. Altere a seguinte linha:
PermitRootLogin yes
Para:
PermitRootLogin no
27. Salve e saia do arquivo:
:wq
28. Reinicie o serviço do SSH;
# /etc/init.d/ssh restart
29. Teste a conexão da máquina de um outro aluno;
# ssh -l root -p 4321 [Seu IP]
30. Se não obtiver sucesso (o que é esperado), tente com o usuário aluno.
# ssh -l aluno -p 4321 [Seu IP]
Laboratório 5 – Transferindo arquivo via

SCP
31. Transfira uma cópia dos seus arquivos .conf da pasta /etc para a pasta /tmp de
um outro aluno;
# scp -P 4321 /etc/*.conf root@[IP do Seu Colega]:/tmp/.
32. Verifique na máquina do outro aluno se os arquivos chegaram corretamente. Para

isso, conecte via SSH no computador do outro aluno;
# ssh -p 4321 root@[IP do Seu Colega]
661
33. Verifique se os arquivos estão no local;
# ls /tmp/*.conf
34. Transfira o arquivo de log messages do computador do outro aluno diretamente

para a sua pasta /tmp;
# scp -P 4321 root@[IP do Seu Colega]:/var/log/messages /tmp/.
35. Verifique se o arquivo chegou corretamente.
# ls -l /tmp/messages
Laboratório 6 – Conectando via SFTP em um

computador remoto
36. Acesse a pasta /tmp;
# cd /tmp
37. Conecte no computador de outro aluno;
# sftp -P 4321 root@[IP do Seu Colega]
38. No computador do outro aluno, vá para a pasta /etc;
sftp> cd /etc
39. Copie o arquivo hosts.allow para o seu computador;
sftp> get hosts.allow
40. Saia do computador remoto;
sftp> bye
41. Observe se o arquivo está no seu computador.
# ls -l hosts.allow
662
Segurança 11
Laboratório 7 – Autenticando através de
chave de criptografia
42. Considerando que o seu computador será o cliente da conexão SSH, crie as chaves
de conexão;
# ssh-keygen -t rsa -b 1024
43. Defina onde a chave será salva. Pressione ENTER apenas;
Enter file in which to save the key (/root/.ssh/id_rsa):
44. Insira a senha duas vezes (pode-se definir uma senha ou, se desejar experimentar,
deixá-la em branco; basta pressionar ENTER);
Enter passphrase (empty for no passphrase):

Enter same passphrase again:
45. Entre na pasta em que a chave foi gerada;
# cd /root/.ssh
46. Envie a chave pública para o servidor SSH (máquina do outro aluno);
# ssh-copy-id -i ./id_rsa.pub ´–p 4321 root@[IP do Seu Colega]´
47. Faça o teste de conexão na máquina do outro aluno.
# ssh -P 4321 root@[IP do Seu Colega]
663
Referências bibliográficas
Livros
TechnoEdition Editora (Org); DOMINGOS, Cesar Augusto. Linux LPI - Módulo I. 1. ed.
São Paulo: TechnoEdition Editora Ltda., 2013. 554 p.
TechnoEdition Editora (Org); DOMINGOS, Cesar Augusto. Linux LPI - Módulo II. 1. ed.
São Paulo: TechnoEdition Editora Ltda., 2013. 444 p.
664

Apostilapdf - Temp - 052.680.436-09 - Linux LPI - Administracao

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

Apostilapdf - Temp - 052.680.436-09 - Linux LPI - Administracao

Enviado por

Direitos autorais:

Formatos disponíveis

Linux LPI - Administração

Linux LPI - Administração

Copyright © Monte Everest Participações e Empreendimentos Ltda.

Linux LPI - Administração

Revisão Ortográfica e Gramatical

Capítulo 1 - Conceitos básicos .............................................................................................. 17

Capítulo 2 - Arquitetura do sistema .................................................................................. 59

2.3.2. Desligar/reiniciar o sistema................................................................. 84

Capítulo 3 - Instalação do Linux e gerenciamento de pacotes ............................... 101

Capítulo 4 - Comandos GNU e Unix .................................................................................... 155

4.1.5. Listando recursivamente..................................................................... 160

4.1.57. expand............................................................................................... 203

4.3.1. Modos de comandos e de edição......................................................... 252

Capítulo 5 - Dispositivos, Sistemas de arquivos e FHS .............................................. 293

5.2.1. Diretórios............................................................................................ 323

Capítulo 6 - Shell script e gerenciamento de dados .................................................... 375

Capítulo 7 - Interface do usuário e desktop ................................................................... 423

7.1.9. Gerenciadores de janela (window managers).......................................433

Capítulo 8 - Tarefas administrativas .................................................................................. 463

8.3.5. Comando iconv................................................................................... 503

Capítulo 9 - Serviços essenciais do sistema ................................................................... 519

Capítulo 10 - Fundamentos de rede ................................................................................... 573

10.1.3. Identificando os integrantes de uma rede............................................ 577

Capítulo 11 - Segurança ........................................................................................................... 637

Referências bibliográficas ...................................................................................................... 664

Nesse contexto, quando fazemos referência à palavra livre, é no sentido de liberdade

Todas as ferramentas desse sistema operacional estavam sendo preparadas do zero,

Os sistemas operacionais que muitos usam atualmente, através das inúmeras

•• Liberdade número 0: É a liberdade de executar o software para qualquer

•• Liberdade número 1: É estudar o funcionamento do software, podendo fazer

•• Liberdade número 2: O usuário tem a liberdade de redistribuir cópias do

•• Liberdade número 3: É a liberdade para modificar o programa e, então,

A junção dessas quatro liberdades é a essência do software livre, no qual a ideia

A história do Linux é um tanto aventureira, pois surgiu pelas mãos de um jovem

Linus Torvalds, como é mais conhecido, começou o desenvolvimento do Linux a partir

Unix-like é um termo para referenciar o padrão de sistemas operacionais Unix,

O kernel Linux é um grande exemplo de software livre licenciado utilizando-se da

Em sua primeira versão, o kernel Linux já conseguia trabalhar em conjunto com

Foi a partir dessa dificuldade que surgiram as primeiras distribuições GNU/Linux –

A maioria das distribuições existentes hoje em dia é ramificação da Slackware e de

No site DistroWatch.Com (distrowatch.com), é possível conferir a lista de

•• Distribuições livres e corporativas

A maioria das distros é mantida por comunidades de colaboradores localizados em

Dentro das distribuições livres, diferem-se ainda as convencionais, tradicionalmente

•• Distribuições from scratch e provenientes (baseadas)

1.1.4. Características herdadas do padrão Unix

1.1.5. Representação por arquivos

1.1.7. Permissão para executar arquivos

1.1.8. Arquivos e diretórios ocultos

1.1.11. Aspecto multitarefa / multiusuário

1.1.12. Estrutura do Sistema Operacional

•• Ambiente de trabalho (Desktop environment): Hospeda todos os programas

•• DM (Display Manager): Aqui são gerenciados os logins na interface gráfica e

•• ttyn: Terminais virtuais que interpretam os comandos introduzidos por um

•• Sistema Operacional: Camada que auxilia e hospeda todos os aplicativos das

•• Kernel Linux: Mediadora entre as camadas superiores e o hardware, essa

•• Hardware: Camada que compreende os dispositivos do sistema disponíveis

1.1.13. Shell, Bash e Sessões

Por se tratar de um interpretador de comandos, o bash terá diversas particularidades,

•• Terminal virtual em modo texto

O conjunto teclado/monitor conectado à máquina compreende o que chamamos

Geralmente, em servidores, o recurso de ambiente gráfico não está habilitado. Em

É possível ter acesso a outros terminais que trabalham de forma completamente