LINUX

Dominando a linha de comando, parte 1

Tutoriais
Ter fluência no uso da linha de comando é um pré-requisito para qualquer bom administrador.
Usar o prompt é, de certa forma, muito parecido com aparecer uma segunda língua. No começo é
normal que você fique catando milho e precise pesquisar e olhar as páginas de manual para se
lembrar mesmo dos comandos mais simples, mas, com o tempo, usar o terminal acaba sendo
uma coisa tão natural quanto falar ou escrever. O importante é não desanimar. Este é um tutorial
de duas partes destinado a servir como uma guia de referência para o uso da linha de comando e
dos utilitários básicos de administração do sistema. Carlos E. Morimoto
30/06/2008
Ter fluência no uso da linha de comando é um pré-requisito para qualquer bom administrador.
Usar o prompt é, de certa forma, muito parecido com aparecer uma segunda língua, onde os
comandos equivalem às palavras e a sintaxe e os argumentos usados equivalem à gramática. A
única forma de adquirir um bom vocabulário e, principalmente, de entender a gramática é
estudando, mas, por outro lado, a única forma de adquirir fluência é realmente falando, o que na
nossa analogia equivale a acumular "horas de vôo" no uso do terminal.
No começo é normal que você fique catando milho e precise pesquisar e olhar as páginas de
manual para se lembrar mesmo dos comandos mais simples, mas, com o tempo, usar o terminal
acaba sendo uma coisa tão natural quanto falar ou escrever. O importante é não desanimar.
Este é um tutorial de duas partes destinado a servir como uma guia de referência para o uso da
linha de comando e dos utilitários básicos de administração do sistema. Ela não tem o objetivo de
esgotar o assunto, mas pode ter certeza que encontrará muitas dicas.
Vamos começar com uma revisão dos comandos básicos do terminal, junto com algumas dicas
úteis.
cd : Possivelmente o comando mais básico do prompt, permite navegar entre diretórios, como em
"cd /etc". Você pode tanto indicar o caminho completo até o diretório desejado, como em "cd
/var/log/apache2", ou usar caminhos relativos, indicando o destino a partir do diretório atual. Se
você está dentro da pasta "/etc" e quer acessar a pasta "/etc/bind", precisa digitar apenas "cd
bind". Para subir um diretório, use "cd .." e, para subir dois níveis, use "cd ../..".
pwd : Serve apenas para confirmar o diretório atual. É usado sem parâmetros, simplesmente
"pwd".
ls : Lista os arquivos dentro do diretório atual. Por padrão, ele mostra apenas os nomes dos
arquivos e não mostra os arquivos ocultos. Para ver tudo, incluindo os arquivos ocultos, use "ls
-a", para ver também as permissões de acesso e o tamanho dos arquivos, use o "ls -la". Para ver
os tamanho dos arquivos especificados de forma legível ("329M" em vez de "344769698")
adicione o parâmetro "h", como em "ls -lha". Você pode ver também os arquivos de qualquer
diretório, sem ter que primeiro precisar usar o "cd" para acessá-lo. Para isso, basta indicar o
diretório, como "ls -lha /etc".
Em muitas distribuições, como no CentOS, o "ls" mostra uma listagem colorida, que torna fácil
identificar os arquivos (pastas aparecem em azul, arquivos compactados em vermelho e assim por
diante), o que torna mais fácil identificar os arquivos. Para ativar esse recurso em outras
distribuições, adicione a linha:
alias ls="ls --color=auto"

... no final do arquivo "/etc/profile".

Outra personalização muito usada é fazer com que os comandos "rm", "cp" e "mv" peçam
confirmação, o que reduz a possibilidade de causar danos catastróficos ao digitar comandos
incorretos. Para isso, adicione as três linhas abaixo no final do arquivo "/etc/profile":
alias rm="rm -i"
alias mv="mv -i"
alias cp="cp -i"

cp : O cp é um comando aparentemente simples, mas que esconde vários segredos. A sintaxe

básica para copiar arquivos é usar o comando cp, seguido do nome do arquivo e a pasta para
onde ele vai, como em "cp /etc/fstab /tmp". Entretanto, em sua forma básica o cp serve apenas
para copiar arquivos isolados; para copiar pastas, é necessário que você adicione a opção "-r"
(que ativa a cópia recursiva), como em "cp -r /home/gdh/* /backup/".
Um parâmetro bastante útil é o "-a", que faz com que o cp sempre copie recursivamente,
mantenha as permissões do arquivo original e preserve os links simbólicos que encontrar pelo
caminho. Em resumo, faz o cp se comportar de uma forma mais simples e lógica, por isso você
acaba usando-o quase sempre, em substituição ao "-r", como em:
# cp -a /var/www /mnt/sda2/backup/

Você pode ainda usar o "*" e a "?" como curingas quando quiser copiar vários arquivos. Para
copiar todos os arquivos da pasta atual para a pasta "/mnt/hda6", por exemplo, use "cp *
/mnt/hda6". A "?" por sua vez é mais contida, substituindo um único caractere. Por exemplo, "cp
arquivo?.txt /mnt/hda6", copia o "arquivo1.txt", "arquivo2.txt" e o "arquivo3.txt", mas não o
"arquivo21.txt".
mv : O mv serve tanto para mover arquivos de um lugar para o outro, quanto para renomear
arquivos, como em:
# cd /etc/squid
# mv squid.conf squid.conf.modelo

rm : Por padrão, o rm deleta apenas arquivos simples, como em "rm arquivo.txt". Para que ele
remova pastas, é necessário adicionar parâmetro "-r", como em "rm -r arquivos/". Em muitas
distribuições, o padrão do rm é pedir confirmação antes de remover cada arquivo, o que se torna
inviável ao remover um diretório com diversos arquivos. A confirmação é eliminada ao adicionar o
parâmetro "-f", o que nos leva ao "rm -rf" (que é o formato mais comumente usado).
Tome cuidado ao usar o "-rf", pois ele não pede confirmação, deleta os arquivos diretamente. Você
pode muito bem pensar em digitar "rm -rf ./*" (para apagar todos os arquivos do diretório atual) e,
na pressa, acabar digitando "rm -rf /*", que apaga todos os arquivos do sistema, incluindo arquivos
em todas as partições e em todos os compartilhamentos de rede que estiverem montados (!). Ou
seja, ao usá-lo, respire fundo e verifique se realmente está deletando a pasta certa antes de
pressionar Enter.
É possível também usar caracteres curingas na hora de remover arquivos. Para remover todos
que possuírem a extensão ".jpg", use "rm -f *.jpg". Para remover todos os arquivos que
começarem com "img", use "rm -f img*". Lembre-se de que você pode usar também o "?" quando
quiser usar o curinga para apenas um caractere específico. Se você quiser remover os arquivos
"doc1.txt", "doc2.txt" e "doc3.txt", mas sem remover o "doc10.txt" e o "doc11.txt", você poderia
usar o comando "rm -f doc?.txt".
mkdir : Cria diretórios, como em "mkdir trabalhos" ou "mkdir /mnt/backup". Para criar pastas
recursivamente (ou seja, criar todas as pastas necessárias até chegar a que você pediu, caso
necessário), adicione o parâmetro "-p", como em:
# mkdir -p /var/log/apache2
rmdir : Remove diretórios. A diferença entre ele e o "rm -f" é que o rmdir remove apenas diretórios
vazios, evitando acidentes.
du : O du permite ver uma lista com o espaço ocupado por cada pasta dentro do diretório atual. É
uma forma rápida de encontrar grandes arquivos ou pastas que estão consumindo muito espaço,
como no caso de logs não rotacionados que crescem a ponto de ameaçarem ocupar todo o
espaço livre na partição raiz do sistema.
man : É impossível para um ser humano (pelo pelo para um ser humano normal ;) memorizar
todos os parâmetros de mais do que um punhado de comandos. Assim como em outras áreas,
você memoriza os parâmetros que usa com mais freqüência e tem apenas uma vaga noção sobre
os demais.
O prompt inclui um sistema de ajuda bastante detalhado, acessível através do comando man. Não
apenas os comandos, mas também a grande maioria dos arquivos de configuração possuem
páginas de manual com os parâmetros suportados. O principal objetivo das páginas de manual é
listar as opções suportadas e não necessariamente serem uma leitura didática. Elas são mais
úteis quando você já tem uma boa noção sobre o que o comando faz e precisa se lembrar de uma
opção específica do que como um guia de estudos. Para usar, basta chamar o "man" seguido do
comando desejado, como em "man ls".
Dentro do leitor, use as setas para rolar a tela e, para sair, pressione a tecla "q". Como falei,
existem manuais também para a muitos dos arquivos de configuração. Experimente usar o "man
fstab" ou "man resolv.conf", por exemplo.
Um pequeno truque é que você pode salvar o conteúdo das páginas do man em arquivos de texto
(de forma a abrí-los em outro editor de texto, ou imprimir), direcionando a saída do comando para
o arquivo desejado, como em:
$ man ls > ls.txt

A seta faz com que a saída do comando seja direcionada, indo para dentro do arquivo em vez de
ser exibida na tela. O arquivo é automaticamente criado, caso não exista. Ao usar uma única seta
(>) como no exemplo, o conteúdo do arquivo é subscrito, por isso é preciso um certo cuidado ao
usar. Outra opção é usar duas setas (>>), o que faz com que o conteúdo seja adicionado ao final
do arquivo, em vez de substituir o conteúdo anterior. As setas são exaustivamente usadas em
shell scripts, pois permitem direcionar a saída de um comando para o outro, permitindo que eles
sejam combinados das mais diversas formas.
Devido à quantidade de parâmetros disponíveis, os manuais de muitos programas são muito
longos e complicados. Por isso, muitos suportam o parâmetro "--help", que exibe uma ajuda
resumida, contendo apenas os parâmetros mais usados. Experimente, por exemplo, o "ls --help".
Se você quiser apenas uma descrição rápida do que um determinado comando faz, experimente o
comando "whatis" (o que é), como em: "whatis ls".
Mais uma variante do man é o comando "info", que contém manuais alternativos para muitos
comandos. Enquanto os manuais do man são técnicos, desenvolvidos para serem manuais de
referência, os do info normalmente utilizam uma linguagem mais simples, abordando apenas as
opções mais comuns. Nem todos os comandos possuem uma página info, mas o número vem
crescendo. Para usá-lo, basta digitar "info comando", como em "info ls". Se por acaso o
comando "info" não estiver disponível, instale-o usando o gerenciador de pacotes, como em "apt-
get install info".
locate : Este é outro comando bastante útil. Ele permite encontrar arquivos de forma instantânea,
servindo como uma espécie de busca indexada. Assim como mecanismos de busca, como o
Google, o locate não sai procurando em todo o HD até achar o arquivo que pediu; ele procura
apenas dentro de uma base de dados, que contém os nomes de todos os arquivos. Esta base é
gerada ao rodar o comando "updatedb", que precisa ser executado pelo menos uma vez antes
que você possa usá-lo.
A vantagem de usar a base de dados é que as buscas são instantâneas, a desvantagem é que
você precisa rodar o updatedb (como root) de vez em quando, a fim de incluir as últimas
modificações. Para procurar um arquivo, simplesmente use "locate arquivo". Se você está
procurando por um programa, experimente o comando "which", uma variante do locate que
mostra apenas executáveis.
find : O find também permite localizar arquivos, mas funciona da forma tradicional, realmente
vasculhando os diretórios em busca dos arquivos, ao invés de usar uma base de dados, como o
locate. Embora seja lento ao procurar em diretórios com muitos arquivos e subdiretórios, o find é
eficiente se você souber previamente onde procurar. Por exemplo, o diretório "/etc" concentra as
configurações do sistema. Se você estiver procurando pelo arquivo "smb.conf" (onde é
armazenada a configuração do Samba), você poderia ir direto à fonte, usando o comando "find
/etc -name smb.conf".
Note que além do diretório onde ele vai procurar (/etc no exemplo), você deve usar o parâmetro "-
name" antes de indicar o nome do arquivo que está procurando. Omitindo o diretório, ele
simplesmente procura dentro do diretório atual. Você pode também fazer buscas por todos os
arquivos com uma determinada extensão, como em "find /mnt/hda6 -name *.mp3".
su: No Linux, existe uma separação clara entre o root e os demais usuários do sistema. O root é o
único que pode alterar a configuração do sistema e usar a maior parte das ferramentas de
configuração. Os usuários normais, por sua vez, podem usar os programas instalados e modificar
arquivos dentro do seu diretório home. Esta organização permite que várias pessoas usem o
mesmo micro (o que é vital no caso dos servidores), sem que um possa alterar as configurações
do outro, nem muito menos mudar as configurações do sistema.
O su permite que você se "promova" a root a qualquer momento. O uso básico é simplesmente
digitar "su -", seguido da senha, como em:
$ su -

Password:

O "$" do terminal vira um "#", alertando que a partir daí você tem plenos poderes. Se ao tentar
abrir arquivos gráficos você receber uma mensagem dizendo que não é possível se conectar ao
X, experimente usar o comando "sux" (se ele não estiver disponível, instale o pacote "sux") no
lugar do su. Ele configura as permissões do servidor X corretamente.
sudo : O Ubuntu e outras distribuições derivadas dele utilizam o sudo como um substituto à senha
de root. Neles, a conta de root vem desativada por padrão e você executa comandos como root
incluindo o "sudo" no início do comando, como em "sudo gedit /etc/fstab". Se preferir voltar ao
sistema tradicional, usando o "su -" para se logar como root, basta destravar a conta de root
usando o comando "sudo passwd".
Assim como outros utilitários, o sudo possui um arquivo de configuração, o "/etc/sudoers", que
permite definir quais usuários poderão usar o sudo e dentro de quais limitações. No Ubuntu,
apenas o usuário administrativo criado durante a instalação pode usar o sudo, o que é
determinado pela linha:
%admin ALL=(ALL) ALL

... dentro do arquivo. Isso faz com que todos os usuários do grupo "admin" (que originalmente
contém apenas o usuário criado durante a instalação) possam usar o sudo para executar qualquer
comando (ALL). Por segurança, o sudo solicita sua senha de usuário ao executar qualquer
comando, uma última linha de proteção contra a possibilidade de alguém usar seu micro quando
você não estiver por perto. Se preferir desativar a verificação, substitua a linha por:
%admin ALL=NOPASSWD: ALL
Se quiser "promover" outros logins, criados depois da instalação, de forma que eles também
possam executar comandos usando o sudo, basta adicioná-los ao grupo "admin", como em:
# adduser gdh admin

cat : Além de permitir ver rapidamente o conteúdo de um arquivo, como em "cat /etc/fstab", ele
também pode ser combinado com outros comandos para realizar tarefas mais complexas. Por
exemplo, se você tem um arquivo "boot.img" com a imagem de um disquete de boot, não bastaria
simplesmente copiar o arquivo para o disquete com o comando cp; você precisaria fazer uma
cópia bit a bit. Existem várias formas de fazer isso, mas uma solução simples seria usar o
comando "cat boot.img > /dev/fd0". Neste caso, ele lista o conteúdo do arquivo, mas ao invés de
mostrar na tela ele o escreve no disquete (/dev/fd0). Você verá muitos usos úteis para estes
recursos especiais ao estudar sobre shell script.
&: No Linux, todos os aplicativos, mesmo os gráficos, podem ser chamados a partir de uma janela
de terminal. O problema é que, ao chamar algum aplicativo, o terminal ficará bloqueado até que o
aplicativo seja finalizado, obrigando-lhe a abrir um para cada programa.
Acrescentar o & no final do comando, como em "gedit /etc/fstab &" resolve este problema,
mantendo o terminal livre. Se você esquecer de acrescentar ao "&" ao abrir um programa, ainda
pode "destravar" o terminal pressionando "Ctrl+Z" (que paralisa o programa e te devolve o
controle do terminal) e depois "bg", que reinicia o programa em background.
Alguns aplicativos exibem mensagens diversas e avisos depois de serem abertos, o que "suja" o
terminal, mas sem comprometer o que você está fazendo. Se isto te incomodar, você pode
adicionar um "&>/dev/null" ao comando, o que descarta todas as mensagens, como em:
$ konqueror ~ & &>/dev/null

O "~" é uma variável do terminal, que representa seu diretório home. Você pode usá-lo para
abreviar comandos: para copiar a pasta "/mnt/sdc1/arquivos" para sua pasta home, você pode
usar "cp -a /mnt/sdc1/arquivos ~", ao invés de digitar "cp -a cp -a /mnt/sdc1/arquivos /home/gdh",
por exemplo.
head: Este é um dos primos do cat, ele permite ver apenas as primeiras linhas do arquivo, ao
invés de exibir tudo. Basta especificar o número de linhas que devem ser exibidas, como por
exemplo "head -20 /var/log/apache2/access.log".
Outro parente distante é o tail (cauda), que mostra as últimas linhas do arquivo. O uso é o
mesmo, basta indicar o número de linhas que devem ser mostradas e o nome do arquivo, como
em "tail -50 /var/log/squid/access.log". Como pode imaginar, ele é muito útil para acompanhar
arquivos de log, que são atualizados continuamente. Como as novas entradas destes arquivos
vão sendo inseridas no final do arquivo, o tail permite verificar rapidamente apenas as novas
inclusões, sem precisar perder tempo abrindo o arquivo inteiro.
Você pode obter um monitor de logs simples combinando o tail com o comando "watch", que
permite executar um comando a cada 2 segundos, atualizando a tela automaticamente. Para
acompanhar os logs de acesso do seu servidor web, por exemplo, você poderia usar:
# watch tail -n 20 /var/log/apache2/access.log

Para acompanhar os logs do Squid, você usaria:

# watch tail -n 20 /var/log/squid/access.log

... e assim por diante.

| (pipe): Junto com as setas de redirecionamento (> e >>), o pipe ( | ) é muito usado em scripts e
comandos diversos. Ele permite fazer com que a saída de um comando seja enviada para outro
ao invés de ser mostrada na tela. Parece uma coisa muito exótica, mas acaba sendo
incrivelmente útil, pois permite "combinar" diversos comandos que originalmente não teriam
nenhuma relação entre si, de forma que eles façam alguma coisa específica.
Um dos usos mais corriqueiros é usar o pipe e o grep para filtrar a saída de outros comandos,
procurando por alguma informação específica. Imagine por exemplo que você quer ver todas as
entradas referentes a um determinado endereço IP no log do Apache (ou do Squid, ou de
qualquer outro serviço). Você pode usar o comando cat para exibir5 o arquivo de log e usar o pipe
e o grep para filtrar a saída, de forma que ele exiba apenas linhas contendo algum endereço
específico, como em:
# cat /var/log/apache2/access.log | grep 200.101.213.68

Outro exemplo simples: sua placa de rede não está funcionando e você quer saber se o módulo
de kernel "sis900", que dá suporte a ela, está carregado. Você pode ver os módulos que estão
carregados usando o comando "lsmod", mas a lista é um pouco longa. Você poderia completar o
lsmod com "| grep sis900", que vai filtrar usando o grep, mostrando na tela apenas as linhas
contendo "sis900". O comando ficaria então "lsmod | grep sis900". Se não aparecer nada na tela,
você sabe de antemão que o módulo não está ativo, Neste caso, você poderia tentar carregá-lo
manualmente usando o comando "modprobe sis900", como root.
wget : O wget é um gerenciador de downloads bastante competente, que oferece um grande
volume de opções, todas usadas via linha de comando. Isso torna ele ideal para situações em que
você está acessando um servidor remoto via SSH e precisa baixar um grande arquivo, ou um
pacote de instalação. Em vez de primeiro baixar o arquivo para a sua máquina e depois transferí-
lo para o servidor, você pode fazer com que o arquivo seja baixado diretamente pelo servidor,
economizando tempo.
O uso mais básico é usar o wget seguido da opção "-c", que faz com que ele continue o download
caso interrompido, como em:
# wget -c http://download3.vmware.com/software/vmserver/VMware-server-1.0.5-80187.tar.gz

Caso a conexão esteja ruim e a transferência esteja parando freqüentemente, você pode
especificar um timeout usando a opção "-T", ela faz com que o wget reinicie a transferência caso
não receba dados dentro do tempo especificando (em segundos), como em:
# wget -c -T 30 http://download3.vmware.com/software/vmserver/VMware-server-1.0.5-
80187.tar.gz

Uma dica é que você pode selecionar a URL do arquivo a ser baixado na janela do navegador e
colar o texto no terminal usando o botão central do mouse. Se você estiver usando o konsole ou o
nome-terminal, você pode também colar o texto da área de transferência clicando com o botão
direito sobre o terminal e usando a opção "colar".
ln : O comando ln permite criar links. Existem dois tipos de links suportados pelo Linux, os hard
links e os soft links (também chamados de links simbólicos) Os soft links são os mais simples e
também os mais usados, eles desempenham a função de um atalho simples, que aponta para um
arquivo ou pasta.
O sistema trata o link da mesma forma que o arquivo, de forma que ao gravar informações no link,
ou acessar seu conteúdo você está na verdade trabalhando diretamente no arquivo. A principal
exceção é que ao mover, deletar ou renomear o link, você altera apenas o link propriamente dito e
não o arquivo. Um soft link é um atalho estático, ao mover ou deletar o arquivo, o link fica
quebrado.
Os hard links por sua vez são mais intimamente ligados ao arquivo e são alterados junto com ele.
Se o arquivo muda de lugar, o link é automaticamente atualizado. Isto é possível porque nos
sistemas de arquivos usados pelo Linux cada arquivo possui um código de identificação (o inode),
que nunca muda. O sistema sabe que o arquivo renomeado é o mesmo do atalho simplesmente
procurando-o pelo inode ao invés do nome. A grande limitação é que os hard links podem ser
criados apenas se o link e o arquivo de destino estão dentro da mesma partição. Este é um dos
motivos dos links simbólicos serem mais usados.
Se usado sem argumentos, o comando ln cria um hard link, como em:
$ ln /var/www/gdhpress/arquivo /home/gdhpress/arquivo

Para criar um link simbólico, acrescente o argumento "-s", como em:

$ ln -s /var/www/gdhpress/html/ /home/gdhpress/html

Você verá muitos links espalhados pela estrutura de diretórios do Linux, um recurso muito usado
quando os arquivos de sistemas mudam de lugar numa nova versão. Mantendo um link na
localização antiga, todos os programas antigos continuam funcionando.
tar : O comando tar pode ser usado para empacotar, compactar e descompactar arquivos, por
isso ele acaba sendo uma ferramenta extremamente usada. Por exemplo, para descompactar um
arquivo com a extensão .tar.gz, pelo terminal, você usaria o comando:
$ tar -zxvf arquivo.tar.gz

Aqui o "tar" é o comando e o "-zxvf" são parâmetros passados para ele. O tar permite tanto
compactar quanto descompactar arquivos e pode trabalhar com muitos formatos de arquivos
diferentes, por isso é necessário especificar que ele deve descompactar o arquivo (-x) e que o
arquivo está comprimido no formato gzip (z). O "v" é na verdade opcional, ele ativa o modo
verbose, onde ele lista na tela os arquivos extraídos e para onde foram.
Se você tivesse em mãos um arquivo .tar.bz2 (que usa o bzip2, um formato de compactação
diferente do gzip), mudaria a primeira letra dos parâmetros, que passaria a ser "j", indicando o
formato, como em:
$ tar -jxvf arquivo.tar.bz2

O tar permite também compactar arquivos e pastas diretamente através do terminal. Nesse caso,
trocamos a opção "x" (extract) por "c" (create) e passamos a indicar o arquivo que será criado e a
pasta ou arquivo que será comprimido, como em:
$ tar -zcvf backup.tar.gz /var/www/gdhpress

Nesse exemplo, criamos o arquivo "backup.tar.gz" incluindo o conteúdo da pasta especificada. O

formato do arquivo não é indicado pela extensão, mas sim pelo parâmetro "z" incluído no
comando.
Se você preferir compactar a pasta usando o bzip2, que é mais demorado, mas em compensação
resulta em arquivos menores, pode substituir o "z" por "j", como em:
$ tar -jcvf backup.tar.gz /var/www/gdhpress

Histórico: O terminal mantém um histórico dos últimos 500 comandos digitados, que é salvo
automaticamente no arquivo ".bash_history", dentro do diretório home.
Para repetir um comando recente, simplesmente pressione as setas para cima ou para baixo até
encontrá-lo. Para exibir a lista dos comandos anteriores, use o comando "history", como em:
# history

1 joe /etc/init.d/firewall
2 echo 1 > /proc/sys/net/ipv4/tcp_syncookies
3 apt-get install postfix
4 joe /etc/postfix/main.cf
5 tail -n 30 /var/log/apache2/access.log

Como você pode ver, os comandos são numerados, de acordo com a ordem em que foram
digitados. Inicialmente a lista será pequena, mas com o tempo ela acumulará várias dezenas de
comandos. Um recurso interessante é a possibilidade de re-executar qualquer comando da lista
chamando-o pelo número, basta usar uma exclamação seguida pelo número com o qual o
comando aparece na lista (sem espaço, como em "!23" ou "!4"). Se quisesse executar novamente
o comando "echo 1 > /proc/sys/net/ipv4/tcp_syncookies" que aparece como número 2 da lista, por
exemplo, usaria:
# !2

Como pode ver, o histórico é uma ferramenta bastante útil para lembrar e executar rapidamente
comandos muito longos, ou comandos que você executa com freqüência. Você pode também
fazer buscas usando o pipe e o grep como em "history | grep cp" (que mostra todas as entradas
onde foi usado o comando cp) ou "history | grep apt-get" (que mostra todos os comandos onde foi
usado o apt-get).
Ponto e vírgula: Você também pode executar uma fila de comandos de uma vez. Basta separá-
los por ponto e vírgula, como em "ls; pwd" ou "cd /mnt/arquivos; ls".
O ponto e vírgula permite também que você agrupe diversos comandos, de forma que eles sejam
executados em ordem. Se você precisa baixar 3 arquivos ISOs, por exemplo, você pode agrupar 3
comandos do wget, cada um com um dos arquivos em uma única linha, separados por ponto e
vírgula, como em:
$ wget -c http://url/cd1.iso; wget http://url/cd2.iso; wget http://url/cd3.iso

Com isso, os 3 arquivos são baixados seqüencialmente, sem necessidade de intervenção.

Case Sensitive: Salvo poucas exceções, todos os comandos e parâmetros dentro de arquivos de
configuração são case-sensitive, ou seja, precisam ser digitados literalmente, respeitando as
maiúsculas e minúsculas.
Na maioria dos casos, tantos os comandos quanto os parâmetros suportados por eles utilizam
letras minúsculas, mas existem exceções, como no caso do comando "MySecureShell" (um shell
alternativo para download de arquivos), que precisa ser digitado assim mesmo, com o M e os dois
S maiúsculos. Existem ainda muitos casos de comandos que suportam parâmetros com letras
maiúsculas e minúsculas, com resultados diferentes.
O comando "ls -s", por exemplo, mostra o tamanho dos arquivos na listagem, enquanto o "ls -S"
mostra os arquivos organizados por tamanho (o maior primeiro). Existe um número grande demais
de exemplos para citar aqui, o importante é ter em mente que eles existem.
reboot: Reinicia o sistema. Faz par com o halt, que faz o desligamento completo. De uma forma
geral, você nunca deve usar o comando "halt" em um servidor remoto, pelo simples fato de que
você precisará de alguém no local para ligá-lo novamente depois. Nos poucos casos em que é
realmente necessário reiniciar o sistema (como ao atualizar o kernel), use sempre o reboot.
shutdown: Também serve para desligar ou reiniciar o sistema, mas permite que você especifique
um horário. É bastante útil no caso dos servidores, pois permite que você agende os reboots do
sistema, fazendo-os em horários de baixa demanda.
Especifique um tempo em minutos que o sistema esperará antes de desligar, usando o parâmetro
"+" como em shutdown -r +60. Você pode ainda especificar um horário, no formato hh:mm como
em shutdown -r +06:00 (para desligar às 6:00 da manhã). Substitua o "-r" por "-h" se quiser
desligar o sistema em vez de reiniciar.
Atalhos : Finalizando esta seção de dicas iniciais, aqui vai uma pequena lista de atalhos úteis:
Ctrl+L : Limpa a tela, atalho para o comando "clear". Ao usar bastante o terminal, você acaba se
acostumando a usá-lo bastante.
Ctrl+C : Este é um dos atalhos mais usados no terminal, ele serve para terminar a execução de
qualquer comando. Se você digitou um "tar -zcvf arquivos.tar.gz /mnt/arquivos" e quer abortar o
backup para fazê-lo em outra hora, ou se algum programa bloqueou o teclado e você quer
finalizá-lo na marra, o Ctrl+C é a solução.
CTRL+L : Atalho para o comando logout, que encerra a sessão atual. Se você usou o comando
"su -" para virar root, o Ctrl+L vai fazê-lo voltar ao prompt inicial. Pressionando Ctrl+L mais uma
vez, você faz logout, fechando o terminal.
Ctrl+Alt+Del: Na maioria das distribuições, o Ctrl+Alt+Del é um atalho para o comando "reboot",
que reinicia o sistema. Entretanto, ele só funciona se usado em um dos terminais de texto puro.
Se usado dentro do modo gráfico, o atalho é lido gerenciador, que provavelmente mostrará a
opção de fazer logout.

Bash_completion e path

Dominando a linha de comando, parte 1

Carlos E. Morimoto
30/06/2008
Um dos recursos mais úteis do terminal é o uso da tecla TAB para completar comandos, o famoso
bash_completion, ou auto-completar. Pressionando a tecla TAB uma vez o interpretador tenta
completar o comando automaticamente e, se houver mais de uma possibilidade, o segundo toque
faz com que ele liste as opções. Usar a tecla TAB não ajuda apenas a reduzir o volume de teclas
digitadas e assim reduzir o tempo necessário para digitar os comandos, mas também ajuda você
a se lembrar de comandos que não usa com freqüência e reduz os erros de digitação.
Por estranho que possa parecer, este recurso tão útil vem desativado na maioria das distribuições,
mas ativá-lo é bastante simples; basta adicionar a seguinte linha no arquivo "/etc/profile":
[ "$PS1" -a -f /etc/bash_completion ] && . /etc/bash_completion

Naturalmente, para que a linha funcione, é necessário que o arquivo "/etc/bash_completion" esteja
presente. Na maioria das distribuições, ele faz parte do pacote do bash, o que faz com que já
venha pré-instalado e pronto para usar, mas existem algumas exceções notáveis, como no caso
do CentOS.
Nesses casos, baixe o arquivo .tar.gz no http://freshmeat.net/projects/bashcompletion/,
descompacte e copie o arquivo manualmente para a pasta /etc.

Path: Por padrão, o sistema procura por comandos a executar apenas dentro de algumas pastas
específicas. Este conjunto de pastas é chamado de "PATH" e é armazenado em uma variável de
sistema com o mesmo nome. Você pode ver a lista usando o comando:
$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/bin/X11:/usr/games

A pasta "/bin" contém utilitários básicos do sistema, como os comandos cat, cp, mv e rm. A maioria
dos executáveis de programas instalados vão para a pasta "/usr/bin", incluindo programas
Se você executar o mesmo comando como root, você vai ver que a lista de pastas é um pouco
diferente:
$ su -
# echo $PATH

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

Como você pode ver, o PATH do root inclui também os diretórios "/usr/sbin" e "/usr/local/sbin".
Estas duas pastas são reservadas a comandos que podem ser executados apenas pelo root.
Se você tentar executar qualquer comando que não esteja em uma das pastas listadas no PATH,
receberá um "command not found", mesmo que o arquivo esteja dentro da pasta atual.
Nesse caso, é necessário especificar o caminho completo para o arquivo, como em:
# /home/root/NVIDIA-Linux-x86-1.0-9746-pkg1.run

Se o arquivo estiver dentro do diretório atual, você pode executá-lo incluindo um "./" (que indica o
diretório atual), como em:
# ./NVIDIA-Linux-x86-1.0-9746-pkg1.run

Se, ao tentar executar o arquivo você receber um "Permission denied" (mesmo como root), falta
marcar a permissão de execução do arquivo. Por padrão, qualquer arquivo baixado ou copiado de
outro lugar é criado com a permissão de execução desmarcada, de forma a evitar avidentes. Você
precisa ativá-la manualmente antes de executar, como em:
# chmod +x NVIDIA-Linux-x86-1.0-9746-pkg1.run
Dominando a linha de comando, parte 2

Tutoriais
Ter fluência no uso da linha de comando é um pré-requisito para qualquer bom administrador.
Usar o prompt é, de certa forma, muito parecido com aparecer uma segunda língua. Nesta
segunda parte do tutorial, veremos dicas sobre os editores de texto, gerenciamento de usuários,
gerenciamento de processos e recuperação do sistema em casos de problemas no boot.Carlos E.
Morimoto
04/07/2008

Ao trabalhar com a configuração manual dos serviços, o editor de textos acaba sendo sua
principal ferramenta de trabalho. Existem inúmeros editores de texto no Linux, boa parte deles são
voltados para programação, com suporte a reconhecimento de sintaxe e diversas outras funções
úteis para programação, mas também existem editores mais simples, destinados a quem quer
simplesmente editar e salvar arquivos de texto, sem muita firula.
Alguns exemplos de editores gráficos comumente usados são o kedit e kwrite no KDE, e o gedit
no Gnome. O grande problema com eles é que eles são ferramentas gráficas, que não estarão
disponíveis quando você estiver configurando um servidor sem o ambiente grpafio instalado via
SSH. Chegamos então aos editores de texto puro, como o joe, nano, mcedit e o vi.
Em qualquer um deles, a sintaxe básica é o comando do editor seguido pelo arquivo que deseja
editar, como em:
# joe /etc/fstab

O mais simples é o mcedit. Ele faz parte do pacote "mc", que é encontrado em todas as
distribuições. Ele normalmente não vem instalado por padrão, mas você resolve isso rapidamente
instalando o pacote manualmente, como em:
# apt-get install mc

No mcedit as funções são acessadas usando as teclas F1 a F10, com uma legenda mostrada na
parte inferior da tela. Para salvar você pressiona F2 e para sair, F10. Ele é provavelmente o editor
mais fácil de usar, a grande limitação é que ele não permite que você cole texto de outras janelas
usando o botão do meio do mouse, um recurso extremamente útil ao copiar exemplos e modelos
de configuração.
O joe é um meio termo. Ele é um editor simples e leve, muito parecido com o antigo Wordstar do
DOS e usa as mesmas teclas de atalho que ele. Para salvar o arquivo e sair, você pressiona
"Ctrl+K" e depois "X", para salvar sem sair o atalho é "Ctrl+K" seguido de "D". Para sair
descartando as alterações, pressione "Ctrl+C", para abrir a janela de ajuda, com os atalhos para
as demais funções pressione "Ctrl+K", "H" e, novamente "Ctrl+K", "H" para fechá-la.
O nano é outro editor de texto simples e leve, daí o nome. Para salvar e sair, pressione "Ctrl+X",
depois "S" e Enter, para sair sem salvar pressione "Ctrl+X" e "N" e, para apenas salvar, use o
"Ctrl+O". Assim como o mcedit, o joe e o nano não vêm pré-instalados na maioria das
distribuições, mas você pode instalá-los rapidamente usando o gerenciador de pacotes, como em:
# apt-get install joe nano
Finalmente, temos o vi, que por algum motivo conquistou um grupo de usuários fiéis ao longo de
seus quase 30 anos de vida e, graças eles, continua vivo até hoje, muito embora seja um dos
editores menos amigáveis.
O vi tem três modos de operação: comando, edição e o modo ex. Ao abrir o programa, você
estará em modo de comando; para começar a editar o texto, pressione a tecla "i". A partir daí, ele
funciona como um editor de textos normal, onde o Enter insere uma nova linha, as setas movem o
cursor, etc.
Quando terminar de editar o arquivo, pressione "Esc" para voltar ao modo de comando e em
seguida "ZZ" (dois Z maiúsculos) para salvar o arquivo e sair. Para sair sem salvar pressione Esc
e digite ":q!" (exatamente como aqui, dois pontos, quê, exclamação, seguido de Enter). Uma
segunda opção para salvar e sair é pressionar Esc seguido de ":wq". Para apenas salvar, sem
sair, pressione Esc seguido de ":w" e para sair sem salvar use o Esc seguido de ":q!".
Resumindo, o Esc faz com que o vi volte ao modo de comando, o ":" nos coloca no modo ex, onde
podemos salvar e fechar, entre outras funções. O "q" fecha o programa, o "w" salva o arquivo e o
"!" é uma confirmação.
Embora não seja exatamente pequeno (se comparado a editores mais simples, como o joe ou o
nano), muito menos fácil de usar, o vi é praticamente o único editor que pode ser encontrado em
qualquer distribuição.
Uma observação é que o Debian o Ubuntu e outras distribuições derivadas deles utilizam o nvi
como editor padrão, no lugar do vi tradicional. Ele se comporta de forma estranha e é bastante
improdutivo. Se você gosta do vi, recomendo que instale o vim, que é a versão completa do editor:
# apt-get install vim
Continuando, ao sair do editor, volta para o terminal. Você pode verificar se o arquivo realmente
foi salvo corretamente usando o cat, como em "cat /etc/fstab". No caso de arquivos longos,
acrescente "| more", que permite ler uma página de cada vez, como em "cat /var/log/syslog |
more".

Acertando o relógio

Dominando a linha de comando, parte 2

Carlos E. Morimoto
04/07/2008
O horário do sistema é mais uma configuração importante em um servidor, já que ele é usado nos
logs gerados, nos atributos dos arquivos e assim por diante. Se o relógio do servidor está errado,
todos os logs serão gerados com horários incorretos, sem falar nos horários dos e-mails enviados
através do servidor e de diversos outros problemas.
A questão do horário é tão importante que existe um protocolo de rede destinado a solucionar o
problema, o NTP (Network Time Protocol). Para usá-lo, o primeiro passo é verificar se os pacotes
"ntp" e "ntpdate" estão instalados no sistema. Nas distribuições derivadas do Debian, você pode
instalá-los rapidamente usando o apt-get:
# apt-get install ntp ntpdate
No Fedora e no CentOS o pacote "ntp" vem instalado por padrão, mas em caso de dúvida você
pode verificar a instalação usando o yum.
Uma vez instalado, o ntp passa a ajustar o relógio do sistema de forma transparente, mantendo o
relógio sincronizado em relação aos servidores especificados no arquivo "/etc/ntp.conf". Você
pode checar o horário do sistema usando o comando date:
# date
Thu Jun 19 14:26:37 BRT 2008
Devido à forma como trabalha, ajustando o relógio de forma suave, poucos segundos de cada
vez, o NTP é destinado a manter o horário sincronizado, mas não a acertar o relógio do sistema
em caso de grandes atrasos. Esta função é reservada ao comando "ntpdate", que ajusta o relógio
"na marra", independentemente de quão grande seja o atraso:
# ntpdate -u pool.ntp.org
A opção "-u" faz com que ele utilize uma porta UDP alta, evitando que você precise manter a porta
123 aberta no firewall e o "pool.ntp.org" é um servidor público, que encaminha a sua requisição a
algum servidor geograficamente próximo. Você pode especificar outro servidor diretamente se
preferir.
Se o horário aparecer atrasado ou adiantado em algumas horas, é sinal de que o fuso-horário do
sistema não foi definido corretamente. Nesse caso, ajuste a configuração usando o comando
"tzselect", também executado como root. Se o servidor utiliza o horário de Brasília (UTC -3), por
exemplo, você usaria as opções "2) Americas > 9) Brazil > 8) S & SE Brazil (GO, DF, MG, ES, RJ,
SP, PR, SC, RS)".

Gerenciamento de usuários

Dominando a linha de comando, parte 2

Carlos E. Morimoto
04/07/2008
Embora desenvolvido de forma independente, o Linux é um sistema Unix, que herda os recursos
multiusuário desenvolvidos desde os primeiros sistemas Unix, usados nas décadas de 70 e 80.
Isso permite que o sistema seja usado por inúmeros usuários simultaneamente, sem que um
atrapalhe as atividades do outro, nem que possa alterar seus arquivos. Dois exemplos extremos
seriam um servidor LTSP, onde dezenas de usuários podem rodar aplicativos simultaneamente,
via rede, através de terminais burros conectados ao servidor principal, e um servidor web de
shared hosting, que pode hospedar milhares de sites diferentes, cada um administrado por um
usuário diferente.
As restrições básicas de acesso são implementadas através de um sistema de permissões
simples, porém eficiente, que consiste num conjunto de três permissões de acesso (ler, gravar e
executar) e três grupos (dono, grupo e outros), que combinadas permitem fazer muita coisa.
Os dois comandos mais básicos são o "adduser" e o "passwd", que permitem, respectivamente
adicionar novos usuários e alterar as senhas de acesso posteriormente, como em:
# adduser joao

(cria o usuário joao, especificando uma senha inicial)

# passwd joao

(altera a senha posteriormente)

O próprio usuário pode alterar a senha usando o comando "passwd", desde que ele saiba a senha
antiga. Se o usuário esqueceu a senha, você pode definir uma nova executando o comando como
root; nesse caso o sistema pede a nova senha diretamente, sem solicitar a senha antiga.
Os usuários são cadastrados no sistema através do arquivo "/etc/passwd". Se tiver curiosidade
em olhar dentro do arquivo você verá uma entrada para cada usuário, incluindo o diretório home e
o shell usado, como em:
joao:x:1001:1001:,,,:/home/joao:/bin/bash

Assim como qualquer outro arquivo de configuração, o "/etc/passwd" pode ser editado
manualmente, ou com a ajuda do comando "usermod". Existem diversas situações em que você
pode desejar trocar o shell padrão ou o diretório home do usuário, de forma a limitar o acesso ao
servidor. Em um servidor web compartilhado por muitos usuários, por exemplo, o diretório home
de cada usuário seria a pasta contendo os arquivos do site, e o shell padrão seria um aplicativo
como o MySecureShell, destinado a limitar o acesso do usuário a esta pasta específica.
Bem antigamente, as senhas eram salvas no próprio arquivo "/etc/passwd", juntamente com as
demais informações, o que abria brecha para diversos tipos de ataques. A partir de um certo ponto
(por volta de 1996) todas as distribuições passaram a utilizar o sistema shadow, onde as senhas
são armazenadas de forma encriptada em um arquivo separado, o "/etc/shadow". Dentro do
arquivo você verá entradas contendo a senha encriptada, como em:
joao:$1$LpQPRMC5$eHXLjiW7ks80LQcepW0Rz.:13993:0:99999:7:::

As senhas são encriptadas usando um algoritmo de mão única, que permite apenas encriptar as
senhas, mas não recuperá-las. Durante o login, o sistema aplica o mesmo algoritmo à senha
digitada pelo usuário e compara a string resultante com a armazenada no arquivo. Se o resultado
for o mesmo, o sistema sabe que a senha confere e o acesso é autorizado.
Este sistema faz com que as senhas não sejam recuperáveis, já que a senha propriamente dita
não é salva em lugar nenhum. Se o usuário esqueceu a senha, você pode usar (como root) o
comando "passwd" para definir uma nova, mas não é possível recuperar a senha antiga.
Continuando, para remover um usuário anteriormente criado, utilize o comando " deluser", como
em:
# deluser joao

Por questão de segurança, o comando remove apenas a conta, sem apagar o diretório home, ou
outras pastas (como o diretório de spool dos e-mails). O diretório home é especialmente
importante, pois ele guarda todas as configurações e os arquivos do usuário, de forma que em um
servidor você só deve removê-lo depois de ter realmente certeza do que está fazendo. Para
remover o usuário apagando também o diretório home, adicione o parâmetro "--remove-home",
como em:
# deluser joao --remove-home

Como comentei, o diretório home é importante, por concentrar todos os arquivos do usuário. Uma
opção saudável ao removê-lo é criar um backup, de forma que você possa restaurá-lo mais tarde
caso necessário. Para isso, use a opção "--backup", que cria um arquivo compactado, contendo
os arquivos do usuário, salvo no diretório onde o comando for executado:
# deluser joao --remove-home --backup

Se executasse o comando "ls" depois de remover o usuário "joao" usando a opção de backup,
veria que foi criado o arquivo "joao.tar.bz2", referente ao backup.
Você também pode bloquear temporariamente um usuário, sem remover o home ou qualquer
outro arquivo usando o comando "passwd -l", como em:
# passwd -l joao

O "passwd -l" realmente trava a conta, fazendo com que o sistema passe a recursar qualquer
senha inserida na hora do login. Para desbloquear a conta posteriormente, use o "passwd -u",
como em:
# passwd -u joao
O Fedora e o CentOS incluem o system-config-users, um utilitário gráfico de administração de
usuários. Uma versão levemente modificada dele pode ser encontrada no Ubuntu e em outras
versões baseadas no Debian, na forma do "users-admin", que faz parte do pacote "gnome-
system-tools".
Além da configuração dos usuários, temos a configuração dos grupos, que permitem organizar os
usuários, definindo as permissões de acesso de forma mais granular.
Imagine um caso em que você tenha um servidor compartilhado entre vários usuários, onde
apenas três deles, "maria", "jose" e "joao" devem ter acesso à pasta "/var/www/intranet", que
contém os arquivos do site interno da empresa.
Uma forma simples fazer isso é criar um grupo, adicionar os três usuários ao grupo e ajustar as
permissões da pasta de forma que o grupo tenha permissão de escrita. Para adicionar o grupo,
usamos o comando "groupadd", como em:
# groupadd intranet

Para adicionar os usuários desejados ao grupo, usamos o próprio comando "adduser", seguido
pelo login e o grupo ao qual ele deve ser adicionado (um de cada vez), como em:
# adduser maria intranet

No CentOS e em outras distribuições derivadas do Red Hat, o comando "adduser" é um link para
o comando "useradd", que não suporta essa opção. No caso delas, usamos o comando
"usermod -a -G", seguido do usuário e do grupo ao qual ele será adicionado, como em:
# usermod -a -G maria intranet

Se você está usando o system-config-users, ou o users-admin, pode também adicionar os

usuários ao grupo acessando as propriedades do grupo:

Existem algumas outras pequenas diferenças entre as opções aceitas pelo comando "adduser"
entre distribuições derivadas do Debian e derivadas do Red Hat, pois ele é na verdade um script,
que pode ser alterado pelos desenvolvedores para adicionar atalhos ou funções diversas.
Voltando ao tema principal, depois de adicionar os usuários ao grupo, falta ajustar as permissões
de acesso, o que é feito usando os comandos "chmod" e "chown". O primeiro permite ajustar as
permissões dos arquivos e pastas, enquanto o segundo permite transferir a posse, dizendo a qual
usuário e a qual grupo determinada pasta ou arquivo pertence.
No Linux, as permissões são agrupadas em 3 atributos principais: leitura, gravação e execução
(no caso dos arquivos) ou listagem do conteúdo (no caso das pastas). Eles são representados,
respectivamente, pelas letras r, w e x.
As permissões são definidas de forma separada para o dono, o grupo (que inclui todos os
usuários incluídos nele) e para os outros ou seja, todos os demais usuários do sistema. Em geral,
o dono tem acesso completo, o grupo tem permissões variáveis, de acordo com a função da
pasta, e os demais podem apenas ler os arquivos, sem alterar o conteúdo.
Se a pasta "/var/www/intranet" no nosso exemplo anterior foi criada pelo root, as permissões de
acesso (informadas pelo comando "ls -l") serão:
drwxr-xr-x 2 root root 4096 Jun 18 09:43 intranet

O primeiro "d" indica que se trata de um diretório. As três letras seguintes (rwx) indicam as
permissões de acesso para o dono da pasta, que no caso possui acesso completo. Em seguida,
temos as permissões de acesso para o grupo (r-x), cujos integrantes podem listar o conteúdo da
pasta (x) e podem ler os arquivos (r), sem poderem alterar nada. As três últimas letras (r-x)
indicam as permissões para os demais usuários, que também podem apenas ler.
O "root root" indica o dono e o grupo ao qual pertence a pasta, no caso o root. Ao cadastrar um
usuário no sistema é sempre criado um grupo com o mesmo nome (contendo apenas o próprio
usuário), o que explica o fato da pasta pertencer ao usuário "root" e também ao grupo "root". :)
Para que os usuários do grupo "intranet" possam alterar o conteúdo da pasta, o primeiro passo é
alterar as permissões, transferindo a posse do grupo "root" para o grupo "intranet". Nesse caso
não precisamos alterar o dono da pasta, que pode continuar sendo o root:
# chown -R root:intranet /var/www/intranet

O "-R" no exemplo faz com que a alteração seja aplicada de forma recursiva, afetando todos os
arquivos e sub-pastas. Sem ele, a alteração seria aplicada apenas à pasta propriamente dita, mas
não ao seu conteúdo. Em seguida, especificamos o novo dono e o novo grupo, separados por ":",
seguido da pasta. Com isso, as permissões serão alteradas para:
drwxr-xr-x 2 root intranet 4096 Jun 18 09:51 intranet

Falta agora alterar as permissões de acesso para o grupo, de forma que os usuários possam
finalmente escrever na pasta. Para isso, usamos o comando "chmod -R g+rw", que especifica que
o grupo (g) terá permissão de leitura e escrita (+rw):
# chmod -R g+rw /var/www/intranet

Se você quisesse fazer o oposto, ou seja, remover a permissão de escrita para o grupo, usaria o
"chmod -R g-w /var/www/intranet", se quisesse remover a permissão de leitura para todos os
demais usuários usaria o "chmod -R o-r" e, se quisesse abrir as permissões para todo mundo,
usaria o "chmod -R ugo+rwx".
Aqui vai uma pequena cola com os parâmetros:
-R : Recursivo, altera as permissões de todo o conteúdo da pasta, opcional.
u : Permissões para o dono da pasta (user).
g : Permissões para o grupo (group).
o : Permissões para os demais (others).
+ : Adiciona a permissão
- : Remove a permissão
r : Permissão de leitura
w : Permissão de escrita
x : No caso dos arquivos indica permissão de escrita e, no caso da pasta, permissão para ver o
conteúdo.
Você pode também especificar as permissões de acesso no formato clássico, onde as permissões
são representadas por três números, como em:
# chmod -R 775 /var/www/intranet

Nesse caso, os três números indicam, respectivamente, as permissões de acesso para o dono,
grupo e para os outros. Cada número representa a soma das permissões desejadas, sendo que:
4 : Leitura
2 : Gravação
1 : Execução / listagem
Você simplesmente soma estes números para ter o número referente ao conjunto de permissões
que deseja:
0 : Sem permissão alguma. Acesso negado.
1 : Permissão apenas para executar (não é possível ler o arquivo ou alterá-lo, apenas
executar um programa) ou, no caso das pastas, permissão apenas para ver a lista dos
arquivos dentro da pasta, sem poder abrí-los.
4 : Apenas leitura. Se usado em uma pasta, o usuário não conseguirá listar o conteúdo, ou
seja, conseguirá abrir os arquivos apenas caso indique o caminho completo.
5 (4+1): Ler e executar (no caso de um arquivo) ou ver os arquivos e abri-los, no caso de
uma pasta.
6 (4+2): Leitura e gravação. Assim como no caso do "4", se usado em uma pasta faz com
que o usuário não consiga listar o conteúdo, apenas acessar os arquivos diretamente.
7 (4+2+1): Controle total.

Gerenciamento de processos

Dominando a linha de comando, parte 2

Carlos E. Morimoto
04/07/2008
Falar em "gerenciamento de processos" pode parecer coisa de advogado, mas é na verdade uma
das funções básicas de qualquer administrador :). Um processo nada mais é do que um aplicativo
ou um serviço ativo, que consome processamento e outros recursos do sistema. Em muitos
casos, um determinado serviço pode deixar de responder, ou pode ser que um determinado
aplicativo simplesmente entre em loop e passe a consumir cada vez mais memória e/ou
processamento até que você consiga fechá-lo manualmente.
Para listar os processos ativos, ou seja, todos os programas e serviços abertos, usamos o
comando "ps". Como de praxe, ele suporta um enorme volume de opções, mas o uso mais
comum é combiná-lo com as opções "aux", o que faz com que ele mostre a lista completa,
contendo os processos iniciados por todos os usuários:
# ps aux

A menos que você já seja um administrador experiente, com profundos conhecimentos, a lista vai
mostrar diversos processos que você não conhece. Uma boa forma de descobrir a função de cada
um é usar o comando "whatis", que mostra a descrição curta do programa, como em:
# whatis named

named (8) - Internet domain name server (DNS)

Outra combinação de opções muito usada é a "axjf", que mostra os processos de forma um pouco
mais organizada, agrupando os processos relacionados:
# ps axjf

Em qualquer um dos dois casos, a lista é geralmente bastante extensa, mas se você souber o
nome do aplicativo ou do serviço, você pode usar o pipe ( | ) combinado com o grep para filtrar a
lista, como em:
# ps aux | grep gdm
root 6042 0.0 0.1 14316 1536 ? Ss Jun10 0:00 /usr/sbin/gdm
root 22692 0.0 0.0 14320 892 ? R 20:07 0:00 /usr/sbin/gdm
root 22691 0.0 0.0 3020 764 pts/0 R+ 20:07 0:00 grep gdm

Existem duas formas de finalizar um processo travado. A primeira é usando o comando "kill", onde
você deve especificar o PID, ou seja, o número de identificação do processo, mostrado na
segunda coluna do relatório, como em:
# kill 6042

Usado dessa forma, o kill tenta finalizar o processo de forma limpa, enviando o sinal de
finalização. Isso geralmente não funciona com processos travados, afinal, se o programa está
travado, é provável que o sinal não seja processado. Nesse caso, adicionados a opção "-9", que
faz com que ele seja finalizado na marra, como em:
# kill -9 6042

A segunda maneira de finalizar os processos é usando o comando "killall", onde você especifica
diretamente o nome do serviço ou programa que quer finalizar, como em:
# killall gdm

Como pode ver, o comando "ps" serve para que você consiga localizar o culpado do problema,
para então poder finalizá-lo usando o kill ou o killall.
Uma variação do "ps" é o comando "pstree", que vai um passo além dentro do conceito de
organização. Ele é geralmente combinado com a opção "-p", que faz com que ele mostre os IDs
dos processos, de forma que você possa finalizá-los usando o kill:
# pstree -p

Temos também o comando "top", que desempenha a função de gerenciador de processos em

modo texto, mostrando uma lista atualizada continuamente:
Para organizar a lista, mostrando os processos que estão consumindo mais processamento nas
primeiras posições (uma boa forma de localizar processos travados), pressione a tecla "g". Para
finalizar um processo, pressione a tecla "k" e digite o PID. Se quiser finalizar o processo na marra,
como ao usar o "kill -9", digite "9" quando ele perguntar sobre o sinal que será usado. Para voltar
ao terminal, use a tecla "q".
Uso de memória: Uma dúvida comum é sobre o consumo de memória dos processos, que é
mostrado na coluna "RSS" do relatório do ps. O valor é informado em kbytes, de forma que um
processo que apareça com o valor "6184", por exemplo, está consumindo pouco mais de 6 MB.
Entretanto, os números não são exatos, pois não levam em conta um fator importante, que é a
reutilização de áreas de memória por parte do Kernel. Se um mesmo aplicativo é aberto várias
vezes, sempre carregando os mesmos arquivos e as mesmas bibliotecas, o Kernel logo aprenderá
a aproveitar essas informações, reutilizando as áreas de memória em que elas estão
armazenadas, em vez de carregar tudo novamente a cada abertura do programa.
Se cada instância do aplicativo consome 6 MB, por exemplo, e ele é aberto 20 vezes, o relatório
do ps mostrará 6 MB de consumo de memoria para cada um, muito embora na realidade eles
estejam consumindo muito menos. O ps não tem acesso a essas informações e por isso ele se
limita a exibir o total usado por cada processo, sem levar em conta as áreas compartilhadas. Isso
faz com que o relatório de uso de memória do ps e de outros utilitários similares sirva mais como
uma estimativa aproximada, que não deve ser levada ao pé da letra.

Gerenciando HDs e partições

Dominando a linha de comando, parte 2

Carlos E. Morimoto
04/07/2008

No Linux, todos os dispositivos de sistema são acessados através de arquivos especiais criados
dentro do diretório "/dev". Isso naturalmente inclui os HDs e as partições.
Tradicionalmente, os HDs IDE são acessados através de devices iniciados com "/dev/hd", como
em "/dev/hda" (master da primeira porta IDE), "/dev/hdb" (slave da primeira IDE), "/dev/hdc"
(master da segunda IDE) e "/dev/hdd" (slave da segunda IDE) e os HDs SCSI, SATA ou SAS
recebem devices iniciados com "/dev/sd", como em "/dev/sda" (primeiro HD), "/dev/sdb" (segundo
HD), "/dev/sdc" (terceiro HD) e assim por diante.
Entretanto, isso mudou nas versões recentes do Kernel (a partir do 2.6.20), onde, devido a uma
mudança no subsistema que dá suporte a discos, todos os HDs passaram a receber devices
iniciados com "/dev/sd", independente de serem HDs IDE, SATA, SCSI ou USB.
Uma boa forma de ver como o sistema detectou os HDs instalados é usar (como root) o comando
"fdisk -l", que lista os HDs e as partições disponíveis:

Neste exemplo, temos um servidor com três HDs instalados, um de 200 GB, visto pelo sistema
como "/dev/sda", um de 80 GB visto como "/dev/sdb" e um HD maior, de 300 GB, visto como
"/dev/sdc". Você pode notar que o "/dev/sdb"está dividido em várias partições, incluindo uma
partição swap (vista pelo sistema como "/dev/sdb5"), enquanto os outros dois são HDs destinados
a armazenar arquivos e por isso foram particionados com uma única partição.
O que faz com que todas as partições sejam corretamente montadas durante o boot são entradas
inseridas no arquivo "/etc/fstab". Aqui temos um exemplo de configuração clássica:
/dev/sda1 / ext3 defaults 0 1
/dev/hda2 /home ext3 noatime 0 2
/dev/hda5 none swap sw 0 0
/dev/cdrom /mnt/cdrom iso9660 defaults,ro,user,noexec,noauto 0 0
proc /proc proc defaults 0 0

Como pode ver, cada linha descreve uma partição que será acessada pelo sistema. No exemplo,
a primeira linha é referente à partição raiz, a segunda se refere a uma partição separada, montada
no diretório home, a terceira é referente à partição swap, a quinta é referente ao CD-ROM e a
última ao diretório proc, um diretório especial usado pelo kernel para armazenar variáveis de
configuração e atalhos de acesso a dispositivos.
Dentro de cada linha, o primeiro parâmetro (/dev/sda1) indica a partição, o segundo o diretório
onde ela será montada (/), o terceiro indica o sistema de arquivos em que a partição foi formatada
(ext3) enquanto o "defaults 0 1" permite definir configurações adicionais. O "default", por exemplo
é um "nada a declarar", que faz com que a partição seja acessada usando as opções padrão,
enquanto o "noatime" na segunda linha é uma opção de otimização, que faz com que o sistema
não atualize a data de acesso quando os arquivos são lidos, o que resulta em um pequeno ganho
de desempenho.
Normalmente, você define os pontos de montagem das partições durante a própria instalação do
sistema, de forma que o instalador se encarregará de adicionar as entradas apropriadas
automaticamente. Ao instalar outros HDs posteriormente, você pode fazer com que o sistema
passe a usá-las inserindo as linhas apropriadas no arquivo "/etc/fstab".
Se você acabou de particionar um novo HD em EXT3 e deseja que a partição "/dev/sdc1" criada
seja montada na pasta "/mnt/sdc1", por exemplo, os passos seriam:
a) Criar a pasta onde a partição será montada:
# mkdir /mnt/sdc1

b) Testar a montagem da partição:

# mount /dev/sdc1 /mnt/sdc1

c) Adicionar a linha abaixo no final do arquivo "/etc/fstab", orientando o sistema a montá-la

automaticamente durante o boot:
/dev/sdc1 /mnt/sdc1 ext3 defaults 0 0

Além de ser usado para montar partições locais, o mount é usado também para montar
compartilhamentos de rede. É possível montar compartilhamentos em servidores Windows, ou
servidores Linux rodando o Samba, compartilhamentos em NFS ou até mesmo montar pastas em
máquinas remotas usando o sshfs.
Continuando, se você estiver usando o Ubuntu, vai perceber que ele não faz referência às
partições dentro do fstab pelo dispositivo, mas sim pelo UUID, que é um identificador único. O uso
dos UUIDs complica a configuração, mas oferece a vantagem de garantir que o sistema continue
sendo capaz de montar as partições mesmo que os HDs mudem de posição ou sejam instalados
em portas diferentes da placa-mãe.
Para seguir o padrão do Ubuntu, identificando a partição através do UUID, você pode verificar
qual é o UUID referente à sua partição usando o comando "blkid", como em:
# blkid /dev/sdc1
/dev/sdc1: UUID="5c5a3aff-d8a3-479e-9e54-c4956bd2b8fd" SEC_TYPE="ext2" TYPE="ext3"

Você pode então especificar o UUID na linha do fstab no lugar do device, como em:
UUID=5c5a3aff-d8a3-479e-9e54-c4956bd2b8fd /mnt/sdc1 ext3 defaults 0 0

Um aviso importante é que o fstab é um dos arquivos essenciais para a inicialização do sistema,
por isso você sempre deve checar e rechecar as alterações. Um erro na linha referente à partição
raiz, por exemplo, simplesmente fará o sistema deixar de inicializar.
Outra observação é que você deve deixar sempre uma linha em branco no final do arquivo, caso
contrário passará a receber um aviso durante o boot. Ela é necessária por um motivo muito
simples: sem ela, se um utilitário de configuração qualquer tentar inserir informações no final do
arquivo, vai acabar inserindo-as no final da linha anterior (em vez de em uma nova linha),
resultando em uma configuração inválida.
Além da questão da montagem de partições, temos a questão da reparação de partições com
estruturas danificadas devido a quedas de energia ou problemas diversos.
A cada boot o sistema realiza um teste rápido de integridade das partições, utilizando o fsck, que
é análogo ao scandisk do Windows. Em casos de problemas graves, que não possam ser
corrigidos automaticamente, ou de erros inesperados ao tentar montar as partições indicadas no
arquivo /etc/fstab, o boot é interrompido e você recebe a fatídica mensagem:
Give root password for maintenance
(or type Control-D for normal startup):

Este prompt é o que temos de mais próximo a uma tela azul no mundo Linux, é essencialmente
um "se vire", que causa arrepios em muitos administradores :). Na maioria dos casos, ao
pressionar "Ctrl+D" a máquina é simplesmente reiniciada e o mesmo erro volta a ser exibido, de
forma que a única forma de continuar é realmente solucionando o problema.
Comece fornecendo a senha de root. Isso lhe dará acesso ao modo single-user, um prompt
limitado, destinado a permitir o uso de ferramentas de reparação.
Se o problema for em uma das partições do HD, o próximo passo é executar a versão apropriada
do fsck, indicando a partição a ser reparada (em caso de dúvida, você pode listar as partições do
sistema usando o comando "fdisk -l"), como em:
# fsck.ext3 /dev/sda1

(para partições formatadas em ext3)

ou:
# reiserfsck --fix-fixable /dev/sda2

(para partições formatadas em ReiserFS)

Muito provavelmente, o teste do fsck indicará erros que precisarão da sua confirmação antes de
serem corrigidos, daí a necessidade de usar o prompt de recuperação. Na maioria dos casos,
você pode simplesmente responder "y" para tudo, mas caso existam dados realmente importantes
na partição é melhor prestar mais atenção. Arquivos danificados ou fragmentos de arquivos que
puderam ser recuperados vão para a pasta "lost+found" no diretório raiz da partição.
O fsck não é capaz de recuperar o sistema de arquivos em casos de problemas com o
superbloco, o setor que contém informações essenciais, como o tipo, tamanho, status e
informações sobre a estrutura do sistema de arquivos.
Sempre que a partição é criada, são criados vários superblocos alternativos, que servem
justamente de backups para casos de problemas com o primeiro. Você pode ver a lista de
endereços usando o comando "mkfs.ext3 -n partição", como em:
# mkfs.ext3 -n /dev/sda1

Ao usar o comando, nunca esqueça de incluir o "-n", caso contrário ao invés de

mostrar as informações, ele vai formatar a partição. No final do relatório você encontra:
Superblock backups stored on blocks:
32768, 98304, 163840, 229376, 294912, 819200, 884736

Chame novamente o comando "fsck.ext3", adicionando a opção "-b", seguida do endereço do

superbloco que será usado. Caso eventualmente o primeiro resulte em erro, experimente o
segundo, e assim por diante:
# fsck.ext3 -f -b 32768 /dev/hda2

Para partições EXT2, use o comando "fsck.ext2", que suporta os mesmos parâmetros.
Continuando, se o erro for no "/etc/fstab", ou em outro arquivo de configuração (você pode ter
deixado a configuração com erros ao editar manualmente o arquivo e só perceber vários dias
depois, ao precisar reiniciar o servidor), é necessário remontar a partição raiz em modo de leitura
e escrita antes de poder fazer a edição. Isso é feito usando o comando "mount -o remount rw
particao-raiz", como em:
# mount -o remount rw /

A partir daí, você pode fazer a edição usando o vi, joe, ou outro editor que rode em modo texto e
salvar as alterações:
# joe /etc/fstab

Terminado, reinicie o sistema usando o "reboot" e tudo deve voltar ao normal.

Outra dica é que, se o servidor possui um drive de CD-ROM, você pode usar um CD do Ubuntu,
ou de qualquer outra distribuição live-CD como sistema de recuperação. Você pode usar o live-CD
para executar os comandos de recuperação do fsck, ou para montar as partições e assim pode
editar o fstab ou outros arquivos de configuração.
O live-CD pode ser usado também para resetar a senha de root, nos famosos casos em que ela é
esquecida. Para isso, comece montando a partição raiz do sistema, a partir do live-CD, como em:
# mount -t ext3 /dev/sda1 /mnt/sda1

Se você estiver usando o Ubuntu ou outra distribuição derivada dele, pode se logar como root no
prompt usando o comando "sudo su". A partir daí, use o comando "chroot" para acessar o sistema
dentro da partição, indicando o diretório onde ela foi montada, como em:
# chroot /mnt/sda1

Isso lhe dará um prompt de comando do sistema dentro da partição, o que permite que você
troque a senha de root usando o comando passwd:
# passwd