El problema lo he encontrado a la hora de configurar el envío de correos electrónicos desde un Drupal ya instalado en el servidor del cliente y con pocas opciones de acceso a según que directorios. Estoy a la espera de que me solucionen un problema de conexión con el SMTP del mismo, pero lo he probado con el SMTP de GMail y funciona perfectamente. Os presento este último caso.

Recordamos los datos de conexión SMTP de GMail

host: smtp.gmail.com
puerto: 465
usar SSL
usuario:  tuemail@gmail.com
contraseña: tuContraseñaEnGmail

¿Qué debemos tener instalado?

Opcional: Para poder enviar emails con HTML yo he instalado el módulo MIMEMail de Drupal.

• Librería de PHPMailer, necesitaremos extraer sobretodo las clases class.phpmailer.php y class.smtp.php.
• PHPMailer, el módulo de Drupal.

Para más información sobre la instalación y configuración de estas librerías y módulos podéis ver los archivos ‘README’ correspondientes.

1. Extraemos la librería y el módulo de Drupal en una carpeta de nuestro ordenador.
2. Dentro de la carpeta /phpmailer (correspondiente al módulo de Drupal) veremos que existe otra carpeta con el mismo nombre ‘phpmailer’.
   Veréis que hay un archivo ‘COPYHERE.txt’, lo único que contiene son los archivos que debemos copiar en esta segunda carpeta. Una vez realizada la copia podemos eliminar el .txt.
3. Abrimos la carpeta de la librería que ya hemos descomprimido y buscamos las clases class.phpmailer.php y class.smtp.php . Las copiamos, y las enganchamos en la carpeta del módulo de paso 2 (/phpmailer/phpmailer).
4. Mediante nuestro cliente de FTP, subimos la carpeta del módulo de Drupal con las clases de la librería incluidas en el directorio correspondiente (/modules).

¿Cómo se usa?

• Activamos el PHPMailer en el listado de Administración de módulos ( /admin/build/modules ). Una vez activado aparecerá un aviso que nos dice que debemos configurar el módulo; seguimos el enlace que nos aparece para configurarlo.
• En mi caso, el enlace me lleva a la configuración de MIMEMail que es el módulo que utilizo para enviar email con HTML. Desde allí mismo puedo configurar la conexión SMTP.
  NOTA: He probado de tener instalado el módulo SMTP auth al mismo tiempo, y al final sólo acaba repitiendo la misma funcionalidad. No aporta ninguna configuración nueva, por lo que al final lo desinstalé.
• En la configuración desde MIMEMail para el SMTP:

1. Escogemos el motor para el Envío de emails: PHPMailer
   
2. Configuramos el motor, probamos con los datos de conexión SMTP para una cuenta de GMail
   
3. Introducimos los datos de autentificación del SMTP (en el caso de tenerlos)
   
4. Configuramos las opciones avanzadas (opcional): tal como introducir un email válido para cuando el destinatario quiere responder al email que le hemos enviado, o habilitar los avisos en los logs (modo Developper de Drupal) en el caso de que se produzca un error en el envío del mail.
5. Envíamos un email de prueba
   

El envío es casi inmediato . Espero que os haya servido este mini-tutorial si teniáis problemas con el envío de emails con Drupal.

Por cierto, la versión de Drupal que suelo utilizar es la 6 aunque la 7 ya esté operativa. ¿Mi motivo? La mayoría de los módulos que me interesan aún no están preparados para la versión 7 .

Un saludo!

El motivo de la publicación de hoy es la necesidad que hemos tenido de generar un XML con la lista de contactos de la que hablábamos el otro día (aquí y aquí), y el lenguaje escogido es el que utilizamos normalmente: PHP5. El método que os presentaré es muy sencillo y ha sido compuesto con funcionalidades relacionadas con XMLWriter (propia de PHP5).

El listado de contactos importados de una cuenta de Gmail por ejemplo, es guardado en un array. Dicho array es pasado como parámetro del método que presento a continuación y dentro de él, se genera el XML. Tal que así:

[stextbox id="info"]private function getXML(array $contacts){
$xml = new XMLWriter;
$xml->openMemory();
$xml->startDocument(’1.0′, ‘UTF-8′);
$xml->startElement(‘contacts’);
foreach ($contacts as $email => $name) {
$xml->startElement(‘contact’);
$xml->startElement(‘user’);
$xml->text($name);
$xml->endElement();
$xml->startElement(‘mailbox’);
$xml->text($email);
$xml->endElement();
$xml->endElement();
$xml->writeElement(‘br’, ”);
}
$xml->endElement();
$xml->endDocument();
echo $xml->outputMemory();
}[/stextbox]

NOTA: $xml->writeElement(‘br’, ”); puede eliminarse ya que no debería formar parte del xml.  Pero de esta manera podréis ver si os muestra por pantalla todo el listado correctamente. Lo he utilizado para listar contact(user+mailbox) uno debajo de otro.

Esta solución ha sido ideada después de ver varias documentaciones y páginas web, y os comparto la que ha sido más importante aquí. Cómo en todo lo relacionado con este mundillo, no hay una sola manera (más eficiente o menos) para hacer las cosas y seguro que podéis encontrar muchísimos scripts por ahí, pero espero que os sea de ayuda igualmente. Almenos para que véais por donde podéis empezar a probar.

Para más información sobre las diferentes funcionalidades de XMLWritter, os comparto el enlace de la documentación de PHP que habla sobre ello. Y en el caso que tengáis soluciones mejores, no dudéis en compartirlas aquí también.

Un saludo desde pingüinos y manzanitas world!

Uno de los problemas que teníamos era que OpenInviter trabaja con SQLite, y si no se tiene dicha extensión instalada en el sistema no es posible modificar algunos archivos sqllite con los que trabaja. No sé hasta que punto es esto bueno o no, pero aquí os dejo la posible solución publicada por este usuario:
Si accedemos al archivo conf.php encontraremos una serie de atributos; debemos buscar aquellos que sean ‘state’ y ‘update_files’ cuyo valor es TRUE y cambiarlo a FALSE (estos dos atributos son los que se encargan de la parte SQLite), o en cualquier caso habilitar dicha extensión SQLite y dejar dichos valores como TRUE.

Otro de los problemas era que debemos eliminar, después de haber sido ejecutado, el archivo postinstall.php. Aún desconozco el uso real de dicho archivo, pero así te lo recomiendan en algún punto de la documentación. Con un poco de tiempo quiero investigar un poco más en ello.

Con estos dos problemas solucionados, ya tenemos otro tipo de sistema de importación de contactos de cuentas de GMAIL aunque también probaremos, con OpenInviter, las otras alternativas (importación de contactos de YahooMail, AOL, MSN, LinkedIn o Plaxo -wow -).

Esto es todo, de momento, desde el zulo, pingüinos y manzanitas world!

[stextbox id="info"]var_dump(curl_version());[/stextbox]

Si no está disponible, var_dump no pintará nada por pantalla y saltará un error sobre la función curl_version().

Esto ha sido sacado de la siguiente página web y me ha servido para realizar algunas operaciones en nuestro servidor que requerían de dicha extensión.

¿Cómo ver si está habilitado sobre un entorno Ubuntu?

Debemos proceder a consultar el archivo de configuración de php que tengamos en nuestro sistema. En mi caso, dicho archivo se encuentra dentro de /etc/php5/conf.g/ y se llama curl.ini. Si visualizamos dicho archivo:

[stextbox id="info"]sudo nano curl.ini[/stextbox]

Veremos las siguientes líneas si está habilitado:

[stextbox id="info" caption="curl.ini"]# configuration for php CURL module
extension=curl.so[/stextbox]

En el caso de que delante de extension=curl.so haya un símbolo #, procederemos a borrarlo (NOTA: # es símbolo de comentario, por lo tanto es como si no estuviera escrito y no se ejecuta).

Un saludo desde el zulo, pingüinos y manzanitas world!

El Zend Framework no da soporte a la API de Google Contacts, de momento, así que parte del trabajo que se había realizado para la integración de Youtube y Picasa no servía de mucho -en principio-. He leído en algún foro del Framework que se está trabajando en este nuevo módulo de Zend_GData, pero aún no hay una fecha de salida. Llegados a este punto, no ha quedado más remedio que pasar unas cuantas horas navegando por la red para poder encontrar alguna solución.

La primera de ellas apareció en este post. Después de realizar nuevas clases y aprender un poco el funcionamiento de algunas funciones cUrl, no he conseguido hacerla funcionar finalmente por temas de autentificación y el token de seguridad. Estoy a la espera de recibir un mensaje del desarrollador a ver si nos puede echar una mano en el asunto.

La segunda de ellas apareció de una idea que tuve relacionada con el siguiente post. Del sistema que ya se había montado para Youtube y Picasa se podían añadir unas nuevas operaciones al objeto Zend_GData:

$gdata = new Zend_Gdata($client);
$query = new Zend_Gdata_Query(“http://www.google.com/m8/feeds/contacts/$username/full”);
$feed = $gdata->getFeed($query);
$entries = $gdata->retrieveAllEntriesForFeed($feed);

En nuestro sistema, $client sería un objeto del tipo Zend_Gdata_HttpClient al que le hacemos un set de las cabeceras necesarias para la conexión con los sistemas Google, las llaves privadas y el token de seguridad provisto. Para más información sobre esto, podéis consultar el post de Xavi dónde se explica el proceso que seguimos para sincronizar con Youtube y Picasa. Os comparto el código del método que nos genera dicho objeto $cliente:

private function getClient($singleUseToken){
$fclient = new Zend_Gdata_HttpClient();
$fclient->setHeaders(“X-GData-Key: key=”.’google_key’);
$fclient->setAuthSubPrivateKeyFile(‘path-to-keys’,null, true);
$sessionToken = Zend_Gdata_AuthSub::getAuthSubSessionToken(trim($singleUseToken),$fclient);
$fclient->setAuthSubToken($sessionToken);
return $fclient;
}

Para terminar os comparto el siguiente enlace que será la tercera solución que probaremos. Como se puede ver, es una clase llamada Open Inviter escrita en PHP5 que permite importar contactos de diferentes cuentas y aplicaciones.
Vamos allá!!!

Un saludo desde pingüinos y manzanitas world!

Hemos sudado la gota gorda pero después de 6 días y dos cabezas pensantes, lo hemos conseguido.

En los próximos días se publicará un post en el blog de Xavi, donde se explicará lo que se ha de tener en cuenta para poder comunicarse y subir videos a Youtube. Lo que no se ha conseguido desde la documentación de Youtube, Zend Framework y las API’s de Google (todo junto),… en los próximos días.

Un saludo desde pingüinos y manzanitas world!

Debo decir que tanto para uno, como para el otro, la información que se pueda encontrar (sitios oficiales, comunidades o libros) no están orientados a la práctica y es muy dificil ver hasta dónde puede llegar. Con esta nueva serie de publicaciones intentaremos ejemplificar su uso. Espero que os sirva de ayuda esta mini guía práctica.

Instalación
Insisto en que la mayoría de los ejemplos prácticos que se publican en este blog estan probados sobre la distribución Ubuntu de Linux. Para este caso, utilizaremos la nueva versión 9.04, y como elementos indispensables PHP, MySQL y Apache2.

• Lo primero de todo será que os descarguéis la versión de drupal disponible en su página web oficial. Podéis descargarla directamente aquí. Una vez la tengáis en vuestro ordenador, extraerla y guardarla allí donde queráis tener el proyecto; en este ejemplo se guardará dentro de una carpeta, en /home/usuario, llamada proyecto.
• El siguiente paso será comprobar que tenemos instalados MySQL, Apache2, y PHP. Como herramienta de administración de MySQL yo utilzo Navicat en su versión Lite. Si no téneis ninguno en el sistema ya instalado, podéis descargarlo aquí.
• Como os podéis imaginar, lo siguiente que haremos será modificar los archivos pertinentes para poder habilitar el nuevo proyecto en local. Para ello tocaremos, entre otros, los archivos de Apache2.

1. Habilitar el nuevo sitio, partiendo por ejemplo del archivo default almacenado en /etc/apache2/sites-available y cambiando la ruta del nuevo proyecto. El nombre del nuevo sitio será local.drupal.com.
   [stextbox id="info"]cd /etc/apache2/sites-available
   sudo cp default local.drupal.comEditamos la información de local.drupal.com.
   sudo gedit local.drupal.com[/stextbox]

   Añadimos los siguiente:
   [stextbox id="info"]<VirtualHost *:80>
   ServerAdmin webmaster@localhost
   ServerName local.drupal.com
   DocumentRoot /home/usuario/proyecto/drupal/
   <Directory />
   Options FollowSymLinks
   AllowOverride All
   </Directory>
   <Directory /home/usuario/proyecto/drupal/>
   Options Indexes FollowSymLinks MultiViews
   AllowOverride All
   Order allow,deny
   allow from all
   </Directory>
   …[/stextbox]

2. Editamos el archivo hosts almacenado en /etc/
   [stextbox id="info"]sugo gedit /etc/hosts[/stextbox]

   Y añadimos la siguiente línea:
   [stextbox id="info"]127.0.0.1    local.drupal.com[/stextbox]

3. [stextbox id="info"]sudo a2ensite local.drupal.com[/stextbox]…y reiniciamos el servidor apache
   [stextbox id="info"]sudo /etc/init.d/apache2 restart[/stextbox]

• Una vez hecho todo esto, y antes de ejecutar el archivo que nos permita instalar Drupal, es recomendable cambiar los permisos de la carpeta “drupal”.
  [stextbox id="info"]sudo chmod 777 -R /home/usuario/proyecto/drupal[/stextbox]
• Abrimos el navegador y tecleamos:
  [stextbox id="info"]http://local.drupal.com/index.php[/stextbox]

  NOTA: index.php es el archivo que se carga para empezar la instalación de drupal.

Si os ha dado algún problema, revisad que tengáis todos los elementos necesarios instalados en vuestro sistema y que los archivos de configuración sean correctos. Si no se ha producido ningún error, se os mostrará la siguiente página:

Click en Install Drupal in English (en mi caso)
NOTA: En la versión anterior no funcionaba del todo bien si se instalaba en otro idioma.

En la siguiente pantalla se pedirá que introduzcamos los datos relacionados con la base de datos. Para crear una nueva base de datos, en mi caso con Navicat Lite, abriremos el programa y seguiremos los siguientes pasos.

1. Crearemos una nueva Conexión (clic derecho>new Connection)
   
2. Crearemos una nueva base de datos en esta nueva Conexión (clic derecho>new Database)
3. Cerramos el programa y volvemos al navegador.

Introducimos los datos relacionados con la base de datos que acabamos de crear, y continuamos con la instalación.

Una vez instalado Drupal, se nos pedirá que introduzcamos los datos del site y la cuenta inicial. Aparecerá una pantalla como la siguiente:

Clic a Save And Continue, para finalizar el proceso.

NOTA: Como último paso es necesario seguir las instrucciones que nos aparecen recuadradas en rojo. (imagen de arriba)

Ya téneis vuestro sistema instalado. En las próximas publicaciones intentaremos describir la estructura de los sites hechos con Drupal e intentaremos empezar a introducir contenido -páginas y bloques-.

Esto es todo, por hoy, desde pingüinos y manzanitas world (sin zulo)!!

Saludos!

Ahora, empecemos con la configuración desde cero de un slave en una nueva máquina (Ubuntu 8.10).

1. Accedemos, como hemos comentado antes, al archivo my.cnf para configurar en la nueva máquina el slave.
   
sudo gedit /etc/mysql/my.cnf
2. Añadimos las siguientes líneas en el apartado [mysqld] :
   server-id=2
master-host = ip/DNShost
master-user = usuarioslave
master-password = clave_acceso_slave
master-port= 3306
replicate-do-db=base_datos
   Comentamos las líneas de skip-networking y bind-address, como hemos dicho en el post anterior.
3. Reiniciamos el servidor MySQL
   
sudo /etc/init.d/mysql restart
4. Accedemos a la consola de MySQL como root:
   
mysql -u root -p
5. Miraremos el estado y configuración del slave, por si ya se hubiera inicializado automáticamente al arrancar MySql.
   
SHOW SLAVE STATUS \G;
   Y a continuación, aparecerá algo así:
   *************************** 1. row ***************************
Slave_IO_State: Waiting for master to send event
Master_Host: IP/DNS_host
Master_User: usuarioslave
Master_Port: 3306
Connect_Retry: 60
Master_Log_File: mysql-bin.000002
Read_Master_Log_Pos: 98
Relay_Log_File: mysqld-relay-bin.000021
Relay_Log_Pos: 235
Relay_Master_Log_File: mysql-bin.000002
Slave_IO_Running: Yes
Slave_SQL_Running: Yes
Replicate_Do_DB: base_datos
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table:
Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Master_Log_Pos: 98
Relay_Log_Space: 235
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Master_SSL_Allowed: No
Master_SSL_CA_File:
Master_SSL_CA_Path:
Master_SSL_Cert:
Master_SSL_Cipher:
Master_SSL_Key:
Seconds_Behind_Master: 0
1 row in set (0.00 sec)

   NOTA: Si no se muestran estas opciones del slave, iguales o parecidas, podemos estar frente dos casos:

   • Slave_IO_Running y Slave_SQL_Running estén a No, cuyo significado es que no están corriendo (no se ha producido un START SLAVE; o a fallado). Muchas veces se soluciona escribiendo dicha sentencia en la consola de MySQL.
   • Los datos referentes al master, que hemos especificado en el archivo de configuración del slave, no son los correctos. Esto podría pasar en el caso de que previamente tuviéramos unos datos del máster que por cualquier operación sobre él se hayan modificado. Esto se puede resolver con el uso de la instrucción RESET SLAVE; qué lo que hace es eliminar los datos anteriores a una modificación del master y vuelve a cargar los nuevos introducidos en el archivo my.cnf del slave. Otra opción, que he encontrado por Internet, es el uso de la siguiente sentencia indicando los nuevos atributos del master:
     STOP SLAVE;
CHANGE MASTER TO MASTER_HOST='IP/DNSnueva', MASTER_USER='usuarioslave', MASTER_PASSWORD='clave_acceso_slave', MASTER_LOG_FILE='file_log_determinado' ;
START SLAVE;
     NOTA: Este último paso no lo hemos necesitado ya que, una vez inicializado el slave, ha conectado directamente con el master y ha recogido sus datos.

Con esto hemos acabado esta serie de post sobre la configuración de un master-slave en MySQL. Espero que os sirva de ayuda.

Esto es todo, por hoy, desde el zulo, pingüinos y manzanitas world!! (con el jefe perdido xD…)

NOTA: El sistema operativo sobre el cuál realizamos el montaje es Ubuntu 8.10.

Configuración del master

En este apartado os indicaré los pasos que hemos seguido para montar nuestro servidor master.

1. Como muchos de vosotros estaréis pensando, uno de los pasos necesarios para la configuración del sistema de MySQL es la edición de su archivo de configuración (valgase la redundancia). En este caso, efectivamente, lo primero que tendremos que hacer será editar my.cnf con privilegios de root; para ello, abriremos el terminal y escribiremos la siguiente línia (la ruta puede variar. Os dejo la ruta donde se encuentra mi archivo de configuración):
   
sudo gedit /etc/mysql/my.cnf

2. Introducir en el apartado [mysqld] los siguientes atributos:
   
server-id=1
innodb_flush_log_at_trx_commit=1
sync_binlog=1
log-bin=mysql-bin
binlog-do-db=base_datos


   Vamos por partes:

   • El id del server, para definir un master, debe ser 1. Por eso indicamos que server-id=1.
   • innodb_flush_log_at_trx_commit=1 y sync_binlog=1 son dos atributos que colocamos en este caso (leer más en el artículo anterior) ya que decidímos que el master debería tener como motor de almacenamiento el InnoDB. Para más información, consultar la documentación de MySQL.
   • log-bin debe indicar en que archivo se escribirá el log del máster. En este caso, utilizamos el mismo que utiliza MySQL. Os dejo un tutorial en el que podréis ver que este archivo log puede destinarse en cualquier lugar.
   • binlog-do-db=base_datos , le indica al master sobre qué base de datos debe guardar la actividad.

   IMPORTANTE: Comentaremos las opciones de skip-networking y bind-address que se encuentran en ese mismo archivo de configuración, en el caso de que existan. Para comentar las líneas debemos situarnos al principio de la línea y añadir un símbolo #.

3. Reiniciar el servidor MySQL
   
sudo /etc/init.d/mysql restart

4. Acceder a la consola de MySQL, como root.
   
mysql -u root -p

   Dentro crearemos un usuario “slave” para que pueda ponerse en contacto con nuestro master y retendremos información del estado del máster para establecer un punto de inicio antes de comenzar el proceso de replicación con el slave.
   
GRANT REPLICATION SLAVE ON *.* TO 'usuarioslave'@'%' IDENTIFIED BY 'clave_acceso_slave';
FLUSH PRIVILEGES;
USE  base_datos;
FLUSH TABLES WITH READ LOCK;
SHOW MASTER STATUS;
+----------------------------+------------+----------------------+---------------------------+
| File       | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+---------------------------+-------------+----------------------+---------------------------+
| mysql-bin.000007 |       98 | base_datos    |                   |
+----------------------------+------------+----------------------+---------------------------+
UNLOCK TABLES;

   NOTA: ‘%’ puede substituirse también por una dirección IP o DNS concreta. Pero para hacer pruebas, este símbolo ya nos sirve.

5. NOTA2: En el caso en el que queramos más slaves, tendremos que darles permisos a cada uno de ellos, con la línea descrita “GRANT REPLICATION SLAVE ON *.* TO ‘usuarioslave’@'%’ IDENTIFIED BY ‘clave_acceso_slave’;” .
6. Una vez hecho todo esto, saldremos de la consola de MySQL con la sentencia:
   
exit;


NOTA DE LA AUTORA: A partir de aquí empezaría la configuración del slave. Deseo que tengáis paciencia, en breve la acabaré de redactar y la compartiré con vosotros. Si téneis cualquier duda o sugerencia, solo téneis que dejar un comentario . Muchas gracias!

Esto es todo, de momento, desde el zulo, pigüinos y manzaitas world! (aún, sin jefe… )

Intentamos trasladar la idea del Cluster y su montaje a un entorno EC2 de Amazon con su almacenamiento en nube (Elastic Compute Cloud) -más información sobre EC2 en los blogs de Santi y Xavi, o en la página oficial de Amazon EC2- y algo empezó a no cuadrar. Nos dimos cuenta, primeramente, que MySQL Cluster es un sistema cuyo uso es recomendado en redes locales que permitan una rápida velocidad y no es un sistema orientado a sistemas web; aún así, decidimos seguir adelante.

Otra piedra en el camino la encontramos unas horas más tarde, cuando leímos (en algún apartado de la documentación de MySQL Cluster) que la seguridad entre la comunicación de los nodos de datos dejaba bastante que desear ya que ésta no estaba encriptada y corrías el peligro de que pudieran interceptar informaciones del sistema. Es por eso que se recomendaba la proximidad entre nodos; nuestra idea era crear diferentes instancias en EC2 que sirvieran como nodos de datos independientes y Amazon no te garantiza ningún tipo de “proximidad” entre instancias (si es que puede hablarse de proximidad como una propiedad realmente física). Aún así, decidimos arriesgarnos a continuar con nuestra primera solución.

Algunos dicen que nuestro sistema, en papel, está muy bien organizado y una vez implementado la mitad de los elementos que aparecen en el modelo de datos desaparecen. Otros dicen que no es necesario el uso de Foreign Keys (claves foráneas) en el momento real de la implementación. Aún así, nosotros estamos en la convicción de que si que lo son y por eso queríamos que nuestro sistema de base de datos las tuviera en cuenta; no importa que digáis que esta es una reflexión demasiado metódica, somos estudiantes en su último año de carrera y apostamos por un sistema bien hecho desde el principio. Por esto, cuando vimos que el motor del Cluster (ndbcluster) no soportaba claves foráneas decidimos no jugar más con dicha estructura.

Nos estuvimos peleando durante varias horas barajando diferentes motores e información diversa de sistemas de bases de datos y finalmente nos dimos cuenta que el propio MySQL tiene un sistema de replicación master-slave que permite el uso de diferentes motores para el master y para el slave. Concretamente, podíamos tener en el master el motor de MySQL InnoDb que si que soporta el uso de claves foráneas (tan importantes en nuestro sistema) y utilizar el motor MyIsam para los slaves. Este sistema se puede montar fácilmente en un entorno EC2, guardando todos los datos en un volumen EBS y utilizando las instancias para montar el master-slave sin contener datos propios. Esta es la última deducción, ya veremos si finalmente es la acertada.

En los próximos días publicaremos las pruebas que vayamos haciendo en su construcción en EC2.

Esto es todo por hoy desde el zulo, pingüinos y manzanitas world! (hoy sin jefe…)