悟 Kong（人造人篇）

$ curl -X POST http://127.0.0.1:8001/services \
    -d "name=example-service" \
    -d "url=https://blog.crazytaxii.com"
{"host":"blog.crazytaxii.com","created_at":1592725613,"connect_timeout":60000,"id":"b136f8d4-9ef3-455c-bb33-db64d1b790ea","protocol":"https","name":"example-service","read_timeout":60000,"port":443,"path":null,"updated_at":1592725613,"retries":5,"write_timeout":60000,"tags":null,"client_certificate":null}

$ curl -X POST http://127.0.0.1:8001/services/example-service/routes \
    -d "hosts[]=example.com"
{"id":"ab0facfc-a589-499d-b205-1798c36f7f92","path_handling":"v0","paths":null,"destinations":null,"headers":null,"protocols":["http","https"],"methods":null,"snis":null,"service":{"id":"b136f8d4-9ef3-455c-bb33-db64d1b790ea"},"name":null,"strip_path":true,"preserve_host":false,"regex_priority":0,"updated_at":1592725755,"sources":null,"hosts":["example.com"],"https_redirect_status_code":426,"tags":null,"created_at":1592725755}

$ curl http://127.0.0.1:8000/ -H "Host: example.com"

http {
  include    conf/mime.types;
  include    /etc/nginx/proxy.conf;
  include    /etc/nginx/fastcgi.conf;
  index    index.html index.htm index.php;

  default_type application/octet-stream;
  log_format   main '$remote_addr - $remote_user [$time_local]  $status '
    '"$request" $body_bytes_sent "$http_referer" '
    '"$http_user_agent" "$http_x_forwarded_for"';
  access_log   logs/access.log  main;
  sendfile     on;
  tcp_nopush   on;
  server_names_hash_bucket_size 128; # this seems to be required for some vhosts

  server { # simple reverse-proxy
    listen       80;
    server_name  domain2.com www.domain2.com;
    access_log   logs/domain2.access.log  main;

    # serve static files
    location ~ ^/(images|javascript|js|css|flash|media|static)/  {
      root    /var/www/virtual/big.server.com/htdocs;
      expires 30d;
    }

    # pass requests for dynamic content to rails/turbogears/zope, et al
    location / {
      proxy_pass      http://127.0.0.1:8080;
    }
  }

  upstream big_server_com {
    server 127.0.0.3:8000 weight=5;
    server 127.0.0.3:8001 weight=5;
    server 192.168.0.1:8000;
    server 192.168.0.1:8001;
  }

  server { # simple load balancing
    listen          80;
    server_name     big.server.com;
    access_log      logs/big.server.access.log main;

    location / {
      proxy_pass      http://big_server_com;
    }
  }
}

upstream kong_upstream {
    server 0.0.0.1;
    balancer_by_lua_block {
        Kong.balancer();
    }

    # injected nginx_upstream_* directives
    keepalive_requests 100;
    keepalive_timeout 60s;
    keepalive 60;
}

server {
    server_name kong;
    listen 0.0.0.0:8000 reuseport backlog=16384;
    listen 0.0.0.0:8443 ssl http2 reuseport backlog=16384;

    rewrite_by_lua_block {
        Kong.rewrite();
    }

    access_by_lua_block {
        Kong.access();
    }

    header_filter_by_lua_block {
        Kong.header_filter();
    }

    body_filter_by_lua_block {
        Kong.body_filter();
    }

    log_by_lua_block {
        Kong.log();
    }

    location / {
        default_type                    '';

        set $upstream_scheme            '';
        set $upstream_uri               '';

        proxy_pass            $upstream_scheme://kong_upstream$upstream_uri;
    }
}

GET / HTTP/1.1
Host: example.com:8000

function Kong.access()
  -- ...

  kong_global.set_phase(kong, PHASES.access)

  runloop.access.before(ctx)

  ctx.delay_response = true

  -- ...
end

before = function(ctx)
  -- routing request
  local router = get_updated_router()
  local match_t = router.exec()
  if not match_t then
    return kong.response.exit(404, { message = "no Route matched with those values" })
  end

  local http_version   = ngx.req.http_version()
  local scheme         = var.scheme
  local host           = var.host
  local port           = tonumber(var.server_port, 10)
  local content_type   = var.content_type

  local route          = match_t.route
  local service        = match_t.service
  local upstream_url_t = match_t.upstream_url_t

  local realip_remote_addr = var.realip_remote_addr
  local forwarded_proto
  local forwarded_host
  local forwarded_port

  -- ...

  balancer_prepare(ctx, match_t.upstream_scheme,
                   upstream_url_t.type,
                   upstream_url_t.host,
                   upstream_url_t.port,
                   service, route)

  ctx.router_matches = match_t.matches

  -- `uri` is the URI with which to call upstream, as returned by the
  --       router, which might have truncated it (`strip_uri`).
  -- `host` is the original header to be preserved if set.
  var.upstream_scheme = match_t.upstream_scheme -- COMPAT: pdk
  var.upstream_uri    = match_t.upstream_uri
  var.upstream_host   = match_t.upstream_host

  -- ...
end

function Kong.balancer()
  -- ...

  kong_global.set_phase(kong, PHASES.balancer)

  local balancer_data = ctx.balancer_data
  local tries = balancer_data.tries
  local current_try = {}
  balancer_data.try_count = balancer_data.try_count + 1
  tries[balancer_data.try_count] = current_try

  -- ...

  current_try.ip   = balancer_data.ip
  current_try.port = balancer_data.port

  -- set the targets as resolved
  ngx_log(ngx_DEBUG, "setting address (try ", balancer_data.try_count, "): ",
                     balancer_data.ip, ":", balancer_data.port)
  local ok, err = set_current_peer(balancer_data.ip, balancer_data.port)
  if not ok then
    ngx_log(ngx_ERR, "failed to set the current peer (address: ",
            tostring(balancer_data.ip), " port: ", tostring(balancer_data.port),
            "): ", tostring(err))

    ctx.KONG_BALANCER_ENDED_AT = get_now_ms()
    ctx.KONG_BALANCER_TIME = ctx.KONG_BALANCER_ENDED_AT - ctx.KONG_BALANCER_START
    ctx.KONG_PROXY_LATENCY = ctx.KONG_BALANCER_ENDED_AT - ctx.KONG_PROCESSING_START

    return ngx.exit(500)
  end
end