Test drive Dynamic Application Sizing

telemetry {
  publish_allocation_metrics = true
  publish_node_metrics       = true
  prometheus_metrics         = true
}

job "prometheus" {
  datacenters = ["dc1"]

  group "prometheus" {
    count = 1

    network {
      port "prometheus_ui" {
        static = 9090
      }
    }

    task "prometheus" {
      driver = "docker"

      config {
        image = "prom/prometheus:v2.18.1"

        args = [
          "--config.file=/etc/prometheus/config/prometheus.yml",
          "--storage.tsdb.path=/prometheus",
          "--web.console.libraries=/usr/share/prometheus/console_libraries",
          "--web.console.templates=/usr/share/prometheus/consoles",
        ]

        volumes = [
          "local/config:/etc/prometheus/config",
        ]

        ports = ["prometheus_ui"]
      }

      template {
        data = <<EOH
---
global:
  scrape_interval:     1s
  evaluation_interval: 1s

scrape_configs:
  - job_name: nomad
    metrics_path: /v1/metrics
    params:
      format: ['prometheus']
    static_configs:
    - targets: ['{{ env "attr.unique.network.ip-address" }}:4646']

  - job_name: consul
    metrics_path: /v1/agent/metrics
    params:
      format: ['prometheus']
    static_configs:
    - targets: ['{{ env "attr.unique.network.ip-address" }}:8500']
EOH

        change_mode   = "signal"
        change_signal = "SIGHUP"
        destination   = "local/config/prometheus.yml"
      }

      resources {
        cpu    = 100
        memory = 256
      }

      service {
        name = "prometheus"
        port = "prometheus_ui"

        check {
          type     = "http"
          path     = "/-/healthy"
          interval = "10s"
          timeout  = "2s"
        }
      }
    }
  }
}

job "das-autoscaler" {
  datacenters = ["dc1"]
  group "autoscaler" {
    count = 1
    task "autoscaler" {
      driver = "docker"
      config {
        image   = "hashicorp/nomad-autoscaler-enterprise:0.2.0-beta2"
        command = "bin/nomad-autoscaler"
        args = [
          "agent",
          "-config",
          "${NOMAD_TASK_DIR}/autoscaler.hcl",
          "-http-bind-address",
          "0.0.0.0",
        ]
        ports = ["http"]
      }
      template {
        destination = "${NOMAD_TASK_DIR}/autoscaler.hcl"
        data = <<EOH
// Set the log level so we can see some more interesting output at the expense
// of chattiness.
log_level = "debug"
// Set the address of the Nomad agent. This can be omitted and in this example
// is set to the default for clarity.
nomad {
  // Use Consul service discovery for the Nomad client IP and Port.
  address = "{{ with service "nomad-client" }}{{ with index . 0 }}http://{{.Address}}:{{.Port}}{{ end }}{{ end }}"
  // Use the splat operator so the autoscaler monitors scaling policies from
  // all Nomad namespaces. If you wish to have it only monitor a single
  // namespace, update this param to match the desired name.
  namespace = "*"
  // If Nomad ACLs are in use, the following line should be uncommented and
  // updated to include an ACL token.
  // token = ""
}
// Setup the Prometheus APM so that the autoscaler can pull historical and
// point-in-time metrics regarding task resource usage.
apm "prometheus" {
  driver = "prometheus"
  config = {
    // Use Consul service discovery for the Prometheus IP and Port.
    address = "{{ with service "prometheus" }}{{ with index . 0 }}http://{{.Address}}:{{.Port}}{{ end }}{{ end }}"
  }
}
policy_eval {
  // Lower the evaluate interval so we can reproduce recommendations after only
  // 5 minutes, rather than having to wait for 24hrs as is the default.
  evaluate_after = "5m"
  // Disable the horizontal application and horizontal cluster workers. This
  // helps reduce log noise during the demo.
  workers = {
    cluster    = 0
    horizontal = 0
  }
}
EOH
      }
      resources {
        cpu    = 1024
        memory = 512
      }
    }
    network {
      port "http" {
        to = 8080
      }
    }
    service {
      name = "nomad-autoscaler"
      port = "http"
      check {
        type     = "http"
        path     = "/v1/health"
        interval = "5s"
        timeout  = "2s"
      }
    }
  }
}

job "example" {
  datacenters = ["dc1"]

  group "cache-lb" {
    count = 1

    network {
      port "lb" {
        to = 6379
      }
    }

    service {
      name         = "redis-lb"
      port         = "lb"
      address_mode = "host"

      check {
        type     = "tcp"
        port     = "lb"
        interval = "10s"
        timeout  = "2s"
      }
    }

    task "nginx" {
      driver = "docker"

      config {
        image = "nginx"
        ports = ["lb"]
        volumes = [
          # It's safe to mount this path as a file because it won't re-render.
          "local/nginx.conf:/etc/nginx/nginx.conf",
          # This path hosts files that will re-render with Consul Template.
          "local/nginx:/etc/nginx/conf.d"
        ]
      }

      # This template overwrites the embedded nginx.conf file so it loads
      # conf.d/*.conf files outside of the `http` block.
      template {
        data        = <<EOF
user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

include /etc/nginx/conf.d/*.conf;
EOF
        destination = "local/nginx.conf"
      }

      # This template creates a TCP proxy to Redis.
      template {
        data          = <<EOF
stream {
  server {
    listen 6379;
    proxy_pass backend;
  }

  upstream backend {
  {{ range service "redis" }}
    server {{ .Address }}:{{ .Port }};
  {{ else }}server 127.0.0.1:65535; # force a 502
  {{ end }}
  }
}
EOF
        destination   = "local/nginx/nginx.conf"
        change_mode   = "signal"
        change_signal = "SIGHUP"
      }

      resources {
        cpu    = 50
        memory = 10
      }
    }
  }

  group "cache" {
    count = 3

    network {
      port "db" {
        to = 6379
      }
    }

    service {
      name         = "redis"
      port         = "db"
      address_mode = "host"

      check {
        type     = "tcp"
        port     = "db"
        interval = "10s"
        timeout  = "2s"
      }
    }

    task "redis" {
      driver = "docker"

      config {
        image = "redis:3.2"
        ports = ["db"]
      }

      resources {
        cpu    = 500
        memory = 256
      }
    }
  }
}

      scaling "cpu" {
        policy {
          cooldown            = "1m"
          evaluation_interval = "1m"

          check "95pct" {
            strategy "app-sizing-percentile" {
              percentile = "95"
            }
          }
        }
      }

      scaling "mem" {
        policy {
          cooldown            = "1m"
          evaluation_interval = "1m"

          check "max" {
            strategy "app-sizing-max" {}
          }
        }
      }

job "das-load-test" {
  datacenters = ["dc1"]
  type        = "batch"

  parameterized {
    payload       = "optional"
    meta_optional = ["requests", "clients"]
  }

  group "redis-benchmark" {
    task "redis-benchmark" {
      driver = "docker"

      config {
        image   = "redis:3.2"
        command = "redis-benchmark"

        args = [
          "-h","${HOST}",
          "-p","${PORT}",
          "-n","${REQUESTS}",
          "-c","${CLIENTS}",
        ]
      }

      template {
        destination = "secrets/env.txt"
        env         = true

        data = <<EOF
{{ with service "redis-lb" }}{{ with index . 0 -}}
HOST={{.Address}}
PORT={{.Port}}
{{- end }}{{ end }}
REQUESTS={{ or (env "NOMAD_META_requests") "100000" }}
CLIENTS={{  or (env "NOMAD_META_clients") "50" }}
EOF
      }

      resources {
        cpu    = 100
        memory = 128
      }
    }
  }
}