function-hcl

Best Practices

Mon, 01 Jan 0001 00:00:00 +0000

Always use fn-hcl-tools package

Run fn-hcl-tools package to produce your txtar script rather than hand-crafting it. This validates your HCL before it reaches the cluster, catching typos in variable names, bad block structure, and syntax errors at authoring time.

fn-hcl-tools package ./my-composition/

Use locals to name things

Pull commonly-used expressions into top-level locals. This makes the code easier to read and avoids long repeated expressions like req.composite.spec.parameters deep inside resource bodies.

DSL Specification

Mon, 01 Jan 0001 00:00:00 +0000

Source of truth

This page is derived from spec.md in the repository. If you find a discrepancy, the repository version is authoritative.

Input Format

The function accepts its HCL program in txtar format via the input field of the Composition pipeline step. All files are treated as one unit.

External Variables

Created automatically from the RunFunctionRequest. Accessed as req.<field>.

Variable	Type	Description
`req.composite`	object	Observed composite resource (XR)
`req.composite_connection`	map(string, bytes)	Observed connection details of the composite
`req.resource`	map(string, object)	Observed resource bodies, keyed by crossplane name
`req.connection`	map(string, map(string, bytes))	Observed connection details, keyed by resource name
`req.resources`	map(string, list(object))	Observed resource collections, keyed by base name
`req.connections`	map(string, list(map(string, bytes)))	Connection details of collections
`req.context`	map(string, any)	Pipeline context
`req.extra_resources`	map(string, list(object))	Extra resources from `requirement` blocks

Top-Level Blocks

`locals`

locals {
 <name> = <expression>
}

Accessed by name directly (no local. prefix).
Ordering does not matter; locals with incomplete values are evaluated lazily.
Circular references are an error.
Cannot shadow names from parent scopes.
Can be defined at: top level, resource, resources template, group, requirement, function.

`resource`

resource <crossplane-name> {
 condition = <bool> # optional
 locals { ... } # optional
 body = { <k8s-manifest> } # required
 composite status { body = { ... } } # optional, repeatable
 composite connection { body = { ... } } # optional, repeatable
 ready { value = <string> } # optional
}

Special variables: self.name, self.resource, self.connection

How It Works

Mon, 01 Jan 0001 00:00:00 +0000

The Crossplane Function Pipeline

Crossplane composition functions run as steps in a pipeline. Each step receives the current desired state, may modify it, and passes it on to the next step. function-hcl is one such step.

Crossplane
 |
 v
+---------------------+
| function-hcl | <-- reads req.composite, evaluates HCL, writes desired resources
+---------------------+
 |
 v
 (next function or final reconcile)

What function-hcl Does

When Crossplane calls function-hcl, it:

Unpacks the input – reads the HCL scripts from the Composition pipeline step’s input field.
Evaluates the HCL – runs the script with access to the current composite resource, observed resources, and context.
Builds desired resources – each resource block that evaluates successfully contributes a desired composed resource to the output. Each resources block produces additional resources in the desired state.
Defers incomplete blocks – resource blocks that contain incomplete values (e.g. a status field from a resource that hasn’t been created yet) are silently deferred rather than causing an error.
Writes back status / connection details / context – composite status, composite connection, and context blocks write values back to the composite resource or pipeline context.

The Reconcile Loop

Crossplane runs composition functions repeatedly as the state of the world changes. This is important for understanding function-hcl’s behavior:

Installation

Mon, 01 Jan 0001 00:00:00 +0000

Prerequisites

Before installing function-hcl you need:

A Kubernetes cluster with Crossplane v1.14 or later installed.
kubectl configured to point at your cluster.

Install via Crossplane Package

The recommended way to install function-hcl is as a Crossplane Function package:

apiVersion: pkg.crossplane.io/v1
kind: Function
metadata:
 name: function-hcl
spec:
 package: xpkg.upbound.io/crossplane-contrib/function-hcl:v0.2.0-rc9

Apply it to your cluster:

kubectl apply -f function.yaml

Verify the function is healthy:

kubectl get function function-hcl

You should see HEALTHY: True and INSTALLED: True in the output.

Source Format

Mon, 01 Jan 0001 00:00:00 +0000

HCL Syntax

function-hcl source code is written in HCL syntax. Code may be spread across multiple files – all files are treated as one unit. The only difference between having multiple files versus a single file is that line numbers will differ in error messages.

txtar Format

The function accepts its input as text in the input field of a Composition pipeline step. This must be in txtar format so that original file names are maintained and line numbers match the source code.

Built-in Functions

Mon, 01 Jan 0001 00:00:00 +0000

function-hcl supports most Terraform functions as of v1.5.7. Exceptions are noted at the end of the page.

Available Functions by Category

Numeric

Function	Description
`abs(n)`	Absolute value
`ceil(n)`	Round up to nearest integer
`floor(n)`	Round down to nearest integer
`log(n, base)`	Logarithm
`max(n1, n2, ...)`	Maximum value
`min(n1, n2, ...)`	Minimum value
`parseint(str, base)`	Parse integer from string
`pow(base, exp)`	Exponentiation
`signum(n)`	Sign of number (-1, 0, 1)

String

Function	Description
`chomp(str)`	Remove trailing newlines
`endswith(str, suffix)`	Check suffix
`format(fmt, args...)`	String formatting (sprintf-style)
`formatlist(fmt, list...)`	Format each element
`indent(spaces, str)`	Indent all lines
`join(sep, list)`	Join list elements
`lower(str)`	Lowercase
`regex(pattern, str)`	Regex match
`regexall(pattern, str)`	All regex matches
`replace(str, old, new)`	String replacement
`split(sep, str)`	Split string
`startswith(str, prefix)`	Check prefix
`strrev(str)`	Reverse string
`substr(str, offset, length)`	Substring
`title(str)`	Title case
`trim(str, chars)`	Trim characters
`trimprefix(str, prefix)`	Trim prefix
`trimsuffix(str, suffix)`	Trim suffix
`trimspace(str)`	Trim whitespace
`upper(str)`	Uppercase

Collection

Function	Description
`alltrue(list)`	All elements are true
`anytrue(list)`	Any element is true
`chunklist(list, size)`	Split list into chunks
`coalesce(vals...)`	First non-null, non-empty value
`coalescelist(lists...)`	First non-empty list
`compact(list)`	Remove empty strings
`concat(lists...)`	Concatenate lists
`contains(list, val)`	Check membership
`distinct(list)`	Remove duplicates
`element(list, idx)`	Get element by index (wraps)
`flatten(list)`	Flatten nested lists
`index(list, val)`	Find index of value
`keys(map)`	Map keys
`length(val)`	Length of string, list, or map
`list(vals...)`	Create a list
`lookup(map, key, default)`	Safe map lookup
`map(k1, v1, k2, v2, ...)`	Create a map
`matchkeys(vals, keys, search)`	Filter by matching keys
`merge(maps...)`	Merge maps
`one(list)`	Extract single element or null
`range(start, limit, step)`	Generate number sequence
`reverse(list)`	Reverse list
`setintersection(sets...)`	Set intersection
`setproduct(sets...)`	Cartesian product
`setsubtract(a, b)`	Set difference
`setunion(sets...)`	Set union
`slice(list, start, end)`	List slice
`sort(list)`	Sort strings lexicographically
`sum(list)`	Sum numbers
`transpose(map)`	Transpose map of lists
`values(map)`	Map values
`zipmap(keys, values)`	Create map from key/value lists

Encoding

Function	Description
`base64decode(str)`	Decode base64
`base64encode(str)`	Encode to base64
`base64gzip(str)`	Gzip then base64 encode
`csvdecode(str)`	Parse CSV
`jsondecode(str)`	Parse JSON
`jsonencode(val)`	Encode to JSON
`textdecodebase64(str, enc)`	Decode base64 with encoding
`textencodebase64(str, enc)`	Encode with encoding then base64
`urlencode(str)`	URL encode
`yamldecode(str)`	Parse YAML
`yamlencode(val)`	Encode to YAML

Hash and Crypto

Function	Description
`base64sha256(str)`	Base64-encoded SHA256
`base64sha512(str)`	Base64-encoded SHA512
`md5(str)`	MD5 hash
`sha1(str)`	SHA1 hash
`sha256(str)`	SHA256 hash
`sha512(str)`	SHA512 hash

IP Network

Function	Description
`cidrhost(prefix, hostnum)`	Calculate host IP
`cidrnetmask(prefix)`	Network mask
`cidrsubnet(prefix, newbits, netnum)`	Calculate subnet
`cidrsubnets(prefix, newbits...)`	Calculate multiple subnets

Type Conversion

Function	Description
`can(expr)`	Test if expression evaluates without error
`nonsensitive(val)`	Remove sensitive marking
`sensitive(val)`	Mark as sensitive
`tobool(val)`	Convert to bool
`tolist(val)`	Convert to list
`tomap(val)`	Convert to map
`tonumber(val)`	Convert to number
`toset(val)`	Convert to set
`tostring(val)`	Convert to string
`try(exprs...)`	First expression that doesn’t error
`type(val)`	Get type of value

Custom Functions

`invoke`

invoke("functionName", { arg1: value1, arg2: value2 })

Calls a user-defined function. The first argument must be a static string. See the language guide for details.

Deferred Rendering

Mon, 01 Jan 0001 00:00:00 +0000

Deferred rendering is the headline feature of function-hcl. It eliminates the boilerplate conditional logic that is common in Crossplane compositions.

The Problem

In a typical Crossplane composition, if resource B uses a status field from resource A, you need to handle the case where resource A hasn’t been created yet. This often requires conditional logic scattered throughout your composition.

How function-hcl Solves It

function-hcl uses a simple rule: if any expression in a block evaluates to an incomplete value (null, missing attribute, missing index), the entire block is deferred — dropped from the output for that reconcile cycle.

Gotchas

Mon, 01 Jan 0001 00:00:00 +0000

Dashes in identifiers mean you can’t subtract without spaces

HCL allows dashes in identifiers. This means a-b is a single identifier, not a minus b. Use spaces for arithmetic: a - b.

locals {
 my-var = 10 # this is a variable named "my-var"
 result = my-var # refers to the variable, not "my" minus "var"
 diff = a - b # subtraction -- spaces required
}

body is an attribute, not a block

body must use = for assignment. Omitting = turns it into a block, which is a different HCL construct and will produce a schema error.

HCL Basics

Mon, 01 Jan 0001 00:00:00 +0000

Before diving into function-hcl specifics, it helps to understand the fundamental building blocks of HCL syntax. This page covers the essentials; for the full language specification see the HCL Native Syntax Specification.

People who have worked with Terraform before should feel free to skip this section.

Blocks

A block is a container that has a type, zero or more labels, and a body enclosed in braces. The body contains attributes and/or nested blocks.

Quickstart

Mon, 01 Jan 0001 00:00:00 +0000

This quickstart creates a simple composition that provisions an S3 bucket using function-hcl.

1. Define a Composite Resource

First, define an XRD and a Claim type for a storage bucket:

apiVersion: apiextensions.crossplane.io/v1
kind: CompositeResourceDefinition
metadata:
 name: xstoragebuckets.example.crossplane.io
spec:
 group: example.crossplane.io
 names:
 kind: XStorageBucket
 plural: xstoragebuckets
 claimNames:
 kind: StorageBucket
 plural: storagebuckets
 versions:
 - name: v1
 served: true
 referenceable: true
 schema:
 openAPIV3Schema:
 type: object
 properties:
 spec:
 type: object
 properties:
 parameters:
 type: object
 required: [region]
 properties:
 region:
 type: string
 description: AWS region for the bucket
 status:
 type: object
 properties:
 bucketArn:
 type: string

Apply it:

Error Conditions

Mon, 01 Jan 0001 00:00:00 +0000

The following conditions are treated as errors by function-hcl. When an error occurs, the function returns a Fatal result that surfaces on the composite resource.

Parsing Errors

Error	Description
HCL syntax error	Invalid HCL syntax in the source files
Schema violation	Block structure doesn’t match the expected schema

Variable Errors

Error	Description
Unknown local variable	Reference to a local variable name that doesn’t exist
Circular reference	Circular dependencies in locals (e.g. `locals { a = b; b = a }`)
Local shadowing	A local variable in an inner scope has the same name as one in a parent scope

Resource Errors

Error	Description
Duplicate resource name	Two resources produce the same crossplane name
Existing resource became incomplete	A resource that exists in the observed state now has an incomplete value. This is a safety check to prevent accidental deletion.

Condition Errors

Error	Description
Incomplete condition	A `condition` value that cannot be evaluated (note: incomplete conditions are treated as `false`, but certain evaluation failures are errors)
Non-boolean condition	A `condition` evaluates to something other than `true` or `false`

Status and Connection Errors

Error	Description
Conflicting status values	Two `composite status` blocks set the same non-object leaf attribute to different values
Conflicting connection values	Two `composite connection` blocks set the same key to different values
Non-string connection value	A connection detail value is not a base64-encoded string

Requirement Errors

Error	Description
Both matchName and matchLabels	A `requirement` block specifies both selection methods
Neither matchName nor matchLabels	A `requirement` block specifies no selection method
Type mismatch	Data type mismatch in `select` attributes

Function Errors

Error	Description
Invalid function name	A `function` or `arg` has a name that is not a valid identifier
Unknown function	`invoke` references a non-existent function
Bad invocation	`invoke` called with missing required arguments or unrecognized argument names
Stack overflow	Call stack exceeds 100 frames (infinite recursion protection)

Context Errors

Error	Description
Conflicting context values	Two `context` blocks write different non-object values to the same key path

IDE Setup

Mon, 01 Jan 0001 00:00:00 +0000

function-hcl has a language server (function-hcl-ls) that provides IDE features for .hcl files used in function-hcl compositions. Extensions are available for VS Code and IntelliJ.

Features

The language server provides:

Code completion
Diagnostics (error reporting)
Hover information
Go to definition
Document symbols
Semantic token highlighting

Installation instructions

Coming soon. Watch this space…

The req Variable

Mon, 01 Jan 0001 00:00:00 +0000

function-hcl provides a built-in req variable that gives you access to the Crossplane request state. It is available everywhere in the script – top-level locals, resource blocks, groups, and nested blocks.

Fields

Expression	Type	Description
`req.composite`	k8s object	The observed composite resource (XR)
`req.composite_connection`	map(string, bytes)	Connection details of the composite resource
`req.resource`	map(string, k8s object)	Observed composed resources, keyed by crossplane resource name
`req.connection`	map(string, map(string, bytes))	Connection details of observed resources, keyed by resource name
`req.resources`	map(string, list(k8s object))	Observed resource collections, keyed by collection base name
`req.connections`	map(string, list(map(string, bytes)))	Connection details of resource collections
`req.context`	map(string, any)	Pipeline context values from upstream functions
`req.extra_resources`	map(string, list(k8s object))	Extra resources fetched via `requirement` blocks

Example

locals {
 comp = req.composite
 compName = comp.metadata.name
 params = comp.spec.parameters
 region = params.region

 # Access an observed resource by its crossplane name
 observedBucket = req.resource.my-bucket

 # Access pipeline context
 upstreamValue = req.context["upstream-function/some-key"]
}

Accessing Observed Resources

Use req.resource.<name> to access any observed composed resource by its crossplane name. This is useful when one resource needs to reference the status of another:

fn-hcl-tools CLI

Mon, 01 Jan 0001 00:00:00 +0000

fn-hcl-tools is a companion CLI for function-hcl that helps package, format, and analyze HCL compositions.

Installation

go install github.com/crossplane-contrib/function-hcl/function-hcl/cmd/fn-hcl-tools@v0.2.0-rc9

Commands

`package`

Packages a directory of HCL files into a single txtar bundle, suitable for embedding in a Composition’s input field.

fn-hcl-tools package *.hcl

The tool runs basic static analysis on the HCL before packing, catching syntax errors early.

Example:

Given a directory:

my-composition/
 main.hcl
 bucket.hcl
 database.hcl

Run:

fn-hcl-tools package my-composition/*.hcl

Output (suitable for pasting into a Composition YAML input field):

Local Variables

Mon, 01 Jan 0001 00:00:00 +0000

Local variables in function-hcl work like Terraform locals, with some important differences.

Basics

Define locals in a locals block. Access them directly by name – no local. prefix needed.

locals {
 baseName = req.composite.metadata.name
 computedName = "${baseName}-bucket"
}

Ordering Doesn’t Matter

All locals blocks in a given scope are processed together and variable ordering doesn’t matter. Dependencies are resolved automatically. This is the same behavior as Terraform.

# These two blocks are treated identically:
locals {
 computedName = "${baseName}-bucket"
}

locals {
 baseName = req.composite.metadata.name
}

Circular references (e.g. locals { a = b; b = a }) are an error.

Resource Blocks

Mon, 01 Jan 0001 00:00:00 +0000

The resource block is the primary way to declare a desired composed resource.

Syntax

resource <crossplane-name> {
 locals { ... } # optional: resource-scoped locals

 body = { ... } # required: the Kubernetes manifest

 composite status { } # optional: write to composite status
 composite connection { } # optional: write connection details
 ready { } # optional: set readiness
}

The `body` Attribute

body is an HCL object expression that produces the full Kubernetes manifest for the composed resource. It must be assigned with =.

Resource Collections

Mon, 01 Jan 0001 00:00:00 +0000

The resources (plural) block creates multiple resources by iterating over a collection.

Syntax

resources <base-name> {
 locals { ... } # optional: collection-scoped locals

 for_each = <expression> # required: list, set, or map to iterate over

 name = <expression> # optional: how to generate each crossplane name
 # default: "${self.basename}-${each.key}"

 template { # required: the template for each resource
 locals { ... } # optional: template-scoped locals
 body = { ... } # required: the Kubernetes manifest
 composite status { } # optional
 composite connection { } # optional
 ready { } # optional
 }
}

Example

resources additional_buckets {
 locals {
 params = req.composite.spec.parameters
 suffixes = params.suffixes
 }

 for_each = suffixes

 template {
 locals {
 resourceName = "${req.composite.metadata.name}-${self.name}"
 }

 body = {
 apiVersion = "s3.aws.upbound.io/v1beta1"
 kind = "Bucket"
 metadata = {
 name = resourceName
 }
 spec = {
 forProvider = {
 forceDestroy = true
 region = params.region
 }
 }
 }
 }
}

The `for_each` Attribute

Must evaluate to a list, set, or map.

Groups

Mon, 01 Jan 0001 00:00:00 +0000

The group block allows you to group related resources together and share local variables among them without polluting the top-level namespace.

Syntax

group {
 condition = <bool> # optional: skip the entire group
 locals { ... } # optional: shared locals for resources in this group

 resource <name> { }
 resource <name> { }
 resources <name> { }
}

Example

group {
 locals {
 vpcParams = req.composite.spec.parameters.vpc
 region = vpcParams.region
 }

 resource my-vpc {
 body = {
 apiVersion = "ec2.aws.upbound.io/v1beta1"
 kind = "VPC"
 metadata = { name = "${req.composite.metadata.name}-vpc" }
 spec = { forProvider = { region = region, cidrBlock = vpcParams.cidr } }
 }
 }

 resource my-subnet {
 body = {
 apiVersion = "ec2.aws.upbound.io/v1beta1"
 kind = "Subnet"
 metadata = { name = "${req.composite.metadata.name}-subnet" }
 spec = {
 forProvider = {
 region = region
 vpcId = req.resource.my-vpc.status.atProvider.id
 cidrBlock = vpcParams.subnetCidr
 }
 }
 }
 }
}

# vpcParams and region are NOT available here

Scoping

Locals defined in a group block are available to all resources within the group.
They are not available outside the group.
Resources in the group still have access to top-level locals.
Groups can contain resource, resources, and nested group blocks.

Conditional Groups

A group can have a condition attribute to skip the entire group:

Conditions

Mon, 01 Jan 0001 00:00:00 +0000

Use a condition attribute to create resources only when specific conditions are met. This is the function-hcl equivalent of Terraform’s count = var.create ? 1 : 0.

On a Resource

resource s3_acl {
 condition = try(req.composite.spec.parameters.createAcls, true)

 body = {
 # ...
 }
}

The condition expression must evaluate to a boolean value. If the value is false, the resource is skipped entirely.

On a Resource Collection

When applied to a resources block, the condition controls the entire collection. To filter individual elements, filter the collection that for_each iterates over instead.

Composite Status

Mon, 01 Jan 0001 00:00:00 +0000

The composite status block writes values to the composite resource’s (XR) status. It can be specified any number of times, and each block can update specific fields.

At the Top Level

composite status {
 body = {
 foobarId = req.resource.foobar.status.atProvider.id
 }
}

Inside a Resource Block

This is the more common pattern, since self.resource gives you direct access to the observed state of the current resource:

resource foobar {
 body = { ... }

 composite status {
 body = {
 foobarId = self.resource.status.atProvider.id
 }
 }
}

Merging Multiple Status Blocks

Multiple composite status blocks can update different fields. Objects are merged:

Composite Connection Details

Mon, 01 Jan 0001 00:00:00 +0000

The composite connection block writes connection details to the composite resource. It works the same way as composite status in terms of scoping and merging.

Syntax

composite connection {
 body = {
 <key> = <base64-encoded-string>
 }
}

All values must be strings that are base64 encoded. The function returns an error otherwise.

At the Top Level

composite connection {
 body = {
 url = base64encode(req.resource.foobar.status.atProvider.url)
 }
}

Inside a Resource Block

resource my-database {
 body = { ... }

 composite connection {
 body = {
 connectionString = base64encode(self.resource.status.atProvider.connectionString)
 password = self.connection["password"] # already base64 from the provider
 }
 }
}

Merging and Conflict Detection

Multiple composite connection blocks can set different keys. Two blocks cannot set the same key to different values – this is an error.

Resource Ready Status

Mon, 01 Jan 0001 00:00:00 +0000

The ready block lets you assign a ready state for a resource. Usually you would use function-auto-ready to automatically set the resource status.

This allows you to set the ready status explicitly.

Syntax

resource foo {
 body = { /* ... */ }

 ready {
 value = "READY_TRUE"
 }
}

Valid Values

The value attribute must evaluate to a string and be one of:

Value	Meaning
`"READY_UNSPECIFIED"`	Ready state is not known
`"READY_TRUE"`	Resource is ready
`"READY_FALSE"`	Resource is not ready

Example: Custom Readiness Check

resource my-database {
 body = { /* ... */ }

 ready {
 value = self.resource.status.atProvider.state == "available" ? "READY_TRUE" : "READY_FALSE"
 }
}

If self.resource is incomplete (resource not yet created), the ready block follows the same deferral rules as other blocks.

Context

Mon, 01 Jan 0001 00:00:00 +0000

The context block writes values into the Crossplane pipeline context, making them available to downstream functions in the pipeline.

Syntax

context {
 key = <string>
 value = <any>
}

Example

context {
 key = "example.com/foo-bar-baz"
 value = {
 foo = { bar = "baz" }
 bar = 10
 baz = "quux"
 }
}

Merging Multiple Context Blocks

You can write to the same context key from multiple blocks. Object values are merged using the same rules as composite status:

Requirements (Extra Resources)

Mon, 01 Jan 0001 00:00:00 +0000

The requirement block lets you request extra resources from Crossplane. These are typically used to read configuration data (like EnvironmentConfig objects) that aren’t part of the composition’s resource tree.

Syntax

requirement <name> {
 condition = <bool> # optional
 locals { ... } # optional

 select {
 apiVersion = <string>
 kind = <string>
 matchName = <string> # match by name
 # OR
 matchLabels = <map(string)> # match by labels
 }
}

You must specify either matchName or matchLabels, but not both.

User-Defined Functions

Mon, 01 Jan 0001 00:00:00 +0000

function-hcl lets you define reusable functions in your HCL code.

Defining Functions

Functions are defined with the function block. They must be defined at the top level (not inside a group or other block).

function addNumbers {
 arg a {}
 arg b { default = 1 }

 locals {
 output = a + b
 }

 body = output
}

Structure

arg blocks define the function’s parameters. Each arg can have an optional default value and an optional description.
locals blocks can be used for temporary calculations.
body is the return value of the function.

Scoping Rules

Functions do not have access to external state. You cannot use req.composite, self, or any other variable from the calling context inside a function. Only the declared arguments and locals within the function are accessible.

function-hcl

Best Practices

Always use fn-hcl-tools package

Use locals to name things

DSL Specification

Source of truth

Input Format

External Variables

Top-Level Blocks

locals

resource

How It Works

The Crossplane Function Pipeline

What function-hcl Does

The Reconcile Loop

Installation

Prerequisites

Install via Crossplane Package

Source Format

HCL Syntax

txtar Format

Built-in Functions

Available Functions by Category

Numeric

String

Collection

Encoding

Hash and Crypto

IP Network

Type Conversion

Custom Functions

invoke

Deferred Rendering

The Problem

How function-hcl Solves It

Gotchas

Dashes in identifiers mean you can’t subtract without spaces

body is an attribute, not a block

HCL Basics

Blocks

Quickstart

1. Define a Composite Resource

Error Conditions

Parsing Errors

Variable Errors

Resource Errors

Condition Errors

Status and Connection Errors

Requirement Errors

Function Errors

Context Errors

IDE Setup

Features

Installation instructions

The req Variable

Fields

Example

Accessing Observed Resources

fn-hcl-tools CLI

Installation

Commands

package

Local Variables

Basics

Ordering Doesn’t Matter

Resource Blocks

Syntax

The body Attribute

Resource Collections

Syntax

Example

The for_each Attribute

Groups

Syntax

Example

Scoping

Conditional Groups

Conditions

On a Resource

On a Resource Collection

`locals`

`resource`

`invoke`

`package`

The `body` Attribute

The `for_each` Attribute