Golang reverse proxy avec plusieurs applications

Question

Je veux servir deux ou plusieurs applications web s'exécutant dans une machine virtuelle (les différents ports et de certains temps dans différents répertoires sous le même port) de la machine hôte et parce que j'ai besoin de l'utilisateur d'être connecté avant de pouvoir accéder à ces applications, je ne peux pas utiliser un proxy statique comme Nginx ou Apache.

Donc, voici ma situation :

192.168.1.1 :est l'ip de l'hôte
192.168.1.2 :est l'ip de la VM

L'intérieur de la VM, j'ai ceci :

192.168.1.2/owncloud :owncloud adresse
192.168.1.2:8080 :une autre application
192.168.1.2:8888 :3e app

Je veux avoir ceci :

192.168.1.1/app1 --> 192.168.1.2/owncloud
192.168.1.1/app2 --> 192.168.1.2:8080
192.168.1.1/app2 --> 192.168.1.2:8888

J'ai essayé d'utiliser golang httputil.ReverseProxy pour atteindre cette gamme, mais avec pas beaucoup de succès:mon code est basé sur ce travail : gist

package main

import(
    "log"
    "net/url"
    "net/http"
    "net/http/httputil"
)

func main() {
    remote, err := url.Parse("http://192.168.1.2:8080")
    if err != nil {
            panic(err)
    }

    proxy := httputil.NewSingleHostReverseProxy(remote)
    http.HandleFunc("/app2", handler(proxy))
    err = http.ListenAndServe(":80", nil)
    if err != nil {
            panic(err)
    }
}

func handler(p *httputil.ReverseProxy) func(http.ResponseWriter, *http.Request) {
    return func(w http.ResponseWriter, r *http.Request) {
        log.Println(r.URL)
        r.URL.Path = "/"                
            p.ServeHTTP(w, r)
    }
}

Edit :
J'ai changé la vm adresse ip:192.168.1.2 pas 192.168.1.1

Answer 1

Vous feriez mieux de faire cela par nom d'hôte plutôt que par l'URL. par exemple

owncloud.domain.com -> IP 192.168.1.2,
app2.domain.com     -> IP 192.168.1.3

Si vous n'étiez pas déjà au courant, le nom d'hôte est juste un en-tête de requête HTTP (hôte: domain.com), vous pouvez donc avoir plusieurs noms d'hôte par IP (Apache appelle ces "hôtes virtuels nommés").

L'avantage de l'utilisation des noms d'hôte plutôt que de l'URL est que l'application Web à l'autre extrémité n'est pas au courant des URL que vous préfixez encore pour les honorer, de sorte que vous puissiez rencontrer des problèmes avec les URL écrites par le L'application Web ne fonctionne pas contre les URL attendues par le proxy inverse. Lorsque les proxy basés sur l'hôte-nom doivent fonctionner car la plupart des applications Web ne réécrivent pas le nom de domaine. (Il s'agit là d'une énorme généralisation, certaines applications Web vous permettront d'ajouter une adresse proxy - mais vous rencontrerez généralement moins de problèmes avec les noms d'hôte)

Le problème le plus important consiste à configurer des sous-domaines sur votre serveur de noms. Je suppose que vos fournisseurs d'enregistrement / DNS vous permettent de créer des sous-domaines gratuits (la plupart de la plupart de doivent), mais si vous utilisez quelque chose comme un DNS dynamique avec cela fonctionnant de votre connexion à large bande à domicile, vous rencontrez des problèmes et aurez Pour acheter votre propre nom de domaine avec les sous-domaines CNAME »à votre adresse DNS dynamique (ou utilisez un compte payant avec vos fournisseurs DNS dynamiques s'ils offrent des sous-domaines).

Une dernière chose, si vous regardez dans votre propriétaire, vous voudrez peut-être également jeter un coup d'œil à Pydio (officiellement Ajaxexplore). Ils ont tous deux des forces et des faiblesses différentes, mais dans mon opinion personnelle, Pydio est un meilleur produit.

Answer 2

Faire une carte comme ça

hostTarget = map[string]string{
    "app1.domain.com": "http://192.168.1.2/owncloud",
    "app2.domain.com": "http://192.168.1.2:8080",
    "app3.domain.com": "http://192.168.1.2:8888",
}

Utilisation httputil.ReverseProxy construire votre gestionnaire

type baseHandle struct{}

func (h *baseHandle) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    host := r.Host

    if target, ok := hostTarget[host]; ok {
        remoteUrl, err := url.Parse(target)
        if err != nil {
            log.Println("target parse fail:", err)
            return
        }

        proxy := httputil.NewSingleHostReverseProxy(remoteUrl)
        proxy.ServeHTTP(w, r)
        return
    }
    w.Write([]byte("403: Host forbidden " + host))
}

ListenAndServe

h := &baseHandle{}
http.Handle("/", h)

server := &http.Server{
    Addr:    ":8080",
    Handler: h,
}
log.Fatal(server.ListenAndServe())

Vous pouvez en cache httputil.ReverseProxy dans la carte du monde le tout dans un fichier ci-dessus.

Voici une SSLDocker projet vu à correspondre avec vous.

Answer 3

Votre passage à la mauvaise adresse IP du proxy inverse.Devrait être votre VM 192.168.1.2.

Dans le docs

NewSingleHostReverseProxy returns a new ReverseProxy that rewrites URLs to the scheme, host, and base path provided in target.