Balanceo de carga en Redis con Nginx

Vuelvo a la carga con un post de Arquitectura para compartir cómo usar Nginx (tanto la versión Open Source como la versión de pago – Nginx Plus) para balancear la carga entre varios servidores Redis.

Introducción a Nginx y Redis

Nginx es un servidor proxy HTTP inverso, un servidor proxy de correo y un servidor proxy TCP / UDP genérico. Productos similares serían HAProxy y Apache.

Redis es un almacén en memoria de estructuras de datos open-source, utilizado como base de datos, caché y broker de mensajes.

Solución al balanceo de carga

El balanceo de carga se refiere a la distribución del tráfico de red entre múltiples servidores backend. Estamos más acostumbrados a utilizar el módulo HTTP de Nginx utilizándolo de proxy o balancear la carga de tráfico HTTP. Desde hace algunas versiones Nginx admite el balanceo de carga de tráfico tanto TCP como UDP.

Para cambiar la configuración de Nginx debemos modificar el fichero o ficheros de configuración, en el caso de que tengamos varios que luego incluiremos con claúsulas “include“. El fichero de configuración principal por defecto de Nginx generalmente se encuentra en /etc/nginx/nginx.conf:

stream {
 server {
 listen 12345;

 #TCP traffic will be proxied to the "stream_backend" upstream group
 proxy_pass stream_backend;
 }

 server {
 listen 12346;

 #TCP traffic will be proxied a proxied server
 proxy_pass backend.example.com:12346;
 }

 server {
 listen 53 udp;

 #UDP traffic will be proxied to the "dns_servers" upstream group
 proxy_pass dns_servers;
 }
 

 upstream stream_backend {
 server 10.0.18.4:18840;
 server 10.0.18.5:18840;
 server 10.0.18.6:18840;
 }
 
 upstream dns_servers {
 server 10.0.18.4:18840;
 server 10.0.18.5:18840;
 server 10.0.18.6:18840;
 }
}
  1. Crearemos un bloque “stream {}” de primer nivel
  2. Definiremos uno o más bloques “server {}” para configurar cada servidor virtual dentro del bloque stream.
  3. Dentro de cada bloque server definiremos mediante la directiva “listen” el puerto en el que el servidor (nginx) escucha tráfico (si es tráfico udp lo especificamos).
  4. Incluiremos además dentro de “server” la directiva “proxy-pass” para definir el servidor o el grupo de upstreams en los cuales se redigirá el tráfico.
  5. Definimos uno o más bloques “upstream {}” de configuración dentro del bloque “stream” estableciendo un nombre a los mismos.
  6. Añadimos a los upstreams una directiva “server” por cada uno de los servidores Redis junto con su dirección IP y su puerto

Conclusión

Hasta aquí la configuración más básica, podemos especificar además el método de balanceo de carga (round-robin, least_conn, least_time, hash) así como parámetros específicos tanto para el número de conexiones máximo, el peso de cada servidor, etc. Al igual que el tráfico de Redis esta solución es aplicable a todo tráfico de red a través del protocolo TCP/UDP. Tienes más información aquí: tcp-load-balancing

 

 

 

Controla la calidad del código con SonarQube

El software SonarQube, anteriormente llamado Sonar es la plataforma abierta más popular para gestionar la calidad del software.

Todos los implicados en el desarrollo de software estamos concienciados en que es indispensable construir buen código, aunque estarás de acuerdo conmigo en que no siempre se consigue. Errores en el software han provocado graves problemas, pérdidas millonarias, e incluso muerte de personas. Podéis leer los siguientes ejemplos: List of software bugs y Top 8 de errores informáticos más costosos de la historia.

Sonarqube nos ayuda en nuestra tarea. Es software libre y evalúa el código fuente usando diversas herramientas de análisis cómo Checkstyle, PMD o FindBugs. Este análisis se consolida en métricas que nos ayudarán a medir y mejorar la calidad de nuestro software. La plataforma cubre 7 ejes para realizar el análisis:

  • Reglas de codificación
  • Diseño y Arquitectura
  • Código duplicado
  • Complejidad del código
  • Pruebas unitarias
  • Errores potenciales
  • Comentarios en el código

sonar1

SonarQube es extensible mediante plugins, de manera que es posible analizar más de 20 lenguajes de programación, incluidos Java, C#, C/C++, PL/SQL, Cobol… Estos plugins permiten de igual manera añadir nuevos lenguajes e incorporar nuevas reglas o métricas avanzadas.

SonarQube es una aplicación basada en web, por lo que las reglas, alertas, configuraciones y demás se pueden configurar online. Además, su base de datos embebida puede ampliarse y configurar una externa como MySQL, Oracle, PostgreSQL, etc. No sólo permite combinar métricas, sino también comparar con las medidas históricas. Otra característica primordial es que puede integrarse en servidores de integración continua.

Instalación

La plataforma está compuesta de tres elementos:

  • Una base de datos para almacenar la configuración de la instancia y los resultados del análisis de proyectos, vistas, etc.
  • Un servidor web para visualizar los análisis y configurar la instancia.
  • Uno o más analizadores para analizar proyectos.

Como hemos dicho SonarQube se distribuye con una base de datos embebida, así que para comenzar a trabajar tan solo tenemos que descargar la última versión del servidor y descomprimirla en un directorio.

Una vez completada, ejecutamos el proceso del servidor ejecutando:

  • Linux / Mac: <directorio_instalación>/bin/<tu_sistema_operativo>/sonar.sh
  • Windows: <directorio_instalación>/bin/windows-x86-XX/StartSonar.bat

Por defecto está configurado en el puerto 9000 (http://localhost:9000), pero es posible modificarlo en el fichero de configuración sonar.properties que se encuentra en el directorio conf del directorio de instalación.

Analizadores

Están disponibles los siguientes analizadores:

  • SonarQube runner: recomendado para proyectos sin Maven
  • Maven: recomendado para proyectos “mavenizados
  • SonarQube Ant Task: Para integrar proyectos con Ant
  • Gradle: Para integrar proyectos construidos con Gradle
  • Continuous integration: Plugins para Jenkins, Hudson, Bamboo o AnthillPro.

SonarQube runner es un analizador manual, de manera que ejecutaremos el programa cada vez que queramos realizar un análisis de código. Mediante un fichero de configuración indicaremos tanto la carpeta dónde se encuentra el código fuente como la versión de análisis. Los demás analizadores son programados, por lo que el analizador se ejecutará cuando sea necesario, bien sea una vez al día, cada vez que se construye el proyecto, cada vez que se sube al control de fuentes, todo a la vez, etc.

Métricas

El cuadro de mando de SonarQube es una interfaz web donde podemos ver los resultados del análisis con los puntos débiles a mejorar. Puedes ver un cuadro de mando SonarQube en nemo.sonarqube.org. Las métricas que puedes consultar las configuramos según nuestras necesidades pero por defecto se muestran las siguientes:

  1. Complejidad. Complejidad ciclomática. Cada vez que sonarqube encuentra una sentencia“if”,”for”,”while”,”case”,”catch”, “throw”,”return” (sin ser la última sentencia de un método), “&&”, “||”, “?”, “else”, se aumenta el contador global de complejidad ciclomática en 1. También se aumenta en 1 el contador por la cabecera del método. Otros valores para la complejidad son:
    • Complejidad/método. Media de la complejidad por cada método. debería sobrepasar el valor de 30.
    • Complejidad/clase. Media de la complejidad de todas las clases. Un valor muy elevado de complejidad ciclomática por clase, nos indica síntomas de un mal diseño.
    • Complejidad/fichero. Media de la complejidad por fichero.
  2. Código duplicado. Cuanto mayor sea la complejidad ciclomática y la duplicidad de código, más difícil será mantener el software, por tanto se trata de una métrica básica. Por defecto se considera una duplicidad de código cuando 10 líneas sucesivas de código se encuentran duplicadas. Sonarqube nos muestra las siguientes métricas para esta categoría.
    • Líneas duplicadas.
    • Bloques duplicados.
    • Archivos duplicados.
    • Número de líneas duplicadas (%). (Número de líneas duplicadas/Número total de líneas) *100
  3. Comentarios. La información mostrada para esta categoría:
    • Líneas comentadas. Número de líneas con comentario.
    • Comentarios (%). Si el valor es un 50% indica que la mitad del fichero es código y la mitad comentarios, si es un 100% indica que son todo comentarios.
  4. Test. Muestra el tanto por ciento de cobertura de pruebas unitarias del proyecto, y en caso de que las haya, cuántas de ellas ha pasado nuestro software. Si bien para otras métricas únicamente es necesario analizar el código fuente, para obtener resultados en esta categoría es necesario compilar el código para la ejecución de las pruebas.
  5. Violaciones.
    • “Issues”. Número de violaciones o malas prácticas en el código
    • Cumplimiento de reglas (%): Se calcula con la siguiente fórmula:

100 -((Violaciones ponderadas / Líneas de código) * 100)

Las violaciones ponderadas son la suma de todas las violaciones multiplicadas por su severidad (10 para las violaciones bloqueantes, 5 para las críticas, 3 para las mayores y 1 para las menores). Estos valores pueden ser modificados cuando accedemos como administradores.

 Deuda Técnica

Una de las medidas que no podemos obviar de Sonarqube es la deuda técnica. Es un valor en días que vendría a ser el tiempo aproximado que nos llevaría subsanar todos los problemas encontrados en nuestro software. Según la entrada de wikipedia, es un eufemismo tecnológico que hace referencia a las consecuencias de un desarrollo apresurado de software o un despliegue descuidado de hardware.

sonar2

El origen del término fue propuesto por Ward Cunningham en 1992. En el siguiente vídeo habla sobre este término.

En definitiva, Sonarqube nos va a ayudar a mantener una buena calidad del software construido, comparando las diferentes versiones y almacenando un histórico de las métricas informadas. Hoy en día es una herramienta clave, de uso casi obligado para evaluar el código entregado y liberado a nuestros clientes.

MongoDB para Principiantes

Este post pretende ser una introducción a MongoDB (MongoDB para principiantes), su modelo de datos, sus comandos de shell y sus consultas.

Últimamente he venido interesándome por el mundo de las bases de datos noSQL y más concretamente sobre MongoDB, que es una de las más utilizadas en entornos de producción, y en empresas como Foursquare y Codecademy. Este post pretende ser una introducción a MongoDB (MongoDB para principiantes), su modelo de datos, sus comandos de shell y sus consultas.

MongoDB (del inglés “humongous”, enorme) es una base de datos NoSQL, que en vez de guardar los datos en tablas, como en las bases de datos relacionales, se almacenan en estructuras de datos JSON.

Comenzó a desarrollarse en octubre de 2007 por la compañía 10gen. En 2009 se lanzó como producto independiente publicado con licencia de código abierto. Actualmente hay versiones para Windows, Linux, OSX y Solaris.

DataModel

Una instalación de MongoDB alberga una o varias bases de datos,y cada una de ellas un conjunto de coleccciones. A su vez cada colección alberga uno o varios (pudiendo ser un número enorme de ellos) documentos. Un documento es cada registro existente en una colección y la unidad básica de datos en MongoDB. Son análogos a objetos JSON pero en base de datos se almacenan en un formato más rico conocido como BSON (Binary JSON). La estructura de un documento se compone de pares “clave-valor“, separadas por “:”:

{
   field1: value1,
   field2: value2,
   field3: value3,
   ...
   fieldN: valueN
}

Cada valor, a su vez, puede ser otro documento. A continuación se muestra un ejemplo:

{
    "_id": ObjectId("4efa8d2b7d284dad101e4bc7"),
    "Last Name": "Johnson",
    "First Name": "Michael",
    "Age": 29,
    "Address": {
        "Street": "1 chemin des Loges",
        "City": "VERSAILLES"
    }
}

El campo “_id” es único en la colección. Si no lo incluimos en el documento a la hora de insertarlo en la colección, MongoDB asignará uno por defecto.

Los documentos utilizan un esquema dinámico. Esto quiere decir que los documentos dentro de una misma colección no necesitan tener los mismos campos ni estructura, y los campos comunes pueden tener distintos tipos de datos. Esta flexibilidad permite elegir el modelado de datos que más se adapte a la aplicación y a sus requisitos de rendimiento. El siguiente documento podría almacenarse junto al anterior ejemplo en la misma colección:

{
    "_id": ObjectId("d2b7d24efa884de4bc7ad101"),
    "Last Name": "Allison",
    "First Name": "Robert",
    "Hobbies": ["music", "sports"]
}

Instalación

Lo primero es descargar el software desde la página correspondiente. Existen versiones para los sistemas operativos más utilizados (Windows, Linux, OSX y Solaris) en versiones de 32 y 64 bits. La versión de 32 bits tiene el problema de estar limitada a 2Gb de datos entre todas las colecciones que almacene. Tras descargarnos el fichero zip o tgz, lo descomprimimos en el sistema de ficheros. En la carpeta principal de la instalación existirá una carpeta bin con las utilidades de la base de datos.

Para ejecutar MongoDB es necesario que exista en el directorio raíz (C:\ en Windows) la siguiente ruta C:\data\db como destino de los datos. En el momento de lanzar la ejecución de MongoDB podemos modificar la ubicación de esta ruta. A continuación ejecutamos desde línea de comandos

C:\mongodb\bin\mongod.exe

Este comando lanzará el proceso de MongoDB y si todo va bien aparecerá el mensaje “waiting for connections”. Para especificar otra ruta para los datos lo haremos indicando el directorio de datos tras el parámetro –dbpath:

C:\mongodb\bin\mongod.exe --dbpath d:\test\mongodb\data

También es posible ejecutar MongoDB como un servicio de Windows. Para instalarlo como servicio

Mongo Shell

Desde otra consola de comandos ejecutamos el siguiente comando:

C:\mongodb\bin\mongo.exe

Mongo shell (mongo.exe) conectará con el proceso mongod.exe que está ejecutando en la máquina local en el puerto 27017 por defecto. Para comprobar que está todo correcto ejecutamos los siguientes comandos:

db.test.save( { a: 1 } )
db.test.find()

El comando save ejecutado sobre la colección test, guarda el documento JSON pasado como parámetro a la función. Después de ejecutar el comando find(), obtenemos el único documento de la colección. A ese documento, como ya habíamos apuntado anteriormente MongoDB le añade un id único:

{"_id" : ObjectId("52fa4fe0d5ac743a52aa98e1"), "a" : 1 }

Por defecto usamos la base de datos test. Para ver las bases de datos utilizamos los siguientes comandos:

> show dbs
curso 0.203125GB
enron 1.953125GB
local 0.078125GB
test 0.203125GB
> use enron
switched to db enron

Junto al nombre de la base de datos, aparece el tamaño que ocupa en el sistema de ficheros. El comando use enron, cambia la base de datos de trabajo y sobre la que se ejecutan las operaciones de la shell. Para visualizar las colecciones de una base de datos ejecutamos el comando:

> show collections
messages
system.indexes

Hay que señalar que no existe ningún comando para crear una base de datos, pero podemos hacerlo con el comando use nombrenuevadb, e insertar un documento en una colección con save. MongoDB creará tanto la base de datos como la colección:

> use customers
switched to db customers
> db.clientes.save({"nombre":"juan"})
> show dbs
curso 0.203125GB
customers 0.203125GB
enron 1.953125GB
local 0.078125GB
test 0.203125GB
> db.clientes.find()
{ "_id" : ObjectId("531995937efc2c88b31af841"), "nombre" : "juan" }

Operaciones CRUD

Definimos operaciones CRUD como las operaciones para crear, leer, actualizar y borrar (Create, Read, Update and Delete) .

Consultas

Para realizar queries, MongoDB provee el método db.collection.find(), siendo collection el nombre de la colección a consultar:

Obtener todos los documentos de una colección

db.inventory.find()

Obtener todos los documentos de una colección que cumplen el valor para el tipo especificado {<field>:<value>}. Se puede indicar más de un valor para el campo con $in

db.inventory.find({tipo:"juguetes"})
db.inventory.find({tipo: { $in: ['comida', 'juguetes'] }})

Obtener todos los documentos de una colección que cumplen más de un valor (AND) para los tipos especificados {<field>:<value>}. Se pueden comparar valores con $lt (menor que) y $gt (mayor que).

db.inventory.find({tipo:"juguetes", precio: { $lt: 9.95 }})

Se pueden configurar queries con operadores OR.

db.inventory.find(
                   { $or: [
                            { qty: { $gt: 100 } },
                            { price: { $lt: 9.95 } }
                          ]
                   }
                 )

Y combinaciones de AND y OR.

db.inventory.find( { type: 'food', $or: [ { qty: { $gt: 100 } },
                                            { price: { $lt: 9.95 } 
                                          } ]
                   } )

Para retornar unos campos específicos en la consulta, los indicamos como segundo parámetro del método find. En el ejemplo sólo retorna los campos item y qty:

db.inventory.find( { type: 'food' }, { item: 1, qty: 1 } )

Para indicar que un campo no queremos que se retorne en la consulta en vez de un 1 asignamos un 0.

db.inventory.find( { type: 'food' }, { item: 1, qty: 1, _id:0 } )

Si queremos que devuelva todos los campos excepto los excluidos, únicamente indicamos éstos.

db.inventory.find( { type: 'food' }, { qty: 0 } )

Inserciones

Se pueden insertar documentos a través de varios métodos. El primero con la llamada al método insert() con el documento a insertar

db.inventory.insert( { _id: 10, type: "misc", item: "card", qty: 15 
} )

El segundo método es a través de la llamada al método update() con el flag upsert:true

db.inventory.update(
                     { type: "book", item : "journal" },
                     { $set : { qty: 10 } },
                     { upsert : true }
                   )

Intenta actualizar el registro Si no especificamos la clave _id, Mongo nos creará una por defecto que además es única

El tercer método es invocando al método save() con el documento a insertar. Si el documento pasado no contiene _id, mongo creará igualmente una clave única.

db.inventory.save( { type: "book", item: "notebook", qty: 40 } )

Actualizaciones

El método update() actualiza un único documento que coincide con el criterio de búsqueda pasado como primer parámetro, con los datos pasados en el documento del segundo parámetro. Podemos pasar la opción multi : true para indicar que se guarden varios.

db.inventory.update( { type : "book" }, { $inc : { qty : -1 } },
   { multi: true }
)

También se puede actualizar un documento por su clave “_id” mediante el método save()

db.inventory.save( { _id: 10, type: "misc", item: "placard"  })

Borrados

El borrado de todos los documentos se hace con remove() o drop()

db.inventory.remove()
db.inventory.drop()

Para el borrado de documentos que coinciden con un criterio de búsqueda

db.inventory.remove( { tipo: "comida" } )

Para profundizar en éste y otros temas podemos acudir al manual en línea de MongoDB o apuntarse a alguno de sus cursos gratuitos.

Integrar Twitter Bootstrap con Ruby on Rails

Twitter Bootstrap es un framework que nos ayuda a desarrollar de forma rápida aplicaciones web. Provee una amplia variedad de código CSS y Javascript para implementar layouts, navegaciones y formularios, así como soporte para diseño adaptativo (Responsive Web Design).

Una opción para usar Bootstrap es la de descargarnos desde la página del framework el CSS y el Javascript e importarlos en el directorio /app/assets/ de nuestro proyecto rails, pero esta no sería la mejor manera de hacerlo si usamos Rails. Twitter Boostrap está escrito con LESS, que es un preprocesador de CSS similar al que usa Rails (SASS), así que si queremos aprovechar todo el potencial de Bootstrap, deberíamos usar un lenguaje como LESS, en lugar de ficheros estáticos. Para integrar LESS con Rails debemos usar varias gemas, como twitter-bootstrap-rails, que es la que yo he usado, aunque hay otras opciones.

Para integrar Bootstrap debemos partir de una aplicación rails ya creada mediante la orden rails new [nombre_app], así como algún modelo del tipo rails g scaffold product name price:decimal –skip-stylesheets. Hemos utilizado la opción --skip-stylesheets porque queremos utilizar las CSS de Bootstrap en lugar de la que sería generada automáticamente. Después, generamos la tabla en base de datos con rake db:migrate. Una vez hecho esto ya es posible ejecutar la aplicación pero con un aspecto nada atractivo todavía. Es hora de integrar Bootstrap.

Lo primero que hay que hacer es añadir la gema twitter-bootstrap-rails al fichero Gemfile que se encuentra en el directorio raíz de la aplicación.

/Gemfile
# Gems used only for assets and not required
# in production environments by default.
group :assets do
        gem 'sass-rails',   '~> 3.2.3'
        gem 'coffee-rails', '~> 3.2.1'

        # See https://github.com/sstephenson/execjs#readme for more supported runtimes
        # gem 'therubyracer'

        gem 'uglifier', '>= 1.0.3'
        gem 'twitter-bootstrap-rails'
end

Instalamos twitter-bootstrap-rails y sus dependencias (libv8 y less-rails) ejecutando bundle install. Una vez ejecutada la orden anterior, llamamos al generador para finalizar el proceso de instalación y colocar Bootstrap (javascript, css) en el directorio /app/assets.

$ rails g bootstrap:install
insert  app/assets/javascripts/application.js
create  app/assets/javascripts/bootstrap.js.coffee
create  app/assets/stylesheets/bootstrap_and_overrides.css.less
gsub  app/assets/stylesheets/application.css
gsub  app/assets/stylesheets/application.css

En el directorio css está situado el fichero bootstrap_and_overrides.css.less, que es el sitio ideal para personalizar nuestros estilos de la aplicación. De echo, si ejecutamos a continuación la aplicación, veremos que la misma tiene otro aspecto, aunque aún es mejorable.

A partir de ahora empezaríamos a diseñar el layout de la aplicación. Editaremos el fichero application.html.erb para incluir el header (encabezado) de todas las páginas de la aplicación:

/app/views/layouts/application.html.erb 
<!DOCTYPE html>
<html>
    <head>
            <title>Store</title>
            <%= stylesheet_link_tag    "application", :media => "all" %>
            <%= javascript_include_tag "application" %>
            <%= csrf_meta_tags %>
    </head>
    <body>
        <div class="container">
                <%= yield %>
        </div>
    </body>
</html>

Con el código insertado entre los tags head mejoramos el comportamiento de HTML5 para versiones anteriores de Internet Explorer, e incluimos los META para incluir Responsive Design para su mejor visualización en los dispositivos móviles. A partir de este momento podemos incorporar cualquier elemento que aparece en la sección de componentes de Bootstrap siguiendo la documentación existente, de manera fácil e intuitiva y utilizando el fichero bootstrap_and_overrides.css.less para personalizar los estilos.

Lo Básico

Si nunca has utilizado Bootstrap debes saber que utiliza un sistema de rejilla de 12 columnas, lo que facilita la creación de un layout especificando la anchura de cada columna. Este layout será responsive, por lo que si modificamos el ancho de la ventana, el contenido se adaptará al nuevo ancho, ideal para visualizar el diseño con un smartphone o tablet. Un ejemplo sería el siguiente, que crea una barra lateral con tamaño de 3 columnas (span3) y el contenido de nuestra aplicación en 9 columnas (span9).

 /app/views/layouts/application.html.erb 
<!DOCTYPE html>
<html>
    <head>
            <title>Store</title>
            <%= stylesheet_link_tag    "application", :media => "all" %>
            <%= javascript_include_tag "application" %>
            <%= csrf_meta_tags %>
    </head>
    <body>
        <div class="container">
                 <div class="row">
                      <div class="span9"><%= yield %></div>
                      <div class="span3">
                         <h2>About Us</h2>
                         <p>Lorem ipsum dolor sit amet, 
consectetur adipisicing elit, sed do eiusmod tempor incididunt 
ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis 
nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo 
consequat. Duis aute irure dolor in reprehenderit in voluptate 
velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint 
occaecat cupidatat non proident, sunt in culpa qui officia deserunt 
mollit anim id est laborum.</p>        
                      </div>
                 </div>
       </div>
    </body>
</html>

Para añadir una barra de navegación responsive en la parte superior de la pantalla, cuyo menú se colapse en un icono desplegable con los enlaces del menú cuando el ancho de la ventana se reduzca, Bootstrap incluye estilos para el siguiente código:

/app/views/layouts/application.html.erb
<div>
    <div>
        <div>
            <a data-toggle="collapse" data-target=".nav-collapse">
                <span></span>
                <span></span>
                <span></span>
            </a>
            <a href="#">Some Store</a>
            <div>
                <ul>
                    <li><%= link_to "Browse Products", products_path %>
                          </li>
                    <li><%= link_to "Price List" %></li>
                    <li><%= link_to "Contact Us" %></li>
                    <li><%= link_to "Cart" %></li>
                </ul>
            </div>
        </div>
    </div>
</div>

 

somestore

En este post hemos visto como integrar Bootstrap en una aplicación rails mediante twitter-bootstrap-rails, como personalizar los estilos en el fichero bootstrap_and_overrides.css.less mediante LESS y como incorporar componentes básicos en nuestra aplicación.

Buscar Ficheros de Gran Tamaño

Cómo buscar y listar todas aquellos ficheros de imágenes de gran tamaño, digamos mayor de 1Mb. Con un sencillo comando desde el terminal de linux en el servidor es posible.

En uno de los proyectos en los que trabajo manejamos una gran cantidad de imágenes que se publican en la web, y es posible su visualización mediante un visor, que permite sencillas transformaciones en las mismas. Las imágenes se van cargando en el servidor de forma periódica ya que existen diversas fuentes de las mismas. En la última carga aparecieron un gran número de ellas cuyo tamaño era excesivo para su publicación en Internet, lo que conllevaba problemas en el visor de las mismas, así como numerosos errores de memoria en el servidor, en el momento de aplicar transformaciones. El dilema era cómo buscar y listar todas aquellos ficheros de imágenes de gran tamaño, digamos mayor de 1Mb.

Lo primero que se nos ocurrió fue desarrollar un proceso en lenguaje java que leyera todas las rutas de las imágenes de la base de datos y se recorriera fichero a fichero para consultar su tamaño. Si era mayor, almacenábamos su nombre y ruta, junto con su tamaño en una lista que, al finalizar el proceso, guardábamos en un fichero de texto.

Al final no es necesario implementar lo descrito en el párrafo anterior, con un simple comando de la shell de linux, fuimos capaces de generar el listado. Abrimos un terminal y tecleamos lo siguiente:

find /MOUNTFIC/PERGAMINOS_INCUNABLES_1  -type f -size +1000k -printf "%h/%f\t%s\n" >> imagenesGrandes.txt

El comando anterior busca en el directorio pasado en el primer parámetro y en todos sus subdirectorios, todos los ficheros, para eso escribimos que el tipo sea f (-type f), cuyo tamaño sea superior a 1Mb (-size +1000k). El código que se muestra a continuación, -printf “%h/%f\t%s\n” formatea la salida, escribe: la ruta + nombre del fichero + tabulador + tamaño del fichero. Separamos cada fichero con un retorno de carro. Con el código >> imagenesGrandes.txt vamos agregando los registros al fichero del mismo nombre.

En el caso de que tengamos las imágenes en varios directorios podemos lanzar este comando varias veces sobre diferentes directorios. El contenido del fichero de texto con el listado de los ficheros no se va machacando con cada ejecución, sino que se va añadiendo al final. Si quisiéramos que se machacara la información deberíamos escribir un sólo signo de mayor que (> imagenesGrandes.txt).