Lorsqu’un projet de data analytics nécessite une connexion API pour extraire la donnée, les défis techniques s’accumulent très rapidement. D’ailleurs, avant même de se lancer dans la connexion, il faut explorer la documentation de l’API pour comprendre comment elle fonctionne, où se trouvent les données dont on a besoin, et à quelle fréquence peut-on faire requêter l’API.
Si vous débutez dans ce type d’intégration de données, nous vous proposons une checklist complète pour vous connecter facilement à tout type d’API.
Nous vous proposons également un cas pratique de connexion à l’API de Pinterest avec deux méthodes : en utilisant Python (nécessite quelques compétences en programmation) et le connecteur universel Web Services de ClicData (no code)
C’est parti !
API : Checklist Pour Choisir La Meilleure Méthode de Connexion
#1 – Identifier le type d’API
Est-ce une API SOAP ou REST ?
Cela aura un impact sur la méthode de connexion :
- Les API REST utilisent généralement HTTP et des formats de messages simples comme JSON, XML ou texte brut. La connexion implique souvent des requêtes HTTP avec des méthodes standards comme GET, POST, PUT, DELETE, etc.
- Les API SOAP utilisent le protocole SOAP, qui repose fortement sur XML pour le formatage des messages. La connexion implique la génération et l’analyse de messages XML selon les spécifications SOAP, nécessitant souvent des bibliothèques ou des frameworks spécialisés.
#2 – Vérifier la méthode d’authentification
Plusieurs méthodes d’authentification sont possibles en fonction des APIs. Voici les plus courantes :
OAuth 2.0
OAuth 2.0 est un cadre d’autorisation qui permet aux applications tierces d’obtenir un accès limité à un service web au nom d’un utilisateur, sans que celui-ci partage directement ses identifiants avec l’application. Le processus OAuth 2.0 implique généralement l’obtention d’un jeton d’accès depuis un serveur d’autorisation en présentant des identifiants (tels qu’un ID client et un secret client), puis l’utilisation de ce jeton pour authentifier les requêtes suivantes à l’API.
| Avantages | Inconvénients |
| – Plus sécurisée car les identifiants de l’utilisateur ne sont pas partagés directement – Nécessite qu’une seule configuration initiale | – Implémentation complexe par rapport aux autres méthodes |
Authentification par Clé API
L’authentification par clé API consiste à générer une clé unique (généralement une longue chaîne de caractères) pour chaque client ou application nécessitant un accès à l’API. Cette clé est généralement incluse dans les requêtes à l’API, soit dans les en-têtes de la requête, soit comme paramètre de requête. Le serveur de l’API vérifie la clé par rapport à une base de données de clés valides pour authentifier le client.
| Avantages | Inconvénients |
| – Facilité d’implémentation. – Convient aux applications simples où une sécurité de base est suffisante. | Moins sécurisé qu’OAuth 2.0, car la clé peut être compromise. |
Authentification de Base
L’authentification de base implique l’envoi d’un nom d’utilisateur et d’un mot de passe avec chaque requête à l’API. Les identifiants sont encodés (mais pas chiffrés) en Base64 et inclus dans les en-têtes de la requête. Bien que simple à mettre en œuvre, l’authentification de base n’est pas considérée comme très sécurisée, car les identifiants sont transmis en clair et peuvent être interceptés.
| Avantages | Inconvénients |
| Mise en œuvre très simple et rapide. | Sécurité faible, car les identifiants peuvent être interceptés et utilisés de manière malveillante. |
#3 – Vérifier la pagination
Si l’API utilise la pagination, la connexion sera plus complexe en raison de la logique des boucles nécessaires. Les méthodes de pagination incluent :
- Pagination basée sur le décalage
- Pagination basée sur le curseur
- Pagination basée sur le token
- Pagination basée sur le temps
- Pagination basée sur un jeu de clés
- Pagination basée sur la page
- Pagination basée sur l’index
Je vous recommande cette documentation Github pour en savoir plus sur la méthode de pagination d’une API. Dans notre exemple de connexion à l’API Pinterest, nous verrons un cas de pagination basée sur la page.
#4 – Vérifier les limitations des outils
Il se peut que vous soyez limité en termes d’appels API en raison du modèle de tarification de l’outil ou parce que les développeurs de l’API ont mis en place une limitation de débit (throttling).
Voici quelques bonnes pratiques pour gérer cette limitation de débit :
⇨ Connaître les règles: Lisez la documentation de l’API pour connaître les limites de appels – combien de requêtes vous pouvez effectuer et dans quel laps de temps (par exemple, par minute, par seconde, etc.)
⇨ Gérer les blocages : Si l’API vous demande de ralentir avec un code HTTP 429 « Too Many Requests », ajustez votre code.
⇨ Réessayer : Soyez patient et augmentez le temps d’attente entre les tentatives pour éviter d’être bloqué à nouveau.
⇨ Surveiller l’activité: monitorez votre utilisation et les messages de l’API pour vous assurer que vous respectez les limites et gérez les éventuels problèmes rapidement.
#5 – Mapper le cas d’utilisation aux scopes de l’API
Associez chaque cas d’utilisation aux scopes ou autorisations correspondants nécessaires pour accéder aux endpoints nécessaires.
Identifiez l’ensemble minimal de scopes requis pour accomplir chaque cas d’utilisation tout en adhérant au principe du moindre privilège.
Examinons quatre exemples :
Cas d’utilisation N°1 – Accès en Lecture Seule aux Informations du Profil Utilisateur
Description du Cas d’Utilisation : Votre application doit afficher des informations de base du profil utilisateur (par exemple, nom, email) sans avoir besoin de modifier ou mettre à jour le profil.
Scope(s) Requis : profile:read
Exemple : Si votre application utilise OAuth 2.0 pour l’authentification, vous pouvez demander le scope profile:read pour accéder aux informations du profil utilisateur.
Cas d’utilisation N°2 – Accès en Lecture et Écriture aux Publications des Utilisateurs
Description du Cas d’Utilisation : Votre application permet aux utilisateurs de créer, consulter, mettre à jour et supprimer leurs publications.
Scope(s) Requis : posts:read, posts:write
Exemple : Si votre application s’intègre à une API de réseau social, vous pourriez demander les scopes posts:read et posts:write pour permettre aux utilisateurs de lire et écrire des publications.
Cas d’utilisation N°3 – Accès aux Transactions Financières pour le Reporting
Description du Cas d’Utilisation : Votre application doit récupérer des données de transactions financières pour générer des rapports mais n’a pas besoin de pouvoir initier des transactions.
Scope(s) Requis : transactions:read
Exemple : Si votre application s’intègre à une API bancaire, vous pourriez demander le scope transactions:read pour accéder à l’historique des transactions de l’utilisateur.
Cas d’utilisation N°4 – Accès Limité aux Données de Localisation pour le Géocodage
Description du Cas d’Utilisation : Votre application nécessite l’accès aux données de localisation pour géocoder des adresses mais n’a pas besoin d’un accès continu à la localisation de l’utilisateur.
Scope(s) Requis : location:read
Exemple : Si votre application s’intègre à une API de cartographie, vous pourriez demander le scope location:read pour accéder aux données de localisation pour géocoder des adresses.
Associer chaque cas d’utilisation aux scopes ou permissions nécessaires pour accéder aux endpoints ou ressources nécessaires. Par exemple :
- Accès en lecture seule aux informations de profil utilisateur : scope
profile:read - Accès en lecture et écriture aux publications utilisateur : scopes
posts:read,posts:write - Accès aux transactions financières pour les rapports : scope
transactions:read - Accès limité aux données de localisation pour le géocodage : scope
location:read
#6 – Choisir le type de requête
Différentes requêtes peuvent être exécutées lors de l’appel de l’API :
- GET : Pour obtenir des données d’un serveur. Exemple : Lire un profil utilisateur.
- POST : Pour envoyer des données à un serveur et créer quelque chose de nouveau. Exemple : Créer un compte utilisateur.
- PUT : Pour mettre à jour des données sur un serveur. Exemple : Mettre à jour un profil utilisateur.
- PATCH : Pour apporter des mises à jour partielles. Exemple : Changer uniquement l’adresse e-mail d’un utilisateur.
- DELETE : Pour supprimer des données d’un serveur. Exemple : Supprimer un compte utilisateur.
#7 – Sélectionner les bons endpoints
Utilisez plusieurs endpoints pour récupérer des données est souvent nécessaire dans les scénarios de connexion aux API où les données souhaitées sont réparties entre différentes ressources ou nécessitent différents paramètres pour être récupérées.
Quelques exemples dans lesquels plusieurs endpoints sont nécessaires :
1 – Normalisation des Données
Parfois, les données sont normalisées entre plusieurs endpoints pour maintenir l’intégrité des données et réduire la redondance.
Exemple : Dans le cas d’un business e-commerce, les informations sur les produits peuvent être stockées séparément des informations d’inventaire. Pour obtenir les détails complets des produits ainsi que le statut des stocks, il serait nécessaire de requêter à la fois les endpoints des produits et de l’inventaire.
2 – Contrôle d’Accès Granulaire
Les API peuvent appliquer un contrôle d’accès granulaire, permettant l’accès à différents sous-ensembles de données en fonction des permissions ou des rôles des utilisateurs.
Exemple : Dans une plateforme de médias sociaux, récupérer les publications et les commentaires des utilisateurs peut nécessiter des endpoints distincts. Les utilisateurs avec différents niveaux d’accès (par exemple, éditeurs et administrateurs) peuvent avoir accès à différents sous-ensembles de commentaires, nécessitant des endpoints séparés pour les récupérer.
3 – Optimisation des Performances
Des endpoints séparés peuvent être fournis pour optimiser les performances en permettant aux clients de récupérer uniquement les données dont ils ont besoin, réduisant ainsi la taille des charges utiles et le temps de réponse.
Exemple : Une API météo peut offrir des endpoints séparés pour les conditions météorologiques actuelles, les prévisions horaires et les prévisions quotidiennes. Les clients intéressés par les conditions actuelles peuvent uniquement requêter le endpoint des conditions actuelles, évitant ainsi la récupération de données inutiles.
4 – Versionnement et Évolution des API
Les API évoluent avec le temps, et de nouvelles fonctionnalités ou modifications peuvent nécessiter l’introduction de nouveaux endpoints tout en maintenant la compatibilité rétroactive.
Exemple : Une API pour un service de messagerie peut introduire un nouveau endpoint pour récupérer les réactions ou les pièces jointes des messages dans une version ultérieure. Les clients utilisant des versions plus anciennes de l’API peuvent continuer à utiliser les endpoints existants sans interruption, tandis que les nouveaux clients peuvent utiliser les nouveaux endpoints pour des fonctionnalités supplémentaires.
#8 – Vérifier le format des données de sortie
La plupart des API renvoient des ensembles de données au format JSON ou XML, qui sont des formats simples à manipuler. Cependant, vous pouvez parfois tomber sur des tables plus complexes avec des objets imbriqués ou des chaînes JSON qui nécessiteraient deux requêtes pour obtenir une table propre.
Si vous travaillez avec un schéma de données complexe, voici les étapes à suivre :
- Analyser la réponse JSON : Commencez par analyser la réponse JSON renvoyée par l’API pour la convertir dans un format qui peut être facilement manipulé et traité dans votre langage de programmation préféré.
- Identifier les objets imbriqués : Identifiez les objets imbriqués ou les chaînes JSON au sein de l’ensemble de données qui doivent être séparés en différentes tables. Ces objets imbriqués représentent généralement des entités distinctes mais liées dans votre modèle de données.
- Extraire les données imbriquées : stockez-les dans des structures de données ou des tables séparées. Cela peut impliquer d’itérer à travers la réponse JSON et d’extraire des champs spécifiques.
- Générer des identifiants uniques : pour les données extraites qui peuvent être utilisés pour établir des relations entre l’ensemble de données principal et les tables imbriquées. Ces identifiants vous aideront à lier les données connexes entre différentes tables.
- Effectuer des opérations de jointure : Utilisez les identifiants uniques pour effectuer des opérations de jointure entre la table principale et les tables imbriquées. Les jointures vous permettent de combiner des données connexes à partir de plusieurs tables basées sur des clés ou des identifiants communs.
- Créer des vues ou des modèles de données : En option, créez des vues ou des modèles de données dans votre outil de gestion de données pour abstraire la complexité du schéma sous-jacent. Les vues peuvent fournir des représentations simplifiées de la structure des données, facilitant ainsi les requêtes et l’analyse.
Exemple de connexion API : Deux méthodes pour extraire des données de l’API Pinterest
En utilisant Python
Python est couramment utilisé par les analystes de données pour créer des visualisations de données personnalisées lorsque les graphiques intégrés ne sont pas suffisants.
Cependant, Python peut également être utilisé pour la connexion aux API. Cela nécessite cependant des compétences en programmation et en ingénierie des données, qui ne sont pas nécessairement les points forts des analystes de données !
Mais si vous deviez utiliser Python pour un projet de connexion API, nous avons préparé un guide étape par étape basé sur un projet public sur GitHub et en suivant notre checklist :
Étape 1 – Authentification :
Commencez le flux OAuth pour demander l’accès utilisateur en envoyant une requête POST à l’adresse https://www.pinterest.com/oauth/
Une fois l’application autorisée, vous serez redirigé vers une URI spécifiée. Une méthode est nécessaire pour recevoir le code d’accès dans l’URI (appelé ici auth_code)
Échangez le code d’accès contre un jeton d’accès en envoyant une requête POST à l’endpoint du jeton d’accès (en utilisant la méthode appelée exchange_auth_code). Cette méthode récupérera à la fois un jeton d’accès et un jeton de rafraîchissement.
def exchange_auth_code(self, auth_code):
"""
Call the Pinterest API to exchange the auth_code (obtained by
a redirect from the browser) for the access_token and (if requested)
refresh_token.
"""
post_data = {
"code": auth_code,
"redirect_uri": self.api_config.redirect_uri,
"grant_type": "authorization_code",
}
if self.api_config.verbosity >= 2:
print("POST", self.api_config.api_uri + "/v5/oauth/token")
if self.api_config.verbosity >= 3:
self.api_config.credentials_warning()
print(post_data)
response = requests.post(
self.api_config.api_uri + "/v5/oauth/token",
headers=self.auth_headers,
data=post_data,
)
unpacked = self.unpack(response)
print("scope: " + unpacked["scope"])
self.access_token = unpacked["access_token"]
self.refresh_token = unpacked["refresh_token"]
self.scopes = unpacked["scope"]Les jetons d’accès Pinterest expirent au bout de 30 jours (2 592 000 secondes), et les jetons de rafraîchissement durent 365 jours (31 536 000 secondes). La méthode de rafraîchissement est obligatoire pour renouveler le jeton d’accès lorsque nécessaire. Pour ce faire, une requête POST est envoyée à l’endpoint du jeton avec le jeton de rafraîchissement inclus en tant que paramètre.
def refresh(self, continuous=False):
print(f"refreshing {self.name}...")
post_data = {"grant_type": "refresh_token", "refresh_token": self.refresh_token}
if continuous:
post_data["refresh_on"] = True
if self.api_config.verbosity >= 2:
print("POST", self.api_config.api_uri + "/v5/oauth/token")
if self.api_config.verbosity >= 3:
self.api_config.credentials_warning()
print(post_data)
response = requests.post(
self.api_config.api_uri + "/v5/oauth/token",
headers=self.auth_headers,
data=post_data,
)
unpacked = self.unpack(response)
self.access_token = unpacked["access_token"]
# save refresh token if it was also refreshed
if "refresh_token" in unpacked:
self.refresh_token = unpacked["refresh_token"]Optionnel : Chaque fois que le jeton d’accès est rafraîchi, vous devrez stocker à la fois les jetons d’accès et de rafraîchissement dans un fichier encodé en JSON en utilisant la méthode d’écriture.
Utilisez le jeton d’accès en l’incluant dans l’en-tête de la requête comme partie de la paire clé-valeur, similaire à ce qui a été fait dans la _init_method, qui sera invoquée lors de l’interrogation de chaque endpoint.
def __init__(self, api_config, name=None):
if name:
self.name = name
else:
self.name = "access_token"
self.api_config = api_config
self.path = pathlib.Path(api_config.oauth_token_dir) / (self.name + ".json")
# use the recommended authorization approach
auth = api_config.app_id + ":" + api_config.app_secret
b64auth = base64.b64encode(auth.encode("ascii")).decode("ascii")
self.auth_headers = {"Authorization": "Basic " + b64auth}Étape 2 – Gérer la pagination :
Il y a deux paramètres de requête : page_size et bookmark.
Incluez le paramètre de requête bookmark et définissez-le sur la valeur retournée dans la réponse de l’appel précédent.
def __next__(self):
if self.index >= len(self.items):
# need to fetch more data, if there is a bookmark
if self.bookmark:
# Determine whether the query needs to be added to the path or
# if the bookmark will be an additional parameter at the end
# of the query.
delimiter = "&" if "?" in self.path else "?"
path_with_bookmark = self.path + delimiter + "bookmark=" + self.bookmark
self._get_response(path_with_bookmark)
if not self.items: # in case there is some sort of error
raise StopIteration
else:
raise StopIteration # no bookmark => all done
retval = self.items[self.index] # get the current element
self.index += 1 # increment the index for the next time
return retvalÉtape 3 – Sélectionner l’endpoint :
Enfin, vous devrez reconstituer la requête GET avec toutes ces méthodes/variables pour appeler un endpoint tel que Board.
def get_response(self, path):
if self.api_config.verbosity >= 2:
print(f"GET {self.api_uri + path}")
return requests.get(
self.api_uri + path,
headers=self.access_token.header(),
allow_redirects=False,
)
def request_data(self, path):
return self.unpack(self.get_response(path))def get(self):
if not self.board_id:
raise ValueError("board_id must be set to get a bord")
return self.request_data(f"/v5/boards/{self.board_id}")En utilisant le connecteur Web Services de ClicData
Si vous ne connaissez pas ClicData, sachez que nous sommes une plateforme complète de gestion de données et d’analyse qui vous permet de connecter, transformer, visualiser, automatiser et collaborer avec des données provenant de n’importe quelle source.
Nous proposons des connecteurs natifs pour la plupart des applications, des systèmes de stockage et des bases de données, ainsi qu’un connecteur universel, Web Services, qui peut extraire des données de n’importe quelle API REST ou SOAP.
Nous allons vous montrer comment intégrer l’API Pinterest avec notre connecteur Web Service.
Cette connexion nécessitera une étape initiale de création d’une application dans le portail des développeurs de Pinterest.
Copiez votre App ID + App secret key (vous en aurez besoin à l’étape 1).
Définissez l’url de rappel vers ClicData : https://app.clicdata.com/oauth2/callback
Sélectionnez les scopes dont vous avez besoin pour votre reporting.
Étape 1 – Authentification
Commencez le flux OAuth pour demander l’accès utilisateur en envoyant une requête POST à l’adresse https://www.pinterest.com/oauth/
Dans l’onglet ‘Serveur’, remplissez le nom d’hôte du service Web :
- Protocole : HTTPS
- Hôte : api.pinterest.com
- Port : 443
Dans l’onglet ‘Authentification’, remplissez les identifiants fournis par Pinterest dans la plateforme de développement de l’application :
- Type d’autorisation : Code d’autorisation
- URL d’autorisation : https://www.pinterest.com/oauth/
- URL du token d’accès : https://api.pinterest.com/v5/oauth/token
- Identifiant client : fourni par Pinterest en tant que ‘ID de l’application’
- Secret client : fourni par Pinterest en tant que ‘Clé secrète de l’application’
- Envoyer l’authentification : Dans l’en-tête
- Portée : toutes les scopes nécessaires. Assurez-vous qu’elles correspondent aux scopes répertoriées dans votre application sur Pinterest. Dans cet exemple : boards
- Audience : optionnel
- Ressource : optionnel
- Ajouter le token : En-tête
Étape 2 – Gestion de la pagination
ClicData vous permet de gérer efficacement la pagination incrémentielle avec arrêt de la réponse lorsque le signet (bookmark) est nul. Apprenez à gérer la pagination API dans notre documentation détaillée.
Étape 3 – Sélection de l’endpoint
Comme vous pouvez le voir sur la capture d’écran ci-dessous, aucune programmation n’est nécessaire pour sélectionner l’endpoint.
Simplifiez la connexion de vos APIs avec ClicData
En conclusion, la connexion des API peut être un défi de taille sans une checklist complète pour vous guider. Notre checklist vous assure de couvrir tous les aspects essentiels de manière efficace.
Les méthodes comme Python offrent des capacités puissantes mais peuvent nécessiter des compétences en codage et ajouter de la complexité. En revanche, les options sans code comme le connecteur web de ClicData rendent l’extraction de données beaucoup plus simple et accessible, idéale pour les API SOAP et REST.
Prêt à simplifier vos connexions API ? Découvrez-en plus sur nos fonctionnalités dans notre documentation. Simplifions ensemble l’intégration des données !
Essayez ClicData avec vos propres données
Centralisez, unifiez et interagissez avec toutes vos données dans des tableaux de bord dynamiques.
Avant la fin de journée.
