Faça o nginx passar o nome do host do upstream ao fazer a reversão

Eu executo vários contêineres de docker com nomes de host:

web1.local web2.local web3.local

O roteamento para estes é feito com base no nome do host pelo nginx. Eu tenho um proxy na frente desta configuração (em uma máquina diferente conectada à Internet) onde eu defino o upstream como:

    upstream main {
      server web1.local:80;
      server web2.local:80;
      server web3.local:80;
    }

E descrição real do host virtual:

    server {
      listen 80;
      server_name example.com;
      location / {
        proxy_pass http://main;
      }
    }

Agora, como os contêineres recebem o nome do host "main" em vez de "web1.local", eles não respondem corretamente à solicitação.

Pergunta: como posso dizer ao nginx para passar o nome do servidor upstream em vez do nome do grupo upstream de servidores no cabeçalho Host: ao solicitar o proxy?

Na verdade, você pode fazer isso via proxy_set_header.

Para obter mais detalhes, consulte aqui: http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_set_header ou veja um exemplo de caso de uso aqui: https://stackoverflow.com/questions/12847771/configure-nginx- com-proxy-pass

Eu incluí a abordagem dinâmica na sua configuração postada acima:

server {
  listen 80;
  server_name example.com;
  location / {
    proxy_pass       http://main;
    proxy_set_header Host            $host;
    proxy_set_header X-Forwarded-For $remote_addr;
  }
}

Aqui está um exemplo com um nome de host estático:

server {
  listen 80;
  server_name example.com;
  location / {
    proxy_pass       http://main;
    proxy_set_header Host            www.example.com;
    proxy_set_header X-Forwarded-For $remote_addr;
  }
}

Eu tive o mesmo problema e finalmente o resolvi usando dois níveis de proxy. Aqui está como você poderia fazer por sua situação (eu acho):

server {
  listen      8001 default_server;
  server_name web1.example.com;
  location / {
    proxy_pass       http://web1.local:80;
    proxy_set_header Host web1.local:80;
  }
}

server {
  listen      8002 default_server;
  server_name web2.example.com;
  location / {
    proxy_pass       http://web2.local:80;
    proxy_set_header Host web2.local:80;
  }
}

server {
  listen      8003 default_server;
  server_name web3.example.com;
  location / {
    proxy_pass       http://web3.local:80;
    proxy_set_header Host web3.local:80;
  }
}

upstream main {
  server 127.0.0.1:8001;
  server 127.0.0.1:8002;
  server 127.0.0.1:8003;
}

server {
  listen      80;
  server_name example.com;
  location / {
    proxy_pass http://main;
  }
}

Como você pode ver, o truque é criar um servidor local que responda a uma porta específica que fará proxy do servidor, reescrevendo o host correto para cada servidor. Em seguida, você pode usar esses servidores locais no seu upstream e, finalmente, usá-lo no proxy real.

Então, ao ler toda a documentação do nginx (eu realmente não consegui analisar o código do módulo upstream = (), eu vim com essa solução bastardizada. Infelizmente, essa solução não controla os hosts com falha, mas simplesmente seleciona um aleatório e redireciona a solicitação para ele. Portanto, tenho que configurar algum tipo de monitoramento para garantir que todos os back-ends estejam em execução.

server {
        listen 80;
        server_name example.com;
        resolver 127.0.0.1;

        location / {
                set $upstream "";
                rewrite_by_lua '
                        local upstreams = {
                                "http://web1.dokku.localdomain",
                                "http://web2.dokku.localdomain",
                                "http://web3.dokku.localdomain",
                                "http://web4.dokku.localdomain"
                        }
                        ngx.var.upstream = upstreams[ math.random( #upstreams ) ] 
                ';
                proxy_pass $upstream;
        }
}

Passamos no endereço upstream como um cabeçalho separado como este

server {
  listen 80;
  server_name example.com;
  location / {
    proxy_pass       http://main;
    proxy_set_header Host            $host;
    proxy_set_header X-Forwarded-For $remote_addr;
    add_header       X-Upstream      $upstream_addr;
  }
}

E se você tentasse?

server {
  listen 80;
  server_name example.com;
  location / {
    proxy_pass       http://main;
    proxy_set_header Host            $upstream_addr;
    proxy_set_header X-Forwarded-For $remote_addr;
    add_header       X-Host          $host;
  }
}

Embora o objetivo pareça lógico, o nginx não mudará o cabeçalho Host: para corresponder ao upstream . Em vez disso, trata upstreamnomes de domínio como um CNAMEno DNS - como uma maneira de acessar um endereço IP.

Os cabeçalhos da solicitação (e o corpo) são corrigidos antes da seleção do upstream. O upstream pode mudar no meio da solicitação se um determinado upstream não responder, mas a solicitação não muda.

Hmm. Eu tenho uma configuração semelhante, na qual eu simplesmente fiz

location / {
    ... 
    proxy_set_header X-Forwarded-Host $http_host;
    proxy_pass ...;
}

O uso de $http_host(o cabeçalho do host HTTP da solicitação de entrada) aqui em vez de $host(a configuração do nome do host do servidor) faz com que o mesmo cabeçalho do host passado pelo cliente seja passado para o upstream no meu teste.

Consulte também https://stackoverflow.com/questions/14352690/change-host-header-in-nginx-reverse-proxy .

Como outras pessoas já postaram usando a variável de script (como $ upstream), você pode configurá-lo da maneira que desejar, e isso corrigirá o problema, sem invasão adicional do cabeçalho.

As variáveis ​​de script de ameaça do manipulador do Proxy Pass de uma maneira diferente, se um valor não for condicional (não tiver $ no nome) for feito backup no upstream na fase de configuração e usado posteriormente.

Uma maneira simples de omitir esse problema e ter as vantagens de (versão gratuita) upstream seria usar algo como Split_Clients:

split_clients $request_uri $my_upstream {
              33%          server1.domainX.com;
              33%          server2.domainX.com;
# Always use DOT at end entry if you wonder why, read the SC code.
              *            server3.domainX.com;  
}
location / {
    ... 
    proxy_pass http://$my_upstream;
}

O exemplo acima parece quase o mesmo que upstream. Existem outros módulos para o mapeamento, por exemplo , chash_map_module , mas como eles estão fora da árvore, você precisará construí-los por conta própria, o que não é possível em alguns casos de uso /