resilien
/
terraform
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Update FAQ and Glossary

This commit is contained in:
Seth Vargo 2017-04-07 00:00:26 -04:00
parent bbb8d1fe6d
commit 85900595bc
No known key found for this signature in database
GPG Key ID: C921994F9C27E0FF
4 changed files with 310 additions and 290 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
website/source/docs/enterprise/faq/index.html.md
View File

@ -1,6 +1,6 @@
--- ---
layout: "enterprise" layout: "enterprise"
page_title: "Terraform Enterprise FAQs" page_title: "FAQ - Terraform Enterprise"
sidebar_current: "docs-enterprise-faq" sidebar_current: "docs-enterprise-faq"
description: |- description: |-
Frequently Asked Questions. Frequently Asked Questions.

254
website/source/docs/enterprise/faq/monolithic-artifacts.html.md
View File

@ -1,6 +1,6 @@
--- ---
layout: "enterprise" layout: "enterprise"
page_title: "FAQ: Monolithic Artifacts" page_title: "Monolithic Artifacts - FAQ - Terraform Enterprise"
sidebar_current: "docs-enterprise-faq-monolithic" sidebar_current: "docs-enterprise-faq-monolithic"
description: |- description: |-
How do I build multiple applications into one artifact? How do I build multiple applications into one artifact?
@ -10,140 +10,150 @@ description: |-
*How do I build multiple applications into one artifact?* *How do I build multiple applications into one artifact?*
Create your new Applications in Terraform Enterprise using the application compilation feature. Create your new Applications in Terraform Enterprise using the application
compilation feature.
You can either link each Application to the single Build Template you will be using to create the monolithic artifact, or run periodic Packer builds. You can either link each Application to the single Build Template you will be
using to create the monolithic artifact, or run periodic Packer builds.
Each time an Application is pushed, it will store the new application version in the artifact registry as a tarball. These will be available for you to download at build-time on the machines they belong. Each time an Application is pushed, it will store the new application version in
the artifact registry as a tarball. These will be available for you to download
at build-time on the machines they belong.
Here's an example `compile.json` template that you will include with the rest of your application files that do the compiling: Here's an example `compile.json` template that you will include with the rest of
your application files that do the compiling:
```json
{
"variables": {
"app_slug": "{{ env `ATLAS_APPLICATION_SLUG` }}"
},
"builders": [
{ {
"variables": { "type": "docker",
"app_slug": "{{ env `ATLAS_APPLICATION_SLUG` }}" "image": "ubuntu:14.04",
}, "commit": true
"builders": [
{
"type": "docker",
"image": "ubuntu:14.04",
"commit": true
}
],
"provisioners": [
{
"type": "shell",
"inline": [
"apt-get -y update"
]
},
{
"type": "file",
"source": ".",
"destination": "/tmp/app"
},
{
"type": "shell",
"inline": [
"cd /tmp/app",
"make"
]
},
{
"type": "file",
"source": "/tmp/compiled-app.tar.gz",
"destination": "compiled-app.tar.gz",
"direction": "download"
}
],
"post-processors": [
[
{
"type": "artifice",
"files": ["compiled-app.tar.gz"]
},
{
"type": "atlas",
"artifact": "{{user `app_slug` }}",
"artifact_type": "archive"
}
]
]
} }
],
"provisioners": [
{
"type": "shell",
"inline": [
"apt-get -y update"
]
},
{
"type": "file",
"source": ".",
"destination": "/tmp/app"
},
{
"type": "shell",
"inline": [
"cd /tmp/app",
"make"
]
},
{
"type": "file",
"source": "/tmp/compiled-app.tar.gz",
"destination": "compiled-app.tar.gz",
"direction": "download"
}
],
"post-processors": [
[
{
"type": "artifice",
"files": ["compiled-app.tar.gz"]
},
{
"type": "atlas",
"artifact": "{{user `app_slug` }}",
"artifact_type": "archive"
}
]
]
}
```
In your Packer template, you can download each of the latest applications
artifacts onto the host using the shell provisioner:
In your Packer template, you can download each of the latest applications artifacts onto the host using the shell provisioner: ```text
$ curl -L -H "X-Atlas-Token: ${ATLAS_TOKEN}" https://atlas.hashicorp.com/api/v1/artifacts/hashicorp/example/archive/latest/file -o example.tar.gz
```
```curl -L -H "X-Atlas-Token: ${ATLAS_TOKEN}" https://atlas.hashicorp.com/api/v1/artifacts/hashicorp/example/archive/latest/file -o example.tar.gz```
Here's an example Packer template: Here's an example Packer template:
```json
{
"variables": {
"atlas_username": "{{env `ATLAS_USERNAME`}}",
"aws_access_key": "{{env `AWS_ACCESS_KEY_ID`}}",
"aws_secret_key": "{{env `AWS_SECRET_ACCESS_KEY`}}",
"aws_region": "{{env `AWS_DEFAULT_REGION`}}",
"instance_type": "c3.large",
"source_ami": "ami-9a562df2",
"name": "example",
"ssh_username": "ubuntu",
"app_dir": "/app"
},
"push": {
"name": "{{user `atlas_username`}}/{{user `name`}}",
"vcs": false
},
"builders": [
{ {
"variables": { "type": "amazon-ebs",
"atlas_username": "{{env `ATLAS_USERNAME`}}", "access_key": "{{user `aws_access_key`}}",
"aws_access_key": "{{env `AWS_ACCESS_KEY_ID`}}", "secret_key": "{{user `aws_secret_key`}}",
"aws_secret_key": "{{env `AWS_SECRET_ACCESS_KEY`}}", "region": "{{user `aws_region`}}",
"aws_region": "{{env `AWS_DEFAULT_REGION`}}", "vpc_id": "",
"instance_type": "c3.large", "subnet_id": "",
"source_ami": "ami-9a562df2", "instance_type": "{{user `instance_type`}}",
"name": "example", "source_ami": "{{user `source_ami`}}",
"ssh_username": "ubuntu", "ami_regions": [],
"app_dir": "/app" "ami_name": "{{user `name`}} {{timestamp}}",
}, "ami_description": "{{user `name`}} AMI",
"push": { "run_tags": { "ami-create": "{{user `name`}}" },
"name": "{{user `atlas_username`}}/{{user `name`}}", "tags": { "ami": "{{user `name`}}" },
"vcs": false "ssh_username": "{{user `ssh_username`}}",
}, "ssh_timeout": "10m",
"builders": [ "ssh_private_ip": false,
{ "associate_public_ip_address": true
"type": "amazon-ebs", }
"access_key": "{{user `aws_access_key`}}", ],
"secret_key": "{{user `aws_secret_key`}}", "provisioners": [
"region": "{{user `aws_region`}}", {
"vpc_id": "", "type": "shell",
"subnet_id": "", "execute_command": "echo {{user `ssh_username`}} | {{ .Vars }} sudo -E -S sh '{{ .Path }}'",
"instance_type": "{{user `instance_type`}}", "inline": [
"source_ami": "{{user `source_ami`}}", "apt-get -y update",
"ami_regions": [], "apt-get -y upgrade",
"ami_name": "{{user `name`}} {{timestamp}}", "apt-get -y install curl unzip tar",
"ami_description": "{{user `name`}} AMI", "mkdir -p {{user `app_dir`}}",
"run_tags": { "ami-create": "{{user `name`}}" }, "chmod a+w {{user `app_dir`}}",
"tags": { "ami": "{{user `name`}}" }, "cd /tmp",
"ssh_username": "{{user `ssh_username`}}", "curl -L -H 'X-Atlas-Token: ${ATLAS_TOKEN}' https://atlas.hashicorp.com/api/v1/artifacts/{{user `atlas_username`}}/{{user `name`}}/archive/latest/file -o example.tar.gz",
"ssh_timeout": "10m", "tar -xzf example.tar.gz -C {{user `app_dir`}}"
"ssh_private_ip": false,
"associate_public_ip_address": true
}
],
"provisioners": [
{
"type": "shell",
"execute_command": "echo {{user `ssh_username`}} | {{ .Vars }} sudo -E -S sh '{{ .Path }}'",
"inline": [
"apt-get -y update",
"apt-get -y upgrade",
"apt-get -y install curl unzip tar",
"mkdir -p {{user `app_dir`}}",
"chmod a+w {{user `app_dir`}}",
"cd /tmp",
"curl -L -H "X-Atlas-Token: ${ATLAS_TOKEN}" https://atlas.hashicorp.com/api/v1/artifacts/{{user `atlas_username`}}/{{user `name`}}/archive/latest/file -o example.tar.gz",
"tar -xzf example.tar.gz -C {{user `app_dir`}}"
]
}
],
"post-processors": [
{
"type": "atlas",
"artifact": "{{user `atlas_username`}}/{{user `name`}}",
"artifact_type": "amazon.image",
"metadata": {
"created_at": "{{timestamp}}"
}
}
] ]
} }
],
"post-processors": [
{
"type": "atlas",
"artifact": "{{user `atlas_username`}}/{{user `name`}}",
"artifact_type": "amazon.image",
"metadata": {
"created_at": "{{timestamp}}"
}
}
]
}
```
Once downloaded, you can place each application slug where it needs to go to produce the monolithic artifact your are accustom to. Once downloaded, you can place each application slug where it needs to go to
produce the monolithic artifact your are accustom to.

110
website/source/docs/enterprise/faq/rolling-deployments.html.md
View File

@ -1,6 +1,6 @@
--- ---
layout: "enterprise" layout: "enterprise"
page_title: "FAQ: Rolling Deployments" page_title: "Rolling Deployments - FAQ - Terraform Enterprise"
sidebar_current: "docs-enterprise-faq-deployments" sidebar_current: "docs-enterprise-faq-deployments"
description: |- description: |-
How do I configure rolling deployments in Terraform Enterprise? How do I configure rolling deployments in Terraform Enterprise?
@ -10,71 +10,85 @@ description: |-
*How do I configure rolling deployments?* *How do I configure rolling deployments?*
User are able to quickly change out an Artifact version that is being utilized by Terraform, using variables within Terraform Enterprise. This is User are able to quickly change out an Artifact version that is being utilized
particularly useful when testing specific versions of the given artifact without performing a full rollout. This configuration also allows one by Terraform, using variables within Terraform Enterprise. This is particularly
to deploy any version of an artifact with ease, simply by changing a version variable in Terraform and re-deploying. useful when testing specific versions of the given artifact without performing a
full rollout. This configuration also allows one to deploy any version of an
artifact with ease, simply by changing a version variable in Terraform and
re-deploying.
Here is an example: Here is an example:
variable "type" { default = "amazon.image" } ```hcl
variable "region" { } variable "type" { default = "amazon.image" }
variable "atlas_username" { } variable "region" {}
variable "pinned_name" { } variable "atlas_username" {}
variable "pinned_version" { default = "latest" } variable "pinned_name" {}
variable "pinned_version" { default = "latest" }
resource "atlas_artifact" "pinned" { resource "atlas_artifact" "pinned" {
name = "${var.atlas_username}/${var.pinned_name}" name = "${var.atlas_username}/${var.pinned_name}"
type = "${var.type}" type = "${var.type}"
version = "${var.pinned_version}" version = "${var.pinned_version}"
lifecycle { create_before_destroy = true } lifecycle { create_before_destroy = true }
metadata { metadata {
region = "${var.region}" region = "${var.region}"
} }
} }
output "pinned" { value = "${atlas_artifact.pinned.metadata_full.ami_id}" } output "pinned" { value = "${atlas_artifact.pinned.metadata_full.ami_id}" }
```
In the above example we have an `atlas_artifact` resource where you pass in the version number via the variable `pinned_version`. (_note: this variable defaults to latest_). In the above example we have an `atlas_artifact` resource where you pass in the
If you ever want to deploy any other version, you just update the variable `pinned_version` and redeploy. version number via the variable `pinned_version`. (_note: this variable defaults
to latest_). If you ever want to deploy any other version, you just update the
variable `pinned_version` and redeploy.
Below is similar to the first example, but it is in the form of a module that handles the creation of artifacts: Below is similar to the first example, but it is in the form of a module that
handles the creation of artifacts:
variable "type" { default = "amazon.image" } ```hcl
variable "region" { } variable "type" { default = "amazon.image" }
variable "atlas_username" { } variable "region" {}
variable "artifact_name" { } variable "atlas_username" {}
variable "artifact_version" { default = "latest" } variable "artifact_name" {}
variable "artifact_version" { default = "latest" }
resource "atlas_artifact" "artifact" { resource "atlas_artifact" "artifact" {
name = "${var.atlas_username}/${var.artifact_name}" name = "${var.atlas_username}/${var.artifact_name}"
type = "${var.type}" type = "${var.type}"
count = "${length(split(",", var.artifact_version))}" count = "${length(split(",", var.artifact_version))}"
version = "${element(split(",", var.artifact_version), count.index)}" version = "${element(split(",", var.artifact_version), count.index)}"
lifecycle { create_before_destroy = true } lifecycle { create_before_destroy = true }
metadata { region = "${var.region}" } metadata { region = "${var.region}" }
} }
output "amis" { value = "${join(",", atlas_artifact.artifact.*.metadata_full.ami_id)}" } output "amis" { value = "${join(",", atlas_artifact.artifact.*.metadata_full.ami_id)}" }
```
One can then use the module as follows (_note: the source will likely be different depending on the location of the module_): One can then use the module as follows (_note: the source will likely be
different depending on the location of the module_):
module "artifact_consul" { ```hcl
source = "../../../modules/aws/util/artifact" module "artifact_consul" {
source = "../../../modules/aws/util/artifact"
type = "${var.artifact_type}" type = "${var.artifact_type}"
region = "${var.region}" region = "${var.region}"
atlas_username = "${var.atlas_username}" atlas_username = "${var.atlas_username}"
artifact_name = "${var.consul_artifact_name}" artifact_name = "${var.consul_artifact_name}"
artifact_version = "${var.consul_artifacts}" artifact_version = "${var.consul_artifacts}"
} }
```
In the above example, we have created artifacts for Consul. In this example, we can create two versions of the artifact, In the above example, we have created artifacts for Consul. In this example, we
"latest" and "pinned". This is useful when rolling a cluster (like Consul) one node at a time, keeping some nodes pinned to current version and others can create two versions of the artifact, "latest" and "pinned". This is useful
deployed with the latest Artifact. when rolling a cluster (like Consul) one node at a time, keeping some nodes
pinned to current version and others deployed with the latest Artifact.
There are additional details for implementing rolling deployments in the [Best-Practices Repo](https://github.com/hashicorp/best-practices/blob/master/terraform/providers/aws/us_east_1_prod/us_east_1_prod.tf#L105-L123), as there are some things uncovered in this FAQ (i.e Using the Terraform Enterprise Artifact in an instance). There are additional details for implementing rolling deployments in the [Best-Practices Repo](https://github.com/hashicorp/best-practices/blob/master/terraform/providers/aws/us_east_1_prod/us_east_1_prod.tf#L105-L123), as there are some things uncovered in this FAQ (i.e Using the Terraform Enterprise Artifact in an instance).

234
website/source/docs/enterprise/glossary/index.html.md
View File

@ -1,6 +1,6 @@
--- ---
layout: "enterprise" layout: "enterprise"
page_title: "Terraform Enterprise Glossary" page_title: "Glossary - Terraform Enterprise"
sidebar_current: "docs-enterprise-glossary" sidebar_current: "docs-enterprise-glossary"
description: |- description: |-
Terminology for Terraform Enterprise. Terminology for Terraform Enterprise.
@ -8,119 +8,117 @@ description: |-
# Glossary # Glossary
Terraform Enterprise, and this documentation, covers a large set of terminology adopted Terraform Enterprise, and this documentation, covers a large set of terminology
from tools, industry standards and the community. This glossary adopted from tools, industry standards and the community. This glossary seeks to
seeks to define as many of those terms as possible to help increase define as many of those terms as possible to help increase understanding in
understanding in interfacing with the platform and reading documentation. interfacing with the platform and reading documentation.
### Authentication Tokens ## Authentication Tokens
Authentication tokens are tokens used to authenticate with Terraform Enterprise via Authentication tokens are tokens used to authenticate with Terraform Enterprise
APIs or through tools. Authentication tokens can be revoked, expired via APIs or through tools. Authentication tokens can be revoked, expired or
or created under any user. created under any user.
### ACL ## ACL
ACL is an acronym for access control list. This defines access ACL is an acronym for access control list. This defines access to a set of
to a set of resources. Access to an object in Terraform Enterprise limited to "read" resources. Access to an object in Terraform Enterprise limited to "read" for
for certain users is an example of an ACL. certain users is an example of an ACL.
### Alert ## Alert
An alert represents a health check status change on a Consul node that An alert represents a health check status change on a Consul node that is sent
is sent to Terraform Enterprise, and then recorded and distributed to various to Terraform Enterprise, and then recorded and distributed to various
notification methods. notification methods.
### Application ## Application
An application is a set of code that represents an application that should An application is a set of code that represents an application that should be
be deployed. Applications can be linked to builds to be made deployed. Applications can be linked to builds to be made available in the
available in the Packer environment. Packer environment.
### Apply ## Apply
An apply is the second step of the two steps required for An apply is the second step of the two steps required for Terraform to make
Terraform to make changes to infrastructure. The apply is the process changes to infrastructure. The apply is the process of communicating with
of communicating with external APIs to make the changes. external APIs to make the changes.
### Artifact ## Artifact
An artifact is an abstract representation of something you wish to An artifact is an abstract representation of something you wish to store and use
store and use again that has undergone configuration, compilation or again that has undergone configuration, compilation or some other build process.
some other build process. An artifact is typically An artifact is typically an image created by Packer that is then deployed by
an image created by Packer that is then deployed by Terraform, or used Terraform, or used locally with Vagrant.
locally with Vagrant.
### Box ## Box
Boxes are a Vagrant specific package format. Vagrant can install Boxes are a Vagrant specific package format. Vagrant can install and uses images
and uses images in box format. in box format.
### Build ## Build
Builds are resources that represent Packer configurations. A build Builds are resources that represent Packer configurations. A build is a generic
is a generic name, sometimes called a "Build Configuration" when name, sometimes called a "Build Configuration" when defined in the Terraform
defined in the Terraform Enterprise UI. Enterprise UI.
### Build Configuration ## Build Configuration
A build configuration are settings associated with a resource that A build configuration are settings associated with a resource that creates
creates artifacts via builds. A build configuration is the name artifacts via builds. A build configuration is the name in `packer push -name
in `packer push -name acemeinc/web`. acemeinc/web`.
### Catalog ## Catalog
The box catalog is a publicly available index of Vagrant Boxes The box catalog is a publicly available index of Vagrant Boxes that can be
that can be downloaded from Terraform Enterprise and used for development. downloaded from Terraform Enterprise and used for development.
### Consul ## Consul
[Consul](https://consul.io) is a HashiCorp tool for service discovery, configuration, [Consul](https://consul.io) is a HashiCorp tool for service discovery,
and orchestration. Consul enables rapid deployment, configuration, monitoring and configuration, and orchestration. Consul enables rapid deployment,
maintenance of service-oriented architectures. configuration, monitoring and maintenance of service-oriented architectures.
### Datacenter ## Datacenter
A datacenter represents a group of nodes in the same network or A datacenter represents a group of nodes in the same network or datacenter
datacenter within Consul. within Consul.
### Environment ## Environment
Environments show the real-time status of your infrastructure, Environments show the real-time status of your infrastructure, any pending
any pending changes, and its change history. Environments can be configured changes, and its change history. Environments can be configured to use any or
to use any or all of these three components. all of these three components.
Environments are the namespace of your Terraform Enterprise managed infrastructure. Environments are the namespace of your Terraform Enterprise managed
As an example, if you to have a production environment infrastructure. As an example, if you to have a production environment for a
for a company named Acme Inc., your environment company named Acme Inc., your environment may be named
may be named `%{DEFAULT_USERNAME}/production`. `my-username/production`.
To read more about features provided under environments, To read more about features provided under environments, read the
read the [Terraform](/docs/enterprise) sections. [Terraform](/docs/enterprise) sections.
### Environment Variables ## Environment Variables
Environment variables injected into the environment of Packer builds or Environment variables injected into the environment of Packer builds or
Terraform Runs (plans and applies). Terraform Runs (plans and applies).
### Flapping ## Flapping
Flapping is something entering and leaving a healthy state rapidly. It is typically associated with a health checks that Flapping is something entering and leaving a healthy state rapidly. It is
briefly report unhealthy status before recovering. typically associated with a health checks that briefly report unhealthy status
before recovering.
### Health Check ## Health Check
Health checks trigger alerts by changing status on a Consul node. That status Health checks trigger alerts by changing status on a Consul node. That status
change is seen by Terraform Enterprise, when connected, and an associated alert is change is seen by Terraform Enterprise, when connected, and an associated alert
recorded and sent to any configured notification methods, like is recorded and sent to any configured notification methods, like email.
email.
### Infrastructure ## Infrastructure
An infrastructure is a stateful representation of a set of Consul An infrastructure is a stateful representation of a set of Consul datacenters.
datacenters.
### Managed Node ## Managed Node
Managed node is the billing metric for Terraform Enterprise. For Consul Enterprise, a node is a host Managed node is the billing metric for Terraform Enterprise. For Consul Enterprise, a node is a host
with a Consul agent on it. For Terraform Enterprise, a node is a compute with a Consul agent on it. For Terraform Enterprise, a node is a compute
@ -130,79 +128,77 @@ as compute resources.
All [Terraform Enterprise features](/docs/enterprise) are paid. All [Terraform Enterprise features](/docs/enterprise) are paid.
### Operator ## Operator
An operator is a person who is making changes to infrastructure or An operator is a person who is making changes to infrastructure or settings.
settings.
### Packer ## Packer
[Packer](https://packer.io) is a tool for creating images for platforms such as Amazon AWS, [Packer](https://packer.io) is a tool for creating images for platforms such as
OpenStack, VMware, VirtualBox, Docker, and more — all from a single Amazon AWS, OpenStack, VMware, VirtualBox, Docker, and more — all from a single
source configuration. source configuration.
### Packer Template ## Packer Template
A Packer template is a JSON file that configure the various components A Packer template is a JSON file that configure the various components of Packer
of Packer in order to create one or more machine images. in order to create one or more machine images.
### Plan ## Plan
A plan is the second step of the two steps required for A plan is the second step of the two steps required for Terraform to make
Terraform to make changes to infrastructure. The plan is the process changes to infrastructure. The plan is the process of determining what changes
of determining what changes will be made to. will be made to.
### Providers ## Providers
Providers are often referenced when discussing Packer Providers are often referenced when discussing Packer or Terraform. Terraform
or Terraform. Terraform providers manage resources in Terraform. providers manage resources in Terraform.
[Read more](https://terraform.io/docs/providers/index.html). [Read more](https://terraform.io/docs/providers/index.html).
### Post-Processors ## Post-Processors
The post-processor section within a Packer template configures The post-processor section within a Packer template configures any
any post-processing that will be done to images built by the builders. post-processing that will be done to images built by the builders. Examples of
Examples of post-processing would be compressing files, uploading post-processing would be compressing files, uploading artifacts, etc..
artifacts, etc..
### Registry ## Registry
Often referred to as the "Artifact Registry", the registry Often referred to as the "Artifact Registry", the registry stores artifacts, be
stores artifacts, be it images or IDs for cloud provider images. it images or IDs for cloud provider images.
### Run ## Run
A run represents a two step Terraform plan and a subsequent apply. A run represents a two step Terraform plan and a subsequent apply.
### Service ## Service
A service in Consul represents an application or service, which A service in Consul represents an application or service, which could be active
could be active on any number of nodes. on any number of nodes.
### Share ## Share
Shares are let you instantly share public access to your running Shares are let you instantly share public access to your running Vagrant
Vagrant environment (virtual machine). environment (virtual machine).
### State ## State
Terraform state is the state of your managed infrastructure from the last Terraform state is the state of your managed infrastructure from the last time
time Terraform was run. By default this state is stored in a local file Terraform was run. By default this state is stored in a local file named
named `terraform.tfstate`, but it can also be stored in Terraform Enterprise `terraform.tfstate`, but it can also be stored in Terraform Enterprise and is
and is then called "Remote state". then called "Remote state".
### Terraform ## Terraform
[Terraform](https://terraform.io) is a tool for safely and [Terraform](https://terraform.io) is a tool for safely and efficiently changing
efficiently changing infrastructure across providers. infrastructure across providers.
### Terraform Configuration ## Terraform Configuration
Terraform configuration is the configuration files and any Terraform configuration is the configuration files and any files that may be
files that may be used in provisioners like `remote-exec`. used in provisioners like `remote-exec`.
### Terraform Variables ## Terraform Variables
Variables in Terraform, uploaded with `terraform push` or Variables in Terraform, uploaded with `terraform push` or set in the UI. These
set in the UI. These differ from environment variables differ from environment variables as they are a first class Terraform variable
as they are a first class Terraform variable used in interpolation. used in interpolation.