Todo lo que quieres saber de Ubuntu y más…
Tilix es un muy buen emulador de terminal para GTK3 que nos proporciona muchas caracteristicas como soporte para varios paneles, configuración a medida del terminal, notificaciones y un largo etcetera. En las últimas versiones de Ubuntu yo lo he instalado con:
sudo apt-get install tilix
Hace poco fue noticia el acuerdo entre Canonical y Microsoft para que se pueda utilizar Bash en los sistemas Windows como puede ser Windows 10. La integración será tan completa que incluso se podrán ejecutar paquetes de linux.
Pero de todas formas a fecha actual y aunque no usemos Windows 10, tambien podemos
disponer de una shell Bash en Windows mediante diferentes alternativas como pueden ser Cygwin, Clientes ssh como MobaXterm que ya llevan Cygwin integrado, Msys2, Git para Windows (que proporciona emulación bash y herramientas y comandos unix) y la opción que comentaré hoy aquí mediante Cmder.
Cmder es un potente emulador de consola para Windows. Si queremos disponer de los principales comandos unix desde windows nos descargamos la version con git para windows (aproximadamente unos 76 Mb) desde su pagina principal.
La descomprimimos y se crea un directorio Cmder. Ahí ya podemos ejecutar el binario principal con lo que se abre la consola.
Tiene varias opciones de personalización y permite el uso de tabs.
Pero lo principal que comentabamos es que ya podemos ejecutar los principales comandos unix en windows como pueden ser p.ej: «ls» o «ps» O incluso editar y ejecutar nuestros propios scrips en bash.
Podriamos p.ej usar «vim» como editor de texto, escribir nuestro shell script, darle permisos de ejecución y luego ejecutarlo con: «bash <nombre script>».
Hemos visto muchas formas de automatizar las conexiones ssh, desde compartir las claves publicas y privadas, o usar scripts de utilidades como sshput, expect-lite o expect. Hoy otra opción utilizando el comando sshpass. Para quien no se quiera complicar mucho, Este comando nos permite enviar la password cuando establecemos una conexion ssh.
Para instalarlo en ubuntu (o sistemas derivados) ejecutamos: sudo apt-get install sshpass
Despues cuando queramos conectar automaticamente a un servidor remoto mediante ssh, podemos usar la siguiente sintaxis:
sshpass -p <password del host remoto> ssh <usuario remoto>@<host remoto>
Mas información | Desde Linux
Tantos años programando shell scripts y esto era algo que no conocía y que implementaba de otra manera. Si que es verdad el dicho «nunca te acostarás sin aprender algo nuevo». Ya no se me olvidará, pues es muy sencillo. Si tienes una variable puedes obtener un substring de la misma con la forma: ${nombre_variable:posicion de inicio:posicion de fin}
De todas formas, una muy buena guia para aprender y siempre recomendable es: advanced bash scripting guide.
En dbaspot encuentro un buen ejemplo de script de como ejecutar un procedimiento PLSQL desde bash y como almacenar los resultados de las consultas en variables. Éste seria un ejemplo (adaptado para usar mi base de datos Oracle XE):
#!/bin/bash
#OUTPUT=$(sqlplus -s '/ as sysdba' <<-EOF
OUTPUT=$(sqlplus -s system/manager@XE <<-EOF
set heading off feedback off serveroutput on trimout on pagesize 0
select instance_name from v\$instance;
select version from v\$instance;
declare
i number := 0;
begin
while i < 3 loop
dbms_output.put_line('Parametro_PLSQL_' || i);
i := i+1;
end loop;
end;
/
EOF
)
# Sin dejar espacios pq los espacios son los nuevos parametros
INSTANCE=$(echo $OUTPUT | awk '{ print $1 }')
VERSION=$(echo $OUTPUT | awk '{ print $2 }')
ARG1=$(echo $OUTPUT | awk '{ print $3 }')
ARG2=$(echo $OUTPUT | awk '{ print $4 }')
ARG3=$(echo $OUTPUT | awk '{ print $5 }')
echo "Database: $INSTANCE":wr
echo "Version: $VERSION"
echo "Arg1: $ARG1"
echo "Arg2: $ARG2"
echo "Arg3: $ARG3"
Aqui puedes adaptarlo para tus propios ejemplos. Lo más importante la cadena de conexión, yo al usar Oracle XE tengo (system/manager@XE), en tu base de datos pon tu cadena usuario/password@SID. Despues que tambien los parametros devueltos no tengan espacios, pues al asignarlos a variables, el espacio es utilizado como separador. En el script hay una parte donde se devuelve una columna directamente de una select y esta es asignada a una variable de la shell, y otra parte donde se escribe el parametro con el paquete dbms_output.
Éste pequeño tip te vendrá muy bien cuando programes en bash shell script p.ej y necesites mostrar de forma tabulada una serie de columnas de un listado. Hay varias formas de hacerlo, pero muchas veces te complicas con funciones o añadiendo espacios adicionales, controlando la longitud de las cadenas, cuando lo que buscas es algo más básico. Para ello podemos utilizar el comando «column» mediante una pipe.
Ejemplo: ejecuta desde la consola:
mount
Que te muestra la lista de puntos de montaje. Pero sale un poquito desorganizado, no?. Prueba ahora con:
mount | column -t
Mejor no?. Y por qué no usarlo con nuestras propios ficheros. P.ej crea un fichero llamado «ejemplo.txt» con el siguiente contenido:
aaa 12 1234 c
bbbbbbb 2222 234 cc
cccc 2345 333333333 ddddd
Para imprimirlo (por consola) de manera más formateada, puedes ejecutar:
cat ejemplo.txt | column -t
No probado y no es mi caso (asi que el que lo necesite que lo ejecute bajo su propio riesgo) pero esto pasa a menudo cuando tienes tu sistema Linux perfectamente instalado y decides instalar Windows en cualquiera de sus variantes (XP, Win7, etc). Entonces las entradas del Grub se pierden y ya no te deja arrancar con Linux, no te aparece el tipico menu donde te permite seleccionar con que sistema operativo quieres arrancar.
La principal forma de solucionar este problema es reconstruir las entradas del Grub. Para ello habitualmente inicias con un Live CD de Linux, montas la partición de Linux y reinstalas el gestor de arranque.
Para facilitar este proceso se proporciona el siguiente script:
#!/bin/bash #Escrito por T383NH3, Blog: MachGeek.wordpress.com #Inicia desde el LiveCD, luego asignale permisos y ejecuta el script #El script solo esta adaptado para un solo Linux sin home, de lo contrario no funcionara. particion=`sudo fdisk -l | egrep "Linux$" | cut -d" " -f1` sudo mkdir /mnt/Linux sudo mount $particion /mnt/Linux sudo grub-install --root-directory=/mnt/Linux /dev/sda if [[ $? -eq 0 ]] then echo "Operacion completada, al reiniciar no vera el grub, pero si iniciara Ubuntu, luego de esto ejecute en un terminal sudo update-grub y listo!" exit 0 else echo "Error, Operacion no finalizada" exit 1 fi
Cuando esto suceda, despues de instalar windows, inicia desde el LiveCD de Ubuntu, guarda este script con el nombre «grubeco», dale permisos de ejecución al script con chmod +x grubreco y ejecútalo: ./grubreco, reinicias entonces e inicias ubuntu, y finalmente luego en la terminal escribes sudo update-grub.
Nota importante: El script solo esta adaptado para un solo Linux sin home, de lo contrario no funcionara.
Enlace | Taringa
Por si estás programando algun script en bash o necesitar imprimir algun texto en consola de manera especial y no recuerdas cual era la combinación, El siguiente script (color-bash.sh) te imprime una tabla de colores en bash:
#!/bin/bash
# prints a color table of 8bg * 8fg * 2 states (regular/bold)
echo
echo Table for 16-color terminal escape sequences.
echo Replace ESC with \\033 in bash.
echo
echo "Background | Foreground colors"
echo "---------------------------------------------------------------------"
for((bg=40;bg<=47;bg++)); do
for((bold=0;bold<=1;bold++)) do
echo -en "\033[0m"" ESC[${bg}m | "
for((fg=30;fg<=37;fg++)); do
if [ $bold == "0" ]; then
echo -en "\033[${bg}m\033[${fg}m [${fg}m "
else
echo -en "\033[${bg}m\033[1;${fg}m [1;${fg}m"
fi
done
echo -e "\033[0m"
done
echo "--------------------------------------------------------------------- "
done
echo
echo
O tambien puedes descargarlo:
wget dev.redcodenetwork.ro/public/shell/color-bash.sh
chmod +x color-bash.sh
./color-bash.sh
Enlace | Red code | Relacionado | Top 7 de prompts para la terminal
No se si a alguien más le será útil (a mi sí ^^). Si generar un fichero de texto plano es muy simple con el comando «echo».
$ echo "Hola Caracola!!" | tee -a output.txt
Generar un fichero binario tambien es muy simple con echo. Ejemplo:
$ echo -e -n "\x0A\xFF\x01\x02" > output.bin
Crea un fichero binario de 4 bytes con los contenidos en hexadecimal 0A, FF, 01 y 02.
Puedes comprobarlo con un editor hexadecimal, como por ejemplo «bless»
$ bless output.bin
Puedes crear tu propio contenido binario de manera similar mediante echo, concatenando secuencias hexadecimales con «\x»
Trabajo mucho con máquinas remotas, en estos casos me gusta abrir mi terminal y conectarme rapidamente utilizando SSH, lo cual no siempre es «tan rápido» porque he de introducir la contraseña u otros parametros de inicio. Para estos casos recomiendo utilizar aplicaciones tan geniales como Pac Manager, que nos simplifica mucho estas tareas o habilitar la posibilidad de conexion SSH sin necesidad de usar contraseña (mediante clave pública). Pero no siempre podemos hacer lo que queramos en máquinas ajenas o instalar software adicional, asi que me plantee crearme unos sencillos scripts que me permitan acceder rapidamente a todas las máquinas remotas que necesite mediante SSH. Son los siguientes y puedes mejorarlos o personalizarlos como necesites.
conectar
conectar es el script principal, es un script que utiliza el comando «expect» (deberás tenerlo instalado en la máquina) y recupera los siguientes parametros que se le pasan por la linea de comandos: máquina, usuario, password, directorio de inicio y caracter usado para el prompt. Su funcionalidad es tan simple como automatizar la conexion ssh de manera que no sea necesario indicar la password y que nos deje en el directorio indicado. Entonces inicia una sesión interactiva para que escribamos los comandos que necesitemos en la máquina remota.
#!/usr/bin/expect set host [lindex $argv 0] set user [lindex $argv 1] set password [lindex $argv 2] set prompt [lindex $argv 3] set directorio [lindex $argv 4] spawn ssh $user@$host expect "password:" send "$password\n"; expect "$prompt" send "cd $directorio\n"; expect "$prompt" interact
c.txt
Es el fichero que utilizo como base de datos para guardar los datos de las máquinas remotas. Pienso utilizar sqlite más adelante pero no queria complicarlo mucho inicialmente para aquellos que desconozcan el uso de sqlite. El fichero es de la forma:
soledad|127.0.0.1|jose|jose|/home/jose/Escritorio|>|SSH|Mi servidor ssh # Formato: alias | ip | user | password | directorio | prompt | protocolo | descripcion
Es decir, añades una linea por cada máquina a la que quieras conectar y en esta linea indicas el nombre de la conexion (alias a usar), la dirección ip de la máquina, el usuario con el que conectar, la password, el directorio base de inicio donde quieres quedarte al inicio de la sesión, el prompt utilizado y el protocolo.
c
Es el script de bash que se encarga de llamar al script de expect (conectar) con los parametros adecuados. Su función principal es a partir de un alias que se le pasa como parametro, examinar el fichero c.txt y extraer la ip, user, password y directorio de esa máquina, para pasarle esos parametros a expect (script conectar). Si no se le pasa ningún parametro lo que hace es imprimir la lista actual de alias del fichero c.txt a modo de recuerdo de las máquinas a las que puedes conectar.
#!/bin/bash
CONSOLA=false
repo="${HOME}/UTIL/c.txt"
RUTA_LIB="${HOME}/UTIL/"
function DEBUG()
{
if ( $CONSOLA )
then
echo "DEBUG: $1 \n"
fi
}
#-----
GET_IP()
{
busqueda="$1"
#DEBUG "Buscando por : [ $busqueda ]"
cat $repo | grep $busqueda | awk -F"|" '{print $2}'
}
#----
GET_USER()
{
busqueda="$1"
#DEBUG "Buscando por : [ $busqueda ]"
cat $repo | grep $busqueda | awk -F"|" '{print $3}'
}
#----
GET_PASSWORD()
{
busqueda="$1"
#DEBUG "Buscando por : [ $busqueda ]"
cat $repo | grep $busqueda | awk -F"|" '{print $4}'
}
#----
GET_DIRECTORIO()
{
busqueda="$1"
#DEBUG "Buscando por : [ $busqueda ]"
cat $repo | grep $busqueda | awk -F"|" '{print $5}'
}
#----
CONECTAR_SSH()
{
${RUTA_LIB}conectar "$1" "$2" "$3" "$4" "$5"
}
SSH()
{
alias="$1"
_Host=`GET_IP "$alias"`
_User=`GET_USER "$alias"`
_Pass=`GET_PASSWORD "$alias"`
_Directorio=`GET_DIRECTORIO "$alias"`
_Prompt=">"
CONECTAR_SSH "$_Host" "$_User" "$_Pass" "$_Prompt" "$_Directorio"
}
ALIASNAME="$1"
if [ -z $ALIASNAME ];
then
echo "Sintaxis: $0 <alias o nombre maquina>"
echo ""
echo "Conexiones disponibles:"
echo "-----------------------"
echo ""
tac $HOME/UTIL/c.txt | grep -v "#" | awk -F"|" '{print $1}' | sort
else
SSH "$1"
fi;
Nota importante: por defecto todos estos scripts deben estar ubicados en $HOME/UTIL aunque se podria editar fácilmente el último script para que utilizara otro path.
Nota 2: el prompt de momento no lo uso y paso por defecto «>» pero es fácil de usar el que sea necesario. p.ej «$»
Por último sólo seria necesario crear el siguiente «alias» en nuestro fichero .bashrc
alias sshe=’$HOME/UTIL/c \$1′
Uso «sshe» por que me recuerda a «ssh y la e es de expect» pero podrias usar cualquier otro nombre.
Ahora conectar a cualquier máquina es tán simple como ejecutar desde consola:
$ sshe alias_de_la_maquina
Ejemplo:
$ sshe soledad
(usa tus propias máquinas de acuerdo al fichero c.txt)
y los scripts anteriores ya se encargan de dejarte el terminal preparado con la conexión ssh abierta.
He preparado un instalador que se encarga de copiar ya todo a tu directorio $HOME/UTIL. Puedes descargarlo junto al resto de scripts del siguiente enlace (nota: wordpress no me deja subir ficheros .zip directamente , asi que está renombrado como .doc pero realmente es un fichero .zip, cambiale la extensión y ya lo podrás descomprimir).
Espero que sea útil, a mi por lo menos si que me lo resulta.
Descarga | SSHE.zip
Ubuntu Life 
Comentarios recientes