Usando Golang para lidar com códigos de erro de API do AWS SDK para respostas da API REST

Tratamento de códigos de erro HTTP de solicitações do AWS SDK em Golang

Implementação de scripts modulares de back-end Golang para gerenciar erros HTTP do AWS SDK

// 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",
    }
}

Convertendo códigos de erro da AWS com declarações de tipo em Golang

Usando asserções de tipo para tratamento aprimorado de erros em Golang

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"}
}

Testes de unidade para funções de conversão de erros de API da AWS

Testando funções para validar respostas de código de status HTTP para diferentes erros de API da AWS

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)
    }
}

Perguntas comuns sobre tratamento de erros do AWS SDK em Golang

1. Como posso recuperar códigos de status HTTP de erros do AWS SDK?
2. No Golang, os erros do AWS SDK geralmente são retornados como strings. Usando um mapeamento personalizado ou uma instrução switch, você pode combinar códigos de erro com códigos de status HTTP relevantes.
3. Está usando switch declarações a melhor abordagem para códigos de erro da AWS?
4. Embora você possa usar um switch declaração, criar uma tabela de mapeamento é geralmente mais eficiente e fácil de manter, especialmente à medida que o número de códigos de erro aumenta.
5. Qual é o propósito errors.As no tratamento de erros da AWS?
6. O errors.As função permite verificar se um erro é de um tipo específico, como smithy.APIError. Isso é essencial para identificar com precisão os erros da AWS no Golang.
7. Por que usar uma estrutura de erro personalizada como UsecaseError?
8. Uma estrutura de erro personalizada permite formatar respostas de erro de maneira compatível com JSON, facilitando a análise e a compreensão dos erros pelos aplicativos clientes.
9. Como posso testar o código de tratamento de erros do AWS SDK de maneira eficaz?
10. O uso de erros simulados em testes de unidade permite simular erros do SDK da AWS sem chamar a AWS diretamente, ajudando a validar como seu código responde a cada tipo de erro.
11. Qual pacote fornece as constantes de status HTTP em Golang?
12. O net/http O pacote em Golang oferece constantes para códigos de status HTTP, facilitando a atribuição de respostas claras e padrão aos clientes da API.
13. É possível capturar todos os erros da AWS com uma única função?
14. Sim, usando uma combinação de errors.As e uma tabela ou switch de mapeamento, você pode capturar e tratar com eficiência vários erros do AWS SDK de maneira unificada.
15. Uma tabela de mapeamento pode tornar meu aplicativo mais lento?
16. Uma pesquisa na tabela de mapeamento geralmente é mais rápida do que múltiplas instruções if-else ou switch. É uma maneira eficiente de lidar com muitos códigos de erro e é altamente recomendada para mapeamento de erros.
17. Por que é necessário converter códigos de erro do AWS SDK em códigos de status HTTP?
18. O mapeamento de códigos de erro da AWS para status HTTP permite que sua API retorne respostas padrão e consistentes, o que ajuda os aplicativos clientes a compreender rapidamente a natureza do erro.
19. Como posso depurar erros do AWS SDK que não correspondem a nenhum código de erro específico?
20. Para erros inesperados, você pode retornar um status padrão como 500 (Erro interno do servidor) e registrar os detalhes do erro para revisão posterior usando slog.Error.

Soluções simplificadas para lidar com códigos de erro do AWS SDK

A criação de um mecanismo robusto de tratamento de erros para solicitações do AWS SDK em uma API Golang pode economizar um tempo significativo de depuração e melhorar a experiência do desenvolvedor. Por meio de asserções de tipo, mapeamentos de erros e estruturas de erros personalizadas, os desenvolvedores podem transformar efetivamente respostas de erro brutas da AWS em códigos HTTP legíveis e acionáveis. Essa configuração é particularmente útil ao trabalhar com erros de autenticação no AWS Cognito.

Ao integrar testes unitários com erros simulados, o tratamento de erros torna-se confiável em diferentes cenários de erro. Essas técnicas não apenas melhoram a qualidade da API, mas também garantem que ela permaneça adaptável e passível de manutenção à medida que os requisitos aumentam. A implementação dessas estratégias mantém a API responsiva e pronta para uso em produção. 🛠️