பிழையை சரிசெய்வது 400: redirect_uri இல் பொருத்தமின்மை Google வணிகத்திலிருந்து பைத்தானுக்கு மதிப்புரைகளை இறக்குமதி செய்யும் போது

Google Reviews API ஒருங்கிணைப்பில் OAuth 2.0 URI சிக்கல்களைத் திருப்பிவிடுதல்

Python இல் Google வணிக மதிப்புரைகளை ஒருங்கிணைக்கும் போது, ​​பல டெவலப்பர்கள் "Error 400: redirect_uri_mmatch" என்ற பொதுவான பிழையை எதிர்கொள்கின்றனர். OAuth 2.0 அமைப்புகளில் உள்ள URI மற்றும் Google Cloud Console இல் குறிப்பிடப்பட்டுள்ளவற்றுக்கு இடையே உள்ள தவறான சீரமைப்பு காரணமாக இந்தச் சிக்கல் எழுகிறது. பிழையானது Google Reviews APIக்கான அணுகலைத் தடுக்கலாம், இது வாடிக்கையாளர் கருத்துக்களை நிரல்ரீதியாகப் பெறுவதற்கு முக்கியமானது.

Google இன் OAuth 2.0 கொள்கையானது கண்டிப்பானது, உள்ளமைக்கப்பட்ட வழிமாற்று URIக்கும் அங்கீகாரத்தின் போது பயன்படுத்தப்பட்டதற்கும் இடையே துல்லியமான பொருத்தம் தேவை. இதை சரியாக உள்ளமைக்கத் தவறினால் விரக்தி ஏற்படலாம், குறிப்பாக பல டெவலப்பர்கள் தெரிவிக்கும் போர்ட் எண் அடிக்கடி மாறும் போது. இந்தச் சிக்கலைப் புரிந்துகொள்வது ஒரு மென்மையான API இணைப்பை உறுதிசெய்து, இந்த சாலைத் தடுப்பைத் தவிர்க்கவும்.

இந்தக் கட்டுரையில், Google வணிக மதிப்புரைகளை அணுகும்போது redirect_uri_mmatch பிழையைத் தீர்ப்பதற்கான படிகளை நாங்கள் படிப்போம். உங்கள் OAuth நற்சான்றிதழ்களை கவனமாக உள்ளமைப்பதன் மூலம், இந்தச் சிக்கலை நாங்கள் நீக்கி, எளிதாக மதிப்பாய்வுகளைப் பெற உங்களுக்கு உதவுவோம். தீர்வு URI ஐ சரியாக அமைப்பது மற்றும் அபிவிருத்திக்காக பயன்படுத்தப்படும் லோக்கல் ஹோஸ்ட் சூழலுடன் அதை சீரமைப்பது.

வணிகச் செயல்திறனைப் பகுப்பாய்வு செய்ய அல்லது உங்கள் இணையதளத்தில் அவற்றைக் காண்பிக்க நீங்கள் மதிப்புரைகளைப் பெற்றாலும், இந்தப் பிழையை எவ்வாறு தீர்ப்பது என்பதைப் புரிந்துகொள்வது நேரத்தைச் சேமிக்கும் மற்றும் வெற்றிகரமான API தொடர்புகளை உறுதி செய்யும். பொருந்தாததைச் சரிசெய்ய இந்தப் படிகளைப் பின்பற்றவும் மற்றும் உங்கள் Google வணிக மதிப்புரைகளை குறுக்கீடுகள் இல்லாமல் அணுகவும்.

Google Reviews API ஐ அணுகுவதற்கான OAuth 2.0 செயல்முறையைப் புரிந்துகொள்வது

மேலே கொடுக்கப்பட்டுள்ள பைதான் ஸ்கிரிப்ட்கள் Google My Business API ஐப் பயன்படுத்தி Google வணிக மதிப்புரைகளைப் பெற வடிவமைக்கப்பட்டுள்ளன. முதல் படி OAuth 2.0 அங்கீகாரத்தை அமைப்பதை உள்ளடக்கியது, இது Google இன் API களுடன் பாதுகாப்பாக தொடர்பு கொள்ள வேண்டும். உங்கள் Google கிளவுட் திட்டத்திற்கான நற்சான்றிதழ்களைக் கொண்ட JSON கோப்பில் உங்கள் OAuth கிளையண்ட் ரகசியங்களைக் குறிப்பிடுவதன் மூலம் இந்த செயல்முறை தொடங்குகிறது. பாதுகாப்பான அணுகலை நிறுவுவதற்கு இந்த நற்சான்றிதழ்கள் முக்கியமானவை URI ஐ திருப்பிவிடவும் கூகுள் கிளவுட் கன்சோலில் உள்ளமைக்கப்பட்டதை பொருத்த வேண்டும். பொருந்தாதது "Error 400: redirect_uri_mmatch" போன்ற பிழையை ஏற்படுத்தலாம்.

நற்சான்றிதழ்கள் ஏற்றப்பட்டதும், InstalledAppFlow ஐப் பயன்படுத்தி ஸ்கிரிப்ட் OAuth ஓட்டத்தைத் தொடங்குகிறது. இந்த ஓட்டம் பயனர் அங்கீகாரத்தைக் கையாள உள்ளூர் சேவையகத்தை (இந்நிலையில், போர்ட் 8080 இல்) தொடங்குகிறது. பயனர் அனுமதி வழங்கும்போது, ​​ஸ்கிரிப்ட் அணுகல் டோக்கனைப் பெறுகிறது, இது Google Reviews APIக்கு அங்கீகரிக்கப்பட்ட கோரிக்கைகளைச் செய்வதற்கு அவசியமாகும். இந்த செயல்முறை தானியங்கு மற்றும் flow.run_local_server முறையால் கையாளப்படுகிறது, நற்சான்றிதழ்கள் பாதுகாப்பாக சேமிக்கப்பட்டு API கோரிக்கைகளுக்குப் பயன்படுத்தப்படுவதை உறுதி செய்கிறது. போன்ற பதிவு வழிமுறைகள் லோகுரு ஓட்டத்தைக் கண்காணிக்கவும், ஏதேனும் சிக்கல்கள் ஏற்பட்டால் பிழைத்திருத்தத்திற்காக தெளிவாகப் பதிவு செய்யப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும் பயன்படுத்தப்படுகின்றன.

நற்சான்றிதழ்களை வெற்றிகரமாகப் பெற்ற பிறகு, கோரிக்கை நூலகத்தைப் பயன்படுத்தி ஸ்கிரிப்ட் ஒரு அமர்வை நிறுவுகிறது. இந்த அமர்வில் அதன் தலைப்புகளில் அணுகல் டோக்கன் உள்ளது, இது Google க்கு API அழைப்புகளைச் செய்யும்போது அங்கீகாரத்திற்குத் தேவைப்படுகிறது. உங்கள் வணிகக் கணக்கு ஐடி மற்றும் இருப்பிட ஐடியைப் பயன்படுத்தி ஸ்கிரிப்ட் சரியான API எண்ட்பாயிண்ட் URL ஐ உருவாக்குகிறது. URL க்கு GET கோரிக்கையை அனுப்புவதன் மூலம், குறிப்பிட்ட வணிக இருப்பிடத்திற்கான மதிப்புரைகளைப் பெற ஸ்கிரிப்ட் முயற்சிக்கிறது. தவறான நற்சான்றிதழ்கள் அல்லது அனுமதிகள் போன்ற HTTP பிழைகளைப் பிடிக்க பிழை கையாளுதலும் இதில் அடங்கும், கோரிக்கையின் போது ஏற்படும் ஏதேனும் சிக்கல்கள் திறமையாக நிர்வகிக்கப்படுவதை உறுதிசெய்கிறது.

Google Reviews API இன் பதில் JSON பொருளாகப் பாகுபடுத்தப்பட்டது, அதில் வணிக இருப்பிடத்திற்கான மதிப்புரைகள் உள்ளன. கோரிக்கை வெற்றிகரமாக இருந்தால், மதிப்புரைகள் கன்சோலில் அச்சிடப்படும், மேலும் ஸ்கிரிப்ட் வெற்றிச் செய்தியைப் பதிவு செய்கிறது. இந்த மட்டு அணுகுமுறையானது செயல்முறை எளிதாக மீண்டும் மீண்டும் செய்யக்கூடியது மற்றும் வெவ்வேறு இடங்கள் அல்லது கணக்குகளுக்கு தனிப்பயனாக்கப்படுவதை உறுதி செய்கிறது. மேலும், அமர்வு மேலாண்மை மற்றும் பிழை கையாளுதலுடன் தெளிவான கட்டமைப்பை பராமரிப்பதன் மூலம், Google Reviews API உடன் பணிபுரியும் போது ஸ்கிரிப்ட் பாதுகாப்பையும் செயல்திறனையும் மேம்படுத்துகிறது. இது டெவலப்பர்களை பகுப்பாய்வு அல்லது காட்சிக்காக வாடிக்கையாளர் மதிப்புரைகளை திறமையாக அணுகவும் நிர்வகிக்கவும் அனுமதிக்கிறது.

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)

பைதான் ஒருங்கிணைப்புக்கான Google APIகளில் OAuth வழிமாற்றுச் சிக்கல்களைத் தீர்க்கிறது

கூகுள் ஏபிஐகளை பைதான் அப்ளிகேஷன்களில் ஒருங்கிணைக்கும் போது பெரும்பாலும் கவனிக்கப்படாத ஒரு முக்கியமான அம்சம் துல்லியமான உள்ளமைவு ஆகும். URI ஐ திருப்பிவிடவும். OAuth 2.0 அங்கீகரிப்புக்கு இந்த அமைப்பு முக்கியமானது, மேலும் இந்த URI இல் பொருந்தாதது பெரும்பாலும் "Error 400: redirect_uri_mismatch" பிழையை ஏற்படுத்துகிறது. Google இன் அங்கீகரிப்பு செயல்முறையானது, ஓட்டம் பாதுகாப்பாக இருப்பதையும் சிறந்த நடைமுறைகளைப் பின்பற்றுவதையும் உறுதிசெய்ய கடுமையாக உள்ளது. எனவே, Google கிளவுட் கன்சோலில் உள்ளமைக்கப்பட்ட URI திருப்பியனுப்புபவர்கள் தங்கள் பயன்பாட்டுக் குறியீட்டில் பயன்படுத்தப்படும் URIயுடன் சரியாகப் பொருந்துவதை உறுதிசெய்ய வேண்டும்.

மற்றொரு முக்கியமான அம்சம், OAuth ஓட்டத்தில் துறைமுகங்கள் எவ்வாறு செயல்படுகின்றன என்பதைப் புரிந்துகொள்வது, குறிப்பாக உள்ளூர் சூழலில் பணிபுரியும் போது. போன்ற கருவிகளைப் பயன்படுத்தும் போது டெவலப்பர்கள் அடிக்கடி போர்ட் எண்களை மாற்றுவதை எதிர்கொள்கின்றனர் (முன்பே குறிப்பிட்ட "52271" பிழை போன்றவை) flow.run_local_server(). போர்ட் எண்ணை சரிசெய்வது நல்லது (எ.கா., 8080) பொருந்தாதவற்றைத் தவிர்க்க, குறியீட்டில் உள்ள போர்ட் எண்ணை வெளிப்படையாக அனுப்புவதன் மூலம் இதைச் செய்யலாம். இது நிலைத்தன்மையை உறுதி செய்வது மட்டுமல்லாமல், டைனமிக் போர்ட் ஒதுக்கீட்டின் காரணமாக எழும் பிழைகளைத் தடுக்கிறது.

கூடுதலாக, உங்கள் மேலாண்மை OAuth 2.0 credentials பாதுகாப்பாக அவசியம். கிளையன்ட் ரகசியங்களைக் கொண்ட JSON கோப்பு பாதுகாப்பான இடத்தில் சேமிக்கப்பட வேண்டும், மேலும் அணுகல் டோக்கன்கள் அவ்வப்போது புதுப்பிக்கப்பட வேண்டும். காலாவதியான டோக்கன்கள் அங்கீகாரச் சிக்கல்களையும் ஏற்படுத்தக்கூடும் என்பதால், இந்த டோக்கன்களைப் புதுப்பித்த நிலையில் வைத்திருப்பது, API அழைப்புகள் செல்லுபடியாகும் என்பதை உறுதி செய்கிறது. ஒட்டுமொத்தமாக, உங்கள் அங்கீகரிப்பு ஓட்டத்தை கவனமாக நிர்வகிப்பது மென்மையான ஒருங்கிணைப்பை உறுதிசெய்கிறது மற்றும் URI பொருத்தமின்மை பிழையை திருப்பிவிடுவது போன்ற பொதுவான குறைபாடுகளை நீக்குகிறது.