Manejar sesiones con Firestore

---

En este instructivo, se muestra cómo manejar sesiones en App Engine.

En muchas apps, se necesita controlar las sesiones para la autenticación y las preferencias del usuario. El paquete sessions del kit de herramientas web Gorilla incluye una implementación basada en un sistema de archivos para realizar esta función. Sin embargo, esta implementación no es adecuada para las apps que se pueden entregar desde varias instancias, ya que la sesión que se registra en una instancia puede diferir de las que se registran en otras. Además, el paquete gorilla/sessions incluye una implementación basada en cookies. Sin embargo, esta implementación requiere que se encripten cookies y se almacene toda la sesión en el cliente, en lugar de solo un ID de sesión, que puede ser muy largo para algunas apps.

Objetivos

• Escribe la aplicación.
• Ejecuta la aplicación de manera local.
• Implementa la aplicación en App Engine.

Costos

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

• App Engine
• Firestore

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos Google Cloud pueden disfrutar de una prueba gratuita.

Cuando termines las tareas que se describen en este documento, puedes evitar que se te siga facturando eliminando los recursos que has creado. Para obtener más información, consulta la sección Limpiar.

Antes de comenzar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Firestore API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

Install the Google Cloud CLI.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

To initialize the gcloud CLI, run the following command:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Firestore API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

Install the Google Cloud CLI.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

To initialize the gcloud CLI, run the following command:

gcloud init

1. Actualiza los componentes de gcloud:

   gcloud components update

2. Prepara el entorno de desarrollo.

Configura el proyecto

1. En la ventana de la terminal, clona el repositorio de la app de muestra en la máquina local:

   git clone https://github.com/GoogleCloudPlatform/golang-samples.git

2. Ve al directorio que contiene el código de muestra:

   cd golang-samples/getting-started/sessions

Comprende cómo funciona la app web

Esta app muestra saludos en diferentes idiomas para cada usuario. A los usuarios recurrentes se los saluda siempre en el mismo idioma.

Para que la app pueda guardar las preferencias de un usuario, debes almacenar la información sobre el usuario actual en una sesión. Esta app de muestra usa Firestore para almacenar los datos de las sesiones.

Puedes usar firestoregorilla, un almacén de sesiones compatible con gorilla/sessions.

1. Primero, la app importa las dependencias y define el tipo de app para conservar un sessions.Store y una plantilla HTML, y determina la lista de saludos.

   
   // Command sessions starts an HTTP server that uses session state.
   package main
   
   import (
   	"context"
   	"fmt"
   	"html/template"
   	"log"
   	"math/rand"
   	"net/http"
   	"os"
   
   	"cloud.google.com/go/firestore"
   	firestoregorilla "github.com/GoogleCloudPlatform/firestore-gorilla-sessions"
   	"github.com/gorilla/sessions"
   )
   
   // app stores a sessions.Store. Create a new app with newApp.
   type app struct {
   	store sessions.Store
   	tmpl  *template.Template
   }
   
   // greetings are the random greetings that will be assigned to sessions.
   var greetings = []string{
   	"Hello World",
   	"Hallo Welt",
   	"Ciao Mondo",
   	"Salut le Monde",
   	"Hola Mundo",
   }
   

2. A continuación, la app define una función main, que crea una nueva instancia de app, registra el controlador de índices y, luego, inicia el servidor HTTP. La función newApp crea la instancia de app mediante la inicialización de un sessions.Store con la función firestoregorilla.New.

   
   func main() {
   	port := os.Getenv("PORT")
   	if port == "" {
   		port = "8080"
   	}
   	projectID := os.Getenv("GOOGLE_CLOUD_PROJECT")
   	if projectID == "" {
   		log.Fatal("GOOGLE_CLOUD_PROJECT must be set")
   	}
   
   	a, err := newApp(projectID)
   	if err != nil {
   		log.Fatalf("newApp: %v", err)
   	}
   
   	http.HandleFunc("/", a.index)
   
   	log.Printf("Listening on port %s", port)
   	if err := http.ListenAndServe(":"+port, nil); err != nil {
   		log.Fatal(err)
   	}
   }
   
   // newApp creates a new app.
   func newApp(projectID string) (*app, error) {
   	ctx := context.Background()
   	client, err := firestore.NewClient(ctx, projectID)
   	if err != nil {
   		log.Fatalf("firestore.NewClient: %v", err)
   	}
   	store, err := firestoregorilla.New(ctx, client)
   	if err != nil {
   		log.Fatalf("firestoregorilla.New: %v", err)
   	}
   
   	tmpl, err := template.New("Index").Parse(`<body>{{.views}} {{if eq .views 1.0}}view{{else}}views{{end}} for "{{.greeting}}"</body>`)
   	if err != nil {
   		return nil, fmt.Errorf("template.New: %w", err)
   	}
   
   	return &app{
   		store: store,
   		tmpl:  tmpl,
   	}, nil
   }
   

3. El controlador de índices obtiene la sesión del usuario y, si es necesario, crea una. A las sesiones nuevas se les asigna un idioma aleatorio y un recuento de vistas de 0. Luego el recuento de vistas aumenta a uno, la sesión se guarda, y la plantilla HTML escribe la respuesta.

   
   // index uses sessions to assign users a random greeting and keep track of
   // views.
   func (a *app) index(w http.ResponseWriter, r *http.Request) {
   	if r.RequestURI != "/" {
   		return
   	}
   
   	// name is a non-empty identifier for this app's sessions. Set it to
   	// something descriptive for your app. It is used as the Firestore
   	// collection name that stores the sessions.
   	name := "hello-views"
   	session, err := a.store.Get(r, name)
   	if err != nil {
   		// Could not get the session. Log an error and continue, saving a new
   		// session.
   		log.Printf("store.Get: %v", err)
   	}
   
   	if session.IsNew {
   		// firestoregorilla uses JSON, which unmarshals numbers as float64s.
   		session.Values["views"] = float64(0)
   		session.Values["greeting"] = greetings[rand.Intn(len(greetings))]
   	}
   	session.Values["views"] = session.Values["views"].(float64) + 1
   	if err := session.Save(r, w); err != nil {
   		log.Printf("Save: %v", err)
   		// Don't return early so the user still gets a response.
   	}
   
   	if err := a.tmpl.Execute(w, session.Values); err != nil {
   		log.Printf("Execute: %v", err)
   	}
   }
   

   En el siguiente diagrama, se muestra cómo Firestore controla las sesiones de la app de App Engine.

   

Nota: Firestore es una base de datos transaccional, distribuida y persistente. A veces, es más conveniente elegir una solución de almacenamiento diferente para las sesiones, como Memcache o Redis, cuyos diseños pueden proporcionar un funcionamiento más rápido en este caso práctico.

Borra sesiones

firestoregorilla no borra las sesiones antiguas o vencidas. Puedes borrar los datos de las sesiones en la consola de Google Cloud o implementar una estrategia de eliminación automática. Cuando usas soluciones de almacenamiento para sesiones, como Memcache o Redis, las sesiones vencidas se borran de forma automática.

Ejecución local

1. En la ventana de la terminal, compila el objeto binario sessions:

   go build
   

2. Inicia el servidor HTTP:

   ./sessions
   

3. Visualiza la app en el navegador web:

   Cloud Shell

   En la barra de herramientas de Cloud Shell, haz clic en Vista previa en la Web y selecciona Vista previa en el puerto 8080.

   Máquina local

   En tu navegador, ve a http://localhost:8080.

   Ves uno de los cinco saludos: "Hello World", "Hallo Welt", "Hola mundo", "Salut le Monde" o "Ciao Mondo". El idioma cambia si abres la página en otro navegador o en modo Incógnito. Puedes ver y editar los datos de las sesiones en la consola de Google Cloud.

   

4. Para detener el servidor HTTP, presiona Control+C en la ventana de la terminal.

Implementa y ejecuta en App Engine

Puedes usar el entorno estándar de App Engine para compilar y, también, implementar una app que se ejecute de forma confiable con cargas pesadas y grandes cantidades de datos.

En este instructivo, se usa el entorno estándar de App Engine para implementar el servidor.

El archivo app.yaml contiene la configuración del entorno estándar de App Engine:

runtime: go112

1. Implementa la app en App Engine con el siguiente comando:

   gcloud app deploy
   

2. En el navegador, ingresa la siguiente URL:

   https://PROJECT_ID.REGION_ID.r.appspot.com

   Reemplaza lo siguiente:

   • PROJECT_ID: El Google Cloud ID de tu proyecto
   • REGION_ID: Un código que App Engine asigna a la app

El saludo ahora se entrega en un servidor web que se ejecuta en una instancia de App Engine.

Depura la app

Si no puedes conectarte a la aplicación de App Engine, verifica lo siguiente:

1. Comprueba que los comandos de implementación de gcloud se completaron correctamente y no generaron ningún error. Si hubo errores (por ejemplo, message=Build failed), corrígelos y, luego, intenta implementar la aplicación de App Engine nuevamente.

2. En la consola de Google Cloud, ve a la página Explorador de registros.

   Ir a la página Explorador de registros

   1. En la lista desplegable Recursos seleccionados recientemente, haz clic en Aplicación de App Engine y, luego, haz clic en Todos module_id. Verás una lista de las solicitudes de cuando visitaste tu aplicación. Si no ves una lista de solicitudes, confirma que seleccionaste Todos module_id en la lista desplegable. Si ves mensajes de error impresos en la consola de Google Cloud, comprueba que el código de tu app coincida con el código de la sección sobre cómo escribir la app web.

   2. Asegúrate de que la API de Firestore esté habilitada.

Limpia

Borra el proyecto

Precaución: Eliminar un proyecto tiene los siguientes efectos:

• Se elimina todo el contenido del proyecto. Si has usado un proyecto que ya existía para las tareas de este documento, cuando lo elimines, también se eliminará cualquier otro trabajo que hayas realizado en él.
• Se pierden los IDs de proyecto personalizados. Cuando creaste este proyecto, es posible que hayas creado un ID de proyecto personalizado que quieras usar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, elimina los recursos seleccionados dentro del proyecto en lugar de eliminar todo el proyecto.

Si tienes previsto consultar varias arquitecturas, tutoriales o guías de inicio rápido, reutilizar los proyectos puede ayudarte a no superar los límites de cuota de proyectos.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Borra la instancia de App Engine

1. In the Google Cloud console, go to the Versions page for App Engine.

   Go to Versions

2. Select the checkbox for the non-default app version that you want to delete.
   Nota: La única forma de eliminar la versión predeterminada de tu aplicación de App Engine es eliminar tu proyecto. Sin embargo, puedes detener la versión predeterminada en la consola. Google Cloud Esta acción detiene todas las instancias asociadas a la versión. Puedes reiniciar estas instancias más adelante si es necesario.

   En el entorno estándar de App Engine, solo puedes detener la versión predeterminada si tu aplicación tiene un escalado manual o básico.

3. Para eliminar la versión de la aplicación, haz clic en Eliminar.

¿Qué sigue?

• Prueba los instructivos de Cloud Run Functions.
• Obtén más información sobre App Engine.
• Prueba Cloud Run, que te permite ejecutar contenedores sin estado en un entorno completamente administrado o en tu propio clúster de Google Kubernetes Engine.