Compila una app para Android con Firebase y el entorno flexible de App Engine

En este instructivo, se demuestra cómo escribir una app para dispositivos móviles con almacenamiento de datos de backend, sincronización en tiempo real y registro de eventos del usuario con Firebase. Los servlets de Java que se ejecutan en el entorno flexible de App Engine de Google Cloud Platform (GCP) escuchan registros de usuarios nuevos almacenados en Firebase y los procesan.

En las instrucciones, se muestra cómo hacerlo con Firebase y el entorno flexible de App Engine.

Si deseas que tu aplicación procese datos del usuario o que organice eventos, puedes extender Firebase con el entorno flexible de App Engine para realizar una sincronización automática de datos en tiempo real.

La app de muestra, Playchat, almacena mensajes de chat en Firebase Realtime Database, que sincroniza esos datos en todos los dispositivos de forma automática. Playchat también escribe los registros de eventos del usuario en Firebase. Para obtener más información sobre cómo la base de datos sincroniza los datos, consulta ¿Cómo funciona? en la documentación de Firebase.

En el siguiente diagrama, se muestra la arquitectura del cliente de Playchat.

Arquitectura de cliente de Playchat

Un conjunto de servlets de Java que se ejecutan en el entorno flexible de App Engine se registran como objetos a la escucha con Firebase. Los servlets responden a los nuevos registros de eventos del usuario y procesan los datos de registro. Los servlets usan transacciones para garantizar que solo un servlet maneje cada registro de eventos del usuario.

En el siguiente diagrama, se muestra la arquitectura del servidor de Playchat.

Arquitectura de servidor de Playchat

La comunicación entre la app y el servlet ocurre en tres partes:

  • Cuando un usuario nuevo se conecta a Playchat, la app solicita un servlet de registro para ese usuario y agrega una entrada en /inbox/ en Firebase Realtime Database.

  • Uno de los servlets acepta la asignación y actualiza el valor de la entrada a su identificador de servlet. El servlet usa una transacción de Firebase para garantizar que sea el único servlet que pueda actualizar el valor. Una vez actualizado el valor, todos los demás servlets ignoran la solicitud.

  • Cuando el usuario accede, cierra sesión o cambia a un nuevo canal, Playchat registra la acción en /inbox/[SERVLET_ID]/[USER_ID]/, en el que [SERVLET_ID] es el identificador de la instancia del servlet y [USER_ID] es un valor de hash que representa al usuario.

  • El servlet detecta las nuevas entradas en la bandeja de entrada y recopila los datos de registro.

En esta app de muestra, los servlets copian los datos de registro de forma local y los muestran en una página web. En una versión de producción de esta app, los servlets podrían procesar los datos de registro o copiarlos en Cloud Storage, Cloud Bigtable o BigQuery para su almacenamiento y análisis.

Objetivos

En este instructivo, se muestra cómo realizar las siguientes acciones:

  • Compilar una app para Android, Playchat, que almacena datos en Firebase Realtime Database

  • Ejecutar un servlet de Java en los entornos flexibles de App Engine que se conecte a Firebase y reciba notificaciones cuando los datos almacenados en Firebase cambien

  • Usar estos dos componentes para compilar un servicio de backend distribuido de transmisión a fin de recolectar y procesar datos de registro

Costos

Firebase tiene un nivel de uso gratuito. Si el uso de estos servicios es menor que los límites especificados en el plan gratuito de Firebase, no se aplican cargos por usar Firebase.

Las instancias dentro del entorno flexible de App Engine se cobran según el costo de las máquinas virtuales subyacentes de Google Compute Engine.

Antes de comenzar

Instala el siguiente software:

Ejecuta el siguiente comando desde la siguiente línea de comandos para instalar el componente de Java de App Engine del SDK de Cloud:

gcloud components install app-engine-java

Clona el código de muestra

  1. Clona el código de la app cliente de frontend.

    git clone https://github.com/GoogleCloudPlatform/firebase-android-client
    
  2. Clona el código del servlet de backend.

    git clone https://github.com/GoogleCloudPlatform/firebase-appengine-backend
    

Genera una huella digital SHA-1 para la app

Si quieres autenticar tu app cliente para el Acceso con Google, debes proporcionar una huella digital SHA-1 del certificado. En este instructivo, se usa un almacén de claves de depuración. Para obtener más información sobre cómo crear versiones de la huella digital del almacén de claves, consulta Autentica tu cliente.

  • Compila un SHA-1 de tu almacén de claves de depuración.

    keytool -exportcert -list -v \
    -alias androiddebugkey -keystore ~/.android/debug.keystore
    

Crea un proyecto de Firebase

  1. Crea una cuenta de Firebase o inicia sesión en una cuenta existente.

  2. Haz clic en Agregar proyecto.

  3. En Nombre del proyecto, ingresa: Playchat

  4. Sigue los pasos de configuración restantes y haz clic en Crear proyecto.

  5. Después de que el asistente aprovisione tu proyecto, haz clic en Continuar.

  6. En la página Descripción general de tu proyecto, haz clic en el ícono de Configuración y, a continuación, haz clic en Configuración del proyecto.

  7. Haz clic en Agregar Firebase a tu app para Android.

  8. En Nombre del paquete de Android, ingresa: com.google.cloud.solutions.flexenv.

  9. En Certificado de firma de depuración SHA-1, ingresa el valor SHA-1 que generaste en la sección anterior.

  10. Haz clic en Registrar app.

  11. Sigue los pasos en la sección Descargar archivo de configuración para agregar el archivo google-services.json a tu proyecto.

  12. Haz clic en Siguiente en la sección Descargar archivo de configuración.

  13. Toma nota de los cambios sugeridos para los archivos build.gradle de nivel de aplicación y del proyecto.

  14. Haz clic en Siguiente en la sección Agregar el SDK de Firebase.

  15. Haz clic en Omitir este paso en la sección Ejecutar tu app para verificar la instalación.

Crea Realtime Database

  1. En el menú de la izquierda de Firebase console, selecciona Base de datos en el grupo Desarrollar.

  2. En la página Base de datos, ve a la sección Realtime Database y haz clic en Crear base de datos.

  3. En el cuadro de diálogo Reglas de seguridad para Realtime Database, selecciona Comenzar en modo de prueba y haz clic en Habilitar.

    En este paso, se muestran los datos que almacenaste en Firebase. En los pasos posteriores de este instructivo, puedes repasar esta página web para ver los datos que la app cliente y el servlet de backend agregaron y actualizaron.

  4. Toma nota de la URL de Firebase para tu proyecto, que tiene el formato https://[FIREBASE_PROJECT_ID].firebaseio.com/ y aparece junto al ícono de vínculo.

Habilita la autenticación de Google para el proyecto de Firebase

Hay una variedad de proveedores de acceso que puedes configurar para conectarte a tu proyecto de Firebase. En este instructivo, aprenderás a configurar la autenticación para que un usuario pueda acceder con una Cuenta de Google.

  1. En el menú de la izquierda de Firebase console, haz clic en Autenticación en el grupo Desarrollar.

  2. Haz clic en Configurar el método de acceso.

  3. Selecciona Google, activa la opción Habilitar y haz clic en Guardar.

Agrega una cuenta de servicio al proyecto de Firebase

El servlet de backend no usa una Cuenta de Google para acceder. En su lugar, se conecta a Firebase con una cuenta de servicio. Sigue los siguientes pasos a fin de crear una cuenta de servicio que pueda conectarse a Firebase y para agregar las credenciales de la cuenta de servicio al código del servlet.

  1. En el menú de la izquierda de Firebase console, al lado de la página principal del proyecto de Playchat, selecciona el ícono de Configuración y luego Configuración del proyecto.

  2. Selecciona Cuentas de servicio y luego Administrar todas las cuentas de servicio.

  3. Haz clic en CREAR CUENTA DE SERVICIO.

  4. Establece la siguiente configuración:

    1. En Nombre de cuenta de servicio, ingresa playchat-servlet.
    2. En Función, selecciona Proyecto > Propietario.

    3. Marca la opción Proporcionar una nueva clave privada.

    4. Selecciona JSON en Tipo de clave.

  5. Haz clic en Crear.

  6. Descarga el archivo de claves JSON para la cuenta de servicio y guárdalo en el proyecto de servicio de backend, firebase-appengine-backend, en el directorio src/main/webapp/WEB-INF/. El nombre del archivo tiene el formato Playchat-[UNIQUE_ID].json.

  7. Edita src/main/webapp/WEB-INF/web.xml y los parámetros de inicialización de la siguiente manera:

    • Reemplaza JSON_FILE_NAME con el nombre del archivo de claves JSON que descargaste.

    • Reemplaza FIREBASE_URL con la URL de Firebase que anotaste antes.

      <init-param>
        <param-name>credential</param-name>
        <param-value>/WEB-INF/JSON_FILE_NAME</param-value>
      </init-param>
      <init-param>
        <param-name>databaseUrl</param-name>
        <param-value>FIREBASE_URL</param-value>
      </init-param>
      

Habilita la facturación y las API para el proyecto de Cloud Platform

Si quieres que el servicio de backend se ejecute en Cloud Platform, debes habilitar la facturación y las API para el proyecto. El proyecto de Cloud Platform es el mismo proyecto que creaste en Crea un proyecto de Firebase y tiene el mismo identificador de proyecto.

  1. En Cloud Platform Console, selecciona el proyecto Playchat.

    Ir a la página Proyectos

  2. Asegúrate de tener habilitada la facturación para tu proyecto.

    Aprende a habilitar la facturación

  3. {% dynamic if "no_credentials" in setvar.task_params %} {% dynamic setvar credential_type %}NO_AUTH{% dynamic endsetvar %} {% dynamic if not setvar.redirect_url %} {% dynamic setvar redirect_url %}https://console.cloud.google.com{% dynamic endsetvar %} {% dynamic endif %}{% dynamic endif %} {% dynamic if setvar.in_henhouse_no_auth_whitelist %} {% dynamic if not setvar.credential_type %}{% dynamic setvar credential_type %}NO_AUTH{% dynamic endsetvar %} {% dynamic endif %} {% dynamic elif setvar.in_henhouse_service_account_whitelist %} {% dynamic if not setvar.credential_type %}{% dynamic setvar credential_type %}SERVICE_ACCOUNT{% dynamic endsetvar %} {% dynamic endif %}{% dynamic endif %} {% dynamic if not setvar.service_account_roles and setvar.credential_type == "SERVICE_ACCOUNT" %} {% dynamic setvar service_account_roles %} {% dynamic endsetvar %} {% dynamic endif %} {% dynamic setvar console %} {% dynamic if "no_steps" not in setvar.task_params %}
  4. {% dynamic endif %} {% dynamic if setvar.api_list %} {% dynamic if setvar.in_henhouse_no_auth_whitelist or setvar.in_henhouse_service_account_whitelist %} Configurar un proyecto de GCP Console.

    Configurar un proyecto

    Haz clic para realizar alguna de las siguientes acciones:

    • Crear o seleccionar un proyecto.
    • Habilitar las {% dynamic if setvar.api_names %}{% dynamic print setvar.api_names %}{% dynamic else %}{% dynamic endif %}{% dynamic if "," in setvar.api_list %} API{% dynamic elif "API" in setvar.api_names %}{% dynamic else %} API{% dynamic endif %} necesarias para el proyecto.
    • {% dynamic if setvar.credential_type == 'SERVICE_ACCOUNT' %}
    • Crear una cuenta de servicio.
    • Descargar una clave privada como JSON.
    • {% dynamic endif %}

    Puedes visualizar y administrar estos recursos en GCP Console en cualquier momento.

    {% dynamic else %}{% dynamic if "no_text" not in setvar.task_params %} Habilita las {% dynamic if setvar.api_names %}{% dynamic print setvar.api_names %}{% dynamic else %}{% dynamic endif %}{% dynamic if "," in setvar.api_list %} API{% dynamic elif "API" in setvar.api_names %}{% dynamic else %} API{% dynamic endif %} necesarias. {% dynamic endif %}

    Habilita las {% dynamic if "," in setvar.api_list %} API{% dynamic else %} API{% dynamic endif %}

    {% dynamic endif %}{% dynamic endif %}{% dynamic if "no_steps" not in setvar.task_params %}
  5. {% dynamic endif %}{% dynamic endsetvar %}{% dynamic print setvar.console %}

Compila y luego implementa el servicio de backend

El servicio de backend en este ejemplo usa una configuración de Docker para especificar su entorno de hosting. Debido a esta personalización, debes usar el entorno flexible de App Engine en lugar del entorno estándar de App Engine.

Para compilar el servlet de backend y luego implementarlo en el entorno flexible de App Engine, puedes usar el complemento de Maven de Google App Engine. Este complemento ya está especificado en el archivo de compilación de Maven incluido en este ejemplo.

Configura el proyecto

Si quieres que Maven sea capaz de compilar el servlet de backend de manera adecuada, debes proporcionarle el proyecto de Google Cloud Platform (GCP) para que pueda iniciar los recursos del servlet en él. El identificador del proyecto de GCP y el identificador del proyecto de Firebase son los mismos.

  1. Proporciona las credenciales que usa la herramienta de gcloud para acceder a GCP.

    gcloud auth login
    
  2. Configura el proyecto como tu proyecto de Firebase con el siguiente comando y reemplaza [FIREBASE_PROJECT_ID] con el nombre del ID del proyecto de Firebase que anotaste antes.

    gcloud config set project [FIREBASE_PROJECT_ID]
    
  3. Verifica que el proyecto se haya configurado con una lista de las opciones de configuración.

    gcloud config list
    

(Opcional) Ejecuta el servicio en el servidor local

Cuando desarrolles un nuevo servicio de backend, ejecuta el servicio de forma local antes de implementarlo en App Engine para iterar con rapidez los cambios sin la sobrecarga que puede generar una implementación completa en App Engine.

Si ejecutas el servidor de forma local, este no usa una configuración de Docker ni se ejecuta en un entorno de App Engine. En su lugar, Maven garantiza que todas las bibliotecas dependientes estén instaladas de forma local y la app se ejecute en el servidor web de Jetty.

  1. En el directorio firebase-appengine-backend, compila y ejecuta el módulo de backend de forma local con el siguiente comando:

    mvn clean package appengine:run
    
    mvn clean package appengine:run -Dgcloud.gcloud_directory=[PATH_TO_TOOL]
    
  2. Si se te pregunta ¿Deseas que la aplicación “Python.app” acepte conexiones de red entrantes?, selecciona Permitir.

Cuando finalice la implementación, abre http://localhost:8080/printLogs para verificar que tu servicio de backend esté en ejecución. La página web muestra “Bandeja de entrada:” seguido de un identificador de 16 dígitos. Este es el identificador de la bandeja de entrada para el servlet que se ejecuta en tu máquina local.

Este identificador no cambia aunque actualices la página, tu servidor local pone en marcha una sola instancia del servlet. Esto es útil para realizar pruebas, porque solo hay un identificador de servlet almacenado en Firebase Realtime Database.

Para cerrar el servidor local, oprime Ctrl+C.

Implementa el servicio en el entorno flexible de App Engine

Cuando ejecutas el servicio de backend en el entorno flexible de App Engine, App Engine usa la configuración en /firebase-appengine-backend/src/main/webapp/Dockerfiles para compilar el entorno de hosting en el que se ejecuta el servicio. El entorno flexible pone en marcha varias instancias del servlet y aumenta y disminuye su escala para satisfacer la demanda.

  • En el directorio firebase-appengine-backend, compila y ejecuta el módulo de backend de forma local con el siguiente comando:

    mvn clean package appengine:deploy
    
    mvn clean package appengine:deploy -Dgcloud.gcloud_directory=[PATH_TO_GCLOUD]
    

A medida que se ejecuta la compilación, podrás ver las líneas “Enviando el contexto de compilación al Daemon de Docker…”. El comando anterior sube tu configuración de Docker y la configura en el entorno flexible de App Engine.

Cuando finalice la implementación, abre https://[FIREBASE_PROJECT_ID].appspot.com/printLogs, en el que [FIREBASE_PROJECT_ID] es el identificador de Crea un proyecto de Firebase. La página web muestra “Bandeja de entrada:” seguido de un identificador de 16 dígitos. Este es el identificador de la bandeja de entrada para un servlet que se ejecuta en el entorno flexible de App Engine.

Cuando actualizas la página, este identificador cambia de manera periódica a medida que App Engine pone en marcha múltiples instancias del servlet a fin de manejar las solicitudes entrantes de los clientes.

Agrega Firebase y Servicios de Google Play a la app para Android

La app cliente usa Firebase Realtime Database a fin de almacenar y sincronizar mensajes, además de documentar los registros de eventos del usuario. La app cliente usa Servicios de Google Play para autenticar a los usuarios con sus Cuentas de Google.

  1. En Android Studio, selecciona Herramientas > SDK Manager.

  2. En la parte superior del panel derecho, selecciona Herramientas del SDK.

  3. Selecciona Servicios de Google Play si no se encuentra seleccionado.

  4. Haz clic en Aceptar.

  5. Selecciona Archivo > Abrir… y elige el directorio firebase-android-client.

  6. Espera a que la información del proyecto de Gradle se termine de compilar. Si se te solicita que uses el wrapper de Gradle, haz clic en Aceptar.

  7. Los cambios en los archivos build.gradle de nivel de aplicación y del proyecto que anotaste en Crea un proyecto de Firebase ya se realizaron en el código de muestra.

Ejecuta y prueba la app para Android

  1. En Android Studio, con el proyecto firebase-android-client abierto, selecciona Ejecutar > Ejecutar ‘app’.

  2. Selecciona un dispositivo o emulador que posea Android 6.0 con las API de Google como tu dispositivo de prueba.

  3. Cuando la app esté cargada en el dispositivo, accede con tu Cuenta de Google.

    Accede a Playchat

  4. Haz clic en el menú a la izquierda del título de PlayChat y selecciona el canal de libros.

    Selecciona un canal

  5. Ingresa un mensaje.

    Envía un mensaje

  6. Cuando lo hagas, la app de Playchat almacenará tu mensaje en Firebase Realtime Database. Firebase sincroniza los datos almacenados en la base de datos de todos los dispositivos. Los dispositivos que ejecuten Playchat mostrarán el nuevo mensaje cuando un usuario seleccione el canal libros.

    Envía un mensaje

Verifica los datos

Luego de usar la app de Playchat para generar algunos eventos del usuario con la app de Playchat, puedes verificar que los servlets estén registrados a la escucha y recolecten registros de eventos del usuario.

Abre Firebase Realtime Database para tu app, en el que [FIREBASE_PROJECT_ID] es el identificador de Crea un proyecto de Firebase.

https://console.firebase.google.com/project/[FIREBASE_PROJECT_ID]/database/data

En la parte inferior de Firebase Realtime Database, en la ubicación de datos /inbox/, podrás encontrar un grupo de nodos prefijados por client- y seguidos de una clave generada al azar que representa el acceso de cuenta de un usuario. A la última entrada en este ejemplo, client-1240563753, le sigue un identificador de 16 dígitos del servlet que se encuentra a la escucha de los eventos de registro de ese usuario, en este ejemplo, 0035806813827987.

Datos almacenados en Firebase Realtime Database

Justo arriba, en la ubicación de datos /inbox/, se encuentran los identificadores de servlet para todos los servlets asignados por el momento. En este ejemplo, solo un servlet recolecta registros. En /inbox/[SERVLET_IDENTIFIER] están los registros de usuario que la app escribió en ese servlet.

Abre la página de App Engine de tu servicio de backend en https://[FIREBASE_PROJECT_ID].appspot.com/printLogs, en el que [FIREBASE_PROJECT_ID] es el identificador de Crea un proyecto de Firebase. En la página, se muestra el identificador del servlet que registró los eventos del usuario que generaste. También puedes ver las entradas de registro de esos eventos en el identificador de la bandeja de entrada del servlet.

Explora el código

La app para Android de Playchat define una clase, FirebaseLogger, que usa a fin de escribir los registros de eventos del usuario en Firebase Realtime Database.

import com.google.cloud.solutions.flexenv.common.LogEntry;
import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;

/*
 * FirebaseLogger pushes user event logs to a specified path.
 * A backend servlet instance listens to
 * the same key and keeps track of event logs.
 */
class FirebaseLogger {
    private final DatabaseReference logRef;

    FirebaseLogger(String path) {
        logRef = FirebaseDatabase.getInstance().getReference().child(path);
    }

    public void log(String tag, String message) {
        LogEntry entry = new LogEntry(tag, message);
        logRef.push().setValue(entry);
    }

}

Cuando un usuario nuevo accede, Playchat llama a la función requestLogger para agregar una nueva entrada a la ubicación /inbox/ en Firebase Realtime Database y establece un objeto de escucha a fin de que Playchat pueda responder cuando un servlet actualiza el valor de esa entrada y acepta la asignación.

Cuando un servlet actualiza el valor, Playchat quita el objeto de escucha y escribe el registro “Acceso” en la bandeja de entrada del servlet.

/*
 * Request that a servlet instance be assigned.
 */
private void requestLogger(final LoggerListener loggerListener) {
    final DatabaseReference databaseReference = FirebaseDatabase.getInstance().getReference();
    databaseReference.child(IBX + "/" + inbox).addListenerForSingleValueEvent(new ValueEventListener() {
        public void onDataChange(@NonNull DataSnapshot snapshot) {
            if (snapshot.exists() && snapshot.getValue(String.class) != null) {
                firebaseLoggerPath = IBX + "/" + snapshot.getValue(String.class) + "/logs";
                fbLog = new FirebaseLogger(firebaseLoggerPath);
                databaseReference.child(IBX + "/" + inbox).removeEventListener(this);
                loggerListener.onLoggerAssigned();
            }
        }

        public void onCancelled(@NonNull DatabaseError error) {
            Log.e(TAG, error.getDetails());
        }
    });

    databaseReference.child(REQLOG).push().setValue(inbox);
}

En el lado del servicio de backend, cuando se inicia una instancia del servlet, la función init(ServletConfig config) en MessageProcessorServlet.java se conecta a Firebase Realtime Database y agrega un objeto de escucha en la ubicación de datos /inbox/.

Cuando se agrega una nueva entrada a la ubicación de datos /inbox/, el servlet actualiza el valor con su identificador, una señal a la app de Playchat de que el servlet acepta la asignación a fin de procesar registros para ese usuario. El servlet usa las transacciones de Firebase para garantizar que solo un servlet pueda actualizar el valor y aceptar la asignación.

/*
 * Receive a request from a client and reply back its inbox ID.
 * Using a transaction ensures that only a single servlet instance replies
 * to the client. This lets the client know to which servlet instance
 * send consecutive user event logs.
 */
firebase.child(REQLOG).addChildEventListener(new ChildEventListener() {
  public void onChildAdded(DataSnapshot snapshot, String prevKey) {
    firebase.child(IBX + "/" + snapshot.getValue()).runTransaction(new Transaction.Handler() {
      public Transaction.Result doTransaction(MutableData currentData) {
        // Only the first servlet instance writes its ID to the client inbox.
        if (currentData.getValue() == null) {
          currentData.setValue(inbox);
        }
        return Transaction.success(currentData);
      }

      public void onComplete(DatabaseError error, boolean committed, DataSnapshot snapshot) {}
    });
    firebase.child(REQLOG).removeValue();
  }
  // ...
});

Después de que un servlet acepta una asignación para procesar los registros de eventos del usuario, agrega un objeto de escucha que detecta cuando la app de Playchat escribe un nuevo archivo de registro en la bandeja de entrada del servlet. El servlet responde mediante la recuperación de los nuevos datos de registro de Firebase Realtime Database.

/*
 * Initialize user event logger. This is just a sample implementation to
 * demonstrate receiving updates. A production version of this app should
 * transform, filter, or load to another data store such as Google BigQuery.
 */
private void initLogger() {
  String loggerKey = IBX + "/" + inbox + "/logs";
  purger.registerBranch(loggerKey);
  firebase.child(loggerKey).addChildEventListener(new ChildEventListener() {
    public void onChildAdded(DataSnapshot snapshot, String prevKey) {
      if (snapshot.exists()) {
        LogEntry entry = snapshot.getValue(LogEntry.class);
        logs.add(entry);
      }
    }

    public void onCancelled(DatabaseError error) {
      localLog.warning(error.getDetails());
    }

    public void onChildChanged(DataSnapshot arg0, String arg1) {}

    public void onChildMoved(DataSnapshot arg0, String arg1) {}

    public void onChildRemoved(DataSnapshot arg0) {}
  });
}

Limpieza

Sigue estos pasos a fin de evitar que se apliquen cargos a tu cuenta de Google Cloud Platform para los recursos que se usaron en este instructivo:

Borra el proyecto de Cloud Platform y Firebase

La forma más sencilla de detener los cargos de facturación es borrar el proyecto que creaste para este instructivo. Aunque creaste el proyecto en Firebase console, también puedes borrarlo en Cloud Platform Console, ya que los proyectos de Cloud Platform y Firebase son los mismos.

  1. In the GCP Console, go to the Projects page.

    Go to the Projects page

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

Borra las versiones no predeterminadas de tu app de App Engine

Si no quieres borrar tu proyecto de Cloud Platform y Firebase, puedes reducir los costos si eliminas las versiones no predeterminadas de tu app de entorno flexible de App Engine.

  1. In the GCP Console, go to the App Engine Versions page.

    Go to the Versions page

  2. Select the checkbox next to the non-default app version you want to delete.
  3. Click Delete delete at the top of the page to delete the app version.

Pasos siguientes

  • Analiza y archiva datos: en este ejemplo, los servlets almacenan datos de registro solo en la memoria. Para ampliar este ejemplo, puedes hacer que los servlets archiven, transformen y analicen los datos con servicios como Cloud Storage, Cloud Bigtable, Google Cloud Dataflow y BigQuery.

  • Distribuye de manera uniforme la carga de trabajo entre los servlets: App Engine proporciona ajuste de escala automático y manual. Con el ajuste de escala automático, el entorno flexible detecta cambios en la carga de trabajo y luego agrega o quita instancias de VM en el clúster. Con el manual, debes especificar un número estático de instancias para manejar el tráfico. Para obtener más información sobre cómo configurar el escalamiento, consulta la configuración de escalamiento de servicio en la documentación de App Engine.

    Debido a que los registros de actividad de los usuarios se asignan a los servlets mediante el acceso a Firebase Realtime Database, puede que la carga de trabajo no se distribuya de manera uniforme. Por ejemplo, un servlet podría procesar más registros de eventos del usuario que otros servlets.

    Puedes mejorar la eficiencia si implementas un administrador de cargas de trabajo que controle la carga de trabajo de manera independiente en cada VM. Este balanceo de la carga de trabajo podría basarse en métricas como las solicitudes de registro por segundo o la cantidad de clientes en simultáneo.

  • Recupera registros de eventos del usuario no procesados: en esta implementación de muestra, si una instancia del servlet falla, la app cliente asociada con esa instancia no deja de enviar eventos de registro a la bandeja de entrada del servlet en Firebase Realtime Database. En una versión de producción de esta app, el servicio de backend debe detectar esta situación para recuperar los registros de eventos del usuario no procesados.

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…