Backup de MongoDB en sharding con LVM

noviembre 10th, 2011 sistemas Juan Vicente Herrera no comments

En primer lugar comentar que la  instalación sobre la que vamos a tratar consiste en dos nodos con sharding, uno de ellos hace además de config y router.

En las pruebas realizadas con los comandos mongodump y mongorestore, la restauración de datos no ha sido satisfactoria y estable, puesto que en algunos casos se pierde la configuración del sharding y en otras no se restauran los datos correctamente, aun usando la opción –oplog que permite escribir los datos recién escritos mientras se hace el backup. A partir de cierto volumen de datos (2.000.000 de registros) se queda colgado el restore.

La versión utilizada es la 2.0. El sistema de ficheros empleado en las particiones donde se alojan los datos del Mongo es ext4 con LVM.

La manera de realizar el backup de manera más fiable (aunque con la importante pega de no ser un backup incremental) es realizando un snapshot del volumen lógico(previo bloqueo de las escrituras en la base de datos), para posteriormente realizar un backup de ese snapshot en el directorio remoto que deseemos. De esta manera solo se bloquean las escrituras en la base de datos durante el tiempo que tarde en hacerse el snapshot.

Partimos de la siguiente infraestructura:

En cada máquina tenemos la siguiente configuración de particiones:

• 1 lvm con el sistema /
• 1 lvm con los datos de Mongo /var/lib/mongodb
• Espacio para crear un snapshot de la partición  anteriormente mencionada(si /var/lib/mongodb ocupa 40 gb, necesitamos otros 40 gb libres por lo menos para crear el snapshot).

Os dejo un pequeño resumen de como redimensionar un volumen LVM,  así como crearlos por si fuera necesario(especialmente necesario si esta montado todo el sistema Linux en un solo volumen lógico).

Una vez cumplimos estos requisitos previos  nos conectamos a la consola del Mongodb:

#mongo -port 30000

y bloqueamos las operaciones de escritura sobre la base de datos:

mongo1$ use admin
mongo1$ db.runCommand({fsync:1,lock:1})

A continuación realizamos una copia exacta del volumen lógico donde guardamos los datos del mongo:

mongo1$  lvcreate -L40G -s -n mongosnapshot /dev/mapper/lvmcondatosmnongo

desbloqueamos las escrituras en en la base de datos(todas las operaciones pendientes seran ejecutadas):

mongo1$ db.$cmd.sys.unlock.findOne()

Y ahora ya podemos hacer el backup sobre esta imagen recien creada. Para ello montamos la imagen en un directorio de nuestra elección:

#mkdir -p /mnt/backup/mongonapshot

#mount /dev/mapper/mongosnapshot /mnt/backup/mongosnapshot

Ahora tenemos que elegir si queremos una copia exacta a nivel de bloques físicos o una copia a nivel de ficheros. Recomiendo la opción de ficheros para restaurar con más rapidez y optimizar el espacio en disco. Con la copia a nivel de disco, copiamos también el espacio no usado.

Fichero: #tar -pczf /backups/mongo.tar.gz /mnt/backup/mongosnapshot

Disco: #dd if=/mnt/backup/mongosnapshot of=/backups/mongo.dd

¡Ya tenemos backup!

Ahora sólo queda restaurar los datos, para lo que tendríamos que para los servicios en cada nodo y descomprimir la copia:

# /etc/init.d/mongodb stop
#tar zxvf  backups/mongo.tar.gz /var/lib/

o restaurar la imagen de disco:

#dd if=/backups/mongo.dd of=/var/lib/mongodb

Referencias:

http://www.howtoforge.com/linux_lvm_snapshots_p1

http://www.mongodb.org/display/DOCS/Backups

Tags: backup. mongodb, lvm

Redimensionar volumenes lógicos (LVM)

octubre 25th, 2011 sistemas Juan Vicente Herrera no comments

En ocasiones tenemos un sistema de ficheros LVM donde se aloja todo el sistema operativo y luego surge la necesidad de crear otros volúmenes lógicos sin añadir otro disco duro para aumentar el espacio, es decir tenemos que reducir el volumen lógico actual para dar cabida a los nuevos.

Por ejemplo podemos necesitar un nuevo volumen lógico para tener un sistema de ficheros distinto al del sistema operativo para aumentar el rendimiento de un servicio, realizar un backup mediante una imagen exacta del volumen etc …

Esta operación en un volumen lógico que no aloje los directorios del sistema operativo básicos es más fácil al poder desmontarse, pero en el sistema raíz es más complicada.

Para ello necesitaremos un  disco que contenga un sistema operativo Linux que arranque en modo “Live”.

Nosotros usaremos para este ejemplo Ubuntu 11.04.

Tras arrancar mediante el cd y seleccionar la opción “Probar Ubuntu”, abrimos una terminal e instalamos las utilidades LVM:

#apt-get install lvm2

Tras ello montaremos los volúmenes lógicos de nuestro sistema de ficheros mediante la siguiente instrucción:

#lvm vgchange -a y

Miramos cuanto espacio ocupa actualmente el sistema para no reducir más de la cuenta la partición:

#df -h
S.ficheros Tamaño Usado disp Uso% Montado en
/dev/mapper/root     60G         30G          50%        50%    /

Antes de redimensionar el volumen lógico chequeamos el correcto estado del volumen:

#vgdisplay

#lvdisplay

#lvcreate -L 25G -n backup VG Name(mostrado previamente con vgdisplay)

Tags: linux, lvm

Enumeraton

septiembre 7th, 2011 android, desarrollo, java, Uncategorized pablisco no comments

The Multiton pattern is a quite an unknown design pattern for many developers. Probably because is not included in the classic Design Patterns book by the Gang of Four or maybe because it can also be seen as several singleton objects merged together.

The basis of this pattern is to have a set of objects where each can be accessed statically, like on the Singleton pattern, but providing an identifier (e.g. a string value) or a specific method for each one. Generally it is backed up by an internal map and objects are lazily initialized if the object is not found inside the map. In the Android SDK, for instance, they use this pattern under Context object. It provides a way to get a system service by providing the method getSystemService(String) with the name of the service. Here is a simple implementation of a Multiton in such way:

class DynamicMultiton {
		private static Map map = new HashMap();

		public Uri getUri(String service) {
			Uri result = map.get(service);
			if (result == null) {
				result = Uri.parse("http://" + service + ".com");
				map.put(service, result);
			}
			return result;
		}

	}

If we have a finite number of objects that are going to be allowed to be generated it is possible to have static constants that are accessed by named methods like it’s shown here:

class StaticMultiton {
		private static Uri oosUri = null;
		private static Uri googleUri = null;

		public Uri get11870Uri() {
			if (oosUri == null) {
				oosUri = Uri.parse("http://11870.com");
			}
			return oosUri;
		}

		public Uri getGoogleUri() {
			if (googleUri == null) {
				googleUri = Uri.parse("http://google.com");
			}
			return googleUri;
		}

	}

This example can be understood as a compound singleton or a static multiton and can be useful, as an example, to provide the concrete instances of abstract factories.

With this post I am introducing a third implementation of this pattern, that simplifies its use in code and increases its performance when running. We part from the case of the dynamic multiton where a static map is used to store the objects. Well, in Java we have another way to implement key-value tables which is not commonly seen as such. These are the Enum types. Internally, a Java enumeration is a especial form of key-value table in which each entry is both the key and the value.

This is an example of how Enums can be used to load Android Animation instances with an Enum:

public enum Animations {

	FadeIn(android.R.anim.fade_in),
	FadeOut(android.R.anim.fade_out),
	SlowFadeIn(R.anim.slow_fade_in),
	LeftToRight(R.anim.animation_left_right),
	RightToLeft(R.anim.animation_right_left),
	LeftToRightOut(R.anim.animation_left_right_out),
	RightToLeftOut(R.anim.animation_right_left_out),
	Down(R.anim.animation_down),
	Up(R.anim.animation_up);

	private int resId;
	private Animation animation;

	private Animations(int resId) {
		this.resId = resId;
	}

	public Animation get(Context context) {
		if (animation == null) {
			animation = AnimationUtils.loadAnimation(context, resId);
		}
		return animation;
	}

}

The only problem with this implementation, as with static multiton implementations, is that you have to edit the enum to add new values, and therefore it’s less flexible than the dynamic multiton. Although with enumerations it’s rather trivial to add new values. On the other hand it has a very good advantage over dynamic implementations and this is that you save the lookup time for the key provided.

Tags: android, anumeraton, design patterns, enum, enumerations, java, multiton, singleton

Jetpack; Lo mejor de la nube de wordpress.com en un solo plugin.

septiembre 5th, 2011 blog, wordpress Juan Vicente Herrera no comments

Jetpack,el cual ha sido desarrollado por Automatic, es un conjunto de características ofrecidas en el alojamiento gratuito y distribuido wordpress.com empaquetadas en un solo plugin, que te permite conectar tu blog basado en una instalación propia de WordPress  con tu cuenta de wordpress.com para beneficiarte de las características basadas en el alojamiento cloud computing de wordrpress.com, antes sólo disponibles para usuarios de dicho alojamiento.

¿Que oferece Jetpack?

Instalando Jetpack podrás aprovecharte de las siguientes funciones, que no son novedosas ya que mediante plugins ya existentes todas están disponibles, pero si son mucho más manejables ahora al estar integradas a la perfección mediante este plugin:

1. Gravatar Hovercards
Esta característica te mostrará un pop-up  de los perfiles de los usuarios de Gravatar en los comentarios que te ayuda a obtener más información del usuario, incluyendo el nombre completo, perfiles bio, web …

2. Twitter Widget
El widget de Twitter muestra tus tweets más recientes dentro de una barra lateral en el tema. Sencillo y claro.

3. WordPress.com Stats
Hay muchos plugins y servicios que proporcionan las estadísticas, pero los datos pueden ser abrumadores. WordPress.com Stats hace más comprensibles las estadísticas mediante gráficas y una interfaz muy atractiva y sencilla de usar. Es de destacar que se haya dejado atrás la versión flash, era necesario.

4. Shortcode Embeds
Códigos cortos que permiten integrar rápidamente un clip de vídeo, imágenes y mucho más … desde otros servicios en tu sitio. Sólo debes usar la etiqueta adecuada según el caso. Muy sencillo y limpio aunque poco novedoso hoy en día.

5. After the Deadline
Me gusta mucho esta característica mediante la cual se puede comprobar la ortografía, gramática y estilo cuando publiques un nuevo post en el blog.

6. WP.me ​​Shortlinks
En lugar de escribir o copiar y pegar direcciones URL larga, ahora puede obtener un enlace corto y sencillo para sus mensajes y páginas. Se utiliza el dominio wp.me, y le da una URL única que puedes utilizar siendo seguro y fiable.

7. LaTeX
LaTeX es un lenguaje de marcas de muy potente destinado a escribir ecuaciones matemáticas complejas, las fórmulas en el editor de entradas etc …

8. Sharedaddy
Esta función crea una barra que permite compartir el contenido con Facebook, Twitter  y muchos más servicios. La verdad es que ahora es mucho más fácil realizar esta tarea, es otra de las funcionalidades que se agradecen.

[youtube=http://www.youtube.com/watch?v=wJy08aChGEY]

Como se puede apreciar son funciones básicas pero muy necesarias y bien integradas en un solo plugin.

Instalación

Es muy sencillo y directo instalar el plugin. El único requisito es tener una cuenta en wordpress.com.

Tras acceder al dashboard de tu blog, debes seleccionar “Añadir nuevo plugin” y buscar por la palabra clave Jetpack:

Después de la instalación tenemos que conectar nuestra instalación de Jetpack con nuestra cuenta de wordpress.com

Tras seleccionar “Connect to WorPress.com” e indicar usuario y contraseña de nuestra cuenta, nos informará de que estamos correctamente conectados y tendremos a nuestra disposición todas las mejoras, accesibles desde el menú correspondiente.

Tags: jetpack, plugin, wordpress

Añadir un acceso directo a un sitio en Android

julio 14th, 2011 Uncategorized pablisco 2 comments

Tags: android, utilidad