AWS API గేట్‌వే: SAM స్థానిక

Daniel Marino

24, సెప్టెంబర్ 2024, మంగళవారం 4:49:54 AMకి

స్థానిక AWS API గేట్‌వేలో 403 ఎర్రర్‌లను అర్థం చేసుకోవడం

తో పని చేసిన తర్వాత AWS API గేట్‌వే మరియు AWS SAM (సర్వర్‌లెస్ అప్లికేషన్ మోడల్) ద్వారా స్థానికంగా పరీక్షించడం, API అమలు చేయబడిన తర్వాత తలెత్తని బగ్‌లను కనుగొనడం విలక్షణమైనది. ఒక సమస్య a పొందడం 403 నిషిద్ధ లోపం CORS కోసం APIని సరిగ్గా కాన్ఫిగర్ చేసినప్పటికీ మరియు ఆథరైజేషన్ టైప్‌ను "NONE"కి సెట్ చేసినప్పటికీ, OPTIONS పద్ధతిని అమలు చేస్తున్నప్పుడు. అమలు చేయబడిన వాతావరణంలో సెటప్ సజావుగా నడుస్తున్నప్పుడు ఈ సమస్య ముఖ్యంగా తీవ్రమవుతుంది.

తో స్థానికంగా OPTIONS అభ్యర్థనలను పరీక్షిస్తున్నప్పుడు కర్ల్, API గేట్‌వే "తప్పిపోయిన ప్రామాణీకరణ టోకెన్" లోపాన్ని అందించవచ్చు. ఇది గందరగోళంగా ఉంది ఎందుకంటే OPTIONS పద్ధతికి ప్రామాణీకరణ అవసరం లేదు, ప్రత్యేకించి 200 ఫలితాన్ని అందించడానికి స్పష్టంగా సెట్ చేసినప్పుడు. విజయవంతమైన స్థానిక అభివృద్ధికి ఈ అసమానత యొక్క మూలాన్ని గుర్తించడం చాలా కీలకం.

అమలు చేయబడిన API గేట్‌వే కంటే SAM లోకల్ ఎందుకు భిన్నంగా ప్రవర్తిస్తుందో అర్థం చేసుకోవడం ఈ సమస్యను పరిష్కరించడంలో మీకు సహాయపడుతుంది. కాన్ఫిగరేషన్ వివరాలను లోతుగా పరిశోధించడం మరియు స్థానిక మరియు అమలు చేయబడిన వాతావరణాలు దాదాపు సాధ్యమయ్యే విధంగా సరిపోలడం చాలా కీలకం. తప్పుడు కాన్ఫిగరేషన్‌లు తరచుగా ఇటువంటి లోపాలను కలిగిస్తాయి.

ఈ కథనంలో, స్థానిక అభివృద్ధి సమయంలో 403 లోపానికి సంభావ్య కారణాలను మరియు దానిని ఎలా పరిష్కరించాలో మేము పరిశీలిస్తాము. మేము సాధారణ ఆపదలను సమీక్షిస్తాము SAM టెంప్లేట్‌లు, CORS హ్యాండ్లింగ్ మరియు API గేట్‌వే సెటప్‌లు, కాబట్టి మీరు ఈ అడ్డంకులను నివారించవచ్చు మరియు సమర్థవంతంగా నిర్మాణాన్ని కొనసాగించవచ్చు.

ఆదేశం	ఉపయోగం యొక్క ఉదాహరణ
app.options()	Express.jsలో OPTIONS అభ్యర్థనలను నిర్వహించడానికి మార్గాన్ని నిర్వచిస్తుంది, ఇది ప్రీఫ్లైట్ CORS హ్యాండ్లింగ్‌కు అవసరం. ఈ సందర్భంలో, ఇది POST అభ్యర్థనతో కొనసాగడానికి ముందు CORS ప్రీఫ్లైట్ ప్రశ్నలకు ప్రతిస్పందించడానికి సర్వర్‌ను ప్రారంభిస్తుంది.
res.setHeader()	ఈ ఫంక్షన్ ప్రతిస్పందనలో నిర్దిష్ట HTTP హెడర్‌లను సెట్ చేస్తుంది యాక్సెస్-నియంత్రణ-అనుమతించు-మూలం, వివిధ మూలాధారాల నుండి APIలను ఉపయోగిస్తున్నప్పుడు CORSని ప్రారంభించడం మరియు 403 ఎర్రర్‌లను నిరోధించడం కోసం ఇవి కీలకమైనవి.
PassthroughBehavior	సరిపోలే టెంప్లేట్ అందుబాటులో లేనప్పుడు అభ్యర్థనలను ఎలా నిర్వహించాలో పేర్కొనే AWS API గేట్‌వే పద్ధతుల కోసం అనుకూల కాన్ఫిగరేషన్. దీన్ని సెట్ చేస్తోంది WHEN_NO_MATCH నిర్దిష్ట అభ్యర్థన టెంప్లేట్ అందించనప్పుడు మాక్ ఇంటిగ్రేషన్ సరిగ్గా పనిచేస్తుందని హామీ ఇస్తుంది.
IntegrationHttpMethod	బ్యాకెండ్ సేవకు కాల్ చేయడానికి API గేట్‌వే ఉపయోగించే HTTP పద్ధతిని నిర్వచిస్తుంది (ఉదా., లాంబ్డా ఫంక్షన్). API గేట్‌వే మార్గాన్ని సముచితమైన HTTP పద్ధతికి లింక్ చేయడానికి ఇది కీలకం, ఇది బ్యాకెండ్ చర్యను ప్రారంభిస్తుంది.
AWS::ApiGateway::Method	AWS SAM టెంప్లేట్ API గేట్‌వే పద్ధతి వనరును నిర్దేశిస్తుంది. API గేట్‌వే మద్దతు ఇవ్వాల్సిన HTTP పద్ధతులను (POST, OPTIONS) నిర్వచించడానికి మరియు వాటిని బ్యాకెండ్ ఇంటిగ్రేషన్‌లకు మ్యాపింగ్ చేయడానికి ఇది కీలకం.
ResponseParameters	వంటి హెడర్‌లను సెట్ చేయడం ద్వారా CORS మద్దతును ప్రారంభించడానికి ఈ ఆదేశం API గేట్‌వే ఇంటిగ్రేషన్ ప్రతిస్పందనలలో ఉపయోగించబడుతుంది యాక్సెస్-నియంత్రణ-అనుమతించు-పద్ధతులు. ఈ పారామితులు CORS విధానానికి అనుగుణంగా క్లయింట్‌కు తిరిగి ఇవ్వబడతాయి.
app.route()	ఈ Flask కమాండ్ నిర్దిష్ట ఫంక్షన్‌లకు HTTP పద్ధతులను (POST మరియు OPTIONS వంటివి) మ్యాప్ చేస్తుంది. ఈ సందర్భంలో, OPTIONS (ప్రీఫ్లైట్ ప్రశ్నలు) మరియు POST (ప్రధాన API అభ్యర్థనలు)కి భిన్నంగా స్పందించడం చాలా కీలకం.
!Ref	AWS క్లౌడ్‌ఫార్మేషన్/SAM టెంప్లేట్‌లలో ఉపయోగించబడింది! Ref టెంప్లేట్‌లోని ఇతర వనరులకు సూచనలు. ఉదాహరణకు, ఇది సూచించడానికి ఉపయోగించబడుతుంది scanRecordsResource మరియు API కాల్‌లను సరైన URLకి సరిగ్గా లింక్ చేయండి.
app.response_class()	ఈ ఆదేశం ఫ్లాస్క్‌లో అనుకూల ప్రతిస్పందన వస్తువును ఉత్పత్తి చేస్తుంది, ఇది మీకు HTTP స్థితి కోడ్‌లు మరియు హెడర్‌లపై నియంత్రణను ఇస్తుంది. నిర్దిష్ట CORS హెడర్‌లను సెట్ చేయడానికి ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది యాక్సెస్-నియంత్రణ-అనుమతించు-మూలం.

AWS API గేట్‌వే స్థానిక ఆహ్వానాన్ని అర్థం చేసుకోవడం మరియు ఆప్టిమైజ్ చేయడం

ఎక్స్‌ప్రెస్ సర్వర్‌లో, మేము ఉపయోగిస్తాము res.setHeader() "యాక్సెస్-కంట్రోల్-అనుమతించు-మూలం" మరియు "యాక్సెస్-కంట్రోల్-అనుమతించు-పద్ధతులు" వంటి CORS హెడర్‌లను సెట్ చేయడానికి. క్రాస్-ఆరిజిన్ అభ్యర్థనలను అనుమతించడం ద్వారా క్లయింట్‌కు తగిన హెడర్‌లు తిరిగి అందించబడతాయని ఇది నిర్ధారిస్తుంది. అదనంగా, స్క్రిప్ట్ యొక్క POST పద్ధతి AWS SDK ద్వారా AWS DynamoDB పట్టికకు కనెక్ట్ అవుతుంది. స్కాన్ ఆపరేషన్ అనేది రీడ్-ఓన్లీ చర్య, ఇది ఎంచుకున్న పట్టిక నుండి అన్ని రికార్డ్‌లను అందిస్తుంది, ఇది డేటాబేస్ పరస్పర చర్యలను స్థానికంగా పరీక్షించడానికి మమ్మల్ని అనుమతిస్తుంది. డేటాబేస్ కనెక్షన్ సమస్యలను నిర్వహించడానికి సరైన లోపం నిర్వహణ ఉపయోగించబడుతుంది, సర్వర్ వైఫల్యాలకు తగిన విధంగా ప్రతిస్పందిస్తుందని నిర్ధారిస్తుంది.

రెండవ ఉదాహరణ, ఫ్లాస్క్‌తో పైథాన్‌లో నిర్మించబడింది, Node.js స్క్రిప్ట్ వలె అదే కార్యాచరణను అందిస్తుంది కానీ పైథాన్‌తో ఎక్కువ అనుభవం ఉన్న డెవలపర్‌ల కోసం ఉద్దేశించబడింది. ఫ్లాస్క్ యొక్క app.route() CORS ప్రీఫ్లైట్ అభ్యర్థనలు సులభంగా నిర్వహించబడతాయని నిర్ధారిస్తూ, పేర్కొన్న నిత్యకృత్యాలకు ఎంపికలు మరియు POST పద్ధతులు రెండింటినీ పద్ధతి రూట్ చేస్తుంది. అనుకూల ప్రతిస్పందనలు ఉపయోగించి నిర్వచించబడ్డాయి app.response_class() పద్ధతి, ఇందులో సంబంధిత CORS హెడర్‌లు ఉంటాయి. POST పద్ధతి, Node.js ఉదాహరణ వలె, DynamoDB పట్టికను స్కాన్ చేయడానికి పైథాన్ (boto3) కోసం AWS SDKని ఉపయోగిస్తుంది. ఈ మాడ్యులారిటీ డెవలపర్‌లు జావాస్క్రిప్ట్ లేదా పైథాన్‌ను ఇష్టపడుతున్నారా అనే దాని ఆధారంగా కేవలం బ్యాకెండ్‌ను మార్చడానికి అనుమతిస్తుంది.

చివరగా, SAM టెంప్లేట్ సెటప్ AWS API గేట్‌వే POST మరియు OPTIONS ప్రశ్నలను స్వీకరించడానికి తగిన విధంగా సెటప్ చేయబడిందని నిర్ధారిస్తుంది. ది పాస్త్రూ బిహేవియర్ అట్రిబ్యూట్ "WHEN_NO_MATCH"కి సెట్ చేయబడింది, ఇది ముందుగా నిర్ణయించిన టెంప్లేట్‌తో సరిపోలని అభ్యర్థనలను నిర్వహించడానికి API గేట్‌వేని అనుమతిస్తుంది. మాక్ ఇంటిగ్రేషన్‌లతో పని చేస్తున్నప్పుడు ఇది ఉపయోగకరంగా ఉంటుంది, ఎందుకంటే ఇది నిజంగా బ్యాకెండ్ లాంబ్డాను అమలు చేయకుండానే 200 స్థితి కోడ్‌ను అందించడానికి సిస్టమ్‌ను అనుమతిస్తుంది. ది ఇంటిగ్రేషన్ స్పందనలు మరియు మెథడ్ రెస్పాన్స్ విభాగాలు OPTIONS పద్ధతి క్లయింట్‌కు సరైన CORS కాన్ఫిగరేషన్‌ను పంపుతుందని నిర్ధారించే శీర్షికలు మరియు ప్రతిస్పందన పారామితులను పేర్కొంటాయి. స్థానిక SAM పరీక్షల సమయంలో "403 ఫర్బిడెన్" సమస్యను నివారించడానికి ఈ పద్ధతి చాలా కీలకం.

స్థానిక SAM ఆహ్వానం కోసం AWS API గేట్‌వేలో 403 ఎర్రర్‌లను పరిష్కరించడం.

పరిష్కారం 1: సమర్థవంతమైన CORS మరియు OPTIONS హ్యాండ్లింగ్‌తో Express.js మరియు AWS SDKని ఉపయోగించి Node.js బ్యాకెండ్.

// Import required modules
const express = require('express');
const AWS = require('aws-sdk');
const cors = require('cors');
const app = express();
app.use(cors());
// Middleware for JSON request parsing
app.use(express.json());
// CORS preflight response handling
app.options('/scanRecords', (req, res) => {
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
  res.status(200).send();
});
// Main POST method for scanRecords
app.post('/scanRecords', async (req, res) => {
  const dynamoDB = new AWS.DynamoDB.DocumentClient();
  try {
    const params = { TableName: 'RecordsTable' };
    const data = await dynamoDB.scan(params).promise();
    res.status(200).json(data);
  } catch (err) {
    res.status(500).send('Error fetching records');
  }
});
// Start the Express server on PORT 3000
app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

AWS SAM లోకల్‌లో "తప్పిపోయిన ప్రమాణీకరణ టోకెన్"ని పరిష్కరిస్తోంది

పరిష్కారం 2: ఫ్లాస్క్‌తో కూడిన పైథాన్ బ్యాకెండ్, స్థానిక SAM మరియు API గేట్‌వేతో కాన్ఫిగర్ చేయబడింది

from flask import Flask, jsonify, request
import boto3
app = Flask(__name__)
# CORS headers for OPTIONS requests
@app.route('/scanRecords', methods=['OPTIONS'])
def options_method():
    response = app.response_class(status=200)
    response.headers['Access-Control-Allow-Origin'] = '*'
    response.headers['Access-Control-Allow-Methods'] = 'POST, OPTIONS'
    response.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization'
    return response
# POST method to scan records from DynamoDB
@app.route('/scanRecords', methods=['POST'])
def scan_records():
    dynamodb = boto3.resource('dynamodb')
    table = dynamodb.Table('RecordsTable')
    try:
        response = table.scan()
        return jsonify(response['Items']), 200
    except Exception as e:
        return str(e), 500
# Run the Flask app on port 3000
if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=3000)

SAMతో AWS API గేట్‌వే స్థానిక ఆహ్వానాన్ని పరీక్షిస్తోంది

పరిష్కారం 3: OPTIONS అభ్యర్థనలను నిర్వహించడానికి మరియు 403 లోపాలను నివారించడానికి SAM టెంప్లేట్‌ను కాన్ఫిగర్ చేయండి.

Resources:
  scanRecords:
    Type: AWS::Serverless::Function
    Properties:
      Handler: dist/dynamo/CRUD.scanRecords
      CodeUri: ./backend
      Policies:
        - AmazonDynamoDBFullAccess
        - CloudWatchLogsFullAccess
      Events:
        ApiEvent:
          Type: Api
          Properties:
            Path: /scanRecords
            Method: post
  scanRecordsOptionsMethod:
    Type: AWS::ApiGateway::Method
    Properties:
      AuthorizationType: NONE
      HttpMethod: OPTIONS
      ResourceId: !Ref scanRecordsResource
      RestApiId: !Ref apiGatewayRestApi
      Integration:
        Type: MOCK
        IntegrationResponses:
          - StatusCode: 200
            ResponseParameters:
              method.response.header.Access-Control-Allow-Headers: "'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token'"
              method.response.header.Access-Control-Allow-Methods: "'POST,OPTIONS'"
              method.response.header.Access-Control-Allow-Origin: "'*'"

AWS API గేట్‌వే లోకల్ 403 ఎర్రర్‌లను పరిష్కరించడం

SAM లోకల్ ఇన్‌వోక్ సమయంలో 403 ఎర్రర్‌ను చూసినప్పుడు API గేట్‌వేలో CORS (క్రాస్-ఆరిజిన్ రిసోర్స్ షేరింగ్) విధానాలు ఎలా అమలు చేయబడతాయో అర్థం చేసుకోవడం చాలా ముఖ్యం. మీ విస్తరణ క్లౌడ్‌లో CORSని సముచితంగా నిర్వహించవచ్చు, స్థానిక ఆహ్వానాన్ని ఉపయోగించడం AWS SAM కొన్నిసార్లు OPTIONS పద్ధతి ఎలా నిర్వహించబడుతుందో మధ్య అననుకూలతలకు దారితీయవచ్చు. ఎందుకంటే స్థానిక పరిసరాలు ఎల్లప్పుడూ అన్ని సెటప్‌లను ఖచ్చితంగా నకిలీ చేయకపోవచ్చు మరియు ప్రామాణీకరణ ఇబ్బందులను నివారించడానికి OPTIONS మెకానిజం సరిగ్గా ఏకీకృతం చేయబడాలి.

మరొక ముఖ్య లక్షణం ఏమిటంటే, 403 లోపం తరచుగా తప్పిపోయిన లేదా తప్పుగా కాన్ఫిగర్ చేయబడిన API గేట్‌వే అనుమతులతో అనుబంధించబడుతుంది. స్థానిక అభివృద్ధి సమయంలో, మీ SAM టెంప్లేట్ సముచితంగా నిర్వచించబడిందని నిర్ధారించుకోవడం చాలా ముఖ్యం అధికార రకం OPTIONS అభ్యర్థనల కోసం "NONE" వలె మరియు సంబంధిత అనుమతులు లాంబ్డా ఫంక్షన్ సరిగ్గా ఏర్పాటు చేయబడింది. లేకపోతే, అభ్యర్థన "మిస్సింగ్ అథెంటికేషన్ టోకెన్" సందేశాన్ని అందిస్తుంది, ఇది సిస్టమ్ పేర్కొనబడని ప్రామాణీకరణ మెకానిజంను ఆశించిందని సూచిస్తుంది.

చివరగా, మాక్ ఇంటిగ్రేషన్‌లను నిర్వహించడం అనేది OPTIONS పద్ధతికి లాంబ్డా ఫంక్షన్‌ను కాల్ చేయవలసిన అవసరాన్ని నివారించడానికి సమర్థవంతమైన సాంకేతికత. సృష్టించు a MOCK ఏకీకరణ మీ API గేట్‌వేలోని ప్రతిస్పందన పారామితులతో, OPTIONS పద్ధతి అవసరమైన CORS హెడర్‌లతో డిఫాల్ట్ 200 ప్రతిస్పందనను అందిస్తుంది. ఇది డెవలప్‌మెంట్ ప్రాసెస్‌ను సులభతరం చేస్తుంది మరియు 403 ఎర్రర్‌లను నివారించడంలో సహాయపడుతుంది, ఇవి తరచుగా స్థానిక మరియు అమలు చేయబడిన సెట్టింగ్‌లలో నిర్వహించని ప్రిఫ్లైట్ ప్రశ్నల వల్ల సంభవిస్తాయి.

AWS API గేట్‌వే 403 లోపాల గురించి సాధారణ ప్రశ్నలు

నేను కేవలం SAM లోకల్‌లో 403 సమస్యను ఎందుకు స్వీకరిస్తున్నాను కానీ అమలులో ఉన్నప్పుడు కాదు?
స్థానిక SAM పర్యావరణం పూర్తి API గేట్‌వే కాన్ఫిగరేషన్‌ను అనుకరించకపోవచ్చు, ప్రత్యేకించి దీని కోసం AuthorizationType మరియు CORS సెట్టింగ్‌లు. మీ స్థానిక సెటప్ OPTIONS అభ్యర్థనల కోసం నకిలీ ఇంటిగ్రేషన్‌లతో సహా అమలు చేయబడిన సెట్టింగ్‌లతో సరిపోలుతుందని నిర్ధారించుకోండి.
"మిస్సింగ్ అథెంటికేషన్ టోకెన్" ఎర్రర్ అంటే ఏమిటి?
ఈ లోపం API గేట్‌వేకి ఒక ప్రామాణీకరణ టోకెన్‌ని కోరుకుంటున్నట్లు సూచిస్తుంది, అది ఇవ్వబడలేదు. OPTIONS అభ్యర్థనల కోసం, దాన్ని నిర్ధారించుకోండి AuthorizationType: NONE మీ SAM టెంప్లేట్‌లో సరిగ్గా కాన్ఫిగర్ చేయబడింది.
AWS API గేట్‌వేలో నేను CORS ప్రీఫ్లైట్ అభ్యర్థనలను ఎలా నిర్వహించగలను?
CORSని నిర్వహించడానికి, మీ గురించి నిర్ధారించుకోండి OPTIONS వంటి సంబంధిత ప్రతిస్పందన హెడర్‌లతో పద్ధతి తగిన విధంగా సెట్ చేయబడింది Access-Control-Allow-Origin మరియు Access-Control-Allow-Methods.
నేను AWS SAMతో స్థానికంగా CORSని పరీక్షించవచ్చా?
అవును, మీరు CORSని స్థానికంగా పరీక్షించవచ్చు, కానీ మీది అని నిర్ధారించుకోండి app.options() పద్ధతి లేదా సమానమైన API గేట్‌వే కాన్ఫిగరేషన్ ప్రీఫ్లైట్ OPTIONS అభ్యర్థన కోసం సరైన శీర్షికలను అందిస్తుంది.
AWS API గేట్‌వేలో మాక్ ఇంటిగ్రేషన్ అంటే ఏమిటి?
ఎ MOCK integration బ్యాకెండ్ లాంబ్డా ఫంక్షన్‌ని ఉపయోగించకుండా API గేట్‌వే నుండి స్టాటిక్ ప్రతిస్పందనలను అందించడానికి మిమ్మల్ని అనుమతిస్తుంది, OPTIONS అభ్యర్థనల కోసం CORS నిర్వహణను సులభతరం చేస్తుంది.

AWS API గేట్‌వే 403 లోపాలను పరిష్కరించడంపై తుది ఆలోచనలు

స్థానిక SAM పరిసరాలలో OPTIONS అభ్యర్థనల కోసం 403 లోపాలను పరిష్కరించడానికి, మీ SAM టెంప్లేట్‌లు మరియు అనుమతులు సరిగ్గా కాన్ఫిగర్ చేయబడ్డాయి. మీ స్థానిక వాతావరణాన్ని మీరు అమలు చేసిన AWS కాన్ఫిగరేషన్‌కు వీలైనంత వరకు సరిపోల్చడం చాలా కీలకం.

మిస్సింగ్ టోకెన్ సమస్యలను నివారించడానికి, ఆథరైజేషన్ టైప్‌ని "NONE"కి మార్చండి మరియు ప్రీఫ్లైట్ CORS ప్రశ్నల కోసం నకిలీ ఇంటిగ్రేషన్‌లను ఉపయోగించండి. ఈ సెట్టింగ్‌ల ఆందోళనలను పరిష్కరించడం వలన స్థానిక అభివృద్ధి మరియు సరైన API గేట్‌వే ప్రవర్తన సాఫీగా ఉంటుంది.

AWS API గేట్‌వే 403 లోపాల కోసం ఉపయోగకరమైన మూలాలు మరియు సూచనలు

CORS ప్రశ్నలను నిర్వహించడంపై దృష్టి సారించి AWS SAM CLI మరియు API గేట్‌వే స్థానిక అభివృద్ధిపై విస్తరిస్తుంది. అధికారిక AWS డాక్యుమెంటేషన్ వివరణాత్మక అంతర్దృష్టులు మరియు ఉదాహరణలను అందిస్తుంది. సందర్శించండి: AWS SAM CLI డాక్యుమెంటేషన్.
API గేట్‌వే సమస్యల కోసం 403 నిషేధిత లోపాలు మరియు తప్పిపోయిన ప్రమాణీకరణ టోకెన్‌ల వంటి వివరణాత్మక ట్రబుల్షూటింగ్ సమాచారాన్ని అందిస్తుంది. చూడండి: .AWS API గేట్‌వే లోపం నిర్వహణ.
API గేట్‌వే మరియు లాంబ్డా ఫంక్షన్‌లలో CORSని కాన్ఫిగర్ చేయడానికి పూర్తి గైడ్. CORS సమస్యలు స్థానిక పరీక్ష సమయంలో 403 లోపాల యొక్క సాధారణ మూలం. మరింత సమాచారం ఇక్కడ: AWS నాలెడ్జ్ సెంటర్.

AWS API గేట్‌వే: SAM స్థానిక ఆహ్వానం సమయంలో OPTIONS అభ్యర్థనలపై 403 లోపాలను పరిష్కరిస్తోంది