Retting av feil 400: mismatch i redirect_uri Når du importerer anmeldelser fra Google Business til Python

Overvinne OAuth 2.0 Redirect URI-problemer i Google Reviews API-integrasjon

Når de integrerer Google Business Reviews i Python, støter mange utviklere på den vanlige feilen «Feil 400: redirect_uri_mismatch». Dette problemet oppstår på grunn av en feiljustering mellom omdirigerings-URIen i OAuth 2.0-innstillingene og det som er spesifisert i Google Cloud Console. Feilen kan forhindre tilgang til Google Anmeldelser API, som er avgjørende for å hente tilbake tilbakemeldinger fra kunder programmatisk.

Googles OAuth 2.0-policy er streng, og krever et nøyaktig samsvar mellom den konfigurerte viderekoblings-URIen og den som ble brukt under autentisering. Unnlatelse av å konfigurere dette kan føre til frustrasjon, spesielt når omdirigeringsportnummeret endres ofte, som mange utviklere rapporterer. Det er viktig å forstå dette problemet for å sikre en jevn API-tilkobling og unngå å treffe denne veisperringen.

I denne artikkelen går vi gjennom trinnene for å løse redirect_uri_mismatch-feilen ved tilgang til Google Business Reviews. Ved å konfigurere OAuth-legitimasjonen din nøye, vil vi eliminere dette problemet og gjøre det mulig for deg å hente anmeldelser på en enkel måte. Løsningen innebærer riktig innstilling av omdirigerings-URI og innretting av den med det lokale vertsmiljøet som brukes til utvikling.

Enten du henter anmeldelser for å analysere virksomhetens ytelse eller for å vise dem på nettstedet ditt, vil det å forstå hvordan du løser denne feilen spare tid og sikre vellykket API-interaksjon. Følg disse trinnene for å fikse uoverensstemmelsen og få tilgang til Google Business-anmeldelser uten avbrudd.

Forstå OAuth 2.0-prosessen for tilgang til Google Anmeldelser API

Python-skriptene ovenfor er laget for å hente Google Business Reviews ved hjelp av Google My Business API. Det første trinnet innebærer å sette opp OAuth 2.0-autorisasjon, som kreves for å samhandle med Googles API-er på en sikker måte. Denne prosessen starter med å spesifisere OAuth-klienthemmelighetene dine i en JSON-fil, som inneholder legitimasjonen for Google Cloud-prosjektet ditt. Disse legitimasjonene er avgjørende for å etablere sikker tilgang, og omdirigere URI må samsvare med den som er konfigurert i Google Cloud Console. En mismatch kan forårsake en feil som "Feil 400: redirect_uri_mismatch."

Når legitimasjonen er lastet inn, starter skriptet en OAuth-flyt ved hjelp av InstalledAppFlow. Denne flyten starter en lokal server (i dette tilfellet på port 8080) for å håndtere brukerautorisasjonen. Når brukeren gir tillatelse, mottar skriptet et tilgangstoken, som er nødvendig for å sende autoriserte forespørsler til Google Anmeldelser API. Denne prosessen automatiseres og håndteres av flow.run_local_server-metoden, som sikrer at legitimasjonen lagres sikkert og brukes til API-forespørsler. Loggingsmekanismer som loguru brukes til å spore flyten og sikre at eventuelle problemer som oppstår logges tydelig for feilsøking.

Etter å ha oppnådd påloggingsinformasjonen, oppretter skriptet en økt ved å bruke forespørselsbiblioteket. Denne økten inkluderer tilgangstokenet i overskriftene, som kreves for autentisering når du foretar API-kall til Google. Skriptet konstruerer den riktige API-endepunkt-URLen ved å bruke bedriftskonto-ID og steds-ID. Ved å sende en GET-forespørsel til URL-en, prøver skriptet å hente anmeldelser for den angitte bedriftsplasseringen. Det inkluderer også feilhåndtering for å fange opp HTTP-feil, for eksempel feil legitimasjon eller tillatelser, som sikrer at eventuelle problemer som oppstår under forespørselen administreres effektivt.

Svaret fra Google Anmeldelser API blir analysert som et JSON-objekt, som inneholder anmeldelsene for bedriftsbeliggenheten. Hvis forespørselen er vellykket, skrives vurderingene ut til konsollen, og skriptet logger en suksessmelding. Denne modulære tilnærmingen sikrer at prosessen lett kan repeteres og kan tilpasses for forskjellige lokasjoner eller kontoer. Videre, ved å opprettholde en klar struktur med øktadministrasjon og feilhåndtering, optimaliserer skriptet sikkerhet og ytelse når du arbeider med Google Anmeldelser API. Dette lar utviklere effektivt få tilgang til og administrere kundeanmeldelser for analyse eller visning.

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)

Løse OAuth-viderekoblingsproblemer i Google APIer for Python-integrasjon

Et kritisk aspekt som ofte blir oversett ved integrering av Google APIer i Python-applikasjoner, er den nøyaktige konfigurasjonen av omdirigere URI. Denne innstillingen er avgjørende for OAuth 2.0-autentisering, og feil samsvar i denne URI resulterer ofte i feilen "Feil 400: redirect_uri_mismatch". Googles autentiseringsprosess er streng for å sikre at flyten er sikker og følger beste praksis. Derfor må utviklere sørge for at omdirigerings-URIen som er konfigurert i Google Cloud Console, samsvarer nøyaktig med den som brukes i applikasjonskoden deres.

Et annet viktig aspekt er å forstå hvordan porter fungerer i OAuth-flyten, spesielt når du arbeider i et lokalt miljø. Utviklere møter ofte endrede portnumre (som "52271"-feilen nevnt tidligere) når de bruker verktøy som flow.run_local_server(). Det er tilrådelig å fikse portnummeret (f.eks. 8080) for å unngå uoverensstemmelser, og dette kan gjøres ved eksplisitt å sende portnummeret i koden. Dette sikrer ikke bare konsistens, men forhindrer også feil som oppstår på grunn av dynamisk porttilordning.

I tillegg kan du administrere din OAuth 2.0 credentials sikkert er viktig. JSON-filen som inneholder klienthemmeligheter må lagres på et sikkert sted, og tilgangstokener bør oppdateres med jevne mellomrom. Å holde disse tokenene oppdatert sikrer at API-kallene forblir gyldige, ettersom utløpte tokens også kan forårsake autentiseringsproblemer. Samlet sett sikrer nøye styring av autentiseringsflyten jevnere integrasjon og eliminerer vanlige fallgruver som feilen for omdirigerings-URI-mismatch.