Créer une application Android à l'aide de Firebase et de l'environnement flexible App Engine

Last reviewed 2018-07-31 UTC

Ce tutoriel explique comment développer avec Firebase une application mobile dotée d'un espace de stockage de données backend, d'une synchronisation en temps réel et d'une journalisation des événements utilisateur. Les servlets Java s'exécutant dans l'environnement flexible App Engine de Google Cloud Platform (GCP) détectent les nouveaux journaux utilisateur qui sont stockés dans Firebase et les traitent.

Les instructions montrent comment procéder en utilisant Firebase et l'environnement flexible App Engine.

Si vous souhaitez que votre application traite les données utilisateur ou orchestre les événements, vous pouvez étendre les fonctionnalités de Firebase avec l'environnement flexible App Engine pour synchroniser automatiquement les données en temps réel.

Par exemple, l'application Playchat stocke les messages de discussion dans la base de données Firebase Realtime Database. Cette base de données synchronise automatiquement les données entre les appareils. Playchat écrit également dans les journaux d'événements utilisateur dans Firebase. Pour en savoir plus sur la synchronisation des données dans la base de données, consultez la section Fonctionnement de la documentation Firebase.

Le schéma ci-dessous illustre l'architecture du client Playchat.

Architecture du client Playchat

Un ensemble de servlets Java qui s'exécutent dans l'environnement flexible d'App Engine s'enregistrent en tant que programmes d'écoute avec Firebase. Les servlets répondent aux nouveaux journaux d'événements utilisateur et traitent les données. Ils utilisent des transactions pour garantir qu'un seul servlet gère chaque journal d'événements utilisateur.

Le schéma ci-dessous illustre l'architecture du serveur Playchat.

Architecture du serveur Playchat

La communication entre l'application et le servlet se déroule en trois parties :

  • Lorsqu'un nouvel utilisateur se connecte à Playchat, l'application demande un servlet de journalisation pour cet utilisateur en ajoutant une entrée sous /inbox/ dans Firebase Realtime Database.

  • L'un des servlets accepte l'attribution en mettant à jour la valeur de l'entrée avec son identifiant. Il utilise une transaction Firebase pour garantir que lui seul peut mettre à jour la valeur. Une fois la valeur mise à jour, tous les autres servlets ignorent la requête.

  • Lorsque l'utilisateur se connecte, se déconnecte ou change de canal, Playchat consigne l'action dans /inbox/[SERVLET_ID]/[USER_ID]/, où [SERVLET_ID] représente l'identifiant de l'instance de servlet et [USER_ID] est une valeur de hachage qui représente l'utilisateur.

  • Le servlet surveille les nouvelles entrées dans la boîte de réception et collecte les données du journal.

Dans cet exemple d'application, les servlets copient les données du journal localement et les affichent sur une page Web. Dans une version de production de cette application, les servlets peuvent traiter les données du journal ou les copier dans Cloud Storage, Cloud Bigtable ou BigQuery afin de les stocker et de les analyser.

Objectifs

Ce tutoriel explique comment :

  • créer une application Android, Playchat, qui stocke des données dans la base de données Firebase Realtime Database ;

  • exécuter un servlet Java dans les environnements flexibles d'App Engine. Ce servlet se connecte à Firebase et reçoit des notifications lorsque les données qui y sont stockées sont modifiées ;

  • utiliser ces deux composants pour créer un service distribué, de streaming et de backend afin de collecter et traiter les données des journaux.

Coûts

Firebase est disponible en version gratuite. Si vous utilisez ces services dans les limites spécifiées dans le forfait gratuit de Firebase, l'utilisation de Firebase est gratuite.

Les instances figurant dans l'environnement flexible d'App Engine sont facturées au coût des machines virtuelles Google Compute Engine sous-jacentes.

Avant de commencer

Installez les composants suivants :

Installez le composant Java App Engine de gcloud CLI en exécutant la commande suivante dans la ligne de commande.

gcloud components install app-engine-java

Cloner l'exemple de code

  1. Clonez le code de l'application cliente frontale.

    git clone https://github.com/GoogleCloudPlatform/firebase-android-client

  2. Clonez le code du servlet de backend.

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

Générer une empreinte SHA-1 pour l'application

Pour authentifier votre application cliente avec Google Sign-in, vous devez fournir une empreinte SHA-1 du certificat. Ce tutoriel utilise le magasin de clés de débogage. Pour savoir comment créer des versions de l'empreinte du magasin de clés, consultez la page Authentifier votre client.

  • Créez une empreinte SHA-1 du magasin de clés de débogage.

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

Créer un projet Firebase

  1. Créez un compte Firebase ou connectez-vous à un compte existant.

  2. Cliquez sur Ajouter un projet.

  3. S'il s'agit de votre première visite sur la page, cliquez sur Créer un projet.

  4. Dans le champ Nom du projet, saisissez Playchat.

  5. Suivez les autres étapes de configuration, puis cliquez sur Créer un projet.

    • Vous n'avez pas besoin d'activer Google Analytics pour ce projet.

  6. Une fois que l'assistant a provisionné votre projet, cliquez sur Continuer.

  7. Sur la page Vue d'ensemble du projet de votre projet, cliquez sur Paramètres , puis sur Paramètres du projet.

  8. Cliquez sur l'icône Android pour ouvrir la page Ajouter Firebase à votre application Android.

  9. Dans le champ Nom du package Android, saisissez com.google.cloud.solutions.flexenv.

  10. Dans Certificat de signature de débogage SHA-1, entrez la valeur SHA-1 que vous avez générée à la section précédente.

  11. Cliquez sur Enregistrer l'application.

  12. Suivez les étapes de la section Télécharger le fichier de configuration pour ajouter le fichier google-services.json à votre projet.

  13. Cliquez sur Suivant dans la section Télécharger le fichier de configuration.

  14. Notez les suggestions de modifications à apporter aux fichiers build.gradle au niveau du projet et de l'application.

  15. Cliquez sur Suivant dans la section Ajouter le SDK Firebase.

  16. Cliquez sur Accéder à la console pour terminer la configuration.

Créer une base de données Realtime Database

  1. Dans la console Firebase, sélectionnez votre projet.

  2. Dans le menu de gauche de la console, sélectionnez Realtime Database dans le groupe Build.

  3. Cliquez sur Créer une base de données dans la section Realtime Database.

  4. Sélectionnez un lieu proche de vous.

  5. Dans la boîte de dialogue Règles de sécurité, sélectionnez Commencer en mode test, puis cliquez sur Activer.

    Cette étape permet d'afficher les données que vous avez stockées dans Firebase. Dans les étapes ultérieures de ce tutoriel, vous pourrez revenir à cette page Web pour consulter les données ajoutées et mises à jour par l'application cliente et le servlet de backend.

  6. Dans l'onglet Règles de la base de données, assurez-vous de disposer des règles de sécurité en lecture/écriture qui spécifient une date située 30 jours dans le futur avec l'unité de temps définie sur epoch Unix. Par exemple, si vous créez la règle le 4 août, la règle doit expirer après le 4 septembre :

    {
  "rules": {
    ".read": "now < 1659639249000", //2022-08-04
    ".write": "now < 1659639249000" //2022-08-04
  }
}

  7. Notez l'URL Firebase de votre projet, qui est au format https://[FIREBASE_PROJECT_ID].firebaseio.com/ et s'affiche à côté d'une icône de lien.

Activer l'authentification Google pour le projet Firebase

Vous pouvez configurer différents fournisseurs de connexion pour vous connecter à votre projet Firebase. Ce tutoriel vous explique comment configurer l'authentification afin que l'utilisateur puisse se connecter à l'aide d'un compte Google.

  1. Dans le menu de gauche de la console Firebase, cliquez sur Authentification dans le groupe Développement.

  2. Cliquez sur Configurer un mode de connexion ou sur Premiers pas si vous accédez à la page pour la première fois.

  3. Dans l'onglet Mode de connexion, sélectionnez Google, activez l'option Activer, sélectionnez l'adresse e-mail d'assistance, puis cliquez sur Enregistrer.

Ajouter un compte de service au projet Firebase

Le servlet de backend ne se connecte pas avec un compte Google. Il utilise un compte de service pour se connecter à Firebase. Lors des étapes suivantes, vous allez créer un compte de service pouvant se connecter à Firebase et ajouter ses identifiants au code du servlet.

  1. Dans le menu de gauche de la console Firebase, à côté de la page d'accueil du projet Playchat, cliquez sur l'icône Paramètres (en forme de roue dentée), puis sur Paramètres du projet.

  2. Sélectionnez l'onglet Comptes de service, puis cliquez sur le lien Gérer les autorisations des comptes de service.

  3. Cliquez sur Créer un compte de service.

  4. Configurez les paramètres suivants :

    1. Dans le champ Nom du compte de service, saisissez playchat-servlet, puis cliquez sur Créer et continuer.

    2. Dans Sélectionner un rôle, sélectionnez Projet > Propriétaire, puis cliquez sur Continuer.

    3. Cliquez sur OK.

  5. Cliquez sur le compte de service que vous venez de créer. Dans l'onglet CLÉS, cliquez sur Ajouter une clé, puis sur Créer une clé.

  6. À côté de Type de clé, cliquez sur JSON, puis sur Créer pour télécharger la clé.

  7. Enregistrez le fichier de clé JSON téléchargé pour le compte de service dans le projet de service de backend (firebase-appengine-backend) dans le répertoire src/main/webapp/WEB-INF/. Le nom du fichier est au format Playchat-[UNIQUE_ID].json.

  8. Modifiez le fichier src/main/webapp/WEB-INF/web.xml, puis apportez les changements ci-dessous aux paramètres d'initialisation :

    • Remplacez JSON_FILE_NAME par le nom du fichier de clé JSON que vous avez téléchargé.

    • Remplacez FIREBASE_URL par l'URL Firebase que vous avez notée précédemment.

      <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>

Activer la facturation et les API pour le projet Cloud Platform

Pour que le service de backend fonctionne sur Cloud Platform, vous devez activer la facturation et les API pour le projet. Le projet Cloud Platform est le même que celui que vous avez créé dans la section Créer un projet Firebase. Il possède le même identifiant.

  1. Dans la console Cloud Platform, sélectionnez le projet Playchat.

    Accéder à la page Projets

  2. Make sure that billing is enabled for your Google Cloud project.

  3. Enable the App Engine Admin API and Compute Engine API APIs.

    Enable the APIs

Créer et déployer le service de backend

Dans cet exemple, le service de backend utilise une configuration Docker pour spécifier son environnement d'hébergement. Cette personnalisation signifie que vous devez utiliser l'environnement flexible App Engine au lieu de l'environnement standard.

Pour créer le servlet de backend et le déployer dans l'environnement flexible App Engine, vous pouvez utiliser le plug-in Google App Engine Maven. Ce dernier est déjà spécifié dans le fichier de version Maven disponible avec cet exemple.

Définir le projet

Pour que Maven puisse créer correctement le servlet de backend, il convient de lui indiquer le projet GCP (Google Cloud Platform) dans lequel les ressources du servlet doivent être lancées. L'identifiant du projet GCP est identique à celui du projet Firebase.

  1. Spécifiez les identifiants que gcloud CLI utilise pour accéder à GCP.

    gcloud auth login

  2. Définissez le projet sur votre projet Firebase à l'aide de la commande suivante, en remplaçant [FIREBASE_PROJECT_ID] par l'ID du projet Firebase que vous avez noté précédemment.

    gcloud config set project [FIREBASE_PROJECT_ID]

  3. Vérifiez que le projet a été défini en affichant la configuration.

    gcloud config list

  4. Si vous utilisez App Engine pour la première fois, initialisez votre application App Engine :

    gcloud app create

(Facultatif) Exécuter le service sur le serveur local

Lorsque vous développez un nouveau service de backend, exécutez-le localement avant de le déployer dans App Engine. Vous pourrez ainsi intégrer rapidement les modifications sans avoir à gérer un déploiement complet dans App Engine.

Lorsque vous exécutez le serveur localement, il n'utilise pas de configuration Docker et ne s'exécute pas dans un environnement App Engine. Maven garantit que toutes les bibliothèques dépendantes sont installées localement et que l'application s'exécute sur le serveur Web Jetty.

  1. Dans le répertoire firebase-appengine-backend, créez et exécutez le module de backend localement en utilisant la commande suivante :

    mvn clean package appengine:run

    Si vous avez installé Google Cloud CLI dans un répertoire autre que ~/google-cloud-sdk, ajoutez le chemin d'installation à la commande comme indiqué ci-dessous, en remplaçant [PATH_TO_TOOL] par votre chemin personnalisé.

    mvn clean package appengine:run -Dgcloud.gcloud_directory=[PATH_TO_TOOL]

  2. Si vous recevez le message Do you want the application "Python.app" to accept incoming network connections? (Souhaitez-vous que l'application "Python.app" accepte les connexions réseau entrantes ?), sélectionnez Autoriser.

Une fois le déploiement terminé, ouvrez http://localhost:8080/printLogs pour vérifier que le service de backend est en cours d'exécution. La page Web affiche la mention Inbox: (Boîte de réception :), suivie d'un identifiant à 16 chiffres. Il s'agit de l'identifiant de la boîte de réception du servlet qui s'exécute sur votre machine locale.

Lorsque vous actualisez la page, cet identifiant ne change pas étant donné que votre serveur local génère une seule instance de servlet. Cela s'avère utile pendant les tests, car un seul identifiant de servlet est stocké dans Firebase Realtime Database.

Pour arrêter le serveur local, appuyez sur les touches Ctrl+C.

Déployer le service dans l'environnement flexible App Engine

Lorsque vous exécutez le service de backend dans l'environnement flexible App Engine, App Engine utilise la configuration définie dans /firebase-appengine-backend/src/main/webapp/Dockerfiles pour créer l'environnement d'hébergement dans lequel s'exécute le service. L'environnement flexible génère plusieurs instances de servlet et les adapte en fonction de la demande.

  • Dans le répertoire firebase-appengine-backend, créez et exécutez le module de backend localement en utilisant la commande suivante :

    mvn clean package appengine:deploy

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

Au cours de l'exécution, le message suivant s'affiche : "Sending build context to Docker daemon…" (Envoi du contexte de création au daemon Docker…). La commande précédente importe votre configuration Docker et la configure dans l'environnement flexible App Engine.

Une fois le déploiement terminé, ouvrez https://[FIREBASE_PROJECT_ID].appspot.com/printLogs, où [FIREBASE_PROJECT_ID] est l'identifiant mentionné à l'étape Créer un projet Firebase. La page Web affiche la mention Inbox: (Boîte de réception :), suivie d'un identifiant à 16 chiffres. Il s'agit de l'identifiant de boîte de réception d'un servlet qui s'exécute dans l'environnement flexible App Engine.

Lorsque vous actualisez la page, cet identifiant change régulièrement étant donné qu'App Engine génère plusieurs instances de servlet pour gérer les requêtes entrantes des clients.

Ajouter Firebase et les services Google Play à l'application Android

L'application cliente utilise Firebase Realtime Database pour stocker et synchroniser les messages, et pour enregistrer les journaux d'événements des utilisateurs. Elle utilise les services Google Play pour authentifier les utilisateurs avec leur compte Google.

  1. Dans Android Studio, sélectionnez Tools > SDK Manager (Outils > SDK Manager).

  2. Sélectionnez l'onglet SDK Tools.

  3. Sélectionnez Google Play services (Services Google Play) si ce n'est pas déjà fait.

  4. Cliquez sur OK pour l'installer.

  5. Sélectionnez File > Open… (Fichier > Ouvrir), puis choisissez le répertoire firebase-android-client.

  6. Patientez jusqu'à la fin de la compilation des informations du projet Gradle. Si vous êtes invité à utiliser le wrapper Gradle, cliquez sur OK.

  7. Les modifications des fichiers build.gradle (au niveau du projet et de l'application) que vous avez notées lors de l'étape Créer un projet Firebase ont déjà été appliquées à l'exemple de code.

Exécuter et tester l'application Android

  1. Dans Android Studio, ouvrez le projet firebase-android-client, puis sélectionnez Run > Run 'app' (Exécuter > Exécuter l'application).

  2. Sélectionnez un appareil ou un émulateur exécutant Android 6.0 avec les API Google comme appareil de test.

  3. Lorsque l'application est chargée sur l'appareil, connectez-vous avec votre compte Google.

    Se connecter à Playchat

  4. Cliquez sur le menu situé à gauche du titre "PlayChat", et sélectionnez le canal "books" (livres).

    Sélectionner un canal

  5. Saisissez un message.

    Envoyer un message

  6. Une fois validé, l'application Playchat stocke votre message dans la base de données Firebase Realtime Database. Firebase synchronise les données stockées dans la base de données entre les appareils. Tous les appareils qui exécutent Playchat afficheront le nouveau message lorsqu'un utilisateur sélectionnera le canal books (livres).

    Envoyer un message

Vérifier les données

Après avoir généré des événements utilisateur à l'aide de l'application Playchat, vous pouvez vérifier que les servlets s'enregistrent en tant que programmes d'écoute et collectent les journaux d'événements utilisateur.

Ouvrez la base de données Firebase Realtime Database pour votre application, où [FIREBASE_PROJECT_ID] est l'identifiant mentionné à l'étape Créer un projet Firebase.

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

En bas de la base de données Firebase Realtime Database, sous l'emplacement de données /inbox/, vous pouvez voir un groupe de nœuds précédés de la mention client- et suivis d'une clé générée de manière aléatoire, qui représente les informations de connexion au compte d'un utilisateur. La dernière entrée de cet exemple, client-1240563753, est suivie de l'identifiant à 16 chiffres du servlet qui écoute les événements de journal de cet utilisateur (0035806813827987, dans ce cas).

Données stockées dans Firebase Realtime Database

Ci-dessus, sous l'emplacement de données /inbox/, se trouvent des identifiants de servlet pour tous les servlets actuellement attribués. Dans cet exemple, un seul servlet collecte les journaux. Les journaux utilisateur écrits par l'application pour ce servlet se trouvent sous /inbox/[SERVLET_IDENTIFIER].

Ouvrez la page App Engine de votre service de backend https://[FIREBASE_PROJECT_ID].appspot.com/printLogs, où [FIREBASE_PROJECT_ID] est l'identifiant mentionné à l'étape Créer un projet Firebase. La page affiche l'identifiant du servlet qui a enregistré les événements utilisateur générés. Vous pouvez également visualiser les entrées de journal correspondant à ces événements sous l'identifiant de la boîte de réception du servlet.

Explorer le code

L'application Android Playchat définit une classe FirebaseLogger qu'elle utilise pour écrire des journaux d'événements utilisateur dans Firebase Realtime Database.

app/src/main/java/com/google/cloud/solutions/flexenv/FirebaseLogger.java 

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);
    }

}

Lorsqu'un nouvel utilisateur se connecte, Playchat appelle la fonction requestLogger pour ajouter une entrée à l'emplacement /inbox/ dans Firebase Realtime Database. Par ailleurs, Playchat définit un écouteur afin de pouvoir répondre lorsqu'un servlet met à jour la valeur de cette entrée, acceptant ainsi l'attribution.

Lorsqu'un servlet met à jour la valeur, Playchat supprime le programme d'écoute et écrit "Signed in" (Connexion) dans la boîte de réception du servlet.

app/src/main/java/com/google/cloud/solutions/flexenv/PlayActivity.java 
/*
 * 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);
}

Du côté du service de backend, lorsqu'une instance de servlet démarre, la fonction init(ServletConfig config) de MessageProcessorServlet.java se connecte à Firebase Realtime Database et ajoute un écouteur à l'emplacement de données /inbox/.

Lorsqu'une entrée est ajoutée à l'emplacement de données /inbox/, le servlet met à jour la valeur avec son identifiant. Cette opération signale à l'application Playchat que le servlet accepte l'attribution pour le traitement des journaux de cet utilisateur. Le servlet utilise les transactions Firebase pour s'assurer que lui seul peut mettre à jour la valeur et accepter l'attribution.

src/main/java/com/google/cloud/solutions/flexenv/backend/MessageProcessorServlet.java 
/*
 * 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();
  }
  // ...
});

Lorsqu'un servlet a accepté l'attribution de traitement des journaux d'événements d'un utilisateur, il ajoute un programme d'écoute qui détecte le moment où l'application Playchat écrit un nouveau fichier journal dans sa boîte de réception. Le servlet répond en récupérant les nouvelles données du journal à partir de Firebase Realtime Database.

src/main/java/com/google/cloud/solutions/flexenv/backend/MessageProcessorServlet.java 
/*
 * 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) {}
  });
}

Nettoyer

Afin d'éviter la facturation sur votre compte Google Cloud Platform des ressources utilisées dans ce tutoriel, procédez comme suit :

Supprimer le projet Cloud Platform et Firebase

Le moyen le plus simple d'arrêter les frais de facturation est de supprimer le projet que vous avez créé dans le cadre de ce tutoriel. Bien que vous ayez créé le projet dans la console Firebase, vous pouvez également le supprimer depuis la console Cloud Platform, car les projets Firebase et Cloud Platform ne font qu'un.

  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.

Supprimer les versions autres que celles par défaut de votre application App Engine

Si vous ne souhaitez pas supprimer votre projet Cloud Platform et Firebase, vous pouvez réduire les coûts en supprimant les versions autres que celles par défaut de votre application d'environnement flexible 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.
  3. Pour supprimer la version de l'application, cliquez sur  Supprimer.

Étape suivante

  • Analyser et archiver les données : dans cet exemple, les servlets ne stockent les données des journaux que dans la mémoire. Pour approfondir cet exemple, vous pouvez demander aux servlets d'archiver, de transformer et d'analyser les données à l'aide de services tels que Cloud Storage, Cloud Bigtable, Google Cloud Dataflow et BigQuery.

  • Distribuer uniformément la charge de travail entre les servlets : App Engine propose un scaling et manuel. Avec le scaling automatique, l'environnement flexible détecte les variations de la charge de travail, puis répond en ajoutant ou en supprimant des instances de VM au niveau du cluster. Avec le scaling manuel, vous spécifiez un nombre fixe d'instances pour gérer le trafic. Pour savoir comment configurer le scaling, consultez la section Paramètres de scaling du service dans la documentation d'App Engine.

    Étant donné que les journaux d'activité des utilisateurs sont attribués aux servlets via l'accès à Firebase Realtime Database, la charge de travail peut ne pas être distribuée uniformément. Par exemple, un servlet peut traiter plus de journaux d'événements utilisateur que d'autres servlets.

    Vous pouvez améliorer l'efficacité en mettant en œuvre un gestionnaire de charge de travail qui contrôle de manière indépendante la charge de travail sur chaque VM. Cet équilibrage de la charge de travail peut être basé sur des métriques telles que le nombre de demandes de journalisation par seconde ou le nombre de clients simultanés.

  • Récupérer les journaux d'événements utilisateur non traités : dans cet exemple de mise en œuvre, si une instance de servlet plante, l'application cliente associée à cette instance continue d'envoyer des événements de journal à la boîte de réception du servlet dans Firebase Realtime Database. Dans une version de production de cette application, le service de backend doit détecter cette situation pour récupérer les journaux d'événements utilisateur non traités.

  • Mettre en œuvre des fonctionnalités supplémentaires à l'aide de produits Cloud AI : découvrez comment proposer des fonctionnalités basées sur le machine learning à l'aide des produits et services Cloud AI. Par exemple, vous pouvez étendre cet exemple de mise en œuvre pour fournir une fonctionnalité de traduction vocale, à l'aide d'une combinaison des API Speech-to-Text, Translation et Text-to-Speech. Pour plus d'informations, consultez la page Intégrer la traduction vocale à votre application Android.