воскресенье, 27 декабря 2015 г.

nginx module to enable haskell binding to nginx configuration files

Do you like haskell and nginx? I love them both and this inspired me to write an nginx module for inlining haskell source code straight into nginx configuration files. The module was published on github as nginx-haskell-module and shipped with an nginx configuration example to show its basic usage. Let’s look at it.
user                    nobody;
worker_processes        2;

events {
    worker_connections  1024;
}

http {
    default_type        application/octet-stream;
    sendfile            on;

    haskell ghc_extra_flags '-hide-package regex-pcre';

    haskell compile /tmp/ngx_haskell.hs '

import qualified Data.Char as C
import           Text.Regex.PCRE
import           Safe

toUpper = map C.toUpper
NGX_EXPORT_S_S (toUpper)

takeN x y = take (readDef 0 y) x
NGX_EXPORT_S_SS (takeN)

NGX_EXPORT_S_S (reverse)

matches :: String -> String -> Bool
matches a b = not $ null (getAllTextMatches $ a =~ b :: [String])
NGX_EXPORT_B_SS (matches)

    ';

    server {
        listen       8010;
        server_name  main;
        error_log    /tmp/nginx-test-haskell-error.log;
        access_log   /tmp/nginx-test-haskell-access.log;

        location / {
            haskell_run toUpper $hs_a $arg_a;
            echo "toUpper ($arg_a) = $hs_a";
            if ($arg_b) {
                haskell_run takeN $hs_a $arg_a $arg_b;
                echo "takeN ($arg_a, $arg_b) = $hs_a";
                break;
            }
            if ($arg_c) {
                haskell_run reverse $hs_a $arg_c;
                echo "reverse ($arg_c) = $hs_a";
                break;
            }
            if ($arg_d) {
                haskell_run matches $hs_a $arg_d $arg_a;
                echo "matches ($arg_d, $arg_a) = $hs_a";
                break;
            }
        }
    }
}
Haskell source code is placed inside the second argument of the directive haskell compile. In this example it contains some imports, three definitions of functions and four special export directives to introduce the functions on the nginx configuration level. There are four types of export directives: NGX_EXPORT_S_S, NGX_EXPORT_S_SS, NGX_EXPORT_B_S and NGX_EXPORT_B_SS for functions of types String -> String, String -> String -> String, String -> Bool and String -> String -> Bool respectively. The code gets written into the path specified in the first argument of the directive haskell compile (it must be an absolute path) and then compiled to a shared library at the very start of nginx. Sometimes ghc may require extra options besides defaults. And here is the case. As soon as import of Text.Regex.PCRE can be ambiguous (because two haskell packages regex-pcre and regex-pcre-builtin provide it), ghc must know which package to use. There is a special ghc flag -hide-package for hiding unwanted packages and it was used in this example by the directive haskell ghc_extra_flags. There is another nginx haskell directive haskell load which is similar to the haskell compile except it does not require the second argument (i.e. the haskell source code). The directive tries to load compiled shared library that corresponds to the path specified in its first argument (/tmp/ngx_haskell.so in this example). If the code argument is present but there is not compiled shared library, the latter will be first compiled and then loaded. If the haskell code fails to compile then nginx won’t start (or won’t reload workers if the code had been wrongly changed in the configuration file and nginx has been sent the SIGHUP signal). Any errors will be logged. To run the compiled haskell code in the nginx context there is another nginx directive haskell_run. It is allowed in server, location and location-if configuration clauses and may accept three or four arguments depending on the arity of the exported function to run which is specified in the first argument of the directive. The second argument introduces an nginx variable where return value of the haskell function will be saved. For example directive
                haskell_run takeN $hs_a $arg_a $arg_b;
introduces a new nginx variable $hs_a which will be calculated on demand as result of running an exported haskell function takeN with arguments $arg_a and $arg_b. Let’s do some curl tests. First of all nginx must be built and run. Besides the haskell module the build requires nginx echo module. It must be specified in options --add-module of nginx configure script.
./configure --add-module=<path-to-nginx-echo-module> --add-module=<path-to-nginx-haskell-module>
Placeholders <path-to-nginx-... are to be replaced with real paths to the modules. After running make we start the nginx daemon.
./objs/nginx -c /home/lyokha/devel/nginx-haskell-module/nginx.conf
[1 of 1] Compiling NgxHaskellUserRuntime ( /tmp/ngx_haskell.hs, /tmp/ngx_haskell.o )
Linking /tmp/ngx_haskell.so ...
Nginx option -c specifies location of the configuration file. The shared library /tmp/ngx_haskell.so was built upon start which was printed on the terminal. And now we are going to ask nginx server to do some haskell calculations!
curl 'http://localhost:8010/?a=hello_world'
toUpper (hello_world) = HELLO_WORLD
curl 'http://localhost:8010/?a=hello_world&b=4'
takeN (hello_world, 4) = hell
curl 'http://localhost:8010/?a=hello_world&b=oops'
takeN (hello_world, oops) = 
curl 'http://localhost:8010/?c=intelligence'
reverse (intelligence) = ecnegilletni
curl 'http://localhost:8010/?d=intelligence&a=^i'
matches (intelligence, ^i) = 1
curl 'http://localhost:8010/?d=intelligence&a=^I'
matches (intelligence, ^I) = 0
Hmm, I did not escape caret inside the URL in the matches examples: seems that curl allowed it, anyway the calculations were correct. Let’s do some changes in the haskell code inside the configuration file, say takeN will be
takeN x y = ("Incredible! " ++) $ take (readDef 0 y) x
, reload nginx configuration
pkill -HUP nginx
and do curl again.
curl 'http://localhost:8010/?a=hello_world&b=4'
takeN (hello_world, 4) = Incredible! hell
Nice, kind of runtime haskell reload! Now I want to explain some details of implementation and concerns about efficiency and exceptions. Haskell code gets compiled while reading nginx configuration file. It means that ghc must be accessible during nginx runtime (except when using haskell load with already compiled haskell library). Only one haskell compile (or haskell load) directive is allowed through the whole configuration. Directive haskell compile (or haskell load) must be placed before directives haskell_run and after directive haskell ghc_extra_flags (if any). Compiled haskell library gets loaded by dlopen() call when starting a worker process (i.e. haskell runtime is loaded for each nginx worker process separately). The haskell code itself is wrapped inside a special haskell FFI code (it can be found in /tmp/ngx_haskell.hs in case of the above example). The FFI tries its best to minimize unnecessary allocations when reading arguments that were passed from nginx, however for S_S and S_SS function types it does allocate a new string for return value which gets promptly copied to an nginx memory pool and freed. It was possible to avoid allocations for return values, but in this case ghc should have known about internal nginx string implementation, so I decided to sacrifice efficiency to avoid runtime dependency on nginx source code (again, this dependency would not have been necessary if this special FFI interface had been compiled in a separate module, but… probably I’ll do that in future). Another concern about efficiency is using in the exported haskell handlers haskell Strings which are simple lists of characters (which is assumed to be inefficient). On the other hand they are lazy (and this often means efficient). Ok, this is a traditional haskell trade-off matter… What about haskell exceptions? C code is unable to handle them and this is a bad news. However writing pure haskell code makes a strong guarantee about high level of exception safety (at least all IO exceptions must go). In the above example I used function readDef from module Safe instead of its partial counterpart read which increased safety level as well.

понедельник, 7 декабря 2015 г.

Шрифты infinality-ultimate для Fedora 23

Добрый человек собрал репозиторий с пропатченными пакетами для infinality. Спасибо ему большое! Некоторое время я вообще думал, что infinality мертв, оказывается нет: здесь находится активный репозиторий разработки, но без поддержки Fedora. Лично я установил только основные патчи, без шрифтов — так, как написано в секции Installation — на мой вкус этого вполне достаточно. До этого у меня стояли версии freetype и fontconfig от Russian Fedora и, в общем-то, я не жаловался на рендеринг, однако теперь я вижу разницу: шрифты стали четче, что-ли. Короче, чувствую, что стало лучше, но доказать не могу :) И сравнительные картинки приводить не стану: не сохранил оригинальный вид, да и в интернете такие сравнения найти несложно.

вторник, 1 декабря 2015 г.

Не такой уж простой модуль nginx для создания комбинированных апстримов

Когда-то давно я написал статью о простом модуле nginx для создания комбинированных апстримов. В ней шла речь о реализации простой директивы add_upstream на уровне блока upstream в конфигурации nginx, которая позволяет добавлять серверы из других апстримов: очень удобно, когда вам требуется собрать апстримы, скомбинированные из нескольких других апстримов, без копирования объявлений составляющих их серверов. На данный момент я больше не могу назвать этот модуль простым, поскольку кроме расширенной функциональности, в его реализации появились разнообразные механизмы nginx, такие как фильтрация заголовков и тела ответов, доступ к переменным и подзапросы (subrequests). Теперь модуль называется модулем комбинированных апстримов, он выложен на гитхабе и снабжен подробной документацией на английском языке. В этой статье я хочу перечислить все возможности данного модуля с примерами их использования.
  • Директива add_upstream в блоке upstream. Это то, с чего все начиналось.
    • Конфигурация
      events {
          worker_connections  1024;
      }
      
      http {
          upstream u1 {
              server localhost:8020;
          }
          upstream u2 {
              server localhost:8030;
          }
          upstream u3 {
              server localhost:8040;
          }
          upstream ucombined {
              add_upstream u1;
              add_upstream u2;
              add_upstream u3 backup;
          }
      
          server {
              listen       127.0.0.1:8010;
              server_name  main;
      
              location / {
                  proxy_pass http://ucombined;
              }
          }
          server {
              listen       127.0.0.1:8020;
              server_name  server1;
              location / {
                  echo "Passed to $server_name";
              }
          }
          server {
              listen       127.0.0.1:8030;
              server_name  server2;
              location / {
                  echo "Passed to $server_name";
              }
          }
          server {
              listen       127.0.0.1:8040;
              server_name  server3;
              location / {
                  echo "Passed to $server_name";
              }
          }
      }
      
    • Тест
      for i in `seq 10` ; do curl 'http://localhost:8010/' ; done
      Passed to server1
      Passed to server1
      Passed to server2
      Passed to server2
      Passed to server1
      Passed to server1
      Passed to server2
      Passed to server2
      Passed to server1
      Passed to server1
      
      Правильно. Если вам интересно, почему каждый сервер опрашивается по два раза подряд, то ответ таков. Мой системный файл /etc/hosts содержит следующие две строки.
      127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
      ::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
      
      Это значит, что loopback интерфейс имеет два адреса — для IPv4 и IPv6 (по крайней мере в /etc/hosts, который nginx читает на старте). Для каждого адреса nginx создает отдельный элемент-сервер в списке round robin peers. Достаточно закомментировать вторую строку в /etc/hosts и перезапустить nginx, чтобы получить настоящий round robin цикл в этом тесте.
  • Директива combine_server_singlets в блоке upstream. Эта штука позволяет плодить апстримы в невероятных количествах :) Представьте, что у вас есть такой апстрим
        upstream u1 {
            server localhost:8020;
            server localhost:8030;
            server localhost:8040;
        }
    
    и вы хотите создать три следующих производных апстрима-синглета (не надо спрашивать зачем, у меня была такая задача и я точно знаю, что она имеет смысл).
        upstream u11 {
            server localhost:8020;
            server localhost:8030 backup;
            server localhost:8040 backup;
        }
        upstream u12 {
            server localhost:8020 backup;
            server localhost:8030;
            server localhost:8040 backup;
        }
        upstream u13 {
            server localhost:8020 backup;
            server localhost:8030 backup;
            server localhost:8040;
        }
    
    Не нужно их создавать вручную! Достаточно поместить новую директиву внутрь порождающего апстрима
        upstream u1 {
            server localhost:8020;
            server localhost:8030;
            server localhost:8040;
            combine_server_singlets;
        }
    
    и апстримы-синглеты будут созданы автоматически. Для тонкой настройки имен порожденных апстримов директива предоставляет два опциональных параметра: суффикс и разрядное выравнивание порядкового номера апстрима.
    • Конфигурация
      events {
          worker_connections  1024;
      }
      
      http {
          upstream u1 {
              server localhost:8020;
              server localhost:8030;
              server localhost:8040;
              combine_server_singlets;
              combine_server_singlets _tmp_ 2;
          }
      
          server {
              listen       127.0.0.1:8010;
              server_name  main;
      
              location /1 {
                  proxy_pass http://u11;
              }
              location /2 {
                  proxy_pass http://u1_tmp_02;
              }
              location /3 {
                  proxy_pass http://u1$cookie_rt;
              }
          }
          server {
              listen       127.0.0.1:8020;
              server_name  server1;
              location / {
                  add_header Set-Cookie "rt=1";
                  echo "Passed to $server_name";
              }
          }
          server {
              listen       127.0.0.1:8030;
              server_name  server2;
              location / {
                  add_header Set-Cookie "rt=2";
                  echo "Passed to $server_name";
              }
          }
          server {
              listen       127.0.0.1:8040;
              server_name  server3;
              location / {
                  add_header Set-Cookie "rt=3";
                  echo "Passed to $server_name";
              }
          }
      }
      
    • Тест
      curl 'http://localhost:8010/1'
      Passed to server1
      curl 'http://localhost:8010/2'
      Passed to server2
      curl 'http://localhost:8010/3'
      Passed to server1
      curl -D- -b 'rt=2' 'http://localhost:8010/3'
      HTTP/1.1 200 OK
      Server: nginx/1.8.0
      Date: Tue, 01 Dec 2015 10:59:00 GMT
      Content-Type: text/plain
      Transfer-Encoding: chunked
      Connection: keep-alive
      Set-Cookie: rt=2
      
      Passed to server2
      curl -D- -b 'rt=3' 'http://localhost:8010/3'
      HTTP/1.1 200 OK
      Server: nginx/1.8.0
      Date: Tue, 01 Dec 2015 10:59:10 GMT
      Content-Type: text/plain
      Transfer-Encoding: chunked
      Connection: keep-alive
      Set-Cookie: rt=3
      
      Passed to server3
      
      Обмен кукой rt дает подсказку, где синглетные апстримы могут быть полезны.
  • Апстрэнды (upstrands). Это такие комбинированные апстримы, внутри которых составляющие их апстримы не теряют свою целостность и идентичность. Слово upstrand образовано из двух составляющих: upstream и strand и означает пучок или жилу апстримов. Я касался деталей реализации апстрэндов в этой статье на английском языке. В двух словах, апстрэнд представляет собой высокоуровневую структуру, которая может опрашивать составляющие ее апстримы по кругу (round robin) до тех пор, пока не найдет апстрим, удовлетворяющий заданному условию — код ответа апстрима (HTTP response) не должен входить в список, заданный директивой next_upstream_statuses. Технически апстрэнды являются блоками — такими же как и апстримы. Они точно так же задаются внутри секции http конфигурации nginx, но вместо серверов составляющими их компонентами являются обычные апстримы. Апстримы добавляются в апстрэнд с помощью директивы upstream. Если имя апстрима начинается с символа тильда, то оно рассматривается как регулярное выражение. Отдельные апстримы внутри апстрэнда могут быть помечены как бэкапные, также имеется возможность блэклистить апстримы на определенное время с помощью параметра blacklist_interval. Опрос нескольких апстримов внутри апстрэнда реализован с помощью механизма подзапросов (subrequests). Этот механизм запускается в результате доступа к встроенной переменной upstrand_NAME, где NAME соответствует имени существующего апстрэнда. Я предполагаю, что в основном апстрэнды будут применяться в директиве proxy_pass модуля nginx proxy, однако здесь нет искусственных ограничений: доступ к механизму запуска подзапросов через переменную позволяет использовать апстрэнды в любом пользовательском модуле. На случай, если имя апстрэнда заранее неизвестно (например, оно приходит в куке), предусмотрена директива dynamic_upstrand, которая записывает имя следующего апстрима предполагаемого апстрэнда в свой первый аргумент-переменную на основании оставшегося списка аргументов (имя апстрэнда будет соответствовать первому не пустому аргументу из этого списка). Директива доступна на уровнях конфигурации server, location и location-if. Апстрэнды предоставляют несколько статусных переменных, среди них upstrand_addr, upstrand_status, upstrand_cache_status, upstrand_connect_time, upstrand_header_time, upstrand_response_time, upstrand_response_length — все они соответствуют аналогичным переменным из модуля upstream, только хранят значения всех посещенных апстримов в рамках данного HTTP запроса — и upstrand_path, в которой записан хронологический порядок (путь) посещения апстримов в рамках данного запроса. Статусные переменные полезны для анализа работы апстрэндов в access логе. А теперь пример конфигурации и curl-тест.
    • Конфигурация
      events {
          worker_connections  1024;
      }
      
      http {
          upstream u01 {
              server localhost:8020;
          }
          upstream u02 {
              server localhost:8030;
          }
          upstream b01 {
              server localhost:8040;
          }
          upstream b02 {
              server localhost:8050;
          }
      
          upstrand us1 {
              upstream ~^u0 blacklist_interval=10s;
              upstream b01 backup;
              next_upstream_statuses 5xx;
          }
          upstrand us2 {
              upstream b02;
              next_upstream_statuses 5xx;
          }
      
          log_format  fmt '$remote_addr [$time_local]\n'
                          '>>> [path]          $upstrand_path\n'
                          '>>> [addr]          $upstrand_addr\n'
                          '>>> [response time] $upstrand_response_time\n'
                          '>>> [status]        $upstrand_status';
      
          server {
              listen       127.0.0.1:8010;
              server_name  main;
              error_log    /tmp/nginx-test-upstrand-error.log;
              access_log   /tmp/nginx-test-upstrand-access.log fmt;
      
              dynamic_upstrand $dus1 $arg_a us2;
      
              location /us {
                  proxy_pass http://$upstrand_us1;
              }
              location /dus {
                  dynamic_upstrand $dus2 $arg_b;
                  if ($arg_b) {
                      proxy_pass http://$dus2;
                      break;
                  }
                  proxy_pass http://$dus1;
              }
          }
          server {
              listen       8020;
              server_name  server1;
      
              location / {
                  echo "Passed to $server_name";
                  #return 503;
              }
          }
          server {
              listen       8030;
              server_name  server2;
      
              location / {
                  echo "Passed to $server_name";
                  #return 503;
              }
          }
          server {
              listen       8040;
              server_name  server3;
      
              location / {
                  echo "Passed to $server_name";
              }
          }
          server {
              listen       8050;
              server_name  server4;
      
              location / {
                  echo "Passed to $server_name";
              }
          }
      }
      
    • Тест
      for i in `seq 6` ; do curl 'http://localhost:8010/us' ; done
      Passed to server1
      Passed to server2
      Passed to server1
      Passed to server2
      Passed to server1
      Passed to server2
      
      В логах nginx мы увидим
      tail -f /tmp/nginx-test-upstrand-*
      ==> /tmp/nginx-test-upstrand-access.log <==
      
      ==> /tmp/nginx-test-upstrand-error.log <==
      
      ==> /tmp/nginx-test-upstrand-access.log <==
      127.0.0.1 [01/Dec/2015:16:52:03 +0300]
      >>> [path]          u01
      >>> [addr]          (u01) 127.0.0.1:8020
      >>> [response time] (u01) 0.000
      >>> [status]        (u01) 200
      127.0.0.1 [01/Dec/2015:16:52:03 +0300]
      >>> [path]          u02
      >>> [addr]          (u02) 127.0.0.1:8030
      >>> [response time] (u02) 0.000
      >>> [status]        (u02) 200
      127.0.0.1 [01/Dec/2015:16:52:03 +0300]
      >>> [path]          u01
      >>> [addr]          (u01) 127.0.0.1:8020
      >>> [response time] (u01) 0.000
      >>> [status]        (u01) 200
      127.0.0.1 [01/Dec/2015:16:52:03 +0300]
      >>> [path]          u02
      >>> [addr]          (u02) 127.0.0.1:8030
      >>> [response time] (u02) 0.001
      >>> [status]        (u02) 200
      127.0.0.1 [01/Dec/2015:16:52:03 +0300]
      >>> [path]          u01
      >>> [addr]          (u01) 127.0.0.1:8020
      >>> [response time] (u01) 0.000
      >>> [status]        (u01) 200
      127.0.0.1 [01/Dec/2015:16:52:03 +0300]
      >>> [path]          u02
      >>> [addr]          (u02) 127.0.0.1:8030
      >>> [response time] (u02) 0.001
      >>> [status]        (u02) 200
      
      А теперь давайте закомментируем директивы echo и раскомментируем директивы return 503 в локейшнах двух первых бэкендов (server1 и server2), перезапустим nginx и протестируем снова.
      for i in `seq 6` ; do curl 'http://localhost:8010/us' ; done
      Passed to server3
      Passed to server3
      Passed to server3
      Passed to server3
      Passed to server3
      Passed to server3
      
      Логи nginx.
      ==> /tmp/nginx-test-upstrand-access.log <==
      127.0.0.1 [01/Dec/2015:16:58:06 +0300]
      >>> [path]          u01 -> u02 -> b01
      >>> [addr]          (u01) 127.0.0.1:8020 (u02) 127.0.0.1:8030 (b01) 127.0.0.1:8040
      >>> [response time] (u01) 0.001 (u02) 0.000 (b01) 0.000
      >>> [status]        (u01) 503 (u02) 503 (b01) 200
      127.0.0.1 [01/Dec/2015:16:58:06 +0300]
      >>> [path]          b01
      >>> [addr]          (b01) 127.0.0.1:8040
      >>> [response time] (b01) 0.000
      >>> [status]        (b01) 200
      127.0.0.1 [01/Dec/2015:16:58:06 +0300]
      >>> [path]          b01
      >>> [addr]          (b01) 127.0.0.1:8040
      >>> [response time] (b01) 0.000
      >>> [status]        (b01) 200
      127.0.0.1 [01/Dec/2015:16:58:06 +0300]
      >>> [path]          b01
      >>> [addr]          (b01) 127.0.0.1:8040
      >>> [response time] (b01) 0.000
      >>> [status]        (b01) 200
      127.0.0.1 [01/Dec/2015:16:58:06 +0300]
      >>> [path]          b01
      >>> [addr]          (b01) 127.0.0.1:8040
      >>> [response time] (b01) 0.000
      >>> [status]        (b01) 200
      127.0.0.1 [01/Dec/2015:16:58:06 +0300]
      >>> [path]          b01
      >>> [addr]          (b01) 127.0.0.1:8040
      >>> [response time] (b01) 0.000
      >>> [status]        (b01) 200
      
      Ждем десять секунд — заблэклисченные апстримы должны разблэклиститься, и повторяем снова.
      for i in `seq 2` ; do curl 'http://localhost:8010/us' ; done
      Passed to server3
      Passed to server3
      
      Логи nginx.
      127.0.0.1 [01/Dec/2015:17:01:44 +0300]
      >>> [path]          u01 -> u02 -> b01
      >>> [addr]          (u01) 127.0.0.1:8020 (u02) 127.0.0.1:8030 (b01) 127.0.0.1:8040
      >>> [response time] (u01) 0.000 (u02) 0.000 (b01) 0.001
      >>> [status]        (u01) 503 (u02) 503 (b01) 200
      127.0.0.1 [01/Dec/2015:17:01:44 +0300]
      >>> [path]          b01
      >>> [addr]          (b01) 127.0.0.1:8040
      >>> [response time] (b01) 0.000
      >>> [status]        (b01) 200
      
      А теперь протестируем работу динамических апстрэндов (предварительно вернув оригинальные настройки локейшнов двух первых бэкендов).
      curl 'http://localhost:8010/dus?a=us1'
      Passed to server1
      curl 'http://localhost:8010/dus?a=us2'
      Passed to server4
      curl 'http://localhost:8010/dus?a=foo&b=us1'
      Passed to server2
      curl 'http://localhost:8010/dus'
      Passed to server4
      curl 'http://localhost:8010/dus?b=foo'
      <html>
      <head><title>500 Internal Server Error</title></head>
      <body bgcolor="white">
      <center><h1>500 Internal Server Error</h1></center>
      <hr><center>nginx/1.8.0</center>
      </body>
      </html>
      
      В первом запросе мы через аргумент a попали на один из апстримов апстрэнда us1 — им оказался апстрим u01, который содержит единственный сервер server1. Во втором запросе, тоже через аргумент a, мы попали на апстрэнд us2 — апстрим b02 — сервер server4. В третьем запросе мы задействовали новый динамический апстрим dus2 через аргумент b, который отправил нас на второй апстрим (round robin же) u02 апстрэнда us1 и сервер server2. В четвертом запросе мы не предоставили аргументов и сработал последний не пустой элемент динамического апстрэнда dus1us2 с его единственным апстримом b02 и единственным сервером server4. В последнем запросе я показал, что может произойти, если динамический апстрэнд вернет пустое значение. В данном случае значение dus2 оказалось пустым и директива proxy_pass, попытавшись выполнить проксирование на неверно сформированный адрес http://, вернула ошибку 500.
    Апстрэнды могут быть полезны, во-первых, для создания двумерных round robin циклов, когда вы знаете, что если некоторый сервер из определенного апстрима вернул неудовлетворительный ответ, то нет необходимости обращаться к другим серверам этого апстрима, а следует незамедлительно переходить к следующему апстриму — простой upstream round robin механизм не способен эмулировать такое поведение, поскольку серверы внутри апстрима не могут образовывать кластеры, и, во-вторых, для переноса части логики протокола уровня приложения с клиента на роутер. Например, если в логике приложения код ответа 204, присланный из некоторого апстрима, обозначает отсутствие данных и клиенту следует тут же проверить наличие данных в другом апстриме, то можно ограничить общение клиента с бэкендом всего одним запросом, перенеся опрос всех направлений-апстримов на плечи роутера, в котором все эти апстримы будут помещены в один апстрэнд. Такой подход полезен еще тем, что инкапсулирует знание топологии бэкендов внутри роутера, ведь клиентам это знание больше не нужно.