ప్రైవేట్ API పై Requests ProxyError? మొదట పర్యావరణాన్ని తనిఖీ చేయండి

VPN ఆన్లో ఉంది, అంతర్గత డాష్బోర్డ్ బ్రౌజర్లో తెరుచుకుంటుంది, అయినా Python స్క్రిప్ట్ ప్రాక్సీ లోపాన్ని విసురుతూనే ఉంది. ఆ చిత్రంలో సొరంగంలో ఏమీ తప్పు లేదు: ఇంటర్ప్రెటర్ తన పర్యావరణం నుండి ప్రాక్సీ చిరునామాను చదివి అభ్యర్థనను అక్కడికి పంపుతుంది. ఈ మార్గదర్శిని ప్రక్రియ నిజంగా చూసే పర్యావరణాన్ని చదుస్తుంది, అత్యంత సన్నిహిత మినహాయింపును వర్తింపజేస్తుంది, ఆ తర్వాత మాత్రమే స్పష్టమైన సెషన్ విధానాన్ని పరిగణిస్తుంది. ప్రతి దశ మీరు కొనసాగుతారా లేదా అని నిర్ణయించే ఆదేశంతో ముగుస్తుంది.

ప్రక్రియ నిజంగా చూసే పర్యావరణాన్ని చదవండి

డెస్క్టాప్ ప్రాక్సీ సెట్టింగ్లు, shell ఎగుమతులు మరియు systemd యూనిట్ యొక్క Environment= పంక్తులు మూడు వేర్వేరు మూలాలు, Requests చివరగా వారసత్వంగా పొందేదాన్ని మాత్రమే చదుస్తుంది. విఫలమయ్యే స్క్రిప్ట్ నడిపే అదే shell, కంటైనర్ లేదా యూనిట్లో క్రింది నిర్ధారణను అమలు చేయండి, మీ ఇంటరాక్టివ్ టెర్మినల్లో కాదు. మీ లాగిన్ shellలో ఎగుమతి చేసిన వేరియబుల్ కంటైనర్ ప్రక్రియకు కనిపించదు, ఆ గ్యాప్ ఎక్కడి నుండో వచ్చే ప్రాక్సీ గురించిన అనేక నివేదికలను వివరిస్తుంది. రెండు ఆదేశాలు ఒకే డేటాను వేర్వేరు వివరాల స్థాయిల్లో ముద్రిస్తాయి.

env | grep -i -E 'proxy|requests_ca_bundle|curl_ca_bundle'
python3 -c "import os;[print(k,'=',v) for k,v in sorted(os.environ.items()) if 'proxy' in k.lower()]"

ప్రతి వేరియబుల్ యొక్క రెండు అక్షరక్రమాలు చదవబడతాయి, నకిలీ నమోదులు ప్రక్రియ పొందిన క్రమంలో వర్తించబడతాయి, కాబట్టి పాత HTTP_PROXY మీరు ఇప్పుడే ఎగుమతి చేసిన విలువను అధిగమించగలదు. CA బండిల్ వేరియబుల్స్ ఇక్కడ కూడా ముఖ్యం, ఎందుకంటే అవి కోడ్లో ఎక్కడా కనిపించకుండానే verify ఏమిటి అని పరిష్కరిస్తుందో మారుస్తాయి. అవుట్పుట్ ఖాళీగా ఉంటే పర్యావరణం మీ సమస్య కాదు, ఈ విభాగాన్ని చదవడం ఆపవచ్చు. మీకు తెలియని ప్రాక్సీని అది జాబితా చేస్తే, ఏదైనా మార్చే ముందు దాన్ని సెట్ చేసే ఫైల్ లేదా యూనిట్ను కనుగొనండి.

నిర్దిష్ట URL తో Requests ఏమి చేస్తుందో అడగండి. ఈ కాల్ ప్యాకెట్ పంపకుండా ఆ అభ్యర్థన కోసం విలీన ప్రాక్సీ, verify మరియు cert విలువలను చూపిస్తుంది.

python3 -c "import requests;s=requests.Session();print(s.merge_environment_settings('https://api.corp.example/status',{},None,None,None))"

ప్రైవేట్ హోస్ట్ కోసం ఖాళీ కాని proxies నమోదే మీ సమాధానం, ముద్రిత verify విలువ అభ్యర్థన ఏ CA బండిల్ను విశ్వసిస్తుందో చెబుతుంది. రెండూ సరిగ్గా కనిపిస్తే వైఫల్యం స్టాక్లో తర్వాత ఉంది, మీరు ధృవీకరణ విభాగానికి వెళ్లాలి. కోడ్ నుండి ఊహించవద్దు: విలీనం ప్రతి అభ్యర్థనకు జరుగుతుంది, అందుకే ఒక సెషన్ రెండు హోస్ట్లకు భిన్నంగా ప్రవర్తించగలదు.

ఏదైనా నిలిపివేయడానికి ముందు ప్రైవేట్ హోస్ట్ను మినహాయించండి

ఇతర గమ్యాలకు ప్రాక్సీ నిజంగా అవసరమైనప్పుడు, సన్నిహిత పరిష్కారం ఈ హోస్ట్ కోసం మినహాయింపు. ఉన్న జాబితాకు జోడించండి, దాన్ని భర్తీ చేయవద్దు, ఎందుకంటే NO_PROXY తొలగించడం దానిపై ఆధారపడిన ఇతర అన్ని అంతర్గత గమ్యాలను విరగ్గొడుతుంది. క్రింది ఆదేశాలు నమోదును జోడించి, ఆపై బైపాస్ వర్తిస్తుందా అని Requests ను అడుగుతాయి.

export NO_PROXY="${NO_PROXY:+$NO_PROXY,}api.corp.example,.corp.example"
python3 -c "import requests;print(requests.utils.should_bypass_proxies('https://api.corp.example/status',None))"

సరిపోలిక హోస్ట్ ప్రత్యయం ఆధారంగా జరుగుతుంది, కాబట్టి .corp.example మొత్తం డొమైన్ను, api.corp.example ఒక పేరును కవర్ చేస్తాయి. బేర్ నక్షత్రం ప్రతి హోస్ట్కు ప్రాక్సీని నిలిపివేస్తుంది, ఉత్పత్తి పని దాన్ని దాదాపు ఎప్పుడూ కోరుకోదు. CIDR నమోదు గౌరవించబడుతుందా అనేది ఇమేజ్లోని Requests మరియు urllib3 వెర్షన్లపై ఆధారపడి ఉంటుంది, కాబట్టి పని చేస్తుందని ఊహించకుండా ఖచ్చితమైన నమోదును పరీక్షించండి. should_bypass_proxies ఫలితాన్ని నిజమైన URL కోసం తనిఖీ చేయండి, జ్ఞాపకం నుండి టైప్ చేసిన హోస్ట్ పేరు కోసం కాదు.

రెండు పొరలను మనస్సులో వేరుగా ఉంచుకోండి. HTTP ప్రాక్సీని దాటడం VPN ను దాటదు, ఎందుకంటే ప్రాక్సీ నిర్ణయం లైబ్రరీలో, సొరంగం నిర్ణయం కర్నెల్ రూటింగ్ పట్టికలో జరుగుతుంది.

trust_env ను ఉద్దేశపూర్వక సెషన్ విధానంగా మాత్రమే నిలిపివేయండి

మొత్తం పని చుట్టుపక్కల కాన్ఫిగరేషన్ను పట్టించుకోకుండా ఉండాలంటే, సెషన్ను స్పష్టంగా నిర్మించి నిర్ణయాన్ని కోడ్లో నమోదు చేయండి. ఇది ఒక విధానం, పరిష్కార మార్గం కాదు, సమీక్షకుడు చూడగల diff కు చెందుతుంది. క్రింది ఉదాహరణ టైమౌట్, స్పష్టమైన CA మార్గం మరియు స్థితి తనిఖీని ఉంచుతుంది.

import requests

with requests.Session() as session:
    session.trust_env = False
    response = session.get(
        "https://api.corp.example/status",
        timeout=(5, 20),
        verify="/etc/ssl/certs/corp-ca.pem",
    )
    response.raise_for_status()

trust_env ను నిలిపివేయడం ఒకేసారి మూడు ప్రవర్తనలను మారుస్తుంది, వాటిలో ఒకటి మాత్రమే ప్రాక్సీ గురించి. Requests .netrc ఆధారాలను చదవడం ఆపేస్తుంది, REQUESTS_CA_BUNDLE మరియు CURL_CA_BUNDLE వేరియబుల్స్ verify పై ప్రభావం చూపడం ఆపేస్తాయి, అది తర్వాత చేర్చిన సర్టిఫికెట్ నిల్వకు తిరిగి వెళ్తుంది. మీ సంస్థ తన సొంత CA తో TLS ను ముగిస్తే, ఆ తిరోగమనం ఇప్పుడు చేసిన మార్పుకు సంబంధం లేనట్టుగా కనిపించే ధృవీకరణ లోపాన్ని లేవనెత్తుతుంది. verify ను స్పష్టంగా పంపడమే రెండు ప్రభావాలను వేరుగా ఉంచుతుంది.

మీరు చేయకూడనిది, వచ్చిన లోపాన్ని సద్దుమణగించడానికి verify=False సెట్ చేయడం. అది తప్పు ప్రాక్సీ కాన్ఫిగరేషన్ను ధృవీకరించని కనెక్షన్తో మారుస్తుంది, మినహాయింపు బయటపెట్టాల్సిన సర్టిఫికెట్ సమస్యను దాచుతుంది.

విఫలమయ్యే పొరను ధృవీకరించి తిరోగమన అవకాశాన్ని ఉంచుకోండి

మూడు వైఫల్యాలు లాగ్లో ఒకేలా కనిపిస్తాయి, వాటికి ఉమ్మడిగా ఏమీ లేదు: గమ్యాన్ని చేరుకోలేని ప్రాక్సీ ProxyError విసురుతుంది లేదా 502 తిరిగి ఇస్తుంది, విశ్వాస సమస్య SSLError విసురుతుంది, అప్లికేషన్ తిరస్కరణ 401 లేదా 403 తిరిగి ఇస్తుంది. మీకు ఏది ఉందో చూడటానికి అభ్యర్థనను Requests వెలుపల మళ్లీ ఉత్పత్తి చేయండి. క్రింది ఆదేశాలు ప్రాక్సీని తొలగించి, సర్టిఫికెట్ గొలుసును పరీక్షించి, ఆ తర్వాత లైబ్రరీ ద్వారా కాల్ను పునరావృతం చేస్తాయి.

curl -sv --noproxy '*' https://api.corp.example/status -o /dev/null
openssl s_client -connect api.corp.example:443 -servername api.corp.example </dev/null
python3 -c "import requests;r=requests.get('https://api.corp.example/status',timeout=10);print(r.status_code)"

curl కాల్ విజయవంతమై Python కాల్ విఫలమైతే, తేడా ఇప్పటికీ పర్యావరణమే. రెండూ TLS దశలో విఫలమైతే, ప్రాక్సీ ఎప్పుడూ సమస్య కాదు, సర్టిఫికెట్ గొలుసే సమస్య. రెండూ 401 తిరిగి ఇస్తే, అభ్యర్థన అప్లికేషన్ను చేరింది, మిగిలిన పని ధృవీకరణ. మూడింటిలో ఏది గమనించారో నమోదు చేయడం తదుపరి వ్యక్తికి ఒక గంట ఆదా చేస్తుంది.

తిరోగమనం ఏ దిశలోనైనా ఒక పంక్తి: మినహాయింపును తొలగించండి, లేదా trust_env ను తిరిగి మార్చండి. జోడించే ముందు మునుపటి NO_PROXY విలువను సేవ్ చేయండి, మీ టెర్మినల్ చరిత్రలో మాత్రమే జీవించే ఎగుమతి కంటే ర్యాపర్ స్క్రిప్ట్ లేదా యూనిట్ స్థాయి Environment= నమోదును ఇష్టపడండి. రెండు మార్పులూ ప్రక్రియ పర్యావరణంలో కనిపిస్తాయి, కాబట్టి పునఃప్రారంభం సాధారణంగా పాత ప్రవర్తనకు తిరిగి తీసుకువస్తుంది.

నాలుగు విషయాలను నిర్ధారించి ముగించండి: ప్రైవేట్ URL కోసం విలీన సెట్టింగ్లు ఏ ప్రాక్సీని చూపవు, సర్టిఫికెట్ ఉద్దేశించిన CA కి వ్యతిరేకంగా చెల్లుబాటు అవుతుంది, అభ్యర్థన మీరు ఆశించిన స్థితిని తిరిగి ఇస్తుంది, మార్పు పునరుత్పత్తి చేయగల స్థలంలో commit చేయబడింది. వివరించని పర్యావరణంతో ఆకుపచ్చ స్క్రిప్ట్ తదుపరి మెషీన్లో మళ్లీ విరిగే మరమ్మతు. ఈ మార్గదర్శిని ఆదేశాలే టికెట్లో అతికించవలసినవి.