Comment implémenter une passerelle API simple dans Golang

Ce qui suit est fourni par le GolangTutoriel colonne Laissez-moi vous présenter comment implémenter une passerelle API simple dans Golang. J'espère que cela sera utile aux amis dans le besoin !

Dans un projet récent, une architecture de microservices-go-kit a été utilisée pour le développement back-end. Dans le style d'architecture des microservices, une grande application est divisée en plusieurs petits systèmes de services. Ces petits systèmes peuvent former leurs propres systèmes, ce qui signifie que ces petits systèmes peuvent avoir leurs propres bases de données, frameworks et même langages. API Gateway (API Gataway). En fait, il existe de nombreux frameworks d'implémentation prêts à l'emploi sur Internet, mais les exigences de ce projet sont relativement simples, nous utiliserons donc Golang pour l'implémenter nous-mêmes. .

Mise en œuvre

La passerelle API est un serveur et la seule entrée du système. Du point de vue de la conception orientée objet, il est similaire au motif de façade. La passerelle API encapsule l'architecture interne du système et fournit une API personnalisée pour chaque client. Il peut également avoir d'autres responsabilités telles que l'authentification, la surveillance, l'équilibrage de charge, la mise en cache, le partage et la gestion des demandes et la gestion des réponses statiques.

Il existe de nombreuses technologies utilisées pour mettre en œuvre des passerelles API, qui sont grossièrement divisées dans les catégories suivantes :

• Proxy inverse universel : Nginx, Haproxy,…
• Cadre de programmation réseau : Netty, Servlet,…
• Cadre de passerelle API : Spring Cloud Gateway, Zuul, Zuul2,…

La fonction la plus basique de la passerelle API est le proxy inverse. Il existe de nombreuses façons de l'implémenter. Cet article implémentera un proxy inverse simple basé sur le type net/http/httputil dans le package de la bibliothèque standard ReverseProxy. La mise en œuvre du proxy inverse implique principalement func NewSingleHostReverseProxy(target *url.URL) *ReverseProxy et type ReverseProxy.

func NewSingleHostReverseProxy(target *url.URL) *ReverseProxy

rrree

NewSingleHostReverseProxy renvoie un nouveau ReverseProxy qui achemine les requêtes URLs vers les targe, scheme, host spécifiés de base path. Le type

// NewSingleHostReverseProxy returns a new ReverseProxy that routes// URLs to the scheme, host, and base path provided in target. If the// target's path is "/base" and the incoming request was for "/dir",// the target request will be for /base/dir.// NewSingleHostReverseProxy does not rewrite the Host header.// To rewrite Host headers, use ReverseProxy directly with a custom// Director policy.func NewSingleHostReverseProxy(target *url.URL) *ReverseProxy {
    targetQuery := target.RawQuery
    director := func(req *http.Request) {
        req.URL.Scheme = target.Scheme
        req.URL.Host = target.Host
        req.URL.Path = singleJoiningSlash(target.Path, req.URL.Path)
        if targetQuery == "" || req.URL.RawQuery == "" {
            req.URL.RawQuery = targetQuery + req.URL.RawQuery       } else {
            req.URL.RawQuery = targetQuery + "&" + req.URL.RawQuery     }
        if _, ok := req.Header["User-Agent"]; !ok {
            // explicitly disable User-Agent so it's not set to default value
            req.Header.Set("User-Agent", "")
        }
    }
    return &ReverseProxy{Director: director}}

ReverseProxy a deux attributs importants, à savoir Director et ModifyResponse. Les deux attributs sont des types de fonction. Lors de la réception d'une demande client, la fonction ServeHTTP appelle d'abord la fonction Director. pour modifier le corps de la requête reçue, par exemple en modifiant l'adresse cible de la requête, les en-têtes de la requête, etc. ; puis utilisez le corps de la requête modifié pour lancer une nouvelle requête. Après avoir reçu la réponse, appelez la fonction ModifyResponse pour modifier la réponse. Enfin, le corps de la réponse modifié est copié et répondu au client, réalisant ainsi l'ensemble du processus de proxy inverse.

Dans NewSingleHostReverseProxy, le code source a analysé le URLs entrant et terminé la modification de Director Il suffit d'appeler la fonction NewSingleHostReverseProxy et de transmettre l'URL du serveur cible. Un simple proxy inverse est terminé.

Code

L'exemple de code implique uniquement les modules user et auth du microservice Vous pouvez modifier certaines parties en fonction des besoins réels

// ReverseProxy is an HTTP Handler that takes an incoming request and// sends it to another server, proxying the response back to the// client.type ReverseProxy struct {
    // Director must be a function which modifies
    // the request into a new request to be sent
    // using Transport. Its response is then copied
    // back to the original client unmodified.
    // Director must not access the provided Request
    // after returning.
    Director func(*http.Request)

    Transport http.RoundTripper

    FlushInterval time.Duration

    ErrorLog *log.Logger

    BufferPool BufferPool   // ModifyResponse is an optional function that modifies the
    // Response from the backend. It is called if the backend
    // returns a response at all, with any HTTP status code.
    // If the backend is unreachable, the optional ErrorHandler is
    // called without any call to ModifyResponse.
    //
    // If ModifyResponse returns an error, ErrorHandler is called
    // with its error value. If ErrorHandler is nil, its default
    // implementation is used.
    ModifyResponse func(*http.Response) error

    ErrorHandler func(http.ResponseWriter, *http.Request, error)}

.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!