domingo, 20 de abril de 2014

¿Cómo elegir una distribución Linux?

He leído innumerables artículos que relatan cómo se debe elegir una distribución Linux, son artículos dirigidos generalmente a principiantes de dicho sistema, en base a estos artículos y en base a cierta experiencia usando GNU/Linux, pudiera dar algunos consejos al respecto. Para elegir una distribución en primera instancia se requiere estar consciente de que se trata en parte en el conocimiento de la persona y la experiencia con sistemas o software, otra parte en la comunidad que soporta la distribución, es decir, se pueden mirar varios puntos pero necesariamente el primer punto es el más importante.

Igualmente, quien se propone una meta u objetivo, puede conociendo o no una materia, asimilar el reto de entenderla, estudiarla y conocerla, es por eso que hago énfasis en que uno mismo es el punto esencial para elegir la distribución y cuánto tiempo se le dedicará para lograr obtener buenos resultados en el aprendizaje de un nuevo sistema a conocer.

Hoy en día, es muy sencillo interactuar con cualquier distribución Linux, todas tienen buenas comunidades de apoyo, foros, información que está al alcance de uno, además, todas las distribuciones ofrecen una instalación un poco más intuitiva que hace 20 años. Aun así, para elegir una distribución Linux, también se debe entender que será inicialmente romper paradigmas, Linux en un principio, fue diseñado y desarrollado como un experimento de laboratorio y aprendizaje de sistemas operativos, hoy en día, se ha convertido en una punta de lanza para el software, pero sigue siendo una herramienta de aprendizaje y constante rompimiento de paradigmas.

Mirando desde ese punto de vista, después vendrán los otros puntos que se requieren para comenzar a usar Linux, entre los que se encuentran:
  • Suite de oficina, todas tienen sistemas de oficina
  • Software equivalentes, la mayoría de los programas tienen su equivalente para Linux
  • Respaldo y soporte de comunidades, existen muchas comunidades de apoyo
  • Facilidad de instalación, la mayoría de las distribuciones tienen gestores de instalación
  • Soporte de hardware, hoy casi todas tienen sus controladores para cualquier hardware, pero igual se debe tener en cuenta ese detalle
Esos serían detalles que se complementan con la capacidad de uno en emprender la elección de la distribución, otros puntos serían la seguridad, la estabilidad, la sencillez; todas ofrecen cada una de esas opciones pero siempre y cuando uno tome parte en ello, es decir, cada sistema viene con una preconfiguración que poco a poco el administrador deberá ir incrementando, incrementando la seguridad, la estabilidad u optimización del sistema y la sencillez.

Claro está también, que se debe elegir una distribución acorde a la orientación o destino de dicha distribución, es decir, si el sistema será usado en un servidor, no recomendaría usar un Ubuntu u otra distribución que ciertamente facilitan las cosas pero que realmente están orientadas a un usuario final, PC de escritorio o persona que simplemente la querrá para jugar y aprender.

En esas bases de estabilidad es muy importante ser sincero y definir las distribuciones que son específicamente hechas para servidores, desarrolladores y administradores experimentados, en ese caso se tienen varias opciones y de las que yo elegiría en el siguiente orden serían:
  • Red Hat
  • Debian
  • CentOS
  • SuSE
Son distribuciones que específicamente están diseñadas para trabajos y cargas pesadas, orientadas a ser usadas en servidores y mantener una estabilidad, cada paquete o programa ofrecido por estas distribuciones están garantizados en su totalidad, además, cada comunidad o empresa que las respaldan, son organizaciones comprometidas con todas esas características que las hacen distribuciones robustas en el campo.

A pesar de todo esto, la persona que tiene esa pregunta constante e intrínseca: ¿por qué?; podrá interactuar con cualquier distribución, estudiarla y definir por cuenta propia cuál es la más adecuada, esa es la libertad que ofrece lo que conocemos como Software Libre. Muchas comunidades darán su opinión orientada a su distribución de preferencia, pero siempre se debe considerar la exigencia en uno mismo y necesidad que se requiere cubrir.

viernes, 11 de abril de 2014

Creación y herencia de modelos en OpenERP

Los modelos en OpenERP hacen referencia a tablas en la base de datos, son objetos que se crean desde un archivo .py, cuando creamos un módulo o aplicación personalizada en un entorno de OpenERP, generalmente se hace un patrón esquema que llevaría una estructura parecida a la siguiente:

mimodulo/
  |- demo/
  |- i18n/
  |   |
  |   '- es.po
  |- __init__.py
  |- mimodulo.py
  |- __openerp__.py
  |- report/
  |- security/
  |   |
  |   |- ir.model.access.csv
  |   '- mimodulo_sec.xml
  |- view/
  |   |
  |   '- mimodulo_view.xml
  |- wizard/
  '- workflow/
      |
      '- mimodulo_flow.xml

En el archivo mimodulo.py se pueden crear módulos nuevos con un esquema parecido al siguiente:

# -*- coding: utf-8 -*-
##############################################################################
#
#    Estudiantes, modulo estudiantes para mimodulo
#    Copyright (C) 2014 Satelite Guayana (http://estudiantes.es).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see .
#
##############################################################################

import time
from openerp.osv import fields, osv

class estudiar(osv.Model):
    _name = 'estudiantes.estudiantes'
    _description = 'Modulo para estudiantes'
    _columns = {
        'name': fields.char("Nombre",20),
        'apellido': fields.char("Apellido",20),
        'telefono': fields.char("Telefono",20),
        'email': fields.char("Correo electronico",50),
        'direccion': fields.text("Direccion",20)
   }

El nombre del modelo no necesariamente debe ser igual al nombre de la tabla que se está creando, si somos de habla hispana, podemos agregar en la cabecera del archivo la referencia:

# -*- coding: utf-8 -*-

Pero no significa que podamos escribir con acentos algún comentario, generalmente ocurren errores por ese detalle, esos acentos sólo podemos escribirlos en el archivo mimodulo.xml.

El caso para heredar modelos, simplemente significa heredar los campos de una tabla original y agregarle más campos que sean necesarios para adaptar la tabla a las necesidades del usuario, en dicho caso sería editar el mismo archivo mimodulo.py con un esquema parecido al siguiente:

# -*- coding: utf-8 -*-
##############################################################################
#
#    Estudiantes, modulo estudiantes para mimodulo
#    Copyright (C) 2014 Satelite Guayana (http://estudiantes.es).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see .
#
##############################################################################

import time
from openerp.osv import fields, osv

class estudiar(osv.Model):
    _inherit = 'res.partner'
    _description = 'Campos adicionales para estudiantes'
    _columns = {
        'seccion': fields.char("Seccion",20),
        'grado': fields.char("Grado que cursa",20),
        'plantel': fields.char("Plantel educativo",20),
        'direccion': fields.text("Direccion",20)
   }

En donde la única diferencia es el atributo _inherit, que se cambia por el atributo _name del esquema para crear un modelo nuevo. Una vez que se crea el contenido del archivo mimodulo.py, se debe agregar la referencia en el archivo __init__.py de la siguiente manera:

import mimodulo

Siempre se debe importar cada modelo o referencia de los mismos, con el nombre del archivo .py sin la extensión. Otro detalle bien importante es el orden del código en archivos de python y el estándar que usa OpenERP para la creación y asignación de valores en las variables.

jueves, 10 de abril de 2014

Maneras para crear menú en OpenERP

Existen varias formas para crear menú en OpenERP, una de las formas más fáciles, es a través de la misma aplicación mediante la interfaz gráfica, la forma más larga es a través de un archivo xml, la documentación oficial expresa estas maneras formales para crearlos, generalmente se hacen menú nuevos y se modifican menús que ya están creados por defecto en la aplicación.

Cuando se crea un menú, inicialmente no se ve en la aplicación al momento de compilar o restaurar los cambios, cada menú debe tener asociado una acción básica para que se pueda apreciar en el marco de la aplicación.

El esquema estándar para crear un menú desde archivo xml con la etiqueta menuitem es la siguiente:

<?xml version="1.0" encoding="utf-8"?>
<openerp>
    <data>
        <menuitem id="id_menu" name="Nombre Menú" parent="id_menu_padre"
                     action="id_accion" sequence="2"/>
    </data>
</openerp>

El otro esquema estándar para crear menú es con la etiqueta record, es la forma más larga pero la veo como la más completa:

<?xml version="1.0" encoding="utf-8"?>
<openerp>
    <data>
        <record id="id_menu" model="ir.ui.menu">
            <field name="name">Nombre Menú</field>
            <field name="action" ref="id_accion"/>
            <field name="sequence" eval="3"/>
            <field name="parent_id" ref="id_menu_padre"/>
        </record>
    </data>
</openerp>

Ambas maneras son válidas tanto para crear un menú nuevo como para modificar los parámetros de un menú. En los casos anteriores son menú que están asociados directamente con un menú principal, es decir, son submenú.

Para crear un menú principal, simplemente no se añade acción en el parámetro action, y si se ha realizado un menú con acción, se debe crear la acción respectiva para que el menú sea visible en la aplicación, el esquema completo sería algo parecido a lo siguiente:

<?xml version="1.0" encoding="utf-8"?>
<openerp>
    <data>
        <record id="id_accion" model="ir.actions.act_window">
            <field name="name">Esta es la ventana de acción</field>
            <field name="type">ir.actions.act_window</field>
            <field name="res_model">modulo.ventana_aplicacion</field>
            <field name="view_type">tree</field>
            <field name="view_mode">tree</field>
        </record>
        <record id="id_menu" model="ir.ui.menu">
            <field name="name">Nombre Menú</field>
            <field name="action" ref="id_accion"/>
            <field name="sequence" eval="3"/>
            <field name="parent_id" ref="id_menu_padre"/>
        </record>
    </data>
</openerp>

Se debe tener en cuenta que la lectura del archivo xml donde se escriben todos los cambios para desarrollar un menú, debe estar en orden, debido a esto, la acción debe estar siempre antes del menú. También se puede combinar la creación con una etiqueta menuitem con la acción respectiva.

Si el menú que se está creando es un menú padre, no se llena el campo action, de esta manera el menú queda por defecto en el panel principal de la aplicación.

miércoles, 9 de abril de 2014

Instalar OpenERP en Debian

Una de las maneras de usar OpenERP es bajando su programa fuente desde el sitio web oficial de dicha herramienta. Sin embargo, para quien usa Debian puede usar el repositorio alternativo de la aplicación que sería:

deb http://nightly.openerp.com/7.0/nightly/deb/ ./

Añadido en el archivo /etc/apt/sources.list se puede actualizar la lista de paquetes e instalar del modo tradicional en Debian:

aptitude update
aptitude install openerp

Una vez que se instala la aplicación, los archivos fuentes principales del programa y de los módulos están en la siguiente dirección:

/usr/share/pyshared/openerp

El archivo de configuración naturalmente se encuentra en el directorio /etc/openerp, igualmente su respectivo archivo de arranque, parada y reinicio desde /etc/init.d/openerp que se usaría tal como cualquier otra aplicación o servicio en cualquier distribución Linux, en Debian se administraría con su forma típica:

invoke-rc.d openerp start
invoke-rc.d openerp restart
invoke-rc.d openerp stop

Finalmente, una vez que se inicia el servicio, se podrá usar localmente desde el navegador web de preferencia con la dirección:

http://localhost:8069/

En el archivo de configuración /etc/openerp/openerp-server.conf se pueden cambiar los parámetros de configuración, tales como el puerto de conexión, ruta de módulos, entre otros.

martes, 25 de marzo de 2014

Configuración de Debian sobre portátil con disco SSD

Una de las tecnologías más recientes en el mercado son las portátiles Netbook, que tienen la característica de ser rápidas, ligeras y muy cómodas para trasladar; poseen disco de estado sólido (SSD) y la mayoría de los archivos se guardan en la nube, los discos traen poco espacio de almacenamiento, pero una ventaja es la velocidad de escritura y lectura en los mismos. Una de las que marcó la pauta fue la Google Chrome.

Estuve instalando Debian en una Samsung ATIV Book 9 Lite, con características básicas de:
  • Procesador Amd Quad-core 64 Bits (4 núcleos)
  • 4 GB en RAM
  • SSD de 128 GB
Inicialmente configuré las opciones del disco duro en el BIOS de la siguiente manera:
  • Boot seguro desactivado
  • Opción de UEFI activada
  • Soporte para discos SATA desactivada
Luego procedí a instalar Debian Jessie desde una unidad externa, reconoció la unidad sin problemas y el instalador también, todo el proceso fue tranquilo, terminó sin problemas, finalmente, cuando termina de instalar el grub, se debe hacer un artificio para que el sistema cuando se reinicie, logre arrancar sin problemas.

Inmediatamente después de la instalación del grub durante la instalación del sistema operativo, el gestor de instalación expulsa el CD de la unidad, se debe esperar sin continuar.

Se abre una shell alternativa bien sea con las combinaciones Ctrl + Alt + F2, una vez en la shell, se presiona Enter para que el sistema emita un prompt para escribir comandos.

Luego de que se tiene el prompt, se verifica en dónde se montaron las particiones creadas, por defecto deben montarse en un directorio temporal, en mi caso se montaron en el directorio temporal /target, quedó algo similar a lo siguiente:

/target/
/target/boot/efi
/target/home

Se debe crear un directorio alternativo:

mkdir /target/boot/efi/EFI/boot

Luego se copia el archivo /target/boot/efi/EFI/debian/grubx64.efi:

cp /target/boot/efi/EFI/debian/grubx64.efi /target/boot/efi/EFI/boot/bootx64.efi

Cuando se ha realizado este pequeño detalle después de la instalación, se puede reiniciar el sistema sin problemas para que el BIOS reconozca el gestor de arranque del sistema operativo e inicie.

Existe información bien detallada en éste enlace donde explican un poco la configuración del gestor de arranque para Debian en modelos de sistemas con soporte EFI/UEFI.

viernes, 14 de marzo de 2014

Configurando un repositorio svn en Debian

Recientemente, unos compañeros de trabajo y yo, decidimos hacer un repositorio sencillo para controlar versiones de desarrollo de programas, no somos expertos en subversion, y los archivos que queremos controlar las versiones en su mayoría, son módulos personalizados para OpenERP, inicialmente instalamos un equipo con Debian, luego sus configuraciones base, finalmente la herramienta subversion.

Instalación de subversion:

aptitude install subversion

Luego, creamos un directorio base provisional para crear dentro de este, un árbol base para el control de versiones, con el código fuente del sistema que queremos controlar por versiones:

mkdir /tmp/sistema
mkdir /tmp/sistema/branches
mkdir /tmp/sistema/tags
mkdir /tmp/sistema/trunk

Creamos un directorio base donde dejaremos el servidor de versiones:

mkdir /var/svn
svnadmin create /var/svn/repositorio

Este último comando genera un árbol interno con archivos de configuración y directorios que ordenan el sistema de forma que subversion clasifique los cambios y las versiones.

Copiamos todo el código fuente al directorio provisional, específicamente en el directorio trunk:

cp -r /home/felix/sistema/* /tmp/sistema/trunk/.

Posteriormente, importamos todo lo que está en el directorio provisional a nuestro árbol del repositorio nuevo:

svn import /tmp/sistema file:///var/svn/repositorio/sistema

Finalmente, cada desarrollador extrae con un checkout el código inicial para comenzar a desarrollar, para todo los demás procesos es cuestión de usar subversion como cliente.

En el árbol de configuración del repositorio, asignamos permisos a los usuarios y la seguridad del mismo. Existe un directorio llamado /config dentro del directorio raíz del repositorio, el cual posee los archivos de configuración básica, el archivo passwd que contiene la lista de usuarios y el svnserve.conf que contiene los parámetros básicos del repositorio incluyendo la llamada del archivo de usuarios.

Podemos usar los usuarios del sistema operativo cambiando la ruta por: /etc/passwd. También se debe considerar que los parámetros en svnserve.conf no deben tener espacios entre el nombre de la variable y su valor, es decir, debe quedar de la siguiente forma:

parametro=valor

La mejor documentación de la herramienta se puede conseguir aquí.

miércoles, 23 de octubre de 2013

Revisión de configuraciones de seguridad en Facebook

No soy adicto al Facebook, y es por eso que en el transcurso de esta semana dediqué un poco de tiempo para revisar las opciones de seguridad que dispone la plataforma, estuve indagando acerca de las publicaciones, si por ejemplo quiero que solo las vean mis amigos, pero inicialmente debemos ubicar los menúes de configuración, se tienen dos opciones.

Arriba a la derecha, la primera que es de privacidad de publicación, con un icono simulando a un candado:


En el menú se despliega unas opciones secundarias que explícitamente sugieren qué se puede hacer, con unas simples preguntas al usuario, es un menú muy intuitivo.

El segundo menú simulando un engranaje, se pueden realizar las configuraciones de privacidad, mis cosas que pueden ver los usuarios de Facebook, tanto amigos, amigos de mis amigos y otros, entre otras opciones, tal como la opción de quién puede realizar una búsqueda de mi perfil dentro de la plataforma Facebook.

En la imagen se muestra el resultado de la selección de la opción Biografía y configuración del etiquetado, en el panel lateral izquierdo, podrás de una manera específica, clasificar y restringir las publicaciones y los comentarios de dichas publicaciones, así como también, quién puede verlas y comentarlas.


La última revisión que realicé fue la de aplicaciones asociadas a la cuenta de Facebook, donde se guarda una lista de aplicaciones que utilizan la autenticación de la cuenta Facebook para realizar funciones específicas, por ejemplo, la aplicación Twitter se encarga de hacer un pequeño feed o alimento de Twitter en Facebook, es decir, las cosas que escribo en Twitter, inmediatamente se replican en Facebook, pero no de manera contraria.


También se pueden configurar los parámetros de uso de dicha aplicación, es bueno chequear siempre este tipo de configuraciones por mayor seguridad de tus datos en la red.

En cuanto tenga más ratos de revisar una que otra opción disponible en la plataforma de Facebook, iré publicando algún detalle, aunque realmente son sencillas e intuitivas las opciones, cualquier niño de diez años puede entenderlas y administrar su cuenta sin problemas.

Pero ante todo, lo más importante para proteger los datos y publicaciones, es tener en cuenta no publicar información sensibles o delicada, la plataforma Facebook no es nuestra, es de un tercero que administra tu información.