Cette page a été traduite par l'API Cloud Translation.

Établir la connectivité avec les API Payments dans Node.js

1. Avant de commencer

Cet atelier de programmation autoguidé vous explique comment établir la connectivité avec les API Stanadard Payments.

Prérequis

Vous avez suivi les étapes 1 et 2 du processus de mise en œuvre.
Vous pouvez héberger le serveur Node.js fourni avec une terminaison TLS à l'aide de Google App Engine ou de votre propre solution sur le domaine configuré avec Google.
Node.js est installé dans votre environnement.

Ce que vous allez apprendre

Vérifier la connectivité en envoyant une requête valide à l'API Google Standard Payments Echo
Recevoir, déchiffrer et analyser une requête de Google adressée à l'API Partner Hosted Echo.

2. Préparation

Télécharger l'application

Téléchargez l'exemple de code Node.js.

Installer des dépendances

Accédez au répertoire du projet et exécutez la commande suivante pour installer les dépendances requises. Si vous utilisez App Engine, vous pouvez ignorer cette étape.

npm install

3. Configurer l'ID de compte de l'intégrateur de paiement (PIAID)

L'ID de compte de l'intégrateur de paiement (PIAID) est un identifiant permettant d'identifier de manière unique vos intégrations. Vous devez avoir reçu votre PIAID de la part de Google en remplissant les conditions préalables avant de commencer ce tutoriel.

Accédez au fichier server.js dans le répertoire du projet.
Définissez la variable PIAID sur le PIAID qui vous a été attribué par Google.

const PIAID = '{PAYMENT_INTEGRATOR_ACCOUNT_ID}';

4. Ajouter des clés PGP

Créez les fichiers suivants dans la structure du projet et ajoutez vos clés PGP pour activer le chiffrement PGP.

Créez un fichier nommé public.key et ajoutez-y la clé publique blindée ASCII.
Créez un fichier nommé private.key et ajoutez-y la clé privée blindée ASCII.
Créez un fichier nommé passphrase.txt et ajoutez-y la phrase secrète secrète.

Ajouter des clés PGP

Parfait, vous êtes prêt à exécuter l'application !

5. Exécuter l'application

Pour lancer l'application, exécutez la commande suivante.

$ node server.js
Server listening on port 8080...

Si vous exécutez une instance App Engine préconfigurée, exécutez plutôt cette commande.

$ gcloud app deploy

Par défaut, le serveur écoute sur le port 8080.

6. Tester la connectivité de l'API Google Standard Payments

Maintenant que l'application s'exécute, il est temps de tester la connectivité avec l'API Google Payments Echo.

Exécutez la commande suivante pour lancer un appel depuis votre instance de l'exemple d'application vers les serveurs de Google. L'exemple d'API echo d'application accepte une requête POST en texte brut. Une fois la requête reçue, une requête ultérieure est envoyée à l'API hébergée par Google.

  $ curl -X POST -H 'Content-Type: text/plain' -d 'Hello from Little Bear' https://{HOSTNAME}/echo

Si la requête API aboutit, Google renvoie la réponse suivante.

{
   "responseHeader":{
      "responseTimestamp":"1606710026723"
   },
   "clientMessage":"Hello from Little Bear",
   "serverMessage":"Server message."
}

pas-à-pas

Maintenant qu'une requête a été envoyée par votre serveur, examinons le fonctionnement.

Créer la requête

buildEchoRequestBody dans bodyHelpers.js crée la requête echo envoyée à l'API de Google.

const message = bodyHelpers.buildEchoRequestBody(req.body);

La requête générée inclut le clientMessage, ainsi que plusieurs champs de valeur par défaut.

{
   "requestHeader":{
      "protocolVersion":{
         "major":1,
         "minor":0,
         "revision":0
      },
      "requestId":"ddfe0fd0-ffdc-4fcf-991a-f0611ec83970",
      "requestTimestamp":"1606715389040"
   },
   "clientMessage":"Hello from Little Bear"
}

Chiffrer la requête

Toutes les requêtes sont chiffrées et encodées en base64url. Dans cet exemple, crypto.js contient des méthodes d'assistance qui effectuent le chiffrement et le déchiffrement à votre place. La méthode crypto.encrypt effectue le chiffrement à l'aide de la clé publique de Google.

const encrypted = await crypto.encrypt(message);

Envoyer la requête POST encodée en base64url

Le message chiffré est encodé en base64url à l'aide du package base64url et envoyé via une requête POST à l'aide d'axios.

const response = await axios.post(ECHO_URL, base64url(encrypted), AXIOS_CONFIG);

Déchiffrer et renvoyer la réponse

La réponse positive de Google est encodée et chiffrée en base64url. Par conséquent, elle doit également être décodée et déchiffrée avant de pouvoir être renvoyée en texte brut.

const encryptedMessage = base64url.toBuffer(response.data);
const decryptedResponse = await crypto.decrypt(encryptedMessage);
res.status(200);
res.send(decryptedResponse);

7. Tester la connectivité de l'API Partner

Pour tester la connectivité de l'API Partner Echo, Google envoie une requête à l'API Partner Hosted Echo.

Lorsque vous êtes prêt, veuillez vous adresser à votre contact Google pour déclencher cette demande de la part de Google.

Le test d'écho est terminé lorsque vous êtes en mesure de lire la demande d'écho entrante de Google et de répondre avec une réponse d'écho valide.

pas-à-pas

Maintenant qu'une requête a été reçue et traitée par votre serveur, voyons comment cela fonctionne.

Décoder la requête en base64url

Lorsque vous recevrez la requête, vous devrez d'abord la décoder en base64url.

const encryptedRequest = base64url.toBuffer(req.body);

Déchiffrer la requête

Une fois que vous avez décodé la requête en base64url, vous devez la déchiffrer.

const decryptedRequest = await crypto.decrypt(encryptedRequest);

Recevoir la requête

Une fois décodé et déchiffré, Google a envoyé une charge utile de message semblable à la suivante.

{
  "requestHeader": {
    "protocolVersion": {
      "major": 1
    },
    "requestId": "G1MQ0YERJ0Q7LPM",
    "requestTimestamp": {
      "epochMillis":1481899949606
    },
    "paymentIntegratorAccountId": "abcdef123456"
  },
  "clientMessage": "echo Me"
}

Créer la réponse

Une fois que vous avez réussi à lire la demande d'écho entrante, vous êtes prêt à créer la réponse.

clientMessage = JSON.parse(decryptedRequest).clientMessage;
responseBody = bodyHelpers.buildEchoResponseBody(clientMessage);

La réponse inclut le message de Google, ainsi qu'un code temporel et un message du serveur.

{
  "responseHeader": {
    "responseTimestamp": {
      "epochMillis":1481899950236
    }
  },
  "clientMessage": "echo Me",
  "serverMessage": "Debug ID 12345"
}

Chiffrer et encoder la réponse en base64

Une fois le message de réponse créé, vous pouvez le chiffrer et l'encoder en base64url.

encryptedResponse = await crypto.encrypt(responseBody);
const encodedResponse = base64url(encryptedResponse);

Renvoyer la réponse

Et, enfin, vous êtes prêt à envoyer la réponse POST.

res.send(encodedResponse);

8. Félicitations !

Dans cet atelier de programmation, vous avez réussi à établir la connectivité avec l'API Echo.