Uma feature que eu ainda não tinha usado é a API que eles disponibilizam para todos os clientes. Bem bacana e flexível.

Como em casa eu tenho IP dinâmico e vez por outra ele muda justamente quando preciso acessar de volta resolvi aproveitar e fiz um shell script quick’n dirty pra usar esse recurso bacana.

Sei que existem diversos serviços de DNS dinâmico por ai, mas preferi essa alternativa que pode ser útil pra mais alguém com uma necessidade parecida.

Tá aqui o script.

Uma forma simples de conseguir uma segurança bacana é utilizar o modo restrito do bash. Com isso habilitado o shell irá desabilitar as seguintes funções:

• Mudar o diretório (cd)
• Mudar o valor das variáveis SHELL, PATH, ENV, or BASH_ENV
• Comandos que incluem /
• Especificar um arquivo que contenha / como fonte para o comando “.”
• Usar redirecionamento de output (>, >>, |)
• etc (man bash para todas as features)

Colocando para rodar:

Crie um link do bash para o rbash e adicione o mesmo em /etc/shells:

ln -s /bin/bash /bin/rbash
echo /bin/rbash >> /etc/shells

Depois é só mudar o shell do usuário a ser restringido para usar o rbash:

usermod -s /bin/rbash username

Combinando isso com traps (do CTRL+C, por exemplo) você consegue criar um ambiente seguro o suficiente para fornecer serviços e acessos aos seus servidores e ainda assim dormir à noite.

Como diria o SuSE: Have a lot of fun!

Eu cai na seguinte situação: Tenho um número X de servidores que tem um usuário que eu posso utilizar para dar login. Existem 4 senhas possíveis para este usuário, mas eu não sei qual senha está em qual servidor, de forma que eu tenho que ir tentando até conseguir quando tento conectar no mesmo.

Depois de conseguir dar login na máquina eu tenho que virar root. Eu sei que cada servidor tem uma senha de root diferente, mas sempre que eu usar a senha de usuário X a senha de root vai ser Y, senha de usuário A, senha de root B.

Até o momento só consegui semi-automatizar o processo, mostrando na tela qual senha funcionou para o usuário, de forma que eu vou saber qual senha de root usar. O ideal é automatizar o login de forma que eu só precise bater o nome da máquina e já caia no prompt de root.

O que fiz foi:

#!/bin/bash
 
senhas="senha1 senha2 senha3 senha4"
 
SERVER=$1
 
for senha in $senhas
do
    export SSHPASS=$senha
    echo "Tentando $senha"
    sshpass -e ssh user@$SERVER
    [ $? -eq 0 ] && exit
done

O Pascal me sugeriu o paramiko, mas acho que ele não tem a funcionalidade de me entregar o prompt de comando. Estou tentando também usar o Pexpect, mas sem muita sorte.

Me deparei com um problema assim hoje: Eu tinha uma função num script shell que recebia um parâmetro de sucesso ou erro. Eu executava algumas coisas e depois tinha que jogar uns dados no arquivo respectivo.

Então inicialmente tinha setado uma variável com os paths dos caminhos:

1
2

ARQUIVO_SUCESSO=/tmp/sucesso
ARQUIVO_ERRO=/tmp/erro

Minha função recebia o status como o primeiro argumento ($1) e por isso depois de processar eu precisaria de algo assim:

1

echo "batatinha" >> $ARQUIVO_$1

Mas logo percebi que isso não funciona. A solução, no entanto, é simples:

1

echo "batatinha" >>  $(eval echo \$ARQUIVO_$1)

Anotem ai na caixa de truques do Bash.

E funciona que é uma maravilha…

$ echo $BASH_VERSION
4.0.0(1)-release
$ declare -A COMIDA
$ COMIDA[Arroz]=Branco
$ COMIDA[Feijao]=Tutu
$ COMIDA[Ovo]=Frito
$ COMIDA[CARNE]=Bife
$ echo ${COMIDA[@]}
Bife Tutu Branco Frito
$ echo ${COMIDA[Arroz]}
Branco
$ echo ${COMIDA[Feijao]}
Tutu
$ echo ${COMIDA[Ovo]}
Frito
$ echo ${COMIDA[CARNE]}
Bife

Mais informações sobre as novas features aqui.

!$

Representa a última parte do último comando executado. Exemplo:

$ grep macarrao comidas.txt
macarrao

$  cat !$
cat comidas.txt
arroz
feijao
batata frita
macarrao

Expansão automática

Expande automaticamente os valores entre chaves. Uma mão na roda para loops:

$ for i in {1..4}; do echo "i vale $i"; done
i vale 1
i vale 2
i vale 3
i vale 4

Também funciona com letras:

$ for i in {a..d}; do echo "i vale $i"; done
i vale a
i vale b
i vale c
i vale d

E pode ser útil em situações assim:

$ mkdir -p diretorio{a..c}/sub-diretorio{w..z}

$ find .
.
./diretorioc
./diretorioc/sub-diretoriow
./diretorioc/sub-diretoriox
./diretorioc/sub-diretorioz
./diretorioc/sub-diretorioy
./diretoriob
./diretoriob/sub-diretoriow
./diretoriob/sub-diretoriox
./diretoriob/sub-diretorioz
./diretoriob/sub-diretorioy
./diretorioa
./diretorioa/sub-diretoriow
./diretorioa/sub-diretoriox
./diretorioa/sub-diretorioz
./diretorioa/sub-diretorioy

^antigo^novo

Executa o último comando substituindo o valor antigo pelo novo. Exemplo:

$ cat /etb/lsb-release
cat: /etb/lsb-release: No such file or directory

$ ^b^c
cat /etc/lsb-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=8.10
DISTRIB_CODENAME=intrepid
DISTRIB_DESCRIPTION="Ubuntu 8.10"

!!

Reexecuta o último comando. Útil quando você esqueceu algo, como o sudo na frente do comando. Exemplo:

$ whoami
user

$ sudo !!
sudo whoami
root

Mais truques e dicas aqui.

Na foto (esquerda pra direita): Eu, Júlio Cézar Neves e Aurélio Marinho Jargas. Autores de “Programacão Shell Linux” e  Shell Script Profissional.

Entenderam? “Entre os maiores”? Hein? Hein?

Macaco do Chongas rulez. Voltamos à programação normal.

Pior ainda quando você precisa que alguém com menos experiência ou conhecimento (aka suporte nível 1) verifique para você o estado do servidor.

A idéia é então centralizar essa checagem num único script, simples e funcional, para facilitar a sua vida e a dos outros admins.

Tenho certeza que já existem por ai trocentos scripts/programas/whatever para fazer isso, mas eu estava entediado e precisava usar um pouco de Perl para não enferrujar completamente (É… ando usando só Python e Bash).

O script está disponível aqui e está bem documentado e é de simples entendimento.

Basta criar um arquivo /etc/checks.txt contendo o que você esperaria ver rodando normalmente e está feito.

Não sei os meus 2 leitores geeks (já que meu pai, minha mãe e minha esposa – meus outros 3 leitores – não se encaixam nesta categoria), mas eu tenho que olhar o man ou o google toda vez que preciso criar um arquivo em branco com o dd. Tenho algum tipo de bloqueio com aquela sintaxe chata dele.

Então resolvi perder uns minutos e fazer um mkfile for Linux, em bash script mesmo. Divirtam-se.

#!/bin/bash
#=============================================================================
#
# mkfile - bash implementation of Solaris' mkfile tool for Linux
#
# Usage:  mkfile [-v] size [g | k | b | m] filename
#
#   Eri Ramos Bastos
#   http://geek.linuxman.pro.br
#=============================================================================
 
progname=$(basename $0)
function die () { echo "$progname: $1"; exit ${2:-1}  ; }
VERBOSE=">/dev/null 2>&1"
 
function Help ()
{
echo "Usage: mkfile [-v] <size>[g|k|b|m] <name1> [<name2>] ..."
echo "  -v    Verbose"
echo
return 0
}    # ----------  end of function Help  ----------
 
#-----------------------------------------------------------------------
#  Check number of command line arguments and set verbose
#-----------------------------------------------------------------------
if [ $# -lt 2 ]
then
Help; die "Insufficient number of arguments"
elif [ $# -gt 2 ]
then
[ "$1" = "-v" ] &&  VERBOSE="" && shift
fi
 
SIZE=$(echo "$1"|tr [kmg] [KMG]) ; shift
 
for file in ${@}
do
eval dd if=/dev/zero of="$file" count=1 bs="$SIZE" "$VERBOSE"
[ $? != 0 ] && Help && die "Error creating file $file" 2
done

Às vezes o que sentia falta era de alguma coisa para facilitar minha vida quando estava fazendo meus scripts. Alguns pedaços de código você usa de novo, de novo e de novo. E é um saco ficar redigitando.
Importar para dentro do arquivo atual (ESC:r /path/arquivo) ajuda, mas não resolve.

A solução

Pesquisando achei o sensacional BASH-IDE para vim. Resolveu todos os meus problemas, exceto a falta de competência como programador.
Utilizando o BASH-IDE podemos configurar um template para novos arquivos, de forma que sempre que abro um novo arquivo .sh no vim ele já adiciona o cabeçalho com informação sobre o autor, data, tag $id$ pro cvs e algumas variáveis e funções que eu coloco em todos os meus script.

O autor do BASH-IDE foi cuidadoso para facilitar a documentação de forma que vários atalhos já são auto-documentados.
Uma nova função criada utilizando o BASH-IDE automaticamente terá o seguinte aspecto:

function teste ()
{

}    # ----------  end of function teste  ----------

E ao chamar o atalho para documentação de função você recebe este template:

#===  FUNCTION  ================================================================
#          NAME:
#   DESCRIPTION:
#    PARAMETERS:
#       RETURNS:
#===============================================================================

Como tudo é baseado em arquivos texto, as customizações só dependem da sua boa vontade. E ainda vem com um uma cheat sheet em pdf pronta para imprimir e pendurar na sua baia!

Boa diversão