Creating URL Shortener with Node.js and Couchbase using N1QL

Con el auge de Twitter, los mensajes de texto SMS y otras formas de interacción con mensajes cortos, ha habido un auge de los servicios de acortamiento de URL. Por ejemplo, puedes utilizar TinyURL, Bitly, Owly y muchos otros. El propósito aquí es tomar URLs muy largas y hacerlas significativamente más cortas para distribuirlas en un mensaje.

Pero, ¿cómo funcionan estos servicios de acortamiento de URL?

Vamos a ver cómo crear nuestro propio acortador de URL usando Node.js con Express Framework y Couchbase Server con N1QL. En nuestro ejemplo, las URLs cortas serán generadas usando Node.js y serán almacenadas y accedidas usando Couchbase.

Requisitos

No hay demasiados requisitos para hacer posible este proyecto. Como mínimo necesitarás lo siguiente para tener éxito:

Servidor Couchbase 4.1+
Node.js 4.0+

Necesitamos usar una versión de Couchbase Server que soporte consultas N1QL. La versión Node.js es menos estricta, pero la necesitaremos para servir nuestra aplicación y obtener dependencias usando el Node Package Manager (NPM).

Preparación de Couchbase y comprensión del formato de datos

Antes de que podamos empezar a desarrollar nuestra aplicación Node.js necesitamos entender el plan de datos así como configurar Couchbase Server para permitir consultas N1QL.

En Couchbase, el objetivo es almacenar nuestros datos en el siguiente formato:

{
    "id": "5Qp8oLmWX",
    "longUrl": "https://www.thepolyglotdeveloper.com/2016/08/using-couchbase-server-golang-web-application/",
    "shortUrl": "http://localhost:3000/5Qp8oLmWX"
}

{

"id": "5Qp8oLmWX",

"longUrl": "https://www.thepolyglotdeveloper.com/2016/08/using-couchbase-server-golang-web-application/",

"shortUrl": "http://localhost:3000/5Qp8oLmWX"

}

Pasaremos a la aplicación una URL larga y generaremos un hash corto único basado en un dato. Este hash se utilizará al construir la URL corta que también se almacenará en el documento de Couchbase. El id del propio documento será también el del valor hash.

Ahora necesitamos crear un bucket de Couchbase Server para almacenar los datos de nuestra aplicación. Este bucket puede crearse a través del Panel de Administración de Couchbase Server. Llamemos a este bucket ejemplo.

Al consultar datos, no siempre haremos búsquedas basadas en el valor de id. Esto significa que necesitaremos crear índices en los valores del documento para permitir consultas N1QL. Para mantener las cosas simples, crear un índice primario simple como el siguiente:

CREATE PRIMARY INDEX ON `example` USING GSI;

1	CREAR PRIMARIO ÍNDICE EN `ejemplo` USO DE GSI;

Esta consulta puede ser ejecutada usando el Couchbase Server Query Workbench (Enterprise Edition) o el Couchbase Shell conocido como CBQ. El índice no será el más rápido porque es muy general, pero cumplirá con las necesidades de nuestra sencilla aplicación.

Desarrollo de la aplicación Node.js URL Shortener con Express Framework

Con la base de datos correctamente configurada podemos preocuparnos del código detrás de la aplicación. Esta aplicación dependerá en gran medida de Express Framework y Couchbase, pero también de una librería de hashing conocida como Hashids.

Creación del proyecto con las dependencias

Vamos a crear un nuevo proyecto Node.js desde el símbolo del sistema (Windows) o Terminal (Mac y Linux):

npm init --y

1	npm init --y

El comando anterior creará un paquete.json donde quiera que estés navegando a través de la línea de comandos. Así que es de esperar que usted está dentro de un directorio fresco.

Ahora necesitamos instalar las dependencias del proyecto. Ejecute lo siguiente desde la línea de comandos:

npm install couchbase body-parser express hashids --save

1	npm instale couchbase cuerpo-analizador express hashids --guardar

En este punto podemos preocuparnos del desarrollo de JavaScript.

Arranque de la aplicación Node.js

Para mantener este proyecto simple y fácil de entender, vamos a mantener toda la lógica de la aplicación en un solo archivo. En una aplicación de producción es probable que desee romper por la limpieza y facilidad de mantenimiento, pero para este ejemplo vamos a estar bien.

Cree un archivo llamado app.js en la raíz del directorio de tu proyecto. En este archivo, lo primero que vamos a hacer es importar las dependencias instaladas así:

var Couchbase = require("couchbase");
var Express = require("express");
var BodyParser = require("body-parser");
var Hashids = require("hashids");

var Couchbase = requiere("couchbase");

var Express = requiere("express");

var BodyParser = requiere("body-parser");

var Hachís = requiere("hashids");

Porque todavía tengo que explicar el body-parser lo explicaré ahora. Esta dependencia nos permite realizar peticiones que contengan un cuerpo. Por ejemplo, al hacer peticiones POST o PUT es habitual incluir un cuerpo JSON en lugar de parámetros URL o parámetros de consulta.

Con las dependencias importadas necesitamos inicializar Express Framework y el motor N1QL de Couchbase:

var app = Express();
var N1qlQuery = Couchbase.N1qlQuery;

1 2	var aplicación = Express(); var N1qlQuery = Couchbase.N1qlQuery;

Aunque hemos importado el body-parser todavía tenemos que inicializarlo. Queremos ser capaces de aceptar valores codificados JSON y URL, así que tenemos que configurar la dependencia así:

app.use(BodyParser.json());
app.use(BodyParser.urlencoded({ extended: true }));

1 2	aplicación.utilice(BodyParser.json()); aplicación.utilice(BodyParser.urlencoded({ ampliado: verdadero }));

En este punto todas nuestras dependencias están inicializadas. Ahora sería una buena idea establecer una conexión con nuestro cluster de Couchbase Server y el bucket de la aplicación. Esto se puede lograr con la siguiente línea:

var bucket = (new Couchbase.Cluster("couchbase://localhost")).openBucket("example");

1	var cubo = (nuevo Couchbase.Grupo("couchbase://localhost")).openBucket("ejemplo");

Finalmente comencemos a servir nuestra aplicación Node.js con lo siguiente:

var server = app.listen(3000, function() {
    console.log("Listening on port %s...", server.address().port);
});

var servidor = aplicación.escuche(3000, función() {

consola.registro("Escuchando en el puerto %s...", servidor.dirección().puerto);

});

Probablemente te estés dando cuenta de que en realidad no hemos añadido ninguna lógica. Estás en lo cierto, ya que hasta ahora sólo hemos hecho bootstrapping en nuestra aplicación.

Creación de la lógica de aplicación del acortador de URL

Lo que queremos hacer ahora es crear algunos RESTful API endpoints. Vamos a crear los siguientes puntos finales:

/
/expand
/create

/ampliar

/crear

En raíz se utilizará para navegar a una URL larga enmascarada tras una URL corta. La dirección /ampliar tomará una URL corta y revelará la URL larga sin navegar hasta ella, y el endpoint /crear tomará una URL larga y creará una URL corta en la base de datos.

Empezando por el /crear y probablemente el punto final más complicado, tenemos lo siguiente:

app.post("/create", function(req, res) {
    if(!req.body.longUrl) {
        return res.status(400).send({"status": "error", "message": "A long URL is required"});
    }
    bucket.query(N1qlQuery.fromString("SELECT `" + bucket._name + "`.* FROM `" + bucket._name + "` WHERE longUrl = $1"), [req.body.longUrl], function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        if(result.length == 0) {
            var hashids = new Hashids();
            var response = {
                id: hashids.encode((new Date).getTime()),
                longUrl: req.body.longUrl
            }
            response.shortUrl = "http://localhost:3000/" + response.id;
            bucket.insert(response.id, response, function(error, result) {
                if(error) {
                    return res.status(400).send(error);
                }
                res.send(response);
            });
        } else {
            res.send(result[0]);
        }
    });
});

aplicación.Correo electrónico:("/crear", función(consulte, res) {

si(!consulte.cuerpo.longUrl) {

devolver res.estado(400).enviar({"status": "error", "mensaje": "Se requiere una URL larga"});

}

cubo.consulta(N1qlQuery.fromString("SELECT `" + cubo.Nombre + "`.* FROM `" + cubo.Nombre + "WHERE longUrl = $1"), [consulte.cuerpo.longUrl], función(error, resultado) {

si(error) {

devolver res.estado(400).enviar(error);

}

si(resultado.longitud == 0) {

var hashids = nuevo Hachís();

var respuesta = {

id: hashids.codificar((nuevo Fecha).getTime()),

longUrl: consulte.cuerpo.longUrl

}

respuesta.shortUrl = "http://localhost:3000/" + respuesta.id;

cubo.insertar(respuesta.id, respuesta, función(error, resultado) {

si(error) {

devolver res.estado(400).enviar(error);

}

res.enviar(respuesta);

});

} si no {

res.enviar(resultado[0]);

}

});

Este endpoint es una petición POST que espera un cuerpo JSON. Si el campo longUrl JSON no existe, se devolverá un error al usuario.

Antes de crear la URL corta, queremos asegurarnos de que aún no se ha creado ninguna. Hacemos esto porque queremos una URL corta por cada URL larga. Podemos conseguirlo creando una consulta N1QL parametrizada basada en la directiva longUrl propiedad. Si la respuesta contiene un documento, lo devolveremos porque el documento ya existe. Si la respuesta no tiene un documento, necesitamos crear uno.

Utilización de la hashids podemos crear un hash basado en la marca de tiempo y usarlo como nuestro id y nuestra URL corta. Después de insertar este nuevo documento podemos devolverlo al usuario.

Veamos ahora cómo ampliar esas URL cortas.

app.get("/expand", function(req, res) {
    if(!req.query.shortUrl) {
        return res.status(400).send({"status": "error", "message": "A short URL is required"});
    }
    bucket.query(N1qlQuery.fromString("SELECT `" + bucket._name + "`.* FROM `" + bucket._name + "` WHERE shortUrl = $1"), [req.query.shortUrl], function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        res.send(result.length &gt; 0 ? result[0] : {});
    });
});

aplicación.consiga("/expand", función(consulte, res) {

si(!consulte.consulta.shortUrl) {

devolver res.estado(400).enviar({"status": "error", "mensaje": "Se requiere una URL corta"});

}

cubo.consulta(N1qlQuery.fromString("SELECT `" + cubo.Nombre + "`.* FROM `" + cubo.Nombre + "WHERE shortUrl = $1"), [consulte.consulta.shortUrl], función(error, resultado) {

si(error) {

devolver res.estado(400).enviar(error);

}

res.enviar(resultado.longitud > 0 ? resultado[0] : {});

});

El código anterior utiliza un concepto similar al de /crear punto final. Tomamos un shortUrl y consultarlo utilizando N1QL. Si se encuentra, podemos devolver la URL larga con la respuesta.

Por fin podemos preocuparnos de la navegación.

app.get("/:id", function(req, res) {
    if(!req.params.id) {
        return res.status(400).send({"status": "error", "message": "An id is required"});
    }
    bucket.get(req.params.id, function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        res.redirect(result.value.longUrl);
    })
});

aplicación.consiga("/:id", función(consulte, res) {

si(!consulte.parámetros.id) {

devolver res.estado(400).enviar({"status": "error", "mensaje": "Se requiere una identificación"});

}

cubo.consiga(consulte.parámetros.id, función(error, resultado) {

si(error) {

devolver res.estado(400).enviar(error);

}

res.redirigir(resultado.valor.longUrl);

})

});

Recuerde que nuestras URL cortas tienen el formato http://localhost:3000/5Qp8oLmWX que es la misma ubicación que nuestro servicio API. Esto significa que 5Qp8oLmWX es sólo un parámetro URL para nuestro raíz punto final.

Con el id podemos hacer una búsqueda de documentos basada en el valor de la clave. Si tiene éxito tendremos el documento que se almacena actualmente.

El código fuente completo de la aplicación

En caso de que quieras ver el código fuente completo de la aplicación que acabamos de crear, puedes encontrarlo a continuación.

var Couchbase = require("couchbase");
var Express = require("express");
var BodyParser = require("body-parser");
var Hashids = require("hashids");

var app = Express();
var N1qlQuery = Couchbase.N1qlQuery;

app.use(BodyParser.json());
app.use(BodyParser.urlencoded({ extended: true }));

var bucket = (new Couchbase.Cluster("couchbase://localhost")).openBucket("example");

app.get("/expand", function(req, res) {
    if(!req.query.shortUrl) {
        return res.status(400).send({"status": "error", "message": "A short URL is required"});
    }
    bucket.query(N1qlQuery.fromString("SELECT `" + bucket._name + "`.* FROM `" + bucket._name + "` WHERE shortUrl = $1"), [req.query.shortUrl], function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        res.send(result.length &gt; 0 ? result[0] : {});
    });
});

app.post("/create", function(req, res) {
    if(!req.body.longUrl) {
        return res.status(400).send({"status": "error", "message": "A long URL is required"});
    }
    bucket.query(N1qlQuery.fromString("SELECT `" + bucket._name + "`.* FROM `" + bucket._name + "` WHERE longUrl = $1"), [req.body.longUrl], function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        if(result.length == 0) {
            var hashids = new Hashids();
            var response = {
                id: hashids.encode((new Date).getTime()),
                longUrl: req.body.longUrl
            }
            response.shortUrl = "http://localhost:3000/" + response.id;
            bucket.insert(response.id, response, function(error, result) {
                if(error) {
                    return res.status(400).send(error);
                }
                res.send(response);
            });
        } else {
            res.send(result[0]);
        }
    });
});

app.get("/:id", function(req, res) {
    if(!req.params.id) {
        return res.status(400).send({"status": "error", "message": "An id is required"});
    }
    bucket.get(req.params.id, function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        res.redirect(result.value.longUrl);
    })
});

var server = app.listen(3000, function() {
    console.log("Listening on port %s...", server.address().port);
});

var Couchbase = requiere("couchbase");

var Express = requiere("express");

var BodyParser = requiere("body-parser");

var Hachís = requiere("hashids");

var aplicación = Express();

var N1qlQuery = Couchbase.N1qlQuery;

aplicación.utilice(BodyParser.json());

aplicación.utilice(BodyParser.urlencoded({ ampliado: verdadero }));

var cubo = (nuevo Couchbase.Grupo("couchbase://localhost")).openBucket("ejemplo");

aplicación.consiga("/expand", función(consulte, res) {

si(!consulte.consulta.shortUrl) {

devolver res.estado(400).enviar({"status": "error", "mensaje": "Se requiere una URL corta"});

}

cubo.consulta(N1qlQuery.fromString("SELECT `" + cubo.Nombre + "`.* FROM `" + cubo.Nombre + "WHERE shortUrl = $1"), [consulte.consulta.shortUrl], función(error, resultado) {

si(error) {

devolver res.estado(400).enviar(error);

}

res.enviar(resultado.longitud > 0 ? resultado[0] : {});

});

aplicación.Correo electrónico:("/crear", función(consulte, res) {

si(!consulte.cuerpo.longUrl) {

devolver res.estado(400).enviar({"status": "error", "mensaje": "Se requiere una URL larga"});

}

cubo.consulta(N1qlQuery.fromString("SELECT `" + cubo.Nombre + "`.* FROM `" + cubo.Nombre + "WHERE longUrl = $1"), [consulte.cuerpo.longUrl], función(error, resultado) {

si(error) {

devolver res.estado(400).enviar(error);

}

si(resultado.longitud == 0) {

var hashids = nuevo Hachís();

var respuesta = {

id: hashids.codificar((nuevo Fecha).getTime()),

longUrl: consulte.cuerpo.longUrl

}

respuesta.shortUrl = "http://localhost:3000/" + respuesta.id;

cubo.insertar(respuesta.id, respuesta, función(error, resultado) {

si(error) {

devolver res.estado(400).enviar(error);

}

res.enviar(respuesta);

});

} si no {

res.enviar(resultado[0]);

}

});

aplicación.consiga("/:id", función(consulte, res) {

si(!consulte.parámetros.id) {

devolver res.estado(400).enviar({"status": "error", "mensaje": "Se requiere una identificación"});

}

cubo.consiga(consulte.parámetros.id, función(error, resultado) {

si(error) {

devolver res.estado(400).enviar(error);

}

res.redirigir(resultado.valor.longUrl);

})

});

var servidor = aplicación.escuche(3000, función() {

consola.registro("Escuchando en el puerto %s...", servidor.dirección().puerto);

});

Probablemente hay muchas optimizaciones que se pueden hacer, pero nos preocupamos más por la lógica a la hora de hacer de este un proyecto exitoso.

Conclusión

Acabas de ver cómo crear un acortador de URL muy básico usando Node.js para la lógica de la aplicación, Couchbase Server como base de datos NoSQL y N1QL como tecnología de consulta.

Si quisieras llevar esto al siguiente nivel, podrías hacer un seguimiento de la información analítica. Por ejemplo, si alguien navega a la raíz endpoint, aumentar un contador, o almacenar el agente del navegador. Cosas simples para añadir un cool-factor a la aplicación acortador de URL.

Nic Raboy, Defensor del Desarrollador, Couchbase

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Todos los mensajes

Crear un acortador de URL con Node.js y Couchbase usando N1QL

Requisitos

Preparación de Couchbase y comprensión del formato de datos

Desarrollo de la aplicación Node.js URL Shortener con Express Framework

Creación del proyecto con las dependencias

Arranque de la aplicación Node.js

Creación de la lógica de aplicación del acortador de URL

El código fuente completo de la aplicación

Conclusión

Autor

Publicado por Nic Raboy, Defensor del Desarrollador, Couchbase

Dejar una respuesta Cancelar respuesta