Configurer nginx pour ne pas planter si l'hôte en amont n'est pas trouvé

Nous avons plusieurs applications de rails sous un domaine commun dans Docker et nous utilisons nginx pour diriger les demandes vers des applications spécifiques.

our_dev_server.com/foo # proxies to foo app
our_dev_server.com/bar # proxies to bar

La configuration ressemble à ceci:

upstream foo {
  server foo:3000;
}

upstream bar {
  server bar:3000;
}

# and about 10 more...

server {
  listen *:80 default_server;

  server_name our_dev_server.com;

  location /foo {
      # this is specific to asset management in rails dev
      rewrite ^/foo/assets(/.*)$ /assets/$1 break;
      rewrite ^/foo(/.*)$ /foo/$1 break;
      proxy_pass http://foo;
  }

  location /bar {
      rewrite ^/bar/assets(/.*)$ /assets/$1 break;
      rewrite ^/bar(/.*)$ /bar/$1 break;
      proxy_pass http://bar;
  }

  # and about 10 more...
}

Si l'une de ces applications n'est pas démarrée, nginx échoue et s'arrête:

host not found in upstream "bar:3000" in /etc/nginx/conf.d/nginx.conf:6

Nous n'avons pas besoin de tous pour être en place, mais nginx échoue autrement. Comment faire en sorte que Nginx ignore les échecs en amont?

1. Si vous pouvez utiliser une adresse IP statique, utilisez-la simplement, elle démarrera et retournera simplement 503si elle ne répond pas.

2. Utilisez la resolverdirective pour pointer vers quelque chose qui peut résoudre l'hôte, qu'il soit actuellement actif ou non.

3. Résolvez-le au locationniveau, si vous ne pouvez pas faire ce qui précède (cela permettra à Nginx de démarrer / s'exécuter) :

   location /foo {
     resolver 127.0.0.1 valid=30s;
     # or some other DNS (you company/internal DNS server)
     #resolver 8.8.8.8 valid=30s;
     set $upstream_foo foo;
     proxy_pass http://$upstream_foo:80;
   }
   
   location /bar {
     resolver 127.0.0.1 valid=30s;
     # or some other DNS (you company/internal DNS server)
     #resolver 8.8.8.8 valid=30s;
     set $upstream_bar foo;
     proxy_pass http://$upstream_bar:80;
   }
   

Pour moi, l'option 3 de la réponse de @ Justin / @ duskwuff a résolu le problème, mais j'ai dû changer l'adresse IP du résolveur en 127.0.0.11 (serveur DNS de Docker):

location /foo {
  resolver 127.0.0.11 valid=30s;
  set $upstream_foo foo;
  proxy_pass http://$upstream_foo:80;
}

location /bar {
  resolver 127.0.0.11 valid=30s;
  set $upstream_bar foo;
  proxy_pass http://$upstream_bar:80;
}

Mais comme @ Justin / @ duskwuff l'a mentionné, vous pouvez utiliser n'importe quel autre serveur DNS externe.

Le principal avantage de l'utilisation upstreamest de définir un groupe de serveurs pouvant écouter sur différents ports et de configurer l'équilibrage de charge et le basculement entre eux .

Dans votre cas, vous ne définissez qu'un seul serveur principal par amont, il doit donc être opérationnel .

À la place, utilisez des variables pour votre proxy_pass( vos ) et n'oubliez pas de gérer les erreurs possibles (404, 503) que vous pourriez obtenir lorsqu'un serveur cible est arrêté.

J'ai eu le même problème «Hôte introuvable» car une partie de mon hôte était mappée en utilisant $uriau lieu de $request_uri:

proxy_pass http://one-api-service.$kubernetes:8091/auth;

Et lorsque la demande est devenue la sous-demande d'authentification, le a $uriperdu sa valeur initiale. Changer le mappage à utiliser $request_uriau lieu de $urirésoudre mon problème:

map $request_uri $kubernetes {
    # ...
}

Vous ne pouvez pas utiliser d' --linkoption, à la place, vous pouvez utiliser le mappage de port et lier nginx à l'adresse hôte.

Exemple: exécutez votre premier conteneur docker avec -p 180:80option, deuxième conteneur avec -p 280:80option.

Exécutez nginx et définissez ces adresses pour le proxy:

proxy_pass http://192.168.1.20:180/; # first container
proxy_pass http://192.168.1.20:280/; # second container