Script para coletar informações básicas da máquina

Coleta informações como hostname, modelo e quantidade de CPU, memória, disco e rede.

A parte de coleta de informações de rede foi baseada no script disponibilizado no Viva o Linux [1].

O script ficou meio grande para colocar aqui no post, então segue um trechinho do código… e no arquivo info_maquina.doc consta o script completo.

#!/bin/bash
#### Script para coletar informacoes da maquina
## Nix - Novembro/2013
# Coleta info de memoria
MEM="$(cat /proc/meminfo | grep "\MemTotal" | cut -d\: -f2-)"
MEM="$(echo ${MEM})"
# Coleta info processador - quantidade
NPROC="$(cat /proc/cpuinfo | grep -i processor | wc -l)"
NPROC="$(echo ${NPROC})"
# Coleta info processador - modelo
PROC="$(cat /proc/cpuinfo | grep "\model name" | tail -1 | cut -d\: -f2-)"
PROC="$(echo ${PROC})"

Saída na tela:

Saída informações da máquinas
Saída informações da máquinas

Referência:

[1] Script simples para pegar informações sobre a placa de rede

Anúncios

Script para validação de senhas em massa

Estreando uma nova categoria dentro de Learning no blog: Scripts.

Não… não sou programadora… mas quem administra sistemas, desde cedo aprende que quanto mais tarefas rotineiras for possível automatizar… mais tempo terá para fazer coisas interessantes, como por exemplo, iniciar um estudo de uma tecnologia que pode ser utilizada na empresa, ou trabalhar em algum projeto, enfim… ‘n’ coisas :).

Ainda tenho muito o que aprender em termos de script (começando pela lógica :(), mas andei brincando com alguns scripts e descobri que apesar de não saber programar, não é que eles foram de grande ajuda no meu dia-a-dia? 🙂

Mas vamos lá… Recentemente, precisei fazer uma validação em massa da senha de root em vários servidores, sendo que para cada um a senha era diferente.

Com a ajuda do expect [1] e um howto [2] bacana encontrado by google, consegui realizar a validação :).
pwtest.exp
#!/usr/bin/expect -f

################################################################################################################
## Script para testar a conexão com o servidor e checar se a senha do usuário root está correta ou não ##
## Utiliza o comando expect para fazer o acesso e inserir a senha ##
## Referência: http://www.pantz.org/software/expect/expect_examples_and_tips.html ##
## Nix - 23/08/2013 ##
################################################################################################################
######### Variaveis ######### 
set timeout 9
set HOST [lindex $argv 0]
set PASS [lindex $argv 1]
log_user 0

## Inicializa a conexão SSH 
spawn ssh -q -o StrictHostKeyChecking=no root@$HOST
## Mensagem de erro a ser exibida caso ocorra timeout na conexão SSH (prompt que solicita a senha não é exibido)
## *assword é para corresponder "Password" ou "password" :)
expect {
 timeout { send_user "\nFailed to get password prompt\n"; exit 1 }
 eof { send_user "\nSSH failure for $HOST\n"; exit 1 }
 "*assword"
}
## Caso o prompt que solicita a senha é exibido, a mesma é enviada
send "$PASS\r"

## Mensagem a ser exibida caso a senha esteja incorreta
## *\# indica o prompt do usuário - no caso, o root
expect {
 timeout { send_user "$HOST - Login failed. Password incorrect.\n"; exit 1}
 "*\# "
}
## Caso a senha esteja correta, é exibida a mensagem abaixo:
send_user "$HOST - Password is correct\n"

## Desconecta do servidor - o mesmo que Control+D:
send "exit\r"
## Encerra programa
close

==============================================================================================================================
valida_pw.sh
#!/bin/bash

################################################################################################################
## Script para validar senhas em massa a partir de um arquivo de servidores e outro com as respectivas senhas 
## Executa o arquivo pwtest.exp 
## Nix - 23/08/2013
################################################################################################################

######## Variaveis ########
# Lista de servidores
HOSTS=$(cat /root/temp/hosts_dev.txt)
# Arquivo de senhas
PWDS=$(cat /root/temp/pws_dev.txt)

####### Contador para ler o arquivo de senhas linha a linha #######
i=0
for pd in $PWDS; do
 pws[$i]=$pd;
 i=`expr $i + 1`
done

####### Contador para ler o arquivo de hosts linha a linha e testar a senha usando o script expect #######
### É passado como parâmetro o servidor ($j) e a senha do mesmo ($pws)
i=0
for j in $HOSTS; do
 /root/temp/pwtest.exp $j ${pws[$i]}
 i=`expr $i + 1`
done

============================================================================================================================== 

Para executar (antes é necessário dar permissão usando o comando chmod ;)):

$./valida_pw.sh

Até a próxima! 🙂
Referências:
[1] http://www.nist.gov/el/msid/expect.cfm
[2] http://www.pantz.org/software/expect/expect_examples_and_tips.html

Exibindo data e hora na saída do comando history

O comando history, como o próprio nome diz, é um histórico de comandos executados no sistema.

Uma informação legal para se ter na saída da lista, é a data e hora.

Para isso, basta inserir a variável HISTTIMEFORMAT no arquivo .bashrc:

HISTTIMEFORMAT=”%d/%m/%y %T – “

Onde:

  • %d – Dia
  • %m – Mês
  • %y – Ano
  • %T – Hora

Após salvar e sair do arquivo, é necessário atualizar a sessão. Isso pode ser feito saindo do terminal e entrando novamente, ou executando o comando source:

$ source ~/.bashrc

Após isso, basta digitar o comando history. Alguns exemplos:

$ history
    1  29/07/12 10:38:46 uname -r
    2  29/07/12 10:38:46 – free -m
    3  29/07/12 10:38:46 – cat /etc/debian_version

Para saber mais:

$ man bash
$ help history
$ man 3 strftime

Até a próxima! 😉

Arquivo .bash_aliases

Já falei um post sobre o comando alias.

Esse comando é bem interessante, pois permite criar apelidos para os comandos de uma forma que seja mais fácil para lembrar.

Embora seja útil, eu sempre fui um tanto restritiva no uso do alias, pois acho que, se acostumar demais a usar o alias, pode acabar esquecendo como usar o comando de verdade, ou até esquecer o nome real para o comando… o que, para que está aprendendo a trabalhar com Linux, pode ser um tanto desastroso.

Mas… o comando alias existe, é útil e eu finalmente deixei de ser chata comigo mesma e comecei usar o alias :P. O motivo? Diariamente, preciso fazer acessos à muitas máquinas… muitas mesmo. E eu não lembro o IP, nem o nome da rede, e muito menos as portas que preciso acessar… Então achei que seria bacana utilizar o alias com o nome das máquinas com o comando ssh…

Comecei fazendo o simples:

# vim ~/.bashrc
alias nix=’ssh ivani@nix.com.br’

A linha acima, eu inseri no arquivo .bashrc do meu usuário. Mas, dando uma lida mais atenta ao .bashrc, vemos que é possível ter um arquivo exclusivo de alias, o .bash_aliases.

Claro que você continua tendo a liberdade de manter seus alias no .bashrc, mas a idéia de concentrar todos alias em um arquivo só é legal porque facilita a manutenção.

A parte do .bashrc que chamou minha atenção é essa:

# Alias definitions.
# You may want to put all your additions into a separate file like
# ~/.bash_aliases, instead of adding them here directly.
# See /usr/share/doc/bash-doc/examples in the bash-doc package.

if [ -f ~/.bash_aliases ]; then
. ~/.bash_aliases
fi

A primeira providência, foi instalar o pacote bash-doc. Uso o Ubuntu 9.10, então fui no terminal e executei:

# sudo apt-get install bash-doc

Depois de instalado, copiei o arquivo Bash_aliases para o meu home:

# cp /usr/share/doc/bash-doc/examples/startup-files/Bash_aliases .bash_aliases

Em seguida editei o arquivo que copiei:

# vim ~/.bash_aliases

Quando editamos o arquivo, ele já vem com alguns exemplos de aliases, que podemos comentar. Eu comentei as linhas dos blocos “Some useful alias” e “Csh compatability” e acrescentei no final do arquivo os meus aliases:

alias ls=’ls –color=auto’
alias grep=’grep –color=auto’
alias fgrep=’fgrep –color=auto’
alias egrep=’egrep –color=auto’
alias nix=’ssh ivani@nix.com.br’

Aí depois salvei o arquivo, saí e atualizei com o comando abaixo:

#source ~/.bashr_aliases

E para ver os alias que estão disponíveis, execute:

# alias

Referência:

Adding Terminal Aliases to Ubuntu

Variáveis de ambiente

Como já falamos em um post anteriormente, o shell é a interface entre o usuário e o kernel do sistema operacional.

O shell padrão do Linux é o bash; ele é executado em um ambiente controlado pelas variáveis de ambiente, que nada mais são do que definições e valores que, tanto o shell como outros programas utilizam para configuração do ambiente do usuário no momento em que é realizado o login.

Existem dois tipos de variáveis:

✔ Variáveis de Usuários – variáveis criadas pelo próprio usuário.
✔ Variáveis de Sistema – variáveis criadas pelo próprio sistema.

Variáveis de Ambiente

Como dito anteriormente, variáveis são nomes que contém algum valor e tem a forma Nome=Valor. Lembram, quando estavam na escola e tinha que fazer as continhas para descobrir o valor da variável x? Por exemplo, x=10. Traduzindo para a forma Nome=Valor, aqui o x, seria o Nome, e Valor, o conteúdo da variável.

As variáveis de ambiente são individuais para cada usuário do sistema ou consoles virtuais e permanecem residentes na memória RAM até que o usuário saia do sistema (logoff) ou até que o sistema seja desligado.

Algumas variáveis do GNU/Linux afetam o comportamento de todo o Sistema Operacional, como por exemplo, o idioma utilizado e o path.

A declaração de variáveis é feita da seguinte forma:

NOME_DA_VARIAVEL=valor_inicial

Onde:

NOME_DA_VARIAVEL – Nada mais é que o nome que queremos dar a nossa variável.

valor_inicial – É o primeiro valor que daremos a nossa variável. Este valor se faz necessário para determinar ao sistema que “tipo” de informação iremos ter na variável.

Exemplo:

Criar uma variável chamada LINUX com o valor Debian:

# LINUX=Debian

Para visualizarmos o conteúdo de uma variável, utilizamos o comando echo, que, além de exibir mensagens na tela, também tem o poder de exibir o conteúdo de uma variável.

Visualizando o conteúdo da variável criada:

# echo $LINUX
Debian

No exemplo acima, estamos visualizando o valor da variável LINUX, que é Debian.

Para que o shell saiba que o comando echo deve exibir o conteúdo de uma variável e não mostrar uma mensagem na tela, devemos adicionar no início do nome da variável o caractere $.

Comandos para manipular variáveis de ambiente

set
O comando set lista todas as variáveis de ambiente do usuário tais como o nome da máquina, arquitetura da máquina, usuário logado, etc…

Exemplo:

# set
HOSTNAME=switch
HOSTTYPE=i486
USER=root
MACHTYPE=i486-pc-linux-gnu
OSTYPE=linux-gnu

Se quisermos visualizar a variável que criamos, podemos filtrar a saída do comando set:

# set | grep LINUX
LINUX=Debian

export
O comando export faz com que a variável criada seja visualizada em todos shells. No exemplo em que criamos a variável LINUX, esta ficou disponível somente no shell em que foi criada… para que seja visualizada em um novo shell, é necessário exportar; e aí, utilizamos o comando export.

Exemplo:

# export LINUX

Para visualizar a variável que foi exportada, utilizamos o comando env, que é o responsável por visualizar as variáveis definidas globalmente:

# env

Visualizar somente a variável LINUX que foi exportada:

# env | grep -i linux
LINUX=Debian

Arquivos de configuração do ambiente do usuário

Além dos comandos que vimos acima, existem arquivos que são utilizados para configurar e carregar o ambiente do usuário. Isso quer dizer que, em um shell que exige login, ou seja, pede um nome de usuário e senha, o sistema irá verificar a existência dos arquivos listados abaixo e executará os comandos que estiverem dentro dos mesmos:

1) /etc/profile
2) ~/.bash_profile
3) ~/.bash_login
4) ~/.profile

/etc/profile
Este arquivo contém comandos que são executados para todos os usuários do sistema no momento do login; somente o usuário root tem permissão para modificar este arquivo.

Ele é lido antes do arquivo de configuração pessoal de cada usuário (.profile caso seja root e .bash_profile caso seja um usuário comum).
.bash_profile
Este arquivo reside no diretório pessoal de cada usuário. É executado em ambientes que usam autenticação (nome e senha). O .bash_profile contém comandos que são executados para o usuário no momento do login no sistema.

Lembrando que se trata de um arquivo oculto pois tem um “.” no início do nome. Aqui, podemos configurar por exemplo, os alias que vimos no post anterior.

Por exemplo:

# echo “alias rm=’rm i'” >> ~/.bash_profile

O comando acima, irá acrescentar a linha alias dentro do arquivo .bash_profile. Fique atento ao operador de redirecionamento, que é o >>, isto é, está acrescentando a linha no arquivo!

Variável PS1
Essa é a variável que contém o formato do prompt do Linux. Ela pode ser modificada através do arquivo .bash_profile (para usuários comuns) ou no .profile (para usuário root).

Por padrão, ela vem configurada da seguinte forma:

PS1=”[\u@\h \W]\$”

Cada uma dessas letras, exibe uma informação no prompt:
\u => Exibe o usuário no momento;
\h => Exibe o nome da máquina;
\W => Exibe o caminho completo do diretório que você está no momento
\$ => Indica o tipo de usuário logado. Se você for usuário comum, será apresentado o símbolo $, em caso do superusuário (root), será #.

Assim como praticamente tudo no Linux, seu prompt pode ser personalizado também. Por exemplo, alguém pode sentir saudade do ‘cebiquim’, isto é, do famoso C:\>.

Não é elegante como o prompt do Linux, mas… se quiser matar a saudade, faça assim:

PS1=”C:\> “

Configurando a variável PS1 conforme mostrado acima, seu terminal trará o C:\>.

Depois que altera o arquivo, é necessário atualizá-lo para que as configurações sejam aplicadas. Você pode deslogar e logar novamente, ou então, utilizar o comando source:

# source ~/.bashrc

O comando acima, irá reler o arquivo .bashrc e efetuar as alterações no prompt.

É isso aí, pessoas… até o próximo post 😉 !

Comando alias

Neste post, vou falar sobre alias, que seriam mais ou menos como apelidos que podemos colocar em comandos. Muitas vezes temos uma linha de comando muito extensa, então é mais fácil criar um apelido para essa  linha de comando ao invés de digitar a linha toda.

O comando que cria os tais apelidos, é o alias… e sua sintaxe é:

alias <apelido>='<comando_linux>

Onde, <apelido> é o “apelido”, e, <comando_linux>, é o comando real que receberá o alias.

E detalhe… não deve existir espaços antes e depois do “=” e, caso o <comando_linux> tenha mais de uma palavra, ele deve vir entre ‘aspas simples’.

Por exemplo… teve um post que falei sobre o comando rm… e até mencionei que este é um comando que deve ser utilizado com muito cuidado!

Nos exemplos do comando rm, vimos que existe a opção -i, que é interativo… e teve até um comentário no post, falando sobre criar um alias para pedir confirmação ao remover um arquivo ou diretório!

Então, vamos criar o alias aqui:

# alias rm=’rm -i’

Após executar o comando acima, toda vez que for remover um arquivo ou diretório, será solicitado uma confirmação. Por exemplo:

# cd /tmp

# touch teste.txt

# rm teste.txt
rm: remove arquivo comum vazio `teste.txt’? y

Para confirmar a remoção, basta teclar y ou então, se desistir de remover, basta teclar n.

Outro exemplo de alias: para limpar o terminal, no Linux utilizamos o comando clear. Para quem tem saudades do DOS e quer usar o cls, basta criar um alias com esse nome:

# alias cls=’clear’

Aí, toda vez que executar o comando cls, irá limpar a tela.

É importante lembrar que, ao criar o alias, o comando original, não será apagado! Isso quer dizer que, caso digite o comando clear, ele irá limpar a tela normalmente! Só no caso do comando rm que, se você não remover o alias ele sempre irá pedir confirmação… se bem que no caso do rm, sempre é bom manter o alias que pede a confirmação 😉 !

Para checar os alias disponíveis, basta executar o comando alias sem argumentos:

# alias
alias rm=’rm -i’
alias cls=’clear’

Para remover um alias, basta executar:

# unalias cls

# alias
alias rm=’rm -i’

Para remover todos os alias:

# unalias -a

Onde a opção -a irá remover todas as definições de alias.

Até o próximo post! 😉