Administración distribuida con SSH

Administración distribuida con SSH

Uso de SSH para ejecutar comandos en sistemas UNIX, con algunos scripts sencillos, poder habilitar la administración de mútliples sistemas simultáneamente desde una computadora sin loggear directamente en las máquinas. Tambíen veremos conceptos basicos de un sistema de administración distribuida con algunos scripts que usan esta técnica.

Simplificando el login remoto

La herramienta SSH proporciona métodos seguros para loggear y para intercambiar información con un sistema remoto. Un número de herramientas diferentes existen para este propósito, incluyendo SSH, SCP y SFTP.

Todas las herramientas anteriores son seguras y la información es encriptada al intercambiarse con un host remoto. La autenticación es segura ya que usa un mecanismo de llave pública o privada. Uno de los principales beneficios de SSH es que podemos “brincar” el loggin y password copiando nuestra llave pública en la máquina remota.
Esto de de mucha utilidad cuando accesamos de manera remota (esto significa que no proporcionaremos un password) para administrar a una computadora.

Cuando queremos acceder a mútiples máquinas mediante SSH sin intercambiar nuestra llave pública, necesitamos teclear nuestro password para cada máquina.

Una manera sencilla de crear una clave pública es de la manera siguiente:

$ssh-keygen -t rsa

Siga las instrucciones en la pantalla, pero no establezca un password, de lo contrario se tendría que introducir el password cada vez que se quiera usar la llave. Se crean un par de archivos que contienen una llave privada y una llave pública. Ahora sólo necesita agregar el contenido de la llave pública del archivo .ssh/id_rsa.pub dentro del archivo .ssh/authorized_keys en la máquina remota y el usuario que queremos que ingrese al sistema. Necesitamos agregar el contenido de la llave para cada máquina en donde deseamos ingresar de manera automática.

Ejecutando un comando remoto

Existen muchas maneras de ejecutar un comando remoto.

Podemos ejecutar un comando remoto, agregando el comando que queremos ejecutar después de la información del host o login. Por ejemplo, para obtener información del disco del host remoto:

$ssh usuario@foo.com df

Hay que recordar que hay que ingresar el password si no tenemos la llave pública en el host remoto.

También podemos ejecutar una secuencia de comandos separando cada comando por un punto y coma (;) y rodeados de comillas:

$ssh usuario@foo.com “df; uptime”

Podemos ejecutar múltiples comandos.. solo hay que asegurarse de que siempre se deben de rodear de comillas.

Simple-CDD (Instalador debian personalizado)

• Para realizar un instalador debian personalizado solo hay que seguir estos sencillos pasos:

$mkdir ~/mi-simple-cdd
$cd ~/mi-simple-cdd

• Agregamos un repositorio a nuestra lista de repositorios:

$echo "deb http://http.us.debian.org/debian unstable main" >> /etc/apt/sources.list

• Actualizamos nuestros repositorios:

$apt-get update

• Instalamos ahora unos paquetes:

$apt-get -t stable install simple-cdd devscripts

• Agregamos nuevamente un nuevo repositorio:

$echo "deb http://http.us.debian.org/debian unstable main/debian-installer" >> /etc/apt/sources.list

• Actualizamos:

$apt-get update

• Obtenemos el archivo:

$dget simple-cdd-profiles

• Comentamos ahora las dos lineas agregadas a nuestro archivo de repositorios y actualizamos nuevamente:

$apt-get update

• Creamos el directorio donde se almacenaran los archivos de perfiles:

$mkdir profiles

• Colocamos ahora dentro de ese directorio la lista de paquetes que deseamos instala, esta lista debe estar contenida en el archivo: NOMBRE.packages

• Enseguida construimos el CD con el perfile seleccionado, e incluyendo el archivo simple-cdd-profiles.udeb:

$build-simple-cdd --profiles NOMBRE --local-packages $(pwd)/simple-cdd-profiles_*.udeb

• Se creara un repositorio parcial dentro del directorio "tmp/mirror", y si todo va bien obtendremos una imagen .iso dentro del directorio "images", lista para ser quemada en un CD.

qemu

Para obtener una maquina virtual con qemu realizamos lo siguiente:

Primero creamos la imagen de disco, es decir, un fichero que contiene la imagen del disco duro del sistema a emular:

$qemu-img create -f qcow sistema.qcow 8G

Creamos una imagen superpuesta a ésta, que en caso de problemas podamos regresar a la imagen original:

$qemu-img create -b sistema.qcow -f qcow sistema2.qcow

Comenzamos a instalar nuestro sistema a amular, desde una imagen iso obtenida del disco de instalacion del sistema a emular:

$qemu -cdrom imagen.iso -boot d sistema2.qcow

Al finalizar la instalacion podremos usar nuestro nuevo sistema:

$qemu -hda sistema2.qcow -m 192

Nota: debemos instalar y cargar el acelerador kqemu para ejecutar la maquina virtual en modo acelerado: $modprobe kqemu major=0

Problemas?

El ratón se bloquea:Si el ratón se te va a una esquina, y se clava, prueba a usar este comando:
$export SDL_VIDEO_X11_DGAMOUSE=0

fuentes:

http://www.kriptopolis.org/qemu
http://www.dekazeta.net

Como crear un repositorio trivial en debian

Colocar los paquetes deseados en un directorio e ingresar a el , ejecutando posteriormente el siguiente comando:

$dpkg-scanpackages . /dev/null | gzip -9c > Packages.gz

Para acceder a el desde internet (obviamente apache instalado y bien configurado) agregar en los sources de apt lo siguiente:

deb http://mi.dominio/ruta/a/paquetes ./


y listo!! tendremos un repositorio trivial .

Compilar el kernel a la debian

• Primero, descargar las fuentes del núcleo.
• Agregar al usuario que compilará el núcleo al grupo src, para poder trabajar en el directorio /usr/src.
• Instalar bzip2 para descomprimir el archivo fuente del kernel.
• Mover el archivo fuente al directorio /usr/src.
• Entrar al directorio /usr/src y descomprimir el archivo fuente.

$tar xjvf linux-xxx.tar.bz2

• Se crea un enlace al directorio recién descomprimido que apunta a ese directorio.

$ln -s linux-xxx linux

• Entrar al directorio /usr/src/linux
  

• Hacer $make xconfig (otras opciones son menuconfig o xconfig), aplicar las configuraciones deseadas, guardar y salir.
• Ahora compilemos el nucleo:

$fakeroot make-kpkg -append-to-version .ddmmyy --initrd kernel_image
(donde dd,mm,yy son día, mes y año respectivamentes)

• Si todo fue bien tendremos un paquete .deb del nuevo kernel.