¿Recuerdas la serie de tutoriales que escribí sobre creación de un almacén de perfiles de usuario con Node.js y NoSQL? Ese tutorial abarcaba mucho terreno, desde la creación de una API RESTful con Node.js, la gestión de sesiones de usuario, el modelado de datos y, por supuesto, el almacenamiento de datos asociados a los usuarios.
¿Y si quisiéramos tomar los mismos conceptos y aplicarlos con Golang en lugar de JavaScript con Node.js?
Vamos a ver cómo desarrollar un almacén de perfiles de usuario con Golang y Servidor Couchbase que actúa como sustituto modular de la alternativa Node.js.
En adelante, vamos a asumir que tienes Go instalado y configurado, así como Couchbase Server. No es importante si has visto el Versión Node.js de este tutorial porque vamos a revisarlo todo.
En caso de que no esté familiarizado con lo que es un almacén de perfiles de usuario o lo que hace, es simplemente una solución para almacenar información sobre los usuarios y la información asociada a los usuarios. Tomemos por ejemplo un blog. Un blog puede tener numerosos autores, que técnicamente son usuarios. Cada autor escribirá contenido y ese contenido estará asociado al usuario particular que lo escribió. Además, cada autor tendrá su propio método para iniciar sesión en el blog.
Dado que los modelos de datos de los usuarios pueden cambiar con tanta frecuencia, el uso de una base de datos NoSQL con un modelo de almacenamiento flexible suele ser más eficaz que una alternativa RDBMS. Puedes encontrar más información sobre el aspecto del modelado de datos en este artículo, Almacén de perfiles de usuario: Modelado avanzado de datosescrito por Kirk Kirkconnell.
Gestión de usuarios Golang para crear un nuevo proyecto
Vamos a pasar todo nuestro tiempo en un único archivo Go. En algún lugar de tu $GOPATHcree un archivo llamado main.go.
También vamos a necesitar algunas dependencias, tanto para Couchbase como para otros paquetes. Desde la línea de comandos, ejecute lo siguiente:
|
1 2 3 4 5 |
ir consiga github.com/couchbase/gocb ir consiga github.com/gorila/contexto ir consiga github.com/gorila/manipuladores ir consiga github.com/gorila/mux ir consiga github.com/satori/ir.uuid |
Las dependencias anteriores nos permitirán comunicarnos con Couchbase Server, generar valores UUID y crear una API RESTful con gestión de recursos compartidos de origen cruzado (CORS).
El siguiente paso es lanzar un poco de código boilerplate para nuestro proyecto. Abra el archivo main.go e incluya lo siguiente:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 |
paquete principal importar ( "encoding/json" "fmt" "log" "net/http" "cadenas" "tiempo" "golang.org/x/crypto/bcrypt" "github.com/couchbase/gocb" "github.com/gorilla/context" "github.com/gorilla/handlers" "github.com/gorilla/mux" uuid "github.com/satori/go.uuid" ) tipo Cuenta struct { Tipo cadena `json:"tipo,omitempty"` Pid cadena `json:"pid,omitempty"` Correo electrónico cadena `json:"email,omitempty"` Contraseña cadena `json:"contraseña,omitempty"` } tipo Perfil struct { Tipo cadena `json:"tipo,omitempty"` Nombre cadena `json:"firstname,omitempty"` Apellido cadena `json:"apellido,omitempty"` } tipo Sesión struct { Tipo cadena `json:"tipo,omitempty"` Pid cadena `json:"pid,omitempty"` } tipo Blog struct { Tipo cadena `json:"tipo,omitempty"` Pid cadena `json:"pid,omitempty"` Título cadena `json:"título,omitempty"` Contenido cadena `json:"contenido,omitempty"` Marca de tiempo int `json:"timestamp,omitempty"` } var cubo *gocb.Cubo func Validar(siguiente http.HandlerFunc) http.HandlerFunc {} func RegisterEndpoint(w http.EscritorRespuesta, req *http.Solicitar) {} func LoginEndpoint(w http.EscritorRespuesta, req *http.Solicitar) {} func AccountEndpoint(w http.EscritorRespuesta, req *http.Solicitar) {} func BlogsPunto final(w http.EscritorRespuesta, req *http.Solicitar) {} func BlogPunto final(w http.EscritorRespuesta, req *http.Solicitar) {} func principal() { fmt.Imprimir("Iniciando el servidor Go...") enrutador := mux.NuevoRouter() grupo, _ := gocb.Conectar("couchbase://localhost") cubo, _ = grupo.OpenBucket("por defecto", "") enrutador.HandleFunc("/cuenta", RegisterEndpoint).Métodos("POST") enrutador.HandleFunc("/login", LoginEndpoint).Métodos("POST") enrutador.HandleFunc("/cuenta", Validar(AccountEndpoint)).Métodos("GET") enrutador.HandleFunc("/blogs", Validar(BlogsPunto final)).Métodos("GET") enrutador.HandleFunc("/blog", Validar(BlogPunto final)).Métodos("POST") registro.Fatal(http.ListenAndServe(":3000", manipuladores.CORS(manipuladores.Cabeceras permitidas([]cadena{"X-Requested-With", "Tipo de contenido", "Autorización"}), manipuladores.Métodos permitidos([]cadena{"GET", "POST", "PUT", "CABEZA", "OPCIONES"}), manipuladores.Orígenes permitidos([]cadena{"*"}))(enrutador))) } |
En lo anterior, notarás que hemos creado algunas estructuras de datos para representar nuestros datos. Vamos con la idea de una plataforma de blogs.
La aplicación tendrá cinco puntos finales de API RESTful, un método validador para nuestras sesiones de usuario, y una variable global de Couchbase que nos permitirá acceder a nuestra instancia abierta en cualquier parte de la aplicación.
|
1 2 3 |
enrutador.HandleFunc("/cuenta", Validar(AccountEndpoint)).Métodos("GET") enrutador.HandleFunc("/blogs", Validar(BlogsPunto final)).Métodos("GET") enrutador.HandleFunc("/blog", Validar(BlogPunto final)).Métodos("POST") |
Obsérvese que los tres extremos anteriores tienen el Validar adjunta a ellos. Esto significa que el usuario debe haberse autentificado y estar proporcionando una sesión válida para progresar. En este sentido, la Validar actúa como intermediario.
Como planeamos consultar datos, más específicamente, artículos de blog a un usuario en particular, necesitamos tener un índice creado. Usando el dashboard web, Couchbase CLI, o la aplicación Go, ejecuta lo siguiente:
|
1 |
CREAR ÍNDICE `blogbyuser` EN `por defecto`(tipo, pid); |
El índice anterior nos permitirá consultar por un tipo así como una propiedad pid propiedad.
Ahora podemos empezar a rellenar los huecos para cada uno de nuestros puntos finales de API.
Permitir a los usuarios registrar nueva información en el almacén de perfiles
Dado que ahora mismo no tenemos usuarios en el almacén de perfiles, tendría sentido crear un endpoint que soporte la creación de nuevos usuarios.
Es una buena práctica no almacenar nunca información de credenciales del tipo nombre de usuario y contraseña con la información real del usuario. Por esta razón, crear un nuevo usuario significa crear un perfil así como un cuenta documento. En cuenta hará referencia al documento perfil documento. Ambos serán modelados después de nuestras estructuras de datos Go que vimos en el código boilerplate.
En el main.go añada lo siguiente:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
func RegisterEndpoint(w http.EscritorRespuesta, req *http.Solicitar) { var datos mapa[cadena]interfaz{} _ = json.NuevoDecodificador(consulte.Cuerpo).Descodifique(&datos) id := uuid.NuevoV4().Cadena() passwordHash, _ := bcrypt.GenerarDesdeContraseña([]byte(datos["contraseña"].(cadena)), 10) cuenta := Cuenta{ Tipo: "cuenta", Pid: id, Correo electrónico: datos["email"].(cadena), Contraseña: cadena(passwordHash), } perfil := Perfil{ Tipo: "perfil", Nombre: datos["nombre"].(cadena), Apellido: datos["apellido"].(cadena), } _, err := cubo.Inserte(id, perfil, 0) si err != nil { w.WriteHeader(401) w.Escriba a([]byte(err.Error())) devolver } _, err = cubo.Inserte(datos["email"].(cadena), cuenta, 0) si err != nil { w.WriteHeader(401) w.Escriba a([]byte(err.Error())) devolver } json.Nuevo codificador(w).Codificar(cuenta) } |
Hay algunas cosas importantes que suceden en el código del punto final anterior.
En primer lugar estamos aceptando datos JSON que fueron enviados con el cuerpo POST de la solicitud del cliente. Estamos generando un id único para el perfil y guardando la contraseña con BCrypt.
A la hora de guardar los datos, el perfil de usuario recibirá un identificador único, mientras que la cuenta recibirá una dirección de correo electrónico como identificador y una referencia al identificador del perfil dentro del documento.
Siguiendo este planteamiento, la cuenta podría ampliarse fácilmente a otras formas de credenciales. Por ejemplo, el documento de cuenta podría rebautizarse como basicauthy podríamos tener Facebook, Twitter, etc., que hacen referencia a la información del perfil.
Implementación de un identificador de sesión para usuarios
Iniciar sesión en la aplicación a través de nuestros dos documentos es un poco diferente. Nunca es buena idea pasar el nombre de usuario y la contraseña más de lo absolutamente necesario.
Por esta razón, es una buena idea utilizar un testigo de sesión que represente al usuario. Este token puede caducar y no contiene información sensible.
Tome el siguiente código de acceso para el main.go file:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
func LoginEndpoint(w http.EscritorRespuesta, req *http.Solicitar) { var datos Cuenta var cuenta Cuenta _ = json.NuevoDecodificador(consulte.Cuerpo).Descodifique(&datos) _, err := cubo.Visite(datos.Correo electrónico, &cuenta) si err != nil { w.WriteHeader(401) w.Escriba a([]byte(err.Error())) devolver } err = bcrypt.CompareHashAndPassword([]byte(cuenta.Contraseña), []byte(datos.Contraseña)) si err != nil { w.WriteHeader(401) w.Escriba a([]byte(err.Error())) devolver } sesión := Sesión{ Tipo: "sesión", Pid: cuenta.Pid, } var resultado mapa[cadena]interfaz{} resultado = escriba a(mapa[cadena]interfaz{}) resultado["sid"] = uuid.NuevoV4().Cadena() _, err = cubo.Inserte(resultado["sid"].(cadena), &sesión, 3600) si err != nil { w.WriteHeader(401) w.Escriba a([]byte(err.Error())) devolver } json.Nuevo codificador(w).Codificar(resultado) } |
Cuando el correo electrónico y la contraseña se pasan a este endpoint, el cuenta basado en el correo electrónico proporcionado. A continuación, se compara la contraseña cifrada de este documento con la contraseña sin cifrar.
Si las credenciales son válidas, se emitirá un sesión se crea un documento de sesión. Este documento de sesión tiene una clave única, pero hace referencia a la clave del archivo perfil documento. También se añade un tiempo de expiración al documento. Cuando pase el tiempo de expiración, el documento será automáticamente eliminado de Couchbase sin ninguna intervención de la aplicación o del usuario. Esto ayuda a asegurar la cuenta.
Con las cuentas en funcionamiento, tenemos que preocuparnos de asociar la información a los usuarios.
Gestión de la información del usuario en el almacén de perfiles mediante un identificador de sesión
Cuando un usuario intenta hacer algo específico para sí mismo, tenemos que validar que es quien debe ser y que la información que está cambiando se aplica a la persona correcta.
Aquí es donde entra en juego el middleware de validación de testigos de sesión.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
func Validar(siguiente http.HandlerFunc) http.HandlerFunc { devolver http.HandlerFunc(func(w http.EscritorRespuesta, req *http.Solicitar) { authorizationHeader := consulte.Cabecera.Visite("autorización") si authorizationHeader != "" { bearerToken := cadenas.Dividir(authorizationHeader, " ") si len(bearerToken) == 2 { var sesión Sesión _, err := cubo.Visite(bearerToken[1], &sesión) si err != nil { w.WriteHeader(401) w.Escriba a([]byte(err.Error())) devolver } contexto.Establecer(consulte, "pid", sesión.Pid) cubo.Toque(bearerToken[1], 0, 3600) siguiente(w, consulte) } } si no { w.WriteHeader(401) w.Escriba a([]byte("Se requiere una cabecera de autorización")) devolver } }) } |
Cada solicitud a uno de nuestros tres puntos finales especiales requerirá una cabecera de autorización que contenga un token de portador con el identificador de sesión. Sin token de portador significa que la solicitud fallará. Un token de portador incorrecto o caducado significa que la solicitud fallará.
La validación intercambiará el identificador de sesión por un identificador de perfil que se utilizará en el siguiente paso de la solicitud.
Empezando por lo sencillo, digamos que queremos devolver la información del perfil de un usuario en particular. Nuestro endpoint podría tener el siguiente aspecto:
|
1 2 3 4 5 6 7 8 9 10 11 |
func AccountEndpoint(w http.EscritorRespuesta, req *http.Solicitar) { pid := contexto.Visite(consulte, "pid").(cadena) var perfil Perfil _, err := cubo.Visite(pid, &perfil) si err != nil { w.WriteHeader(401) w.Escriba a([]byte(err.Error())) devolver } json.Nuevo codificador(w).Codificar(perfil) } |
En pid se pasa desde el middleware de validación y se realiza una búsqueda con el id del perfil.
No es tan difícil hasta ahora, ¿verdad?
Vayamos un poco más allá e introduzcamos algunas consultas N1QL en nuestro proyecto. Digamos que queremos obtener todas las entradas del blog de un usuario en particular. Esto hará uso de nuestro índice, así como las consultas SQL-como.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
func BlogsPunto final(w http.EscritorRespuesta, req *http.Solicitar) { var n1qlParámetros []interfaz{} n1qlParámetros = añadir(n1qlParámetros, contexto.Visite(consulte, "pid").(cadena)) consulta := gocb.NuevoN1qlQuery("SELECT `" + cubo.Nombre() + "`.* FROM `" + cubo.Nombre() + "WHERE type = 'blog' AND pid = $1") consulta.Coherencia(gocb.SolicitarPlus) filas, err := cubo.EjecutarN1qlQuery(consulta, n1qlParámetros) si err != nil { w.WriteHeader(401) w.Escriba a([]byte(err.Error())) devolver } var fila Blog var resultado []Blog para filas.Siguiente(&fila) { resultado = añadir(resultado, fila) fila = Blog{} } filas.Cerrar() si resultado == nil { resultado = escriba a([]Blog, 0) } json.Nuevo codificador(w).Codificar(resultado) } |
En el código del punto final anterior, tomamos la variable pid del middleware de validación y añadirlo como parámetro para nuestra consulta parametrizada.
Vamos a iterar a través de la Resultados de la consulta devueltos por la consulta y añadirlos a un []Blog variable. Si no se encuentra ningún resultado, se devuelve una porción vacía.
Hacer búsquedas directas basadas en la clave siempre será más rápido que las consultas N1QL, pero las consultas N1QL son muy útiles cuando necesitas consultar por información de propiedades.
El punto final no es diferente de lo que ya hemos visto:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
func BlogPunto final(w http.EscritorRespuesta, req *http.Solicitar) { var blog Blog _ = json.NuevoDecodificador(consulte.Cuerpo).Descodifique(&blog) blog.Tipo = "blog" blog.Pid = contexto.Visite(consulte, "pid").(cadena) blog.Marca de tiempo = int(tiempo.Ahora().Unix()) _, err := cubo.Inserte(uuid.NuevoV4().Cadena(), blog, 0) si err != nil { w.WriteHeader(401) w.Escriba a([]byte(err.Error())) devolver } json.Nuevo codificador(w).Codificar(blog) } |
En el código anterior, aceptamos un cuerpo POST del cliente, así como el archivo pid del middleware de validación. A continuación, esa información se guarda en Couchbase.
Conclusión
Acabas de ver cómo crear una tienda básica de perfiles de usuario, o en este caso, una plataforma de blogs, utilizando el lenguaje de programación Go y Servidor Couchbase. Se trata de un tutorial alternativo a un tutorial anterior que había escrito sobre el mismo tema, pero con Node.js.
¿Quieres llevar este tutorial al siguiente nivel? Echa un vistazo a cómo crear un cliente web front-end con Angular o un front-end de cliente móvil con NativeScript.
Para obtener más información sobre el uso de Couchbase con Golang, consulte el documento Portal para desarrolladores de Couchbase.
