Jam Blog - Isla de Margarita - Venezuela

Crea tu propia nube con Syncthing, alternativa a BTSync y AeroFS

2015-01-07T00:00:00-04:30

Syncthing es una aplicacion opensource de sincronizacion de archivos escrita en Golang la cual implementa su propio protocolo de Block Exchange.

Syncthing es de codigo abierto y viene a ser una alternativa a BittorrentSync y AeroFS, la cual son dos conocidas aplicaciones para sincronizar archivos usando el protocolo P2P y conectando los nodos (PC, Laptop, Servidor) de forma directa, sin usar ningun servidor como intermediario y encriptando todas las comunicaciones entre ellos.

Con Syncthing tu eres propietario de tu propia nube y de tus datos, tu ideas la infrastructura a usar y como la vas a usar, tu decides que se va a respaldar y cuantas replicas quieres tener ademas de decidir que tanto espacio de almacenamiento quieres o necesitas. Esta aplicacion es tambien multiplataforma por lo que puedes correr un nodo en Linux, BSD, Windows y mac.

Instalacion:

En el Servidor uno descargamos los binarios de Syncthing desde su repositorio Github

Para el momento de escribir este articulo la ultima version es la v0.10.18. En mi caso descargo la version de 32bits para Linux, pero en la misma pagina puede descargarse las versiones 64bits y las versiones para plataformas como BSD, Windows y mac.

$ wget https://github.com/syncthing/syncthing/releases/download/v0.10.18/syncthing-linux-386-v0.10.18.tar.gz

Descomprimir el paquete de binarios

$ tar xzvf syncthing-linux-386-v0.10.18.tar.gz

y luego copiamos el binario syncthing ubicado en la carpeta que se crea al descomprimir el paquete al directorio /usr/local/bin/

$ sudo cp syncthing-linux-386-v0.10.18/syncthing /usr/local/bin/

una vez copiado el binario podemos eliminar la carpeta extraida pues ya no la necesitamos.

Servicio upstart para Debian/Ubuntu:

Con esto tenemos Syncthing instalado y listo para usar, pero seria un poco incomodo ejecutarlo pues tendriamos que iniciarlo desde esa carpeta, en este caso usaremos un script upstart para poder arrancar y detener syncthing mas facil.

Creamos un archivo en /etc/init/ con el nombre syncthing.conf y colocamos el siguiente contenido:

description "Syncthing P2P sync service"

start on (local-filesystems and net-device-up IFACE!=lo)
  stop on runlevel [!2345]

  env STNORESTART=yes
  env HOME=/home/tu_usuario
  setuid "tu_usuario"
  setgid "tu_grupo"

  exec /usr/local/bin/syncthing

  respawn

Notese que se ajusta el directorio HOME de tu usuario y se agrega tu nombre de usuario y grupo en setuid y setgid.

Con esto ya podemos arrancar el servicio de Syncthing con un simple:

$ sudo initctl start syncthing

o con un simple:

$ sudo service syncthing start

Configuracion basica en servidores:

Ya en este punto deberiamos tener corriendo syncthing, por default la interfaz web escucha en el puerto 8080 y como medida de seguridad lo hace solo en localhost, lo que quiere decir que por defecto no puedes acceder de forma remota.

Syncthing en el primer arranque crea un archivo config.xml de Configuracion en la ruta ~/.config/syncthing/. Si abrimos este archivo en un editor podemos editarlo para que pueda recibir conexiones desde el exterior y poder administrar Syncthing de forma remota.

Buscamos las siguientes lineas:

<gui enabled="true" tls="false">
    <address>127.0.0.1:8080</address>
</gui>

y reemplazamos la IP 127.0.0.1 por 0.0.0.0

NOTA: De seguro estas utilizando un Firewall en tu servidor, por lo que es necesario que abras el puerto 8080 para poder recibir conexiones entrantes.

$ sudo ufw allow 8080
$ sudo ufw allow 22000

Syncthing usa por defecto el puerto 22000 para el protocolo de sincronizacion por lo que este tambien debe abrirse para conexiones entrantes.

Con esto ya puedes acceder a tu servidor desde el navegador y configurar Syncthing desde la interfaz web incluida. http://servidor.tld:8080

En la parte superior derecha podemos ver un engranaje desee el cual podemos acceder a la seccion de configuracion:

Como se puede notar, es posible configurar el nombre del dispositivo (nodo), la ip y puerto de escucha para la interfaz web, y lo mas importante, la asignacion de un nombre de usuario y clave para proteger el acceso a interfaz web, asi como el uso de HTTPS para proteger la comunicacion en dicha interfaz.

De esta misma forma es posible instalar y configurar multiples servidores (nodos) en internet para sincronizacion y respaldo de archivos.

Conexion entre dos nodos y comparticion de archivos:

La forma en la que Syncthing se comunica entre los demas nodos es usando un ID unico. En el primer arranque, Syncthing genera este ID para identificar el nodo.

Un ID identificador de nodo es similar a esto:

y es posible obtenerlo desde el boton de engranaje antes mencionado, haciendo click en “Mostrar ID”

Notese que tambien se visualiza un codigo QR, esto es debido a que esta en desarrollo una version para telefonos celulares en la que podemos agregar los nodos de sincronizacion usando su codigo QR.

Para agregar un nodo al cual nuestro servidor puede comunicarse para sincronizar archivos y carpetas basta con hacer click en “Agregar Dispositivo” en la pagina principal de la interfaz web, a continuacion nos aparece un formulario en donde nos solicita unicamente el ID del nodo y el nombre del mismo.

Tambien nos permite elegir que carpetas queremos sincronizar con ese nodo en especifico.

Esta tarea se debe hacer de la misma forma en el nodo receptor, en el cual se debe crear y compartir la carpeta con el mismo nombre que en el nodo de origen.

Creando Repositorios (carpetas):

En Syncthing los repositorios son simples carpetas las cuales contienen los archivos a sincronizar y compartir con los nodos que tu elijas. Para crear una tan solo has click en el boton “Agregar Repositorio” y acontinuacion aparecera una ventana como esta:

En dicho formulario se puede colocar el ID del repositorio el cual sera el nombre unico que tendra la carpeta en el nodo actual. Tambien es posible indicar la ruta del repositorio o carpeta, si esta no existe en el servidor syncthing la creara de forma automatica.

De igual forma puedes indicar aqui con cuales nodos deseas compartir dicho repositorio.

Nuevamente: si deseas compartir y sincronizar este reporitorio con otro nodo, el repositorio debe ser creado con el mismo ID y nombre de carpeta en el nodo receptor

Con todo esto en mente tenemos el conocimiento necesario para armasr nuestra propia Nube privada, solo tu tienes acceso a ella, solo tu la controlas y decides que tanto espacio de almacenamiento quieres que esta tenga. Al mismo tiempo tienes la capacidad de agregar mas nodos a esta Nube a modo de replicas de seguridad.

Syncthing es una herramienta que a pesar de estar todavia en desarrollo se comporta de una manera muy estable y nos brinda un gran potencial para proteger nuestros datos mas preciados.

Configuracion basica de Fail2Ban en Linux.

2014-12-21T00:00:00-04:30

Segun la Wikipedia:

Fail2ban es una aplicación escrita en Python para la prevención de intrusos en un sistema, que actúa penalizando o bloqueando las conexiones remotas que intentan accesos por fuerza bruta.

Fail2ban nos sirve de ayuda para proteger servidores y vps contra ataques de fuerza bruta sobre determinados servicios que estos ofrescan, la manera en que trabaja es analizando los archivos de logs que los diversos servicios generan, y busca en ellos registros de comportamientos no tipicos (por lo general basado en alguna regla ya especificada) para luego determinar la ip del origen del ataque y proceder a banearla o bloquearla mediante el Firewall o algun sistema de control de paquetes.

Instalacion de Fail2ban:

Para instalar Fail2ban basta con teclear en una terminal:

$ sudo apt-get install fail2ban iptables-persistent

Aqui el paquete iptables-persistent lo instalamos para que las reglas de baneo agregadas al firewall iptables esten disponibles y sean persistentes luego de un reinicio.

Configuracion basica de Fail2ban:

Una vez instalado, procedemos a realizar alguna configuracion basica requerida para comenzar a proteger ciertos servicios en el servidor, en este caso se pasa a configurar fail2ban para proteger el servicio SSH.

Fail2ban viene con un archivo de configuracion jail.conf que nos sirve de ejemplo y que por lo general en las actualizaciones puede cambiar, por lo que es recomendable copiarlo y renombrarlo a jail.local para luego alli editar y colocar las configuraciones a nuestro gusto:

$ sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local

una vez copiado el archivo, podemos proceder a configurarlo de acuerdo a nuestras necesidades:

bantime:

Al abrir el archivo jail.local una de las primeras cosas que podemos editar es la linea referente al bantime el cual hace referencia al tiempo (en segundos) en la que una IP sera baneada o bloqueada. Por lo general viene con un tiempo algo corto como 600 segundos, que seria algo asi como 10 minutos.

Este valor podriamos cambiarlo a por ejemplo a 3600 que seria algo asi como 1 hora.

bantime = 3600

maxretry:

La cantidad maxima de intentos fallidos que se pueden permitir se especifica con maxretry, si una IP alcanza este numero, pasara a ser baneada o bloqueada. Por lo general viene configurada a 3, pero podriamos ser super exigentes y cambiarlo a 2.

maxretry = 2

findtime:

Una IP puede alcanzar el limite de intentos fallidos (especificado con maxretry) de forma muy rapida, o puede que haga los intentos en ciclos de varios minutos o horas, ese tiempo limite podriamos especificarlo con findtime, si una IP alcanza los intentos fallidos dentro de ese periodo de tiempo, pasara a ser baneada.

Por lo general viene con un valor bajo como 600 segundos, pero podemos cambiarlo a nuestro gusto por un valor mas alto.

findtime = 1000

destemail:

Fail2ban nos permite especificar una direccion de correos para que este nos envie notificaciones con informacion sobre una IP recientemente bloqueada. Con destemail espeficificamos ese correo.

destemail = correo@dominio.tld

mta:

Fail2ban es capaz de usar algun agente de transferencia de correos instalado en el servidor para el envio de notificaciones, por default viene configurado para usar sendmail, pero podriamos cambiarlo a mail para luego usar servicios como Postfix para que este realice el envio de los correos.

mta = mail

action:

Con esto configuramos la accion que fail2ban tomara para realizar un baneo, estas acciones estan tambien especificadas en el archivo, nosotros solo tendremos que elegir una:

action = %(action_mwl)s

Configuraciones de baneo por servicios:

Fail2ban viene con un conjunto de reglas de bloqueo predefinida de acuerdo a determinados servicios, culminando en archivo jail.local podemos ver algunas de estas reglas, muchas de ellas estan desactivadas, por lo que tan solo debemos buscar la que necesitamos y activarla:

[ssh]

enabled  = true
port     = ssh
filter   = sshd
logpath  = /var/log/auth.log
maxretry = 3

Esta regla arriba nos permite proteger el servicio SSH contra ataques de fuerza bruta y demas intentos de acceso, notese que se especifica con logpath la ruta del archivo log de dicho servicio, este archivo es el que Fail2ban analizara en busqueda de potenciales atacantes para ser bloqueados.

Notese tambien que podemos espeficicar el puerto con port el cual usa dicho servicio, si por ejemplo hemos cambiado el puerto de escucha para SSH a 2222 o similar, debemos indicarlo tambien alli.

Tambien podemos ver que se especifica tambien el maxretry esto nos permite ajustar el maximo numero de intento fallidos para cada regla o servicio.

Una vez realizada la configuracion basica, ya tenemos listo fail2ban para comenzar a trabajar y proteger, para aplicar las reglas tan solo necesitamos reiniciarlo:

$ sudo service fail2ban stop
$ sudo service fail2ban start

Ya con esto podemos estar un poco mas tranquilos de haber agregado una capa mas de seguridad a nuestra PC o servidor. Logicamente es posible activar mas reglas o agregar nuestras propias reglas personalizadas, ademas de completar la configuracion para el envio de notificaciones por correos.

Configuracion basica de UFW Firewall en Linux.

2014-12-17T00:00:00-04:30

Al administrar servidores, una de las primeras cosas que se deben configurar para aumentar la seguridad de los mismos es configurar un Firewall, Por suerte en Linux se incluye uno por defecto llamado Iptables pero este firewall muchos lo ven un poco complejo de configurar y administrar. Existen alternativas mas sencillas de usar como por ejemplo UFW.

UFW es en realidad es una CLI o intefaz de linea de comandos para el Firewall Iptables que incluye Linux, esta interfaz nos proporciona una manera un poco mas sencilla de administrar y configurar Iptables. para UFW incluso existe una GUI o interfaz grafica llamada GUFW el cual podriamos usar en una PC de escritorio o Laptop para administrar y configurar el firewall.

Instalacion de UFW en el servidor:

para instalarlo basta con escribir en una terminal el comando

$ sudo apt-get install ufw

Por defecto UFW esta desactivado luego de la instalacion, por lo que podemos ver su estado con el comando:

$ sudo ufw status verbose

Configuraciones basicas de UFW:

Algunas de las configuraciones basicas que podemos usar en UFW para asegurar nuestros servidores son.

Reglas por defecto:

Las reglas por defecto o default rules son, como su nombre lo indica, una serie de reglas standar que nos facilita la configuracion de el Firewall, estas reglas nos permiten especificar si queremos permitir allow o denegar deny el trafico entrante incoming o el trafico saliente outgoing, ademas de algunas otras reglas.

Una configuracion muy buena que de hecho usa GUFW apenas es instalado en una PC, es la de denegar deny todo el trafico entrante y permitir allow el trafico saliente.

Esto lo podemos ajustar con los siguientes comandos:

$ sudo ufw default deny incoming

Para denegar todo el trafico entrante.

$ sudo ufw default allow outgoing

Con estas dos configuraciones una PC esta bastante protegida al igual que un servidor, pero si queremos aumentar la seguridad podriamos tambien denegar el trafico saliente para una mayor seguridad, claro esta con la desventaja de que tendras que estar pendiente de que aplicaciones requieren alguna regla de trafico saliente para poder funcionar correctamente.

Permitir conexiones:

Supongamos que estamos configurando el firewall en nuestro servidor y denegamos todo el trafico entrante, como vamos a conectarnos remotamente a el mediante SSH?. Necesitamos aplicar una regla que nos permita conectarnos al puerto 22.

Para esto usamos la opcion allow y le especificamos el puerto al que queremos permitir el trafico entrante y el protocolo TCP que este use:

$ sudo ufw allow 22/tcp

UFW viene con algun conjunto de reglas prestablecidas que podemos usar mediante su nombre, por ejemplo el comando anterior trata de abrir el puerto 22 que es conocido por ser el puerto usado para conexiones SSH, esta regla podriamos tambien habilitarla con el comando:

$ sudo ufw allow ssh

De la misma forma podriamos usar otras reglas preestablecidas para servicios conocidos como por ejemplo HTTP que usa el puerto 80, HTTPS que usa el puerto 443, etc.

Rangos de puertos:

Es posible tambien que quieras permitir el trafico entrante no solo a un puerto sino a un rango de estos, un ejemnplo de esto podria ser con la aplicacion Mosh que requiere sea abierto el rango de puertos que van del 60000 al 61000 por el protocolo udp.

Esto lo podriamos aplicar escribiendo algo como:

$ sudo ufw allow 60000:61000/udp

Denegar conexiones:

De la misma forma en la que permitimos conexiones entrantes, podemos denegar dichas conexiones.

Supongamos que tenemos una regla por defecto en la que se permite todo el trafico entrante (NO se recomienda), pero nosotros queremos denegar el trafico entrante solo en un puerto determinado, podriamos aplicar dicha configuracion con algo como:

$ sudo ufw deny 22/tcp

De la misma forma podriamos hacerlo para denegar un rango de puerto.

$ sudo ufw deny 60000:61000/udp

Eliminar reglas:

Supongamos que hemos configurado el servidor SSH para usar el puerto 2222 en lugar del puerto 22 anteriormente abierto, deberiamos eliminar la regla anterior en la que se permitia la entrada al puerto 22. Esto podriamos realizarlo con el siguiente comando:

$ sudo ufw delete allow 22/tcp

De forma similar podriamos hacerlo si se trata de un rango de puertos:

$ sudo ufw delete allow 60000:61000/udp

Si por ejemplo tenemos un conjunto de reglas establecidas con UFW de las cuales queremos eliminar algunas pero no conocemos como realizar dicha eliminacion por ser algun tipo de regla compleja, podriamos listarlas con el comando:

$ sudo ufw status numbered

Lo que nos devolveria un conjunto de reglas numeradas como estas:

     To                         Action      From
     --                         ------      ----
[ 1] 22                         ALLOW IN    Anywhere
[ 2] 80                         ALLOW IN    Anywhere
[ 3] 443                        ALLOW IN    Anywhere
[ 4] 60000:61000/udp            ALLOW IN    Anywhere
[ 5] 22000/tcp                  ALLOW IN    Anywhere

Como se nota arriba, las reglas estan numeradas, por lo que podriamos usar ese numero para eliminar una regla en especifico:

$ sudo ufw delete 5

Lo que nos eliminara la ultima regla listada.

Activando y desactivando UFW:

Una vez configurada todas las reglas y asegurarnos de que todo esta correcto, procedemos a activar el firewall con el comando:

$ sudo ufw enable

Con esto ya tendremos UFW activo y protegiendo las conexiones con las reglas que hemos especificado.

En caso de que queramos desactivar UFW tecleamos el comando:

$ sudo ufw disable

Si por alguna razon requieres que se eliminen todas las reglas aplicadas

$ sudo ufw reset

Estas son solo algunas de las configuraciones basicas de UFW con las que podemos agregar una buena capa de seguridad a nuestras PC y servidores, logicamente existen configuraciones avanzadas que se pueden usar para mejorar todavia mas la seguridad o para realizar algun tipo de tarea espeficica.

Autenticacion SSH basada en llaves publicas y privadas.

2014-12-16T00:00:00-04:30

Por lo general cuando uno va a administrar un servidor o VPS de forma remota, lo hace mediante una conexion SSH y por lo general inicias sesion usando un nombre de usuario y clave. A pesar de que estas conexiones SSH son seguras, la forma de autenticarse con usuario y clave no lo es del todo ya que esta expuestas a posibles ataques mediante fuerza bruta. Para tener un poco mas a segurado nuestros servidores o VPS es aconsejable la autenticacion pero usando llaves SSH y desactivando la autenticacion con claves.

Para realizar esto tan solo debemos realizar unos pocos pasos:

Subiendo tu llave SSH publica al servidor:

Para poder autenticarnos en un servidor usando llaves SSH lo primero que podemos hacer es subir nuestra llave publica, estas, cuando las creas, por defecto son un archivo llamado id_rsa.pub ubicado en la carpeta ~/.ssh/ en tu PC.

El contenido de esta llave publica SSH id_rsa.pub debemos colocarlo en el servidor, en un archivo llamado authorized_keys ubicado en la carpeta ~/.ssh en el servidor.

Configurando el servidor OpenSSH para autenticacion con llaves:

Una vez subida al servidor la llave publica, toca realizar algunas configuraciones para autenticarnos usando dicha llave. Es probable de que si en este punto intentas autenticarte en el servidor, puedas realizarlo sin problemas usando la llave SSH pero la idea es que solo se permitan los accesos y autenticacion solo con llaves y no con claves.

Para realizar esto necesitamos editar en el servidor el archivo /etc/ssh/sshd_config y cambiar o agregar las siguientes lineas de modo que queden como esta:

PubkeyAuthentication yes
PasswordAuthentication no
ChallengeResponseAuthentication no¬
UsePAM no

La primera y la segunda linea son las mas importantes, PubkeyAuthentication yes permite la autenticacion mediante llaves SSH, y PasswordAuthentication no deshabilita la autenticacion mediante claves.

Con esto ya puedes conectarte a tu servidor o VPS usando tu llave publica SSH y estar un poco mas tranquilo ya que con esto le agregas un poco mas de seguridad a tu servidor.

Pero ya que estamos, podriamos mejorar un poco mas la seguridad del servidor haciendo algunos ajustes extras:

Desactivando la autenticacion para el usuario root:

El usuario root es el usuario con los mayores permisos en el sistema, iniciar sesion en el servidor con este usuario es arriesgado ya que con el mas minimo error en un comando es posible que produscas fallas irreparables en el sistema operativo.

Desactivar la autenticacion del usuario root tambien nos permite agregar una capa mas de seguridad al impedir que inicien sesion como root algun atacante que haya logrado conseguir la clave del usuario root o su llave ssh.

Para realizar esto necesitamos editar en el servidor el archivo /etc/ssh/sshd_config y cambiar o agregar las siguientes lineas de modo que queden como esta:

PermitRootLogin no

Nota Recuerda habilitar esta opcion solo despues de darle permisos de administrador a algun usuario standar. por ejemplo agregando tu usuario al archivo en /etc/sudoers

Permitir acceso solo a ciertos usuarios:

Otra forma de aumentar la seguridad es permitir el acceso solo a determinados usuarios. Para realizar esto necesitamos editar en el servidor el archivo /etc/ssh/sshd_config y cambiar o agregar las siguientes lineas de modo que queden como esta:

AllowUsers mi-usuario pepito fulanito

De la misma forma podrias usar la directiva AllowGroup para permitir unicamente a cierto grupo autenticarse en el servidor.

Una vez terminado tan solo necesitamos reiniciar OpenSSH y tendremos activa todas estas configuraciones.

Con esto ya aumentamos un poco mas la seguridad en nuestro servidor, logicamente se podrian realizar mas ajustes o agregar por ejemplo un sistema que utilice el firewall para bloquear el acceso a las IP que hayan tenido una cierta cantidad de intentos fallidos de autenticacion. Esto ultimo lo explicare un poco mas adelante.

Administrando multiples llaves SSH y repositorios Git

2014-12-04T00:00:00-04:30

Hay ocasiones en la que te encuentras con que tienes que usar multiples cuentas GitHub, Bitbuket, Heroku o mas especifico, multiples cuentas en diversos repositorios git. Esto puede deberse a que por ejemplo ya tengas cuenta personal en Github y alguna empresa para la que estes trabajando te pida crearte una nueva cuenta GitHub usando una direccion de correo de dicha empresa. En estos casos y si usas autenticacion via llaves SSH, puedes encontrarte con el inconveniente de que al hacer un git pull, git push o similares, git use la llave SSH que no corresponde a la cuenta que debes usar en ese servicio especifico.

Para corregir esto y poder usar multiples llaves SSH y multiples cuentas de repositorios Git, podemos crear un archivo config de configuracion dentro de la carpeta ~/.ssh en la que espeficiquemos como trabajaremos con las multiples cuentas y llaves SSH en un mismo servicio o reporisorio Git.

#############################
# CONFIGURACION PARA GITHUB.#
#############################
#Cuenta GitHub Personal.
Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa
  IdentitiesOnly yes

#Cuenta GitHub segundaria
Host segundaria.github.com
  HostName github.com
  User git
  PreferredAuthentications publickey
  IdentityFile ~/.ssh/id_rsa_segundaria
  IdentitiesOnly yes

En este ejemplo podemos ver que tenemos dos cuentas GitHub a las cuales se acceden desde una URL personalizada que especificamos con Host. Esta a su vez se le indica la llave SSH a usar mediante IdentityFile y el servidor en donde se encuentra dicho servicio se especifica con HostName

Notese que en este ejemplo logicamente la URL segundaria.github.com no existe, esta URL tan solo la usamos para poder indicar la cuenta GitHub y su respectiva llave SSH que debera usar Git para identificarnos en GitHub.

De la misma forma podemos hacer algo muy similar con multiples cuentas en servicios como Bitbucket o Heroku como podemos ver a continuacion en el siguiente archivo.

################################
# CONFIGURACION PARA BITBUCKET.#
################################
#Cuenta BitBucket Personal.
Host bitbucket.com
  HostName bitbucket.com
  User git
  IdentityFile ~/.ssh/id_rsa
  IdentitiesOnly yes

#Cuenta BitBucket segundaria
Host segundaria.bitbucket.com
  HostName bitbucket.com
  User git
  IdentityFile ~/.ssh/id_rsa_segundaria
  IdentitiesOnly yes

#############################
# CONFIGURACION PARA HEROKU.#
#############################
#Cuenta Heroku Personal.
Host heroku.com
  HostName heroku.com
  User git
  IdentityFile ~/.ssh/id_rsa
  IdentitiesOnly yes

#Cuenta Heroku segundaria
Host segundaria.heroku.com
  HostName heroku.com
  User git
  PreferredAuthentications publickey
  IdentityFile ~/.ssh/id_rsa_segundaria
  IdentitiesOnly yes

Hay ocasiones en la que solo tienes una cuenta en algun servidor Git, pero igual necesitas espeficicar que use una llave SSH especifica para poder autenticarnos correctamente en dicho servidor. En esos casos podemos escribir algo como esto:

############################################
# CONFIGURACION PARA SERVIDOR GIT PERSONAL.#
############################################
#Cuenta Git Personal.
Host git.miservidor.net
  HostName git.miservidor.net
  User git
  IdentityFile ~/.ssh/id_rsa_gitpersonal
  IdentitiesOnly yes

Con esto hecho ya podemos comenzar a clonar repositorios usando el el comando:

$ git clone git@segundaria.github.com:jesusangelm/ConfVim.git

Con esto clonaremos dicho repo usando la cuenta segundaria en GitHub y su respectiva llave SSH.

Notese que pueden haber ocasiones en donde para hacer un git pull o git push necesitaras especificar manualmente la URL personalizada o alias dentro de la carpeta .git/ en el archivo config en la carpeta principal de tu proyecto Git:

Cambiamos:

url = git@github.com:jesusangelm/jesusangelm.github.com.git

por:

url = git@segundaria.github.com:jesusangelm/jesusangelm.github.com.git

Referencia Markdown

2014-07-19T00:00:00-04:30

Segun la Wikipedia:

Markdown es un lenguaje de marcado ligero creado originalmente por John Gruber y Aaron Swartz que trata de conseguir la máxima legibilidad y “publicabilidad” tanto en sus forma de entrada como de salida, inspirándose en muchas convenciones existentes para marcar mensajes de correo electrónico usando texto plano. Markdown convierte el texto marcado en documentos XHTML bien formados, reemplazando el signo ‘menor que’ (‘<’) y los et por sus correspondientes referencias de entidad de caracteres. Markdown fue implementado originariamente en Perl por Gruber, pero desde entonces ha sido traducido a multitud de lenguajes de programación, incluyendo PHP, Python, Ruby, Java y Common Lisp. Se distribuye bajo licencia BSD y se distribuye como plugin (o al menos está disponible) en diferentes sistemas de gestión de contenidos (CMS).

Hago este articulo a modo de referencia debido a que por lo general cuando tengo que formatear texto para algun comentario o algun articulo de este blog, lo hago en Markdown y siempre se me olvidan la sintaxis por lo que tengo que correr a a buscar un sitio para referencias. Con esto ya sabre que lo unico que tengo que buscar es mi propio blog xD.

Cuando escribes un comentario, un articulo, un correo por lo general lo haces en texto plano y sin formato o con un formato muy pobre que podria perderse al publicar dicho texto, con un comentario en algun foro o un articulo en un blog es probable que le quieras dar algo de formato, como por ejemplo resaltar un texto, agregar un enlace o crear una lista simple. En un correo o un articulo de uhn blog por ejemplo la solucion seria escribir el contenido en HTML, pero escribir HTML para formatear un texto podria ser un suplicio ya que necesitarias escribir muchas etiquetas y muy probablemente necesitaras agregar estilos CSS para ayudar al formateado del texto. Es aqui donde Markdown te ayuda ya que al tener una sintaxis sencilla y basica te sera mas facil escirbir y formatear el texto.

Hay que tener en cuenta que markdown no es un reemplazo de HTML y muchas de las etiquetas existentes en HTML no estan disponibles para Markdown, para estos casos lo que se debe hacer es simplemente usar la forma HTML.

Cabeceras:

Markdown soporta dos estilos de cabeceras, el estilo Setex y el estilo Atx

Estilo Atx:

En HTML necesitarias escribir una cabecera con las etiquetas <h1> y </h1> pero en markdown basta con solo escribir el simbolo # para obtener una cabecera <h1>. Este estilo acepta los 6 niveles tal cual lo hace las etiquetas <h1>.

Teniendo esto en cuenta y para obtener algo como esto:

Texto con cabecera h1

Texto con cabecera h2

Text con cabecera h3

Necesitariamos escribir algo como esto:

# Texto con cabecera h1

## Texto con cabecera h2

### Text con cabecera h3

Estilo Setex:

Este estilo acepta unicamente dos niveles de la etiqueta <h1>

Si quieres obtener algo como esto:

Texto con nivel h1

Texto con estilo h2

Debes escribir algo como esto:

Texto con nivel h1
==================

Texto con estilo h2
-------------------

Parrafos:

En HTML si quieres indicar que escribes un parrafo debes usar la etiqueta <p> y </p>. Pero en Markdown no es necesario esto, de hecho no es necesario nada, simplemente escribes una lineas de texto continuas y sin espacio y markdown tomara esta linea como un parrafo. Por ejemplo este parrafo explicativo se obtiene tan solo con escribir algo como esto:

En HTML si quieres indicar que escribes un parrafo debes usar la etiqueta `<p>`
y `</p>`. Pero en Markdown no es necesario esto, de hecho no es necesario nada,
 simplemente escribes una lineas de texto continuas y sin espacio y markdown 
 tomara esta linea como un parrafo. Por ejemplo este parrafo explicativo se
 obtiene tan solo con escribir algo como esto:

No tiene ningun misterio…

Citas:

En HTML probablemente has escrito citas con las etiquetas <blockquote>, pero en Markdown es tan facil como colocar un > al inicio del texto de la cita.

Por ejemplo el extracto de Wikipedia que ves arriba es una cita que se obtubo escribiendo algo como esto:

> Markdown es un lenguaje de marcado ligero creado originalmente por John Gruber y Aaron Swartz que trata de conseguir la máxima legibilidad y "publicabilidad" tanto en sus forma de entrada como de salida, inspirándose en muchas convenciones existentes para marcar mensajes de correo electrónico usando texto plano. Markdown convierte el texto marcado en documentos XHTML bien formados, reemplazando el signo 'menor que' ('<') y los et por sus correspondientes referencias de entidad de caracteres. Markdown fue implementado originariamente en Perl por Gruber, pero desde entonces ha sido traducido a multitud de lenguajes de programación, incluyendo PHP, Python, Ruby, Java y Common Lisp. Se distribuye bajo licencia BSD y se distribuye como plugin (o al menos está disponible) en diferentes sistemas de gestión de contenidos (CMS).

Cita anidada:

Puedes anidar una cita dentro de otra como por ejemplo esta:

Una cita principal.

Una cita anidada.

La cual se lograria con algo como:

> Una cita principal.
>
> > Una cita anidada.
>

Tambien puedes formatear las citas agregandole elementos markdown dentro de ellas.

Listas:

En HTML tu creas una lista con etiquetas como <ol> y <li>. Markdown soporta listas tanto ordenadas como no-ordenadas.

Listas no-ordenadas:

Las listas no-ordenadas las puedes escribir con los simbolos +, - o * como marcador de lista, por lo que si quieres hacer algo como esto:

ArchLinux.
Ubuntu.
Debian.

Se usaria algo como esto:

* ArchLinux.
* Ubuntu.
* Debian.

es igual a

- ArchLinux.
- Ubuntu.
- Debian.

y es igual a

+ ArchLinux.
+ Ubuntu.
+ Debian.

Listas ordenadas:

Las listas ordenadas las escribes simplemente con numeros seguidos de un punto. Asi que si quieres crear algo como esto:

ArchLinux.
Ubuntu.
Debian.

Escribiras algo como:

1. ArchLinux.
2. Ubuntu.
3. Debian.

Un detalle a tener en cuenta es que el orden de los numeros que coloques para marcar una lista ordenada no tiene efectos al ser convertido a HTML por lo que si escribes algo como:

1. ArchLinux.
1. Ubuntu.
1. Debian.

o escribes algo como

1. ArchLinux.
3. Ubuntu.
5. Debian.

siempre obtendras una lista ordenada similar al ejemplo de arriba.

Bloques de codigo:

Puedes escribir codigo fuente con bloques de codigo pre-formateados, HTML hace esto usando las etiquetas <pre> y <code>, pero en Markdown tu escribes los bloques de codigo identando el mismo codigo con 4 espacios o un tab.

Por ejemplo si queremos mostrar un bloque de codigo fuente como este:

def metodo_ruby
  puts "Hola mundo"
end

Deberas escribir algo como esto:

1    def metodo_ruby
2      puts "Hola mundo"
3    end

Notese los 4 espacios antes de la palabra clave def de la funcion los cuales van consecutivos hasta la palabra clave end que cierra la funcion.

Reglas horizontales:

En HTML tu crearias una linea o regla horizontal usando la etiqueta <hr>, pero en markdown las puedes hacer repitiendo los simbolos * y -

Para conseguir las siguientes cuatros reglas (si, probale que no las veas bien):

Necesitaras escribir algo como esto:

* * *


***


*****


- - -


-----------------

Enlaces:

En HTML los enlaces se escriben usando la etiquetas <a> pero en markdown se hace tan solo con rodeando el texto del enlace con [] y justo al lado colocas la url del enlace rodeada con ().

Por ejemplo el siguiente enlace:

Jam Blog

lo logramos escribiendo algo como:

[Jam Blog](http://blog.jam.net.ve)

Tambien se puede agregar identificadores a los enlaces para luego agrupar estos todos juntos en cualquier parte del documento, esto como una forma de tenerlos ordenados para facil edicion.

Por ejemplo los siguientes grupos de enlaces:

Ubuntu Arch Linux Debian

Se obtienen escribiendo lo siguiente:

[Ubuntu][1]
[Arch Linux][2]
[Debian][3]

[1]: http://ubuntu.com "Linux para seres humanos."
[2]: https://archlinux.org
[3]: http://debian.org

Notese el texto opcional que se muestra al colocar el cursor sobre el enlace de Ubuntu.

Enfasis:

En HTML si quieres hacer notar un texto negritas o haciendolo cursivo usas las etiquetas <strong> y <em> respectivamente, pero en markdown logras el mismo efecto usando * y _.

Por ejemplo:

Pablito clavo un clavito y el clavito clavo a Pablito.

lo puedes lograr escribiendo:

*Pablito* clavo un _clavito_ y el **clavito** __clavo__ a Pablito.

Como puedes notar se puede lograr el texto negrita usando solo un _ o un * y el texto cursivo se puede lograr usando dos ** o dos __ al inicio y al final de la palabra.

Codigo simple:

Ya habiamos visto como escribir bloques de codigo mas arriba, pero esta vez veremos como escribir codigo fuente de una sola linea.

En HTML lo escribes usando la etiqueta <code>, usando markdown se logra con el `

Por ejemplo:

puts "Hola Markdown" if Markdown.include?

`mosca` que el simbolo es ` y no '.

Le hace escribiendo:

`puts "Hola Markdown" if Markdown.include?`

`` `mosca` `` que el simbolo es `` ` `` y no `'`.

Notese que si se quiere incluir un texto con que contiene el mismo simbolo ` debes rodear el contenido con un doble `

Imagenes:

En HTML agregas imagenes al documento usando la etiqueta <img>, con markdown se hace de una forma muy similar a como se hacen con los enlaces, con la unica diferencia de que se usa un simbolo ! al inicio de los [] y en los () se coloca la ruta de la imagen.

Por ejemplo:

Se puede lograr escribiendo:

![Markdown](https://i.imgur.com/Mz0i3G8.png "Logo Markdown")

Notese que a pesar de que se puede colocar el texto alt y el title existentes en la etiqueta <img> HTML, no podemos controlar la dimension de la imagen ni la posicion. Asi que asegurate de que la imagen ya este en las dimensiones deseadas o usa solo la etiqueta HTML <img> y codigo CSS.

De la misma forma que hicimos con los enlaces, podemos agrupar imagenes con un identificador.

Miselaneos:

Enlaces automaticos:

Cuando vimos como formatear enlaces en Markdown lo hicimos con algo como [texto enlace](http://url.tld), pero markdown de hecho tiene una forma simple de convertir una url escrita en un enlace basico:

http://blog.jam.net.ve

correo@dominio.tld

Se logra simplemente escribiendo:

<http://blog.jam.net.ve>

<correo@dominio.tld>

Quiebre de linea:

Si por ejemplo quieres escribir una linea
y romperla en un punto especifico tan solo
debes agregar dos o masespacios en el punto
donde quieres que se haga el salto de linea.

Como puedes notar el parrafo explicativo de arriba no es tan largo, pues se incluyo en el el quiebre de linea el cual se obtubo escribiendo:

Si por ejemplo quieres escribir una linea  
y romperla en un punto especifico tan solo  
debes agregar dos espacios en el  punto donde  
quieres que se haga el salto de linea.

Notese los dos espacios al final de cada linea para marcar el quiebre o salto.

Escape:

Markdown nos da una forma para escribir simbolos que el mismo usa en su sintaxis como por ejemplo el *, -, _, etc.

*Texto rodeado con **

_Texto rodeado con __

Esto se logra escribiendo:

\*Texto rodeado con `*`\*

\_Texto rodeado con `_`\_

Tambien hay caracteres de escape para los siguientes simbolos:

\   backslash
`   backtick
*   asterisk
_   underscore
{}  curly braces
[]  square brackets
()  parentheses
#   hash mark
+   plus sign
-   minus sign (hyphen)
.   dot
!   exclamation mark

Como ven, markdown es sumamente sencillo y basico con una sintaxis facil de escribir. Existen algunas reglas especificas para cada algunos elementos que no se describen aqui, si deseas puedes visitar la referencia oficial

Creando imagenes Docker desde archivos dockerfile

2014-07-07T00:00:00-04:30

Hace algunos meses atras escribi un articulo en el que comentaba que era la herramienta Docker y Como instalar Docker.

En Docker existe un archivo llamado dockerfile el cual es una especie de receta que interpreta Docker y que crea a partir de ella una Imagen Docker desde la cual y con un simple comando podremos nosotros crear un contenedor Docker para alvergar alli nuestras aplicaciones o servicios.

En esta oportunidad mostrare un ejemplo sumamente sencillo de como se podria construir una imagen docker adaptada a nuestras necesidades especificas. En este caso creare una imagen basada en Ubuntu 14.04 LTS la cual se le instalaran una serie de paquetes basicos y se le le realizara la configuracion de el servidor OpenSSH para asi poder conectarnos a el contenedor de manera remota.

El archivo dockerfile

Vamos a crear un archivo llamado dockerfile el cual va a contener lo siguiente:

Nota: Este dockerfile esta disponible en mi Repositorio Github para una mejor lectura y seguimiento del articulo.

#Imagen docker de prueba.

#Origen: Ubuntu 14.04 LTS
FROM ubuntu:14.04

#Creador:
MAINTAINER Jesus Marin <jam@jam.net.ve>

#Actualizar el repositorio Ubuntu, luego descarga e instala paquetes que
#requieren actualizacion.
RUN apt-get -qq update && apt-get -qqy upgrade

#Instalar algunos paquetes bases, utiles para mi y algunas dependencias.
RUN apt-get -qqy install wget git curl dnsutils tmux zsh openssh-server pwgen vim

#Tomado de https://github.com/tutumcloud/tutum-ubuntu/blob/master/Dockerfile
#Para configurar SSHD y crear una contrasena para usuario ROOT
RUN mkdir -p /var/run/sshd && sed -i "s/UsePrivilegeSeparation.*/UsePrivilegeSeparation no/g" /etc/ssh/sshd_config && sed -i "s/UsePAM.*/UsePAM no/g" /etc/ssh/sshd_config && sed -i "s/PermitRootLogin.*/PermitRootLogin yes/g" /etc/ssh/sshd_config
ADD set_root_pw.sh /set_root_pw.sh
ADD run.sh /run.sh
RUN chmod +x /*.sh

EXPOSE 22
CMD ["/run.sh"]

Un dockerfile por dentro.

Notese que el archivo esta compuesto principalmente por conjuntos de INSTRUCCION en mayusculas segido de una sentencia en minuscula.

El texto que esta despues de un # es simplemente un comentario.

La instruccion FROM.

En la primeras lineas podemos ver la palabra FROM, esta nos indica que Imagen Base vamos a tomar para crear nuestra imagen personalizada, en este caso usamos ubuntu:14.04. Docker toma esta imagen desde el Docker Registry el cual contiene nuestra imagen base Ubuntu 14.04 LTS.

Notese que despues del nombre de la imagen indicamos la version de Ubuntu a usar, bueno esto en Docker se llama TAG y es la forma en que podemos usar una version especifica de esa imagen, si vemos las tags disponibles de dicha imagen en su repositorio podemos ver que tambien disponemos de otras versiones de Ubuntu como la 13.10 o la 12.04.

Si por ejemplo no queremos usar como imagen base a Ubuntu sino que queremos crear una imagen Debian o CentOS podriamos decir:

FROM debian:stable

FROM centos:6.4

La instruccion MAINTAINER

Esta instruccion no tiene mucha ciencia, tan solo especificamos quien es el autor de dicho dockerfile y su correo.

La instruccion RUN

Esta instruccion la veras en casi cualquier dockerfile ya que con ella especificas los comandos que quieras ejecutar. En este caso indicamos que se ejecutara el comando:

apt-get -qq update && apt-get -qqy upgrade

El cual ejecuta a apt-get para que actualice el listado de repositorios e inmediatamente actualice los paquetes que dispongan de actualizacion.

Mas abajo puedes ver que se ejecuta nuevamente apt-get pero esta vez para instalar algunos paquetes basicos que no estan en la imagen base y que podrias requerir para tu imagen personalizada.

Tambien puedes ver que ejecuta una serie de comandos concatenados que crean carpetas en ciertas ubicaciones de la imagen base y realiza configuraciones en archivos. En esta parte se realiza una configuracion de el servidor OpenSSH.

La instruccion ADD

Con esta instruccion podemos hacer que se agrege a la imagen base un archivo que nosotros queremos que contenga, indicando la ubicacion actual de dicho archivo en nuestro sistema y la ubicacion donde dentro de la imagen donde queremos que se aloje dicho archivo.

En este caso set_root_pw.sh es el archivo a agregar, no especificamos una ruta ya que el archivo esta en la misma carpeta en la que esta el archivo dockerfile. Esta instruccion es seguida de /set_root_pw.sh notese el / delante del nombre del archivo, aqui si estamos especificando una ruta y es la ruta de destino dentro de la imagen en donde ubicaremos dicho archivo a agregar.

La instruccion EXPOSE

Con esta instruccion le decimos a Docker que los contenedores de esta imagen escucharan en el puerto especificado una vez que dichos contenedores se esten ejecutando. Docker tambien puede usar esta informacion para interconectar contenedores usando enlaces.

En nuestro caso exponemos el puerto 22 ya que usaremos un servidor OpenSSH para poder conectarnos al contenedor via SSH. Si por ejemplo estubiesemos creando un contenedor que alberga un servidor Web como por ejemplo Nginx o Apache, necesitariamos exponer su puerto de eschucha el cual es tipicamente el puerto 80, lo mismo va si queremos usar cualquier otro servicio.

La instruccion CMD

Esta instruccion es un tanto similar a la instruccion RUN solo que CMD ejecuta el comando indicado unicamente cuando arranque el contenedor y no cuando se este construyendo el mismo, esto puede servirnos para ejecutar servicios que ya esten instalados o para correr archivos ejecutables espeficicando su ubicacion.

Esta instruccion tiene la limitante de que solo se puede colocar una sola vez en un archivo dockerfile.

En nuestro caso tan solo arrancamos el ejecutable run.sh que ya hemos agregado en la raiz de la imagen base.

Por supuesto estas no son todas las instrucciones, existen algunas otras mas en la Dockerfile Reference.

Construyendo la imagen

Una vez tenemos nuestro archivo dockerfile nos vamos a una terminal, nos ubicamos en el mismo directorio donde reside nuestro dockerfile y ejecutamos:

docker build -t="usuariodocker/ubuntu:14.04" .

Docker tiene como convencion que el nombre del repositorio contenga el nombre de la persona u organizacion que crea la imagen seguido de una / y luego el nombre de la imagen y como opcional un tag

Notese tambien el . al final, con esto indicamos que la ubicacion del archivo dockerfile esta en el directorio actual.

Cuando ejecutes el comando veras todo el proceso de construccion de la imagen separando cada instruccion colocada en el dockerfile como un step o paso numerado. El proceso puede tomar algunos minutos ya que consistira en la descarga de la imagen base desde internet y tambien de la actualizacion de repositorios y paquetes.

Creando contenedores en el fondo a partir de nuestra imagen personalizada

Debido a que este contenedor esta creado con servicios, necesitaremos ejecutarlo en el fondo o como un daemon para que de este modo pueda ejecutarse el servicio o los servicios que pueda contener. Para esto ejecutamos en una terminal:

docker run -d -P usuariodocker/ubuntu:14.04

Este comando nos mostrara una secuencia de numeros y letras el cual es el ID del contenedor.

El flag -d hace que el contenedor se ejecute en el fondo y el flag -P le dice a Docker que mapee los puertos que el contenedor este exponiendo, hacia el S.O huesped, en nuestro caso el contenedor expone el puerto 22 pero Docker mapea este el acceso a este puerto a travez de nuestro S.O usando un puerto distinto, como por ejemplo el 49153.

Para saber que puerto esta mapeando docker hacia el exterior tan solo teclea el comando:

docker ps -a

El cual te devolvera algo como esto:

CONTAINER ID        IMAGE                      COMMAND             CREATED             STATUS              PORTS                   NAMES
c3032b4c1033        usuariodocker/ubuntu:14.04   /run.sh           55 seconds ago       Up 50 seconds        0.0.0.0:49153->22/tcp   goofy_archimedes

en la columna port puedes ver el puerto expuesto por el contenedor y el puerto que docker mapea para que podamos acceder a el. Tambien puedes ver el ID del contenedor el cual podemos usar para obtener la clave de usuario root que el archivo ejecutable set_root_pw.sh configuro.

Para ver esta clave ejecutamos en una terminal:

docker logs c3032b4c1033

y podras ver algo como esto:

=> Setting a random password to the root user
=> Done!
========================================================================
You can now connect to this Ubuntu container via SSH using:

 ssh -p <port> root@<host>
and enter the root password 'S3cR3Tp4SS' when prompted

Please remember to change the above password as soon as possible!
========================================================================

Conectandonos al contenedor mediante SSH

Habiamos dicho que este contenedor personalizado contenia un servicio SSH para poder acceder a el remotamente como si se tratase de un servidor dedicado o VPS, ya sabemos que el contenedor expone el puerto 22 perteneciente al servicio OpenSSH y que Docker mapea este puerto al exterior usando en este caso el puerto 49153.

Bien para poder conectarnos por ssh tan solo ejecutamos en una terminal:

ssh -p 49153 root@localhost

usando la clave root que vimos arriba.

Con vez, no es nada del otro mundo y con solo unos pocos pasos podemos crear imagenes docker adaptadas a nuestras necesidades, de las cuales podemos crear contenedores portatiles para alojar nuestras aplicaciones, servicios o un entorno de desarrollo y todo esto aislado de nuestro sistema operativo.

Instalando chruby y ruby-install

2014-04-19T00:00:00-04:30

chruby es un administrador de versiones Ruby tal como RVM o rbenv pero que a diferencia de estos dos ultimos, lleva la simplicidad al extremo ya que esa es basicamente su unica funcion, esto tambien le da la ventaja de ser uno de los administradores de versiones Ruby mas ligero con cerca de 99 Lineas de codigo.

La principal diferencia de chruby con respecto a rvm es su sencillez debido a que no esta plagado de caracteristicas que probablemente no uses o que en realidad no necesitas. Su principal diferencia con respecto a rbenv es que no usa los fulanos shims los cuales en mi opinion y experiencia hacian que los comandos ruby se ejecutaran con lentitud teniendo por ejemplo retrasos de hasta 1 segundo para que respondiera un simple ruby -v.

Entre sus caracteristicas esta:

Actualiza la Variable de Entorno $PATH.
Agrega tambien los directorios RubyGems bin/ a $PATH.
Configura correctamente $GEM_HOME y $GEM_PATH.
- lo que hace que para los usuarios las gemas se instalen en ~/.gem/$ruby/$version.
- y para el usuario root las gemas se instalen en /path/to/$ruby/$gemdir.
Tambien configura las Variables de Entorno $RUBY_ROOT, $RUBY_ENGINE, $RUBY_VERSION y $GEM_ROOT.
Opcionalmente puede configurar $RUBYOPT si se le da el argumento especifico.
Llama a hash -r para limpiar el command-lookup hash-table.
Por defecto usa la version ruby del sistema.
Soporte opcional del cambiado automatico de rubies por medio del archivo .ruby-version.
Soporte para bash y zsh.
Ligero (~99 LOC).
incluye tests.

Instalacion:

La documentacion oficial de chruby te explica este paso pidiendote que descargues la ultima version contenida en un archivo comprimido, pero yo prefiero usar Git, listar los Tags de sus versiones y elegir la ultima version para luego compilar desde alli, esto me permite estar al tanto de las ultimas versiones con tan solo un git pull en vez de estar revisando la pagina y descargar archivos comprimidos.

#clonamos el repositorio
$ git clone https://github.com/postmodern/chruby.git

#revisamos las versiones disponibles
$ git tag

#elegimos la ultima version disponible hasta ahora
$ git checkout v0.3.8

#instalamos
$ sudo make install

Configuracion:

Luego de instalar chruby tan solo debemos modificar nuestro archivo de configuracion .bashrc o .zshrc segun sea el caso y agregar la siguiente linea.

source /usr/local/share/chruby/chruby.sh

Ya con esto tenemos instalado y configurado chruby, pero debido a que chruby se enfoca en ser lo mas simple y minimalista no podremos hacer nada con el sin tener instalado alguna version de ruby. De hecho si escribes el comando chruby en la terminal, este no te mostrara informacion alguna.

Es aqui donde entra ruby-install. el cual es una aplicacion hecha por el mismo creador de chruby la cual nos permite instalar cualquier version de ruby que quieras, algo asi como el ruby-build de rbenv pero con caracteristicas extras interesantes como resolucion de dependencias requeridas para compilar las distintas versiones de ruby disponibles.

Para instalar ruby-install hacemos lo mismos pasos que hicimos para instalar chruby:

#clonamos el repositorio
$ git clone https://github.com/postmodern/ruby-install.git

#revisamos las versiones disponibles
$ git tag

#elegimos la ultima version disponible hasta ahora
$ git checkout v0.4.2

#instalamos
$ sudo make install

Con esto tenemos instalado y listo para usar ruby-install por lo que modemos probarla junto con chruby instalando alguna version de Ruby.

$ ruby-install ruby 2.1

Con esto comenzara la descarga, compilacion e instalacion de Ruby.

Si ejecutas ruby-install sin ningun parametro podras ver el listado de rubies disponibles:

$ ruby-install 
Known ruby versions:
  ruby:
    1:      1.9.3-p545
    1.9:    1.9.3-p545
    1.9.3:  1.9.3-p545
    2.0:    2.0.0-p451
    2.0.0:  2.0.0-p451
    2:      2.1.1
    2.1:    2.1.1
    stable: 2.1.1
  jruby:
    1.7:    1.7.12
    stable: 1.7.12
  rbx:
    2.1:    2.1.1
    2.2:    2.2.6
    stable: 2.2.6
  maglev:
    1.0:    1.0.0
    1.1:    1.1RC1
    stable: 1.0.0
  mruby:
    1.0:    1.0.0
    stable: 1.0.0

Para decirle a chruby que use alguna version de ruby en especifico es tan simple como un:

$ chruby ruby-2.1.1

chruby no cambia las versiones ruby por defecto y de hecho si reinicias la terminal o la pc, no recuerda la version de ruby que acabas de perdirle que use, por lo que si quieres que mantenga usando por defecto una version en especifica puedes colocar en tu .bashrc o .zshrc ese mismo comando que usamos arriba.

Instalando Docker en ArchLinux

2014-03-01T00:00:00-04:30

Cuando se esta desarrollando una aplicacion y llega el momento de implementarla en produccion siempre se busca que este proceso sea lo mas sencillo, rapido y confiable tanto como sea posible, hoy en dia existe varias herramientas que nos facilitan el trabajo como por ejemplo las PaaS como Heroku que no permiten por ejemplo colocar nuestra aplicaciones Rails y tenerla funcionando en pocos minutos, o las IaaS como las AWS de Amazon que nos permiten crear instancias de VM para colocar alli nuestras aplicaciones y sus dependencias, u otras herramientas un tanto mas sencillas como Chef. En esta ocasion hablaremos de una nueva herramienta conocida como Docker que nos puede ayudar igualmente pero de la forma mas sencilla posible.

Docker.

Docker es una herramienta de codigo abierto que nos permite automatizar el despliegue de cualquier aplicacion en un contenedor ligero, portatil, autosuficiente y que se pueda ejecutar practicamente en cualquier lugar.

Los contenedores de Docker pueden encapsular cualquier carga que se ejecutaran consistentemente en practicamente cualquier servidor. El mismo contenedor en el que se desarrolla, contruye y prueba la aplicacion puede correr a escala en un servidor en produccion, en una maquina virtual, en un cluster, en OpenStack, en una instancia publica o en cualquier combinacion de estas mismas.

Los usos comunes de Docker pueden ser:

Automatizacion de el empaquetado y despliegue de aplicaciones.
Creacion de entornos PaaS ligeros y privados.
Pruebas a automatizadas y de integracion continua.
Implementar y escalar aplicaiones web, Bases de datos y servicios backend.

En una forma simple se podria pensar que Docker funciona como una herramienta como VirtualBox junto a Vagrant, pero los contenedores Docker no son Maquinas Virtuales (VM) ya que estos no reservan espacio en memoria o procesos, ademas los contenedores en Docker y su contenido se ejecutan mucho mas rapido que en una VM, y son mucho mas ligeros. Muchos dicen que Docker es como un chroot con esteroides.

Instalacion:

En ArchLinux el proceso es muy sencillo ya que se cuenta con el respectivo paquete en los repositorios, tambien puede ser instalado desde AUR. en este caso optare por instalar Docker desde el repositorio ArchLinux.

$ sudo pacman -S docker

Configuracion y ejecucion:

Para usar Docker sin ser root tan solo debemos agregar nuestro usuario al grupo docker

$ sudo gpasswd -a USUARIO docker

NOTA: Cambie USUARIO por el usuario que quiera usar.

Luego tan solo habilitamos sus servicio y lo ejecutamos:

$ sudo systemctl enable docker
$ sudo systemctl start docker

Pruebas:

Para ver una lista de comandos disponible podemos simplemente ejecutar docker en la terminal. Tambien podemos ejecutar el comando docker info y veremos algo como esto:

$ docker info
Containers: 5
Images: 4
Driver: devicemapper
 Pool Name: docker-8:17-1706253-pool
 Data file: /var/lib/docker/devicemapper/devicemapper/data
 Metadata file: /var/lib/docker/devicemapper/devicemapper/metadata
 Data Space Used: 305.1 Mb
 Data Space Total: 102400.0 Mb
 Metadata Space Used: 1.0 Mb
 Metadata Space Total: 2048.0 Mb
Username: jesusangelm
Registry: [https://index.docker.io/v1/]
WARNING: No swap limit support

Ahora que vemos que funciona todo correctamente podemos descargar una imagen base pre-construida para Docker, las imagenes de Docker son sistemas que usaran los contenedores como base para correr nuestras aplicaciones. Estas imagenes son Sistemas Operativos como Ubuntu, Fedora, ArchLinux, etc y en el Docker Index puedes encontrar un listado de imagenes disponibles para descargar o tambien puedes subir y comparti una imagen creada por ti.

En este caso usare la imagen de BusyBox, para esto tan solo ejecutamos en la terminal:

$ docker pull busybox

Una vez descargada la imagen podemos meternos en su terminal y comenzar a trabajar en ella:

$ docker run -i -t busybox:latest sh

Con esto entraremos en su entorno como si de un chroot se tratase, para salir tan solo ejecuta el comando exit.

Con todo esto podremos tener instalado y funcionando Docker para comenzar a usarlo, crear nuestros entornos de desarrollo o crear contenedores con aplicaciones que puedan ser implementada en produccion muy rapido y sin problemas. Este tutorial es una explicacion muy basica para el sin fin de usos que podemos darle a Docker, recomiendo leer la Tutorial Interactivo y la Documentacion de Docker para conocerlo en mas detalles.

Un ejemplo de uso puede ser por ejemplo crear un contenedor Docker en el cual se desarrolla y alberga una aplicacion Rails y otro contenedor que ejecute un servicio PostgreSQL, para luego interconectar estos dos contenedores y hacer que nuestra aplicacion Rails pueda conectarse y usar la Base de datos Postgresql en el segundo contenedor. Logicamente podrias colocar estos dos contenedores ne un servidor de produccion y se ejecutaran se inmediato y sin problemas tal cual estubiesen en entorno de desarrollo, Ejemplos como estos son los que hacen interesante el uso de Docker.

DNSCrypt + DNSMasq en ArchLinux - Encripta tus peticiones DNS y saltate cualquier restrincion de tu ISP.

2014-02-16T00:00:00-04:30

Hace algo de tiempo ya escribi un articulo de como acelerar un poco el internet usando DNSMasq como una cache DNS, en esta ocasion vamos a mejorar un poco la seguridad de nuestra conexion a internet con la ayuda de DNSCrypt.

DNSCrypt nos provee un servicio local que puede ser usado directamente como resolvedor o redireccionador DNS, encriptando y autenticando las peticiones DNS usando el protocolo DNSCrypt y pasandolos a un servidor superior. Estas propiedades de DNSCrypt nos permite entonces encriptar las peticiones DNS de forma que ningun proxy o ISP pueda capturarlas y/o modificarlas para espiarte o bloquearte determinadas paginas.

En este ejemplo yo usare ArchLinux ya que es la distro que uso actualmente, pero la informacion es facilmente aplicable a otras distros como Ubuntu o Debian, en estas dos ultimas distros linux se requiere compilar e instalar aparte Libsodium ya que si mal no recuerdo hasta la fecha no existen paquetes en sus repositorios.

Instalando DNSCript y DNSMasq.

Para instalarlos en ArchLinux tan solo ejecutamos en la terminal:

$ sudo pacman -S dnsmasq dnscrypt-proxy

NOTA: En los repos de ArchLinux cuenta con el paquete libsodium el cual debe instalarse para poder usar DNSCrypt, aqui es instalado automaticamente como dependencia, pero si estas en alguna otra distro como Debian o Ubuntu deberas descargar Libsodium compilarlo e instalarlo.

Configurando Dnsmasq para que trabaje junto a Dnscrypt.

Para que Dnsmasq trabaje con Dnscrypt y asi cachear las peticiones dns de dnscrypt tan solo debemos agregar o descomentar las siguientes lineas en su archivo de configuracion que deberia estar en /etc/dnsmasq.conf

# Configuration file for dnsmasq.
#
# Format is one option per line, legal options are the same as the
# long options legal on the command line. See
# "/usr/sbin/dnsmasq --help" or "man 8 dnsmasq" for details.
 
# Don't read the hostnames in /etc/hosts.
no-hosts
 
# Do not go into the background at startup but otherwise run as
# normal.
keep-in-foreground
 
# Do not provide DHCP or TFTP on the loopback interface.
no-dhcp-interface=lo
 
# Only listen on the loopback interface.
listen-address=127.0.0.1
 
# Only bind to interfaces dnsmasq is listening on.
bind-interfaces
 
# Never forward addresses in the non-routed address spaces.
bogus-priv
 
# Don't read /etc/resolv.conf.
no-resolv
 
# Reject (and log) addresses from upstream nameservers which are in
# the private IP ranges. This blocks an attack where a browser behind
# a firewall is used to probe machines on the local network.
stop-dns-rebind
 
# Exempt 127.0.0.0/8 from rebinding checks. This address range is
# returned by realtime black hole servers, so blocking it may disable
# these services.
rebind-localhost-ok
 
# Never forward plain names (without a dot or domain part).
domain-needed
 
# Upstream server is dnscrypt-proxy on local machine.
server=127.0.0.2
 
# Set the cache size here. If you don't use spam blocking add-ons such
# Adblock Plus or Ghostery, you may want to increase this value as you
# will be resolving more domain names.
cache-size=1000
 
# Pass through DNSSEC validation results from dnscrypt-proxy.
proxy-dnssec

Si se fijan en la configuracion indicamos una IP de escucha en listen-address=127.0.0.1 esta IP sera la que luego colocaremos en nuestra interfaz de red como servidor DNS para asi redireccionar todas las peticiones DNS hacia Dnsmasq. Tambien podemos notar que especificamos un servidor en server=127.0.0.2 esta sera la direccion IP en la que DNScrypt esta escuchando peticiones.

Configurando Dnscrypt.

Bien si de casualidad no lo has notado, hay que hacer un pequeno ajuste para correjir un conflicto, y es que por defecto tanto DNSMasq como Dnscrypt escuchan usando la misma direccion IP local, lo cual no deberia ser. Para corregir esto y adaptarlo a la configuracion que ya tenemos hecha para Dnsmasq editaremos el archivo /etc/conf.d/dnscrypt-proxy el cual probablemente contenga esto:

DNSCRYPT_LOCALIP=127.0.0.1
DNSCRYPT_LOCALPORT=53
DNSCRYPT_USER=nobody
DNSCRYPT_PROVIDER_NAME=2.dnscrypt-cert.opendns.com
DNSCRYPT_PROVIDER_KEY=B735:1140:206F:225D:3E2B:D822:D7FD:691E:A1C3:3CC8:D666:8D0C:BE04:BFAB:CA43:FB79
DNSCRYPT_RESOLVERIP=208.67.220.220
DNSCRYPT_RESOLVERPORT=443

Aqui solo cambiaremos el contenido de la linea que dice DNSCRYPT_LOCALIP=127.0.0.1 y cambiaremos la IP por ADIVINEN!!! 127.0.0.2.

Configurando nuestra interfaz de red:

Una vez realizada la configuracion de Dnsmasq y Dnscrypt tan solo resta adaptar nuestra interfaz de red de internet y ajustarla para que use como unico servidor DNS la IP 127.0.0.1 esta es la IP local de nuestra PC y la misma IP a la cual esta escuchando Dnsmasq. es probable que requieras reiniciar tu interfaz de red para que los cambios tengan efecto.

Ejecutando los servicios y primera prueba:

Con todo esto ya tenemos listo nuestro encriptado de peticiones DNS y chacheado de las mismas para una mayor seguridad, evitar la vigilancia y saltar la censura de tu ISP o Gobierno.

En ArchLinux basta con ejecutar:

$ sudo systemctl enable dnscrypt-proxy.service
$ sudo systemctl enable dnsmasq.service

Para habilitar los servicios y luego para arrancar:

$ sudo systemctl start dnscrypt-proxy.service
$ sudo systemctl start dnsmasq.service

Bien, para esta prueba podemos hacer una simple consulta DNS con el comando dig a alguna URL que sepamos esta censurada por nuestro Proveedor de internet, en mi caso mi proveedor es CANTV el cual pertenece al Gobierno Venezolano y una de las paginas muy conocidas que esta siendo censuradas desde hace tiempo por el Gobierno de Venezuela es DolarToday.

Si yo realizo una consulta dig a dolartoday.com seguro obtendre algo como esto:

<<>> DiG 9.9.2-P2 <<>> dolartoday.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 34898
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;dolartoday.com.			IN	A

;; ANSWER SECTION:
dolartoday.com.		299	IN	A	

;; Query time: 316 msec
;; SERVER: 200.44.32.12#53(200.44.32.12)
;; WHEN: Sun Feb 16 12:36:53 2014
;; MSG SIZE  rcvd: 59

Notese que en la columna de registros A no tenemos absolutamente nada, es decir no nos estan dando la IP del servidor de DolarToday.com para poder conectar y cargar la pagina. Notese tambien la IP 200.44.32.12 esta es la IP de uno de los servidores DNS de CANTV los cuales se agregan automaticamente cuando conectas a internet con dicho proveedor.

Con Dnsmasq, Dnscrypt ejecutandose y la interfaz de red configurada y lista, al realizar la misma consulta DNS con dig obtendriamos algo como esto:

<<>> DiG 9.9.2-P2 <<>> dolartoday.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 34898
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;dolartoday.com.			IN	A

;; ANSWER SECTION:
dolartoday.com.		299	IN	A	108.162.207.195

;; Query time: 316 msec
;; SERVER: 127.0.0.1#53(127.0.0.1)
;; WHEN: Sun Feb 16 12:36:53 2014
;; MSG SIZE  rcvd: 59

Ahora si!!! puedes notarse como se nos entrega un valor en la columna A la cual es la IP del servidor donde esta alojada la web a la que intentamos acceder y que esta bloqueada por nuestro ISP. Notese tambien que el servidor al que se envia la consulta DNS es la IP 127.0.0.1 el cual es nuestra misma PC y la IP es en donde esta escuchando Dnsmasq por las peticiones DNS que le solicitemos para que este a su vez se las solicite a Dnscrypt y este a su vez realice una consulta SEGURA y ENCRIPTADA a un servidor DNS confiable y libre de censuras.

Probablemente te preguntaras a que servidor Confiable esta Dnscrypt realizando las consultas DNS, pues arriba en la configuracion de Dnscrypt esta una pista: DNSCRYPT_RESOLVERIP=208.67.220.220 y DNSCRYPT_PROVIDER_NAME=2.dnscrypt-cert.opendns.com. Esta direccion IP pertenece al servicio OpenDNS el cual es el servicio con el que viene configurado por defecto Dnscrypt.

Opendns sirve muy bien para realizar el trabajo que deseamos el cual es saltarnos restrinciones, pero si lo deseas puedes cambiarlo por algun otro, en la pagina de Dnscrypt puedes encontrar una lista de actuales proveedores de servicios DNS con Dnscrypt activado como por ejemplo CloudNS de Australia, OpenNIC con servidores en varias partes del mundo, DnsCrypt.eu con servidores en Holanda y Dinamarca y Soltysiak.com con servidores en Polonia.

Flisol Margarita 2013 - Venezuela

2013-03-24T00:00:00-04:30

El FLISOL (Festival Latinoamericano de Instalación de Software Libre) es un evento que se realiza en las comunidades de todo el mundo en donde todas las personas interesadas en probar y/o instalar una distribución Linux, puede llevar su PC y un colaborador de la feria le instalara la distro que deseas ¡¡¡totalmente Gratis!!!. Además de esto, se realizaran charlas sobre la filosofía y los beneficios del uso de Linux y software libre.

Este es un tipo de festival que se realiza en todo el mundo, y este 27 de Abril de 2013 se realizara en 17 ciudades de Venezuela entre ellas la Isla de Margarita. Para ver las demás ciudades participantes click Aqui

Así que si vives en Margarita y te gusta el software libre o tienes curiosidad en conocer Linux y sus beneficios, no dudes en ir, ¡¡¡la asistencia es totalmente libre y gratuita!!!. Este año el Flisol Margarita tendra 3 sedes:

Porlamar.
Guatamare (UDO Nueva Esparta).
Juan Griego. ¡Posiblemente me veras aqui!

Si deseas quete instalen una distribucion Linux, puedes llevar tu PC o Laptop. Es muy recomendable de que antes de llevar tu PC/Laptop hagas un respaldo de tus datos y liberes espacio en tu Disco Duro. Tambien es muy recomendable que lleves minimo 2 CD/DVD virgen para copiar en el la distribucion Linux de tu preferencia en caso de que se nos agoten los discos que regalamos, lo cual suele suceder los primeros 5 minutos del evento.

¡¡¡Te esperamos en el Flisol Margarita 2013!!!

Instalando rbenv en linux

2012-04-27T00:00:00-04:30

Es una herramienta en linea de comandos que nos permite administrar y cambiar fácilmente entre nuestras múltiples instalaciones de diversas versiones de Ruby. Es muy sencillo, discreto, y sigue la tradicion UNIX.

Rbenv a diferencia de RVM solo nos permite en su instalacion por defecto administrar multiples versiones de Ruby, lo que nos lleva a una solucion mas limpia y simple con menos peculiaridades y trampas. rbenv fue creado por Sam Stephenson de 37Signal el cual creo el Framework JavaScript Prototype.

Que hace rbenv?

Nos permite cambiar la versión de Ruby global de usuario.
Proporciona soporte para las versiones de Ruby en pre-proyecto o desarrollo.
Permite reemplazar la version de Ruby con variables de entorno.

En contraste con RVM, rbenv no…

Necesita ser cargado en una terminal.
No sobreescribe comandos de consola como cd. Eso es peligroso y propenso a errores.
Tiene un archivo de configuracion. No hay nada que configurar excepto que version de Ruby quieres usar.
Instala Ruby. Tu puedes compilar e instalar Ruby por tu cuenta, o usar ruby-build para automatizar el proceso.
Administra gemas. Para ese trabajo existen muy buenas herramientas dedicadas como Bundler.
Exige cambios de las librerias Ruby para compatibilidad.
Pregunta con advertencias cuando cambios a un proyecto. En lugar de ejecutar código arbitrario, rbenv lee solo el nombre de la version de cada proyecto.

Instalacion.

Antes que nada tengo que advertirte que rbenv no es compatible con RVM por lo que si estas usandolo te aconsejo desinstalarlo. Como lo puedes hacer? simplemente elimina la carpeta ~/.rvm y borra cualquier referencia hacia RVM en tu ~/.bashrc o ~/.bash_profile o ~/.zshrc.

Antes de instalar rbenv debes instalar algunas dependencias basicas para compilar Ruby entre otras cosas, probablemente ya las tengas instaladas pero si obtienes algun error compilando Ruby te recomiendo leer mi Guia de instalacion de RVM.

En primer lugar clonamos rbenv desde su repositorio Github a una carpeta en ~/.rbenv ejecutanto en la terminal:

$ cd
$ git clone git://github.com/sstephenson/rbenv.git .rbenv

Agregamos ~/.rbenv/bin a nuestro $PATH para acceder al comando rbenv:

$ echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bash_profile

En caso de que uses Zsh modifica ~/.zshrc en lugar de ~/.bash_profile

Agrega rbenv init a tu shell para activar shims y autocompletado:

$ echo 'eval "$(rbenv init -)"' >> ~/.bash_profile

En caso de que uses Zsh modifica ~/.zshrc en lugar de ~/.bash_profile

Reinicia tu terminal, simplemente cierrala y vuelve a abrirla o ejecuta:

$ exec $SHELL

FELICITACIONES!!! Con esto ya tienes instalado rbenv!!!

Instalacion de Ruby.

Existen dos metodos de instalar Ruby con rbenv:

1- Compilando desde sus fuentes:

Tan solo instala la versionde Ruby que desees en ~./rbenv/versions por ejemplo si queremos instalar Ruby 1.9.3-p194:

Descargamos los fuentes desde ftp.ruby-lang.org

luego descomprimes el archivo, entramos a el en una terminal y ejecutamos los siguientes comandos:

$ ./configure --prefix=$HOME/.rbenv/versions/1.9.3-p194
$ make
$ make install

Con esto ya tendriamos instalado Ruby, tan solo nos faltaria reconstruir los archivos shim (calce) binarios:

$ rbenv rehash

Nota Esto lo debemos hacer cada vez que se instala un nuevo binario de Ruby como por ejemplo cuando instalamos una nueva version de Ruby o cuando instalamos una Gema que contiene un binario como por ejemplo rake.

2- Por medio de el plugin ruby-build

Tan solo debemos instalarlo como plugins para rbenv dentro de ~/.rbenv/plugins ejecutando los siguientes comandos:

$ mkdir -p ~/.rbenv/plugins
$ cd ~/.rbenv/plugins
$ git clone git://github.com/sstephenson/ruby-build.git

Luego de esto puedes usar el comando rbenv install por ejemplo si queremos instalar Ruby 1.9.2-p318 ejecutamos:

$ rbenv install 1.9.2-p318

Nota: debido a que ruby-build usa una especie de recipes o definiciones de compilacion para descargar, compilar e instalas las distintas versiones de Ruby, al momento de ser liberada una nueva version de ruby te recomiendo

Antes de intentar instalarla, actualizar el plugin ruby-build ejecutando en la terminal:

$ cd ~/.rbenv/plugins/ruby-build
$ git pull

Si luego de esto todavia no puedes instalar la nueva version de Ruby es posible que no este todavia actualizado el repositorio de ruby-build por lo que deberas instalar descargando los fuentes y compilandolos tal cual explico en el 1er metodo.

Nota: Recuerda ejecutar rbenv rehash cada vez que instales una version de Ruby o instales una gema que contenga binarios, esto es lo unico en lo que hay que tener cuidado con rbenv.

Actualizando rbenv.

Debido a que rbenv se descarga desde su repositorio de desarrollo Github usando git, podemos actualizarlo a la ultima version facilmente ejecutando en la terminal:

$ cd ~/.rbenv
$ git pull

Usos basicos de rbenv.

Bien ya tenemos instalado rbenv y algunas versiones de Ruby, ahora nos toca ver como podemos cambiar entre las distintas versiones que tenemos instaladas.

rbenv determina cual version de Ruby sera utilizada con un simple modelo de prioridad:

global > local > shell

El parametro global le indica a rbenv que se usara la version de Ruby indicada en todo el sistema y todas las consolas que se abran.

rbenv global 1.9.3-p194

El parametro local le indica a rbenv que se usara la version de Ruby indicada solo en la carpeta (y subcarpetas) o proyecto en el que te encuentres, y lo configura creando un archivo oculto .rbenv-version en la raiz de la carpeta en la que estas.

rbenv local 1.9.2-p318

El parametro shell le indica a rbenv que se usara la version de ruby indicada solo en esa sesion shell en ejecucion, por lo que al cerrar esa terminal y volverla abrir se fijara la version de Ruby indicada en el parametro global

rbenv shell 1.9.3-p125

Existe un parametro especial que le indica a rbenv usar la version de Ruby instalada en el sistema. para acceder a ella tan solo ejecuta:

rbenv system

Para mas comandos utiles de rbenv puedes ejecutar rbenv help para leer la ayuda.

Actualizando de android 2.1 Eclair a Android 2.2.1 Froyo en un Samsung Galaxy Spica i5700 Digitel

2011-10-08T00:00:00-04:30

Sigo aprendiendo cada vez mas sobre Android, aunque con algunos tropezones. Hace unas semanas comentaba como actualice mi Galaxy Spica I5700 de Android 1.5 Cupcake (Oficial Digitel) a Android 2.1 Eclair (Oficial Digitel), las mejoras eran ya muy notables en esa actualización pero… se puede mejorar mucho mas!!! si actualizamos a alguna de las tantas Rom personalizadas de Android 2.2 Froyo. Pues estuve leyendo sobre las ventajas de hacer una nueva actualización y a la final note que me convenía mucho.

Pues bien la room que elegí fue CyanogenMod 6.1.1 Spica Alpha 8.4 la cual esta basada en Froyo 2.2.1 e incluye mejoras interesantes como soporte 3D y soporte MultiTouch, al ser Froyo también corrige el bug en Eclair de la cámara que se queda oscura cuando se toman fotos estando conectada al Wifi. Por ser una room modificada, incluye un kernel actualizado con muchas mejoras como por ejemplo tener un recovery el cual es una muy buena utilidad que nos permitiria hacer cosas como por ejemplo ser root desde que enciendes el teléfono :D, hacer respaldos, aplicar actualizaciones y/o modificaciones comprimidas en .zip, instalar nuevas room, particionar la MicroSD, entre muchas otras funciones (tambien depende del kernel que instales).

OJO estos pasos fueron realizados partiendo de un Samsung Galaxy Spica I5700 con Android 2.1 Eclair actualizado mediante Kies mini (Room oficial de samsung), si este no es tu caso NO HAGAS NADA!!! ya que podrías tener un kernel distinto que podría no ser compatible con los que aquí se usan.

Notas antes de comenzar, si no cumples con algunas de estas notas NO HAGAS NADA!!!

Tu teléfono debe estar cargado al 100%. lo mismo va en caso de que estés desde una Laptop, y muy recomendable estar conectado a un UPS, no valla a ser que CortoElec le de por quitarte la luz en pleno proceso de actualización.
En el teléfono ve a “Configuración” o “Ajustes” luego “Aplicaciones” luego “Desarrollo” y por ultimo asegurare de que “Depuración de USB” esta marcada.
Entra en teléfono como si fueses a marcar un numero para llamar, pero teclea *#7284# y verifica que UART y USB esten marcados en PDA.
Has un respaldo de tus contactos y archivos en tu MicroSD. recomendable sincronizar los contactos con tu cuenta de Google/Gmail para que queden respaldados allí y luego puedas recuperarlos fácilmente.
Recomendable: instalar la aplicación APN Backup & Restore para que respaldes tus APN la guardes en la memoria MicroSD o tu PC y las puedas restaurar luego.
Si harás la actualización en una PC de escritorio conecta el cable USB del teléfono a un conector USB que sea directo a la Tarjeta Madre de la PC. no uses los puertos delanteros o laterales del gabinete de la PC ya que suelen ser de pobre calidad y suelen fallar mucho, tampoco uses concentradores o Hub.
Rezar dos Padres Nuestros y tres Ave Maria. es broma, pero de seguro querrás tener a Dios de tu lado en este momento.

Requerimientos:

Descargar Odin 4.03
Descargar CyanogenMod-6.1.1-Spica-alpha8.4
Descargar el kernel de Leshak para Firmware Original.

OJO claramente dice Firmware original, Android 2.1 de agencia o actualizado mediante Kies Mini como en mi caso, si este no es tu situacion, NO HAGAS NADA!!! ya que podrías tener un kernel distinto que podría no ser compatible con los que aquí se usan.

Necesitas tener instalados los drivers necesarios para conectar el teléfono a la PC, si en tu caso ya tienes instalado Samsung NPS (New PC Studio) o el Kies Mini, entonces ya tienes los drivers instalados, pero cabe aclarar un detalle debes desactivar el inicio automatico de Kies o NPS, puedes hacerlo mediante el Ccleaner. sino lo que puedes hacer es entrar en la carpeta donde esta instalado NPS y/o Kies, debe haber por alli algun ejecutable llamado SAMSUNG_USB_Driver_for_Mobile_Phones.exe de unos 18.6Mb (Version 1.3.850) respaldalo en alguna otra ubicación, des instala el Kies y/o el NPS, limpia registros y demas con Ccleaner, reinicia la PC, luego instala los drivers que respaldaste y vuelve a reiniciar. si no quieres hacer todo esto puedes descargar los drivers desde aqui.
Desactivar el inicio automático de tu antivirus, esto es para evitar posibles problema con los drivers.

Procedimientos:

Una vez que tengas instalado los drivers, ayas descargado Odin, la Room de Froyo para tu Spica, descargado el kernel de leshak i5700_LK2-08_PDA.7z y hayas configurado y reiniciado la PC para que NPS, Kies y tu antivirus no se inicien, entonces toca flashear para obtener root y recovery.

0- Descomprime el Odin_4.03_Spica_ops.zip, obtendrás una carpeta con el Odin y dos archivos.

1- Descomprime el kernel de leshak i5700_LK2-08_PDA.7z, deberías obtener i5700_LK2-08_PDA.tar (OJO no lo descomprimas nuevamente, déjalo así) de unos 15.2Mb y copíalo dentro de la carpeta donde tienes el Odin

2- Copia la room CM-6.1.1-Spica-a8.4_update.zip en la raíz de la tarjeta MicroSD, luego apaga tu teléfono, retira la tarjeta SIM y la MicroSD, luego colocalo en modo Download, presionando las teclas Volumen abajo + Camara + End o Apagar .

3- Abre el Odin (si estas en Windows Vista/Windows 7 abrelo como Administrador) Conecta el teléfono a la PC, espera un ratico que Windows reconozca el dispositivo. El Odin deberia reconocerlo marcando en la casilla de Messages Added!!! y Detected!!!, ademas deberia aparecer con fondo amarillo la casilla COM Port Mapping y un numero de puerto COM.

4- En el Odin presiona el boton Reset Files, presiona el boton OPS y agrega el archivo spica_jc3.ops, luego presiona el boton PDA y agrega el archivo i5700_LK2-08_PDA.tar

5- Verifica que todo se vea similar a esto:

6- Si todo esta bien, entonces le damos al boton Start, Odin debería comenzar a Flashear el nuevo kernel en tu teléfono, el proceso no debería tardar mas que unos pocos segundos ya que el archivo es bastante pequeño. El teléfono se reiniciara y entrara en el Recovery, (no es necesario, pero por seguridad espera al menos unos dos minutos y verifica que en el teléfono siga mostrándote el recovery) una vez dentro del recovery puedes desconectar el teléfono de la PC y Listo!!! ya tienes tu teléfono Rooteado y con Recovery :D

7- Apaga el Teléfono, quita la batería, coloca la tarjeta MicroSD (solo la MicroSD no coloques la tarjeta SIM) que en la cual copiaste la Room, coloca nuevamente la batería y entra ahora en el modo Recovery tecleando Volumen Abajo + Tecla de llamada + Tecla de terminar llamada/Apagar. Dejalo unos segundos presionado hasta que veas el menu del Recovery.

8- Este es el famoso Recovery :D se maneja usando los botones del teléfono y las confirmaciones que nos pide la hacemos seleccionando el boton de Home (no se usa tocando la pantalla). lo recomendable en este punto seria hacer un respaldo (por si las moscas) para eso ve a la opción “Samdroid 0.2.1 Backup” y de una vez comenzara a realizarse el respaldo el cual tarda unos minutos o unas 5 o 6 lineas. este respaldo luego en caso de inconvenientes podemos flashearlo mediante el Odin.

9- Ahora ve a la opcion “Wipe, Choose what” y luego aplica los 3 wipe que aparecen los cuales son “wipe data/cache”, “wipe cache” y “Wipe Dalvik cache” tal como dice el recovery necesitas confirmar la opción a aplicar, presionando el botón Home (el botón de la casita)

10- Luego de esto vuelve al menú principal del Recovery y selecciona la opcion “Apply any zip from SD” y elegimos el archivo CM-6.1.1-Spica-a8.4_update.zip que copiamos anteriormente en la MicroSD. confirmamos la opción presionando Home, ahora se comenzara a instalar la nueva room, podrás ver el estado del proceso en la pantalla con todo lo que se esta realizando, también veras en el fondo una barra amarilla cargándose. Es posible que el teléfono se reinicie incluso unas 5 veces, no te preocupes, pues esto es normal. Espera hasta que en la pantalla te diga algo como “Install from sd complete” y vuelva al recovery. en este punto ya debe de haberse instalado tu nueva version de Android 2.2.1 Froyo :D tan solo reinicia el telefono en la opcion “Reboot system now” y ahora tu Spica se iniciara por primera vez con Froyo :D. no te preocupes si el primer inicio demora mas de lo normal, esto es normal. En mi caso demoro creo que como 5min aunque con el miedo y las bolas en las gargantas me parecieron como 15min LOOL

11- Una vez que tu Spica cargue Froyo por primera vez, veras que aparecerá el menú de configuración inicial. pero si hiciste los pasos tal cual aparecen aquí es probable que no tengas puesta la tarjeta SIM, por lo que debes preferiblemente cambiar el idioma a tu preferido, omitir toda la configuración inicial y apagar el teléfono. luego saca la batería, coloca la tarjeta SIM, vuelve a colocar la batería y enciende el teléfono nuevamente. Ahora si podras completar la configuración inicial y comenzar a disfrutar de Android 2.2.1 Froyo con multitouch, drivers 3D y rooteado desde el inicio :D

Posibles problemas:

Por suerte yo no tuve problemas graves, pero si tuve uno que me comió por varias semanas. Resulta que cuando conectaba el teléfono a la PC, el Odin me lo reconocía sin problemas, marcaba su puerto COM con fondo azul y todo lo demás como la imagen arriba. pero al hacer click en Start el Odin se quedaba sin hacer nada mas que mostrarme el mensaje “<1> setup connection…” en la casilla de mensajes.

Luego de unas cuantas semanas investigando, probando sugerencias que me fueron recomendadas en varios foros, etc. recibí por Twitter una recomendación por parte de IIKndyII (Muuuuchas gracias!!!!!) que fue la que soluciono mi problema. Cuando se quede el Odin en “<1> setup connection…” proceda a cerrar el Odin, luego desconecte el teléfono de la PC, apáguelo (quitando la batería y colocándosela nuevamente) inicie nuevamente en modo download, abra el Odin, cargue los archivos necesarios y conecte nuevamente el teléfono, espere unos 2 minutos (yo me puse a ver un video de como se flasheaba un kernel al Spica :D) y luego presione el boton Start. Y tal cual como me dijo IIKndyII… seguro ahora si lo reconoce y Odin comienza a flashear :D

En caso de que Odin te tenga rabia y te siga mostrando el mensaje, reintenta esta recomendación o reinicia la PC y vuelve a intentar.

Primeras impresiones:

Esta actualización yo la realice el Lunes de esta semana, por lo que no tengo ni una semana con la room, pero las primeras impresiones han sido muy favorables con respecto a Eclair actualizado desde Kies (oficial). lo mas destacable es que con esta room la batería me esta durando muuuuchisimo mas que con Eclair. y como muestra les comento que la ultima vez que cargue el teléfono fue el martes en la noche, y hasta el dia de hoy sábado todavía no lo e puesto a cargar, si! lleva casi 4 dias sin cargarse!!! y todavía la bateria esta al 60%. claro esta tengo las conexiones 2G/3G desactivadas y solo estoy usando la conexión WiFi de mi casa. no he usado mucho el teléfono, tan solo he hecho unas 4 llamadas de menos de 1min C/U, actualice unas 3 aplicaciones desde el market (este mismo se actualizo a la version 3.1.5) e instale unas 4 aplicaciones. use unos 5min el GPS con la aplicación Navitel + los mapas de mi área y todavía tengo batería!!!! :P

Actualizando de android 1.5 Cupcake a Android 2.1 Eclair en un Samsung Galaxy Spica i5700 Digitel

2011-09-17T00:00:00-04:30

Hace poco mas de una semana adquirí un teléfono con S.O Android, específicamente el Samsung Galaxy Spica I5700 de Digitel, luego de jurungarlo por unas cuantas horas viendo y probando todas sus funciones me encontré con que no podía instalar muchas de las mejores aplicaciones disponibles para Android por el simple hecho de que el teléfono viene con Android 1.5 Cupcake, el cual es ya una versión desactualizada, por lo que para exprimir mejor las funciones del equipo debería actualizar como mínimo a Android 2.1 Eclair o superiores.

Buscando en internet encontré mucha información para actualizar el Galaxy Spica i5700 a Eclair o incluso ir mas allá y actualizar a Froyo o Gingerbread, pero muchas de ellas se realizan con métodos un tanto extraños (Flasheando con Odin y/o aplicar roms con Recovery) a simple vista para alguien como yo que apenas tenia unas horas de experiencia en Android y teléfonos inteligentes, por lo que decidí dejarlas a un lado para estudiar mejor los procedimientos e intentarlo de forma segura en un futuro cercano.

Por suerte en la pagina de Samsung Venezuela ofrecen una actualización a Eclair (no es Froyo ni Gingerbread pero al menos es algo.) con un método un tanto mas directo, con menos pasos y podría decirse que mas seguro ya que en la pagina de Digitel dicen que hay una actualización disponible para este equipo en la pagina de Samsung (al menos lo incitan a uno a actualizar con ese método, si algo saliera mal ellos “deberían” poder responder sin rechistar.), por lo que decidí actualizar de esta forma:

Lo unico malo de todo esto es que hay que usar Windows :( pero bueh no queda de otra (por ahora)… en mi caso yo use Windows 7 64bits.

Notas antes de comenzar, si no cumples con algunas de estas notas NO HAGAS NADA!!!:

Tu teléfono debe estar cargado al 100%. lo mismo va en caso de que estés desde una Laptop, y muy recomendable estar conectado a un UPS, no valla a ser que CortoElec le de por quitarte la luz en pleno proceso de actualización.
En el teléfono ve a “Configuración” o “Ajustes” luego “Aplicaciones” luego “Desarrollo” y por ultimo asegurare de que “Depuración de USB” esta marcada.
Has un respaldo de tus contactos, recomendable sincronizar los contactos con tu cuenta de Google/Gmail para que queden respaldados allí y luego puedas recuperarlos fácilmente.
Recomendable: instalar la aplicación APN Backup & Restore para que respaldes tus APN la guardes en la memoria MicroSD o tu PC y las puedas restaurar luego.
Estar conectado a internet con una conexión rápida y estable. ya que Kies se descargara los archivos necesarios y son como 115Mb Aprox. yo me conecte desde un módem USB Movistar que es muy rápido en mi zona, pero sospecho que este fue la causa de un error que explicare mas adelante, si cuentas con un internet Wifi o cableado de alta velocidad usalo en vez del módem para estar mas seguro.
Si harás la actualización en una PC de escritorio conecta el cable USB del teléfono a un conector USB que sea directo a la Tarjeta Madre de la PC. no uses los puertos delanteros o laterales del gabinete de la PC ya que suelen ser de pobre calidad y suelen fallar mucho, tampoco uses concentradores o Hub.
Rezar dos Padres Nuestros y tres Ave Maria. :P es broma, pero de seguro querrás tener a Dios de tu lado en este momento :D

Procedimiento:

Primero que todo debemos descargar la aplicación Kies Mini desde la pagina de Samsung Venezuela.
la instalamos, en la ventana donde pregunta el país elige España e idioma Español ya que Venezuela no aparece por ningún lado :S
Si por casualidad tienes instalado NPS (Samsung New PC Studio) cierralo por completo, que no haya procesos de el ejecutándose (verifica en la bandeja de sistema y en el administrador de tareas).
Abre el Kies Mini, y en el menú elige “Instalar controladores” para que se instalen los drivers y reinicia la PC.

Nota: a pesar de que en alguno otros tutoriales de flasheo con Odin y similares recomiendan quitar la MicroSD y la SIM, en este método no es necesario. en mi caso yo no se lo quite.

Abre nuevamente el Kies, conecta el teléfono a la PC y espera que lo reconozca, al cabo de unos segundos debería marcarte que hay una actualización. una vez te diga que existe una, comienza el proceso de actualización.
El proceso comienza descargando los archivos necesarios (Roms y demás) de internet, por lo que el tiempo depende de que tan rápida y estable sea tu conexión. (en mi caso demoro como 10min).

Nota: en caso de que estando en el proceso de descargas estés se cancele y te muestre error, desconecta el teléfono apagalo quita la pila, colocala nuevamente y enciendelo, cierra el Kies, abrelo nuevamente , conecta el teléfono e intenta de nuevo. en mi caso completo la descarga al tercer intento. :S

una vez termine la descarga el teléfono se reiniciara para entrar en “modo download” (pantalla negra con logo y letras de fondo azul) y el Kies comenzara a copiar los archivos descargados al teléfono, veras el proceso de copiado en el teléfono mediante una barra azul que se va llenando.
una vez terminado, el teléfono se reiniciara nuevamente y ahora mostrara una pantalla negra con un logo de una cajita con una barra abajo que se va llenando (en mi caso no se lleno mucho), supongo que en este paso se instalan y aplican los archivos descargados. En este paso es probable que el Kies te diga que ya ha sido completada la actualización, pero Espera!!! no le hagas caso que el teléfono sigue haciendo algo, mantenlo conectado a la PC.
cuando termine la instalación, (no demora mucho) el teléfono se reiniciara, cargara Android 2.1 Eclair, entraras en tu escritorio (el del teléfono) y eso sera todo :D

Posibles problemas:

Bueno a pesar de que este método parece mas directo, corto y sencillo no es a prueba de errores. en mi caso cuando termino la descarga de los archivos desde internet, y luego de que el teléfono se reiniciara para entrar en “Modo download” Windows comenzó a instalar unos drivers para reconocer el dispositivos y para remate me pidió reiniciar (ni loco iba yo a reiniciar en pleno proceso de actualización), luego de instalado el drivers y detectado el dispositivo el modem USB se desconecto (eyecto) al igual que el teléfono (quedándose este con el logo de Samsung en la pantalla) y el Kies me mostró un mensaje en el que decía que la actualización no podo ser completada y sugiriendo hacer una recuperación de emergencia. :O en ese momento tenia las bolas en la garganta!!!!.

En ese momento lo único que se me ocurrió fue terminar de desconectar el teléfono a la laptop, quitar la pila, volverla a colocar y encender el teléfono. Para mi alivio inicio normalmente y sin problemas a Android Cupcake (si allí se bajaron las que te conté a su lugar LOOL ). al cabo de un rato decidí volver a intentarlo, pero para mi sorpresa al abrir el Kies este me mostraba que había un intento de actualización que no se completo y me pedía que hiciera una “recuperación de emergencia” y me paso a mostrar los pasos para realizarla los cuales son simplemente colocar el teléfono uno mismo en “modo Download” presionando las teclas Volumen abajo + Camara + End o Apagar estando apagado el teléfono y luego conectarlo a la PC y darle a “Recuperación de emergencia” en el Kies. Esto lo que hizo fue copiar al teléfono los archivos descargados, pero esta vez si los instalo y los aplico por lo que al cabo de unos segundos el teléfono se reinicio y entro a Android 2.1 Eclair :D

Implementando una aplicacion Rails 3 en Cloudfoundry

2011-08-15T00:00:00-04:30

CloudFoundry es la plataforma abierta como proyecto de servicios iniciada por VMware la cual puede soportar múltiples frameworks, varios servicios cloud de algunos proveedores , y múltiples aplicaciones de servicios. todo esto en una plataforma escalable en la nube.

Estos servicios están actualmente en version Beta, por lo que de momento son gratuitos pero se requiere de una invitación que puedes solicitar en la pagina de CloudFoundry. casualmente hoy me llego mi invitación (apenas la había pedido ayer) por lo me pude darle un vistazo rápido a la plataforma y hacer unas primeras pruebas.

Instalación de VMC CLI y configuración:

Lo primero en que me di cuenta es que el servicio se administra mediante una CLI (Command Line Interface) o interfaz de linea de comandos (si todavía no tienes ni P!##@ idea, lo administras desde la terminal!!! ). que se instala mediante una gema ruby llamada VMC (de VMware Cloud… creo!!!) por lo que tenemos que teclear en la terminal:

gem install vmc

luego de esto debemos ejecutar:

vmc target api.cloudfoundry.com

Ahora podemos iniciar sesion en el servicio tecleando:

vmc login

colocamos nuestro dirección de correos, la contraseña temporal que se nos envió con la invitación y tal cual dice la invitación, aprovechamos de cambiar la contraseña temporal por una fija tecleando:

vmc passwd

Implementacion de una aplicación Rails 3:

En mi caso yo use un sencillo blog con registro de usuarios usando la gema Devise. la aplicación no es gran cosa y usa Sqlite 3 como Base de datos.

para esto me muevo en la terminal y entrar a la carpeta donde esta la aplicación, una vez alli tecleo en la terminal:

vmc push

Esto nos hará una serie de preguntas:

- Would you like to deploy from the current directory?:

respondemos Y - si

- Application Name: colocamos aqui el nombre de la apliacion

- Application Deployed URL: ‘blogdevisejam.cloudfoundry.com’?

nos muestra la URL a la cual podremos acceder y ver nuestra aplicacion.

Nota: si no me equivoco las url son únicas, por lo que si ya existe una aplicación con la url que queremos usar, deberemos pensar en otra.

- Detected a Rails Application, is this correct? [Yn]:

nos descubrieron!!! pillaron que queremos subir una aplicacion rails, por lo que no le mentimos y contestamos Y.

- Memory Reservation [Default:256M] (64M, 128M, 256M, 512M or 1G)

respondemos 256M - podemos darle simplemente enter y tomara el valor por defecto el cual es 256M.

Deja de preguntarnos vainas y comienza a instalar y configurar la aplicacion:

Y listo!!!

podemos ir a la url indicada en el “cuestionario” y ver nuestra aplicación en ejecución.

así de fácil :D

Claro esta, esto es solo el principio, aplicaciones mas complejas requieren configuraciones y pasos mas complejos.

Cloudfoundry ademas de Rails (ruby) soporta aplicaciones Node.js (javascript del lado servidor), Spring (Java), Sinatra (Ruby) y Grails. se pueden usar bases de datos como MongoDB, Redis y MySQL.

a simple vista tiene buena pinta el servicio, uno mas a la lista de hosting “de momento gratuito” que podemos usar para probar aplicaciones en Internet. habría que esperar a que salga de la etapa beta, ver que otras características se agregan y demás.

Instalando Zsh y OhMyZsh en Linux

2011-08-09T00:00:00-04:30

Extraído de Wikipedia:

ZSH:

Es un potente intérprete de comandos para sistemas operativos de tipo Unix, como por ejemplo los BSD o GNU/Linux.1 La primera versión de zsh fue escrita por Paul Falstad en 1990, cuando era estudiante en la Universidad de Princeton. Zsh se diseñó para poder usarse interactivamente. Se le han incorporado muchas de las características principales de otras shells de Unix como, bash, ksh, o tcshy además posee características propias originales

Una de las características de Zsh que enamoran al usuario es su alta capacidad de personalización y ser compatible con Bash. pues bien estas dos características justamente son las que me hicieron probar por unos meses Zsh y luego usarla como Shell por defecto en mi PC y Laptop.

OhMyZsh: Es un framework impulsado por la comunidad para la administración de las configuraciones de Zsh, el cual le agrega características como auto-completado, corrección de escritura y viene con mas de 50 plugins opcionales que agregan aun mas funcionalidades a la shell. no conforme con esto también incluye la posibilidad de personalizar la forma en que se muestra tu shell y la información que esta muestre mediante themes que puedes crear tu mismo, o usar uno de los que incluye OhMyZsh (mas de 90).

Instalación: Para instalar Zsh en Ubuntu tan solo debemos ejecutar en la terminal:

sudo aptitude install zsh

con esto ya tendremos instalado Zsh con las caracteristicas que vienen por defecto, pero como en este caso queremos es explotar sus capacidades de personalización necesitaremos instalar OhMyZsh.

OhMyZsh se instala descargándolo desde su repositorio en GitHub, el autor ofrece un comando que automatiza la descarga e instalacion del mismo, pero para poder ejecutarlo necesitas tener instalado Git para clonar el repositorio, esto lo haces son un simple: sudo aptitude install git una vez instalado Git puedes instalar OhMyZsh tecleando en la terminal:

wget --no-check-certificate https://github.com/robbyrussell/oh-my-zsh/raw/master/tools/install.sh -O - | sh

Con este comando se descargara OhMyZsh desde su repo en github y lo clonara en la carpeta ~/.oh-my-zsh de tu usuario, luego de eso podrás comenzar a usarlo.

Instalación Manual: el metodo mas largo (la verdad no tanto) para instalar OhMyZsh es simple, tan solo clona el repositorio en una carpeta oculta llamada .oh-my-zsh tecleando:

git clone git://github.com/robbyrussell/oh-my-zsh.git ~/.oh-my-zsh

luego de esto creas tu archivo de configuracion .zshrc copiando la plantilla que OhMyZsh trae por defecto:

cp ~/.oh-my-zsh/templates/zshrc.zsh-template ~/.zshrc

Por ultimo ajusta Zsh para que sea tu shell predeterminada:

chsh -s /usr/bin/zsh

ya luego de esto solo debes reiniciar o abrir una nueva terminal para ver Zsh+OhMyZsh funcionando.

Personalización: si vas a la carpeta ~/.oh-my-zsh/themes y ~/.oh-my-zsh/plugins veras los themes y plugins disponibles para personalizar tu shell y activar nuevas funcionalidades.

Para activar y usar un plugins tan solo debes abrir con tu editor favorito el archivo ~/.zshrc y buscar la linea:

plugins=(git)

y agregar dentro de los paréntesis el nombre del plugins que quieres usar, por ejemplo en las ultimas actualizaciones de han agregado plugins como cloudapp el cual es una herramienta para subir imágenes desde la terminal a el hosting de imagenes en getcloudapp.com que hasta donde se puede ver en la pagina solo ofrece soporte para MacOS, pero como dispone de una API, podemos usarlo tambien en Linux :P asi que para agregarlo tan solo escribimos:

plugins=(git cloudapp)

Para activar y usar themes es similar a como hicimos para ctivar plugins. pero en vez de buscar la linea plugins, buscamos la linea:

ZSH_THEME="robbyrussell"

y cambiamos “robbyrussell” por el nombre del theme que quieras usar.

yo en mi caso me hice mi propio theme modificando y combinando funciones de varios themes que vienen incluidos, mi theme lo llame “jam” por lo que en mi caso esta linea se ve asi:

ZSH_THEME="jam"

y mi shell se ve asi:

Instalando RVM, Ruby y Rails en Linux.

2011-05-17T00:00:00-04:30

Hace unos días atras estaba intentando instalar Ruby 1.9.2 desde los repositorios, como ya mi laptop tenia la versión 1.8.7 me di a la tarea de desinstalar por completo esta versión. Luego de terminal de instalar Ruby 1.9.2 y hacer la primera prueba, me encontré con que con que no había salido todo bien, algunas aplicaciones como Gem y Rake estaban buscando el ejecutable de Ruby 1.8.7 (que ya no estaba) y no el de Ruby 1.9.2. Leyendo en internet encontré algunas posibles soluciones en las que sugerían crear enlaces simbólicos para que de este modo las aplicaciones que buscaran determinadas versiones de Ruby (1.8.7 en mi caso) usara la versión instalada (Ruby 1.9.2). asi lo hice, pero no fue la solución optima ya que muchas aplicaciones no estaban trabajando del todo bien y seguían mostrando algunos errores.

De vuelta a los buscadores, intentando encontrar alguna forma de tener Ruby 1.9.2 + Rails 3.0.7 y demás acompañantes en su ultima versión trabajando en armonía y sin problemas, me tope con RVM (Ruby Version Manager) el cual es una aplicación de linea de comandos que nos permite instalar, administrar y poder trabajar con múltiples versiones (o sabores) de Ruby y otras aplicaciones en gemas. Esto quiere decir que si asi lo queremos podríamos tener instalado en nuestra computadora Ruby 1.8.7, Ruby 1.9.2, Rails 2.x, Rails 3.07 y usar en cualquier momento la version que mas nos convenga. En este caso yo instale Ruby 1.9.2 + Rails 3.0.7 En Ubuntu 10.10 64bits.

Instalación:

Si nos vamos a la guia de instalación en la pagina oficial, lo primero que nos dice es que tenemos dos formas de instalación a elegir:

Instalación para un solo usuario es la mas comun, y la recomendada en la cual todo el contenido de RVM y la versión de Ruby y Gems a elegir estarán ubicadas en la carpeta del usuario que realice la instalación.

Instalación multi-usuario (root) este método es similar a como cuando instalas Ruby u otro paquete desde los repositorios usando privilegios de administrador, este metodo permise que todos los usuarios en el sistema puedan usar la instalacion de RVM y Ruby.

Como yo soy el único que usa esta Laptop y tan solo quiero Ruby para aprender y hacer pruebas, me basta con la primera opción, ademas de que me da la ventaja de mantener mi configuración en caso de que decida reinstalar el S.O tan solo haciendo un respaldo de mi carpeta personal y luego restaurándola en otra PC.

Para instalar RVM tecleamos en una terminal:

Nota: este comando requiere algunas dependencias instaladas, tan solo teclean sudo aptitude install build-essential git-core curl en la terminal y luego continua con:

bash <<(curl -s https://rvm.beginrescueend.com/install/rvm)

Esto nos descargara un script en bash (el cual recomiendan leer aqui) que luego es ejecutado por… ¡adivinen! :P ¡si! por Bash. este script lo que hace es clonar RVM de su repositorio en GitHub

Una vez terminada la instalacion, el contenido de RVM se ubicara en la carpeta .rvm que se encuentra dentro de tu carpeta de usuario ~/

Cargando RVM en tu sesion Shell como funcion:

Para que nuestra terminal pueda trabajar sin problemas con RVM debemos agregar la siguiente linea al archivo ~/.bash_profile, para esto tecleamos en la terminal:

echo '[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm" # Load RVM function' && ~/.bash_profile

Recargando la configuración de Shell y primera prueba:

Cierra y abre tu terminal en uso, (o abre una nueva) y teclea en ella la siguiente linea para recargar la configuración nueva:

source .bash_profile

Luego teclea la siguiente linea para hacer una prueba y ver si todo esta trabajando bien:

type rvm | head -1

Si todo ha ido bien, nos deberia responder rvm: es una función

Ahora debemos verificar algunas otras dependencias a instalar antes de continuar:

rvm notes

Esto nos devuelve algo como esto:

Notes for Linux ( DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=10.10
DISTRIB_CODENAME=maverick
DISTRIB_DESCRIPTION="Ubuntu 10.10" )

NOTE: 'ruby' represents Matz's Ruby Interpreter (MRI) (1.8.X, 1.9.X)
             This is the *original* / standard Ruby Language Interpreter
      'ree'  represents Ruby Enterprise Edition
      'rbx'  represents Rubinius

bash >= 3.2 is required
curl is required
git is required (>= 1.7 recommended)
patch is required (for ree and some ruby-head's).

If you wish to install rbx and/or Ruby 1.9 head (MRI) (eg. 1.9.2-head),
then you must install and use rvm 1.8.7 first.

If you wish to have the 'pretty colors' again,
  set 'export rvm_pretty_print_flag=1' in ~/.rvmrc.

dependencies:
# For RVM
  rvm: bash curl git

# For Ruby (MRI &amp; ree)  you should install the following OS dependencies:
  ruby: /usr/bin/apt-get install build-essential bison openssl libreadline6 libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-0 libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev ncurses-dev

# For JRuby (if you wish to use it) you will need:
  jruby: /usr/bin/apt-get install curl g++ openjdk-6-jre-headless
  jruby-head: /usr/bin/apt-get install ant openjdk-6-jdk

# In addition to ruby: dependencies,
  ruby-head: subversion

# For IronRuby (if you wish to use it) you will need:
  ironruby: /usr/bin/apt-get install curl mono-2.0-devel

Si leemos detenidamente notamos que una de las dependencias de RVM es Bash, Curl y Git, pero no necesitaremos instalarla ya que de seguro lo hiciste cuando ejecutaste el comando junto a la primera nota antes de instalar RVM, de lo contrario no estarías aqui :P También podemos ver que hay dependencia de acuerdo a la simplemente de Ruby que deseamos usar, en mi caso usare Ruby (‘ruby’ represents Matz’s Ruby Interpreter (MRI) (1.8.X, 1.9.X)) el cual es el mas común ya uqe Jruby es una implementacion de Ruby+Java y Ironruby es implementacion de Ruby+plataforma .Net/Mono. por lo tanto las dependencias a instalar para Ruby serian:

sudo aptitude install build-essential bison openssl libreadline6 libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-0 libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev ncurses-dev

¡Felicidades! ya has instalado RVM, pero todavia no hemos terminado…

Instalando Ruby + Rails:

Bien aquí viene la parte mas divertida, primero instalaremos Ruby, recuerden que en mi caso elegi la version 1.9.2 por lo que tecleo en la terminal:

rvm install 1.9.2

Este proceso puede llevar algunos minutos ya que el comando descargara las fuentes de Ruby, las extraerá en la carpeta ~/.rvm , lo compilara y luego lo instalara.

Una vez terminado el proceso deberás elegir la versión de Ruby a usar, en nuestro caso instalamos Ruby 1.9.2 por lo que tecleamos en la terminal:

rvm use 1.9.2

Bien ahora a comprobar que hemos hecho todo bien, tecleamos en la terminal:

ruby -v

lo que nos deberá responder algo similar a: ruby 1.9.2p180 (2011-02-18 revision 30909) [x86_64-linux]

comprobación extra: si tecleamos el comando which ruby podremos ver donde se encuentra el ejecutable de Ruby, en mi caso es: /home/angel/.rvm/rubies/ruby-1.9.2-p180/bin/ruby Si hubiésemos instalado ruby desde los repos la ubicacion seria algo como /usr/bin/ruby

Si queremos usar esta version de Ruby por defecto, deberemos teclear en la terminal:

rvm use 1.9.2 --default

Pero hay algo que debemos corregir, ya que si por ejemplo reiniciamos la PC y al entrar abrimos una terminal y tecleamos ruby -v de seguro obtendremos un error que nos dira que no tenemos ruby instalado, ¡como que no si lo acabo de hacer!, para solventar esto abrimos con tu editor de texto favorito el archivo .bashrc ubicado en tu carpeta de usuario ~/.bashrc y al final del archivo coloca la siguiente linea:

source $HOME/.rvm/scripts/rvm

Ruby 1.9.2 incluye rubygems, asi que lo mas que podriamos hacer seria actualizar tecleando en la terminal:

gem update --system<

revisamos la versión de gem tecleando gem -v en la terminal

Instalación de Rails:

gem install rails

verificamos la version de rails tecleando en la terminal rails -v

Si eres de los que usas IRB (Ruby Interactivo) de seguro al ejecutarlo te mostrara un mensaje de error referente a readline, ademas en IRB no podras mover el cursor entre los caracteres y/o no tendrás auto-completado. Para solucionar esto tecleamos en la terminal estos tres comandos:

cd .rvm/src/ruby-1.9.2-p180/ext/readline/
ruby extconf.rb
make install

Para verificar abre de nuevo IRB, si todo ha salido bien, notaras que puedes mover el cursor entre los caracteres y tendrás auto-completado.

Mejora Extra en IRB:

si deseas tener coloreado en IRB instala las gemas wirble y hirb:

gem install wirble hirb

Luego abre el archivo .irbrc ubicado en tu carpeta de usuario ~/.irbrc (crealo si no existe) y agrega lo siguiente:

require 'rubygems'
require 'wirble'
require 'hirb'
Wirble.init
Wirble.colorize
# hirb (active record output format in table)
Hirb::View.enable

# IRB Options
IRB.conf[:AUTO_INDENT] = true
IRB.conf[:SAVE_HISTORY] = 1000
IRB.conf[:EVAL_HISTORY] = 200

# Log to STDOUT if in Rails
if ENV.include?('RAILS_ENV') &amp;&amp; !Object.const_defined?('RAILS_DEFAULT_LOGGER')
  require 'logger'
  RAILS_DEFAULT_LOGGER = Logger.new(STDOUT)
  #IRB.conf[:USE_READLINE] = true

  # Display the RAILS ENV in the prompt
  # ie : [Development]&gt;&gt;
  IRB.conf[:PROMPT][:CUSTOM] = {
   :PROMPT_N =>; "[#{ENV["RAILS_ENV"].capitalize}]&gt;&gt; ",
   :PROMPT_I =>; "[#{ENV["RAILS_ENV"].capitalize}]&gt;&gt; ",
   :PROMPT_S =>t; nil,
   :PROMPT_C =>; "?&gt; ",
   :RETURN =&gt; "=>; %s\n"
   }
  # Set default prompt
  IRB.conf[:PROMPT_MODE] = :CUSTOM
end

# We can also define convenient methods (credits go to thoughtbot)
# def me
#  User.find_by_email("me@gmail.com")</pre>

Bien esto es todo, ya queda de tu parte instalar las gemas que mas uses y adaptarlo de acuerdo a tus necesidades. :)

Mongoengine un ODM para conectar a MongoDB desde Python

2011-01-14T00:00:00-04:30

MongoEngine es un ODM (Object Document Mapper) que nos permite mapear la estructura de nuestra base de datos a objetos en nuestras aplicaciones Python que se conectan a instancias MongoDB, esto con el fin de poder usar la informacion en nuestra base de datos somo si se tratasen de un objeto. Esto nos ofrece la ventaja de que podemos escribir de una manera mas comoda nuestra aplicacion, definir un esquema para la base de datos y mejorar nuestro codigo, entre otras ventajas mas.

Para instar MongoEngine en Linux tan solo debemos escribir en la terminal:

sudo easy_install mongoengine

Nota: debido a que MongoEngine usa el driver PyMongo para conectar nuestras aplicaciones Python a bases de datos NoSQL MongoDB, es capaz de detectar si tenemos o no instalado el driver PyMongo, por lo que si no lo tenemos instalado MongoEngine lo instalara automaticamente. De todos modos puedes instalar PyMongo de forma separada tecleando:

sudo easy_install pymongo

Si leyeron mi articulo anterior sobre Ejemplos de Consultas Map/Reduce en MongoDB de seguro habran leido que al final del articulo mencionaba que en especifico esa consulta map/reduce podriamos mejorarla y hacerlas de una forma mas sencilla y sin funciones JavaScript si usaramos un ODM, pues bien MongoEngine es uno de los ODM con los que podemos mejorar el codigo de la aplicacion RegistroDeTransferencias.

Usando el ODM MongoEngine nuestra aplicacion quedaria similar a esto:

#! /usr/bin/env python
from mongoengine import *
from datetime import *
from time import *

class Rsubida(Document):
 subida = FloatField()
 fecha_agregado = StringField()
 hora_agregado = StringField()

class Rbajada(Document):
 bajada = FloatField()
 fecha_agregado = StringField()
 hora_agregado = StringField()

print "Conectando a la Base de datos en la instancia Local"
#Conectando a la instancia MongoDB local en la base de datos "bdregistrotransgerenciamdb"
connect("bdregistrotransgerenciamdb")

la_subida = float(raw_input('Introdusca la cantidad de datos Enviados: '))
la_bajada = float(raw_input('Introdusca la cantidad de datos Recibidos: '))

fecha = date.today()
fechaagregado = fecha.strftime("%d-%m-%y")
horaagregado = strftime("%I:%M %p")

print "Los datos ingresados son:"
print "Subida: " + str(la_subida)
print "Bajada: " + str(la_bajada)
print "Fecha Agregado " + fechaagregado
print "Hora Agregado " + horaagregado

respuesta = raw_input("Estos datos son correctos? introdusca solo (s/n): ")

if respuesta == "s":
 regsubida = Rsubida(subida = la_subida, fecha_agregado = fechaagregado, hora_agregado = horaagregado)
 regbajada = Rbajada(bajada = la_bajada, fecha_agregado = fechaagregado, hora_agregado = horaagregado)

 regsubida.save()
 regbajada.save()
 print "Registros de Subida y Bajada ALMACENADOS con Exito!"

else:
 print "Cancelado!!!"

#Algunas consultas
respuesta = raw_input("Deseas ver algunas consultas? introdusca solo (s/n): ")

if respuesta == "s":
 #Mostrando todos los registros de bajada en la coleccion
 for rbajada in Rbajada.objects:
 print "Bajada: " + str(rbajada.bajada)

 #Sumatoria de todos los registros de bajada :)
 print "Total datos Bajada: " + str(Rbajada.objects.sum("bajada")) + " MB"
 print "Total datos Subida: " + str(Rsubida.objects.sum("subida")) + " MB"
 tbajada = Rbajada.objects.sum("bajada")
 tsubida = Rsubida.objects.sum("subida")
 total = tbajada + tsubida
 print "Total Consumido: " + str(total) + " MB"

else:
 print "Cancelado!"

Como podemos ver en las primeras lineas del codigo, creamos dos clases llamadas Rsubida y Rbajada, estas clases contienen lo que es la estructura y tipo de datos de lo que contendran nuestros documentos. De esta forma podemos establecer un esquema predeterminado para la informacion que se almacenara en nuestra base de datos. Cabe destacar tambien que por cada clase que se crea, MongoEngine generara una coleccion correspondiente en la base de datos, por lo que en en este ejemplo nuestra base de datos contendra dos colecciones rsubida que contendra los registros de subida y rbajada que contendra los registros de bajada.

Consultas: Aqui esta la parte que mas nos interesa, si nos fijamos en todo el codigo, no vemos por ningun lado las funciones JavaScript Map/Reduce, esto es porque simplemente no las necesitamos para realizar especificamente las consultas que ya teniamos:

#Mostrando todos los registros de bajada en la coleccion
for rbajada in Rbajada.objects:
  print "Bajada: " + str(rbajada.bajada)

el ejemplo de salida de esta seccion del codigo seria algo como esto:

Bajada: 36.3
Bajada: 123.0
Bajada: 66.4

Esta seccion del codigo nos mostrara los registros de bajadas que estan contenido en el campo bajada, notese que en esta ocacion no nos devuelve un documento JSON con los datos solicitados (incluyendo su corchetes y comillas), sino que simplemente nos devuelve el valor en especifico.

La seccion del codigo con la que sustituimos las consultas map/reduce y su codigo en javascript es la siguiente:

print "Total datos Bajada: " + str(Rbajada.objects.sum("bajada")) + " MB"
 print "Total datos Subida: " + str(Rsubida.objects.sum("subida")) + " MB"

lo que nos devolvera algo como:

Total datos Bajada: 225.7 MB
Total datos Subida: 142.3 MB

Coo vez aqui estamos aprovechando una de los beneficios de usar un ODM, y usar el contenido de nuestra base de datos como si de simples objetos se tratasen ya que con simplemente elegir la clase Rbajada y seleccionando su atributo (variable) “bajada” y haciendo uso del metodo sum() podremos realizar la sumatoria de todo los registros de bajada en en la coleccion Rbajada. Todo esto sin usar map/reduce ni funciones javascript :P

Con esto podemos completar la aplicacion y mostrar el total consumido, es decir, la suma de los datos de subida con los datos de bajada.

tbajada = Rbajada.objects.sum("bajada")
tsubida = Rsubida.objects.sum("subida")
total = tbajada + tsubida
print "Total Consumido: " + str(total) + " MB"

los que nos muestra:

Total Consumido: 368.0 MB

Como vemos, un ODM nos puede facilitar mucho la vida y mejorar nuestras aplicaciones, ademas de acortar un poco el codigo ya que si se fijan. hay muchas menos lineas y mas funciones que la version anterior de la aplicacion que no usa MongoEngine.

Esta aplicacion planeo mejorarla cada vez mas mientras continue aprendiendo sobre Python y MongoDB por loq eu e puesto a disposicion su codigo en GitHub para los que quieran descargarlo o solo si les parece util. :)

Saludos y espero les sirva!

Ejemplos de consultas MapReduce en MongoDB

2011-01-12T00:00:00-04:30

Hace unos articulos atras les mostre un ejemplo de como podriamos usar Python y el driver PyMongo para almacenar informacion en MongoDB, el ejemplo que vimos fue mi aplicacion de RegistroDeTransferencias. Al final de dicho articulo explico como podriamos ver y consultar los datos almacenados usando la consola interactiva de MongoDB, pero… ¿y si queremos que sea la misma aplicacion que nos muestre algunas consultas?. Pues a eso vamos, en este articulo haremos que RegistroDeTransferencias nos muestre el total de datos de subida y bajada.

Para que nuestra aplicacion nos muestre esta informacion necesitamos crear dos funciones Map/Reduce escritas en JavaScript.

La funcion Map para los datos de subida seria algo como esto:

ms = Code("""function() {
 emit("Subida", this.subida);
 }""")

y su funcion Reduce seria algo como:

rs = Code("""function(k, v) {
 var i, sum = 0;
 for (i in v) {
 sum += v[i];
 }
 return sum;
 }""")

Nota Para que el metodo Code() que contiene las funciones Map/Reduce funcione es necesario hacer uso del modulo BSON e importar Code, por lo que al inicio del archivo debemos agregar lo siguiente:

from bson.code import Code

En la funcion Map (ms) lo que hara sera seleccionarnos todos registros del campo subida en nuestra coleccion y emitirlos como parametro VALUE, mientras que la funcion Reduce (rs) recibira como parametro en la KEY VALUE (v) los registros de subida que seleccionamos en nuestra funcion Map y a continuacio en una secuencia for, sumara todos los valores de subida existentes, lo que nos devolvera el total de subida.

Para ejecutar nuestras funciones Map/Reduce y hacer que nos genere y muestre la informacion que solicitamos debemos agregar en nuestra aplicacion lo siguiente:

print "Sumatoria de SUBIDA"
resultado = colsubida.map_reduce(ms, rs)

for subida in resultado.find():
	print subida

Como podemos ver, se elige la coleccion colsubida que contiene los registros de subida y a continuacion usamos el metodo map_reduce() pasandole como parametro nuestras funciones Map (ms) y funcion Reduce (rs). Luego de esto la recorremos en un for y mostramos el resultado.

De forma similar podriamos usar otra funcion Map/Reduce para mostrar el total de bajada, si modificamos el codigo de la aplicacion RegistroDeTransferencias y añadimos lo que hemos visto, nos quedaria algo como esto:

from pymongo import *
from datetime import *
from time import *
from bson.code import Code

print "Conectando al Servidor de Base de Datos Local..."
conexion = Connection() # Conexion local por defecto

#conexion = Connection("usuario:contraseña@servidor.com:27075/basededato") #Conexion a un servidor remoto

#creando/obteniendo un objeto que referencie a la base de datos.
db = conexion['bdregistrodetransferencias'] #base de datos a usar

#creando/obteniendo un objeto que referencie a la coleccion.
colbajada = db['bajada'] #coleccion con registros de bajada
colsubida = db['subida'] #coleccion con registros de subida

#solicitando los datos de subida y bajada
la_subida = float(raw_input('Introdusca la cantidad de datos Enviados: '))
la_descarga = float(raw_input('Introdusca la cantidad de datos Recibidos: '))

# obteniendo la fecha, hora y almacenandolas en variables.
fecha = date.today()
fecha_agregado = fecha.strftime("%d-%m-%y")
hora_agregado = strftime("%I:%M %p")

print "Los datos ingresados son:"
print "Subida: " + str(la_subida)
print "Bajada: " + str(la_descarga)
print "Fecha Agregado " + fecha_agregado
print "Hora Agregado " + hora_agregado
respuesta = raw_input("Estos datos son correctos? introdusca solo (s/n): ")

if respuesta == "s":
#creando el diccionario con los documentos de subida y bajada
 registrobajada = {"bajada": la_descarga, "fecha_agregado": fecha_agregado, "hora_agregado": hora_agregado}
 registrosubida = {"subida": la_subida, "fecha_agregado": fecha_agregado, "hora_agregado": hora_agregado}

#insertando los datos en la BD
 colbajada.insert(registrobajada)
 colsubida.insert(registrosubida)
 print('Documento Guardado con EXITO!')

else:
 print "Cancelado!!!"

respuesta = raw_input("Deseas ver la sumatoria de subida/bajada? (s/n): ")
if respuesta == "s":
 ms = Code("""function() {
 emit("Subida", this.subida);
 }""")

 rs = Code("""function(k, v) {
 var i, sum = 0;
 for (i in v) {
 sum += v[i];
 }
 return sum;
 }""")

 mb = Code("""function() {
 emit("Bajada", this.bajada);
 }""")

 rb = Code("""function(k, v) {
 var i, sum = 0;
 for (i in v) {
 sum += v[i];
 }
 return sum;
 }""")

 print "Sumatoria de SUBIDA"
 resultado = colsubida.map_reduce(ms, rs)

 for subida in resultado.find():
 print subida

 print "Sumatoria de BAJADA"
 resultado = colbajada.map_reduce(mb, rb)

 for bajada in resultado.find():
 print bajada

else:
 print "Cancelado!!!"

Al ejecutar la aplicacion y responder afirmativamente a la pregunta “Deseas ver la sumatoria de subida/bajada? (s/n): “ veremos algo similar a esto:

Deseas ver la sumatoria de subida/bajada? (s/n): s
Sumatoria de SUBIDA
{u'_id': u'Subida', u'value': 126.10999999999999}
Sumatoria de BAJADA
{u'_id': u'Bajada', u'value': 805.0}

Como vemos, no es muy dificil realizar consultas Map/Reduce en MongoDB, aunque comparandola a como lo haciamos en CouchDB es un tanto mas largo y posiblemente engorroso.

Lo bueno de esto es que, esta misma consulta podriamos realizarla tal cual, hacer que nos devuelva unicamente solo numeros y no un documento JSON ({u’_id’: u’Subida’, u’value’: 126.10999999999999}) si usamos un ODM :D y lo mejor, sin usar funciones Map/Reduce lo que hara tambien que nuestra aplicacion tenga menos lineas de codigo… Pero esto se los mostrare proximamente :P

Saludos y espero les sirva!.

Instalando RockMongo interfaz de administracion web para MongoDB

2011-01-11T00:00:00-04:30

En el mundo de las bases de datos relacionales, una de las formas mas usadas para administrar una base de datos es usando una interfaz web, esto sobretodo si el usuario no cuenta con un acceso shell a su cuenta de hosting. En las bases de datos relacionales por lo general se usa aplicaciones escritas en PHP como phpMyAdmin para MySQL y phpPgAdmin para PostgreSQL.

Bien en el mundo de las bases de datos NoSQL hay aplicaciones web similares, una de ellas es RockMongo la cual esta escrita en PHP y posee una interfaz bastante intuitiva y un tanto similar a phpMyAdmin. Instalar RockMongo es sumamente sencillo y al estar escrita en PHP lo unico que requerimos es tener instalado y corriendo un servicio web como Nginx, Apache o similares, el lenguaje PHP y el driver correspondiente para accesar a MongoDB desde PHP.

Bien por suerte hace unos dias explique como instalar Nginx con soporte PHP5 en Ubuntu, por lo que siguiendo dicho articulo tendremos mas de medio camino listo! (¡Todos mis articulos estan friamente calculados! jajajaja :P ). Nos queda nada mas instalar el driver PHP para MongoDB y descargar e instalar RockMongo.

Instalando el Driver MongoDB y PHP: Bien para instalar este driver tan solo abrimos una terminal y escribimos en ella:

sudo pecl install mongo

esto nos instalara el driver para poder acceder a MongoDB desde PHP, ahora debemos configurar nuestro archivo php.ini y agregar la siguiente linea:

extension=mongo.so

Nota: si seguiste mi articulo sobre como instalar Nginx con soporte PHP5 en Ubuntu, en la carpeta /etc/php5 encontraras varios archivos php.ini, el que debemos editar sera aquel que se encuentre dentro de la carpeta fpm, es decir la ruta del archivo seria algo como /etc/php5/fpm/php.ini ¿porque editamos especificamente este archivo? pues simple, porque siguiendo ese tutorial estamos corriendo PHP mediante FastCGI usando PHP5-FPM, de todos modos y si asi lo deseas, puedes agregar la linea en las demas archivos php.ini sin problemas.

luego de editar el archivo php.ini debemos reiniciar PHP5-FPM para que los cambios tengan efecto:

sudo service php5-fpm restart

Ahora nos queda instalar RockMongo, para esto tan solo debemos descargar la ultima version desde la pagina oficial. Al momento de escirbir esto la ultima version es la 1.0.11 con buenas mejoras como traduccion al Español, insertar y modificar documentos en formato JSON (en versiones anteriores habia que escribir los documentos en arrays PHP).

una ves descargardo, lo descomprimimos y obtendremos una carpeta llamada rockmongo la cual debemos copiar en la raiz de nuestro servidor web, en nustro caso debemos copiar dicha carpeta en /var/www

Nota: recuerda que el directorio /var/www por lo general pertenece a root (administrador) por lo que necesitaras privilegios de administrador para copiar la carpeta rockmongo dicho directorio.

si lo deseas puedes abrir con tu editor favorito y ver el archivo config.php, encontraremos algo como esto:

$MONGO["servers"] = array(
 array(
 "host" => "localhost", // Replace your MongoDB host ip or domain name here
 "port" => "27017", // MongoDB connection port
 "username" => null, // MongoDB connection username
 "password" => null, // MongoDB connection password
 "auth_enabled" => true,//Enable authentication, set to "false" to disable authentication
 "admins" => array(
 "admin" => "admin", // Administrator's USERNAME => PASSWORD
 //"iwind" => "123456",
 ),

como ves, RockMongo nos permite configurarlo para conectarse a instancias locales o remotas de MongoDB, asi como tambien ver y cambiar los datos de usuario y contraseña del admin para iniciar sesion en Rockmongo. Si dejamos el archivo tal como esta, rockmongo se conectara a nuestra instancia local de mongodb y usaremos para iniciar sesion em rockmongo el nombre de usuario “admin” y contraseña “admin”.

Bien ya tenemos instalado y configurado RockMongo y ya podemos comenzar a usarlo, tan solo debemos ingresar en nuestro navegador y escirbir en la barra de direcciones:

http://localhost/rockmongo

luego de loguearte como admin veras algo como esto:

Nota: es probable que al teclear esta direccion en el navegador no veas nada o veas un error, es posible que requieras darle los permisos de lectura-escritura-ejecucion necesarios a la carpeta rockmongo y sus archivos.

tecleando el comando estando ubicado en /var/www:

sudo chmod 777 rockmongo/*

te podria sacar del apuro, pero ojo no es lo mas recomendable en un servidor.

Bien ya con esto tienes instalado y funcionando RockMongo por lo que ya puedes usarlo para “jugar” con MongoDB. Por supuesto este no es la unica interfaz de administracion para MongoDB, existen muchas otras como FangOfMongo la cual esta programada en Python y Django, pero en mis pruebas no me convencio mucho. Existen tambien phpMoAdmin la cual es bastante liviana y viene escrita en tan solo 1 archivo .php, pero la interfaz no me parece muy intuitiva, ademas de ser extremadamente simple. Si conocer las demas Gui de Administarcion ta solo visita la documentacion oficial de MongoDB.

Saludos y espero les sirva :D

Almacenando datos en MongoDB desde Python

2011-01-10T00:00:00-04:30

Mas NoSQL :D … luego de ver como almacenabamos informacion en CouchDB desde una aplicacion en Python, veremos como hacer lo mismo pero esta vez enviando los datos a una base de datos MongoDB.

Para este caso usaremos la misma aplicacion de RegistroDeTransferencias que programe anteriormente y que almacena los datos en CouchDB, solo que esta vez modificare el codigo para que almacene la informacion en MongoDB. :P

Para poder conectar nuestras aplicaciones Python a MongoDB y que estas utilicen dicha base de datos NoSQL para almacenar la informacion necesitamos del driver correspondiente el cual se llama PyMongo. Para instalar el driver para python en Ubuntu lo haremos de forma similar a como lo hicimos con CouchDB usando Easy_Install, para esto abrimos una terminal y escribimos:

sudo easy_install pymongo

Ya con esto tendremos instalado Pymongo y podremos comenzar a usarlo para que nuestras aplicaciones en python se conecten a MongoDB.

Como les decia, la aplicacion que usaremos en este ejemplo es mi aplicacion de RegistroDeTransferencias que programe anteriormente y que almacena los datos en CouchDB, pero luego de hacerle unos pequeños cambios pasara a almacenar la informacion en MongoDB. La aplicacion se compone de un simple archivo llamado rdtmongo.py y el codigo es el siguiente:

from pymongo import *
from datetime import *
from time import *


print "Conectando al Servidor de Base de Datos Local..."
conexion = Connection() # Conexion local por defecto

#conexion = Connection("usuario:contraseña@servidor.com:27075/basededato") #Conexion a un servidor remoto

#creando/obteniendo un objeto que referencie a la base de datos.
db = conexion['bdregistrodetransferencias'] #base de datos a usar

#creando/obteniendo un objeto que referencie a la coleccion.
colbajada = db['bajada'] #coleccion con registros de bajada
colsubida = db['subida'] #coleccion con registros de subida

#solicitando los datos de subida y bajada
la_subida = float(raw_input('Introdusca la cantidad de datos Enviados: '))
la_descarga = float(raw_input('Introdusca la cantidad de datos Recibidos: '))

# obteniendo la fecha, hora y almacenandolas en variables.
fecha = date.today()
fecha_agregado = fecha.strftime("%d-%m-%y")
hora_agregado = strftime("%I:%M %p")

print "Los datos ingresados son:"
print "Subida: " + str(la_subida)
print "Bajada: " + str(la_descarga)
print "Fecha Agregado " + fecha_agregado
print "Hora Agregado " + hora_agregado
respuesta = raw_input("Estos datos son correctos? introdusca solo (s/n): ")

if respuesta == "s":
#creando el diccionario con los documentos de subida y bajada
 registrobajada = {"bajada": la_descarga, "fecha_agregado": fecha_agregado, "hora_agregado": hora_agregado}
 registrosubida = {"subida": la_subida, "fecha_agregado": fecha_agregado, "hora_agregado": hora_agregado}

#insertando los datos en la BD
 colbajada.insert(registrobajada)
 colsubida.insert(registrosubida)
 print('Documento Guardado con EXITO!')

else:
 print "Cancelado!!!"

Como ven es una aplicacion super sencilla y basica, en este ejemplo yo separe los registros de subida y bajada en en dos colecciones subida y bajada almacenadas en la base de datos bdregistrodetransferencias de esta forma los registros en la base de datos quedan mejor organizados y nos ayuda a la hora de buscar o consultar un documento.

Para ejecutar esta aplicacion en la terminal tan solo tecleamos:

python rdtmongo.py

y veremos algo como esto

Si nos vamos a la consola interactiva de MongoDB y nos movemos a la base de datos bdregistrodetransferencias:

use bdregistrodetransferencias

podremos ver las colecciones tecleando en la terminal:

show collections

tambien podremos ver todos los documentos de la coleccion subida y bajada teclando:

db.subida.find()

db.bajada.find()

respectivamente, lo cual nos devolvera algo como esto:

{ "_id" : ObjectId("4d2150de5ff0885b8b000001"), "subida" : 2.9, "fecha_agregado" : "03-01-11", "hora_agregado" : "12:00 AM" }
{ "_id" : ObjectId("4d2164dd5ff0887868000001"), "subida" : 7.02, "fecha_agregado" : "03-01-11", "hora_agregado" : "01:25 AM" }
{ "_id" : ObjectId("4d2221855ff0884395000001"), "subida" : 5.57, "fecha_agregado" : "03-01-11", "hora_agregado" : "02:50 PM" }
{ "_id" : ObjectId("4d22b1505ff08829ab000001"), "subida" : 11.4, "fecha_agregado" : "04-01-11", "hora_agregado" : "01:04 AM" }

Por supuesto podriamos ejecutar consultas simples para visualizar los datos de subida y bajada o consultas Map/Reduce para calcular un total de datos de subida o bajada consumidos, pero eso se los mostrare proximamente :D

Tambien has estado probando MongoDB ??? ya has realizado una aplicacion??? cuentanos tu experiencia con MongoDB!!!

Usos basicos de MongoDB Console

2011-01-09T00:00:00-04:30

Y seguimos con mas pruebas de NoSQL :D … Hace unos dias comentaba como instalar MongoDB en Ubuntu 10.10, ahora veremos algunos usos basicos de la consola de administracion que incluye MongoDB para almacenar informacion, hacer algunas consultas entre otras tareas administrativas.

Para acceder a la consola administrativa de MongoDB tan solo debemos escribir en la teminal:

mongo

esto nos devolvera:

MongoDB shell version: 1.6.5
connecting to: test

Al hacer esto ejecutaremos la consola de MongoDB la cual por defecto intenta conectarse a la instancia MongoDB local (en tu PC) por lo que conviene tener MongoDB ejecutandoce con anterioridad. Cuando arrancamos la consola de esta manera y sin parametros, la misma se conecta a una base de datos llamada “test” en la que podemos hacer nustras primeras pruebas, esto lo podemos comprobar ejecutando el siguiente comando:

db

lo cual nos devolvera el nombre de la base de datos en la qeu estamos la cual es test.

Creando/Usando una base de datos:

Para crear la nueva base de datos llamada “pruebas” tan solo debemos escribir el siguiente comando:

use pruebas

esto nos devolvera algo como:

> use pruebas
switched to db pruebas

Este comando creara la base de datos “pruebas” y nos movera hacia ella, una detalle en este comando es que si por ejemplo la base de datos ya existe, tan solo nos mueve hacia ella para poder usarla, en caso de no existir la base de dato, el sistema la crea.

Creando Colecciones e insertando documentos:

Como les comentaba en el articulo “instalando MongoDB en Ubuntu“ MongoDB es una base de datos del tipo documentos en la que almacena dichos documentos en una especie de agrupaciones conocidas como colecciones, estas colecciones vendrian siendo algo asi como las tablas en MySQL.

Para crear una coleccion llamada “prueba01” y y almacenar documentos en ella podemos usar el siguiente comando de ejemplo:

db.prueba01.insert({titulo: "Primera prueba", contenido: "Mi primera prueba de insercion de un documento"})

en donde:

prueba01 es el nombre de la coleccion donde se encuentra el documento.
{titulo: “Primera prueba”, contenido: “Mi primera prueba de insercion de un documento”} es el documento que estamos insertando en la coleccion.

Podemos añadir mas documentos en formato JSON con campos iguales o diferentes al que acabamos de añadir y estos seran almacenados sin ningun problema, justamente esta es una de las ventajas de las bases de datos NoSQL.

db.prueba01.insert({titulo: "Segunda prueba", contenido: "Mi segunda prueba de insercion de un documento", hora: "03:20 PM", fecha: "9/01/2011"})

Mostrar los documentos almacenados en una coleccion:

Para ver todos los documentos almacenados en nuestra coleccion prueba01 podemos usar el siguiente comando:

db.prueba01.find()

lo cual nos devolvera algo como esto:

{ "_id" : ObjectId("4d2a1f5f9d3ceffc299d0fad"), "titulo" : "Primera prueba", "contenido" : "Mi primera prueba de insercion de un documento" }
{ "_id" : ObjectId("4d2a223b9d3ceffc299d0fae"), "titulo" : "Segunda prueba", "contenido" : "Mi segunda prueba de insercion de un documento", "hora" : "03:20 PM", "fecha" : "9/01/2011" }

en nuestro caso solo hemos almacenado dos documento y esto es lo unico que nos muestra. pero si por ejemplo queremos ver solo un resultado podemos ejecutar el siguiente comando:

db.prueba01.findOne()

el cual nos devolvera algo como:

{
 "_id" : ObjectId("4d2a1f5f9d3ceffc299d0fad"),
 "titulo" : "Primera prueba",
 "contenido" : "Mi primera prueba de insercion de un documento"
}

Listando las bases de datos:

Si queremos obtener un listado de las bases de datos que estan en nuestra instancia MongoDB tan solo tecleamos:

show dbs

y esto nos mostrara las bases de datos que tenemos… en nuestro caso puede devolvernos:

> show dbs
admin
local
pruebas
test

Listando las colecciones en una base de datos:

Para obtener un listado de las colecciones almacenadas en la base de datos en la que nos encontramos podemos teclear:

show collections

el cual nos devolvera

>show collections
perros
prueba01

Consultas “super basicas”:

usando el comando db.prueba01.find() podemos realizar una consulta sencilla pasandole al metodo find() un parametro el cual sera un documento, este documento sera una especie de ejemplo de lo que queremos que sea buscado. Por ejemplo si queremos que se nos muestre el documento en donde esta contenida la Key/Value “hora” : “03:20 PM” podemos pasarle eso mismo como documento:

db.prueba01.find({"hora" : "03:20 PM"})

esto nos devolvera el segundo documento que añadimos hace un rato y en el cual contiene el campo hora : 03:20 PM:

> db.prueba01.find({"hora" : "03:20 PM"})
{ "_id" : ObjectId("4d2a223b9d3ceffc299d0fae"), "titulo" : "Segunda prueba", "contenido" : "Mi segunda prueba de insercion de un documento", "hora" : "03:20 PM", "fecha" : "9/01/2011" }

Por supuesto, esta es una consulta super basica, MongoDB incluye muchas maneras de realizar consultas de este tipo (pasando un documento JSON como parametro), pero uno de los metodos mas potentes es usando funciones Map/Reduce un tanto parecido a como se hace en CouchDB.

Eliminando documentos:

Para eliminar un documento podemos realizarlo de manera similar a como hicimos la consulta anterior, es decir pasar un documento JSON como parametro a una funcion, solo que en este caso la funcion se llama remove():

db.prueba01.remove({"hora" : "03:20 PM"})

Este comando nos elimino el documento que contenia el campo “hora” : “03:20 PM” de la coleccion. prueba a realizar la consulta anterior y veras que ya no aparece dicho documento en la coleccion.

Por supuesto MongoDB y su consola interactiva tiene muchas otras caracteristicas y funciones que requeririan un libro entero para ser explicada en detalle.

como complemento podemos usar el comando:

help

para visualizar un listado de comandos que podemos usar en la consola MongoDB.

Si deseas aprender mas sobre MongoDB visita:

Instalando Nginx con soporte PHP5 en Ubuntu

2011-01-04T00:00:00-04:30

Hace unos meses atras escribi un articulo en el que explicaba como Instalar Nginx en CentOS, en aquellos tiempos tenia el servidor dedicado con CentOS en el que hacia las pruebas. Ahora les paso a explicar como instalar el servicio web Nginx con soporte para PHP5 (a travez de PHP-FPM - Administrador de procesos FastCGI ) en Ubuntu 10.10 y asi tener un servidor web local para hacer pruebas con PHP, instalar algun CMS, instalar alguna interfaz de administracion para MongoDB :P , etc.

Para esto lo primero que debemos hacer es instalar Nginx tecleando en la terminal:

sudo aptitude install nginx

con esto tendremos el servidor web Nginx instalado y funcionando en Ubuntu. Lo podemos comprobar escribiendo en el navegador:

http://localhost

Es probable que veas un mensaje 404 Not Found y esto es porque en Ubuntu 10.10 el directorio raiz de Nginx por defecto es /var/www y alli no hay ningun index.html, sino que esta en /var/www/nginx-default . Para solucionar esto copia el contenido de este ultimo directorio en /var/www y entra de nuevo en http://localhost Ahora si veras la pagina de Bienvenida de Nginx.

Ahora debemos instalar PHP5, PHP5-FPM y algunos extras, mas para esto teclamos en la terminal:

sudo aptitude install php5-cgi php5-fpm php5-dev php5-curl php5-cli php5-imagick php5-sqlite php-pear

Con esto ya deberiamos tener instalado PHP5 y ejecutandose PHP5-FPM (PHP5 sobre FastCGI).

Ahora nos queda configurar un poco Nginx para que pueda dar soporte PHP sobre FastCGI

Para esto debemos abrir el archivo de configuracion de sitios en Nginx y modificarlo un poco, lo abrimos con Vim teclando:

sudo vim /etc/nginx/sites-available/default

y lo modificamos para que se vea como esto:

# You may add here your
# server {
#    ...
# }
# statements for each of your virtual hosts

server {

 listen   80; ## listen for ipv4
 listen   [::]:80 default ipv6only=on; ## listen for ipv6

 server_name  localhost;

 access_log  /var/log/nginx/localhost.access.log;

 location / {
 root   /var/www;
 index  index.php index.html index.htm;
 }

 location /doc {
 root   /usr/share;
 autoindex on;
 allow 127.0.0.1;
 deny all;
 }

 location /images {
 root   /usr/share;
 autoindex on;
 }

 #error_page  404  /404.html;

 # redirect server error pages to the static page /50x.html
 #
 #error_page   500 502 503 504  /50x.html;
 location = /50x.html {
 root   /var/www;
 }

 # proxy the PHP scripts to Apache listening on 127.0.0.1:80
 #
 #location ~ \.php$ {
 #proxy_pass   http://127.0.0.1;
 #}

 # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
 #
 location ~ \.php$ {
 fastcgi_pass   127.0.0.1:9000;
 fastcgi_index  index.php;
 fastcgi_param  SCRIPT_FILENAME  /var/www$fastcgi_script_name;
 include fastcgi_params;
 }

 # deny access to .htaccess files, if Apache's document root
 # concurs with nginx's one
 #
 location ~ /\.ht {
 deny  all;
 }
}

La parte mas importante de todo es el bloque location ~ .php$ … en el que se especifica como Nginx va a trabajar con FastCGI.

Una vez realizado esto reiniciamos Nginx con:

sudo service nginx restart

Para comprobar que Nginx trabaja perfectamente con PHP5 nos vamos al directorio /var/www y con nano agregamos el archivo info.php:

sudo vim info.php

en dicho archivo agregamos lo siguiente:

<?php
	phpinfo();
?>

Lo guardamos, cerramos y en el navegador escribimos:

http://localhost/info.php

si todo a ido bien veremos algo como esto:

Bien ya tienes instalado Nginx con soporte PHP5 mediante FastCGI (php5-fpm) :P

Ejemplos de vistas-consultas en CouchDB

2010-12-26T00:00:00-04:30

Continuando con mis practicas y articulos sobre CouchDB traigo ahora algunos ejemplos de vistas/consultas para mostrar nuestros datos almacenados, recordemos que en CouchDB las vistas se crean usando funciones escritas en el lenguaje JavaScript, aunque se puede usar otros lenguajes como Ruby, Python, etc mediante plugins.

Las vistas que crearemos a continuacion sera para consultar y organizar los datos almacenados por la aplicacion RegistroDeTransferencias la cual explique hace unos dias, por lo que recomiendo que primero sigas dicho articulo antes de continuar para que asi no estes tan perdido.

Como comentaba anteriormente cuando programaba la aplicacion de RegistroDeTransferencias, la misma almacenaba en CouchDB los datos de subida y bajada transferidos durante una sesion, ademas de almacenar tambien la fecha y hora.

Para crear vistas en CouchDB primero debemos ingresar en Futon, seleccionar nuestra base de datos y luego en el listbox “View” de la parte superior derecha seleccionar “Temporary view…” Una vez alli veremos una seccion llamada “View Code” la cual contiene dos cajas de textos, una llamada “Map Function” en donde escribiremos la mayoria de nuestras funciones Map para crear vistas, y otra caja de texto llamada “Reduce Function” en donde podremos escribir funciones Reduce que filtren, realicen operaciones u organicen mejor los datos seleccionados por las funciones Map, Estas funciones Reduce son opcionales y no son estrictamente necesarias a menos que algun caso especial las requiera. si te fijas bien ya esta escrito una funcion en la caja de texto Map, esta es uan funcion de ejemplo muy basica que luego de presionar el boton “Run” nos mostrara en el campo “Value” todos los documentos en la base de datos

Una vista sencilla que podriamos programar podria ser por ejemplo aquella en la que me muestre todos los registros de bajada organizado por fecha y hora. Esta vista la podriamos hacer escribiendo lo siguiente en el textbox de las funciones Map:

function(doc) {
emit([doc.fecha_agregado, doc.hora_agregado], doc.bajada);
}

Esta funcion nos devolvera algo como esto:

Como podemos ver, en el campo Key (llave) nos muestra la fecha y hora en la que se tomo el documento y en el campo Value (valor) nos muestra los datos de bajada para cada documento en la base de datos. de forma similar podemos crear una vista para mostrar los valores de subida. Esta funcion nos sirve por ejemplo para ver cuantos datos nos descargamos en X dia.

Una de las bellezas de CouchDB es que estas vistas podemos almacenarlas en la misma base de datos para asi consultarla cuando lo queramos sin necesidad de volver a escribir la misma funcion :D esto lo hacemos haciendo click en el boton “Save As…” y en “Desing document:” colocamos un nombre cualquiera que nos identifique el uso de esas consultas (algo asi como una categoria de consultas), por ejemplo: “vista_subida-bajada” y en “View Name:” colocamos el nombre de la vista que acabamos de escribir, por ejemplo: “bajada”.

Otro ejemplo de vistas que podemos crear es una en la que por ejemplo muestre unicamente los datos de subida (en el campo Key) y bajada (en el campo Value), esta vista la podriamos ver escribiendo lo siguiente en el campo Map Function:

function(doc) {
emit({Subida: doc.subida}, {Bajada: doc.bajada});
}

Esto nos devolvera algo como:

Como podemos ver se le a agregado la leyenda Subida y Bajada junto a los datos de subida y bajada para asi identificarlos mejor.

Bien hasta ahora hemos usado dos sencillas funciones Map pero ninguna combinada con una funcione Reduce, bien es hora de ver como son estas fuciones y un ejemplo de uso de las mismas. :D

Una vista que podriamos escribir usando funciones Map y Reduce podria ser aquella en la que nos muestre el valor total de datos de bajada, esto se haria por ejemplo selecionando todos los documentos con la llave bajada y luego haciendo una sumatoria de sus valores, la funcion Map seria algo como esto:

function(doc) {
emit("bajada", doc.bajada);
}

y la funcion Reduce seria algo como esto:

function (key, values, rereduce) {
return sum(values);
}

Esto nos mostrara algo como esto:

Como vemos solo nos devuelve una sola fila con la leyenda Bajada en el campo Key y en el campo Value nos muestra la suma total de los datos de bajada; 2.498Mb :O y mi plan es de 3000Mb estoy casi qeu sin internet :( LOL.

Este mismo ejemplo podemos usarlo para calcular el consumo total de subida.

Por ultimo podriamos hacer una modificacion a la ultima funcion para mostrar y calcular de una sola vez y en una misma vista los datos tanto de subida como de bajada :P

la funcion Map seria algo como esto:

function(doc) {
emit("subida", doc.subida);
emit("bajada", doc.bajada);
}

Y la funcion Reduce seria algo como:

function (key, values, rereduce) {
return sum(values);
}

Esto nos mostrara algo como:

Como podemos observar esto nos mostrara dos filas en la que vemos el total de datos de subida como el total de datos de bajada en el campo Value ademas de su respectiva leyenda en el campo Key.

Bien esto es todo por el momento pero no es para nada complejo ya que estas mismas vistas las podemos usar desde la aplicacion RegistroDeTransferencia para que sea desde ella misma donde hagamos las consultas previamente creadas y asi no tener que estar visitando Futon cada vez que queramos ver y consultar nuestra informacion en la base de datos, pero eso es algo en lo que estoy practicando y aprendiendo asi que por lo tanto se los muestrare en otra ocasion :D

Saludos

Programando una aplicacion de registrodetransferencias en Python y CouchDB

2010-12-23T00:00:00-04:30

Una de las ventajas de ser programador es que puedes escribir uno mismo sus aplicaciones para resolver un problema determinado que se tenga, y pues yo tenia un problema :D . Resulta que mi unica conexion a internet es mediante un Modem USB, estos modem vienen con un software que solo funciona bajo Windows (algunos funcionan en MacOS) que te permite llevar un registro de las transferencias de datos consumidas y asi saber cuando estas a punto de consumirte tu cuota mensual de datos. Pues como solo uso Linux estos registros los llevava era en notas (tomboy) escribiendo los datos de subida y bajada que consumia despues de desconectarme.

Este metodo que usaba me era un tanto engorroso y no era muy fiable ya que mas de una vez perdi algunas notas o las borraba accidentalmente. Luego de aprender las funciones mas basicas de CouchDB, Python y Couchdbkit se me ocurrio escribir una aplicacion de consola que me facilite el registro de mis transferencias y que los almacene en un entorno confiable.

Ya les e comentado como instalar CouchDB en Ubuntu y tambien como instalar Couchdbkit y programar la primera aplicacion basica, por lo que si todavia no has instalado Couchdb y/o no tienes instalado Couchdbkit deberas pasar por estos articulos antes de continuar.

Como les decia, esta aplicacion de RegistroDeTransferencias es super basica y no es nada del otro mundo programarla. Al igual que la aplicacion anterior de Lista de Contactos esta estara escrita en Python y usara el framework Couchdbkit para gestionar la conexion con la base de datos CouchDB.

Esta aplicacion que se ejecuta desde la terminal solicitara los datos de subida y bajada transferidos (en Mb), luego los mostrara para verificar que sean correctos y luego tras confirmar se almacenaran en CouchDB. Al verificar en Futon (la interfaz de Administracion web de couchdb) los documentos creados ademas de ver los datos de subida y bajada previamente introducidos, veremos la fecha y hora en la que se almaceno ese documento. Estos dos ultimos datos se obtienen automaticamente desde la PC usando los modulos time y datetime de Python. Esta aplicacion esta conformada por dos archivos: registrodetransferencias.py y registrodetransferenciasapp.py

El contenido de registrodetransferencias.py es:

from couchdbkit.schema import Document
from couchdbkit.schema.properties import *
class registrodetransferencias(Document):
subida = FloatProperty()
bajada = FloatProperty()
fecha_agregado = StringProperty()
hora_agregado = StringProperty()

Y el Contenido de registrodetransferenciasapp.py es:

#Importando los modulos necesarios
from datetime import *
from registrodetransferencias import registrodetransferencias
from couchdbkit import *
from time import *
print "Conectando al Servidor de Base de Datos..."
#Creando el objeto "Servidor" y colocando los datos de conexion
server = Server("http://usuario:contrasena@localhost:5984")
#Creando/Accesando a la base de dato (no tengo muy claro esto
#pero al parecer el metodo se encarga de verificar que la base
#de datos ya exista, si existe crea una session y se conecta
#si no existe crea la base de datos.
db = server.get_or_create_db("bdregistrodetransferencias")
la_subida = float(raw_input('Introdusca la cantidad de datos Enviados: '))
la_descarga = float(raw_input('Introdusca la cantidad de datos Recibidos: '))
print "Los datos ingresados son:"
print "Subida: " + str(la_subida)
print "Bajada: " + str(la_descarga)
respuesta = raw_input("Estos datos son correctos? introdusca solo (s/n): ")
if respuesta == "s":
#Asocia "Bookmark" a la base de datos (NPI LOL)
registrodetransferencias.set_db(db)
fecha = date.today()
#Los datos del documento a guardar.
registro = registrodetransferencias(
subida = la_subida,
bajada = la_descarga,
fecha_agregado = fecha.strftime("%d-%m-%y"),
hora_agregado = strftime("%I:%M %p")
)
print('Guardando el documento al Servidor CouchDB...')
#guargando el documento
registro.save()
print('Documento Guardado con EXITO!')
else:
print "Cancelado!!!"

Nota: no se mucho de programacion en Python (estoy aprendiendo) y tengo fallas en programacion orientada a objetos por lo que el programa puede contener errores o ser muy basico.

Como ven, es una aplicacion sumamente sencilla y facil de hacer muy similar a lista de contactos que se hizo en articulos anteriores. esta aplicacion podria ser mejorado por ejemplo si hacemos que el mismo programa tome los valores de subida y bajada de la PC y los almacene sin necesidad de que uno mismo los introdusca (similar a como se hace con la fecha y hora), pero todavia no encuentro la manera de hacer eso :-( .

Para ejecutarlo en la terminal tan solo escribimos en la misma:

python registrodetransferenciasapp.py

y veremos algo como esto:

Al ingresar en Futon para verificar los documentos creados veremos algo como esto:

Para visualizar de una forma sencilla en Futon los datos almacenados y/o calcular el total consumido podriamos usar las funciones Map/Reduce escritas en JavaScript, pero esto se los mostrare en otro articulo proximamente. :P

Si eres de los que no quieren tener una base de datos corriendo en su PC pero quieres probarla y aprender a usarla entonces estas de suerte ya que CouchOne y Cloudant ofrecen hosting Cloud de CouchDB Gratis!!! con lo que prodras tener una interfaz Futon online en donde administrar tus bases de datos.

Tambien has estado probando CouchDB ??? ya has realizado una aplicacion??? cuentanos tu experiencia con CouchDB!!!

Espero les sirva!!!

Instalando CouchDB en Ubuntu

2010-12-12T00:00:00-04:30

Desde hace un mes aproximadamente e estado leyendo sobre sistemas de bases de datos del tipo NoSQL, estos sistemas de bases de datos se estan poniendo de moda entre las grandes compañias que requieren alta escalabilidad y performance a bajo costo. Los sistemas de bases de datos NoSQL no son para nada similares a los sistemas de bases de datos Relacionales a los que estamos acostumbrado, en los Sistemas de Administracion de Bases de Datos Relacionales (RDBMS) se acostumbra a organizar los datos en forma de tablas las cuales contienen filas, columnas y un campo clave o ID por lo general autoincremental, ademas de que se usan esquemas de relaciones entre otras tablas.

Bien en los Sistemas NoSQL casi nada de esto existe, CouchDB es un sistema de bases de datos NoSQL que almacena la informacion en forma de documentos, estos documentos reflejan los datos en formato JSON, es decir organiza la los datos en Clave:Valor y no en tablas. Estos documentos JSON contienen una ID unica No-Incremental que puede ser autogenerada o que puede definir uno mismo.

Una de las ventajas de CouchDB frente a otros sistemas NoSQL del tipo documento es que incluye una interfaz web (FUTON) de facil manejo desde la que podemos administrar nuestras bases de datos, CouchDB ademas soporta accesibilidad por REST/HTTP por lo que podemos administrar nuestra base de datos mediante una URL. Otra de las ventajas de couchDB es el soporte de replicaciones del tipo Mestro-Esclavo, Maestro-Maestro y Replicacion incremental con deteccion/resolucion de conflictos bidireccional.

Un documento sencillo en CouchDB podria ser algo como esto:

"_id" : "ksjfhk65464f65g464f68465cx4665",
"_rev" : "1-6d4f654d5fv5fz3214fd45d45",
"Nombre" : "Angel",
"Nick" : "JamUnix",
"Web" : "www.jam.net.ve",
"Lenguajes_conocidos" : ["Vb.Net", "HTML5", "CSS3", "otros mas..."]

Para instalar CouchDB en Ubuntu y comenzar a “jugar” con el y aprender como funciona una base de datos NoSQL tan solo teclea en la terminal:

sudo aptitude install couchdb

Con esto tendremos CouchDB instalado y ejecutandoce en nuestra PC, para comprobarlo podemos ir a la terminal y mediante Curl teclear:

curl http://localhost:5984

lo que nos devolvera algo como:

{"couchdb":"Welcome","version":"1.0.1"}

CouchDB ofrece una interfaz web llamada Futon en la que podemos administrar las bases de datos, para entrar en Futon tan solo debemos abrir nuestro navegador y colocar la siguiente URL:

http://localhost:5984/_utils

Con lo que veras algo como esto:

Por ahora no hay mucha documentacion en Español sobre CouchDB, pero si te interesa aprender mas sobre este sistema puedes leer este primer y segundo articulo publicado en 4tic.com

Tambien puedes visitar la Wiki de CouchDB o leer la Guia en Ingles.

Pronto publicare mas articulos acerca de como crear documentos sencillos usando Futon, los usos con curl y un ejemplo de como conectar y almacenar datos usando Python y el Framework CouchDBKit.

Acelerometro y Ubuntu

2010-11-21T00:00:00-04:30

Hasta hace unas horas no sabia que podia usar el Acelerometro (lis3lv02d) que tiene mi laptop en Linux, tan solo sabia que lo usa en Windows la aplicacion HP 3D DriveGuard para proteger el disco duro en casos de una posible caida y golpe contra el suelo. Pero en Linux es posible sacarle provecho al acelerometro para algo mas que proteger el disco duro.

Una manera de saber que nuestra laptop posee un acelerometro es tecleando en la terminal:

cat /sys/devices/platform/lis3lv02d/position

si nos devuelve algo como:

(18,36,936)

entonces quiere decir que tenermos un acelerometro correctamente reconocido por Linux, el valor en (18,36,936) representa el eje X,Y,Z .

Buscando en google me encontre con un script en Bash el cual usa el acelerometro de la laptop para rotar las caras del cubo de escritorio de Compiz. el script en cuestion se encuentra en los foros de ArchLinux y fue escrito por el usuario SamoTurk.

Este script requiere que tengamos instalado el paquete wmctrl, por lo que si no lo tienes aun tendras que instalarlo tecleando en la terminal:

sudo aptitude install wmctrl

En realidad son dos script:

#!/bin/bash
# lis3lv02d-rotate
#
# Author: Samo Turk
#
# Released under GPLv3
COUNTER=0
while [  $COUNTER -lt 100 ]; do
sleep 2
POS=`cat /sys/devices/platform/lis3lv02d/position | awk -F , '{print$1}' | awk -F "(" '{print$2}'`
echo $POS
if [ $POS -ge 350 ]; then
./compiz-rotate-wmctrl left
elif [ $POS -le -350 ]; then
./compiz-rotate-wmctrl right
fi
let COUNTER=COUNTER+1
done

Este script lo guardaremos en un archivo llamado “lis3lv02d-rotate”

#!/bin/bash
#
# compiz-rotate-wmctrl - Rotate the cube using wmctrl
#
# Author: Shang-Feng Yang
# Released under GPLv3
VER="1.0"
function rotate() {
# The target face number (begins with 0)
TVPN=$(( $1 % ${NF} ))
# The X coordinate of the target viewport
TVPX=$(( ${TVPN} * ${WW} ))
# Change to the target viewport
wmctrl -o ${TVPX},0
}
function usage() {
echo -e "$(basename $0) v${VER}\n"
echo -e "Usage:\n"
echo -e "\t$(basename $0) {left|right|#}\n"
echo -e "\tWhere:\n"
echo -e "\t\tleft - rotate the cube to the left"
echo -e "\t\tright - rotate the cube to the right"
echo -e "\t\t# - rotate to #th face (begins with 0)\n\n"
echo -e "Author: Shang-Feng Yang "
echo -e "Released under GPLv3"
}
# The action to be performed. $ACT could be 'left' or 'right' to rotate
# left or right, accordingly. $ACT could also be the number of the face
# to rotate into.
ACT=$(echo $1 |tr '[A-Z]' '[a-z]')
[ "x$ACT" == "x" ] && { usage; exit 1; } || {
case $ACT in
left|right|[0-9]|[0-9][0-9])
;;
*)
usage
exit 1
;;
esac
}
# The informations about the desktop
INFO=$(wmctrl -d)
# The width of the desktop
DW=$(echo "${INFO}"| awk '{sub(/x[0-9]+/, "", $4); print $4}')
# The width of the workarea
WW=$(echo "${INFO}"| awk '{sub(/x[0-9]+/, "", $9); print $9}')
# The number of faces on the cube
NF=$(($DW/$WW))
# The X coordinate of the viewport
CVPX=$(echo "${INFO}" |awk '{sub(/,[0-9]+/, "", $6); print $6}')
# Current number of the face in all faces (begins with 0)
CVPN=$(( ${CVPX} / ${WW} ))
[ "$ACT" == "right" ] && {
ACT=$(( ${CVPN} + 1 ))
} || {
[ "$ACT" == "left" ] && {
ACT=$(( ${CVPN} - 1 ))
}
}
rotate ${ACT}

Y este segundo script lo guardaremos en un archivo llamado “compiz-rotate-wmctrl” en la misma carpeta donde esta el primer script luego le agregamos permisos de ejecucion a ambos archivos.

Para probar este script ejecutamos desde la terminal tecleando:

sh ./lis3lv02d-rotate

Ahora solo nos queda inclinar la laptop a la izquierda o derecha y el cubo de escritorio deberia cambiar en ese sentido similar a como lo muestra este video.

Otras de las utilidades que le posemos dar a el acelerometro es en los juegos NeverBall en el que podemos mover la esfera inclinando la laptop hacia los lados como se ve en este video.

Una tercera utilidad que encontre para el acelerometro es unirse al proyecto Quake-Catcher Network en el cual se usan las laptops con acelerometros como una especie de sismografos conectados a internet y asi detectar posibles temblores y terremotos en tu localidad, lamentablemente no todo el software que se necesita es soportado en Linux y al parecer solo esta disponible para Mac y Windows.

Por ultimo siempre podremos volver a la utilidad principal para la que el fabricante coloco el acelerometro en las laptops, es decir Proteger nuestro disco duro. En linux podemos usar el software HPfall el cual usara el acelerometro para detectar movimientos bruscos o caidas y proteger el disco duro en esas situaciones para asi evitar daños o perdida de datos.

Para instalar HPfall debemos agregar el repositorio del autor tecleando en la terminal:

sudo apt-add-repository ppa:pmjdebruijn/ppa

actualizamos la lista de paquetes

sudo aptitude update

ahora instalamos HPFALL

sudo aptitude install hpfall

Esto nos ejecutara un demonio en cada inicio el cual estara monitoreando junto con el acelerometro los movimientos para asi proteger el disco en caso de una caida.

Este software no tiene ninguna interfaz de configuracion, asi que no te sorprendas si estas buscando un icono en el menu aplicaciones y no encuentras nada, a fin de cuentas el HP 3D DriveGuard tampoco trae mucha cosa que se diga.

Me gustaria probar alguna otra utilidad pero de momento no encuentro mas, me gustaria un software en el que pueda ver en tiempo real los valores de X,Y,Z mientras muevo la laptop pero por ahora no e encontrado nada parecido mas que usar el comando cat /sys/devices/platform/lis3lv02d/position

Guia de restauracion del GRUB con Ubuntu

2010-11-13T00:00:00-04:30

Bueno el amigo Nejode lo a vuelto a hacer y nos a sorprendido nuevamente con otra de sus guias, hace unas semanas puso a disposicion la guia para conexiones a escritorios remotos, pero en esta ocasion nos ofrece una guia de Grub2 en la que nos explica como podemos usar Ubuntu para recuperar el Grub (gestor de arranque) en nuestro disco duro.

No es extraño que en ocasiones uno pueda perder el arranque de nuestro pc luego de una instalacion de Winxp/Vista/7 y este daño el arranque de nuestro Linux que ya teniamos en otra particion, pues bien si este es tu caso (o cualquien otro en donde hayas perdido el Grub o el arranque del sistema) entonces ya no tienes escusa para ponerte manos a la obra y recuperar tu sistema restaurando el Grub.

Nota: Esta guia se a publicado en JamUnix Blog con el permiso explicito del autor.

Entendiendo la notacion octal de los permisos de sistemas en Linux

2010-11-11T00:00:00-04:30

Si administras un servidor, una cuenta de hosting o usas una distro Linux es muy probable que en algun momento hayas tenido que cambiar los permisos a alguna carpeta o archivo. En sistemas Linux comunmente se usa el comando chmod seguido de un conjunto de letras y simbolos (notacion simbolica) o seguido de una cifra de 3 digitos (notacion octal), pero en ocasiones usamos estos permisos sin saber que significan o que estan haciendo realmente ya que copiamos el comando de alguna guia o pagina.

Bien en esta ocasion explicare un poco como es el funcionamiento de la notacion octal y como saber el significado de esos numeros que colocamos.

En primer lugar la notacion octal consiste en un conjunto de valores de 3 o 4 digitos en base 8. cuando escribimos un permiso en notacion octal de 3 digitos, cada numero representa un un componente de permisos a establecer.

Para saber que permisos le estamos asignando a un archivo o carpeta podemos valernos del significado de cada numero. por ejemplo:

4 - Lectura

2 - Escritura

1 - Ejecucion

La posicion de estos numeros en la cifra tambien tiene un significado, por ejemplo:

7 x x

La primera posicion en la cifra significa que ese permiso sera valido para el usuario (propietario del archivo o carpeta).

x 7 x

La segunda posicion en la cifra significa que ese permiso sera valido para el grupo.

x x 7

La tercera posicion en la cifra significa que ese permiso sera valido para el publico.

Si por ejemplo escribimos un comando como este:

chmod 421 archivo.txt

Lo que estariamos haciendo es:

Permitirle al dueño leer (abrir/ver) el archivo.txt
Permitirle al grupo escribir (editar) el archivo.txt
Permitirle al resto de los usuarios o el publico ejecutar el archivo.txt

Hasta aqui todo se entiende a simple vista, pero de seguro te estaras preguntando ¿como hacer si quiero que el usuario tenga permisos de lectura-escritura y permisos de solo lectura a los grupos y el publico? Pues bien muy facil, los valores octales pueden conbinarse (sumarse), veamos este ejemplo:

chmod 644 archivo.txt

Aqui estariamos combinando (sumando) el valor octal para el permiso de lectura y el valor octal para el permiso de escritura, los que nos daria como resultado 6 que seria igual a el permiso Lectura-Escritura. Al grupo y al publico se le asigna el valor octal 4 que seria el equivalente al permiso de solo lectura.

Otro caso podria ser este ejemplo:

chmod 750 archivo.txt

En este caso estariamos:

Asignandole permisos de lectura-escritura-ejecucion al usuario.
Asignandole permisos de lectura-ejecucion al grupo.
Quitandole todo los permisos al publico.

En este caso al la posicion correspondiente al publico se le asigna el valor “0” lo que significa que no se le esta dando ningun tipo de permisos, es decir el publico no puede ver/abrir archivo.txt, no puede escribir/editar en archivo.txt ni tampoco puede ejecutar archivo.txt.

Despues de ver esto ya no seria problemas leer o asignar permisos a un archivo o una carpeta tanto en tu pc con linux como en un servidor remoto o un hosting accesandi via FTP.

Espero les sirva tanto como a mi.

Guia de conexion de escritorios remotos en Linux

2010-11-04T00:00:00-04:30

De seguro muchos se han topado con la necesidad de conectarse remotamente con su PC para realizar alguna tarea sin estar frente a ella pero se han vuelto un ocho intentando lograr la conexion. es por esto que les traigo una buena guia escrita por el amigo Nejode Miembro del Grupo de Usuarios Ubuntu de Venezuela.

Con esta guia podran realizar la configuracion y conexion de escritorios remotos (VNC) usando entre dos PC usando Vino y Vinagre. Cabe destacar que la guia esta muy bien explicada por lo que de seguro no tendran problemas en realizar la configuracion. Nota: Esta guia se a publicado en JamUnix Blog con el permiso explicito del autor.

Montando particiones NTFS en Linux

2010-10-30T00:00:00-04:30

Esto es algo que ya hay en muchos blogs, foros, etc… pero lo coloco aqui en JamUnix Blog a modo de respaldo para tenerlo a mano cuando lo necesite ya que cuando instalo una nueva version de Ubuntu u otra distro como Debian o Arch Linux, siempre ando buscando como automontar mis particiones NTFS.

Bien comencemos, para automontar particiones usaremos la aplicacion ntfs-3g la cual nos facilitara mucho la tarea, por lo que lo primero que haremos sera instalarla tecleando en una terminal:

sudo aptitude install ntfs-3g

Luego de esto creamos una carpeta llamada “JamNTFS”en /media en la cual montaremos la particion NTFS. Por supuesto podemos colocarle el nombre que queramos a la carpeta.

mkdir /media/jamunixNTFS

Ahora debemos averiguar en donde se encuentra nuestra particion NTFS a montar, para ver esto tecleamos en la terminal:

sudo fdisk -l

Esto nos mostrara un listado de las particiones que tenemos, es algo similar a esto:

Dispositivo Inicio    Comienzo      Fin      Bloques  Id  Sistema
/dev/sda1   *           1          13      102400    7  HPFS/NTFS
La partición 1 no termina en un límite de cilindro.
/dev/sda2              13       25843   207478784    7  HPFS/NTFS
/dev/sda3           25843       31984    49324032   83  Linux
/dev/sda4           31984       38914    55663617    5  Extendida
/dev/sda5           31984       32233     1998848   82  Linux swap / Solaris
/dev/sda6           32233       38914    53663744   83  Linux

Como podemos ver tenemos 2 particiones NTFS sda1 y sda2, y la que yo configurare para que se automonte sera la sda2.

Para hacer dicho montaje de la particion /dev/sda2 en la carpeta /media/JamNTFS que ya creamos mas arriba, tecleamos en la terminal:

mount -t ntfs-3g /dev/sda2 /media/JamNTFS

Ya con esto tendremos montada nuestra particion NTFS.

Ahora haremos una configuracion mas para que se automonte la particion cada vez que iniciemos el S.O para esto editaremos el archivo fstab tecleando en la terminal:

sudo gedit /etc/fstab

y agregamos la siguiente linea al final del archivo:

/dev/sda2 /media/JamNTFS ntfs-3g defaults,locale=es_ES.UTF8 0 0

guardamos, cerramos y reiniciamos para ver al siguiente inicio nuestra particion NTFS montada de manera automatica.

Saludos y espero les sirva tanto como a mi.

Monitoreando nuestro sistema vigilando los archivos de registros logs.

2010-10-26T00:00:00-04:30

Los archivos de registros o archivos log como se conocen comummente, son archivos en donde se van almacenando un registro de todos los eventos que ocurren en un sistema durante un periodo de tiempo en particular. Estos archivos son usados tanto por el sistema operativo como por las aplicaciones o demonios (procesos) para registrar datos o informacion sobre un evento en particular. En un sistema Linux podemos encontrar estos archivos de registro o logs en la carpeta /var/log En esta carpeta encontraremos casi todos los archivos de registros de un sistema, pero cabe destacar que muchas aplicaciones crean estos archivos en sus propias carpetas fuera de /var/log.

Ahora bien, ¿En que nos sirve los logs para monitorear nuestro sistema? pues muy sencillo, los principales archivos logs que estan en la carpeta /var/log van almacenando informacion de casi todos los eventos que ocurren en tu PC practicamente desde que la enciendes y en ellos podremos ver por ejemplo que pasa internamente en Linux cuando conectas una Memoria USB, un Modem USB o cuando estas conectado a internet puedes ver los intentos de entrada bloqueados por tu firewall. En otras circunstancias podremos ser capaces de observar algun mensaje de error que se pueda producir cuando estas conectando algun hardware nuevo o si tienes un servicio web instalado podras ver quienes estan conectados a tu equipo.

Aqui en JamUnix Blog veremos algunos archivos Logs y sus usos:

/var/log/messages

Este es el archivo principal de registros y almacena la mayoria de los mensajes de interes.

/var/log/auth.log

Muestra mensajes sobre autenticacion de usuarios y permisos

/var/log/daemon.log

Muestra mensajes sobre demonios (permisos) o servicios corriendo en el sistema.

/log/dmesg

Muestra mensajes del nucleo Linux.

/var/log/dpkg.log

Muestra un registro de los paquetes binarios instalado.

/var/log/kern.log

Muestra mensajes del Kernel

/var/log/boot.log

Muestra mensajes referentes al arranque del sistema.

/var/log/debug

Muestra mensajes de depuracion.

/var/log/lpr.log

Muestra mensajes sobre la impresora

/var/log/mail.err

/var/log/mail.info

/var/log/mail.warn

/var/log/mail.log

Archivos varios que muestran mensajes sobre error, informacion, alertas y registro (respectivamente) para los correos (requiere tener un servicio de correos funcionando).

/var/log/mysql.*

Archivos varios de registro para el servicio mysql (requiere tener un servicio mysql).

/var/log/user.log

Muestra informacion acerca de los procesos usados por el usuario

/var/log/Xorg.0.log

Muestra registros de Xorg

/var/log/apache2/*

Archivos de registro varios que muestra informacion sobre el servicio web Apache (requiere tener apache instalado).

/var/log/lighttpd/*

Archivos de registro varios que muestran informacion sobre el servicio web Lighttpd (requiere tener instalado Lighttpd)

… Entre otros.

Por supuesto existen mucho mas archivos de logs, ya que muchos de los programas y aplicaciones que instales de seguro colocara su propio archivo de registro en /var/log o en su propia carpeta. Por ejemplo, si instalamos el gestor de paquetes Aptitude, podremos ver un buen logs de los paquetes que instalamos con el en el archivos /var/log/aptitude

Estos archivos tambien pueden variar dependiendo de la distribucion Linux que se use.

Un tips importante es que podemos ver estos archivos desde la terminal usando comandos como tail, cat, less o grep. un ejemplo podria ser tecleando en la terminal:

tail -f  /var/log/message

Con esto podriamos dejar abierta la terminal y detectar en tiempo real cualquier nuevo registro en el archivo log

Saludos y espero les sirva.

6 sencillas herramientas para monitoreo de red utiles.

2010-10-17T00:00:00-04:30

Desde hace unos meses para aca e estado leyendo un poco de las grandes posibilidades que ofrece la terminal y su gran poder para controlar y administar practicamente toda tu PC. Ultimamente e estado viendo aplicaciones y comandos para la terminal que me permitan ver y monitoriar las conexiones a internet por lo que les traigo aqui 3 comandos y 3 aplicaciones de terminal utiles para monitoriar tu red.

Aplicaciones:

Iptraf: Es una aplicacion basada en la terminal de estadisticas de red. tiene como caracteristicas el conteo de bytes y monitoreo de conexiones de paquetes TCP. Tambien ofrece estadisticas de las interfaces de red (eth0, ppp0, wlan0, etc) e indicadores de actividad, tambien nos muestra las interrupciones de trafico TCP/UDP.

Para instalarlo tan solo tecleamos en una terminal:

sudo aptitude install iptraf

y luego lo ejecutamos con:

sudo iptraf

Iftop: Escucha el trafico que hay en una interfaz de red y nos muestra en una tabla el ancho de banda consumido ademas del nombre de host remoto al cual estamos conectados y el puerto usado para la conexion.

Para instalarlo tan solo debemos teclear en una terminal:

sudo aptitude install iftop

y lo ejecutamos tecleando:

sudo iftop -i ppp0

Nota: cambie ppp0 por su interfaz de red. ejemplo: eth0 (cableada), wlan0 (inalambrica), ppp0 (modem), etc…

Ifstat: es una herramienta para informarnos sobre el ancho de banda de las interfaces de red muy similar a vmstat/iostat.

Para instalarlo tan solo ejecutamos en una terminal:

sudo aptitude install ifstat

y lo ejecutamos tecleando:

ifstat -i ppp0

Nota: cambie ppp0 por su interfaz de red. ejemplo: eth0 (cableada), wlan0 (inalambrica), ppp0 (modem), etc…

Comandos:

lsof

sudo lsof -i4

Segun el Man (Manual) de lsof, nos dice que este comando lista los archivos abiertos (de alli deriva su nombre: ls “listar”, o > de open y f > de file = lsof ) por lo que al ejecutarlo veremos una lista de las conexiones abiertas, que aplicacion, proceso o archivo la esta usando y tambien el puerto por el cual se realiza dicha conexion. Una salida de este comando mostraria algo similar a esto:

COMMAND    PID    USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
avahi-dae 1056   avahi   13u  IPv4   7319      0t0  UDP *:mdns
avahi-dae 1056   avahi   15u  IPv4   7321      0t0  UDP *:53814
dnsmasq   1214 dnsmasq    4u  IPv4   7595      0t0  UDP *:domain
dnsmasq   1214 dnsmasq    5u  IPv4   7596      0t0  TCP *:domain (LISTEN)
cupsd     1327    root    6u  IPv4   7752      0t0  TCP localhost.localdomain:ipp (LISTEN)
xchat     2805  usuario   14u  IPv4  22697      0t0  TCP Pc-Linux:43198->antonieta.freenode.net:8001 (ESTABLISHED)
pidgin    2807   usuario    9w  IPv4  24691      0t0  TCP Pc-Linux:59995->baymsg1.gateway.messenger.live.com:msnp (ESTABLISHED)
pidgin    2807   usuario   17u  IPv4  24548   0t0  TCP Pc-Linux:57466->1e100.net:xmpp-client (ESTABLISHED)

Para saber mas sobre este comando lee su manual tecleando en la terminal:

man lsof

netstat:

sudo netstat -lptu

netstat es un comando que nos puede mostrar las conexiones de red, tablas de enrutamiento, estadisticas de las diferentes interfaces de red, conexiones enmascaradas entre otras funciones. Con la opcion -lptu en realidad le estamos diciendo a netstat que nos muestre multiples opciones de informacion (cada letra equivale a una opcion) por lo que en este caso le estamos pidiendo que liste los sockets abierto “l”, nos mueste los programas que estan usando esos sockets “p” y que sean mediante protocolos TCP “t” y UTP “u”

una salida tipica de este comando seria similar a esto:

Conexiones activas de Internet (solo servidores)
Proto  Recib Enviad Dirección local         Dirección remota       Estado       PID/Program name
tcp        0      0 *:domain                *:*                        ESCUCHAR    1214/dnsmasq
tcp        0      0 localhost.localdoma:ipp *:*                     ESCUCHAR    1327/cupsd
tcp6       0      0 [::]:domain             [::]:*                     ESCUCHAR    1214/dnsmasq
tcp6       0      0 PC-Linux:ipp          [::]:*                      ESCUCHAR    1327/cupsd
udp        0      0 *:mdns                  *:*                                 1056/avahi-daemon:
udp        0      0 *:domain                *:*                                 1214/dnsmasq
udp        0      0 *:53814                 *:*                                 1056/avahi-daemon:
udp6       0      0 [::]:mdns               [::]:*                              1056/avahi-daemon:
udp6       0      0 [::]:42850              [::]:*                              1056/avahi-daemon:
udp6       0      0 [::]:domain             [::]:*                              1214/dnsmasq

Para saber mas de este comando y sus posibilidades teclea en la terminal:

man netstat

ss -o

ss es un comando muy similar a netstat que nos sirve para investigar cualquier informacion acerca de los sockets y conexiones abiertas. ademas de volcado de datos.

Una salida tipica de este comando seria algo como esto:

State      Recv-Q Send-Q                Local Address:Port                         Peer Address:Port
ESTAB      0      0                                     127:xx:xx:xx:34123             69:xx:xx:xx:www
CLOSE-WAIT 1      0                                 127:xx:xx:xx:42456       69:xx:xx:xx:www
ESTAB      0      0                                     127:xx:xx:xx:59995             69:xx:xx:xx:msnp
ESTAB      0      0                                     127:xx:xx:xx:37673              69:xx:xx:xx:www

Para saber mas de este comando teclea en la terminal:

man ss

Saludos.

Exportar tus contrasenas de lastpass a keepassx

2010-09-14T00:00:00-04:30

Para los que no conocen LastPass es un servicio online gratuito que nos permite guardar las contraseñas de todas las paginas a las cuales estamos registrados y nos facilita la tarea de loguearnos o registrarnos en dichas paginas autorellenando los formularios. Y para los que no conoscan KeePassX es una aplicacion con caracteristicas similares a LastPass solo que este se ejecuta como aplicacion de escritorio y guarda las contraseñas en tu PC.

Para muchos paranoicos no les agrada mucho la idea de usar LastPass ya que este al ser un servicio gratuito y online esta propenso a ataques o a que los mismos creadores escudriñen en nuestras contraseñas (a fin de cuentas ellos son los que tienen acceso a esos datos). Por lo que si tu ya tienes unas cuantas contraseñas almacenadas en LastPass y deseas almacenarlas en tu PC podemos valernos del Script LastPass2KeePass que nos permite importarlas en .XML y exportarlas en KeePassX para administrarlas desde este ultimo y no desde LastPass.

Para hacer esto tan solo debemos descargarnos el Script haciendo click Aqui

Nota: articulo Actualizado el 22-02-2011, Salte al final para saber mas y luego continué a partir de aqui

Una vez descargado el script le damos permiso de ejecucion tecleando en la terminal:

sudo chmod +x lastpass2keepass.py

Ahora solo necesitamos exportar las contraseñas almacenadas en LastPast en un archivo, si por ejemplo usas el plugins de LastPass en tu navegador basta con hacer click en el icono Herramientas Exportar a Archivo CVS LastPass. Le colocas un nombre al archivo y lo guardas en la misma carpeta donde tengas el script LastPass2KeePass
Ahora nos vamos a la terminal y ejecutamos el script de importacion tecleando en la terminal:

sudo python lastpass2keepass.py contraseñasLastPass contraseñaskeepass.xml

Donde:

contraseñasLastPass : Es el nombre del archivo donde estan las contraseñas exportadas desde LastPass.
contraseñaskeepass.xml : Es el nombre que quieres que tenga el archivo con tus contraseñas convertidas a formato XML de KeePassX.
Ahora tan solo debemos Importar las contraseñas en KeePassX, para esto solo abrimos la aplicacion y nos vamos a Fichero - Importar desde… - KeePassX XML (*.xml) Y elegimos nuestro archivo exportado que en nuestro caso se llama contraseñaskeepass.xml

Ya con esto tendras tus contraseñas de LastPass almacenadas en KeePassX y desde ahora podras administrarla desde este ultimo teniendo la seguridad de que solo tu eres el que las puedes ver y tocar :-)

Actualizacion: 22-02-2011:

El repositorio en Github donde se encontraba la aplicacion lastpass2keepass.py ya no esta disponible a la fecha, por tal motivo copio a continuacion el codigo que compone la aplicacion:

# lastpass2keepass
# Supports:
# Keepass XML - keepassxml
# USAGE: python lastpass2keepass.py exportedTextFile
# The LastPass Export format;
# url,username,password,1extra,name,grouping(\ delimited),last_touch,launch_count,fav

import sys, csv, time, datetime, itertools, re # Toolkit
import xml.etree.ElementTree as ET # Saves data, easier to type

# Strings

fileError = "You either need more permissions or the file does not exist.""
lineBreak = "____________________________________________________________\n"

def formattedPrint(string):
 print lineBreak
 print string
 print lineBreak

# Files
# Check for existence/read/write.

try:
 inputFile = sys.argv[1]
except:
 formattedPrint("USAGE: python lastpass2keepass.py exportedTextFile")
 sys.exit()

try:
 f = open(inputFile)
except IOError:
 formattedPrint("Cannot read file: '%s' Error: '%s'"" % (inputFile, fileError) )
 sys.exit()

# Create XML file.
outputFile = inputFile + ".export.xml:

try:
 open(outputFile, "w").close() # Clean.
 w = open(outputFile, "aw")
except IOError:
 formattedPrint("Cannot write to disk... exiting. Error: '%s'"% (fileError) )
 sys.exit()

# Parser
# Create a csv dialect and extract the data to a reader object.
dialect = csv.Sniffer().sniff(f.read(1024))
f.seek(0)
reader = csv.reader(f, dialect)

# Create a list of the entries, allow us to manipulate it.
# Can't be done with reader object.

allEntries = []

for x in reader:
 allEntries.append(x)
allEntries.pop(0) # Remove LP format string.

f.close() # Close the read file.

# Keepass XML generator

# Add doctype to head, clear file.
w.write("<!DOCTYPE KEEPASSX_DATABASE>")

# Generate Creation date
# Form current time expression.
now = datetime.datetime.now()
formattedNow = now.strftime("%Y-%m-%dT%H:%M")

# Initialize tree
# build a tree structure
page = ET.Element('database')
doc = ET.ElementTree(page)

# Dictionary of failed entries
failed = {}

formattedPrint("DEBUG of '%s' file conversion to the KeePassXML format, outputing to the '%s' file."" %(inputFile,outputFile))

# A dictionary, organising the categories.
resultant = {}

# Parses allEntries into a resultant.
for entry in allEntries:
 try:
 categories = re.split(r"[/\\]",entry[5]) # Grab final category.
 for x in categories:
 resultant.setdefault(categories.pop(), []).append(entry) # Sort by categories.
 except:
 # Catch illformed entries
 # Grab entryElement position
 p = allEntries.index(entry) + 2
 failed[p] = [",".join(entry)]
 print "Failed to format entryElement at line %s" % (p)

# Initilize and loop through all entries
for category, categoryEntries in resultant.iteritems():

 # Create head of group elements
 headElement = ET.SubElement(page, "group")
 ET.SubElement(headElement, "title").text = str(category)
 ET.SubElement(headElement, "icon").text = "0" # Lastpass does not retain icons.

 for entry in categoryEntries:
 # entryElement information
 try:
 # Each entryElement
 entryElement = ET.SubElement(headElement, "entry")
 # entryElement tree
 ET.SubElement(entryElement, 'title').text = str(entry[4])
 ET.SubElement(entryElement, 'username').text = str(entry[1])
 ET.SubElement(entryElement, 'password').text = str(entry[2])
 ET.SubElement(entryElement, 'url').text = str(entry[0])
 ET.SubElement(entryElement, 'comment').text = str(entry[3])
 ET.SubElement(entryElement, 'icon').text = "0"
 ET.SubElement(entryElement, 'creation').text = formattedNow
 ET.SubElement(entryElement, 'lastaccess').text = str(entry[6])
 ET.SubElement(entryElement, 'lastmod').text = str(entry[7])
 ET.SubElement(entryElement, 'expire').text = "Never"
 except:
 # Catch illformed entries
 # Grab entry position
 p = allEntries.index(entry) + 2
 failed[p] = [",".join(entry)]
 print "Failed to format entry at line %d" %(p)

# Check if it was a clean conversion.
if len(failed) != 0:
 # Create a failed list.
 failedList = ["%d : %s" %(p, str(e[0]).decode("utf-8")) for p, e in failed.items()]
 formattedPrint("The conversion was not clean.")
 print "You need to manually import the below entries from the '%s' file, as listed by below." %(inputFile)
 formattedPrint("Line Number : entryElement")
 for x in failedList:
 print x

# Write out tree
# wrap it in an ElementTree instance, and save as XML
doc.write(w)
w.close()

print lineBreak
print "\n'%s' has been succesfully converted to the KeePassXML format." %(inputFile)
print "Converted data can be found in the '%s' file.\n" %(outputFile)
print lineBreak

Guardelo con el nombre lastpass2keepass.py y continue con el articulo debajo de la nota.

Existen dos fork en Github, el de harisdsv y el de anirudhjoshi, pero en las pruebas que realice, estos no me funcionaron a la perfección.

Saludos y Espero les sirva…

Vuela en internet usando una cache DNS - Dnsmasq en Ubuntu

2010-08-20T00:00:00-04:30

Desde hace unos meses para aca mi internet HSDPA ha estado presentando molestos inconveniente los cuales me obligan a recargar o solicitar las paginas mas de una vez para que estas puedan presentarse completamente y sin errores por lo que decidi usar una cache DNS con Dnsmasq para probar como puede esto ayudar a mi conexion y que las paginas cargen a la primera solicitud y sin problemas.

Dnsmasq es un servidor DHCP y DNS ligero y de bajo impacto para el sistema que nos permite usarlo cachear las peticiones DNS hacia internet que realiza nuestro computador pra resolver la IP de un dominio, de manera que cuando se desee accesar de nuevo a un dominio ya resuelto, no se tenga que volver a solicitar a los servidores DNS en internet sino que se resuelven en la misma PC ya que esta conoce de antemano la ip correspondiente.

Antes de instalar Dnsmasq vemos los tiempos aproximados que se tarda mi conexion en resolver la ip de un dominio:

Para instalar Dnsmasq tan solo debemos ejecutar en la terminal la siguiente orden, pero antes asegurese de tener activado los repositorios “universe”

sudo apt-get install dnsmasq

Luego de esto pasamos a configurar dnsmasq editando el archivo dnsmasq.conf tecleando en la terminal:

sudo gedit /etc/dnsmasq.conf

descomentamos y modificamos la linea que contiene:

#listen-address=

para que quede de esta manera:

listen-address=127.0.0.1

Luego de esto nos toca editar el cliente DHCP tecleando en la terminal:

sudo gedit /etc/dhcp3/dhclient.conf

y nos aseguramos que las siguientes lineas:

prepend domain-name-servers 127.0.0.1;
request subnet-mask, broadcast-address, time-offset, routers,
domain-name, domain-name-servers, domain-search, host-name,
netbios-name-servers, netbios-scope, interface-mtu,
rfc3442-classless-static-routes, ntp-servers;

esten descomentada y tenga la IP 127.0.0.1

Por ultimo nos toca editar el archivo resolv.conf y agregar la ip de nuestro servidor cache dns local tecleando en la terminal:

sudo vim /etc/resolv.conf

y colocamos nuestra IP local de primero en la lista de modo que quede similar a esto:

nameserver 127.0.0.1
nameserver 208.67.222.222
nameserver 208.67.220.220

por ultimo reiniciamos dnsmasq para que aplique la configuracion:

sudo /etc/init.d/dnsmasq restart

Por ultimo consultamos 2 veces el mismo dominio para ver el tiempo que se toma ahora ¿porque dos veces? la primera para que haga la consulta a internet y permitir que dnsmasq la almacene en cache y la segunda para que se realice la consulta de manera local ya que dnsmasq conoce ya la ip resultante y no se necesita hacer consultas al exterior.

como ven ahora es mucho mas rapido si se realizan consultas locales a dominios ya resueltos con anterioridad.

Saludos y espero le sirva.

Migrando tu blog Wordpress. Un Metodo mas

2010-03-15T00:00:00-04:30

Desde que empece este blog e tenido que aprender por mi cuenta y en ocasiones de mala manera la administracion, uso y configuracion de Wordpress. Una de las cosas que tube que aprender a hacer y que en un principio siempre me daban fallos al realizarlas es migrar el blog de hosting. Como ninguno de mis lectores saben y ya han podido leer aqui, hubo un tiempo en el que tenia innumerables problemas con mi anterior proveedor de hosting el cual me migraba a cada rato de servidor para intentar solventar la situacion. En esas migraciones el traslado del contenido del blog y la base de datos se hacia sacando backups con las herramientas del panel de control web cPanel y luego eran restauradas en el nuevo servidor, No se porque pero siempre me quedaba mal el blog luego de estas migraciones y restauraciones mediante cPanel.

Uno de los motivos de estos errores me di cuenta que era que al migrar la base de datos esta quedaba con la vieja ruta de la cuenta de hosting en donde estaba el contenido del blog en el servidor, por lo que en el nuevo servidor si esta ruta no era la misma, se terminaba el mundo.

Bien luego de esto y en otro proceso de migracion de servidor mas, me propuse hacerlo yo mismo y a mi modo y paso a explicar:

Primero que nada debemos realizar un respaldo de los archivos del blog, si tu blog esta en una carpeta podemos comprimir esta y descargarla para luego trasladarla al nuevo servidor. Esto lo podemos hacer por medio del cPanel con la herramienta “Administrador de Archivos” seleccionamos la carpeta con el contenido del blog y le damos a “Comprimir”

Luego de esto debemos sacar un respaldo a la Base de Datos del blog, esto lo podemos hacer usando el PhpMyAdmin que esta en el cPanel, dandole a la pestaña “Exportar” luego seleccionamos la base de datos en el recuadro del lado superior izquierdo y marcamos la opcion “SQL” en la parte inferior izquierda. Si deseamos comprimir la base de datos la comprimimos seleccionando cualquiera de los dos formatos disponibles y le damos a continuar. Esto nos iniciara la descarga de la base de datos de nuetro blog.

Antes que nada deberiamos verificar que en el nuevo servidor nuestro directorio home se llame igual que en el servidor anterior, esto en cPanel lo podemos verificar en el panel superior izquierda en donde dice “Directorio Home” si es el mismo podemos pasar a importar la base de datos en el nuevo servidor por medio de phpMyAdmin, de lo contrario debemos editar la base de datos como explico a continuacion.

Bien una vez descargada la base de datos pasamos a abrir el archivo .sql en tu editor de codigo favorito (si usas Windows y la base de datos es de unos cuantos megas no uses el blog de notas, simplemente no esta hecho para esto) y buscamos la linea en donde este la direccion de nuestro directorio home es algo similar a esto:

/home/usuarioviejoservidor/public_html/blog/

y cambiamos el nombre de usuario para que quede

/home/usuarionuevoservidor/public_html/blog/

una vez editada la base de datos guardamos los cambios y podemos proceder a importarla en el nuevo servidor por medio de phpMyAdmin seleccionando la pestaña “Importar” y luego agregando la ruta de la base de datos en nuestra pc por medio del boton “Browse” le damos al boton “Continuar”

si todo a ido bien deberiamos tener importada con exito la base de datos de nuetro blog en el nuevo servidor.

Ahora debemos importar en el nuevo servidor los archivos de nuestro blog, para hacer esto podemos subir el archivo comprimido por medio de nuestro cliente FTP favorito o tambien por medio de la terminal situandonos en la raiz de nuestra carpeta web publica (public_html o httpd o html) usando el comando “wget” de este modo:

wget http://www.tuviejohosting.com/archivos-blog.zip

una ves transferido los archivos al nuevo hosting debemos descomprimirlo, para esto podemos usar de nuevo el “Administrador de archivos” en el cPanel, seleccionamos el archivo compromido y le damos a la opcion “Extraer”

Bien ahora solo nos falta configurar la nueva conexion entre el blog y la base de datos, para esto debemos crear el usuario de la base de datos en el nuevo servidor y otorgarles sus respectivos privilegios, esto lo podemos hacer en el mismo cPanel en la opcion “MySql Basesde Datos”.

Como nombre de usuarios puedes usar los mismos que tenias en el anterior hosting, al igual que la contraseña (aunque es aconsejable cambiarla para mayor seguridad). Tambien en esta misma seccion del cPanel debemos añadir el usuario que acabas de crear a la base de datos que acabamos de importar para que este sea el que tenga privilegios de uso de esa base de datos en especifico.

Bien por ultimo ya solo debemos editar el archivo wp-config.php de nuestro blog y agregar los nuevos datos de conexion como el nombre de la base de datos, el usuario y la contraseña. Una vez listo tan solo debemos subirlo y remplazarlo por el que ya estaba en el nuevo hosting con la informacion del viejo servidor.

Bien para este momento ya deberia estar todo bien y funcionando correctamente, pero si como yo tienes las url de los permalinks (enlaces permanentes) personalizadas, deberas apuntar tu viejo dominio a el nuevo hosting y esperar a que los cambios en los DNS se rieguen por todo internet para poder ver correctamente el contendido del blog y para que puedan funcionar los enlaces. Esto por lo general dura como mucho unas horas o mas, pero tambien puede que este en mucho menos tiempo, asi que tan solo queda esperar y listo.

Saludos y espero que les haya servido tanto como a mi.

Instalando drivers Madwifi en Ubuntu - Atheros AR928

2009-12-14T00:00:00-04:30

Hace unas semanas atras estaba comentando que habia instalado Ubuntu 9.10 en mi laptop y que estaba intentando colocar el chip inalambrico en modo monitor para hacer auditorias wifi (contra mi router), Por fin e logrado instalar los drivers Madwifi para mi tarjeta inalambrica la cual es una Atheros AR5009 o como en la web de Madwifi se conoce como AR928X.

Despues de buscar un manual o explicacion para instalarlos, la verdad encontre demasiadas formas de hacerlo, ademas de 3 drivers distintos que podia usar (compat-wireless-2.6.31-rc7, madwifi-hal-0.10.5.6-r4100-20090929 y el madwifi-0.9.4-current) me fui por la explicacion de la pagina LinuxWireless e instale el driver madwifi-hal-0.10.5.6-r4100-20090929 ya que me parecio el mas completo de los tres (en realidad es el mas pesado 4.2Mb).

Para instalarlo solo:

Descague el Drivers desde el Snapshot de Madwifi
Luego Descomprimimos y abrimos la carpeta en la terminal

cd madwifi-hal-0.10.5.6-r4100-20090929

-Ahora compilamos.

$ sudo make

y ahora instalamos

$ sudo make install

con esto ya deberia de tener corrctamente instalado los drivers.

pero como ando buscando es colocarlo en modo monitor entonces instale el Aircrack-ng:

$ sudo apt-get install aircrack-ng

y configure la inalambrica en modo monitor en la terminal:

airmon-ng start wlan0

con esto deberia de haber activado el modo monitor, para comprobarlo teclee en la terminal:

iwconfig

el cual me devolvio algo como esto:

lo        no wireless extensions.
eth0      no wireless extensions.
wlan0     IEEE 802.11abgn  ESSID:&quot;Mi Router&quot;
 Mode:Managed  Frequency:2.437 GHz  Access Point: XX:XX:XX:XX:XX:XX
 Bit Rate=54 Mb/s   Tx-Power=20 dBm
 Retry  long limit:7   RTS thr:off   Fragment thr:off
 Power Management:on
 Link Quality=70/70  Signal level=-31 dBm
 Rx invalid nwid:0  Rx invalid crypt:0  Rx invalid frag:0
 Tx excessive retries:0  Invalid misc:0   Missed beacon:0

mon0      IEEE 802.11abgn  Mode:Monitor  Frequency:2.437 GHz  Tx-Power=20 dBm
 Retry  long limit:7   RTS thr:off   Fragment thr:off
 Power Management:on

notese que se agrego una nueva interfaz el cual se llama “mon0” esta es la interfaz que se utilizara para trabajar en modo monitor, capturar e inyectar paquetes.

solo resta ahora instalar algunas otras herramientas al gusto de cada quien, en mi caso aparte de Aircrack instale Kismet el cual me instalo a la vez el WireShark. Con este ultimo puedo usar la interfaz mon0 como interfaz de captura para (valga la rebusnancia ) capturar paquetes.

Espero que les sirva esta info tanto como a mi.

Saludos.