Golang proxy reverso com vários apps

Question

Eu quero servir a dois ou mais aplicativos da web em execução em uma máquina virtual (portas diferentes e algum tempo no diretório diferente sob a mesma porta) do host da máquina e porque eu preciso que o usuário esteja conectado antes de ele pode acessar os aplicativos que eu não posso usar um proxy estático como Nginx ou Apache.

Então aqui está a minha situação :

192.168.1.1 :é o ip do host
192.168.1.2 :é o VM ip

Dentro da VM eu tenho este :

192.168.1.2/owncloud :owncloud endereço
192.168.1.2:8080 :um outro aplicativo
192.168.1.2:8888 :3º app

Eu quero ter isso :

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

Eu tentei usar golang httputil.ReverseProxy para alcançar este encaminhamento, mas sem muito sucesso:meu código é baseado neste trabalho : essência

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

Editar :
Eu mudei o vm endereço ip:192.168.1.2 não 192.168.1.1

Answer 1

O melhor é fazer isso pelo nome, ao invés de incluir URL.por exemplo,

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

Se você já não estavam cientes, o nome de host é apenas um cabeçalho de solicitação HTTP (Host:domain.com), de modo que você pode ter vários nomes de host por IP (Apache chama isso de "chamado de virtual hosts").

A vantagem de usar nomes de host em vez de URLs é que o aplicativo web, no outro extremo, não está ciente de URLs que você está prefixo ainda precisa respeitá-los, de modo que você pode executar em problemas com as URLs que estão sendo escrito por web app não funciona contra as URLs que estão sendo esperados para o proxy reverso.Onde, como nome de host com base proxies deve funcionar como a maioria dos web apps não vai reescrever o nome de domínio.(esta é uma grande generalização, porém, alguns aplicativos de web permitirá que você adicionar um endereço de proxy - mas, geralmente, você vai correr em menos problemas com nomes de host)

O maior problema é ter que configurar sub-domínios em seu servidor de nomes.Eu estou assumindo que o seu registo / provedores de DNS permite que você crie subdomínios gratuitos (mais deveria), mas se você estiver usando algo como o DNS dinâmico com esta funcionando fora de sua casa conexão de banda larga, em seguida, você irá se deparar com problemas e vai ter que comprar o seu próprio nome de domínio com o subdomínios CNAME ed para o seu endereço de DNS dinâmico (ou utilize uma conta paga com o seu DNS dinâmico fornecedores se eles oferecem subdomínios).

Uma última coisa, se você está olhando para owncloud, em seguida, você também pode querer dar uma olhada em Pydio (formalmente AjaxExplore) bem.Ambos têm diferentes pontos fortes e fracos, mas na minha opinião pessoal Pydio é um produto melhor.

Answer 2

Fazer um mapa de como

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

Utilização httputil.ReverseProxy construir o seu processador

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

Você pode armazenados em cache httputil.ReverseProxy no mapa global, tudo em ficheiro acima.

Aqui é um SSLDocker projeto de visto para corresponder com você.

Answer 3

Sua passagem IP incorreto para o proxy reverso.Deve ser a sua VM 192.168.1.2.

No docs

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