From 66e17b500465e810fc9825797fea6f8036827a2a Mon Sep 17 00:00:00 2001 From: taimack Date: Tue, 30 Sep 2025 13:43:40 -0500 Subject: [PATCH] Updates for tfc-agent release 1.25.0 --- .../data/cloud-docs-agents-nav-data.json | 16 + .../docs/cloud-docs/agents/agent-pools.mdx | 187 ++++ .../v1.25.x/docs/cloud-docs/agents/agents.mdx | 342 +++++++ .../docs/cloud-docs/agents/changelog.mdx | 840 ++++++++++++++++++ .../v1.25.x/docs/cloud-docs/agents/hooks.mdx | 209 +++++ .../v1.25.x/docs/cloud-docs/agents/index.mdx | 20 + .../docs/cloud-docs/agents/logging.mdx | 84 ++ .../docs/cloud-docs/agents/metrics.mdx | 176 ++++ .../cloud-docs/agents/request-forwarding.mdx | 137 +++ .../docs/cloud-docs/agents/requirements.mdx | 83 ++ .../docs/cloud-docs/agents/telemetry.mdx | 153 ++++ .../docs/cloud-docs/agents/tracing.mdx | 28 + .../v1.25.x/docs/partials/agents.mdx | 1 + .../v1.25.x/docs/partials/beta.mdx | 6 + .../v1.25.x/docs/partials/policy.mdx | 1 + .../docs/partials/request-forwarding-tier.mdx | 5 + .../img/request-forwarding-arch-dark.png | Bin 0 -> 8880 bytes .../img/request-forwarding-arch-light.png | Bin 0 -> 8333 bytes .../v1.25.x/img/request-forwarding-arch.png | Bin 0 -> 20978 bytes .../v1.25.x/img/telemetry-arch-dark.png | Bin 0 -> 16604 bytes .../v1.25.x/img/telemetry-arch-light.png | Bin 0 -> 15135 bytes .../v1.25.x/img/telemetry-arch.png | Bin 0 -> 144700 bytes 22 files changed, 2288 insertions(+) create mode 100644 content/terraform-docs-agents/v1.25.x/data/cloud-docs-agents-nav-data.json create mode 100644 content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/agent-pools.mdx create mode 100644 content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/agents.mdx create mode 100644 content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/changelog.mdx create mode 100644 content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/hooks.mdx create mode 100644 content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/index.mdx create mode 100644 content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/logging.mdx create mode 100644 content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/metrics.mdx create mode 100644 content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/request-forwarding.mdx create mode 100644 content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/requirements.mdx create mode 100644 content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/telemetry.mdx create mode 100644 content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/tracing.mdx create mode 100644 content/terraform-docs-agents/v1.25.x/docs/partials/agents.mdx create mode 100644 content/terraform-docs-agents/v1.25.x/docs/partials/beta.mdx create mode 100644 content/terraform-docs-agents/v1.25.x/docs/partials/policy.mdx create mode 100644 content/terraform-docs-agents/v1.25.x/docs/partials/request-forwarding-tier.mdx create mode 100644 content/terraform-docs-agents/v1.25.x/img/request-forwarding-arch-dark.png create mode 100644 content/terraform-docs-agents/v1.25.x/img/request-forwarding-arch-light.png create mode 100644 content/terraform-docs-agents/v1.25.x/img/request-forwarding-arch.png create mode 100644 content/terraform-docs-agents/v1.25.x/img/telemetry-arch-dark.png create mode 100644 content/terraform-docs-agents/v1.25.x/img/telemetry-arch-light.png create mode 100644 content/terraform-docs-agents/v1.25.x/img/telemetry-arch.png diff --git a/content/terraform-docs-agents/v1.25.x/data/cloud-docs-agents-nav-data.json b/content/terraform-docs-agents/v1.25.x/data/cloud-docs-agents-nav-data.json new file mode 100644 index 000000000..6e6a3d5fa --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/data/cloud-docs-agents-nav-data.json @@ -0,0 +1,16 @@ +[ + { + "heading": "HCP Terraform Agents" + }, + { "title": "Overview", "path": "" }, + { "title": "Requirements", "path": "requirements" }, + { "title": "Install and Run Agents", "path": "agents" }, + { "title": "Inject Custom Run Actions (Hooks)", "path": "hooks" }, + { "title": "Manage Agent Pools", "path": "agent-pools" }, + { "title": "Request Forwarding", "path": "request-forwarding" }, + { "title": "Telemetry", "path": "telemetry" }, + { "title": "Logging", "path": "logging" }, + { "title": "Metrics", "path": "metrics" }, + { "title": "Tracing", "path": "tracing" }, + { "title": "Changelog", "path": "changelog" } +] diff --git a/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/agent-pools.mdx b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/agent-pools.mdx new file mode 100644 index 000000000..3ca3506a3 --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/agent-pools.mdx @@ -0,0 +1,187 @@ +--- +page_title: Manage HCP Terraform agent pools +description: >- + Agent pools are groups of one or more agents. Learn how to manage agent pools and assign them to specific workspaces or Stacks. +--- + +# Manage agent pools + +HCP Terraform organizes agents into agent pools. An agent pool represents a group of agents that lets HCP Terraform communicate with isolated, private, or on-premises infrastructure. When you configure a workspace or Stack to execute runs using agents, any available agent in that workspace or Stack's associated agent pool can complete the run. + + + +Terraform Enterprise does not support Stacks. You can only scope agent pools to workspaces and projects in Terraform Enterprise. + + + +## Permissions + +Managing agent pools requires the following permissions: + +- You must have the [**Manage Agent Pools**](/terraform/cloud-docs/users-teams-organizations/permissions/organization#manage-agent-pools) permission in your organization to manage an organization's agents. +- You must have **Admin** access to a workspace or Stack before you can change its execution mode to use an agent pool. + +Refer to [Permissions](/terraform/cloud-docs/users-teams-organizations/permissions) in the HCP Terraform documentation for details. + +[permissions-citation]: #intentionally-unused---keep-for-maintainers + +## Create an agent pool + +To create an agent pool: + +1. Go to your organization's settings, click **Agents**, and then click **Create agent pool**. + +1. Enter an **Agent Pool Name**, and then click **Continue**. HCP Terraform uses this name to distinguish agent pools in a workspace or Stack's settings. + +1. Enter a token **Description**, and then click **Create Token**. + +1. Save your token information in a secure location. You need the token to connect an agent to this HCP Terraform agent pool, and HCP Terraform does not display the token again after this step. + +1. Click **Finish**. + +To connect an agent to this pool, configure and [start an agent using the official Docker image](/terraform/cloud-docs/agents/agents#quick-start). +Alternatively, configure and [start an agent using the binary](/terraform/cloud-docs/agents/agents#start-an-agent) then provide then agent with your agent pool's token. + +## Scope an agent pool + +Scoping an agent pool lets you specify which workspaces, projects, or Stacks can use it. The agent pool is only available from within the chosen workspaces, projects, or Stacks, and it does not appear in other workspace's, project's, or Stack's lists of available agent pools. + +~> **Important:** Scoping an agent pool does not remove it from workspaces, projects, or Stacks that are actively using it. To remove access, you must first remove the agent pool from within the workspace, project, or Stack settings. + +To scope an agent pool to specific workspaces, projects, or Stacks within the organization: + +1. Go to your organization's settings, and then click **Agents**. The **Agents** page appears, with a list of agent pools for the organization. + +1. Click the name of the pool you want to update. + +1. Click **Grant access to specific projects, workspaces, and Stacks**. A menu opens where you can search for workspaces, projects, and Stacks within this organization. + +1. Type in the search field to find available workspaces, projects, and Stacks and select the workspaces, projects, and Stacks that should have access to the agent pool. + +1. Click **Save**. + +Only the specified workspaces, projects, and Stacks can use the agent pool. + +## Configure workspaces to use the agent + +Use the following steps to configure a workspace to use an agent pool. + +### Step 1: Manage existing runs + +Changing a workspace's [execution mode](/terraform/cloud-docs/workspaces/settings#execution-mode) after Terraform completes a plan causes that run to error during apply. To minimize these errors, do the following in the workspace before you change the execution mode: + +1. Disable [auto-apply](/terraform/cloud-docs/workspaces/settings#auto-apply-and-manual-apply). +1. Wait for the workspace to complete any runs that are no longer in the [pending stage](/terraform/cloud-docs/run/states#1-the-pending-stage). +1. [Lock the workspace](/terraform/cloud-docs/workspaces/settings#locking) to prevent new runs. + +### Step 2: Select agent pool + +To configure the workspace to execute runs using an agent: + +1. Go to the workspace's **General Settings** page. +1. Select **Agent** as the [execution mode](/terraform/cloud-docs/workspaces/settings#execution-mode), and select the agent pool this workspace should use. +1. Click **Save Settings**. + +The workspace begins using the agent for Terraform runs. Runs involving an agent include information about that agent in the run details. HCP Terraform may use different agents for the plan and apply operations, depending on agent availability within the pool. + +## Configure Stacks to use the agent + +Use the following steps to configure a Stack to use an agent pool. + +### Step 1: Manage existing runs + +Changing a Stack's [execution mode](/terraform/cloud-docs/stacks/configure#change-execution-mode) after Terraform completes a plan causes that run to error during apply. To minimize these errors, wait for all in-progress deployment runs to complete before you change the execution mode. + +### Step 2: Select agent pool + +To learn how to configure a Stack to execute runs using an agent, refer to [Configure a Stack](/terraform/cloud-docs/stacks/configure#configure-a-stack-1). + +After changing the execution mode, your Stack begins using the agent for deployment runs. Runs involving an agent include information about that agent in the run details. HCP Terraform may use different agents for the plan and apply runs, depending on agent availability within the pool. + +## Configure projects to use the agent + +To configure the project to execute runs using an agent: + +1. Go to the project's **General Settings** page. +1. Select **Agent** as the [execution mode](/terraform/cloud-docs/workspaces/settings#execution-mode), and select the agent pool this project should use. +1. Click **Save Settings**. + +The project begins using the agent for Terraform runs. Any workspace within the project will inherit the execution mode, which will be passed onto the run. Runs involving an agent include information about that agent in the run details. HCP Terraform may use different agents for the plan and apply operations, depending on agent availability within the pool. + +## Exclude workspaces and Stacks from accessing an agent pool + +Excluding workspaces and Stacks from an agent pool prevents the specified workspaces and Stacks from using it. + +To exclude a workspace or Stack from an agent pool: + +1. Go to your organization's settings, and then click **Agents**. The **Agents** page appears, with a list of agent pools for the organization. + +1. Click the name of the pool you want to update. + +1. Click **Grant access to specific projects and workspaces**. + +1. Click **Add exclusions**. A menu opens where you can search for workspaces and Stacks within this organization. + +1. Type in the search field to find available workspaces and Stacks and select the workspaces and Stacks that should be restricted from accessing the agent pool. + +1. Click **Save**. + +Only the specified workspaces and Stacks are restricted from accessing the agent pool. + +## Revoke an agent token + +You may revoke an issued token from your agents at any time. + +Revoking a token causes the agents using it to exit. You must reinitialize agents with a new token before they can continue servicing runs. + +Allow active runs in the associated agent pool to finish before revoking a token. If you de-authorize an agent while it is still performing a run, the agent does not post updates about that run. We recommend generating a new token first, initializing the agents using it, and then revoking the old token once no agents are using it. Agent tokens display information about the last time an agent used them. You can use this information to help you decide whether a token is safe to revoke. + +1. Navigate to your organization's settings, click **Agents**, and then click the name of the agent pool you want to manage. + +1. Click **Revoke Token** for the token you want to revoke. + +1. Click **Yes, delete token** to confirm. + +## Delete an agent pool + +~> **Important:** You cannot delete an agent pool that is still associated with one or more workspaces or Stacks. + +To delete an agent pool: + +1. Wait for all associated workspaces and Stacks to complete all in progress runs. +1. Remove the agent pool from all associated workspaces and Stacks. +1. Navigate to your organization's settings, click **Agents**, and then click the name of the agent pool you want to delete. +1. Click **Delete agent pool**. +1. Click **Yes, delete agent pool** to confirm. + + +## View agent statuses + +To view agent statuses, go to your organization's settings and click **Agents**. The **Agents** page appears, containing a list of agents and their corresponding statuses. An agent can have one of the following statuses: + +- **Idle**: The agent is running normally and waiting for jobs to be available. +- **Busy**: The agent is running normally and currently executing a job. +- **Unknown**: The agent has not reported any status for an unexpected period of time. The agent may yet recover if the agent's situation is temporary, such as a short-lived network partition. +- **Errored**: The agent encountered an unrecoverable error or has been in an Unknown state for long enough that HCP Terraform considers it errored. This status may indicate that something interrupted the agent process, the process crashed, a permanent network partition exists, or another similar problem. If the agent was in the process of running an operation (such as a plan or apply), the agent marks that operation as errored. If the current agent process recovers, it exits immediately. +- **Exited**: The agent exited normally and successfully informed Terraform of it doing so. + +## Agent capacity usage + +Refer to [HCP Terraform pricing](https://www.hashicorp.com/products/terraform/pricing) for more information about HCP Terraform Agents. + +Agents count towards the organization's purchased agent capacity if they are in the **Idle**, **Busy**, or **Unknown** state. Agents that are in the **Errored** or **Exited** state do not count towards the organization's total agent capacity. + +Agents in the **Unknown** state continue to count against the organization's total agent allowance, as this status is typically an indicator of a temporary communication issue between the agent and HCP Terraform. **Unknown** agents that do not respond after a period of 5 minutes automatically transition to an **Errored** state, at which point they do not count against the agent allowance. + +Agents may have an **Unknown** status if they terminate without gracefully exiting. Agents should always be shut down according to the [Stop the Agent](/terraform/cloud-docs/agents/agents#stop-the-agent) section to allow them to deregister from HCP Terraform. To minimize **Unknown** agent statuses, we strongly recommend configuring any process supervisor, application scheduler, or other runtime manager to follow this procedure. + +You can deregister agents that are **Unknown**, **Errored**, or **Exited** through either the **Organization Settings > Agents** page or through the [Agent API](/terraform/cloud-docs/api-docs/agents#delete-an-agent). Deregistered agents no longer appear in the settings page or count against the organization's agent allowance. + +## Change the agent pool architecture + +All agents in a pool must have the same architecture, which is determined by the first agent to register. If you need to change the architecture of the agent pool, such as switching from x86 to ARM64, you can complete the following steps: + +1. Spin down all existing agents in the pool so that no agents are registered. +1. Spin up and register an agent of the desired architecture. + +This agent pool will require subsequent registered agents to have the same architecture. diff --git a/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/agents.mdx b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/agents.mdx new file mode 100644 index 000000000..3e10d1366 --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/agents.mdx @@ -0,0 +1,342 @@ +--- +page_title: Install and run HCP Terraform agents +description: >- + Use HCP Terraform agents to manage infrastructure in private networks. Learn how to install, configure, and run agents on your own infrastructure. +--- + +# Install and run agents + +@include 'agents.mdx' + +The agent software runs on your own infrastructure. The token you provide when starting the agent assigns it to an HCP Terraform [agent pool](/terraform/cloud-docs/agents/agent-pools). + +If you have your Agent pool and token already set up, [start the agent using the official Docker image](/terraform/cloud-docs/agents/agents#run-an-agent-with-docker). + +## Operational considerations + +Agents do not guarantee a clean working environment per Terraform execution. Each execution occurs in its own temporary directory with a clean environment, but references to absolute file paths or other machine state may cause interference between Terraform executions. We strongly recommend that you write your Terraform code to be stateless and idempotent. You may also want to consider using [single-execution mode](#optional-configuration-single-execution-mode) to ensure your agent only runs a single workload. + +### Run multiple agents + +You may choose to run multiple agents within your network, up to the organization's purchased agent limit. If there are multiple agents available within an organization, HCP Terraform selects the first available agent within the target pool. + +Each agent process runs a single Terraform run at a time. Multiple agent processes can be concurrently run on a single instance, license limit permitting. + +### Resilience + +The agent distributes as a standalone binary that runs on any supported system. By default, the agent runs in the foreground as a long-running process that continuously polls for workloads from HCP Terraform. An agent process may terminate unexpectedly due to stopping the process forcefully, power cycling the host machine, and other methods. We strongly recommend pairing the agent with a process supervisor to ensure that it automatically restarts in case of an error. + +### Updates + +By default, the agent automatically updates itself to the latest minor version. Administrators must update the host operating system and all other installed software. + +To customize this update behavior, pass the flag `-auto-update` or set the environment variable `TFC_AGENT_AUTO_UPDATE` to one of the following settings. + +| Update Setting | Behavior | +| -------------- | ------------------------------------------------------------------------------------------------------------ | +| `minor` | Matches the default behavior, automatically updates the agent to the latest minor version. | +| `patch` | The agent only updates to the newest patch version, new minor versions require a manual update. | +| `disabled` | Disables automatic updates, all updates are manual. + +## Run an agent with Docker + +To start the agent with the official Docker image and connect it to an HCP Terraform agent pool: + +1. Retrieve the [token](/terraform/cloud-docs/agents/agent-pools#create-an-agent-pool) from the HCP Terraform agent pool you want to use. +1. Set the `TFC_AGENT_TOKEN` environment variable. +1. (Optional) Set the `TFC_AGENT_NAME` environment variable. This name is for your reference only. The agent ID appears in logs and API requests. + +```shell-session +export TFC_AGENT_TOKEN=your-token +export TFC_AGENT_NAME=your-agent-name +docker run --platform=linux/amd64 -e TFC_AGENT_TOKEN -e TFC_AGENT_NAME hashicorp/tfc-agent:latest +``` + +Once complete, your agent and its status appear on the **Agents** page in the HCP Terraform UI. Workspaces can now use this agent pool for runs. Refer to [Configure Workspaces to Use the Agent](/terraform/cloud-docs/agents/agent-pools#configure-workspaces-to-use-the-agent) for details. + +## Run an agent using the binary + +To download and install the agent: + +1. Download the latest [agent release](https://releases.hashicorp.com/tfc-agent/), the associated checksum file (.SHA256sums), and the checksum signature (.sig). +1. Verify the integrity of the downloaded archive, as well as the signature of the `SHA256SUMS` file using the instructions available on [HashiCorp's security page](https://www.hashicorp.com/security). +1. Extract the release archive. The `unzip` utility is available on most Linux distributions, and you can invoke it by running `unzip `. The `unzip` command extracts two individual binaries (`tfc-agent` and `tfc-agent-core`). These binaries must reside in the same directory for the agent to function properly. + +To start the agent and connect it to an HCP Terraform agent pool: + +1. Retrieve the [token](/terraform/cloud-docs/agents/agent-pools#create-an-agent-pool) from the HCP Terraform agent pool you want to use. +1. Set the `TFC_AGENT_TOKEN` environment variable. +1. (Optional) Set the `TFC_AGENT_NAME` environment variable. This name is for your reference only. The agent ID appears in logs and API requests. + +``` +export TFC_AGENT_TOKEN=your-token +export TFC_AGENT_NAME=your-agent-name +./tfc-agent +``` +Once complete, your agent and its status appear on the **Agents** page in the HCP Terraform UI. Workspaces can now use this agent pool for runs. Refer to [Configure Workspaces to Use the Agent](/terraform/cloud-docs/agents/agent-pools#configure-workspaces-to-use-the-agent) for details. + +## Optional configuration + +The optional configurations for customizing the agent include building a custom Docker image that grants sudo privileges for software installation, running in single-execution mode to process a single workload before terminating, and enabling request forwarding for secure access to private resources. + +### Enable search queries + +@include 'beta.mdx' + +You can query your existing infrastructure to find resources that are not yet managed by Terraform. This makes it easier to identify and import unmanaged resources into your Terraform workspace. Refer to [Import existing resources to state](terraform/cloud-docs/workspaces/import) for more information. + +To use the search functionality, you must include the `query` operation in the [`TFE_AGENT_ACCEPT` variable](#accept) when starting your agent. + +### Customize the agent Docker image + +The Docker image executes the `tfc-agent` process as the non-root `tfc-agent` user. For some workflows, you may need to build a customized version of the agent Docker image for your internal use. For example, if your workflow needs to install software using `apt-get` during `local-exec` scripts. + +```Dockerfile +FROM hashicorp/tfc-agent:latest + +USER root + +# Install sudo. The container runs as a non-root user, but people may rely on +# the ability to apt-get install things. +RUN apt-get -y install sudo + +# Permit tfc-agent to use sudo apt-get commands. +RUN echo 'tfc-agent ALL=NOPASSWD: /usr/bin/apt-get , /usr/bin/apt' >> /etc/sudoers.d/50-tfc-agent + +USER tfc-agent +``` + +The above customized Dockerfile lets an agent install additional software using `sudo apt-get`. + +### Single-execution mode + +You can also configure the agent to run in single-execution mode, which ensures that the agent only runs a single workload, then terminates. You can use this configuration in combination with Docker and a process supervisor to ensure a clean working environment for every Terraform run. + +To use single-execution mode, start the agent with the `-single` command line argument. + +### Request forwarding + +You can configure the agent to accept forwarded requests from HCP Terraform. Request forwarding enables HCP Terraform to securely access private infrastructure resources, such as private VCS systems. See [Request Forwarding](/terraform/cloud-docs/agents/request-forwarding) for more details. By default, request forwarding is disabled. To enable it, start the agent with the `-request-forwarding` command line argument. + +Agents handle forwarded requests separately from other workloads and may process requests in parallel to plans, applies, policy checks, etc. You can modify this behavior by enabling or disabling certain workload types via the `-accept` parameter, and selectively setting the `-request-forwarding` flag on certain agent(s) only. For example, you may have a pool of 4 agents, where two are configured to handle only plans and applies, and the other two are configured to handle only request forwarding. + +## Stop the agent + +~> **Important:** We strongly recommend that you only terminate the agent using one of these methods. Abruptly terminating an agent by forcefully stopping the process or power cycling the host does not let the agent deregister and results in an **Unknown** agent status. Abrupt termination may cause further capacity issues. Refer to [capacity issues](/terraform/cloud-docs/agents/agent-pools#agent-capacity-usage) for details. + +The agent maintains a registration and a liveness indicator within HCP Terraform during the entire course of its runtime. When an agent retires, it must deregister itself from HCP Terraform. The agent deregisters automatically as part of its shutdown procedure in the following scenarios: + +- You enter `Ctrl-C` in an interactive terminal. +- The agent process ID receives one of `SIGINT`, `SIGTERM`, or `SIGQUIT`. It is important to send only one signal. The agent interprets a second signal as forceful termination signal exits immediately. + +After initiating a graceful shutdown by either of these methods, the terminal user or parent program should wait for the agent to exit. The amount of time this exit takes depends on the agent's current workload. The agent waits for any current operations to complete before deregistering and exiting. + +## Address provider compatibility errors + +If a provider does not support your agent’s architecture, the following error appears in the agent’s TRACE logs, the CLI, or the UI: + +```plaintext +Error: Incompatible provider version + +Provider registry.terraform.io// does not have a +package available for your current platform, . + +Provider releases are separate from Terraform CLI releases, so not all +providers are available for all platforms. Other versions of this provider +may have different platforms supported. +``` + +You can call the [Terraform provider registry API](/terraform/internals/provider-registry-protocol#list-available-versions) to confirm the architectures available for a provider. + +Sample request: + +```shell-session +$ curl 'https://registry.terraform.io/v1/providers/hashicorp/random/versions' +``` + +Sample response: + +```json +{ + "versions": [ + { + "version": "2.0.0", + "protocols": ["4.0", "5.1"], + "platforms": [ + {"os": "darwin", "arch": "amd64"}, + {"os": "linux", "arch": "amd64"}, + {"os": "linux", "arch": "arm"}, + {"os": "windows", "arch": "amd64"} + ] + }, + { + "version": "2.0.1", + "protocols": ["5.2"], + "platforms": [ + {"os": "darwin", "arch": "amd64"}, + {"os": "linux", "arch": "amd64"}, + {"os": "linux", "arch": "arm"}, + {"os": "windows", "arch": "amd64"} + ] + } + ] +} +``` + + +# CLI options + + +* `-name `: + An optional user-specified name for the agent. This name may be used in + the HCP Terraform user interface to help easily identify the agent. + + Default: `The agent's ephemeral ID, assigned during boot.` + + Environment variable: `TFC_AGENT_NAME` + + +* `-log-level `: + The log verbosity expressed as a level string. Level options include + "trace", "debug", "info", "warn", and "error". Log levels have a + progressive level of data sensitivy. The "info", "warn", and "error" levels + are considered generally safe for log collection and don't include + sensitive information. The "debug" log level may include internal system + details, such as specific commands and arguments including paths to user + data on the local filesystem. The "trace" log level is the most sensitive + and may include personally identifiable information, secrets, + pre-authorized internal URLs, and other sensitive material. + + Default: `info` + + Environment variable: `TFC_AGENT_LOG_LEVEL` + + +* `-log-json`: + Enable JSON logging mode. + + Default: `false` + + Environment variable: `TFC_AGENT_LOG_JSON` + + +* `-data-dir `: + The path to a directory to store all agent-related data, including + Terraform configurations, cached Terraform release archives, etc. It is + important to ensure that the given directory is backed by plentiful + storage. + + Default: `~/.tfc-agent` + + Environment variable: `TFC_AGENT_DATA_DIR` + + +* `-cache-dir `: + The path to a directory to store all agent-related cache data, including + cached Terraform release archives, policy binaries, etc. It is important to + ensure that the given directory is backed by plentiful storage. + + Default: `/cache` + + Environment variable: `TFC_AGENT_CACHE_DIR` + + +* `-single`: + Enable single mode. This causes the agent to handle at most one job and + immediately exit thereafter. Useful for running agents as ephemeral + containers, VMs, or other isolated contexts with a higher-level scheduler + or process supervisor. + + Default: `false` + + Environment variable: `TFC_AGENT_SINGLE` + + +* `-auto-update`: + Controls automatic core updates behavior. Acceptable values include + "disabled", "patch", and "minor". + + Default: `minor` + + Environment variable: `TFC_AGENT_AUTO_UPDATE` + + +* `-address `: + The HTTP or HTTPS address of the HCP Terraform API. + + Default: `https://app.terraform.io` + + Environment variable: `TFC_ADDRESS` + + +* `-token `: + The agent token to use when making requests to the HCP Terraform API. + This token must be obtained from the API or UI. It is recommended to use + the environment variable whenever possible for configuring this setting due + to the sensitive nature of API tokens. + + Required, no default. + Environment variable: `TFC_AGENT_TOKEN` + + +* `-otlp-address `: + Optional host:port address of an OpenTelemetry collector to send telemetry + data to, including metrics and tracing. Currently the agent connects to + this address using the gRPC protocol. + + Default: `none` + + Environment variable: `TFC_AGENT_OTLP_ADDRESS` + + +* `-otlp-cert-file `: + Optional path to a client TLS certificate file to load. When present, the + given certificate is used to encrypt the client connection to the + OpenTelemetry collector. When omitted, client connections are not secure. + + Default: `none` + + Environment variable: `TFC_AGENT_OTLP_CERT_FILE` + + +* `-accept `: + Optional string of comma-separated job types that this agent may run. + Acceptable job types are "plan", "apply", "policy", "assessment", "ingress", + "stack_prepare", "stack_plan", "stack_apply", "source_bundle", "stack_aggregate_outputs", + and "test". Do not put whitespace in between entries. + + Default: `plan,apply,policy,assessment,stack_prepare,stack_plan,stack_apply,source_bundle,stack_aggregate_outputs,test` + + Environment variable: `TFC_AGENT_ACCEPT` + + +* `-request-forwarding`: + Enable handling of forwarded HTTP requests. Enable this option only if you + are using product features which require it. + + Default: `false` + + Environment variable: `TFC_AGENT_REQUEST_FORWARDING` + + +* `-hyok`: + Enable handling HYOK requests for generating, re-encrypting, or decrypting data + keys using your KMS. This is not required to handle runs on HYOK workspaces. + Enable this option only if you are using product features which require it. + + Default: `false` + + Environment variable: `TFC_AGENT_HYOK` + + +* `-h`: + Display this message and exit. + +* `-v`: + Display the version and exit. + diff --git a/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/changelog.mdx b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/changelog.mdx new file mode 100644 index 000000000..073c1162b --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/changelog.mdx @@ -0,0 +1,840 @@ +--- +page_title: Changelog - HCP Terraform Agents - HCP Terraform and Terraform Enterprise +description: >- + Keep track of changes to the HCP Terraform Agent +--- + +# HCP Terraform Agent Changelog + +These are the release notes from the HCP Terraform Agent application. Changes +within each release are categorized into one or more of the following labels: + +* `FEATURES` - Used for net-new features being added to the agent. +* `BUG FIXES` - Backward-compatible fixes for buggy functionality. +* `IMPROVEMENTS` - Functional improvements to performance, effeciency, etc. +* `SECURITY` - Fixes for security-related issues. +* `BREAKING CHANGES` - Reserved for changes which break previous functionality. + +Each version below corresponds to a release artifact available for download on +the official [releases website](https://releases.hashicorp.com/tfc-agent/). + +## 1.25.0 (09/30/2025) + +FEATURES: + +* Added query as one of the default workload types the agent can run (#1183) + +BUG FIXES: + +* Fixed an issue where identical module sources using the FQDN and generic hostname resulted in a 422 error (#1178) + +SECURITY: + +* Updated Go to 1.25.1 to resolve various CVEs (#1188) + +## 1.24.0 (09/16/2025) + +FEATURES: + +* Added support to run Terraform query agent jobs (#1125) +* Added support for Stacks (#1158) + +## 1.23.2 (08/14/2025) + +SECURITY: + +* Changed Sentinel and OPA command output to log at `trace` level. These +policy engines allow authors to create policies which may inadvertently output +sensitive information, which should never be included in normal operational +logs. (#1139) + +## 1.23.1 (08/05/2025) + +BUG FIXES: + +* Fixed agent to terminate immediately when authentication tokens are revoked during job execution (#1092) + +SECURITY: + +* Updated Go to 1.24.5 to resolve various CVEs (#1122) + +## 1.23.0 (07/22/2025) + +BUG FIXES: + +* Removed erroneous Println statement used for debugging (#1099) + +FEATURES: + +* Added support for Hold Your Own Key (HYOK) to enable data key generation, key revocation, and key testing. (#1095, #1109) + +## 1.22.5 (06/24/2025) + +SECURITY: + +* Updated dependency `github.com/go-chi/chi/v5` to `v5.2.2` to resolve vulnerability [GHSA-vrw8-fxc6-2r93](https://github.com/go-chi/chi/security/advisories/GHSA-vrw8-fxc6-2r93) (#1086) + +## 1.22.4 (06/11/2025) + +BUG FIXES: + +* Added a file system sync when extracting the terraform binary in order to avoid rare, unreported errors during execution (#1065) + +IMPROVEMENTS: + +* Added Linux ARM64 agent builds (#1073) + +## 1.22.3 (05/27/2025) + +SECURITY: + +* Updated dependency `github.com/hashicorp/go-slug` to `v0.16.5` to resolve various vulnerabilities (#968) + +## 1.22.2 (05/13/2025) + +BUG FIXES: + +* Fixed Request Forwarding to restart after an agent update (#1020) + +SECURITY: + +* Updated Go to 1.24.3 to resolve various CVEs (#1030) + +## 1.22.1 (04/29/2025) + +SECURITY: + +* Updated golang.org/x/net dependency to v0.39.0 to address GO-2025-3595 (#995) + +## 1.22.0 (04/15/2025) + +FEATURES: + +* Added ability to check for private module versions that are revoked and display revocations warnings in the run output of existing module consumers. New users of the revoked version will see an error in their run output. (#973) + +## 1.21.2 (04/03/2025) + +BUG FIXES: + +* Silenced profiler errors on systems where i/o data is unavailable (#973) +* Fixed spurious 404 errors seen as workloads are completed (#667) + +## 1.21.1 (04/01/2025) + +SECURITY: + +* Added guards for sensitive values exposed by procfs (#776, #784) + +IMPROVEMENTS: + +* Improved backpressure signaling for request forwarding (#964) + +## 1.21.0 (03/18/2025) + +IMPROVEMENTS: + +* Upgraded Ubuntu to `v24.04` for base Docker image. (#922) + +## 1.20.2 (03/04/2025) + +SECURITY: + +* Updated golang.org/x/crypto dependency to v0.35.0 to address GO-2025-3487 (#935) +* Updated golang.org/x/oauth2 dependency to v0.27.0 to address GO-2025-3488 (#935) + +## 1.20.1 (02/19/2025) + +BUG FIXES: + +* Fixed a bug that would prevent tfc-agent from cleaning up temporary directories that contained subdirectories with readonly permissions. (#921) + +## 1.20.0 (02/06/2025) + +BUG FIXES: + +* Rolled back to Ubuntu `v20.04` from upgrade to `v24.04` for base Docker image to address errors seen with `v24.04`. (#913) + - This fixed a bug which caused tfc-agent:v1.19.0 to break on certain configs using local-exec or other provisioners that rely on python or the AWS CLI. + +## 1.19.0 (02/05/2025) + +BUG FIXES: + +* Changed `201` HTTP status code log from `ERROR` to `DEBUG`. (#891) + +IMPROVEMENTS: + +* Upgraded Ubuntu to `v24.04` for base Docker image. (#903) +* Added log of `OS` and `Arch` at agent start (#901) + +## 1.18.0 (01/29/2025) + +FEATURES: + +* Added ability to check for private module versions that are deprecated and display deprecation warnings in the run output (#879) + +SECURITY: + +* Updated dependency `github.com/hashicorp/go-slug` to `v0.16.4` (#892) + - This resolved [CVE-2025-0377 in hashicorp/go-slug](https://discuss.hashicorp.com/t/hcsec-2025-01-hashicorp-go-slug-vulnerable-to-zip-slip-attack/72719). + - Fixed a bug which caused tfc-agent:v1.17.6 to break on certain API-driven workflows in HCP Terraform and Terraform Enterprise. + +## 1.17.6 (01/23/2025) + +SECURITY: + +* Updated dependency `github.com/hashicorp/go-slug` to `v0.16.3` (#867) + - **Important:** v0.16.3 of go-slug contained a bug which caused tfc-agent:v1.17.6 to break on certain API-driven workflows in HCP Terraform and Terraform Enterprise. + - This resolved [CVE-2025-0377 in hashicorp/go-slug](https://discuss.hashicorp.com/t/hcsec-2025-01-hashicorp-go-slug-vulnerable-to-zip-slip-attack/72719). +* Updated dependencies `github.com/go-git/go-git/v5` to `v5.13.1` and `golang.org/x/net` to `v0.34.0` (#873) + +## 1.17.5 (12/12/2024) + +BUG FIXES: + +* Ensured Sentinel subjects are correctly managed and Terraform plugins are enabled when required (#854) + +## 1.17.4 (12/12/2024) + +BUG FIXES: + +* Surfaced errors due to invalid Sentinel output on errored Sentinel commands (#850) + +## 1.17.3 (12/10/2024) + +BUG FIXES: + +* Updated inaccurate constraint introduced in previous version gating ephemeral variables (#841) +* Fixed an issue where streaming extremely large job outputs would retry after the server rejected further requests (#837) + +## 1.17.2 (11/26/2024) + +IMPROVEMENTS: + +* Added jitter to connection retries for Request Forwarding (#817) +* Ensured ephemeral variables (Terraform v1.10 feature) are passed between plan & apply (#831) + +## 1.17.1 (11/13/20204) + +IMPROVEMENTS: + +* Added support for a custom timeout on each hook (#820) + +## 1.17.0 (10/30/2024) + +BREAKING CHANGES: + +* Changed the network protocol that supports unreleased Request Forwarding functionality, which affects Private VCS Providers (#801) + +BUG FIXES: + +* Fixed issue where some fatal errors were logged at debug level instead of error (#799) +* Fixed an issue where the hashicorp/tfc-agent Docker image could have the wrong owners for /home/tfc-agent/bin/* content (#807) + +## 1.16.0 (10/02/2024) + +FEATURES: + +* Added support for authenticating with AWS and GCP using dynamic credentials generated via HCP Vault Secrets (#786) + +## 1.15.5 (09/18/2024) + +IMPROVEMENTS: + +* Included a copy of the license text with all releases (#772) + +SECURITY: + +* Moved to building with Go 1.22.7 in which several CVEs are addressed (#781) + +## 1.15.4 (07/24/2024) + +SECURITY: + +* Moved to building with Go 1.22.5 in which several CVEs are addressed (#727) + +## 1.15.3 (07/10/2024) + +SECURITY: + +* Updated go-retryablehttp dependency to address CVE-2024-6104 (#712) +* Removed unnecessary linux-libc-dev package from published container image (#714) + +## 1.15.2 (05/29/2024) + +BUG FIXES: + +* Fixed consistency of the `status.` gauge metrics (#680) +* Fixed cpu utilization gauge and clarified metric names (#681) + +IMPROVEMENTS: + +* Improved collection of errors from VCS Repositories when performing ingress (#683) + +## 1.15.1 (05/01/2024) + +IMPROVEMENTS: + +* Added telemetry metric `requests.forwarding.count` (#651) +* Added error log for when an organization does not have request forwarding permission (#658) +* Improved logs when disconnected from the broker (#654) +* Added resource utilization metrics during workload execution (#619) +* Added support for authenticating with HCP via dynamic credentials (#673) + +BUG FIXES: + +* Updated documentation to include ingress and test as accept options. (#643) +* Fixed bug which allowed forwarding requests when unauthorized. (#661) + +## 1.15.0 (03/13/2024) + +FEATURES: + +* Added support for HTTP request forwarding (#635) +* Added support for Ingress functionality (#637) + +## 1.14.5 (02/28/2024) + +BUG FIXES: + +* Fixed bug to handle Sentinel parameters that were collection of nested data types (#624) + +## 1.14.4 (02/14/2024) + +BUG FIXES: + +* Fixed Sentinel metrics to use snake-case for consistency with other metrics (#617) + +## 1.14.3 (01/17/2024) + +BUG FIXES: + +* Updated dependencies to address CVEs: GHSA-9763-4f94-gfch, CVE-2023-49569, CVE-2023-49568 + +## 1.14.2 (12/19/2023) + +BUG FIXES: + +* Fixed issue that caused a canceled plan to not interrupt terraform (#575) + +## 1.14.1 (11/16/2023) + +BUG FIXES: + +* Fixed issue that could cause a "failed to load shared config file" error in certain cases for Vault-backed AWS dynamic credentials (#557) + +## 1.14.0 (11/09/2023) + +FEATURES: + +* Added support for terraform test (#546) +* Added support for dynamic provider credentials for the Kubernetes and Helm providers (#503) + +IMPROVEMENTS: + +* Optimized filesystem storage footprint by trimming provider installs before upload (#532) + +BUG FIXES: + +* Fixed unexpected behavior with policies by preserving file timestamps and modes on unpacked archives (#548) + +## 1.13.1 (10/25/2023) + +IMPROVEMENTS: + +* Added any warnings emitted from Sentinel evaluation into the policy outcome (#534) + +## 1.13.0 (09/27/2023) + +FEATURES: + +* Added support for Sentinel policies to be evaluated within the agent (#519) + +IMPROVEMENTS: + +* Increased timeout for generating JSON artifacts from 5 to 10 minutes (#511) + +## 1.12.1 (09/13/2023) + +IMPROVEMENTS: + +* Added policy tool version into the policy outcome for better debugging (#461) +* Added handling for the "errored.tfstate" file when states fail to upload (#464) +* Added ability to omit filesystem upload based on the presence of the filesystem url (#480) + +BUG FIXES: + +* Fixed a race condition which could lead to unsent job status updates to the backend (#466) + +## 1.12.0 (07/26/2023) + +BUG FIXES: + +* Fixed OpenTelemetry log message to reflect insecure connections (#453) + +FEATURES: + +* Added support for specifying a wait time after generating Vault-backed AWS credentials (#451) +* Added support for multiple dynamic credentials configurations (#452) + +IMPROVEMENTS: + +* Increased max wait time for Vault-backed Azure credentials to 25 minutes from 15 minutes (#450) + +## 1.11.0 (07/19/2023) + +FEATURES: + +* Added support for specifying a wait time after generating Vault-backed Azure credentials (#437) +* Ensured that all assessment jobs execute a terraform refresh (#426) + +BUG FIXES: + +* Fixed dependency report generation to respect Terraform workspace working directory settings - previous report generation would fail to find files relating to Terraform dependencies in some circumstances. (#441) + +## 1.10.1 (07/07/2023) + +BUG FIXES: + +* Fixed JSON unmarshalling errors when generating the redacted plan (#427) + +## 1.10.0 (06/08/2023) + +FEATURES: + +* Added support for Terraform 1.5 (#395) + +## 1.9.0 (05/04/2023) + +FEATURES: + +* Added support for specifying a custom CA cert for Vault dynamic credentials (#379) +* Added support for setting env vars from Terraform hook scripts (#378) + +IMPROVEMENTS: + +* Updated Docker container to pre-create the data directory (#380) + +## 1.8.0 (04/18/2023) + +BUG FIXES: + +* Fixed an issue which prevented some Dynamic Credentials validation error messages from being relayed (#365) +* Fixed crash when unpacking configuration versions that contained archive entries with an empty name (#371) + +IMPROVEMENTS: + +* Updated logs, metrics, and traces to have consistently named attributes (#357, #364) +* Removed unnecessary nesting from telemetry attributes (#368) + +FEATURES: + +* Added ability to collect terraform, module and provider versions for reporting purposes (#367) +* Added support for vault-backed dynamic provider credentials (#370) + +## 1.7.1 (03/29/2023) + +BUG FIXES: + +* Fixed tracing span issues when executing Terraform operations (#340) +* Changed the metrics export interval to support more telemetry platforms (#348) + +IMPROVEMENTS: + +* Updated OpenTelemetry SDK libraries for improved compatibility (#327) + +## 1.7.0 (03/02/2023) + +FEATURES: + +* Added support for dynamic provider credentials (#328) + +BUG FIXES: + +* Fixed exit code during startup errors (#335) + +## 1.6.1 (02/23/2023) + +SECURITY: + +* Added validation checks for filepaths when extracting Terraform bundles (#323) + +## 1.6.0 (12/20/2022) + +FEATURES: + +* Added a new configuration setting for defining the cache directory (#303) + +IMPROVEMENTS: + +* Increased deadline for "terraform init" process to 10 minutes (#312) + +## 1.5.0 (12/14/2022) + +FEATURES: + +* Added new CLI configuration for controlling which types of jobs an agent accepts (#251) +* Terraform module sources now support the generic hostname `localterraform.com` (#264) + +BUG FIXES: + +* Fixed hook scripts not executing if the operation errors or exits early (#250) +* Fixed handling of plugin directory in custom Terraform bundles (#295) + +## 1.4.0 (10/05/2022) + +IMPROVEMENTS: + +* Added better validation of Terraform run payloads (#226) + +FEATURES: + +* Added the policy component, making it possible for policies to be evaluated within the agent (#235) + +## 1.3.1 (09/13/2022) + +BUG FIXES: + +* Fixed issues with download retries (#191) +* Fixed validation of workspaces with no Terraform configuration files (#190) + +IMPROVEMENTS: + +* Added error logging when failing to generate JSON artifacts (#192) + +## 1.3.0 (08/04/2022) + +FEATURES: + +* Added generation of "terraform show" plaintext output during plans (#183) + +BUG FIXES: + +* Fixed a race condition causing tfc-agent to send status updates forever (#186) + +## 1.2.7 (08/01/2022) + +BUG FIXES: + +* Fixed provider symlink preservation for custom Terraform bundles (#182) + +IMPROVEMENTS: + +* Removed the redundant "terraform init" command during apply operations (#182) + +## 1.2.6 (06/24/2022) + +BUG FIXES: + +* Fixed execution of internal Terraform commands when TF_* args are set (#170) + +## 1.2.5 (06/23/2022) + +BUG FIXES: + +* Fixed support for absolute symlinks which point to relative files (#168) +* Added a fixed deadline for telemetry shutdown (#166) + +IMPROVEMENTS: + +* Added user-error classification for bad data during filesystem uploads (#167) + +## 1.2.4 (06/21/2022) + +BUG FIXES: + +* Added support for dangling symlinks with relative targets (#164) + +## 1.2.3 (06/09/2022) + +BUG FIXES: + +* Fixed inconsistent paths between plan and apply (#161) + +## 1.2.2 (05/12/2022) + +IMPROVEMENTS: + +* Added attributes to traces created by the agent. (#134) + +BUG FIXES: + +* Fixed handling of Terraform JSON artifact generation errors (#156) + +## 1.2.1 (05/11/2022) + +BUG FIXES: + +* Fixed the ability to use a symlink as the working directory (#151) + +## 1.2.0 (05/02/2022) + +IMPROVEMENTS: + +* Added better error handling for non-existent working directories (#148) +* Added jq, python, and pip to the Docker image (#149) + +## 1.1.7 (04/25/2022) + +BUG FIXES: + +* Fixed response handling for retryable downloads (#146) + +## 1.1.6 (04/20/2022) + +BUG FIXES: + +* Fixed OpenTelemetry metrics by rolling back client version (#144) + +## 1.1.5 (04/18/2022) + +IMPROVEMENTS: + +* Improved resilience of downloads by adding retries. (#136) + +## 1.1.4 (03/22/2022) + +BUG FIXES: + +* Fixed `HOME` environment variable during hook execution. (#130) + +## 1.1.3 (03/17/2022) + +SECURITY: + +* Updated Docker image to address OpenSSL CVE-2022-0778 (#129) + +## 1.1.2 (03/11/2022) + +BUG FIXES: + +* Fixed Terraform variable validation to accept Terraform v0.12+ syntax. (#122) +* Fixed core HTTP requests (fetch jobs, post status) to log in debug mode (#125) +* Extended HTTP header timeout to 30 seconds (#127) + +## 1.1.1 (03/09/2022) + +IMPROVEMENTS: + +* Added redacted HTTP logs in debug log mode (#123) + +## 1.1.0 (02/23/2022) + +FEATURES: + +* Added support for executing hooks at various stages of a Terraform run. (#109) + +BUG FIXES: + +* Fixed missing operation name in Terraform run temp dir paths (#115) + +IMPROVEMENTS: + +* Added Nomad context to logs, traces, and metrics when available (#109) +* Added ping command to Docker image (#112) + +## 1.0.2 (12/07/2021) + +BUG FIXES: + +* Fixed key collision in log attributes when performaing status updates (#105) +* Fixed race condition during status updates at the end of a job (#106) + +## 1.0.1 (11/11/2021) + +IMPROVEMENTS: + +* Added basic user-error classification to Terraform component logs (#103) + +## 1.0.0 (10/29/2021) + +BREAKING CHANGES: + +* Changed logging to only include Terraform output at trace level (#88) +* Removed deprecated `-disable-update` and `TFC_AGENT_DISABLE_UPDATE` (#95) + +SECURITY: + +* Removed all SUID/SGID binaries from the Docker container (#91) + +BUG FIXES: + +* Fixed agent behavior when core HTTP requests block for a long time (#90) + +IMPROVEMENTS: + +* Added additional metadata to logs when using JSON logging mode (#84) +* Added more descriptive log when new major versions become available (#89) +* Increased HTTP retries when receiving server errors from TFC (#92) +* Added utilities to Docker image to support modules, provisioners, etc. (#93) +* Added support for Terraform versions 1.1+ via the "cloud" integration (#94) +* Added detection of unrecognized `TFC_AGENT_*` environment variables (#97) + +## 0.4.2 (10/06/2021) + +BUG FIXES: + +* Fixed errors resulting from using "disabled" auto-update mode (#81) +* Fixed trace flushing to ensure all spans are recorded properly (#82) + +IMPROVEMENTS: + +* Added verification of core plugin major version (#80) + +## 0.4.1 (09/13/2021) + +IMPROVEMENTS: + +* Increased timeout for generating JSON artifacts from one to five minutes (#78) +* Improved timeout logging when generating JSON artifacts (#78) + +## 0.4.0 (08/20/2021) + +FEATURES: + +* Added configurable automatic update strategy to make upgrades safer (#59) + +BUG FIXES: + +* Fixed segfault when no valid Terraform files were found (#67) + +## 0.3.2 (07/22/2021) + +BUG FIXES: + +* Fixed Docker image OS permissions for automatic updates (#64) + +## 0.3.1 (07/22/2021) + +BUG FIXES: + +* Fixed Terraform output buffer corruption (#63) + +## 0.3.0 (07/07/2021) + +BREAKING CHANGES: + +* Changed the user in the Docker container to be non-root (#56) + +SECURITY: + +* Changed the user in the Docker container to be non-root (#56) + +## 0.2.1 (06/03/2021) + +IMPROVEMENTS: + +* Added HTTP retries during registration and status updates. (#53) + +FEATURES: + +* Added support for JSON-formatted log output (#54) + +BUG FIXES: + +* Fixed release builds to always compile binaries statically (#55) + +## 0.2.0 (06/18/2021) + +FEATURES: + +* Added support for using custom Terraform bundles (#52) +* Added support for Terraform's -replace flag (#51) +* Added support for Terraform's -refresh-only flag (#49) +* Added support for structured run output (#34) + +BUG FIXES: + +* Fixed Terraform resource targeting (#50) + +## 0.1.14 (05/06/2021) + +BREAKING CHANGES: + +* Updated the HashiCorp GPG public key for release verification (#41) + +## 0.1.13 (05/06/2021) + +FEATURES: + +* Added support for Terraform's -refresh=false flag (#43) +* Added support for flash messages (#47) + +## 0.1.12 (04/27/2021) + +FEATURES: + +* Added support for exporting tracing and metrics via OpenTelemetry (#38) + +## 0.1.11 (04/14/2021) + +IMPROVEMENTS: + +* Expanded signal handling to include SIGTERM, SIGINT, and SIGQUIT (#39) + +## 0.1.10 (04/05/2021) + +IMPROVEMENTS: + +* Added support for Terraform versions back to v0.9.1 (#35) + +## 0.1.9 (03/09/2021) + +BUG FIXES: + +* Fixed upgrades from Terraform v0.12 to v0.13 (#33) + +IMPROVEMENTS: + +* Added base OS update during Docker image builds (#30) + +## 0.1.8 (01/11/2021) + +BUG FIXES: + +* Added a work-around for Docker sending multiple INT signals on ctrl+c (#29) + +## 0.1.7 (01/07/2021) + +SECURITY: + +* Removed access to tfc-agent configuration env vars after agent boot up (#28) + +## 0.1.6 (01/05/2021) + +FEATURES: + +* Added variable sensitivity propagation for Terraform 0.14+ (#27) + +## 0.1.5 (12/03/2020) + +SECURITY: + +* Mitigated zipslip vulnerability (#24) + +## 0.1.4 (10/21/2020) + +BUG FIXES: + +* Fixed handling of user-defined SSH keys during Terraform runs (#21) + +## 0.1.3 (09/08/2020) + +BUG FIXES: + +* Removed dynamic linker cache in Docker image (#20) + +## 0.1.2 (08/14/2020) + +BUG FIXES: + +* Fixed handling of custom env vars when running "terraform version" (#19) + +## 0.1.1 (08/12/2020) + +BUG FIXES: + +* Added required packages used by Terraform for cloning modules + +## 0.1.0 (08/12/2020) + +Initial release diff --git a/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/hooks.mdx b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/hooks.mdx new file mode 100644 index 000000000..dfa7f5f54 --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/hooks.mdx @@ -0,0 +1,209 @@ +--- +page_title: HCP Terraform agent hooks +description: >- + Use HCP Terraform agent hooks to run custom programs at specific stages of Terraform runs. +--- + +# Agent Hooks + +HCP Terraform Agents support running custom programs, or _hooks_, during +strategic points of a Terraform run. These hooks allow you to extend the +functionality of Terraform runs. For example, you may create a hook to +dynamically download software required by the Terraform run or send an HTTP +request to a system to kick off an external workflow. + + +Agent hooks do not support Stack workflows in HCP Terraform. + + +## Supported Hooks + +HCP Terraform Agents support the following hooks: + +- `pre-plan` - Runs before `terraform init` during a `plan` operation. + +- `post-plan` - Runs after `terraform plan` during a `plan` operation + regardless of whether or not `terraform plan` completed successfully. + +- `pre-apply` - Runs before `terraform init` during an `apply` operation. + +- `post-apply` - Runs after `terraform apply` during an `apply` operation + regardless of whether or not `terraform apply` completed successfully. + +## Hook Behavior + +Please note the following behavior when using hooks: + +- If a hook exits with a non-zero exit code, the Terraform run will fail + immediately. +- The standard output and standard error from the hook will be printed + alongside the Terraform run output in the HCP Terraform or Terraform Enterprise user + interface. +- The hook name must match one of the [supported hooks](#supported-hooks). You + cannot customize or change these names. Because of this, there can only be + one hook of each type configured for each agent. For example, you could + create a `pre-plan` and `pre-apply` hook, but you cannot create two + `pre-plan` hooks. +- Each hook must have the execute permission set. +- Each hook has a default timeout of 60 seconds and a max timeout of 10 minutes. + You can configure hook timeouts using global timeouts or hook-specific timeouts. + You can set the value of any hook timeout in seconds. If a hook times out, the Terraform + run fails immediately. + - To set global timeouts, use the `TFC_AGENT_HOOK_TIMEOUT` environment variable. + - To set hook-specific timeouts, use an environment variable with the hook’s name + `TFC_AGENT_HOOK_[HOOK NAME]_TIMEOUT`. For example, you can set the timeout for the + pre-plan hook to 2 minutes by setting `TFC_AGENT_HOOK_PRE_PLAN_TIMEOUT=120`. + A hook-specific timeout takes precedence over the global hook timeout. +- Terraform environment variables do not persist across hooks. For example, if a + `pre-plan` hook exports environment variables, they will not be available + during the `post-plan` hook. Similarly, if `terraform plan` exports + environment variables, they will not be available during the `post-plan` hook. + +## Setting Terraform Environment Variables + +Hooks may be used to set environment variables for subsequent `terraform` +commands to use. To set an environment variable, write lines in `KEY=value` +format to the file pointed to by the `$TFC_AGENT_ENV` environment variable. +Newlines are used to separate multiple environment variables. For example, to +set the `FOO` and `BAR` environment variables for the `terraform plan` operation +to consume, write the following in a `pre-plan` hook script: + +``` +#!/bin/sh +echo FOO=hello >> $TFC_AGENT_ENV +echo BAR=world >> $TFC_AGENT_ENV +``` + +Environment variables set by a hook script in this way are only applicable to +the current operation, and are not persisted for later operations. For example, +if `FOO=bar` is set in the `pre-plan` hook, then `FOO=bar` will be set during +the `terraform plan` command, but will not be set during `terraform apply`. To +use the variable during the apply phase, write the variable to the +`$TFC_AGENT_ENV` file again in the `pre-apply` hook script. + +## Configuration + +Hooks are stored within the `hooks` subdirectory of the agent's data directory. +By default, that's `~/.tfc-agent/hooks`. + +To configure a hook, create a file named `terraform-${HOOK}` where `${HOOK}` +is one of the hooks listed above. Then store that file within the `hooks` +subdirectory and make it executable. The agent will trigger configured hooks +at the appropriate points during Terraform runs. + +For example, a `pre-plan` hook is an executable file named +`~/.tfc-agent/hooks/terraform-pre-plan`. When this hook is configured, an agent +will run this hook before `terraform init` during a `plan` operation. + +### Running an Agent as a Binary + +To configure hooks when running the `tfc-agent` binary directly on a Linux +instance: + +1. Create the `hooks` directory within the agent's data directory. + + ```sh + mkdir -p ~/.tfc-agent/hooks + ``` + +1. Create one or more hooks inside the `hooks` directory. The following +example creates a `pre-plan` hook that prints a message when it runs. + + ```sh + cat < ~/.tfc-agent/hooks/terraform-pre-plan + #!/bin/bash + echo "Example hook output." + EOF + ``` + +1. Make the hooks executable. + + ```sh + chmod +x ~/.tfc-agent/hooks/terraform-pre-plan + ``` + +1. Start the agent. + + ```sh + tfc-agent + ``` + +1. The agent will now trigger configured hooks at the appropriate points +during Terraform runs. The standard output and standard error from the hook +will be printed alongside the Terraform run in the HCP Terraform or Terraform Enterprise +user interface. + + ``` + Terraform v1.1.0 + Executing pre-plan hook... + Example hook output. + Initializing plugins and modules... + ``` + +### Running an Agent with Docker + +When running `tfc-agent` using Docker, you must build a new Docker image +containing the hooks. To configure hooks: + +1. Create a new directory and navigate into it. This limits the Docker build +context to this new directory. + + ```sh + mkdir hooks-docker-example + cd hooks-docker-example + ``` + +1. Create a `hooks` directory. + + ```sh + mkdir hooks + ``` + +1. Create one or more hooks inside the `hooks` directory. The following +example creates a `pre-plan` hook that prints a message when it runs. + + ```sh + cat < hooks/terraform-pre-plan + #!/bin/bash + echo "Example hook output." + EOF + ``` + +1. Make the hooks executable. + + ```sh + chmod +x hooks/terraform-pre-plan + ``` + +1. Create a `Dockerfile` with the following content. + + ``` + FROM hashicorp/tfc-agent:latest + RUN mkdir /home/tfc-agent/.tfc-agent + ADD --chown=tfc-agent:tfc-agent hooks /home/tfc-agent/.tfc-agent/hooks + ``` + +1. Build a new `hashicorp/tfc-agent` Docker image using the `Dockerfile`. + + ``` + docker build -t hashicorp/tfc-agent:your-tag . + ``` + +1. Start the agent using the Docker image. + + ```sh + docker run -e TFC_AGENT_TOKEN=your-token -e TFC_AGENT_NAME=your-agent-name \ + hashicorp/tfc-agent:your-tag + ``` + +1. The agent will now trigger configured hooks at the appropriate points +during Terraform runs. The standard output and standard error from the hook +will be printed alongside the Terraform run in the HCP Terraform or Terraform Enterprise +user interface. + + ``` + Terraform v1.1.0 + Executing pre-plan hook... + Example hook output. + Initializing plugins and modules... + ``` diff --git a/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/index.mdx b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/index.mdx new file mode 100644 index 000000000..b837c5730 --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/index.mdx @@ -0,0 +1,20 @@ +--- +page_title: HCP Terraform agents +description: >- + HCP Terraform agents let you manage isolated, private, or on-premises infrastructure while keeping your network secure. +--- + +# HCP Terraform Agents + +@include 'agents.mdx' + +HCP Terraform Agents allow HCP Terraform to communicate with isolated, private, or on-premises infrastructure. By deploying lightweight agents within a specific network segment, you can establish a simple connection between your environment and HCP Terraform, facilitating provisioning and management operations. This is useful for on-premises infrastructure types such as vSphere, Nutanix, OpenStack, enterprise networking providers, and any systems in a protected enclave. + +> **Hands-on:** Try the [Manage Private Environments with HCP Terraform Agents](/terraform/tutorials/cloud/cloud-agents) tutorial. + +The agent requires only outbound connectivity to HCP Terraform, enabling private networks to remain secure. No special networking configuration or exceptions are typically needed. + +## Terraform Enterprise + +Terraform Enterprise supports HCP Terraform Agents. Refer to +[HCP Terraform Agents on Terraform Enterprise](/terraform/enterprise/application-administration/agents-on-tfe) for Terraform Enterprise specific documentation and requirements. diff --git a/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/logging.mdx b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/logging.mdx new file mode 100644 index 000000000..28c3bfc2d --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/logging.mdx @@ -0,0 +1,84 @@ +--- +page_title: HCP Terraform agent logging +description: >- + HCP Terraform agent logs contain output and flash messages about agent operations. Learn about agent verbosity levels and format. +--- + +# Agent logging + +HCP Terraform Agents log helpful messages that tell operators about +agent behavior, including communication with HCP Terraform APIs, specific +commands run, actions taken, and runtime management. + +## Log output + +HCP Terraform Agents write log messages directly to stdout/stderr. This +lets the operator capture the logs in a variety of +different logging systems, gives CLI users a way +to see a log of the agent's behavior directly in their terminal. By default, +the agent does not automatically persist the log output in any way. The user +must write the logs to a file or collect them with a process or +container supervisor if persistence is required. + +## Log verbosity and levels + +The volume of logs and the level of detail they contain are controlled by log +levels. There are 5 levels supported by the agent: + +* `error` contains only critical error messages. The agent process is otherwise + silent. +* `warn` contains all error-level messages, as well as informational messages + such as system messages directly from the HCP Terraform platform. +* `info` contains all warn-level messages and high-level information about the + agent and the workflows it is executing. In normal circumstances, this is + the safest and most helpful log level for day to day operation. +* `debug` contains all info-level messages, plus additional informational + messages which provide further context about behavior, data, and events. +* `trace` contains all debug-level messages, plus verbose process logs such as + the line-by-line output of the `terraform` command. + +## Data format + +By default, HCP Terraform Agents emit log lines in a human-readable text +format. This is convenient for running the HCP Terraform Agent locally and streaming the +logs directly to a terminal, or for use in log systems where raw logs are +consumed directly by operators. The default text format looks something like +the following: + +``` +2023-04-14T17:12:43.002Z [INFO] core: Job received: job_type=plan job_id=run-xxx +``` + +It is also possible to configure the HCP Terraform Agent to produce JSON- +formatted logs. This format will cause each log line to be serialized as an +individual JSON object, and is more ideal for logging systems which are capable +of parsing and performing post-processing on log data for each line. JSON +logging mode is enabled by passing the `-log-json` CLI flag, or setting the +environment variable `TFC_AGENT_LOG_JSON=1`. The JSON format contains additional +verbose information in each log message, and looks something like this: + +``` +{"@level":"info","@message":"Job received","@module":"core","@timestamp":"2023-04-13T23:35:28.653853Z","agent_id":"agent-xxx","agent_name":"name","agent_pool_id":"apool-xxx","agent_version":"1.7.1","job_id":"run-xxx","job_type":"plan"} +``` + +## Log data sensitivity + +Log levels have a progressive level of data sensitivy. The `info`, `warn`, and +`error` levels are considered generally safe for log collection and don't +include sensitive information. The `debug` log level may include internal +system details, such as specific commands and arguments including paths to user +data on the local filesystem. The `trace` log level is the most sensitive and +may include personally identifiable information, secrets, pre-authorized +internal URLs, and other sensitive material. + +## Flash Messages + +Flash Messages are a type of log that HashiCorp may send to agents from time to time. These messages may be used to communicate important or breaking changes to the agent. Flash Messages will be emitted when HashiCorp adds a new one, or when starting up an agent for the first time. Their output looks something like: + +``` +2021-09-22T15:20:59.269Z [WARN] notice: A breaking change is incoming. +``` + +Flash Messages are version specific, and may only apply to the specific version of the agent you are running. + +Adding monitoring and alerting for these `notice` messages may help you operate HCP Terraform Agents more easily. diff --git a/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/metrics.mdx b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/metrics.mdx new file mode 100644 index 000000000..24c0d4bf2 --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/metrics.mdx @@ -0,0 +1,176 @@ +--- +page_title: HCP Terraform agent metrics +description: >- + Use metrics to analyze HCP Terraform agent performance. Learn about supported core, runtime, and Terraform and policy component metrics. +--- + +# Agent metrics + +The HCP Terraform Agent emits numerous metrics describing the agent's +performance. + + +## Metric naming conventions + +All metrics emitted by the HCP Terraform Agent follow some general naming +conventions which convey useful context about the measurements. + +* All metrics are prefixed by `tfc-agent.` to distinguish them from any + other metrics in your environment. +* When a metric requires a unit in order to be understood, an un-abbreviated + unit will be the last component of the metric name. For example, `.bytes`, or + `.milliseconds`. +* All timing metrics (other than runtime metrics) are measured in milliseconds. +* All data size metrics are measured in bytes. +* Underscores are used to separate words in metric names when submitted to the + collector over the OTLP protocol. + +## Metric data types + +HCP Terraform agents emit three types of metric data: + +* Gauges submit an absolute number value at the end of a measurement period. +* Counters accumulate number values during a measurement period. The sum of the + numbers is recorded at the end of a measurement period and the value is reset + to zero for the next period. +* Timers measure the time taken to complete a task. + +## Core metrics + +The following metrics are generated by the HCP Terraform Agent core program, +and are related to generic operations performed regularly by all agents. All +metrics in this section are prefixed by `tfc-agent.core.`. + +| Meric name | Type | Description | +| ---------------------------- | ----- | -------------------------------------------------------------------- | +| `status.busy` | Gauge | Number of agents in `busy` status. | +| `status.idle` | Gauge | Number of agents in `idle` status. | +| `register.milliseconds` | Timer | Time to register the agent with HCP Terraform. | +| `fetch_job.milliseconds` | Timer | Time to complete a job dequeue request. | +| `update_status.milliseconds` | Timer | Time to send a status update over from the agent to HCP Terraform. | + +## Runtime metrics + +The HCP Terraform Agent produces a number of metrics which are generated by +the application runtime, and are primarily useful in debugging the HCP Terraform Agent. +These metrics are emitted periodically throughout the entire agent process +lifecycle. It is important to note that these metrics do not represent a +complete picture of resource utilization by the agent. The agent may fork child +processes (such as the Terraform binary or other programs) which maintain their +own distinct runtimes and consume resources independently of the agent. To +monitor resource utilization comprehensively, consider monitoring VM or +container metrics. All metrics in this section are prefixed by +`tfc-agent.core.runtime.`. + +| Metric name | Type | Description | +| ------------------------------- | ----- | --------------------------------------------------- | +| `go.mem.heap_alloc.bytes` | Gauge | Memory allocated to heap objects by the Go runtime. | +| `go.mem.heap_idle.bytes` | Gauge | Memory allocated to the heap which are unused. | +| `go.mem.heap_inuse.bytes` | Gauge | Memory allocated to the heap which are in use. | +| `go.mem.heap_sys.bytes` | Gauge | Memory obtained from the OS for the heap. | +| `go.mem.heap_released.bytes` | Gauge | Memory returned to the OS during GC. | +| `go.mem.heap_objects.count` | Gauge | Number of allocated heap objects. | +| `go.mem.lookups.count` | Gauge | Number of pointer lookups. | +| `go.mem.malloc.count` | Gauge | Cumulative count of heap objects allocated. | +| `go.mem.free.count` | Gauge | Cumulative count of heap objects freed. | +| `go.gc.count` | Gauge | Number of completed GC cycles. | +| `go.goroutines.count` | Gauge | Number of running goroutines. | +| `go.gc.pause_total.nanoseconds` | Timer | Cumulative time spent in stop-the-world pauses. | +| `uptime.milliseconds` | Timer | Cumulative time since the agent started. | + +## Resource utilization metrics + +HCP Terraform Agents emit metrics about overall system resource utilization any +time the agent's status is `busy` (i.e., when the agent is handling a plan, +apply, policy evaluation, etc.) These metrics use kernel-level information to +produce metrics and should match closely with what you would get from familiar +tools such as `top` and `free`. All metrics in this section are prefixed by +`tfc-agent.core.profiler.`. + +| Metric name | Type | Description | +| --------------------------- | ----- | --------------------------------------------------------------------------- | +| `cpu.busy.percent` | Gauge | Percentage of CPU time spent in a busy state. | +| `memory.used.percent` | Gauge | Percentage of memory used. | +| `memory.used.bytes` | Gauge | Used memory size in bytes. | +| `io.read.bytes_per_second` | Gauge | Read throughput of the agent and descendant processes in bytes per second. | +| `io.write.bytes_per_second` | Gauge | Write throughput of the agent and descendant processes in bytes per second. | + +## Terraform component metrics + +The following metrics are emitted by the `terraform` component, which is +responsible for handling Terraform operations like plans and applies. All +metrics in this section are prefixed by `tfc-agent.core.terraform.`. + +| Metric name | Type | Description | +| ---------------------------------------------- | ----- | ----------------------------------------------------------------------------------- | +| `configure_terraform_cli.milliseconds` | Timer | Time spent configuring the Terraform CLI utility prior to execution. | +| `handle_signal.milliseconds` | Timer | Time spent handling a signal from HCP Terraform. | +| `execute.milliseconds` | Timer | Time spent handling a Terraform operation. | +| `output_stream.upload_chunk.bytes` | Gauge | Size of a chunk of Terraform output uploaded. | +| `output_stream.upload_chunk.milliseconds` | Timer | Time spent uploading a single chunk of Terraform output. | +| `output_stream.upload_full.bytes` | Gauge | Size of a full Terraform log uploaded. | +| `output_stream.upload_full.milliseconds` | Timer | Time spent uploading the full Terraform log. | +| `output_stream.close.milliseconds` | Timer | Time spent finalizing a Terraform output stream. | +| `override_sensitive_variables.milliseconds` | Timer | Time spent generating a configuration file to override variable sensitivity. | +| `override_sensitive_variables.count` | Gauge | Number of variables in a run of which HCP Terraform modified the sensitivty flag. | +| `persist_filesystem.milliseconds` | Timer | Time spent packing and uploading a filesystem image. | +| `persist_filesystem.pack.bytes` | Gauge | Size of a packed up filesystem image. | +| `persist_filesystem.pack.milliseconds` | Timer | Time spent packing the contents of a filesystem. | +| `persist_filesystem.upload.milliseconds` | Timer | Time spent uploading a packed up filesystem image. | +| `plan_json.generate.bytes` | Gauge | Size of a generated JSON-formatted plan. | +| `plan_json.generate.milliseconds` | Timer | Time spent generating a JSON plan. | +| `plan_json.upload.milliseconds` | Timer | Time spent uploading a JSON plan. | +| `provider_schemas_json.generate.bytes` | Gauge | Size of a generated JSON-formatted provider schemas file. | +| `provider_schemas_json.generate.milliseconds` | Timer | Time spent generating the provider schemas document. | +| `provider_schemas_json.upload.milliseconds` | Timer | Time spent uploading a provider schemas document. | +| `restore_filesystem.milliseconds` | Timer | Time spent downloading and unpacking a filesystem image. | +| `restore_filesystem.download.bytes` | Gauge | Size of a downloaded filesystem image. | +| `restore_filesystem.download.milliseconds` | Timer | Time spent downloading a filesystem image. | +| `restore_filesystem.unpack.milliseconds` | Timer | Time spent unpacking the contents of a filesystem image. | +| `run_meta.additions` | Gauge | Number of resources added or proposed to be added in a Terraform operation. | +| `run_meta.changes` | Gauge | Number of resources changed or proposed to change in a Terraform operation. | +| `run_meta.destructions` | Gauge | Number of resources destroyed or proposed to be destroyed in a Terraform operation. | +| `setup_backend.milliseconds` | Timer | Time spent configuring Terraform CLI for HCP Terraform. | +| `setup_ssh_key.milliseconds` | Timer | Time spent configuring an SSH key for Terraform to use while downloading modules. | +| `setup_ssh_key.check_git_version.milliseconds` | Timer | Time spent ensuring the local version of "git" is adequate for leveraging SSH auth. | +| `setup_terraform_binary.milliseconds` | Timer | Time spent downloading and unpacking a Terraform Community release. | +| `setup_terraform_binary.download.bytes` | Gauge | Size of a downloaded Terraform Community version. | +| `setup_terraform_binary.download.milliseconds` | Timer | Time spent downloading a Terraform Community release. | +| `setup_terraform_binary.unpack.bytes` | Gauge | Size of an unpacked Terraform Community release. | +| `setup_terraform_binary.unpack.milliseconds` | Timer | Time spent unpacking a Terraform Community release. | +| `setup_terraform_config.milliseconds` | Timer | Time spent downloading and unpacking a Terraform configuration. | +| `setup_terraform_config.download.bytes` | Gauge | Size of a downloaded Terraform configuration. | +| `setup_terraform_config.download.milliseconds` | Timer | Time spent downloading a Terraform configuration. | +| `setup_terraform_config.unpack.milliseconds` | Timer | Time spent unpacking a downloaded Terraform configuration. | +| `setup_terraform_config.verify.milliseconds` | Timer | Time spent verifying a Terraform configuration. | +| `setup_terraform_variables.milliseconds` | Timer | Time spent configuring Terraform variables provided by TFC. | +| `setup_terraform_variables.write_file.bytes` | Gauge | Size of a tfvars file, generated by TFC-provided input variables. | +| `terraform_init.milliseconds` | Timer | Time spent running `terraform init`. | +| `terraform_apply.milliseconds` | Timer | Time spent running `terraform apply`. | +| `terraform_plan.milliseconds` | Timer | Time spent running `terraform plan`. | +| `terraform_version.milliseconds` | Timer | Time spent running `terraform version`. | + +## Policy component metrics + +@include 'policy.mdx' + +The following metrics are emitted by the `policy` component, which is +responsible for handling OPA policy enforcement operations. All metrics in this +section are prefixed by `tfc-agent.core.policy.`. + +| Metric name | Type | Description | +| ---------------------------------------------- | ----- | -------------------------------------------------------- | +| `execute.milliseconds` | Timer | Time spent handling a policy operation. | +| `policy_set.download.bytes` | Gauge | Size of a downloaded policy set. | +| `policy_set.download.milliseconds` | Timer | Time spent downloading a policy set. | +| `policy_set.unpack.milliseconds` | Timer | Time spent unpacking a policy set. | +| `generate_opa_input_file.milliseconds` | Timer | Time spent generating the OPA input file. | +| `parse_opa_config.milliseconds` | Timer | Time spent parsing the OPA configuration. | +| `plan_json_download.milliseconds` | Timer | Time spent downloading the Terraform JSON plan document. | +| `plan_json_download.bytes` | Gauge | Size of a downloaded Terraform JSON plan document. | +| `run_opa_eval.milliseconds` | Timer | Time spent evaluating OPA policies. | +| `setup_policies.milliseconds` | Timer | Time spent setting up individually managed policies. | +| `setup_policy_engines.milliseconds` | Timer | Time spent setting up policy runtimes. | +| `setup_subjects.milliseconds` | Timer | Time spent setting up subjects for policy enforcement. | +| `write_sentinel_config.milliseconds` | Timer | Time spent generating the Sentinel config file. | +| `run_sentinel_apply.milliseconds` | Timer | Time spent evaluating Sentinel policies. | diff --git a/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/request-forwarding.mdx b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/request-forwarding.mdx new file mode 100644 index 000000000..ce09936df --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/request-forwarding.mdx @@ -0,0 +1,137 @@ +--- +page_title: HCP Terraform agent request forwarding +description: >- + Learn how request forwarding enables accessing private network resources. +--- + +# Request forwarding + +@include 'request-forwarding-tier.mdx' + +You can configure HCP Terraform Agents to handle HTTP and HTTPS +request forwarding on behalf of HCP Terraform. This enables HCP Terraform to access +services in private networks without requiring direct inbound network access. + +Only specific features and use cases use agent request forwarding to +fulfill requests. + +## Request Forwarding Architecture + +Request forwarding is an additional function that you can enable on a per-agent +basis. Agents are deployed into private networks where they have direct access +to the target private services, such as private version control systems or other APIs. +Agents register with HCP Terraform via outbound-only connections. HCP Terraform +holds these connections open and uses them to transmit requests and responses +between the target API and HCP Terraform. + +![Request forwarding architecture diagram](/img/request-forwarding-arch-dark.png) + +## Forwarded Request Routing + +Request forwarding requires the use of [agent pools](/terraform/cloud-docs/agents/agent-pools). +Each agent pool may have multiple agents registered with request forwarding enabled. The agent pool is +then selected by the user in HCP Terraform as the target for various features +which require access to private network resources. This creates the mapping from +HCP Terraform resources (such as VCS connections) to a pool of agents capable +of accessing the target API. + +## Agent Configuration + +To enable request forwarding, start the agent with the `-request-forwarding` +flag, or set the environment variable `TFC_AGENT_REQUEST_FORWARDING=true`. When +the agent starts, you will see the following log messages: + +``` +[INFO] core: Broker connection is enabled +[INFO] grpc_connector: Connecting to broker: host=agents.terraform.io:7146 +[INFO] grpc_connector: agent grpc server serving... +[INFO] grpc_connector: Keep alive is enabled: host=agents.terraform.io:7146 +[DEBUG] rpc_server: Handling broker authorization challenge +[DEBUG] rpc_server: status-event: successful connection +``` + +These log messages indicate that the agent has successfully connected to HCP Terraform +and is ready to start forwarding requests. + +### Optionally accept ingress jobs to access a private VCS + +If you want to use a private VCS provider, you must configure your HCP Terraform agent to support private VCS by allowing access to those private repositories. To learn more, refer to [Connect to Private VCS Providers](/terraform/cloud-docs/vcs/private#configure-the-agent-pool-and-agent). + +## Requirements and Limitations + +Agent version 1.21.1+ is required to use request forwarding. + +We recommend that you allocate at least 250MB of additional system memory specifically +for request forwarding. This is in addition to the minimum +[system requirements](/terraform/cloud-docs/agents/requirements). + +Forwarded requests are limited to a 10MB response body. This limit comfortably +supports all HCP Terraform operations while providing protection against +unbounded responses. + +All forwarded requests are subject to a request timeout. The default timeout is +60 seconds, but this value is tuned for specific features and use cases and may +be set slightly higher or lower depending on the type of request being made. + +Agents must be able to connect to HCP Terraform outbound over the internet, as +well as to private infrastructure targets for request forwarding via HTTP and HTTPS. + +## Performance and Scaling + +Each agent may handle multiple requests simultaneously. In many cases, a single +agent may provide sufficient throughput to handle all forwarded requests. It is +recommended that 2 or more agents with request forwarding enabled are deployed +for each pool which will leverage request forwarding features. Running multiple +request forwarding agents provides better fault tolerance and distribution of +requests. + +We recommend that you monitor the memory and CPU utilization on your agents with +request forwarding enabled to determine if you need to deploy additional agents. Refer to +[runtime metrics](/terraform/cloud-docs/agents/metrics#runtime-metrics) for more details. + +Since an agent may handle more than one forwarded request simultaneously, both horizontal +(number of agents) and vertical (system resources per agent host) scaling vectors are important. + +## Egress Proxy Support + +If your agents require an egress proxy to reach HCP Terraform over the internet, you can set the +`HTTPS_PROXY` environment variable with your proxy's address when starting the agent. Your +proxy software must support the [HTTP CONNECT](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/CONNECT) protocol, +which the agent will use to establish a secure tunnel through the proxy to HCP Terraform. + +## Security considerations + +The agent application secures forwarded requests by ensuring that requests may +only be forwarded through the agent which originate from HCP Terraform. The agent +guarantees this by requiring an authenticated session to be established prior to forwarding any requests. + +Because forwarded requests and responses may contain sensitive information, +such as API tokens to 3rd party vendors and PII, we recommend +that production use cases use dedicated agents to handle request +forwarding functionality. This ensures that no other processes executing user +code will be running within the same process space and avoids certain +attack vectors. + +To dedicate an agent to request forwarding only, set the [accepted +workload types](/terraform/cloud-docs/agents/agents#accept) to `none`. This +disables all workloads except for request forwarding from being executed. + +## Hold your own key + + + +HCP Terraform agent versions 1.23 or later support the hold your own key feature. To use the latest features, [upgrade your agents to the latest version](/terraform/cloud-docs/agents/changelog). + + + +[Hold your own key (HYOK)](/terraform/cloud-docs/hold-your-own-key) is an HCP Terraform feature that lets you provide and control an encryption key to secure sensitive artifacts produced by Terraform and stored within HCP Terraform. + +HYOK uses the HCP Terraform agent request forwarding interface to generate data keys that HCP Terraform uses to encrypt data. The agent encrypts these data keys using your key management system (KMS). + +HCP Terraform uses the request forwarding interface to: + +- Check your KMS for new key versions. +- Re-encrypt data keys when someone revokes a key configuration. +- Temporarily decrypt data keys when a user requests a decrypted download of a file. + +All HCP Terraform agents that have enabled request forwarding support HYOK. To explicitly enable request forwarding, start the agent with the `-hyok` flag, or set the environment variable `TFC_AGENT_HYOK=true`. We recommend using a dedicated agent pool for HYOK, using the `-hyok` flag or `TFC_AGENT_HYOK` environment variable to explicitly enable the feature on your agents. diff --git a/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/requirements.mdx b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/requirements.mdx new file mode 100644 index 000000000..5c4e143f5 --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/requirements.mdx @@ -0,0 +1,83 @@ +--- +page_title: HCP Terraform agent requirements +description: >- + Use HCP Terraform agents to manage infrastructure in private networks. Learn about supported operating systems and hardware and networking requirements. +--- + +# Agent Requirements + +Ensure your system meets the following requirements before installing and configuring HCP Terraform Agents. Refer to [HCP Terraform Agents on Terraform Enterprise](/terraform/enterprise/admin/agents-on-tfe) for additional Terraform Enterprise requirements. + +## Environment + +You can deploy agents to x86_64 and ARM64 Linux. You can also run the agent in Docker using our official [HCP Terraform Agent Docker container](https://hub.docker.com/r/hashicorp/tfc-agent). + +All agents in an agent pool should have the same operating system. If the agents use different resources, run performance can vary significantly between each agent in the pool. + +The architecture of the agent pool is determined by the first agent that connects to HCP Terraform. For example, when the first agent to register to an empty pool is an ARM64 agent, subsequent agents that register must be ARM64 agents. Attempting to register an ARM64 agent to an existing x86-only agent pool results in an error. + +Refer to [Change the agent pool architecture](/terraform/cloud-docs/agents/agent-pools#change-the-agent-pool-architecture) for instructions on how to switch between architectures. + +## Terraform versions + +You can use the agent with the following versions of Terraform. + +- Terraform 0.12 and newer for agents on x86-64. +- Terraform 0.13.5 and newer for agents on ARM64. + +Workspaces configured to use Terraform versions older than 0.12 cannot select the agent-based execution mode. + + +## Hardware + +The host running the agent has varying resource requirements depending on the workspaces and Stacks the agent serves, and the agent's configuration. A host can be a dedicated or shared cloud instance, virtual machine, bare metal server, or a container. You should monitor and adjust memory, CPU, and disk space based on each workspace and Stack's usage and performance. + +All agents in an agent pool should have the same hardware resources available. If the agents use different resources, run performance can vary significantly between each agent in the pool. + +Use the following specifications as a reference: + +- At least 4GB of free disk space + - Each run requires the agent to temporarily store local copies of the tarred repository, extracted repository, state file, any providers or modules, and the Terraform binary itself. + - When using agents for private VCS operations, we recommend that the agent has storage capacity equal to at least twice the maximum expected repository size. +- At least 2GB of system memory + - This provides the agent with enough memory to complete run operations, such as `terraform plan`, `git clone`, and `sentinel apply`. This also supports operations such as uploading and downloading artifacts, constructing temporary execution environments, and parsing configurations. + - If you enable request forwarding, we recommend that you add at least 250MB of additional memory. The agent may hold multiple forwarded requests and responses in memory until they are successfully executed and relayed to HCP Terraform. + +## Software + +Agents may depend on third-party tooling for certain features and functionality. +The tfc-agent itself does not have any direct dependency on any of the following +tools, though most common uses of Terraform will require them. The agent makes +the assumption that the following utilities are pre-installed, and their +respective CLI commands available on the `$PATH` of the user running tfc-agent. + +* `git` - The Git CLI. May be used by the Terraform CLI when downloading modules + from remote Git servers. Git version 2.3 or greater is required. +* `ssh` - The SSH CLI. Used by `git` when the remote source uses the SSH + protocol. + +In addition to the above tools, it is often useful to install the following +optional software to support a broad range of uses. These tools may be used by +Terraform's `local-exec` provisioners, an `external` data source, or a tfc-agent +[hook script](/terraform/cloud-docs/agents/hooks). + +* `curl` - Simple command-line HTTP client. +* `wget` - Simple command-line HTTP client. +* `jq` - JSON data inspection utility. +* `unzip` - Unarchiver for zip archives. +* `tar` - Unarchiver for tar archives. +* `gzip` - Decompression utility for gzipped archives. + +## Networking + +In order for an agent to function properly, it must be able to make outbound TCP connections to the HCP Terraform application APIs. These requests may require perimeter networking as well as container host networking changes, depending on your environment. Refer to the [HCP Terraform IP Ranges documentation](/terraform/cloud-docs/architectural-details/ip-ranges) for more details on the IP ranges. + +Additionally, the agent must also be able to communicate with any services required by the Terraform code it is executing. This includes the Terraform releases distribution service, [releases.hashicorp.com](https://releases.hashicorp.com), as well as any provider APIs. The following services run on these IP ranges: + +| Hostname | Port/Protocol | Directionality | Purpose | +| ---------------------- | -------------- | -------------- | ----------------------------------------------------------------------------------------------------------------------------------- | +| app.terraform.io | tcp/443, HTTPS | Outbound | Polling for new workloads, providing status updates, and downloading private modules from HCP Terraform's Private Module Registry | +| registry.terraform.io | tcp/443, HTTPS | Outbound | Downloading public modules from the Terraform Registry | +| releases.hashicorp.com | tcp/443, HTTPS | Outbound | Updating agent components and downloading Terraform binaries | +| archivist.terraform.io | tcp/443, HTTPS | Outbound | Blob Storage | +| agents.terraform.io | tcp/7146, TCP | Outbound | Agent RPC interface (currently used for request forwarding and hold your own key features) | diff --git a/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/telemetry.mdx b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/telemetry.mdx new file mode 100644 index 000000000..8bd7e073c --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/telemetry.mdx @@ -0,0 +1,153 @@ +--- +page_title: HCP Terraform agent telemetry +description: >- + Use telemetry data to analyze the HCP Terraform agent performance. Learn about telemetry architecture and how to run and configure telemetry for your agents. +--- + +# Telemetry + +HCP Terraform Agents may be configured to emit helpful telemetry data, +including both trace spans and metrics. + +## Telemetry architecture + +HCP Terraform Agents emit telemetry data using the +[OpenTelemetry](https://opentelemetry.io/) protocol. The agent is a simple +producer of telemetry data, and relies on an OpenTelemetry Collector to perform +aggregation, post-processing, and exporting of telemetry data to upstream +technology and/or vendors. OpenTelemetry is an extensible telemetry protocol and +open source platform, which enables the HCP Terraform Agent to remain +vendor-agnostic while producing high-value telemetry data for a wide array +of platforms. + +![telemetry architecture diagram](/img/telemetry-arch-dark.png) + +## Agent Configuration + +To configure your agent to emit telemetry data, you must include the +`-otlp-address` flag or `TFC_AGENT_OTLP_ADDRESS` environment variable. This +should be set to the host:port address of an [OpenTelemetry +collector](https://opentelemetry.io/docs/concepts/data-collection/). This +address should be a GRPC server running an OLTP collector. + +Optionally, you can pass the `-otlp-cert-file` or `TFC_AGENT_OTLP_CERT_FILE`. +The agent will use a certificate at the path supplied to encrypt the client +connection to the OpenTelemetry collector. When omitted, client connections are +not secured. + +## OpenTelemetry Collector + +The OpenTelemetry Collector has a pluggable architecture. This opens up the +ecosystem and makes it possible to leverage a wide array of telemetry platforms +and technologies. The OpenTelemetry project distributes the collector in two +flavors: `core` and `contrib`. For most uses, the `contrib` distribution will +be most useful, as it includes a wide array of integrations for specific +telemetry platforms and technologies which are not available in the `core` +distribution. The `contrib` distribution is available as a pre-packaged +Docker container labeled +[otel/opentelemetry-collector-contrib](https://hub.docker.com/r/otel/opentelemetry-collector-contrib). + +## Compatibility + +Each released version of the HCP Terraform Agent ships with a specific version +of the OpenTelemetry client libraries built in. As these libraries and +implementations change, it is possible that certain versions of the agent will +become incompatible with newer versions of the OpenTelemetry collector. To +track version compatibility, the table below will be updated whenever these +version constraints become known. + +| HCP Terraform Agent version | Compatible OpenTelemetry Collector version | +| ----------------------------- | ------------------------------------------ | +| >= 0.1.12, <= 1.7.0 | <= 0.42.0 | +| >= 1.7.1 | Tested up to 0.73.0 | + +### Running the collector + +By default, the `contrib` distribution accepts telemetry from a wide variety of +sources, and dumps information about the metrics and traces collected to stdout. +To start the collector with default settings, run the following command: + +``` +docker run -p 127.0.0.1:4317:4317/tcp otel/opentelemetry-collector-contrib:0.42.0 +``` + +This will start an OpenTelemetry collector, and expose the gRPC interface (which +the HCP Terraform Agent can talk to) on port 4317 of the local machine. + +### Configuring the collector + +The OpenTelemetry collector takes configuration in the form of a YAML file. Refer to the [default YAML configuration file](https://github.com/open-telemetry/opentelemetry-collector-releases/blob/main/distributions/otelcol-contrib/config.yaml) as a starting point for writing your own configuration. + +To tweak the configuration, save your custom YAML configuration to a file on +disk called `collector.yaml`, and run the collector container with the +following command: + +``` +docker run \ + --mount type=bind,source=${PWD}/collector.yml,target=/etc/otelcol-contrib/config.yaml \ + -p 127.0.0.1:4317:4317/tcp \ + otel/opentelemetry-collector-contrib:0.42.0 +``` + +The collector should start with your modified configuration. + +## DataDog Agent + +The HCP Terraform Agent may target a DataDog agent directly instead of an +OpenTelemetry collector. To configure the DataDog agent to accept OTLP +connections, refer to the [DataDog OpenTelemetry +documentation](https://docs.datadoghq.com/opentelemetry/otlp_ingest_in_the_agent). +Note that the tfc-agent talks to a gRPC OTLP receiver only. Be sure to +configure the DataDog agent to accept a gRPC OTLP connection. Once the +DataDog agent is listening for gRPC connections, [configure the tfc-agent] using +the address of the DataDog agent's gRPC listener in place of the OpenTelemetry +collector address. + +## Tracing + +The agent emits tracing spans which are useful in understanding and debugging +various operations performed by the HCP Terraform Agent. + +See the [Tracing](/terraform/cloud-docs/agents/tracing) documentation for details. + +## Metrics + +HCP Terraform Agents emit granular metrics which are useful in understanding +the behavior and performance of various operations in a high-level, aggregated +view. + +See the [Metrics](/terraform/cloud-docs/agents/metrics) documentation for details. + +## Categories + +Telemetry data can be broken down into three categories, global, Terraform, and policy. + +### Global +Once an Agent has registered, global fields are present on telemetry. + +| Telemetry Key | Description | Example Value | +| ------------------------ | --------------------------------------- | ------------------ | +| `agent_id` | Unique identifier for an agent. | "agent-xxx" | +| `agent_name` | Name of an agent. | "agent1" | +| `agent_version` | Semantic version of agent. | "1.7.1" | +| `agent_pool_id` | Unique identifier for an agent pool. | "apool-xxx" | + +### Terraform +Terraform fields are present on telemetry once an Agent begins handling a Terraform run. + +| Telemetry Key | Description | Example Value | +| ------------------------ | ---------------------------------------- | ----------------- | +| `organization_name` | Name of an organization. | "organization1" | +| `run_id` | Unique identifier for a Terraform run. | "run-xxx" | +| `run_operation` | Terraform operation. | "apply" | +| `workspace_name` | Name of a workspace. | "workspace1" | + +### Policy + +@include 'policy.mdx' + +Policy fields are present on telemetry once an Agent begins handling policy evaluation. + +| Telemetry Key | Description | Example Value | +| ------------------------ | ----------------------------------------- | ---------------- | +| `policy_evaluation_id` | Unique identifier for a policy evaluation.| "poleval-xxx" | diff --git a/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/tracing.mdx b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/tracing.mdx new file mode 100644 index 000000000..42116d2c5 --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/docs/cloud-docs/agents/tracing.mdx @@ -0,0 +1,28 @@ +--- +page_title: HCP Terraform agents tracing +description: >- + Use tracing spans to analyze and debug HCP Terraform agent operations. Learn about supported tools and rules for tracing spans. +--- + +# Tracing + +The agent emits tracing spans that can be consumed by various distributed +tracing tools. Information about supported tools can be found on the +[OpenTelemetry Registry](https://opentelemetry.io/registry/). A span describes +a single, concise unit of work performed by the agent, such as writing a file +or downloading an artifact. + +## Span names + +Each span has a unique name in plain English, explaining what it represents. +Due to this descriptive nature of spans, individual trace spans are not +documented on this page. + +## Span attributes + +Span attribute keys typically contain only letters, numbers, and underscores. +In some cases, span attributes may contain dots (`.`) to provide structure to a +set of related attributes. + +Span attributes in the `debug` namespace will have information relevant to the +current span's scope. diff --git a/content/terraform-docs-agents/v1.25.x/docs/partials/agents.mdx b/content/terraform-docs-agents/v1.25.x/docs/partials/agents.mdx new file mode 100644 index 000000000..659e70525 --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/docs/partials/agents.mdx @@ -0,0 +1 @@ +-> **Note:** Your HCP Terraform plan determines the number of agents you can use. Refer to [HCP Terraform pricing](https://www.hashicorp.com/products/terraform/pricing) for details. diff --git a/content/terraform-docs-agents/v1.25.x/docs/partials/beta.mdx b/content/terraform-docs-agents/v1.25.x/docs/partials/beta.mdx new file mode 100644 index 000000000..8767ca6f5 --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/docs/partials/beta.mdx @@ -0,0 +1,6 @@ + + + +This feature is currently in beta. Do not use beta functionality in production environments. + + \ No newline at end of file diff --git a/content/terraform-docs-agents/v1.25.x/docs/partials/policy.mdx b/content/terraform-docs-agents/v1.25.x/docs/partials/policy.mdx new file mode 100644 index 000000000..017c2d233 --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/docs/partials/policy.mdx @@ -0,0 +1 @@ +-> **Note:** Private policy evaluation is available in HCP Terraform **Premium** edition. Refer to [HCP Terraform pricing](https://www.hashicorp.com/products/terraform/pricing) for details. \ No newline at end of file diff --git a/content/terraform-docs-agents/v1.25.x/docs/partials/request-forwarding-tier.mdx b/content/terraform-docs-agents/v1.25.x/docs/partials/request-forwarding-tier.mdx new file mode 100644 index 000000000..100b1fd27 --- /dev/null +++ b/content/terraform-docs-agents/v1.25.x/docs/partials/request-forwarding-tier.mdx @@ -0,0 +1,5 @@ + + +Request forwarding is available on the HCP Terraform **Premium** edition. Refer to [HCP Terraform pricing](https://www.hashicorp.com/products/terraform/pricing) for details. + + diff --git a/content/terraform-docs-agents/v1.25.x/img/request-forwarding-arch-dark.png b/content/terraform-docs-agents/v1.25.x/img/request-forwarding-arch-dark.png new file mode 100644 index 0000000000000000000000000000000000000000..3f2f1aa7019517ffef6e2f4028d00aae64d36517 GIT binary patch literal 8880 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 literal 0 HcmV?d00001 diff --git a/content/terraform-docs-agents/v1.25.x/img/request-forwarding-arch-light.png b/content/terraform-docs-agents/v1.25.x/img/request-forwarding-arch-light.png new file mode 100644 index 0000000000000000000000000000000000000000..0750eb11e7f4265a486aa80f3456a34850eddae8 GIT binary patch literal 8333 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 literal 0 HcmV?d00001 diff --git a/content/terraform-docs-agents/v1.25.x/img/telemetry-arch-dark.png b/content/terraform-docs-agents/v1.25.x/img/telemetry-arch-dark.png new file mode 100644 index 0000000000000000000000000000000000000000..d95afa38d472b1e8684d71749db37be71b85be16 GIT binary patch literal 16604 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 literal 0 HcmV?d00001 diff --git a/content/terraform-docs-agents/v1.25.x/img/telemetry-arch-light.png b/content/terraform-docs-agents/v1.25.x/img/telemetry-arch-light.png new file mode 100644 index 0000000000000000000000000000000000000000..f0c27d2f3646f9ec54bcfc632f65c0f677ce2fba GIT binary patch literal 15135 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 z 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 ~tXUK9I!reGIRPXd5z&bTrC!u6 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 )Sameb&y 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 Dstc^n literal 0 HcmV?d00001