Correction de l'erreur 400 : incompatibilité dans redirect_uri lors de l'importation d'avis de Google Business vers Python

Surmonter les problèmes d'URI de redirection OAuth 2.0 dans l'intégration de l'API Google Reviews

Lors de l'intégration de Google Business Reviews dans Python, de nombreux développeurs rencontrent l'erreur courante « Erreur 400 : redirect_uri_mismatch ». Ce problème est dû à un mauvais alignement entre l'URI de redirection dans les paramètres OAuth 2.0 et ce qui est spécifié dans Google Cloud Console. L'erreur peut empêcher l'accès à l'API Google Reviews, qui est cruciale pour récupérer les commentaires des clients par programmation.

La politique OAuth 2.0 de Google est stricte, exigeant une correspondance précise entre l'URI de redirection configuré et celui utilisé lors de l'authentification. Ne pas configurer correctement cela peut entraîner de la frustration, en particulier lorsque le numéro de port de redirection change fréquemment, comme le signalent de nombreux développeurs. Comprendre ce problème est essentiel pour garantir une connexion API fluide et éviter de rencontrer cet obstacle.

Dans cet article, nous passerons en revue les étapes pour résoudre l'erreur redirect_uri_mismatch lors de l'accès à Google Business Reviews. En configurant soigneusement vos informations d'identification OAuth, nous éliminerons ce problème et vous permettra de récupérer facilement des avis. La solution consiste à définir correctement l'URI de redirection et à l'aligner avec l'environnement localhost utilisé pour le développement.

Que vous récupériez des avis pour analyser les performances de votre entreprise ou pour les afficher sur votre site Web, comprendre comment résoudre cette erreur vous fera gagner du temps et garantira une interaction réussie avec l'API. Suivez ces étapes pour corriger l'inadéquation et accéder à vos avis Google Business sans interruption.

Comprendre le processus OAuth 2.0 pour accéder à l'API Google Reviews

Les scripts Python fournis ci-dessus sont conçus pour récupérer Google Business Reviews à l'aide de l'API Google My Business. La première étape consiste à configurer l’autorisation OAuth 2.0, nécessaire pour interagir en toute sécurité avec les API de Google. Ce processus commence par spécifier vos secrets client OAuth dans un fichier JSON, qui contient les informations d'identification de votre projet Google Cloud. Ces informations d'identification sont essentielles pour établir un accès sécurisé, et le URI de redirection doit correspondre à celui configuré dans Google Cloud Console. Une incompatibilité peut provoquer une erreur telle que « Erreur 400 : redirect_uri_mismatch ».

Une fois les informations d'identification chargées, le script lance un flux OAuth à l'aide d'InstalledAppFlow. Ce flux lance un serveur local (dans ce cas, sur le port 8080) pour gérer l'autorisation utilisateur. Lorsque l'utilisateur accorde l'autorisation, le script reçoit un jeton d'accès, nécessaire pour effectuer des demandes autorisées à l'API Google Reviews. Ce processus est automatisé et géré par la méthode flow.run_local_server, garantissant que les informations d'identification sont stockées en toute sécurité et utilisées pour les requêtes API. Mécanismes de journalisation comme loguru sont utilisés pour suivre le flux et garantir que tous les problèmes rencontrés sont clairement enregistrés pour le débogage.

Après avoir obtenu les informations d'identification, le script établit une session à l'aide de la bibliothèque de requêtes. Cette session inclut le jeton d'accès dans ses en-têtes, qui est requis pour l'authentification lors des appels d'API vers Google. Le script construit l'URL correcte du point de terminaison de l'API à l'aide de votre ID de compte professionnel et de votre ID d'emplacement. En envoyant une requête GET à l'URL, le script tente de récupérer les avis pour l'emplacement commercial spécifié. Il inclut également une gestion des erreurs pour détecter les erreurs HTTP, telles que des informations d'identification ou des autorisations incorrectes, garantissant ainsi que tous les problèmes rencontrés lors de la demande sont gérés efficacement.

La réponse de l'API Google Reviews est analysée comme un objet JSON, qui contient les avis relatifs à l'emplacement de l'entreprise. Si la demande aboutit, les avis sont imprimés sur la console et le script enregistre un message de réussite. Cette approche modulaire garantit que le processus est facilement reproductible et peut être personnalisé pour différents sites ou comptes. De plus, en maintenant une structure claire avec la gestion des sessions et la gestion des erreurs, le script optimise la sécurité et les performances lorsque vous travaillez avec l'API Google Reviews. Cela permet aux développeurs d'accéder et de gérer efficacement les avis des clients à des fins d'analyse ou d'affichage.

import requests
from google_auth_oauthlib.flow import InstalledAppFlow
from loguru import logger as log
# Replace with your actual Google Business account and location IDs
my_business_account_id = "YOUR_ACCOUNT_ID"
location_id = "YOUR_LOCATION_ID"
# Path to your OAuth 2.0 Client Secret JSON file
GCP_CREDENTIALS_PATH = "path/to/your/google_review_client.json"
# Set a consistent redirect URI
redirect_uri = "http://localhost:8080/"
# Setup the OAuth 2.0 flow with required scopes
flow = InstalledAppFlow.from_client_secrets_file(
    GCP_CREDENTIALS_PATH,
    scopes=["https://www.googleapis.com/auth/business.manage"],
    redirect_uri=redirect_uri)
# Run OAuth flow to obtain credentials
credentials = flow.run_local_server(port=8080)
log.debug(f"Credentials: {credentials}")
# Setup the API request session
session = requests.Session()
session.headers.update({"Authorization": f"Bearer {credentials.token}"})
# Construct the API endpoint URL
url = f"https://mybusiness.googleapis.com/v4/accounts/{my_business_account_id}/locations/{location_id}/reviews"
# Make API request and handle potential errors
try:
    response = session.get(url)
    response.raise_for_status()
    reviews = response.json()
    print("Reviews fetched successfully.")
    print(reviews)
except requests.exceptions.HTTPError as http_err:
    log.error(f"HTTP error: {http_err}")
except Exception as err:
    log.error(f"Unexpected error: {err}")

# Step 1: Open Google Cloud Console
# Step 2: Navigate to your project and go to "APIs & Services" > "Credentials"
# Step 3: Edit the OAuth 2.0 Client IDs settings
# Step 4: In "Authorized redirect URIs", add "http://localhost:8080/"
# Step 5: Save your changes
# After setting the correct redirect URI, re-run your Python script
# This ensures the OAuth 2.0 flow will use the correct URI during authentication

from flask import Flask, redirect, request, session, url_for
from google_auth_oauthlib.flow import Flow
# Flask setup
app = Flask(__name__)
app.secret_key = "your_secret_key"
# Path to OAuth 2.0 Client Secret JSON
GCP_CREDENTIALS_PATH = "google_review_client.json"
@app.route("/authorize")
def authorize():
    flow = Flow.from_client_secrets_file(
        GCP_CREDENTIALS_PATH,
        scopes=["https://www.googleapis.com/auth/business.manage"],
        redirect_uri=url_for("oauth2callback", _external=True)
    )
    authorization_url, _ = flow.authorization_url()
    return redirect(authorization_url)
@app.route("/oauth2callback")
def oauth2callback():
    flow = Flow.from_client_secrets_file(
        GCP_CREDENTIALS_PATH,
        scopes=["https://www.googleapis.com/auth/business.manage"],
        redirect_uri=url_for("oauth2callback", _external=True)
    )
    flow.fetch_token(authorization_response=request.url)
    session["credentials"] = flow.credentials
    return redirect("/reviews")
# Run the Flask server
if __name__ == "__main__":
    app.run("localhost", 8080)

Résoudre les problèmes de redirection OAuth dans les API Google pour l'intégration Python

Un aspect critique souvent négligé lors de l'intégration des API Google dans les applications Python est la configuration précise du URI de redirection. Ce paramètre est vital pour l'authentification OAuth 2.0, et une incohérence dans cet URI entraîne souvent l'erreur « Erreur 400 : redirect_uri_mismatch ». Le processus d'authentification de Google est rigoureux pour garantir que le flux est sécurisé et respecte les meilleures pratiques. Par conséquent, les développeurs doivent s'assurer que l'URI de redirection configuré dans Google Cloud Console correspond exactement à celui utilisé dans leur code d'application.

Un autre aspect important est de comprendre comment les ports fonctionnent dans le flux OAuth, en particulier lorsque vous travaillez dans un environnement local. Les développeurs sont fréquemment confrontés à des changements de numéros de port (comme l'erreur « 52271 » mentionnée précédemment) lorsqu'ils utilisent des outils tels que flow.run_local_server(). Il est conseillé de fixer le numéro de port (par exemple, 8080) pour éviter les incompatibilités, et cela peut être fait en transmettant explicitement le numéro de port dans le code. Cela garantit non seulement la cohérence, mais évite également les erreurs résultant de l'attribution dynamique des ports.

De plus, la gestion de votre OAuth 2.0 credentials en toute sécurité est essentiel. Le fichier JSON contenant les secrets client doit être stocké dans un emplacement sécurisé et les jetons d'accès doivent être actualisés périodiquement. Garder ces jetons à jour garantit que les appels d'API restent valides, car les jetons expirés peuvent également entraîner des problèmes d'authentification. Dans l’ensemble, une gestion minutieuse de votre flux d’authentification garantit une intégration plus fluide et élimine les pièges courants tels que l’erreur de non-concordance d’URI de redirection.