Lors du débogage d'API avec Postman, la génération de signatuers pour l'authentification AKSK (Access Key/Secret Key) nécessite un script Pre-request. Voici comment procéder :

Script Pre-request pour Postman

Copiez le script JavaScript suivant dans la section "Pre-request Script" de Postman :

// Configuration des clés d'accès et secrètes
const accessKeyId = "VOTRE_ACCESS_KEY";
const secretAccessKey = "VOTRE_SECRET_KEY";

// Génération du timestamp actuel
const timestamp = Date.now();

// Génération d'un nombre aléatoire dans une plage spécifique
const nonce = Math.floor(Math.random() * 32768) + 32768;

// Stockage des valeurs dans les variables d'environnement Postman
pm.environment.set("accessKey", accessKeyId);
pm.environment.set("randomValue", nonce);
pm.environment.set("requestTimestamp", timestamp);

// Construction du tableau de paramètres pour la signature
let signatureParams = [];
signatureParams.push({ key: "accessKey", value: accessKeyId });
signatureParams.push({ key: "random", value: nonce });
signatureParams.push({ key: "timestamp", value: timestamp });

// Ajout des paramètres de requête existants (s'ils ne sont pas désactivés et ont une valeur)
const requestQuery = pm.request.url.query;
for (const param of requestQuery) {
   if (!param.disabled && param.value) {
       signatureParams.push({ key: param.key, value: param.value });
   }
}

// Tri des paramètres par clé alphabétique
signatureParams.sort((a, b) => a.key.localeCompare(b.key));

// Construction de la chaîne de requête pour le hachage
let queryString = "";
for (const param of signatureParams) {
   queryString += `${param.key}=${param.value}&`;
}
queryString += `secretKey=${secretAccessKey}`; // Ajout de la clé secrète

// Calcul du MD5 et mise en majuscules pour la signature
const signature = CryptoJS.MD5(queryString).toString().toUpperCase();

// Stockage de la signature dans une variable d'environnement
pm.environment.set("signature", signature);
   

Configuraton des Headers dans Postman

Ajoutez les quatre en-têtes suivants dans la section "Headers" de votre requête Postman :

• accessKey
• timestamp
• random
• sign (contenant la valeur calculée par le script)

Exemple d'Appel d'API côté Backend

Pour intégrer l'authantification AKSK dans votre application backend, suivez ces étapes :

1. Intégration du SDK

Assurez-vous que le SDK nécessaire est correctement importé dans votre projet.

2. Configuration des Identifiants

Configurez les valeurs de accessKey, secretKey et l'URL de base de l'API. Ces informations peuvent être chargées depuis un fichier de configuration système ou définies comme des constantes.

3. Implémentation de la Méthode d'Appel

Utilisez un client HTTP tel que HttpClient ou RestTemplate (dans le contexte Java/Spring) pour effectuer les appels d'API.

import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import java.util.HashMap;
import java.util.Map;

@Service
public class ApiServiceClient {

   @Value("${api.service.url}")
   private String serviceBaseUrl;
   @Value("${api.service.accessKey}")
   private String apiKey;
   @Value("${api.service.secretKey}")
   private String apiSecret;

   // Supposons que AkSkProperties et AkSignUtils sont des classes utilitaires fournies par le SDK
   // public static class AkSkProperties { ... }
   // public static class AkSignUtils { public static Map<String, String> getUrlSign(...) { ... } }

   public String callApiService(Map<String, String> requestParams) {
       // Instanciation des propriétés de configuration AKSK
       AkSkProperties configProperties = new AkSkProperties();
       configProperties.setAccessKey(apiKey);
       configProperties.setSecretKey(apiSecret);
       configProperties.setUrl(serviceBaseUrl);

       // Génération des paramètres de signature (accessKey, timestamp, random, sign)
       // La méthode getUrlSign du SDK se charge du tri, de la génération du timestamp/nonce et du calcul de la signature.
       Map<String, String> signatureData = AkSignUtils.getUrlSign(configProperties, requestParams);

       // Configuration des en-têtes de la requête HTTP
       HttpHeaders headers = new HttpHeaders();
       headers.add("accessKey", signatureData.get("accessKey"));
       headers.add("timestamp", signatureData.get("timestamp"));
       headers.add("random", signatureData.get("random"));
       headers.add("sign", signatureData.get("sign"));

       // Création de l'entité de requête (corps vide pour une requête GET)
       HttpEntity<String> requestEntity = new HttpEntity<>(null, headers);

       // Utilisation de RestTemplate pour effectuer l'appel d'API
       RestTemplate restTemplate = new RestTemplate();
       ResponseEntity<String> response = restTemplate.exchange(
               serviceBaseUrl, // L'URL de l'endpoint à appeler
               HttpMethod.GET,   // La méthode HTTP
               requestEntity,  // Les en-têtes configurés
               String.class    // Le type de réponse attendu
       );

       // Récupération et retour du corps de la réponse
       return response.getBody();
   }
}