|
| 1 | +# 6.2 ¿Cómo usar sesiones en Go? |
| 2 | + |
| 3 | +En la sección 6.1, aprendimos que las sesiones son soluciones para la verificación de usuarios y que por ahora, la librería estándar de Go no tiene soporte para las sesiones o el manejo de ellas. Entonces, vamos a implementar nuestro propio manejador de sesiones en Go. |
| 4 | + |
| 5 | +## Creando sesiones |
| 6 | + |
| 7 | +El principio básico detrás de las sesiones es que el servidor mantiene la información de cada cliente , y los clientes tienen una única sesión para acceder a su información. Cuando los usuarios visitan la aplicación web, el servidor crea una sesión siguiendo los siguientes pasos en tanto sean necesarios: |
| 8 | + |
| 9 | +- Crear un identificador de sesión único. |
| 10 | +- Abrir un espacio de almacenamiento: normalmente tenemos las sesiones en memoria, pero las perderás si el sistema accidentalmente se interrumpe. Esto puede ser un serio problema si la aplicación web maneja datos sensibles, como de comercio electrónico por ejemplo. Para solucionar este problema, puedes guardar los datos de sesión en la base de datos o en el sistema de ficheros. Eso hace que los datos sean mas fiables y fácil de compartir con otras aplicaciones, sin embargo la negociaciónde información es mas del lado del servidor para leer y escribir sesiones. |
| 11 | +- Enviar el identificador de sesión único al cliente. |
| 12 | + |
| 13 | +El paso clave aquí es enviar un identificador único de sesión al cliente. En el contexto de una respuesta HTTP estándar, puedes usar el encabezado o el cuerpo que lo acompaña, por consiguiente, tenemos dos maneras de enviar identificadores de sesión a los clientes: por cookies o por URLs. |
| 14 | + |
| 15 | +- Cookies: el servidor puede fácilmente usar `Set-cookie` dentro del encabezado de la respuesta para enviar el identificador de sesión del cliente, y el cliente puede usar esta cookie para las futuras peticiones; usualmente definimos el tiempo de expiración de cookies que contienen información de sesión a 0, lo que significa que la cookie será guardada en memoria y será eliminada cuando el usuario cierre el navegador. |
| 16 | +- URLs: concatenar el identificador de sesión como argumento en todas las páginas. Esta opción puede sonar desordenada, pero es la mejor opción si el navegador tiene deshabilitadas las cookies. |
| 17 | + |
| 18 | +## Usando Go para manejar sesiones |
| 19 | + |
| 20 | +Hemos hablado sobre la construcción de sesiones, y deberías tener una idea de como funciona, pero ¿cómo podemos usar sesiones en páginas dinámicas? Miremos de cerca al ciclo de vida de una sesión y luego podremos continuar la implementación de nuestro manejador de sesiones en Go. |
| 21 | + |
| 22 | +### Diseño del manejo de sesión |
| 23 | + |
| 24 | +Aquí está una lista de algunas de las consideraciones claves para el diseño del manejo de sesión |
| 25 | + |
| 26 | +- Manejador de sesiones Global. |
| 27 | +- Mantener el identificador de sesión único. |
| 28 | +- Tener una sesión por cada usuario. |
| 29 | +- Almacenamiento de la sesión en memoria, archivos o base de datos. |
| 30 | +- Manejar las sesiones expiradas. |
| 31 | + |
| 32 | +A continuación vamos a examinar un ejemplo completo de un manejador de sesiones en Go y el porqué de las decisiones de diseño que se tomaron. |
| 33 | + |
| 34 | +### Manejador de sesión |
| 35 | + |
| 36 | +Definir un manejador de sesiones global: |
| 37 | +``` |
| 38 | + type Manager struct { |
| 39 | + cookieName string //private cookiename |
| 40 | + lock sync.Mutex // protects session |
| 41 | + provider Provider |
| 42 | + maxlifetime int64 |
| 43 | + } |
| 44 | +
|
| 45 | + func NewManager(provideName, cookieName string, maxlifetime int64) (*Manager, error) { |
| 46 | + provider, ok := provides[provideName] |
| 47 | + if !ok { |
| 48 | + return nil, fmt.Errorf("session: unknown provide %q (forgotten import?)", provideName) |
| 49 | + } |
| 50 | + return &Manager{provider: provider, cookieName: cookieName, maxlifetime: maxlifetime}, nil |
| 51 | + } |
| 52 | +``` |
| 53 | +Crear un manejador de sesiones global en la función `main()`: |
| 54 | +``` |
| 55 | + var globalSessions *session.Manager |
| 56 | + // Then, initialize the session manager |
| 57 | + func init() { |
| 58 | + globalSessions = NewManager("memory","gosessionid",3600) |
| 59 | + } |
| 60 | +``` |
| 61 | +Como sabemos que podemos guardar las sesiones de muchas maneras, como en memoria, sistema de ficheros o directamente en la base de datos, necesitamos definir un interfaz `Provider` en orden de representar la estructura bajo nuestro manejador de sesiones: |
| 62 | +``` |
| 63 | + type Provider interface { |
| 64 | + SessionInit(sid string) (Session, error) |
| 65 | + SessionRead(sid string) (Session, error) |
| 66 | + SessionDestroy(sid string) error |
| 67 | + SessionGC(maxLifeTime int64) |
| 68 | + } |
| 69 | +``` |
| 70 | +- `SessionInit` implementa la inicialización de una sesión y retorna una nueva sesión si es exitoso. |
| 71 | +- `SessionRead` retorna una sesión representada con el identificador de sesión sid. Crea una nueva sesión y la retorna si no existe. |
| 72 | +- `SessionDestroy` dado un sid, elimina la sesión correspondiente. |
| 73 | +- `SessionGC` elimina las variables de sesión basado en el criterio `maxLifeTime`. |
| 74 | + |
| 75 | +Entonces, ¿qué métodos debería tener nuestra interfaz de sesión? Si tienes alguna experiencia en desarrollo web deberías saber que solo hay cuatro operaciones para las sesiones: definir el valor, obtener el valor, eliminar el valor y obtener el identificador actual. Entonces en nuestra interfaz de sesión vamos a tener estos cuatro métodos para realizar estas operaciones. |
| 76 | +``` |
| 77 | + type Session interface { |
| 78 | + Set(key, value interface{}) error //set session value |
| 79 | + Get(key interface{}) interface{} //get session value |
| 80 | + Delete(key interface{}) error //delete session value |
| 81 | + SessionID() string //back current sessionID |
| 82 | + } |
| 83 | +``` |
| 84 | +Este diseño está basado en `database/sql/driver`, que define la interface primero, luego registra la estructura específica que queremos usar. El siguiente código es la implementación interna de nuestra función de registro. |
| 85 | +``` |
| 86 | + var provides = make(map[string]Provider) |
| 87 | +
|
| 88 | + // Register makes a session provider available by the provided name. |
| 89 | + // If a Register is called twice with the same name or if the driver is nil, |
| 90 | + // it panics. |
| 91 | + func Register(name string, provider Provider) { |
| 92 | + if provider == nil { |
| 93 | + panic("session: Register provider is nil") |
| 94 | + } |
| 95 | + if _, dup := provides[name]; dup { |
| 96 | + panic("session: Register called twice for provider " + name) |
| 97 | + } |
| 98 | + provides[name] = provider |
| 99 | + } |
| 100 | +``` |
| 101 | +### Identificacores de sesión únicos. |
| 102 | + |
| 103 | +Los identificadores de sesión únics sirven para identificar usuarios en las aplicaciones web, por lo tanto deben ser únicos. El siguiente código muestra como lograr esto: |
| 104 | +``` |
| 105 | + func (manager *Manager) sessionId() string { |
| 106 | + b := make([]byte, 32) |
| 107 | + if _, err := io.ReadFull(rand.Reader, b); err != nil { |
| 108 | + return "" |
| 109 | + } |
| 110 | + return base64.URLEncoding.EncodeToString(b) |
| 111 | + } |
| 112 | +``` |
| 113 | +### Crear una sesión |
| 114 | + |
| 115 | +Necesitamos localizar u obtener una sesión existente en orden de validar las operaciones de usuario. La función `SessionStart` es para verificar la existencia de cualquier sesión relacionada al usuario actual, y crearla si no ninguna sesión es encontrada. |
| 116 | +``` |
| 117 | + func (manager *Manager) SessionStart(w http.ResponseWriter, r *http.Request) (session Session) { |
| 118 | + manager.lock.Lock() |
| 119 | + defer manager.lock.Unlock() |
| 120 | + cookie, err := r.Cookie(manager.cookieName) |
| 121 | + if err != nil || cookie.Value == "" { |
| 122 | + sid := manager.sessionId() |
| 123 | + session, _ = manager.provider.SessionInit(sid) |
| 124 | + cookie := http.Cookie{Name: manager.cookieName, Value: url.QueryEscape(sid), Path: "/", HttpOnly: true, MaxAge: int(manager.maxlifetime)} |
| 125 | + http.SetCookie(w, &cookie) |
| 126 | + } else { |
| 127 | + sid, _ := url.QueryUnescape(cookie.Value) |
| 128 | + session, _ = manager.provider.SessionRead(sid) |
| 129 | + } |
| 130 | + return |
| 131 | + } |
| 132 | +``` |
| 133 | +Aquí hay un ejemplo que usa la sesión de usuario para el ingreso. |
| 134 | +``` |
| 135 | + func login(w http.ResponseWriter, r *http.Request) { |
| 136 | + sess := globalSessions.SessionStart(w, r) |
| 137 | + r.ParseForm() |
| 138 | + if r.Method == "GET" { |
| 139 | + t, _ := template.ParseFiles("login.gtpl") |
| 140 | + w.Header().Set("Content-Type", "text/html") |
| 141 | + t.Execute(w, sess.Get("username")) |
| 142 | + } else { |
| 143 | + sess.Set("username", r.Form["username"]) |
| 144 | + http.Redirect(w, r, "/", 302) |
| 145 | + } |
| 146 | + } |
| 147 | +``` |
| 148 | +### Operaciones con valores: definir, obtener y eliminar. |
| 149 | + |
| 150 | +La función `SessionStart` retorna una variable que implementa la interfaz de sesión. ¿Cómo la usamos? |
| 151 | + |
| 152 | +Viste un `session.Get("uid")` en el ejemplo anterior para una operación básica. Ahora examinémolo en mejor detalle. |
| 153 | +``` |
| 154 | + func count(w http.ResponseWriter, r *http.Request) { |
| 155 | + sess := globalSessions.SessionStart(w, r) |
| 156 | + createtime := sess.Get("createtime") |
| 157 | + if createtime == nil { |
| 158 | + sess.Set("createtime", time.Now().Unix()) |
| 159 | + } else if (createtime.(int64) + 360) < (time.Now().Unix()) { |
| 160 | + globalSessions.SessionDestroy(w, r) |
| 161 | + sess = globalSessions.SessionStart(w, r) |
| 162 | + } |
| 163 | + ct := sess.Get("countnum") |
| 164 | + if ct == nil { |
| 165 | + sess.Set("countnum", 1) |
| 166 | + } else { |
| 167 | + sess.Set("countnum", (ct.(int) + 1)) |
| 168 | + } |
| 169 | + t, _ := template.ParseFiles("count.gtpl") |
| 170 | + w.Header().Set("Content-Type", "text/html") |
| 171 | + t.Execute(w, sess.Get("countnum")) |
| 172 | + } |
| 173 | +``` |
| 174 | +Como puedes ver, operar con sesiones simplemente es usar un patrón llave/valor en las operaciones de definición, obtención y eliminación. |
| 175 | + |
| 176 | +Porque las sesiones tiene el concepto de tiempo de expiración definimos un Recolector de Basura para actualizar el último tiempo de modificación. De esta manera, el recolector de basura no eliminará sesiones que todavía están siendo usados. |
| 177 | + |
| 178 | +### Definir sesiones. |
| 179 | + |
| 180 | +Sabemos que las aplicaciones web tienen una operación de cerrar sesión. Cuando los usuarios cierran sesión, necesitamos eliminar la sesión correspondiente. Ya hemos usado la operación de reset en el ejemplo anterior, ahora vamos a mirar el cuerpo de la función. |
| 181 | +``` |
| 182 | + //Destroy sessionid |
| 183 | + func (manager *Manager) SessionDestroy(w http.ResponseWriter, r *http.Request){ |
| 184 | + cookie, err := r.Cookie(manager.cookieName) |
| 185 | + if err != nil || cookie.Value == "" { |
| 186 | + return |
| 187 | + } else { |
| 188 | + manager.lock.Lock() |
| 189 | + defer manager.lock.Unlock() |
| 190 | + manager.provider.SessionDestroy(cookie.Value) |
| 191 | + expiration := time.Now() |
| 192 | + cookie := http.Cookie{Name: manager.cookieName, Path: "/", HttpOnly: true, Expires: expiration, MaxAge: -1} |
| 193 | + http.SetCookie(w, &cookie) |
| 194 | + } |
| 195 | + } |
| 196 | +``` |
| 197 | +### Eliminar sesiones |
| 198 | + |
| 199 | +Vamos a ver como dejar al manejador de sesiones eliminar una sesión. Necesitamos iniciar el recolector de baseura en la función `main()`: |
| 200 | +``` |
| 201 | + func init() { |
| 202 | + go globalSessions.GC() |
| 203 | + } |
| 204 | +
|
| 205 | + func (manager *Manager) GC() { |
| 206 | + manager.lock.Lock() |
| 207 | + defer manager.lock.Unlock() |
| 208 | + manager.provider.SessionGC(manager.maxlifetime) |
| 209 | + time.AfterFunc(time.Duration(manager.maxlifetime), func() { manager.GC() }) |
| 210 | + } |
| 211 | +``` |
| 212 | +Como podemos ver el recolector de basura hace un uso completo del paquete `time`. Automáticamente llama al recolector de basura cuando la sesión se termina, asegurando que todas las sesiones se puedan usar durante `maxLifeTime`. Una solución similar puede usarse para contar los usuarios activos. |
| 213 | + |
| 214 | +## Resumen |
| 215 | + |
| 216 | +Hemos implementado un manejador de sesión global para una aplicación web y definido la interfaz `Provider` como implementación de una `Session`. En la siguiente sección vamos a hablar sobre como implementar un `Provider` para una estructura de almacenamiento de sesiones, que podrás referencia en el futuro. |
| 217 | + |
| 218 | +## Enlaces |
| 219 | + |
| 220 | +- [Índice](preface.md) |
| 221 | +- Sección anterior: [Sesiones y cookies](06.1.md) |
| 222 | +- Siguiente sección: [Almacenamiento de sesiones](06.3.md) |
0 commit comments