Jumppad

https://jumppad.dev
Admin
Jumppad enables the creation and configuration of lightweight, reproducible, and portable...
Tokens:33,284
Snippets:459
Trust Score:5.5
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Jumppad via quick install script

Source: https://jumppad.dev/docs/introduction/installation

Executes the installation script directly from the Jumppad website.

```bash
curl https://jumppad.dev/install | bash
```

--------------------------------

### Install and Run Exec Resources

Source: https://jumppad.dev/docs/resources/exec

Demonstrates using an exec resource to download and install a binary, followed by a second resource that runs the binary as a daemon.

```hcl
resource "exec" "install" {
  script = <<-EOF
  #!/bin/sh
  OS=$(uname -s | tr '[:upper:]' '[:lower:]')
  ARCH=$(uname -m | tr '[:upper:]' '[:lower:]')

  if [ ! -f /tmp/consul ]; then
    curl -L -o /tmp/consul.zip \
      https://releases.hashicorp.com/consul/1.16.2/consul_1.16.2_$${OS}_$${ARCH}.zip
    cd /tmp && unzip ./consul.zip
  fi
  EOF
}

resource "exec" "run" {
  depends_on = ["resource.exec.install"]

  script = <<-EOF
  #!/bin/sh
  /tmp/consul agent -dev
  EOF

  daemon = true
}
```

--------------------------------

### Clone example blueprints repository

Source: https://jumppad.dev/docs/introduction/running

Downloads the official examples repository to the local machine to access available blueprints.

```bash
git clone https://github.com/jumppad-labs/examples.git
cd examples
```

--------------------------------

### Setup Blueprint Statements

Source: https://jumppad.dev/docs/cli/test

Statements for initializing blueprints with optional paths and versioning.

```gherkin
Scenario: Single Container from Local Blueprint
  Given I have a running blueprint
```

```gherkin
Scenario: Single Container from Local Blueprint
  Given I have a running blueprint using version "0.1.2"
```

```gherkin
Scenario: Single Container from Local Blueprint
  Given I have a running blueprint
  And I have a running blueprint at path "./testsetup/container"
```

```gherkin
Scenario: Single Container from Local Blueprint
  Given I have a running blueprint at path "./testsetup/container" using version "<version>"
  Examples:
    | consul            | envoy    |
    | 1.8.0             | 1.14.3   |
    | 1.7.3             | 1.14.3   |
```

--------------------------------

### Complete nomad_job configuration example

Source: https://jumppad.dev/docs/resources/nomad/nomad_job

A full example showing the definition of a nomad_cluster and a corresponding nomad_job with a health check.

```hcl
resource "nomad_cluster" "dev" {
  network {
    id = resource.network.cloud.meta.id
  }
}

resource "nomad_job" "example" {
  cluster = resource.nomad_cluster.dev.meta.id

  paths = ["./app_config/example1.nomad"]

  health_check {
    timeout    = "60s"
    nomad_jobs = ["example"]
  }
}
```

--------------------------------

### Run Connector

Source: https://jumppad.dev/docs/cli/connector

Starts the connector service with configurable bind addresses and logging options.

```bash
jumppad connector run [flags]
```

--------------------------------

### Purge Command Output Example

Source: https://jumppad.dev/docs/cli/purge

Example output showing the removal of Docker images, Helm charts, and blueprints.

```text
jumppad purge
2020-04-21T14:00:17.962+0100 [INFO]  Removing image: image=docker.io/nicholasjackson/fake-service:v0.9.0
2020-04-21T14:00:17.972+0100 [INFO]  Removing image: image=docker.io/envoyproxy/envoy:v1.14.1
2020-04-21T14:00:17.976+0100 [INFO]  Removing Helm charts: path=/home/nicj/.jumppad/helm_charts
2020-04-21T14:00:17.976+0100 [INFO]  Removing Blueprints: path=/home/nicj/.jumppad/helm_charts
```

--------------------------------

### Install Helm Chart from a Local Folder

Source: https://jumppad.dev/docs/resources/helm

Deploys a Helm chart located in a local directory path.

```hcl
resource "helm" "vault" {
  cluster = resource.k8s_cluster.k3s
  chart   = "./files/helm/vault"

  values_string = {
    "server.dataStorage.size" = "128Mb"
  }
}
```

--------------------------------

### Check current version

Source: https://jumppad.dev/docs/cli/version

Display the currently installed version of Jumppad.

```bash
jumppad version
Current Version: 0.1.4
```

--------------------------------

### Quote and Trim Function Examples

Source: https://jumppad.dev/docs/resources/template

Demonstrate the usage of quote and trim functions for string manipulation.

```text
// given the string abc

quote "abc" // would return the value "abc"
```

```text
// given the string abc

trim " abc " // would return the value "abc"
```

--------------------------------

### Verify Jumppad installation output

Source: https://jumppad.dev/docs/introduction/installation

Expected terminal output confirming successful installation and system diagnostics.

```text
################################
Installing Jumppad to /usr/local/bin/jumppad

Please note: You may be prompted for your password

To remove Jumppad and all configuration use the command "jumppad uninstall"
Downloading https://github.com/jumppad-labs/jumppad/releases/download/v0.20.1/jumppad_0.20.1_linux_x86_64.tar.gz
/usr/bin/sudo
[sudo] password for nicj: 

###### SYSTEM DIAGNOSTICS ######
 [   OK    ] Docker
 [   OK    ] Git
 [   OK    ] xdg-open
```

--------------------------------

### Install CLI Autocomplete

Source: https://jumppad.dev/docs/cli/overview

Generate completion scripts for supported shells including bash, zsh, fish, and powershell.

```bash
jumppad completion [bash|zsh|fish|powershell]
```

--------------------------------

### Install Jumppad via Homebrew

Source: https://jumppad.dev/docs/introduction/installation

Command to install Jumppad on macOS using the Homebrew package manager.

```bash
brew install jumppad-labs/homebrew-repo/jumppad
```

--------------------------------

### Install Helm Chart from a GitHub Repository

Source: https://jumppad.dev/docs/resources/helm

Deploys a Helm chart directly from a GitHub repository URL using values_string for configuration.

```hcl
resource "helm" "vault" {
  cluster = resource.k8s_cluster.k3s
  chart = "github.com/hashicorp/vault-helm"

  values_string = {
    "server.dataStorage.size" = "128Mb"
  }
}
```

--------------------------------

### Configure Terraform with network and environment

Source: https://jumppad.dev/docs/resources/terraform

This example demonstrates integrating a Terraform resource with a network and container, including complex variable structures and environment settings.

```hcl
resource "network" "main" {
  subnet = "10.10.0.0/16"
}

resource "container" "vault" {
  image {
    name = "vault:1.13.3"
  }

  network {
    id = resource.network.main.meta.id
  }

  port {
    local = 8200
    host  = 8200
  }

  environment = {
    VAULT_DEV_ROOT_TOKEN_ID = "root"
  }
}

resource "terraform" "configure_vault" {
  network {
    id = resource.network.main.meta.id
  }

  environment = {
    VAULT_TOKEN = "root"
    VAULT_ADDR  = "http://${resource.container.vault.container_name}:8200"
  }

  variables = {
    first  = "one"
    second = 2
    third = {
      x = 3
      y = 4
    }
  }

  source            = "./workspace"
  working_directory = "/"
  version           = "1.14.8"
}

output "first" {
  value = resource.terraform.configure_vault.output.first
}

output "vault_secret" {
  value = resource.terraform.configure_vault.output.vault_secret
}
```

--------------------------------

### Example Output of jumppad down

Source: https://jumppad.dev/docs/cli/down

Shows the log output generated when running the down command to destroy Kubernetes configurations, ingresses, clusters, and networks.

```text
jumppad down

2020-08-16T13:33:31.160+0100 [INFO]  Destroy Kubernetes configuration: ref=app config=[/home/nicj/go/src/github.com/jumppad-run/jumppad-website/examples/simple_kubernetes/k8s_app]
2020-08-16T13:33:31.160+0100 [INFO]  Destroy Ingress: ref=app type=ingress
2020-08-16T13:33:31.394+0100 [INFO]  Destroy Cluster: ref=k3s
2020-08-16T13:33:31.832+0100 [INFO]  Destroy Network: ref=local
```

--------------------------------

### Environment and Variable Configuration

Source: https://jumppad.dev/docs/cli/test

Statements for setting environment and Jumppad variables, including HCL interpolation examples.

```gherkin
Scenario: Single Container from Local Blueprint
  Given the environment variable "CONSUL_VERSION" has a value "1.8.0"
  And I have a running blueprint
```

```hcl
container "consul" {
  image   {
    name = "consul:${env("CONSUL_VERSION")}"
  }
}
```

```gherkin
Scenario: Single Container from Local Blueprint
  Given the following environment variables are set
    | key            | value                 |
    | CONSUL_VERSION | 1.8.0                 |
    | ENVOY_VERSION  | 1.14.3                |
  And I have a running blueprint
```

```gherkin
Scenario: Single Container from Local Blueprint
  Given the following jumppad variables are set
    | key            | value                 |
    | consul_version | 1.8.0                 |
    | envoy_version  | 1.14.3                |
  And I have a running blueprint
```

--------------------------------

### Reference Container Name

Source: https://jumppad.dev/docs/resources/k8s/kubernetes_cluster

Example of the fully qualified resource name used to address the cluster.

```text
  server.name.k8s-cluster.local.jmpd.in
```

--------------------------------

### Nomad Client Container Names

Source: https://jumppad.dev/docs/resources/nomad/nomad_cluster

Example list of fully qualified resource names for Nomad client nodes.

```text
[
  abse42wsdff.client.name.nomad-cluster.local.jmpd.in,
  kjdf23123.client.name.nomad-cluster.local.jmpd.in,
  123dfkjs.client.name.nomad-cluster.local.jmpd.in,
]
```

--------------------------------

### Install Helm Chart from a Helm Repository

Source: https://jumppad.dev/docs/resources/helm

Deploys a Helm chart by specifying a remote repository URL and a health check configuration.

```hcl
resource "helm" "consul" {
  cluster = resource.k8s_cluster.k3s

  repository {
    name = "hashicorp"
    url  = "https://helm.releases.hashicorp.com"
  }

  chart   = "hashicorp/consul"
  version = "v0.40.0"

  values = "./helm/consul-values.yaml"

  health_check {
    timeout = "240s"
    pods = [
      "component=connect-injector",
      "component=client",
      "component=controller",
      "component=server",
    ]
  }
}
```

--------------------------------

### Define a Task Resource

Source: https://jumppad.dev/docs/resources/docs/task

Example of a task resource configuration including prerequisites, global config, and multiple validation conditions.

```hcl
resource "task" "manual_installation" {
  prerequisites = []
  
  config {
    user = "root"
    target = variable.terraform_target
  }

  condition "binary_exists" {
    description = "Terraform installed on path"

    check {
      script = file("checks/installation/manual_installation/binary_exists")
      failure_message = "terraform binary not found on the PATH"
    }

    solve {
      script = file("checks/installation/manual_installation/solve")
      timeout = 60
    }
  }

  condition "latest_version" {
    description = "Terraform binary is the latest version"

    check {
      script = template_file("checks/installation/manual_installation/version_latest", { name = "terraform"})
      failure_message = "terraform binary is not the latest version"
    }
  }
}
```

--------------------------------

### Define Certificate Authority and Leaf Certificate Resources

Source: https://jumppad.dev/docs/resources/cert/certificate_leaf

Example showing the creation of a CA and a subsequent leaf certificate using the CA's output paths.

```hcl
resource "certificate_ca" "cd_consul_ca" {
  output = data("certs")
}

resource "certificate_leaf" "cd_consul_server" {
  ca_key = resource.certificate_ca.cd_consul_ca.private_key.path
  ca_cert = resource.certificate_ca.cd_consul_ca.certificate.path

  ip_addresses = ["127.0.0.1"]

  dns_names = [
    "localhost",
    "server.${var.cd_consul_dc}.consul",
    "1.consul.server.container.local.jmpd.in",
    "2.consul.server.container.local.jmpd.in",
    "3.consul.server.container.local.jmpd.in"
  ]

  output = data("certs")
}
```

--------------------------------

### Define Variable Files

Source: https://jumppad.dev/docs/resources/internal/variables

Example content for a .vars file used to override default variable values.

```hcl
version = "1.8.1"

subnet = {
  main = "192.1.0.0/16"
  consul = "192.2.0.0/16"
}
```

--------------------------------

### Get .jumppad folder location with jumppad()

Source: https://jumppad.dev/docs/resources/internal/functions

Returns the absolute path to the .jumppad configuration folder.

```hcl
resource "template" "mine" {
  source = "./mysource.txt"
  destination = "./mydestination.txt"

  variables = {
    location = jumppad()
  }
}
```

--------------------------------

### Running tests with purge flag

Source: https://jumppad.dev/docs/cli/test

Example of running tests with the --purge flag to clear cached dependencies.

```bash
jumppad test --purge ./examples/container 
Feature: Docker Container
  In order to test jumppad creates containers correctly
  I should apply a blueprint which defines a simple container setup
  and test the resources are created correctly
  Scenario: Single Container from Local Blueprint                                                                   # examples/container/test/container.feature:6
    Given the following environment variables are set                                                               # test.go:309 -> *CucumberRunner
      | key            | value  |
      | CONSUL_VERSION | 1.8.0  |
      | ENVOY_VERSION  | 1.14.3 |
    And I have a running blueprint                                                                                  # test.go:141 -> *CucumberRunner
    Then the following resources should be running                                                                  # test.go:189 -> *CucumberRunner
      | name                  | type      |
      | onprem                | network   |
      | consul                | container |
      | envoy                 | sidecar   |
      | consul-container-http | ingress   |
    And a HTTP call to "http://consul.container.local.jmpd.in:8500/v1/status/leader" should result in status 200     # test.go:277 -> *CucumberRunner
    And a HTTP call to "http://consul-http.ingress.local.jmpd.in:28500/v1/status/leader" should result in status 200 # test.go:277 -> *CucumberRunner
```

--------------------------------

### Configure a container with a sidecar

Source: https://jumppad.dev/docs/resources/container/sidecar

Example demonstrating the definition of a consul container and an associated envoy sidecar resource.

```hcl
resource "container" "consul" {
  image {
    name = "consul:${variable.consul_version}"
  }

  command = ["consul", "agent", "-config-file", "/config/config.hcl"]

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

  volume {
    source      = resource.template.consul_config.destination
    destination = "/config/config.hcl"
  }

  network {
    id         = resource.network.onprem.meta.id
    ip_address = "10.6.0.200" // optional
    aliases    = ["myalias"]
  }

  environment = {
    something       = variable.something
    foo             = env("BAH")
    file            = file("./conf.txt")
    abc             = "123"
    SHIPYARD_FOLDER = shipyard()
    HOME_FOLDER     = home()
  }
  
  port_range {
    range       = "8500-8502"
    enable_host = true
  }

}

resource "sidecar" "envoy" {
  target = resource.container.consul.meta.id

  image {
    name = "envoyproxy/envoy:v${variable.envoy_version}"
  }

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

  volume {
    source      = data("config")
    destination = "/config"
  }
}
```

--------------------------------

### Define environment variables using output resources

Source: https://jumppad.dev/docs/cli/env

Example of defining an environment variable within a blueprint using an output resource.

```hcl
output "KUBECONFIG" {
  value = k8s_config("k3s")
}
```

--------------------------------

### Matrix Testing Scenario

Source: https://jumppad.dev/docs/cli/test

Use the Examples table to run a scenario multiple times with interpolated values. Column names wrapped in <> are replaced at runtime.

```gherkin
Scenario: Single Container from Local Blueprint with multiple runs
  Given the environment variable "CONSUL_VERSION" has a value "<consul>"
  And the environment variable "ENVOY_VERSION" has a value "<envoy>"
  And I have a running blueprint
  Then the following resources should be running
    | name                      | type      |
    | onprem                    | network   |
    | consul                    | container |
    | envoy                     | sidecar   |
    | consul-container-http     | ingress   |
  And a HTTP call to "http://consul-http.ingress.local.jmpd.in:8500/v1/status/leader" should result in status 200
  And the response body should contain "10.6.0.200"
  Examples:
    | consul            | envoy    |
    | 1.8.0             | 1.14.3   |
    | 1.7.3             | 1.14.3   |
```

--------------------------------

### Build and deploy a container

Source: https://jumppad.dev/docs/resources/build

Demonstrates using a build resource to create an image, which is then referenced by a container resource.

```hcl
resource "build" "app" {
  container {
    dockerfile = "Dockerfile"
    context    = "./src"
  }
}

resource "container" "app" {
  image {
    name = resource.build.app.image
  }

  command = ["/bin/app"]

  port {
    local  = 9090
    remote = 9090
    host   = 9090
  }

  network {
    id = resource.network.onprem.meta.id
  }
}
```

--------------------------------

### Usage syntax for the up command

Source: https://jumppad.dev/docs/cli/up

Basic command structure for initiating resource creation.

```bash
jumppad up <file|directory|url> [flags]
```

--------------------------------

### Reference a Nomad Cluster

Source: https://jumppad.dev/docs/resources/k8s/kubernetes_config

Example of referencing a cluster for job application.

```hcl
  resource "nomad_job" "example" {
    cluster = resource.nomad_cluster.dev
    ...
  }
```

--------------------------------

### Define and Use Simple Variables

Source: https://jumppad.dev/docs/resources/internal/variables

Demonstrates defining simple string variables and referencing them in resources using direct access or interpolation.

```hcl
variable "version" {
  default = "1.6.1"
}

variable "subnet`" {
  default = "10.6.0.0/16"
}

resource "network" "onprem" {
  subnet = variable.subnet
}

resource "container" "consul" {
  image   {
    name = "consul:${variable.version}"
  }

  command = ["consul", "agent", "-dev"]

  network   {
    id = resource.network.onprem.meta.id
    ip_address = "10.6.0.200"
  }
}
```

--------------------------------

### Run a local blueprint

Source: https://jumppad.dev/docs/introduction/running

Executes a blueprint from a local directory path. This command initializes resources and opens defined browser windows.

```bash
jumppad up ./kubernetes-vault
Running configuration from:  ./kubernetes-vault

2020-04-04T17:15:28.988+0100 [DEBUG] Statefile does not exist
2020-04-04T17:15:28.989+0100 [INFO]  Creating Network: ref=cloud
2020-04-04T17:15:44.012+0100 [INFO]  Creating Container: ref=tools
2020-04-04T17:15:44.012+0100 [INFO]  Creating Cluster: ref=k3s
2020-04-04T17:15:44.012+0100 [INFO]  Creating Documentation: ref=docs
```

--------------------------------

### Version command usage

Source: https://jumppad.dev/docs/cli/version

General syntax for executing the version command.

```bash
jumppad version [command] [flags]
```

--------------------------------

### Get Docker host IP with docker_ip()

Source: https://jumppad.dev/docs/resources/internal/functions

Retrieves the IP address of the configured Docker host.

```hcl
resource "template" "mine" {
  source = "./mysource.txt"
  destination = "./mydestination.txt"

  variables = {
    url = "${docker_ip()}:8080"
  }
}
```

--------------------------------

### Get current directory with dir()

Source: https://jumppad.dev/docs/resources/internal/functions

Returns the directory path of the file containing the current resource.

```hcl
resource "template" "mine" {
  source = "${dir()}/mysource.txt"
  destination = "./mydestination.txt"
}
```

--------------------------------

### Reuse modules with dependencies

Source: https://jumppad.dev/docs/resources/internal/module

Demonstrates instantiating the same module multiple times with different configurations and managing execution order using depends_on.

```hcl
resource "network" "cloud" {
  subnet = "10.5.0.0/16"
}

module "consul_dc1" {
  source = "./module_k3s"

  variables = {
    network_id  = resource.network.cloud.meta.id
    consul_port = 18500
  }
}

module "consul_dc2" {
  // CI has limited resources, add a manual dependency to ensure that only one module
  // is created at once
  depends_on = ["module.consul_dc1"]

  source = "./module_k3s"

  variables = {
    network_id  = resource.network.cloud.meta.id
    consul_port = 18501
  }
}

output "dc1_addr" {
  value = module.consul_dc1.output.consul_http_addr
}

output "dc2_addr" {
  value = module.consul_dc2.output.consul_http_addr
}
```

--------------------------------

### Create temporary data folder with data()

Source: https://jumppad.dev/docs/resources/internal/functions

Creates a temporary folder with 755 permissions that persists until jumppad down is called.

```hcl
resource "template" "mine" {
  source = "./mysource.txt"
  destination = "${data("temp")}/file.txt"

  variables = {
    DOCKER_HOST = docker_host
  }
}
```

--------------------------------

### Define an Ingress Resource

Source: https://jumppad.dev/docs/resources/ingress

Example of configuring an ingress resource to route traffic to a Kubernetes cluster service.

```hcl
resource "k8s_cluster" "dev" {
}

resource "ingress" "consul_http" {
  port = 18500

  target {
    resource = resource.k8s_cluster.dev
    port     = 8500

    config = {
      service   = "consul-consul-server"
      namespace = "default"
    }
  }
}
```

--------------------------------

### Create a stack from a GitHub blueprint

Source: https://jumppad.dev/docs/cli/up

Deploy a stack directly from a remote GitHub repository path.

```bash
jumppad up github.com/jumppad-up/blueprints//vault-k8s
... output
```

--------------------------------

### Basic usage of jumppad env

Source: https://jumppad.dev/docs/cli/env

Displays the standard command syntax for the env command.

```bash
jumppad env [flags]
```

--------------------------------

### Define container command

Source: https://jumppad.dev/docs/resources/container/container

Specify an array of strings to execute a command upon container startup.

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

--------------------------------

### Get Docker host address with docker_host

Source: https://jumppad.dev/docs/resources/internal/functions

Returns the socket or TCP address for the current Docker host.

```hcl
resource "template" "mine" {
  source = "./mysource.txt"
  destination = "./mydestination.txt"

  variables = {
    DOCKER_HOST = docker_host
  }
}
```

--------------------------------

### Build application and extract artifacts

Source: https://jumppad.dev/docs/resources/build

Builds an application within a container and copies the resulting binary to the local host.

```hcl
resource "build" "app" {
  container {
    dockerfile = "Dockerfile"
    context    = "./src"
  }

  output {
    source = "/go/src/github.com/jumppad-labs/jumppad/bin"
    destination = "${data("local_app")}/bin"
  }
}

resource "exec" "app" {
  script = <<-EOF
    jumppad up ./config
  EOF
}
```

--------------------------------

### run_as

Source: https://jumppad.dev/docs/resources/container/container

Configures the user and group identity for running container processes.

```APIDOC
## run_as

### Parameters
- **user** (string) - Linux user ID or name.
- **group** (string) - Linux group ID or name.
```

--------------------------------

### http_health_check

Source: https://jumppad.dev/docs/resources/container/sidecar

Configures an HTTP health check that executes a GET request and validates the response against expected status codes.

```APIDOC
## http_health_check

### Description
A HTTP health check executes a HTTP request for the given address and evaluates the response against the expected `success_codes`.

### Parameters
- **address** (string) - Required - The URL to check.
- **method** (string) - Optional - HTTP method to use when executing the check (default: GET).
- **body** (string) - Optional - HTTP body to send with the request.
- **headers** (map[string][string]) - Optional - HTTP headers to send with the check.
- **success_codes** ([]number) - Optional - HTTP status codes that indicate the check passed (default: 200).

### Configuration Example
```
http {
  address = "http://localhost:8500/v1/status/leader"
  method  = "GET"
  body    = <<-EOF
    {"test": "123"}
  EOF
  headers = {
    "X-Auth-Token": ["abc123"]
  }
  success_codes = [200]
}
```
```

--------------------------------

### Building a container

Source: https://jumppad.dev/docs/resources/container/sidecar

Configures build parameters for creating a container from a Dockerfile.

```hcl
  build   {
    file = "./Dockerfile"
    context = "./src"
  }
```

--------------------------------

### Gherkin test feature definition

Source: https://jumppad.dev/docs/cli/test

Example of a Gherkin feature file defining environment variables and resource assertions for a blueprint.

```gherkin
Feature: Docker Container
  In order to test jumppad creates containers correctly
  I should apply a blueprint which defines a simple container setup
  and test the resources are created correctly
Scenario: Single Container from Local Blueprint
  Given the following environment variables are set
    | key            | value                 |
    | CONSUL_VERSION | 1.8.0                 |
    | ENVOY_VERSION  | 1.14.3                |
  And I have a running blueprint
  Then the following resources should be running
    | name                      | type      |
    | onprem                    | network   |
    | consul                    | container |
    | envoy                     | sidecar   |
    | consul-container-http     | ingress   |
  And a HTTP call to "http://consul.container.local.jmpd.in:8500/v1/status/leader" should result in status 200
  And a HTTP call to "http://consul-http.ingress.local.jmpd.in:28500/v1/status/leader" should result in status 200
```

--------------------------------

### Pass a variable file

Source: https://jumppad.dev/docs/cli/up

Load configuration variables from a specified file.

```bash
jumppad up github.com/jumppad-up/blueprints//vault-k8s --vars-file ./jumppad.vars
... output
```

--------------------------------

### Define a minimal container resource

Source: https://jumppad.dev/docs/resources/container/container

Creates a container from a registry image with basic network configuration.

```hcl
resource "container" "unique_name" {
    network {
        id         = resource.network.cloud.meta.id
        ip_address = "10.16.0.203"
        aliases    = ["my_unique_name_ip_address"]
    }

    image {
        name = "consul:1.6.1"
    }
}
```

--------------------------------

### Nomad Server Container Name

Source: https://jumppad.dev/docs/resources/nomad/nomad_cluster

Example of the fully qualified resource name for the Nomad server used for Docker network addressing.

```text
  server.name.nomad-cluster.local.jmpd.in
```

--------------------------------

### Run Jumppad in development mode

Source: https://jumppad.dev/docs/cli/dev

Executes the dev command on a specified configuration directory to enable automatic updates.

```bash
jumppad dev ./config_folder
```

--------------------------------

### data(name)

Source: https://jumppad.dev/docs/resources/internal/functions

Creates a temporary folder that exists until jumppad down is executed.

```APIDOC
## data(name)

### Description
The `data` function creates a temporary folder that exists until `jumppad down` is executed. Data folders are created with the permissions `755`. First use of `data` creates the folder inside of `.jumppad/data`, subsequent uses return the path.

### Parameters
- **name** (string) - Required - Name of the data folder to create, or path to return.
```

--------------------------------

### Jumppad test command usage

Source: https://jumppad.dev/docs/cli/test

Basic syntax for executing the test command against a specified blueprint.

```bash
jumppad test <blueprint>
```

--------------------------------

### Run system dependency check

Source: https://jumppad.dev/docs/cli/check

Executes the check command to verify the environment configuration.

```bash
jumppad check
```

--------------------------------

### Define script execution methods

Source: https://jumppad.dev/docs/resources/exec

Demonstrates inline scripts, file-based scripts, and template-based scripts for the exec resource.

```hcl
resource "exec" "inline" {
  script = <<-EOF
  #!/bin/bash
  ls -lha
  EOF
}

resource "exec" "file" {
  script = file("script.sh")
}

resource "exec" "template" {
  script = template_file("script.sh.tpl", {
    foo = "bar"
  })
}
```

--------------------------------

### Configure HTTP health check

Source: https://jumppad.dev/docs/resources/container/container

Defines an HTTP GET request health check with custom headers, body, and expected success status codes.

```hcl
http {
  address = "http://localhost:8500/v1/status/leader"
  method  = "GET"
  body    = <<-EOF
    {"test": "123"}
  EOF
  headers = {
    "X-Auth-Token": ["abc123"]
  }
  success_codes = [200]
}
```

--------------------------------

### Create data folder with permissions

Source: https://jumppad.dev/docs/resources/internal/functions

Use data_with_permissions to define a temporary directory with specific octal permissions that persists until the environment is torn down.

```hcl
resource "template" "mine" {
  source = "./mysource.txt"
  destination = "${data_with_permissions("temp", 644)}/file.txt"

  variables = {
    DOCKER_HOST = docker_host
  }
}
```

--------------------------------

### data_with_permissions(name, permissions)

Source: https://jumppad.dev/docs/resources/internal/functions

Creates a temporary folder with specified permissions that persists until the jumppad down command is executed.

```APIDOC
## data_with_permissions(name, permissions)

### Description
Creates a temporary folder that exists until `jumppad down` is executed. Allows specifying directory permissions.

### Parameters
- **name** (string) - Required - Name of the data folder to create, or path to return.
- **permissions** (int) - Required - Permissions for the directory.

### Example
```
resource "template" "mine" {
  source = "./mysource.txt"
  destination = "${data_with_permissions("temp", 644)}/file.txt"

  variables = {
    DOCKER_HOST = docker_host
  }
}
```
```

--------------------------------

### Create a stack from a directory

Source: https://jumppad.dev/docs/cli/up

Recursively process a directory to create a stack.

```bash
jumppad up ./-stack
... output
```

--------------------------------

### Usage of the output command

Source: https://jumppad.dev/docs/cli/output

Basic syntax for retrieving Blueprint variables.

```bash
jumppad output [variable]
```

--------------------------------

### Configure Claude Desktop for Context7

Source: https://jumppad.dev/docs/introduction/context7

Add this JSON block to the Claude Desktop MCP settings file to enable the server.

```json
{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["@context7/mcp-server"]
    }
  }
}
```

--------------------------------

### Create a full Kubernetes cluster with Helm and Ingress

Source: https://jumppad.dev/docs/resources/k8s/kubernetes_cluster

Configures a cluster with image pre-loading, local Kubernetes manifests, a remote Helm chart, and ingress rules for service access.

```hcl
resource "network" "cloud" {
  subnet = "10.5.0.0/16"
}

resource "k8s_cluster" "k3s" {
  network {
    id = resource.network.cloud.meta.id
  }

  copy_image {
    name = "shipyardrun/connector:v0.1.0"
  }
}

resource "k8s_config" "fake_service" {
  cluster = resource.k8s_cluster.k3s

  paths = ["./fake_service.yaml"]

  health_check {
    timeout = "240s"
    pods    = ["app.kubernetes.io/name=fake-service"]
  }
}

resource "helm" "vault" {
  cluster = resource.k8s_cluster.k3s

  repository {
    name = "hashicorp"
    url  = "https://helm.releases.hashicorp.com"
  }

  chart   = "hashicorp/vault"
  version = "v0.18.0"

  values = "./helm/vault-values.yaml"

  health_check {
    timeout = "240s"
    pods    = ["app.kubernetes.io/name=vault"]
  }
}

resource "ingress" "vault_http" {
  port = 18200

  target {
    resource = resource.k8s_cluster.k3s
    port = 8200

    config = {
      service   = "vault"
      namespace = "default"
    }
  }
}

resource "ingress" "fake_service" {
  port = 19090

  target {
    resource = resource.k8s_cluster.k3s
    port = 9090

    config = {
      service   = "fake-service"
      namespace = "default"
    }
  }
}

output "VAULT_ADDR" {
  value = "http://${resource.ingress.vault_http.local_address}"
}

output "KUBECONFIG" {
  value = resource.k8s_cluster.k3s.kube_config.path
}
```

--------------------------------

### Run a blueprint from Git

Source: https://jumppad.dev/docs/introduction/running

Downloads and executes a blueprint directly from a remote Git repository.

```bash
jumppad up github.com/jumppad-labs/examples//kubernetes-vault
```

--------------------------------

### Define and Access List Outputs

Source: https://jumppad.dev/docs/resources/internal/output

Demonstrates defining a list of numbers and accessing specific elements using zero-based indexing.

```hcl
output "list" {
  value = [1,2,3] 
}
```

```hcl
output "list_value" {
  value = output.list.2 // 3
}
```

--------------------------------

### Define a full container resource

Source: https://jumppad.dev/docs/resources/container/container

Configures a container with dependencies, registry credentials, custom commands, environment variables, volumes, and port mappings.

```hcl
resource "container" "unique_name" {
    depends_on = ["resource.container.another"]

    network {
        id         = resource.network.cloud.meta.id
        ip_address = "10.16.0.200"
        aliases    = ["my_unique_name_ip_address"]
    }

    image {
        name     = "consul:1.6.1"
        username = "repo_username"
        password = "repo_password"
    }

    command = [
        "consul",
        "agent"
    ]

    environment = {
        CONSUL_HTTP_ADDR = "http://localhost:8500"
    }

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

    port {
        local  = 8500
        remote = 8500
        host   = 18500
    }
    
    port_range {
        range       = "9000-9002"
        enable_host = true
    }

    privileged = false
}
```

--------------------------------

### Basic Exec Usage

Source: https://jumppad.dev/docs/cli/exec

The general syntax for executing a command within a target resource.

```bash
jumppad exec <target> -- <command>
```

--------------------------------

### Connector Usage

Source: https://jumppad.dev/docs/cli/connector

General usage pattern for the connector command.

```bash
jumppad connector <command>
```

--------------------------------

### Tail logs for all resources

Source: https://jumppad.dev/docs/cli/logs

Streams logs from all currently running resources.

```bash
jumppad logs
[docker-cache]       # Secondary tier caching of manifests; configure via MANIFEST_CACHE_SECONDARY_REGEX and MANIFEST_CACHE_SECONDARY_TIME
[docker-cache]       location ~ ^/v2/(.*)/manifests/(.*)(\d|\.)+(.*)(\d|\.)+(.*)(\d|\.)+ {
[docker-cache]           set $docker_proxy_request_type "manifest-secondary";
[docker-cache]           proxy_cache_valid 60d;
[docker-cache]           include "/etc/nginx/nginx.manifest.stale.conf";
[users-1]   Aug 10 12:20:16 users-1 consul[80]: 2021-08-10T12:20:16.994Z [ERROR] agent.client: RPC failed to server: method=Intention.Match server=10.0.0.3:8300 error="rpc error making call: Permission denied"
[users-1]   Aug 10 12:20:17 users-1 consul[80]: 2021-08-10T12:20:17.642Z [DEBUG] agent.client.memberlist.lan: memberlist: Stream connection from=10.0.0.3:41084
[users-1]   Aug 10 12:20:18 users-1 consul[174]: [2021-08-10 12:20:18.290][174][debug][main] [source/server/server.cc:209] flushing stats
[server]   Aug 10 12:20:47 server consul[58]: 2021-08-10T12:20:47.613Z [WARN]  agent.server.intentions: Operation on intention prefix denied due to ACLs: prefix=users accessorID=
[server]   Aug 10 12:20:47 server consul[58]: 2021-08-10T12:20:47.644Z [DEBUG] agent.server.memberlist.lan: memberlist: Initiating push/pull sync with: users-1 10.0.0.2:8301
[server]   Aug 10 12:20:48 server consul[58]: 2021-08-10T12:20:48.152Z [WARN]  agent.server.intentions: Operation on intention prefix denied due to ACLs: prefix=users accessorID=
[users-1]   Aug 10 12:20:48 users-1 consul[80]: 2021-08-10T12:20:48.152Z [ERROR] agent.client: RPC failed to server: method=Intention.Match server=10.0.0.3:8300 error="rpc error making call: Permission denied"
[users-1]   Aug 10 12:20:48 users-1 consul[174]: [2021-08-10 12:20:48.309][174][debug][main] [source/server/server.cc:209] flushing stats
```

--------------------------------

### Create a Root Certificate

Source: https://jumppad.dev/docs/resources/cert/certificate_ca

Defines a certificate_ca resource with a specified output directory for the generated files.

```hcl
resource "certificate_ca" "cd_consul_ca" {
  output = data("certs")
}
```

--------------------------------

### home()

Source: https://jumppad.dev/docs/resources/internal/functions

Retrieves the path to the current user's home directory.

```APIDOC
## home()

### Description
The `home` function returns the absolute path of the current user's HOME folder.

### Example
```
variables = {
  home = home()
}
```
```

--------------------------------

### jumppad()

Source: https://jumppad.dev/docs/resources/internal/functions

Returns the location of the .jumppad folder.

```APIDOC
## jumppad()

### Description
The `jumppad` function returns the location of the `.jumppad` folder.
```

--------------------------------

### Create a stack from a specific file

Source: https://jumppad.dev/docs/cli/up

Target a specific HCL file to define the stack.

```bash
jumppad up my-stack/network.hcl
... output
```

--------------------------------

### Configure a Docker Image

Source: https://jumppad.dev/docs/resources/docs/docs

Defines a container image with authentication credentials using environment variables.

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

--------------------------------

### Set output variables in an exec script

Source: https://jumppad.dev/docs/resources/exec

Demonstrates how to capture output variables by writing key-value pairs to the file path specified by the EXEC_OUTPUT environment variable.

```hcl
resource "exec" "inline" {
  script = <<-EOF
  #!/bin/bash
  ls -lha

  echo "FOO=BAR" > ${EXEC_OUTPUT}
  EOF
}

output "foo" {
  value = resource.exec.inline.output.FOO
}
```

--------------------------------

### Load Shell Completions

Source: https://jumppad.dev/docs/cli/overview

Commands to initialize autocompletion in the current session or persist it for future sessions on Linux and macOS.

```bash
source <(yourprogram completion bash)

# To load completions for each session, execute once:
# Linux:
jumppad completion bash > /etc/bash_completion.d/jumppad

# macOS:
jumppad completion bash > /usr/local/etc/bash_completion.d/jumppad
```

--------------------------------

### Open Default Shell in Container

Source: https://jumppad.dev/docs/cli/exec

Initiate the default shell session inside a specified container.

```bash
jumppad exec container.consul
```

--------------------------------

### Configure Helm values from a file

Source: https://jumppad.dev/docs/resources/helm

Specifies a local file path for Helm chart values.

```hcl
resource "helm" "mychart" {
  values = "./values.yaml"
}
```

--------------------------------

### Use template helpers

Source: https://jumppad.dev/docs/resources/internal/functions

Template helpers like file, quote, and trim can be used within template source blocks.

```hcl
resource "template" "consul_config" {

  source = <<-EOF

  file_content = "{{ file "./myfile.txt" }}"
  quote = {{quote something}} 
  trim = {{quote (trim with_whitespace)}}

  EOF

  destination = "./consul_config/consul.hcl"
}
```

--------------------------------

### Jumppad logs command usage

Source: https://jumppad.dev/docs/cli/logs

Basic syntax for the logs command.

```bash
jumppad logs [target]
```

--------------------------------

### resources

Source: https://jumppad.dev/docs/resources/container/container

Configures resource limits for the container, including CPU, memory, and GPU passthrough.

```APIDOC
## resources

### Parameters
- **cpu** (int) - Maximum CPU consumption in MHz.
- **cpu_pin** ([]number) - Logical CPUs to pin the container to.
- **memory** (string) - Maximum memory in Megabytes.
- **gpu** (gpu) - GPU settings configuration.
```

--------------------------------

### Configure Template Source

Source: https://jumppad.dev/docs/resources/template

Define the template source using either a local file path or inline HereDoc content.

```hcl
  source = "myfile.txt"
```

```hcl
  source = <<-EOF
  My inline content
  EOF
```

--------------------------------

### gpu

Source: https://jumppad.dev/docs/resources/container/container

Configures GPU device passthrough for accelerated workloads.

```APIDOC
## gpu

### Parameters
- **driver** (string) - The GPU driver to use (e.g., "nvidia").
- **device_ids** ([]string) - List of GPU device IDs to pass to the container.
```

--------------------------------

### Configure Helm values using a map

Source: https://jumppad.dev/docs/resources/helm

Provides Helm values directly as a map of strings.

```hcl
resource "helm" "mychart" {
  values_string = {
    "global.storage" = "128Mb"
  }
}
```

--------------------------------

### template_file(path, variables)

Source: https://jumppad.dev/docs/resources/internal/functions

Renders the contents of a template file at the given path using provided input variables.

```APIDOC
## template_file(path, variables)

### Description
Returns the rendered contents of a template file at the given path with the given input variables using the Handlebars templating language.

### Parameters
- **path** (string) - Required - Path to the template file.
- **variables** (map[string]interface) - Required - Input variables for the template.

### Example
```
mytype "test" {
  my_file = template_file("./mytemplate.tmpl", {
    name = "world"
  })
}
```
```

--------------------------------

### Display all variables

Source: https://jumppad.dev/docs/cli/output

Retrieves all defined variables in the system as a JSON object.

```bash
jumppad output
{
  "KUBECONFIG": "/home/nicj/.jumppad/config/k3s/kubeconfig-docker.yaml"
}
```

--------------------------------

### Customize a stack with variables

Source: https://jumppad.dev/docs/cli/up

Override configuration variables using the --var flag.

```bash
jumppad up github.com/jumppad-up/blueprints//vault-k8s --var network=dc1
... output
```

--------------------------------

### Implicit dependency via interpolation

Source: https://jumppad.dev/docs/resources/internal/meta

Jumppad automatically creates dependency graphs when properties are interpolated between resources.

```hcl
  resource "container" "mine" {
    image {
      name = resource.container.myother.image.name
    }
  }
  
  resource "container" "myother" {
    image {
      name = "myimage:version"
    }
  }
```

--------------------------------

### Add Docker labels

Source: https://jumppad.dev/docs/resources/container/container

Apply metadata labels to the container.

```hcl
labels = {
  "com.example.version" = "1.0"
  "com.example.app" = "myapp"
}
```

--------------------------------

### Define container build configuration

Source: https://jumppad.dev/docs/resources/build

Specifies the Dockerfile and build context for the container image.

```hcl
container {
  dockerfile = "Dockerfile"
  context    = "./src"
}
```

--------------------------------

### Configure docs resource in HCL

Source: https://jumppad.dev/docs/resources/docs/docs

Defines a docs resource with network, image, logo, and asset path configurations.

```hcl
resource "docs" "docs" {
  network {
    id = resource.network.main.meta.id
  }

  image {
    name = "ghcr.io/jumppad-labs/docs:v0.4.0"
  }

  logo {
    url = "https://mycompany.com/logo.png"
    width = 32
    height = 32
  }

  content = [
    module.course.output.book
  ]

 assets = "${dir()}/assets"
}
```

--------------------------------

### Configure VS Code for Context7

Source: https://jumppad.dev/docs/introduction/context7

Add this configuration to your VS Code settings to integrate the Context7 MCP server with GitHub Copilot.

```json
{
  "mcp": {
    "servers": {
      "context7": {
        "type": "http",
        "url": "https://mcp.context7.com/mcp"
      }
    }
  }
}
```

--------------------------------

### Create a simple Kubernetes cluster

Source: https://jumppad.dev/docs/resources/k8s/kubernetes_cluster

Defines a basic single-node Kubernetes cluster within a network and outputs the path to the generated kubeconfig file.

```hcl
resource "network" "cloud" {
  subnet = "10.5.0.0/16"
}

resource "k8s_cluster" "k3s" {
  network {
    id = resource.network.cloud.meta.id
  }
}

output "KUBECONFIG" {
  value = resource.k8s_cluster.k3s.kube_config.path
}
```

--------------------------------

### Define resource dependencies

Source: https://jumppad.dev/docs/resources/internal/meta

Explicitly define resource creation order using the depends_on property.

```hcl
  resource "container" "mine" {
    depends_on = ["resource.container.myother"]
  }
  
  resource "container" "myother" {

  }
```

--------------------------------

### Basic Purge Usage

Source: https://jumppad.dev/docs/cli/purge

Execute the purge command to clear cached assets.

```bash
jumppad purge
```
Tokens:
Raw