head e tail – visualizando o início e o fim de um arquivo em modo texto

Nesse post, vou falar de dois comandos que nos ajudam a visualizar o início e o fim de um arquivo!

Comando head

Esse comando permite visualizar as primeiras linhas de um arquivo em modo texto. Por exemplo:

# head /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/bin/sh
man:x:6:12:man:/var/cache/man:/bin/sh
lp:x:7:7:lp:/var/spool/lpd:/bin/sh
mail:x:8:8:mail:/var/mail:/bin/sh
news:x:9:9:news:/var/spool/news:/bin/sh

Por padrão, sem nenhum parâmetro, o head nos mostra as 10 primeiras linhas… sendo que, se quisermos modificar essa opção, ver mais linhas ou menos linhas, basta fazer:

# head -5 /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
sync:x:4:65534:sync:/bin:/bin/sync


Acima, eu pedi para ver somente as 5 primeiras linhas do arquivo /etc/passwd.

Comando tail

Esse comando, mostra as últimas linhas de um arquivo em modo texto! E, assim como o head, por padrão o tail sem nenhum parâmetro, sempre vai mostrar as 10 últimas linhas do arquivo!

Exemplo:

# tail /etc/passwd
identd:x:102:65534::/var/run/identd:/bin/false
ivani:x:1000:1000:,,,:/home/ivani:/bin/bash
sshd:x:103:65534::/var/run/sshd:/usr/sbin/nologin
vana:x:1001:1001:,,,:/home/vana:/bin/bash
josue:x:1002:1002:,,,:/home/josue:/bin/bash
familia:x:1003:1003:,,,:/home/familia:/bin/bash
priscila:x:1004:1004:,,,:/home/priscila:/bin/bash
manasses:x:1005:1005:,,,:/home/manasses:/bin/bash
messagebus:x:104:104::/var/run/dbus:/bin/false
haldaemon:x:105:105:Hardware abstraction layer,,,:/home/haldaemon:/bin/false

E, assim como o head, se quisermos ver mais ou menos linhas do final do arquivo, basta fazer:

# tail -5 /etc/passwd
familia:x:1003:1003:,,,:/home/familia:/bin/bash
priscila:x:1004:1004:,,,:/home/priscila:/bin/bash
manasses:x:1005:1005:,,,:/home/manasses:/bin/bash
messagebus:x:104:104::/var/run/dbus:/bin/false
haldaemon:x:105:105:Hardware abstraction layer,,,:/home/haldaemon:/bin/false

E aqui, uma dica sobre o tail: ele permite ver as últimas linhas de um  arquivo em tempo real.

Isso é muito útil quando você quer ler o que está sendo escrito em um log… então, para não ficar abrindo o arquivo de log, basta acrescentar o parâmetro -f:

# tail -f /var/log/syslog

Acima, será mostrado em tempo real, o que está sendo escrito no arquivo /var/log/syslog.

Para saber mais…

# man head

# man tail

Anúncios

Como pedir ajuda no Linux!

O linux é um sistema muito bem documentado… seja na net ou utilizando a linha de comando… informação é o que não nos falta! =)

Seguem alguns comandos de ajuda que são bastante úteis!

Comando man

O comando man vem de manual, e possui páginas com ajuda para diversos comandos. Ele possui 9 seções:

1 – Programas executáveis ou comandos internos
Exemplo: passwd – comando utilizado para alterar a senha do usuário.

2 – Chamadas do sistema (funções oferecidas pelo kernel)
Exemplo: sysctl – utilizado para ler/escrever parâmetros do sistema.

3 – Chamadas de Bibliotecas (funções dentro de biblioteca do sistema)
Exemplo: zlib – biblioteca de compressão e descompressão.

4 – Arquivos especiais (normalmente encontrados no diretório /dev)
Exemplo: random – dispositivo fonte de números aleatórios do kernel.

5 – Formatos de arquivos e convenções
Exemplo: /etc/passwd – arquivo que guarda as informações dos usuários cadastrados no sistema.

6 – Jogos
Exemplo: pacman.

7 – Pacotes de macros e convenções
Exemplo: o próprio man 🙂 !

8 – Comandos de Administração do Sistema
Exemplo: halt – comando utilizado para desligar o sistema.

9 – Rotinas do Kernel (não padrões)
Sem documentação.

Agora, vejamos a diferença entre: man 1 passwd e man 5 passwd:

man 1 passwd – exibe a man page do comando passwd, que é utilizado para troca de senha de usuário

man 5 passwd – exibe a man page do arquivo /etc/passwd, que guarda a lista de usuários cadastrados no sistema.

Comando help

Oferece ajuda rápida para os comandos internos do interpretador de comandos (shell).

Por exemplo, para termos uma ajuda rápida de todos os comandos internos do shell, basta digitar:

# help

Mais um exemplo legal, é como obter ajuda rápida de um comando interno específico do shell:

# help cd

Entendendo a diferença entre help e –help!

O comando help é utilizado para ajuda dos comandos internos.

Já a opção –help oferece ajuda rápida para comandos externos.

Por exemplo, para listar rapidamente todas opções do comando ls:

# ls –help

Comando apropos

Esse comando é utilizado quando não sabemos qual man page podemos acessar para um determinado assunto.
Aí, o comando apropos entra em ação localizando as man pages através de um banco de dados que é construído com o comando catman:

# catman

Após executar esse comando, podemos localizar as man pages que contém a palavra user:

apropos user


Comandos que nos ajudam sair do sufoco:

whereis – localiza o comando e suas man pages.

Exemplo:

# whereis ls
ls: /bin/ls /usr/share/man/man1/ls.1.gz

whatis – mostra uma descrição da man page.

Exemplo:

# whatis ls
ls (1)               – list directory contents

E fica aqui uma dica… postei sobre estrutura de diretórios, mas, vale dizer que até isso está na documentação manual!

Para ler, basta fazer:

# man hier

Bem, é isso ai… agora, nada de dizer que não sabe por onde começar pedindo ajuda! 😉

Conhecendo o | (pipe) , o more e o grep

No post do comando ls, vimos como listar o conteúdo de um diretório. Vimos a opção de listar de forma recursiva e também listar arquivos ocultos.

Com a opção -R, quando listamos o diretório /, as informações passam praticamente “voando” na tela. Seria mais ou menos como dar aquela olhadinha rápida em um livro… somente olhando as páginas sem realmente analisar o conteúdo!

Só prá relembrar:

# ls -R /

O comando more no Linux é o paginador, que pode ser usando com vários outros comandos que precisam de uma ‘pausa’ na tela.

No nosso caso, queremos paginar a saída do ls , que está muito grande e não conseguimos ver tudo! Mas, para usar o comando estou conseguindo ver tudo!

E, para fazer isso, preciso de um ajudante, o | (pipe)!!!

O pipe no shell, faz com que eu possa jogar um comando, para dentro de outro!!

Ihh.. enrolou tudo. Vamos explicar melhor: todo comando no Linux, irá mostrar um resultado que chamamos de “saída do comando”.

E essa saída do comando sempre irá aparecer na tela (monitor) que é a saída padrão.

O pipe, tem o poder de fazer com que a saída de um comando não vá para a tela, e sim para o outro comando;

O nosso ls recursivo passou tudo muito rápido! Então, vamos usar o comando more para paginar!

Vejam:

# ls /R | more

Agora sim, o ls vai esperar um <enter > a cada tela cheia! Fazendo uma comparação, (uiiiii!) o more aqui funcionaria como a opção -p do comando dir usado no DOS!

E usamos o | (pipe) para dizer que a saída do comando ls que vinha muito rápido, não deveria ir para a tela, e sim para o comando more!

Onde o comando more recebeu toda a informação do ls e na hora de mostrar, paginou!

Agora, vamos ver como localizar um determinado arquivo dentro de um diretório! Vamos listar o diretório /etc.

# ls /etc

Quando executamos o comando acima, ele irá mostrar a listagem do diretório /etc de uma forma muito rápida. Então, podemos combinar o ls com o more para mostrar a lista de forma pausada:

# ls /etc | more

Bem, isso já resolve o nosso problema de ver a listagem do /etc de forma pausada. Mas… e se quisermos localizar um determinado arquivo ou diretório?

Vejam que mesmo paginando, ainda temos muita coisa… Daí, pra facilitar, podemos usar o comando grep, que funciona como uma espécie de filtro no Linux!

Dentro do diretório /etc, vamos localizar arquivos que contenham a cadeia de caracteres ‘pa’; para isso, primeiro vamos ter que listar para depois filtrar:

# ls | grep pa
manpath.config
pam.conf
pam.d
passwd

Vejam que o resultado do comando acima, trouxe não somente o que começa com pa como também tudo que tem pa no nome! Isso é o básico de uma filtragem!

Agora, melhorando nossa pesquisa e incrementando mais o filtro… e se quisessemos ver tudo o que começa com pa?

Exemplo:

# ls | grep ^pa
pam.conf
pam.d
passwd

Vejam que apenas acrescentamos a opção ^ que significa começo de linha, ou seja, tudo que começar com pa!

Ainda falando o grep, vamos fazer ao contrário… vamos listar tudo “que não comece” com pa:

# ls /etc/ | grep -v ^pa

Onde a opção -v aqui é inverso, ou seja, mostre tudo exceto o que comece com pa!

Vejam que usamos o pipe para unir comandos, e o legal de tudo isso, é que podemos usar o pipe mais de uma vez em uma mesma linha de comando!

Exemplo:

# ls /etc/ | grep -v ^m | more

No exemplo acima, jogamos um comando dentro do outro!

Primeiro, listamos o que tem dentro do /etc e jogamos para o grep, que irá tirar tudo que começa com m, e jogar para o more, que por sua vez, irá paginar o que sobrou do filtro!

Bem é isso aí… por enquanto vamos ficando por aqui e até o próximo post!

Comando cat

Vimos como entrar em um diretório, listar seu conteúdo identificando o que é arquivo ou diretório. Mas um comando essencial para visualização de arquivos em modo texto, é o cat.

O cat é utilizado para mostrar o conteúdo de um arquivo e também pode ser usado para concatenar dois arquivos.

Exemplos:

1) Exibe o conteúdo do arquivo /etc/motd:

# cat /etc/motd

Linux switch 2.6.18-5-486 #1 Mon Dec 24 16:04:42 UTC 2007 i686
The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.


2) Concatena o conteúdo do arquivo /etc/motd no arquivo /root/garantia.txt:

# cat /etc/motd > /root/garantia.txt

3) Acrescenta o conteúdo do arquivo garantia.txt no arquivo /etc/motd:

# cat /root/garantia.txt >> /etc/motd
E o cat também pode ser usado como editor de textos! Claro que não é aquela maravilha, mas quebra um galho.. 😉

Exemplo:

# cat > teste

Esse eh um teste do cat fazendo o papel de editor de textos.

Quando digitar as linhas acima, o terminal irá travar… para voltar, basta teclar CTRL+D. E se quiser ver o que foi digitado…

# cat teste

Esse eh um teste do cat fazendo o papel de editor de textos.

Bem, por hoje é só 🙂 .

No próximo post, escreverei sobre outros comandos importantes que são utilizados no modo texto.

Comando ls

No post anterior, falei sobre os comandos pwd e cd. Esses comandos são bem simples e muito utilizados. Mas tem uma coisa importante: quando entramos em um diretório, com certeza queremos ver o que está dentro dele. E é nessa hora que entra em ação o comando ls.

Comando ls

A função do comando ls é listar o conteúdo de um diretório. Vejam um exemplo:

# cd /

# ls
bin boot dev etc home lib media mnt opt proc root sbin srv sys tmp usr var

Entrei no diretório / e listei o que tinha dentro dele!

E, depois que eu ver o conteúdo do diretório / posso escolher o que quero fazer (por exemplo, listar conteúdo de um outro diretório para conhecer seu conteúdo)!

Assim como no comando cd, o ls também tem opções que facilitam nossa vida! Vejam:

# ls -l

É -l (l de limão!)… e serve para ver informações de uma forma mais completa do arquivo!

Se eu apenas fizer:

# ls /
boot floppy lib opt srv

Vejam que eu vou ter somente nome de arquivos ou diretórios!

Agora, seu eu chamo com o -l. vou ter mais informações!

Um exemplo:

# ls -l /
drwxr-xr-x 4 root root 1024 2007-01-15 23:17 boot

Vou ter uma saída parecida com essa para cada arquivo ou pasta!!

Vamos fazer nosso papel de administrador do sistema e analisar essa saída:

drwxr-xr-x 4 root root 1024 2008-04-26 22:57 boot

Vejam que aqui tenho 9 campos!

Aí, vocês vão contando os campos ai, e pensam, a Nix nem sabe contar direito… só tem 8! Mas tem 9 campos sim… na figura abaixo, dá pra visualizar melhor. Os campos estão numerados para facilitar o entendimento:

1) No primeiro campo, que é só um caracter, temos a descrição do estou listando: se arquivo ou diretório. Nessa caso, temos um ‘d‘ que representa diretório!

Aqui, além do ‘d’, podemos ter as seguintes possibilidades:

l => é l de limão, e indica que se trata de um link – como se fosse um atalho
– => hifen, e indica que se trata de um arquivo
c => indica dispositivo de caracter
b => indica dispositivo de bloco
s => sockets – criam pontos de comunicação entre processos cliente-servidor
p => pipes – realizam comunicação entre processos na mesma máquina.

2) O campo rwxr-xr-x lista as permissões, ou seja, o que pode ser feito ou não com o arquivo ou diretório. As permissões sempre irão variar com as iniciais rwx, mas como vou colocar um post para falar só sobre esse assunto, vamos ficar apenas com a informação de que o segundo campo na saída do comando ls -l mostra as permissões!

3) Quantidade de links que o diretório boot tem no sistema!

4) Usuário dono do diretório, que no caso é o todo-poderoso root!

5) Grupo dono do diretório, que é o grupo do root!

6) Tamanho do arquivo ou diretório.

7) Data da criação do diretório

8 ) Hora da criação

9) Nome do arquivo ou diretório

Ainda falando do ls, no Linux, assim como no Windows, temos arquivos ocultos! E, um arquivo ou diretório oculto no Linux é caracterizado por um . (ponto) na frente do nome!!

Por exemplo, temos os dois arquivos abaixo:

visivel.txt

.invisivel.txt

Nesse exemplo, visivel.txt é um arquivo que, quem entrar no diretório, de cara, já consegue ver… só que o arquivo .invisivel.txt, justamente por ter um ponto na frente do nome, é um arquivo oculto!!

E, na hora que for listar o conteúdo do diretório, e conseguir enxergar os ocultos, temos que usar a opção -a (all). Exemplo:

# ls -a /root

.bash_history .bashrc

Vejam que com essa opção, podemos listar os arquivos ocultos do diretório /root.

Uma outra opção interessante, porém pouco usada do comando ls é o Recursivo!!

O recursivo, entra em todos os diretórios e subdiretórios, até não ter mais nenhum para entrar!

Exemplo: sei que tem o diretório /.

E dentro do / temos aqueles 16 diretórios que conhecemos no post Estrutura de Diretórios… e dentro de cada um deles tem vários diretórios!

Se fizermos:

# ls -R /

Ele vai entrar em todos diretórios e subdiretórios, mostrando o que tem dentro (vai ser uma listagem louca… rs)

E o comando só vai parar quando terminar de listar todos os diretórios que tem abaixo do / que foi o que pedimos para listar!

Isso é legal de ser usado quando queremos encontrar algum arquivo, mas existem comandos de localização que são mais rápidos!

Bem, por hoje é só 🙂 .

Comandos pwd e cd

Todo mundo que está começando a aprender Linux, precisa conhecer 4 comandos que irão acompanhar por todo o tempo que você utilizar a linha de comando.

Os comandos são: pwd, cd, ls e cat. Eles são super ultra utilizados, então é bom conhecê-los bem. Neste post, vou falar sobre os comandos pwd e cd.

Comando pwd

Falando sobre o comando pwd, ele é utilizado para se localizar no sistema. Assim que você loga no sistema, vai cair no seu diretório home (lembra… cada usuário tem um diretório para chamar de seu? 😉 ).

Eu loguei no sistema com o usuário ivani. Então, para saber se realmente estou no meu home, utilizo o comando pwd.

Obs.: Nos exemplos, sempre vai ter um “#”… mas ele não deve ser digitado! É só pra informar que se trata de um comando! 🙂

# pwd
/home/ivani

Então agora sabemos onde estamos. Se começar a navegar pelos diretórios e achar que está perdido, use o comando pwd para se localizar!

Comando cd

O comando cd é utilizado para entrar em um diretório ou sair dele.

Vimos no post de Estrutura de Diretórios que o Linux é bem organizado! Para analisar essa estrutura através do shell, utilizamos o comando cd.

# cd /

O comando acima informa ao shell para entrar no diretório / (raiz).

Para confirmar se realmente estou no diretório que pedi para entrar, utilizamos o comando pwd:

# pwd
/

Eu posso entrar em 2 diretórios de uma vez só, mas para fazer isso, um diretório precisa estar dentro do outro. Explicando melhor:

Quando falei sobre a estrutura de diretório do Linux, falei sobre o diretório usr que está dentro do /.

Então, para entrar nesse diretório, fazemos assim:

# cd /

# cd usr

Ou então, para ser mais rápido e economizar dedos na digitação:

# cd /usr

Acima, primeiro entramos no diretório /, e depois usr

Para sairmos desse diretório, existem várias formas:

# cd ..

Siiim! É o comando cd, com espaço e os “..” (dois pontos)! Onde ai, voltamos um diretório.

Uma opção legal do comando cd é o poder que ele tem de voltar para o último diretório acessado.

Exemplo:

# cd /usr

# pwd

/usr

# cd local

# pwd

/usr/local

Estamos dentro do diretório local, que está dentro do usr, que por sua vez está dentro do /. Para voltar ao último diretório acessado (no caso o /usr), utilizamos o comando cd com um – (hífen):

# cd –

/usr

Vejam que ele além de mudar para o /usr, também avisa na tela: “Estou indo para o /usr!”

Se você digitar o comando cd sem parâmetros, ele irá voltar para o diretório home do usuário logado.

Exemplo: quero ir para o diretório /tmp e depois para meu home:

# cd /tmp/

# pwd

/tmp

# cd

# pwd

/home/ivani

Vejam que utilizando os comandos pwd e cd, conseguimos se localizar no sistema e navegar pela árvore de diretórios. Por enquanto, nesse post vamos ficando por aqui.

No próximo post, vamos falar sobre os comandos ls e cat… Não percam! 🙂

Comandos no Gnu/Linux

Uma das tantas vantagens do Linux, é a variedade de comandos que ele oferece.

E, para quem conhece comandos, a administração do sistema acaba sendo um processo mais rápido.

Um administrador de sistemas até pode ter lá sua interface gráfica para gerenciar… mas quando se tem intimidade com o teclado e a linha de comando, não se fica preso a distribuição!

Existem dois tipos de comandos:

Comandos internos
– são comandos que estão dentro do interpretador de comandos – o shell bash, por exemplo; quando este é carregado na memória, seus comandos ficam residentes nela. A grande vantagem dos comandos internos é a velocidade, pois não precisam ser procurados no disco rígido nem criam processos.

Comandos externos
– são comandos que estão localizados em diretórios específicos no disco rígido, como /bin, /sbin, /usr/bin e /usr/sbin. Quando o usuário utiliza um comando desses diretórios, o Linux precisa consultar o disco rígido sempre que um desses comandos é solicitado. A maioria dos comandos do Linux é externa.

Nos próximos posts, pretendo falar sobre alguns comandos utilzados no Linux no dia-a-dia.