registry

registry

import "github.com/ecshreve/slomad/internal/registry"

Index

• Variables
• func GetTraefikJob() (*nomadApi.Job, error)
• func convertJob(in *nomadStructs.Job) (*nomadApi.Job, error)
• func getStorageArgs(storage string) []string
• func promConfigHelper(tmpl string) string

Variables

var ControllerJob = smd.Job{
    Name:   "storage-controller",
    Type:   smd.STORAGE_CONTROLLER,
    Target: smd.WORKER,
    Ports:  smd.BasicPortConfig(0),
    Shape:  smd.DEFAULT_TASK,
    Args:   getStorageArgs("controller"),
}

var GrafanaJob = smd.Job{
    Name:    "grafana",
    Type:    smd.SERVICE,
    Target:  smd.WORKER,
    Ports:   smd.BasicPortConfig(3000),
    Shape:   smd.LARGE_TASK,
    User:    "root",
    Env:     map[string]string{"GF_SERVER_HTTP_PORT": "${NOMAD_PORT_http}"},
    Volumes: []smd.Volume{{Src: "grafana-vol", Dst: "/var/lib/grafana", Mount: true}},
}

TODO: mount nomad volume and persist data

var InfluxDBJob = smd.Job{
    Name:    "influxdb",
    Type:    smd.SERVICE,
    Target:  smd.WORKER,
    Ports:   smd.BasicPortConfig(8086),
    Shape:   smd.LARGE_TASK,
    Volumes: []smd.Volume{{Src: "influx_data", Dst: "/var/lib/influxdb"}},
}

var LokiJob = smd.Job{
    Name:   "loki",
    Type:   smd.SERVICE,
    Target: smd.WORKER,
    Ports:  smd.BasicPortConfig(3100),
    Shape:  smd.TINY_TASK,
}

var NodeExporterJob = smd.Job{
    Name:  "node-exporter",
    Type:  smd.SYSTEM,
    Ports: smd.BasicPortConfig(9100),
    Shape: smd.TINY_TASK,
    Args: []string{
        "--web.listen-address=:${NOMAD_PORT_http}",
        "--path.procfs=/host/proc",
        "--path.sysfs=/host/sys",
        "--collector.filesystem.ignored-mount-points",
        "^/(sys|proc|dev|host|etc|rootfs/var/lib/docker/containers|rootfs/var/lib/docker/overlay2|rootfs/run/docker/netns|rootfs/var/lib/docker/aufs)($$|/)",
    },
    Volumes: []smd.Volume{
        {Src: "/proc", Dst: "/host/proc"},
        {Src: "/sys", Dst: "/host/sys"},
        {Src: "/", Dst: "/rootfs"},
    },
}

var NodeJob = smd.Job{
    Name:  "storage-node",
    Type:  smd.STORAGE_NODE,
    Ports: smd.BasicPortConfig(0),
    Shape: smd.TINY_TASK,
    Args:  getStorageArgs("node"),
}

var PlexJob = smd.Job{
    Name:   "plex",
    Type:   smd.SERVICE,
    Target: smd.PLEXBOX,
    Ports:  []*smd.Port{{Label: "http", To: 32400, From: 32400, Static: true}},
    Shape:  smd.LARGE_TASK,
    User:   "root",
    Env: map[string]string{
        "TZ":           "America/Los_Angeles",
        "VERSION":      "docker",
        "ADVERTISE_IP": "http://plex.slab.lan:80",
        "PGID":         "100",
        "PUID":         "1027",
    },
    Volumes: []smd.Volume{
        {Src: "/mnt/nfs/config/plex", Dst: "/config"},
        {Src: "/mnt/nfs/media/music", Dst: "/music"},
        {Src: "/mnt/nfs/media/tv", Dst: "/tv"},
        {Src: "/mnt/nfs/media/movies", Dst: "/movies"},
        {Src: "/dev/shm", Dst: "/transcode"},
    },
}

PrometheusJob is a Job for the Prometheus service.

var PrometheusJob = smd.Job{
    Name:      "prometheus",
    Type:      smd.SERVICE,
    Target:    smd.WORKER,
    Ports:     smd.BasicPortConfig(9090),
    Shape:     smd.LARGE_TASK,
    Templates: map[string]string{"prometheus.yml": promConfigHelper(prometheusConfig)},
    Volumes:   []smd.Volume{{Src: "local/config", Dst: "/etc/prometheus"}},
}

var PromtailJob = smd.Job{
    Name:  "promtail",
    Type:  smd.SYSTEM,
    Ports: smd.BasicPortConfig(3200),
    Shape: smd.TINY_TASK,
    Env:   map[string]string{"HOSTNAME": "${attr.unique.hostname}"},
    Args: []string{
        "-config.file=/local/config/promtail.yml",
        "-server.http-listen-port=${NOMAD_PORT_http}",
    },
    Templates: map[string]string{"promtail.yml": promConfigHelper(promtailConfig)},
    Volumes: []smd.Volume{
        {Src: "/opt/nomad/data/", Dst: "/nomad/"},
        {Src: "/data/promtail", Dst: "/data"},
    },
}

var SpeedtestJob = smd.Job{
    Name:   "speedtest",
    Type:   smd.SERVICE,
    Target: smd.WORKER,
    Ports:  smd.BasicPortConfig(80),
    Shape:  smd.TINY_TASK,
}

var WhoamiJob = smd.Job{
    Name:   "whoami",
    Type:   smd.SERVICE,
    Target: smd.WORKER,
    Shape:  smd.TINY_TASK,
    Args:   []string{"--port", "${NOMAD_PORT_http}"},
    Ports:  smd.BasicPortConfig(80),
}

var prometheusConfig string

var promtailConfig string

var traefikJob = nomadStructs.Job{
    ID:          "traefik",
    Name:        "traefik",
    Region:      "global",
    Priority:    92,
    Datacenters: []string{"dcs"},
    Type:        "service",
    TaskGroups: []*nomadStructs.TaskGroup{
        {
            Services: []*nomadStructs.Service{
                {
                    Name:      "traefik-web",
                    PortLabel: "web",
                    Checks: []*nomadStructs.ServiceCheck{
                        {
                            Name:          fmt.Sprintf("%s = tcp check", "traefik-web"),
                            Type:          nomadStructs.ServiceCheckTCP,
                            Interval:      10 * time.Second,
                            Timeout:       2 * time.Second,
                            InitialStatus: "passing",
                        },
                    },
                    Provider: "consul",
                },
            },
            Name:  "traefik",
            Count: 1,
            Tasks: []*nomadStructs.Task{
                {
                    Name:   "traefik",
                    Driver: "docker",
                    Config: map[string]interface{}{
                        "image":        "reg.slab.lan:5000/traefik:latest",
                        "network_mode": "host",
                        "args": []string{
                            "--entryPoints.web.address=:80",
                            "--entryPoints.websecure.address=:443",
                            "--entryPoints.admin.address=:8081",
                            "--entrypoints.websecure.http.redirections.entryPoint.to=web",
                            "--entrypoints.websecure.http.redirections.entryPoint.scheme=http",
                            "--accesslog=true",
                            "--api=true",
                            "--api.dashboard=true",
                            "--api.insecure=true",
                            "--metrics=true",
                            "--metrics.prometheus=true",
                            "--metrics.prometheus.addEntryPointsLabels=true",
                            "--ping=true",
                            "--ping.entryPoint=admin",
                            "--providers.consulcatalog=true",
                            "--providers.consulcatalog.endpoint.address=127.0.0.1:8500",
                            "--providers.consulcatalog.prefix=traefik",
                            "--providers.consulcatalog.refreshInterval=30s",
                            "--providers.consulcatalog.exposedByDefault=false",
                            "--providers.consulcatalog.defaultrule=Host(`{{ .Name }}.slab.lan`)",
                            "--providers.consulcatalog.endpoint.tls.insecureskipverify=true",
                        },
                    },
                    Resources: &nomadStructs.Resources{
                        CPU:      512,
                        MemoryMB: 512,
                    },
                    LogConfig: nomadStructs.DefaultLogConfig(),
                    Services: []*nomadStructs.Service{
                        {
                            Name:      "traefik",
                            PortLabel: "websecure",
                            Tags: []string{
                                "traefik.enable=true",
                                "traefik.http.routers.api.rule=Host(`traefik.slab.lan`)",
                                "traefik.http.routers.api.service=api@internal",
                            },
                            TaskName: "traefik",
                            Checks: []*nomadStructs.ServiceCheck{
                                {
                                    Name:          fmt.Sprintf("%s = http check", "traefik"),
                                    Type:          nomadStructs.ServiceCheckHTTP,
                                    Interval:      10 * time.Second,
                                    Timeout:       2 * time.Second,
                                    InitialStatus: "passing",
                                    Path:          "/ping",
                                    PortLabel:     "admin",
                                    TaskName:      "traefik",
                                },
                            },
                            Provider: "consul",
                        },
                    },
                },
            },
            RestartPolicy:    nomadStructs.NewRestartPolicy("service"),
            ReschedulePolicy: &nomadStructs.DefaultServiceJobReschedulePolicy,
            EphemeralDisk: &nomadStructs.EphemeralDisk{
                SizeMB: 256,
            },
            Networks: []*nomadStructs.NetworkResource{
                {
                    Mode: "host",
                    ReservedPorts: []nomadStructs.Port{
                        {
                            Label: "web",
                            Value: 80,
                            To:    0,
                        },
                        {
                            Label: "websecure",
                            Value: 443,
                            To:    0,
                        },
                        {
                            Label: "admin",
                            Value: 8081,
                            To:    0,
                        },
                    },
                },
            },
        },
    },
    Namespace: "default",
    Constraints: []*nomadStructs.Constraint{
        {
            LTarget: "${attr.unique.hostname}",
            RTarget: "worker-0",
            Operand: "regexp",
        },
    },
}

func GetTraefikJob

func GetTraefikJob() (*nomadApi.Job, error)

func convertJob

func convertJob(in *nomadStructs.Job) (*nomadApi.Job, error)

convertJob converts a Nomad Job to a Nomad API Job.

func getStorageArgs

func getStorageArgs(storage string) []string

getStorageArgs returns the common args for the storage controller and node.

TODO: input validation

func promConfigHelper

func promConfigHelper(tmpl string) string

Generated by gomarkdoc