nginx.tmpl

{{ $CurrentContainer := where $ "ID" .Docker.CurrentContainerID | first }}

{{ define "upstream" }}
	{{ if .Address }}
		{{/* If we got the containers from swarm and this container's port is published to host, use host IP:PORT */}}
		{{ if and .Container.Node.ID .Address.HostPort }}
			# {{ .Container.Node.Name }}/{{ .Container.Name }}
			server {{ .Container.Node.Address.IP }}:{{ .Address.HostPort }};
		{{/* If there is no swarm node or the port is not published on host, use container's IP:PORT */}}
		{{ else if .Network }}
			# {{ .Container.Name }}
			server {{ .Network.IP }}:{{ .Address.Port }};
		{{ end }}
	{{ else if .Network }}
		# {{ .Container.Name }}
		server {{ .Network.IP }} down;
	{{ end }}
{{ end }}


{{ $enable_ipv6 := eq (or ($.Env.ENABLE_IPV6) "") "true" }}

{{ range $host, $containers := groupByMulti $ "Env.VIRTUAL_HOST" "," }}

{{ $host := trim $host }}
{{ $is_regexp := hasPrefix "~" $host }}
{{ $upstream_name := when $is_regexp (sha1 $host) $host }}

stream {
  # {{ $host }}
  upstream {{ $upstream_name }}8000 {
  {{ range $container := $containers }}
          {{ $addrLen := len $container.Addresses }}
  
          {{ range $knownNetwork := $CurrentContainer.Networks }}
                  {{ range $containerNetwork := $container.Networks }}
                          {{ if (and (ne $containerNetwork.Name "ingress") (or (eq $knownNetwork.Name $containerNetwork.Name) (eq $knownNetwork.Name "host"))) }}
                                  {{ $port := coalesce $container.Env.VIRTUAL_PORT "8000" }}
                                  {{ $address := where $container.Addresses "Port" $port | first }}
                                  {{ template "upstream" (dict "Container" $container "Address" $address "Network" $containerNetwork) }}
                          {{ end }}
                  {{ end }}
          {{ end }}
  {{ end }}
  }
  
  upstream {{ $upstream_name }}8001 {
  {{ range $container := $containers }}
          {{ $addrLen := len $container.Addresses }}
  
          {{ range $knownNetwork := $CurrentContainer.Networks }}
                  {{ range $containerNetwork := $container.Networks }}
                          {{ if (and (ne $containerNetwork.Name "ingress") (or (eq $knownNetwork.Name $containerNetwork.Name) (eq $knownNetwork.Name "host"))) }}
                                  {{ $port := coalesce $container.Env.VIRTUAL_PORT "8001" }}
                                  {{ $address := where $container.Addresses "Port" $port | first }}
                                  {{ template "upstream" (dict "Container" $container "Address" $address "Network" $containerNetwork) }}
                          {{ end }}
                  {{ end }}
          {{ end }}
  {{ end }}
  }
  
  upstream {{ $upstream_name }}8443 {
  {{ range $container := $containers }}
          {{ $addrLen := len $container.Addresses }}
  
          {{ range $knownNetwork := $CurrentContainer.Networks }}
                  {{ range $containerNetwork := $container.Networks }}
                          {{ if (and (ne $containerNetwork.Name "ingress") (or (eq $knownNetwork.Name $containerNetwork.Name) (eq $knownNetwork.Name "host"))) }}
                                  {{ $port := coalesce $container.Env.VIRTUAL_PORT "8443" }}
                                  {{ $address := where $container.Addresses "Port" $port | first }}
                                  {{ template "upstream" (dict "Container" $container "Address" $address "Network" $containerNetwork) }}
                          {{ end }}
                  {{ end }}
          {{ end }}
  {{ end }}
  }
  
  upstream {{ $upstream_name }}8444 {
  {{ range $container := $containers }}
          {{ $addrLen := len $container.Addresses }}
  
          {{ range $knownNetwork := $CurrentContainer.Networks }}
                  {{ range $containerNetwork := $container.Networks }}
                          {{ if (and (ne $containerNetwork.Name "ingress") (or (eq $knownNetwork.Name $containerNetwork.Name) (eq $knownNetwork.Name "host"))) }}
                                  {{ $port := coalesce $container.Env.VIRTUAL_PORT "8444" }}
                                  {{ $address := where $container.Addresses "Port" $port | first }}
                                  {{ template "upstream" (dict "Container" $container "Address" $address "Network" $containerNetwork) }}
                          {{ end }}
                  {{ end }}
          {{ end }}
  {{ end }}
  }
  
  {{ $default_host := or ($.Env.DEFAULT_HOST) "" }}
  {{ $default_server := index (dict $host "" $default_host "default_server") $host }}
  
  {{/* Get the VIRTUAL_PROTO defined by containers w/ the same vhost, falling back to "http" */}}
  {{ $proto := trim (or (first (groupByKeys $containers "Env.VIRTUAL_PROTO")) "http") }}
  
  {{/* Get the HTTPS_METHOD defined by containers w/ the same vhost, falling back to "redirect" */}}
  {{ $https_method := or (first (groupByKeys $containers "Env.HTTPS_METHOD")) "redirect" }}
  
  {{/* Get the first cert name defined by containers w/ the same vhost */}}
  {{ $certName := (first (groupByKeys $containers "Env.CERT_NAME")) }}
  
  {{/* Get the best matching cert  by name for the vhost. */}}
  {{ $vhostCert := (closest (dir "/etc/nginx/certs") (printf "%s.crt" $host))}}
  
  {{/* vhostCert is actually a filename so remove any suffixes since they are added later */}}
  {{ $vhostCert := trimSuffix ".crt" $vhostCert }}
  {{ $vhostCert := trimSuffix ".key" $vhostCert }}
  
  {{/* Use the cert specified on the container or fallback to the best vhost match */}}
  {{ $cert := (coalesce $certName $vhostCert) }}
  
  {{ $is_https := (and (ne $https_method "nohttps") (ne $cert "") (exists (printf "/etc/nginx/certs/%s.crt" $cert)) (exists (printf "/etc/nginx/certs/%s.key" $cert))) }}
  
    
  server {
  	listen 8000 {{ $default_server }};
    proxy_pass {{ trim $upstream_name }}8000;
  }
  
  server {
  	listen 8001 {{ $default_server }};
    proxy_pass {{ trim $upstream_name }}8001;
  }
  
  server {
  	listen 8443 {{ $default_server }};
    proxy_pass {{ trim $upstream_name }}8443;
  }
  
  server {
  	listen 8444 {{ $default_server }};
  	proxy_pass {{ trim $upstream_name }}8444;
  }
  
  
  {{ end }}
}