REST API பதில்களுக்கான AWS SDK API பிழைக் குறியீடுகளைக் கையாள Golang ஐப் பயன்படுத்துதல்

கோலாங்கில் உள்ள AWS SDK இலிருந்து டிகோடிங் பிழைக் குறியீடுகள்

கோலாங்கில் AWS SDK உடன் பணிபுரிவது சிக்கலானதாக உணரலாம், குறிப்பாக REST API இல் HTTP பிழைக் குறியீடுகளை கையாளும் போது. பயனர் அங்கீகாரத்திற்காக Cognito போன்ற AWS சேவைகளுடன் நீங்கள் பணிபுரிந்திருந்தால், SDK வழங்கிய API பிழைகளை விளக்குவதில் நீங்கள் சவால்களை எதிர்கொண்டிருக்கலாம். 🌐

இந்த பிழைகள் பொதுவாக பிழைத்திருத்தம் மற்றும் கிளையன்ட் பக்க கையாளுதலுக்கு முக்கியமான தகவல்களை உள்ளடக்கியது, ஆனால் JSON-அடிப்படையிலான பதிலுக்கு பயனுள்ள ஒன்றாக அவற்றைப் பாகுபடுத்துவது நேரடியானதல்ல. தெளிவான HTTP நிலைக் குறியீட்டிற்குப் பதிலாக, கோலாங்கில் உள்ள AWS SDK பிழைகள் பெரும்பாலும் குறியீடுகளை சரங்களாக வழங்குகின்றன, இதனால் டெவலப்பர்கள் சரியான முழு எண் பிரதிநிதித்துவத்தைப் பற்றி யூகிக்கிறார்கள்.

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

இந்த வழிகாட்டியில், இந்த AWS SDK பிழைகளை கட்டமைக்கப்பட்ட JSON பதில்களுக்குப் பயன்படுத்தக்கூடிய HTTP பிழைக் குறியீடுகளாக மாற்றுவதற்கான ஒரு முறையை நாங்கள் ஆராய்வோம், இது கடினமான தீர்வுகளிலிருந்து உங்களைக் காப்பாற்றுகிறது. இந்த பிழைகளை டீகோட் செய்து கையாள்வதற்கான மிகவும் நெறிப்படுத்தப்பட்ட அணுகுமுறையில் மூழ்குவோம்! 🚀

கோலாங்கில் AWS SDK கோரிக்கைகளுக்கான வலுவான பிழை கையாளுதல்

மேலே உள்ள எடுத்துக்காட்டு ஸ்கிரிப்ட்கள், Golang REST API ஐ உருவாக்கும் போது AWS SDK இலிருந்து வரும் பிழைகளை எவ்வாறு கையாள்வது மற்றும் விளக்குவது என்பதில் கவனம் செலுத்துகிறது. குறிப்பாக, இந்த ஸ்கிரிப்ட்கள் AWS API பிழைகளைப் படம்பிடித்து, JSON பதில்களில் பயன்படுத்தக்கூடிய வடிவத்திற்கு மாற்றுவதையும், அவற்றைப் பொருத்தமான HTTP நிலைக் குறியீடுகளுக்கு வரைபடமாக்குவதையும் நோக்கமாகக் கொண்டுள்ளன. பயனர்களை அங்கீகரிப்பது போன்ற பணிகளுக்கு நீங்கள் AWS Cognito ஐ அழைக்கும் போது, ​​SDK ஆனது AWS க்கு குறிப்பிட்ட பிழைகளை வழங்கக்கூடும், ஆனால் நேரடியாகப் பயன்படுத்தக்கூடிய HTTP நிலைக் குறியீடு இல்லை. இயல்பாக, இந்தப் பிழைகள் சரங்களாக வருகின்றன, இவை நேரடி மேப்பிங் இல்லாமல் அலசுவது சவாலானது, குறிப்பாக உங்களுக்கு கட்டமைக்கப்பட்ட பிழை பதில் தேவைப்படும்போது.

இங்குள்ள மைய தீர்வுகளில் ஒன்று a ஐப் பயன்படுத்துவது மேப்பிங் அட்டவணை, இது குறிப்பிட்ட AWS பிழைக் குறியீடுகளை HTTP நிலைக் குறியீடுகளுடன் எளிதாக நிர்வகிக்கவும் மீண்டும் பயன்படுத்தவும் பொருந்தும். எடுத்துக்காட்டாக, AWS SDK இல் உள்ள “UserNotFoundException” பிழையானது HTTP 404 காணப்படாத பதிலுக்கு மொழிபெயர்க்கப்பட்டது. இந்த அணுகுமுறை டெவலப்பர் அதிக எண்ணிக்கையிலான நிபந்தனை சரிபார்ப்புகளைத் தவிர்க்க அனுமதிக்கிறது, இதன் விளைவாக தூய்மையான குறியீடு புதுப்பிக்க எளிதானது. எடுத்துக்காட்டாக, ConvertAWSAPIError செயல்பாடு ஒரு பிழையை எடுத்துக்கொள்கிறது, அது APIError வகையைச் சேர்ந்ததா எனச் சரிபார்த்து, அப்படியானால், மேப் செய்யப்பட்ட HTTP குறியீடு மற்றும் வடிவமைக்கப்பட்ட பிழைச் செய்தியை வழங்கும். 🛠️

இந்த ஸ்கிரிப்ட்களின் மற்றொரு இன்றியமையாத பகுதியாக தனிப்பயன் பிழை வகை, UsecaseError ஆகும், இது JSON இல் பிழை பதில்களை தரப்படுத்த வடிவமைக்கப்பட்டுள்ளது. இந்த வகை HTTP நிலைக்கான குறியீடு புலத்தையும் விரிவான பிழை செய்திக்கான செய்தி புலத்தையும் உள்ளடக்கியது. இந்த தனிப்பயன் பிழை வகையைப் பயன்படுத்துவதன் மூலம், API பதில்கள் சீரானதாகவும், பயனர்களுக்கு ஏற்றதாகவும் இருக்கும், இது பிழைத்திருத்தம் மற்றும் கிளையன்ட் பக்க பிழை கையாளுதலுக்கு முக்கியமானது. UsecaseError struct ஆனது Error() செயல்பாட்டின் மூலம் பிழை இடைமுகத்தையும் செயல்படுத்துகிறது, இது Go இல் ஒரு பிழை பொருளாக மாறி மாறி பயன்படுத்த அனுமதிக்கிறது, இது நிலையான பிழை வகைகளை எதிர்பார்க்கும் செயல்பாடுகளில் பொருந்தக்கூடிய தன்மையை பராமரிக்கிறது.

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

நடைமுறையில், நீங்கள் ஒரு தயாரிப்பு-தர API ஐ உருவாக்கினால், இந்த வழியில் பிழைகளைக் கையாள்வது, எதிர்பாராத சிக்கல்கள் ஒரு அர்த்தமுள்ள HTTP நிலையுடன் கட்டமைக்கப்பட்ட JSON பதில்களாகத் திரும்புவதை உறுதிசெய்கிறது, மோசமான கோரிக்கைகளுக்கு 400 அல்லது உள் பிழைகளுக்கு 500 போன்றது. ஒட்டுமொத்தமாக, இங்கு பயன்படுத்தப்படும் முறைகள் பிழை கையாளுதலை திறமையான மற்றும் மாற்றியமைக்கக்கூடியதாக ஆக்குகிறது, இது AWS Cognito இலிருந்து குறிப்பிட்ட நிகழ்வுகளை திறம்பட நிர்வகிக்க உங்களை அனுமதிக்கிறது. வகை வலியுறுத்தல்கள், பிழை மேப்பிங் மற்றும் போலி சோதனைகள் ஆகியவற்றைப் பயன்படுத்துவதன் மூலம், இந்த ஸ்கிரிப்டுகள் சிறந்த பிழைத்திருத்தத்தை செயல்படுத்துகின்றன, குறியீட்டைப் படிக்கக்கூடியதாக வைத்திருக்கின்றன மற்றும் பிழை ஏற்படக்கூடிய மீண்டும் மீண்டும் `ஸ்விட்ச்` அறிக்கைகளைத் தடுக்கின்றன. இந்த மட்டு அணுகுமுறை தொழில்முறை API வடிவமைப்பின் ஒரு மூலக்கல்லாகும்.

// Approach 1: Using a Mapping Table to Convert String Error Codes to HTTP Status Codes
package main

import (
    "errors"
    "fmt"
    "net/http"
    "github.com/aws/smithy-go"
)

// UsecaseError represents the custom error structure for JSON responses
type UsecaseError struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
}

// Error satisfies the error interface for UsecaseError
func (e *UsecaseError) Error() string {
    return fmt.Sprintf(`{"code": %d, "message": "%s"}`, e.Code, e.Message)
}

// Map of AWS error codes to HTTP status codes
var errorCodeMapping = map[string]int{
    "NotAuthorizedException": http.StatusUnauthorized,
    "UserNotFoundException": http.StatusNotFound,
    "TooManyRequestsException": http.StatusTooManyRequests,
    "InternalErrorException": http.StatusInternalServerError,
    // Add additional mappings as necessary
}

// ConvertAWSAPIError handles AWS SDK errors and returns a UsecaseError
func ConvertAWSAPIError(err error) *UsecaseError {
    var apiErr smithy.APIError
    if errors.As(err, &apiErr) {
        code, exists := errorCodeMapping[apiErr.ErrorCode()]
        if exists {
            return &UsecaseError{
                Code:    code,
                Message: apiErr.ErrorMessage(),
            }
        }
    }
    // Default error response
    return &UsecaseError{
        Code:    http.StatusInternalServerError,
        Message: "An unknown error occurred",
    }
}

package main

import (
    "errors"
    "fmt"
    "net/http"
    "github.com/aws/smithy-go"
)

// UsecaseError struct to hold HTTP code and message
type UsecaseError struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
}

func (e *UsecaseError) Error() string {
    return fmt.Sprintf(`{"code": %d, "message": "%s"}`, e.Code, e.Message)
}

// AWSAPIErrorToHTTP maps APIError codes directly to HTTP status codes using type assertions
func AWSAPIErrorToHTTP(err error) *UsecaseError {
    var apiErr smithy.APIError
    if errors.As(err, &apiErr) {
        switch apiErr.ErrorCode() {
        case "NotAuthorizedException":
            return &UsecaseError{Code: http.StatusUnauthorized, Message: apiErr.ErrorMessage()}
        case "UserNotFoundException":
            return &UsecaseError{Code: http.StatusNotFound, Message: apiErr.ErrorMessage()}
        case "TooManyRequestsException":
            return &UsecaseError{Code: http.StatusTooManyRequests, Message: apiErr.ErrorMessage()}
        default:
            return &UsecaseError{Code: http.StatusInternalServerError, Message: apiErr.ErrorMessage()}
        }
    }
    return &UsecaseError{Code: http.StatusInternalServerError, Message: "Unknown error"}
}

package main

import (
    "errors"
    "testing"
    "net/http"
)

// Mock error types for testing
type mockAPIError struct{}

func (e *mockAPIError) ErrorCode() string {
    return "UserNotFoundException"
}

func (e *mockAPIError) ErrorMessage() string {
    return "User not found"
}

func TestConvertAWSAPIError(t *testing.T) {
    mockErr := &mockAPIError{}
    err := ConvertAWSAPIError(mockErr)
    if err.Code != http.StatusNotFound {
        t.Errorf("expected %d, got %d", http.StatusNotFound, err.Code)
    }
}

கோலாங் APIகளுக்கான AWS SDK இல் மேப்பிங் நுட்பங்களில் பிழை

AWS சேவைகளை நம்பியிருக்கும் Golang இல் REST API ஐ உருவாக்கும்போது, ​​குறிப்பாக AWS Cognito ஐப் பயன்படுத்தி பயனர் அங்கீகாரத்திற்கு, பயனுள்ள பிழை கையாளுதல் அவசியம். வாடிக்கையாளர்களுக்கு துல்லியமான மற்றும் தகவலறிந்த HTTP நிலைக் குறியீடுகளை வழங்க, AWS SDK பிழைகளை சரியாகப் படம்பிடித்து விளக்குவது மிகவும் முக்கியமானது. ஒரு பொதுவான சிக்கல் என்னவென்றால், AWS SDK ஆனது HTTP-நட்பு நிலைக் குறியீடுகளுக்குப் பதிலாக சரங்களாகப் பிழைகளை வழங்குகிறது, இது API முழுவதும் தொடர்ந்து பிழைகளைக் கையாள்வது சவாலாக இருக்கும். இங்கே, வகை வலியுறுத்தல் மற்றும் பிழை மாற்றும் முறைகள் செயல்பாட்டுக்கு வருகின்றன. வகை வலியுறுத்தலைப் பயன்படுத்தி, ஒரு பிழை சில இடைமுகங்களைச் செயல்படுத்துகிறதா என்பதைச் சரிபார்க்கலாம் smithy.APIError, AWS-குறிப்பிட்ட பிழை விவரங்களைப் படம்பிடிப்பதை எளிதாக்குகிறது.

பிழைகளை நிர்வகிப்பதற்கான கூடுதல் அணுகுமுறை, உலகளாவிய மேப்பிங் அட்டவணை AWS பிழைக் குறியீடுகளை HTTP நிலைக் குறியீடுகளுக்கு உருவாக்குகிறது, இது பராமரிப்பை மேம்படுத்துகிறது. எடுத்துக்காட்டாக, "UserNotFoundException" ஐ HTTP 404 க்கு மேப்பிங் செய்வது (கண்டுபிடிக்கப்படவில்லை) பல நிபந்தனை அறிக்கைகளை கைமுறையாக எழுதாமல் பயனர் நட்பு மற்றும் தொடர்புடைய பிழைச் செய்தியை API வழங்கும் என்பதை உறுதி செய்கிறது. 🛠️ UsecaseError போன்ற தனிப்பயன் பிழை வகையுடன் இணைந்து, HTTP குறியீடு மற்றும் ஒரு செய்தி ஆகிய இரண்டிற்கான புலங்களையும் உள்ளடக்கியது, இந்த அமைவு ஒவ்வொரு பிழையும் தரப்படுத்தப்பட்ட அமைப்பு மற்றும் பயனுள்ள தகவல்களைக் கொண்டிருப்பதை உறுதி செய்கிறது. இந்த அணுகுமுறை API கிளையண்டுகளுக்கான பிழைச் செய்திகளின் வாசிப்புத்திறனை மேம்படுத்துவது மட்டுமல்லாமல் பின்தளத்தில் பிழைத்திருத்தத்தை எளிதாக்குகிறது.

இறுதியாக, போலி பிழை வகைகளுடன் அலகு சோதனைகளை நடத்துவது வளர்ச்சி சுழற்சியின் இன்றியமையாத பகுதியாகும். இந்த சோதனைகள் பல்வேறு AWS பிழை காட்சிகளை உருவகப்படுத்துகின்றன, பிழை கையாளும் குறியீடு ஒவ்வொரு பிழைக் குறியீட்டையும் சரியான HTTP நிலைக்கு மாற்றுகிறது என்பதைச் சரிபார்க்கிறது. சோதனையானது குறியீட்டின் நடத்தையை சரிபார்ப்பது மட்டுமல்லாமல், உற்பத்தியில் பிழை பதில்களின் துல்லியம் மற்றும் நிலைத்தன்மையையும் உறுதி செய்கிறது. இந்த உத்திகள் மூலம், AWS SDK பிழைகளைக் கையாள ஒரு வலுவான, பராமரிக்கக்கூடிய மற்றும் அளவிடக்கூடிய வழியை Golang API பெறுகிறது, இறுதியில் API உடன் தொடர்பு கொள்ளும் வாடிக்கையாளர்களுக்கு சிறந்த பயனர் அனுபவத்திற்கு வழிவகுக்கும்.