Envoyer un message à l'aide de l'API FCM HTTP v1

À l'aide de l'API FCM HTTP v1, vous pouvez créer des requêtes de message et les envoyer à ces types de cibles :

• Nom du sujet
• Condition
• Jeton d'enregistrement de l'appareil
• Nom du groupe d'appareils (protocole uniquement)

Vous pouvez envoyer des messages avec une charge utile de notification composée de champs prédéfinis, une charge utile de données de vos propres champs définis par l'utilisateur ou un message contenant les deux types de charges utiles. Pour en savoir plus, consultez la section Types de messages.

Autoriser les requêtes d'envoi HTTP v1

Selon les détails de votre environnement de serveur, utilisez une combinaison de ces stratégies pour autoriser les requêtes de serveur adressées aux services Firebase :

• Identifiants par défaut de l'application Google (ADC)
• Fichier JSON de compte de service
• Jeton d'accès OAuth 2.0 éphémère dérivé d'un compte de service

Si votre application s'exécute sur Compute Engine, Google Kubernetes Engine, App Engine, ou Cloud Functions (y compris Cloud Functions for Firebase), utilisez les identifiants par défaut de l'application (ADC). L'ADC utilise votre compte de service par défaut existant pour obtenir des identifiants permettant d'autoriser les requêtes. Il permet également des tests locaux flexibles via la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS. Pour une automatisation maximale du flux d'autorisation, utilisez l'ADC avec les bibliothèques de serveur du SDK Admin.

Si votre application s'exécute dans un environnement de serveur non Google, vous devez télécharger un fichier JSON de compte de service à partir de votre projet Firebase. Tant que vous avez accès à un système de fichiers contenant le fichier de clé privée, vous pouvez utiliser la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS pour autoriser les requêtes avec ces identifiants obtenus manuellement. Si vous n'avez pas accès à ce fichier, vous devez référencer le fichier de compte de service dans votre code. Cette opération doit être effectuée avec une extrême prudence en raison du risque d'exposition de vos identifiants.

Fournir des identifiants à l'aide de l'ADC

Les identifiants par défaut de l'application Google (ADC) recherchent vos identifiants dans l'ordre suivant :

1. L'ADC vérifie si la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS est définie. Si elle est définie, l'ADC utilise le fichier de compte de service vers lequel la variable renvoie.

2. Si la variable d'environnement n'est pas définie, l'ADC utilise le compte de service par défaut proposé par Compute Engine, Google Kubernetes Engine, App Engine, et Cloud Functions pour les applications exécutées sur ces services.

3. Si l'ADC ne peut utiliser aucun des identifiants ci-dessus, le système génère une erreur.

L'exemple de code suivant du SDK Admin illustre cette stratégie. Il n'indique pas explicitement les identifiants de l'application. Cependant, l'ADC est capable de trouver implicitement les identifiants tant que la variable d'environnement est définie, ou tant que l'application s'exécute sur Compute Engine, Google Kubernetes Engine, App Engine, ou Cloud Functions.

admin.initializeApp({
  credential: admin.credential.applicationDefault(),
});

FirebaseOptions options = FirebaseOptions.builder()
    .setCredentials(GoogleCredentials.getApplicationDefault())
    .setDatabaseUrl("https://<DATABASE_NAME>.firebaseio.com/")
    .build();

FirebaseApp.initializeApp(options);

default_app = firebase_admin.initialize_app()

app, err := firebase.NewApp(context.Background(), nil)
if err != nil {
	log.Fatalf("error initializing app: %v\n", err)
}
init.go

FirebaseApp.Create(new AppOptions()
{
    Credential = GoogleCredential.GetApplicationDefault(),
});

Fournir des identifiants manuellement

Les projets Firebase sont compatibles avec les comptes de service Google, que vous pouvez utiliser pour appeler les API de serveur Firebase à partir de votre serveur d'application ou de votre environnement de confiance. Si vous développez du code localement ou si vous déployez votre application sur site, vous pouvez utiliser les identifiants obtenus à l'aide de ce compte de service pour autoriser les requêtes de serveur.

Vous pouvez afficher tous les comptes de service de votre projet Firebase dans les settings paramètres > Comptes de service tab.

Pour authentifier un compte de service et l'autoriser à accéder aux services Firebase, vous devez générer un fichier de clé privée au format JSON.

Pour générer un fichier de clé privée pour votre compte de service :

1. Dans la console Firebase, accédez aux settings Paramètres > Comptes de service, sous l'onglet.

2. Cliquez sur Générer une nouvelle clé privée, puis confirmez en cliquant sur Générer une clé.

3. Stockez le fichier JSON contenant la clé de manière sécurisée.

Lorsque vous autorisez l'accès via un compte de service, vous avez deux choix pour fournir les identifiants à votre application. Vous pouvez définir la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS ou transmettre explicitement le chemin d'accès à la clé du compte de service dans le code. La première option est plus sécurisée et est fortement recommandée.

Pour définir la variable d'environnement :

Définissez la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS de façon à pointer vers le chemin du fichier JSON contenant la clé de votre compte de service. Cette variable ne s'applique qu'à la session d'interface système actuelle. Par conséquent, si vous ouvrez une nouvelle session, vous devez la définir à nouveau.

export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"

$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\service-account-file.json"

Une fois que vous avez terminé les étapes ci-dessus, les identifiants par défaut de l'application (ADC) peuvent déterminer implicitement vos identifiants, ce qui vous permet d'utiliser les identifiants de compte de service lors des tests ou de l'exécution dans des environnements non Google.

Utiliser des identifiants pour générer des jetons d'accès

Sauf si vous utilisez le Firebase Admin SDK, qui gère automatiquement l'autorisation, vous devez générer le jeton d'accès et l'ajouter pour envoyer des requêtes.

Utilisez vos identifiants Firebase avec la bibliothèque Google Auth pour le langage de votre choix afin de récupérer un jeton d'accès OAuth 2.0 éphémère :

 function getAccessToken() {
  return new Promise(function(resolve, reject) {
    const key = require('../placeholders/service-account.json');
    const jwtClient = new google.auth.JWT(
      key.client_email,
      null,
      key.private_key,
      SCOPES,
      null
    );
    jwtClient.authorize(function(err, tokens) {
      if (err) {
        reject(err);
        return;
      }
      resolve(tokens.access_token);
    });
  });
}
index.js

def _get_access_token():
  """Retrieve a valid access token that can be used to authorize requests.

  :return: Access token.
  """
  credentials = service_account.Credentials.from_service_account_file(
    'service-account.json', scopes=SCOPES)
  request = google.auth.transport.requests.Request()
  credentials.refresh(request)
  return credentials.token
messaging.py

private static String getAccessToken() throws IOException {
  GoogleCredentials googleCredentials = GoogleCredentials
          .fromStream(new FileInputStream("service-account.json"))
          .createScoped(Arrays.asList(SCOPES));
  googleCredentials.refresh();
  return googleCredentials.getAccessToken().getTokenValue();
}
Messaging.java

Une fois votre jeton d'accès expiré, la méthode d'actualisation du jeton est appelée automatiquement pour récupérer un jeton d'accès mis à jour.

Pour autoriser l'accès à FCM, demandez le champ d'application https://www.googleapis.com/auth/firebase.messaging.

Pour ajouter le jeton d'accès à un en-tête de requête HTTP :

Ajoutez le jeton en tant que valeur de l'en-tête Authorization au format Authorization: Bearer <access_token> :

headers: {
  'Authorization': 'Bearer ' + accessToken
}
index.js

headers = {
  'Authorization': 'Bearer ' + _get_access_token(),
  'Content-Type': 'application/json; UTF-8',
}
messaging.py

URL url = new URL(BASE_URL + FCM_SEND_ENDPOINT);
HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
httpURLConnection.setRequestProperty("Authorization", "Bearer " + getServiceAccountAccessToken());
httpURLConnection.setRequestProperty("Content-Type", "application/json; UTF-8");
return httpURLConnection;
FirebaseMessagingSnippets.java

Autoriser un compte de service à partir d'un autre projet

Vous pouvez envoyer des messages pour un projet, le "projet cible", tout en utilisant un jeton OAuth 2.0 généré à partir d'un compte de service dans un autre projet, le "projet émetteur". Cela vous permet de centraliser la gestion des comptes de service dans un seul projet tout en envoyant des messages pour le compte d'autres personnes. Pour ce faire, procédez comme suit :

1. Dans le projet émetteur, assurez-vous que l'API Firebase Cloud Messaging est activée. Pour vérifier si elle est activée dans la Firebase console, accédez aux settings Paramètres > Général. Cliquez ensuite sur l'onglet Cloud Messaging.

2. Dans le projet émetteur, créez un compte de service.

3. Dans le projet cible, attribuez le rôle Administrateur de l'API Firebase Cloud Messaging à l'adresse e-mail du compte de service. Pour ce faire, accédez à la page IAM et administration > IAM de la console.Google Cloud Ce rôle permet au compte de service du projet émetteur d'envoyer des messages au projet cible.

4. Générez un jeton d'accès OAuth 2.0 pour le compte de service dans le projet émetteur. Pour ce faire, utilisez l'une des options suivantes :

   • Téléchargez et utilisez le fichier JSON de clé de compte de service.
   • Utilisez Workload Identity si votre service s'exécute sur Google Cloud.

5. Utilisez le jeton d'accès obtenu dans l'en-tête Authorization de votre requête d'envoi. La requête doit être adressée au point de terminaison HTTP v1 pour le projet cible:

     POST https://fcm.googleapis.com/v1/TARGET_PROJECT_ID/messages:send

Envoyer des messages à des appareils spécifiques

Pour envoyer un message à un seul appareil spécifique, transmettez le jeton d'enregistrement de l'appareil comme indiqué.

POST https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Content-Type: application/json
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA

{
   "message":{
      "token":"bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...",
      "notification":{
        "body":"This is an FCM notification message!",
        "title":"FCM Message"
      }
   }
}

curl -X POST -H "Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA" -H "Content-Type: application/json" -d '{
"message":{
   "notification":{
     "title":"FCM Message",
     "body":"This is an FCM Message"
   },
   "token":"bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1..."
}}' https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send

En cas de succès, la réponse de l'API HTTP v1 est un objet JSON contenant l'ID du message :

    {
      "name":"projects/myproject-b5ae1/messages/0:1500415314455276%31bd1c9631bd1c96"
    }

Envoyer un message de notification de test à l'aide de l'API FCM HTTP v1

Cette section explique comment envoyer un message de notification de test à l'aide de l'API FCM HTTP v1.

URL de la requête HTTP

La requête consiste en une requête HTTP POST adressée à la cible spécifiée (jeton d'enregistrement, sujet ou condition) à l'URL suivante :

POST https://fcm.googleapis.com/v1/projectId/messages:send

Exemple JSON de requête HTTP complète

Voici un exemple complet illustrant comment publier une notification dans une requête HTTP POST :

{
  "message": {
    "token": REGISTRATION_TOKEN,
    "notification": {
      "title": "FCM API test",
      "body": "This is the body of the notification.",
      "image": "https://cat.10515.net/1.jpg"
    }
  }
}

Exécuter

Cliquez sur Exécuter pour essayer l'exemple dans l'explorateur d'API.