echo "c/o/s/a/s/#s/o/b/r/e/#/l/i/n/u/x/,#p/y/t/h/o/n/,#n/o/d/e/./j/s,#a/n/d/r/o/i/d/././.#a/n/d#/a/l/l#/t/h/a/t#j/a/z/z"|sed -e's/\///g;s/#/ /g' cosas sobre linux, python, node.js, android... and all that jazz
lucaMac:nodeapps pepo$ git clone git@github.com:pepoviola/Socket.IO_rooms.git
Cloning into Socket.IO_rooms...
ERROR: Hi pepoviola, it's GitHub. We're doing an SSH key audit.
Please visit https://github.com/settings/ssh/audit/1767330
to approve this key so we know it's safe.
Fingerprint: 7c:(...):54
fatal: The remote end hung up unexpectedly
Yes, I had read the news that they had exploited a vulnerability that allowed update rails attributes inserting a new SSH key for more detail can read these links [0].
Therefore began an audit GitHub SSH key, for it asks that we enter the link listed above ("Please visit https://github.com/settings/ssh/audit/1767330") to approve or reject our key now ... If you have multiple keys as I uploaded to github, since different machines rub shoulders and this means that you must enter each machine and check if the ssh fingerprint is correct or not. Which brings us to what inspired me to write this post, i dont know if everyone knows how to read your fingerprint to validate the github presented to us, if do not know it I leave here a simple explanation.
The first thing to know is where is our public key, which usually is in the path ~/.ssh/ (/home/[user]/.ssh) with the name id_rsa.pub, when you have found this file must run the following command
lucaMac:nodeapps pepo$ git clone git@github.com:pepoviola/Socket.IO_rooms.git
Cloning into Socket.IO_rooms...
ERROR: Hi pepoviola, it's GitHub. We're doing an SSH key audit.
Please visit https://github.com/settings/ssh/audit/1767330
to approve this key so we know it's safe.
Fingerprint: 7c:(...):54
fatal: The remote end hung up unexpectedly
Así es, había leido de la noticia de que habían explotado una vulnerabilidad de rails que permitía updetear los atributos insertando una nueva key de SSH, para más detalle puede leer estos links [0].
Por lo tanto Github comenzó una auditoria de claves SSH, para ello nos pide que ingresemos al link que figura arriba (" Please visit https://github.com/settings/ssh/audit/1767330 "), para aprobar o rejectar nuestras claves, ahora... Si tu tienen como yo varias claves subidas a github, ya que codeas e diferentes maquinas esto representa que debes ingresar a cada maquina y chequear si el fingerprint de ssh es correcto o no. Lo cual nos trae a lo que me inspiró a escribir este post, que es que no sé si todo el mundo sabe como leer su fingerprint para validarlo con los que nos presenta github, si no lo saben les dejo aquí una simple explicación.
Lo primero que debemos saber es donde se encuentra nuestra llave pública, que por lo general se encuentra en el path ~/.ssh/ (/home/[user]/.ssh) con el nombre id_rsa.pub, una vez localizado este archivo debemos ejecutar el siguiente comando
Esta serie de post, tienen relación con el post anterior real time apps con node.js el cual explica como realizar la instalación de los componentes necesarios para desarrollar una aplicación con node.js + mongoDB + socket.IO.
Pero en el camino me pareció mejor comenzar con algunas cosas básicas, y a partir de ellas ir sumando complejidad hasta lograr una aplicación (que todavía no tengo definida cual sera, se escuchan ideas) que haga uso de socket.IO para las interacciones en tiempo real.
Bueno, vamos a comenzar con una introducción muy básica a frameworks Express.
Este framework es muy utilizado y se combina a la perfección con socket.IO, es muy simple de utilizar y trae muchas cosas "out of the box" lista para utlizar.
Lo primero que vamos a hacer es crear el entorno donde desarrollaremos este demo, para ello creamos el directorio de la aplicación y dentro de el creamos la siguiente estructura de subdirectorios:
Paso a explicar para que utilizares cada directorio:
views : Es el directorio donde alojaremos nuestros templates node_modules : Donde se instalaran los módules que utilizaremos public : Directorio de contenido, aquí alojaremos nuestros css, js, imagenes, etc.
Una vez creados los directorios, abrimos nuestro editor preferido para comenzar a desarrollar nuestra app.
El contenido de este simple ejemplo es:
var express = require('express');
var app = module.exports = express.createServer();
En estas dos líneas cargamos el módulo que necesitamos y llamamos a la función createServer que nos retorna un objeto con el servidor web que utilizaremos para escuchar las peticiones y responderlas.
Luego pasamos a la configuración del mismo, que son las siguientes líneas
En ellas primero establecemos el directorio /views como repositorio de templates, para ello usamos una variable definida globalmente en tiempo de ejecució de node.js que es __dirname cuyo valor es un string con el path absoluto del directorio de nuestra app.
Luego establecemos a "ejs" como nuestro motor para renderizar los templates, para ello recordemos intalar el módulo vía npm (npm install ejs).
El último set es para establecer que no utilizaremos un archivo de layout para este ejemplo, si quiesieramos podríamos tener un archivo de base para todos nuestros templates o también para utilizar sólo para algunas páginas.
Luego declaramos los Middlewares que vamos a utilizar, el primero express.bodyParser() es utilizado para el parseo de los post (sean json o no) y nos devuelve el resultado del parsea accesible vía la variable req.body , el siguiente es express.methodOverride() que es importante que esté declarado después de express.bodyParser() ya que realiza una verificación sobre la variable req.body , este middleware es muy útil para sobreescribir los métodos de nuestros formularios, simplemente con un campo input con el atributo hidden, algo así:
Luego declaramos el uso de app.router que es simplemente el middleware que contiene todas las rutas definidas, y realiza consulta de rutas basándose en la URL de la solicitud actual y el método HTTP.
Y por último declaramos el directorio desde donde proveemos nuestro contenido estático express.static(__dirname + '/public'), esto nos permite acceder a nustros recursos (dentro del directorio public) directamente referenciandolo como <link href="/css/style.css" rel="stylesheet" type="text/css"></link> , noten que no hace falta referenciar el directorio public sino que directamente hacemos referencia a los directorios dentro del mismo.
Bueno y con esto tenemos nuestra primera app utilizando node & Express, el código de este primer post se encuentra en Github Posts
This is a small article about how to use node.js as web server to display the results of a query to a MySQL database engine.
The first thing to do is to check is that we have installed the mysql module to run it the following:
lucaMac:BLOG_POSTs pepo$ node
> var Client = require('mysql').Client
Error: Cannot find module 'mysql'
at Function._resolveFilename (module.js:332:11)
at Function._load (module.js:279:25)
at Module.require (module.js:354:17)
at require (module.js:370:17)
at repl:1:14
at REPLServer.eval (repl.js:80:21)
at repl.js:190:20
at REPLServer.eval (repl.js:87:5)
at Interface. (repl.js:182:12)
at Interface.emit (events.js:67:17)
>
If fails, proceed to install the module via npm:
npm install mysql
The first thing we do is create the object for the query:
var Client = require('mysql').Client,
client = new Client();
client.user = 'user';
client.password = 'password';
client.host='127.0.0.1';
client.port='3306';
client.database='database_name'
client.connect();
And within this we perform the query, and associate to its callback function
client.query(
"select * from table where campo1 > 1 limit 10;",
function select(err, results, fields) {
if (err) {
console.log("Error: " + err.message);
throw err;
}
print data to the console and the web response
console.log("Number of rows: "+results.length);
console.log(results);
for (var i in results){
var result = results[i];
res.write(result.campo1+"\n");
}
res.end();
});
We finished the code, setting up a port for listening
A few days ago I finished a simple application tweetland.com.ar I made in order to learn more about Node.js and MongoDB ... on the road I also came across Socket.IO which is a great library for real time applications.
The first is to prepare the environment. To do this first download node.js (from node.js ), after downloading the installation follows the traditional steps:
./configure
make
make install *
* the last step as root
Once installed, continue with the installation of modules. For this node has npm (which is Node Package Manager) that allows us to install the modules with a single command install npm . Instructions for installing npm are in your home page, also I leave
curl http://npmjs.org/install.sh | sh
At this time we have installed both node.js as its package manager npm. Usually what I usually do is create a directory in my case I call nodeapps as workspace.
Entering the same:
cd "path to nodeapps"
and within it begin to install the modules you require. This is important because when you install the modules npm node_modules create the directory (if not there before), and install the modules in that directory.
This is important because when we do within our code something like:
var sys = require('sys');
node will automatically search the directory sys module within node_modules in the current directory and not finding it will continue with the search recursively upwards, which is always important to remember where you installed the modules that we use.
Before going further make the installation of some modules used, these are express, socket.io, mongoose.
And this is precisely the last module we will use to interact with our database MongoDB, which is an object-oriented database (JSON), high performance and scalable. (in another post I will explain a little more how it works because it is a relatively new and very interesting).
To install you have to download the appropriate version from download , and once discharged, proceed to decompress
pepo@sokol:~/DESARROLLO/POSTS/node_socket_mongo$ tar -xzf mongodb-linux-i686-2.0.2.tgz
Once unpacked and could start the service mongod and start, but I'd rather create the directory structure I will use my base, create two directories for data and logs, the first store the files of the database and the second of logs. I also create the configuration file with which I will start the service, in my case is as follows:
Bind_ip option is set to only listen on localhost requests (since by default it does on all interfaces) and indicate that we will not configure the authentication and verbose.
To start the service simply run:
bin/mongod --config mongod.config *
* Inside the unzipped directory MongoDB
we see something like this:
# mongodb-linux-i686-2.0.2/bin/mongod --config mongod.config
all output going to: ./logs/mongodb.log
Finally to test the service entered as follows (always from the binary directory MongoDB):
pepo@sokol:bin$ ./mongo
MongoDB shell version: 2.0.2
connecting to: test
> show dbs
local (empty)
Well, with this we have our environment set up and configured to start programming applications in node.js with MongoDB, but that will be for the next post....
Hace unos días terminé una simple aplicación tweetland.com.ar que realicé con el objetivo de aprender (existe otro?) más sobre Node.js y mongoDB... en el camino también me topé con Socket.IO que es una gran librería para realizar aplicaciones en tiempo real.
Lo primero es preparar el ambiente, para ello primero descargamos node.js (desde su home page node.js), una vez descargado la instalación sigue los pasos tradicionales:
./configure
make
make install *
* este último como root
Una vez instalado, seguimos con la instalación de módulos. Para ello node cuenta con npm (que es Node Package Manager) que nos permite instalar los módulos con un simple comando npm install . Las instrucciones para instalar npm están en su home page, igualmente se las dejo:
curl http://npmjs.org/install.sh | sh
En este momento ya tenemos instalado tanto node.js como su manejador de paquetes npm. Por lo general lo que suelo hacer es crear un directorio, en mi caso lo llamo nodeapps, como workspace.
Ingreso al mismo:
cd "path to nodeapps"
y dentro de él comienzo a instalar los modulos que requiero. Esto es importante porque al instalar los modulos npm creará el directorio node_modules (siempre y cuando no exista antes), e instalará los modulos en dicho directorio.
Y esto es importante porque cuando dentro de nuestro código hagamos algo como:
var sys = require('sys');
node automáticamente buscará el módulo sys dentro de directorio node_modules en el directorio actual y de no encontrarlo seguira con la busqueda recursiva hacia arriba, por lo cual siempre es importante tener en mente donde se instalán los módulos que vamos a utilizar.
Antes de seguir adelante realicen la instalación de algunos módulos que utilizaran, estos son express, socket.io, mongoose .
Y este último módulo es justamente el que utilizaremos para interactuar con nuestra base de datos mongoDB, que es una base orientada a objetos (JSON), de alta performance y escalable. (en otro post explicaré un poco más como funciona ya que es una tecnología relativamente nueva y muy interesante).
Para realizar la instalación tenemos que descargar la versión que corresponda desde mongoDB download , y una vez descargada la descomprimimos
pepo@sokol:~/DESARROLLO/POSTS/node_socket_mongo$ tar -xzf mongodb-linux-i686-2.0.2.tgz
Una vez descomprimido ya podríamos arrancar el servicio mongod y comenzar, pero antes prefiero crear la estructura de directorios que utilizaré con mi base, para eso creo dos directorios data y logs, el primero guardará los archivos de la base de datos y el segundo los archivos de logs. También creo el archivo de configuración con el que voy a levantar el servicio, en mi caso tiene la siguiente forma:
La opción bind_ip está configurada para que sólo escuche las peticiones sobre el localhost (ya que por defecto lo hace sobre todas las interfaces) e indicamos que no tendremos autenticación y configuramos el verbose.
Para levantar el servicio simplemente ejecutamos:
bin/mongod --config mongod.config *
* Dentro de directorio descomprimido de mongoDB
Y veremos algo como:
# mongodb-linux-i686-2.0.2/bin/mongod --config mongod.config
all output going to: ./logs/mongodb.log
Por último para probar el servicio ingresamos de la siguiente forma (siempre desde el directorio de binarios de mongoDB):
pepo@sokol:bin$ ./mongo
MongoDB shell version: 2.0.2
connecting to: test
> show dbs
local (empty)
Bueno, y con esto ya tenemos nnuestro entorno instalado y configurado para comenzar a programar aplicaciones en con node.js con mongoDB, pero eso quedará para la próxima....
En este tiempo de diversas resoluciones de pantallas es cada vez más importante poder contar con buenas herramientas para probar facilmente como se un sitio en diferentes dispositivos, en este link les dejo 5 muy buenas herramientas que facilitan esa tarea.
