Container container

Network attaches the container to an existing network defined in a separate stanza. This block can be specified multiple times to attach the container to multiple networks.

Image defines a Docker image to use when creating the container.

Entrypoint for the container, if not set, Jumppad starts the container using the entrypoint defined in the Docker image.

Command allows you to specify a command to execute when starting a container. Command is specified as an array of strings, each part of the command is a separate string.

For example, to start a container and follow logs at /dev/null the following command could be used.

command = [
    "tail",
    "-f",
    "/dev/null"
]

Allows you to set environment variables in the container.

environment = {
  PATH = "/user/local/bin"
}

A volume allows you to specify a local volume which is mounted to the container when it is created. This stanza can be specified multiple times.

  volume {
    source      = "./"
    destination = "/files"
  }

A port stanza allows you to expose container ports on the local network or host. This stanza can be specified multiple times.

  port {
    local = 80
    remote = 80
    host  = 8080
  }

A port_range stanza allows you to expose a range of container ports on the local network or host. This stanza can be specified multiple times.

The following example would create 11 ports from 80 to 90 (inclusive) and expose them to the host machine.

  port {
    range       = "80-90"
    enable_host = true
  }

Should the container run in Docker privileged mode?

The maximum number of times a container will be restarted when it exits with a status code other than 0

Define resource constraints for the container

Define a health check for the container, the resource will only be marked as successfully created when the health check passes.

  health_check {
    timeout = "30s"
    http {
      address = "http://localhost:8500/v1/status/leader"
      success_codes = [200]
    }
    
    tcp {
      address = "localhost:8500"
    }
    
   exec {
      script = <<-EOF
        #!/bin/bash

        curl "http://localhost:9090"
      EOF
    }
  }

Allows the container to be run as a specific user or group.

  run_as {
    user = "1000"
    group = "nicj"
  }

Fully qualified resource name for the container, this value can be used to access the container from within the Docker network. container_name is also the name of the created Docker container.

  name.container.local.jmpd.in

ID of the network to attach the container to, specified in reference format. e.g. to attach to a network called cloud

network {
  id = "network.cloud"
}

Static IP address to assign container for the network, the ip address must be within range defined by the network subnet. If this parameter is omitted an IP address will be automatically assigned.

Aliases allow alternate names to specified for the container. Aliases can be used to reference a container across the network, the container will respond to ping and other network resolution using the primary assigned name [name].container.shipyard.run and the aliases.

network {
  name    = "network.cloud"
  aliases = [
    "alt1.container.local.jmpd.in", 
    "alt2.container.local.jmpd.in"
  ]
}

Name will equal the name of the network as created by jumppad.

assigned_address will equal the assigned IP address for the network. This will equal ip_address if set; otherwise, this is the automatically assigned ip_address.

Name of the image to use when creating the container, can either be the full canonical name or short name for Docker official images. e.g. consul:v1.6.1 or docker.io/consul:v1.6.1.

Username to use when connecting to a private image repository

Password to use when connecting to a private image repository, for both username and password interpolated environment variables can be used in place of static values.

image {
  name = "myregistry.io/myimage:latest"
  username = env("REGISTRY_USERNAME")
  password = env("REGISTRY_PASSWORD")
}

The source volume to mount in the container, can be specified as a relative ./ or absolute path /usr/local/bin. Relative paths are relative to the file declaring the container.

The destination in the container to mount the volume to, must be an absolute path.

The type of the mount, can be one of the following values:

• bind: bind the source path to the destination path in the container
• volume: source is a Docker volume
• tmpfs: create a temporary filesystem

Configures bind propagation for Docker volume mounts, only applies to bind mounts, can be one of the following values:

• shared
• slave
• private
• rslave
• rprivate

For more information please see the Docker documentation https://docs.docker.com/storage/bind-mounts/#configure-bind-propagation

Configures recursiveness of the bind mount. By default Docker mounts with the equivalent of mount --rbind meaning that mounts below the the source directory are visible in the container. For instance running docker run --rm --mount type=bind,src=/,target=/host,readonly busybox will make /run of the host available as /host/run in the container -- and to make matters even worse it will be writable (since only the toplevel bind is set readonly, not the children). If bind_propagation_non_recursive is set to true then the container will only see an empty /host/run, meaning the tmpfs which is typically mounted to /run on the host is not propagated into the container.

Configures Selinux relabeling for the container (usually specified as :z or :Z) and can be one of the following values:

• shared (Equivalent to :z)
• private (Equivalent to :Z)

The local port in the container.

The host port to map the local port to.

The protocol to use when exposing the port, can be "tcp", or "udp".

Should a browser window be automatically opened when this resource is created. Browser windows will open at the path specified by this property.

The port range to expose, e.g, 8080-8082 would expose the ports 8080, 8081, 8082.

The host port to map the local port to.

The protocol to use when exposing the port, can be "tcp", or "udp".

The maximum duration to wait before marking the health check as failed. Expressed as a Go duration, e.g. 1s = 1 second, 100ms = 100 milliseconds.

HTTP Health Check block defining the address to check and expected status codes.

Can be specified more than once.

TCP Health Check block defining the address to test.

Can be specified more than once.

Exec Health Check block defining either a command to run in the current container, or a script to execute.

Can be specified more than once.

The URL to check, health check expects a HTTP status code to be returned by the URL in order to pass the health check.

HTTP method to use when executing the check

HTTP body to send with the request

HTTP body to send with the request

HTTP headers to send with the check

HTTP status codes returned from the endpoint when called. If the returned status code matches any in the array then the health check will pass.

The adress to check.

A command to execute.

exec {
  command = ["pg_isready"]
}

A script to execute in the target container, the script is coppied to the container into the /tmp directory and is then executed.

exec {
  script = <<-EOF
    #!/bin/bash
    
    FILE=/etc/resolv.conf
    if [ -f "$FILE" ]; then
        echo "$FILE exists."
    fi
  EOF
}

Set the maximum CPU which can be consumed by the container in MHz, 1 CPU == 1000MHz.

Pin the container CPU consumption to one or more logical CPUs. For example to pin the container to the core 1 and 4.

resources {
  cpi_pin = [1,4]
}

Maximum memory which a container can consume, specified in Megabytes.

GPU settings to pass through to container

The GPU driver to use, i.e "nvidia", note: This has not been tested this with AMD or other GPUs.

The GPUs to pass to the container, i.e "0", "1", "2".

Linux user ID or user name to run the container as, this overrides the default user configured in the container image.

Linux group ID or group name to run the container as, this overrides the default group configured in the container image.