Linux Reporting

IBRIX - The Intelligent Network Fabric

2010-07-01T04:58:00.000-07:00

HP Adquiere IBRIX para Potenciar las Capacidades de Almacenamiento en Entornos Scale-Out. HP e IBRIX anuncian un acuerdo definitivo por el que HP adquiere IBRIX, proveedor de primera fila de software file serving de empresa que incluye protección de datos, funciones de alta disponibilidad y servicios de gestión de datos para instalaciones informáticas de altas prestaciones, cloud y scale-out extremos.

Con una escalabilidad de decenas de petabytes, las empresas pueden controlar el crecimiento masivo de los datos y acometer los desafíos que plantea el funcionamiento de las aplicaciones en los entornos más exigentes. La capacidad de gestión de datos de la suite de software Fusion de IBRIX también permite a las empresas ir añadiendo capacidad sin problemas a medida que vayan creciendo sus prestaciones o sus datos.

Mas adelante hablare extensamente sobre este software de "file Serving" implementado en la serie X9000 de HP.

HP Data Protector A.06.00

2010-06-04T04:10:00.000-07:00

HP Openview DataProtector es un software de gestión de backups que soporta copias de seguridad tanto a disco como a cinta. Está diseñado para simplificar las tareas de backup y recuperación de datos reduciendo los tiempos de realización a la menor ventana posible. DataProtector soporta distintos tipos de backups;

• Backup de sistemas completos
• Backup on-line de bases de datos (Oracle, SQL)
• Backup de ficheros abiertos
• Backups de desastre (zero-downtime backups).

Trabajando con SVC (SAN Volume Controller)

2010-04-28T08:29:00.000-07:00

SAN Volume Controller es un dispositivo que permite que los usuarios virtualicen su almacenamiento y ayuda a aumentar la utilización de capacidad existente, así como centralizar la administración de múltiples controladores en un ambiente SAN de sistema abierto. SAN Volume Controller también está diseñado para permitir que los administradores reasignen, escalen la capacidad de almacenamiento y realicen cambios en sistemas de almacenamiento subyacentes sin interrumpir las aplicaciones.

Las principales características de un Cluster SVC son:

- Cluster 8 Nodos dividido en 4 bloques de entrada salida (I/O Groups)
- Alta disponibilidad ya que normalmente cuenta con 2 Fabrics.
- 4 puertos/nodo = 32 puertos (16 en cada Fabric)
- Cada nodo Cluster tiene 2 puertos conectados a cada uno de los Fabrics.

La información suele estar estructurada de la siguiente forma:

Ejemplo de Estructura de la información:


Unidad    Definición
·······································································
MDISK      Volúmenes de discos presentados a las cabinas. Máximo 2TB 
MDGroup    Agrupación de MDISK bajo un criterio. 
Extents    Información Dividida en unidad mínima para presentar al SVC 
VDISK      Volúmenes que se presentan a los host.

Ejemplo Configruación I/O Groups por plataforma:


I/O Group Nodo SVC Plataforma
·······································································
IO-GROUP 0 SVC1:SVC7 Plataforma1
IO-GROUP 1 SVC2:SVC8 Plataforma2
IO-GROUP 2 SVC4:SVC10 Plataforma3 
IO-GROUP 3 SVC5:SVC11 Plataforma4

MDGS (Managed Disk Groups):


Mdisk Group Plataformas
·······································································
MDG1_Linux      Plataforma1 
MDG2_Win        Plataforma2 
MDG3_Vmware     Plataforma3
MDG4_Unix       Plataforma4

Proceso por pasos para identificar el I/O Group y MDisk correspondiente a un Host:

Accedemos al GUI del SVC a traves de ip: "IPSERVERSVC":9080.


· With Host [Work with host > Host]
     1 Seleccionas el Host para el que se desea obtener la información. 
        - En el menu desplegable “Show de VDisks Mapped to this host”
          - Pulsamos Go 

*En la tabla que resulta de pinchar en “Go”, podemos observar la columna I/O Group donde podemos ver el I/O Group al que pertenece el Host y la columna MDisk Group, donde nos dice el MDisk.

Proceso Asignación de Nuevos Vdisks (LUN's):


1.- Crear Vdisk (parámetros generales)
        - Mdisk Group desde el cual debe crearse 
        - Tamaño 
        - Nombre identificativo 
        - I/O Group (I/O por donde se enruta el trafico) 
* En la selección "set attributes" de la creación de un  vdisk no utilizamos UNIT DEVICE IDENTIFIER (UDI). 
* Cuando no añades ninguno te los selecciona todos para cuando sean unidades de tamaño considerable >10G. El efecto lateral es que te hace un stripping de todos los extents dentro de cada Mdisk, perteneciente a un MDG (Managed Disk Group). 

2.- Declarar el/los Host/s 
        - Cuando se trata de un host Nuevo 
        - Asignar uno o mas WWPN (World Wide Port Name) 

3.- Mapeado de volumen con host/s 
        - Vinculo entre los vdisk y los host. 
        - Numero Identificativo del vinculo = LUN ID o SCSI ID
          * Preferible hacerlo por SSH .

4.- Mapeado de volumen con host/s vía SSH
 # svctask (Comando tareas SVC) 
 # svcinfo (Información tareas SVC)
 
        Ejemplo Mapeado de Host:
        # svctask mkvdiskhostmap -force -host “hostname” (-scsi) (id_scsi)  
        *Una vez hecho, en el interfaz SVC fijarse en las UIDS de los VDISK creadas, 
         esto sera lo que enviaremos vía e-mail a los usuarios que solicitan las LUNS.

Continuara ...

Introducción a TSM (Tivoli Storage Manager)

2010-04-28T06:07:00.000-07:00

TSM es una solución orientada a la empresa que integra automáticamente backup de red, almacenamiento y recuperación administración del almacenamiento y recuperación de desastre. El grupo de productos Tivoli Storage Manager es ideal para los ambientes heterogéneos, y datos intensivos; soportando a 35 plataformas y a 250 dispositivos de almacenamiento a través de LANs, de WANs y de SANs, suministrando además protección para las bases de datos y aplicaciones de e-mail.

Un ejemplo de arquitectura:

Las mejoras de características para el servidor y el cliente explotan la tecnología Storage Area Network (SAN) y responden a la necesidad de acelerar las operaciones de backup y restauración. Tivoli Storage Manager utiliza bibliotecas compartidas SAN, dando a servidores múltiples la capacidad de compartir una biblioteca automatizada en una configuración Storage Area Network (SAN) de alto rendimiento.

La característica de transferencia de datos del cliente LAN-free reduce el tráfico de la red y mejora el ancho de banda haciendo copias de seguridad y restaurando datos desde discos attachados SAN o cintas de almacenamiento.

Antes de nada recordemos un poco los modelos de backup de almacenamiento:

Modelos de almacenamiento:

- Backup Full (Copia íntegra del host)
- Backup Incremental (varios tipos, mirando atributos)
- Backup Diferencial (cambios con respecto al primer día) *se utiliza sobre todo en bases de datos
- Backup Sintética (Syntetic) Sin la intervención del cliente problema.

* TSM utiliza siempre la Incremental (versión activa).

Dentro del un fichero “name_profile”.opt ENABLELANFREE=YES para LAN free Backup. Corre un servicio que se llama
TSM StorageAgent (/Tivoli/TSM/StorageAgent). El fichero dsmsta.opt de este directorio tiene que tener el siguiente parámetro: SERVERNAME= “NombreServidor”


# define server STA_Nombre (en el servidor TSM)
# dsmsta set storageserver serverpass=”password”…
-> Genera un fichero devconfig.out (incluye el servername en el dsmsta.out y un devconfig.txt)

Características TSM (Tivoli Storage Manager):

TSM se basa en un esquema cliente/servidor:

SERVIDOR

CLIENTE

BBDD

Recovery Logs

Planificador

ISC (interfaz administración)

CLI (linea de comandos)

GUI (Interfaz Gráfica)

CLI (línea de comandos)

Planificador (Scheduler)

Agente Lan Free

TDP (SQL, ORACLE, Storage Agent

* Management Console (Para ver todas las caracteristicas del Servidor TSM en GUI).

* La BBDD del TSM y el Recovery Logs son Críticos!!!, si por lo que sea se pierde, hemos perdido toda la información de backup y en principio no se podría recuperar. Se hace backup diario de la BBDD del TSM, que implica una limpia del Recovery Log.

El recovery_log tiene un límite máximo de 13 GB, si se pasa de ese tamaño se produce un error, de ahí que cada vez que se hace backup de la BBDD se limpie el log.

Si tuviéramos una carga de trabajo que generara más de 13GB en el recovery log, habría dos posibles soluciones: (A) Trabajar con dos TSM y separar la carga de trabajo. (B) Hacer más de un Backup de la BBDD al día (si estamos en esa situación, también tendríamos seguramente sobrecarga de trabajo en el servidor TSM).

Dispositivos de almacenamiento en TSM

- Tipos de dispositivos: Disco y Cinta.


# he “comando”         Ayuda Comando
# lsdev –cc tape       Listar discos TSM entornos Unix
# tsmdlst              Listar discos TSM entornos Win

- Primero tenemos que definirlos:

TSM ve drive y librerías. SA (Storage Agent) solo ve drives (Cintas).


# define library       Definimos la librería
# define path library  Camino hacia la librería
# define drive         Definimos un Drive
# define path drive    Camino hacia el drive

- Comandos query & select:


# q path d=f           Mostrar los PATH
# q devclass           Muestra clases de dispositivos
- mount retention Al terminar de escribir cuanto tiempo espero para desmontar (def 60s)
- mount wait  Espera un tiempo… (Mirar en help)
# q drive f=d          Muestra cintas con formato detallado
# q libvol             Muestra Todas las cintas dentro de la librería
# q vol                Muestra todas las cintas que tienen datos, estén donde estén.
# q stg                Query StoragePool (Todos los Storage Pool que existen)
# q opt                Opciones generales de tsm
# q act se=”search”    Mostrar lo que ha estado haciendo TSM (activity Log)
# q script             Muestra script que hemos creado en el sistema para TSM
# q sess               Sesiones activas en el server TSM
# q even **            Muestra todas las planificaciones de clientes
# q even * type=admin  Muestra planificaciones administrativas
# q node               Clientes que tenemos

# select * from libvolumes where status=’scratch’ (Muestra cintas con formato Scratch)
# select * from syscat.tables (Todas las tablas relacionadas con formato cintas)

- Cambios Físicos en la Librería:


# checkout             Sacar una cinta
# checkin              Meter una cinta
# update Library       Actualizar estado físico de la librería (nº cintas)

- Definir volúmenes o discos para TSM (Storage Pool Disco):


# define stg  Dispol
# define vol f:\TSMgroup\disk1.dsm f=100GB
# define vol f:\TSMgroup\disk2.dsm f=200GB

- Ejemplo Definir storage pool Discos:


# define stgpool “poolname” “poolclass”
# q stg
# define vol “poolname” “volname” formatsize=”format_size”
# q pr (ver procesos)
# q stg

- Como se pasan datos de un pool a otro:


#move data “Source_vol_name” “target_stgpool”

Reclamación  (Umbral 60%, Datos sueltos en cintas se pasan a 1)
Colocación  (Asignar cintas por Nodo o por Grupo)

- Monitorización TSM:


Lanzamos dsmadmc –console (modo consola, solo monitorización)

# actlog (activity Log)
# q act begin=”fecha”  search=”parámetro”

Políticas de Backups

- Políticas de Backup en TSM:

PD – Policy Domain  Nombre Dominio de Politicas (PD_Name)
 PS – Policy Set   Nombre de Configuración de Politica (PS_Name)
  MC – Management Class Clase de Mantenimiento (1 default, resto asignar) (MC_Name)
   BG – Backup Group  Grupo de Backup (Políticas de Copias con versiones activas de archivos)
        -> NOLIMIT  No utilizamos Versiones.
        -> DESTINATION  Nombre StoragePool de destino
        -> VEREXISTS  Cuantas versiones de ficheros mantengo (versiones activas)
        -> VERDELETE  Cuantas versiones de ficheros borrados mantengo (versiones inactivas)
        -> RETEXTRA  Número de días que permanece activo el archivo.
        -> RETONLY  Por cuantos días mantengo los archivos borrados.
        -> SERIALIZATION SHRSTATIC
                     SHRDYNAMIC
                     STATIC
                     DYNAMIC

AG – Archive Group         Grupo de archivado (Políticas de Copias Archivado con limite de días)
        -> DESTINATION  Donde Se archiva
        -> RETVER  Cuantos días pasan antes de borrar el archivado

Backup Base de datos TSM

El tamaño máximo del log es de 13GB. Debemos poner el log en un disco distinto a la base de datos. Existen dos modos de backup:


NORMAL   Backup Full (el log necesita menos espacio y el TSM no se cae)
ROLLFORWARD   Backup incremental último minuto  (el log necesita más espacio y TSM se cae si se llena)

# define dbvol   Definimos volumen de la base de datos
# q db    Muestra bases de datos
# q dbvol   Muestra volúmenes de bases datos
# q dbvol f=d   Muestra Detalladamente volúmenes bases de datos   
# define logvol   Definimos le volumen del log
# q log    Muestra Información log base datos
# q logvol   Muestra volúmenes de log de base datos
# q logvol f=d   Muestra detalladamente volúmenes de bases de datos.

# extend db   Se extiende la base de datos el tamaño que queremos 
# reduce db   Se reduce el tamaño de la base de datos en lo que le mostremos

- Opciones Volumen de Base Datos:


Capacidad disponible  Total de la capacidad de los volúmenes
Capacidad asignada  Capacidad que asignamos para la base de datos
Porcentaje de utilización Porcentaje de utilización actual
Máximo porcentaje utilización Definimos el máximo porcentaje que se puede usar
Máxima extensión  Límite cuanto podemos extender
Máxima reducción   Límite cuanto podemos reducir

Registro de Usuarios Clientes

- Registrar usuarios clientes de TSM:


#reg “name_client” PD_Unix  
        /usr/ AIX
        /opt/ other Unix/Linux Systems
            dsm.opt
      -Servername “Server1”
            dsm.sys
             -Nodename “nombre_cliente”
             -TpcServeraddres “IP_server”

#reg “name_client” PD_Windows
#dsm opt
        Nodename (Name_client) 
 Tpcserveraddres (Dirección Servidor)
# dsm nombre opt

Configurando Backups en Clientes:

Client Command Line( CCL) se encuentra:


Windows          Program Files/Tivoli/TSM/baclient
AIX   /usr/Tivoli/client/ba/bin

GUI (Web Client Interface) > http://x.x.x.x:1581


# dsm   Backup - Archive GUI Windows
# dsmj   Backup – Archive GUI UNIX

Restaurar Base Datos desde consola:

Cuando se va a realizar un cambio en los ficheros opt, debemos parar todos los servicios que se encuentran con: Ps –fe | grep dsm (dsm scheduler) y volver a lanzarlos. DsmCAD (Client Acceptor Daemon) Demonio que maneja el scheduler.


# dsmc restore db vol Restaurar la base de datos de TSM desde consola.

Ficheros importantes TSM:


dsmserv.opt  Configuraciones del servidor. (Mirar Guía de rendimiento para optimizar)
dsmserv.dsk  Almacena Dirección archivo configuración Servidor
volhist.out  TSM guarda todo su histórico de volúmenes.
devconfig.out  Histórico dispositivos TSM

Pasar datos de disco a cinta:


# Migrate STGpool “Volumen_Disco” “pool_Cinta”
# 
# 
# bk db
# bk volhist. out
# bk devconfig.out
# delete …

Catalyst

2010-04-16T05:19:00.000-07:00

Recomiendo este libro a todo aquel que se quiera iniciar en Catalyst web Framework. Catalyst utiliza MVC. ¿Que es esto?:

Es una metodología o estilo para construir aplicacines que divide la implementación en modelo, vista y controlador. el modelo es la representación de la información con el cual opera el sistema. La vista representa el modelo en un formato de salida para interactuar con el usuario (GUI). El controlador es la parte del sistema que responde a eventos del usuario e interactua con el modelo con la info de entrada.

En las siguientes anotaciones podrás encontrar varios métodos de instalación para ubuntu (apt-get / CPAN), creación de un proyecto, anotaciones sobre el Helper TTSite, Action Types, FormBuilder, Template toolkit y un ejemplo practico. Espero que os sirva de iniciación :)

Instalación Catalyst Apt-get:

    
 - libcatalyst-perl
 - libcatalyst-engine-apache-perl
 - libcatalyst-model-cdbi-perl
 - libcatalyst-modules-extra-perl
 - libcatalyst-modules-perl
 - libcatalyst-view-tt-perl

Instalación Catalyst CPAN:


 - Catalyst::Runtime
 - Catalyst::Devel
 - Task::Catalyst
 - Catalyst::Model::DBIC::Schema
 - Catalyst::View::TT
 - DBD::SQLite
 - DBIx::Class

# catalyst.pl evento -> crea una la carpeta evento con el contenido:


 .
 |-- Changes
 |-- Makefile.PL
 |-- README
 |-- evento.conf
 |-- lib
 |   |-- evento
 |   |   |-- Controller
 |   |   |   `-- Root.pm
 |   |   |-- Model
 |   |   `-- View
 |   `-- evento.pm
 |-- root
 |   |-- favicon.ico
 |   `-- static
 |       `-- images
 |           |-- btn_120x50_built.png
 |           |-- btn_120x50_built_shadow.png
 |           |-- btn_120x50_powered.png
 |           |-- btn_120x50_powered_shadow.png
 |           |-- btn_88x31_built.png
 |           |-- btn_88x31_built_shadow.png
 |           |-- btn_88x31_powered.png
 |            |-- btn_88x31_powered_shadow.png
 |           `-- catalyst_logo.png
 |-- script
 |   |-- evento_cgi.pl
 |   |-- evento_create.pl
 |   |-- evento_fastcgi.pl
 |   |-- evento_server.pl
 |   `-- evento_test.pl
 `-- t
     |-- 01app.t
     |-- 02pod.t
     `-- 03podcoverage.t

Ahora lanzamos el Server Catalyst:


 $ script/evento_server.pl -r                -> Ejecutamos el servidor de Catalyst.
 Navegador -> http://localhost:3000          -> Ver pagina bienvenida

Nuestra controladora creada está ubicada en lib/evento/Controller y desde allí vamos a crear todos los método necesarios para nuestra aplicación.


 $ scritp/evento_create.pl Controller registro       -> Creamos un controlador
 $ script/evento_create.pl View participante TTSite  -> Creación de vistas participante

Creamos la carpeta root/src/"participante" y el archivo de vita participante.tt2


 $ vim participante.tt2
 _________________________________________
 | root/src/participante/participante.tt2 \
 --------------------------------------------------------------------------
 1 *p* Hola: [% nombre %] */p*
 --------------------------------------------------------------------------

uso (*) en lugar de (<) y (>) para presentar el código sin que lo interprete.

Modificamos:


    | lib/evento/Controller/registro.pm \
    --------------------------------------------------------------------------
    30 sub saludo : Local {
    31     my ( $self, $c) = @_;
    32
    33     $c->stash->{template} = “participante/participante.tt2“;
    34     $c->stash->{nombre}   = “Joel Gómez“;
    35 }
    --------------------------------------------------------------------------

En nuestra subrutina saludo lo que estamos haciendo es diciéndole a Catalyst cual es la vista que va a usar para ese método y paso una variable llamada nombre para la vista.

Helper TTSite: encapsula los trozos de lógica correspondientes a la presentación y al acceso a datos y componentes que necesite una vista, haciendo que la vista permanezca de esta forma mucho más simple reutilizable y mantenible. La lógica de presentación se encarga de formatear datos a través de Template Toolkit para que sean visualizados en una página, mientras que el acceso a datos o componentes implica la obtención de datos. TTSite tiene como debilidad que no podemos incluir Javascript’s o Css’s de manera razonable a una vista en particular (digo razonable porque si tratan de incluirlo entonces éste quedará fuera de la etiqueta de nuestro html generado). Por tal motivo tendremos que hacer unas pequeñas y sencillas modificaciones al Helper.

Actions Types: Los Actions Types es la forma mediante el cual Catalyst puede leer a la URL en la Controladora para luego hacer Match con los métodos dentro de ella. Los diferentes Actions son los siguientes:


- Path

sub metodo : Path(’save’) { }
Hace Match con el método save de la controladora http://localhost:3000/controlador/save esta también se puede usar de forma relativa al controlador en uso sub metodo : Path(‘/save’) { }
Hace Match con http://localhost:3000/save

- Local

sub metodo : Local { }
Hace Match con http://localhost:3000/controlador/metodo no hace falta colocarle los argumentos

- Global

sub metodo : Global { }
Es similar a la anterior solo que nuestra URL es http://localhost:3000/metodo se ignora el nombre de la controladora

- Regex

sub metodo : Regexp(^save) { }
Este hace uso de expresiones regulares para hacer match con la URL de manera Global, el resultado puede ser el siguiente:

        http://localhost:3000/save
        http://localhost:3000/save_usuario
        http://localhost:3000/save_evento

- LocalRegexp

sub metodo : LocalRegexp(^save) { }
Igual que el anterior pero ahora de manera local, la URL puede ser

        http://localhost:3000/controlador/save
        http://localhost:3000/controlador/save_usuario
        http://localhost:3000/controlador/save_evento

- Private

sub metodo : Private { }
Este nunca hará Match por la URL, es decir, no se puede acceder a este método mediante la URL, es privado de la controladora.

- Building-in Actions Special

Estas son acciones predefinida por Catalyst, las cuales son: index, auto, begin, end y default

- index     -> Usuario coloca solo nombre de controladora: Ej, http://localhost:3000/controlador
- auto      -> Se ejecuta despues de begin justo antes de procesar el metodo que hace Match con URL.
- begin     -> Nombre de controlador identificado y antes de hacer Match con otro se ejecuta begin.
- end       -> Se le llama despues de hacer Match con el metodo pasado por URL y ejecutar contenido.
- default   -> Si no consigue hacer Match con un metodo se ejecuta default.

FORMBUILDER

Conceptos básicos

FormBuilder está diseñado para manejar todas las partes de una solicitud de un formulario CGI - generación, la presentación y la validación. Como tal, aplicaciones de FormBuilder generalmente se bucle vuelta sobre sí mismos. Es decir, usted tendrá una sola secuencia de comandos que, cuando se invoca, se hará cargo de toda la aplicación sólo basándose en los parámetros CGI.

FormBuilder utiliza un Object-Oriented llamada-estilo, pero no permita que le espantar. Uso es sumamente fácil, ya que hay sólo dos funciones que necesita saber acerca de. A lo largo de la documentación, nuestro objeto de FormBuilder siempre se identificarán como $form, y encontrará esto funciona igualmente bien en sus propios scripts.

Estos son los pasos básicos:


1.Crear un objeto de $form con CGI::FormBuilder->new()
2.Definir los campos de formulario con el $form->field() método.
3.Comprobación de si el formulario se presentó con $form->submitted y si es así, validar con $form->validate.
4.Obtener valores individuales mediante la $form->field() método, y hacer todo lo que usted necesita con los datos
  (actualizar una base de datos, etc.).
5.Si el formulario no fue presentado (o se produce un error de validación), imprimirlo utilizando los principales
  $form->render función.

Esto es lo que hay que! FormBuilder se hará cargo de la generación de HTML y JavaScript, diseño de tabla, validación adherencia, mensajes de error y así sucesivamente. Echemos un vistazo a una secuencia de comandos de FormBuilder básico.


    #!/usr/bin/perl

    use CGI::FormBuilder;

    @fields = qw(first_name last_name email phone);

    $form = CGI::FormBuilder->new(
             fields => \@fields,
        );

    if ($form->submitted && $form->validate) {
        # you would write code here to act on the form data
        $fname = $form->field('first_name');
        $lname = $form->field('last_name');

        print $form->confirm(header => 1);
    } else {
        print $form->render(header => 1);
    }

En primer lugar, definimos nuestros campos y crear un nuevo objeto de $form especificar esos campos (tenemos que barra diagonal inversa nuestra matriz de \@fields para que se pasa de una sola pieza). A continuación FormBuilder les lleva, crea etiquetas legibles para cada campo y todo lo pone espera en una tabla HTML automáticamente por el $form->render método. De hecho, FormBuilder títulos incluso el nombre de la forma que se basa en el nombre de la secuencia de comandos. (personal_info.pl se convierte en "Información personal").

Cuando el usuario golpea el botón de "Enviar", $form->submitted devolverá true, que en nuestro ejemplo anterior también causaría $form->validate para ejecutar (debido a la && en la instrucción if). Si ambos devuelven true, significa que se presentaron datos de forma válida, y, a continuación, puede hacer cualquier cosa que necesite hacer con esos datos.

Llegar a los datos del formulario es tan fácil como con el método de field() en una forma similar a la función de param() de CGI.pm. La función de field() tiene numerosos otros usos, como veremos más adelante.

Detener para un segundo y ver esto en acción. A continuación, compruebe que el HTML generado por esta aplicación antes de pasar al siguiente paso.

Guía básica de PERL

2009-10-28T12:07:00.000-07:00

Como buenos Administradores de sistems es hora de que os metáis en el fabuloso mundo de PERL, una herramienta imprescindible para todo buen administrador. He aquí una pequeña iniciación a este mundo, lo que podríamos denominar "guía básica de PERL", sacada de varios manuales y apuntes propios.

Iré añadiendo los ejemplos y actualizándola en la mayor medida que pueda. Podéis encontrarla siempre que la necesitéis en cursos online o al final del blog en "articulos destacados". Seguramente tenga muchas fallas, no dudeis en corregirlas en los comentarios. Espero que esta guía te muestre lo que buscas.

INDICE

1- TIPOS DE DATOS
- Datos escalares
- Datos Array
- Datos Hash
- Datos Booleanos
- Combinando datos escalares, arrays y hashes
- Funciones sobre datos Hashes

2- ESTRUCTURAS DE CONTROL
- Lógica de Perl
- Clases de estructuras
- Nomenclatura
- Operadores lógicos
- Preferencias en operadores lógicos
- Operadores de comparación
- Operador Triario
- Control de flujo

3- SUBRUTINAS
- Definición de subrutina
- Modismo @_
- Función return
- Función wantarray

4- EXPRESIONES REGULARES
- Operador m// (empareja)
- Operador s/// (substitución)
- Modificador '/x'
- Operador split
- Sentencias de Escape
- Conversión Perl cadena/numérica

5- VARIABLES
- Variable $!
- Variables sensibles al contexto
- Variables contextuales multitipo y multiestado
- La Variable $_
- Variables predefinidas en Perl
- Variables Privadas

6- FUNCIONES
- Depurador Perl
- substr
- index y rindex
- reverse
- length
- chop y chomp
- push y pop
- shift y unshift
- splice

7- MANEJO DE ARCHIVOS
- Lectura de Datos
- Lectura de Ficheros

8- MODULOS

1.- TIPOS DE DATOS EN PERL

Existen tres tipos de datos esencialmente en perl y algunos tipos de estructuras:

SCALAR: Pueden guardar un solo valor
$escalar

ARRAY: Guardan una colección de valores indexados por posición
@arreglo, $arreglo[2]

HASH: Guardan una colección de valores indexados por llave alfanumerica
%hash, $hash{llave}

CODE: Apuntan a codigo con nombre, funciones %func() o simplemente:
func()

FORMAT: Apuntan a definiciones de formato de salida
format Formato = (...)[7]

FILEHANDLE: Permiten el manejo de archivos o de directorios
FH

GLOB: Se refiere a cualquiera de los tipos de datos anteriores que tengan el mismo nombre despues del prefijo identificador:
*glob se refiere $glob, @glob, %glob, &glob, filehandle glob y formato glob

Algunos ejemplos de datos:

Datos Escalares: Una variable escalar puede almacenar un número, una cadena de caracteres o una referencia.

$n      = 42;     # Numero
$nombre = "juan"; # Cadena
$color  = 'rojo'; # Cadena

Las cadenas con comillas dobles permiten la interpolación de variables:

$a = 1;
print "$a";  # Imprime un 1
print '$a';  # Imprime $a

· Ejemplo: Variables seguidas de letras ("variable_letras.pl")

#!/usr/bin/perl

$que = "chuleta";
$n = 3;

print "Antonio comio $n $ques. \n";
print "Antonio comio $n ${que}s .\n";

Datos Array:

@puntuaciones = (32, 45, 16, 5);

Datos Hash:

%favorito = (
joe => 'rojo',
sam => 'azul',
);

Datos Booleanos:

$fruta = '0'; # Falso
$fruta = '5'; # Verdadero
$fruta = "5 mangos"; # Verdadero

Ejemplos: Valores Booleanos

$falso = 0; # el número cero
$falso = 0.0; # el número cero como flotante
$falso = '0'; # el ''string'' cero
$falso = ""; # el ''string'' vacío
$falso = undef; # el valor devuelto por undef

Si, específicamente, quiere asegurarse de tener un resultado 1/0
(como en el lenguaje C), necesita realizar el cálculo siguiente:

my $resultado_real = $resultado_booleano ? 1 : 0;

Combinando datos escalares, arrays y hashes

$puntuaciones[2] # un elemento de @puntuaciones
$favorito{joe} # un valor de %favorito

@puntuaciones[2, 3, 1] # tres elementos de @puntuaciones
@favorito{'joe', 'sam'} # dos valores de %favorito

El número de elementos en un array puede ser obtenido evaluando el
array en contexto escalar o con la ayuda del sigil $#. Éste último
da el índice del último elemento dentro del array, no el número de
elementos.

$numero = @amigos;
$#amigos; # el índice del último elemento en @amigos
$#amigos+1; # normalmente el número de elementos en @amigos,
# que es uno más que $#amigos porque el primer
# elemento tiene el índice 0, no 1

Funciones sobre datos hashes

# guarda en el array @nombres_de_clientes
# todas las claves del hash %direcciones
@nombres_de_clientes = keys %direcciones;

# guarda en @direcciones_de_email
# todos los valores de %direcciones
@direcciones_de_email = values %direcciones;

2.- ESTRUCTURAS DE CONTROL

Lógica de Perl

1 Cualquier cadena es true con la excepción de las cadenas "" y "0".
2 Cualquier número es true excepto el 0.
3 Cualquier referencia es true.
4 Cualquier valor undefined es false.

Perl tiene varias clases de estructuras de control.

* Control de ciclos: do, while, for, foreach, continue.
* Control de sentencias: if, else, unless, until, elsif.
* Control de flujo: goto, elsif, next, last, redo, return.

La nomeclatura ed estas estructuras deben de tener esta forma:

* Las CONDICIONES están rodeadas por paréntesis () y
* Los BLOQUES rodeados por llaves {}
* Las expresiones opcionales por corchetes cuadrados []
* Las ETIQUETAS deben llevar al final dos puntos ':';

Ejemplos estructuras:

[ETIQUETA] while CONDICION BLOQUE [continue BLOQUE ]
[ETIQUETA] until CONDICION BLOQUE [continue BLOQUE ]
[ETIQUETA] foreach [VARIABLE] (LISTA) BLOQUE [continue BLOQUE]
[ETIQUETA] for (EXPRESION_1;EXPRESION_2;EXPRESION_3) BLOQUE
if CONDICION BLOQUE [[elsif BLOQUE] else BLOQUE]
unless CONDICION BLOQUE [else BLOQUE]

Para una sola sentencia

DECLARACIÓN if CONDICIÓN
DECLARACIÓN unless CONDICIÓN
DECLARACIÓN while CONDICIÓN
DECLARACIÓN until CONDICIÓN
DECLARACIÓN foreach LISTA

· Ejemplo: if y unless ("sentcontrol_if.pl")
· Ejemplo: do while ("sentcontrol_dowhile.pl")
· Ejemplo: for y foreach ("sentcontrol_foreach.pl")

Operadores lógicos

EXPRESION_1 and EXPRESION_2;
EXPRESION_1 or EXPRESION_2;
EXPRESION_1 && EXPRESION_2;
EXPRESION_1 || EXPRESION_2;
EXPRESION_1 eq EXPRESION_2;
EXPRESION_1 == EXPRESION_2;

Preferencias en operadores lógicos
_______________________________________________

left terms and list operators (leftward)
left ->
nonassoc ++ --
right **
right ! ~ \ and unary + and -
left =~ !~
left * / % x
left + - .
left << >>
nonassoc named unary operators
nonassoc < > <= >= lt gt le ge
nonassoc == != <=> eq ne cmp ~~
left &
left | ^
left &&
left || //
nonassoc .. ...
right ?:
right = += -= *= etc.
left , =>
nonassoc list operators (rightward)
right not
left and
left or xor
_______________________________________________

+ info: # perldoc perlop
· Ejemplo: Operaciones Lógicas 1 ("op_log1.pl")
· Ejemplo: Operaciones Lógicas 2 ("op_log2.pl")

*** Utilizando and y or nunca se llega a cumplir la operación
lógica si print $a es "true". Utilizando && y || siempre se da
preferencia a la operación lógica antes que a el operador print.

Ahora miremos esta tabla comparativa sacada con el modulo Deparse:
"perl -MO=Deparse -p archivo.pl", esto nos mostrara la forma en que
esta parentizado Perl el archivo de ejemplo "op_log2.pl":

op_log2.pl Parentización PERL
____________________________________________

$a = 4; $a = 4;
$b = "hola"; $b = 'hola';
$d = print ($a and $b); $d = print($a && $b);
print $d; print $d;
$e = print $a and $b; $b if $e = print($a);
print $e; print $e;
$f = (print $a && $b); $f = print($a && $b);
____________________________________________

Operadores de comparación

Comparación Numerico Cadena
______________________________________________

Igual == eq
distinto != ne
Menor que <> gt
Menor o igual que <= le Mayor o igual que >= ge
Comparación <=> cmp
______________________________________________

· Ejemplo: comparación cadenas ("comp_cadenas.pl")

Operador triario

if CONDICION BLOQUE else BLOQUE puede expresarse:
[DECLARACION] [(] CONDICIÓN ? EXPRESION_1 : EXPRESION_2 [)];

Control de Flujo

Las palabras clave de control de flujo next, last, return y redo
son expresiones, por lo que pueden ser usadas con los operadores
"cortocircuito". Perl tambien cuenta con dos construcciones para
bucles:

resultados = grep { ... } lista
resultados = map { ... } lista

grep devuelve todos los elementos de lista en que el bloque subor-
dinado evalúa a verdadero. map evalúa el bloque subordinado por
cada elemento de lista y devuelve una lista de los valores resul-
tantes. Estas construcciones permiten un estilo simple de progra-
mación funcional.

3.- SUBRUTINAS

Las rutinas nos permitirán reutilizar código y tenerlo más orga-
nizado ya que podremos acceder a éste desde cualquier parte del
programa e incluso desde otros programas.

Las subrutinas se definen con la palabra clave sub:

foo(); # paréntesis necesarios aquí...
sub foo { ... }
foo; # ... pero no aquí

Una lista de argumentos pueden ser indicados después del nombre de
la subrutina. Los argumentos pueden ser escalares, listas o hashes.

foo $x, @y, %z;

Los elementos de @_ pueden ser accedidos con los subíndices de la
forma normal.

$_[0], $_[1]

Un modismo común es asignar @_ a una lista de variables con nombres.

my($x, $y, $z) = @_;

Otro modismo es sacar los parámetros de @_. Esto es muy común
cuando la subrutina toma un sólo argumento.

my $x = shift; # Si no se dice nada, nos referimos a @_

Las subrutinas pueden devolver valores.

return 42, $x, @y, %z;

La expresión devuelta es evaluada en el contexto de la llamada de
la subrutina; esto puede sorprender al desprevenido.

sub lista { (4, 5, 6) }
sub array { @x = (4, 5, 6); @x }

$x = lista; # devuelve 6 - último elemento de la lista
$x = array; # devuelve 3 - número de elementos de la lista
@x = lista; # devuelve (4, 5, 6)
@x = array; # devuelve (4, 5, 6)

Una subrutina puede descubrir su contexto de llamada con la función
wantarray.

sub cualquiera { wantarray ? (1, 2) : "Naranjas" }

$x = cualquiera; # devuelve "Naranjas"
@x = cualquiera; # devuelve (1, 2)

4.- EXPRESIONES REGULARES

Una expresión regular es un modelo o una forma de comparar con una
cadena de caracteres. Esta comparación es conocida con el nombre de
pattern matching o reconocimiento de patrones, permite identificar
las ocurrencias del modelo en los datos tratados. se pueden dividir
en: (Comparación) (Sustitución) (Traducción).

(Expresiones Regulares de Comparación)

· Ejemplos: Expresiones regulares ("expresiones_regulares.pl")

Caracteres de control que definen modelos complejos de rutinas de
comparación:

Simbolo | Descripción | Clase | Negación
_______________________________________________________________

\w Caracteres alfanuméricos [0-9a-zA-Z] \W
\s Espacio '' \S
\d Caracteres numéricos [0-9] \D
\A Inicio de cadena X \Z
\b Inicio y fin de cadena X \B
_______________________________________________________________

· Ejemplo: Area de circunferencia ("circunferencia.pl")

Caracteres de control, secuencias de Escape:
_______________________________________________________________

\a Alarma (beep!)
\b Retroceso
\n Nueva línea
\r Retorno de carro
\t Tabulador
\f Formfeed
\e Escape
\007 Cualquier carácter ASCII en octal
\x7f Cualquier carácter ASCII en hexadecimal
\cC Cualquier caracter de control (CTRL+C)
\u Cambia el siguiente caracter a mayusculas
\U Cambia a mayusculas todo el contenido.
\l Cambia el siguiente caracter a minusculas
\L Cambia a minusculas todo el contenido.
\E Final de cambio a mayusculas o minusculas
_______________________________________________________________

Caracteres genéricos que aumentan la flexibilidad en la construcción
de patrodes de búsqueda:

Caracter Descripción
_______________________________________________________________

^c. La linea que empieza por el caracter c
$c La linea que termina por el caracter c
. Cualquier caracter excepto el \n
c+ Una o mas instancias del caracter c
c* Cero o mas instancias del caracter c
c? Cero o una instancia del caracter c
c{N} N instancias del caracter c
c{N,} Al menos N instancias del caracter c
c{N,M} Entre N y M instancias del caracter c
_______________________________________________________________

(Expresiones Regulares de Sustitución)

El operador m// (empareja) permite comprobar un emparejamiento por
medio de una expresión regular. (Para abreviar, el precedente m
puede ser omitido.) En el caso más simple, una expresión como:

$x =~ m/abc/

evalúa a verdadero si y sólo si el string $x empareja con la
expresión regular abc.

$x =~ m/a(.)c/; # captura el carácter entre 'a' y 'c' y lo
# guarda en $1

El operador s/// (sustitución) especifica una operación de búsqueda
y reemplazo:
$x =~ s/abc/aBc/; # Convierte la b en mayúscula
$x =~ m/abc/i; # emparejamiento independientemente de si
# están en mayúscula o minúscula

$x =~ s/abc/aBc/g; # búsqueda y reemplazo global (a lo largo de
# todo el string)

Las expresiones regulares pueden ser densas y crípticas. Esto es
porque la sintaxis de las expresiones regulares es extremadamente
compacta, generalmente usando caracteres sueltos o pares de
caracteres que representan sus operaciones. Perl alivia un poco
este problema con el modificador '/x' que permite a los programador
es poner espacio en blanco y comentarios dentro de las expresiones
regulares:

$x =~ m/a # empareja una 'a'
. # empareja cualquier carácter
c # empareja una 'c'
/x;
Un uso común de las expresiones regulares es el de especificar de
limitadores de campos al operador split:

@palabras = split m/,/, $línea; # divide la $línea de valores
# separados por comas

El operador split complementa la captura de string. La captura de
string devuelve las partes de un string que emparejan con una
expresión regular; split devuelve las partes que no emparejan.

Perl convierte automáticamente los valores de su representación
numérica a su representación como cadena. Ejemplos:

$n = 0 + "123"; # contexto numérico $n == 123
$n = 0 + "123xyz"; # contexto numérico $n == 123
$n = 0 + "\n123xyz"; # contexto numérico $n == 123
$n = 0 + "x123xyz"; # no hay número al comienzo $n == 0
$n = 0 + "x123"; # no hay número al comienzo $n == 0
$n = 0 + oct("x123"); # $n == 291

5.- VARIABLES

La Variable $!

En un contexto numérico, la variable escalar $! retorna el valor
numérico de la variable del sistema errno, la cual contiene el
último error encontrado durante una llamada al sistema o a ciertas
funciones de la biblioteca estándar C. En un contexto de cadena
devuelve la cadena producida por la función perror():

root@rootmachine# perl -de 0
DB<1> open $FILE, "fichero"
DB<2> print "$!"
No existe el fichero o el directorio
DB<3> print $!+0
2
DB<4> print $!
No existe el fichero o el directorio

Variables sensibles al contexto

root@rootmachine# perl -de 0
DB<1> use Scalar::Util qw{dualvar} # lmportamos el modulo Scalar
DB<2> use Lingua::EN::Words2Nums # Importamos el módulo Lingua
DB<3> $x = "one thousand two hundred thirty one"
DB<4> $x = dualvar words2nums($x), $x # Creamos una variable dual
DB<5> print "$x plus one is ".($x+1) # Observe la salida ...
one thousand two hundred thirty one plus one is 1232
DB<6> use Roman # Otro ejemplo ...
DB<7> $y = 457
DB<8> $y = dualvar $y, roman($y)
DB<9> p 0+$y." en números romanos es '$y'"
457 en números romanos es 'cdlvii'

· Ejemplo: Numeros Romanos ("num_roman.pl")

Variables contextuales multitipo con mas de dos tipos.

· Ejemplo: Contextual Return ("mult_context_var.pl")
· Ejemplo: Localtime ("localtime.pl") ACTIVE variable multiestado

La Variable $_

La variable especial $_ es el argumento por defecto para un gran
número de funciones, operadores y estructuras de control. Asi pues
estas dos expresiones son lo mismo:

print;
print $_;

Otro ejemplo: La función length devuelve la longitud en caracteres
de la expresión que se le pasa como argumento. Si se omite la
expresión usará la "variable por defecto" $_

root@rootmachine# perl -wde 0
DB<1> $_ = "Hello World!\n"
DB<2> p length
13

Variables Predefinidas en Perl

root@rootmachine# perldoc perlvar

Variables Privadas: Se declaran usando el operador my:

my $a = 4;
{
my $a = ;
my $b = ;
$a = ($a < $b)? $a : $b print "$a\n"; } print "$a\n";

Estas variables tienen como ámbito el bloque que las rodea. Asi la declaración de la variable léxica $a en la línea 3 oculta la variable léxica declarada en la línea 1. Las modificaciones de $a en el  bloque de las líneas 2-7 no afecta a la variable $a declarada  en la línea 1. Si no esta dentro de ningún bloque, el ámbito de la  variable será el fichero actual.

6.- FUNCIONES

A partir de ahora usaremos el depurador para ver la conducta de
Perl con estas sentencias:

root@rootmachine# perl -de 0
DB<1> $days = 5;
DB<2> x $days
0 5

Operadores de Cadena

"hola"."chicos" # es lo mismo que "holachicos"
"HLP"x2 # es HLPHLP
$s .= " un poco mas"; # Lo mismo que $s = $s . " un poco mas";

Si se quiere obtener uno o mas elementos de una cadena se usa
substr, veamoslo en el depurador:

root@rootmachine# perl -de 0
DB<1> $x = 'hola mundo'
DB<2> p substr($x,5) # Muestra a partir de la 5
mundo
DB<3> p substr($x,5,3) # Muestra 3 a partir de la 5
mun
DB<4> p substr($x,-2) # Segunda desde el final
do
DB<5> p substr($x,2,2,'mi') # Sustituimos
la
DB<6> x $x # Indice y Valor
0 'homi mundo'

Función index y rindex: busca subcadenas dentro de una cadena
desde el principio y desde el final.

root@rootmachine# perl -de 0
DB<1> $x= 'hola mundo'
DB<2> p index $x, 'mundo'
5
DB<3> p index $x, 'o'
1
DB<4> p index $x, 'o', 3
9
DB<5> p rindex $x, 'o'
9
DB<6> p rindex $x, 'o',4
1

Función reverse invierte los elementos de una cadena.

root@rootmachine# perl -de 0
DB<1> $x = 'hola mundo'
DB<2> $y = reverse $x
DB<3> p $y
odnum aloh

Función length retorna la longitud de una cadena.

root@rootmachine# perl -de 0
DB<1> $x = 'hola mundo'
DB<2> p length $x
10

Función chop y chomp elimina el ultimo elemento de una cadena.
(chomp solo lo elimina si es un retorno de carro o separador de
lectura).

root@rootmachine# perl -de 0
DB<3> chop $x
DB<4> p $x
hola mund
DB<5> chomp $x
DB<6> p $x
hola mund
DB<7> $x .= "\n"
DB<8> p $x
hola mund
# retorno de carro
DB<9> chomp $x
DB<10> p $x
hola mund

Hay varias funciones para trabajar con arrays Las mas básicas son
push, pop, shift, unshift y splice donde:

push # Coloca un elemento al final del array
pop # Coge un elemento del final del array
shift # coloca un elemento al principio del array
unshift # Coge un elemento al principio del array
splice # Coloca un elemento en cualquier punto del array

· Ejemplo: Función Array ("funcion_array.pl")
· Ejemplo: Buscar en un Array ("buscar_array.pl")
· Ejemplo: Chop ("chop.pl")

7.- MANEJO DE ARCHIVOS

Lectura de datos. El operador nos permite leer desde la
entrada estándar. Asi en:

$line = ;

La variable $line contiene el retorno de carro leído. Es por eso
que se usa el operador chomp el cual elimina el retorno de carro
·final:

$line = ; # "hola\n"
chomp($line); # $line contiene ahora "hola"

Lectura de ficheros. En general un fichero se abre mediante la
función open:

root@rootmachine# perl -de 0
DB<1> open $F, "> /tmp/file.txt" # apertura en modo escritura
DB<2> print $F "hello world\n"
DB<3> close($F)
DB<4> open $F, "/tmp/file.txt" # apertura en modo lectura
DB<5> $x = <$F>
DB<6> print $x
hello world

· Ejemplo: Apertura de Fichero ("open_file.pl")

8.- MODULOS

Instalción de modulos en Perl:
root@rootmachine# cpanp
CPAN exploration and module installation

Synasix de llamada del modulo:
use Scalar::Util qw{dualvar} valor doble?

De-duplicación NetApp FAS2020

2009-09-25T09:25:00.000-07:00

Con de-duplicación nos referimos a una funcionalidad que implementan las cabinas de almacenamiento y que permite que se identifiquen y eliminen bloques de datos redundantes. Esto se hace de forma transparente para los servidores o usuarios clientes, que seguirán viendo la estructura de datos original, pero internamente la cabina estará ahorrándonos los bloques de 4KB que estén escritos varias veces.

Esto se puede hacer para cualquier tipo de protocolo de acceso: FC, iSCSI, NFS y/o CIFS. En los dos últimos, dado que se exporta un sistema de ficheros, los ahorros de la de-duplicación son mostrados directamente al cliente, que vera como sus datos ocupan menos espacio en el sistema de ficheros tras ejecutar el proceso de la de-duplicación.

En los servicios de LUNs (FC o iSCSI), los clientes ven un disco SCSI virtual que típicamente formatearan con un sistema de ficheros propios. En estos casos los clientes no pueden ver ningún cambio en el espacio disponible, puesto que esto “volvería loco” al sistema de ficheros en el cliente. Lo que conseguimos en estos casos es que el espacio "de-duplicado" sea espacio libre en la cabina, y que haciendo *thin-provisioning ese espacio lo podamos reutilizar para otras LUNs o servicios. Este es el cacharrito en cuestión:

La forma en que en NetApp implementan la de-duplicación está pensada para poderla utilizar en muchos conjuntos de datos productivos, ya que al realizarse la búsqueda de bloques redundantes como un proceso “batch”, que típicamente se ejecutará fuera de la ventana de máximo rendimiento del equipo, el habilitar la de-duplicación no afecta en gran medida al rendimiento del equipo y es bastante probable que dado un equipo que está dando un determinado servicio, sin cambiar ni añadir nada de hardware podamos de-duplicar parte o todos los datos de ese servicio/s.

Una consideración que si hay que tener en cuenta a la hora del rendimiento es que al de-duplicar los datos perdemos secuencialidad en los mismos, por lo que las lecturas secuenciales de datos de-duplicados pueden verse algo penalizadas, es decir, nuestros backups puede que tarden un poco más. Las lecturas aleatorias y las escrituras típicamente no sufren penalización o esta es muy baja.

Ejemplo Practico:

Primero creamos tres maquinas virtuales y realizamos la de-duplicación (documento explicativo). Las maquinas ocupaban 4GB cada una de espacio de almacenamiento, un total de 12GB. Tras la de-duplicación el espacio se quedo en 4,1GB. Después añadimos otras 3 maquinas y volvimos a realizar la de-duplicación para ver la evolución. Los resultados finales fueron (antes/después de la de-duplicación):

con lo cual tenemos que cada maquina virtual incrementa en 0,2GB mas o menos el total del almacenamiento reduciendo notablemente su espacio inicial.

THIN-PROVISIONING

*El thin-provisioning consiste en presentar más espacio de almacenamiento del que se está utilizando o incluso existe en el sistema de almacenamiento. El caso más habitual consiste en poder crear una LUN (o disco SCSI virtual) que no consume todo el espacio que tiene la misma. Por ejemplo, creamos una LUN de 100GB que no consume 100GB en la cabina. Un ejemplo con la línea de comandos de equipos netapp de como controlar el thin-provisioning de una LUN, una propiedad que podemos activar o desactivar para cada LUN de forma individual:


# Creamos una LUN
> lun create -s 2g -t linux /vol/test/lun0
> df -h test
Filesystem               total       used      avail capacity  Mounted on
/vol/test/                10GB     2052MB     8187MB      20%  /vol/test/

# Consume 2GB del volumen que la contiene
# Le quitamos la reserva de espacio, para que sea  "thin-provisioned"

> lun set reservation /vol/test/lun0 disable
> lun show -v /vol/test/lun0
  /vol/test/lun0                 2g (2147483648)    (r/w, online)
          Serial#: C4ifmJMYpfja
          Share: none
          Space Reservation: disabled
          Multiprotocol Type: linux

> df -h
Filesystem               total       used      avail capacity  Mounted on
/vol/test/                10GB      128KB    10239MB       0%  /vol/test/

Tras quitar la reserva de espacio, la LUN solo consume unos pocos KB, por que todavía no tiene datos. Conforme se almacenen datos se irá consumiendo espacio del volumen hasta un máximo de 2GB que es el tamaño de ese disco virtual, tal y como lo ve el servidor cliente. Desde el interfaz web es incluso más sencillo, puesto que lo único que hay que hacer es quitar la reserva de espacio en el momento de crear la LUN:

Remote Logging SysLog

2009-07-08T09:04:00.001-07:00

syslog es un estándar de facto para el envío de mensajes de registro en una red informática IP. Por syslog se conoce tanto al protocolo de red como a la aplicación o biblioteca que envía los mensajes de registro. Un mensaje de registro suele tener información sobre la seguridad del sistema, aunque puede contener cualquier información. Junto con cada mensaje se incluye la fecha y hora del envío.

En nuestro caso vamos a utilizar sylog-ng(nextgen) ya que es mucho mas flexible (Permite aplicar filtros, clasificar de acuerdo a distintos orígenes y enviar a diferentes destinos los logs, etc...).El archivo de configuración a modificar en cuestión es /etc/syslog-ng/syslog-ng.conf, tanto en el servidor como en los clientes que enviaran los logs por red. Añadimos al Server las siguientes lineas:


source remote { tcp(port(514) keep-alive(no)); };
destination hosts { file("/var/log/HOSTS/$HOST/$FACILITY" owner(root)
  group(root) perm(0600) dir_perm(0700) create_dirs(yes)); };
log { source(remote); destination(hosts); };

Así estará escuchando por el puerto 514 cualquier sourcelog emitida por los clientes y la guardara en carpetas separadas con la estructura /var/log/HOSTS/"hostname"/. En los clientes hemos añadido las siguientes lineas al config file:


destination loghost {tcp("IP_SERVER" port(514));};
log { source(src); destination(loghost); };

Esto enviara la totalidad de logs que gestiona syslog a nuestro server.

Sincronización de servidores NTP en modo Peer y Multicasting

2009-07-08T09:02:00.000-07:00

Network Time Protocol (NTP) es un protocolo de Internet para sincronizar los relojes de los sistemas informáticos a través de ruteo de paquetes en redes con latencia variable. NTP utiliza UDP como su capa de transporte, usando el puerto 123. En el trabajo me toco configurar una red de servidores NTP en modo peer/multicasting, algo un poco mas avanzado, a continuación tienes las anotaciones;

Este es el esquema de una red de servidores NTP utilizando sincronización Server, Peer, Multicasting:

El archivo de configuración de los server que van a ofrecer multicasting se encuentra en /etc/ntp.conf y suele tener el siguiente formato:


server X.X.X.X burst iburst             # Server NTP Principal de la empresa
peer Y.Y.Y.Y                            # Server Peer
server 127.127.1.0                      # local clock (LCL)
fudge 127.127.1.0  stratum 10           # LCL is unsynchronized
broadcast 224.0.1.1 key 1               # Sync Broadcast
driftfile /var/lib/ntp/drift/ntp.drift  # path for drift file
logfile   /var/log/ntp                  # alternate log file
authenticate yes                        # Autentificación activada
keys /etc/ntp.keys                      # path for keys file
trustedkey 1                            # define trusted keys
requestkey 1                            # key (7) for accessing server variables

Un posible cliente multicast de este Server NTP tendría el siguiente /etc/ntp.conf:


enable bclient                          # habilita recepción broadcast
multicastclient 224.0.1.1 key 1
server 127.127.1.0                      # local clock (LCL)
fudge 127.127.1.0  stratum 10           # LCL is unsynchronized
authenticate yes
keys /etc/ntp.keys
trustedkey 1
requestkey 1

Para una sincronización broadcast-multicast como esta hay que tener en cuenta las trusted keys, ya que sin ellas no es posible la sync con los servers. Para ello hay que establecer contraseñas (keys) comunes en el archivo /etc/ntp.keys de cada maquina que actúa en la sync. En el ejemplo anterior estamos utilizando la primera key para este proceso. Mas información sobre este archivo: osr507doc.Un ejemplo de ntp.keys seria:


1      M    MiTrustedKey

Algunos comandos que me fueron de utilidad durante el proceso de configuración (bajo SLES11):


# vim /etc/ntp.conf             Archivo configuración ntpd
# vim /etc/ntp.keys             Archivo configuración trusted keys
# service ntp restart           Reiniciar el servicio ntp despues de cada config
# ntpq -p                       Network Time Protocol Query Utils
# rcntp status                  Remote Call Network Time Protocol
# tcpdump -w udp port 123       Escucha paquetes tcp por el puerto 123 (ntp service)
# date                          Muestra la fecha para ver si hay sincronización
# ln -s /usr/share/zoneinfo/ZonaXXX /etc/localtime

Seguridad en Redes Wifi v1.0

2009-06-08T07:46:00.000-07:00

Después de leer muchos "tutoriales" "manuales" "guías" y demás documentación me doy cuenta de que en ningún sitio esta explicado en condiciones lo que es el sistema Wi-Fi de transmisión de datos y lo que es más importante, que medidas de seguridad tiene.

Pues bien aquí se va a explicar, desde cero al infinito o al límite de conocimiento que tenga la red sobre el tema (que perfectamente puede ser infinito).

En este primer post de seguridad informatica, descubriréis muchas cosas, entre ellas mi pasión por el hacking. Así pues preparaos para un chute tecnológico instantáneo, al estilo matrix como sé que os gusta :

Si no tienes ni idea de lo que estamos hablando es recomendable que empieces con esta práctica metodología de estudio. La metodología de estudio de cualquier tecnología, técnica o incluso por qué leches no decirlo, del mundo real y todo lo que nos rodea es simple, al igual que la mayoría de las respuestas a los grandes misterios de la humanidad: PREGUNTATE A TI MISMO! [y después acude a google xD]

Siguiendo esta metodología nos encontramos con estas series de preguntas que cualquier homínido con dos dedos de frente se haría. Así llegamos a la primera sección que toda guía especializada debería llevar: Documéntate o muere!!!


1. ¿Qué es la comunicación inalámbrica? [Respuesta]
2. ¿Qué es el sistema Wi-Fi? [Respuesta]
3. ¿Qué tipos de dispositivos van a entrar en juego?
- Punto de acceso (AP)
- Enrutador (router)
- Concentradores (hubs)
- Conmutadores (switches)
     - Dispositivos de recepción
- Tarjetas PCI
- Tarjetas PCMCIA
          - Adaptadores USB
4. ¿Qué tipo de seguridad tiene? [Respuesta]
5. Todavía no me queda del todo claro...
- ¿Qué es el sistema de cifrado WEP? [Respuesta]
- ¿Qué es el sistema de cifrado WPA? [Respuesta]
- ¿Qué es el sistema de cifrado WPA2? [Respuesta]
- ¿Cómo funciona el protocolo IPsec? [Respuesta]
- ¿Espera .. Que es una MAC? [Respuesta] ¿y un filtrado de MAC? [Respuesta]
- ¿Que es el SSID? ¿Se puede ocultar el SSID? [Respuesta]
- ¿Qué significa que el DHCP está Deshabilitado en el AP? [Respuesta]

Ahora que sabéis todos estos conceptos, ¿Que necesitamos para reventar una Wi-fi?, - un bate de beisbol que emita ondas hertzianas de baja frecuencia, NO! la respuesta a todas nuestras preguntas es la sección: Hacking Tools!!


1. Un PC (a poder ser Laptop)
2. Sistema Operativo y Utilidades de auditoría Wi-fi:
- Anonym.OS [Info][Download]
- Arudius [Info][Download]
- BlackTrack (Auditor Security Collection) [Info][Download]
- CQure AP [Info & Download]
- Frenzy [Info][Download]
- Knoppix STD [Info][Download]
- Linux LiveCD Router [Info][Download]
- Operator [Info][Download]
- Pentoo [Info][Download]
- Phlak [Info][Download]
- ProTech [Info][Download]
- Sisela [Info][Download]
- Talos Security LivecD [Info][Download]
- WarLinux [Info][Download]
- WHAX [Info][Download]
- Wifiway [Info][Download]
- wifislax [Info][Download]

3. Existen muchos SO de auditoría ¿cual escojo? - Pues depende, si quieres profundizar en el mundo de la auditoria wireless o te quieres dedicar a ello profesionalmente te diría que probases todos y sacases tus propias conclusiones [incluso podrías generar tu propia distro live-cd con las tools que más te gustasen]. Si estas realizando algún proyecto de investigación BlackTrack es una buena opción por su amplia gama de tools y si lo que quieres es una herramienta para un acceso rápido preparada para hasta el más imbécil sin duda usaría Wifiway o Wifislax. La elección es tuya.

4. ¿Con win-xpeta o WinVistoso no puedo hacerlo? - Puedes hacerlo pero yo no te voy a decir como, por mi ampliamente conocido ASKO sobre esta serie de sistemas operativos preparados para realizar cualquier cosa orientada a ... vamos a fichar a games o trastear con el photoshop. Pero aquí tienes un par de "tutoriales" de esos que les gustan a gente como tu: [tutorial1] [tutorial2] [tutorial3]

5. Documento en continua Expansión: id visitando estos sites:
http://frikeando.wordpress.com/2006/06/29/auditoria-wireless-%C2%BFque-tarjeta-wifi-debo-usarcomprar/
http://linux-wless.passys.nl/
http://hwagm.elhacker.net/htm/inicios.htm

iSCSI Server en SLES11

2009-06-08T06:18:00.000-07:00

¿Qué es iSCSI?

iSCSI es un extensión de SCSI, que no es otra cosa que un protocolo para comunicación de dispositivos. SCSI suele usarse en dispositivos conectados físicamente a un host o servidor, tales como discos duros, lectoras de cds o dispositivos de cinta. En iSCSI, los comandos SCSI que manejan el dispositivo, se envían a través de la red. De forma que en vez de tener un disco SCSI conectado físicamente a nuestro equipo, lo conectamos por medio de la red.

Funciones Principales:

Como se puede ver en el diagrama siguiente, iSCSI tiene una arquitectura tipo cliente servidor:

El target iSCSI

El target iSCSI es en pocas palabras el servidor. Un target puede ofrecer uno o más recursos iSCSI por la red. En las soluciones Linux para iSCSI, no hace falta que el dispositivo a exportar sea necesariamente un disco SCSI; medios de almacenamiento de distinta naturaleza se pueden usar, como por ejemplo:


  * Particiones RAID
  * Particiones LVM
  * Discos enteros
  * Particiones comunes
  * Archivos
  * Dispositivos de CD, cintas, etc.

El iniciador iSCSI

El iniciador es el cliente de iSCSI. Generalmente el iniciador consta de dos partes: los módulos o drivers que proveen soporte para que el sistema operativo pueda reconocer discos de tipo iSCSI y un programa que gestiona las conexiones a dichos discos.

Proceso de Instalación de Server/Client iSCSI:

Creando unidades virtuales LVM: (Volume groput: System - Logical Volume: test1)


# pvscan / pvs
# vgcreate system /dev/cciss/c0d0p5
# lvcreate system -n test1 /dev/ccissc0d0p5 -L10G
# mkfs.ext3 /dev/system/test1

Instalando el Target iSCSI (


yast -i linux-source libssl-dev (Librerias de desarrololo ssl)
yast -i iscsitarget

Ficheros que instala iscsitarget:


/etc/ietd.conf
/etc/init.d/iscsitarget
/etc/sysconfig/SuSEfirewall2.d/services/iscsitarget
/usr/sbin/ietadm
/usr/sbin/ietd
/usr/sbin/rciscsitarget
/usr/share/doc/packages/iscsitarget
/usr/share/doc/packages/iscsitarget/COPYING
/usr/share/doc/packages/iscsitarget/README
/usr/share/man/man5/ietd.conf.5.gz
/usr/share/man/man8/ietd.8.gz

Configuración del target

La configuración de IET se encuentra en /etc/ietd.conf

Allí tendremos que configurar dos cosas principalmente:

* El nombre de nuestro target iSCSI
* El nombre de usuario y la contraseña para la conexión del iniciador
* El dispositivo que ofreceremos como target iSCSI


Target iqn.2009-06.int.empresa.com:lvm.10G.test1
      IncomingUser "usuario" "password"
      Lun 0 Path=/dev/system/test1,Type=fileio
      Alias TEST1

/etc/init.d/iscsitarget start  -> Levantamos el servidor
update-rc.d iscsitarget defaults -> scsi target inicia junto con el server

Montando el Iniciador iSCSI


yast -i open-iscsi
-> iscsid (demonio que controla el iniciador)
-> iscsiadm (programa para configurar y gestionar el iniciador)

/etc/init.d/open-iscsi start  (iniciamos el servicio)

Descubrir y sonsacar información del target iSCSI:


iscsiadm -m discovery -t sendtargets -p "ip_Servidor_iSCSI"
iscsiadm -m discovery
iscsiadm -m node --targetname iqn.2009-06.int.empresa.com:lvm.10G.test1

Actualizamos la configuración con los datos de nuestro target iSCSI:


iscsiadm -m node --targetname "iqn.2009-06.int.empresa.com:lvm.10G.test1" --portal "ip_Servidor_iSCSI":"Puerto_Target(def 3260)" --op=update --name node.session.auth.authmethod --value=CHAP
iscsiadm -m node --targetname "iqn.2009-06.int.empresa.com:lvm.10G.test1" --portal "ip_Servidor_iSCSI":"Puerto_Target(def 3260)" --op=update --name node.session.auth.username --value="usuario"
iscsiadm -m node --targetname "iqn.2009-06.int.empresa.com:lvm.10G.test1" --portal "ip_Servidor_iSCSI":"Puerto_Target(def 3260)" --op=update --name node.session.auth.password --value="password"

Iniciar sesión con el target iSCSI:


iscsiadm -m node --targetname iqn.2009-06.int.empresa.com:lvm.10G.test1 -p "ip_Servidor_iSCSI" --login
iscsiadm -m node --targetname iqn.2009-06.int.empresa.com:lvm.10G.test1 -p "ip_Servidor_iSCSI" --logout

Automatización del target iSCSI en el arranque:


yast -i yast2-iscsi-client

yast ( > Network Serices > iSCSI Initiator)
ISCSI Initiator Discovery: IP server, Port, outgoing Authentication, Username, Password (ietd.confg)
Connected Targets (toggle Start-Up = Automatic)
Service (When Booting)

Finish.

Veritas NetBackup en RHEL (Red Hat)

2009-03-16T02:33:00.000-07:00

Según la web oficial de Netbackup: "Veritas NetBackup 6.5 ofrece una protección de datos de alto rendimiento para UNIX, Windows, Linux y NetWare, escalable hasta los entornos más extensos. Con una protección completa que abarca desde las oficinas remotas hasta los datacenters y los repositorios de información, NetBackup ofrece una sola consola para todas las operaciones de copia de respaldo y recuperación".

Vamos a realizar una instalación de NetBackup en RHEL (Red Hat Enterprise Linux). Lo primero que tenemos que mirar es la funcionalidad del software (para que sirve) y a la hora de instalar las listas de compatibilidades del sitio oficial (Mirar Anotaciones).

Funciones Principales:

- Plataforma unica para administrar, proteger y recuperar datos de las diferentes capas de Almacenamiento.
- Eliminación de datos duplicados, nuevos controles biblioteca virtual de cintas (VTL)
- Protección y Recuperación de datos integrada para entornos virtuales, aplicaciones criticas, bases de datos y Servidores.

Requisitos del Sistema:
- Operating Systems
- Master Compatibility List

Agentes Soportados:
- Veritas NetBackup para DB2, Informix, Lotus Notes, Microsoft Exchange Server, Microsoft SharePoint Server, Microsoft SQL server, NDMP, Oracle, SAP, Sybase, Vault.

Pasos de la instalación:

01 - Install Private Branch Exchange (PBX)
02 - Install Netbackup
03 - Licenses Netbackup
04 - Pre-Install Puredisk
05 - Licenses Puredisk
06 - Change /etc/hosts (Master Server, Nodos, Puredisk, etc,.....)
07 - Defines Storage Units (Crear Storage Units bien sean hardisk or TapeLibrarys.
08 - Define Polices Netbackup (Definimos las politicas de los clients)
09 - apt-get install "dialog" (display dialog boxes from shell scripts) *man dialog + información
10 - Launch /opt/pdinstall/edit_topology.sh
11 - Launch /opt/pdinstall/install_newStoragePool.sh

Instalación Netbackup Server RHEL:

01. Install a couple of dependencies: yum install compat-libstdc++-296 xinetd libXp
02. Make sure that the hostname is set correctly. This is very important.
03. Temporarily disable SELinux: setenforce 0
04. Untar the installation files:


     tar xvf NetBackup_6.5_LinuxRedhat2.6.tar.gz
     tar xvf NetBackup_6.5_ICS_LinuxX86.tar.gz

05. Start the installation:


     ./NB_65_LinuxR_x86_20070723/install
     .....
     #ICS Directory: ./NB_65_ICS_1.4.37.0_LinuxX86/

06. Fix SELinux:


     chcon -t textrel_shlib_t /usr/openv/lib/*
     setenforce 1

07. Start Netbackup:


     /etc/init.d/netbackup start

Instalación Cliente Netbackup:

01. Untar the installation file:


     tar xvf NetBackup_6.5_CLIENTS2.tar.gz

02. Start the installation:


     NB_65_CLIENTS2_20070723/install

03. Fix SELinux issues:


     chcon -t textrel_shlib_t /usr/openv/lib/*

04. Start the client:


     /etc/init.d/nbclient start

Sun Solaris en VMware bajo Ubuntu

2009-03-11T02:51:00.000-07:00

Vamos a instalar VMware WorkStation bajo Ubuntu y despues vamos a virtualizar una machine con Solaris 8 (por ejemplo) como sistema operativo. Lo primero es conseguir vmware workstation para ubuntu y después podemos ponernos con el tutorial:

Antes de instalarlo necesitamos los siguiente :

1° Instalar Build Essentials y Linux Headers
2° Instalar xinetd


sudo apt-get install build-essential linux-headers-['uname -r']
sudo apt-get install xinetd

Finalmente lo instalan descomprimiendo el archivo y ejecutando en un terminal lo siguiente:


sudo sh VMware-Workstation-6.5.1-126130.i386.bundle

Con esto deberiamos tener instalado perfectamente VMware. Ahora descargamos una ISO de Solaris 8, 9 o 10 para arch x86 y empezamos a configurar la Virtual Machine:

> Edit Virtual Machine Setting
· Memory: 512 MB
· Processors: 1 (2 si hay posibilidad)
· Hard Disk (IDE): 8GB
· CD/DVD: (Apuntamos hacia la ISO o el DVD en función de donde tengamos la iso de solaris)
· Autodetect el resto.

> Pestaña Options
· General: Guest Operating System: Solaris X
· SnapShot/Replay: Just Power Off

Le damos a "Power On" y arrancamos la machine para comenzar la instalación de Solaris (para realizar una instalación en x86 tenemos que insertar el cd "Software1" en ved de "installation"):

Ahora hacemos este combo: "F2 > Enter > F2", Solaris se liara a hacer una serie de historias (reconocimiento de hardware, etc...) hasta que llegamos a la pantalla de arranque de Solaris:

En esta patalla utilizamos las teclas "vi" para movernos, es decir j (bajar) k (subir) y el espacio para seleccionar. asi pues le decimos que nos cargue el kernel de solaris desde el dispositivo que precisemos, en mi caso CD y pulsamos F2.

Tipo de instalación: 1-Solaris Interactive
Select a language: 0 English
Local Language: U.S.A. ISO-8859

kdmconfig:
· select "Change Video Device/Monitor" and press F2
···· Video Device Selection: "16 color Starndard VGA 640x480 (256K)" > F2
···· Monitor Type Selection: "MultiFrecuency 100Khz (Up to 1600x1200 @ 80Hz)" > F2
· press F2 again to keep the "video device" (i.e. your video card)
· in the "Monitor Types" list select the Mulitsync options best suited for your monitor specifications and press F2
· select your screen size and press F2
· accept the detected resolution/color combination for your video card
· select a virtual screen size that matches the screen size you selected in the previous step

Seleccionamos Zona Geografica, Instalar la distribución completa, custom layout (a no ser que queramos modificar el espacio en Var u otro punto de montaje), Automatical reboot. Cuando rebootea nos pide la pass de root, se la damos y cuando arranque "el sistema" insertamos el cd "software2" y le damos al intro. Se instalara el resto de paquetes y cuando rebootemos de nuevo el sistema estara listo para arrancar. Eso, eso eso estodo amigos...

Cacti - Graficado en Red

2008-08-21T05:00:00.001-07:00

Cacti es una completa solución de graficado en red, diseñada para aprovechar el poder de almacenamiento y la funcionalidad de graficar que poseen las RRDtool. Esta herramienta, desarrollada en PHP, provee un pooler ágil, plantillas de gráficos avanzadas, múltiples métodos para la recopilación de datos, y manejo de usuarios. Tiene una interfaz de usuario fácil de usar, que resulta conveniente para instalaciones del tamaño de una LAN, así como también para redes complejas con cientos de dispositivos.

Modelos de Almacenamiento de Datos

2008-08-21T04:51:00.000-07:00

Los principales modelos de almacenamiento de datos son los siguientes:

- Desestructurado.
Pila de disquetes, CD-R. DVD o cintas apilados con una minima información
de que ha sido copiado y cuando.

- Completa + Incremental.
En primer lugar se hace la copia del sistema operativo al completo. Despues copiamos solo los archivos que se hayan modificado desde la ultima copia de seguridad. Es necesario un gran espacio de almacenaje.

- Diferencial.
Una copia de seguridad diferencial es una copia de cada archivo en un sistema de ficheros que ha cambiado desde la última copia de seguridad completa.

- Espejo.
Mirroring es el proceso automatizado de los datos por escrito a dos unidades simulteneously. Mirroring se utiliza para proporcionar redundancia. Si una unidad falla, la unidad redundante seguir para almacenar los datos y facilitar el acceso a ella. La unidad no puede ser sustituido y la unidad se podrá volver a espejos. Mirroring se utiliza en RAID de nivel 1.

- Protección continua de datos.
En este modelo el sistema registra inmediatamente cada cambio en el sistema anfitrion.

Instalando SVN - Subversión

2008-08-12T00:21:00.000-07:00

SVN es un sistema de control de versiones para que vaios programadores puedan trabajar en el mismo proyecto. En el servidor se monta un repositorio SVN y en el se van registrando los cambios (versiones) y los logs de comentarios que vean dejando los programadores conforme realizan cambios en el programa.

Tipos de redes de Almacenamiento

2008-08-11T03:28:00.000-07:00

Es un poco lioso diferenciar los tipos de redes de almacenamiento ya que algunos conceptos se asemejan bastante. En estas anotaciones creo que quedan bien explicados:

NFS - Network File System

2008-08-11T01:59:00.000-07:00

Es un protocolo de nivel de aplicación, segun el modelo OSI. Originalmente fue desarrollado por Sun Microsystems, con el objetivo de que fuese independiente de la maquina, el sistema operativo y el protocolo de tansporte, esto fue posible gracias a que esta implementeado sobre protocolos XDR (Presentacion) y ONC RPC(Sesion). El protocolo NFS esta incluido por defecto en los SO Unix y Linux.

Fibre Channel (Canal de fibra)

2008-08-08T05:31:00.000-07:00

Despues de hablar de las SAN's es preciso que hablemos de su principal medio de transporte de datos, el fibre channel. Os dejo un pequeño esquema (como siempre) de lo que voy investigando:

SAN - Redes de almacenamiento

2008-08-07T08:15:00.000-07:00

Hace poco se me ha asignado un proyecto de almacenamiento que tiene que ver con el amplio mundillo de las SAN's y he empezado a investigar sobre el asunto. Aquí os traigo un pequeño esquema para que sepáis de que va la cosa:

Instalación y configuración básica Nagios

2008-08-05T05:35:00.000-07:00

Ya estuvimos viendo de que trataba este monitor de red. Ahora vamos a instalarlo y a realizar configuraciones básicas, sobre usuarios, grupos de usuarios y equipos de la red.

LVM: Gestionando volúmenes Lógicos

2008-08-05T00:58:00.000-07:00

LVM es una implementación de un administrador de volúmenes lógicos para el kernel Linux. Se escribió originalmente en 1998 por Heinz Mauelshagen, que se basó en el administrador de volúmenes de Veritas usado en sistemas HP-UX. LVM incluye muchas de las características que se esperan de un administrador de volúmenes, incluyendo:

- Redimensionado de grupos lógicos
- Redimensionado de volúmenes lógicos
- Instantáneas de sólo lectura (LVM2 ofrece lectura y escritura)
- RAID0 de volúmenes lógicos

Sus principales características son:


LVM - administrador de volumenes lógicos
  \_ Redimensionado de grupos lógicos y volumenes lógicos
   \_ Instantaneas de solo lectura
    \_ RAID0 de volúmenes lógicos.

LVM se desompone en 3 partes:
   -Volumenes fisicos (PV) > HD, particiones, raid's etc...
   \_ Chunks de datos (PE physicals Extents)
   -Volumenes logicos (LV) > Equivalente a una partición..
    \_ LE (Logical Extents)
   -Grupos de Volumenes (VG) > Grupo qu eengloba LV's y PV's.

Darles el tipo 8e (LVM) a las particiones:


$ cfdisk /dev/sda
$ cfdisk /dev/sdb

Inicializar dispositivo logico: (esta opción borra todo los datos que hubiese en las particiones o discos)


$ dd if=/dev/zero of=/dev/sda1 bs=1k count=1
$ dd if=/dev/zero of=/dev/sdb1 bs=1k count=1
$ pvcreate /dev/sda1
Physical volume "/dev/sda1" successfully created
$ pvcreate /dev/sdb1
Physical volume "/dev/sdb1" successfully created

Creación de un Grupo Volumen (VG):


$ vgcreate LinuxReporting /dev/sda1 /dev/sdb1
Volume group "LinuxReporting" successfully created

$ vgdiplay            #(verificamos que hemos generado el grupo)
--- Volume group ---
VG Name               LinuxReporting
VG Access             read/write
VG Status             available/resizable
VG #                  0
MAX LV                256
Cur LV                0
Open LV               0
MAX LV Size           255.99 GB
Max PV                256
Cur PV                2
Act PV                2
VG Size               8.46 GB
PE Size               4 MB
Total PE              2166
Alloc PE / Size       0 / 0
Free  PE / Size       2166 / 8.46 GB
VG UUID               qFePyg-SvH1-Q10s-i885-1ZF2-hurF-VsPCnW

Creación del Volumen lógivco (LV):


$ lvcreate -L1G -n usr LinuxReporting
lvcreate -- doing automatic backup of "vg_LinuxReporting"
lvcreate -- logical volume "/dev/LinuxReporting/usr" successfully created

Creación del sistema de ficheros:


$ mkfs.reiserfs /dev/LinuxReporting/usrr (Crear Sistema Reiserfs)
(Puede necesitarse el paquete reiserfsprogs)
$ mkfs.jfs /dev/vg_LinuxReporting/usr (Crear Sistema jfs)

Montando el Sistema de ficheros:


$ mount /dev/LinuxReporting/usr /mnt (montamos la particion en mnt)
$ cp -R /usr/* /mnt (copiamos todo el contenido de usr a mnt)
$ cd /usr && find . -depth -print0 | afio -px -0a /mnt (otra forma de copiarlo)
$ mount -t jfs /dev/vg_Linuxreporting/usr /mnt/LRlv1

Después añadimos la entrada a /etc/fstab para que /mnt/LRlv1 este disponible cuando reiniciemos la maquina. En nuestro caso de la reiserfs seria:


/dev/LinuxReporting/usr /usr  reiserfs        defaults        0       0

Puede que también lo tengas que añadir al Init para que se active el grupo volumen para que lo pueda montar el kernel del sistema de manaera correcta. Nos vamos a /etc/rcS.d/ y añadimos lo siguiente:


$ ln -s /etc/init.d/lvm S25lvm

Sesion automática con Telnet

2008-07-31T03:30:00.000-07:00

He aqui un script muy interesante para realizar pruebas automaticas a un servidor smtp. A mi me sirvio para poder chekear un filtro de correo linkandolo despues a Nagios, el sistema de monitorización del que hablamos hace poco.

Diagramas en Linux: dia

2008-07-29T10:46:00.000-07:00

Dia es una inspiracion del programa de Windows comercial "Visio", aunque más orientado hacia esquemas informales para uso ocasional. Se puede utilizar para extraer diferentes tipos de diagramas. En la actualidad cuenta con objetos especiales para ayudar a sacar diagramas entidad relación, diagramas UML, diagramas de flujo, diagramas de red, y muchos otros esquemas. También es posible añadir soporte para nuevas formas de escritura simple archivos XML, usando un subconjunto de SVG para dibujar la forma.

Puede cargar y guardar los diagramas personalizados a un formato XML (gzipped por defecto, para ahorrar espacio), puede exportar diagramas a una serie de formatos, incluyendo EPS, SVG, xfig, PNG y WMF, y puede imprimir los diagramas (incluidos los que cubren múltiples páginas).

Para descargar este paquete desde nuestro gestor de paquetes preferido ya sea synaptis o adept descargar el paquete dia, o desde consola: # apt-get install dia

Herramientas inalámbricas desde Shell

2008-07-29T00:12:00.000-07:00

Wireless tools es un juego de herramientas de información y configuración de conexiones inalámbricas. Esta compuesto por:

# dhclient (Dynamic Host Configuration Protocol Client)
# iwconfig (Información sobre las interfaces de red)
# iwconfig Interface (Información concreta de Interfaces)
# iwconfig Interface essid "ESSID" (asignamos essid)
# iwconfig Interface key s:clavesecreta (contraseña WEP)
# iwconfig Interface key HEXADECIMALKEY (Hexadecimal key)
# iwlist scanning (rastreador wifi)
# iwgetid Interface (Nos muestra essid asociado)
# iwevent (controla los eventos inalámbricos)
# iwspy Interface (información sobre usuarios de otra WLAN)

Como siempre podéis indagar en cada uno de las utilidades accediendo a las man pages o en la siguiente dirección: iwconfig.