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

Ce tutoriel explique comment développer une application iOS avec Firebase, et comment la doter d'un espace de stockage de données backend, de la synchronisation en temps réel et de la journalisation des événements utilisateur. Les servlets Java qui s'exécutent dans l'environnement flexible App Engine écoutent les nouveaux journaux utilisateur 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 dans 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 iOS (Playchat) qui stocke des données dans la base de données Firebase Realtime Database ;

  • exécuter un servlet Java dans l'environnement flexible App Engine (e 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 App Engine sont facturées au coût des machines virtuelles Compute Engine sous-jacentes.

Avant de commencer

Installez les composants suivants :

Installez le composant Java App Engine du SDK Cloud en exécutant la commande suivante dans une fenêtre de terminal.

gcloud components install app-engine-java

Cloner l'exemple de code

  1. Clonez le code de l'application cliente.

    git clone https://github.com/GoogleCloudPlatform/firebase-ios-samples
    
  2. Clonez le code du servlet de backend.

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

Créer un projet Firebase

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

  2. Cliquez sur Ajouter un projet.

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

  4. Suivez les autres étapes d'installation, puis cliquez sur Créer un projet.

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

  6. Sur la page Présentation de votre projet, cliquez sur l'icône Paramètres (en forme de roue dentée), puis sur Paramètres du projet.

  7. Cliquez sur Ajouter Firebase à votre application iOS.

  8. Dans ID du groupe iOS, saisissez com.google.cloud.solutions.flexenv.PlayChat.

  9. Cliquez sur Enregistrer l'application.

  10. Suivez les étapes de la section Télécharger le fichier de configuration pour ajouter le fichier GoogleService-Info.plist au dossier PlayChat de votre projet.

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

  12. Notez les instructions permettant d'utiliser CocoaPods afin d'installer et de gérer les dépendances du projet.

  13. Exécutez la commande suivante pour installer les dépendances :

    pod install
    

    Vous devrez peut-être exécuter la commande pod repo update si votre installation de CocoaPods ne trouve pas la dépendance Firebase.

    Après cette étape et pour tous les futurs développements sur l'application iOS, utilisez le fichier .xcworkspace nouvellement créé à la place du fichier .xcodeproj.

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

  15. Notez le code requis pour initialiser Firebase dans votre projet.

  16. Cliquez sur Suivant dans la section Ajouter le code d'initialisation.

  17. Cliquez sur Ignorer cette étape dans la section Exécuter votre application pour vérifier l'installation.

Créer une base de données Realtime Database

  1. Dans le menu de gauche de la console Firebase, sélectionnez Base de données dans le groupe Développer.

  2. Sur la page Base de données, accédez à la section Realtime Database, puis cliquez sur Créer une base de données.

  3. Dans la boîte de dialogue Règles de sécurité pour Realtime Database, 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.

  4. Notez l'URL Firebase de votre projet, qui utilise le 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évelopper.

  2. Cliquez sur Configurer un mode de connexion.

  3. Sélectionnez Google, activez l'option Activer, 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. Cliquez sur Comptes de service, puis sur Gérer tous les 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.
    2. Dans Rôle, sélectionnez Projet > Propriétaire.

    3. Cochez Indiquez une nouvelle clé privée.

    4. Sélectionnez JSON pour Type de clé.
  5. Cliquez sur Créer.

  6. Téléchargez le fichier de clé JSON du compte de service, puis enregistrez-le dans le projet de service de backend firebase-appengine-backend qui se trouve dans le répertoire src/main/webapp/WEB-INF/. Le nom du fichier est au format Playchat-[UNIQUE_ID].json.

  7. 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 de 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 Google Cloud Platform

Pour que le service de backend s'exécute sur GCP, vous devez activer la facturation et les API pour le projet. Le projet GCP 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 Google Cloud Platform, sélectionnez le projet Playchat.

    Accéder à la page "Projets"

  2. Assurez-vous que la facturation est activée pour votre projet Google Cloud Platform.

    Découvrir comment activer la facturation

  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 %}Configurez un projet dans la console GCP.

    Configurer un projet

    Cliquez pour effectuer les opérations suivantes :

    • Créer ou sélectionner un projet
    • Activer {% dynamic if setvar.api_names %}{% dynamic print setvar.api_names %}{% dynamic else %}{% dynamic endif %}{% dynamic if "," in setvar.api_list %}les API requises{% dynamic elif "API" in setvar.api_names %}{% dynamic else %}l'API requise{% dynamic endif %} pour ce projet
    • {% dynamic if setvar.credential_type == 'SERVICE_ACCOUNT' %}
    • Créer un compte de service
    • Télécharger une clé privée au format JSON
    • {% dynamic endif %}

    Vous pouvez afficher et gérer ces ressources à tout moment dans la console GCP.

    {% dynamic else %}{% dynamic if "no_text" not in setvar.task_params %}Activez {% dynamic if setvar.api_names %}{% dynamic print setvar.api_names %}{% dynamic else %}{% dynamic endif %}{% dynamic if "," in setvar.api_list %}les API requises{% dynamic elif "API" in setvar.api_names %}{% dynamic else %}l'API requise{% dynamic endif %}. {% dynamic endif %}

    Activer {% dynamic if "," in setvar.api_list %}les API{% dynamic else %}l'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 %}

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 plug-in 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 qui permettent à l'outil gcloud d'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. Examinez la configuration pour vérifier que le projet a été défini.

    gcloud config list
    

(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
    
    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 Allow (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 d'App Engine

Lorsque vous exécutez le service de backend dans l'environnement flexible d'App Engine, App Engine utilise la configuration de /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 utilisé à 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.

Mettre à jour le schéma d'URL dans l'exemple iOS

  1. Dans Xcode, avec l'espace de travail PlayChat ouvert, ouvrez le dossier PlayChat.

  2. Ouvrez GoogleService-Info.plist et copiez la valeur de REVERSED_CLIENT_ID.

  3. Ouvrez Info.plist et accédez à key URL types > Item 0 (Editor) > URL Schemes > Item 0 [types d'URL clés > Élément 0 (Éditeur) > Schémas d'URL > Élément 0].

  4. Remplacez la valeur de l'espace réservé, [REVERSED_CLIENT_ID], par la valeur copiée de GoogleService-Info.plist.

Exécuter et tester l'application iOS

  1. Dans Xcode, l'espace de travail PlayChat étant ouvert, sélectionnez Product (Produit) > Run (Exécuter).

  2. Une fois l'application chargée dans le simulateur, connectez-vous avec votre compte Google.

    Se connecter à Playchat

  3. Sélectionnez le canal books (livres).

  4. Saisissez un message.

    Envoyer un message

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 affichent le nouveau message lorsqu'un utilisateur sélectionne 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 Firebase Realtime Database pour votre application, où [FIREBASE_PROJECT_ID] est l'identifiant utilisé à 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 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 utilisé à 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 iOS Playchat définit une classe, FirebaseLogger, qu'elle utilise pour écrire des journaux d'événements utilisateur dans Firebase Realtime Database.

import Firebase

class FirebaseLogger {
  var logRef: DatabaseReference!

  init(ref: DatabaseReference!, path: String!) {
    logRef = ref.child(path)
  }

  func log(_ tag: String!, message: String!) {
    let entry: LogEntry = LogEntry(tag: tag, log: message)
    logRef.childByAutoId().setValue(entry.toDictionary())
  }
}

Lorsqu'un nouvel utilisateur se connecte, Playchat appelle la fonction requestLogger pour ajouter une nouvelle entrée à l'emplacement /requestLogger/ de Firebase Realtime Database. Playchat définit aussi un programme d'écoute afin de pouvoir répondre lorsqu'un servlet met à jour la valeur de cette entrée, en acceptant 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.

func requestLogger() {
  ref.child(IBX + "/" + inbox!).removeValue()
  ref.child(IBX + "/" + inbox!)
    .observe(.value, with: { snapshot in
      print(self.inbox!)
      if snapshot.exists() {
        self.fbLog = FirebaseLogger(ref: self.ref, path: self.IBX + "/"
          + String(describing: snapshot.value!) + "/logs")
        self.ref.child(self.IBX + "/" + self.inbox!).removeAllObservers()
        self.msgViewController!.fbLog = self.fbLog
        self.fbLog!.log(self.inbox, message: "Signed in")
      }
    })
  ref.child(REQLOG).childByAutoId().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 programme d'écoute à l'emplacement de données /inbox/.

Lorsque l'emplacement de données /inbox/ reçoit une nouvelle entrée, 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.

/*
 * 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.

/*
 * 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) {}
  });
}

Effectuer un nettoyage

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 Google 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 à partir de la console GCP, car les projets Firebase et GCP sont identiques.

  1. Dans la console GCP, accédez à la page "Projets".

    Accéder à la page Projets

  2. Dans la liste des projets, sélectionnez celui que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

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

Si vous ne souhaitez pas supprimer vos projets GCP 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. Dans la console GCP, accédez à la page "Versions" d'App Engine.

    Accéder à la page Versions

  2. Cochez la case à côté de la version de l'application (autre que celle par défaut) que vous souhaitez supprimer.
  3. Cliquez sur le bouton Supprimer en haut de la page pour supprimer la version de l'application.

Étapes suivantes

  • 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 automatique 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 page Paramètres de scaling du service dans la documentation 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.

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…