Skip to main content
skill CX Codex

volcengine-iac — Claude Code skill for Volcengine Terraform

The volcengine-iac Claude Code skill builds Terraform configuration for Volcengine infrastructure. It activates when Terraform is chosen or a Terraform state already exists.

MIT 111 installs ★ 37 updated 2026-11-16

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add volcengine/volcengine-agent-toolkit --skill volcengine-iac -a claude-code
Open on GitHub

What volcengine-iac does

The skill prepares Terraform files for Volcengine resources and runs the init, validate, and plan steps. It is triggered by an explicit IaC choice, an existing Terraform state, or a request to inspect plans, changes, or drift. New configurations start from verified volcenginecc examples; reusable modules still use the older volcengine/volcengine provider.

Working files go into .volcengine/terraform/ by default. The gen_tfvars.py script creates terraform.tfvars; configuration comes from examples or assembled modules. A plan summary must be shown and explicitly approved before apply. Requirements include terraform >= 1.5, jq, git, python3, VOLCENGINE_ACCESS_KEY, VOLCENGINE_SECRET_KEY, and VOLCENGINE_REGION. ve login can replace AccessKey/SecretKey authentication, and VOLCENGINE_SESSION_TOKEN supports temporary credentials.

Application packaging and runtime rollout remain with volcengine-deploy, not this skill. It does not take over CLI deployments or temporary demos. When invoked by volcengine-deploy, it writes results to .volcengine/iac-outputs.json.

What it helps with

  • create Terraform files for Volcengine resources
  • generate terraform.tfvars from deployment choices
  • inspect an infrastructure plan before applying it
  • check a Terraform setup for drift

Example prompts for the agent

  • Set up Terraform for the Volcengine resources in this project.
  • Use the existing Terraform state and prepare a change plan for VKE and the database.
  • Build a Volcengine IaC configuration and show the terraform plan summary before applying it.

How to install volcengine-iac

1Skills CLI (Vercel)

npx skills add volcengine/volcengine-agent-toolkit --skill volcengine-iac -a claude-code

2Manually: put the files in place

~/.claude/skills/volcengine-iac/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/volcengine-iac/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about volcengine-iac

How do I install volcengine-iac in Claude Code?

Run npx skills add volcengine/volcengine-agent-toolkit --skill volcengine-iac -a claude-code. The skill file is installed at ~/.claude/skills/volcengine-iac/SKILL.md.

What does volcengine-iac do?

It prepares Terraform configuration for Volcengine infrastructure and checks the proposed plan. Applying that plan requires explicit user approval.

What does volcengine-iac need to run?

It requires terraform >= 1.5, jq, git, python3, VOLCENGINE_ACCESS_KEY, VOLCENGINE_SECRET_KEY, and VOLCENGINE_REGION. Use ve login instead of AccessKey/SecretKey authentication if needed.

Source text

SKILL.md · MIT
---
name: volcengine-iac
description: >-
  Use Terraform/IaC for Volcengine resources only when the user explicitly chooses
  Terraform/IaC, already has a Terraform workflow/state, or confirms they need
  plan/diff/drift/destroy safety for VKE, managed databases/cache/storage, load balancers,
  domains/certificates, logging/monitoring, or team-managed infrastructure.
license: MIT
metadata:
  openclaw:
    envVars:
      - name: VOLCENGINE_ACCESS_KEY
        required: false
        description: AccessKey for AK/SK auth path (alternative to `ve login`)
      - name: VOLCENGINE_SECRET_KEY
        required: false
        description: SecretKey for AK/SK auth path
      - name: VOLCENGINE_SESSION_TOKEN
        required: false
        description: Optional STS session token for temporary credentials
      - name: VOLCENGINE_REGION
        required: false
        description: Default region; falls back to cn-beijing if unset
---

# Volcengine IaC Skill

Generate, plan, and apply Volcengine infrastructure with Terraform when the user chooses IaC. `volcengine-deploy` still owns application packaging, runtime rollout, health checks, and CLI resource-ledger deployment.

When writing new examples, prefer the Cloud Control provider `volcengine/volcenginecc`. Start from verified examples under `assets/examples/`, then read the matching `references/volcenginecc-*.md` note for validation results and pitfalls. Blocked resources are tracked in [`references/volcenginecc-blocked.md`](./references/volcenginecc-blocked.md). Existing reusable modules under `assets/modules/` still use the legacy `volcengine/volcengine` provider until each component is re-verified with `volcenginecc`.

Use this skill when one of these is true:

- the user asks for Terraform or IaC,
- the user already has Terraform state/workspace,
- plan/diff/drift detection matters,
- the infrastructure is intended for long-term team-managed operation and the user chooses IaC,
- the deployment needs VKE, managed databases/cache/storage, load balancers, domains/certificates, IAM/KMS, logging, monitoring, or Serverless triggers and the user chooses IaC.

Do not use this skill just because a deployment is long-lived, VKE-based, or has managed dependencies. Recommend IaC where appropriate, but let the user choose. Do not use this skill when the user asks for CLI, a temporary demo/quick validation, a pure ECS single-VM service with no plan/diff/destroy requirement, or when Terraform/provider installation is blocked and the target can safely use the CLI fallback.

The skill ships verified `volcenginecc` examples under `assets/examples/`, legacy reusable modules under `assets/modules/`, and wrapper scripts for tfvars generation, plan summaries, output export, and drift checks. Select files only after the target shape is known; do not load broad catalogs into context for small Terraform edits.

Resources outside the six legacy modules (CLB/ALB, VKE, CR, databases, caches, object storage) should be added as verified `volcenginecc` examples first, then wrapped only after repeated use proves the interface is stable.

---

## 0. Prerequisites

Required env vars: `VOLCENGINE_ACCESS_KEY`, `VOLCENGINE_SECRET_KEY`, `VOLCENGINE_REGION`. Do not print them or dump the environment (`env`, `printenv`, `echo $VOLCENGINE_*`, with or without a `sed`/`grep` filter) to check that they are set; a missing or rejected credential shows up as an error from `terraform plan`.

Required tools: `terraform >= 1.5`, `jq`, `git`, `python3` (for `gen_tfvars.py`).

Optional: `.volcengine/deploy-choice.json` from `volcengine-prepare`/`volcengine-deploy`. If absent, ask a short batch of Terraform-specific questions.

The skill writes Terraform working files into `.volcengine/terraform/` by default. State can use a TOS S3-compatible backend when the user wants remote state; see [`references/backend-tos.md`](./references/backend-tos.md). Local state is acceptable for small one-off experiments when the user accepts the tradeoff.

If invoked by `volcengine-deploy`, return outputs in `.volcengine/iac-outputs.json` and let deploy continue with image build/push, Cloud Assistant commands, Kubernetes manifests, veFaaS release, migrations, and health checks.

---

## 1. Generation Flow

### Path A — driven by `.volcengine/deploy-choice.json`

```bash
work_dir="${work_dir:-.volcengine/terraform}"
workload="${workload:-standard}"
mkdir -p "$work_dir"

python3 scripts/gen_tfvars.py \
  --input ".volcengine/deploy-choice.json" \
  --output "$work_dir/terraform.tfvars" \
  --workload "$workload"
```

`gen_tfvars.py` derives:
- `project`, `region`, AZ pair from the choice file and environment
- `enable_vke / enable_cr / enable_rds / enable_redis / enable_tos` flags from the chosen mode and known dependencies
- Sizing (instance type, node count, RDS spec, Redis capacity) from a coarse `--workload` tier

The user can override any value before applying.

### Path B — natural language input

When no prepare report exists, ask the user **one batch of questions**, then create a Terraform working directory from verified examples or legacy modules and generate matching variable values. Required answers:

1. Project name (resource prefix)
2. Region (e.g. `cn-beijing`)
3. Need VKE? (yes/no)
4. Stateful deps needed: MySQL? PostgreSQL? Redis? TOS bucket?
5. Workload tier: light / standard / heavy

### Files written

`gen_tfvars.py` writes only `terraform.tfvars`. The Terraform configuration files come from copied verified examples under `assets/examples/` or from a small root module assembled from `assets/modules/`; edit those files to match the selected stack instead of expecting the script to generate them.

| File | Purpose |
|---|---|
| `main.tf` / `variables.tf` | Copied or assembled Terraform configuration |
| `terraform.tfvars` | Concrete values generated by `gen_tfvars.py` or edited by hand |
| `backend.tf` | Generated only when TOS remote state is selected; otherwise omit it |

The full per-module variable schema lives in [`references/modules.md`](./references/modules.md). For new `volcenginecc` work, start from a verified example under `assets/examples/` instead of these legacy modules unless the user explicitly needs the old provider.

### Path C — `volcenginecc` verified examples

Copy the relevant verified example, then run the same init/validate/plan sequence:

```bash
cp -R "assets/examples/<example-name>" "$work_dir/<component>"
cd "$work_dir/<component>"
terraform init -backend=false -input=false
terraform validate
terraform plan -out=tfplan.binary -input=false
```

Before apply, show the plan summary and require explicit user confirmation. Read the matching reference before changing inputs or destroying resources; the references contain field choices, validation notes, import IDs, and provider pitfalls.

---

## 2. Deployment stack mapping

Use the deployment shape to choose a small set of verified examples. Start with examples; wrap into reusable modules only after repeated use proves the interface stable. Typical stacks combine:

- ECS: `volcenginecc-network`, `volcenginecc-ecs`, optional TLS/CloudMonitor
- VKE: `volcenginecc-network`, `volcenginecc-vke`, `volcenginecc-cr`, CLB or ALB
- veFaaS: `volcenginecc-vefaas`, optional APIG/TLS
- Stateful web app: runtime stack plus RDS, Redis, and/or TOS examples
- Private service: runtime stack plus private NAT or network connectivity examples
- Domain entry: runtime stack plus DNS and load balancer certificate examples

This mapping is a guide, not a promise that a prebuilt module exists. Copy relevant examples into `.volcengine/terraform/<component>` and keep component boundaries clear so plan/destroy output remains readable.

For the end-to-end VKE private CR nginx path, use `assets/examples/volcengine-vke-cr-nginx/` and read `references/volcengine-vke-cr-nginx.md` first. That example exists for the CR credential addon, `core-dns`, CR token expiry, and image architecture pitfalls found in a real run.

---

## 3. Catalog

Use the filesystem as the catalog. After selecting a deployment shape, list only the relevant directories under `assets/examples/`, then read the matching `references/volcenginecc-*.md` file for validation notes, import IDs, and provider caveats. Do not load every example into context up front.

Common example families:

- `volcenginecc-network`, VPC extras, NAT, VPN, DirectConnect, CEN, TransitRouter, PrivateLink, DNS, PrivateZone
- `volcenginecc-ecs`, ECS extras, launch template versions, EBS snapshots, Auto Scaling
- `volcenginecc-vke`, `volcenginecc-cr`, CLB/ALB entry, APIG, veFaaS
- `volcenginecc-rdsmysql`, `volcenginecc-rdspostgresql`, `volcenginecc-rdsmssql`, Redis, Kafka allowlist
- `volcenginecc-tos`, TOS notification, TLS, CloudMonitor, IAM, FileNAS, EFS

Legacy `volcengine` modules are still available under `assets/modules/`; read [`references/modules.md`](./references/modules.md) before using them.

Legacy modules currently cover `network`, `vke`, `cr`, `rds-mysql`, `redis`, and `tos`. ECS and CLB/ALB stay as verified examples because their workload shapes vary too much for one stable module interface.

---

## 4. Init & Backend

```bash
cd "$work_dir"

# Map Volcengine creds to the Terraform s3 backend's required env variable names.
export AWS_ACCESS_KEY_ID="$VOLCENGINE_ACCESS_KEY"
export AWS_SECRET_ACCESS_KEY="$VOLCENGINE_SECRET_KEY"
export AWS_EC2_METADATA_DISABLED=true

terraform init -input=false
tf_workspace="${tf_workspace:-default}"
terraform workspace select "$tf_workspace" || \
  terraform workspace new "$tf_workspace"
```

When remote state is requested, generate `backend.tf` from `references/backend-tos.md`. The verified TOS backend shape requires `skip_requesting_account_id = true` and must not set `force_path_style` or `use_path_style`.

Provider download (~30–60 seconds first time) goes through `registry.terraform.io`. In China networks this may be blocked or slow. If public registry access fails and the user still wants IaC, configure Terraform `provider_installation` with a filesystem or internal mirror. Otherwise return to `volcengine-deploy` and ask whether to use the CLI resource-ledger path.

For the TOS bucket prerequisite (must exist before `init`), see [`references/backend-tos.md`](./references/backend-tos.md). Without a TOS bucket, omit `backend.tf` and Terraform falls back to local state.

---

## 5. Plan

```bash
terraform plan -out=tfplan.binary -input=false
terraform show -json tfplan.binary > tfplan.json
bash scripts/plan_summary.sh tfplan.json
```

`plan_summary.sh` groups changes by action (CREATE / UPDATE / DELETE / REPLACE) and prints a one-line summary at the end. Show this to the user before any apply.

Watch for:
- **DELETEs you didn't ask for** — usually a sign of drift or a mistakenly removed module call
- **REPLACEs on stateful resources** — RDS / Redis replace = data loss; abort and inspect the diff with `terraform show tfplan.binary`

---

## 6. Apply

**Always require explicit user confirmation.** Do not pass `-auto-approve`. The pattern:

```text
The plan above will create N resources, change M, destroy K. Approve apply? [yes/no]
```

After yes:

```bash
terraform apply tfplan.binary
```

VKE cluster creation takes ~10–15 minutes. RDS HA instances take ~20 minutes. Surface the long-running message to the user once at apply start so they don't think it hung.

After apply succeeds, run `export_outputs.sh` automatically:

```bash
bash scripts/export_outputs.sh
echo "Resources ready. .volcengine/iac-outputs.json now contains downstream consumption keys."
```

---

## 7. Outputs for Downstream

`export_outputs.sh` writes `terraform output -json` to `.volcengine/iac-outputs.json` with mode `0600`. Downstream skills commonly consume VPC/subnet/security group IDs, VKE kubeconfig, CR repository data, RDS/Redis endpoints or IDs, and TOS bucket names. Some keys are conditional on which examples/modules were enabled; consumers must use defensive `jq` defaults.

---

## 8. Destroy

```bash
# Show what will be destroyed first
terraform plan -destroy -out=destroy.binary
terraform show -json destroy.binary | bash scripts/plan_summary.sh
```

Then:

```text
This will permanently delete N resources including RDS / Redis / TOS bucket data. Confirm? [yes/no]
```

On yes:

```bash
terraform destroy
# Note: provider does not accept -auto-approve=false; we rely on the agent-level prompt above.
```

**Hard rule**: never destroy in `prod` workspace without a second confirmation. The agent should explicitly re-prompt:

```text
Workspace = prod. Re-confirm destroy by typing 'destroy prod':
```

---

## 9. Drift Detection

```bash
bash scripts/check_drift.sh
```

Returns:
- `0` and `{"drift": false, ...}` — no drift
- `2` and `{"drift": true, "changed_resources": N, ...}` — N resources changed outside Terraform
- `1` and `{"drift": "error", ...}` — refresh-only plan errored

Use this:
- After known manual interventions (someone resized a node pool via console)
- Periodically as a CI job (weekly)
- Before any non-trivial `apply` to confirm baseline matches state

---

## 10. Import Existing Resources

If the user wants to adopt resources created via `volcengine-cli` or console, use `terraform import`. Import IDs differ by resource; read the matching `references/volcenginecc-*.md` or [`references/modules.md`](./references/modules.md) before importing. After import, run `terraform plan` and reconcile by editing config, not state.

---

## 11. Safety Rules

- Never read `~/.volcengine/config.json`; it may contain plaintext AK/SK. Never print credential environment variables either.
- Never commit `terraform.tfstate*` or `.volcengine/iac-outputs.json`.
- Never pass `-auto-approve` to `terraform apply` or `terraform destroy`.
- Run `check_drift.sh` before every apply on shared environments.
- Set mode `0600` on files holding kubeconfig or secrets.
- Pin provider versions in every module/example.

The scripts enforce file permissions where possible. Apply and destroy gates are the agent's responsibility.

---

## 12. Troubleshooting

Look up by the exact error string; act on the mapped cause before suspecting unrelated layers.

| Symptom | Cause | Fix |
|---|---|---|
| `terraform init`: "Failed to query available provider packages" | outbound to `registry.terraform.io` blocked | Configure `provider_installation` with a filesystem/internal mirror and rerun `init`; otherwise return to `volcengine-deploy` and ask whether CLI resource-ledger provisioning is acceptable |
| `terraform init`: "InvalidAccessKeyId" against TOS backend | s3 backend env vars not exported | Export `AWS_ACCESS_KEY_ID="$VOLCENGINE_ACCESS_KEY"`, `AWS_SECRET_ACCESS_KEY="$VOLCENGINE_SECRET_KEY"`, `AWS_EC2_METADATA_DISABLED=true` |
| `terraform init`: TOS backend returns `InvalidPathAccess` | path-style access or unsupported workspace prefix | Use the verified template in [`references/backend-tos.md`](./references/backend-tos.md): keep `skip_requesting_account_id = true`, remove `force_path_style`/`use_path_style` |
| `apply` succeeds for VPC but subnet fails with `InvalidVpc.InvalidStatus` | VPC not yet `Available` (consistency window) | Add `depends_on = [volcengine_vpc.main]` (already wired in the network module) |
| VKE cluster stuck in `Creating` for >20 min | quota or AZ capacity | `ve vke ListClusters --body '{"Filter":{"Ids":["..."]}}' \| jq .Result.Items[0].Status` for the real reason |
| `redis` output missing endpoint | provider does not export it | Resolve via `ve redis DescribeDBInstanceDetail --InstanceId $(jq -r '.redis_instance_id.value' .volcengine/iac-outputs.json)` |
| `terraform plan` shows unexpected changes after no edits | drift, or provider patch bump silently changing a default | Run `check_drift.sh`, inspect `tfplan.json`, decide whether to accept or revert |
| Two engineers' `apply` collide | TOS backend has no DynamoDB-style locking | Coordinate manually; see [`references/backend-tos.md`](./references/backend-tos.md) |
| Resource-specific apply/import drift | provider caveat for that resource | Read the matching `references/volcenginecc-*.md` note before editing config |

© volcengine · MIT · volcengine/volcengine-agent-toolkit

Similar skills

All skills for DevOps and infrastructure →
iac-terraform-data-engineering reason-machines iac-terraform-data-engineering is a Claude Code skill for provisioning AWS infrastructure with Terraform. It activates for requests about data-platform resources, infrastructure state, or data-pipeline setup. CX Codex +1 1,800installs terraform-data-engineering-iac reason-machines terraform-data-engineering-iac — a skill for Claude Code, Codex, Cursor and other agents that covers Terraform fundamentals for data engineering: provisioning S3 buckets, EC2 instances and IAM policies on AWS. CX Codex +1 1,800installs iac-security-review OWASP iac-security-review reviews Terraform, Kubernetes, and CloudFormation for security misconfigurations. Use it before an infrastructure change is reviewed or deployed. CX Codex +1 196installs terraform-iac-expert curiositech terraform-iac-expert — a Claude Code skill for infrastructure as code: modules, state, multi-environment layouts, backends, secrets. Useful when a Terraform project outgrows a single main.tf. CX Codex +1 179installs azure-iac-generator official github azure-iac-generator generates Bicep, Terraform, ARM, and Pulumi infrastructure templates with format-specific validation. Verifies API schemas via MCP servers before outputting code. CX Codex +1 188installs azure-iac-exporter official github The azure-iac-exporter GitHub Copilot subagent turns live Azure resources into Infrastructure as Code templates. It captures cloud configuration for reproduction in Bicep, ARM, Terraform, or Pulumi. CX Codex +1 186installs

From the same set9

volcengine-cli volcengine-cli — a skill for Claude Code and Codex that automates Volcengine cloud resources via the ve command-line tool. It provisions ECS instances, handles VPC networks, and queries Ark models. CX Codex +1 1,300installs volcengine-find-skills The volcengine-find-skills Claude Code skill searches the Volcengine catalog and installs selected skills. It activates when a task needs a matching capability or the current Volcengine setup falls short. CX Codex +1 292installs volcengine-feedback The volcengine-feedback Claude Code skill drafts feedback about Volcengine cloud workflows and can submit it to GitHub with authorization. It can offer a feedback prompt after a CLI error or an unfinished task while the main work continues. CX Codex +1 216installs volcengine-api This Claude Code skill answers questions about Volcengine API specifications. It activates for requests about parameters, error codes, request methods, responses, or API differences. CX Codex +1 154installs volcengine-deploy The volcengine-deploy Claude Code skill deploys a local project or Git repository to Volcengine as a cloud service. It activates when asked to publish code, run an app in the cloud, or deploy to ECS, VKE, or veFaaS. CX Codex +1 122installs volcengine-prepare The volcengine-prepare Claude Code skill examines a project before deployment to Volcengine. It ranks viable options across ECS, VKE, and veFaaS. CX Codex +1 119installs volcengine-tls This Claude Code skill guides agents through Volcengine TLS tasks using volclog. It activates for log searches and analysis, plus work with log projects and topics. CX Codex +1 118installs volcengine-sdk-generator The volcengine-sdk-generator Claude Code skill finds Volcengine APIs and generates SDK call examples. It activates for code requests in Python, Go, Java, PHP, cURL, or Node.js, and for SDK configuration questions. CX Codex +1 112installs

Project sponsors

Companies that keep this analytics open